Package

// Move bytecode v6
module 3.genesis {
use 0000000000000000000000000000000000000000000000000000000000000002::balance;
use 0000000000000000000000000000000000000000000000000000000000000002::coin;
use 0000000000000000000000000000000000000000000000000000000000000002::object;
use 0000000000000000000000000000000000000000000000000000000000000002::safe;
use 0000000000000000000000000000000000000000000000000000000000000002::transfer;
use 0000000000000000000000000000000000000000000000000000000000000002::tx_context;
use 0000000000000000000000000000000000000000000000000000000000000003::safe_system;
use 0000000000000000000000000000000000000000000000000000000000000003::safe_system_state_inner;
use 0000000000000000000000000000000000000000000000000000000000000003::stake_subsidy;
use 0000000000000000000000000000000000000000000000000000000000000003::validator;
use 0000000000000000000000000000000000000000000000000000000000000003::validator_set;
use 0000000000000000000000000000000000000000000000000000000000000001::option;
use 0000000000000000000000000000000000000000000000000000000000000001::vector;

struct GenesisValidatorMetadata has copy, drop {
	name: vector<u8>,
	description: vector<u8>,
	image_url: vector<u8>,
	project_url: vector<u8>,
	safe_address: address,
	gas_price: u64,
	commission_rate: u64,
	protocol_public_key: vector<u8>,
	proof_of_possession: vector<u8>,
	network_public_key: vector<u8>,
	worker_public_key: vector<u8>,
	network_address: vector<u8>,
	p2p_address: vector<u8>,
	primary_address: vector<u8>,
	worker_address: vector<u8>
}

struct GenesisChainParameters has copy, drop {
	protocol_version: u64,
	chain_start_timestamp_ms: u64,
	epoch_duration_ms: u64,
	stake_subsidy_start_epoch: u64,
	stake_subsidy_initial_distribution_amount: u64,
	stake_subsidy_period_length: u64,
	stake_subsidy_decrease_rate: u16,
	max_validator_count: u64,
	min_validator_joining_stake: u64,
	validator_low_stake_threshold: u64,
	validator_very_low_stake_threshold: u64,
	validator_low_stake_grace_period: u64
}

struct TokenDistributionSchedule {
	stake_subsidy_fund_safelet: u64,
	allocations: vector<TokenAllocation>
}

struct TokenAllocation {
	recipient_address: address,
	amount_safelet: u64,
	staked_with_validator: Option<address>
}

create(Arg0: UID, Arg1: Balance<SAFE>, Arg2: GenesisChainParameters, Arg3: vector<GenesisValidatorMetadata>, Arg4: TokenDistributionSchedule, Arg5: &mut TxContext) {
L6:	loc0: u64
L7:	loc1: u64
L8:	loc2: vector<TokenAllocation>
L9:	loc3: u64
L10:	loc4: vector<u8>
L11:	loc5: u64
L12:	loc6: u64
L13:	loc7: u64
L14:	loc8: u64
L15:	loc9: vector<u8>
L16:	loc10: vector<u8>
L17:	loc11: vector<u8>
L18:	loc12: vector<u8>
L19:	loc13: vector<u8>
L20:	loc14: vector<u8>
L21:	loc15: vector<u8>
L22:	loc16: vector<u8>
L23:	loc17: vector<u8>
L24:	loc18: address
L25:	loc19: StakeSubsidy
L26:	loc20: u64
L27:	loc21: u64
L28:	loc22: u64
L29:	loc23: Balance<SAFE>
L30:	loc24: Balance<SAFE>
L31:	loc25: SystemParameters
L32:	loc26: vector<GenesisValidatorMetadata>
L33:	loc27: &mut vector<Validator>
L34:	loc28: Validator
L35:	loc29: vector<Validator>
L36:	loc30: vector<u8>
L37:	loc31: vector<u8>
B0:
	0: CopyLoc[5](Arg5: &mut TxContext)
	1: FreezeRef
	2: Call tx_context::epoch(&TxContext): u64
	3: LdU64(0)
	4: Eq
	5: BrFalse(7)
B1:
	6: Branch(11)
B2:
	7: MoveLoc[5](Arg5: &mut TxContext)
	8: Pop
	9: LdConst[0](u64: 0)
	10: Abort
B3:
	11: VecPack(6, 0)
	12: StLoc[35](loc29: vector<Validator>)
	13: MoveLoc[3](Arg3: vector<GenesisValidatorMetadata>)
	14: StLoc[32](loc26: vector<GenesisValidatorMetadata>)
	15: MutBorrowLoc[32](loc26: vector<GenesisValidatorMetadata>)
	16: Call vector::reverse<GenesisValidatorMetadata>(&mut vector<GenesisValidatorMetadata>)
	17: ImmBorrowLoc[32](loc26: vector<GenesisValidatorMetadata>)
	18: VecLen(7)
	19: StLoc[7](loc1: u64)
	20: LdU64(0)
	21: StLoc[14](loc8: u64)
	22: MoveLoc[7](loc1: u64)
	23: StLoc[28](loc22: u64)
B4:
	24: CopyLoc[14](loc8: u64)
	25: CopyLoc[28](loc22: u64)
	26: Lt
	27: BrFalse(84)
B5:
	28: CopyLoc[14](loc8: u64)
	29: Pop
	30: MutBorrowLoc[32](loc26: vector<GenesisValidatorMetadata>)
	31: VecPopBack(7)
	32: Unpack[0](GenesisValidatorMetadata)
	33: StLoc[36](loc30: vector<u8>)
	34: StLoc[20](loc14: vector<u8>)
	35: StLoc[19](loc13: vector<u8>)
	36: StLoc[17](loc11: vector<u8>)
	37: StLoc[37](loc31: vector<u8>)
	38: StLoc[18](loc12: vector<u8>)
	39: StLoc[22](loc16: vector<u8>)
	40: StLoc[23](loc17: vector<u8>)
	41: StLoc[9](loc3: u64)
	42: StLoc[11](loc5: u64)
	43: StLoc[24](loc18: address)
	44: StLoc[21](loc15: vector<u8>)
	45: StLoc[15](loc9: vector<u8>)
	46: StLoc[10](loc4: vector<u8>)
	47: StLoc[16](loc10: vector<u8>)
	48: MoveLoc[24](loc18: address)
	49: MoveLoc[23](loc17: vector<u8>)
	50: MoveLoc[18](loc12: vector<u8>)
	51: MoveLoc[37](loc31: vector<u8>)
	52: MoveLoc[22](loc16: vector<u8>)
	53: MoveLoc[16](loc10: vector<u8>)
	54: MoveLoc[10](loc4: vector<u8>)
	55: MoveLoc[15](loc9: vector<u8>)
	56: MoveLoc[21](loc15: vector<u8>)
	57: MoveLoc[17](loc11: vector<u8>)
	58: MoveLoc[19](loc13: vector<u8>)
	59: MoveLoc[20](loc14: vector<u8>)
	60: MoveLoc[36](loc30: vector<u8>)
	61: MoveLoc[11](loc5: u64)
	62: MoveLoc[9](loc3: u64)
	63: CopyLoc[5](Arg5: &mut TxContext)
	64: Call validator::new(address, vector<u8>, vector<u8>, vector<u8>, vector<u8>, vector<u8>, vector<u8>, vector<u8>, vector<u8>, vector<u8>, vector<u8>, vector<u8>, vector<u8>, u64, u64, &mut TxContext): Validator
	65: StLoc[34](loc28: Validator)
	66: ImmBorrowLoc[35](loc29: vector<Validator>)
	67: ImmBorrowLoc[34](loc28: Validator)
	68: Call validator_set::is_duplicate_validator(&vector<Validator>, &Validator): bool
	69: Not
	70: BrFalse(72)
B6:
	71: Branch(76)
B7:
	72: MoveLoc[5](Arg5: &mut TxContext)
	73: Pop
	74: LdConst[1](u64: 1)
	75: Abort
B8:
	76: MutBorrowLoc[35](loc29: vector<Validator>)
	77: MoveLoc[34](loc28: Validator)
	78: VecPushBack(6)
	79: MoveLoc[14](loc8: u64)
	80: LdU64(1)
	81: Add
	82: StLoc[14](loc8: u64)
	83: Branch(24)
B9:
	84: MoveLoc[32](loc26: vector<GenesisValidatorMetadata>)
	85: VecUnpack(7, 0)
	86: MoveLoc[4](Arg4: TokenDistributionSchedule)
	87: Unpack[2](TokenDistributionSchedule)
	88: StLoc[8](loc2: vector<TokenAllocation>)
	89: StLoc[26](loc20: u64)
	90: MutBorrowLoc[1](Arg1: Balance<SAFE>)
	91: MoveLoc[26](loc20: u64)
	92: Call balance::split<SAFE>(&mut Balance<SAFE>, u64): Balance<SAFE>
	93: StLoc[30](loc24: Balance<SAFE>)
	94: Call balance::zero<SAFE>(): Balance<SAFE>
	95: StLoc[29](loc23: Balance<SAFE>)
	96: MoveLoc[1](Arg1: Balance<SAFE>)
	97: MoveLoc[8](loc2: vector<TokenAllocation>)
	98: MutBorrowLoc[35](loc29: vector<Validator>)
	99: CopyLoc[5](Arg5: &mut TxContext)
	100: Call allocate_tokens(Balance<SAFE>, vector<TokenAllocation>, &mut vector<Validator>, &mut TxContext)
	101: MutBorrowLoc[35](loc29: vector<Validator>)
	102: StLoc[33](loc27: &mut vector<Validator>)
	103: CopyLoc[33](loc27: &mut vector<Validator>)
	104: FreezeRef
	105: VecLen(6)
	106: StLoc[6](loc0: u64)
	107: LdU64(0)
	108: StLoc[12](loc6: u64)
	109: MoveLoc[6](loc0: u64)
	110: StLoc[27](loc21: u64)
B10:
	111: CopyLoc[12](loc6: u64)
	112: CopyLoc[27](loc21: u64)
	113: Lt
	114: BrFalse(127)
B11:
	115: CopyLoc[12](loc6: u64)
	116: StLoc[13](loc7: u64)
	117: CopyLoc[33](loc27: &mut vector<Validator>)
	118: MoveLoc[13](loc7: u64)
	119: VecMutBorrow(6)
	120: LdU64(0)
	121: Call validator::activate(&mut Validator, u64)
	122: MoveLoc[12](loc6: u64)
	123: LdU64(1)
	124: Add
	125: StLoc[12](loc6: u64)
	126: Branch(111)
B12:
	127: MoveLoc[33](loc27: &mut vector<Validator>)
	128: Pop
	129: ImmBorrowLoc[2](Arg2: GenesisChainParameters)
	130: ImmBorrowField[0](GenesisChainParameters.epoch_duration_ms: u64)
	131: ReadRef
	132: ImmBorrowLoc[2](Arg2: GenesisChainParameters)
	133: ImmBorrowField[1](GenesisChainParameters.stake_subsidy_start_epoch: u64)
	134: ReadRef
	135: ImmBorrowLoc[2](Arg2: GenesisChainParameters)
	136: ImmBorrowField[2](GenesisChainParameters.max_validator_count: u64)
	137: ReadRef
	138: ImmBorrowLoc[2](Arg2: GenesisChainParameters)
	139: ImmBorrowField[3](GenesisChainParameters.min_validator_joining_stake: u64)
	140: ReadRef
	141: ImmBorrowLoc[2](Arg2: GenesisChainParameters)
	142: ImmBorrowField[4](GenesisChainParameters.validator_low_stake_threshold: u64)
	143: ReadRef
	144: ImmBorrowLoc[2](Arg2: GenesisChainParameters)
	145: ImmBorrowField[5](GenesisChainParameters.validator_very_low_stake_threshold: u64)
	146: ReadRef
	147: ImmBorrowLoc[2](Arg2: GenesisChainParameters)
	148: ImmBorrowField[6](GenesisChainParameters.validator_low_stake_grace_period: u64)
	149: ReadRef
	150: CopyLoc[5](Arg5: &mut TxContext)
	151: Call safe_system_state_inner::create_system_parameters(u64, u64, u64, u64, u64, u64, u64, &mut TxContext): SystemParameters
	152: StLoc[31](loc25: SystemParameters)
	153: MoveLoc[30](loc24: Balance<SAFE>)
	154: ImmBorrowLoc[2](Arg2: GenesisChainParameters)
	155: ImmBorrowField[7](GenesisChainParameters.stake_subsidy_initial_distribution_amount: u64)
	156: ReadRef
	157: ImmBorrowLoc[2](Arg2: GenesisChainParameters)
	158: ImmBorrowField[8](GenesisChainParameters.stake_subsidy_period_length: u64)
	159: ReadRef
	160: ImmBorrowLoc[2](Arg2: GenesisChainParameters)
	161: ImmBorrowField[9](GenesisChainParameters.stake_subsidy_decrease_rate: u16)
	162: ReadRef
	163: CopyLoc[5](Arg5: &mut TxContext)
	164: Call stake_subsidy::create(Balance<SAFE>, u64, u64, u16, &mut TxContext): StakeSubsidy
	165: StLoc[25](loc19: StakeSubsidy)
	166: MoveLoc[0](Arg0: UID)
	167: MoveLoc[35](loc29: vector<Validator>)
	168: MoveLoc[29](loc23: Balance<SAFE>)
	169: ImmBorrowLoc[2](Arg2: GenesisChainParameters)
	170: ImmBorrowField[10](GenesisChainParameters.protocol_version: u64)
	171: ReadRef
	172: ImmBorrowLoc[2](Arg2: GenesisChainParameters)
	173: ImmBorrowField[11](GenesisChainParameters.chain_start_timestamp_ms: u64)
	174: ReadRef
	175: MoveLoc[31](loc25: SystemParameters)
	176: MoveLoc[25](loc19: StakeSubsidy)
	177: MoveLoc[5](Arg5: &mut TxContext)
	178: Call safe_system::create(UID, vector<Validator>, Balance<SAFE>, u64, u64, SystemParameters, StakeSubsidy, &mut TxContext)
	179: Ret
}

allocate_tokens(Arg0: Balance<SAFE>, Arg1: vector<TokenAllocation>, Arg2: &mut vector<Validator>, Arg3: &mut TxContext) {
L4:	loc0: u64
L5:	loc1: Balance<SAFE>
L6:	loc2: u64
L7:	loc3: u64
L8:	loc4: address
L9:	loc5: Option<address>
L10:	loc6: u64
L11:	loc7: vector<TokenAllocation>
L12:	loc8: address
B0:
	0: MoveLoc[1](Arg1: vector<TokenAllocation>)
	1: StLoc[11](loc7: vector<TokenAllocation>)
	2: ImmBorrowLoc[11](loc7: vector<TokenAllocation>)
	3: VecLen(22)
	4: StLoc[4](loc0: u64)
	5: LdU64(0)
	6: StLoc[7](loc3: u64)
	7: MoveLoc[4](loc0: u64)
	8: StLoc[10](loc6: u64)
B1:
	9: CopyLoc[7](loc3: u64)
	10: CopyLoc[10](loc6: u64)
	11: Lt
	12: BrFalse(49)
B2:
	13: CopyLoc[7](loc3: u64)
	14: Pop
	15: MutBorrowLoc[11](loc7: vector<TokenAllocation>)
	16: VecPopBack(22)
	17: Unpack[3](TokenAllocation)
	18: StLoc[9](loc5: Option<address>)
	19: StLoc[6](loc2: u64)
	20: StLoc[8](loc4: address)
	21: MutBorrowLoc[0](Arg0: Balance<SAFE>)
	22: MoveLoc[6](loc2: u64)
	23: Call balance::split<SAFE>(&mut Balance<SAFE>, u64): Balance<SAFE>
	24: StLoc[5](loc1: Balance<SAFE>)
	25: ImmBorrowLoc[9](loc5: Option<address>)
	26: Call option::is_some<address>(&Option<address>): bool
	27: BrFalse(39)
B3:
	28: MoveLoc[9](loc5: Option<address>)
	29: Call option::destroy_some<address>(Option<address>): address
	30: StLoc[12](loc8: address)
	31: CopyLoc[2](Arg2: &mut vector<Validator>)
	32: MoveLoc[12](loc8: address)
	33: Call validator_set::get_validator_mut(&mut vector<Validator>, address): &mut Validator
	34: MoveLoc[5](loc1: Balance<SAFE>)
	35: MoveLoc[8](loc4: address)
	36: CopyLoc[3](Arg3: &mut TxContext)
	37: Call validator::request_add_stake_at_genesis(&mut Validator, Balance<SAFE>, address, &mut TxContext)
	38: Branch(44)
B4:
	39: MoveLoc[5](loc1: Balance<SAFE>)
	40: CopyLoc[3](Arg3: &mut TxContext)
	41: Call coin::from_balance<SAFE>(Balance<SAFE>, &mut TxContext): Coin<SAFE>
	42: MoveLoc[8](loc4: address)
	43: Call transfer::public_transfer<Coin<SAFE>>(Coin<SAFE>, address)
B5:
	44: MoveLoc[7](loc3: u64)
	45: LdU64(1)
	46: Add
	47: StLoc[7](loc3: u64)
	48: Branch(9)
B6:
	49: MoveLoc[2](Arg2: &mut vector<Validator>)
	50: Pop
	51: MoveLoc[3](Arg3: &mut TxContext)
	52: Pop
	53: MoveLoc[11](loc7: vector<TokenAllocation>)
	54: VecUnpack(22, 0)
	55: MoveLoc[0](Arg0: Balance<SAFE>)
	56: Call balance::destroy_zero<SAFE>(Balance<SAFE>)
	57: Ret
}

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

// Move bytecode v6
module 3.safe_system {
use 0000000000000000000000000000000000000000000000000000000000000002::balance;
use 0000000000000000000000000000000000000000000000000000000000000002::coin;
use 0000000000000000000000000000000000000000000000000000000000000002::dynamic_field;
use 0000000000000000000000000000000000000000000000000000000000000002::object;
use 0000000000000000000000000000000000000000000000000000000000000002::safe;
use 0000000000000000000000000000000000000000000000000000000000000002::table;
use 0000000000000000000000000000000000000000000000000000000000000002::transfer;
use 0000000000000000000000000000000000000000000000000000000000000002::tx_context;
use 0000000000000000000000000000000000000000000000000000000000000002::vec_map;
use 0000000000000000000000000000000000000000000000000000000000000003::safe_system_state_inner;
use 0000000000000000000000000000000000000000000000000000000000000003::stake_subsidy;
use 0000000000000000000000000000000000000000000000000000000000000003::staking_pool;
use 0000000000000000000000000000000000000000000000000000000000000003::validator;
use 0000000000000000000000000000000000000000000000000000000000000003::validator_cap;
use 0000000000000000000000000000000000000000000000000000000000000003::validator_set;
use 0000000000000000000000000000000000000000000000000000000000000001::option;

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

public(friend) create(Arg0: UID, Arg1: vector<Validator>, Arg2: Balance<SAFE>, Arg3: u64, Arg4: u64, Arg5: SystemParameters, Arg6: StakeSubsidy, Arg7: &mut TxContext) {
L8:	loc0: SafeSystemState
L9:	loc1: SafeSystemStateInner
L10:	loc2: u64
B0:
	0: MoveLoc[1](Arg1: vector<Validator>)
	1: MoveLoc[2](Arg2: Balance<SAFE>)
	2: MoveLoc[3](Arg3: u64)
	3: MoveLoc[4](Arg4: u64)
	4: MoveLoc[5](Arg5: SystemParameters)
	5: MoveLoc[6](Arg6: StakeSubsidy)
	6: MoveLoc[7](Arg7: &mut TxContext)
	7: Call safe_system_state_inner::create(vector<Validator>, Balance<SAFE>, u64, u64, SystemParameters, StakeSubsidy, &mut TxContext): SafeSystemStateInner
	8: StLoc[9](loc1: SafeSystemStateInner)
	9: Call safe_system_state_inner::genesis_system_state_version(): u64
	10: StLoc[10](loc2: u64)
	11: MoveLoc[0](Arg0: UID)
	12: CopyLoc[10](loc2: u64)
	13: Pack[0](SafeSystemState)
	14: StLoc[8](loc0: SafeSystemState)
	15: MutBorrowLoc[8](loc0: SafeSystemState)
	16: MutBorrowField[0](SafeSystemState.id: UID)
	17: MoveLoc[10](loc2: u64)
	18: MoveLoc[9](loc1: SafeSystemStateInner)
	19: Call dynamic_field::add<u64, SafeSystemStateInner>(&mut UID, u64, SafeSystemStateInner)
	20: MoveLoc[8](loc0: SafeSystemState)
	21: Call transfer::share_object<SafeSystemState>(SafeSystemState)
	22: Ret
}

entry public request_add_validator_candidate(Arg0: &mut SafeSystemState, Arg1: vector<u8>, Arg2: vector<u8>, Arg3: vector<u8>, Arg4: vector<u8>, Arg5: vector<u8>, Arg6: vector<u8>, Arg7: vector<u8>, Arg8: vector<u8>, Arg9: vector<u8>, Arg10: vector<u8>, Arg11: vector<u8>, Arg12: vector<u8>, Arg13: u64, Arg14: u64, Arg15: &mut TxContext) {
B0:
	0: MoveLoc[0](Arg0: &mut SafeSystemState)
	1: Call load_system_state_mut(&mut SafeSystemState): &mut SafeSystemStateInnerV2
	2: MoveLoc[1](Arg1: vector<u8>)
	3: MoveLoc[2](Arg2: vector<u8>)
	4: MoveLoc[3](Arg3: vector<u8>)
	5: MoveLoc[4](Arg4: vector<u8>)
	6: MoveLoc[5](Arg5: vector<u8>)
	7: MoveLoc[6](Arg6: vector<u8>)
	8: MoveLoc[7](Arg7: vector<u8>)
	9: MoveLoc[8](Arg8: vector<u8>)
	10: MoveLoc[9](Arg9: vector<u8>)
	11: MoveLoc[10](Arg10: vector<u8>)
	12: MoveLoc[11](Arg11: vector<u8>)
	13: MoveLoc[12](Arg12: vector<u8>)
	14: MoveLoc[13](Arg13: u64)
	15: MoveLoc[14](Arg14: u64)
	16: MoveLoc[15](Arg15: &mut TxContext)
	17: Call safe_system_state_inner::request_add_validator_candidate(&mut SafeSystemStateInnerV2, vector<u8>, vector<u8>, vector<u8>, vector<u8>, vector<u8>, vector<u8>, vector<u8>, vector<u8>, vector<u8>, vector<u8>, vector<u8>, vector<u8>, u64, u64, &mut TxContext)
	18: Ret
}

entry public request_remove_validator_candidate(Arg0: &mut SafeSystemState, Arg1: &mut TxContext) {
B0:
	0: MoveLoc[0](Arg0: &mut SafeSystemState)
	1: Call load_system_state_mut(&mut SafeSystemState): &mut SafeSystemStateInnerV2
	2: MoveLoc[1](Arg1: &mut TxContext)
	3: Call safe_system_state_inner::request_remove_validator_candidate(&mut SafeSystemStateInnerV2, &mut TxContext)
	4: Ret
}

entry public request_add_validator(Arg0: &mut SafeSystemState, Arg1: &mut TxContext) {
B0:
	0: MoveLoc[0](Arg0: &mut SafeSystemState)
	1: Call load_system_state_mut(&mut SafeSystemState): &mut SafeSystemStateInnerV2
	2: MoveLoc[1](Arg1: &mut TxContext)
	3: FreezeRef
	4: Call safe_system_state_inner::request_add_validator(&mut SafeSystemStateInnerV2, &TxContext)
	5: Ret
}

entry public request_remove_validator(Arg0: &mut SafeSystemState, Arg1: &mut TxContext) {
B0:
	0: MoveLoc[0](Arg0: &mut SafeSystemState)
	1: Call load_system_state_mut(&mut SafeSystemState): &mut SafeSystemStateInnerV2
	2: MoveLoc[1](Arg1: &mut TxContext)
	3: FreezeRef
	4: Call safe_system_state_inner::request_remove_validator(&mut SafeSystemStateInnerV2, &TxContext)
	5: Ret
}

entry public request_set_gas_price(Arg0: &mut SafeSystemState, Arg1: &UnverifiedValidatorOperationCap, Arg2: u64) {
B0:
	0: MoveLoc[0](Arg0: &mut SafeSystemState)
	1: Call load_system_state_mut(&mut SafeSystemState): &mut SafeSystemStateInnerV2
	2: MoveLoc[1](Arg1: &UnverifiedValidatorOperationCap)
	3: MoveLoc[2](Arg2: u64)
	4: Call safe_system_state_inner::request_set_gas_price(&mut SafeSystemStateInnerV2, &UnverifiedValidatorOperationCap, u64)
	5: Ret
}

entry public set_candidate_validator_gas_price(Arg0: &mut SafeSystemState, Arg1: &UnverifiedValidatorOperationCap, Arg2: u64) {
B0:
	0: MoveLoc[0](Arg0: &mut SafeSystemState)
	1: Call load_system_state_mut(&mut SafeSystemState): &mut SafeSystemStateInnerV2
	2: MoveLoc[1](Arg1: &UnverifiedValidatorOperationCap)
	3: MoveLoc[2](Arg2: u64)
	4: Call safe_system_state_inner::set_candidate_validator_gas_price(&mut SafeSystemStateInnerV2, &UnverifiedValidatorOperationCap, u64)
	5: Ret
}

entry public request_set_commission_rate(Arg0: &mut SafeSystemState, Arg1: u64, Arg2: &mut TxContext) {
B0:
	0: MoveLoc[0](Arg0: &mut SafeSystemState)
	1: Call load_system_state_mut(&mut SafeSystemState): &mut SafeSystemStateInnerV2
	2: MoveLoc[1](Arg1: u64)
	3: MoveLoc[2](Arg2: &mut TxContext)
	4: FreezeRef
	5: Call safe_system_state_inner::request_set_commission_rate(&mut SafeSystemStateInnerV2, u64, &TxContext)
	6: Ret
}

entry public set_candidate_validator_commission_rate(Arg0: &mut SafeSystemState, Arg1: u64, Arg2: &mut TxContext) {
B0:
	0: MoveLoc[0](Arg0: &mut SafeSystemState)
	1: Call load_system_state_mut(&mut SafeSystemState): &mut SafeSystemStateInnerV2
	2: MoveLoc[1](Arg1: u64)
	3: MoveLoc[2](Arg2: &mut TxContext)
	4: FreezeRef
	5: Call safe_system_state_inner::set_candidate_validator_commission_rate(&mut SafeSystemStateInnerV2, u64, &TxContext)
	6: Ret
}

entry public request_add_stake(Arg0: &mut SafeSystemState, Arg1: Coin<SAFE>, Arg2: address, Arg3: &mut TxContext) {
B0:
	0: MoveLoc[0](Arg0: &mut SafeSystemState)
	1: MoveLoc[1](Arg1: Coin<SAFE>)
	2: MoveLoc[2](Arg2: address)
	3: CopyLoc[3](Arg3: &mut TxContext)
	4: Call request_add_stake_non_entry(&mut SafeSystemState, Coin<SAFE>, address, &mut TxContext): StakedSafe
	5: MoveLoc[3](Arg3: &mut TxContext)
	6: FreezeRef
	7: Call tx_context::sender(&TxContext): address
	8: Call transfer::public_transfer<StakedSafe>(StakedSafe, address)
	9: Ret
}

public request_add_stake_non_entry(Arg0: &mut SafeSystemState, Arg1: Coin<SAFE>, Arg2: address, Arg3: &mut TxContext): StakedSafe {
B0:
	0: MoveLoc[0](Arg0: &mut SafeSystemState)
	1: Call load_system_state_mut(&mut SafeSystemState): &mut SafeSystemStateInnerV2
	2: MoveLoc[1](Arg1: Coin<SAFE>)
	3: MoveLoc[2](Arg2: address)
	4: MoveLoc[3](Arg3: &mut TxContext)
	5: Call safe_system_state_inner::request_add_stake(&mut SafeSystemStateInnerV2, Coin<SAFE>, address, &mut TxContext): StakedSafe
	6: Ret
}

entry public request_add_stake_mul_coin(Arg0: &mut SafeSystemState, Arg1: vector<Coin<SAFE>>, Arg2: Option<u64>, Arg3: address, Arg4: &mut TxContext) {
B0:
	0: MoveLoc[0](Arg0: &mut SafeSystemState)
	1: Call load_system_state_mut(&mut SafeSystemState): &mut SafeSystemStateInnerV2
	2: MoveLoc[1](Arg1: vector<Coin<SAFE>>)
	3: MoveLoc[2](Arg2: Option<u64>)
	4: MoveLoc[3](Arg3: address)
	5: CopyLoc[4](Arg4: &mut TxContext)
	6: Call safe_system_state_inner::request_add_stake_mul_coin(&mut SafeSystemStateInnerV2, vector<Coin<SAFE>>, Option<u64>, address, &mut TxContext): StakedSafe
	7: MoveLoc[4](Arg4: &mut TxContext)
	8: FreezeRef
	9: Call tx_context::sender(&TxContext): address
	10: Call transfer::public_transfer<StakedSafe>(StakedSafe, address)
	11: Ret
}

entry public request_withdraw_stake(Arg0: &mut SafeSystemState, Arg1: StakedSafe, Arg2: &mut TxContext) {
B0:
	0: MoveLoc[0](Arg0: &mut SafeSystemState)
	1: MoveLoc[1](Arg1: StakedSafe)
	2: CopyLoc[2](Arg2: &mut TxContext)
	3: Call request_withdraw_stake_non_entry(&mut SafeSystemState, StakedSafe, &mut TxContext): Balance<SAFE>
	4: CopyLoc[2](Arg2: &mut TxContext)
	5: Call coin::from_balance<SAFE>(Balance<SAFE>, &mut TxContext): Coin<SAFE>
	6: MoveLoc[2](Arg2: &mut TxContext)
	7: FreezeRef
	8: Call tx_context::sender(&TxContext): address
	9: Call transfer::public_transfer<Coin<SAFE>>(Coin<SAFE>, address)
	10: Ret
}

public convert_to_fungible_staked_safe(Arg0: &mut SafeSystemState, Arg1: StakedSafe, Arg2: &mut TxContext): FungibleStakedSafe {
B0:
	0: MoveLoc[0](Arg0: &mut SafeSystemState)
	1: Call load_system_state_mut(&mut SafeSystemState): &mut SafeSystemStateInnerV2
	2: MoveLoc[1](Arg1: StakedSafe)
	3: MoveLoc[2](Arg2: &mut TxContext)
	4: Call safe_system_state_inner::convert_to_fungible_staked_safe(&mut SafeSystemStateInnerV2, StakedSafe, &mut TxContext): FungibleStakedSafe
	5: Ret
}

public redeem_fungible_staked_safe(Arg0: &mut SafeSystemState, Arg1: FungibleStakedSafe, Arg2: &TxContext): Balance<SAFE> {
B0:
	0: MoveLoc[0](Arg0: &mut SafeSystemState)
	1: Call load_system_state_mut(&mut SafeSystemState): &mut SafeSystemStateInnerV2
	2: MoveLoc[1](Arg1: FungibleStakedSafe)
	3: MoveLoc[2](Arg2: &TxContext)
	4: Call safe_system_state_inner::redeem_fungible_staked_safe(&mut SafeSystemStateInnerV2, FungibleStakedSafe, &TxContext): Balance<SAFE>
	5: Ret
}

public request_withdraw_stake_non_entry(Arg0: &mut SafeSystemState, Arg1: StakedSafe, Arg2: &mut TxContext): Balance<SAFE> {
B0:
	0: MoveLoc[0](Arg0: &mut SafeSystemState)
	1: Call load_system_state_mut(&mut SafeSystemState): &mut SafeSystemStateInnerV2
	2: MoveLoc[1](Arg1: StakedSafe)
	3: MoveLoc[2](Arg2: &mut TxContext)
	4: FreezeRef
	5: Call safe_system_state_inner::request_withdraw_stake(&mut SafeSystemStateInnerV2, StakedSafe, &TxContext): Balance<SAFE>
	6: Ret
}

entry public report_validator(Arg0: &mut SafeSystemState, Arg1: &UnverifiedValidatorOperationCap, Arg2: address) {
B0:
	0: MoveLoc[0](Arg0: &mut SafeSystemState)
	1: Call load_system_state_mut(&mut SafeSystemState): &mut SafeSystemStateInnerV2
	2: MoveLoc[1](Arg1: &UnverifiedValidatorOperationCap)
	3: MoveLoc[2](Arg2: address)
	4: Call safe_system_state_inner::report_validator(&mut SafeSystemStateInnerV2, &UnverifiedValidatorOperationCap, address)
	5: Ret
}

entry public undo_report_validator(Arg0: &mut SafeSystemState, Arg1: &UnverifiedValidatorOperationCap, Arg2: address) {
B0:
	0: MoveLoc[0](Arg0: &mut SafeSystemState)
	1: Call load_system_state_mut(&mut SafeSystemState): &mut SafeSystemStateInnerV2
	2: MoveLoc[1](Arg1: &UnverifiedValidatorOperationCap)
	3: MoveLoc[2](Arg2: address)
	4: Call safe_system_state_inner::undo_report_validator(&mut SafeSystemStateInnerV2, &UnverifiedValidatorOperationCap, address)
	5: Ret
}

entry public rotate_operation_cap(Arg0: &mut SafeSystemState, Arg1: &mut TxContext) {
B0:
	0: MoveLoc[0](Arg0: &mut SafeSystemState)
	1: Call load_system_state_mut(&mut SafeSystemState): &mut SafeSystemStateInnerV2
	2: MoveLoc[1](Arg1: &mut TxContext)
	3: Call safe_system_state_inner::rotate_operation_cap(&mut SafeSystemStateInnerV2, &mut TxContext)
	4: Ret
}

entry public update_validator_name(Arg0: &mut SafeSystemState, Arg1: vector<u8>, Arg2: &TxContext) {
B0:
	0: MoveLoc[0](Arg0: &mut SafeSystemState)
	1: Call load_system_state_mut(&mut SafeSystemState): &mut SafeSystemStateInnerV2
	2: MoveLoc[1](Arg1: vector<u8>)
	3: MoveLoc[2](Arg2: &TxContext)
	4: Call safe_system_state_inner::update_validator_name(&mut SafeSystemStateInnerV2, vector<u8>, &TxContext)
	5: Ret
}

entry public update_validator_description(Arg0: &mut SafeSystemState, Arg1: vector<u8>, Arg2: &TxContext) {
B0:
	0: MoveLoc[0](Arg0: &mut SafeSystemState)
	1: Call load_system_state_mut(&mut SafeSystemState): &mut SafeSystemStateInnerV2
	2: MoveLoc[1](Arg1: vector<u8>)
	3: MoveLoc[2](Arg2: &TxContext)
	4: Call safe_system_state_inner::update_validator_description(&mut SafeSystemStateInnerV2, vector<u8>, &TxContext)
	5: Ret
}

entry public update_validator_image_url(Arg0: &mut SafeSystemState, Arg1: vector<u8>, Arg2: &TxContext) {
B0:
	0: MoveLoc[0](Arg0: &mut SafeSystemState)
	1: Call load_system_state_mut(&mut SafeSystemState): &mut SafeSystemStateInnerV2
	2: MoveLoc[1](Arg1: vector<u8>)
	3: MoveLoc[2](Arg2: &TxContext)
	4: Call safe_system_state_inner::update_validator_image_url(&mut SafeSystemStateInnerV2, vector<u8>, &TxContext)
	5: Ret
}

entry public update_validator_project_url(Arg0: &mut SafeSystemState, Arg1: vector<u8>, Arg2: &TxContext) {
B0:
	0: MoveLoc[0](Arg0: &mut SafeSystemState)
	1: Call load_system_state_mut(&mut SafeSystemState): &mut SafeSystemStateInnerV2
	2: MoveLoc[1](Arg1: vector<u8>)
	3: MoveLoc[2](Arg2: &TxContext)
	4: Call safe_system_state_inner::update_validator_project_url(&mut SafeSystemStateInnerV2, vector<u8>, &TxContext)
	5: Ret
}

entry public update_validator_next_epoch_network_address(Arg0: &mut SafeSystemState, Arg1: vector<u8>, Arg2: &TxContext) {
B0:
	0: MoveLoc[0](Arg0: &mut SafeSystemState)
	1: Call load_system_state_mut(&mut SafeSystemState): &mut SafeSystemStateInnerV2
	2: MoveLoc[1](Arg1: vector<u8>)
	3: MoveLoc[2](Arg2: &TxContext)
	4: Call safe_system_state_inner::update_validator_next_epoch_network_address(&mut SafeSystemStateInnerV2, vector<u8>, &TxContext)
	5: Ret
}

entry public update_candidate_validator_network_address(Arg0: &mut SafeSystemState, Arg1: vector<u8>, Arg2: &TxContext) {
B0:
	0: MoveLoc[0](Arg0: &mut SafeSystemState)
	1: Call load_system_state_mut(&mut SafeSystemState): &mut SafeSystemStateInnerV2
	2: MoveLoc[1](Arg1: vector<u8>)
	3: MoveLoc[2](Arg2: &TxContext)
	4: Call safe_system_state_inner::update_candidate_validator_network_address(&mut SafeSystemStateInnerV2, vector<u8>, &TxContext)
	5: Ret
}

entry public update_validator_next_epoch_p2p_address(Arg0: &mut SafeSystemState, Arg1: vector<u8>, Arg2: &TxContext) {
B0:
	0: MoveLoc[0](Arg0: &mut SafeSystemState)
	1: Call load_system_state_mut(&mut SafeSystemState): &mut SafeSystemStateInnerV2
	2: MoveLoc[1](Arg1: vector<u8>)
	3: MoveLoc[2](Arg2: &TxContext)
	4: Call safe_system_state_inner::update_validator_next_epoch_p2p_address(&mut SafeSystemStateInnerV2, vector<u8>, &TxContext)
	5: Ret
}

entry public update_candidate_validator_p2p_address(Arg0: &mut SafeSystemState, Arg1: vector<u8>, Arg2: &TxContext) {
B0:
	0: MoveLoc[0](Arg0: &mut SafeSystemState)
	1: Call load_system_state_mut(&mut SafeSystemState): &mut SafeSystemStateInnerV2
	2: MoveLoc[1](Arg1: vector<u8>)
	3: MoveLoc[2](Arg2: &TxContext)
	4: Call safe_system_state_inner::update_candidate_validator_p2p_address(&mut SafeSystemStateInnerV2, vector<u8>, &TxContext)
	5: Ret
}

entry public update_validator_next_epoch_primary_address(Arg0: &mut SafeSystemState, Arg1: vector<u8>, Arg2: &TxContext) {
B0:
	0: MoveLoc[0](Arg0: &mut SafeSystemState)
	1: Call load_system_state_mut(&mut SafeSystemState): &mut SafeSystemStateInnerV2
	2: MoveLoc[1](Arg1: vector<u8>)
	3: MoveLoc[2](Arg2: &TxContext)
	4: Call safe_system_state_inner::update_validator_next_epoch_primary_address(&mut SafeSystemStateInnerV2, vector<u8>, &TxContext)
	5: Ret
}

entry public update_candidate_validator_primary_address(Arg0: &mut SafeSystemState, Arg1: vector<u8>, Arg2: &TxContext) {
B0:
	0: MoveLoc[0](Arg0: &mut SafeSystemState)
	1: Call load_system_state_mut(&mut SafeSystemState): &mut SafeSystemStateInnerV2
	2: MoveLoc[1](Arg1: vector<u8>)
	3: MoveLoc[2](Arg2: &TxContext)
	4: Call safe_system_state_inner::update_candidate_validator_primary_address(&mut SafeSystemStateInnerV2, vector<u8>, &TxContext)
	5: Ret
}

entry public update_validator_next_epoch_worker_address(Arg0: &mut SafeSystemState, Arg1: vector<u8>, Arg2: &TxContext) {
B0:
	0: MoveLoc[0](Arg0: &mut SafeSystemState)
	1: Call load_system_state_mut(&mut SafeSystemState): &mut SafeSystemStateInnerV2
	2: MoveLoc[1](Arg1: vector<u8>)
	3: MoveLoc[2](Arg2: &TxContext)
	4: Call safe_system_state_inner::update_validator_next_epoch_worker_address(&mut SafeSystemStateInnerV2, vector<u8>, &TxContext)
	5: Ret
}

entry public update_candidate_validator_worker_address(Arg0: &mut SafeSystemState, Arg1: vector<u8>, Arg2: &TxContext) {
B0:
	0: MoveLoc[0](Arg0: &mut SafeSystemState)
	1: Call load_system_state_mut(&mut SafeSystemState): &mut SafeSystemStateInnerV2
	2: MoveLoc[1](Arg1: vector<u8>)
	3: MoveLoc[2](Arg2: &TxContext)
	4: Call safe_system_state_inner::update_candidate_validator_worker_address(&mut SafeSystemStateInnerV2, vector<u8>, &TxContext)
	5: Ret
}

entry public update_validator_next_epoch_protocol_pubkey(Arg0: &mut SafeSystemState, Arg1: vector<u8>, Arg2: vector<u8>, Arg3: &TxContext) {
B0:
	0: MoveLoc[0](Arg0: &mut SafeSystemState)
	1: Call load_system_state_mut(&mut SafeSystemState): &mut SafeSystemStateInnerV2
	2: MoveLoc[1](Arg1: vector<u8>)
	3: MoveLoc[2](Arg2: vector<u8>)
	4: MoveLoc[3](Arg3: &TxContext)
	5: Call safe_system_state_inner::update_validator_next_epoch_protocol_pubkey(&mut SafeSystemStateInnerV2, vector<u8>, vector<u8>, &TxContext)
	6: Ret
}

entry public update_candidate_validator_protocol_pubkey(Arg0: &mut SafeSystemState, Arg1: vector<u8>, Arg2: vector<u8>, Arg3: &TxContext) {
B0:
	0: MoveLoc[0](Arg0: &mut SafeSystemState)
	1: Call load_system_state_mut(&mut SafeSystemState): &mut SafeSystemStateInnerV2
	2: MoveLoc[1](Arg1: vector<u8>)
	3: MoveLoc[2](Arg2: vector<u8>)
	4: MoveLoc[3](Arg3: &TxContext)
	5: Call safe_system_state_inner::update_candidate_validator_protocol_pubkey(&mut SafeSystemStateInnerV2, vector<u8>, vector<u8>, &TxContext)
	6: Ret
}

entry public update_validator_next_epoch_worker_pubkey(Arg0: &mut SafeSystemState, Arg1: vector<u8>, Arg2: &TxContext) {
B0:
	0: MoveLoc[0](Arg0: &mut SafeSystemState)
	1: Call load_system_state_mut(&mut SafeSystemState): &mut SafeSystemStateInnerV2
	2: MoveLoc[1](Arg1: vector<u8>)
	3: MoveLoc[2](Arg2: &TxContext)
	4: Call safe_system_state_inner::update_validator_next_epoch_worker_pubkey(&mut SafeSystemStateInnerV2, vector<u8>, &TxContext)
	5: Ret
}

entry public update_candidate_validator_worker_pubkey(Arg0: &mut SafeSystemState, Arg1: vector<u8>, Arg2: &TxContext) {
B0:
	0: MoveLoc[0](Arg0: &mut SafeSystemState)
	1: Call load_system_state_mut(&mut SafeSystemState): &mut SafeSystemStateInnerV2
	2: MoveLoc[1](Arg1: vector<u8>)
	3: MoveLoc[2](Arg2: &TxContext)
	4: Call safe_system_state_inner::update_candidate_validator_worker_pubkey(&mut SafeSystemStateInnerV2, vector<u8>, &TxContext)
	5: Ret
}

entry public update_validator_next_epoch_network_pubkey(Arg0: &mut SafeSystemState, Arg1: vector<u8>, Arg2: &TxContext) {
B0:
	0: MoveLoc[0](Arg0: &mut SafeSystemState)
	1: Call load_system_state_mut(&mut SafeSystemState): &mut SafeSystemStateInnerV2
	2: MoveLoc[1](Arg1: vector<u8>)
	3: MoveLoc[2](Arg2: &TxContext)
	4: Call safe_system_state_inner::update_validator_next_epoch_network_pubkey(&mut SafeSystemStateInnerV2, vector<u8>, &TxContext)
	5: Ret
}

entry public update_candidate_validator_network_pubkey(Arg0: &mut SafeSystemState, Arg1: vector<u8>, Arg2: &TxContext) {
B0:
	0: MoveLoc[0](Arg0: &mut SafeSystemState)
	1: Call load_system_state_mut(&mut SafeSystemState): &mut SafeSystemStateInnerV2
	2: MoveLoc[1](Arg1: vector<u8>)
	3: MoveLoc[2](Arg2: &TxContext)
	4: Call safe_system_state_inner::update_candidate_validator_network_pubkey(&mut SafeSystemStateInnerV2, vector<u8>, &TxContext)
	5: Ret
}

public validator_address_by_pool_id(Arg0: &mut SafeSystemState, Arg1: &ID): address {
B0:
	0: MoveLoc[0](Arg0: &mut SafeSystemState)
	1: Call load_system_state_mut(&mut SafeSystemState): &mut SafeSystemStateInnerV2
	2: MoveLoc[1](Arg1: &ID)
	3: Call safe_system_state_inner::validator_address_by_pool_id(&mut SafeSystemStateInnerV2, &ID): address
	4: Ret
}

public pool_exchange_rates(Arg0: &mut SafeSystemState, Arg1: &ID): &Table<u64, PoolTokenExchangeRate> {
B0:
	0: MoveLoc[0](Arg0: &mut SafeSystemState)
	1: Call load_system_state_mut(&mut SafeSystemState): &mut SafeSystemStateInnerV2
	2: MoveLoc[1](Arg1: &ID)
	3: Call safe_system_state_inner::pool_exchange_rates(&mut SafeSystemStateInnerV2, &ID): &Table<u64, PoolTokenExchangeRate>
	4: Ret
}

public active_validator_addresses(Arg0: &mut SafeSystemState): vector<address> {
B0:
	0: MoveLoc[0](Arg0: &mut SafeSystemState)
	1: Call load_system_state_mut(&mut SafeSystemState): &mut SafeSystemStateInnerV2
	2: FreezeRef
	3: Call safe_system_state_inner::active_validator_addresses(&SafeSystemStateInnerV2): vector<address>
	4: Ret
}

public(friend) calculate_rewards(Arg0: &mut SafeSystemState, Arg1: &StakedSafe, Arg2: &TxContext): u64 {
L3:	loc0: ID
L4:	loc1: &mut ValidatorSet
B0:
	0: MoveLoc[0](Arg0: &mut SafeSystemState)
	1: Call load_system_state_mut(&mut SafeSystemState): &mut SafeSystemStateInnerV2
	2: Call safe_system_state_inner::validators_mut(&mut SafeSystemStateInnerV2): &mut ValidatorSet
	3: StLoc[4](loc1: &mut ValidatorSet)
	4: CopyLoc[1](Arg1: &StakedSafe)
	5: Call staking_pool::pool_id(&StakedSafe): ID
	6: StLoc[3](loc0: ID)
	7: MoveLoc[4](loc1: &mut ValidatorSet)
	8: ImmBorrowLoc[3](loc0: ID)
	9: Call validator_set::validator_by_pool_id(&mut ValidatorSet, &ID): &Validator
	10: Call validator::get_staking_pool_ref(&Validator): &StakingPool
	11: MoveLoc[1](Arg1: &StakedSafe)
	12: MoveLoc[2](Arg2: &TxContext)
	13: Call tx_context::epoch(&TxContext): u64
	14: Call staking_pool::calculate_rewards(&StakingPool, &StakedSafe, u64): u64
	15: Ret
}

advance_epoch(Arg0: Balance<SAFE>, Arg1: Balance<SAFE>, Arg2: &mut SafeSystemState, Arg3: u64, Arg4: u64, Arg5: u64, Arg6: u64, Arg7: u64, Arg8: u64, Arg9: u64, Arg10: &mut TxContext): Balance<SAFE> {
B0:
	0: CopyLoc[10](Arg10: &mut TxContext)
	1: FreezeRef
	2: Call tx_context::sender(&TxContext): address
	3: LdConst[2](address: 0x00..)
	4: Eq
	5: BrFalse(7)
B1:
	6: Branch(13)
B2:
	7: MoveLoc[2](Arg2: &mut SafeSystemState)
	8: Pop
	9: MoveLoc[10](Arg10: &mut TxContext)
	10: Pop
	11: LdConst[0](u64: 0)
	12: Abort
B3:
	13: MoveLoc[2](Arg2: &mut SafeSystemState)
	14: Call load_system_state_mut(&mut SafeSystemState): &mut SafeSystemStateInnerV2
	15: MoveLoc[3](Arg3: u64)
	16: MoveLoc[4](Arg4: u64)
	17: MoveLoc[0](Arg0: Balance<SAFE>)
	18: MoveLoc[1](Arg1: Balance<SAFE>)
	19: MoveLoc[5](Arg5: u64)
	20: MoveLoc[6](Arg6: u64)
	21: MoveLoc[7](Arg7: u64)
	22: MoveLoc[8](Arg8: u64)
	23: MoveLoc[9](Arg9: u64)
	24: MoveLoc[10](Arg10: &mut TxContext)
	25: Call safe_system_state_inner::advance_epoch(&mut SafeSystemStateInnerV2, u64, u64, Balance<SAFE>, Balance<SAFE>, u64, u64, u64, u64, u64, &mut TxContext): Balance<SAFE>
	26: Ret
}

load_system_state(Arg0: &mut SafeSystemState): &SafeSystemStateInnerV2 {
B0:
	0: MoveLoc[0](Arg0: &mut SafeSystemState)
	1: Call load_inner_maybe_upgrade(&mut SafeSystemState): &mut SafeSystemStateInnerV2
	2: FreezeRef
	3: Ret
}

load_system_state_mut(Arg0: &mut SafeSystemState): &mut SafeSystemStateInnerV2 {
B0:
	0: MoveLoc[0](Arg0: &mut SafeSystemState)
	1: Call load_inner_maybe_upgrade(&mut SafeSystemState): &mut SafeSystemStateInnerV2
	2: Ret
}

load_inner_maybe_upgrade(Arg0: &mut SafeSystemState): &mut SafeSystemStateInnerV2 {
L1:	loc0: &mut SafeSystemStateInnerV2
L2:	loc1: SafeSystemStateInnerV2
B0:
	0: CopyLoc[0](Arg0: &mut SafeSystemState)
	1: ImmBorrowField[1](SafeSystemState.version: u64)
	2: ReadRef
	3: LdU64(1)
	4: Eq
	5: BrFalse(25)
B1:
	6: CopyLoc[0](Arg0: &mut SafeSystemState)
	7: MutBorrowField[0](SafeSystemState.id: UID)
	8: CopyLoc[0](Arg0: &mut SafeSystemState)
	9: ImmBorrowField[1](SafeSystemState.version: u64)
	10: ReadRef
	11: Call dynamic_field::remove<u64, SafeSystemStateInner>(&mut UID, u64): SafeSystemStateInner
	12: Call safe_system_state_inner::v1_to_v2(SafeSystemStateInner): SafeSystemStateInnerV2
	13: StLoc[2](loc1: SafeSystemStateInnerV2)
	14: LdU64(2)
	15: CopyLoc[0](Arg0: &mut SafeSystemState)
	16: MutBorrowField[1](SafeSystemState.version: u64)
	17: WriteRef
	18: CopyLoc[0](Arg0: &mut SafeSystemState)
	19: MutBorrowField[0](SafeSystemState.id: UID)
	20: CopyLoc[0](Arg0: &mut SafeSystemState)
	21: ImmBorrowField[1](SafeSystemState.version: u64)
	22: ReadRef
	23: MoveLoc[2](loc1: SafeSystemStateInnerV2)
	24: Call dynamic_field::add<u64, SafeSystemStateInnerV2>(&mut UID, u64, SafeSystemStateInnerV2)
B2:
	25: CopyLoc[0](Arg0: &mut SafeSystemState)
	26: MutBorrowField[0](SafeSystemState.id: UID)
	27: CopyLoc[0](Arg0: &mut SafeSystemState)
	28: ImmBorrowField[1](SafeSystemState.version: u64)
	29: ReadRef
	30: Call dynamic_field::borrow_mut<u64, SafeSystemStateInnerV2>(&mut UID, u64): &mut SafeSystemStateInnerV2
	31: StLoc[1](loc0: &mut SafeSystemStateInnerV2)
	32: CopyLoc[1](loc0: &mut SafeSystemStateInnerV2)
	33: FreezeRef
	34: Call safe_system_state_inner::system_state_version(&SafeSystemStateInnerV2): u64
	35: MoveLoc[0](Arg0: &mut SafeSystemState)
	36: ImmBorrowField[1](SafeSystemState.version: u64)
	37: ReadRef
	38: Eq
	39: BrFalse(41)
B3:
	40: Branch(45)
B4:
	41: MoveLoc[1](loc0: &mut SafeSystemStateInnerV2)
	42: Pop
	43: LdConst[1](u64: 1)
	44: Abort
B5:
	45: MoveLoc[1](loc0: &mut SafeSystemStateInnerV2)
	46: Ret
}

validator_voting_powers(Arg0: &mut SafeSystemState): VecMap<address, u64> {
B0:
	0: MoveLoc[0](Arg0: &mut SafeSystemState)
	1: Call load_system_state(&mut SafeSystemState): &SafeSystemStateInnerV2
	2: Call safe_system_state_inner::active_validator_voting_powers(&SafeSystemStateInnerV2): VecMap<address, u64>
	3: Ret
}

store_execution_time_estimates(Arg0: &mut SafeSystemState, Arg1: vector<u8>) {
B0:
	0: MoveLoc[0](Arg0: &mut SafeSystemState)
	1: Call load_system_state_mut(&mut SafeSystemState): &mut SafeSystemStateInnerV2
	2: MoveLoc[1](Arg1: vector<u8>)
	3: Call safe_system_state_inner::store_execution_time_estimates(&mut SafeSystemStateInnerV2, vector<u8>)
	4: Ret
}

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

// Move bytecode v6
module 3.safe_system_state_inner {
use 0000000000000000000000000000000000000000000000000000000000000002::bag;
use 0000000000000000000000000000000000000000000000000000000000000002::balance;
use 0000000000000000000000000000000000000000000000000000000000000002::coin;
use 0000000000000000000000000000000000000000000000000000000000000002::event;
use 0000000000000000000000000000000000000000000000000000000000000002::object;
use 0000000000000000000000000000000000000000000000000000000000000002::safe;
use 0000000000000000000000000000000000000000000000000000000000000002::table;
use 0000000000000000000000000000000000000000000000000000000000000002::transfer;
use 0000000000000000000000000000000000000000000000000000000000000002::tx_context;
use 0000000000000000000000000000000000000000000000000000000000000002::vec_map;
use 0000000000000000000000000000000000000000000000000000000000000002::vec_set;
use 0000000000000000000000000000000000000000000000000000000000000003::stake_subsidy;
use 0000000000000000000000000000000000000000000000000000000000000003::staking_pool;
use 0000000000000000000000000000000000000000000000000000000000000003::storage_fund;
use 0000000000000000000000000000000000000000000000000000000000000003::validator;
use 0000000000000000000000000000000000000000000000000000000000000003::validator_cap;
use 0000000000000000000000000000000000000000000000000000000000000003::validator_set;
use 0000000000000000000000000000000000000000000000000000000000000001::option;
use 0000000000000000000000000000000000000000000000000000000000000001::vector;

struct SystemParameters has store {
	epoch_duration_ms: u64,
	stake_subsidy_start_epoch: u64,
	max_validator_count: u64,
	min_validator_joining_stake: u64,
	validator_low_stake_threshold: u64,
	validator_very_low_stake_threshold: u64,
	validator_low_stake_grace_period: u64,
	extra_fields: Bag
}

struct SystemParametersV2 has store {
	epoch_duration_ms: u64,
	stake_subsidy_start_epoch: u64,
	min_validator_count: u64,
	max_validator_count: u64,
	min_validator_joining_stake: u64,
	validator_low_stake_threshold: u64,
	validator_very_low_stake_threshold: u64,
	validator_low_stake_grace_period: u64,
	extra_fields: Bag
}

struct SafeSystemStateInner has store {
	epoch: u64,
	protocol_version: u64,
	system_state_version: u64,
	validators: ValidatorSet,
	storage_fund: StorageFund,
	parameters: SystemParameters,
	reference_gas_price: u64,
	validator_report_records: VecMap<address, VecSet<address>>,
	stake_subsidy: StakeSubsidy,
	safe_mode: bool,
	safe_mode_storage_rewards: Balance<SAFE>,
	safe_mode_computation_rewards: Balance<SAFE>,
	safe_mode_storage_rebates: u64,
	safe_mode_non_refundable_storage_fee: u64,
	epoch_start_timestamp_ms: u64,
	extra_fields: Bag
}

struct SafeSystemStateInnerV2 has store {
	epoch: u64,
	protocol_version: u64,
	system_state_version: u64,
	validators: ValidatorSet,
	storage_fund: StorageFund,
	parameters: SystemParametersV2,
	reference_gas_price: u64,
	validator_report_records: VecMap<address, VecSet<address>>,
	stake_subsidy: StakeSubsidy,
	safe_mode: bool,
	safe_mode_storage_rewards: Balance<SAFE>,
	safe_mode_computation_rewards: Balance<SAFE>,
	safe_mode_storage_rebates: u64,
	safe_mode_non_refundable_storage_fee: u64,
	epoch_start_timestamp_ms: u64,
	extra_fields: Bag
}

struct SystemEpochInfoEvent has copy, drop {
	epoch: u64,
	protocol_version: u64,
	reference_gas_price: u64,
	total_stake: u64,
	storage_fund_reinvestment: u64,
	storage_charge: u64,
	storage_rebate: u64,
	storage_fund_balance: u64,
	stake_subsidy_amount: u64,
	total_gas_fees: u64,
	total_stake_rewards_distributed: u64,
	leftover_storage_fund_inflow: u64
}

public(friend) create(Arg0: vector<Validator>, Arg1: Balance<SAFE>, Arg2: u64, Arg3: u64, Arg4: SystemParameters, Arg5: StakeSubsidy, Arg6: &mut TxContext): SafeSystemStateInner {
L7:	loc0: u64
L8:	loc1: ValidatorSet
B0:
	0: MoveLoc[0](Arg0: vector<Validator>)
	1: CopyLoc[6](Arg6: &mut TxContext)
	2: Call validator_set::new(vector<Validator>, &mut TxContext): ValidatorSet
	3: StLoc[8](loc1: ValidatorSet)
	4: ImmBorrowLoc[8](loc1: ValidatorSet)
	5: Call validator_set::derive_reference_gas_price(&ValidatorSet): u64
	6: StLoc[7](loc0: u64)
	7: LdU64(0)
	8: MoveLoc[2](Arg2: u64)
	9: Call genesis_system_state_version(): u64
	10: MoveLoc[8](loc1: ValidatorSet)
	11: MoveLoc[1](Arg1: Balance<SAFE>)
	12: Call storage_fund::new(Balance<SAFE>): StorageFund
	13: MoveLoc[4](Arg4: SystemParameters)
	14: MoveLoc[7](loc0: u64)
	15: Call vec_map::empty<address, VecSet<address>>(): VecMap<address, VecSet<address>>
	16: MoveLoc[5](Arg5: StakeSubsidy)
	17: LdFalse
	18: Call balance::zero<SAFE>(): Balance<SAFE>
	19: Call balance::zero<SAFE>(): Balance<SAFE>
	20: LdU64(0)
	21: LdU64(0)
	22: MoveLoc[3](Arg3: u64)
	23: MoveLoc[6](Arg6: &mut TxContext)
	24: Call bag::new(&mut TxContext): Bag
	25: Pack[2](SafeSystemStateInner)
	26: Ret
}

public(friend) create_system_parameters(Arg0: u64, Arg1: u64, Arg2: u64, Arg3: u64, Arg4: u64, Arg5: u64, Arg6: u64, Arg7: &mut TxContext): SystemParameters {
B0:
	0: MoveLoc[0](Arg0: u64)
	1: MoveLoc[1](Arg1: u64)
	2: MoveLoc[2](Arg2: u64)
	3: MoveLoc[3](Arg3: u64)
	4: MoveLoc[4](Arg4: u64)
	5: MoveLoc[5](Arg5: u64)
	6: MoveLoc[6](Arg6: u64)
	7: MoveLoc[7](Arg7: &mut TxContext)
	8: Call bag::new(&mut TxContext): Bag
	9: Pack[0](SystemParameters)
	10: Ret
}

public(friend) v1_to_v2(Arg0: SafeSystemStateInner): SafeSystemStateInnerV2 {
L1:	loc0: u64
L2:	loc1: u64
L3:	loc2: u64
L4:	loc3: u64
L5:	loc4: u64
L6:	loc5: Bag
L7:	loc6: SystemParameters
L8:	loc7: u64
L9:	loc8: u64
L10:	loc9: bool
L11:	loc10: Balance<SAFE>
L12:	loc11: u64
L13:	loc12: u64
L14:	loc13: Balance<SAFE>
L15:	loc14: StakeSubsidy
L16:	loc15: u64
L17:	loc16: Bag
L18:	loc17: StorageFund
L19:	loc18: u64
L20:	loc19: u64
L21:	loc20: VecMap<address, VecSet<address>>
L22:	loc21: u64
L23:	loc22: ValidatorSet
B0:
	0: MoveLoc[0](Arg0: SafeSystemStateInner)
	1: Unpack[2](SafeSystemStateInner)
	2: StLoc[17](loc16: Bag)
	3: StLoc[3](loc2: u64)
	4: StLoc[12](loc11: u64)
	5: StLoc[13](loc12: u64)
	6: StLoc[11](loc10: Balance<SAFE>)
	7: StLoc[14](loc13: Balance<SAFE>)
	8: StLoc[10](loc9: bool)
	9: StLoc[15](loc14: StakeSubsidy)
	10: StLoc[21](loc20: VecMap<address, VecSet<address>>)
	11: StLoc[9](loc8: u64)
	12: StLoc[7](loc6: SystemParameters)
	13: StLoc[18](loc17: StorageFund)
	14: StLoc[23](loc22: ValidatorSet)
	15: Pop
	16: StLoc[8](loc7: u64)
	17: StLoc[1](loc0: u64)
	18: MoveLoc[7](loc6: SystemParameters)
	19: Unpack[0](SystemParameters)
	20: StLoc[6](loc5: Bag)
	21: StLoc[19](loc18: u64)
	22: StLoc[22](loc21: u64)
	23: StLoc[20](loc19: u64)
	24: StLoc[5](loc4: u64)
	25: StLoc[4](loc3: u64)
	26: StLoc[16](loc15: u64)
	27: StLoc[2](loc1: u64)
	28: MoveLoc[1](loc0: u64)
	29: MoveLoc[8](loc7: u64)
	30: LdU64(2)
	31: MoveLoc[23](loc22: ValidatorSet)
	32: MoveLoc[18](loc17: StorageFund)
	33: MoveLoc[2](loc1: u64)
	34: MoveLoc[16](loc15: u64)
	35: LdU64(4)
	36: MoveLoc[4](loc3: u64)
	37: MoveLoc[5](loc4: u64)
	38: MoveLoc[20](loc19: u64)
	39: MoveLoc[22](loc21: u64)
	40: MoveLoc[19](loc18: u64)
	41: MoveLoc[6](loc5: Bag)
	42: Pack[1](SystemParametersV2)
	43: MoveLoc[9](loc8: u64)
	44: MoveLoc[21](loc20: VecMap<address, VecSet<address>>)
	45: MoveLoc[15](loc14: StakeSubsidy)
	46: MoveLoc[10](loc9: bool)
	47: MoveLoc[14](loc13: Balance<SAFE>)
	48: MoveLoc[11](loc10: Balance<SAFE>)
	49: MoveLoc[13](loc12: u64)
	50: MoveLoc[12](loc11: u64)
	51: MoveLoc[3](loc2: u64)
	52: MoveLoc[17](loc16: Bag)
	53: Pack[3](SafeSystemStateInnerV2)
	54: Ret
}

public(friend) request_add_validator_candidate(Arg0: &mut SafeSystemStateInnerV2, Arg1: vector<u8>, Arg2: vector<u8>, Arg3: vector<u8>, Arg4: vector<u8>, Arg5: vector<u8>, Arg6: vector<u8>, Arg7: vector<u8>, Arg8: vector<u8>, Arg9: vector<u8>, Arg10: vector<u8>, Arg11: vector<u8>, Arg12: vector<u8>, Arg13: u64, Arg14: u64, Arg15: &mut TxContext) {
L16:	loc0: Validator
B0:
	0: CopyLoc[15](Arg15: &mut TxContext)
	1: FreezeRef
	2: Call tx_context::sender(&TxContext): address
	3: MoveLoc[1](Arg1: vector<u8>)
	4: MoveLoc[2](Arg2: vector<u8>)
	5: MoveLoc[3](Arg3: vector<u8>)
	6: MoveLoc[4](Arg4: vector<u8>)
	7: MoveLoc[5](Arg5: vector<u8>)
	8: MoveLoc[6](Arg6: vector<u8>)
	9: MoveLoc[7](Arg7: vector<u8>)
	10: MoveLoc[8](Arg8: vector<u8>)
	11: MoveLoc[9](Arg9: vector<u8>)
	12: MoveLoc[10](Arg10: vector<u8>)
	13: MoveLoc[11](Arg11: vector<u8>)
	14: MoveLoc[12](Arg12: vector<u8>)
	15: MoveLoc[13](Arg13: u64)
	16: MoveLoc[14](Arg14: u64)
	17: CopyLoc[15](Arg15: &mut TxContext)
	18: Call validator::new(address, vector<u8>, vector<u8>, vector<u8>, vector<u8>, vector<u8>, vector<u8>, vector<u8>, vector<u8>, vector<u8>, vector<u8>, vector<u8>, vector<u8>, u64, u64, &mut TxContext): Validator
	19: StLoc[16](loc0: Validator)
	20: MoveLoc[0](Arg0: &mut SafeSystemStateInnerV2)
	21: MutBorrowField[0](SafeSystemStateInnerV2.validators: ValidatorSet)
	22: MoveLoc[16](loc0: Validator)
	23: MoveLoc[15](Arg15: &mut TxContext)
	24: Call validator_set::request_add_validator_candidate(&mut ValidatorSet, Validator, &mut TxContext)
	25: Ret
}

public(friend) request_remove_validator_candidate(Arg0: &mut SafeSystemStateInnerV2, Arg1: &mut TxContext) {
B0:
	0: MoveLoc[0](Arg0: &mut SafeSystemStateInnerV2)
	1: MutBorrowField[0](SafeSystemStateInnerV2.validators: ValidatorSet)
	2: MoveLoc[1](Arg1: &mut TxContext)
	3: Call validator_set::request_remove_validator_candidate(&mut ValidatorSet, &mut TxContext)
	4: Ret
}

public(friend) request_add_validator(Arg0: &mut SafeSystemStateInnerV2, Arg1: &TxContext) {
B0:
	0: CopyLoc[0](Arg0: &mut SafeSystemStateInnerV2)
	1: ImmBorrowField[0](SafeSystemStateInnerV2.validators: ValidatorSet)
	2: Call validator_set::next_epoch_validator_count(&ValidatorSet): u64
	3: CopyLoc[0](Arg0: &mut SafeSystemStateInnerV2)
	4: ImmBorrowField[1](SafeSystemStateInnerV2.parameters: SystemParametersV2)
	5: ImmBorrowField[2](SystemParametersV2.max_validator_count: u64)
	6: ReadRef
	7: Lt
	8: BrFalse(10)
B1:
	9: Branch(16)
B2:
	10: MoveLoc[0](Arg0: &mut SafeSystemStateInnerV2)
	11: Pop
	12: MoveLoc[1](Arg1: &TxContext)
	13: Pop
	14: LdConst[1](u64: 1)
	15: Abort
B3:
	16: MoveLoc[0](Arg0: &mut SafeSystemStateInnerV2)
	17: MutBorrowField[0](SafeSystemStateInnerV2.validators: ValidatorSet)
	18: MoveLoc[1](Arg1: &TxContext)
	19: Call validator_set::request_add_validator(&mut ValidatorSet, &TxContext)
	20: Ret
}

public(friend) request_remove_validator(Arg0: &mut SafeSystemStateInnerV2, Arg1: &TxContext) {
B0:
	0: CopyLoc[0](Arg0: &mut SafeSystemStateInnerV2)
	1: ImmBorrowField[0](SafeSystemStateInnerV2.validators: ValidatorSet)
	2: Call validator_set::active_validators(&ValidatorSet): &vector<Validator>
	3: VecLen(51)
	4: CopyLoc[0](Arg0: &mut SafeSystemStateInnerV2)
	5: ImmBorrowField[1](SafeSystemStateInnerV2.parameters: SystemParametersV2)
	6: ImmBorrowField[3](SystemParametersV2.min_validator_count: u64)
	7: ReadRef
	8: Ge
	9: BrFalse(26)
B1:
	10: CopyLoc[0](Arg0: &mut SafeSystemStateInnerV2)
	11: ImmBorrowField[0](SafeSystemStateInnerV2.validators: ValidatorSet)
	12: Call validator_set::next_epoch_validator_count(&ValidatorSet): u64
	13: CopyLoc[0](Arg0: &mut SafeSystemStateInnerV2)
	14: ImmBorrowField[1](SafeSystemStateInnerV2.parameters: SystemParametersV2)
	15: ImmBorrowField[3](SystemParametersV2.min_validator_count: u64)
	16: ReadRef
	17: Gt
	18: BrFalse(20)
B2:
	19: Branch(26)
B3:
	20: MoveLoc[0](Arg0: &mut SafeSystemStateInnerV2)
	21: Pop
	22: MoveLoc[1](Arg1: &TxContext)
	23: Pop
	24: LdConst[1](u64: 1)
	25: Abort
B4:
	26: MoveLoc[0](Arg0: &mut SafeSystemStateInnerV2)
	27: MutBorrowField[0](SafeSystemStateInnerV2.validators: ValidatorSet)
	28: MoveLoc[1](Arg1: &TxContext)
	29: Call validator_set::request_remove_validator(&mut ValidatorSet, &TxContext)
	30: Ret
}

public(friend) request_set_gas_price(Arg0: &mut SafeSystemStateInnerV2, Arg1: &UnverifiedValidatorOperationCap, Arg2: u64) {
L3:	loc0: ValidatorOperationCap
B0:
	0: CopyLoc[0](Arg0: &mut SafeSystemStateInnerV2)
	1: MutBorrowField[0](SafeSystemStateInnerV2.validators: ValidatorSet)
	2: MoveLoc[1](Arg1: &UnverifiedValidatorOperationCap)
	3: LdConst[10](u8: 2)
	4: Call validator_set::verify_cap(&mut ValidatorSet, &UnverifiedValidatorOperationCap, u8): ValidatorOperationCap
	5: StLoc[3](loc0: ValidatorOperationCap)
	6: MoveLoc[0](Arg0: &mut SafeSystemStateInnerV2)
	7: MutBorrowField[0](SafeSystemStateInnerV2.validators: ValidatorSet)
	8: ImmBorrowLoc[3](loc0: ValidatorOperationCap)
	9: LdFalse
	10: Call validator_set::get_validator_mut_with_verified_cap(&mut ValidatorSet, &ValidatorOperationCap, bool): &mut Validator
	11: MoveLoc[3](loc0: ValidatorOperationCap)
	12: MoveLoc[2](Arg2: u64)
	13: Call validator::request_set_gas_price(&mut Validator, ValidatorOperationCap, u64)
	14: Ret
}

public(friend) set_candidate_validator_gas_price(Arg0: &mut SafeSystemStateInnerV2, Arg1: &UnverifiedValidatorOperationCap, Arg2: u64) {
L3:	loc0: ValidatorOperationCap
B0:
	0: CopyLoc[0](Arg0: &mut SafeSystemStateInnerV2)
	1: MutBorrowField[0](SafeSystemStateInnerV2.validators: ValidatorSet)
	2: MoveLoc[1](Arg1: &UnverifiedValidatorOperationCap)
	3: LdConst[11](u8: 3)
	4: Call validator_set::verify_cap(&mut ValidatorSet, &UnverifiedValidatorOperationCap, u8): ValidatorOperationCap
	5: StLoc[3](loc0: ValidatorOperationCap)
	6: MoveLoc[0](Arg0: &mut SafeSystemStateInnerV2)
	7: MutBorrowField[0](SafeSystemStateInnerV2.validators: ValidatorSet)
	8: ImmBorrowLoc[3](loc0: ValidatorOperationCap)
	9: LdTrue
	10: Call validator_set::get_validator_mut_with_verified_cap(&mut ValidatorSet, &ValidatorOperationCap, bool): &mut Validator
	11: MoveLoc[3](loc0: ValidatorOperationCap)
	12: MoveLoc[2](Arg2: u64)
	13: Call validator::set_candidate_gas_price(&mut Validator, ValidatorOperationCap, u64)
	14: Ret
}

public(friend) request_set_commission_rate(Arg0: &mut SafeSystemStateInnerV2, Arg1: u64, Arg2: &TxContext) {
B0:
	0: MoveLoc[0](Arg0: &mut SafeSystemStateInnerV2)
	1: MutBorrowField[0](SafeSystemStateInnerV2.validators: ValidatorSet)
	2: MoveLoc[1](Arg1: u64)
	3: MoveLoc[2](Arg2: &TxContext)
	4: Call validator_set::request_set_commission_rate(&mut ValidatorSet, u64, &TxContext)
	5: Ret
}

public(friend) set_candidate_validator_commission_rate(Arg0: &mut SafeSystemStateInnerV2, Arg1: u64, Arg2: &TxContext) {
B0:
	0: MoveLoc[0](Arg0: &mut SafeSystemStateInnerV2)
	1: MutBorrowField[0](SafeSystemStateInnerV2.validators: ValidatorSet)
	2: MoveLoc[2](Arg2: &TxContext)
	3: Call validator_set::get_validator_mut_with_ctx_including_candidates(&mut ValidatorSet, &TxContext): &mut Validator
	4: MoveLoc[1](Arg1: u64)
	5: Call validator::set_candidate_commission_rate(&mut Validator, u64)
	6: Ret
}

public(friend) request_add_stake(Arg0: &mut SafeSystemStateInnerV2, Arg1: Coin<SAFE>, Arg2: address, Arg3: &mut TxContext): StakedSafe {
B0:
	0: MoveLoc[0](Arg0: &mut SafeSystemStateInnerV2)
	1: MutBorrowField[0](SafeSystemStateInnerV2.validators: ValidatorSet)
	2: MoveLoc[2](Arg2: address)
	3: MoveLoc[1](Arg1: Coin<SAFE>)
	4: Call coin::into_balance<SAFE>(Coin<SAFE>): Balance<SAFE>
	5: MoveLoc[3](Arg3: &mut TxContext)
	6: Call validator_set::request_add_stake(&mut ValidatorSet, address, Balance<SAFE>, &mut TxContext): StakedSafe
	7: Ret
}

public(friend) request_add_stake_mul_coin(Arg0: &mut SafeSystemStateInnerV2, Arg1: vector<Coin<SAFE>>, Arg2: Option<u64>, Arg3: address, Arg4: &mut TxContext): StakedSafe {
L5:	loc0: Balance<SAFE>
B0:
	0: MoveLoc[1](Arg1: vector<Coin<SAFE>>)
	1: MoveLoc[2](Arg2: Option<u64>)
	2: CopyLoc[4](Arg4: &mut TxContext)
	3: Call extract_coin_balance(vector<Coin<SAFE>>, Option<u64>, &mut TxContext): Balance<SAFE>
	4: StLoc[5](loc0: Balance<SAFE>)
	5: MoveLoc[0](Arg0: &mut SafeSystemStateInnerV2)
	6: MutBorrowField[0](SafeSystemStateInnerV2.validators: ValidatorSet)
	7: MoveLoc[3](Arg3: address)
	8: MoveLoc[5](loc0: Balance<SAFE>)
	9: MoveLoc[4](Arg4: &mut TxContext)
	10: Call validator_set::request_add_stake(&mut ValidatorSet, address, Balance<SAFE>, &mut TxContext): StakedSafe
	11: Ret
}

public(friend) request_withdraw_stake(Arg0: &mut SafeSystemStateInnerV2, Arg1: StakedSafe, Arg2: &TxContext): Balance<SAFE> {
B0:
	0: MoveLoc[0](Arg0: &mut SafeSystemStateInnerV2)
	1: MutBorrowField[0](SafeSystemStateInnerV2.validators: ValidatorSet)
	2: MoveLoc[1](Arg1: StakedSafe)
	3: MoveLoc[2](Arg2: &TxContext)
	4: Call validator_set::request_withdraw_stake(&mut ValidatorSet, StakedSafe, &TxContext): Balance<SAFE>
	5: Ret
}

public(friend) convert_to_fungible_staked_safe(Arg0: &mut SafeSystemStateInnerV2, Arg1: StakedSafe, Arg2: &mut TxContext): FungibleStakedSafe {
B0:
	0: MoveLoc[0](Arg0: &mut SafeSystemStateInnerV2)
	1: MutBorrowField[0](SafeSystemStateInnerV2.validators: ValidatorSet)
	2: MoveLoc[1](Arg1: StakedSafe)
	3: MoveLoc[2](Arg2: &mut TxContext)
	4: Call validator_set::convert_to_fungible_staked_safe(&mut ValidatorSet, StakedSafe, &mut TxContext): FungibleStakedSafe
	5: Ret
}

public(friend) redeem_fungible_staked_safe(Arg0: &mut SafeSystemStateInnerV2, Arg1: FungibleStakedSafe, Arg2: &TxContext): Balance<SAFE> {
B0:
	0: MoveLoc[0](Arg0: &mut SafeSystemStateInnerV2)
	1: MutBorrowField[0](SafeSystemStateInnerV2.validators: ValidatorSet)
	2: MoveLoc[1](Arg1: FungibleStakedSafe)
	3: MoveLoc[2](Arg2: &TxContext)
	4: Call validator_set::redeem_fungible_staked_safe(&mut ValidatorSet, FungibleStakedSafe, &TxContext): Balance<SAFE>
	5: Ret
}

public(friend) report_validator(Arg0: &mut SafeSystemStateInnerV2, Arg1: &UnverifiedValidatorOperationCap, Arg2: address) {
B0:
	0: CopyLoc[0](Arg0: &mut SafeSystemStateInnerV2)
	1: ImmBorrowField[0](SafeSystemStateInnerV2.validators: ValidatorSet)
	2: CopyLoc[2](Arg2: address)
	3: Call validator_set::is_active_validator_by_safe_address(&ValidatorSet, address): bool
	4: BrFalse(6)
B1:
	5: Branch(12)
B2:
	6: MoveLoc[0](Arg0: &mut SafeSystemStateInnerV2)
	7: Pop
	8: MoveLoc[1](Arg1: &UnverifiedValidatorOperationCap)
	9: Pop
	10: LdConst[0](u64: 0)
	11: Abort
B3:
	12: CopyLoc[0](Arg0: &mut SafeSystemStateInnerV2)
	13: MutBorrowField[0](SafeSystemStateInnerV2.validators: ValidatorSet)
	14: MoveLoc[1](Arg1: &UnverifiedValidatorOperationCap)
	15: LdConst[9](u8: 1)
	16: Call validator_set::verify_cap(&mut ValidatorSet, &UnverifiedValidatorOperationCap, u8): ValidatorOperationCap
	17: MoveLoc[2](Arg2: address)
	18: MoveLoc[0](Arg0: &mut SafeSystemStateInnerV2)
	19: MutBorrowField[4](SafeSystemStateInnerV2.validator_report_records: VecMap<address, VecSet<address>>)
	20: Call report_validator_impl(ValidatorOperationCap, address, &mut VecMap<address, VecSet<address>>)
	21: Ret
}

public(friend) undo_report_validator(Arg0: &mut SafeSystemStateInnerV2, Arg1: &UnverifiedValidatorOperationCap, Arg2: address) {
B0:
	0: CopyLoc[0](Arg0: &mut SafeSystemStateInnerV2)
	1: MutBorrowField[0](SafeSystemStateInnerV2.validators: ValidatorSet)
	2: MoveLoc[1](Arg1: &UnverifiedValidatorOperationCap)
	3: LdConst[9](u8: 1)
	4: Call validator_set::verify_cap(&mut ValidatorSet, &UnverifiedValidatorOperationCap, u8): ValidatorOperationCap
	5: MoveLoc[2](Arg2: address)
	6: MoveLoc[0](Arg0: &mut SafeSystemStateInnerV2)
	7: MutBorrowField[4](SafeSystemStateInnerV2.validator_report_records: VecMap<address, VecSet<address>>)
	8: Call undo_report_validator_impl(ValidatorOperationCap, address, &mut VecMap<address, VecSet<address>>)
	9: Ret
}

report_validator_impl(Arg0: ValidatorOperationCap, Arg1: address, Arg2: &mut VecMap<address, VecSet<address>>) {
L3:	loc0: address
L4:	loc1: &mut VecSet<address>
B0:
	0: ImmBorrowLoc[0](Arg0: ValidatorOperationCap)
	1: Call validator_cap::verified_operation_cap_address(&ValidatorOperationCap): &address
	2: ReadRef
	3: StLoc[3](loc0: address)
	4: CopyLoc[3](loc0: address)
	5: CopyLoc[1](Arg1: address)
	6: Neq
	7: BrFalse(9)
B1:
	8: Branch(13)
B2:
	9: MoveLoc[2](Arg2: &mut VecMap<address, VecSet<address>>)
	10: Pop
	11: LdConst[3](u64: 3)
	12: Abort
B3:
	13: CopyLoc[2](Arg2: &mut VecMap<address, VecSet<address>>)
	14: FreezeRef
	15: ImmBorrowLoc[1](Arg1: address)
	16: Call vec_map::contains<address, VecSet<address>>(&VecMap<address, VecSet<address>>, &address): bool
	17: Not
	18: BrFalse(25)
B4:
	19: MoveLoc[2](Arg2: &mut VecMap<address, VecSet<address>>)
	20: MoveLoc[1](Arg1: address)
	21: MoveLoc[3](loc0: address)
	22: Call vec_set::singleton<address>(address): VecSet<address>
	23: Call vec_map::insert<address, VecSet<address>>(&mut VecMap<address, VecSet<address>>, address, VecSet<address>)
	24: Branch(41)
B5:
	25: MoveLoc[2](Arg2: &mut VecMap<address, VecSet<address>>)
	26: ImmBorrowLoc[1](Arg1: address)
	27: Call vec_map::get_mut<address, VecSet<address>>(&mut VecMap<address, VecSet<address>>, &address): &mut VecSet<address>
	28: StLoc[4](loc1: &mut VecSet<address>)
	29: CopyLoc[4](loc1: &mut VecSet<address>)
	30: FreezeRef
	31: ImmBorrowLoc[3](loc0: address)
	32: Call vec_set::contains<address>(&VecSet<address>, &address): bool
	33: Not
	34: BrFalse(39)
B6:
	35: MoveLoc[4](loc1: &mut VecSet<address>)
	36: MoveLoc[3](loc0: address)
	37: Call vec_set::insert<address>(&mut VecSet<address>, address)
	38: Branch(41)
B7:
	39: MoveLoc[4](loc1: &mut VecSet<address>)
	40: Pop
B8:
	41: Ret
}

undo_report_validator_impl(Arg0: ValidatorOperationCap, Arg1: address, Arg2: &mut VecMap<address, VecSet<address>>) {
L3:	loc0: address
L4:	loc1: &mut VecSet<address>
B0:
	0: CopyLoc[2](Arg2: &mut VecMap<address, VecSet<address>>)
	1: FreezeRef
	2: ImmBorrowLoc[1](Arg1: address)
	3: Call vec_map::contains<address, VecSet<address>>(&VecMap<address, VecSet<address>>, &address): bool
	4: BrFalse(6)
B1:
	5: Branch(10)
B2:
	6: MoveLoc[2](Arg2: &mut VecMap<address, VecSet<address>>)
	7: Pop
	8: LdConst[4](u64: 4)
	9: Abort
B3:
	10: CopyLoc[2](Arg2: &mut VecMap<address, VecSet<address>>)
	11: ImmBorrowLoc[1](Arg1: address)
	12: Call vec_map::get_mut<address, VecSet<address>>(&mut VecMap<address, VecSet<address>>, &address): &mut VecSet<address>
	13: StLoc[4](loc1: &mut VecSet<address>)
	14: ImmBorrowLoc[0](Arg0: ValidatorOperationCap)
	15: Call validator_cap::verified_operation_cap_address(&ValidatorOperationCap): &address
	16: ReadRef
	17: StLoc[3](loc0: address)
	18: CopyLoc[4](loc1: &mut VecSet<address>)
	19: FreezeRef
	20: ImmBorrowLoc[3](loc0: address)
	21: Call vec_set::contains<address>(&VecSet<address>, &address): bool
	22: BrFalse(24)
B4:
	23: Branch(30)
B5:
	24: MoveLoc[2](Arg2: &mut VecMap<address, VecSet<address>>)
	25: Pop
	26: MoveLoc[4](loc1: &mut VecSet<address>)
	27: Pop
	28: LdConst[4](u64: 4)
	29: Abort
B6:
	30: CopyLoc[4](loc1: &mut VecSet<address>)
	31: ImmBorrowLoc[3](loc0: address)
	32: Call vec_set::remove<address>(&mut VecSet<address>, &address)
	33: MoveLoc[4](loc1: &mut VecSet<address>)
	34: FreezeRef
	35: Call vec_set::is_empty<address>(&VecSet<address>): bool
	36: BrFalse(43)
B7:
	37: MoveLoc[2](Arg2: &mut VecMap<address, VecSet<address>>)
	38: ImmBorrowLoc[1](Arg1: address)
	39: Call vec_map::remove<address, VecSet<address>>(&mut VecMap<address, VecSet<address>>, &address): address * VecSet<address>
	40: Pop
	41: Pop
	42: Branch(45)
B8:
	43: MoveLoc[2](Arg2: &mut VecMap<address, VecSet<address>>)
	44: Pop
B9:
	45: Ret
}

public(friend) rotate_operation_cap(Arg0: &mut SafeSystemStateInnerV2, Arg1: &mut TxContext) {
B0:
	0: MoveLoc[0](Arg0: &mut SafeSystemStateInnerV2)
	1: MutBorrowField[0](SafeSystemStateInnerV2.validators: ValidatorSet)
	2: CopyLoc[1](Arg1: &mut TxContext)
	3: FreezeRef
	4: Call validator_set::get_validator_mut_with_ctx_including_candidates(&mut ValidatorSet, &TxContext): &mut Validator
	5: MoveLoc[1](Arg1: &mut TxContext)
	6: Call validator::new_unverified_validator_operation_cap_and_transfer(&mut Validator, &mut TxContext)
	7: Ret
}

public(friend) update_validator_name(Arg0: &mut SafeSystemStateInnerV2, Arg1: vector<u8>, Arg2: &TxContext) {
B0:
	0: MoveLoc[0](Arg0: &mut SafeSystemStateInnerV2)
	1: MutBorrowField[0](SafeSystemStateInnerV2.validators: ValidatorSet)
	2: MoveLoc[2](Arg2: &TxContext)
	3: Call validator_set::get_validator_mut_with_ctx_including_candidates(&mut ValidatorSet, &TxContext): &mut Validator
	4: MoveLoc[1](Arg1: vector<u8>)
	5: Call validator::update_name(&mut Validator, vector<u8>)
	6: Ret
}

public(friend) update_validator_description(Arg0: &mut SafeSystemStateInnerV2, Arg1: vector<u8>, Arg2: &TxContext) {
B0:
	0: MoveLoc[0](Arg0: &mut SafeSystemStateInnerV2)
	1: MutBorrowField[0](SafeSystemStateInnerV2.validators: ValidatorSet)
	2: MoveLoc[2](Arg2: &TxContext)
	3: Call validator_set::get_validator_mut_with_ctx_including_candidates(&mut ValidatorSet, &TxContext): &mut Validator
	4: MoveLoc[1](Arg1: vector<u8>)
	5: Call validator::update_description(&mut Validator, vector<u8>)
	6: Ret
}

public(friend) update_validator_image_url(Arg0: &mut SafeSystemStateInnerV2, Arg1: vector<u8>, Arg2: &TxContext) {
B0:
	0: MoveLoc[0](Arg0: &mut SafeSystemStateInnerV2)
	1: MutBorrowField[0](SafeSystemStateInnerV2.validators: ValidatorSet)
	2: MoveLoc[2](Arg2: &TxContext)
	3: Call validator_set::get_validator_mut_with_ctx_including_candidates(&mut ValidatorSet, &TxContext): &mut Validator
	4: MoveLoc[1](Arg1: vector<u8>)
	5: Call validator::update_image_url(&mut Validator, vector<u8>)
	6: Ret
}

public(friend) update_validator_project_url(Arg0: &mut SafeSystemStateInnerV2, Arg1: vector<u8>, Arg2: &TxContext) {
B0:
	0: MoveLoc[0](Arg0: &mut SafeSystemStateInnerV2)
	1: MutBorrowField[0](SafeSystemStateInnerV2.validators: ValidatorSet)
	2: MoveLoc[2](Arg2: &TxContext)
	3: Call validator_set::get_validator_mut_with_ctx_including_candidates(&mut ValidatorSet, &TxContext): &mut Validator
	4: MoveLoc[1](Arg1: vector<u8>)
	5: Call validator::update_project_url(&mut Validator, vector<u8>)
	6: Ret
}

public(friend) update_validator_next_epoch_network_address(Arg0: &mut SafeSystemStateInnerV2, Arg1: vector<u8>, Arg2: &TxContext) {
L3:	loc0: &mut Validator
L4:	loc1: &Validator
B0:
	0: CopyLoc[0](Arg0: &mut SafeSystemStateInnerV2)
	1: MutBorrowField[0](SafeSystemStateInnerV2.validators: ValidatorSet)
	2: MoveLoc[2](Arg2: &TxContext)
	3: Call validator_set::get_validator_mut_with_ctx(&mut ValidatorSet, &TxContext): &mut Validator
	4: StLoc[3](loc0: &mut Validator)
	5: CopyLoc[3](loc0: &mut Validator)
	6: MoveLoc[1](Arg1: vector<u8>)
	7: Call validator::update_next_epoch_network_address(&mut Validator, vector<u8>)
	8: MoveLoc[3](loc0: &mut Validator)
	9: FreezeRef
	10: StLoc[4](loc1: &Validator)
	11: MoveLoc[0](Arg0: &mut SafeSystemStateInnerV2)
	12: ImmBorrowField[0](SafeSystemStateInnerV2.validators: ValidatorSet)
	13: MoveLoc[4](loc1: &Validator)
	14: Call validator_set::assert_no_pending_or_active_duplicates(&ValidatorSet, &Validator)
	15: Ret
}

public(friend) update_candidate_validator_network_address(Arg0: &mut SafeSystemStateInnerV2, Arg1: vector<u8>, Arg2: &TxContext) {
B0:
	0: MoveLoc[0](Arg0: &mut SafeSystemStateInnerV2)
	1: MutBorrowField[0](SafeSystemStateInnerV2.validators: ValidatorSet)
	2: MoveLoc[2](Arg2: &TxContext)
	3: Call validator_set::get_validator_mut_with_ctx_including_candidates(&mut ValidatorSet, &TxContext): &mut Validator
	4: MoveLoc[1](Arg1: vector<u8>)
	5: Call validator::update_candidate_network_address(&mut Validator, vector<u8>)
	6: Ret
}

public(friend) update_validator_next_epoch_p2p_address(Arg0: &mut SafeSystemStateInnerV2, Arg1: vector<u8>, Arg2: &TxContext) {
L3:	loc0: &mut Validator
L4:	loc1: &Validator
B0:
	0: CopyLoc[0](Arg0: &mut SafeSystemStateInnerV2)
	1: MutBorrowField[0](SafeSystemStateInnerV2.validators: ValidatorSet)
	2: MoveLoc[2](Arg2: &TxContext)
	3: Call validator_set::get_validator_mut_with_ctx(&mut ValidatorSet, &TxContext): &mut Validator
	4: StLoc[3](loc0: &mut Validator)
	5: CopyLoc[3](loc0: &mut Validator)
	6: MoveLoc[1](Arg1: vector<u8>)
	7: Call validator::update_next_epoch_p2p_address(&mut Validator, vector<u8>)
	8: MoveLoc[3](loc0: &mut Validator)
	9: FreezeRef
	10: StLoc[4](loc1: &Validator)
	11: MoveLoc[0](Arg0: &mut SafeSystemStateInnerV2)
	12: ImmBorrowField[0](SafeSystemStateInnerV2.validators: ValidatorSet)
	13: MoveLoc[4](loc1: &Validator)
	14: Call validator_set::assert_no_pending_or_active_duplicates(&ValidatorSet, &Validator)
	15: Ret
}

public(friend) update_candidate_validator_p2p_address(Arg0: &mut SafeSystemStateInnerV2, Arg1: vector<u8>, Arg2: &TxContext) {
B0:
	0: MoveLoc[0](Arg0: &mut SafeSystemStateInnerV2)
	1: MutBorrowField[0](SafeSystemStateInnerV2.validators: ValidatorSet)
	2: MoveLoc[2](Arg2: &TxContext)
	3: Call validator_set::get_validator_mut_with_ctx_including_candidates(&mut ValidatorSet, &TxContext): &mut Validator
	4: MoveLoc[1](Arg1: vector<u8>)
	5: Call validator::update_candidate_p2p_address(&mut Validator, vector<u8>)
	6: Ret
}

public(friend) update_validator_next_epoch_primary_address(Arg0: &mut SafeSystemStateInnerV2, Arg1: vector<u8>, Arg2: &TxContext) {
B0:
	0: MoveLoc[0](Arg0: &mut SafeSystemStateInnerV2)
	1: MutBorrowField[0](SafeSystemStateInnerV2.validators: ValidatorSet)
	2: MoveLoc[2](Arg2: &TxContext)
	3: Call validator_set::get_validator_mut_with_ctx(&mut ValidatorSet, &TxContext): &mut Validator
	4: MoveLoc[1](Arg1: vector<u8>)
	5: Call validator::update_next_epoch_primary_address(&mut Validator, vector<u8>)
	6: Ret
}

public(friend) update_candidate_validator_primary_address(Arg0: &mut SafeSystemStateInnerV2, Arg1: vector<u8>, Arg2: &TxContext) {
B0:
	0: MoveLoc[0](Arg0: &mut SafeSystemStateInnerV2)
	1: MutBorrowField[0](SafeSystemStateInnerV2.validators: ValidatorSet)
	2: MoveLoc[2](Arg2: &TxContext)
	3: Call validator_set::get_validator_mut_with_ctx_including_candidates(&mut ValidatorSet, &TxContext): &mut Validator
	4: MoveLoc[1](Arg1: vector<u8>)
	5: Call validator::update_candidate_primary_address(&mut Validator, vector<u8>)
	6: Ret
}

public(friend) update_validator_next_epoch_worker_address(Arg0: &mut SafeSystemStateInnerV2, Arg1: vector<u8>, Arg2: &TxContext) {
B0:
	0: MoveLoc[0](Arg0: &mut SafeSystemStateInnerV2)
	1: MutBorrowField[0](SafeSystemStateInnerV2.validators: ValidatorSet)
	2: MoveLoc[2](Arg2: &TxContext)
	3: Call validator_set::get_validator_mut_with_ctx(&mut ValidatorSet, &TxContext): &mut Validator
	4: MoveLoc[1](Arg1: vector<u8>)
	5: Call validator::update_next_epoch_worker_address(&mut Validator, vector<u8>)
	6: Ret
}

public(friend) update_candidate_validator_worker_address(Arg0: &mut SafeSystemStateInnerV2, Arg1: vector<u8>, Arg2: &TxContext) {
B0:
	0: MoveLoc[0](Arg0: &mut SafeSystemStateInnerV2)
	1: MutBorrowField[0](SafeSystemStateInnerV2.validators: ValidatorSet)
	2: MoveLoc[2](Arg2: &TxContext)
	3: Call validator_set::get_validator_mut_with_ctx_including_candidates(&mut ValidatorSet, &TxContext): &mut Validator
	4: MoveLoc[1](Arg1: vector<u8>)
	5: Call validator::update_candidate_worker_address(&mut Validator, vector<u8>)
	6: Ret
}

public(friend) update_validator_next_epoch_protocol_pubkey(Arg0: &mut SafeSystemStateInnerV2, Arg1: vector<u8>, Arg2: vector<u8>, Arg3: &TxContext) {
L4:	loc0: &mut Validator
L5:	loc1: &Validator
B0:
	0: CopyLoc[0](Arg0: &mut SafeSystemStateInnerV2)
	1: MutBorrowField[0](SafeSystemStateInnerV2.validators: ValidatorSet)
	2: MoveLoc[3](Arg3: &TxContext)
	3: Call validator_set::get_validator_mut_with_ctx(&mut ValidatorSet, &TxContext): &mut Validator
	4: StLoc[4](loc0: &mut Validator)
	5: CopyLoc[4](loc0: &mut Validator)
	6: MoveLoc[1](Arg1: vector<u8>)
	7: MoveLoc[2](Arg2: vector<u8>)
	8: Call validator::update_next_epoch_protocol_pubkey(&mut Validator, vector<u8>, vector<u8>)
	9: MoveLoc[4](loc0: &mut Validator)
	10: FreezeRef
	11: StLoc[5](loc1: &Validator)
	12: MoveLoc[0](Arg0: &mut SafeSystemStateInnerV2)
	13: ImmBorrowField[0](SafeSystemStateInnerV2.validators: ValidatorSet)
	14: MoveLoc[5](loc1: &Validator)
	15: Call validator_set::assert_no_pending_or_active_duplicates(&ValidatorSet, &Validator)
	16: Ret
}

public(friend) update_candidate_validator_protocol_pubkey(Arg0: &mut SafeSystemStateInnerV2, Arg1: vector<u8>, Arg2: vector<u8>, Arg3: &TxContext) {
B0:
	0: MoveLoc[0](Arg0: &mut SafeSystemStateInnerV2)
	1: MutBorrowField[0](SafeSystemStateInnerV2.validators: ValidatorSet)
	2: MoveLoc[3](Arg3: &TxContext)
	3: Call validator_set::get_validator_mut_with_ctx_including_candidates(&mut ValidatorSet, &TxContext): &mut Validator
	4: MoveLoc[1](Arg1: vector<u8>)
	5: MoveLoc[2](Arg2: vector<u8>)
	6: Call validator::update_candidate_protocol_pubkey(&mut Validator, vector<u8>, vector<u8>)
	7: Ret
}

public(friend) update_validator_next_epoch_worker_pubkey(Arg0: &mut SafeSystemStateInnerV2, Arg1: vector<u8>, Arg2: &TxContext) {
L3:	loc0: &mut Validator
L4:	loc1: &Validator
B0:
	0: CopyLoc[0](Arg0: &mut SafeSystemStateInnerV2)
	1: MutBorrowField[0](SafeSystemStateInnerV2.validators: ValidatorSet)
	2: MoveLoc[2](Arg2: &TxContext)
	3: Call validator_set::get_validator_mut_with_ctx(&mut ValidatorSet, &TxContext): &mut Validator
	4: StLoc[3](loc0: &mut Validator)
	5: CopyLoc[3](loc0: &mut Validator)
	6: MoveLoc[1](Arg1: vector<u8>)
	7: Call validator::update_next_epoch_worker_pubkey(&mut Validator, vector<u8>)
	8: MoveLoc[3](loc0: &mut Validator)
	9: FreezeRef
	10: StLoc[4](loc1: &Validator)
	11: MoveLoc[0](Arg0: &mut SafeSystemStateInnerV2)
	12: ImmBorrowField[0](SafeSystemStateInnerV2.validators: ValidatorSet)
	13: MoveLoc[4](loc1: &Validator)
	14: Call validator_set::assert_no_pending_or_active_duplicates(&ValidatorSet, &Validator)
	15: Ret
}

public(friend) update_candidate_validator_worker_pubkey(Arg0: &mut SafeSystemStateInnerV2, Arg1: vector<u8>, Arg2: &TxContext) {
B0:
	0: MoveLoc[0](Arg0: &mut SafeSystemStateInnerV2)
	1: MutBorrowField[0](SafeSystemStateInnerV2.validators: ValidatorSet)
	2: MoveLoc[2](Arg2: &TxContext)
	3: Call validator_set::get_validator_mut_with_ctx_including_candidates(&mut ValidatorSet, &TxContext): &mut Validator
	4: MoveLoc[1](Arg1: vector<u8>)
	5: Call validator::update_candidate_worker_pubkey(&mut Validator, vector<u8>)
	6: Ret
}

public(friend) update_validator_next_epoch_network_pubkey(Arg0: &mut SafeSystemStateInnerV2, Arg1: vector<u8>, Arg2: &TxContext) {
L3:	loc0: &mut Validator
L4:	loc1: &Validator
B0:
	0: CopyLoc[0](Arg0: &mut SafeSystemStateInnerV2)
	1: MutBorrowField[0](SafeSystemStateInnerV2.validators: ValidatorSet)
	2: MoveLoc[2](Arg2: &TxContext)
	3: Call validator_set::get_validator_mut_with_ctx(&mut ValidatorSet, &TxContext): &mut Validator
	4: StLoc[3](loc0: &mut Validator)
	5: CopyLoc[3](loc0: &mut Validator)
	6: MoveLoc[1](Arg1: vector<u8>)
	7: Call validator::update_next_epoch_network_pubkey(&mut Validator, vector<u8>)
	8: MoveLoc[3](loc0: &mut Validator)
	9: FreezeRef
	10: StLoc[4](loc1: &Validator)
	11: MoveLoc[0](Arg0: &mut SafeSystemStateInnerV2)
	12: ImmBorrowField[0](SafeSystemStateInnerV2.validators: ValidatorSet)
	13: MoveLoc[4](loc1: &Validator)
	14: Call validator_set::assert_no_pending_or_active_duplicates(&ValidatorSet, &Validator)
	15: Ret
}

public(friend) update_candidate_validator_network_pubkey(Arg0: &mut SafeSystemStateInnerV2, Arg1: vector<u8>, Arg2: &TxContext) {
B0:
	0: MoveLoc[0](Arg0: &mut SafeSystemStateInnerV2)
	1: MutBorrowField[0](SafeSystemStateInnerV2.validators: ValidatorSet)
	2: MoveLoc[2](Arg2: &TxContext)
	3: Call validator_set::get_validator_mut_with_ctx_including_candidates(&mut ValidatorSet, &TxContext): &mut Validator
	4: MoveLoc[1](Arg1: vector<u8>)
	5: Call validator::update_candidate_network_pubkey(&mut Validator, vector<u8>)
	6: Ret
}

public(friend) advance_epoch(Arg0: &mut SafeSystemStateInnerV2, Arg1: u64, Arg2: u64, Arg3: Balance<SAFE>, Arg4: Balance<SAFE>, Arg5: u64, Arg6: u64, Arg7: u64, Arg8: u64, Arg9: u64, Arg10: &mut TxContext): Balance<SAFE> {
L11:	loc0: u64
L12:	loc1: bool
L13:	loc2: u64
L14:	loc3: u64
L15:	loc4: u64
L16:	loc5: u64
L17:	loc6: u64
L18:	loc7: u64
L19:	loc8: u64
L20:	loc9: u64
L21:	loc10: bool
L22:	loc11: bool
L23:	loc12: bool
L24:	loc13: u64
L25:	loc14: u64
L26:	loc15: u64
L27:	loc16: u64
L28:	loc17: u64
L29:	loc18: u64
L30:	loc19: u64
L31:	loc20: u64
L32:	loc21: u64
L33:	loc22: u64
L34:	loc23: Balance<SAFE>
L35:	loc24: u64
L36:	loc25: u64
L37:	loc26: u64
L38:	loc27: u64
L39:	loc28: Balance<SAFE>
L40:	loc29: Balance<SAFE>
L41:	loc30: Balance<SAFE>
L42:	loc31: Balance<SAFE>
L43:	loc32: u64
L44:	loc33: u64
L45:	loc34: u64
L46:	loc35: u64
L47:	loc36: Balance<SAFE>
L48:	loc37: u64
L49:	loc38: Balance<SAFE>
L50:	loc39: u64
L51:	loc40: u64
L52:	loc41: u64
L53:	loc42: u64
L54:	loc43: u64
L55:	loc44: u64
B0:
	0: CopyLoc[0](Arg0: &mut SafeSystemStateInnerV2)
	1: ImmBorrowField[5](SafeSystemStateInnerV2.epoch_start_timestamp_ms: u64)
	2: ReadRef
	3: StLoc[38](loc27: u64)
	4: CopyLoc[9](Arg9: u64)
	5: CopyLoc[0](Arg0: &mut SafeSystemStateInnerV2)
	6: MutBorrowField[5](SafeSystemStateInnerV2.epoch_start_timestamp_ms: u64)
	7: WriteRef
	8: LdConst[8](u64: 10000)
	9: StLoc[28](loc17: u64)
	10: CopyLoc[7](Arg7: u64)
	11: CopyLoc[28](loc17: u64)
	12: Le
	13: BrFalse(19)
B1:
	14: CopyLoc[8](Arg8: u64)
	15: MoveLoc[28](loc17: u64)
	16: Le
	17: StLoc[12](loc1: bool)
	18: Branch(21)
B2:
	19: LdFalse
	20: StLoc[12](loc1: bool)
B3:
	21: MoveLoc[12](loc1: bool)
	22: BrFalse(24)
B4:
	23: Branch(30)
B5:
	24: MoveLoc[0](Arg0: &mut SafeSystemStateInnerV2)
	25: Pop
	26: MoveLoc[10](Arg10: &mut TxContext)
	27: Pop
	28: LdConst[5](u64: 5)
	29: Abort
B6:
	30: CopyLoc[0](Arg0: &mut SafeSystemStateInnerV2)
	31: ImmBorrowField[1](SafeSystemStateInnerV2.parameters: SystemParametersV2)
	32: ImmBorrowField[6](SystemParametersV2.stake_subsidy_start_epoch: u64)
	33: ReadRef
	34: LdU64(0)
	35: Gt
	36: BrFalse(42)
B7:
	37: LdU64(20)
	38: CopyLoc[0](Arg0: &mut SafeSystemStateInnerV2)
	39: MutBorrowField[1](SafeSystemStateInnerV2.parameters: SystemParametersV2)
	40: MutBorrowField[6](SystemParametersV2.stake_subsidy_start_epoch: u64)
	41: WriteRef
B8:
	42: CopyLoc[0](Arg0: &mut SafeSystemStateInnerV2)
	43: MutBorrowField[7](SafeSystemStateInnerV2.safe_mode_storage_rewards: Balance<SAFE>)
	44: Call balance::withdraw_all<SAFE>(&mut Balance<SAFE>): Balance<SAFE>
	45: StLoc[41](loc30: Balance<SAFE>)
	46: MutBorrowLoc[3](Arg3: Balance<SAFE>)
	47: MoveLoc[41](loc30: Balance<SAFE>)
	48: Call balance::join<SAFE>(&mut Balance<SAFE>, Balance<SAFE>): u64
	49: Pop
	50: CopyLoc[0](Arg0: &mut SafeSystemStateInnerV2)
	51: MutBorrowField[8](SafeSystemStateInnerV2.safe_mode_computation_rewards: Balance<SAFE>)
	52: Call balance::withdraw_all<SAFE>(&mut Balance<SAFE>): Balance<SAFE>
	53: StLoc[40](loc29: Balance<SAFE>)
	54: MutBorrowLoc[4](Arg4: Balance<SAFE>)
	55: MoveLoc[40](loc29: Balance<SAFE>)
	56: Call balance::join<SAFE>(&mut Balance<SAFE>, Balance<SAFE>): u64
	57: Pop
	58: MoveLoc[5](Arg5: u64)
	59: CopyLoc[0](Arg0: &mut SafeSystemStateInnerV2)
	60: ImmBorrowField[9](SafeSystemStateInnerV2.safe_mode_storage_rebates: u64)
	61: ReadRef
	62: Add
	63: StLoc[5](Arg5: u64)
	64: LdU64(0)
	65: CopyLoc[0](Arg0: &mut SafeSystemStateInnerV2)
	66: MutBorrowField[9](SafeSystemStateInnerV2.safe_mode_storage_rebates: u64)
	67: WriteRef
	68: MoveLoc[6](Arg6: u64)
	69: CopyLoc[0](Arg0: &mut SafeSystemStateInnerV2)
	70: ImmBorrowField[10](SafeSystemStateInnerV2.safe_mode_non_refundable_storage_fee: u64)
	71: ReadRef
	72: Add
	73: StLoc[6](Arg6: u64)
	74: LdU64(0)
	75: CopyLoc[0](Arg0: &mut SafeSystemStateInnerV2)
	76: MutBorrowField[10](SafeSystemStateInnerV2.safe_mode_non_refundable_storage_fee: u64)
	77: WriteRef
	78: CopyLoc[0](Arg0: &mut SafeSystemStateInnerV2)
	79: ImmBorrowField[0](SafeSystemStateInnerV2.validators: ValidatorSet)
	80: Call validator_set::total_stake(&ValidatorSet): u64
	81: StLoc[55](loc44: u64)
	82: CopyLoc[0](Arg0: &mut SafeSystemStateInnerV2)
	83: ImmBorrowField[11](SafeSystemStateInnerV2.storage_fund: StorageFund)
	84: Call storage_fund::total_balance(&StorageFund): u64
	85: StLoc[46](loc35: u64)
	86: CopyLoc[46](loc35: u64)
	87: MoveLoc[55](loc44: u64)
	88: Add
	89: StLoc[54](loc43: u64)
	90: ImmBorrowLoc[3](Arg3: Balance<SAFE>)
	91: Call balance::value<SAFE>(&Balance<SAFE>): u64
	92: StLoc[45](loc34: u64)
	93: ImmBorrowLoc[4](Arg4: Balance<SAFE>)
	94: Call balance::value<SAFE>(&Balance<SAFE>): u64
	95: StLoc[29](loc18: u64)
	96: Call balance::zero<SAFE>(): Balance<SAFE>
	97: StLoc[42](loc31: Balance<SAFE>)
	98: CopyLoc[10](Arg10: &mut TxContext)
	99: FreezeRef
	100: Call tx_context::epoch(&TxContext): u64
	101: StLoc[37](loc26: u64)
	102: CopyLoc[37](loc26: u64)
	103: CopyLoc[0](Arg0: &mut SafeSystemStateInnerV2)
	104: ImmBorrowField[1](SafeSystemStateInnerV2.parameters: SystemParametersV2)
	105: ImmBorrowField[6](SystemParametersV2.stake_subsidy_start_epoch: u64)
	106: ReadRef
	107: Ge
	108: BrFalse(119)
B9:
	109: MoveLoc[9](Arg9: u64)
	110: MoveLoc[38](loc27: u64)
	111: CopyLoc[0](Arg0: &mut SafeSystemStateInnerV2)
	112: ImmBorrowField[1](SafeSystemStateInnerV2.parameters: SystemParametersV2)
	113: ImmBorrowField[12](SystemParametersV2.epoch_duration_ms: u64)
	114: ReadRef
	115: Add
	116: Ge
	117: StLoc[22](loc11: bool)
	118: Branch(121)
B10:
	119: LdFalse
	120: StLoc[22](loc11: bool)
B11:
	121: MoveLoc[22](loc11: bool)
	122: BrFalse(169)
B12:
	123: CopyLoc[0](Arg0: &mut SafeSystemStateInnerV2)
	124: ImmBorrowField[13](SafeSystemStateInnerV2.stake_subsidy: StakeSubsidy)
	125: Call stake_subsidy::get_distribution_counter(&StakeSubsidy): u64
	126: LdU64(540)
	127: Eq
	128: BrFalse(134)
B13:
	129: CopyLoc[37](loc26: u64)
	130: LdU64(560)
	131: Gt
	132: StLoc[23](loc12: bool)
	133: Branch(136)
B14:
	134: LdFalse
	135: StLoc[23](loc12: bool)
B15:
	136: MoveLoc[23](loc12: bool)
	137: BrFalse(163)
B16:
	138: MoveLoc[37](loc26: u64)
	139: LdU64(560)
	140: Sub
	141: StLoc[11](loc0: u64)
	142: LdU64(0)
	143: StLoc[33](loc22: u64)
	144: MoveLoc[11](loc0: u64)
	145: StLoc[44](loc33: u64)
B17:
	146: CopyLoc[33](loc22: u64)
	147: CopyLoc[44](loc33: u64)
	148: Lt
	149: BrFalse(163)
B18:
	150: CopyLoc[33](loc22: u64)
	151: Pop
	152: MutBorrowLoc[42](loc31: Balance<SAFE>)
	153: CopyLoc[0](Arg0: &mut SafeSystemStateInnerV2)
	154: MutBorrowField[13](SafeSystemStateInnerV2.stake_subsidy: StakeSubsidy)
	155: Call stake_subsidy::advance_epoch(&mut StakeSubsidy): Balance<SAFE>
	156: Call balance::join<SAFE>(&mut Balance<SAFE>, Balance<SAFE>): u64
	157: Pop
	158: MoveLoc[33](loc22: u64)
	159: LdU64(1)
	160: Add
	161: StLoc[33](loc22: u64)
	162: Branch(146)
B19:
	163: MutBorrowLoc[42](loc31: Balance<SAFE>)
	164: CopyLoc[0](Arg0: &mut SafeSystemStateInnerV2)
	165: MutBorrowField[13](SafeSystemStateInnerV2.stake_subsidy: StakeSubsidy)
	166: Call stake_subsidy::advance_epoch(&mut StakeSubsidy): Balance<SAFE>
	167: Call balance::join<SAFE>(&mut Balance<SAFE>, Balance<SAFE>): u64
	168: Pop
B20:
	169: ImmBorrowLoc[42](loc31: Balance<SAFE>)
	170: Call balance::value<SAFE>(&Balance<SAFE>): u64
	171: StLoc[43](loc32: u64)
	172: MutBorrowLoc[4](Arg4: Balance<SAFE>)
	173: MoveLoc[42](loc31: Balance<SAFE>)
	174: Call balance::join<SAFE>(&mut Balance<SAFE>, Balance<SAFE>): u64
	175: Pop
	176: MoveLoc[46](loc35: u64)
	177: CastU128
	178: CopyLoc[29](loc18: u64)
	179: CastU128
	180: Mul
	181: MoveLoc[54](loc43: u64)
	182: CastU128
	183: Div
	184: CastU64
	185: StLoc[50](loc39: u64)
	186: MutBorrowLoc[4](Arg4: Balance<SAFE>)
	187: CopyLoc[50](loc39: u64)
	188: CastU64
	189: Call balance::split<SAFE>(&mut Balance<SAFE>, u64): Balance<SAFE>
	190: StLoc[49](loc38: Balance<SAFE>)
	191: MoveLoc[50](loc39: u64)
	192: CastU128
	193: MoveLoc[7](Arg7: u64)
	194: CastU128
	195: Mul
	196: LdConst[8](u64: 10000)
	197: CastU128
	198: Div
	199: CastU64
	200: StLoc[48](loc37: u64)
	201: MutBorrowLoc[49](loc38: Balance<SAFE>)
	202: CopyLoc[48](loc37: u64)
	203: Call balance::split<SAFE>(&mut Balance<SAFE>, u64): Balance<SAFE>
	204: StLoc[47](loc36: Balance<SAFE>)
	205: CopyLoc[0](Arg0: &mut SafeSystemStateInnerV2)
	206: ImmBorrowField[14](SafeSystemStateInnerV2.epoch: u64)
	207: ReadRef
	208: LdU64(1)
	209: Add
	210: CopyLoc[0](Arg0: &mut SafeSystemStateInnerV2)
	211: MutBorrowField[14](SafeSystemStateInnerV2.epoch: u64)
	212: WriteRef
	213: MoveLoc[1](Arg1: u64)
	214: CopyLoc[0](Arg0: &mut SafeSystemStateInnerV2)
	215: ImmBorrowField[14](SafeSystemStateInnerV2.epoch: u64)
	216: ReadRef
	217: Eq
	218: BrFalse(220)
B21:
	219: Branch(226)
B22:
	220: MoveLoc[0](Arg0: &mut SafeSystemStateInnerV2)
	221: Pop
	222: MoveLoc[10](Arg10: &mut TxContext)
	223: Pop
	224: LdConst[7](u64: 8)
	225: Abort
B23:
	226: ImmBorrowLoc[4](Arg4: Balance<SAFE>)
	227: Call balance::value<SAFE>(&Balance<SAFE>): u64
	228: StLoc[31](loc20: u64)
	229: ImmBorrowLoc[49](loc38: Balance<SAFE>)
	230: Call balance::value<SAFE>(&Balance<SAFE>): u64
	231: StLoc[52](loc41: u64)
	232: CopyLoc[0](Arg0: &mut SafeSystemStateInnerV2)
	233: MutBorrowField[0](SafeSystemStateInnerV2.validators: ValidatorSet)
	234: MutBorrowLoc[4](Arg4: Balance<SAFE>)
	235: MutBorrowLoc[49](loc38: Balance<SAFE>)
	236: CopyLoc[0](Arg0: &mut SafeSystemStateInnerV2)
	237: MutBorrowField[4](SafeSystemStateInnerV2.validator_report_records: VecMap<address, VecSet<address>>)
	238: MoveLoc[8](Arg8: u64)
	239: CopyLoc[0](Arg0: &mut SafeSystemStateInnerV2)
	240: ImmBorrowField[1](SafeSystemStateInnerV2.parameters: SystemParametersV2)
	241: ImmBorrowField[15](SystemParametersV2.validator_low_stake_grace_period: u64)
	242: ReadRef
	243: MoveLoc[10](Arg10: &mut TxContext)
	244: Call validator_set::advance_epoch(&mut ValidatorSet, &mut Balance<SAFE>, &mut Balance<SAFE>, &mut VecMap<address, VecSet<address>>, u64, u64, &mut TxContext)
	245: CopyLoc[0](Arg0: &mut SafeSystemStateInnerV2)
	246: ImmBorrowField[0](SafeSystemStateInnerV2.validators: ValidatorSet)
	247: Call validator_set::total_stake(&ValidatorSet): u64
	248: StLoc[36](loc25: u64)
	249: ImmBorrowLoc[4](Arg4: Balance<SAFE>)
	250: Call balance::value<SAFE>(&Balance<SAFE>): u64
	251: StLoc[30](loc19: u64)
	252: ImmBorrowLoc[49](loc38: Balance<SAFE>)
	253: Call balance::value<SAFE>(&Balance<SAFE>): u64
	254: StLoc[51](loc40: u64)
	255: MoveLoc[31](loc20: u64)
	256: MoveLoc[30](loc19: u64)
	257: Sub
	258: StLoc[32](loc21: u64)
	259: MoveLoc[52](loc41: u64)
	260: MoveLoc[51](loc40: u64)
	261: Sub
	262: StLoc[53](loc42: u64)
	263: MoveLoc[2](Arg2: u64)
	264: CopyLoc[0](Arg0: &mut SafeSystemStateInnerV2)
	265: MutBorrowField[16](SafeSystemStateInnerV2.protocol_version: u64)
	266: WriteRef
	267: CopyLoc[0](Arg0: &mut SafeSystemStateInnerV2)
	268: ImmBorrowField[0](SafeSystemStateInnerV2.validators: ValidatorSet)
	269: Call validator_set::derive_reference_gas_price(&ValidatorSet): u64
	270: CopyLoc[0](Arg0: &mut SafeSystemStateInnerV2)
	271: MutBorrowField[17](SafeSystemStateInnerV2.reference_gas_price: u64)
	272: WriteRef
	273: MoveLoc[49](loc38: Balance<SAFE>)
	274: StLoc[34](loc23: Balance<SAFE>)
	275: MutBorrowLoc[34](loc23: Balance<SAFE>)
	276: MoveLoc[4](Arg4: Balance<SAFE>)
	277: Call balance::join<SAFE>(&mut Balance<SAFE>, Balance<SAFE>): u64
	278: Pop
	279: ImmBorrowLoc[34](loc23: Balance<SAFE>)
	280: Call balance::value<SAFE>(&Balance<SAFE>): u64
	281: StLoc[35](loc24: u64)
	282: CopyLoc[0](Arg0: &mut SafeSystemStateInnerV2)
	283: MutBorrowField[11](SafeSystemStateInnerV2.storage_fund: StorageFund)
	284: MoveLoc[3](Arg3: Balance<SAFE>)
	285: MoveLoc[47](loc36: Balance<SAFE>)
	286: MoveLoc[34](loc23: Balance<SAFE>)
	287: CopyLoc[5](Arg5: u64)
	288: MoveLoc[6](Arg6: u64)
	289: Call storage_fund::advance_epoch(&mut StorageFund, Balance<SAFE>, Balance<SAFE>, Balance<SAFE>, u64, u64): Balance<SAFE>
	290: StLoc[39](loc28: Balance<SAFE>)
	291: CopyLoc[0](Arg0: &mut SafeSystemStateInnerV2)
	292: ImmBorrowField[14](SafeSystemStateInnerV2.epoch: u64)
	293: ReadRef
	294: StLoc[24](loc13: u64)
	295: CopyLoc[0](Arg0: &mut SafeSystemStateInnerV2)
	296: ImmBorrowField[16](SafeSystemStateInnerV2.protocol_version: u64)
	297: ReadRef
	298: StLoc[25](loc14: u64)
	299: CopyLoc[0](Arg0: &mut SafeSystemStateInnerV2)
	300: ImmBorrowField[17](SafeSystemStateInnerV2.reference_gas_price: u64)
	301: ReadRef
	302: StLoc[26](loc15: u64)
	303: MoveLoc[36](loc25: u64)
	304: StLoc[27](loc16: u64)
	305: MoveLoc[45](loc34: u64)
	306: StLoc[13](loc2: u64)
	307: MoveLoc[48](loc37: u64)
	308: CastU64
	309: StLoc[14](loc3: u64)
	310: MoveLoc[5](Arg5: u64)
	311: StLoc[15](loc4: u64)
	312: CopyLoc[0](Arg0: &mut SafeSystemStateInnerV2)
	313: ImmBorrowField[11](SafeSystemStateInnerV2.storage_fund: StorageFund)
	314: Call storage_fund::total_balance(&StorageFund): u64
	315: StLoc[16](loc5: u64)
	316: MoveLoc[43](loc32: u64)
	317: StLoc[17](loc6: u64)
	318: MoveLoc[29](loc18: u64)
	319: StLoc[18](loc7: u64)
	320: MoveLoc[32](loc21: u64)
	321: MoveLoc[53](loc42: u64)
	322: Add
	323: StLoc[19](loc8: u64)
	324: MoveLoc[35](loc24: u64)
	325: StLoc[20](loc9: u64)
	326: MoveLoc[24](loc13: u64)
	327: MoveLoc[25](loc14: u64)
	328: MoveLoc[26](loc15: u64)
	329: MoveLoc[27](loc16: u64)
	330: MoveLoc[14](loc3: u64)
	331: MoveLoc[13](loc2: u64)
	332: MoveLoc[15](loc4: u64)
	333: MoveLoc[16](loc5: u64)
	334: MoveLoc[17](loc6: u64)
	335: MoveLoc[18](loc7: u64)
	336: MoveLoc[19](loc8: u64)
	337: MoveLoc[20](loc9: u64)
	338: Pack[4](SystemEpochInfoEvent)
	339: Call event::emit<SystemEpochInfoEvent>(SystemEpochInfoEvent)
	340: LdFalse
	341: CopyLoc[0](Arg0: &mut SafeSystemStateInnerV2)
	342: MutBorrowField[18](SafeSystemStateInnerV2.safe_mode: bool)
	343: WriteRef
	344: CopyLoc[0](Arg0: &mut SafeSystemStateInnerV2)
	345: ImmBorrowField[9](SafeSystemStateInnerV2.safe_mode_storage_rebates: u64)
	346: ReadRef
	347: LdU64(0)
	348: Eq
	349: BrFalse(369)
B24:
	350: Branch(351)
B25:
	351: CopyLoc[0](Arg0: &mut SafeSystemStateInnerV2)
	352: ImmBorrowField[7](SafeSystemStateInnerV2.safe_mode_storage_rewards: Balance<SAFE>)
	353: Call balance::value<SAFE>(&Balance<SAFE>): u64
	354: LdU64(0)
	355: Eq
	356: BrFalse(364)
B26:
	357: MoveLoc[0](Arg0: &mut SafeSystemStateInnerV2)
	358: ImmBorrowField[8](SafeSystemStateInnerV2.safe_mode_computation_rewards: Balance<SAFE>)
	359: Call balance::value<SAFE>(&Balance<SAFE>): u64
	360: LdU64(0)
	361: Eq
	362: StLoc[21](loc10: bool)
	363: Branch(373)
B27:
	364: MoveLoc[0](Arg0: &mut SafeSystemStateInnerV2)
	365: Pop
	366: LdFalse
	367: StLoc[21](loc10: bool)
	368: Branch(373)
B28:
	369: MoveLoc[0](Arg0: &mut SafeSystemStateInnerV2)
	370: Pop
	371: LdFalse
	372: StLoc[21](loc10: bool)
B29:
	373: MoveLoc[21](loc10: bool)
	374: BrFalse(376)
B30:
	375: Branch(378)
B31:
	376: LdConst[6](u64: 7)
	377: Abort
B32:
	378: MoveLoc[39](loc28: Balance<SAFE>)
	379: Ret
}

public(friend) epoch(Arg0: &SafeSystemStateInnerV2): u64 {
B0:
	0: MoveLoc[0](Arg0: &SafeSystemStateInnerV2)
	1: ImmBorrowField[14](SafeSystemStateInnerV2.epoch: u64)
	2: ReadRef
	3: Ret
}

public(friend) protocol_version(Arg0: &SafeSystemStateInnerV2): u64 {
B0:
	0: MoveLoc[0](Arg0: &SafeSystemStateInnerV2)
	1: ImmBorrowField[16](SafeSystemStateInnerV2.protocol_version: u64)
	2: ReadRef
	3: Ret
}

public(friend) system_state_version(Arg0: &SafeSystemStateInnerV2): u64 {
B0:
	0: MoveLoc[0](Arg0: &SafeSystemStateInnerV2)
	1: ImmBorrowField[19](SafeSystemStateInnerV2.system_state_version: u64)
	2: ReadRef
	3: Ret
}

public(friend) genesis_system_state_version(): u64 {
B0:
	0: LdConst[1](u64: 1)
	1: Ret
}

public(friend) epoch_start_timestamp_ms(Arg0: &SafeSystemStateInnerV2): u64 {
B0:
	0: MoveLoc[0](Arg0: &SafeSystemStateInnerV2)
	1: ImmBorrowField[5](SafeSystemStateInnerV2.epoch_start_timestamp_ms: u64)
	2: ReadRef
	3: Ret
}

public(friend) validator_stake_amount(Arg0: &SafeSystemStateInnerV2, Arg1: address): u64 {
B0:
	0: MoveLoc[0](Arg0: &SafeSystemStateInnerV2)
	1: ImmBorrowField[0](SafeSystemStateInnerV2.validators: ValidatorSet)
	2: MoveLoc[1](Arg1: address)
	3: Call validator_set::validator_total_stake_amount(&ValidatorSet, address): u64
	4: Ret
}

public(friend) active_validator_voting_powers(Arg0: &SafeSystemStateInnerV2): VecMap<address, u64> {
L1:	loc0: u64
L2:	loc1: vector<address>
L3:	loc2: u64
L4:	loc3: u64
L5:	loc4: vector<address>
L6:	loc5: address
L7:	loc6: u64
L8:	loc7: VecMap<address, u64>
B0:
	0: CopyLoc[0](Arg0: &SafeSystemStateInnerV2)
	1: Call active_validator_addresses(&SafeSystemStateInnerV2): vector<address>
	2: StLoc[2](loc1: vector<address>)
	3: Call vec_map::empty<address, u64>(): VecMap<address, u64>
	4: StLoc[8](loc7: VecMap<address, u64>)
	5: MoveLoc[2](loc1: vector<address>)
	6: StLoc[5](loc4: vector<address>)
	7: ImmBorrowLoc[5](loc4: vector<address>)
	8: VecLen(32)
	9: StLoc[1](loc0: u64)
	10: LdU64(0)
	11: StLoc[3](loc2: u64)
	12: MoveLoc[1](loc0: u64)
	13: StLoc[4](loc3: u64)
B1:
	14: CopyLoc[3](loc2: u64)
	15: CopyLoc[4](loc3: u64)
	16: Lt
	17: BrFalse(37)
B2:
	18: CopyLoc[3](loc2: u64)
	19: Pop
	20: MutBorrowLoc[5](loc4: vector<address>)
	21: VecPopBack(32)
	22: StLoc[6](loc5: address)
	23: CopyLoc[0](Arg0: &SafeSystemStateInnerV2)
	24: ImmBorrowField[0](SafeSystemStateInnerV2.validators: ValidatorSet)
	25: CopyLoc[6](loc5: address)
	26: Call validator_set::validator_voting_power(&ValidatorSet, address): u64
	27: StLoc[7](loc6: u64)
	28: MutBorrowLoc[8](loc7: VecMap<address, u64>)
	29: MoveLoc[6](loc5: address)
	30: MoveLoc[7](loc6: u64)
	31: Call vec_map::insert<address, u64>(&mut VecMap<address, u64>, address, u64)
	32: MoveLoc[3](loc2: u64)
	33: LdU64(1)
	34: Add
	35: StLoc[3](loc2: u64)
	36: Branch(14)
B3:
	37: MoveLoc[0](Arg0: &SafeSystemStateInnerV2)
	38: Pop
	39: MoveLoc[5](loc4: vector<address>)
	40: VecUnpack(32, 0)
	41: MoveLoc[8](loc7: VecMap<address, u64>)
	42: Ret
}

public(friend) validator_staking_pool_id(Arg0: &SafeSystemStateInnerV2, Arg1: address): ID {
B0:
	0: MoveLoc[0](Arg0: &SafeSystemStateInnerV2)
	1: ImmBorrowField[0](SafeSystemStateInnerV2.validators: ValidatorSet)
	2: MoveLoc[1](Arg1: address)
	3: Call validator_set::validator_staking_pool_id(&ValidatorSet, address): ID
	4: Ret
}

public(friend) validator_staking_pool_mappings(Arg0: &SafeSystemStateInnerV2): &Table<ID, address> {
B0:
	0: MoveLoc[0](Arg0: &SafeSystemStateInnerV2)
	1: ImmBorrowField[0](SafeSystemStateInnerV2.validators: ValidatorSet)
	2: Call validator_set::staking_pool_mappings(&ValidatorSet): &Table<ID, address>
	3: Ret
}

public(friend) get_reporters_of(Arg0: &SafeSystemStateInnerV2, Arg1: address): VecSet<address> {
L2:	loc0: VecSet<address>
B0:
	0: CopyLoc[0](Arg0: &SafeSystemStateInnerV2)
	1: ImmBorrowField[4](SafeSystemStateInnerV2.validator_report_records: VecMap<address, VecSet<address>>)
	2: ImmBorrowLoc[1](Arg1: address)
	3: Call vec_map::contains<address, VecSet<address>>(&VecMap<address, VecSet<address>>, &address): bool
	4: BrFalse(12)
B1:
	5: MoveLoc[0](Arg0: &SafeSystemStateInnerV2)
	6: ImmBorrowField[4](SafeSystemStateInnerV2.validator_report_records: VecMap<address, VecSet<address>>)
	7: ImmBorrowLoc[1](Arg1: address)
	8: Call vec_map::get<address, VecSet<address>>(&VecMap<address, VecSet<address>>, &address): &VecSet<address>
	9: ReadRef
	10: StLoc[2](loc0: VecSet<address>)
	11: Branch(16)
B2:
	12: MoveLoc[0](Arg0: &SafeSystemStateInnerV2)
	13: Pop
	14: Call vec_set::empty<address>(): VecSet<address>
	15: StLoc[2](loc0: VecSet<address>)
B3:
	16: MoveLoc[2](loc0: VecSet<address>)
	17: Ret
}

public(friend) get_storage_fund_total_balance(Arg0: &SafeSystemStateInnerV2): u64 {
B0:
	0: MoveLoc[0](Arg0: &SafeSystemStateInnerV2)
	1: ImmBorrowField[11](SafeSystemStateInnerV2.storage_fund: StorageFund)
	2: Call storage_fund::total_balance(&StorageFund): u64
	3: Ret
}

public(friend) get_storage_fund_object_rebates(Arg0: &SafeSystemStateInnerV2): u64 {
B0:
	0: MoveLoc[0](Arg0: &SafeSystemStateInnerV2)
	1: ImmBorrowField[11](SafeSystemStateInnerV2.storage_fund: StorageFund)
	2: Call storage_fund::total_object_storage_rebates(&StorageFund): u64
	3: Ret
}

public(friend) validator_address_by_pool_id(Arg0: &mut SafeSystemStateInnerV2, Arg1: &ID): address {
B0:
	0: MoveLoc[0](Arg0: &mut SafeSystemStateInnerV2)
	1: MutBorrowField[0](SafeSystemStateInnerV2.validators: ValidatorSet)
	2: MoveLoc[1](Arg1: &ID)
	3: Call validator_set::validator_address_by_pool_id(&mut ValidatorSet, &ID): address
	4: Ret
}

public(friend) pool_exchange_rates(Arg0: &mut SafeSystemStateInnerV2, Arg1: &ID): &Table<u64, PoolTokenExchangeRate> {
B0:
	0: MoveLoc[0](Arg0: &mut SafeSystemStateInnerV2)
	1: MutBorrowField[0](SafeSystemStateInnerV2.validators: ValidatorSet)
	2: MoveLoc[1](Arg1: &ID)
	3: Call validator_set::pool_exchange_rates(&mut ValidatorSet, &ID): &Table<u64, PoolTokenExchangeRate>
	4: Ret
}

public(friend) active_validator_addresses(Arg0: &SafeSystemStateInnerV2): vector<address> {
B0:
	0: MoveLoc[0](Arg0: &SafeSystemStateInnerV2)
	1: ImmBorrowField[0](SafeSystemStateInnerV2.validators: ValidatorSet)
	2: Call validator_set::active_validator_addresses(&ValidatorSet): vector<address>
	3: Ret
}

extract_coin_balance(Arg0: vector<Coin<SAFE>>, Arg1: Option<u64>, Arg2: &mut TxContext): Balance<SAFE> {
L3:	loc0: u64
L4:	loc1: Balance<SAFE>
L5:	loc2: Coin<SAFE>
L6:	loc3: Coin<SAFE>
L7:	loc4: Coin<SAFE>
L8:	loc5: u64
L9:	loc6: Balance<SAFE>
L10:	loc7: Coin<SAFE>
L11:	loc8: Coin<SAFE>
L12:	loc9: u64
L13:	loc10: u64
L14:	loc11: Balance<SAFE>
L15:	loc12: vector<Coin<SAFE>>
L16:	loc13: vector<Coin<SAFE>>
B0:
	0: MutBorrowLoc[0](Arg0: vector<Coin<SAFE>>)
	1: VecPopBack(107)
	2: StLoc[5](loc2: Coin<SAFE>)
	3: MoveLoc[0](Arg0: vector<Coin<SAFE>>)
	4: StLoc[15](loc12: vector<Coin<SAFE>>)
	5: MoveLoc[5](loc2: Coin<SAFE>)
	6: StLoc[6](loc3: Coin<SAFE>)
	7: MoveLoc[15](loc12: vector<Coin<SAFE>>)
	8: StLoc[16](loc13: vector<Coin<SAFE>>)
	9: MutBorrowLoc[16](loc13: vector<Coin<SAFE>>)
	10: Call vector::reverse<Coin<SAFE>>(&mut vector<Coin<SAFE>>)
	11: ImmBorrowLoc[16](loc13: vector<Coin<SAFE>>)
	12: VecLen(107)
	13: StLoc[3](loc0: u64)
	14: LdU64(0)
	15: StLoc[12](loc9: u64)
	16: MoveLoc[3](loc0: u64)
	17: StLoc[13](loc10: u64)
B1:
	18: CopyLoc[12](loc9: u64)
	19: CopyLoc[13](loc10: u64)
	20: Lt
	21: BrFalse(41)
B2:
	22: CopyLoc[12](loc9: u64)
	23: Pop
	24: MutBorrowLoc[16](loc13: vector<Coin<SAFE>>)
	25: VecPopBack(107)
	26: StLoc[11](loc8: Coin<SAFE>)
	27: MoveLoc[6](loc3: Coin<SAFE>)
	28: StLoc[7](loc4: Coin<SAFE>)
	29: MoveLoc[11](loc8: Coin<SAFE>)
	30: StLoc[10](loc7: Coin<SAFE>)
	31: MutBorrowLoc[7](loc4: Coin<SAFE>)
	32: MoveLoc[10](loc7: Coin<SAFE>)
	33: Call coin::join<SAFE>(&mut Coin<SAFE>, Coin<SAFE>)
	34: MoveLoc[7](loc4: Coin<SAFE>)
	35: StLoc[6](loc3: Coin<SAFE>)
	36: MoveLoc[12](loc9: u64)
	37: LdU64(1)
	38: Add
	39: StLoc[12](loc9: u64)
	40: Branch(18)
B3:
	41: MoveLoc[16](loc13: vector<Coin<SAFE>>)
	42: VecUnpack(107, 0)
	43: MoveLoc[6](loc3: Coin<SAFE>)
	44: Call coin::into_balance<SAFE>(Coin<SAFE>): Balance<SAFE>
	45: StLoc[14](loc11: Balance<SAFE>)
	46: ImmBorrowLoc[1](Arg1: Option<u64>)
	47: Call option::is_some<u64>(&Option<u64>): bool
	48: BrFalse(76)
B4:
	49: MoveLoc[1](Arg1: Option<u64>)
	50: Call option::destroy_some<u64>(Option<u64>): u64
	51: StLoc[8](loc5: u64)
	52: MutBorrowLoc[14](loc11: Balance<SAFE>)
	53: MoveLoc[8](loc5: u64)
	54: Call balance::split<SAFE>(&mut Balance<SAFE>, u64): Balance<SAFE>
	55: StLoc[9](loc6: Balance<SAFE>)
	56: ImmBorrowLoc[14](loc11: Balance<SAFE>)
	57: Call balance::value<SAFE>(&Balance<SAFE>): u64
	58: LdU64(0)
	59: Gt
	60: BrFalse(69)
B5:
	61: MoveLoc[14](loc11: Balance<SAFE>)
	62: CopyLoc[2](Arg2: &mut TxContext)
	63: Call coin::from_balance<SAFE>(Balance<SAFE>, &mut TxContext): Coin<SAFE>
	64: MoveLoc[2](Arg2: &mut TxContext)
	65: FreezeRef
	66: Call tx_context::sender(&TxContext): address
	67: Call transfer::public_transfer<Coin<SAFE>>(Coin<SAFE>, address)
	68: Branch(73)
B6:
	69: MoveLoc[2](Arg2: &mut TxContext)
	70: Pop
	71: MoveLoc[14](loc11: Balance<SAFE>)
	72: Call balance::destroy_zero<SAFE>(Balance<SAFE>)
B7:
	73: MoveLoc[9](loc6: Balance<SAFE>)
	74: StLoc[4](loc1: Balance<SAFE>)
	75: Branch(80)
B8:
	76: MoveLoc[2](Arg2: &mut TxContext)
	77: Pop
	78: MoveLoc[14](loc11: Balance<SAFE>)
	79: StLoc[4](loc1: Balance<SAFE>)
B9:
	80: MoveLoc[4](loc1: Balance<SAFE>)
	81: Ret
}

public(friend) store_execution_time_estimates(Arg0: &mut SafeSystemStateInnerV2, Arg1: vector<u8>) {
L2:	loc0: u64
B0:
	0: LdConst[0](u64: 0)
	1: StLoc[2](loc0: u64)
	2: CopyLoc[0](Arg0: &mut SafeSystemStateInnerV2)
	3: ImmBorrowField[20](SafeSystemStateInnerV2.extra_fields: Bag)
	4: CopyLoc[2](loc0: u64)
	5: Call bag::contains<u64>(&Bag, u64): bool
	6: BrFalse(12)
B1:
	7: CopyLoc[0](Arg0: &mut SafeSystemStateInnerV2)
	8: MutBorrowField[20](SafeSystemStateInnerV2.extra_fields: Bag)
	9: CopyLoc[2](loc0: u64)
	10: Call bag::remove<u64, vector<u8>>(&mut Bag, u64): vector<u8>
	11: Pop
B2:
	12: MoveLoc[0](Arg0: &mut SafeSystemStateInnerV2)
	13: MutBorrowField[20](SafeSystemStateInnerV2.extra_fields: Bag)
	14: MoveLoc[2](loc0: u64)
	15: MoveLoc[1](Arg1: vector<u8>)
	16: Call bag::add<u64, vector<u8>>(&mut Bag, u64, vector<u8>)
	17: Ret
}

public(friend) validators(Arg0: &SafeSystemStateInnerV2): &ValidatorSet {
B0:
	0: MoveLoc[0](Arg0: &SafeSystemStateInnerV2)
	1: ImmBorrowField[0](SafeSystemStateInnerV2.validators: ValidatorSet)
	2: Ret
}

public(friend) validators_mut(Arg0: &mut SafeSystemStateInnerV2): &mut ValidatorSet {
B0:
	0: MoveLoc[0](Arg0: &mut SafeSystemStateInnerV2)
	1: MutBorrowField[0](SafeSystemStateInnerV2.validators: ValidatorSet)
	2: Ret
}

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

// Move bytecode v6
module 3.stake_subsidy {
use 0000000000000000000000000000000000000000000000000000000000000002::bag;
use 0000000000000000000000000000000000000000000000000000000000000002::balance;
use 0000000000000000000000000000000000000000000000000000000000000002::safe;
use 0000000000000000000000000000000000000000000000000000000000000002::tx_context;
use 0000000000000000000000000000000000000000000000000000000000000001::u64;

struct StakeSubsidy has store {
	balance: Balance<SAFE>,
	distribution_counter: u64,
	current_distribution_amount: u64,
	stake_subsidy_period_length: u64,
	stake_subsidy_decrease_rate: u16,
	extra_fields: Bag
}

public(friend) create(Arg0: Balance<SAFE>, Arg1: u64, Arg2: u64, Arg3: u16, Arg4: &mut TxContext): StakeSubsidy {
B0:
	0: CopyLoc[3](Arg3: u16)
	1: LdConst[1](u128: 10000)
	2: CastU16
	3: Le
	4: BrFalse(6)
B1:
	5: Branch(10)
B2:
	6: MoveLoc[4](Arg4: &mut TxContext)
	7: Pop
	8: LdConst[0](u64: 0)
	9: Abort
B3:
	10: MoveLoc[0](Arg0: Balance<SAFE>)
	11: LdU64(0)
	12: MoveLoc[1](Arg1: u64)
	13: MoveLoc[2](Arg2: u64)
	14: MoveLoc[3](Arg3: u16)
	15: MoveLoc[4](Arg4: &mut TxContext)
	16: Call bag::new(&mut TxContext): Bag
	17: Pack[0](StakeSubsidy)
	18: Ret
}

public(friend) advance_epoch(Arg0: &mut StakeSubsidy): Balance<SAFE> {
L1:	loc0: u128
L2:	loc1: Balance<SAFE>
L3:	loc2: u64
B0:
	0: CopyLoc[0](Arg0: &mut StakeSubsidy)
	1: ImmBorrowField[0](StakeSubsidy.current_distribution_amount: u64)
	2: ReadRef
	3: CopyLoc[0](Arg0: &mut StakeSubsidy)
	4: ImmBorrowField[1](StakeSubsidy.balance: Balance<SAFE>)
	5: Call balance::value<SAFE>(&Balance<SAFE>): u64
	6: Call u64::min(u64, u64): u64
	7: StLoc[3](loc2: u64)
	8: CopyLoc[0](Arg0: &mut StakeSubsidy)
	9: MutBorrowField[1](StakeSubsidy.balance: Balance<SAFE>)
	10: MoveLoc[3](loc2: u64)
	11: Call balance::split<SAFE>(&mut Balance<SAFE>, u64): Balance<SAFE>
	12: StLoc[2](loc1: Balance<SAFE>)
	13: CopyLoc[0](Arg0: &mut StakeSubsidy)
	14: ImmBorrowField[2](StakeSubsidy.distribution_counter: u64)
	15: ReadRef
	16: LdU64(1)
	17: Add
	18: CopyLoc[0](Arg0: &mut StakeSubsidy)
	19: MutBorrowField[2](StakeSubsidy.distribution_counter: u64)
	20: WriteRef
	21: CopyLoc[0](Arg0: &mut StakeSubsidy)
	22: ImmBorrowField[2](StakeSubsidy.distribution_counter: u64)
	23: ReadRef
	24: CopyLoc[0](Arg0: &mut StakeSubsidy)
	25: ImmBorrowField[3](StakeSubsidy.stake_subsidy_period_length: u64)
	26: ReadRef
	27: Mod
	28: LdU64(0)
	29: Eq
	30: BrFalse(53)
B1:
	31: CopyLoc[0](Arg0: &mut StakeSubsidy)
	32: ImmBorrowField[0](StakeSubsidy.current_distribution_amount: u64)
	33: ReadRef
	34: CastU128
	35: CopyLoc[0](Arg0: &mut StakeSubsidy)
	36: ImmBorrowField[4](StakeSubsidy.stake_subsidy_decrease_rate: u16)
	37: ReadRef
	38: CastU128
	39: Mul
	40: LdConst[1](u128: 10000)
	41: Div
	42: StLoc[1](loc0: u128)
	43: CopyLoc[0](Arg0: &mut StakeSubsidy)
	44: ImmBorrowField[0](StakeSubsidy.current_distribution_amount: u64)
	45: ReadRef
	46: MoveLoc[1](loc0: u128)
	47: CastU64
	48: Sub
	49: MoveLoc[0](Arg0: &mut StakeSubsidy)
	50: MutBorrowField[0](StakeSubsidy.current_distribution_amount: u64)
	51: WriteRef
	52: Branch(55)
B2:
	53: MoveLoc[0](Arg0: &mut StakeSubsidy)
	54: Pop
B3:
	55: MoveLoc[2](loc1: Balance<SAFE>)
	56: Ret
}

public current_epoch_subsidy_amount(Arg0: &StakeSubsidy): u64 {
B0:
	0: CopyLoc[0](Arg0: &StakeSubsidy)
	1: ImmBorrowField[0](StakeSubsidy.current_distribution_amount: u64)
	2: ReadRef
	3: MoveLoc[0](Arg0: &StakeSubsidy)
	4: ImmBorrowField[1](StakeSubsidy.balance: Balance<SAFE>)
	5: Call balance::value<SAFE>(&Balance<SAFE>): u64
	6: Call u64::min(u64, u64): u64
	7: Ret
}

public(friend) get_distribution_counter(Arg0: &StakeSubsidy): u64 {
B0:
	0: MoveLoc[0](Arg0: &StakeSubsidy)
	1: ImmBorrowField[2](StakeSubsidy.distribution_counter: u64)
	2: ReadRef
	3: Ret
}

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

// Move bytecode v6
module 3.staking_pool {
use 0000000000000000000000000000000000000000000000000000000000000002::bag;
use 0000000000000000000000000000000000000000000000000000000000000002::balance;
use 0000000000000000000000000000000000000000000000000000000000000002::object;
use 0000000000000000000000000000000000000000000000000000000000000002::safe;
use 0000000000000000000000000000000000000000000000000000000000000002::table;
use 0000000000000000000000000000000000000000000000000000000000000002::transfer;
use 0000000000000000000000000000000000000000000000000000000000000002::tx_context;
use 0000000000000000000000000000000000000000000000000000000000000001::option;
use 0000000000000000000000000000000000000000000000000000000000000001::u64;

struct StakingPool has store, key {
	id: UID,
	activation_epoch: Option<u64>,
	deactivation_epoch: Option<u64>,
	safe_balance: u64,
	rewards_pool: Balance<SAFE>,
	pool_token_balance: u64,
	exchange_rates: Table<u64, PoolTokenExchangeRate>,
	pending_stake: u64,
	pending_total_safe_withdraw: u64,
	pending_pool_token_withdraw: u64,
	extra_fields: Bag
}

struct PoolTokenExchangeRate has copy, drop, store {
	safe_amount: u64,
	pool_token_amount: u64
}

struct StakedSafe has store, key {
	id: UID,
	pool_id: ID,
	stake_activation_epoch: u64,
	principal: Balance<SAFE>
}

struct FungibleStakedSafe has store, key {
	id: UID,
	pool_id: ID,
	value: u64
}

struct FungibleStakedSafeData has store, key {
	id: UID,
	total_supply: u64,
	principal: Balance<SAFE>
}

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

public(friend) new(Arg0: &mut TxContext): StakingPool {
B0:
	0: CopyLoc[0](Arg0: &mut TxContext)
	1: Call object::new(&mut TxContext): UID
	2: Call option::none<u64>(): Option<u64>
	3: Call option::none<u64>(): Option<u64>
	4: LdU64(0)
	5: Call balance::zero<SAFE>(): Balance<SAFE>
	6: LdU64(0)
	7: CopyLoc[0](Arg0: &mut TxContext)
	8: Call table::new<u64, PoolTokenExchangeRate>(&mut TxContext): Table<u64, PoolTokenExchangeRate>
	9: LdU64(0)
	10: LdU64(0)
	11: LdU64(0)
	12: MoveLoc[0](Arg0: &mut TxContext)
	13: Call bag::new(&mut TxContext): Bag
	14: Pack[0](StakingPool)
	15: Ret
}

public(friend) request_add_stake(Arg0: &mut StakingPool, Arg1: Balance<SAFE>, Arg2: u64, Arg3: &mut TxContext): StakedSafe {
L4:	loc0: u64
B0:
	0: ImmBorrowLoc[1](Arg1: Balance<SAFE>)
	1: Call balance::value<SAFE>(&Balance<SAFE>): u64
	2: StLoc[4](loc0: u64)
	3: CopyLoc[0](Arg0: &mut StakingPool)
	4: FreezeRef
	5: Call is_inactive(&StakingPool): bool
	6: Not
	7: BrFalse(9)
B1:
	8: Branch(15)
B2:
	9: MoveLoc[0](Arg0: &mut StakingPool)
	10: Pop
	11: MoveLoc[3](Arg3: &mut TxContext)
	12: Pop
	13: LdConst[11](u64: 10)
	14: Abort
B3:
	15: CopyLoc[4](loc0: u64)
	16: LdU64(0)
	17: Gt
	18: BrFalse(20)
B4:
	19: Branch(26)
B5:
	20: MoveLoc[0](Arg0: &mut StakingPool)
	21: Pop
	22: MoveLoc[3](Arg3: &mut TxContext)
	23: Pop
	24: LdConst[18](u64: 17)
	25: Abort
B6:
	26: CopyLoc[0](Arg0: &mut StakingPool)
	27: ImmBorrowField[0](StakingPool.pending_stake: u64)
	28: ReadRef
	29: MoveLoc[4](loc0: u64)
	30: Add
	31: CopyLoc[0](Arg0: &mut StakingPool)
	32: MutBorrowField[0](StakingPool.pending_stake: u64)
	33: WriteRef
	34: MoveLoc[3](Arg3: &mut TxContext)
	35: Call object::new(&mut TxContext): UID
	36: MoveLoc[0](Arg0: &mut StakingPool)
	37: FreezeRef
	38: Call object::id<StakingPool>(&StakingPool): ID
	39: MoveLoc[2](Arg2: u64)
	40: MoveLoc[1](Arg1: Balance<SAFE>)
	41: Pack[2](StakedSafe)
	42: Ret
}

public(friend) request_withdraw_stake(Arg0: &mut StakingPool, Arg1: StakedSafe, Arg2: &TxContext): Balance<SAFE> {
L3:	loc0: bool
L4:	loc1: bool
L5:	loc2: u64
L6:	loc3: Balance<SAFE>
L7:	loc4: Balance<SAFE>
L8:	loc5: u64
L9:	loc6: Balance<SAFE>
L10:	loc7: u64
B0:
	0: ImmBorrowLoc[1](Arg1: StakedSafe)
	1: ImmBorrowField[1](StakedSafe.stake_activation_epoch: u64)
	2: ReadRef
	3: CopyLoc[2](Arg2: &TxContext)
	4: Call tx_context::epoch(&TxContext): u64
	5: Gt
	6: BrFalse(13)
B1:
	7: CopyLoc[0](Arg0: &mut StakingPool)
	8: FreezeRef
	9: Call is_preactive(&StakingPool): bool
	10: Not
	11: StLoc[3](loc0: bool)
	12: Branch(15)
B2:
	13: LdFalse
	14: StLoc[3](loc0: bool)
B3:
	15: MoveLoc[3](loc0: bool)
	16: BrFalse(33)
B4:
	17: MoveLoc[2](Arg2: &TxContext)
	18: Pop
	19: MoveLoc[1](Arg1: StakedSafe)
	20: Call unwrap_staked_safe(StakedSafe): Balance<SAFE>
	21: StLoc[6](loc3: Balance<SAFE>)
	22: CopyLoc[0](Arg0: &mut StakingPool)
	23: ImmBorrowField[0](StakingPool.pending_stake: u64)
	24: ReadRef
	25: ImmBorrowLoc[6](loc3: Balance<SAFE>)
	26: Call balance::value<SAFE>(&Balance<SAFE>): u64
	27: Sub
	28: MoveLoc[0](Arg0: &mut StakingPool)
	29: MutBorrowField[0](StakingPool.pending_stake: u64)
	30: WriteRef
	31: MoveLoc[6](loc3: Balance<SAFE>)
	32: Ret
B5:
	33: CopyLoc[0](Arg0: &mut StakingPool)
	34: FreezeRef
	35: MoveLoc[1](Arg1: StakedSafe)
	36: Call withdraw_from_principal(&StakingPool, StakedSafe): u64 * Balance<SAFE>
	37: StLoc[7](loc4: Balance<SAFE>)
	38: StLoc[5](loc2: u64)
	39: ImmBorrowLoc[7](loc4: Balance<SAFE>)
	40: Call balance::value<SAFE>(&Balance<SAFE>): u64
	41: StLoc[8](loc5: u64)
	42: CopyLoc[0](Arg0: &mut StakingPool)
	43: CopyLoc[8](loc5: u64)
	44: CopyLoc[5](loc2: u64)
	45: MoveLoc[2](Arg2: &TxContext)
	46: Call tx_context::epoch(&TxContext): u64
	47: Call withdraw_rewards(&mut StakingPool, u64, u64, u64): Balance<SAFE>
	48: StLoc[9](loc6: Balance<SAFE>)
	49: MoveLoc[8](loc5: u64)
	50: ImmBorrowLoc[9](loc6: Balance<SAFE>)
	51: Call balance::value<SAFE>(&Balance<SAFE>): u64
	52: Add
	53: StLoc[10](loc7: u64)
	54: CopyLoc[0](Arg0: &mut StakingPool)
	55: ImmBorrowField[2](StakingPool.pending_total_safe_withdraw: u64)
	56: ReadRef
	57: MoveLoc[10](loc7: u64)
	58: Add
	59: CopyLoc[0](Arg0: &mut StakingPool)
	60: MutBorrowField[2](StakingPool.pending_total_safe_withdraw: u64)
	61: WriteRef
	62: CopyLoc[0](Arg0: &mut StakingPool)
	63: ImmBorrowField[3](StakingPool.pending_pool_token_withdraw: u64)
	64: ReadRef
	65: MoveLoc[5](loc2: u64)
	66: Add
	67: CopyLoc[0](Arg0: &mut StakingPool)
	68: MutBorrowField[3](StakingPool.pending_pool_token_withdraw: u64)
	69: WriteRef
	70: CopyLoc[0](Arg0: &mut StakingPool)
	71: FreezeRef
	72: Call is_inactive(&StakingPool): bool
	73: BrFalse(77)
B6:
	74: LdTrue
	75: StLoc[4](loc1: bool)
	76: Branch(81)
B7:
	77: CopyLoc[0](Arg0: &mut StakingPool)
	78: FreezeRef
	79: Call is_preactive(&StakingPool): bool
	80: StLoc[4](loc1: bool)
B8:
	81: MoveLoc[4](loc1: bool)
	82: BrFalse(86)
B9:
	83: MoveLoc[0](Arg0: &mut StakingPool)
	84: Call process_pending_stake_withdraw(&mut StakingPool)
	85: Branch(88)
B10:
	86: MoveLoc[0](Arg0: &mut StakingPool)
	87: Pop
B11:
	88: MutBorrowLoc[7](loc4: Balance<SAFE>)
	89: MoveLoc[9](loc6: Balance<SAFE>)
	90: Call balance::join<SAFE>(&mut Balance<SAFE>, Balance<SAFE>): u64
	91: Pop
	92: MoveLoc[7](loc4: Balance<SAFE>)
	93: Ret
}

public(friend) redeem_fungible_staked_safe(Arg0: &mut StakingPool, Arg1: FungibleStakedSafe, Arg2: &TxContext): Balance<SAFE> {
L3:	loc0: &mut FungibleStakedSafeData
L4:	loc1: UID
L5:	loc2: PoolTokenExchangeRate
L6:	loc3: ID
L7:	loc4: u64
L8:	loc5: u64
L9:	loc6: Balance<SAFE>
L10:	loc7: u64
B0:
	0: MoveLoc[1](Arg1: FungibleStakedSafe)
	1: Unpack[3](FungibleStakedSafe)
	2: StLoc[10](loc7: u64)
	3: StLoc[6](loc3: ID)
	4: StLoc[4](loc1: UID)
	5: MoveLoc[6](loc3: ID)
	6: CopyLoc[0](Arg0: &mut StakingPool)
	7: FreezeRef
	8: Call object::id<StakingPool>(&StakingPool): ID
	9: Eq
	10: BrFalse(12)
B1:
	11: Branch(18)
B2:
	12: MoveLoc[0](Arg0: &mut StakingPool)
	13: Pop
	14: MoveLoc[2](Arg2: &TxContext)
	15: Pop
	16: LdConst[2](u64: 1)
	17: Abort
B3:
	18: MoveLoc[4](loc1: UID)
	19: Call object::delete(UID)
	20: CopyLoc[0](Arg0: &mut StakingPool)
	21: FreezeRef
	22: MoveLoc[2](Arg2: &TxContext)
	23: Call tx_context::epoch(&TxContext): u64
	24: Call pool_token_exchange_rate_at_epoch(&StakingPool, u64): PoolTokenExchangeRate
	25: StLoc[5](loc2: PoolTokenExchangeRate)
	26: CopyLoc[0](Arg0: &mut StakingPool)
	27: MutBorrowField[4](StakingPool.extra_fields: Bag)
	28: LdFalse
	29: Pack[5](FungibleStakedSafeDataKey)
	30: Call bag::borrow_mut<FungibleStakedSafeDataKey, FungibleStakedSafeData>(&mut Bag, FungibleStakedSafeDataKey): &mut FungibleStakedSafeData
	31: StLoc[3](loc0: &mut FungibleStakedSafeData)
	32: MoveLoc[5](loc2: PoolTokenExchangeRate)
	33: CopyLoc[10](loc7: u64)
	34: CopyLoc[3](loc0: &mut FungibleStakedSafeData)
	35: ImmBorrowField[5](FungibleStakedSafeData.principal: Balance<SAFE>)
	36: Call balance::value<SAFE>(&Balance<SAFE>): u64
	37: CopyLoc[3](loc0: &mut FungibleStakedSafeData)
	38: ImmBorrowField[6](FungibleStakedSafeData.total_supply: u64)
	39: ReadRef
	40: Call calculate_fungible_staked_safe_withdraw_amount(PoolTokenExchangeRate, u64, u64, u64): u64 * u64
	41: StLoc[8](loc5: u64)
	42: StLoc[7](loc4: u64)
	43: CopyLoc[3](loc0: &mut FungibleStakedSafeData)
	44: ImmBorrowField[6](FungibleStakedSafeData.total_supply: u64)
	45: ReadRef
	46: CopyLoc[10](loc7: u64)
	47: Sub
	48: CopyLoc[3](loc0: &mut FungibleStakedSafeData)
	49: MutBorrowField[6](FungibleStakedSafeData.total_supply: u64)
	50: WriteRef
	51: MoveLoc[3](loc0: &mut FungibleStakedSafeData)
	52: MutBorrowField[5](FungibleStakedSafeData.principal: Balance<SAFE>)
	53: MoveLoc[7](loc4: u64)
	54: Call balance::split<SAFE>(&mut Balance<SAFE>, u64): Balance<SAFE>
	55: StLoc[9](loc6: Balance<SAFE>)
	56: MutBorrowLoc[9](loc6: Balance<SAFE>)
	57: CopyLoc[0](Arg0: &mut StakingPool)
	58: MutBorrowField[7](StakingPool.rewards_pool: Balance<SAFE>)
	59: MoveLoc[8](loc5: u64)
	60: Call balance::split<SAFE>(&mut Balance<SAFE>, u64): Balance<SAFE>
	61: Call balance::join<SAFE>(&mut Balance<SAFE>, Balance<SAFE>): u64
	62: Pop
	63: CopyLoc[0](Arg0: &mut StakingPool)
	64: ImmBorrowField[2](StakingPool.pending_total_safe_withdraw: u64)
	65: ReadRef
	66: ImmBorrowLoc[9](loc6: Balance<SAFE>)
	67: Call balance::value<SAFE>(&Balance<SAFE>): u64
	68: Add
	69: CopyLoc[0](Arg0: &mut StakingPool)
	70: MutBorrowField[2](StakingPool.pending_total_safe_withdraw: u64)
	71: WriteRef
	72: CopyLoc[0](Arg0: &mut StakingPool)
	73: ImmBorrowField[3](StakingPool.pending_pool_token_withdraw: u64)
	74: ReadRef
	75: MoveLoc[10](loc7: u64)
	76: Add
	77: MoveLoc[0](Arg0: &mut StakingPool)
	78: MutBorrowField[3](StakingPool.pending_pool_token_withdraw: u64)
	79: WriteRef
	80: MoveLoc[9](loc6: Balance<SAFE>)
	81: Ret
}

calculate_fungible_staked_safe_withdraw_amount(Arg0: PoolTokenExchangeRate, Arg1: u64, Arg2: u64, Arg3: u64): u64 * u64 {
L4:	loc0: u64
L5:	loc1: u64
L6:	loc2: u64
L7:	loc3: u64
L8:	loc4: u64
L9:	loc5: u64
B0:
	0: ImmBorrowLoc[0](Arg0: PoolTokenExchangeRate)
	1: CopyLoc[3](Arg3: u64)
	2: Call get_safe_amount(&PoolTokenExchangeRate, u64): u64
	3: StLoc[9](loc5: u64)
	4: MoveLoc[2](Arg2: u64)
	5: CopyLoc[9](loc5: u64)
	6: Call u64::min(u64, u64): u64
	7: StLoc[5](loc1: u64)
	8: MoveLoc[9](loc5: u64)
	9: CopyLoc[5](loc1: u64)
	10: Sub
	11: StLoc[8](loc4: u64)
	12: CopyLoc[1](Arg1: u64)
	13: CastU128
	14: MoveLoc[5](loc1: u64)
	15: CastU128
	16: Mul
	17: CopyLoc[3](Arg3: u64)
	18: CastU128
	19: Div
	20: CastU64
	21: StLoc[6](loc2: u64)
	22: CopyLoc[1](Arg1: u64)
	23: CastU128
	24: MoveLoc[8](loc4: u64)
	25: CastU128
	26: Mul
	27: MoveLoc[3](Arg3: u64)
	28: CastU128
	29: Div
	30: CastU64
	31: StLoc[7](loc3: u64)
	32: ImmBorrowLoc[0](Arg0: PoolTokenExchangeRate)
	33: MoveLoc[1](Arg1: u64)
	34: Call get_safe_amount(&PoolTokenExchangeRate, u64): u64
	35: StLoc[4](loc0: u64)
	36: CopyLoc[6](loc2: u64)
	37: CopyLoc[7](loc3: u64)
	38: Add
	39: MoveLoc[4](loc0: u64)
	40: Le
	41: BrFalse(43)
B1:
	42: Branch(45)
B2:
	43: LdConst[21](u64: 20)
	44: Abort
B3:
	45: MoveLoc[6](loc2: u64)
	46: MoveLoc[7](loc3: u64)
	47: Ret
}

public(friend) convert_to_fungible_staked_safe(Arg0: &mut StakingPool, Arg1: StakedSafe, Arg2: &mut TxContext): FungibleStakedSafe {
L3:	loc0: bool
L4:	loc1: PoolTokenExchangeRate
L5:	loc2: &mut FungibleStakedSafeData
L6:	loc3: UID
L7:	loc4: FungibleStakedSafeDataKey
L8:	loc5: ID
L9:	loc6: u64
L10:	loc7: Balance<SAFE>
L11:	loc8: u64
B0:
	0: MoveLoc[1](Arg1: StakedSafe)
	1: Unpack[2](StakedSafe)
	2: StLoc[10](loc7: Balance<SAFE>)
	3: StLoc[11](loc8: u64)
	4: StLoc[8](loc5: ID)
	5: StLoc[6](loc3: UID)
	6: CopyLoc[8](loc5: ID)
	7: CopyLoc[0](Arg0: &mut StakingPool)
	8: FreezeRef
	9: Call object::id<StakingPool>(&StakingPool): ID
	10: Eq
	11: BrFalse(13)
B1:
	12: Branch(19)
B2:
	13: MoveLoc[0](Arg0: &mut StakingPool)
	14: Pop
	15: MoveLoc[2](Arg2: &mut TxContext)
	16: Pop
	17: LdConst[2](u64: 1)
	18: Abort
B3:
	19: CopyLoc[2](Arg2: &mut TxContext)
	20: FreezeRef
	21: Call tx_context::epoch(&TxContext): u64
	22: CopyLoc[11](loc8: u64)
	23: Ge
	24: BrFalse(26)
B4:
	25: Branch(32)
B5:
	26: MoveLoc[0](Arg0: &mut StakingPool)
	27: Pop
	28: MoveLoc[2](Arg2: &mut TxContext)
	29: Pop
	30: LdConst[20](u64: 19)
	31: Abort
B6:
	32: CopyLoc[0](Arg0: &mut StakingPool)
	33: FreezeRef
	34: Call is_preactive(&StakingPool): bool
	35: Not
	36: BrFalse(43)
B7:
	37: CopyLoc[0](Arg0: &mut StakingPool)
	38: FreezeRef
	39: Call is_inactive(&StakingPool): bool
	40: Not
	41: StLoc[3](loc0: bool)
	42: Branch(45)
B8:
	43: LdFalse
	44: StLoc[3](loc0: bool)
B9:
	45: MoveLoc[3](loc0: bool)
	46: BrFalse(48)
B10:
	47: Branch(54)
B11:
	48: MoveLoc[0](Arg0: &mut StakingPool)
	49: Pop
	50: MoveLoc[2](Arg2: &mut TxContext)
	51: Pop
	52: LdConst[16](u64: 15)
	53: Abort
B12:
	54: MoveLoc[6](loc3: UID)
	55: Call object::delete(UID)
	56: CopyLoc[0](Arg0: &mut StakingPool)
	57: FreezeRef
	58: MoveLoc[11](loc8: u64)
	59: Call pool_token_exchange_rate_at_epoch(&StakingPool, u64): PoolTokenExchangeRate
	60: StLoc[4](loc1: PoolTokenExchangeRate)
	61: ImmBorrowLoc[4](loc1: PoolTokenExchangeRate)
	62: ImmBorrowLoc[10](loc7: Balance<SAFE>)
	63: Call balance::value<SAFE>(&Balance<SAFE>): u64
	64: Call get_token_amount(&PoolTokenExchangeRate, u64): u64
	65: StLoc[9](loc6: u64)
	66: LdFalse
	67: Pack[5](FungibleStakedSafeDataKey)
	68: StLoc[7](loc4: FungibleStakedSafeDataKey)
	69: CopyLoc[0](Arg0: &mut StakingPool)
	70: ImmBorrowField[4](StakingPool.extra_fields: Bag)
	71: CopyLoc[7](loc4: FungibleStakedSafeDataKey)
	72: Call bag::contains<FungibleStakedSafeDataKey>(&Bag, FungibleStakedSafeDataKey): bool
	73: Not
	74: BrFalse(85)
B13:
	75: MoveLoc[0](Arg0: &mut StakingPool)
	76: MutBorrowField[4](StakingPool.extra_fields: Bag)
	77: MoveLoc[7](loc4: FungibleStakedSafeDataKey)
	78: CopyLoc[2](Arg2: &mut TxContext)
	79: Call object::new(&mut TxContext): UID
	80: CopyLoc[9](loc6: u64)
	81: MoveLoc[10](loc7: Balance<SAFE>)
	82: Pack[4](FungibleStakedSafeData)
	83: Call bag::add<FungibleStakedSafeDataKey, FungibleStakedSafeData>(&mut Bag, FungibleStakedSafeDataKey, FungibleStakedSafeData)
	84: Branch(103)
B14:
	85: MoveLoc[0](Arg0: &mut StakingPool)
	86: MutBorrowField[4](StakingPool.extra_fields: Bag)
	87: MoveLoc[7](loc4: FungibleStakedSafeDataKey)
	88: Call bag::borrow_mut<FungibleStakedSafeDataKey, FungibleStakedSafeData>(&mut Bag, FungibleStakedSafeDataKey): &mut FungibleStakedSafeData
	89: StLoc[5](loc2: &mut FungibleStakedSafeData)
	90: CopyLoc[5](loc2: &mut FungibleStakedSafeData)
	91: ImmBorrowField[6](FungibleStakedSafeData.total_supply: u64)
	92: ReadRef
	93: CopyLoc[9](loc6: u64)
	94: Add
	95: CopyLoc[5](loc2: &mut FungibleStakedSafeData)
	96: MutBorrowField[6](FungibleStakedSafeData.total_supply: u64)
	97: WriteRef
	98: MoveLoc[5](loc2: &mut FungibleStakedSafeData)
	99: MutBorrowField[5](FungibleStakedSafeData.principal: Balance<SAFE>)
	100: MoveLoc[10](loc7: Balance<SAFE>)
	101: Call balance::join<SAFE>(&mut Balance<SAFE>, Balance<SAFE>): u64
	102: Pop
B15:
	103: MoveLoc[2](Arg2: &mut TxContext)
	104: Call object::new(&mut TxContext): UID
	105: MoveLoc[8](loc5: ID)
	106: MoveLoc[9](loc6: u64)
	107: Pack[3](FungibleStakedSafe)
	108: Ret
}

public(friend) withdraw_from_principal(Arg0: &StakingPool, Arg1: StakedSafe): u64 * Balance<SAFE> {
L2:	loc0: PoolTokenExchangeRate
L3:	loc1: Balance<SAFE>
B0:
	0: ImmBorrowLoc[1](Arg1: StakedSafe)
	1: ImmBorrowField[8](StakedSafe.pool_id: ID)
	2: ReadRef
	3: CopyLoc[0](Arg0: &StakingPool)
	4: Call object::id<StakingPool>(&StakingPool): ID
	5: Eq
	6: BrFalse(8)
B1:
	7: Branch(12)
B2:
	8: MoveLoc[0](Arg0: &StakingPool)
	9: Pop
	10: LdConst[2](u64: 1)
	11: Abort
B3:
	12: MoveLoc[0](Arg0: &StakingPool)
	13: ImmBorrowLoc[1](Arg1: StakedSafe)
	14: ImmBorrowField[1](StakedSafe.stake_activation_epoch: u64)
	15: ReadRef
	16: Call pool_token_exchange_rate_at_epoch(&StakingPool, u64): PoolTokenExchangeRate
	17: StLoc[2](loc0: PoolTokenExchangeRate)
	18: MoveLoc[1](Arg1: StakedSafe)
	19: Call unwrap_staked_safe(StakedSafe): Balance<SAFE>
	20: StLoc[3](loc1: Balance<SAFE>)
	21: ImmBorrowLoc[2](loc0: PoolTokenExchangeRate)
	22: ImmBorrowLoc[3](loc1: Balance<SAFE>)
	23: Call balance::value<SAFE>(&Balance<SAFE>): u64
	24: Call get_token_amount(&PoolTokenExchangeRate, u64): u64
	25: MoveLoc[3](loc1: Balance<SAFE>)
	26: Ret
}

unwrap_staked_safe(Arg0: StakedSafe): Balance<SAFE> {
L1:	loc0: Balance<SAFE>
B0:
	0: MoveLoc[0](Arg0: StakedSafe)
	1: Unpack[2](StakedSafe)
	2: StLoc[1](loc0: Balance<SAFE>)
	3: Pop
	4: Pop
	5: Call object::delete(UID)
	6: MoveLoc[1](loc0: Balance<SAFE>)
	7: Ret
}

public(friend) deposit_rewards(Arg0: &mut StakingPool, Arg1: Balance<SAFE>) {
B0:
	0: CopyLoc[0](Arg0: &mut StakingPool)
	1: ImmBorrowField[9](StakingPool.safe_balance: u64)
	2: ReadRef
	3: ImmBorrowLoc[1](Arg1: Balance<SAFE>)
	4: Call balance::value<SAFE>(&Balance<SAFE>): u64
	5: Add
	6: CopyLoc[0](Arg0: &mut StakingPool)
	7: MutBorrowField[9](StakingPool.safe_balance: u64)
	8: WriteRef
	9: MoveLoc[0](Arg0: &mut StakingPool)
	10: MutBorrowField[7](StakingPool.rewards_pool: Balance<SAFE>)
	11: MoveLoc[1](Arg1: Balance<SAFE>)
	12: Call balance::join<SAFE>(&mut Balance<SAFE>, Balance<SAFE>): u64
	13: Pop
	14: Ret
}

public(friend) process_pending_stakes_and_withdraws(Arg0: &mut StakingPool, Arg1: &TxContext) {
L2:	loc0: u64
B0:
	0: MoveLoc[1](Arg1: &TxContext)
	1: Call tx_context::epoch(&TxContext): u64
	2: LdU64(1)
	3: Add
	4: StLoc[2](loc0: u64)
	5: CopyLoc[0](Arg0: &mut StakingPool)
	6: Call process_pending_stake_withdraw(&mut StakingPool)
	7: CopyLoc[0](Arg0: &mut StakingPool)
	8: Call process_pending_stake(&mut StakingPool)
	9: CopyLoc[0](Arg0: &mut StakingPool)
	10: MutBorrowField[10](StakingPool.exchange_rates: Table<u64, PoolTokenExchangeRate>)
	11: CopyLoc[2](loc0: u64)
	12: CopyLoc[0](Arg0: &mut StakingPool)
	13: ImmBorrowField[9](StakingPool.safe_balance: u64)
	14: ReadRef
	15: CopyLoc[0](Arg0: &mut StakingPool)
	16: ImmBorrowField[11](StakingPool.pool_token_balance: u64)
	17: ReadRef
	18: Pack[1](PoolTokenExchangeRate)
	19: Call table::add<u64, PoolTokenExchangeRate>(&mut Table<u64, PoolTokenExchangeRate>, u64, PoolTokenExchangeRate)
	20: MoveLoc[0](Arg0: &mut StakingPool)
	21: FreezeRef
	22: MoveLoc[2](loc0: u64)
	23: Call check_balance_invariants(&StakingPool, u64)
	24: Ret
}

process_pending_stake_withdraw(Arg0: &mut StakingPool) {
B0:
	0: CopyLoc[0](Arg0: &mut StakingPool)
	1: ImmBorrowField[9](StakingPool.safe_balance: u64)
	2: ReadRef
	3: CopyLoc[0](Arg0: &mut StakingPool)
	4: ImmBorrowField[2](StakingPool.pending_total_safe_withdraw: u64)
	5: ReadRef
	6: Sub
	7: CopyLoc[0](Arg0: &mut StakingPool)
	8: MutBorrowField[9](StakingPool.safe_balance: u64)
	9: WriteRef
	10: CopyLoc[0](Arg0: &mut StakingPool)
	11: ImmBorrowField[11](StakingPool.pool_token_balance: u64)
	12: ReadRef
	13: CopyLoc[0](Arg0: &mut StakingPool)
	14: ImmBorrowField[3](StakingPool.pending_pool_token_withdraw: u64)
	15: ReadRef
	16: Sub
	17: CopyLoc[0](Arg0: &mut StakingPool)
	18: MutBorrowField[11](StakingPool.pool_token_balance: u64)
	19: WriteRef
	20: LdU64(0)
	21: CopyLoc[0](Arg0: &mut StakingPool)
	22: MutBorrowField[2](StakingPool.pending_total_safe_withdraw: u64)
	23: WriteRef
	24: LdU64(0)
	25: MoveLoc[0](Arg0: &mut StakingPool)
	26: MutBorrowField[3](StakingPool.pending_pool_token_withdraw: u64)
	27: WriteRef
	28: Ret
}

public(friend) process_pending_stake(Arg0: &mut StakingPool) {
L1:	loc0: PoolTokenExchangeRate
B0:
	0: CopyLoc[0](Arg0: &mut StakingPool)
	1: ImmBorrowField[9](StakingPool.safe_balance: u64)
	2: ReadRef
	3: CopyLoc[0](Arg0: &mut StakingPool)
	4: ImmBorrowField[11](StakingPool.pool_token_balance: u64)
	5: ReadRef
	6: Pack[1](PoolTokenExchangeRate)
	7: StLoc[1](loc0: PoolTokenExchangeRate)
	8: CopyLoc[0](Arg0: &mut StakingPool)
	9: ImmBorrowField[9](StakingPool.safe_balance: u64)
	10: ReadRef
	11: CopyLoc[0](Arg0: &mut StakingPool)
	12: ImmBorrowField[0](StakingPool.pending_stake: u64)
	13: ReadRef
	14: Add
	15: CopyLoc[0](Arg0: &mut StakingPool)
	16: MutBorrowField[9](StakingPool.safe_balance: u64)
	17: WriteRef
	18: ImmBorrowLoc[1](loc0: PoolTokenExchangeRate)
	19: CopyLoc[0](Arg0: &mut StakingPool)
	20: ImmBorrowField[9](StakingPool.safe_balance: u64)
	21: ReadRef
	22: Call get_token_amount(&PoolTokenExchangeRate, u64): u64
	23: CopyLoc[0](Arg0: &mut StakingPool)
	24: MutBorrowField[11](StakingPool.pool_token_balance: u64)
	25: WriteRef
	26: LdU64(0)
	27: MoveLoc[0](Arg0: &mut StakingPool)
	28: MutBorrowField[0](StakingPool.pending_stake: u64)
	29: WriteRef
	30: Ret
}

withdraw_rewards(Arg0: &mut StakingPool, Arg1: u64, Arg2: u64, Arg3: u64): Balance<SAFE> {
L4:	loc0: u64
L5:	loc1: PoolTokenExchangeRate
L6:	loc2: u64
L7:	loc3: u64
B0:
	0: CopyLoc[0](Arg0: &mut StakingPool)
	1: FreezeRef
	2: MoveLoc[3](Arg3: u64)
	3: Call pool_token_exchange_rate_at_epoch(&StakingPool, u64): PoolTokenExchangeRate
	4: StLoc[5](loc1: PoolTokenExchangeRate)
	5: ImmBorrowLoc[5](loc1: PoolTokenExchangeRate)
	6: MoveLoc[2](Arg2: u64)
	7: Call get_safe_amount(&PoolTokenExchangeRate, u64): u64
	8: StLoc[7](loc3: u64)
	9: CopyLoc[7](loc3: u64)
	10: CopyLoc[1](Arg1: u64)
	11: Ge
	12: BrFalse(18)
B1:
	13: MoveLoc[7](loc3: u64)
	14: MoveLoc[1](Arg1: u64)
	15: Sub
	16: StLoc[4](loc0: u64)
	17: Branch(20)
B2:
	18: LdU64(0)
	19: StLoc[4](loc0: u64)
B3:
	20: MoveLoc[4](loc0: u64)
	21: CopyLoc[0](Arg0: &mut StakingPool)
	22: ImmBorrowField[7](StakingPool.rewards_pool: Balance<SAFE>)
	23: Call balance::value<SAFE>(&Balance<SAFE>): u64
	24: Call u64::min(u64, u64): u64
	25: StLoc[6](loc2: u64)
	26: MoveLoc[0](Arg0: &mut StakingPool)
	27: MutBorrowField[7](StakingPool.rewards_pool: Balance<SAFE>)
	28: MoveLoc[6](loc2: u64)
	29: Call balance::split<SAFE>(&mut Balance<SAFE>, u64): Balance<SAFE>
	30: Ret
}

public(friend) activate_staking_pool(Arg0: &mut StakingPool, Arg1: u64) {
B0:
	0: CopyLoc[0](Arg0: &mut StakingPool)
	1: MutBorrowField[10](StakingPool.exchange_rates: Table<u64, PoolTokenExchangeRate>)
	2: CopyLoc[1](Arg1: u64)
	3: Call initial_exchange_rate(): PoolTokenExchangeRate
	4: Call table::add<u64, PoolTokenExchangeRate>(&mut Table<u64, PoolTokenExchangeRate>, u64, PoolTokenExchangeRate)
	5: CopyLoc[0](Arg0: &mut StakingPool)
	6: FreezeRef
	7: Call is_preactive(&StakingPool): bool
	8: BrFalse(10)
B1:
	9: Branch(14)
B2:
	10: MoveLoc[0](Arg0: &mut StakingPool)
	11: Pop
	12: LdConst[15](u64: 14)
	13: Abort
B3:
	14: CopyLoc[0](Arg0: &mut StakingPool)
	15: FreezeRef
	16: Call is_inactive(&StakingPool): bool
	17: Not
	18: BrFalse(20)
B4:
	19: Branch(24)
B5:
	20: MoveLoc[0](Arg0: &mut StakingPool)
	21: Pop
	22: LdConst[17](u64: 16)
	23: Abort
B6:
	24: MoveLoc[0](Arg0: &mut StakingPool)
	25: MutBorrowField[12](StakingPool.activation_epoch: Option<u64>)
	26: MoveLoc[1](Arg1: u64)
	27: Call option::fill<u64>(&mut Option<u64>, u64)
	28: Ret
}

public(friend) deactivate_staking_pool(Arg0: &mut StakingPool, Arg1: u64) {
B0:
	0: CopyLoc[0](Arg0: &mut StakingPool)
	1: FreezeRef
	2: Call is_inactive(&StakingPool): bool
	3: Not
	4: BrFalse(6)
B1:
	5: Branch(10)
B2:
	6: MoveLoc[0](Arg0: &mut StakingPool)
	7: Pop
	8: LdConst[12](u64: 11)
	9: Abort
B3:
	10: MoveLoc[1](Arg1: u64)
	11: Call option::some<u64>(u64): Option<u64>
	12: MoveLoc[0](Arg0: &mut StakingPool)
	13: MutBorrowField[13](StakingPool.deactivation_epoch: Option<u64>)
	14: WriteRef
	15: Ret
}

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

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

public fungible_staked_safe_pool_id(Arg0: &FungibleStakedSafe): ID {
B0:
	0: MoveLoc[0](Arg0: &FungibleStakedSafe)
	1: ImmBorrowField[14](FungibleStakedSafe.pool_id: ID)
	2: ReadRef
	3: Ret
}

public staked_safe_amount(Arg0: &StakedSafe): u64 {
B0:
	0: MoveLoc[0](Arg0: &StakedSafe)
	1: ImmBorrowField[15](StakedSafe.principal: Balance<SAFE>)
	2: Call balance::value<SAFE>(&Balance<SAFE>): u64
	3: Ret
}

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

public is_preactive(Arg0: &StakingPool): bool {
B0:
	0: MoveLoc[0](Arg0: &StakingPool)
	1: ImmBorrowField[12](StakingPool.activation_epoch: Option<u64>)
	2: Call option::is_none<u64>(&Option<u64>): bool
	3: Ret
}

public(friend) activation_epoch(Arg0: &StakingPool): Option<u64> {
B0:
	0: MoveLoc[0](Arg0: &StakingPool)
	1: ImmBorrowField[12](StakingPool.activation_epoch: Option<u64>)
	2: ReadRef
	3: Ret
}

public is_inactive(Arg0: &StakingPool): bool {
B0:
	0: MoveLoc[0](Arg0: &StakingPool)
	1: ImmBorrowField[13](StakingPool.deactivation_epoch: Option<u64>)
	2: Call option::is_some<u64>(&Option<u64>): bool
	3: Ret
}

public fungible_staked_safe_value(Arg0: &FungibleStakedSafe): u64 {
B0:
	0: MoveLoc[0](Arg0: &FungibleStakedSafe)
	1: ImmBorrowField[16](FungibleStakedSafe.value: u64)
	2: ReadRef
	3: Ret
}

public split_fungible_staked_safe(Arg0: &mut FungibleStakedSafe, Arg1: u64, Arg2: &mut TxContext): FungibleStakedSafe {
B0:
	0: CopyLoc[1](Arg1: u64)
	1: CopyLoc[0](Arg0: &mut FungibleStakedSafe)
	2: ImmBorrowField[16](FungibleStakedSafe.value: u64)
	3: ReadRef
	4: Le
	5: BrFalse(7)
B1:
	6: Branch(13)
B2:
	7: MoveLoc[0](Arg0: &mut FungibleStakedSafe)
	8: Pop
	9: MoveLoc[2](Arg2: &mut TxContext)
	10: Pop
	11: LdConst[1](u64: 0)
	12: Abort
B3:
	13: CopyLoc[0](Arg0: &mut FungibleStakedSafe)
	14: ImmBorrowField[16](FungibleStakedSafe.value: u64)
	15: ReadRef
	16: CopyLoc[1](Arg1: u64)
	17: Sub
	18: CopyLoc[0](Arg0: &mut FungibleStakedSafe)
	19: MutBorrowField[16](FungibleStakedSafe.value: u64)
	20: WriteRef
	21: MoveLoc[2](Arg2: &mut TxContext)
	22: Call object::new(&mut TxContext): UID
	23: MoveLoc[0](Arg0: &mut FungibleStakedSafe)
	24: ImmBorrowField[14](FungibleStakedSafe.pool_id: ID)
	25: ReadRef
	26: MoveLoc[1](Arg1: u64)
	27: Pack[3](FungibleStakedSafe)
	28: Ret
}

public join_fungible_staked_safe(Arg0: &mut FungibleStakedSafe, Arg1: FungibleStakedSafe) {
L2:	loc0: UID
L3:	loc1: ID
L4:	loc2: u64
B0:
	0: MoveLoc[1](Arg1: FungibleStakedSafe)
	1: Unpack[3](FungibleStakedSafe)
	2: StLoc[4](loc2: u64)
	3: StLoc[3](loc1: ID)
	4: StLoc[2](loc0: UID)
	5: CopyLoc[0](Arg0: &mut FungibleStakedSafe)
	6: ImmBorrowField[14](FungibleStakedSafe.pool_id: ID)
	7: ReadRef
	8: MoveLoc[3](loc1: ID)
	9: Eq
	10: BrFalse(12)
B1:
	11: Branch(16)
B2:
	12: MoveLoc[0](Arg0: &mut FungibleStakedSafe)
	13: Pop
	14: LdConst[2](u64: 1)
	15: Abort
B3:
	16: MoveLoc[2](loc0: UID)
	17: Call object::delete(UID)
	18: CopyLoc[0](Arg0: &mut FungibleStakedSafe)
	19: ImmBorrowField[16](FungibleStakedSafe.value: u64)
	20: ReadRef
	21: MoveLoc[4](loc2: u64)
	22: Add
	23: MoveLoc[0](Arg0: &mut FungibleStakedSafe)
	24: MutBorrowField[16](FungibleStakedSafe.value: u64)
	25: WriteRef
	26: Ret
}

public split(Arg0: &mut StakedSafe, Arg1: u64, Arg2: &mut TxContext): StakedSafe {
L3:	loc0: u64
B0:
	0: CopyLoc[0](Arg0: &mut StakedSafe)
	1: ImmBorrowField[15](StakedSafe.principal: Balance<SAFE>)
	2: Call balance::value<SAFE>(&Balance<SAFE>): u64
	3: StLoc[3](loc0: u64)
	4: CopyLoc[1](Arg1: u64)
	5: CopyLoc[3](loc0: u64)
	6: Le
	7: BrFalse(9)
B1:
	8: Branch(15)
B2:
	9: MoveLoc[0](Arg0: &mut StakedSafe)
	10: Pop
	11: MoveLoc[2](Arg2: &mut TxContext)
	12: Pop
	13: LdConst[4](u64: 3)
	14: Abort
B3:
	15: MoveLoc[3](loc0: u64)
	16: CopyLoc[1](Arg1: u64)
	17: Sub
	18: LdConst[0](u64: 1000..)
	19: Ge
	20: BrFalse(22)
B4:
	21: Branch(28)
B5:
	22: MoveLoc[0](Arg0: &mut StakedSafe)
	23: Pop
	24: MoveLoc[2](Arg2: &mut TxContext)
	25: Pop
	26: LdConst[19](u64: 18)
	27: Abort
B6:
	28: CopyLoc[1](Arg1: u64)
	29: LdConst[0](u64: 1000..)
	30: Ge
	31: BrFalse(33)
B7:
	32: Branch(39)
B8:
	33: MoveLoc[0](Arg0: &mut StakedSafe)
	34: Pop
	35: MoveLoc[2](Arg2: &mut TxContext)
	36: Pop
	37: LdConst[19](u64: 18)
	38: Abort
B9:
	39: MoveLoc[2](Arg2: &mut TxContext)
	40: Call object::new(&mut TxContext): UID
	41: CopyLoc[0](Arg0: &mut StakedSafe)
	42: ImmBorrowField[8](StakedSafe.pool_id: ID)
	43: ReadRef
	44: CopyLoc[0](Arg0: &mut StakedSafe)
	45: ImmBorrowField[1](StakedSafe.stake_activation_epoch: u64)
	46: ReadRef
	47: MoveLoc[0](Arg0: &mut StakedSafe)
	48: MutBorrowField[15](StakedSafe.principal: Balance<SAFE>)
	49: MoveLoc[1](Arg1: u64)
	50: Call balance::split<SAFE>(&mut Balance<SAFE>, u64): Balance<SAFE>
	51: Pack[2](StakedSafe)
	52: Ret
}

entry public split_staked_safe(Arg0: &mut StakedSafe, Arg1: u64, Arg2: &mut TxContext) {
B0:
	0: MoveLoc[0](Arg0: &mut StakedSafe)
	1: MoveLoc[1](Arg1: u64)
	2: CopyLoc[2](Arg2: &mut TxContext)
	3: Call split(&mut StakedSafe, u64, &mut TxContext): StakedSafe
	4: MoveLoc[2](Arg2: &mut TxContext)
	5: FreezeRef
	6: Call tx_context::sender(&TxContext): address
	7: Call transfer::transfer<StakedSafe>(StakedSafe, address)
	8: Ret
}

entry public join_staked_safe(Arg0: &mut StakedSafe, Arg1: StakedSafe) {
L2:	loc0: Balance<SAFE>
B0:
	0: CopyLoc[0](Arg0: &mut StakedSafe)
	1: FreezeRef
	2: ImmBorrowLoc[1](Arg1: StakedSafe)
	3: Call is_equal_staking_metadata(&StakedSafe, &StakedSafe): bool
	4: BrFalse(6)
B1:
	5: Branch(10)
B2:
	6: MoveLoc[0](Arg0: &mut StakedSafe)
	7: Pop
	8: LdConst[13](u64: 12)
	9: Abort
B3:
	10: MoveLoc[1](Arg1: StakedSafe)
	11: Unpack[2](StakedSafe)
	12: StLoc[2](loc0: Balance<SAFE>)
	13: Pop
	14: Pop
	15: Call object::delete(UID)
	16: MoveLoc[0](Arg0: &mut StakedSafe)
	17: MutBorrowField[15](StakedSafe.principal: Balance<SAFE>)
	18: MoveLoc[2](loc0: Balance<SAFE>)
	19: Call balance::join<SAFE>(&mut Balance<SAFE>, Balance<SAFE>): u64
	20: Pop
	21: Ret
}

public is_equal_staking_metadata(Arg0: &StakedSafe, Arg1: &StakedSafe): bool {
L2:	loc0: bool
B0:
	0: CopyLoc[0](Arg0: &StakedSafe)
	1: ImmBorrowField[8](StakedSafe.pool_id: ID)
	2: ReadRef
	3: CopyLoc[1](Arg1: &StakedSafe)
	4: ImmBorrowField[8](StakedSafe.pool_id: ID)
	5: ReadRef
	6: Eq
	7: BrFalse(17)
B1:
	8: MoveLoc[0](Arg0: &StakedSafe)
	9: ImmBorrowField[1](StakedSafe.stake_activation_epoch: u64)
	10: ReadRef
	11: MoveLoc[1](Arg1: &StakedSafe)
	12: ImmBorrowField[1](StakedSafe.stake_activation_epoch: u64)
	13: ReadRef
	14: Eq
	15: StLoc[2](loc0: bool)
	16: Branch(23)
B2:
	17: MoveLoc[0](Arg0: &StakedSafe)
	18: Pop
	19: MoveLoc[1](Arg1: &StakedSafe)
	20: Pop
	21: LdFalse
	22: StLoc[2](loc0: bool)
B3:
	23: MoveLoc[2](loc0: bool)
	24: Ret
}

public pool_token_exchange_rate_at_epoch(Arg0: &StakingPool, Arg1: u64): PoolTokenExchangeRate {
L2:	loc0: u64
L3:	loc1: u64
B0:
	0: CopyLoc[0](Arg0: &StakingPool)
	1: CopyLoc[1](Arg1: u64)
	2: Call is_preactive_at_epoch(&StakingPool, u64): bool
	3: BrFalse(8)
B1:
	4: MoveLoc[0](Arg0: &StakingPool)
	5: Pop
	6: Call initial_exchange_rate(): PoolTokenExchangeRate
	7: Ret
B2:
	8: CopyLoc[0](Arg0: &StakingPool)
	9: ImmBorrowField[13](StakingPool.deactivation_epoch: Option<u64>)
	10: CopyLoc[1](Arg1: u64)
	11: Call option::get_with_default<u64>(&Option<u64>, u64): u64
	12: MoveLoc[1](Arg1: u64)
	13: Call u64::min(u64, u64): u64
	14: StLoc[3](loc1: u64)
	15: CopyLoc[0](Arg0: &StakingPool)
	16: ImmBorrowField[12](StakingPool.activation_epoch: Option<u64>)
	17: Call option::borrow<u64>(&Option<u64>): &u64
	18: ReadRef
	19: StLoc[2](loc0: u64)
B3:
	20: CopyLoc[3](loc1: u64)
	21: CopyLoc[2](loc0: u64)
	22: Ge
	23: BrFalse(41)
B4:
	24: CopyLoc[0](Arg0: &StakingPool)
	25: ImmBorrowField[10](StakingPool.exchange_rates: Table<u64, PoolTokenExchangeRate>)
	26: CopyLoc[3](loc1: u64)
	27: Call table::contains<u64, PoolTokenExchangeRate>(&Table<u64, PoolTokenExchangeRate>, u64): bool
	28: BrFalse(36)
B5:
	29: Branch(30)
B6:
	30: MoveLoc[0](Arg0: &StakingPool)
	31: ImmBorrowField[10](StakingPool.exchange_rates: Table<u64, PoolTokenExchangeRate>)
	32: MoveLoc[3](loc1: u64)
	33: Call table::borrow<u64, PoolTokenExchangeRate>(&Table<u64, PoolTokenExchangeRate>, u64): &PoolTokenExchangeRate
	34: ReadRef
	35: Ret
B7:
	36: MoveLoc[3](loc1: u64)
	37: LdU64(1)
	38: Sub
	39: StLoc[3](loc1: u64)
	40: Branch(20)
B8:
	41: MoveLoc[0](Arg0: &StakingPool)
	42: Pop
	43: Call initial_exchange_rate(): PoolTokenExchangeRate
	44: Ret
}

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

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

public(friend) exchange_rates(Arg0: &StakingPool): &Table<u64, PoolTokenExchangeRate> {
B0:
	0: MoveLoc[0](Arg0: &StakingPool)
	1: ImmBorrowField[10](StakingPool.exchange_rates: Table<u64, PoolTokenExchangeRate>)
	2: Ret
}

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

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

is_preactive_at_epoch(Arg0: &StakingPool, Arg1: u64): bool {
L2:	loc0: bool
B0:
	0: CopyLoc[0](Arg0: &StakingPool)
	1: Call is_preactive(&StakingPool): bool
	2: BrFalse(8)
B1:
	3: MoveLoc[0](Arg0: &StakingPool)
	4: Pop
	5: LdTrue
	6: StLoc[2](loc0: bool)
	7: Branch(15)
B2:
	8: MoveLoc[0](Arg0: &StakingPool)
	9: ImmBorrowField[12](StakingPool.activation_epoch: Option<u64>)
	10: Call option::borrow<u64>(&Option<u64>): &u64
	11: ReadRef
	12: MoveLoc[1](Arg1: u64)
	13: Gt
	14: StLoc[2](loc0: bool)
B3:
	15: MoveLoc[2](loc0: bool)
	16: Ret
}

get_safe_amount(Arg0: &PoolTokenExchangeRate, Arg1: u64): u64 {
L2:	loc0: bool
B0:
	0: CopyLoc[0](Arg0: &PoolTokenExchangeRate)
	1: ImmBorrowField[17](PoolTokenExchangeRate.safe_amount: u64)
	2: ReadRef
	3: LdU64(0)
	4: Eq
	5: BrFalse(9)
B1:
	6: LdTrue
	7: StLoc[2](loc0: bool)
	8: Branch(15)
B2:
	9: CopyLoc[0](Arg0: &PoolTokenExchangeRate)
	10: ImmBorrowField[18](PoolTokenExchangeRate.pool_token_amount: u64)
	11: ReadRef
	12: LdU64(0)
	13: Eq
	14: StLoc[2](loc0: bool)
B3:
	15: MoveLoc[2](loc0: bool)
	16: BrFalse(21)
B4:
	17: MoveLoc[0](Arg0: &PoolTokenExchangeRate)
	18: Pop
	19: MoveLoc[1](Arg1: u64)
	20: Ret
B5:
	21: CopyLoc[0](Arg0: &PoolTokenExchangeRate)
	22: ImmBorrowField[17](PoolTokenExchangeRate.safe_amount: u64)
	23: ReadRef
	24: CastU128
	25: MoveLoc[1](Arg1: u64)
	26: CastU128
	27: Mul
	28: MoveLoc[0](Arg0: &PoolTokenExchangeRate)
	29: ImmBorrowField[18](PoolTokenExchangeRate.pool_token_amount: u64)
	30: ReadRef
	31: CastU128
	32: Div
	33: CastU64
	34: Ret
}

get_token_amount(Arg0: &PoolTokenExchangeRate, Arg1: u64): u64 {
L2:	loc0: bool
B0:
	0: CopyLoc[0](Arg0: &PoolTokenExchangeRate)
	1: ImmBorrowField[17](PoolTokenExchangeRate.safe_amount: u64)
	2: ReadRef
	3: LdU64(0)
	4: Eq
	5: BrFalse(9)
B1:
	6: LdTrue
	7: StLoc[2](loc0: bool)
	8: Branch(15)
B2:
	9: CopyLoc[0](Arg0: &PoolTokenExchangeRate)
	10: ImmBorrowField[18](PoolTokenExchangeRate.pool_token_amount: u64)
	11: ReadRef
	12: LdU64(0)
	13: Eq
	14: StLoc[2](loc0: bool)
B3:
	15: MoveLoc[2](loc0: bool)
	16: BrFalse(21)
B4:
	17: MoveLoc[0](Arg0: &PoolTokenExchangeRate)
	18: Pop
	19: MoveLoc[1](Arg1: u64)
	20: Ret
B5:
	21: CopyLoc[0](Arg0: &PoolTokenExchangeRate)
	22: ImmBorrowField[18](PoolTokenExchangeRate.pool_token_amount: u64)
	23: ReadRef
	24: CastU128
	25: MoveLoc[1](Arg1: u64)
	26: CastU128
	27: Mul
	28: MoveLoc[0](Arg0: &PoolTokenExchangeRate)
	29: ImmBorrowField[17](PoolTokenExchangeRate.safe_amount: u64)
	30: ReadRef
	31: CastU128
	32: Div
	33: CastU64
	34: Ret
}

initial_exchange_rate(): PoolTokenExchangeRate {
B0:
	0: LdU64(0)
	1: LdU64(0)
	2: Pack[1](PoolTokenExchangeRate)
	3: Ret
}

check_balance_invariants(Arg0: &StakingPool, Arg1: u64) {
L2:	loc0: u64
L3:	loc1: PoolTokenExchangeRate
L4:	loc2: u64
B0:
	0: CopyLoc[0](Arg0: &StakingPool)
	1: MoveLoc[1](Arg1: u64)
	2: Call pool_token_exchange_rate_at_epoch(&StakingPool, u64): PoolTokenExchangeRate
	3: StLoc[3](loc1: PoolTokenExchangeRate)
	4: ImmBorrowLoc[3](loc1: PoolTokenExchangeRate)
	5: CopyLoc[0](Arg0: &StakingPool)
	6: ImmBorrowField[9](StakingPool.safe_balance: u64)
	7: ReadRef
	8: Call get_token_amount(&PoolTokenExchangeRate, u64): u64
	9: StLoc[4](loc2: u64)
	10: MoveLoc[0](Arg0: &StakingPool)
	11: ImmBorrowField[11](StakingPool.pool_token_balance: u64)
	12: ReadRef
	13: StLoc[2](loc0: u64)
	14: MoveLoc[4](loc2: u64)
	15: MoveLoc[2](loc0: u64)
	16: Eq
	17: BrFalse(19)
B1:
	18: Branch(21)
B2:
	19: LdConst[10](u64: 9)
	20: Abort
B3:
	21: Ret
}

public(friend) calculate_rewards(Arg0: &StakingPool, Arg1: &StakedSafe, Arg2: u64): u64 {
L3:	loc0: u64
L4:	loc1: PoolTokenExchangeRate
L5:	loc2: PoolTokenExchangeRate
L6:	loc3: u64
L7:	loc4: u64
L8:	loc5: u64
B0:
	0: CopyLoc[1](Arg1: &StakedSafe)
	1: Call staked_safe_amount(&StakedSafe): u64
	2: StLoc[7](loc4: u64)
	3: CopyLoc[0](Arg0: &StakingPool)
	4: MoveLoc[1](Arg1: &StakedSafe)
	5: ImmBorrowField[1](StakedSafe.stake_activation_epoch: u64)
	6: ReadRef
	7: Call pool_token_exchange_rate_at_epoch(&StakingPool, u64): PoolTokenExchangeRate
	8: StLoc[4](loc1: PoolTokenExchangeRate)
	9: ImmBorrowLoc[4](loc1: PoolTokenExchangeRate)
	10: CopyLoc[7](loc4: u64)
	11: Call get_token_amount(&PoolTokenExchangeRate, u64): u64
	12: StLoc[6](loc3: u64)
	13: CopyLoc[0](Arg0: &StakingPool)
	14: MoveLoc[2](Arg2: u64)
	15: Call pool_token_exchange_rate_at_epoch(&StakingPool, u64): PoolTokenExchangeRate
	16: StLoc[5](loc2: PoolTokenExchangeRate)
	17: ImmBorrowLoc[5](loc2: PoolTokenExchangeRate)
	18: MoveLoc[6](loc3: u64)
	19: Call get_safe_amount(&PoolTokenExchangeRate, u64): u64
	20: StLoc[8](loc5: u64)
	21: CopyLoc[8](loc5: u64)
	22: CopyLoc[7](loc4: u64)
	23: Ge
	24: BrFalse(30)
B1:
	25: MoveLoc[8](loc5: u64)
	26: MoveLoc[7](loc4: u64)
	27: Sub
	28: StLoc[3](loc0: u64)
	29: Branch(32)
B2:
	30: LdU64(0)
	31: StLoc[3](loc0: u64)
B3:
	32: MoveLoc[3](loc0: u64)
	33: MoveLoc[0](Arg0: &StakingPool)
	34: ImmBorrowField[7](StakingPool.rewards_pool: Balance<SAFE>)
	35: Call balance::value<SAFE>(&Balance<SAFE>): u64
	36: Call u64::min(u64, u64): u64
	37: Ret
}

Constants [
	0 => u64: 1000000000
	1 => u64: 0
	2 => u64: 1
	3 => u64: 2
	4 => u64: 3
	5 => u64: 4
	6 => u64: 5
	7 => u64: 6
	8 => u64: 7
	9 => u64: 8
	10 => u64: 9
	11 => u64: 10
	12 => u64: 11
	13 => u64: 12
	14 => u64: 13
	15 => u64: 14
	16 => u64: 15
	17 => u64: 16
	18 => u64: 17
	19 => u64: 18
	20 => u64: 19
	21 => u64: 20
]
}

// Move bytecode v6
module 3.storage_fund {
use 0000000000000000000000000000000000000000000000000000000000000002::balance;
use 0000000000000000000000000000000000000000000000000000000000000002::safe;

struct StorageFund has store {
	total_object_storage_rebates: Balance<SAFE>,
	non_refundable_balance: Balance<SAFE>
}

public(friend) new(Arg0: Balance<SAFE>): StorageFund {
B0:
	0: Call balance::zero<SAFE>(): Balance<SAFE>
	1: MoveLoc[0](Arg0: Balance<SAFE>)
	2: Pack[0](StorageFund)
	3: Ret
}

public(friend) advance_epoch(Arg0: &mut StorageFund, Arg1: Balance<SAFE>, Arg2: Balance<SAFE>, Arg3: Balance<SAFE>, Arg4: u64, Arg5: u64): Balance<SAFE> {
L6:	loc0: Balance<SAFE>
B0:
	0: CopyLoc[0](Arg0: &mut StorageFund)
	1: MutBorrowField[0](StorageFund.non_refundable_balance: Balance<SAFE>)
	2: MoveLoc[2](Arg2: Balance<SAFE>)
	3: Call balance::join<SAFE>(&mut Balance<SAFE>, Balance<SAFE>): u64
	4: Pop
	5: CopyLoc[0](Arg0: &mut StorageFund)
	6: MutBorrowField[0](StorageFund.non_refundable_balance: Balance<SAFE>)
	7: MoveLoc[3](Arg3: Balance<SAFE>)
	8: Call balance::join<SAFE>(&mut Balance<SAFE>, Balance<SAFE>): u64
	9: Pop
	10: CopyLoc[0](Arg0: &mut StorageFund)
	11: MutBorrowField[1](StorageFund.total_object_storage_rebates: Balance<SAFE>)
	12: MoveLoc[1](Arg1: Balance<SAFE>)
	13: Call balance::join<SAFE>(&mut Balance<SAFE>, Balance<SAFE>): u64
	14: Pop
	15: CopyLoc[0](Arg0: &mut StorageFund)
	16: MutBorrowField[1](StorageFund.total_object_storage_rebates: Balance<SAFE>)
	17: MoveLoc[5](Arg5: u64)
	18: Call balance::split<SAFE>(&mut Balance<SAFE>, u64): Balance<SAFE>
	19: StLoc[6](loc0: Balance<SAFE>)
	20: CopyLoc[0](Arg0: &mut StorageFund)
	21: MutBorrowField[0](StorageFund.non_refundable_balance: Balance<SAFE>)
	22: MoveLoc[6](loc0: Balance<SAFE>)
	23: Call balance::join<SAFE>(&mut Balance<SAFE>, Balance<SAFE>): u64
	24: Pop
	25: MoveLoc[0](Arg0: &mut StorageFund)
	26: MutBorrowField[1](StorageFund.total_object_storage_rebates: Balance<SAFE>)
	27: MoveLoc[4](Arg4: u64)
	28: Call balance::split<SAFE>(&mut Balance<SAFE>, u64): Balance<SAFE>
	29: Ret
}

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

public total_balance(Arg0: &StorageFund): u64 {
B0:
	0: CopyLoc[0](Arg0: &StorageFund)
	1: ImmBorrowField[1](StorageFund.total_object_storage_rebates: Balance<SAFE>)
	2: Call balance::value<SAFE>(&Balance<SAFE>): u64
	3: MoveLoc[0](Arg0: &StorageFund)
	4: ImmBorrowField[0](StorageFund.non_refundable_balance: Balance<SAFE>)
	5: Call balance::value<SAFE>(&Balance<SAFE>): u64
	6: Add
	7: Ret
}

}

// Move bytecode v6
module 3.validator {
use 0000000000000000000000000000000000000000000000000000000000000002::bag;
use 0000000000000000000000000000000000000000000000000000000000000002::balance;
use 0000000000000000000000000000000000000000000000000000000000000002::event;
use 0000000000000000000000000000000000000000000000000000000000000002::object;
use 0000000000000000000000000000000000000000000000000000000000000002::safe;
use 0000000000000000000000000000000000000000000000000000000000000002::transfer;
use 0000000000000000000000000000000000000000000000000000000000000002::tx_context;
use 0000000000000000000000000000000000000000000000000000000000000002::url;
use 0000000000000000000000000000000000000000000000000000000000000003::staking_pool;
use 0000000000000000000000000000000000000000000000000000000000000003::validator_cap;
use 0000000000000000000000000000000000000000000000000000000000000001::ascii;
use 0000000000000000000000000000000000000000000000000000000000000001::bcs;
use 0000000000000000000000000000000000000000000000000000000000000001::option;
use 0000000000000000000000000000000000000000000000000000000000000001::string;

struct ValidatorMetadata has store {
	safe_address: address,
	protocol_pubkey_bytes: vector<u8>,
	network_pubkey_bytes: vector<u8>,
	worker_pubkey_bytes: vector<u8>,
	proof_of_possession: vector<u8>,
	name: String,
	description: String,
	image_url: Url,
	project_url: Url,
	net_address: String,
	p2p_address: String,
	primary_address: String,
	worker_address: String,
	next_epoch_protocol_pubkey_bytes: Option<vector<u8>>,
	next_epoch_proof_of_possession: Option<vector<u8>>,
	next_epoch_network_pubkey_bytes: Option<vector<u8>>,
	next_epoch_worker_pubkey_bytes: Option<vector<u8>>,
	next_epoch_net_address: Option<String>,
	next_epoch_p2p_address: Option<String>,
	next_epoch_primary_address: Option<String>,
	next_epoch_worker_address: Option<String>,
	extra_fields: Bag
}

struct Validator has store {
	metadata: ValidatorMetadata,
	voting_power: u64,
	operation_cap_id: ID,
	gas_price: u64,
	staking_pool: StakingPool,
	commission_rate: u64,
	next_epoch_stake: u64,
	next_epoch_gas_price: u64,
	next_epoch_commission_rate: u64,
	extra_fields: Bag
}

struct StakingRequestEvent has copy, drop {
	pool_id: ID,
	validator_address: address,
	staker_address: address,
	epoch: u64,
	amount: u64
}

struct UnstakingRequestEvent has copy, drop {
	pool_id: ID,
	validator_address: address,
	staker_address: address,
	stake_activation_epoch: u64,
	unstaking_epoch: u64,
	principal_amount: u64,
	reward_amount: u64
}

struct ConvertingToFungibleStakedSafeEvent has copy, drop {
	pool_id: ID,
	stake_activation_epoch: u64,
	staked_safe_principal_amount: u64,
	fungible_staked_safe_amount: u64
}

struct RedeemingFungibleStakedSafeEvent has copy, drop {
	pool_id: ID,
	fungible_staked_safe_amount: u64,
	safe_amount: u64
}

public(friend) new_metadata(Arg0: address, Arg1: vector<u8>, Arg2: vector<u8>, Arg3: vector<u8>, Arg4: vector<u8>, Arg5: String, Arg6: String, Arg7: Url, Arg8: Url, Arg9: String, Arg10: String, Arg11: String, Arg12: String, Arg13: Bag): ValidatorMetadata {
L14:	loc0: address
L15:	loc1: String
L16:	loc2: String
L17:	loc3: String
L18:	loc4: String
L19:	loc5: Option<vector<u8>>
L20:	loc6: Option<vector<u8>>
L21:	loc7: Option<vector<u8>>
L22:	loc8: Option<vector<u8>>
L23:	loc9: Option<String>
L24:	loc10: Option<String>
L25:	loc11: vector<u8>
L26:	loc12: Option<String>
L27:	loc13: Option<String>
L28:	loc14: Bag
L29:	loc15: vector<u8>
L30:	loc16: vector<u8>
L31:	loc17: vector<u8>
L32:	loc18: String
L33:	loc19: String
L34:	loc20: Url
L35:	loc21: Url
B0:
	0: MoveLoc[0](Arg0: address)
	1: StLoc[14](loc0: address)
	2: MoveLoc[1](Arg1: vector<u8>)
	3: StLoc[25](loc11: vector<u8>)
	4: MoveLoc[2](Arg2: vector<u8>)
	5: StLoc[29](loc15: vector<u8>)
	6: MoveLoc[3](Arg3: vector<u8>)
	7: StLoc[30](loc16: vector<u8>)
	8: MoveLoc[4](Arg4: vector<u8>)
	9: StLoc[31](loc17: vector<u8>)
	10: MoveLoc[5](Arg5: String)
	11: StLoc[32](loc18: String)
	12: MoveLoc[6](Arg6: String)
	13: StLoc[33](loc19: String)
	14: MoveLoc[7](Arg7: Url)
	15: StLoc[34](loc20: Url)
	16: MoveLoc[8](Arg8: Url)
	17: StLoc[35](loc21: Url)
	18: MoveLoc[9](Arg9: String)
	19: StLoc[15](loc1: String)
	20: MoveLoc[10](Arg10: String)
	21: StLoc[16](loc2: String)
	22: MoveLoc[11](Arg11: String)
	23: StLoc[17](loc3: String)
	24: MoveLoc[12](Arg12: String)
	25: StLoc[18](loc4: String)
	26: Call option::none<vector<u8>>(): Option<vector<u8>>
	27: StLoc[19](loc5: Option<vector<u8>>)
	28: Call option::none<vector<u8>>(): Option<vector<u8>>
	29: StLoc[20](loc6: Option<vector<u8>>)
	30: Call option::none<vector<u8>>(): Option<vector<u8>>
	31: StLoc[21](loc7: Option<vector<u8>>)
	32: Call option::none<vector<u8>>(): Option<vector<u8>>
	33: StLoc[22](loc8: Option<vector<u8>>)
	34: Call option::none<String>(): Option<String>
	35: StLoc[23](loc9: Option<String>)
	36: Call option::none<String>(): Option<String>
	37: StLoc[24](loc10: Option<String>)
	38: Call option::none<String>(): Option<String>
	39: StLoc[26](loc12: Option<String>)
	40: Call option::none<String>(): Option<String>
	41: StLoc[27](loc13: Option<String>)
	42: MoveLoc[13](Arg13: Bag)
	43: StLoc[28](loc14: Bag)
	44: MoveLoc[14](loc0: address)
	45: MoveLoc[25](loc11: vector<u8>)
	46: MoveLoc[29](loc15: vector<u8>)
	47: MoveLoc[30](loc16: vector<u8>)
	48: MoveLoc[31](loc17: vector<u8>)
	49: MoveLoc[32](loc18: String)
	50: MoveLoc[33](loc19: String)
	51: MoveLoc[34](loc20: Url)
	52: MoveLoc[35](loc21: Url)
	53: MoveLoc[15](loc1: String)
	54: MoveLoc[16](loc2: String)
	55: MoveLoc[17](loc3: String)
	56: MoveLoc[18](loc4: String)
	57: MoveLoc[19](loc5: Option<vector<u8>>)
	58: MoveLoc[22](loc8: Option<vector<u8>>)
	59: MoveLoc[20](loc6: Option<vector<u8>>)
	60: MoveLoc[21](loc7: Option<vector<u8>>)
	61: MoveLoc[23](loc9: Option<String>)
	62: MoveLoc[24](loc10: Option<String>)
	63: MoveLoc[26](loc12: Option<String>)
	64: MoveLoc[27](loc13: Option<String>)
	65: MoveLoc[28](loc14: Bag)
	66: Pack[0](ValidatorMetadata)
	67: Ret
}

public(friend) new(Arg0: address, Arg1: vector<u8>, Arg2: vector<u8>, Arg3: vector<u8>, Arg4: vector<u8>, Arg5: vector<u8>, Arg6: vector<u8>, Arg7: vector<u8>, Arg8: vector<u8>, Arg9: vector<u8>, Arg10: vector<u8>, Arg11: vector<u8>, Arg12: vector<u8>, Arg13: u64, Arg14: u64, Arg15: &mut TxContext): Validator {
L16:	loc0: bool
L17:	loc1: ValidatorMetadata
B0:
	0: ImmBorrowLoc[9](Arg9: vector<u8>)
	1: VecLen(42)
	2: LdConst[17](u64: 256)
	3: Le
	4: BrFalse(59)
B1:
	5: ImmBorrowLoc[10](Arg10: vector<u8>)
	6: VecLen(42)
	7: LdConst[17](u64: 256)
	8: Le
	9: BrFalse(56)
B2:
	10: ImmBorrowLoc[11](Arg11: vector<u8>)
	11: VecLen(42)
	12: LdConst[17](u64: 256)
	13: Le
	14: BrFalse(53)
B3:
	15: ImmBorrowLoc[12](Arg12: vector<u8>)
	16: VecLen(42)
	17: LdConst[17](u64: 256)
	18: Le
	19: BrFalse(50)
B4:
	20: ImmBorrowLoc[5](Arg5: vector<u8>)
	21: VecLen(42)
	22: LdConst[17](u64: 256)
	23: Le
	24: BrFalse(47)
B5:
	25: ImmBorrowLoc[6](Arg6: vector<u8>)
	26: VecLen(42)
	27: LdConst[17](u64: 256)
	28: Le
	29: BrFalse(44)
B6:
	30: ImmBorrowLoc[7](Arg7: vector<u8>)
	31: VecLen(42)
	32: LdConst[17](u64: 256)
	33: Le
	34: BrFalse(41)
B7:
	35: ImmBorrowLoc[8](Arg8: vector<u8>)
	36: VecLen(42)
	37: LdConst[17](u64: 256)
	38: Le
	39: StLoc[16](loc0: bool)
	40: Branch(61)
B8:
	41: LdFalse
	42: StLoc[16](loc0: bool)
	43: Branch(61)
B9:
	44: LdFalse
	45: StLoc[16](loc0: bool)
	46: Branch(61)
B10:
	47: LdFalse
	48: StLoc[16](loc0: bool)
	49: Branch(61)
B11:
	50: LdFalse
	51: StLoc[16](loc0: bool)
	52: Branch(61)
B12:
	53: LdFalse
	54: StLoc[16](loc0: bool)
	55: Branch(61)
B13:
	56: LdFalse
	57: StLoc[16](loc0: bool)
	58: Branch(61)
B14:
	59: LdFalse
	60: StLoc[16](loc0: bool)
B15:
	61: MoveLoc[16](loc0: bool)
	62: BrFalse(64)
B16:
	63: Branch(68)
B17:
	64: MoveLoc[15](Arg15: &mut TxContext)
	65: Pop
	66: LdConst[9](u64: 9)
	67: Abort
B18:
	68: CopyLoc[14](Arg14: u64)
	69: LdConst[16](u64: 2000)
	70: Le
	71: BrFalse(73)
B19:
	72: Branch(77)
B20:
	73: MoveLoc[15](Arg15: &mut TxContext)
	74: Pop
	75: LdConst[8](u64: 8)
	76: Abort
B21:
	77: CopyLoc[13](Arg13: u64)
	78: LdConst[18](u64: 100000)
	79: Lt
	80: BrFalse(82)
B22:
	81: Branch(86)
B23:
	82: MoveLoc[15](Arg15: &mut TxContext)
	83: Pop
	84: LdConst[15](u64: 102)
	85: Abort
B24:
	86: MoveLoc[0](Arg0: address)
	87: MoveLoc[1](Arg1: vector<u8>)
	88: MoveLoc[2](Arg2: vector<u8>)
	89: MoveLoc[3](Arg3: vector<u8>)
	90: MoveLoc[4](Arg4: vector<u8>)
	91: MoveLoc[5](Arg5: vector<u8>)
	92: Call ascii::string(vector<u8>): String
	93: Call string::from_ascii(String): String
	94: MoveLoc[6](Arg6: vector<u8>)
	95: Call ascii::string(vector<u8>): String
	96: Call string::from_ascii(String): String
	97: MoveLoc[7](Arg7: vector<u8>)
	98: Call url::new_unsafe_from_bytes(vector<u8>): Url
	99: MoveLoc[8](Arg8: vector<u8>)
	100: Call url::new_unsafe_from_bytes(vector<u8>): Url
	101: MoveLoc[9](Arg9: vector<u8>)
	102: Call ascii::string(vector<u8>): String
	103: Call string::from_ascii(String): String
	104: MoveLoc[10](Arg10: vector<u8>)
	105: Call ascii::string(vector<u8>): String
	106: Call string::from_ascii(String): String
	107: MoveLoc[11](Arg11: vector<u8>)
	108: Call ascii::string(vector<u8>): String
	109: Call string::from_ascii(String): String
	110: MoveLoc[12](Arg12: vector<u8>)
	111: Call ascii::string(vector<u8>): String
	112: Call string::from_ascii(String): String
	113: CopyLoc[15](Arg15: &mut TxContext)
	114: Call bag::new(&mut TxContext): Bag
	115: Call new_metadata(address, vector<u8>, vector<u8>, vector<u8>, vector<u8>, String, String, Url, Url, String, String, String, String, Bag): ValidatorMetadata
	116: StLoc[17](loc1: ValidatorMetadata)
	117: ImmBorrowLoc[17](loc1: ValidatorMetadata)
	118: Call validate_metadata(&ValidatorMetadata)
	119: MoveLoc[17](loc1: ValidatorMetadata)
	120: MoveLoc[13](Arg13: u64)
	121: MoveLoc[14](Arg14: u64)
	122: MoveLoc[15](Arg15: &mut TxContext)
	123: Call new_from_metadata(ValidatorMetadata, u64, u64, &mut TxContext): Validator
	124: Ret
}

public(friend) deactivate(Arg0: &mut Validator, Arg1: u64) {
B0:
	0: MoveLoc[0](Arg0: &mut Validator)
	1: MutBorrowField[0](Validator.staking_pool: StakingPool)
	2: MoveLoc[1](Arg1: u64)
	3: Call staking_pool::deactivate_staking_pool(&mut StakingPool, u64)
	4: Ret
}

public(friend) activate(Arg0: &mut Validator, Arg1: u64) {
B0:
	0: MoveLoc[0](Arg0: &mut Validator)
	1: MutBorrowField[0](Validator.staking_pool: StakingPool)
	2: MoveLoc[1](Arg1: u64)
	3: Call staking_pool::activate_staking_pool(&mut StakingPool, u64)
	4: Ret
}

public(friend) adjust_stake_and_gas_price(Arg0: &mut Validator) {
B0:
	0: CopyLoc[0](Arg0: &mut Validator)
	1: ImmBorrowField[1](Validator.next_epoch_gas_price: u64)
	2: ReadRef
	3: CopyLoc[0](Arg0: &mut Validator)
	4: MutBorrowField[2](Validator.gas_price: u64)
	5: WriteRef
	6: CopyLoc[0](Arg0: &mut Validator)
	7: ImmBorrowField[3](Validator.next_epoch_commission_rate: u64)
	8: ReadRef
	9: MoveLoc[0](Arg0: &mut Validator)
	10: MutBorrowField[4](Validator.commission_rate: u64)
	11: WriteRef
	12: Ret
}

public(friend) request_add_stake(Arg0: &mut Validator, Arg1: Balance<SAFE>, Arg2: address, Arg3: &mut TxContext): StakedSafe {
L4:	loc0: u64
L5:	loc1: u64
L6:	loc2: StakedSafe
B0:
	0: ImmBorrowLoc[1](Arg1: Balance<SAFE>)
	1: Call balance::value<SAFE>(&Balance<SAFE>): u64
	2: StLoc[4](loc0: u64)
	3: CopyLoc[4](loc0: u64)
	4: LdU64(0)
	5: Gt
	6: BrFalse(8)
B1:
	7: Branch(14)
B2:
	8: MoveLoc[0](Arg0: &mut Validator)
	9: Pop
	10: MoveLoc[3](Arg3: &mut TxContext)
	11: Pop
	12: LdConst[11](u64: 11)
	13: Abort
B3:
	14: CopyLoc[3](Arg3: &mut TxContext)
	15: FreezeRef
	16: Call tx_context::epoch(&TxContext): u64
	17: LdU64(1)
	18: Add
	19: StLoc[5](loc1: u64)
	20: CopyLoc[0](Arg0: &mut Validator)
	21: MutBorrowField[0](Validator.staking_pool: StakingPool)
	22: MoveLoc[1](Arg1: Balance<SAFE>)
	23: MoveLoc[5](loc1: u64)
	24: CopyLoc[3](Arg3: &mut TxContext)
	25: Call staking_pool::request_add_stake(&mut StakingPool, Balance<SAFE>, u64, &mut TxContext): StakedSafe
	26: StLoc[6](loc2: StakedSafe)
	27: CopyLoc[0](Arg0: &mut Validator)
	28: ImmBorrowField[0](Validator.staking_pool: StakingPool)
	29: Call staking_pool::is_preactive(&StakingPool): bool
	30: BrFalse(34)
B4:
	31: CopyLoc[0](Arg0: &mut Validator)
	32: MutBorrowField[0](Validator.staking_pool: StakingPool)
	33: Call staking_pool::process_pending_stake(&mut StakingPool)
B5:
	34: CopyLoc[0](Arg0: &mut Validator)
	35: ImmBorrowField[5](Validator.next_epoch_stake: u64)
	36: ReadRef
	37: CopyLoc[4](loc0: u64)
	38: Add
	39: CopyLoc[0](Arg0: &mut Validator)
	40: MutBorrowField[5](Validator.next_epoch_stake: u64)
	41: WriteRef
	42: CopyLoc[0](Arg0: &mut Validator)
	43: FreezeRef
	44: Call staking_pool_id(&Validator): ID
	45: MoveLoc[0](Arg0: &mut Validator)
	46: ImmBorrowField[6](Validator.metadata: ValidatorMetadata)
	47: ImmBorrowField[7](ValidatorMetadata.safe_address: address)
	48: ReadRef
	49: MoveLoc[2](Arg2: address)
	50: MoveLoc[3](Arg3: &mut TxContext)
	51: FreezeRef
	52: Call tx_context::epoch(&TxContext): u64
	53: MoveLoc[4](loc0: u64)
	54: Pack[2](StakingRequestEvent)
	55: Call event::emit<StakingRequestEvent>(StakingRequestEvent)
	56: MoveLoc[6](loc2: StakedSafe)
	57: Ret
}

public(friend) convert_to_fungible_staked_safe(Arg0: &mut Validator, Arg1: StakedSafe, Arg2: &mut TxContext): FungibleStakedSafe {
L3:	loc0: FungibleStakedSafe
L4:	loc1: u64
L5:	loc2: u64
B0:
	0: ImmBorrowLoc[1](Arg1: StakedSafe)
	1: Call staking_pool::stake_activation_epoch(&StakedSafe): u64
	2: StLoc[4](loc1: u64)
	3: ImmBorrowLoc[1](Arg1: StakedSafe)
	4: Call staking_pool::staked_safe_amount(&StakedSafe): u64
	5: StLoc[5](loc2: u64)
	6: CopyLoc[0](Arg0: &mut Validator)
	7: MutBorrowField[0](Validator.staking_pool: StakingPool)
	8: MoveLoc[1](Arg1: StakedSafe)
	9: MoveLoc[2](Arg2: &mut TxContext)
	10: Call staking_pool::convert_to_fungible_staked_safe(&mut StakingPool, StakedSafe, &mut TxContext): FungibleStakedSafe
	11: StLoc[3](loc0: FungibleStakedSafe)
	12: MoveLoc[0](Arg0: &mut Validator)
	13: FreezeRef
	14: Call staking_pool_id(&Validator): ID
	15: MoveLoc[4](loc1: u64)
	16: MoveLoc[5](loc2: u64)
	17: ImmBorrowLoc[3](loc0: FungibleStakedSafe)
	18: Call staking_pool::fungible_staked_safe_value(&FungibleStakedSafe): u64
	19: Pack[4](ConvertingToFungibleStakedSafeEvent)
	20: Call event::emit<ConvertingToFungibleStakedSafeEvent>(ConvertingToFungibleStakedSafeEvent)
	21: MoveLoc[3](loc0: FungibleStakedSafe)
	22: Ret
}

public(friend) redeem_fungible_staked_safe(Arg0: &mut Validator, Arg1: FungibleStakedSafe, Arg2: &TxContext): Balance<SAFE> {
L3:	loc0: u64
L4:	loc1: Balance<SAFE>
B0:
	0: ImmBorrowLoc[1](Arg1: FungibleStakedSafe)
	1: Call staking_pool::fungible_staked_safe_value(&FungibleStakedSafe): u64
	2: StLoc[3](loc0: u64)
	3: CopyLoc[0](Arg0: &mut Validator)
	4: MutBorrowField[0](Validator.staking_pool: StakingPool)
	5: MoveLoc[1](Arg1: FungibleStakedSafe)
	6: MoveLoc[2](Arg2: &TxContext)
	7: Call staking_pool::redeem_fungible_staked_safe(&mut StakingPool, FungibleStakedSafe, &TxContext): Balance<SAFE>
	8: StLoc[4](loc1: Balance<SAFE>)
	9: CopyLoc[0](Arg0: &mut Validator)
	10: ImmBorrowField[5](Validator.next_epoch_stake: u64)
	11: ReadRef
	12: ImmBorrowLoc[4](loc1: Balance<SAFE>)
	13: Call balance::value<SAFE>(&Balance<SAFE>): u64
	14: Sub
	15: CopyLoc[0](Arg0: &mut Validator)
	16: MutBorrowField[5](Validator.next_epoch_stake: u64)
	17: WriteRef
	18: MoveLoc[0](Arg0: &mut Validator)
	19: FreezeRef
	20: Call staking_pool_id(&Validator): ID
	21: MoveLoc[3](loc0: u64)
	22: ImmBorrowLoc[4](loc1: Balance<SAFE>)
	23: Call balance::value<SAFE>(&Balance<SAFE>): u64
	24: Pack[5](RedeemingFungibleStakedSafeEvent)
	25: Call event::emit<RedeemingFungibleStakedSafeEvent>(RedeemingFungibleStakedSafeEvent)
	26: MoveLoc[4](loc1: Balance<SAFE>)
	27: Ret
}

public(friend) request_add_stake_at_genesis(Arg0: &mut Validator, Arg1: Balance<SAFE>, Arg2: address, Arg3: &mut TxContext) {
L4:	loc0: u64
B0:
	0: CopyLoc[3](Arg3: &mut TxContext)
	1: FreezeRef
	2: Call tx_context::epoch(&TxContext): u64
	3: LdU64(0)
	4: Eq
	5: BrFalse(7)
B1:
	6: Branch(13)
B2:
	7: MoveLoc[0](Arg0: &mut Validator)
	8: Pop
	9: MoveLoc[3](Arg3: &mut TxContext)
	10: Pop
	11: LdConst[12](u64: 12)
	12: Abort
B3:
	13: ImmBorrowLoc[1](Arg1: Balance<SAFE>)
	14: Call balance::value<SAFE>(&Balance<SAFE>): u64
	15: StLoc[4](loc0: u64)
	16: CopyLoc[4](loc0: u64)
	17: LdU64(0)
	18: Gt
	19: BrFalse(21)
B4:
	20: Branch(27)
B5:
	21: MoveLoc[0](Arg0: &mut Validator)
	22: Pop
	23: MoveLoc[3](Arg3: &mut TxContext)
	24: Pop
	25: LdConst[11](u64: 11)
	26: Abort
B6:
	27: CopyLoc[0](Arg0: &mut Validator)
	28: MutBorrowField[0](Validator.staking_pool: StakingPool)
	29: MoveLoc[1](Arg1: Balance<SAFE>)
	30: LdU64(0)
	31: MoveLoc[3](Arg3: &mut TxContext)
	32: Call staking_pool::request_add_stake(&mut StakingPool, Balance<SAFE>, u64, &mut TxContext): StakedSafe
	33: MoveLoc[2](Arg2: address)
	34: Call transfer::public_transfer<StakedSafe>(StakedSafe, address)
	35: CopyLoc[0](Arg0: &mut Validator)
	36: MutBorrowField[0](Validator.staking_pool: StakingPool)
	37: Call staking_pool::process_pending_stake(&mut StakingPool)
	38: CopyLoc[0](Arg0: &mut Validator)
	39: ImmBorrowField[5](Validator.next_epoch_stake: u64)
	40: ReadRef
	41: MoveLoc[4](loc0: u64)
	42: Add
	43: MoveLoc[0](Arg0: &mut Validator)
	44: MutBorrowField[5](Validator.next_epoch_stake: u64)
	45: WriteRef
	46: Ret
}

public(friend) request_withdraw_stake(Arg0: &mut Validator, Arg1: StakedSafe, Arg2: &TxContext): Balance<SAFE> {
L3:	loc0: u64
L4:	loc1: u64
L5:	loc2: u64
L6:	loc3: u64
L7:	loc4: Balance<SAFE>
B0:
	0: ImmBorrowLoc[1](Arg1: StakedSafe)
	1: Call staking_pool::staked_safe_amount(&StakedSafe): u64
	2: StLoc[3](loc0: u64)
	3: ImmBorrowLoc[1](Arg1: StakedSafe)
	4: Call staking_pool::stake_activation_epoch(&StakedSafe): u64
	5: StLoc[5](loc2: u64)
	6: CopyLoc[0](Arg0: &mut Validator)
	7: MutBorrowField[0](Validator.staking_pool: StakingPool)
	8: MoveLoc[1](Arg1: StakedSafe)
	9: CopyLoc[2](Arg2: &TxContext)
	10: Call staking_pool::request_withdraw_stake(&mut StakingPool, StakedSafe, &TxContext): Balance<SAFE>
	11: StLoc[7](loc4: Balance<SAFE>)
	12: ImmBorrowLoc[7](loc4: Balance<SAFE>)
	13: Call balance::value<SAFE>(&Balance<SAFE>): u64
	14: StLoc[6](loc3: u64)
	15: CopyLoc[6](loc3: u64)
	16: CopyLoc[3](loc0: u64)
	17: Sub
	18: StLoc[4](loc1: u64)
	19: CopyLoc[0](Arg0: &mut Validator)
	20: ImmBorrowField[5](Validator.next_epoch_stake: u64)
	21: ReadRef
	22: MoveLoc[6](loc3: u64)
	23: Sub
	24: CopyLoc[0](Arg0: &mut Validator)
	25: MutBorrowField[5](Validator.next_epoch_stake: u64)
	26: WriteRef
	27: CopyLoc[0](Arg0: &mut Validator)
	28: FreezeRef
	29: Call staking_pool_id(&Validator): ID
	30: MoveLoc[0](Arg0: &mut Validator)
	31: ImmBorrowField[6](Validator.metadata: ValidatorMetadata)
	32: ImmBorrowField[7](ValidatorMetadata.safe_address: address)
	33: ReadRef
	34: CopyLoc[2](Arg2: &TxContext)
	35: Call tx_context::sender(&TxContext): address
	36: MoveLoc[5](loc2: u64)
	37: MoveLoc[2](Arg2: &TxContext)
	38: Call tx_context::epoch(&TxContext): u64
	39: MoveLoc[3](loc0: u64)
	40: MoveLoc[4](loc1: u64)
	41: Pack[3](UnstakingRequestEvent)
	42: Call event::emit<UnstakingRequestEvent>(UnstakingRequestEvent)
	43: MoveLoc[7](loc4: Balance<SAFE>)
	44: Ret
}

public(friend) request_set_gas_price(Arg0: &mut Validator, Arg1: ValidatorOperationCap, Arg2: u64) {
B0:
	0: CopyLoc[2](Arg2: u64)
	1: LdConst[18](u64: 100000)
	2: Lt
	3: BrFalse(5)
B1:
	4: Branch(9)
B2:
	5: MoveLoc[0](Arg0: &mut Validator)
	6: Pop
	7: LdConst[15](u64: 102)
	8: Abort
B3:
	9: ImmBorrowLoc[1](Arg1: ValidatorOperationCap)
	10: Call validator_cap::verified_operation_cap_address(&ValidatorOperationCap): &address
	11: ReadRef
	12: CopyLoc[0](Arg0: &mut Validator)
	13: ImmBorrowField[6](Validator.metadata: ValidatorMetadata)
	14: ImmBorrowField[7](ValidatorMetadata.safe_address: address)
	15: ReadRef
	16: Eq
	17: BrFalse(19)
B4:
	18: Branch(23)
B5:
	19: MoveLoc[0](Arg0: &mut Validator)
	20: Pop
	21: LdConst[14](u64: 101)
	22: Abort
B6:
	23: MoveLoc[2](Arg2: u64)
	24: MoveLoc[0](Arg0: &mut Validator)
	25: MutBorrowField[1](Validator.next_epoch_gas_price: u64)
	26: WriteRef
	27: Ret
}

public(friend) set_candidate_gas_price(Arg0: &mut Validator, Arg1: ValidatorOperationCap, Arg2: u64) {
B0:
	0: CopyLoc[0](Arg0: &mut Validator)
	1: FreezeRef
	2: Call is_preactive(&Validator): bool
	3: BrFalse(5)
B1:
	4: Branch(9)
B2:
	5: MoveLoc[0](Arg0: &mut Validator)
	6: Pop
	7: LdConst[10](u64: 10)
	8: Abort
B3:
	9: CopyLoc[2](Arg2: u64)
	10: LdConst[18](u64: 100000)
	11: Lt
	12: BrFalse(14)
B4:
	13: Branch(18)
B5:
	14: MoveLoc[0](Arg0: &mut Validator)
	15: Pop
	16: LdConst[15](u64: 102)
	17: Abort
B6:
	18: ImmBorrowLoc[1](Arg1: ValidatorOperationCap)
	19: Call validator_cap::verified_operation_cap_address(&ValidatorOperationCap): &address
	20: ReadRef
	21: CopyLoc[0](Arg0: &mut Validator)
	22: ImmBorrowField[6](Validator.metadata: ValidatorMetadata)
	23: ImmBorrowField[7](ValidatorMetadata.safe_address: address)
	24: ReadRef
	25: Eq
	26: BrFalse(28)
B7:
	27: Branch(32)
B8:
	28: MoveLoc[0](Arg0: &mut Validator)
	29: Pop
	30: LdConst[14](u64: 101)
	31: Abort
B9:
	32: CopyLoc[2](Arg2: u64)
	33: CopyLoc[0](Arg0: &mut Validator)
	34: MutBorrowField[1](Validator.next_epoch_gas_price: u64)
	35: WriteRef
	36: MoveLoc[2](Arg2: u64)
	37: MoveLoc[0](Arg0: &mut Validator)
	38: MutBorrowField[2](Validator.gas_price: u64)
	39: WriteRef
	40: Ret
}

public(friend) request_set_commission_rate(Arg0: &mut Validator, Arg1: u64) {
B0:
	0: CopyLoc[1](Arg1: u64)
	1: LdConst[16](u64: 2000)
	2: Le
	3: BrFalse(5)
B1:
	4: Branch(9)
B2:
	5: MoveLoc[0](Arg0: &mut Validator)
	6: Pop
	7: LdConst[8](u64: 8)
	8: Abort
B3:
	9: MoveLoc[1](Arg1: u64)
	10: MoveLoc[0](Arg0: &mut Validator)
	11: MutBorrowField[3](Validator.next_epoch_commission_rate: u64)
	12: WriteRef
	13: Ret
}

public(friend) set_candidate_commission_rate(Arg0: &mut Validator, Arg1: u64) {
B0:
	0: CopyLoc[0](Arg0: &mut Validator)
	1: FreezeRef
	2: Call is_preactive(&Validator): bool
	3: BrFalse(5)
B1:
	4: Branch(9)
B2:
	5: MoveLoc[0](Arg0: &mut Validator)
	6: Pop
	7: LdConst[10](u64: 10)
	8: Abort
B3:
	9: CopyLoc[1](Arg1: u64)
	10: LdConst[16](u64: 2000)
	11: Le
	12: BrFalse(14)
B4:
	13: Branch(18)
B5:
	14: MoveLoc[0](Arg0: &mut Validator)
	15: Pop
	16: LdConst[8](u64: 8)
	17: Abort
B6:
	18: MoveLoc[1](Arg1: u64)
	19: MoveLoc[0](Arg0: &mut Validator)
	20: MutBorrowField[4](Validator.commission_rate: u64)
	21: WriteRef
	22: Ret
}

public(friend) deposit_stake_rewards(Arg0: &mut Validator, Arg1: Balance<SAFE>) {
B0:
	0: CopyLoc[0](Arg0: &mut Validator)
	1: ImmBorrowField[5](Validator.next_epoch_stake: u64)
	2: ReadRef
	3: ImmBorrowLoc[1](Arg1: Balance<SAFE>)
	4: Call balance::value<SAFE>(&Balance<SAFE>): u64
	5: Add
	6: CopyLoc[0](Arg0: &mut Validator)
	7: MutBorrowField[5](Validator.next_epoch_stake: u64)
	8: WriteRef
	9: MoveLoc[0](Arg0: &mut Validator)
	10: MutBorrowField[0](Validator.staking_pool: StakingPool)
	11: MoveLoc[1](Arg1: Balance<SAFE>)
	12: Call staking_pool::deposit_rewards(&mut StakingPool, Balance<SAFE>)
	13: Ret
}

public(friend) process_pending_stakes_and_withdraws(Arg0: &mut Validator, Arg1: &TxContext) {
B0:
	0: MoveLoc[0](Arg0: &mut Validator)
	1: MutBorrowField[0](Validator.staking_pool: StakingPool)
	2: MoveLoc[1](Arg1: &TxContext)
	3: Call staking_pool::process_pending_stakes_and_withdraws(&mut StakingPool, &TxContext)
	4: Ret
}

public is_preactive(Arg0: &Validator): bool {
B0:
	0: MoveLoc[0](Arg0: &Validator)
	1: ImmBorrowField[0](Validator.staking_pool: StakingPool)
	2: Call staking_pool::is_preactive(&StakingPool): bool
	3: Ret
}

public metadata(Arg0: &Validator): &ValidatorMetadata {
B0:
	0: MoveLoc[0](Arg0: &Validator)
	1: ImmBorrowField[6](Validator.metadata: ValidatorMetadata)
	2: Ret
}

public safe_address(Arg0: &Validator): address {
B0:
	0: MoveLoc[0](Arg0: &Validator)
	1: ImmBorrowField[6](Validator.metadata: ValidatorMetadata)
	2: ImmBorrowField[7](ValidatorMetadata.safe_address: address)
	3: ReadRef
	4: Ret
}

public name(Arg0: &Validator): &String {
B0:
	0: MoveLoc[0](Arg0: &Validator)
	1: ImmBorrowField[6](Validator.metadata: ValidatorMetadata)
	2: ImmBorrowField[8](ValidatorMetadata.name: String)
	3: Ret
}

public description(Arg0: &Validator): &String {
B0:
	0: MoveLoc[0](Arg0: &Validator)
	1: ImmBorrowField[6](Validator.metadata: ValidatorMetadata)
	2: ImmBorrowField[9](ValidatorMetadata.description: String)
	3: Ret
}

public image_url(Arg0: &Validator): &Url {
B0:
	0: MoveLoc[0](Arg0: &Validator)
	1: ImmBorrowField[6](Validator.metadata: ValidatorMetadata)
	2: ImmBorrowField[10](ValidatorMetadata.image_url: Url)
	3: Ret
}

public project_url(Arg0: &Validator): &Url {
B0:
	0: MoveLoc[0](Arg0: &Validator)
	1: ImmBorrowField[6](Validator.metadata: ValidatorMetadata)
	2: ImmBorrowField[11](ValidatorMetadata.project_url: Url)
	3: Ret
}

public network_address(Arg0: &Validator): &String {
B0:
	0: MoveLoc[0](Arg0: &Validator)
	1: ImmBorrowField[6](Validator.metadata: ValidatorMetadata)
	2: ImmBorrowField[12](ValidatorMetadata.net_address: String)
	3: Ret
}

public p2p_address(Arg0: &Validator): &String {
B0:
	0: MoveLoc[0](Arg0: &Validator)
	1: ImmBorrowField[6](Validator.metadata: ValidatorMetadata)
	2: ImmBorrowField[13](ValidatorMetadata.p2p_address: String)
	3: Ret
}

public primary_address(Arg0: &Validator): &String {
B0:
	0: MoveLoc[0](Arg0: &Validator)
	1: ImmBorrowField[6](Validator.metadata: ValidatorMetadata)
	2: ImmBorrowField[14](ValidatorMetadata.primary_address: String)
	3: Ret
}

public worker_address(Arg0: &Validator): &String {
B0:
	0: MoveLoc[0](Arg0: &Validator)
	1: ImmBorrowField[6](Validator.metadata: ValidatorMetadata)
	2: ImmBorrowField[15](ValidatorMetadata.worker_address: String)
	3: Ret
}

public protocol_pubkey_bytes(Arg0: &Validator): &vector<u8> {
B0:
	0: MoveLoc[0](Arg0: &Validator)
	1: ImmBorrowField[6](Validator.metadata: ValidatorMetadata)
	2: ImmBorrowField[16](ValidatorMetadata.protocol_pubkey_bytes: vector<u8>)
	3: Ret
}

public proof_of_possession(Arg0: &Validator): &vector<u8> {
B0:
	0: MoveLoc[0](Arg0: &Validator)
	1: ImmBorrowField[6](Validator.metadata: ValidatorMetadata)
	2: ImmBorrowField[17](ValidatorMetadata.proof_of_possession: vector<u8>)
	3: Ret
}

public network_pubkey_bytes(Arg0: &Validator): &vector<u8> {
B0:
	0: MoveLoc[0](Arg0: &Validator)
	1: ImmBorrowField[6](Validator.metadata: ValidatorMetadata)
	2: ImmBorrowField[18](ValidatorMetadata.network_pubkey_bytes: vector<u8>)
	3: Ret
}

public worker_pubkey_bytes(Arg0: &Validator): &vector<u8> {
B0:
	0: MoveLoc[0](Arg0: &Validator)
	1: ImmBorrowField[6](Validator.metadata: ValidatorMetadata)
	2: ImmBorrowField[19](ValidatorMetadata.worker_pubkey_bytes: vector<u8>)
	3: Ret
}

public next_epoch_network_address(Arg0: &Validator): &Option<String> {
B0:
	0: MoveLoc[0](Arg0: &Validator)
	1: ImmBorrowField[6](Validator.metadata: ValidatorMetadata)
	2: ImmBorrowField[20](ValidatorMetadata.next_epoch_net_address: Option<String>)
	3: Ret
}

public next_epoch_p2p_address(Arg0: &Validator): &Option<String> {
B0:
	0: MoveLoc[0](Arg0: &Validator)
	1: ImmBorrowField[6](Validator.metadata: ValidatorMetadata)
	2: ImmBorrowField[21](ValidatorMetadata.next_epoch_p2p_address: Option<String>)
	3: Ret
}

public next_epoch_primary_address(Arg0: &Validator): &Option<String> {
B0:
	0: MoveLoc[0](Arg0: &Validator)
	1: ImmBorrowField[6](Validator.metadata: ValidatorMetadata)
	2: ImmBorrowField[22](ValidatorMetadata.next_epoch_primary_address: Option<String>)
	3: Ret
}

public next_epoch_worker_address(Arg0: &Validator): &Option<String> {
B0:
	0: MoveLoc[0](Arg0: &Validator)
	1: ImmBorrowField[6](Validator.metadata: ValidatorMetadata)
	2: ImmBorrowField[23](ValidatorMetadata.next_epoch_worker_address: Option<String>)
	3: Ret
}

public next_epoch_protocol_pubkey_bytes(Arg0: &Validator): &Option<vector<u8>> {
B0:
	0: MoveLoc[0](Arg0: &Validator)
	1: ImmBorrowField[6](Validator.metadata: ValidatorMetadata)
	2: ImmBorrowField[24](ValidatorMetadata.next_epoch_protocol_pubkey_bytes: Option<vector<u8>>)
	3: Ret
}

public next_epoch_proof_of_possession(Arg0: &Validator): &Option<vector<u8>> {
B0:
	0: MoveLoc[0](Arg0: &Validator)
	1: ImmBorrowField[6](Validator.metadata: ValidatorMetadata)
	2: ImmBorrowField[25](ValidatorMetadata.next_epoch_proof_of_possession: Option<vector<u8>>)
	3: Ret
}

public next_epoch_network_pubkey_bytes(Arg0: &Validator): &Option<vector<u8>> {
B0:
	0: MoveLoc[0](Arg0: &Validator)
	1: ImmBorrowField[6](Validator.metadata: ValidatorMetadata)
	2: ImmBorrowField[26](ValidatorMetadata.next_epoch_network_pubkey_bytes: Option<vector<u8>>)
	3: Ret
}

public next_epoch_worker_pubkey_bytes(Arg0: &Validator): &Option<vector<u8>> {
B0:
	0: MoveLoc[0](Arg0: &Validator)
	1: ImmBorrowField[6](Validator.metadata: ValidatorMetadata)
	2: ImmBorrowField[27](ValidatorMetadata.next_epoch_worker_pubkey_bytes: Option<vector<u8>>)
	3: Ret
}

public operation_cap_id(Arg0: &Validator): &ID {
B0:
	0: MoveLoc[0](Arg0: &Validator)
	1: ImmBorrowField[28](Validator.operation_cap_id: ID)
	2: Ret
}

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

public total_stake_amount(Arg0: &Validator): u64 {
B0:
	0: MoveLoc[0](Arg0: &Validator)
	1: ImmBorrowField[0](Validator.staking_pool: StakingPool)
	2: Call staking_pool::safe_balance(&StakingPool): u64
	3: Ret
}

public stake_amount(Arg0: &Validator): u64 {
B0:
	0: MoveLoc[0](Arg0: &Validator)
	1: ImmBorrowField[0](Validator.staking_pool: StakingPool)
	2: Call staking_pool::safe_balance(&StakingPool): u64
	3: Ret
}

public total_stake(Arg0: &Validator): u64 {
B0:
	0: MoveLoc[0](Arg0: &Validator)
	1: ImmBorrowField[0](Validator.staking_pool: StakingPool)
	2: Call staking_pool::safe_balance(&StakingPool): u64
	3: Ret
}

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

public(friend) set_voting_power(Arg0: &mut Validator, Arg1: u64) {
B0:
	0: MoveLoc[1](Arg1: u64)
	1: MoveLoc[0](Arg0: &mut Validator)
	2: MutBorrowField[29](Validator.voting_power: u64)
	3: WriteRef
	4: Ret
}

public pending_stake_amount(Arg0: &Validator): u64 {
B0:
	0: MoveLoc[0](Arg0: &Validator)
	1: ImmBorrowField[0](Validator.staking_pool: StakingPool)
	2: Call staking_pool::pending_stake_amount(&StakingPool): u64
	3: Ret
}

public pending_stake_withdraw_amount(Arg0: &Validator): u64 {
B0:
	0: MoveLoc[0](Arg0: &Validator)
	1: ImmBorrowField[0](Validator.staking_pool: StakingPool)
	2: Call staking_pool::pending_stake_withdraw_amount(&StakingPool): u64
	3: Ret
}

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

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

public pool_token_exchange_rate_at_epoch(Arg0: &Validator, Arg1: u64): PoolTokenExchangeRate {
B0:
	0: MoveLoc[0](Arg0: &Validator)
	1: ImmBorrowField[0](Validator.staking_pool: StakingPool)
	2: MoveLoc[1](Arg1: u64)
	3: Call staking_pool::pool_token_exchange_rate_at_epoch(&StakingPool, u64): PoolTokenExchangeRate
	4: Ret
}

public staking_pool_id(Arg0: &Validator): ID {
B0:
	0: MoveLoc[0](Arg0: &Validator)
	1: ImmBorrowField[0](Validator.staking_pool: StakingPool)
	2: Call object::id<StakingPool>(&StakingPool): ID
	3: Ret
}

public is_duplicate(Arg0: &Validator, Arg1: &Validator): bool {
L2:	loc0: bool
L3:	loc1: vector<u8>
L4:	loc2: bool
L5:	loc3: bool
L6:	loc4: bool
L7:	loc5: &vector<u8>
L8:	loc6: bool
L9:	loc7: bool
L10:	loc8: bool
L11:	loc9: bool
L12:	loc10: vector<u8>
L13:	loc11: &vector<u8>
L14:	loc12: bool
L15:	loc13: vector<u8>
L16:	loc14: &vector<u8>
L17:	loc15: bool
L18:	loc16: vector<u8>
L19:	loc17: &vector<u8>
L20:	loc18: bool
L21:	loc19: bool
L22:	loc20: String
L23:	loc21: &String
L24:	loc22: bool
L25:	loc23: String
L26:	loc24: &String
L27:	loc25: bool
L28:	loc26: vector<u8>
L29:	loc27: &vector<u8>
L30:	loc28: bool
L31:	loc29: vector<u8>
L32:	loc30: &vector<u8>
L33:	loc31: bool
L34:	loc32: vector<u8>
L35:	loc33: vector<u8>
L36:	loc34: &vector<u8>
L37:	loc35: bool
L38:	loc36: vector<u8>
L39:	loc37: &vector<u8>
L40:	loc38: bool
L41:	loc39: &vector<u8>
L42:	loc40: vector<u8>
L43:	loc41: &vector<u8>
L44:	loc42: bool
L45:	loc43: String
L46:	loc44: &String
L47:	loc45: bool
L48:	loc46: String
L49:	loc47: &String
L50:	loc48: bool
L51:	loc49: bool
L52:	loc50: bool
L53:	loc51: bool
L54:	loc52: bool
L55:	loc53: bool
L56:	loc54: bool
L57:	loc55: bool
L58:	loc56: bool
L59:	loc57: Option<String>
L60:	loc58: Option<vector<u8>>
L61:	loc59: Option<vector<u8>>
L62:	loc60: Option<vector<u8>>
L63:	loc61: Option<vector<u8>>
L64:	loc62: Option<vector<u8>>
L65:	loc63: Option<String>
L66:	loc64: &String
L67:	loc65: &vector<u8>
L68:	loc66: &vector<u8>
L69:	loc67: &vector<u8>
L70:	loc68: &vector<u8>
L71:	loc69: &vector<u8>
L72:	loc70: &String
L73:	loc71: Option<String>
L74:	loc72: Option<vector<u8>>
L75:	loc73: Option<vector<u8>>
L76:	loc74: Option<vector<u8>>
L77:	loc75: Option<vector<u8>>
L78:	loc76: Option<vector<u8>>
L79:	loc77: Option<String>
L80:	loc78: &String
L81:	loc79: &vector<u8>
L82:	loc80: &vector<u8>
L83:	loc81: &vector<u8>
L84:	loc82: &vector<u8>
L85:	loc83: &vector<u8>
L86:	loc84: &String
L87:	loc85: &Option<String>
L88:	loc86: &Option<String>
L89:	loc87: &Option<vector<u8>>
L90:	loc88: &Option<vector<u8>>
L91:	loc89: &Option<vector<u8>>
L92:	loc90: &Option<vector<u8>>
L93:	loc91: &Option<vector<u8>>
L94:	loc92: &Option<vector<u8>>
L95:	loc93: &Option<vector<u8>>
L96:	loc94: &Option<String>
L97:	loc95: &Option<vector<u8>>
L98:	loc96: &Option<vector<u8>>
L99:	loc97: &Option<vector<u8>>
L100:	loc98: &Option<String>
L101:	loc99: &Option<String>
L102:	loc100: &Option<vector<u8>>
L103:	loc101: &Option<vector<u8>>
L104:	loc102: &Option<vector<u8>>
L105:	loc103: &Option<String>
L106:	loc104: &Option<vector<u8>>
L107:	loc105: &Option<vector<u8>>
L108:	loc106: &Option<String>
L109:	loc107: &Option<String>
L110:	loc108: &Option<vector<u8>>
L111:	loc109: &Option<vector<u8>>
L112:	loc110: &Option<vector<u8>>
L113:	loc111: &Option<vector<u8>>
L114:	loc112: &Option<vector<u8>>
L115:	loc113: &ValidatorMetadata
L116:	loc114: &ValidatorMetadata
B0:
	0: MoveLoc[0](Arg0: &Validator)
	1: ImmBorrowField[6](Validator.metadata: ValidatorMetadata)
	2: StLoc[116](loc114: &ValidatorMetadata)
	3: MoveLoc[1](Arg1: &Validator)
	4: ImmBorrowField[6](Validator.metadata: ValidatorMetadata)
	5: StLoc[115](loc113: &ValidatorMetadata)
	6: CopyLoc[116](loc114: &ValidatorMetadata)
	7: ImmBorrowField[7](ValidatorMetadata.safe_address: address)
	8: ReadRef
	9: CopyLoc[115](loc113: &ValidatorMetadata)
	10: ImmBorrowField[7](ValidatorMetadata.safe_address: address)
	11: ReadRef
	12: Eq
	13: BrFalse(21)
B1:
	14: MoveLoc[116](loc114: &ValidatorMetadata)
	15: Pop
	16: MoveLoc[115](loc113: &ValidatorMetadata)
	17: Pop
	18: LdTrue
	19: StLoc[2](loc0: bool)
	20: Branch(927)
B2:
	21: CopyLoc[116](loc114: &ValidatorMetadata)
	22: ImmBorrowField[8](ValidatorMetadata.name: String)
	23: ReadRef
	24: CopyLoc[115](loc113: &ValidatorMetadata)
	25: ImmBorrowField[8](ValidatorMetadata.name: String)
	26: ReadRef
	27: Eq
	28: BrFalse(36)
B3:
	29: MoveLoc[116](loc114: &ValidatorMetadata)
	30: Pop
	31: MoveLoc[115](loc113: &ValidatorMetadata)
	32: Pop
	33: LdTrue
	34: StLoc[2](loc0: bool)
	35: Branch(927)
B4:
	36: CopyLoc[116](loc114: &ValidatorMetadata)
	37: ImmBorrowField[12](ValidatorMetadata.net_address: String)
	38: ReadRef
	39: CopyLoc[115](loc113: &ValidatorMetadata)
	40: ImmBorrowField[12](ValidatorMetadata.net_address: String)
	41: ReadRef
	42: Eq
	43: BrFalse(51)
B5:
	44: MoveLoc[116](loc114: &ValidatorMetadata)
	45: Pop
	46: MoveLoc[115](loc113: &ValidatorMetadata)
	47: Pop
	48: LdTrue
	49: StLoc[2](loc0: bool)
	50: Branch(927)
B6:
	51: CopyLoc[116](loc114: &ValidatorMetadata)
	52: ImmBorrowField[13](ValidatorMetadata.p2p_address: String)
	53: ReadRef
	54: CopyLoc[115](loc113: &ValidatorMetadata)
	55: ImmBorrowField[13](ValidatorMetadata.p2p_address: String)
	56: ReadRef
	57: Eq
	58: BrFalse(66)
B7:
	59: MoveLoc[116](loc114: &ValidatorMetadata)
	60: Pop
	61: MoveLoc[115](loc113: &ValidatorMetadata)
	62: Pop
	63: LdTrue
	64: StLoc[2](loc0: bool)
	65: Branch(927)
B8:
	66: CopyLoc[116](loc114: &ValidatorMetadata)
	67: ImmBorrowField[16](ValidatorMetadata.protocol_pubkey_bytes: vector<u8>)
	68: ReadRef
	69: CopyLoc[115](loc113: &ValidatorMetadata)
	70: ImmBorrowField[16](ValidatorMetadata.protocol_pubkey_bytes: vector<u8>)
	71: ReadRef
	72: Eq
	73: BrFalse(81)
B9:
	74: MoveLoc[116](loc114: &ValidatorMetadata)
	75: Pop
	76: MoveLoc[115](loc113: &ValidatorMetadata)
	77: Pop
	78: LdTrue
	79: StLoc[2](loc0: bool)
	80: Branch(927)
B10:
	81: CopyLoc[116](loc114: &ValidatorMetadata)
	82: ImmBorrowField[18](ValidatorMetadata.network_pubkey_bytes: vector<u8>)
	83: ReadRef
	84: CopyLoc[115](loc113: &ValidatorMetadata)
	85: ImmBorrowField[18](ValidatorMetadata.network_pubkey_bytes: vector<u8>)
	86: ReadRef
	87: Eq
	88: BrFalse(96)
B11:
	89: MoveLoc[116](loc114: &ValidatorMetadata)
	90: Pop
	91: MoveLoc[115](loc113: &ValidatorMetadata)
	92: Pop
	93: LdTrue
	94: StLoc[2](loc0: bool)
	95: Branch(927)
B12:
	96: CopyLoc[116](loc114: &ValidatorMetadata)
	97: ImmBorrowField[18](ValidatorMetadata.network_pubkey_bytes: vector<u8>)
	98: ReadRef
	99: CopyLoc[115](loc113: &ValidatorMetadata)
	100: ImmBorrowField[19](ValidatorMetadata.worker_pubkey_bytes: vector<u8>)
	101: ReadRef
	102: Eq
	103: BrFalse(111)
B13:
	104: MoveLoc[116](loc114: &ValidatorMetadata)
	105: Pop
	106: MoveLoc[115](loc113: &ValidatorMetadata)
	107: Pop
	108: LdTrue
	109: StLoc[2](loc0: bool)
	110: Branch(927)
B14:
	111: CopyLoc[116](loc114: &ValidatorMetadata)
	112: ImmBorrowField[19](ValidatorMetadata.worker_pubkey_bytes: vector<u8>)
	113: ReadRef
	114: CopyLoc[115](loc113: &ValidatorMetadata)
	115: ImmBorrowField[19](ValidatorMetadata.worker_pubkey_bytes: vector<u8>)
	116: ReadRef
	117: Eq
	118: BrFalse(126)
B15:
	119: MoveLoc[116](loc114: &ValidatorMetadata)
	120: Pop
	121: MoveLoc[115](loc113: &ValidatorMetadata)
	122: Pop
	123: LdTrue
	124: StLoc[2](loc0: bool)
	125: Branch(927)
B16:
	126: CopyLoc[116](loc114: &ValidatorMetadata)
	127: ImmBorrowField[19](ValidatorMetadata.worker_pubkey_bytes: vector<u8>)
	128: ReadRef
	129: CopyLoc[115](loc113: &ValidatorMetadata)
	130: ImmBorrowField[18](ValidatorMetadata.network_pubkey_bytes: vector<u8>)
	131: ReadRef
	132: Eq
	133: BrFalse(141)
B17:
	134: MoveLoc[116](loc114: &ValidatorMetadata)
	135: Pop
	136: MoveLoc[115](loc113: &ValidatorMetadata)
	137: Pop
	138: LdTrue
	139: StLoc[2](loc0: bool)
	140: Branch(927)
B18:
	141: CopyLoc[116](loc114: &ValidatorMetadata)
	142: ImmBorrowField[20](ValidatorMetadata.next_epoch_net_address: Option<String>)
	143: ReadRef
	144: CopyLoc[115](loc113: &ValidatorMetadata)
	145: ImmBorrowField[20](ValidatorMetadata.next_epoch_net_address: Option<String>)
	146: ReadRef
	147: StLoc[73](loc71: Option<String>)
	148: StLoc[59](loc57: Option<String>)
	149: ImmBorrowLoc[59](loc57: Option<String>)
	150: StLoc[96](loc94: &Option<String>)
	151: CopyLoc[96](loc94: &Option<String>)
	152: Call option::is_some<String>(&Option<String>): bool
	153: BrFalse(179)
B19:
	154: MoveLoc[96](loc94: &Option<String>)
	155: Call option::borrow<String>(&Option<String>): &String
	156: StLoc[72](loc70: &String)
	157: ImmBorrowLoc[73](loc71: Option<String>)
	158: StLoc[105](loc103: &Option<String>)
	159: CopyLoc[105](loc103: &Option<String>)
	160: Call option::is_some<String>(&Option<String>): bool
	161: BrFalse(170)
B20:
	162: MoveLoc[105](loc103: &Option<String>)
	163: Call option::borrow<String>(&Option<String>): &String
	164: StLoc[86](loc84: &String)
	165: MoveLoc[72](loc70: &String)
	166: MoveLoc[86](loc84: &String)
	167: Eq
	168: StLoc[10](loc8: bool)
	169: Branch(176)
B21:
	170: MoveLoc[105](loc103: &Option<String>)
	171: Pop
	172: MoveLoc[72](loc70: &String)
	173: Pop
	174: LdFalse
	175: StLoc[10](loc8: bool)
B22:
	176: MoveLoc[10](loc8: bool)
	177: StLoc[9](loc7: bool)
	178: Branch(183)
B23:
	179: MoveLoc[96](loc94: &Option<String>)
	180: Pop
	181: LdFalse
	182: StLoc[9](loc7: bool)
B24:
	183: MoveLoc[9](loc7: bool)
	184: BrFalse(192)
B25:
	185: MoveLoc[116](loc114: &ValidatorMetadata)
	186: Pop
	187: MoveLoc[115](loc113: &ValidatorMetadata)
	188: Pop
	189: LdTrue
	190: StLoc[2](loc0: bool)
	191: Branch(927)
B26:
	192: CopyLoc[116](loc114: &ValidatorMetadata)
	193: ImmBorrowField[21](ValidatorMetadata.next_epoch_p2p_address: Option<String>)
	194: ReadRef
	195: CopyLoc[115](loc113: &ValidatorMetadata)
	196: ImmBorrowField[21](ValidatorMetadata.next_epoch_p2p_address: Option<String>)
	197: ReadRef
	198: StLoc[79](loc77: Option<String>)
	199: StLoc[65](loc63: Option<String>)
	200: ImmBorrowLoc[65](loc63: Option<String>)
	201: StLoc[87](loc85: &Option<String>)
	202: CopyLoc[87](loc85: &Option<String>)
	203: Call option::is_some<String>(&Option<String>): bool
	204: BrFalse(230)
B27:
	205: MoveLoc[87](loc85: &Option<String>)
	206: Call option::borrow<String>(&Option<String>): &String
	207: StLoc[66](loc64: &String)
	208: ImmBorrowLoc[79](loc77: Option<String>)
	209: StLoc[88](loc86: &Option<String>)
	210: CopyLoc[88](loc86: &Option<String>)
	211: Call option::is_some<String>(&Option<String>): bool
	212: BrFalse(221)
B28:
	213: MoveLoc[88](loc86: &Option<String>)
	214: Call option::borrow<String>(&Option<String>): &String
	215: StLoc[80](loc78: &String)
	216: MoveLoc[66](loc64: &String)
	217: MoveLoc[80](loc78: &String)
	218: Eq
	219: StLoc[8](loc6: bool)
	220: Branch(227)
B29:
	221: MoveLoc[88](loc86: &Option<String>)
	222: Pop
	223: MoveLoc[66](loc64: &String)
	224: Pop
	225: LdFalse
	226: StLoc[8](loc6: bool)
B30:
	227: MoveLoc[8](loc6: bool)
	228: StLoc[6](loc4: bool)
	229: Branch(234)
B31:
	230: MoveLoc[87](loc85: &Option<String>)
	231: Pop
	232: LdFalse
	233: StLoc[6](loc4: bool)
B32:
	234: MoveLoc[6](loc4: bool)
	235: BrFalse(243)
B33:
	236: MoveLoc[116](loc114: &ValidatorMetadata)
	237: Pop
	238: MoveLoc[115](loc113: &ValidatorMetadata)
	239: Pop
	240: LdTrue
	241: StLoc[2](loc0: bool)
	242: Branch(927)
B34:
	243: CopyLoc[116](loc114: &ValidatorMetadata)
	244: ImmBorrowField[24](ValidatorMetadata.next_epoch_protocol_pubkey_bytes: Option<vector<u8>>)
	245: ReadRef
	246: CopyLoc[115](loc113: &ValidatorMetadata)
	247: ImmBorrowField[24](ValidatorMetadata.next_epoch_protocol_pubkey_bytes: Option<vector<u8>>)
	248: ReadRef
	249: StLoc[74](loc72: Option<vector<u8>>)
	250: StLoc[60](loc58: Option<vector<u8>>)
	251: ImmBorrowLoc[60](loc58: Option<vector<u8>>)
	252: StLoc[89](loc87: &Option<vector<u8>>)
	253: CopyLoc[89](loc87: &Option<vector<u8>>)
	254: Call option::is_some<vector<u8>>(&Option<vector<u8>>): bool
	255: BrFalse(281)
B35:
	256: MoveLoc[89](loc87: &Option<vector<u8>>)
	257: Call option::borrow<vector<u8>>(&Option<vector<u8>>): &vector<u8>
	258: StLoc[67](loc65: &vector<u8>)
	259: ImmBorrowLoc[74](loc72: Option<vector<u8>>)
	260: StLoc[90](loc88: &Option<vector<u8>>)
	261: CopyLoc[90](loc88: &Option<vector<u8>>)
	262: Call option::is_some<vector<u8>>(&Option<vector<u8>>): bool
	263: BrFalse(272)
B36:
	264: MoveLoc[90](loc88: &Option<vector<u8>>)
	265: Call option::borrow<vector<u8>>(&Option<vector<u8>>): &vector<u8>
	266: StLoc[81](loc79: &vector<u8>)
	267: MoveLoc[67](loc65: &vector<u8>)
	268: MoveLoc[81](loc79: &vector<u8>)
	269: Eq
	270: StLoc[5](loc3: bool)
	271: Branch(278)
B37:
	272: MoveLoc[90](loc88: &Option<vector<u8>>)
	273: Pop
	274: MoveLoc[67](loc65: &vector<u8>)
	275: Pop
	276: LdFalse
	277: StLoc[5](loc3: bool)
B38:
	278: MoveLoc[5](loc3: bool)
	279: StLoc[4](loc2: bool)
	280: Branch(285)
B39:
	281: MoveLoc[89](loc87: &Option<vector<u8>>)
	282: Pop
	283: LdFalse
	284: StLoc[4](loc2: bool)
B40:
	285: MoveLoc[4](loc2: bool)
	286: BrFalse(294)
B41:
	287: MoveLoc[116](loc114: &ValidatorMetadata)
	288: Pop
	289: MoveLoc[115](loc113: &ValidatorMetadata)
	290: Pop
	291: LdTrue
	292: StLoc[2](loc0: bool)
	293: Branch(927)
B42:
	294: CopyLoc[116](loc114: &ValidatorMetadata)
	295: ImmBorrowField[26](ValidatorMetadata.next_epoch_network_pubkey_bytes: Option<vector<u8>>)
	296: ReadRef
	297: CopyLoc[115](loc113: &ValidatorMetadata)
	298: ImmBorrowField[26](ValidatorMetadata.next_epoch_network_pubkey_bytes: Option<vector<u8>>)
	299: ReadRef
	300: StLoc[75](loc73: Option<vector<u8>>)
	301: StLoc[61](loc59: Option<vector<u8>>)
	302: ImmBorrowLoc[61](loc59: Option<vector<u8>>)
	303: StLoc[91](loc89: &Option<vector<u8>>)
	304: CopyLoc[91](loc89: &Option<vector<u8>>)
	305: Call option::is_some<vector<u8>>(&Option<vector<u8>>): bool
	306: BrFalse(332)
B43:
	307: MoveLoc[91](loc89: &Option<vector<u8>>)
	308: Call option::borrow<vector<u8>>(&Option<vector<u8>>): &vector<u8>
	309: StLoc[68](loc66: &vector<u8>)
	310: ImmBorrowLoc[75](loc73: Option<vector<u8>>)
	311: StLoc[92](loc90: &Option<vector<u8>>)
	312: CopyLoc[92](loc90: &Option<vector<u8>>)
	313: Call option::is_some<vector<u8>>(&Option<vector<u8>>): bool
	314: BrFalse(323)
B44:
	315: MoveLoc[92](loc90: &Option<vector<u8>>)
	316: Call option::borrow<vector<u8>>(&Option<vector<u8>>): &vector<u8>
	317: StLoc[82](loc80: &vector<u8>)
	318: MoveLoc[68](loc66: &vector<u8>)
	319: MoveLoc[82](loc80: &vector<u8>)
	320: Eq
	321: StLoc[58](loc56: bool)
	322: Branch(329)
B45:
	323: MoveLoc[92](loc90: &Option<vector<u8>>)
	324: Pop
	325: MoveLoc[68](loc66: &vector<u8>)
	326: Pop
	327: LdFalse
	328: StLoc[58](loc56: bool)
B46:
	329: MoveLoc[58](loc56: bool)
	330: StLoc[57](loc55: bool)
	331: Branch(336)
B47:
	332: MoveLoc[91](loc89: &Option<vector<u8>>)
	333: Pop
	334: LdFalse
	335: StLoc[57](loc55: bool)
B48:
	336: MoveLoc[57](loc55: bool)
	337: BrFalse(345)
B49:
	338: MoveLoc[116](loc114: &ValidatorMetadata)
	339: Pop
	340: MoveLoc[115](loc113: &ValidatorMetadata)
	341: Pop
	342: LdTrue
	343: StLoc[2](loc0: bool)
	344: Branch(927)
B50:
	345: CopyLoc[116](loc114: &ValidatorMetadata)
	346: ImmBorrowField[26](ValidatorMetadata.next_epoch_network_pubkey_bytes: Option<vector<u8>>)
	347: ReadRef
	348: CopyLoc[115](loc113: &ValidatorMetadata)
	349: ImmBorrowField[27](ValidatorMetadata.next_epoch_worker_pubkey_bytes: Option<vector<u8>>)
	350: ReadRef
	351: StLoc[76](loc74: Option<vector<u8>>)
	352: StLoc[62](loc60: Option<vector<u8>>)
	353: ImmBorrowLoc[62](loc60: Option<vector<u8>>)
	354: StLoc[93](loc91: &Option<vector<u8>>)
	355: CopyLoc[93](loc91: &Option<vector<u8>>)
	356: Call option::is_some<vector<u8>>(&Option<vector<u8>>): bool
	357: BrFalse(383)
B51:
	358: MoveLoc[93](loc91: &Option<vector<u8>>)
	359: Call option::borrow<vector<u8>>(&Option<vector<u8>>): &vector<u8>
	360: StLoc[69](loc67: &vector<u8>)
	361: ImmBorrowLoc[76](loc74: Option<vector<u8>>)
	362: StLoc[94](loc92: &Option<vector<u8>>)
	363: CopyLoc[94](loc92: &Option<vector<u8>>)
	364: Call option::is_some<vector<u8>>(&Option<vector<u8>>): bool
	365: BrFalse(374)
B52:
	366: MoveLoc[94](loc92: &Option<vector<u8>>)
	367: Call option::borrow<vector<u8>>(&Option<vector<u8>>): &vector<u8>
	368: StLoc[83](loc81: &vector<u8>)
	369: MoveLoc[69](loc67: &vector<u8>)
	370: MoveLoc[83](loc81: &vector<u8>)
	371: Eq
	372: StLoc[56](loc54: bool)
	373: Branch(380)
B53:
	374: MoveLoc[94](loc92: &Option<vector<u8>>)
	375: Pop
	376: MoveLoc[69](loc67: &vector<u8>)
	377: Pop
	378: LdFalse
	379: StLoc[56](loc54: bool)
B54:
	380: MoveLoc[56](loc54: bool)
	381: StLoc[55](loc53: bool)
	382: Branch(387)
B55:
	383: MoveLoc[93](loc91: &Option<vector<u8>>)
	384: Pop
	385: LdFalse
	386: StLoc[55](loc53: bool)
B56:
	387: MoveLoc[55](loc53: bool)
	388: BrFalse(396)
B57:
	389: MoveLoc[116](loc114: &ValidatorMetadata)
	390: Pop
	391: MoveLoc[115](loc113: &ValidatorMetadata)
	392: Pop
	393: LdTrue
	394: StLoc[2](loc0: bool)
	395: Branch(927)
B58:
	396: CopyLoc[116](loc114: &ValidatorMetadata)
	397: ImmBorrowField[27](ValidatorMetadata.next_epoch_worker_pubkey_bytes: Option<vector<u8>>)
	398: ReadRef
	399: CopyLoc[115](loc113: &ValidatorMetadata)
	400: ImmBorrowField[27](ValidatorMetadata.next_epoch_worker_pubkey_bytes: Option<vector<u8>>)
	401: ReadRef
	402: StLoc[77](loc75: Option<vector<u8>>)
	403: StLoc[63](loc61: Option<vector<u8>>)
	404: ImmBorrowLoc[63](loc61: Option<vector<u8>>)
	405: StLoc[95](loc93: &Option<vector<u8>>)
	406: CopyLoc[95](loc93: &Option<vector<u8>>)
	407: Call option::is_some<vector<u8>>(&Option<vector<u8>>): bool
	408: BrFalse(434)
B59:
	409: MoveLoc[95](loc93: &Option<vector<u8>>)
	410: Call option::borrow<vector<u8>>(&Option<vector<u8>>): &vector<u8>
	411: StLoc[70](loc68: &vector<u8>)
	412: ImmBorrowLoc[77](loc75: Option<vector<u8>>)
	413: StLoc[97](loc95: &Option<vector<u8>>)
	414: CopyLoc[97](loc95: &Option<vector<u8>>)
	415: Call option::is_some<vector<u8>>(&Option<vector<u8>>): bool
	416: BrFalse(425)
B60:
	417: MoveLoc[97](loc95: &Option<vector<u8>>)
	418: Call option::borrow<vector<u8>>(&Option<vector<u8>>): &vector<u8>
	419: StLoc[84](loc82: &vector<u8>)
	420: MoveLoc[70](loc68: &vector<u8>)
	421: MoveLoc[84](loc82: &vector<u8>)
	422: Eq
	423: StLoc[54](loc52: bool)
	424: Branch(431)
B61:
	425: MoveLoc[97](loc95: &Option<vector<u8>>)
	426: Pop
	427: MoveLoc[70](loc68: &vector<u8>)
	428: Pop
	429: LdFalse
	430: StLoc[54](loc52: bool)
B62:
	431: MoveLoc[54](loc52: bool)
	432: StLoc[53](loc51: bool)
	433: Branch(438)
B63:
	434: MoveLoc[95](loc93: &Option<vector<u8>>)
	435: Pop
	436: LdFalse
	437: StLoc[53](loc51: bool)
B64:
	438: MoveLoc[53](loc51: bool)
	439: BrFalse(447)
B65:
	440: MoveLoc[116](loc114: &ValidatorMetadata)
	441: Pop
	442: MoveLoc[115](loc113: &ValidatorMetadata)
	443: Pop
	444: LdTrue
	445: StLoc[2](loc0: bool)
	446: Branch(927)
B66:
	447: CopyLoc[116](loc114: &ValidatorMetadata)
	448: ImmBorrowField[27](ValidatorMetadata.next_epoch_worker_pubkey_bytes: Option<vector<u8>>)
	449: ReadRef
	450: CopyLoc[115](loc113: &ValidatorMetadata)
	451: ImmBorrowField[26](ValidatorMetadata.next_epoch_network_pubkey_bytes: Option<vector<u8>>)
	452: ReadRef
	453: StLoc[78](loc76: Option<vector<u8>>)
	454: StLoc[64](loc62: Option<vector<u8>>)
	455: ImmBorrowLoc[64](loc62: Option<vector<u8>>)
	456: StLoc[98](loc96: &Option<vector<u8>>)
	457: CopyLoc[98](loc96: &Option<vector<u8>>)
	458: Call option::is_some<vector<u8>>(&Option<vector<u8>>): bool
	459: BrFalse(485)
B67:
	460: MoveLoc[98](loc96: &Option<vector<u8>>)
	461: Call option::borrow<vector<u8>>(&Option<vector<u8>>): &vector<u8>
	462: StLoc[71](loc69: &vector<u8>)
	463: ImmBorrowLoc[78](loc76: Option<vector<u8>>)
	464: StLoc[99](loc97: &Option<vector<u8>>)
	465: CopyLoc[99](loc97: &Option<vector<u8>>)
	466: Call option::is_some<vector<u8>>(&Option<vector<u8>>): bool
	467: BrFalse(476)
B68:
	468: MoveLoc[99](loc97: &Option<vector<u8>>)
	469: Call option::borrow<vector<u8>>(&Option<vector<u8>>): &vector<u8>
	470: StLoc[85](loc83: &vector<u8>)
	471: MoveLoc[71](loc69: &vector<u8>)
	472: MoveLoc[85](loc83: &vector<u8>)
	473: Eq
	474: StLoc[51](loc49: bool)
	475: Branch(482)
B69:
	476: MoveLoc[99](loc97: &Option<vector<u8>>)
	477: Pop
	478: MoveLoc[71](loc69: &vector<u8>)
	479: Pop
	480: LdFalse
	481: StLoc[51](loc49: bool)
B70:
	482: MoveLoc[51](loc49: bool)
	483: StLoc[50](loc48: bool)
	484: Branch(489)
B71:
	485: MoveLoc[98](loc96: &Option<vector<u8>>)
	486: Pop
	487: LdFalse
	488: StLoc[50](loc48: bool)
B72:
	489: MoveLoc[50](loc48: bool)
	490: BrFalse(498)
B73:
	491: MoveLoc[116](loc114: &ValidatorMetadata)
	492: Pop
	493: MoveLoc[115](loc113: &ValidatorMetadata)
	494: Pop
	495: LdTrue
	496: StLoc[2](loc0: bool)
	497: Branch(927)
B74:
	498: CopyLoc[116](loc114: &ValidatorMetadata)
	499: ImmBorrowField[20](ValidatorMetadata.next_epoch_net_address: Option<String>)
	500: StLoc[100](loc98: &Option<String>)
	501: CopyLoc[100](loc98: &Option<String>)
	502: Call option::is_some<String>(&Option<String>): bool
	503: BrFalse(516)
B75:
	504: MoveLoc[100](loc98: &Option<String>)
	505: Call option::borrow<String>(&Option<String>): &String
	506: StLoc[49](loc47: &String)
	507: CopyLoc[115](loc113: &ValidatorMetadata)
	508: ImmBorrowField[12](ValidatorMetadata.net_address: String)
	509: ReadRef
	510: StLoc[48](loc46: String)
	511: MoveLoc[49](loc47: &String)
	512: ImmBorrowLoc[48](loc46: String)
	513: Eq
	514: StLoc[47](loc45: bool)
	515: Branch(520)
B76:
	516: MoveLoc[100](loc98: &Option<String>)
	517: Pop
	518: LdFalse
	519: StLoc[47](loc45: bool)
B77:
	520: MoveLoc[47](loc45: bool)
	521: BrFalse(529)
B78:
	522: MoveLoc[116](loc114: &ValidatorMetadata)
	523: Pop
	524: MoveLoc[115](loc113: &ValidatorMetadata)
	525: Pop
	526: LdTrue
	527: StLoc[2](loc0: bool)
	528: Branch(927)
B79:
	529: CopyLoc[116](loc114: &ValidatorMetadata)
	530: ImmBorrowField[21](ValidatorMetadata.next_epoch_p2p_address: Option<String>)
	531: StLoc[101](loc99: &Option<String>)
	532: CopyLoc[101](loc99: &Option<String>)
	533: Call option::is_some<String>(&Option<String>): bool
	534: BrFalse(547)
B80:
	535: MoveLoc[101](loc99: &Option<String>)
	536: Call option::borrow<String>(&Option<String>): &String
	537: StLoc[46](loc44: &String)
	538: CopyLoc[115](loc113: &ValidatorMetadata)
	539: ImmBorrowField[13](ValidatorMetadata.p2p_address: String)
	540: ReadRef
	541: StLoc[45](loc43: String)
	542: MoveLoc[46](loc44: &String)
	543: ImmBorrowLoc[45](loc43: String)
	544: Eq
	545: StLoc[44](loc42: bool)
	546: Branch(551)
B81:
	547: MoveLoc[101](loc99: &Option<String>)
	548: Pop
	549: LdFalse
	550: StLoc[44](loc42: bool)
B82:
	551: MoveLoc[44](loc42: bool)
	552: BrFalse(560)
B83:
	553: MoveLoc[116](loc114: &ValidatorMetadata)
	554: Pop
	555: MoveLoc[115](loc113: &ValidatorMetadata)
	556: Pop
	557: LdTrue
	558: StLoc[2](loc0: bool)
	559: Branch(927)
B84:
	560: CopyLoc[116](loc114: &ValidatorMetadata)
	561: ImmBorrowField[24](ValidatorMetadata.next_epoch_protocol_pubkey_bytes: Option<vector<u8>>)
	562: StLoc[102](loc100: &Option<vector<u8>>)
	563: CopyLoc[102](loc100: &Option<vector<u8>>)
	564: Call option::is_some<vector<u8>>(&Option<vector<u8>>): bool
	565: BrFalse(578)
B85:
	566: MoveLoc[102](loc100: &Option<vector<u8>>)
	567: Call option::borrow<vector<u8>>(&Option<vector<u8>>): &vector<u8>
	568: StLoc[43](loc41: &vector<u8>)
	569: CopyLoc[115](loc113: &ValidatorMetadata)
	570: ImmBorrowField[16](ValidatorMetadata.protocol_pubkey_bytes: vector<u8>)
	571: ReadRef
	572: StLoc[42](loc40: vector<u8>)
	573: MoveLoc[43](loc41: &vector<u8>)
	574: ImmBorrowLoc[42](loc40: vector<u8>)
	575: Eq
	576: StLoc[40](loc38: bool)
	577: Branch(582)
B86:
	578: MoveLoc[102](loc100: &Option<vector<u8>>)
	579: Pop
	580: LdFalse
	581: StLoc[40](loc38: bool)
B87:
	582: MoveLoc[40](loc38: bool)
	583: BrFalse(591)
B88:
	584: MoveLoc[116](loc114: &ValidatorMetadata)
	585: Pop
	586: MoveLoc[115](loc113: &ValidatorMetadata)
	587: Pop
	588: LdTrue
	589: StLoc[2](loc0: bool)
	590: Branch(927)
B89:
	591: CopyLoc[116](loc114: &ValidatorMetadata)
	592: ImmBorrowField[26](ValidatorMetadata.next_epoch_network_pubkey_bytes: Option<vector<u8>>)
	593: StLoc[103](loc101: &Option<vector<u8>>)
	594: CopyLoc[103](loc101: &Option<vector<u8>>)
	595: Call option::is_some<vector<u8>>(&Option<vector<u8>>): bool
	596: BrFalse(609)
B90:
	597: MoveLoc[103](loc101: &Option<vector<u8>>)
	598: Call option::borrow<vector<u8>>(&Option<vector<u8>>): &vector<u8>
	599: StLoc[39](loc37: &vector<u8>)
	600: CopyLoc[115](loc113: &ValidatorMetadata)
	601: ImmBorrowField[18](ValidatorMetadata.network_pubkey_bytes: vector<u8>)
	602: ReadRef
	603: StLoc[38](loc36: vector<u8>)
	604: MoveLoc[39](loc37: &vector<u8>)
	605: ImmBorrowLoc[38](loc36: vector<u8>)
	606: Eq
	607: StLoc[37](loc35: bool)
	608: Branch(613)
B91:
	609: MoveLoc[103](loc101: &Option<vector<u8>>)
	610: Pop
	611: LdFalse
	612: StLoc[37](loc35: bool)
B92:
	613: MoveLoc[37](loc35: bool)
	614: BrFalse(622)
B93:
	615: MoveLoc[116](loc114: &ValidatorMetadata)
	616: Pop
	617: MoveLoc[115](loc113: &ValidatorMetadata)
	618: Pop
	619: LdTrue
	620: StLoc[2](loc0: bool)
	621: Branch(927)
B94:
	622: CopyLoc[116](loc114: &ValidatorMetadata)
	623: ImmBorrowField[26](ValidatorMetadata.next_epoch_network_pubkey_bytes: Option<vector<u8>>)
	624: StLoc[104](loc102: &Option<vector<u8>>)
	625: CopyLoc[104](loc102: &Option<vector<u8>>)
	626: Call option::is_some<vector<u8>>(&Option<vector<u8>>): bool
	627: BrFalse(640)
B95:
	628: MoveLoc[104](loc102: &Option<vector<u8>>)
	629: Call option::borrow<vector<u8>>(&Option<vector<u8>>): &vector<u8>
	630: StLoc[36](loc34: &vector<u8>)
	631: CopyLoc[115](loc113: &ValidatorMetadata)
	632: ImmBorrowField[19](ValidatorMetadata.worker_pubkey_bytes: vector<u8>)
	633: ReadRef
	634: StLoc[35](loc33: vector<u8>)
	635: MoveLoc[36](loc34: &vector<u8>)
	636: ImmBorrowLoc[35](loc33: vector<u8>)
	637: Eq
	638: StLoc[33](loc31: bool)
	639: Branch(644)
B96:
	640: MoveLoc[104](loc102: &Option<vector<u8>>)
	641: Pop
	642: LdFalse
	643: StLoc[33](loc31: bool)
B97:
	644: MoveLoc[33](loc31: bool)
	645: BrFalse(653)
B98:
	646: MoveLoc[116](loc114: &ValidatorMetadata)
	647: Pop
	648: MoveLoc[115](loc113: &ValidatorMetadata)
	649: Pop
	650: LdTrue
	651: StLoc[2](loc0: bool)
	652: Branch(927)
B99:
	653: CopyLoc[116](loc114: &ValidatorMetadata)
	654: ImmBorrowField[27](ValidatorMetadata.next_epoch_worker_pubkey_bytes: Option<vector<u8>>)
	655: StLoc[106](loc104: &Option<vector<u8>>)
	656: CopyLoc[106](loc104: &Option<vector<u8>>)
	657: Call option::is_some<vector<u8>>(&Option<vector<u8>>): bool
	658: BrFalse(671)
B100:
	659: MoveLoc[106](loc104: &Option<vector<u8>>)
	660: Call option::borrow<vector<u8>>(&Option<vector<u8>>): &vector<u8>
	661: StLoc[32](loc30: &vector<u8>)
	662: CopyLoc[115](loc113: &ValidatorMetadata)
	663: ImmBorrowField[19](ValidatorMetadata.worker_pubkey_bytes: vector<u8>)
	664: ReadRef
	665: StLoc[31](loc29: vector<u8>)
	666: MoveLoc[32](loc30: &vector<u8>)
	667: ImmBorrowLoc[31](loc29: vector<u8>)
	668: Eq
	669: StLoc[30](loc28: bool)
	670: Branch(675)
B101:
	671: MoveLoc[106](loc104: &Option<vector<u8>>)
	672: Pop
	673: LdFalse
	674: StLoc[30](loc28: bool)
B102:
	675: MoveLoc[30](loc28: bool)
	676: BrFalse(684)
B103:
	677: MoveLoc[116](loc114: &ValidatorMetadata)
	678: Pop
	679: MoveLoc[115](loc113: &ValidatorMetadata)
	680: Pop
	681: LdTrue
	682: StLoc[2](loc0: bool)
	683: Branch(927)
B104:
	684: CopyLoc[116](loc114: &ValidatorMetadata)
	685: ImmBorrowField[27](ValidatorMetadata.next_epoch_worker_pubkey_bytes: Option<vector<u8>>)
	686: StLoc[107](loc105: &Option<vector<u8>>)
	687: CopyLoc[107](loc105: &Option<vector<u8>>)
	688: Call option::is_some<vector<u8>>(&Option<vector<u8>>): bool
	689: BrFalse(702)
B105:
	690: MoveLoc[107](loc105: &Option<vector<u8>>)
	691: Call option::borrow<vector<u8>>(&Option<vector<u8>>): &vector<u8>
	692: StLoc[29](loc27: &vector<u8>)
	693: CopyLoc[115](loc113: &ValidatorMetadata)
	694: ImmBorrowField[18](ValidatorMetadata.network_pubkey_bytes: vector<u8>)
	695: ReadRef
	696: StLoc[28](loc26: vector<u8>)
	697: MoveLoc[29](loc27: &vector<u8>)
	698: ImmBorrowLoc[28](loc26: vector<u8>)
	699: Eq
	700: StLoc[27](loc25: bool)
	701: Branch(706)
B106:
	702: MoveLoc[107](loc105: &Option<vector<u8>>)
	703: Pop
	704: LdFalse
	705: StLoc[27](loc25: bool)
B107:
	706: MoveLoc[27](loc25: bool)
	707: BrFalse(715)
B108:
	708: MoveLoc[116](loc114: &ValidatorMetadata)
	709: Pop
	710: MoveLoc[115](loc113: &ValidatorMetadata)
	711: Pop
	712: LdTrue
	713: StLoc[2](loc0: bool)
	714: Branch(927)
B109:
	715: CopyLoc[115](loc113: &ValidatorMetadata)
	716: ImmBorrowField[20](ValidatorMetadata.next_epoch_net_address: Option<String>)
	717: StLoc[108](loc106: &Option<String>)
	718: CopyLoc[108](loc106: &Option<String>)
	719: Call option::is_some<String>(&Option<String>): bool
	720: BrFalse(733)
B110:
	721: MoveLoc[108](loc106: &Option<String>)
	722: Call option::borrow<String>(&Option<String>): &String
	723: StLoc[26](loc24: &String)
	724: CopyLoc[116](loc114: &ValidatorMetadata)
	725: ImmBorrowField[12](ValidatorMetadata.net_address: String)
	726: ReadRef
	727: StLoc[25](loc23: String)
	728: MoveLoc[26](loc24: &String)
	729: ImmBorrowLoc[25](loc23: String)
	730: Eq
	731: StLoc[24](loc22: bool)
	732: Branch(737)
B111:
	733: MoveLoc[108](loc106: &Option<String>)
	734: Pop
	735: LdFalse
	736: StLoc[24](loc22: bool)
B112:
	737: MoveLoc[24](loc22: bool)
	738: BrFalse(746)
B113:
	739: MoveLoc[116](loc114: &ValidatorMetadata)
	740: Pop
	741: MoveLoc[115](loc113: &ValidatorMetadata)
	742: Pop
	743: LdTrue
	744: StLoc[2](loc0: bool)
	745: Branch(927)
B114:
	746: CopyLoc[115](loc113: &ValidatorMetadata)
	747: ImmBorrowField[21](ValidatorMetadata.next_epoch_p2p_address: Option<String>)
	748: StLoc[109](loc107: &Option<String>)
	749: CopyLoc[109](loc107: &Option<String>)
	750: Call option::is_some<String>(&Option<String>): bool
	751: BrFalse(764)
B115:
	752: MoveLoc[109](loc107: &Option<String>)
	753: Call option::borrow<String>(&Option<String>): &String
	754: StLoc[23](loc21: &String)
	755: CopyLoc[116](loc114: &ValidatorMetadata)
	756: ImmBorrowField[13](ValidatorMetadata.p2p_address: String)
	757: ReadRef
	758: StLoc[22](loc20: String)
	759: MoveLoc[23](loc21: &String)
	760: ImmBorrowLoc[22](loc20: String)
	761: Eq
	762: StLoc[20](loc18: bool)
	763: Branch(768)
B116:
	764: MoveLoc[109](loc107: &Option<String>)
	765: Pop
	766: LdFalse
	767: StLoc[20](loc18: bool)
B117:
	768: MoveLoc[20](loc18: bool)
	769: BrFalse(777)
B118:
	770: MoveLoc[116](loc114: &ValidatorMetadata)
	771: Pop
	772: MoveLoc[115](loc113: &ValidatorMetadata)
	773: Pop
	774: LdTrue
	775: StLoc[2](loc0: bool)
	776: Branch(927)
B119:
	777: CopyLoc[115](loc113: &ValidatorMetadata)
	778: ImmBorrowField[24](ValidatorMetadata.next_epoch_protocol_pubkey_bytes: Option<vector<u8>>)
	779: StLoc[110](loc108: &Option<vector<u8>>)
	780: CopyLoc[110](loc108: &Option<vector<u8>>)
	781: Call option::is_some<vector<u8>>(&Option<vector<u8>>): bool
	782: BrFalse(795)
B120:
	783: MoveLoc[110](loc108: &Option<vector<u8>>)
	784: Call option::borrow<vector<u8>>(&Option<vector<u8>>): &vector<u8>
	785: StLoc[19](loc17: &vector<u8>)
	786: CopyLoc[116](loc114: &ValidatorMetadata)
	787: ImmBorrowField[16](ValidatorMetadata.protocol_pubkey_bytes: vector<u8>)
	788: ReadRef
	789: StLoc[18](loc16: vector<u8>)
	790: MoveLoc[19](loc17: &vector<u8>)
	791: ImmBorrowLoc[18](loc16: vector<u8>)
	792: Eq
	793: StLoc[17](loc15: bool)
	794: Branch(799)
B121:
	795: MoveLoc[110](loc108: &Option<vector<u8>>)
	796: Pop
	797: LdFalse
	798: StLoc[17](loc15: bool)
B122:
	799: MoveLoc[17](loc15: bool)
	800: BrFalse(808)
B123:
	801: MoveLoc[116](loc114: &ValidatorMetadata)
	802: Pop
	803: MoveLoc[115](loc113: &ValidatorMetadata)
	804: Pop
	805: LdTrue
	806: StLoc[2](loc0: bool)
	807: Branch(927)
B124:
	808: CopyLoc[115](loc113: &ValidatorMetadata)
	809: ImmBorrowField[26](ValidatorMetadata.next_epoch_network_pubkey_bytes: Option<vector<u8>>)
	810: StLoc[111](loc109: &Option<vector<u8>>)
	811: CopyLoc[111](loc109: &Option<vector<u8>>)
	812: Call option::is_some<vector<u8>>(&Option<vector<u8>>): bool
	813: BrFalse(826)
B125:
	814: MoveLoc[111](loc109: &Option<vector<u8>>)
	815: Call option::borrow<vector<u8>>(&Option<vector<u8>>): &vector<u8>
	816: StLoc[16](loc14: &vector<u8>)
	817: CopyLoc[116](loc114: &ValidatorMetadata)
	818: ImmBorrowField[18](ValidatorMetadata.network_pubkey_bytes: vector<u8>)
	819: ReadRef
	820: StLoc[15](loc13: vector<u8>)
	821: MoveLoc[16](loc14: &vector<u8>)
	822: ImmBorrowLoc[15](loc13: vector<u8>)
	823: Eq
	824: StLoc[14](loc12: bool)
	825: Branch(830)
B126:
	826: MoveLoc[111](loc109: &Option<vector<u8>>)
	827: Pop
	828: LdFalse
	829: StLoc[14](loc12: bool)
B127:
	830: MoveLoc[14](loc12: bool)
	831: BrFalse(839)
B128:
	832: MoveLoc[116](loc114: &ValidatorMetadata)
	833: Pop
	834: MoveLoc[115](loc113: &ValidatorMetadata)
	835: Pop
	836: LdTrue
	837: StLoc[2](loc0: bool)
	838: Branch(927)
B129:
	839: CopyLoc[115](loc113: &ValidatorMetadata)
	840: ImmBorrowField[26](ValidatorMetadata.next_epoch_network_pubkey_bytes: Option<vector<u8>>)
	841: StLoc[112](loc110: &Option<vector<u8>>)
	842: CopyLoc[112](loc110: &Option<vector<u8>>)
	843: Call option::is_some<vector<u8>>(&Option<vector<u8>>): bool
	844: BrFalse(857)
B130:
	845: MoveLoc[112](loc110: &Option<vector<u8>>)
	846: Call option::borrow<vector<u8>>(&Option<vector<u8>>): &vector<u8>
	847: StLoc[13](loc11: &vector<u8>)
	848: CopyLoc[116](loc114: &ValidatorMetadata)
	849: ImmBorrowField[19](ValidatorMetadata.worker_pubkey_bytes: vector<u8>)
	850: ReadRef
	851: StLoc[12](loc10: vector<u8>)
	852: MoveLoc[13](loc11: &vector<u8>)
	853: ImmBorrowLoc[12](loc10: vector<u8>)
	854: Eq
	855: StLoc[11](loc9: bool)
	856: Branch(861)
B131:
	857: MoveLoc[112](loc110: &Option<vector<u8>>)
	858: Pop
	859: LdFalse
	860: StLoc[11](loc9: bool)
B132:
	861: MoveLoc[11](loc9: bool)
	862: BrFalse(870)
B133:
	863: MoveLoc[116](loc114: &ValidatorMetadata)
	864: Pop
	865: MoveLoc[115](loc113: &ValidatorMetadata)
	866: Pop
	867: LdTrue
	868: StLoc[2](loc0: bool)
	869: Branch(927)
B134:
	870: CopyLoc[115](loc113: &ValidatorMetadata)
	871: ImmBorrowField[27](ValidatorMetadata.next_epoch_worker_pubkey_bytes: Option<vector<u8>>)
	872: StLoc[113](loc111: &Option<vector<u8>>)
	873: CopyLoc[113](loc111: &Option<vector<u8>>)
	874: Call option::is_some<vector<u8>>(&Option<vector<u8>>): bool
	875: BrFalse(888)
B135:
	876: MoveLoc[113](loc111: &Option<vector<u8>>)
	877: Call option::borrow<vector<u8>>(&Option<vector<u8>>): &vector<u8>
	878: StLoc[7](loc5: &vector<u8>)
	879: CopyLoc[116](loc114: &ValidatorMetadata)
	880: ImmBorrowField[19](ValidatorMetadata.worker_pubkey_bytes: vector<u8>)
	881: ReadRef
	882: StLoc[3](loc1: vector<u8>)
	883: MoveLoc[7](loc5: &vector<u8>)
	884: ImmBorrowLoc[3](loc1: vector<u8>)
	885: Eq
	886: StLoc[52](loc50: bool)
	887: Branch(892)
B136:
	888: MoveLoc[113](loc111: &Option<vector<u8>>)
	889: Pop
	890: LdFalse
	891: StLoc[52](loc50: bool)
B137:
	892: MoveLoc[52](loc50: bool)
	893: BrFalse(901)
B138:
	894: MoveLoc[116](loc114: &ValidatorMetadata)
	895: Pop
	896: MoveLoc[115](loc113: &ValidatorMetadata)
	897: Pop
	898: LdTrue
	899: StLoc[2](loc0: bool)
	900: Branch(927)
B139:
	901: MoveLoc[115](loc113: &ValidatorMetadata)
	902: ImmBorrowField[27](ValidatorMetadata.next_epoch_worker_pubkey_bytes: Option<vector<u8>>)
	903: StLoc[114](loc112: &Option<vector<u8>>)
	904: CopyLoc[114](loc112: &Option<vector<u8>>)
	905: Call option::is_some<vector<u8>>(&Option<vector<u8>>): bool
	906: BrFalse(919)
B140:
	907: MoveLoc[114](loc112: &Option<vector<u8>>)
	908: Call option::borrow<vector<u8>>(&Option<vector<u8>>): &vector<u8>
	909: StLoc[41](loc39: &vector<u8>)
	910: MoveLoc[116](loc114: &ValidatorMetadata)
	911: ImmBorrowField[18](ValidatorMetadata.network_pubkey_bytes: vector<u8>)
	912: ReadRef
	913: StLoc[34](loc32: vector<u8>)
	914: MoveLoc[41](loc39: &vector<u8>)
	915: ImmBorrowLoc[34](loc32: vector<u8>)
	916: Eq
	917: StLoc[21](loc19: bool)
	918: Branch(925)
B141:
	919: MoveLoc[116](loc114: &ValidatorMetadata)
	920: Pop
	921: MoveLoc[114](loc112: &Option<vector<u8>>)
	922: Pop
	923: LdFalse
	924: StLoc[21](loc19: bool)
B142:
	925: MoveLoc[21](loc19: bool)
	926: StLoc[2](loc0: bool)
B143:
	927: MoveLoc[2](loc0: bool)
	928: Ret
}

public(friend) new_unverified_validator_operation_cap_and_transfer(Arg0: &mut Validator, Arg1: &mut TxContext) {
L2:	loc0: address
B0:
	0: CopyLoc[1](Arg1: &mut TxContext)
	1: FreezeRef
	2: Call tx_context::sender(&TxContext): address
	3: StLoc[2](loc0: address)
	4: CopyLoc[2](loc0: address)
	5: CopyLoc[0](Arg0: &mut Validator)
	6: ImmBorrowField[6](Validator.metadata: ValidatorMetadata)
	7: ImmBorrowField[7](ValidatorMetadata.safe_address: address)
	8: ReadRef
	9: Eq
	10: BrFalse(12)
B1:
	11: Branch(18)
B2:
	12: MoveLoc[0](Arg0: &mut Validator)
	13: Pop
	14: MoveLoc[1](Arg1: &mut TxContext)
	15: Pop
	16: LdConst[13](u64: 100)
	17: Abort
B3:
	18: MoveLoc[2](loc0: address)
	19: MoveLoc[1](Arg1: &mut TxContext)
	20: Call validator_cap::new_unverified_validator_operation_cap_and_transfer(address, &mut TxContext): ID
	21: MoveLoc[0](Arg0: &mut Validator)
	22: MutBorrowField[28](Validator.operation_cap_id: ID)
	23: WriteRef
	24: Ret
}

public(friend) update_name(Arg0: &mut Validator, Arg1: vector<u8>) {
B0:
	0: ImmBorrowLoc[1](Arg1: vector<u8>)
	1: VecLen(42)
	2: LdConst[17](u64: 256)
	3: Le
	4: BrFalse(6)
B1:
	5: Branch(10)
B2:
	6: MoveLoc[0](Arg0: &mut Validator)
	7: Pop
	8: LdConst[9](u64: 9)
	9: Abort
B3:
	10: MoveLoc[1](Arg1: vector<u8>)
	11: Call ascii::string(vector<u8>): String
	12: Call string::from_ascii(String): String
	13: MoveLoc[0](Arg0: &mut Validator)
	14: MutBorrowField[6](Validator.metadata: ValidatorMetadata)
	15: MutBorrowField[8](ValidatorMetadata.name: String)
	16: WriteRef
	17: Ret
}

public(friend) update_description(Arg0: &mut Validator, Arg1: vector<u8>) {
B0:
	0: ImmBorrowLoc[1](Arg1: vector<u8>)
	1: VecLen(42)
	2: LdConst[17](u64: 256)
	3: Le
	4: BrFalse(6)
B1:
	5: Branch(10)
B2:
	6: MoveLoc[0](Arg0: &mut Validator)
	7: Pop
	8: LdConst[9](u64: 9)
	9: Abort
B3:
	10: MoveLoc[1](Arg1: vector<u8>)
	11: Call ascii::string(vector<u8>): String
	12: Call string::from_ascii(String): String
	13: MoveLoc[0](Arg0: &mut Validator)
	14: MutBorrowField[6](Validator.metadata: ValidatorMetadata)
	15: MutBorrowField[9](ValidatorMetadata.description: String)
	16: WriteRef
	17: Ret
}

public(friend) update_image_url(Arg0: &mut Validator, Arg1: vector<u8>) {
B0:
	0: ImmBorrowLoc[1](Arg1: vector<u8>)
	1: VecLen(42)
	2: LdConst[17](u64: 256)
	3: Le
	4: BrFalse(6)
B1:
	5: Branch(10)
B2:
	6: MoveLoc[0](Arg0: &mut Validator)
	7: Pop
	8: LdConst[9](u64: 9)
	9: Abort
B3:
	10: MoveLoc[1](Arg1: vector<u8>)
	11: Call url::new_unsafe_from_bytes(vector<u8>): Url
	12: MoveLoc[0](Arg0: &mut Validator)
	13: MutBorrowField[6](Validator.metadata: ValidatorMetadata)
	14: MutBorrowField[10](ValidatorMetadata.image_url: Url)
	15: WriteRef
	16: Ret
}

public(friend) update_project_url(Arg0: &mut Validator, Arg1: vector<u8>) {
B0:
	0: ImmBorrowLoc[1](Arg1: vector<u8>)
	1: VecLen(42)
	2: LdConst[17](u64: 256)
	3: Le
	4: BrFalse(6)
B1:
	5: Branch(10)
B2:
	6: MoveLoc[0](Arg0: &mut Validator)
	7: Pop
	8: LdConst[9](u64: 9)
	9: Abort
B3:
	10: MoveLoc[1](Arg1: vector<u8>)
	11: Call url::new_unsafe_from_bytes(vector<u8>): Url
	12: MoveLoc[0](Arg0: &mut Validator)
	13: MutBorrowField[6](Validator.metadata: ValidatorMetadata)
	14: MutBorrowField[11](ValidatorMetadata.project_url: Url)
	15: WriteRef
	16: Ret
}

public(friend) update_next_epoch_network_address(Arg0: &mut Validator, Arg1: vector<u8>) {
B0:
	0: ImmBorrowLoc[1](Arg1: vector<u8>)
	1: VecLen(42)
	2: LdConst[17](u64: 256)
	3: Le
	4: BrFalse(6)
B1:
	5: Branch(10)
B2:
	6: MoveLoc[0](Arg0: &mut Validator)
	7: Pop
	8: LdConst[9](u64: 9)
	9: Abort
B3:
	10: MoveLoc[1](Arg1: vector<u8>)
	11: Call ascii::string(vector<u8>): String
	12: Call string::from_ascii(String): String
	13: Call option::some<String>(String): Option<String>
	14: CopyLoc[0](Arg0: &mut Validator)
	15: MutBorrowField[6](Validator.metadata: ValidatorMetadata)
	16: MutBorrowField[20](ValidatorMetadata.next_epoch_net_address: Option<String>)
	17: WriteRef
	18: MoveLoc[0](Arg0: &mut Validator)
	19: ImmBorrowField[6](Validator.metadata: ValidatorMetadata)
	20: Call validate_metadata(&ValidatorMetadata)
	21: Ret
}

public(friend) update_candidate_network_address(Arg0: &mut Validator, Arg1: vector<u8>) {
B0:
	0: CopyLoc[0](Arg0: &mut Validator)
	1: FreezeRef
	2: Call is_preactive(&Validator): bool
	3: BrFalse(5)
B1:
	4: Branch(9)
B2:
	5: MoveLoc[0](Arg0: &mut Validator)
	6: Pop
	7: LdConst[10](u64: 10)
	8: Abort
B3:
	9: ImmBorrowLoc[1](Arg1: vector<u8>)
	10: VecLen(42)
	11: LdConst[17](u64: 256)
	12: Le
	13: BrFalse(15)
B4:
	14: Branch(19)
B5:
	15: MoveLoc[0](Arg0: &mut Validator)
	16: Pop
	17: LdConst[9](u64: 9)
	18: Abort
B6:
	19: MoveLoc[1](Arg1: vector<u8>)
	20: Call ascii::string(vector<u8>): String
	21: Call string::from_ascii(String): String
	22: CopyLoc[0](Arg0: &mut Validator)
	23: MutBorrowField[6](Validator.metadata: ValidatorMetadata)
	24: MutBorrowField[12](ValidatorMetadata.net_address: String)
	25: WriteRef
	26: MoveLoc[0](Arg0: &mut Validator)
	27: ImmBorrowField[6](Validator.metadata: ValidatorMetadata)
	28: Call validate_metadata(&ValidatorMetadata)
	29: Ret
}

public(friend) update_next_epoch_p2p_address(Arg0: &mut Validator, Arg1: vector<u8>) {
B0:
	0: ImmBorrowLoc[1](Arg1: vector<u8>)
	1: VecLen(42)
	2: LdConst[17](u64: 256)
	3: Le
	4: BrFalse(6)
B1:
	5: Branch(10)
B2:
	6: MoveLoc[0](Arg0: &mut Validator)
	7: Pop
	8: LdConst[9](u64: 9)
	9: Abort
B3:
	10: MoveLoc[1](Arg1: vector<u8>)
	11: Call ascii::string(vector<u8>): String
	12: Call string::from_ascii(String): String
	13: Call option::some<String>(String): Option<String>
	14: CopyLoc[0](Arg0: &mut Validator)
	15: MutBorrowField[6](Validator.metadata: ValidatorMetadata)
	16: MutBorrowField[21](ValidatorMetadata.next_epoch_p2p_address: Option<String>)
	17: WriteRef
	18: MoveLoc[0](Arg0: &mut Validator)
	19: ImmBorrowField[6](Validator.metadata: ValidatorMetadata)
	20: Call validate_metadata(&ValidatorMetadata)
	21: Ret
}

public(friend) update_candidate_p2p_address(Arg0: &mut Validator, Arg1: vector<u8>) {
B0:
	0: CopyLoc[0](Arg0: &mut Validator)
	1: FreezeRef
	2: Call is_preactive(&Validator): bool
	3: BrFalse(5)
B1:
	4: Branch(9)
B2:
	5: MoveLoc[0](Arg0: &mut Validator)
	6: Pop
	7: LdConst[10](u64: 10)
	8: Abort
B3:
	9: ImmBorrowLoc[1](Arg1: vector<u8>)
	10: VecLen(42)
	11: LdConst[17](u64: 256)
	12: Le
	13: BrFalse(15)
B4:
	14: Branch(19)
B5:
	15: MoveLoc[0](Arg0: &mut Validator)
	16: Pop
	17: LdConst[9](u64: 9)
	18: Abort
B6:
	19: MoveLoc[1](Arg1: vector<u8>)
	20: Call ascii::string(vector<u8>): String
	21: Call string::from_ascii(String): String
	22: CopyLoc[0](Arg0: &mut Validator)
	23: MutBorrowField[6](Validator.metadata: ValidatorMetadata)
	24: MutBorrowField[13](ValidatorMetadata.p2p_address: String)
	25: WriteRef
	26: MoveLoc[0](Arg0: &mut Validator)
	27: ImmBorrowField[6](Validator.metadata: ValidatorMetadata)
	28: Call validate_metadata(&ValidatorMetadata)
	29: Ret
}

public(friend) update_next_epoch_primary_address(Arg0: &mut Validator, Arg1: vector<u8>) {
B0:
	0: ImmBorrowLoc[1](Arg1: vector<u8>)
	1: VecLen(42)
	2: LdConst[17](u64: 256)
	3: Le
	4: BrFalse(6)
B1:
	5: Branch(10)
B2:
	6: MoveLoc[0](Arg0: &mut Validator)
	7: Pop
	8: LdConst[9](u64: 9)
	9: Abort
B3:
	10: MoveLoc[1](Arg1: vector<u8>)
	11: Call ascii::string(vector<u8>): String
	12: Call string::from_ascii(String): String
	13: Call option::some<String>(String): Option<String>
	14: CopyLoc[0](Arg0: &mut Validator)
	15: MutBorrowField[6](Validator.metadata: ValidatorMetadata)
	16: MutBorrowField[22](ValidatorMetadata.next_epoch_primary_address: Option<String>)
	17: WriteRef
	18: MoveLoc[0](Arg0: &mut Validator)
	19: ImmBorrowField[6](Validator.metadata: ValidatorMetadata)
	20: Call validate_metadata(&ValidatorMetadata)
	21: Ret
}

public(friend) update_candidate_primary_address(Arg0: &mut Validator, Arg1: vector<u8>) {
B0:
	0: CopyLoc[0](Arg0: &mut Validator)
	1: FreezeRef
	2: Call is_preactive(&Validator): bool
	3: BrFalse(5)
B1:
	4: Branch(9)
B2:
	5: MoveLoc[0](Arg0: &mut Validator)
	6: Pop
	7: LdConst[10](u64: 10)
	8: Abort
B3:
	9: ImmBorrowLoc[1](Arg1: vector<u8>)
	10: VecLen(42)
	11: LdConst[17](u64: 256)
	12: Le
	13: BrFalse(15)
B4:
	14: Branch(19)
B5:
	15: MoveLoc[0](Arg0: &mut Validator)
	16: Pop
	17: LdConst[9](u64: 9)
	18: Abort
B6:
	19: MoveLoc[1](Arg1: vector<u8>)
	20: Call ascii::string(vector<u8>): String
	21: Call string::from_ascii(String): String
	22: CopyLoc[0](Arg0: &mut Validator)
	23: MutBorrowField[6](Validator.metadata: ValidatorMetadata)
	24: MutBorrowField[14](ValidatorMetadata.primary_address: String)
	25: WriteRef
	26: MoveLoc[0](Arg0: &mut Validator)
	27: ImmBorrowField[6](Validator.metadata: ValidatorMetadata)
	28: Call validate_metadata(&ValidatorMetadata)
	29: Ret
}

public(friend) update_next_epoch_worker_address(Arg0: &mut Validator, Arg1: vector<u8>) {
B0:
	0: ImmBorrowLoc[1](Arg1: vector<u8>)
	1: VecLen(42)
	2: LdConst[17](u64: 256)
	3: Le
	4: BrFalse(6)
B1:
	5: Branch(10)
B2:
	6: MoveLoc[0](Arg0: &mut Validator)
	7: Pop
	8: LdConst[9](u64: 9)
	9: Abort
B3:
	10: MoveLoc[1](Arg1: vector<u8>)
	11: Call ascii::string(vector<u8>): String
	12: Call string::from_ascii(String): String
	13: Call option::some<String>(String): Option<String>
	14: CopyLoc[0](Arg0: &mut Validator)
	15: MutBorrowField[6](Validator.metadata: ValidatorMetadata)
	16: MutBorrowField[23](ValidatorMetadata.next_epoch_worker_address: Option<String>)
	17: WriteRef
	18: MoveLoc[0](Arg0: &mut Validator)
	19: ImmBorrowField[6](Validator.metadata: ValidatorMetadata)
	20: Call validate_metadata(&ValidatorMetadata)
	21: Ret
}

public(friend) update_candidate_worker_address(Arg0: &mut Validator, Arg1: vector<u8>) {
B0:
	0: CopyLoc[0](Arg0: &mut Validator)
	1: FreezeRef
	2: Call is_preactive(&Validator): bool
	3: BrFalse(5)
B1:
	4: Branch(9)
B2:
	5: MoveLoc[0](Arg0: &mut Validator)
	6: Pop
	7: LdConst[10](u64: 10)
	8: Abort
B3:
	9: ImmBorrowLoc[1](Arg1: vector<u8>)
	10: VecLen(42)
	11: LdConst[17](u64: 256)
	12: Le
	13: BrFalse(15)
B4:
	14: Branch(19)
B5:
	15: MoveLoc[0](Arg0: &mut Validator)
	16: Pop
	17: LdConst[9](u64: 9)
	18: Abort
B6:
	19: MoveLoc[1](Arg1: vector<u8>)
	20: Call ascii::string(vector<u8>): String
	21: Call string::from_ascii(String): String
	22: CopyLoc[0](Arg0: &mut Validator)
	23: MutBorrowField[6](Validator.metadata: ValidatorMetadata)
	24: MutBorrowField[15](ValidatorMetadata.worker_address: String)
	25: WriteRef
	26: MoveLoc[0](Arg0: &mut Validator)
	27: ImmBorrowField[6](Validator.metadata: ValidatorMetadata)
	28: Call validate_metadata(&ValidatorMetadata)
	29: Ret
}

public(friend) update_next_epoch_protocol_pubkey(Arg0: &mut Validator, Arg1: vector<u8>, Arg2: vector<u8>) {
B0:
	0: MoveLoc[1](Arg1: vector<u8>)
	1: Call option::some<vector<u8>>(vector<u8>): Option<vector<u8>>
	2: CopyLoc[0](Arg0: &mut Validator)
	3: MutBorrowField[6](Validator.metadata: ValidatorMetadata)
	4: MutBorrowField[24](ValidatorMetadata.next_epoch_protocol_pubkey_bytes: Option<vector<u8>>)
	5: WriteRef
	6: MoveLoc[2](Arg2: vector<u8>)
	7: Call option::some<vector<u8>>(vector<u8>): Option<vector<u8>>
	8: CopyLoc[0](Arg0: &mut Validator)
	9: MutBorrowField[6](Validator.metadata: ValidatorMetadata)
	10: MutBorrowField[25](ValidatorMetadata.next_epoch_proof_of_possession: Option<vector<u8>>)
	11: WriteRef
	12: MoveLoc[0](Arg0: &mut Validator)
	13: ImmBorrowField[6](Validator.metadata: ValidatorMetadata)
	14: Call validate_metadata(&ValidatorMetadata)
	15: Ret
}

public(friend) update_candidate_protocol_pubkey(Arg0: &mut Validator, Arg1: vector<u8>, Arg2: vector<u8>) {
B0:
	0: CopyLoc[0](Arg0: &mut Validator)
	1: FreezeRef
	2: Call is_preactive(&Validator): bool
	3: BrFalse(5)
B1:
	4: Branch(9)
B2:
	5: MoveLoc[0](Arg0: &mut Validator)
	6: Pop
	7: LdConst[10](u64: 10)
	8: Abort
B3:
	9: MoveLoc[1](Arg1: vector<u8>)
	10: CopyLoc[0](Arg0: &mut Validator)
	11: MutBorrowField[6](Validator.metadata: ValidatorMetadata)
	12: MutBorrowField[16](ValidatorMetadata.protocol_pubkey_bytes: vector<u8>)
	13: WriteRef
	14: MoveLoc[2](Arg2: vector<u8>)
	15: CopyLoc[0](Arg0: &mut Validator)
	16: MutBorrowField[6](Validator.metadata: ValidatorMetadata)
	17: MutBorrowField[17](ValidatorMetadata.proof_of_possession: vector<u8>)
	18: WriteRef
	19: MoveLoc[0](Arg0: &mut Validator)
	20: ImmBorrowField[6](Validator.metadata: ValidatorMetadata)
	21: Call validate_metadata(&ValidatorMetadata)
	22: Ret
}

public(friend) update_next_epoch_network_pubkey(Arg0: &mut Validator, Arg1: vector<u8>) {
B0:
	0: MoveLoc[1](Arg1: vector<u8>)
	1: Call option::some<vector<u8>>(vector<u8>): Option<vector<u8>>
	2: CopyLoc[0](Arg0: &mut Validator)
	3: MutBorrowField[6](Validator.metadata: ValidatorMetadata)
	4: MutBorrowField[26](ValidatorMetadata.next_epoch_network_pubkey_bytes: Option<vector<u8>>)
	5: WriteRef
	6: MoveLoc[0](Arg0: &mut Validator)
	7: ImmBorrowField[6](Validator.metadata: ValidatorMetadata)
	8: Call validate_metadata(&ValidatorMetadata)
	9: Ret
}

public(friend) update_candidate_network_pubkey(Arg0: &mut Validator, Arg1: vector<u8>) {
B0:
	0: CopyLoc[0](Arg0: &mut Validator)
	1: FreezeRef
	2: Call is_preactive(&Validator): bool
	3: BrFalse(5)
B1:
	4: Branch(9)
B2:
	5: MoveLoc[0](Arg0: &mut Validator)
	6: Pop
	7: LdConst[10](u64: 10)
	8: Abort
B3:
	9: MoveLoc[1](Arg1: vector<u8>)
	10: CopyLoc[0](Arg0: &mut Validator)
	11: MutBorrowField[6](Validator.metadata: ValidatorMetadata)
	12: MutBorrowField[18](ValidatorMetadata.network_pubkey_bytes: vector<u8>)
	13: WriteRef
	14: MoveLoc[0](Arg0: &mut Validator)
	15: ImmBorrowField[6](Validator.metadata: ValidatorMetadata)
	16: Call validate_metadata(&ValidatorMetadata)
	17: Ret
}

public(friend) update_next_epoch_worker_pubkey(Arg0: &mut Validator, Arg1: vector<u8>) {
B0:
	0: MoveLoc[1](Arg1: vector<u8>)
	1: Call option::some<vector<u8>>(vector<u8>): Option<vector<u8>>
	2: CopyLoc[0](Arg0: &mut Validator)
	3: MutBorrowField[6](Validator.metadata: ValidatorMetadata)
	4: MutBorrowField[27](ValidatorMetadata.next_epoch_worker_pubkey_bytes: Option<vector<u8>>)
	5: WriteRef
	6: MoveLoc[0](Arg0: &mut Validator)
	7: ImmBorrowField[6](Validator.metadata: ValidatorMetadata)
	8: Call validate_metadata(&ValidatorMetadata)
	9: Ret
}

public(friend) update_candidate_worker_pubkey(Arg0: &mut Validator, Arg1: vector<u8>) {
B0:
	0: CopyLoc[0](Arg0: &mut Validator)
	1: FreezeRef
	2: Call is_preactive(&Validator): bool
	3: BrFalse(5)
B1:
	4: Branch(9)
B2:
	5: MoveLoc[0](Arg0: &mut Validator)
	6: Pop
	7: LdConst[10](u64: 10)
	8: Abort
B3:
	9: MoveLoc[1](Arg1: vector<u8>)
	10: CopyLoc[0](Arg0: &mut Validator)
	11: MutBorrowField[6](Validator.metadata: ValidatorMetadata)
	12: MutBorrowField[19](ValidatorMetadata.worker_pubkey_bytes: vector<u8>)
	13: WriteRef
	14: MoveLoc[0](Arg0: &mut Validator)
	15: ImmBorrowField[6](Validator.metadata: ValidatorMetadata)
	16: Call validate_metadata(&ValidatorMetadata)
	17: Ret
}

public(friend) effectuate_staged_metadata(Arg0: &mut Validator) {
L1:	loc0: &mut Option<String>
L2:	loc1: &mut Option<String>
L3:	loc2: &mut Option<vector<u8>>
L4:	loc3: &mut Option<vector<u8>>
L5:	loc4: &mut Option<vector<u8>>
L6:	loc5: &mut Option<String>
L7:	loc6: &mut Option<String>
B0:
	0: CopyLoc[0](Arg0: &mut Validator)
	1: MutBorrowField[6](Validator.metadata: ValidatorMetadata)
	2: MutBorrowField[20](ValidatorMetadata.next_epoch_net_address: Option<String>)
	3: StLoc[1](loc0: &mut Option<String>)
	4: CopyLoc[1](loc0: &mut Option<String>)
	5: FreezeRef
	6: Call option::is_some<String>(&Option<String>): bool
	7: BrFalse(15)
B1:
	8: MoveLoc[1](loc0: &mut Option<String>)
	9: Call option::extract<String>(&mut Option<String>): String
	10: CopyLoc[0](Arg0: &mut Validator)
	11: MutBorrowField[6](Validator.metadata: ValidatorMetadata)
	12: MutBorrowField[12](ValidatorMetadata.net_address: String)
	13: WriteRef
	14: Branch(17)
B2:
	15: MoveLoc[1](loc0: &mut Option<String>)
	16: Pop
B3:
	17: CopyLoc[0](Arg0: &mut Validator)
	18: MutBorrowField[6](Validator.metadata: ValidatorMetadata)
	19: MutBorrowField[21](ValidatorMetadata.next_epoch_p2p_address: Option<String>)
	20: StLoc[6](loc5: &mut Option<String>)
	21: CopyLoc[6](loc5: &mut Option<String>)
	22: FreezeRef
	23: Call option::is_some<String>(&Option<String>): bool
	24: BrFalse(32)
B4:
	25: MoveLoc[6](loc5: &mut Option<String>)
	26: Call option::extract<String>(&mut Option<String>): String
	27: CopyLoc[0](Arg0: &mut Validator)
	28: MutBorrowField[6](Validator.metadata: ValidatorMetadata)
	29: MutBorrowField[13](ValidatorMetadata.p2p_address: String)
	30: WriteRef
	31: Branch(34)
B5:
	32: MoveLoc[6](loc5: &mut Option<String>)
	33: Pop
B6:
	34: CopyLoc[0](Arg0: &mut Validator)
	35: MutBorrowField[6](Validator.metadata: ValidatorMetadata)
	36: MutBorrowField[22](ValidatorMetadata.next_epoch_primary_address: Option<String>)
	37: StLoc[7](loc6: &mut Option<String>)
	38: CopyLoc[7](loc6: &mut Option<String>)
	39: FreezeRef
	40: Call option::is_some<String>(&Option<String>): bool
	41: BrFalse(49)
B7:
	42: MoveLoc[7](loc6: &mut Option<String>)
	43: Call option::extract<String>(&mut Option<String>): String
	44: CopyLoc[0](Arg0: &mut Validator)
	45: MutBorrowField[6](Validator.metadata: ValidatorMetadata)
	46: MutBorrowField[14](ValidatorMetadata.primary_address: String)
	47: WriteRef
	48: Branch(51)
B8:
	49: MoveLoc[7](loc6: &mut Option<String>)
	50: Pop
B9:
	51: CopyLoc[0](Arg0: &mut Validator)
	52: MutBorrowField[6](Validator.metadata: ValidatorMetadata)
	53: MutBorrowField[23](ValidatorMetadata.next_epoch_worker_address: Option<String>)
	54: StLoc[2](loc1: &mut Option<String>)
	55: CopyLoc[2](loc1: &mut Option<String>)
	56: FreezeRef
	57: Call option::is_some<String>(&Option<String>): bool
	58: BrFalse(66)
B10:
	59: MoveLoc[2](loc1: &mut Option<String>)
	60: Call option::extract<String>(&mut Option<String>): String
	61: CopyLoc[0](Arg0: &mut Validator)
	62: MutBorrowField[6](Validator.metadata: ValidatorMetadata)
	63: MutBorrowField[15](ValidatorMetadata.worker_address: String)
	64: WriteRef
	65: Branch(68)
B11:
	66: MoveLoc[2](loc1: &mut Option<String>)
	67: Pop
B12:
	68: CopyLoc[0](Arg0: &mut Validator)
	69: MutBorrowField[6](Validator.metadata: ValidatorMetadata)
	70: MutBorrowField[24](ValidatorMetadata.next_epoch_protocol_pubkey_bytes: Option<vector<u8>>)
	71: StLoc[3](loc2: &mut Option<vector<u8>>)
	72: CopyLoc[3](loc2: &mut Option<vector<u8>>)
	73: FreezeRef
	74: Call option::is_some<vector<u8>>(&Option<vector<u8>>): bool
	75: BrFalse(91)
B13:
	76: MoveLoc[3](loc2: &mut Option<vector<u8>>)
	77: Call option::extract<vector<u8>>(&mut Option<vector<u8>>): vector<u8>
	78: CopyLoc[0](Arg0: &mut Validator)
	79: MutBorrowField[6](Validator.metadata: ValidatorMetadata)
	80: MutBorrowField[16](ValidatorMetadata.protocol_pubkey_bytes: vector<u8>)
	81: WriteRef
	82: CopyLoc[0](Arg0: &mut Validator)
	83: MutBorrowField[6](Validator.metadata: ValidatorMetadata)
	84: MutBorrowField[25](ValidatorMetadata.next_epoch_proof_of_possession: Option<vector<u8>>)
	85: Call option::extract<vector<u8>>(&mut Option<vector<u8>>): vector<u8>
	86: CopyLoc[0](Arg0: &mut Validator)
	87: MutBorrowField[6](Validator.metadata: ValidatorMetadata)
	88: MutBorrowField[17](ValidatorMetadata.proof_of_possession: vector<u8>)
	89: WriteRef
	90: Branch(93)
B14:
	91: MoveLoc[3](loc2: &mut Option<vector<u8>>)
	92: Pop
B15:
	93: CopyLoc[0](Arg0: &mut Validator)
	94: MutBorrowField[6](Validator.metadata: ValidatorMetadata)
	95: MutBorrowField[26](ValidatorMetadata.next_epoch_network_pubkey_bytes: Option<vector<u8>>)
	96: StLoc[4](loc3: &mut Option<vector<u8>>)
	97: CopyLoc[4](loc3: &mut Option<vector<u8>>)
	98: FreezeRef
	99: Call option::is_some<vector<u8>>(&Option<vector<u8>>): bool
	100: BrFalse(108)
B16:
	101: MoveLoc[4](loc3: &mut Option<vector<u8>>)
	102: Call option::extract<vector<u8>>(&mut Option<vector<u8>>): vector<u8>
	103: CopyLoc[0](Arg0: &mut Validator)
	104: MutBorrowField[6](Validator.metadata: ValidatorMetadata)
	105: MutBorrowField[18](ValidatorMetadata.network_pubkey_bytes: vector<u8>)
	106: WriteRef
	107: Branch(110)
B17:
	108: MoveLoc[4](loc3: &mut Option<vector<u8>>)
	109: Pop
B18:
	110: CopyLoc[0](Arg0: &mut Validator)
	111: MutBorrowField[6](Validator.metadata: ValidatorMetadata)
	112: MutBorrowField[27](ValidatorMetadata.next_epoch_worker_pubkey_bytes: Option<vector<u8>>)
	113: StLoc[5](loc4: &mut Option<vector<u8>>)
	114: CopyLoc[5](loc4: &mut Option<vector<u8>>)
	115: FreezeRef
	116: Call option::is_some<vector<u8>>(&Option<vector<u8>>): bool
	117: BrFalse(125)
B19:
	118: MoveLoc[5](loc4: &mut Option<vector<u8>>)
	119: Call option::extract<vector<u8>>(&mut Option<vector<u8>>): vector<u8>
	120: MoveLoc[0](Arg0: &mut Validator)
	121: MutBorrowField[6](Validator.metadata: ValidatorMetadata)
	122: MutBorrowField[19](ValidatorMetadata.worker_pubkey_bytes: vector<u8>)
	123: WriteRef
	124: Branch(129)
B20:
	125: MoveLoc[0](Arg0: &mut Validator)
	126: Pop
	127: MoveLoc[5](loc4: &mut Option<vector<u8>>)
	128: Pop
B21:
	129: Ret
}

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

native public validate_metadata_bcs(Arg0: vector<u8>);

public(friend) get_staking_pool_ref(Arg0: &Validator): &StakingPool {
B0:
	0: MoveLoc[0](Arg0: &Validator)
	1: ImmBorrowField[0](Validator.staking_pool: StakingPool)
	2: Ret
}

new_from_metadata(Arg0: ValidatorMetadata, Arg1: u64, Arg2: u64, Arg3: &mut TxContext): Validator {
L4:	loc0: ID
L5:	loc1: address
L6:	loc2: StakingPool
B0:
	0: ImmBorrowLoc[0](Arg0: ValidatorMetadata)
	1: ImmBorrowField[7](ValidatorMetadata.safe_address: address)
	2: ReadRef
	3: StLoc[5](loc1: address)
	4: CopyLoc[3](Arg3: &mut TxContext)
	5: Call staking_pool::new(&mut TxContext): StakingPool
	6: StLoc[6](loc2: StakingPool)
	7: MoveLoc[5](loc1: address)
	8: CopyLoc[3](Arg3: &mut TxContext)
	9: Call validator_cap::new_unverified_validator_operation_cap_and_transfer(address, &mut TxContext): ID
	10: StLoc[4](loc0: ID)
	11: MoveLoc[0](Arg0: ValidatorMetadata)
	12: LdU64(0)
	13: MoveLoc[4](loc0: ID)
	14: CopyLoc[1](Arg1: u64)
	15: MoveLoc[6](loc2: StakingPool)
	16: CopyLoc[2](Arg2: u64)
	17: LdU64(0)
	18: MoveLoc[1](Arg1: u64)
	19: MoveLoc[2](Arg2: u64)
	20: MoveLoc[3](Arg3: &mut TxContext)
	21: Call bag::new(&mut TxContext): Bag
	22: Pack[1](Validator)
	23: 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
	13 => u64: 100
	14 => u64: 101
	15 => u64: 102
	16 => u64: 2000
	17 => u64: 256
	18 => u64: 100000
]
}

// Move bytecode v6
module 3.validator_cap {
use 0000000000000000000000000000000000000000000000000000000000000002::object;
use 0000000000000000000000000000000000000000000000000000000000000002::transfer;
use 0000000000000000000000000000000000000000000000000000000000000002::tx_context;

struct UnverifiedValidatorOperationCap has store, key {
	id: UID,
	authorizer_validator_address: address
}

struct ValidatorOperationCap has drop {
	authorizer_validator_address: address
}

public(friend) unverified_operation_cap_address(Arg0: &UnverifiedValidatorOperationCap): &address {
B0:
	0: MoveLoc[0](Arg0: &UnverifiedValidatorOperationCap)
	1: ImmBorrowField[0](UnverifiedValidatorOperationCap.authorizer_validator_address: address)
	2: Ret
}

public(friend) verified_operation_cap_address(Arg0: &ValidatorOperationCap): &address {
B0:
	0: MoveLoc[0](Arg0: &ValidatorOperationCap)
	1: ImmBorrowField[1](ValidatorOperationCap.authorizer_validator_address: address)
	2: Ret
}

public(friend) new_unverified_validator_operation_cap_and_transfer(Arg0: address, Arg1: &mut TxContext): ID {
L2:	loc0: bool
L3:	loc1: UnverifiedValidatorOperationCap
L4:	loc2: ID
L5:	loc3: address
B0:
	0: CopyLoc[1](Arg1: &mut TxContext)
	1: FreezeRef
	2: Call tx_context::sender(&TxContext): address
	3: StLoc[5](loc3: address)
	4: CopyLoc[5](loc3: address)
	5: LdConst[0](address: 0x00..)
	6: Eq
	7: BrFalse(11)
B1:
	8: LdTrue
	9: StLoc[2](loc0: bool)
	10: Branch(15)
B2:
	11: MoveLoc[5](loc3: address)
	12: CopyLoc[0](Arg0: address)
	13: Eq
	14: StLoc[2](loc0: bool)
B3:
	15: MoveLoc[2](loc0: bool)
	16: BrFalse(18)
B4:
	17: Branch(22)
B5:
	18: MoveLoc[1](Arg1: &mut TxContext)
	19: Pop
	20: LdU64(0)
	21: Abort
B6:
	22: MoveLoc[1](Arg1: &mut TxContext)
	23: Call object::new(&mut TxContext): UID
	24: CopyLoc[0](Arg0: address)
	25: Pack[0](UnverifiedValidatorOperationCap)
	26: StLoc[3](loc1: UnverifiedValidatorOperationCap)
	27: ImmBorrowLoc[3](loc1: UnverifiedValidatorOperationCap)
	28: Call object::id<UnverifiedValidatorOperationCap>(&UnverifiedValidatorOperationCap): ID
	29: StLoc[4](loc2: ID)
	30: MoveLoc[3](loc1: UnverifiedValidatorOperationCap)
	31: MoveLoc[0](Arg0: address)
	32: Call transfer::public_transfer<UnverifiedValidatorOperationCap>(UnverifiedValidatorOperationCap, address)
	33: MoveLoc[4](loc2: ID)
	34: Ret
}

public(friend) into_verified(Arg0: &UnverifiedValidatorOperationCap): ValidatorOperationCap {
B0:
	0: MoveLoc[0](Arg0: &UnverifiedValidatorOperationCap)
	1: ImmBorrowField[0](UnverifiedValidatorOperationCap.authorizer_validator_address: address)
	2: ReadRef
	3: Pack[1](ValidatorOperationCap)
	4: Ret
}

Constants [
	0 => address: 0x0000000000000000000000000000000000000000000000000000000000000000
]
}

// Move bytecode v6
module 3.validator_set {
use 0000000000000000000000000000000000000000000000000000000000000002::bag;
use 0000000000000000000000000000000000000000000000000000000000000002::balance;
use 0000000000000000000000000000000000000000000000000000000000000002::event;
use 0000000000000000000000000000000000000000000000000000000000000002::object;
use 0000000000000000000000000000000000000000000000000000000000000002::priority_queue;
use 0000000000000000000000000000000000000000000000000000000000000002::safe;
use 0000000000000000000000000000000000000000000000000000000000000002::table;
use 0000000000000000000000000000000000000000000000000000000000000002::table_vec;
use 0000000000000000000000000000000000000000000000000000000000000002::transfer;
use 0000000000000000000000000000000000000000000000000000000000000002::tx_context;
use 0000000000000000000000000000000000000000000000000000000000000002::vec_map;
use 0000000000000000000000000000000000000000000000000000000000000002::vec_set;
use 0000000000000000000000000000000000000000000000000000000000000003::staking_pool;
use 0000000000000000000000000000000000000000000000000000000000000003::validator;
use 0000000000000000000000000000000000000000000000000000000000000003::validator_cap;
use 0000000000000000000000000000000000000000000000000000000000000003::validator_wrapper;
use 0000000000000000000000000000000000000000000000000000000000000003::voting_power;
use 0000000000000000000000000000000000000000000000000000000000000001::option;
use 0000000000000000000000000000000000000000000000000000000000000001::vector;

struct ValidatorSet has store {
	total_stake: u64,
	active_validators: vector<Validator>,
	pending_active_validators: TableVec<Validator>,
	pending_removals: vector<u64>,
	staking_pool_mappings: Table<ID, address>,
	inactive_validators: Table<ID, ValidatorWrapper>,
	validator_candidates: Table<address, ValidatorWrapper>,
	at_risk_validators: VecMap<address, u64>,
	extra_fields: Bag
}

struct ValidatorEpochInfoEvent has copy, drop {
	epoch: u64,
	validator_address: address,
	reference_gas_survey_quote: u64,
	stake: u64,
	commission_rate: u64,
	pool_staking_reward: u64,
	storage_fund_staking_reward: u64,
	pool_token_exchange_rate: PoolTokenExchangeRate,
	tallying_rule_reporters: vector<address>,
	tallying_rule_global_score: u64
}

struct ValidatorEpochInfoEventV2 has copy, drop {
	epoch: u64,
	validator_address: address,
	reference_gas_survey_quote: u64,
	stake: u64,
	voting_power: u64,
	commission_rate: u64,
	pool_staking_reward: u64,
	storage_fund_staking_reward: u64,
	pool_token_exchange_rate: PoolTokenExchangeRate,
	tallying_rule_reporters: vector<address>,
	tallying_rule_global_score: u64
}

struct ValidatorJoinEvent has copy, drop {
	epoch: u64,
	validator_address: address,
	staking_pool_id: ID
}

struct ValidatorLeaveEvent has copy, drop {
	epoch: u64,
	validator_address: address,
	staking_pool_id: ID,
	is_voluntary: bool
}

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

public(friend) new(Arg0: vector<Validator>, Arg1: &mut TxContext): ValidatorSet {
L2:	loc0: u64
L3:	loc1: u64
L4:	loc2: u64
L5:	loc3: Table<ID, address>
L6:	loc4: u64
L7:	loc5: u64
L8:	loc6: &vector<Validator>
L9:	loc7: &Validator
L10:	loc8: ValidatorSet
B0:
	0: ImmBorrowLoc[0](Arg0: vector<Validator>)
	1: Call calculate_total_stakes(&vector<Validator>): u64
	2: StLoc[7](loc5: u64)
	3: CopyLoc[1](Arg1: &mut TxContext)
	4: Call table::new<ID, address>(&mut TxContext): Table<ID, address>
	5: StLoc[5](loc3: Table<ID, address>)
	6: ImmBorrowLoc[0](Arg0: vector<Validator>)
	7: StLoc[8](loc6: &vector<Validator>)
	8: CopyLoc[8](loc6: &vector<Validator>)
	9: VecLen(67)
	10: StLoc[2](loc0: u64)
	11: LdU64(0)
	12: StLoc[3](loc1: u64)
	13: MoveLoc[2](loc0: u64)
	14: StLoc[6](loc4: u64)
B1:
	15: CopyLoc[3](loc1: u64)
	16: CopyLoc[6](loc4: u64)
	17: Lt
	18: BrFalse(36)
B2:
	19: CopyLoc[3](loc1: u64)
	20: StLoc[4](loc2: u64)
	21: CopyLoc[8](loc6: &vector<Validator>)
	22: MoveLoc[4](loc2: u64)
	23: VecImmBorrow(67)
	24: StLoc[9](loc7: &Validator)
	25: MutBorrowLoc[5](loc3: Table<ID, address>)
	26: CopyLoc[9](loc7: &Validator)
	27: Call validator::staking_pool_id(&Validator): ID
	28: MoveLoc[9](loc7: &Validator)
	29: Call validator::safe_address(&Validator): address
	30: Call table::add<ID, address>(&mut Table<ID, address>, ID, address)
	31: MoveLoc[3](loc1: u64)
	32: LdU64(1)
	33: Add
	34: StLoc[3](loc1: u64)
	35: Branch(15)
B3:
	36: MoveLoc[8](loc6: &vector<Validator>)
	37: Pop
	38: CopyLoc[7](loc5: u64)
	39: MoveLoc[0](Arg0: vector<Validator>)
	40: CopyLoc[1](Arg1: &mut TxContext)
	41: Call table_vec::empty<Validator>(&mut TxContext): TableVec<Validator>
	42: LdConst[21](vector<u64>: 00)
	43: MoveLoc[5](loc3: Table<ID, address>)
	44: CopyLoc[1](Arg1: &mut TxContext)
	45: Call table::new<ID, ValidatorWrapper>(&mut TxContext): Table<ID, ValidatorWrapper>
	46: CopyLoc[1](Arg1: &mut TxContext)
	47: Call table::new<address, ValidatorWrapper>(&mut TxContext): Table<address, ValidatorWrapper>
	48: Call vec_map::empty<address, u64>(): VecMap<address, u64>
	49: MoveLoc[1](Arg1: &mut TxContext)
	50: Call bag::new(&mut TxContext): Bag
	51: Pack[0](ValidatorSet)
	52: StLoc[10](loc8: ValidatorSet)
	53: MutBorrowLoc[10](loc8: ValidatorSet)
	54: MutBorrowField[0](ValidatorSet.active_validators: vector<Validator>)
	55: MoveLoc[7](loc5: u64)
	56: Call voting_power::set_voting_power(&mut vector<Validator>, u64)
	57: MoveLoc[10](loc8: ValidatorSet)
	58: Ret
}

public(friend) request_add_validator_candidate(Arg0: &mut ValidatorSet, Arg1: Validator, Arg2: &mut TxContext) {
L3:	loc0: bool
L4:	loc1: address
B0:
	0: CopyLoc[0](Arg0: &mut ValidatorSet)
	1: FreezeRef
	2: ImmBorrowLoc[1](Arg1: Validator)
	3: Call is_duplicate_with_active_validator(&ValidatorSet, &Validator): bool
	4: Not
	5: BrFalse(13)
B1:
	6: CopyLoc[0](Arg0: &mut ValidatorSet)
	7: FreezeRef
	8: ImmBorrowLoc[1](Arg1: Validator)
	9: Call is_duplicate_with_pending_validator(&ValidatorSet, &Validator): bool
	10: Not
	11: StLoc[3](loc0: bool)
	12: Branch(15)
B2:
	13: LdFalse
	14: StLoc[3](loc0: bool)
B3:
	15: MoveLoc[3](loc0: bool)
	16: BrFalse(18)
B4:
	17: Branch(24)
B5:
	18: MoveLoc[0](Arg0: &mut ValidatorSet)
	19: Pop
	20: MoveLoc[2](Arg2: &mut TxContext)
	21: Pop
	22: LdConst[2](u64: 2)
	23: Abort
B6:
	24: ImmBorrowLoc[1](Arg1: Validator)
	25: Call validator::safe_address(&Validator): address
	26: StLoc[4](loc1: address)
	27: CopyLoc[0](Arg0: &mut ValidatorSet)
	28: ImmBorrowField[1](ValidatorSet.validator_candidates: Table<address, ValidatorWrapper>)
	29: CopyLoc[4](loc1: address)
	30: Call table::contains<address, ValidatorWrapper>(&Table<address, ValidatorWrapper>, address): bool
	31: Not
	32: BrFalse(34)
B7:
	33: Branch(40)
B8:
	34: MoveLoc[0](Arg0: &mut ValidatorSet)
	35: Pop
	36: MoveLoc[2](Arg2: &mut TxContext)
	37: Pop
	38: LdConst[6](u64: 6)
	39: Abort
B9:
	40: ImmBorrowLoc[1](Arg1: Validator)
	41: Call validator::is_preactive(&Validator): bool
	42: BrFalse(44)
B10:
	43: Branch(50)
B11:
	44: MoveLoc[0](Arg0: &mut ValidatorSet)
	45: Pop
	46: MoveLoc[2](Arg2: &mut TxContext)
	47: Pop
	48: LdConst[7](u64: 7)
	49: Abort
B12:
	50: CopyLoc[0](Arg0: &mut ValidatorSet)
	51: MutBorrowField[2](ValidatorSet.staking_pool_mappings: Table<ID, address>)
	52: ImmBorrowLoc[1](Arg1: Validator)
	53: Call validator::staking_pool_id(&Validator): ID
	54: MoveLoc[4](loc1: address)
	55: Call table::add<ID, address>(&mut Table<ID, address>, ID, address)
	56: MoveLoc[0](Arg0: &mut ValidatorSet)
	57: MutBorrowField[1](ValidatorSet.validator_candidates: Table<address, ValidatorWrapper>)
	58: ImmBorrowLoc[1](Arg1: Validator)
	59: Call validator::safe_address(&Validator): address
	60: MoveLoc[1](Arg1: Validator)
	61: MoveLoc[2](Arg2: &mut TxContext)
	62: Call validator_wrapper::create_v1(Validator, &mut TxContext): ValidatorWrapper
	63: Call table::add<address, ValidatorWrapper>(&mut Table<address, ValidatorWrapper>, address, ValidatorWrapper)
	64: Ret
}

public(friend) request_remove_validator_candidate(Arg0: &mut ValidatorSet, Arg1: &mut TxContext) {
L2:	loc0: ID
L3:	loc1: Validator
L4:	loc2: address
B0:
	0: CopyLoc[1](Arg1: &mut TxContext)
	1: FreezeRef
	2: Call tx_context::sender(&TxContext): address
	3: StLoc[4](loc2: address)
	4: CopyLoc[0](Arg0: &mut ValidatorSet)
	5: ImmBorrowField[1](ValidatorSet.validator_candidates: Table<address, ValidatorWrapper>)
	6: CopyLoc[4](loc2: address)
	7: Call table::contains<address, ValidatorWrapper>(&Table<address, ValidatorWrapper>, address): bool
	8: BrFalse(10)
B1:
	9: Branch(16)
B2:
	10: MoveLoc[0](Arg0: &mut ValidatorSet)
	11: Pop
	12: MoveLoc[1](Arg1: &mut TxContext)
	13: Pop
	14: LdConst[8](u64: 8)
	15: Abort
B3:
	16: CopyLoc[0](Arg0: &mut ValidatorSet)
	17: MutBorrowField[1](ValidatorSet.validator_candidates: Table<address, ValidatorWrapper>)
	18: MoveLoc[4](loc2: address)
	19: Call table::remove<address, ValidatorWrapper>(&mut Table<address, ValidatorWrapper>, address): ValidatorWrapper
	20: Call validator_wrapper::destroy(ValidatorWrapper): Validator
	21: StLoc[3](loc1: Validator)
	22: ImmBorrowLoc[3](loc1: Validator)
	23: Call validator::is_preactive(&Validator): bool
	24: BrFalse(26)
B4:
	25: Branch(32)
B5:
	26: MoveLoc[0](Arg0: &mut ValidatorSet)
	27: Pop
	28: MoveLoc[1](Arg1: &mut TxContext)
	29: Pop
	30: LdConst[7](u64: 7)
	31: Abort
B6:
	32: ImmBorrowLoc[3](loc1: Validator)
	33: Call validator::staking_pool_id(&Validator): ID
	34: StLoc[2](loc0: ID)
	35: CopyLoc[0](Arg0: &mut ValidatorSet)
	36: MutBorrowField[2](ValidatorSet.staking_pool_mappings: Table<ID, address>)
	37: CopyLoc[2](loc0: ID)
	38: Call table::remove<ID, address>(&mut Table<ID, address>, ID): address
	39: Pop
	40: MutBorrowLoc[3](loc1: Validator)
	41: CopyLoc[1](Arg1: &mut TxContext)
	42: FreezeRef
	43: Call tx_context::epoch(&TxContext): u64
	44: Call validator::deactivate(&mut Validator, u64)
	45: MoveLoc[0](Arg0: &mut ValidatorSet)
	46: MutBorrowField[3](ValidatorSet.inactive_validators: Table<ID, ValidatorWrapper>)
	47: MoveLoc[2](loc0: ID)
	48: MoveLoc[3](loc1: Validator)
	49: MoveLoc[1](Arg1: &mut TxContext)
	50: Call validator_wrapper::create_v1(Validator, &mut TxContext): ValidatorWrapper
	51: Call table::add<ID, ValidatorWrapper>(&mut Table<ID, ValidatorWrapper>, ID, ValidatorWrapper)
	52: Ret
}

public(friend) request_add_validator(Arg0: &mut ValidatorSet, Arg1: &TxContext) {
L2:	loc0: bool
L3:	loc1: Validator
L4:	loc2: address
B0:
	0: CopyLoc[1](Arg1: &TxContext)
	1: Call tx_context::sender(&TxContext): address
	2: StLoc[4](loc2: address)
	3: CopyLoc[0](Arg0: &mut ValidatorSet)
	4: ImmBorrowField[1](ValidatorSet.validator_candidates: Table<address, ValidatorWrapper>)
	5: CopyLoc[4](loc2: address)
	6: Call table::contains<address, ValidatorWrapper>(&Table<address, ValidatorWrapper>, address): bool
	7: BrFalse(9)
B1:
	8: Branch(15)
B2:
	9: MoveLoc[0](Arg0: &mut ValidatorSet)
	10: Pop
	11: MoveLoc[1](Arg1: &TxContext)
	12: Pop
	13: LdConst[8](u64: 8)
	14: Abort
B3:
	15: CopyLoc[0](Arg0: &mut ValidatorSet)
	16: MutBorrowField[1](ValidatorSet.validator_candidates: Table<address, ValidatorWrapper>)
	17: MoveLoc[4](loc2: address)
	18: Call table::remove<address, ValidatorWrapper>(&mut Table<address, ValidatorWrapper>, address): ValidatorWrapper
	19: Call validator_wrapper::destroy(ValidatorWrapper): Validator
	20: StLoc[3](loc1: Validator)
	21: CopyLoc[0](Arg0: &mut ValidatorSet)
	22: FreezeRef
	23: ImmBorrowLoc[3](loc1: Validator)
	24: Call is_duplicate_with_active_validator(&ValidatorSet, &Validator): bool
	25: Not
	26: BrFalse(34)
B4:
	27: CopyLoc[0](Arg0: &mut ValidatorSet)
	28: FreezeRef
	29: ImmBorrowLoc[3](loc1: Validator)
	30: Call is_duplicate_with_pending_validator(&ValidatorSet, &Validator): bool
	31: Not
	32: StLoc[2](loc0: bool)
	33: Branch(36)
B5:
	34: LdFalse
	35: StLoc[2](loc0: bool)
B6:
	36: MoveLoc[2](loc0: bool)
	37: BrFalse(39)
B7:
	38: Branch(45)
B8:
	39: MoveLoc[0](Arg0: &mut ValidatorSet)
	40: Pop
	41: MoveLoc[1](Arg1: &TxContext)
	42: Pop
	43: LdConst[2](u64: 2)
	44: Abort
B9:
	45: ImmBorrowLoc[3](loc1: Validator)
	46: Call validator::is_preactive(&Validator): bool
	47: BrFalse(49)
B10:
	48: Branch(55)
B11:
	49: MoveLoc[0](Arg0: &mut ValidatorSet)
	50: Pop
	51: MoveLoc[1](Arg1: &TxContext)
	52: Pop
	53: LdConst[7](u64: 7)
	54: Abort
B12:
	55: CopyLoc[0](Arg0: &mut ValidatorSet)
	56: FreezeRef
	57: ImmBorrowLoc[3](loc1: Validator)
	58: Call validator::total_stake(&Validator): u64
	59: MoveLoc[1](Arg1: &TxContext)
	60: Call can_join(&ValidatorSet, u64, &TxContext): bool
	61: BrFalse(63)
B13:
	62: Branch(67)
B14:
	63: MoveLoc[0](Arg0: &mut ValidatorSet)
	64: Pop
	65: LdConst[5](u64: 5)
	66: Abort
B15:
	67: MoveLoc[0](Arg0: &mut ValidatorSet)
	68: MutBorrowField[4](ValidatorSet.pending_active_validators: TableVec<Validator>)
	69: MoveLoc[3](loc1: Validator)
	70: Call table_vec::push_back<Validator>(&mut TableVec<Validator>, Validator)
	71: Ret
}

can_join(Arg0: &ValidatorSet, Arg1: u64, Arg2: &TxContext): bool {
L3:	loc0: u64
L4:	loc1: u64
B0:
	0: CopyLoc[0](Arg0: &ValidatorSet)
	1: MoveLoc[2](Arg2: &TxContext)
	2: Call get_voting_power_thresholds(&ValidatorSet, &TxContext): u64 * u64 * u64
	3: Pop
	4: Pop
	5: StLoc[4](loc1: u64)
	6: MoveLoc[0](Arg0: &ValidatorSet)
	7: ImmBorrowField[5](ValidatorSet.total_stake: u64)
	8: ReadRef
	9: CopyLoc[1](Arg1: u64)
	10: Add
	11: StLoc[3](loc0: u64)
	12: MoveLoc[1](Arg1: u64)
	13: MoveLoc[3](loc0: u64)
	14: Call voting_power::derive_raw_voting_power(u64, u64): u64
	15: MoveLoc[4](loc1: u64)
	16: Ge
	17: Ret
}

get_voting_power_thresholds(Arg0: &ValidatorSet, Arg1: &TxContext): u64 * u64 * u64 {
L2:	loc0: u64
L3:	loc1: u64
L4:	loc2: u64
L5:	loc3: u64
L6:	loc4: u64
L7:	loc5: u64
L8:	loc6: u64
L9:	loc7: u64
L10:	loc8: VotingPowerAdmissionStartEpochKey
L11:	loc9: u64
B0:
	0: LdFalse
	1: Pack[5](VotingPowerAdmissionStartEpochKey)
	2: StLoc[10](loc8: VotingPowerAdmissionStartEpochKey)
	3: CopyLoc[0](Arg0: &ValidatorSet)
	4: ImmBorrowField[6](ValidatorSet.extra_fields: Bag)
	5: CopyLoc[10](loc8: VotingPowerAdmissionStartEpochKey)
	6: Call bag::contains<VotingPowerAdmissionStartEpochKey>(&Bag, VotingPowerAdmissionStartEpochKey): bool
	7: BrFalse(15)
B1:
	8: MoveLoc[0](Arg0: &ValidatorSet)
	9: ImmBorrowField[6](ValidatorSet.extra_fields: Bag)
	10: MoveLoc[10](loc8: VotingPowerAdmissionStartEpochKey)
	11: Call bag::borrow<VotingPowerAdmissionStartEpochKey, u64>(&Bag, VotingPowerAdmissionStartEpochKey): &u64
	12: ReadRef
	13: StLoc[2](loc0: u64)
	14: Branch(22)
B2:
	15: MoveLoc[0](Arg0: &ValidatorSet)
	16: Pop
	17: CopyLoc[1](Arg1: &TxContext)
	18: Call tx_context::epoch(&TxContext): u64
	19: LdU64(1)
	20: Add
	21: StLoc[2](loc0: u64)
B3:
	22: MoveLoc[2](loc0: u64)
	23: StLoc[11](loc9: u64)
	24: MoveLoc[1](Arg1: &TxContext)
	25: Call tx_context::epoch(&TxContext): u64
	26: StLoc[9](loc7: u64)
	27: CopyLoc[9](loc7: u64)
	28: CopyLoc[11](loc9: u64)
	29: LdConst[20](u64: 14)
	30: Add
	31: Lt
	32: BrFalse(40)
B4:
	33: LdU64(12)
	34: LdU64(8)
	35: LdU64(4)
	36: StLoc[8](loc6: u64)
	37: StLoc[7](loc5: u64)
	38: StLoc[6](loc4: u64)
	39: Branch(67)
B5:
	40: MoveLoc[9](loc7: u64)
	41: MoveLoc[11](loc9: u64)
	42: LdU64(2)
	43: LdConst[20](u64: 14)
	44: Mul
	45: Add
	46: Lt
	47: BrFalse(55)
B6:
	48: LdU64(6)
	49: LdU64(4)
	50: LdU64(2)
	51: StLoc[5](loc3: u64)
	52: StLoc[4](loc2: u64)
	53: StLoc[3](loc1: u64)
	54: Branch(61)
B7:
	55: LdU64(3)
	56: LdU64(2)
	57: LdU64(1)
	58: StLoc[5](loc3: u64)
	59: StLoc[4](loc2: u64)
	60: StLoc[3](loc1: u64)
B8:
	61: MoveLoc[3](loc1: u64)
	62: MoveLoc[4](loc2: u64)
	63: MoveLoc[5](loc3: u64)
	64: StLoc[8](loc6: u64)
	65: StLoc[7](loc5: u64)
	66: StLoc[6](loc4: u64)
B9:
	67: MoveLoc[6](loc4: u64)
	68: MoveLoc[7](loc5: u64)
	69: MoveLoc[8](loc6: u64)
	70: Ret
}

public(friend) assert_no_pending_or_active_duplicates(Arg0: &ValidatorSet, Arg1: &Validator) {
B0:
	0: CopyLoc[0](Arg0: &ValidatorSet)
	1: ImmBorrowField[0](ValidatorSet.active_validators: vector<Validator>)
	2: CopyLoc[1](Arg1: &Validator)
	3: Call count_duplicates_vec(&vector<Validator>, &Validator): u64
	4: MoveLoc[0](Arg0: &ValidatorSet)
	5: ImmBorrowField[4](ValidatorSet.pending_active_validators: TableVec<Validator>)
	6: MoveLoc[1](Arg1: &Validator)
	7: Call count_duplicates_tablevec(&TableVec<Validator>, &Validator): u64
	8: Add
	9: LdU64(1)
	10: Eq
	11: BrFalse(13)
B1:
	12: Branch(15)
B2:
	13: LdConst[2](u64: 2)
	14: Abort
B3:
	15: Ret
}

public(friend) request_remove_validator(Arg0: &mut ValidatorSet, Arg1: &TxContext) {
L2:	loc0: Option<u64>
L3:	loc1: address
L4:	loc2: u64
B0:
	0: MoveLoc[1](Arg1: &TxContext)
	1: Call tx_context::sender(&TxContext): address
	2: StLoc[3](loc1: address)
	3: CopyLoc[0](Arg0: &mut ValidatorSet)
	4: ImmBorrowField[0](ValidatorSet.active_validators: vector<Validator>)
	5: MoveLoc[3](loc1: address)
	6: Call find_validator(&vector<Validator>, address): Option<u64>
	7: StLoc[2](loc0: Option<u64>)
	8: ImmBorrowLoc[2](loc0: Option<u64>)
	9: Call option::is_some<u64>(&Option<u64>): bool
	10: BrFalse(12)
B1:
	11: Branch(18)
B2:
	12: MoveLoc[0](Arg0: &mut ValidatorSet)
	13: Pop
	14: MoveLoc[2](loc0: Option<u64>)
	15: Call option::destroy_none<u64>(Option<u64>)
	16: LdConst[4](u64: 4)
	17: Abort
B3:
	18: MoveLoc[2](loc0: Option<u64>)
	19: Call option::destroy_some<u64>(Option<u64>): u64
	20: StLoc[4](loc2: u64)
	21: CopyLoc[0](Arg0: &mut ValidatorSet)
	22: ImmBorrowField[7](ValidatorSet.pending_removals: vector<u64>)
	23: ImmBorrowLoc[4](loc2: u64)
	24: Call vector::contains<u64>(&vector<u64>, &u64): bool
	25: Not
	26: BrFalse(28)
B4:
	27: Branch(32)
B5:
	28: MoveLoc[0](Arg0: &mut ValidatorSet)
	29: Pop
	30: LdConst[11](u64: 11)
	31: Abort
B6:
	32: MoveLoc[0](Arg0: &mut ValidatorSet)
	33: MutBorrowField[7](ValidatorSet.pending_removals: vector<u64>)
	34: MoveLoc[4](loc2: u64)
	35: VecPushBack(21)
	36: Ret
}

public(friend) request_add_stake(Arg0: &mut ValidatorSet, Arg1: address, Arg2: Balance<SAFE>, Arg3: &mut TxContext): StakedSafe {
B0:
	0: ImmBorrowLoc[2](Arg2: Balance<SAFE>)
	1: Call balance::value<SAFE>(&Balance<SAFE>): u64
	2: LdConst[19](u64: 1000..)
	3: Ge
	4: BrFalse(6)
B1:
	5: Branch(12)
B2:
	6: MoveLoc[0](Arg0: &mut ValidatorSet)
	7: Pop
	8: MoveLoc[3](Arg3: &mut TxContext)
	9: Pop
	10: LdConst[10](u64: 10)
	11: Abort
B3:
	12: MoveLoc[0](Arg0: &mut ValidatorSet)
	13: MoveLoc[1](Arg1: address)
	14: Call get_candidate_or_active_validator_mut(&mut ValidatorSet, address): &mut Validator
	15: MoveLoc[2](Arg2: Balance<SAFE>)
	16: CopyLoc[3](Arg3: &mut TxContext)
	17: FreezeRef
	18: Call tx_context::sender(&TxContext): address
	19: MoveLoc[3](Arg3: &mut TxContext)
	20: Call validator::request_add_stake(&mut Validator, Balance<SAFE>, address, &mut TxContext): StakedSafe
	21: Ret
}

public(friend) request_withdraw_stake(Arg0: &mut ValidatorSet, Arg1: StakedSafe, Arg2: &TxContext): Balance<SAFE> {
L3:	loc0: &mut Validator
L4:	loc1: ID
L5:	loc2: address
B0:
	0: ImmBorrowLoc[1](Arg1: StakedSafe)
	1: Call staking_pool::pool_id(&StakedSafe): ID
	2: StLoc[4](loc1: ID)
	3: CopyLoc[0](Arg0: &mut ValidatorSet)
	4: ImmBorrowField[2](ValidatorSet.staking_pool_mappings: Table<ID, address>)
	5: CopyLoc[4](loc1: ID)
	6: Call table::contains<ID, address>(&Table<ID, address>, ID): bool
	7: BrFalse(20)
B1:
	8: CopyLoc[0](Arg0: &mut ValidatorSet)
	9: ImmBorrowField[2](ValidatorSet.staking_pool_mappings: Table<ID, address>)
	10: ImmBorrowLoc[1](Arg1: StakedSafe)
	11: Call staking_pool::pool_id(&StakedSafe): ID
	12: Call table::borrow<ID, address>(&Table<ID, address>, ID): &address
	13: ReadRef
	14: StLoc[5](loc2: address)
	15: MoveLoc[0](Arg0: &mut ValidatorSet)
	16: MoveLoc[5](loc2: address)
	17: Call get_candidate_or_active_validator_mut(&mut ValidatorSet, address): &mut Validator
	18: StLoc[3](loc0: &mut Validator)
	19: Branch(38)
B2:
	20: CopyLoc[0](Arg0: &mut ValidatorSet)
	21: ImmBorrowField[3](ValidatorSet.inactive_validators: Table<ID, ValidatorWrapper>)
	22: CopyLoc[4](loc1: ID)
	23: Call table::contains<ID, ValidatorWrapper>(&Table<ID, ValidatorWrapper>, ID): bool
	24: BrFalse(26)
B3:
	25: Branch(32)
B4:
	26: MoveLoc[0](Arg0: &mut ValidatorSet)
	27: Pop
	28: MoveLoc[2](Arg2: &TxContext)
	29: Pop
	30: LdConst[3](u64: 3)
	31: Abort
B5:
	32: MoveLoc[0](Arg0: &mut ValidatorSet)
	33: MutBorrowField[3](ValidatorSet.inactive_validators: Table<ID, ValidatorWrapper>)
	34: MoveLoc[4](loc1: ID)
	35: Call table::borrow_mut<ID, ValidatorWrapper>(&mut Table<ID, ValidatorWrapper>, ID): &mut ValidatorWrapper
	36: Call validator_wrapper::load_validator_maybe_upgrade(&mut ValidatorWrapper): &mut Validator
	37: StLoc[3](loc0: &mut Validator)
B6:
	38: MoveLoc[3](loc0: &mut Validator)
	39: MoveLoc[1](Arg1: StakedSafe)
	40: MoveLoc[2](Arg2: &TxContext)
	41: Call validator::request_withdraw_stake(&mut Validator, StakedSafe, &TxContext): Balance<SAFE>
	42: Ret
}

public(friend) convert_to_fungible_staked_safe(Arg0: &mut ValidatorSet, Arg1: StakedSafe, Arg2: &mut TxContext): FungibleStakedSafe {
L3:	loc0: &mut Validator
L4:	loc1: ID
L5:	loc2: address
B0:
	0: ImmBorrowLoc[1](Arg1: StakedSafe)
	1: Call staking_pool::pool_id(&StakedSafe): ID
	2: StLoc[4](loc1: ID)
	3: CopyLoc[0](Arg0: &mut ValidatorSet)
	4: ImmBorrowField[2](ValidatorSet.staking_pool_mappings: Table<ID, address>)
	5: CopyLoc[4](loc1: ID)
	6: Call table::contains<ID, address>(&Table<ID, address>, ID): bool
	7: BrFalse(19)
B1:
	8: CopyLoc[0](Arg0: &mut ValidatorSet)
	9: ImmBorrowField[2](ValidatorSet.staking_pool_mappings: Table<ID, address>)
	10: MoveLoc[4](loc1: ID)
	11: Call table::borrow<ID, address>(&Table<ID, address>, ID): &address
	12: ReadRef
	13: StLoc[5](loc2: address)
	14: MoveLoc[0](Arg0: &mut ValidatorSet)
	15: MoveLoc[5](loc2: address)
	16: Call get_candidate_or_active_validator_mut(&mut ValidatorSet, address): &mut Validator
	17: StLoc[3](loc0: &mut Validator)
	18: Branch(37)
B2:
	19: CopyLoc[0](Arg0: &mut ValidatorSet)
	20: ImmBorrowField[3](ValidatorSet.inactive_validators: Table<ID, ValidatorWrapper>)
	21: CopyLoc[4](loc1: ID)
	22: Call table::contains<ID, ValidatorWrapper>(&Table<ID, ValidatorWrapper>, ID): bool
	23: BrFalse(25)
B3:
	24: Branch(31)
B4:
	25: MoveLoc[0](Arg0: &mut ValidatorSet)
	26: Pop
	27: MoveLoc[2](Arg2: &mut TxContext)
	28: Pop
	29: LdConst[3](u64: 3)
	30: Abort
B5:
	31: MoveLoc[0](Arg0: &mut ValidatorSet)
	32: MutBorrowField[3](ValidatorSet.inactive_validators: Table<ID, ValidatorWrapper>)
	33: MoveLoc[4](loc1: ID)
	34: Call table::borrow_mut<ID, ValidatorWrapper>(&mut Table<ID, ValidatorWrapper>, ID): &mut ValidatorWrapper
	35: Call validator_wrapper::load_validator_maybe_upgrade(&mut ValidatorWrapper): &mut Validator
	36: StLoc[3](loc0: &mut Validator)
B6:
	37: MoveLoc[3](loc0: &mut Validator)
	38: MoveLoc[1](Arg1: StakedSafe)
	39: MoveLoc[2](Arg2: &mut TxContext)
	40: Call validator::convert_to_fungible_staked_safe(&mut Validator, StakedSafe, &mut TxContext): FungibleStakedSafe
	41: Ret
}

public(friend) redeem_fungible_staked_safe(Arg0: &mut ValidatorSet, Arg1: FungibleStakedSafe, Arg2: &TxContext): Balance<SAFE> {
L3:	loc0: &mut Validator
L4:	loc1: ID
L5:	loc2: address
B0:
	0: ImmBorrowLoc[1](Arg1: FungibleStakedSafe)
	1: Call staking_pool::fungible_staked_safe_pool_id(&FungibleStakedSafe): ID
	2: StLoc[4](loc1: ID)
	3: CopyLoc[0](Arg0: &mut ValidatorSet)
	4: ImmBorrowField[2](ValidatorSet.staking_pool_mappings: Table<ID, address>)
	5: CopyLoc[4](loc1: ID)
	6: Call table::contains<ID, address>(&Table<ID, address>, ID): bool
	7: BrFalse(19)
B1:
	8: CopyLoc[0](Arg0: &mut ValidatorSet)
	9: ImmBorrowField[2](ValidatorSet.staking_pool_mappings: Table<ID, address>)
	10: MoveLoc[4](loc1: ID)
	11: Call table::borrow<ID, address>(&Table<ID, address>, ID): &address
	12: ReadRef
	13: StLoc[5](loc2: address)
	14: MoveLoc[0](Arg0: &mut ValidatorSet)
	15: MoveLoc[5](loc2: address)
	16: Call get_candidate_or_active_validator_mut(&mut ValidatorSet, address): &mut Validator
	17: StLoc[3](loc0: &mut Validator)
	18: Branch(37)
B2:
	19: CopyLoc[0](Arg0: &mut ValidatorSet)
	20: ImmBorrowField[3](ValidatorSet.inactive_validators: Table<ID, ValidatorWrapper>)
	21: CopyLoc[4](loc1: ID)
	22: Call table::contains<ID, ValidatorWrapper>(&Table<ID, ValidatorWrapper>, ID): bool
	23: BrFalse(25)
B3:
	24: Branch(31)
B4:
	25: MoveLoc[0](Arg0: &mut ValidatorSet)
	26: Pop
	27: MoveLoc[2](Arg2: &TxContext)
	28: Pop
	29: LdConst[3](u64: 3)
	30: Abort
B5:
	31: MoveLoc[0](Arg0: &mut ValidatorSet)
	32: MutBorrowField[3](ValidatorSet.inactive_validators: Table<ID, ValidatorWrapper>)
	33: MoveLoc[4](loc1: ID)
	34: Call table::borrow_mut<ID, ValidatorWrapper>(&mut Table<ID, ValidatorWrapper>, ID): &mut ValidatorWrapper
	35: Call validator_wrapper::load_validator_maybe_upgrade(&mut ValidatorWrapper): &mut Validator
	36: StLoc[3](loc0: &mut Validator)
B6:
	37: MoveLoc[3](loc0: &mut Validator)
	38: MoveLoc[1](Arg1: FungibleStakedSafe)
	39: MoveLoc[2](Arg2: &TxContext)
	40: Call validator::redeem_fungible_staked_safe(&mut Validator, FungibleStakedSafe, &TxContext): Balance<SAFE>
	41: Ret
}

public(friend) request_set_commission_rate(Arg0: &mut ValidatorSet, Arg1: u64, Arg2: &TxContext) {
L3:	loc0: address
B0:
	0: MoveLoc[2](Arg2: &TxContext)
	1: Call tx_context::sender(&TxContext): address
	2: StLoc[3](loc0: address)
	3: MoveLoc[0](Arg0: &mut ValidatorSet)
	4: MutBorrowField[0](ValidatorSet.active_validators: vector<Validator>)
	5: MoveLoc[3](loc0: address)
	6: Call get_validator_mut(&mut vector<Validator>, address): &mut Validator
	7: MoveLoc[1](Arg1: u64)
	8: Call validator::request_set_commission_rate(&mut Validator, u64)
	9: Ret
}

public(friend) advance_epoch(Arg0: &mut ValidatorSet, Arg1: &mut Balance<SAFE>, Arg2: &mut Balance<SAFE>, Arg3: &mut VecMap<address, VecSet<address>>, Arg4: u64, Arg5: u64, Arg6: &mut TxContext) {
L7:	loc0: vector<u64>
L8:	loc1: vector<u64>
L9:	loc2: VecMap<u64, u64>
L10:	loc3: VecMap<u64, u64>
L11:	loc4: VotingPowerAdmissionStartEpochKey
L12:	loc5: u64
L13:	loc6: u64
L14:	loc7: vector<address>
L15:	loc8: u64
L16:	loc9: u64
L17:	loc10: u64
L18:	loc11: u64
L19:	loc12: vector<u64>
L20:	loc13: vector<u64>
B0:
	0: CopyLoc[6](Arg6: &mut TxContext)
	1: FreezeRef
	2: Call tx_context::epoch(&TxContext): u64
	3: LdU64(1)
	4: Add
	5: StLoc[12](loc5: u64)
	6: Call voting_power::total_voting_power(): u64
	7: StLoc[18](loc11: u64)
	8: LdFalse
	9: Pack[5](VotingPowerAdmissionStartEpochKey)
	10: StLoc[11](loc4: VotingPowerAdmissionStartEpochKey)
	11: CopyLoc[0](Arg0: &mut ValidatorSet)
	12: ImmBorrowField[6](ValidatorSet.extra_fields: Bag)
	13: CopyLoc[11](loc4: VotingPowerAdmissionStartEpochKey)
	14: Call bag::contains<VotingPowerAdmissionStartEpochKey>(&Bag, VotingPowerAdmissionStartEpochKey): bool
	15: Not
	16: BrFalse(24)
B1:
	17: CopyLoc[0](Arg0: &mut ValidatorSet)
	18: MutBorrowField[6](ValidatorSet.extra_fields: Bag)
	19: MoveLoc[11](loc4: VotingPowerAdmissionStartEpochKey)
	20: CopyLoc[6](Arg6: &mut TxContext)
	21: FreezeRef
	22: Call tx_context::epoch(&TxContext): u64
	23: Call bag::add<VotingPowerAdmissionStartEpochKey, u64>(&mut Bag, VotingPowerAdmissionStartEpochKey, u64)
B2:
	24: CopyLoc[0](Arg0: &mut ValidatorSet)
	25: ImmBorrowField[0](ValidatorSet.active_validators: vector<Validator>)
	26: CopyLoc[18](loc11: u64)
	27: CopyLoc[1](Arg1: &mut Balance<SAFE>)
	28: FreezeRef
	29: Call balance::value<SAFE>(&Balance<SAFE>): u64
	30: CopyLoc[2](Arg2: &mut Balance<SAFE>)
	31: FreezeRef
	32: Call balance::value<SAFE>(&Balance<SAFE>): u64
	33: Call compute_unadjusted_reward_distribution(&vector<Validator>, u64, u64, u64): vector<u64> * vector<u64>
	34: StLoc[20](loc13: vector<u64>)
	35: StLoc[19](loc12: vector<u64>)
	36: CopyLoc[0](Arg0: &mut ValidatorSet)
	37: FreezeRef
	38: CopyLoc[3](Arg3: &mut VecMap<address, VecSet<address>>)
	39: ReadRef
	40: Call compute_slashed_validators(&ValidatorSet, VecMap<address, VecSet<address>>): vector<address>
	41: StLoc[14](loc7: vector<address>)
	42: CopyLoc[0](Arg0: &mut ValidatorSet)
	43: ImmBorrowField[0](ValidatorSet.active_validators: vector<Validator>)
	44: ImmBorrowLoc[14](loc7: vector<address>)
	45: Call sum_voting_power_by_addresses(&vector<Validator>, &vector<address>): u64
	46: StLoc[15](loc8: u64)
	47: CopyLoc[0](Arg0: &mut ValidatorSet)
	48: ImmBorrowField[0](ValidatorSet.active_validators: vector<Validator>)
	49: ImmBorrowLoc[14](loc7: vector<address>)
	50: Call get_validator_indices(&vector<Validator>, &vector<address>): vector<u64>
	51: MoveLoc[4](Arg4: u64)
	52: ImmBorrowLoc[19](loc12: vector<u64>)
	53: ImmBorrowLoc[20](loc13: vector<u64>)
	54: Call compute_reward_adjustments(vector<u64>, u64, &vector<u64>, &vector<u64>): u64 * VecMap<u64, u64> * u64 * VecMap<u64, u64>
	55: StLoc[10](loc3: VecMap<u64, u64>)
	56: StLoc[17](loc10: u64)
	57: StLoc[9](loc2: VecMap<u64, u64>)
	58: StLoc[16](loc9: u64)
	59: CopyLoc[0](Arg0: &mut ValidatorSet)
	60: ImmBorrowField[0](ValidatorSet.active_validators: vector<Validator>)
	61: MoveLoc[18](loc11: u64)
	62: MoveLoc[15](loc8: u64)
	63: MoveLoc[19](loc12: vector<u64>)
	64: MoveLoc[20](loc13: vector<u64>)
	65: MoveLoc[16](loc9: u64)
	66: MoveLoc[9](loc2: VecMap<u64, u64>)
	67: MoveLoc[17](loc10: u64)
	68: MoveLoc[10](loc3: VecMap<u64, u64>)
	69: Call compute_adjusted_reward_distribution(&vector<Validator>, u64, u64, vector<u64>, vector<u64>, u64, VecMap<u64, u64>, u64, VecMap<u64, u64>): vector<u64> * vector<u64>
	70: StLoc[8](loc1: vector<u64>)
	71: StLoc[7](loc0: vector<u64>)
	72: CopyLoc[0](Arg0: &mut ValidatorSet)
	73: MutBorrowField[0](ValidatorSet.active_validators: vector<Validator>)
	74: ImmBorrowLoc[7](loc0: vector<u64>)
	75: ImmBorrowLoc[8](loc1: vector<u64>)
	76: MoveLoc[1](Arg1: &mut Balance<SAFE>)
	77: MoveLoc[2](Arg2: &mut Balance<SAFE>)
	78: CopyLoc[6](Arg6: &mut TxContext)
	79: Call distribute_reward(&mut vector<Validator>, &vector<u64>, &vector<u64>, &mut Balance<SAFE>, &mut Balance<SAFE>, &mut TxContext)
	80: CopyLoc[0](Arg0: &mut ValidatorSet)
	81: MutBorrowField[0](ValidatorSet.active_validators: vector<Validator>)
	82: Call adjust_stake_and_gas_price(&mut vector<Validator>)
	83: CopyLoc[0](Arg0: &mut ValidatorSet)
	84: MutBorrowField[0](ValidatorSet.active_validators: vector<Validator>)
	85: CopyLoc[6](Arg6: &mut TxContext)
	86: FreezeRef
	87: Call process_pending_stakes_and_withdraws(&mut vector<Validator>, &TxContext)
	88: MoveLoc[12](loc5: u64)
	89: CopyLoc[0](Arg0: &mut ValidatorSet)
	90: ImmBorrowField[0](ValidatorSet.active_validators: vector<Validator>)
	91: ImmBorrowLoc[7](loc0: vector<u64>)
	92: ImmBorrowLoc[8](loc1: vector<u64>)
	93: CopyLoc[3](Arg3: &mut VecMap<address, VecSet<address>>)
	94: FreezeRef
	95: ImmBorrowLoc[14](loc7: vector<address>)
	96: Call emit_validator_epoch_events(u64, &vector<Validator>, &vector<u64>, &vector<u64>, &VecMap<address, VecSet<address>>, &vector<address>)
	97: CopyLoc[0](Arg0: &mut ValidatorSet)
	98: CopyLoc[3](Arg3: &mut VecMap<address, VecSet<address>>)
	99: CopyLoc[6](Arg6: &mut TxContext)
	100: Call process_pending_removals(&mut ValidatorSet, &mut VecMap<address, VecSet<address>>, &mut TxContext)
	101: CopyLoc[0](Arg0: &mut ValidatorSet)
	102: MoveLoc[5](Arg5: u64)
	103: MoveLoc[3](Arg3: &mut VecMap<address, VecSet<address>>)
	104: MoveLoc[6](Arg6: &mut TxContext)
	105: Call update_validator_positions_and_calculate_total_stake(&mut ValidatorSet, u64, &mut VecMap<address, VecSet<address>>, &mut TxContext): u64
	106: StLoc[13](loc6: u64)
	107: CopyLoc[13](loc6: u64)
	108: CopyLoc[0](Arg0: &mut ValidatorSet)
	109: MutBorrowField[5](ValidatorSet.total_stake: u64)
	110: WriteRef
	111: CopyLoc[0](Arg0: &mut ValidatorSet)
	112: MutBorrowField[0](ValidatorSet.active_validators: vector<Validator>)
	113: MoveLoc[13](loc6: u64)
	114: Call voting_power::set_voting_power(&mut vector<Validator>, u64)
	115: MoveLoc[0](Arg0: &mut ValidatorSet)
	116: Call effectuate_staged_metadata(&mut ValidatorSet)
	117: Ret
}

update_validator_positions_and_calculate_total_stake(Arg0: &mut ValidatorSet, Arg1: u64, Arg2: &mut VecMap<address, VecSet<address>>, Arg3: &mut TxContext): u64 {
L4:	loc0: u64
L5:	loc1: u64
L6:	loc2: Validator
L7:	loc3: &mut vector<Validator>
L8:	loc4: u64
L9:	loc5: u64
L10:	loc6: u64
L11:	loc7: u64
L12:	loc8: u64
L13:	loc9: u64
L14:	loc10: u64
L15:	loc11: u64
L16:	loc12: &mut u64
L17:	loc13: vector<Validator>
L18:	loc14: u64
L19:	loc15: u64
L20:	loc16: u64
L21:	loc17: u64
L22:	loc18: u64
L23:	loc19: u64
L24:	loc20: vector<Validator>
L25:	loc21: vector<Validator>
L26:	loc22: Validator
L27:	loc23: Validator
L28:	loc24: Validator
L29:	loc25: address
L30:	loc26: &Validator
L31:	loc27: u64
L32:	loc28: u64
L33:	loc29: u64
B0:
	0: VecPack(67, 0)
	1: StLoc[24](loc20: vector<Validator>)
	2: CopyLoc[0](Arg0: &mut ValidatorSet)
	3: ImmBorrowField[4](ValidatorSet.pending_active_validators: TableVec<Validator>)
	4: Call table_vec::length<Validator>(&TableVec<Validator>): u64
	5: StLoc[5](loc1: u64)
	6: LdU64(0)
	7: StLoc[12](loc8: u64)
	8: MoveLoc[5](loc1: u64)
	9: StLoc[22](loc18: u64)
B1:
	10: CopyLoc[12](loc8: u64)
	11: CopyLoc[22](loc18: u64)
	12: Lt
	13: BrFalse(32)
B2:
	14: CopyLoc[12](loc8: u64)
	15: StLoc[10](loc6: u64)
	16: MutBorrowLoc[24](loc20: vector<Validator>)
	17: StLoc[7](loc3: &mut vector<Validator>)
	18: MoveLoc[10](loc6: u64)
	19: Pop
	20: CopyLoc[0](Arg0: &mut ValidatorSet)
	21: MutBorrowField[4](ValidatorSet.pending_active_validators: TableVec<Validator>)
	22: Call table_vec::pop_back<Validator>(&mut TableVec<Validator>): Validator
	23: StLoc[6](loc2: Validator)
	24: MoveLoc[7](loc3: &mut vector<Validator>)
	25: MoveLoc[6](loc2: Validator)
	26: VecPushBack(67)
	27: MoveLoc[12](loc8: u64)
	28: LdU64(1)
	29: Add
	30: StLoc[12](loc8: u64)
	31: Branch(10)
B3:
	32: MoveLoc[24](loc20: vector<Validator>)
	33: StLoc[17](loc13: vector<Validator>)
	34: ImmBorrowLoc[17](loc13: vector<Validator>)
	35: Call calculate_total_stakes(&vector<Validator>): u64
	36: StLoc[18](loc14: u64)
	37: CopyLoc[0](Arg0: &mut ValidatorSet)
	38: ImmBorrowField[0](ValidatorSet.active_validators: vector<Validator>)
	39: Call calculate_total_stakes(&vector<Validator>): u64
	40: MoveLoc[18](loc14: u64)
	41: Add
	42: StLoc[13](loc9: u64)
	43: CopyLoc[0](Arg0: &mut ValidatorSet)
	44: FreezeRef
	45: CopyLoc[3](Arg3: &mut TxContext)
	46: FreezeRef
	47: Call get_voting_power_thresholds(&ValidatorSet, &TxContext): u64 * u64 * u64
	48: StLoc[32](loc28: u64)
	49: StLoc[14](loc10: u64)
	50: StLoc[15](loc11: u64)
	51: LdU64(0)
	52: StLoc[23](loc19: u64)
	53: CopyLoc[0](Arg0: &mut ValidatorSet)
	54: ImmBorrowField[0](ValidatorSet.active_validators: vector<Validator>)
	55: VecLen(67)
	56: StLoc[9](loc5: u64)
B4:
	57: CopyLoc[9](loc5: u64)
	58: LdU64(0)
	59: Gt
	60: BrFalse(164)
B5:
	61: MoveLoc[9](loc5: u64)
	62: LdU64(1)
	63: Sub
	64: StLoc[9](loc5: u64)
	65: CopyLoc[0](Arg0: &mut ValidatorSet)
	66: ImmBorrowField[0](ValidatorSet.active_validators: vector<Validator>)
	67: CopyLoc[9](loc5: u64)
	68: VecImmBorrow(67)
	69: StLoc[30](loc26: &Validator)
	70: CopyLoc[30](loc26: &Validator)
	71: Call validator::safe_address(&Validator): address
	72: StLoc[29](loc25: address)
	73: MoveLoc[30](loc26: &Validator)
	74: Call validator::total_stake(&Validator): u64
	75: CopyLoc[13](loc9: u64)
	76: Call voting_power::derive_raw_voting_power(u64, u64): u64
	77: StLoc[33](loc29: u64)
	78: CopyLoc[33](loc29: u64)
	79: CopyLoc[14](loc10: u64)
	80: Ge
	81: BrFalse(95)
B6:
	82: Branch(83)
B7:
	83: CopyLoc[0](Arg0: &mut ValidatorSet)
	84: ImmBorrowField[8](ValidatorSet.at_risk_validators: VecMap<address, u64>)
	85: ImmBorrowLoc[29](loc25: address)
	86: Call vec_map::contains<address, u64>(&VecMap<address, u64>, &address): bool
	87: BrFalse(57)
B8:
	88: CopyLoc[0](Arg0: &mut ValidatorSet)
	89: MutBorrowField[8](ValidatorSet.at_risk_validators: VecMap<address, u64>)
	90: ImmBorrowLoc[29](loc25: address)
	91: Call vec_map::remove<address, u64>(&mut VecMap<address, u64>, &address): address * u64
	92: Pop
	93: Pop
	94: Branch(57)
B9:
	95: MoveLoc[33](loc29: u64)
	96: CopyLoc[32](loc28: u64)
	97: Ge
	98: BrFalse(147)
B10:
	99: CopyLoc[0](Arg0: &mut ValidatorSet)
	100: ImmBorrowField[8](ValidatorSet.at_risk_validators: VecMap<address, u64>)
	101: ImmBorrowLoc[29](loc25: address)
	102: Call vec_map::contains<address, u64>(&VecMap<address, u64>, &address): bool
	103: BrFalse(119)
B11:
	104: CopyLoc[0](Arg0: &mut ValidatorSet)
	105: MutBorrowField[8](ValidatorSet.at_risk_validators: VecMap<address, u64>)
	106: ImmBorrowLoc[29](loc25: address)
	107: Call vec_map::get_mut<address, u64>(&mut VecMap<address, u64>, &address): &mut u64
	108: StLoc[16](loc12: &mut u64)
	109: CopyLoc[16](loc12: &mut u64)
	110: ReadRef
	111: LdU64(1)
	112: Add
	113: CopyLoc[16](loc12: &mut u64)
	114: WriteRef
	115: MoveLoc[16](loc12: &mut u64)
	116: ReadRef
	117: StLoc[8](loc4: u64)
	118: Branch(126)
B12:
	119: CopyLoc[0](Arg0: &mut ValidatorSet)
	120: MutBorrowField[8](ValidatorSet.at_risk_validators: VecMap<address, u64>)
	121: MoveLoc[29](loc25: address)
	122: LdU64(1)
	123: Call vec_map::insert<address, u64>(&mut VecMap<address, u64>, address, u64)
	124: LdU64(1)
	125: StLoc[8](loc4: u64)
B13:
	126: MoveLoc[8](loc4: u64)
	127: CopyLoc[1](Arg1: u64)
	128: Gt
	129: BrFalse(57)
B14:
	130: CopyLoc[0](Arg0: &mut ValidatorSet)
	131: MutBorrowField[0](ValidatorSet.active_validators: vector<Validator>)
	132: CopyLoc[9](loc5: u64)
	133: Call vector::remove<Validator>(&mut vector<Validator>, u64): Validator
	134: StLoc[26](loc22: Validator)
	135: CopyLoc[0](Arg0: &mut ValidatorSet)
	136: MoveLoc[26](loc22: Validator)
	137: CopyLoc[2](Arg2: &mut VecMap<address, VecSet<address>>)
	138: LdFalse
	139: CopyLoc[3](Arg3: &mut TxContext)
	140: Call process_validator_departure(&mut ValidatorSet, Validator, &mut VecMap<address, VecSet<address>>, bool, &mut TxContext): u64
	141: StLoc[19](loc15: u64)
	142: MoveLoc[23](loc19: u64)
	143: MoveLoc[19](loc15: u64)
	144: Add
	145: StLoc[23](loc19: u64)
	146: Branch(57)
B15:
	147: CopyLoc[0](Arg0: &mut ValidatorSet)
	148: MutBorrowField[0](ValidatorSet.active_validators: vector<Validator>)
	149: CopyLoc[9](loc5: u64)
	150: Call vector::remove<Validator>(&mut vector<Validator>, u64): Validator
	151: StLoc[27](loc23: Validator)
	152: CopyLoc[0](Arg0: &mut ValidatorSet)
	153: MoveLoc[27](loc23: Validator)
	154: CopyLoc[2](Arg2: &mut VecMap<address, VecSet<address>>)
	155: LdFalse
	156: CopyLoc[3](Arg3: &mut TxContext)
	157: Call process_validator_departure(&mut ValidatorSet, Validator, &mut VecMap<address, VecSet<address>>, bool, &mut TxContext): u64
	158: StLoc[20](loc16: u64)
	159: MoveLoc[23](loc19: u64)
	160: MoveLoc[20](loc16: u64)
	161: Add
	162: StLoc[23](loc19: u64)
	163: Branch(57)
B16:
	164: MoveLoc[2](Arg2: &mut VecMap<address, VecSet<address>>)
	165: Pop
	166: MoveLoc[17](loc13: vector<Validator>)
	167: StLoc[25](loc21: vector<Validator>)
	168: MutBorrowLoc[25](loc21: vector<Validator>)
	169: Call vector::reverse<Validator>(&mut vector<Validator>)
	170: ImmBorrowLoc[25](loc21: vector<Validator>)
	171: VecLen(67)
	172: StLoc[4](loc0: u64)
	173: LdU64(0)
	174: StLoc[11](loc7: u64)
	175: MoveLoc[4](loc0: u64)
	176: StLoc[21](loc17: u64)
B17:
	177: CopyLoc[11](loc7: u64)
	178: CopyLoc[21](loc17: u64)
	179: Lt
	180: BrFalse(232)
B18:
	181: Branch(182)
B19:
	182: CopyLoc[11](loc7: u64)
	183: Pop
	184: MutBorrowLoc[25](loc21: vector<Validator>)
	185: VecPopBack(67)
	186: StLoc[28](loc24: Validator)
	187: ImmBorrowLoc[28](loc24: Validator)
	188: Call validator::total_stake(&Validator): u64
	189: StLoc[31](loc27: u64)
	190: CopyLoc[31](loc27: u64)
	191: CopyLoc[13](loc9: u64)
	192: Call voting_power::derive_raw_voting_power(u64, u64): u64
	193: CopyLoc[15](loc11: u64)
	194: Ge
	195: BrFalse(215)
B20:
	196: MutBorrowLoc[28](loc24: Validator)
	197: CopyLoc[3](Arg3: &mut TxContext)
	198: FreezeRef
	199: Call tx_context::epoch(&TxContext): u64
	200: Call validator::activate(&mut Validator, u64)
	201: CopyLoc[3](Arg3: &mut TxContext)
	202: FreezeRef
	203: Call tx_context::epoch(&TxContext): u64
	204: ImmBorrowLoc[28](loc24: Validator)
	205: Call validator::safe_address(&Validator): address
	206: ImmBorrowLoc[28](loc24: Validator)
	207: Call validator::staking_pool_id(&Validator): ID
	208: Pack[3](ValidatorJoinEvent)
	209: Call event::emit<ValidatorJoinEvent>(ValidatorJoinEvent)
	210: CopyLoc[0](Arg0: &mut ValidatorSet)
	211: MutBorrowField[0](ValidatorSet.active_validators: vector<Validator>)
	212: MoveLoc[28](loc24: Validator)
	213: VecPushBack(67)
	214: Branch(227)
B21:
	215: CopyLoc[0](Arg0: &mut ValidatorSet)
	216: MutBorrowField[1](ValidatorSet.validator_candidates: Table<address, ValidatorWrapper>)
	217: ImmBorrowLoc[28](loc24: Validator)
	218: Call validator::safe_address(&Validator): address
	219: MoveLoc[28](loc24: Validator)
	220: CopyLoc[3](Arg3: &mut TxContext)
	221: Call validator_wrapper::create_v1(Validator, &mut TxContext): ValidatorWrapper
	222: Call table::add<address, ValidatorWrapper>(&mut Table<address, ValidatorWrapper>, address, ValidatorWrapper)
	223: MoveLoc[23](loc19: u64)
	224: MoveLoc[31](loc27: u64)
	225: Add
	226: StLoc[23](loc19: u64)
B22:
	227: MoveLoc[11](loc7: u64)
	228: LdU64(1)
	229: Add
	230: StLoc[11](loc7: u64)
	231: Branch(177)
B23:
	232: MoveLoc[0](Arg0: &mut ValidatorSet)
	233: Pop
	234: MoveLoc[3](Arg3: &mut TxContext)
	235: Pop
	236: MoveLoc[25](loc21: vector<Validator>)
	237: VecUnpack(67, 0)
	238: MoveLoc[13](loc9: u64)
	239: MoveLoc[23](loc19: u64)
	240: Sub
	241: Ret
}

effectuate_staged_metadata(Arg0: &mut ValidatorSet) {
L1:	loc0: u64
L2:	loc1: u64
L3:	loc2: u64
L4:	loc3: u64
L5:	loc4: &mut vector<Validator>
B0:
	0: MoveLoc[0](Arg0: &mut ValidatorSet)
	1: MutBorrowField[0](ValidatorSet.active_validators: vector<Validator>)
	2: StLoc[5](loc4: &mut vector<Validator>)
	3: CopyLoc[5](loc4: &mut vector<Validator>)
	4: FreezeRef
	5: VecLen(67)
	6: StLoc[1](loc0: u64)
	7: LdU64(0)
	8: StLoc[2](loc1: u64)
	9: MoveLoc[1](loc0: u64)
	10: StLoc[4](loc3: u64)
B1:
	11: CopyLoc[2](loc1: u64)
	12: CopyLoc[4](loc3: u64)
	13: Lt
	14: BrFalse(26)
B2:
	15: CopyLoc[2](loc1: u64)
	16: StLoc[3](loc2: u64)
	17: CopyLoc[5](loc4: &mut vector<Validator>)
	18: MoveLoc[3](loc2: u64)
	19: VecMutBorrow(67)
	20: Call validator::effectuate_staged_metadata(&mut Validator)
	21: MoveLoc[2](loc1: u64)
	22: LdU64(1)
	23: Add
	24: StLoc[2](loc1: u64)
	25: Branch(11)
B3:
	26: MoveLoc[5](loc4: &mut vector<Validator>)
	27: Pop
	28: Ret
}

public derive_reference_gas_price(Arg0: &ValidatorSet): u64 {
L1:	loc0: u64
L2:	loc1: Entry<u64>
L3:	loc2: &mut vector<Entry<u64>>
L4:	loc3: &Validator
L5:	loc4: u64
L6:	loc5: u64
L7:	loc6: PriorityQueue<u64>
L8:	loc7: vector<Entry<u64>>
L9:	loc8: u64
L10:	loc9: u64
L11:	loc10: u64
L12:	loc11: u64
L13:	loc12: &vector<Validator>
L14:	loc13: &Validator
L15:	loc14: &vector<Validator>
L16:	loc15: u64
B0:
	0: MoveLoc[0](Arg0: &ValidatorSet)
	1: ImmBorrowField[0](ValidatorSet.active_validators: vector<Validator>)
	2: StLoc[13](loc12: &vector<Validator>)
	3: VecPack(123, 0)
	4: StLoc[8](loc7: vector<Entry<u64>>)
	5: MoveLoc[13](loc12: &vector<Validator>)
	6: StLoc[15](loc14: &vector<Validator>)
	7: CopyLoc[15](loc14: &vector<Validator>)
	8: VecLen(67)
	9: StLoc[1](loc0: u64)
	10: LdU64(0)
	11: StLoc[6](loc5: u64)
	12: MoveLoc[1](loc0: u64)
	13: StLoc[10](loc9: u64)
B1:
	14: CopyLoc[6](loc5: u64)
	15: CopyLoc[10](loc9: u64)
	16: Lt
	17: BrFalse(42)
B2:
	18: CopyLoc[6](loc5: u64)
	19: StLoc[5](loc4: u64)
	20: CopyLoc[15](loc14: &vector<Validator>)
	21: MoveLoc[5](loc4: u64)
	22: VecImmBorrow(67)
	23: StLoc[4](loc3: &Validator)
	24: MutBorrowLoc[8](loc7: vector<Entry<u64>>)
	25: StLoc[3](loc2: &mut vector<Entry<u64>>)
	26: MoveLoc[4](loc3: &Validator)
	27: StLoc[14](loc13: &Validator)
	28: CopyLoc[14](loc13: &Validator)
	29: Call validator::gas_price(&Validator): u64
	30: MoveLoc[14](loc13: &Validator)
	31: Call validator::voting_power(&Validator): u64
	32: Call priority_queue::new_entry<u64>(u64, u64): Entry<u64>
	33: StLoc[2](loc1: Entry<u64>)
	34: MoveLoc[3](loc2: &mut vector<Entry<u64>>)
	35: MoveLoc[2](loc1: Entry<u64>)
	36: VecPushBack(123)
	37: MoveLoc[6](loc5: u64)
	38: LdU64(1)
	39: Add
	40: StLoc[6](loc5: u64)
	41: Branch(14)
B3:
	42: MoveLoc[15](loc14: &vector<Validator>)
	43: Pop
	44: MoveLoc[8](loc7: vector<Entry<u64>>)
	45: Call priority_queue::new<u64>(vector<Entry<u64>>): PriorityQueue<u64>
	46: StLoc[7](loc6: PriorityQueue<u64>)
	47: LdU64(0)
	48: StLoc[11](loc10: u64)
	49: Call voting_power::total_voting_power(): u64
	50: Call voting_power::quorum_threshold(): u64
	51: Sub
	52: StLoc[12](loc11: u64)
	53: LdU64(0)
	54: StLoc[9](loc8: u64)
B4:
	55: CopyLoc[11](loc10: u64)
	56: CopyLoc[12](loc11: u64)
	57: Lt
	58: BrFalse(68)
B5:
	59: MutBorrowLoc[7](loc6: PriorityQueue<u64>)
	60: Call priority_queue::pop_max<u64>(&mut PriorityQueue<u64>): u64 * u64
	61: StLoc[16](loc15: u64)
	62: StLoc[9](loc8: u64)
	63: MoveLoc[11](loc10: u64)
	64: MoveLoc[16](loc15: u64)
	65: Add
	66: StLoc[11](loc10: u64)
	67: Branch(55)
B6:
	68: MoveLoc[9](loc8: u64)
	69: Ret
}

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

public validator_total_stake_amount(Arg0: &ValidatorSet, Arg1: address): u64 {
B0:
	0: MoveLoc[0](Arg0: &ValidatorSet)
	1: ImmBorrowField[0](ValidatorSet.active_validators: vector<Validator>)
	2: MoveLoc[1](Arg1: address)
	3: Call get_validator_ref(&vector<Validator>, address): &Validator
	4: Call validator::total_stake(&Validator): u64
	5: Ret
}

public validator_stake_amount(Arg0: &ValidatorSet, Arg1: address): u64 {
B0:
	0: MoveLoc[0](Arg0: &ValidatorSet)
	1: ImmBorrowField[0](ValidatorSet.active_validators: vector<Validator>)
	2: MoveLoc[1](Arg1: address)
	3: Call get_validator_ref(&vector<Validator>, address): &Validator
	4: Call validator::total_stake(&Validator): u64
	5: Ret
}

public validator_voting_power(Arg0: &ValidatorSet, Arg1: address): u64 {
B0:
	0: MoveLoc[0](Arg0: &ValidatorSet)
	1: ImmBorrowField[0](ValidatorSet.active_validators: vector<Validator>)
	2: MoveLoc[1](Arg1: address)
	3: Call get_validator_ref(&vector<Validator>, address): &Validator
	4: Call validator::voting_power(&Validator): u64
	5: Ret
}

public validator_staking_pool_id(Arg0: &ValidatorSet, Arg1: address): ID {
B0:
	0: MoveLoc[0](Arg0: &ValidatorSet)
	1: ImmBorrowField[0](ValidatorSet.active_validators: vector<Validator>)
	2: MoveLoc[1](Arg1: address)
	3: Call get_validator_ref(&vector<Validator>, address): &Validator
	4: Call validator::staking_pool_id(&Validator): ID
	5: Ret
}

public staking_pool_mappings(Arg0: &ValidatorSet): &Table<ID, address> {
B0:
	0: MoveLoc[0](Arg0: &ValidatorSet)
	1: ImmBorrowField[2](ValidatorSet.staking_pool_mappings: Table<ID, address>)
	2: Ret
}

public validator_address_by_pool_id(Arg0: &mut ValidatorSet, Arg1: &ID): address {
L2:	loc0: address
B0:
	0: CopyLoc[0](Arg0: &mut ValidatorSet)
	1: ImmBorrowField[2](ValidatorSet.staking_pool_mappings: Table<ID, address>)
	2: CopyLoc[1](Arg1: &ID)
	3: ReadRef
	4: Call table::contains<ID, address>(&Table<ID, address>, ID): bool
	5: BrFalse(14)
B1:
	6: MoveLoc[0](Arg0: &mut ValidatorSet)
	7: ImmBorrowField[2](ValidatorSet.staking_pool_mappings: Table<ID, address>)
	8: MoveLoc[1](Arg1: &ID)
	9: ReadRef
	10: Call table::borrow<ID, address>(&Table<ID, address>, ID): &address
	11: ReadRef
	12: StLoc[2](loc0: address)
	13: Branch(23)
B2:
	14: MoveLoc[0](Arg0: &mut ValidatorSet)
	15: MutBorrowField[3](ValidatorSet.inactive_validators: Table<ID, ValidatorWrapper>)
	16: MoveLoc[1](Arg1: &ID)
	17: ReadRef
	18: Call table::borrow_mut<ID, ValidatorWrapper>(&mut Table<ID, ValidatorWrapper>, ID): &mut ValidatorWrapper
	19: Call validator_wrapper::load_validator_maybe_upgrade(&mut ValidatorWrapper): &mut Validator
	20: FreezeRef
	21: Call validator::safe_address(&Validator): address
	22: StLoc[2](loc0: address)
B3:
	23: MoveLoc[2](loc0: address)
	24: Ret
}

public(friend) pool_exchange_rates(Arg0: &mut ValidatorSet, Arg1: &ID): &Table<u64, PoolTokenExchangeRate> {
L2:	loc0: &Validator
L3:	loc1: address
B0:
	0: CopyLoc[0](Arg0: &mut ValidatorSet)
	1: ImmBorrowField[2](ValidatorSet.staking_pool_mappings: Table<ID, address>)
	2: CopyLoc[1](Arg1: &ID)
	3: ReadRef
	4: Call table::contains<ID, address>(&Table<ID, address>, ID): bool
	5: BrFalse(19)
B1:
	6: CopyLoc[0](Arg0: &mut ValidatorSet)
	7: ImmBorrowField[2](ValidatorSet.staking_pool_mappings: Table<ID, address>)
	8: MoveLoc[1](Arg1: &ID)
	9: ReadRef
	10: Call table::borrow<ID, address>(&Table<ID, address>, ID): &address
	11: ReadRef
	12: StLoc[3](loc1: address)
	13: MoveLoc[0](Arg0: &mut ValidatorSet)
	14: MoveLoc[3](loc1: address)
	15: LdConst[17](u8: 3)
	16: Call get_active_or_pending_or_candidate_validator_ref(&mut ValidatorSet, address, u8): &Validator
	17: StLoc[2](loc0: &Validator)
	18: Branch(27)
B2:
	19: MoveLoc[0](Arg0: &mut ValidatorSet)
	20: MutBorrowField[3](ValidatorSet.inactive_validators: Table<ID, ValidatorWrapper>)
	21: MoveLoc[1](Arg1: &ID)
	22: ReadRef
	23: Call table::borrow_mut<ID, ValidatorWrapper>(&mut Table<ID, ValidatorWrapper>, ID): &mut ValidatorWrapper
	24: Call validator_wrapper::load_validator_maybe_upgrade(&mut ValidatorWrapper): &mut Validator
	25: FreezeRef
	26: StLoc[2](loc0: &Validator)
B3:
	27: MoveLoc[2](loc0: &Validator)
	28: Call validator::get_staking_pool_ref(&Validator): &StakingPool
	29: Call staking_pool::exchange_rates(&StakingPool): &Table<u64, PoolTokenExchangeRate>
	30: Ret
}

public(friend) validator_by_pool_id(Arg0: &mut ValidatorSet, Arg1: &ID): &Validator {
L2:	loc0: &Validator
L3:	loc1: address
B0:
	0: CopyLoc[0](Arg0: &mut ValidatorSet)
	1: ImmBorrowField[2](ValidatorSet.staking_pool_mappings: Table<ID, address>)
	2: CopyLoc[1](Arg1: &ID)
	3: ReadRef
	4: Call table::contains<ID, address>(&Table<ID, address>, ID): bool
	5: BrFalse(19)
B1:
	6: CopyLoc[0](Arg0: &mut ValidatorSet)
	7: ImmBorrowField[2](ValidatorSet.staking_pool_mappings: Table<ID, address>)
	8: MoveLoc[1](Arg1: &ID)
	9: ReadRef
	10: Call table::borrow<ID, address>(&Table<ID, address>, ID): &address
	11: ReadRef
	12: StLoc[3](loc1: address)
	13: MoveLoc[0](Arg0: &mut ValidatorSet)
	14: MoveLoc[3](loc1: address)
	15: LdConst[17](u8: 3)
	16: Call get_active_or_pending_or_candidate_validator_ref(&mut ValidatorSet, address, u8): &Validator
	17: StLoc[2](loc0: &Validator)
	18: Branch(27)
B2:
	19: MoveLoc[0](Arg0: &mut ValidatorSet)
	20: MutBorrowField[3](ValidatorSet.inactive_validators: Table<ID, ValidatorWrapper>)
	21: MoveLoc[1](Arg1: &ID)
	22: ReadRef
	23: Call table::borrow_mut<ID, ValidatorWrapper>(&mut Table<ID, ValidatorWrapper>, ID): &mut ValidatorWrapper
	24: Call validator_wrapper::load_validator_maybe_upgrade(&mut ValidatorWrapper): &mut Validator
	25: FreezeRef
	26: StLoc[2](loc0: &Validator)
B3:
	27: MoveLoc[2](loc0: &Validator)
	28: Ret
}

public(friend) next_epoch_validator_count(Arg0: &ValidatorSet): u64 {
B0:
	0: CopyLoc[0](Arg0: &ValidatorSet)
	1: ImmBorrowField[0](ValidatorSet.active_validators: vector<Validator>)
	2: VecLen(67)
	3: CopyLoc[0](Arg0: &ValidatorSet)
	4: ImmBorrowField[7](ValidatorSet.pending_removals: vector<u64>)
	5: VecLen(21)
	6: Sub
	7: MoveLoc[0](Arg0: &ValidatorSet)
	8: ImmBorrowField[4](ValidatorSet.pending_active_validators: TableVec<Validator>)
	9: Call table_vec::length<Validator>(&TableVec<Validator>): u64
	10: Add
	11: Ret
}

public(friend) is_active_validator_by_safe_address(Arg0: &ValidatorSet, Arg1: address): bool {
L2:	loc0: Option<u64>
B0:
	0: MoveLoc[0](Arg0: &ValidatorSet)
	1: ImmBorrowField[0](ValidatorSet.active_validators: vector<Validator>)
	2: MoveLoc[1](Arg1: address)
	3: Call find_validator(&vector<Validator>, address): Option<u64>
	4: StLoc[2](loc0: Option<u64>)
	5: ImmBorrowLoc[2](loc0: Option<u64>)
	6: Call option::is_some<u64>(&Option<u64>): bool
	7: Ret
}

is_duplicate_with_active_validator(Arg0: &ValidatorSet, Arg1: &Validator): bool {
B0:
	0: MoveLoc[0](Arg0: &ValidatorSet)
	1: ImmBorrowField[0](ValidatorSet.active_validators: vector<Validator>)
	2: MoveLoc[1](Arg1: &Validator)
	3: Call is_duplicate_validator(&vector<Validator>, &Validator): bool
	4: Ret
}

public(friend) is_duplicate_validator(Arg0: &vector<Validator>, Arg1: &Validator): bool {
B0:
	0: MoveLoc[0](Arg0: &vector<Validator>)
	1: MoveLoc[1](Arg1: &Validator)
	2: Call count_duplicates_vec(&vector<Validator>, &Validator): u64
	3: LdU64(0)
	4: Gt
	5: Ret
}

count_duplicates_vec(Arg0: &vector<Validator>, Arg1: &Validator): u64 {
L2:	loc0: u64
L3:	loc1: u64
L4:	loc2: u64
L5:	loc3: u64
L6:	loc4: u64
L7:	loc5: &vector<Validator>
L8:	loc6: &vector<Validator>
B0:
	0: MoveLoc[0](Arg0: &vector<Validator>)
	1: StLoc[7](loc5: &vector<Validator>)
	2: LdU64(0)
	3: StLoc[3](loc1: u64)
	4: MoveLoc[7](loc5: &vector<Validator>)
	5: StLoc[8](loc6: &vector<Validator>)
	6: CopyLoc[8](loc6: &vector<Validator>)
	7: VecLen(67)
	8: StLoc[2](loc0: u64)
	9: LdU64(0)
	10: StLoc[5](loc3: u64)
	11: MoveLoc[2](loc0: u64)
	12: StLoc[6](loc4: u64)
B1:
	13: CopyLoc[5](loc3: u64)
	14: CopyLoc[6](loc4: u64)
	15: Lt
	16: BrFalse(34)
B2:
	17: CopyLoc[5](loc3: u64)
	18: StLoc[4](loc2: u64)
	19: CopyLoc[8](loc6: &vector<Validator>)
	20: MoveLoc[4](loc2: u64)
	21: VecImmBorrow(67)
	22: CopyLoc[1](Arg1: &Validator)
	23: Call validator::is_duplicate(&Validator, &Validator): bool
	24: BrFalse(29)
B3:
	25: MoveLoc[3](loc1: u64)
	26: LdU64(1)
	27: Add
	28: StLoc[3](loc1: u64)
B4:
	29: MoveLoc[5](loc3: u64)
	30: LdU64(1)
	31: Add
	32: StLoc[5](loc3: u64)
	33: Branch(13)
B5:
	34: MoveLoc[1](Arg1: &Validator)
	35: Pop
	36: MoveLoc[8](loc6: &vector<Validator>)
	37: Pop
	38: MoveLoc[3](loc1: u64)
	39: Ret
}

is_duplicate_with_pending_validator(Arg0: &ValidatorSet, Arg1: &Validator): bool {
B0:
	0: MoveLoc[0](Arg0: &ValidatorSet)
	1: ImmBorrowField[4](ValidatorSet.pending_active_validators: TableVec<Validator>)
	2: MoveLoc[1](Arg1: &Validator)
	3: Call count_duplicates_tablevec(&TableVec<Validator>, &Validator): u64
	4: LdU64(0)
	5: Gt
	6: Ret
}

count_duplicates_tablevec(Arg0: &TableVec<Validator>, Arg1: &Validator): u64 {
L2:	loc0: u64
L3:	loc1: u64
L4:	loc2: u64
L5:	loc3: u64
L6:	loc4: u64
B0:
	0: LdU64(0)
	1: StLoc[5](loc3: u64)
	2: CopyLoc[0](Arg0: &TableVec<Validator>)
	3: Call table_vec::length<Validator>(&TableVec<Validator>): u64
	4: StLoc[2](loc0: u64)
	5: LdU64(0)
	6: StLoc[3](loc1: u64)
	7: MoveLoc[2](loc0: u64)
	8: StLoc[6](loc4: u64)
B1:
	9: CopyLoc[3](loc1: u64)
	10: CopyLoc[6](loc4: u64)
	11: Lt
	12: BrFalse(30)
B2:
	13: CopyLoc[3](loc1: u64)
	14: StLoc[4](loc2: u64)
	15: CopyLoc[0](Arg0: &TableVec<Validator>)
	16: MoveLoc[4](loc2: u64)
	17: Call table_vec::borrow<Validator>(&TableVec<Validator>, u64): &Validator
	18: CopyLoc[1](Arg1: &Validator)
	19: Call validator::is_duplicate(&Validator, &Validator): bool
	20: BrFalse(25)
B3:
	21: MoveLoc[5](loc3: u64)
	22: LdU64(1)
	23: Add
	24: StLoc[5](loc3: u64)
B4:
	25: MoveLoc[3](loc1: u64)
	26: LdU64(1)
	27: Add
	28: StLoc[3](loc1: u64)
	29: Branch(9)
B5:
	30: MoveLoc[0](Arg0: &TableVec<Validator>)
	31: Pop
	32: MoveLoc[1](Arg1: &Validator)
	33: Pop
	34: MoveLoc[5](loc3: u64)
	35: Ret
}

get_candidate_or_active_validator_mut(Arg0: &mut ValidatorSet, Arg1: address): &mut Validator {
L2:	loc0: &mut Validator
B0:
	0: CopyLoc[0](Arg0: &mut ValidatorSet)
	1: ImmBorrowField[1](ValidatorSet.validator_candidates: Table<address, ValidatorWrapper>)
	2: CopyLoc[1](Arg1: address)
	3: Call table::contains<address, ValidatorWrapper>(&Table<address, ValidatorWrapper>, address): bool
	4: BrFalse(12)
B1:
	5: MoveLoc[0](Arg0: &mut ValidatorSet)
	6: MutBorrowField[1](ValidatorSet.validator_candidates: Table<address, ValidatorWrapper>)
	7: MoveLoc[1](Arg1: address)
	8: Call table::borrow_mut<address, ValidatorWrapper>(&mut Table<address, ValidatorWrapper>, address): &mut ValidatorWrapper
	9: Call validator_wrapper::load_validator_maybe_upgrade(&mut ValidatorWrapper): &mut Validator
	10: StLoc[2](loc0: &mut Validator)
	11: Branch(17)
B2:
	12: MoveLoc[0](Arg0: &mut ValidatorSet)
	13: MutBorrowField[0](ValidatorSet.active_validators: vector<Validator>)
	14: MoveLoc[1](Arg1: address)
	15: Call get_validator_mut(&mut vector<Validator>, address): &mut Validator
	16: StLoc[2](loc0: &mut Validator)
B3:
	17: MoveLoc[2](loc0: &mut Validator)
	18: Ret
}

find_validator(Arg0: &vector<Validator>, Arg1: address): Option<u64> {
L2:	loc0: u64
L3:	loc1: Option<u64>
L4:	loc2: u64
L5:	loc3: u64
L6:	loc4: u64
L7:	loc5: &vector<Validator>
B0:
	0: MoveLoc[0](Arg0: &vector<Validator>)
	1: StLoc[7](loc5: &vector<Validator>)
	2: CopyLoc[7](loc5: &vector<Validator>)
	3: VecLen(67)
	4: StLoc[2](loc0: u64)
	5: LdU64(0)
	6: StLoc[4](loc2: u64)
	7: MoveLoc[2](loc0: u64)
	8: StLoc[6](loc4: u64)
B1:
	9: CopyLoc[4](loc2: u64)
	10: CopyLoc[6](loc4: u64)
	11: Lt
	12: BrFalse(33)
B2:
	13: CopyLoc[4](loc2: u64)
	14: StLoc[5](loc3: u64)
	15: CopyLoc[7](loc5: &vector<Validator>)
	16: CopyLoc[5](loc3: u64)
	17: VecImmBorrow(67)
	18: Call validator::safe_address(&Validator): address
	19: CopyLoc[1](Arg1: address)
	20: Eq
	21: BrFalse(28)
B3:
	22: MoveLoc[7](loc5: &vector<Validator>)
	23: Pop
	24: MoveLoc[5](loc3: u64)
	25: Call option::some<u64>(u64): Option<u64>
	26: StLoc[3](loc1: Option<u64>)
	27: Branch(37)
B4:
	28: MoveLoc[4](loc2: u64)
	29: LdU64(1)
	30: Add
	31: StLoc[4](loc2: u64)
	32: Branch(9)
B5:
	33: MoveLoc[7](loc5: &vector<Validator>)
	34: Pop
	35: Call option::none<u64>(): Option<u64>
	36: StLoc[3](loc1: Option<u64>)
B6:
	37: MoveLoc[3](loc1: Option<u64>)
	38: Ret
}

find_validator_from_table_vec(Arg0: &TableVec<Validator>, Arg1: address): Option<u64> {
L2:	loc0: u64
L3:	loc1: u64
B0:
	0: CopyLoc[0](Arg0: &TableVec<Validator>)
	1: Call table_vec::length<Validator>(&TableVec<Validator>): u64
	2: StLoc[3](loc1: u64)
	3: LdU64(0)
	4: StLoc[2](loc0: u64)
B1:
	5: CopyLoc[2](loc0: u64)
	6: CopyLoc[3](loc1: u64)
	7: Lt
	8: BrFalse(27)
B2:
	9: Branch(10)
B3:
	10: CopyLoc[0](Arg0: &TableVec<Validator>)
	11: CopyLoc[2](loc0: u64)
	12: Call table_vec::borrow<Validator>(&TableVec<Validator>, u64): &Validator
	13: Call validator::safe_address(&Validator): address
	14: CopyLoc[1](Arg1: address)
	15: Eq
	16: BrFalse(22)
B4:
	17: MoveLoc[0](Arg0: &TableVec<Validator>)
	18: Pop
	19: MoveLoc[2](loc0: u64)
	20: Call option::some<u64>(u64): Option<u64>
	21: Ret
B5:
	22: MoveLoc[2](loc0: u64)
	23: LdU64(1)
	24: Add
	25: StLoc[2](loc0: u64)
	26: Branch(5)
B6:
	27: MoveLoc[0](Arg0: &TableVec<Validator>)
	28: Pop
	29: Call option::none<u64>(): Option<u64>
	30: Ret
}

get_validator_indices(Arg0: &vector<Validator>, Arg1: &vector<address>): vector<u64> {
L2:	loc0: u64
L3:	loc1: &address
L4:	loc2: u64
L5:	loc3: u64
L6:	loc4: u64
L7:	loc5: Option<u64>
L8:	loc6: vector<u64>
L9:	loc7: u64
L10:	loc8: &vector<address>
B0:
	0: LdConst[21](vector<u64>: 00)
	1: StLoc[8](loc6: vector<u64>)
	2: MoveLoc[1](Arg1: &vector<address>)
	3: StLoc[10](loc8: &vector<address>)
	4: CopyLoc[10](loc8: &vector<address>)
	5: VecLen(28)
	6: StLoc[2](loc0: u64)
	7: LdU64(0)
	8: StLoc[4](loc2: u64)
	9: MoveLoc[2](loc0: u64)
	10: StLoc[9](loc7: u64)
B1:
	11: CopyLoc[4](loc2: u64)
	12: CopyLoc[9](loc7: u64)
	13: Lt
	14: BrFalse(49)
B2:
	15: CopyLoc[4](loc2: u64)
	16: StLoc[5](loc3: u64)
	17: CopyLoc[10](loc8: &vector<address>)
	18: MoveLoc[5](loc3: u64)
	19: VecImmBorrow(28)
	20: StLoc[3](loc1: &address)
	21: CopyLoc[0](Arg0: &vector<Validator>)
	22: MoveLoc[3](loc1: &address)
	23: ReadRef
	24: Call find_validator(&vector<Validator>, address): Option<u64>
	25: StLoc[7](loc5: Option<u64>)
	26: ImmBorrowLoc[7](loc5: Option<u64>)
	27: Call option::is_some<u64>(&Option<u64>): bool
	28: BrFalse(30)
B3:
	29: Branch(38)
B4:
	30: MoveLoc[0](Arg0: &vector<Validator>)
	31: Pop
	32: MoveLoc[10](loc8: &vector<address>)
	33: Pop
	34: MoveLoc[7](loc5: Option<u64>)
	35: Call option::destroy_none<u64>(Option<u64>)
	36: LdConst[4](u64: 4)
	37: Abort
B5:
	38: MoveLoc[7](loc5: Option<u64>)
	39: Call option::destroy_some<u64>(Option<u64>): u64
	40: StLoc[6](loc4: u64)
	41: MutBorrowLoc[8](loc6: vector<u64>)
	42: MoveLoc[6](loc4: u64)
	43: VecPushBack(21)
	44: MoveLoc[4](loc2: u64)
	45: LdU64(1)
	46: Add
	47: StLoc[4](loc2: u64)
	48: Branch(11)
B6:
	49: MoveLoc[0](Arg0: &vector<Validator>)
	50: Pop
	51: MoveLoc[10](loc8: &vector<address>)
	52: Pop
	53: MoveLoc[8](loc6: vector<u64>)
	54: Ret
}

public(friend) get_validator_mut(Arg0: &mut vector<Validator>, Arg1: address): &mut Validator {
L2:	loc0: u64
L3:	loc1: Option<u64>
B0:
	0: CopyLoc[0](Arg0: &mut vector<Validator>)
	1: FreezeRef
	2: MoveLoc[1](Arg1: address)
	3: Call find_validator(&vector<Validator>, address): Option<u64>
	4: StLoc[3](loc1: Option<u64>)
	5: ImmBorrowLoc[3](loc1: Option<u64>)
	6: Call option::is_some<u64>(&Option<u64>): bool
	7: BrFalse(9)
B1:
	8: Branch(15)
B2:
	9: MoveLoc[0](Arg0: &mut vector<Validator>)
	10: Pop
	11: MoveLoc[3](loc1: Option<u64>)
	12: Call option::destroy_none<u64>(Option<u64>)
	13: LdConst[4](u64: 4)
	14: Abort
B3:
	15: MoveLoc[3](loc1: Option<u64>)
	16: Call option::destroy_some<u64>(Option<u64>): u64
	17: StLoc[2](loc0: u64)
	18: MoveLoc[0](Arg0: &mut vector<Validator>)
	19: MoveLoc[2](loc0: u64)
	20: VecMutBorrow(67)
	21: Ret
}

get_active_or_pending_or_candidate_validator_mut(Arg0: &mut ValidatorSet, Arg1: address, Arg2: bool): &mut Validator {
L3:	loc0: u64
L4:	loc1: u64
L5:	loc2: Option<u64>
L6:	loc3: Option<u64>
B0:
	0: CopyLoc[0](Arg0: &mut ValidatorSet)
	1: ImmBorrowField[0](ValidatorSet.active_validators: vector<Validator>)
	2: CopyLoc[1](Arg1: address)
	3: Call find_validator(&vector<Validator>, address): Option<u64>
	4: StLoc[5](loc2: Option<u64>)
	5: ImmBorrowLoc[5](loc2: Option<u64>)
	6: Call option::is_some<u64>(&Option<u64>): bool
	7: BrFalse(16)
B1:
	8: MutBorrowLoc[5](loc2: Option<u64>)
	9: Call option::extract<u64>(&mut Option<u64>): u64
	10: StLoc[3](loc0: u64)
	11: MoveLoc[0](Arg0: &mut ValidatorSet)
	12: MutBorrowField[0](ValidatorSet.active_validators: vector<Validator>)
	13: MoveLoc[3](loc0: u64)
	14: VecMutBorrow(67)
	15: Ret
B2:
	16: CopyLoc[0](Arg0: &mut ValidatorSet)
	17: ImmBorrowField[4](ValidatorSet.pending_active_validators: TableVec<Validator>)
	18: CopyLoc[1](Arg1: address)
	19: Call find_validator_from_table_vec(&TableVec<Validator>, address): Option<u64>
	20: StLoc[6](loc3: Option<u64>)
	21: ImmBorrowLoc[6](loc3: Option<u64>)
	22: Call option::is_some<u64>(&Option<u64>): bool
	23: BrFalse(32)
B3:
	24: MutBorrowLoc[6](loc3: Option<u64>)
	25: Call option::extract<u64>(&mut Option<u64>): u64
	26: StLoc[4](loc1: u64)
	27: MoveLoc[0](Arg0: &mut ValidatorSet)
	28: MutBorrowField[4](ValidatorSet.pending_active_validators: TableVec<Validator>)
	29: MoveLoc[4](loc1: u64)
	30: Call table_vec::borrow_mut<Validator>(&mut TableVec<Validator>, u64): &mut Validator
	31: Ret
B4:
	32: MoveLoc[2](Arg2: bool)
	33: BrFalse(35)
B5:
	34: Branch(39)
B6:
	35: MoveLoc[0](Arg0: &mut ValidatorSet)
	36: Pop
	37: LdConst[9](u64: 9)
	38: Abort
B7:
	39: MoveLoc[0](Arg0: &mut ValidatorSet)
	40: MutBorrowField[1](ValidatorSet.validator_candidates: Table<address, ValidatorWrapper>)
	41: MoveLoc[1](Arg1: address)
	42: Call table::borrow_mut<address, ValidatorWrapper>(&mut Table<address, ValidatorWrapper>, address): &mut ValidatorWrapper
	43: Call validator_wrapper::load_validator_maybe_upgrade(&mut ValidatorWrapper): &mut Validator
	44: Ret
}

public(friend) get_validator_mut_with_verified_cap(Arg0: &mut ValidatorSet, Arg1: &ValidatorOperationCap, Arg2: bool): &mut Validator {
B0:
	0: MoveLoc[0](Arg0: &mut ValidatorSet)
	1: MoveLoc[1](Arg1: &ValidatorOperationCap)
	2: Call validator_cap::verified_operation_cap_address(&ValidatorOperationCap): &address
	3: ReadRef
	4: MoveLoc[2](Arg2: bool)
	5: Call get_active_or_pending_or_candidate_validator_mut(&mut ValidatorSet, address, bool): &mut Validator
	6: Ret
}

public(friend) get_validator_mut_with_ctx(Arg0: &mut ValidatorSet, Arg1: &TxContext): &mut Validator {
L2:	loc0: address
B0:
	0: MoveLoc[1](Arg1: &TxContext)
	1: Call tx_context::sender(&TxContext): address
	2: StLoc[2](loc0: address)
	3: MoveLoc[0](Arg0: &mut ValidatorSet)
	4: MoveLoc[2](loc0: address)
	5: LdFalse
	6: Call get_active_or_pending_or_candidate_validator_mut(&mut ValidatorSet, address, bool): &mut Validator
	7: Ret
}

public(friend) get_validator_mut_with_ctx_including_candidates(Arg0: &mut ValidatorSet, Arg1: &TxContext): &mut Validator {
L2:	loc0: address
B0:
	0: MoveLoc[1](Arg1: &TxContext)
	1: Call tx_context::sender(&TxContext): address
	2: StLoc[2](loc0: address)
	3: MoveLoc[0](Arg0: &mut ValidatorSet)
	4: MoveLoc[2](loc0: address)
	5: LdTrue
	6: Call get_active_or_pending_or_candidate_validator_mut(&mut ValidatorSet, address, bool): &mut Validator
	7: Ret
}

get_validator_ref(Arg0: &vector<Validator>, Arg1: address): &Validator {
L2:	loc0: u64
L3:	loc1: Option<u64>
B0:
	0: CopyLoc[0](Arg0: &vector<Validator>)
	1: MoveLoc[1](Arg1: address)
	2: Call find_validator(&vector<Validator>, address): Option<u64>
	3: StLoc[3](loc1: Option<u64>)
	4: ImmBorrowLoc[3](loc1: Option<u64>)
	5: Call option::is_some<u64>(&Option<u64>): bool
	6: BrFalse(8)
B1:
	7: Branch(14)
B2:
	8: MoveLoc[0](Arg0: &vector<Validator>)
	9: Pop
	10: MoveLoc[3](loc1: Option<u64>)
	11: Call option::destroy_none<u64>(Option<u64>)
	12: LdConst[4](u64: 4)
	13: Abort
B3:
	14: MoveLoc[3](loc1: Option<u64>)
	15: Call option::destroy_some<u64>(Option<u64>): u64
	16: StLoc[2](loc0: u64)
	17: MoveLoc[0](Arg0: &vector<Validator>)
	18: MoveLoc[2](loc0: u64)
	19: VecImmBorrow(67)
	20: Ret
}

public(friend) get_active_or_pending_or_candidate_validator_ref(Arg0: &mut ValidatorSet, Arg1: address, Arg2: u8): &Validator {
L3:	loc0: bool
L4:	loc1: bool
L5:	loc2: u64
L6:	loc3: u64
L7:	loc4: Option<u64>
L8:	loc5: Option<u64>
B0:
	0: CopyLoc[0](Arg0: &mut ValidatorSet)
	1: ImmBorrowField[0](ValidatorSet.active_validators: vector<Validator>)
	2: CopyLoc[1](Arg1: address)
	3: Call find_validator(&vector<Validator>, address): Option<u64>
	4: StLoc[7](loc4: Option<u64>)
	5: ImmBorrowLoc[7](loc4: Option<u64>)
	6: Call option::is_some<u64>(&Option<u64>): bool
	7: BrFalse(11)
B1:
	8: LdTrue
	9: StLoc[3](loc0: bool)
	10: Branch(15)
B2:
	11: CopyLoc[2](Arg2: u8)
	12: LdConst[15](u8: 1)
	13: Eq
	14: StLoc[3](loc0: bool)
B3:
	15: MoveLoc[3](loc0: bool)
	16: BrFalse(25)
B4:
	17: MutBorrowLoc[7](loc4: Option<u64>)
	18: Call option::extract<u64>(&mut Option<u64>): u64
	19: StLoc[5](loc2: u64)
	20: MoveLoc[0](Arg0: &mut ValidatorSet)
	21: ImmBorrowField[0](ValidatorSet.active_validators: vector<Validator>)
	22: MoveLoc[5](loc2: u64)
	23: VecImmBorrow(67)
	24: Ret
B5:
	25: CopyLoc[0](Arg0: &mut ValidatorSet)
	26: ImmBorrowField[4](ValidatorSet.pending_active_validators: TableVec<Validator>)
	27: CopyLoc[1](Arg1: address)
	28: Call find_validator_from_table_vec(&TableVec<Validator>, address): Option<u64>
	29: StLoc[8](loc5: Option<u64>)
	30: ImmBorrowLoc[8](loc5: Option<u64>)
	31: Call option::is_some<u64>(&Option<u64>): bool
	32: BrFalse(36)
B6:
	33: LdTrue
	34: StLoc[4](loc1: bool)
	35: Branch(40)
B7:
	36: MoveLoc[2](Arg2: u8)
	37: LdConst[16](u8: 2)
	38: Eq
	39: StLoc[4](loc1: bool)
B8:
	40: MoveLoc[4](loc1: bool)
	41: BrFalse(50)
B9:
	42: MutBorrowLoc[8](loc5: Option<u64>)
	43: Call option::extract<u64>(&mut Option<u64>): u64
	44: StLoc[6](loc3: u64)
	45: MoveLoc[0](Arg0: &mut ValidatorSet)
	46: ImmBorrowField[4](ValidatorSet.pending_active_validators: TableVec<Validator>)
	47: MoveLoc[6](loc3: u64)
	48: Call table_vec::borrow<Validator>(&TableVec<Validator>, u64): &Validator
	49: Ret
B10:
	50: MoveLoc[0](Arg0: &mut ValidatorSet)
	51: MutBorrowField[1](ValidatorSet.validator_candidates: Table<address, ValidatorWrapper>)
	52: MoveLoc[1](Arg1: address)
	53: Call table::borrow_mut<address, ValidatorWrapper>(&mut Table<address, ValidatorWrapper>, address): &mut ValidatorWrapper
	54: Call validator_wrapper::load_validator_maybe_upgrade(&mut ValidatorWrapper): &mut Validator
	55: FreezeRef
	56: Ret
}

public get_active_validator_ref(Arg0: &ValidatorSet, Arg1: address): &Validator {
L2:	loc0: u64
L3:	loc1: Option<u64>
B0:
	0: CopyLoc[0](Arg0: &ValidatorSet)
	1: ImmBorrowField[0](ValidatorSet.active_validators: vector<Validator>)
	2: MoveLoc[1](Arg1: address)
	3: Call find_validator(&vector<Validator>, address): Option<u64>
	4: StLoc[3](loc1: Option<u64>)
	5: ImmBorrowLoc[3](loc1: Option<u64>)
	6: Call option::is_some<u64>(&Option<u64>): bool
	7: BrFalse(9)
B1:
	8: Branch(15)
B2:
	9: MoveLoc[0](Arg0: &ValidatorSet)
	10: Pop
	11: MoveLoc[3](loc1: Option<u64>)
	12: Call option::destroy_none<u64>(Option<u64>)
	13: LdConst[4](u64: 4)
	14: Abort
B3:
	15: MoveLoc[3](loc1: Option<u64>)
	16: Call option::destroy_some<u64>(Option<u64>): u64
	17: StLoc[2](loc0: u64)
	18: MoveLoc[0](Arg0: &ValidatorSet)
	19: ImmBorrowField[0](ValidatorSet.active_validators: vector<Validator>)
	20: MoveLoc[2](loc0: u64)
	21: VecImmBorrow(67)
	22: Ret
}

public get_pending_validator_ref(Arg0: &ValidatorSet, Arg1: address): &Validator {
L2:	loc0: u64
L3:	loc1: Option<u64>
B0:
	0: CopyLoc[0](Arg0: &ValidatorSet)
	1: ImmBorrowField[4](ValidatorSet.pending_active_validators: TableVec<Validator>)
	2: MoveLoc[1](Arg1: address)
	3: Call find_validator_from_table_vec(&TableVec<Validator>, address): Option<u64>
	4: StLoc[3](loc1: Option<u64>)
	5: ImmBorrowLoc[3](loc1: Option<u64>)
	6: Call option::is_some<u64>(&Option<u64>): bool
	7: BrFalse(9)
B1:
	8: Branch(15)
B2:
	9: MoveLoc[0](Arg0: &ValidatorSet)
	10: Pop
	11: MoveLoc[3](loc1: Option<u64>)
	12: Call option::destroy_none<u64>(Option<u64>)
	13: LdConst[12](u64: 12)
	14: Abort
B3:
	15: MoveLoc[3](loc1: Option<u64>)
	16: Call option::destroy_some<u64>(Option<u64>): u64
	17: StLoc[2](loc0: u64)
	18: MoveLoc[0](Arg0: &ValidatorSet)
	19: ImmBorrowField[4](ValidatorSet.pending_active_validators: TableVec<Validator>)
	20: MoveLoc[2](loc0: u64)
	21: Call table_vec::borrow<Validator>(&TableVec<Validator>, u64): &Validator
	22: Ret
}

public(friend) verify_cap(Arg0: &mut ValidatorSet, Arg1: &UnverifiedValidatorOperationCap, Arg2: u8): ValidatorOperationCap {
L3:	loc0: &Validator
L4:	loc1: ID
L5:	loc2: &ID
L6:	loc3: address
B0:
	0: CopyLoc[1](Arg1: &UnverifiedValidatorOperationCap)
	1: Call validator_cap::unverified_operation_cap_address(&UnverifiedValidatorOperationCap): &address
	2: ReadRef
	3: StLoc[6](loc3: address)
	4: CopyLoc[2](Arg2: u8)
	5: LdConst[15](u8: 1)
	6: Eq
	7: BrFalse(14)
B1:
	8: MoveLoc[0](Arg0: &mut ValidatorSet)
	9: FreezeRef
	10: MoveLoc[6](loc3: address)
	11: Call get_active_validator_ref(&ValidatorSet, address): &Validator
	12: StLoc[3](loc0: &Validator)
	13: Branch(19)
B2:
	14: MoveLoc[0](Arg0: &mut ValidatorSet)
	15: MoveLoc[6](loc3: address)
	16: MoveLoc[2](Arg2: u8)
	17: Call get_active_or_pending_or_candidate_validator_ref(&mut ValidatorSet, address, u8): &Validator
	18: StLoc[3](loc0: &Validator)
B3:
	19: MoveLoc[3](loc0: &Validator)
	20: Call validator::operation_cap_id(&Validator): &ID
	21: StLoc[5](loc2: &ID)
	22: CopyLoc[1](Arg1: &UnverifiedValidatorOperationCap)
	23: Call object::id<UnverifiedValidatorOperationCap>(&UnverifiedValidatorOperationCap): ID
	24: StLoc[4](loc1: ID)
	25: MoveLoc[5](loc2: &ID)
	26: ImmBorrowLoc[4](loc1: ID)
	27: Eq
	28: BrFalse(30)
B4:
	29: Branch(34)
B5:
	30: MoveLoc[1](Arg1: &UnverifiedValidatorOperationCap)
	31: Pop
	32: LdConst[14](u64: 101)
	33: Abort
B6:
	34: MoveLoc[1](Arg1: &UnverifiedValidatorOperationCap)
	35: Call validator_cap::into_verified(&UnverifiedValidatorOperationCap): ValidatorOperationCap
	36: Ret
}

process_pending_removals(Arg0: &mut ValidatorSet, Arg1: &mut VecMap<address, VecSet<address>>, Arg2: &mut TxContext) {
L3:	loc0: u64
L4:	loc1: u64
L5:	loc2: u64
L6:	loc3: u64
L7:	loc4: Validator
B0:
	0: CopyLoc[0](Arg0: &mut ValidatorSet)
	1: MutBorrowField[7](ValidatorSet.pending_removals: vector<u64>)
	2: Call sort_removal_list(&mut vector<u64>)
	3: CopyLoc[0](Arg0: &mut ValidatorSet)
	4: ImmBorrowField[7](ValidatorSet.pending_removals: vector<u64>)
	5: VecLen(21)
	6: StLoc[3](loc0: u64)
	7: LdU64(0)
	8: StLoc[4](loc1: u64)
	9: MoveLoc[3](loc0: u64)
	10: StLoc[6](loc3: u64)
B1:
	11: CopyLoc[4](loc1: u64)
	12: CopyLoc[6](loc3: u64)
	13: Lt
	14: BrFalse(38)
B2:
	15: CopyLoc[4](loc1: u64)
	16: Pop
	17: CopyLoc[0](Arg0: &mut ValidatorSet)
	18: MutBorrowField[7](ValidatorSet.pending_removals: vector<u64>)
	19: VecPopBack(21)
	20: StLoc[5](loc2: u64)
	21: CopyLoc[0](Arg0: &mut ValidatorSet)
	22: MutBorrowField[0](ValidatorSet.active_validators: vector<Validator>)
	23: MoveLoc[5](loc2: u64)
	24: Call vector::remove<Validator>(&mut vector<Validator>, u64): Validator
	25: StLoc[7](loc4: Validator)
	26: CopyLoc[0](Arg0: &mut ValidatorSet)
	27: MoveLoc[7](loc4: Validator)
	28: CopyLoc[1](Arg1: &mut VecMap<address, VecSet<address>>)
	29: LdTrue
	30: CopyLoc[2](Arg2: &mut TxContext)
	31: Call process_validator_departure(&mut ValidatorSet, Validator, &mut VecMap<address, VecSet<address>>, bool, &mut TxContext): u64
	32: Pop
	33: MoveLoc[4](loc1: u64)
	34: LdU64(1)
	35: Add
	36: StLoc[4](loc1: u64)
	37: Branch(11)
B3:
	38: MoveLoc[1](Arg1: &mut VecMap<address, VecSet<address>>)
	39: Pop
	40: MoveLoc[0](Arg0: &mut ValidatorSet)
	41: Pop
	42: MoveLoc[2](Arg2: &mut TxContext)
	43: Pop
	44: Ret
}

process_validator_departure(Arg0: &mut ValidatorSet, Arg1: Validator, Arg2: &mut VecMap<address, VecSet<address>>, Arg3: bool, Arg4: &mut TxContext): u64 {
L5:	loc0: u64
L6:	loc1: u64
L7:	loc2: address
L8:	loc3: ID
B0:
	0: CopyLoc[4](Arg4: &mut TxContext)
	1: FreezeRef
	2: Call tx_context::epoch(&TxContext): u64
	3: LdU64(1)
	4: Add
	5: StLoc[5](loc0: u64)
	6: ImmBorrowLoc[1](Arg1: Validator)
	7: Call validator::safe_address(&Validator): address
	8: StLoc[7](loc2: address)
	9: ImmBorrowLoc[1](Arg1: Validator)
	10: Call validator::staking_pool_id(&Validator): ID
	11: StLoc[8](loc3: ID)
	12: CopyLoc[0](Arg0: &mut ValidatorSet)
	13: MutBorrowField[2](ValidatorSet.staking_pool_mappings: Table<ID, address>)
	14: CopyLoc[8](loc3: ID)
	15: Call table::remove<ID, address>(&mut Table<ID, address>, ID): address
	16: Pop
	17: CopyLoc[0](Arg0: &mut ValidatorSet)
	18: ImmBorrowField[8](ValidatorSet.at_risk_validators: VecMap<address, u64>)
	19: ImmBorrowLoc[7](loc2: address)
	20: Call vec_map::contains<address, u64>(&VecMap<address, u64>, &address): bool
	21: BrFalse(28)
B1:
	22: CopyLoc[0](Arg0: &mut ValidatorSet)
	23: MutBorrowField[8](ValidatorSet.at_risk_validators: VecMap<address, u64>)
	24: ImmBorrowLoc[7](loc2: address)
	25: Call vec_map::remove<address, u64>(&mut VecMap<address, u64>, &address): address * u64
	26: Pop
	27: Pop
B2:
	28: MoveLoc[2](Arg2: &mut VecMap<address, VecSet<address>>)
	29: CopyLoc[7](loc2: address)
	30: Call clean_report_records_leaving_validator(&mut VecMap<address, VecSet<address>>, address)
	31: CopyLoc[5](loc0: u64)
	32: MoveLoc[7](loc2: address)
	33: ImmBorrowLoc[1](Arg1: Validator)
	34: Call validator::staking_pool_id(&Validator): ID
	35: MoveLoc[3](Arg3: bool)
	36: Pack[4](ValidatorLeaveEvent)
	37: Call event::emit<ValidatorLeaveEvent>(ValidatorLeaveEvent)
	38: ImmBorrowLoc[1](Arg1: Validator)
	39: Call validator::total_stake(&Validator): u64
	40: StLoc[6](loc1: u64)
	41: MutBorrowLoc[1](Arg1: Validator)
	42: MoveLoc[5](loc0: u64)
	43: Call validator::deactivate(&mut Validator, u64)
	44: MoveLoc[0](Arg0: &mut ValidatorSet)
	45: MutBorrowField[3](ValidatorSet.inactive_validators: Table<ID, ValidatorWrapper>)
	46: MoveLoc[8](loc3: ID)
	47: MoveLoc[1](Arg1: Validator)
	48: MoveLoc[4](Arg4: &mut TxContext)
	49: Call validator_wrapper::create_v1(Validator, &mut TxContext): ValidatorWrapper
	50: Call table::add<ID, ValidatorWrapper>(&mut Table<ID, ValidatorWrapper>, ID, ValidatorWrapper)
	51: MoveLoc[6](loc1: u64)
	52: Ret
}

clean_report_records_leaving_validator(Arg0: &mut VecMap<address, VecSet<address>>, Arg1: address) {
L2:	loc0: u64
L3:	loc1: u64
L4:	loc2: u64
L5:	loc3: &address
L6:	loc4: vector<address>
L7:	loc5: &mut VecSet<address>
L8:	loc6: u64
B0:
	0: CopyLoc[0](Arg0: &mut VecMap<address, VecSet<address>>)
	1: FreezeRef
	2: ImmBorrowLoc[1](Arg1: address)
	3: Call vec_map::contains<address, VecSet<address>>(&VecMap<address, VecSet<address>>, &address): bool
	4: BrFalse(10)
B1:
	5: CopyLoc[0](Arg0: &mut VecMap<address, VecSet<address>>)
	6: ImmBorrowLoc[1](Arg1: address)
	7: Call vec_map::remove<address, VecSet<address>>(&mut VecMap<address, VecSet<address>>, &address): address * VecSet<address>
	8: Pop
	9: Pop
B2:
	10: CopyLoc[0](Arg0: &mut VecMap<address, VecSet<address>>)
	11: FreezeRef
	12: Call vec_map::keys<address, VecSet<address>>(&VecMap<address, VecSet<address>>): vector<address>
	13: StLoc[6](loc4: vector<address>)
	14: ImmBorrowLoc[6](loc4: vector<address>)
	15: VecLen(28)
	16: StLoc[2](loc0: u64)
	17: LdU64(0)
	18: StLoc[3](loc1: u64)
	19: MoveLoc[2](loc0: u64)
	20: StLoc[8](loc6: u64)
B3:
	21: CopyLoc[3](loc1: u64)
	22: CopyLoc[8](loc6: u64)
	23: Lt
	24: BrFalse(65)
B4:
	25: CopyLoc[3](loc1: u64)
	26: StLoc[4](loc2: u64)
	27: ImmBorrowLoc[6](loc4: vector<address>)
	28: MoveLoc[4](loc2: u64)
	29: VecImmBorrow(28)
	30: StLoc[5](loc3: &address)
	31: CopyLoc[0](Arg0: &mut VecMap<address, VecSet<address>>)
	32: CopyLoc[5](loc3: &address)
	33: Call vec_map::get_mut<address, VecSet<address>>(&mut VecMap<address, VecSet<address>>, &address): &mut VecSet<address>
	34: StLoc[7](loc5: &mut VecSet<address>)
	35: CopyLoc[7](loc5: &mut VecSet<address>)
	36: FreezeRef
	37: ImmBorrowLoc[1](Arg1: address)
	38: Call vec_set::contains<address>(&VecSet<address>, &address): bool
	39: BrFalse(56)
B5:
	40: CopyLoc[7](loc5: &mut VecSet<address>)
	41: ImmBorrowLoc[1](Arg1: address)
	42: Call vec_set::remove<address>(&mut VecSet<address>, &address)
	43: MoveLoc[7](loc5: &mut VecSet<address>)
	44: FreezeRef
	45: Call vec_set::is_empty<address>(&VecSet<address>): bool
	46: BrFalse(53)
B6:
	47: CopyLoc[0](Arg0: &mut VecMap<address, VecSet<address>>)
	48: MoveLoc[5](loc3: &address)
	49: Call vec_map::remove<address, VecSet<address>>(&mut VecMap<address, VecSet<address>>, &address): address * VecSet<address>
	50: Pop
	51: Pop
	52: Branch(60)
B7:
	53: MoveLoc[5](loc3: &address)
	54: Pop
	55: Branch(60)
B8:
	56: MoveLoc[7](loc5: &mut VecSet<address>)
	57: Pop
	58: MoveLoc[5](loc3: &address)
	59: Pop
B9:
	60: MoveLoc[3](loc1: u64)
	61: LdU64(1)
	62: Add
	63: StLoc[3](loc1: u64)
	64: Branch(21)
B10:
	65: MoveLoc[0](Arg0: &mut VecMap<address, VecSet<address>>)
	66: Pop
	67: Ret
}

sort_removal_list(Arg0: &mut vector<u64>) {
L1:	loc0: u64
L2:	loc1: u64
L3:	loc2: u64
L4:	loc3: u64
B0:
	0: CopyLoc[0](Arg0: &mut vector<u64>)
	1: FreezeRef
	2: VecLen(21)
	3: StLoc[4](loc3: u64)
	4: LdU64(1)
	5: StLoc[2](loc1: u64)
B1:
	6: CopyLoc[2](loc1: u64)
	7: CopyLoc[4](loc3: u64)
	8: Lt
	9: BrFalse(48)
B2:
	10: Branch(11)
B3:
	11: CopyLoc[0](Arg0: &mut vector<u64>)
	12: FreezeRef
	13: CopyLoc[2](loc1: u64)
	14: VecImmBorrow(21)
	15: ReadRef
	16: StLoc[1](loc0: u64)
	17: CopyLoc[2](loc1: u64)
	18: StLoc[3](loc2: u64)
B4:
	19: CopyLoc[3](loc2: u64)
	20: LdU64(0)
	21: Gt
	22: BrFalse(43)
B5:
	23: Branch(24)
B6:
	24: MoveLoc[3](loc2: u64)
	25: LdU64(1)
	26: Sub
	27: StLoc[3](loc2: u64)
	28: CopyLoc[0](Arg0: &mut vector<u64>)
	29: FreezeRef
	30: CopyLoc[3](loc2: u64)
	31: VecImmBorrow(21)
	32: ReadRef
	33: CopyLoc[1](loc0: u64)
	34: Gt
	35: BrFalse(43)
B7:
	36: CopyLoc[0](Arg0: &mut vector<u64>)
	37: CopyLoc[3](loc2: u64)
	38: CopyLoc[3](loc2: u64)
	39: LdU64(1)
	40: Add
	41: VecSwap(21)
	42: Branch(19)
B8:
	43: MoveLoc[2](loc1: u64)
	44: LdU64(1)
	45: Add
	46: StLoc[2](loc1: u64)
	47: Branch(6)
B9:
	48: MoveLoc[0](Arg0: &mut vector<u64>)
	49: Pop
	50: Ret
}

process_pending_stakes_and_withdraws(Arg0: &mut vector<Validator>, Arg1: &TxContext) {
L2:	loc0: u64
L3:	loc1: u64
L4:	loc2: u64
L5:	loc3: u64
L6:	loc4: &mut vector<Validator>
B0:
	0: MoveLoc[0](Arg0: &mut vector<Validator>)
	1: StLoc[6](loc4: &mut vector<Validator>)
	2: CopyLoc[6](loc4: &mut vector<Validator>)
	3: FreezeRef
	4: VecLen(67)
	5: StLoc[2](loc0: u64)
	6: LdU64(0)
	7: StLoc[3](loc1: u64)
	8: MoveLoc[2](loc0: u64)
	9: StLoc[5](loc3: u64)
B1:
	10: CopyLoc[3](loc1: u64)
	11: CopyLoc[5](loc3: u64)
	12: Lt
	13: BrFalse(26)
B2:
	14: CopyLoc[3](loc1: u64)
	15: StLoc[4](loc2: u64)
	16: CopyLoc[6](loc4: &mut vector<Validator>)
	17: MoveLoc[4](loc2: u64)
	18: VecMutBorrow(67)
	19: CopyLoc[1](Arg1: &TxContext)
	20: Call validator::process_pending_stakes_and_withdraws(&mut Validator, &TxContext)
	21: MoveLoc[3](loc1: u64)
	22: LdU64(1)
	23: Add
	24: StLoc[3](loc1: u64)
	25: Branch(10)
B3:
	26: MoveLoc[6](loc4: &mut vector<Validator>)
	27: Pop
	28: MoveLoc[1](Arg1: &TxContext)
	29: Pop
	30: Ret
}

public(friend) calculate_total_stakes(Arg0: &vector<Validator>): u64 {
L1:	loc0: u64
L2:	loc1: u64
L3:	loc2: u64
L4:	loc3: u64
L5:	loc4: u64
L6:	loc5: &vector<Validator>
L7:	loc6: &Validator
B0:
	0: LdU64(0)
	1: StLoc[4](loc3: u64)
	2: MoveLoc[0](Arg0: &vector<Validator>)
	3: StLoc[6](loc5: &vector<Validator>)
	4: CopyLoc[6](loc5: &vector<Validator>)
	5: VecLen(67)
	6: StLoc[1](loc0: u64)
	7: LdU64(0)
	8: StLoc[2](loc1: u64)
	9: MoveLoc[1](loc0: u64)
	10: StLoc[5](loc4: u64)
B1:
	11: CopyLoc[2](loc1: u64)
	12: CopyLoc[5](loc4: u64)
	13: Lt
	14: BrFalse(31)
B2:
	15: CopyLoc[2](loc1: u64)
	16: StLoc[3](loc2: u64)
	17: CopyLoc[6](loc5: &vector<Validator>)
	18: MoveLoc[3](loc2: u64)
	19: VecImmBorrow(67)
	20: StLoc[7](loc6: &Validator)
	21: MoveLoc[4](loc3: u64)
	22: MoveLoc[7](loc6: &Validator)
	23: Call validator::total_stake(&Validator): u64
	24: Add
	25: StLoc[4](loc3: u64)
	26: MoveLoc[2](loc1: u64)
	27: LdU64(1)
	28: Add
	29: StLoc[2](loc1: u64)
	30: Branch(11)
B3:
	31: MoveLoc[6](loc5: &vector<Validator>)
	32: Pop
	33: MoveLoc[4](loc3: u64)
	34: Ret
}

adjust_stake_and_gas_price(Arg0: &mut vector<Validator>) {
L1:	loc0: u64
L2:	loc1: u64
L3:	loc2: u64
L4:	loc3: u64
L5:	loc4: &mut vector<Validator>
B0:
	0: MoveLoc[0](Arg0: &mut vector<Validator>)
	1: StLoc[5](loc4: &mut vector<Validator>)
	2: CopyLoc[5](loc4: &mut vector<Validator>)
	3: FreezeRef
	4: VecLen(67)
	5: StLoc[1](loc0: u64)
	6: LdU64(0)
	7: StLoc[2](loc1: u64)
	8: MoveLoc[1](loc0: u64)
	9: StLoc[4](loc3: u64)
B1:
	10: CopyLoc[2](loc1: u64)
	11: CopyLoc[4](loc3: u64)
	12: Lt
	13: BrFalse(25)
B2:
	14: CopyLoc[2](loc1: u64)
	15: StLoc[3](loc2: u64)
	16: CopyLoc[5](loc4: &mut vector<Validator>)
	17: MoveLoc[3](loc2: u64)
	18: VecMutBorrow(67)
	19: Call validator::adjust_stake_and_gas_price(&mut Validator)
	20: MoveLoc[2](loc1: u64)
	21: LdU64(1)
	22: Add
	23: StLoc[2](loc1: u64)
	24: Branch(10)
B3:
	25: MoveLoc[5](loc4: &mut vector<Validator>)
	26: Pop
	27: Ret
}

compute_reward_adjustments(Arg0: vector<u64>, Arg1: u64, Arg2: &vector<u64>, Arg3: &vector<u64>): u64 * VecMap<u64, u64> * u64 * VecMap<u64, u64> {
L4:	loc0: u64
L5:	loc1: u64
L6:	loc2: VecMap<u64, u64>
L7:	loc3: VecMap<u64, u64>
L8:	loc4: u64
L9:	loc5: u64
L10:	loc6: u64
L11:	loc7: u64
L12:	loc8: u64
L13:	loc9: vector<u64>
L14:	loc10: u64
B0:
	0: LdU64(0)
	1: StLoc[11](loc7: u64)
	2: Call vec_map::empty<u64, u64>(): VecMap<u64, u64>
	3: StLoc[6](loc2: VecMap<u64, u64>)
	4: LdU64(0)
	5: StLoc[12](loc8: u64)
	6: Call vec_map::empty<u64, u64>(): VecMap<u64, u64>
	7: StLoc[7](loc3: VecMap<u64, u64>)
	8: MoveLoc[0](Arg0: vector<u64>)
	9: StLoc[13](loc9: vector<u64>)
	10: ImmBorrowLoc[13](loc9: vector<u64>)
	11: VecLen(21)
	12: StLoc[4](loc0: u64)
	13: LdU64(0)
	14: StLoc[5](loc1: u64)
	15: MoveLoc[4](loc0: u64)
	16: StLoc[9](loc5: u64)
B1:
	17: CopyLoc[5](loc1: u64)
	18: CopyLoc[9](loc5: u64)
	19: Lt
	20: BrFalse(73)
B2:
	21: CopyLoc[5](loc1: u64)
	22: Pop
	23: MutBorrowLoc[13](loc9: vector<u64>)
	24: VecPopBack(21)
	25: StLoc[14](loc10: u64)
	26: CopyLoc[2](Arg2: &vector<u64>)
	27: CopyLoc[14](loc10: u64)
	28: VecImmBorrow(21)
	29: ReadRef
	30: CastU128
	31: CopyLoc[1](Arg1: u64)
	32: CastU128
	33: Mul
	34: LdConst[18](u64: 10000)
	35: CastU128
	36: Div
	37: CastU64
	38: StLoc[8](loc4: u64)
	39: MutBorrowLoc[6](loc2: VecMap<u64, u64>)
	40: CopyLoc[14](loc10: u64)
	41: CopyLoc[8](loc4: u64)
	42: Call vec_map::insert<u64, u64>(&mut VecMap<u64, u64>, u64, u64)
	43: MoveLoc[11](loc7: u64)
	44: MoveLoc[8](loc4: u64)
	45: Add
	46: StLoc[11](loc7: u64)
	47: CopyLoc[3](Arg3: &vector<u64>)
	48: CopyLoc[14](loc10: u64)
	49: VecImmBorrow(21)
	50: ReadRef
	51: CastU128
	52: CopyLoc[1](Arg1: u64)
	53: CastU128
	54: Mul
	55: LdConst[18](u64: 10000)
	56: CastU128
	57: Div
	58: CastU64
	59: StLoc[10](loc6: u64)
	60: MutBorrowLoc[7](loc3: VecMap<u64, u64>)
	61: MoveLoc[14](loc10: u64)
	62: CopyLoc[10](loc6: u64)
	63: Call vec_map::insert<u64, u64>(&mut VecMap<u64, u64>, u64, u64)
	64: MoveLoc[12](loc8: u64)
	65: MoveLoc[10](loc6: u64)
	66: Add
	67: StLoc[12](loc8: u64)
	68: MoveLoc[5](loc1: u64)
	69: LdU64(1)
	70: Add
	71: StLoc[5](loc1: u64)
	72: Branch(17)
B3:
	73: MoveLoc[3](Arg3: &vector<u64>)
	74: Pop
	75: MoveLoc[2](Arg2: &vector<u64>)
	76: Pop
	77: MoveLoc[13](loc9: vector<u64>)
	78: VecUnpack(21, 0)
	79: MoveLoc[11](loc7: u64)
	80: MoveLoc[6](loc2: VecMap<u64, u64>)
	81: MoveLoc[12](loc8: u64)
	82: MoveLoc[7](loc3: VecMap<u64, u64>)
	83: Ret
}

compute_slashed_validators(Arg0: &ValidatorSet, Arg1: VecMap<address, VecSet<address>>): vector<address> {
L2:	loc0: vector<address>
L3:	loc1: &vector<Validator>
L4:	loc2: VecSet<address>
L5:	loc3: vector<address>
L6:	loc4: address
B0:
	0: LdConst[22](vector<address>: 00)
	1: StLoc[5](loc3: vector<address>)
B1:
	2: ImmBorrowLoc[1](Arg1: VecMap<address, VecSet<address>>)
	3: Call vec_map::is_empty<address, VecSet<address>>(&VecMap<address, VecSet<address>>): bool
	4: Not
	5: BrFalse(36)
B2:
	6: Branch(7)
B3:
	7: MutBorrowLoc[1](Arg1: VecMap<address, VecSet<address>>)
	8: Call vec_map::pop<address, VecSet<address>>(&mut VecMap<address, VecSet<address>>): address * VecSet<address>
	9: StLoc[4](loc2: VecSet<address>)
	10: StLoc[6](loc4: address)
	11: CopyLoc[0](Arg0: &ValidatorSet)
	12: CopyLoc[6](loc4: address)
	13: Call is_active_validator_by_safe_address(&ValidatorSet, address): bool
	14: BrFalse(16)
B4:
	15: Branch(20)
B5:
	16: MoveLoc[0](Arg0: &ValidatorSet)
	17: Pop
	18: LdConst[0](u64: 0)
	19: Abort
B6:
	20: CopyLoc[0](Arg0: &ValidatorSet)
	21: ImmBorrowField[0](ValidatorSet.active_validators: vector<Validator>)
	22: StLoc[3](loc1: &vector<Validator>)
	23: MoveLoc[4](loc2: VecSet<address>)
	24: Call vec_set::into_keys<address>(VecSet<address>): vector<address>
	25: StLoc[2](loc0: vector<address>)
	26: MoveLoc[3](loc1: &vector<Validator>)
	27: ImmBorrowLoc[2](loc0: vector<address>)
	28: Call sum_voting_power_by_addresses(&vector<Validator>, &vector<address>): u64
	29: Call voting_power::quorum_threshold(): u64
	30: Ge
	31: BrFalse(2)
B7:
	32: MutBorrowLoc[5](loc3: vector<address>)
	33: MoveLoc[6](loc4: address)
	34: VecPushBack(28)
	35: Branch(2)
B8:
	36: MoveLoc[0](Arg0: &ValidatorSet)
	37: Pop
	38: MoveLoc[5](loc3: vector<address>)
	39: Ret
}

compute_unadjusted_reward_distribution(Arg0: &vector<Validator>, Arg1: u64, Arg2: u64, Arg3: u64): vector<u64> * vector<u64> {
L4:	loc0: u64
L5:	loc1: u64
L6:	loc2: u64
L7:	loc3: u64
L8:	loc4: u64
L9:	loc5: vector<u64>
L10:	loc6: u64
L11:	loc7: vector<u64>
L12:	loc8: u64
L13:	loc9: &vector<Validator>
B0:
	0: LdConst[21](vector<u64>: 00)
	1: StLoc[9](loc5: vector<u64>)
	2: LdConst[21](vector<u64>: 00)
	3: StLoc[11](loc7: vector<u64>)
	4: CopyLoc[0](Arg0: &vector<Validator>)
	5: VecLen(67)
	6: StLoc[7](loc3: u64)
	7: MoveLoc[3](Arg3: u64)
	8: MoveLoc[7](loc3: u64)
	9: Div
	10: StLoc[12](loc8: u64)
	11: MoveLoc[0](Arg0: &vector<Validator>)
	12: StLoc[13](loc9: &vector<Validator>)
	13: CopyLoc[13](loc9: &vector<Validator>)
	14: VecLen(67)
	15: StLoc[4](loc0: u64)
	16: LdU64(0)
	17: StLoc[5](loc1: u64)
	18: MoveLoc[4](loc0: u64)
	19: StLoc[10](loc6: u64)
B1:
	20: CopyLoc[5](loc1: u64)
	21: CopyLoc[10](loc6: u64)
	22: Lt
	23: BrFalse(50)
B2:
	24: CopyLoc[5](loc1: u64)
	25: StLoc[6](loc2: u64)
	26: CopyLoc[13](loc9: &vector<Validator>)
	27: MoveLoc[6](loc2: u64)
	28: VecImmBorrow(67)
	29: Call validator::voting_power(&Validator): u64
	30: CastU128
	31: CopyLoc[2](Arg2: u64)
	32: CastU128
	33: Mul
	34: CopyLoc[1](Arg1: u64)
	35: CastU128
	36: Div
	37: CastU64
	38: StLoc[8](loc4: u64)
	39: MutBorrowLoc[9](loc5: vector<u64>)
	40: MoveLoc[8](loc4: u64)
	41: VecPushBack(21)
	42: MutBorrowLoc[11](loc7: vector<u64>)
	43: CopyLoc[12](loc8: u64)
	44: VecPushBack(21)
	45: MoveLoc[5](loc1: u64)
	46: LdU64(1)
	47: Add
	48: StLoc[5](loc1: u64)
	49: Branch(20)
B3:
	50: MoveLoc[13](loc9: &vector<Validator>)
	51: Pop
	52: MoveLoc[9](loc5: vector<u64>)
	53: MoveLoc[11](loc7: vector<u64>)
	54: Ret
}

compute_adjusted_reward_distribution(Arg0: &vector<Validator>, Arg1: u64, Arg2: u64, Arg3: vector<u64>, Arg4: vector<u64>, Arg5: u64, Arg6: VecMap<u64, u64>, Arg7: u64, Arg8: VecMap<u64, u64>): vector<u64> * vector<u64> {
L9:	loc0: u64
L10:	loc1: u64
L11:	loc2: u64
L12:	loc3: u64
L13:	loc4: vector<u64>
L14:	loc5: u64
L15:	loc6: vector<u64>
L16:	loc7: u64
L17:	loc8: u64
L18:	loc9: u64
L19:	loc10: u64
L20:	loc11: u64
L21:	loc12: u64
L22:	loc13: u64
L23:	loc14: u64
L24:	loc15: u64
L25:	loc16: u64
L26:	loc17: u64
L27:	loc18: u64
L28:	loc19: u64
B0:
	0: MoveLoc[1](Arg1: u64)
	1: MoveLoc[2](Arg2: u64)
	2: Sub
	3: StLoc[25](loc16: u64)
	4: LdConst[21](vector<u64>: 00)
	5: StLoc[13](loc4: vector<u64>)
	6: LdConst[21](vector<u64>: 00)
	7: StLoc[15](loc6: vector<u64>)
	8: CopyLoc[0](Arg0: &vector<Validator>)
	9: VecLen(67)
	10: StLoc[22](loc13: u64)
	11: CopyLoc[22](loc13: u64)
	12: ImmBorrowLoc[6](Arg6: VecMap<u64, u64>)
	13: Call vec_map::size<u64, u64>(&VecMap<u64, u64>): u64
	14: Sub
	15: StLoc[23](loc14: u64)
	16: MoveLoc[22](loc13: u64)
	17: StLoc[9](loc0: u64)
	18: LdU64(0)
	19: StLoc[20](loc11: u64)
	20: MoveLoc[9](loc0: u64)
	21: StLoc[24](loc15: u64)
B1:
	22: CopyLoc[20](loc11: u64)
	23: CopyLoc[24](loc15: u64)
	24: Lt
	25: BrFalse(109)
B2:
	26: CopyLoc[20](loc11: u64)
	27: StLoc[21](loc12: u64)
	28: CopyLoc[0](Arg0: &vector<Validator>)
	29: CopyLoc[21](loc12: u64)
	30: VecImmBorrow(67)
	31: Call validator::voting_power(&Validator): u64
	32: StLoc[28](loc19: u64)
	33: ImmBorrowLoc[3](Arg3: vector<u64>)
	34: CopyLoc[21](loc12: u64)
	35: VecImmBorrow(21)
	36: ReadRef
	37: StLoc[26](loc17: u64)
	38: ImmBorrowLoc[6](Arg6: VecMap<u64, u64>)
	39: ImmBorrowLoc[21](loc12: u64)
	40: Call vec_map::contains<u64, u64>(&VecMap<u64, u64>, &u64): bool
	41: BrFalse(53)
B3:
	42: Branch(43)
B4:
	43: ImmBorrowLoc[6](Arg6: VecMap<u64, u64>)
	44: ImmBorrowLoc[21](loc12: u64)
	45: Call vec_map::get<u64, u64>(&VecMap<u64, u64>, &u64): &u64
	46: ReadRef
	47: StLoc[16](loc7: u64)
	48: MoveLoc[26](loc17: u64)
	49: MoveLoc[16](loc7: u64)
	50: Sub
	51: StLoc[10](loc1: u64)
	52: Branch(67)
B5:
	53: CopyLoc[5](Arg5: u64)
	54: CastU128
	55: MoveLoc[28](loc19: u64)
	56: CastU128
	57: Mul
	58: CopyLoc[25](loc16: u64)
	59: CastU128
	60: Div
	61: CastU64
	62: StLoc[17](loc8: u64)
	63: MoveLoc[26](loc17: u64)
	64: MoveLoc[17](loc8: u64)
	65: Add
	66: StLoc[10](loc1: u64)
B6:
	67: MoveLoc[10](loc1: u64)
	68: StLoc[12](loc3: u64)
	69: MutBorrowLoc[13](loc4: vector<u64>)
	70: MoveLoc[12](loc3: u64)
	71: VecPushBack(21)
	72: ImmBorrowLoc[4](Arg4: vector<u64>)
	73: CopyLoc[21](loc12: u64)
	74: VecImmBorrow(21)
	75: ReadRef
	76: StLoc[27](loc18: u64)
	77: ImmBorrowLoc[8](Arg8: VecMap<u64, u64>)
	78: ImmBorrowLoc[21](loc12: u64)
	79: Call vec_map::contains<u64, u64>(&VecMap<u64, u64>, &u64): bool
	80: BrFalse(91)
B7:
	81: ImmBorrowLoc[8](Arg8: VecMap<u64, u64>)
	82: ImmBorrowLoc[21](loc12: u64)
	83: Call vec_map::get<u64, u64>(&VecMap<u64, u64>, &u64): &u64
	84: ReadRef
	85: StLoc[18](loc9: u64)
	86: MoveLoc[27](loc18: u64)
	87: MoveLoc[18](loc9: u64)
	88: Sub
	89: StLoc[11](loc2: u64)
	90: Branch(99)
B8:
	91: CopyLoc[7](Arg7: u64)
	92: CopyLoc[23](loc14: u64)
	93: Div
	94: StLoc[19](loc10: u64)
	95: MoveLoc[27](loc18: u64)
	96: MoveLoc[19](loc10: u64)
	97: Add
	98: StLoc[11](loc2: u64)
B9:
	99: MoveLoc[11](loc2: u64)
	100: StLoc[14](loc5: u64)
	101: MutBorrowLoc[15](loc6: vector<u64>)
	102: MoveLoc[14](loc5: u64)
	103: VecPushBack(21)
	104: MoveLoc[20](loc11: u64)
	105: LdU64(1)
	106: Add
	107: StLoc[20](loc11: u64)
	108: Branch(22)
B10:
	109: MoveLoc[0](Arg0: &vector<Validator>)
	110: Pop
	111: MoveLoc[13](loc4: vector<u64>)
	112: MoveLoc[15](loc6: vector<u64>)
	113: Ret
}

distribute_reward(Arg0: &mut vector<Validator>, Arg1: &vector<u64>, Arg2: &vector<u64>, Arg3: &mut Balance<SAFE>, Arg4: &mut Balance<SAFE>, Arg5: &mut TxContext) {
L6:	loc0: u64
L7:	loc1: u64
L8:	loc2: u64
L9:	loc3: u64
L10:	loc4: Balance<SAFE>
L11:	loc5: u64
L12:	loc6: u64
L13:	loc7: &mut Validator
L14:	loc8: address
L15:	loc9: u64
L16:	loc10: Balance<SAFE>
B0:
	0: CopyLoc[0](Arg0: &mut vector<Validator>)
	1: FreezeRef
	2: VecLen(67)
	3: StLoc[9](loc3: u64)
	4: CopyLoc[9](loc3: u64)
	5: LdU64(0)
	6: Gt
	7: BrFalse(9)
B1:
	8: Branch(23)
B2:
	9: MoveLoc[0](Arg0: &mut vector<Validator>)
	10: Pop
	11: MoveLoc[4](Arg4: &mut Balance<SAFE>)
	12: Pop
	13: MoveLoc[3](Arg3: &mut Balance<SAFE>)
	14: Pop
	15: MoveLoc[5](Arg5: &mut TxContext)
	16: Pop
	17: MoveLoc[2](Arg2: &vector<u64>)
	18: Pop
	19: MoveLoc[1](Arg1: &vector<u64>)
	20: Pop
	21: LdConst[13](u64: 13)
	22: Abort
B3:
	23: MoveLoc[9](loc3: u64)
	24: StLoc[6](loc0: u64)
	25: LdU64(0)
	26: StLoc[7](loc1: u64)
	27: MoveLoc[6](loc0: u64)
	28: StLoc[12](loc6: u64)
B4:
	29: CopyLoc[7](loc1: u64)
	30: CopyLoc[12](loc6: u64)
	31: Lt
	32: BrFalse(101)
B5:
	33: CopyLoc[7](loc1: u64)
	34: StLoc[8](loc2: u64)
	35: CopyLoc[0](Arg0: &mut vector<Validator>)
	36: CopyLoc[8](loc2: u64)
	37: VecMutBorrow(67)
	38: StLoc[13](loc7: &mut Validator)
	39: CopyLoc[1](Arg1: &vector<u64>)
	40: CopyLoc[8](loc2: u64)
	41: VecImmBorrow(21)
	42: ReadRef
	43: StLoc[11](loc5: u64)
	44: CopyLoc[3](Arg3: &mut Balance<SAFE>)
	45: CopyLoc[11](loc5: u64)
	46: Call balance::split<SAFE>(&mut Balance<SAFE>, u64): Balance<SAFE>
	47: StLoc[10](loc4: Balance<SAFE>)
	48: MoveLoc[11](loc5: u64)
	49: CastU128
	50: CopyLoc[13](loc7: &mut Validator)
	51: FreezeRef
	52: Call validator::commission_rate(&Validator): u64
	53: CastU128
	54: Mul
	55: LdConst[18](u64: 10000)
	56: CastU128
	57: Div
	58: CastU64
	59: StLoc[15](loc9: u64)
	60: MutBorrowLoc[10](loc4: Balance<SAFE>)
	61: MoveLoc[15](loc9: u64)
	62: CastU64
	63: Call balance::split<SAFE>(&mut Balance<SAFE>, u64): Balance<SAFE>
	64: StLoc[16](loc10: Balance<SAFE>)
	65: MutBorrowLoc[16](loc10: Balance<SAFE>)
	66: CopyLoc[4](Arg4: &mut Balance<SAFE>)
	67: CopyLoc[2](Arg2: &vector<u64>)
	68: MoveLoc[8](loc2: u64)
	69: VecImmBorrow(21)
	70: ReadRef
	71: Call balance::split<SAFE>(&mut Balance<SAFE>, u64): Balance<SAFE>
	72: Call balance::join<SAFE>(&mut Balance<SAFE>, Balance<SAFE>): u64
	73: Pop
	74: ImmBorrowLoc[16](loc10: Balance<SAFE>)
	75: Call balance::value<SAFE>(&Balance<SAFE>): u64
	76: LdU64(0)
	77: Gt
	78: BrFalse(91)
B6:
	79: CopyLoc[13](loc7: &mut Validator)
	80: FreezeRef
	81: Call validator::safe_address(&Validator): address
	82: StLoc[14](loc8: address)
	83: CopyLoc[13](loc7: &mut Validator)
	84: MoveLoc[16](loc10: Balance<SAFE>)
	85: CopyLoc[14](loc8: address)
	86: CopyLoc[5](Arg5: &mut TxContext)
	87: Call validator::request_add_stake(&mut Validator, Balance<SAFE>, address, &mut TxContext): StakedSafe
	88: MoveLoc[14](loc8: address)
	89: Call transfer::public_transfer<StakedSafe>(StakedSafe, address)
	90: Branch(93)
B7:
	91: MoveLoc[16](loc10: Balance<SAFE>)
	92: Call balance::destroy_zero<SAFE>(Balance<SAFE>)
B8:
	93: MoveLoc[13](loc7: &mut Validator)
	94: MoveLoc[10](loc4: Balance<SAFE>)
	95: Call validator::deposit_stake_rewards(&mut Validator, Balance<SAFE>)
	96: MoveLoc[7](loc1: u64)
	97: LdU64(1)
	98: Add
	99: StLoc[7](loc1: u64)
	100: Branch(29)
B9:
	101: MoveLoc[0](Arg0: &mut vector<Validator>)
	102: Pop
	103: MoveLoc[4](Arg4: &mut Balance<SAFE>)
	104: Pop
	105: MoveLoc[3](Arg3: &mut Balance<SAFE>)
	106: Pop
	107: MoveLoc[5](Arg5: &mut TxContext)
	108: Pop
	109: MoveLoc[2](Arg2: &vector<u64>)
	110: Pop
	111: MoveLoc[1](Arg1: &vector<u64>)
	112: Pop
	113: Ret
}

emit_validator_epoch_events(Arg0: u64, Arg1: &vector<Validator>, Arg2: &vector<u64>, Arg3: &vector<u64>, Arg4: &VecMap<address, VecSet<address>>, Arg5: &vector<address>) {
L6:	loc0: u64
L7:	loc1: vector<address>
L8:	loc2: u64
L9:	loc3: u64
L10:	loc4: u64
L11:	loc5: u64
L12:	loc6: u64
L13:	loc7: vector<address>
L14:	loc8: &Validator
L15:	loc9: address
B0:
	0: CopyLoc[1](Arg1: &vector<Validator>)
	1: VecLen(67)
	2: StLoc[6](loc0: u64)
	3: LdU64(0)
	4: StLoc[9](loc3: u64)
	5: MoveLoc[6](loc0: u64)
	6: StLoc[11](loc5: u64)
B1:
	7: CopyLoc[9](loc3: u64)
	8: CopyLoc[11](loc5: u64)
	9: Lt
	10: BrFalse(77)
B2:
	11: CopyLoc[9](loc3: u64)
	12: StLoc[10](loc4: u64)
	13: CopyLoc[1](Arg1: &vector<Validator>)
	14: CopyLoc[10](loc4: u64)
	15: VecImmBorrow(67)
	16: StLoc[14](loc8: &Validator)
	17: CopyLoc[14](loc8: &Validator)
	18: Call validator::safe_address(&Validator): address
	19: StLoc[15](loc9: address)
	20: CopyLoc[4](Arg4: &VecMap<address, VecSet<address>>)
	21: ImmBorrowLoc[15](loc9: address)
	22: Call vec_map::contains<address, VecSet<address>>(&VecMap<address, VecSet<address>>, &address): bool
	23: BrFalse(32)
B3:
	24: Branch(25)
B4:
	25: CopyLoc[4](Arg4: &VecMap<address, VecSet<address>>)
	26: ImmBorrowLoc[15](loc9: address)
	27: Call vec_map::get<address, VecSet<address>>(&VecMap<address, VecSet<address>>, &address): &VecSet<address>
	28: ReadRef
	29: Call vec_set::into_keys<address>(VecSet<address>): vector<address>
	30: StLoc[7](loc1: vector<address>)
	31: Branch(34)
B5:
	32: LdConst[22](vector<address>: 00)
	33: StLoc[7](loc1: vector<address>)
B6:
	34: MoveLoc[7](loc1: vector<address>)
	35: StLoc[13](loc7: vector<address>)
	36: CopyLoc[5](Arg5: &vector<address>)
	37: ImmBorrowLoc[15](loc9: address)
	38: Call vector::contains<address>(&vector<address>, &address): bool
	39: BrFalse(43)
B7:
	40: LdU64(0)
	41: StLoc[8](loc2: u64)
	42: Branch(45)
B8:
	43: LdU64(1)
	44: StLoc[8](loc2: u64)
B9:
	45: MoveLoc[8](loc2: u64)
	46: StLoc[12](loc6: u64)
	47: CopyLoc[0](Arg0: u64)
	48: MoveLoc[15](loc9: address)
	49: CopyLoc[14](loc8: &Validator)
	50: Call validator::gas_price(&Validator): u64
	51: CopyLoc[14](loc8: &Validator)
	52: Call validator::total_stake(&Validator): u64
	53: CopyLoc[14](loc8: &Validator)
	54: Call validator::voting_power(&Validator): u64
	55: CopyLoc[14](loc8: &Validator)
	56: Call validator::commission_rate(&Validator): u64
	57: CopyLoc[2](Arg2: &vector<u64>)
	58: CopyLoc[10](loc4: u64)
	59: VecImmBorrow(21)
	60: ReadRef
	61: CopyLoc[3](Arg3: &vector<u64>)
	62: MoveLoc[10](loc4: u64)
	63: VecImmBorrow(21)
	64: ReadRef
	65: MoveLoc[14](loc8: &Validator)
	66: CopyLoc[0](Arg0: u64)
	67: Call validator::pool_token_exchange_rate_at_epoch(&Validator, u64): PoolTokenExchangeRate
	68: MoveLoc[13](loc7: vector<address>)
	69: MoveLoc[12](loc6: u64)
	70: Pack[2](ValidatorEpochInfoEventV2)
	71: Call event::emit<ValidatorEpochInfoEventV2>(ValidatorEpochInfoEventV2)
	72: MoveLoc[9](loc3: u64)
	73: LdU64(1)
	74: Add
	75: StLoc[9](loc3: u64)
	76: Branch(7)
B10:
	77: MoveLoc[1](Arg1: &vector<Validator>)
	78: Pop
	79: MoveLoc[3](Arg3: &vector<u64>)
	80: Pop
	81: MoveLoc[5](Arg5: &vector<address>)
	82: Pop
	83: MoveLoc[4](Arg4: &VecMap<address, VecSet<address>>)
	84: Pop
	85: MoveLoc[2](Arg2: &vector<u64>)
	86: Pop
	87: Ret
}

public sum_voting_power_by_addresses(Arg0: &vector<Validator>, Arg1: &vector<address>): u64 {
L2:	loc0: u64
L3:	loc1: &address
L4:	loc2: u64
L5:	loc3: u64
L6:	loc4: u64
L7:	loc5: u64
L8:	loc6: &vector<address>
L9:	loc7: &Validator
B0:
	0: LdU64(0)
	1: StLoc[7](loc5: u64)
	2: MoveLoc[1](Arg1: &vector<address>)
	3: StLoc[8](loc6: &vector<address>)
	4: CopyLoc[8](loc6: &vector<address>)
	5: VecLen(28)
	6: StLoc[2](loc0: u64)
	7: LdU64(0)
	8: StLoc[4](loc2: u64)
	9: MoveLoc[2](loc0: u64)
	10: StLoc[6](loc4: u64)
B1:
	11: CopyLoc[4](loc2: u64)
	12: CopyLoc[6](loc4: u64)
	13: Lt
	14: BrFalse(36)
B2:
	15: CopyLoc[4](loc2: u64)
	16: StLoc[5](loc3: u64)
	17: CopyLoc[8](loc6: &vector<address>)
	18: MoveLoc[5](loc3: u64)
	19: VecImmBorrow(28)
	20: StLoc[3](loc1: &address)
	21: CopyLoc[0](Arg0: &vector<Validator>)
	22: MoveLoc[3](loc1: &address)
	23: ReadRef
	24: Call get_validator_ref(&vector<Validator>, address): &Validator
	25: StLoc[9](loc7: &Validator)
	26: MoveLoc[7](loc5: u64)
	27: MoveLoc[9](loc7: &Validator)
	28: Call validator::voting_power(&Validator): u64
	29: Add
	30: StLoc[7](loc5: u64)
	31: MoveLoc[4](loc2: u64)
	32: LdU64(1)
	33: Add
	34: StLoc[4](loc2: u64)
	35: Branch(11)
B3:
	36: MoveLoc[0](Arg0: &vector<Validator>)
	37: Pop
	38: MoveLoc[8](loc6: &vector<address>)
	39: Pop
	40: MoveLoc[7](loc5: u64)
	41: Ret
}

public active_validators(Arg0: &ValidatorSet): &vector<Validator> {
B0:
	0: MoveLoc[0](Arg0: &ValidatorSet)
	1: ImmBorrowField[0](ValidatorSet.active_validators: vector<Validator>)
	2: Ret
}

public is_validator_candidate(Arg0: &ValidatorSet, Arg1: address): bool {
B0:
	0: MoveLoc[0](Arg0: &ValidatorSet)
	1: ImmBorrowField[1](ValidatorSet.validator_candidates: Table<address, ValidatorWrapper>)
	2: MoveLoc[1](Arg1: address)
	3: Call table::contains<address, ValidatorWrapper>(&Table<address, ValidatorWrapper>, address): bool
	4: Ret
}

public(friend) is_active_validator(Arg0: &ValidatorSet, Arg1: address): bool {
L2:	loc0: u64
L3:	loc1: bool
L4:	loc2: u64
L5:	loc3: u64
L6:	loc4: u64
L7:	loc5: &vector<Validator>
B0:
	0: MoveLoc[0](Arg0: &ValidatorSet)
	1: ImmBorrowField[0](ValidatorSet.active_validators: vector<Validator>)
	2: StLoc[7](loc5: &vector<Validator>)
	3: CopyLoc[7](loc5: &vector<Validator>)
	4: VecLen(67)
	5: StLoc[2](loc0: u64)
	6: LdU64(0)
	7: StLoc[5](loc3: u64)
	8: MoveLoc[2](loc0: u64)
	9: StLoc[6](loc4: u64)
B1:
	10: CopyLoc[5](loc3: u64)
	11: CopyLoc[6](loc4: u64)
	12: Lt
	13: BrFalse(33)
B2:
	14: CopyLoc[5](loc3: u64)
	15: StLoc[4](loc2: u64)
	16: CopyLoc[7](loc5: &vector<Validator>)
	17: MoveLoc[4](loc2: u64)
	18: VecImmBorrow(67)
	19: Call validator::safe_address(&Validator): address
	20: CopyLoc[1](Arg1: address)
	21: Eq
	22: BrFalse(28)
B3:
	23: MoveLoc[7](loc5: &vector<Validator>)
	24: Pop
	25: LdTrue
	26: StLoc[3](loc1: bool)
	27: Branch(37)
B4:
	28: MoveLoc[5](loc3: u64)
	29: LdU64(1)
	30: Add
	31: StLoc[5](loc3: u64)
	32: Branch(10)
B5:
	33: MoveLoc[7](loc5: &vector<Validator>)
	34: Pop
	35: LdFalse
	36: StLoc[3](loc1: bool)
B6:
	37: MoveLoc[3](loc1: bool)
	38: Ret
}

public is_inactive_validator(Arg0: &ValidatorSet, Arg1: ID): bool {
B0:
	0: MoveLoc[0](Arg0: &ValidatorSet)
	1: ImmBorrowField[3](ValidatorSet.inactive_validators: Table<ID, ValidatorWrapper>)
	2: MoveLoc[1](Arg1: ID)
	3: Call table::contains<ID, ValidatorWrapper>(&Table<ID, ValidatorWrapper>, ID): bool
	4: Ret
}

public(friend) is_at_risk_validator(Arg0: &ValidatorSet, Arg1: address): bool {
B0:
	0: MoveLoc[0](Arg0: &ValidatorSet)
	1: ImmBorrowField[8](ValidatorSet.at_risk_validators: VecMap<address, u64>)
	2: ImmBorrowLoc[1](Arg1: address)
	3: Call vec_map::contains<address, u64>(&VecMap<address, u64>, &address): bool
	4: Ret
}

public(friend) active_validator_addresses(Arg0: &ValidatorSet): vector<address> {
L1:	loc0: u64
L2:	loc1: u64
L3:	loc2: u64
L4:	loc3: vector<address>
L5:	loc4: u64
L6:	loc5: &vector<Validator>
L7:	loc6: &Validator
L8:	loc7: &vector<Validator>
B0:
	0: MoveLoc[0](Arg0: &ValidatorSet)
	1: ImmBorrowField[0](ValidatorSet.active_validators: vector<Validator>)
	2: StLoc[8](loc7: &vector<Validator>)
	3: LdConst[22](vector<address>: 00)
	4: StLoc[4](loc3: vector<address>)
	5: MoveLoc[8](loc7: &vector<Validator>)
	6: StLoc[6](loc5: &vector<Validator>)
	7: CopyLoc[6](loc5: &vector<Validator>)
	8: VecLen(67)
	9: StLoc[1](loc0: u64)
	10: LdU64(0)
	11: StLoc[2](loc1: u64)
	12: MoveLoc[1](loc0: u64)
	13: StLoc[5](loc4: u64)
B1:
	14: CopyLoc[2](loc1: u64)
	15: CopyLoc[5](loc4: u64)
	16: Lt
	17: BrFalse(33)
B2:
	18: CopyLoc[2](loc1: u64)
	19: StLoc[3](loc2: u64)
	20: CopyLoc[6](loc5: &vector<Validator>)
	21: MoveLoc[3](loc2: u64)
	22: VecImmBorrow(67)
	23: StLoc[7](loc6: &Validator)
	24: MutBorrowLoc[4](loc3: vector<address>)
	25: MoveLoc[7](loc6: &Validator)
	26: Call validator::safe_address(&Validator): address
	27: VecPushBack(28)
	28: MoveLoc[2](loc1: u64)
	29: LdU64(1)
	30: Add
	31: StLoc[2](loc1: u64)
	32: Branch(14)
B3:
	33: MoveLoc[6](loc5: &vector<Validator>)
	34: Pop
	35: MoveLoc[4](loc3: vector<address>)
	36: 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
	13 => u64: 13
	14 => u64: 101
	15 => u8: 1
	16 => u8: 2
	17 => u8: 3
	18 => u64: 10000
	19 => u64: 1000000000
	20 => u64: 14
	21 => vector<u64>: 00
	22 => vector<address>: 00
]
}

// Move bytecode v6
module 3.validator_wrapper {
use 0000000000000000000000000000000000000000000000000000000000000002::tx_context;
use 0000000000000000000000000000000000000000000000000000000000000002::versioned;
use 0000000000000000000000000000000000000000000000000000000000000003::validator;

struct ValidatorWrapper has store {
	inner: Versioned
}

public(friend) create_v1(Arg0: Validator, Arg1: &mut TxContext): ValidatorWrapper {
B0:
	0: LdU64(1)
	1: MoveLoc[0](Arg0: Validator)
	2: MoveLoc[1](Arg1: &mut TxContext)
	3: Call versioned::create<Validator>(u64, Validator, &mut TxContext): Versioned
	4: Pack[0](ValidatorWrapper)
	5: Ret
}

public(friend) load_validator_maybe_upgrade(Arg0: &mut ValidatorWrapper): &mut Validator {
B0:
	0: CopyLoc[0](Arg0: &mut ValidatorWrapper)
	1: FreezeRef
	2: Call upgrade_to_latest(&ValidatorWrapper)
	3: MoveLoc[0](Arg0: &mut ValidatorWrapper)
	4: MutBorrowField[0](ValidatorWrapper.inner: Versioned)
	5: Call versioned::load_value_mut<Validator>(&mut Versioned): &mut Validator
	6: Ret
}

public(friend) destroy(Arg0: ValidatorWrapper): Validator {
B0:
	0: ImmBorrowLoc[0](Arg0: ValidatorWrapper)
	1: Call upgrade_to_latest(&ValidatorWrapper)
	2: MoveLoc[0](Arg0: ValidatorWrapper)
	3: Unpack[0](ValidatorWrapper)
	4: Call versioned::destroy<Validator>(Versioned): Validator
	5: Ret
}

upgrade_to_latest(Arg0: &ValidatorWrapper) {
B0:
	0: MoveLoc[0](Arg0: &ValidatorWrapper)
	1: Call version(&ValidatorWrapper): u64
	2: LdU64(1)
	3: Eq
	4: BrFalse(6)
B1:
	5: Branch(8)
B2:
	6: LdConst[0](u64: 0)
	7: Abort
B3:
	8: Ret
}

version(Arg0: &ValidatorWrapper): u64 {
B0:
	0: MoveLoc[0](Arg0: &ValidatorWrapper)
	1: ImmBorrowField[0](ValidatorWrapper.inner: Versioned)
	2: Call versioned::version(&Versioned): u64
	3: Ret
}

Constants [
	0 => u64: 0
]
}

// Move bytecode v6
module 3.voting_power {
use 0000000000000000000000000000000000000000000000000000000000000003::validator;
use 0000000000000000000000000000000000000000000000000000000000000001::option;
use 0000000000000000000000000000000000000000000000000000000000000001::u64;
use 0000000000000000000000000000000000000000000000000000000000000001::vector;

struct VotingPowerInfo has drop {
	validator_index: u64,
	voting_power: u64
}

struct VotingPowerInfoV2 has drop {
	validator_index: u64,
	voting_power: u64,
	stake: u64
}

public(friend) set_voting_power(Arg0: &mut vector<Validator>, Arg1: u64) {
L2:	loc0: u64
L3:	loc1: vector<VotingPowerInfoV2>
L4:	loc2: u64
L5:	loc3: u64
L6:	loc4: u64
B0:
	0: LdConst[0](u64: 10000)
	1: StLoc[6](loc4: u64)
	2: CopyLoc[6](loc4: u64)
	3: CopyLoc[0](Arg0: &mut vector<Validator>)
	4: FreezeRef
	5: VecLen(11)
	6: Call u64::divide_and_round_up(u64, u64): u64
	7: StLoc[2](loc0: u64)
	8: MoveLoc[6](loc4: u64)
	9: LdConst[2](u64: 1000)
	10: MoveLoc[2](loc0: u64)
	11: Call u64::max(u64, u64): u64
	12: Call u64::min(u64, u64): u64
	13: StLoc[5](loc3: u64)
	14: CopyLoc[0](Arg0: &mut vector<Validator>)
	15: FreezeRef
	16: CopyLoc[5](loc3: u64)
	17: MoveLoc[1](Arg1: u64)
	18: Call init_voting_power_info(&vector<Validator>, u64, u64): vector<VotingPowerInfoV2> * u64
	19: StLoc[4](loc2: u64)
	20: StLoc[3](loc1: vector<VotingPowerInfoV2>)
	21: MutBorrowLoc[3](loc1: vector<VotingPowerInfoV2>)
	22: MoveLoc[5](loc3: u64)
	23: MoveLoc[4](loc2: u64)
	24: Call adjust_voting_power(&mut vector<VotingPowerInfoV2>, u64, u64)
	25: CopyLoc[0](Arg0: &mut vector<Validator>)
	26: MoveLoc[3](loc1: vector<VotingPowerInfoV2>)
	27: Call update_voting_power(&mut vector<Validator>, vector<VotingPowerInfoV2>)
	28: MoveLoc[0](Arg0: &mut vector<Validator>)
	29: FreezeRef
	30: Call check_invariants(&vector<Validator>)
	31: Ret
}

init_voting_power_info(Arg0: &vector<Validator>, Arg1: u64, Arg2: u64): vector<VotingPowerInfoV2> * u64 {
L3:	loc0: u64
L4:	loc1: u64
L5:	loc2: u64
L6:	loc3: vector<VotingPowerInfoV2>
L7:	loc4: u64
L8:	loc5: u64
L9:	loc6: u64
L10:	loc7: u64
B0:
	0: LdU64(0)
	1: StLoc[9](loc6: u64)
	2: VecPack(13, 0)
	3: StLoc[6](loc3: vector<VotingPowerInfoV2>)
	4: CopyLoc[0](Arg0: &vector<Validator>)
	5: VecLen(11)
	6: StLoc[3](loc0: u64)
	7: LdU64(0)
	8: StLoc[4](loc1: u64)
	9: MoveLoc[3](loc0: u64)
	10: StLoc[8](loc5: u64)
B1:
	11: CopyLoc[4](loc1: u64)
	12: CopyLoc[8](loc5: u64)
	13: Lt
	14: BrFalse(43)
B2:
	15: CopyLoc[4](loc1: u64)
	16: StLoc[5](loc2: u64)
	17: CopyLoc[0](Arg0: &vector<Validator>)
	18: CopyLoc[5](loc2: u64)
	19: VecImmBorrow(11)
	20: Call validator::total_stake(&Validator): u64
	21: StLoc[7](loc4: u64)
	22: CopyLoc[7](loc4: u64)
	23: CopyLoc[2](Arg2: u64)
	24: Call derive_raw_voting_power(u64, u64): u64
	25: CopyLoc[1](Arg1: u64)
	26: Call u64::min(u64, u64): u64
	27: StLoc[10](loc7: u64)
	28: MutBorrowLoc[6](loc3: vector<VotingPowerInfoV2>)
	29: MoveLoc[5](loc2: u64)
	30: CopyLoc[10](loc7: u64)
	31: MoveLoc[7](loc4: u64)
	32: Pack[1](VotingPowerInfoV2)
	33: Call insert(&mut vector<VotingPowerInfoV2>, VotingPowerInfoV2)
	34: MoveLoc[9](loc6: u64)
	35: MoveLoc[10](loc7: u64)
	36: Add
	37: StLoc[9](loc6: u64)
	38: MoveLoc[4](loc1: u64)
	39: LdU64(1)
	40: Add
	41: StLoc[4](loc1: u64)
	42: Branch(11)
B3:
	43: MoveLoc[0](Arg0: &vector<Validator>)
	44: Pop
	45: MoveLoc[6](loc3: vector<VotingPowerInfoV2>)
	46: LdConst[0](u64: 10000)
	47: MoveLoc[9](loc6: u64)
	48: Sub
	49: Ret
}

public(friend) derive_raw_voting_power(Arg0: u64, Arg1: u64): u64 {
B0:
	0: MoveLoc[0](Arg0: u64)
	1: CastU128
	2: LdConst[0](u64: 10000)
	3: CastU128
	4: Mul
	5: MoveLoc[1](Arg1: u64)
	6: CastU128
	7: Div
	8: CastU64
	9: Ret
}

insert(Arg0: &mut vector<VotingPowerInfoV2>, Arg1: VotingPowerInfoV2) {
L2:	loc0: u64
L3:	loc1: Option<u64>
L4:	loc2: u64
L5:	loc3: u64
L6:	loc4: VotingPowerInfoV2
L7:	loc5: &mut vector<VotingPowerInfoV2>
L8:	loc6: u64
L9:	loc7: u64
L10:	loc8: Option<u64>
L11:	loc9: &VotingPowerInfoV2
L12:	loc10: u64
L13:	loc11: Option<u64>
L14:	loc12: u64
L15:	loc13: &mut vector<VotingPowerInfoV2>
B0:
	0: CopyLoc[0](Arg0: &mut vector<VotingPowerInfoV2>)
	1: FreezeRef
	2: VecLen(13)
	3: StLoc[12](loc10: u64)
	4: CopyLoc[0](Arg0: &mut vector<VotingPowerInfoV2>)
	5: StLoc[15](loc13: &mut vector<VotingPowerInfoV2>)
	6: CopyLoc[15](loc13: &mut vector<VotingPowerInfoV2>)
	7: FreezeRef
	8: VecLen(13)
	9: StLoc[2](loc0: u64)
	10: LdU64(0)
	11: StLoc[8](loc6: u64)
	12: MoveLoc[2](loc0: u64)
	13: StLoc[14](loc12: u64)
B1:
	14: CopyLoc[8](loc6: u64)
	15: CopyLoc[14](loc12: u64)
	16: Lt
	17: BrFalse(44)
B2:
	18: CopyLoc[8](loc6: u64)
	19: StLoc[9](loc7: u64)
	20: CopyLoc[15](loc13: &mut vector<VotingPowerInfoV2>)
	21: FreezeRef
	22: CopyLoc[9](loc7: u64)
	23: VecImmBorrow(13)
	24: StLoc[11](loc9: &VotingPowerInfoV2)
	25: ImmBorrowLoc[1](Arg1: VotingPowerInfoV2)
	26: ImmBorrowField[0](VotingPowerInfoV2.stake: u64)
	27: ReadRef
	28: MoveLoc[11](loc9: &VotingPowerInfoV2)
	29: ImmBorrowField[0](VotingPowerInfoV2.stake: u64)
	30: ReadRef
	31: Ge
	32: BrFalse(39)
B3:
	33: MoveLoc[15](loc13: &mut vector<VotingPowerInfoV2>)
	34: Pop
	35: MoveLoc[9](loc7: u64)
	36: Call option::some<u64>(u64): Option<u64>
	37: StLoc[3](loc1: Option<u64>)
	38: Branch(48)
B4:
	39: MoveLoc[8](loc6: u64)
	40: LdU64(1)
	41: Add
	42: StLoc[8](loc6: u64)
	43: Branch(14)
B5:
	44: MoveLoc[15](loc13: &mut vector<VotingPowerInfoV2>)
	45: Pop
	46: Call option::none<u64>(): Option<u64>
	47: StLoc[3](loc1: Option<u64>)
B6:
	48: MoveLoc[3](loc1: Option<u64>)
	49: StLoc[10](loc8: Option<u64>)
	50: MoveLoc[0](Arg0: &mut vector<VotingPowerInfoV2>)
	51: StLoc[7](loc5: &mut vector<VotingPowerInfoV2>)
	52: MoveLoc[1](Arg1: VotingPowerInfoV2)
	53: StLoc[6](loc4: VotingPowerInfoV2)
	54: MoveLoc[10](loc8: Option<u64>)
	55: StLoc[13](loc11: Option<u64>)
	56: ImmBorrowLoc[13](loc11: Option<u64>)
	57: Call option::is_some<u64>(&Option<u64>): bool
	58: BrFalse(63)
B7:
	59: MoveLoc[13](loc11: Option<u64>)
	60: Call option::destroy_some<u64>(Option<u64>): u64
	61: StLoc[5](loc3: u64)
	62: Branch(67)
B8:
	63: MoveLoc[13](loc11: Option<u64>)
	64: Call option::destroy_none<u64>(Option<u64>)
	65: MoveLoc[12](loc10: u64)
	66: StLoc[5](loc3: u64)
B9:
	67: MoveLoc[5](loc3: u64)
	68: StLoc[4](loc2: u64)
	69: MoveLoc[7](loc5: &mut vector<VotingPowerInfoV2>)
	70: MoveLoc[6](loc4: VotingPowerInfoV2)
	71: MoveLoc[4](loc2: u64)
	72: Call vector::insert<VotingPowerInfoV2>(&mut vector<VotingPowerInfoV2>, VotingPowerInfoV2, u64)
	73: Ret
}

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

update_voting_power(Arg0: &mut vector<Validator>, Arg1: vector<VotingPowerInfoV2>) {
L2:	loc0: u64
L3:	loc1: u64
L4:	loc2: u64
L5:	loc3: vector<VotingPowerInfoV2>
L6:	loc4: u64
L7:	loc5: u64
B0:
	0: MoveLoc[1](Arg1: vector<VotingPowerInfoV2>)
	1: StLoc[5](loc3: vector<VotingPowerInfoV2>)
	2: ImmBorrowLoc[5](loc3: vector<VotingPowerInfoV2>)
	3: VecLen(13)
	4: StLoc[2](loc0: u64)
	5: LdU64(0)
	6: StLoc[3](loc1: u64)
	7: MoveLoc[2](loc0: u64)
	8: StLoc[4](loc2: u64)
B1:
	9: CopyLoc[3](loc1: u64)
	10: CopyLoc[4](loc2: u64)
	11: Lt
	12: BrFalse(31)
B2:
	13: CopyLoc[3](loc1: u64)
	14: Pop
	15: MutBorrowLoc[5](loc3: vector<VotingPowerInfoV2>)
	16: VecPopBack(13)
	17: Unpack[1](VotingPowerInfoV2)
	18: Pop
	19: StLoc[7](loc5: u64)
	20: StLoc[6](loc4: u64)
	21: CopyLoc[0](Arg0: &mut vector<Validator>)
	22: MoveLoc[6](loc4: u64)
	23: VecMutBorrow(11)
	24: MoveLoc[7](loc5: u64)
	25: Call validator::set_voting_power(&mut Validator, u64)
	26: MoveLoc[3](loc1: u64)
	27: LdU64(1)
	28: Add
	29: StLoc[3](loc1: u64)
	30: Branch(9)
B3:
	31: MoveLoc[0](Arg0: &mut vector<Validator>)
	32: Pop
	33: MoveLoc[5](loc3: vector<VotingPowerInfoV2>)
	34: VecUnpack(13, 0)
	35: Ret
}

check_invariants(Arg0: &vector<Validator>) {
L1:	loc0: u64
L2:	loc1: u64
L3:	loc2: u64
L4:	loc3: u64
L5:	loc4: u64
L6:	loc5: u64
L7:	loc6: u64
L8:	loc7: u64
L9:	loc8: u64
L10:	loc9: u64
L11:	loc10: u64
L12:	loc11: u64
L13:	loc12: u64
L14:	loc13: u64
L15:	loc14: u64
L16:	loc15: u64
L17:	loc16: u64
L18:	loc17: &vector<Validator>
L19:	loc18: &Validator
L20:	loc19: &Validator
L21:	loc20: u64
B0:
	0: LdU64(0)
	1: StLoc[17](loc16: u64)
	2: CopyLoc[0](Arg0: &vector<Validator>)
	3: StLoc[18](loc17: &vector<Validator>)
	4: CopyLoc[18](loc17: &vector<Validator>)
	5: VecLen(11)
	6: StLoc[2](loc1: u64)
	7: LdU64(0)
	8: StLoc[7](loc6: u64)
	9: MoveLoc[2](loc1: u64)
	10: StLoc[16](loc15: u64)
B1:
	11: CopyLoc[7](loc6: u64)
	12: CopyLoc[16](loc15: u64)
	13: Lt
	14: BrFalse(42)
B2:
	15: CopyLoc[7](loc6: u64)
	16: StLoc[8](loc7: u64)
	17: CopyLoc[18](loc17: &vector<Validator>)
	18: MoveLoc[8](loc7: u64)
	19: VecImmBorrow(11)
	20: Call validator::voting_power(&Validator): u64
	21: StLoc[21](loc20: u64)
	22: CopyLoc[21](loc20: u64)
	23: LdU64(0)
	24: Gt
	25: BrFalse(27)
B3:
	26: Branch(33)
B4:
	27: MoveLoc[18](loc17: &vector<Validator>)
	28: Pop
	29: MoveLoc[0](Arg0: &vector<Validator>)
	30: Pop
	31: LdConst[6](u64: 4)
	32: Abort
B5:
	33: MoveLoc[17](loc16: u64)
	34: MoveLoc[21](loc20: u64)
	35: Add
	36: StLoc[17](loc16: u64)
	37: MoveLoc[7](loc6: u64)
	38: LdU64(1)
	39: Add
	40: StLoc[7](loc6: u64)
	41: Branch(11)
B6:
	42: MoveLoc[18](loc17: &vector<Validator>)
	43: Pop
	44: MoveLoc[17](loc16: u64)
	45: LdConst[0](u64: 10000)
	46: Eq
	47: BrFalse(49)
B7:
	48: Branch(53)
B8:
	49: MoveLoc[0](Arg0: &vector<Validator>)
	50: Pop
	51: LdConst[3](u64: 1)
	52: Abort
B9:
	53: CopyLoc[0](Arg0: &vector<Validator>)
	54: VecLen(11)
	55: StLoc[9](loc8: u64)
	56: CopyLoc[9](loc8: u64)
	57: StLoc[1](loc0: u64)
	58: LdU64(0)
	59: StLoc[5](loc4: u64)
	60: MoveLoc[1](loc0: u64)
	61: StLoc[14](loc13: u64)
B10:
	62: CopyLoc[5](loc4: u64)
	63: CopyLoc[14](loc13: u64)
	64: Lt
	65: BrFalse(136)
B11:
	66: CopyLoc[5](loc4: u64)
	67: StLoc[3](loc2: u64)
	68: CopyLoc[3](loc2: u64)
	69: LdU64(1)
	70: Add
	71: StLoc[6](loc5: u64)
	72: CopyLoc[9](loc8: u64)
	73: StLoc[15](loc14: u64)
B12:
	74: CopyLoc[6](loc5: u64)
	75: CopyLoc[15](loc14: u64)
	76: Lt
	77: BrFalse(131)
B13:
	78: CopyLoc[6](loc5: u64)
	79: StLoc[4](loc3: u64)
	80: CopyLoc[0](Arg0: &vector<Validator>)
	81: CopyLoc[3](loc2: u64)
	82: VecImmBorrow(11)
	83: StLoc[19](loc18: &Validator)
	84: CopyLoc[0](Arg0: &vector<Validator>)
	85: MoveLoc[4](loc3: u64)
	86: VecImmBorrow(11)
	87: StLoc[20](loc19: &Validator)
	88: CopyLoc[19](loc18: &Validator)
	89: Call validator::total_stake(&Validator): u64
	90: StLoc[12](loc11: u64)
	91: CopyLoc[20](loc19: &Validator)
	92: Call validator::total_stake(&Validator): u64
	93: StLoc[13](loc12: u64)
	94: MoveLoc[19](loc18: &Validator)
	95: Call validator::voting_power(&Validator): u64
	96: StLoc[10](loc9: u64)
	97: MoveLoc[20](loc19: &Validator)
	98: Call validator::voting_power(&Validator): u64
	99: StLoc[11](loc10: u64)
	100: CopyLoc[12](loc11: u64)
	101: CopyLoc[13](loc12: u64)
	102: Gt
	103: BrFalse(113)
B14:
	104: CopyLoc[10](loc9: u64)
	105: CopyLoc[11](loc10: u64)
	106: Ge
	107: BrFalse(109)
B15:
	108: Branch(113)
B16:
	109: MoveLoc[0](Arg0: &vector<Validator>)
	110: Pop
	111: LdConst[4](u64: 2)
	112: Abort
B17:
	113: MoveLoc[12](loc11: u64)
	114: MoveLoc[13](loc12: u64)
	115: Lt
	116: BrFalse(126)
B18:
	117: MoveLoc[10](loc9: u64)
	118: MoveLoc[11](loc10: u64)
	119: Le
	120: BrFalse(122)
B19:
	121: Branch(126)
B20:
	122: MoveLoc[0](Arg0: &vector<Validator>)
	123: Pop
	124: LdConst[4](u64: 2)
	125: Abort
B21:
	126: MoveLoc[6](loc5: u64)
	127: LdU64(1)
	128: Add
	129: StLoc[6](loc5: u64)
	130: Branch(74)
B22:
	131: MoveLoc[5](loc4: u64)
	132: LdU64(1)
	133: Add
	134: StLoc[5](loc4: u64)
	135: Branch(62)
B23:
	136: MoveLoc[0](Arg0: &vector<Validator>)
	137: Pop
	138: Ret
}

public total_voting_power(): u64 {
B0:
	0: LdConst[0](u64: 10000)
	1: Ret
}

public quorum_threshold(): u64 {
B0:
	0: LdConst[1](u64: 6667)
	1: Ret
}

Constants [
	0 => u64: 10000
	1 => u64: 6667
	2 => u64: 1000
	3 => u64: 1
	4 => u64: 2
	5 => u64: 3
	6 => u64: 4
]
}