tank

Module0x3466…98bb

Move path: 0xce7f…4db2::tank
Functions: 3122 public, 0 entry
Structs: 6
Friend modules: buck

tank

Bytecode1254 lines

The on-chain disassembly. Offsets are instruction numbers within each function.

// Move bytecode v7

module ce7ff77a83ea0cb6fd39bd8748e2ec89a3f41e8efdc3f4eb123e0ca37b184db2.tank {

use 00db9a10bb9536ab367b7d1ffa404c1d6c55f009076df1139dc108dd86608bbe::math;

use ce7ff77a83ea0cb6fd39bd8748e2ec89a3f41e8efdc3f4eb123e0ca37b184db2::bkt;

use ce7ff77a83ea0cb6fd39bd8748e2ec89a3f41e8efdc3f4eb123e0ca37b184db2::constants;

use ce7ff77a83ea0cb6fd39bd8748e2ec89a3f41e8efdc3f4eb123e0ca37b184db2::tank_events;

use 0000000000000000000000000000000000000000000000000000000000000002::balance;

use 0000000000000000000000000000000000000000000000000000000000000002::dynamic_field;

use 0000000000000000000000000000000000000000000000000000000000000002::object;

use 0000000000000000000000000000000000000000000000000000000000000002::package;

use 0000000000000000000000000000000000000000000000000000000000000002::table;

use 0000000000000000000000000000000000000000000000000000000000000002::transfer;

use 0000000000000000000000000000000000000000000000000000000000000002::tx_context;

struct Tank<phantom Ty0, phantom Ty1> has store, key {

id: UID,

reserve: Balance<Ty0>,

collateral_pool: Balance<Ty1>,

current_p: u64,

current_epoch: u64,

epoch_scale_sum_map: Table<EpochAndScale, u64>,

current_scale: u64,

bkt_pool: Balance<BKT>,

epoch_scale_gain_map: Table<EpochAndScale, u64>,

total_flash_loan_amount: u64

}

struct ContributorToken<phantom Ty0, phantom Ty1> has store, key {

id: UID,

deposit_amount: u64,

start_p: u64,

start_s: u64,

start_g: u64,

start_epoch: u64,

start_scale: u64,

ctx_epoch: u64

}

struct FlashReceipt<phantom Ty0, phantom Ty1> {

amount: u64,

fee: u64

}

struct EpochAndScale has copy, drop, store {

epoch: u64,

scale: u64

}

struct DigestKey has copy, drop, store {

dummy_field: bool

}

struct TANK has drop {

dummy_field: bool

}

public err_deposit_and_withdraw_in_same_txn() {

B0:

0LdConst[6](u64: 8)

1Abort

}

init(Arg0: TANK, Arg1: &mut TxContext) {

B0:

0MoveLoc[0](Arg0: TANK)

1CopyLoc[1](Arg1: &mut TxContext)

2Call package::claim<TANK>(TANK, &mut TxContext): Publisher

3MoveLoc[1](Arg1: &mut TxContext)

4FreezeRef

5Call tx_context::sender(&TxContext): address

6Call transfer::public_transfer<Publisher>(Publisher, address)

7Ret

}

public new_table(Arg0: &mut TxContext): Table<EpochAndScale, u64> {

B0:

0MoveLoc[0](Arg0: &mut TxContext)

1Call table::new<EpochAndScale, u64>(&mut TxContext): Table<EpochAndScale, u64>

2Ret

}

add_table(Arg0: &mut Table<EpochAndScale, u64>, Arg1: u64, Arg2: u64) {

L3: loc0: EpochAndScale

B0:

0CopyLoc[0](Arg0: &mut Table<EpochAndScale, u64>)

1CopyLoc[1](Arg1: u64)

2CopyLoc[2](Arg2: u64)

3Pack[3](EpochAndScale)

4StLoc[3](loc0: EpochAndScale)

5FreezeRef

6MoveLoc[3](loc0: EpochAndScale)

7Call table::contains<EpochAndScale, u64>(&Table<EpochAndScale, u64>, EpochAndScale): bool

8Not

9BrFalse(17)

B1:

10MoveLoc[0](Arg0: &mut Table<EpochAndScale, u64>)

11MoveLoc[1](Arg1: u64)

12MoveLoc[2](Arg2: u64)

13Pack[3](EpochAndScale)

14LdU64(0)

15Call table::add<EpochAndScale, u64>(&mut Table<EpochAndScale, u64>, EpochAndScale, u64)

16Branch(19)

B2:

17MoveLoc[0](Arg0: &mut Table<EpochAndScale, u64>)

18Pop

B3:

19Ret

}

public(friend) new<Ty0, Ty1>(Arg0: &mut TxContext): Tank<Ty0, Ty1> {

B0:

0CopyLoc[0](Arg0: &mut TxContext)

1Call object::new(&mut TxContext): UID

2Call balance::zero<Ty0>(): Balance<Ty0>

3Call balance::zero<Ty1>(): Balance<Ty1>

4Call constants::p_initial_value(): u64

5LdU64(0)

6CopyLoc[0](Arg0: &mut TxContext)

7Call new_table(&mut TxContext): Table<EpochAndScale, u64>

8LdU64(0)

9Call balance::zero<BKT>(): Balance<BKT>

10MoveLoc[0](Arg0: &mut TxContext)

11Call new_table(&mut TxContext): Table<EpochAndScale, u64>

12LdU64(0)

13PackGeneric[0](Tank<Ty0, Ty1>)

14Ret

}

public(friend) collect_bkt<Ty0, Ty1>(Arg0: &mut Tank<Ty0, Ty1>, Arg1: Balance<BKT>) {

L2: loc0: u64

L3: loc1: &mut u64

L4: loc2: u64

B0:

0ImmBorrowLoc[1](Arg1: Balance<BKT>)

1Call balance::value<BKT>(&Balance<BKT>): u64

2StLoc[2](loc0: u64)

3CopyLoc[0](Arg0: &mut Tank<Ty0, Ty1>)

4FreezeRef

5Call get_reserve_balance<Ty0, Ty1>(&Tank<Ty0, Ty1>): u64

6StLoc[4](loc2: u64)

7CopyLoc[0](Arg0: &mut Tank<Ty0, Ty1>)

8MutBorrowFieldGeneric[0](Tank.bkt_pool: Balance<BKT>)

9MoveLoc[1](Arg1: Balance<BKT>)

10Call balance::join<BKT>(&mut Balance<BKT>, Balance<BKT>): u64

11Pop

12CopyLoc[0](Arg0: &mut Tank<Ty0, Ty1>)

13MutBorrowFieldGeneric[1](Tank.epoch_scale_gain_map: Table<EpochAndScale, u64>)

14CopyLoc[0](Arg0: &mut Tank<Ty0, Ty1>)

15ImmBorrowFieldGeneric[2](Tank.current_epoch: u64)

16ReadRef

17CopyLoc[0](Arg0: &mut Tank<Ty0, Ty1>)

18ImmBorrowFieldGeneric[3](Tank.current_scale: u64)

19ReadRef

20Call add_table(&mut Table<EpochAndScale, u64>, u64, u64)

21CopyLoc[0](Arg0: &mut Tank<Ty0, Ty1>)

22MutBorrowFieldGeneric[1](Tank.epoch_scale_gain_map: Table<EpochAndScale, u64>)

23CopyLoc[0](Arg0: &mut Tank<Ty0, Ty1>)

24ImmBorrowFieldGeneric[2](Tank.current_epoch: u64)

25ReadRef

26CopyLoc[0](Arg0: &mut Tank<Ty0, Ty1>)

27ImmBorrowFieldGeneric[3](Tank.current_scale: u64)

28ReadRef

29Pack[3](EpochAndScale)

30Call table::borrow_mut<EpochAndScale, u64>(&mut Table<EpochAndScale, u64>, EpochAndScale): &mut u64

31StLoc[3](loc1: &mut u64)

32CopyLoc[3](loc1: &mut u64)

33ReadRef

34MoveLoc[0](Arg0: &mut Tank<Ty0, Ty1>)

35ImmBorrowFieldGeneric[4](Tank.current_p: u64)

36ReadRef

37CopyLoc[2](loc0: u64)

38MoveLoc[4](loc2: u64)

39Call math::mul_factor(u64, u64, u64): u64

40Add

41MoveLoc[3](loc1: &mut u64)

42WriteRef

43MoveLoc[2](loc0: u64)

44Call tank_events::emit_collect_bkt<Ty1>(u64)

45Ret

}

public deposit<Ty0, Ty1>(Arg0: &mut Tank<Ty0, Ty1>, Arg1: Balance<Ty0>, Arg2: &mut TxContext): ContributorToken<Ty0, Ty1> {

L3: loc0: &u64

L4: loc1: &u64

L5: loc2: u64

L6: loc3: EpochAndScale

L7: loc4: UID

B0:

0CopyLoc[0](Arg0: &mut Tank<Ty0, Ty1>)

1FreezeRef

2Call is_not_locked<Ty0, Ty1>(&Tank<Ty0, Ty1>): bool

3BrFalse(5)

B1:

4Branch(11)

B2:

5MoveLoc[0](Arg0: &mut Tank<Ty0, Ty1>)

6Pop

7MoveLoc[2](Arg2: &mut TxContext)

8Pop

9LdConst[0](u64: 0)

10Abort

B3:

11ImmBorrowLoc[1](Arg1: Balance<Ty0>)

12Call balance::value<Ty0>(&Balance<Ty0>): u64

13LdU64(0)

14Gt

15BrFalse(17)

B4:

16Branch(23)

B5:

17MoveLoc[0](Arg0: &mut Tank<Ty0, Ty1>)

18Pop

19MoveLoc[2](Arg2: &mut TxContext)

20Pop

21LdConst[5](u64: 7)

22Abort

B6:

23ImmBorrowLoc[1](Arg1: Balance<Ty0>)

24Call balance::value<Ty0>(&Balance<Ty0>): u64

25StLoc[5](loc2: u64)

26CopyLoc[5](loc2: u64)

27Call tank_events::emit_deposit<Ty1>(u64)

28CopyLoc[0](Arg0: &mut Tank<Ty0, Ty1>)

29MutBorrowFieldGeneric[5](Tank.reserve: Balance<Ty0>)

30MoveLoc[1](Arg1: Balance<Ty0>)

31Call balance::join<Ty0>(&mut Balance<Ty0>, Balance<Ty0>): u64

32Pop

33CopyLoc[0](Arg0: &mut Tank<Ty0, Ty1>)

34ImmBorrowFieldGeneric[2](Tank.current_epoch: u64)

35ReadRef

36CopyLoc[0](Arg0: &mut Tank<Ty0, Ty1>)

37ImmBorrowFieldGeneric[3](Tank.current_scale: u64)

38ReadRef

39Pack[3](EpochAndScale)

40StLoc[6](loc3: EpochAndScale)

41CopyLoc[0](Arg0: &mut Tank<Ty0, Ty1>)

42MutBorrowFieldGeneric[6](Tank.epoch_scale_sum_map: Table<EpochAndScale, u64>)

43CopyLoc[0](Arg0: &mut Tank<Ty0, Ty1>)

44ImmBorrowFieldGeneric[2](Tank.current_epoch: u64)

45ReadRef

46CopyLoc[0](Arg0: &mut Tank<Ty0, Ty1>)

47ImmBorrowFieldGeneric[3](Tank.current_scale: u64)

48ReadRef

49Call add_table(&mut Table<EpochAndScale, u64>, u64, u64)

50CopyLoc[0](Arg0: &mut Tank<Ty0, Ty1>)

51ImmBorrowFieldGeneric[6](Tank.epoch_scale_sum_map: Table<EpochAndScale, u64>)

52CopyLoc[6](loc3: EpochAndScale)

53Call table::borrow<EpochAndScale, u64>(&Table<EpochAndScale, u64>, EpochAndScale): &u64

54StLoc[4](loc1: &u64)

55CopyLoc[0](Arg0: &mut Tank<Ty0, Ty1>)

56MutBorrowFieldGeneric[1](Tank.epoch_scale_gain_map: Table<EpochAndScale, u64>)

57CopyLoc[0](Arg0: &mut Tank<Ty0, Ty1>)

58ImmBorrowFieldGeneric[2](Tank.current_epoch: u64)

59ReadRef

60CopyLoc[0](Arg0: &mut Tank<Ty0, Ty1>)

61ImmBorrowFieldGeneric[3](Tank.current_scale: u64)

62ReadRef

63Call add_table(&mut Table<EpochAndScale, u64>, u64, u64)

64CopyLoc[0](Arg0: &mut Tank<Ty0, Ty1>)

65ImmBorrowFieldGeneric[1](Tank.epoch_scale_gain_map: Table<EpochAndScale, u64>)

66MoveLoc[6](loc3: EpochAndScale)

67Call table::borrow<EpochAndScale, u64>(&Table<EpochAndScale, u64>, EpochAndScale): &u64

68StLoc[3](loc0: &u64)

69CopyLoc[2](Arg2: &mut TxContext)

70Call object::new(&mut TxContext): UID

71StLoc[7](loc4: UID)

72MutBorrowLoc[7](loc4: UID)

73LdFalse

74Pack[4](DigestKey)

75CopyLoc[2](Arg2: &mut TxContext)

76FreezeRef

77Call tx_context::digest(&TxContext): &vector<u8>

78ReadRef

79Call dynamic_field::add<DigestKey, vector<u8>>(&mut UID, DigestKey, vector<u8>)

80MoveLoc[7](loc4: UID)

81MoveLoc[5](loc2: u64)

82CopyLoc[0](Arg0: &mut Tank<Ty0, Ty1>)

83ImmBorrowFieldGeneric[4](Tank.current_p: u64)

84ReadRef

85MoveLoc[4](loc1: &u64)

86ReadRef

87MoveLoc[3](loc0: &u64)

88ReadRef

89CopyLoc[0](Arg0: &mut Tank<Ty0, Ty1>)

90ImmBorrowFieldGeneric[2](Tank.current_epoch: u64)

91ReadRef

92MoveLoc[0](Arg0: &mut Tank<Ty0, Ty1>)

93ImmBorrowFieldGeneric[3](Tank.current_scale: u64)

94ReadRef

95MoveLoc[2](Arg2: &mut TxContext)

96FreezeRef

97Call tx_context::epoch(&TxContext): u64

98PackGeneric[1](ContributorToken<Ty0, Ty1>)

99Ret

}

public(friend) absorb<Ty0, Ty1>(Arg0: &mut Tank<Ty0, Ty1>, Arg1: Balance<Ty1>, Arg2: u64): Balance<Ty0> {

L3: loc0: u64

L4: loc1: &mut u64

L5: loc2: u64

L6: loc3: u64

L7: loc4: u64

B0:

0ImmBorrowLoc[1](Arg1: Balance<Ty1>)

1Call balance::value<Ty1>(&Balance<Ty1>): u64

2StLoc[3](loc0: u64)

3CopyLoc[0](Arg0: &mut Tank<Ty0, Ty1>)

4ImmBorrowFieldGeneric[5](Tank.reserve: Balance<Ty0>)

5Call balance::value<Ty0>(&Balance<Ty0>): u64

6StLoc[7](loc4: u64)

7CopyLoc[7](loc4: u64)

8CopyLoc[2](Arg2: u64)

9Sub

10StLoc[5](loc2: u64)

11CopyLoc[7](loc4: u64)

12LdU64(0)

13Gt

14BrFalse(16)

B1:

15Branch(20)

B2:

16MoveLoc[0](Arg0: &mut Tank<Ty0, Ty1>)

17Pop

18LdConst[4](u64: 6)

19Abort

B3:

20CopyLoc[0](Arg0: &mut Tank<Ty0, Ty1>)

21MutBorrowFieldGeneric[6](Tank.epoch_scale_sum_map: Table<EpochAndScale, u64>)

22CopyLoc[0](Arg0: &mut Tank<Ty0, Ty1>)

23ImmBorrowFieldGeneric[2](Tank.current_epoch: u64)

24ReadRef

25CopyLoc[0](Arg0: &mut Tank<Ty0, Ty1>)

26ImmBorrowFieldGeneric[3](Tank.current_scale: u64)

27ReadRef

28Call add_table(&mut Table<EpochAndScale, u64>, u64, u64)

29CopyLoc[0](Arg0: &mut Tank<Ty0, Ty1>)

30MutBorrowFieldGeneric[6](Tank.epoch_scale_sum_map: Table<EpochAndScale, u64>)

31CopyLoc[0](Arg0: &mut Tank<Ty0, Ty1>)

32ImmBorrowFieldGeneric[2](Tank.current_epoch: u64)

33ReadRef

34CopyLoc[0](Arg0: &mut Tank<Ty0, Ty1>)

35ImmBorrowFieldGeneric[3](Tank.current_scale: u64)

36ReadRef

37Pack[3](EpochAndScale)

38Call table::borrow_mut<EpochAndScale, u64>(&mut Table<EpochAndScale, u64>, EpochAndScale): &mut u64

39StLoc[4](loc1: &mut u64)

40CopyLoc[4](loc1: &mut u64)

41ReadRef

42CopyLoc[0](Arg0: &mut Tank<Ty0, Ty1>)

43ImmBorrowFieldGeneric[4](Tank.current_p: u64)

44ReadRef

45CopyLoc[3](loc0: u64)

46CopyLoc[7](loc4: u64)

47Call math::mul_factor(u64, u64, u64): u64

48Add

49MoveLoc[4](loc1: &mut u64)

50WriteRef

51CopyLoc[0](Arg0: &mut Tank<Ty0, Ty1>)

52ImmBorrowFieldGeneric[4](Tank.current_p: u64)

53ReadRef

54CopyLoc[5](loc2: u64)

55MoveLoc[7](loc4: u64)

56Call math::mul_factor(u64, u64, u64): u64

57StLoc[6](loc3: u64)

58MoveLoc[5](loc2: u64)

59LdU64(0)

60Eq

61BrFalse(88)

B4:

62CopyLoc[0](Arg0: &mut Tank<Ty0, Ty1>)

63ImmBorrowFieldGeneric[2](Tank.current_epoch: u64)

64ReadRef

65LdU64(1)

66Add

67CopyLoc[0](Arg0: &mut Tank<Ty0, Ty1>)

68MutBorrowFieldGeneric[2](Tank.current_epoch: u64)

69WriteRef

70Call constants::p_initial_value(): u64

71CopyLoc[0](Arg0: &mut Tank<Ty0, Ty1>)

72MutBorrowFieldGeneric[4](Tank.current_p: u64)

73WriteRef

74LdU64(0)

75CopyLoc[0](Arg0: &mut Tank<Ty0, Ty1>)

76MutBorrowFieldGeneric[3](Tank.current_scale: u64)

77WriteRef

78CopyLoc[0](Arg0: &mut Tank<Ty0, Ty1>)

79MutBorrowFieldGeneric[6](Tank.epoch_scale_sum_map: Table<EpochAndScale, u64>)

80CopyLoc[0](Arg0: &mut Tank<Ty0, Ty1>)

81ImmBorrowFieldGeneric[2](Tank.current_epoch: u64)

82ReadRef

83CopyLoc[0](Arg0: &mut Tank<Ty0, Ty1>)

84ImmBorrowFieldGeneric[3](Tank.current_scale: u64)

85ReadRef

86Call add_table(&mut Table<EpochAndScale, u64>, u64, u64)

87Branch(120)

B5:

88CopyLoc[6](loc3: u64)

89Call constants::scale_factor(): u64

90Lt

91BrFalse(116)

B6:

92MoveLoc[6](loc3: u64)

93Call constants::scale_factor(): u64

94Mul

95CopyLoc[0](Arg0: &mut Tank<Ty0, Ty1>)

96MutBorrowFieldGeneric[4](Tank.current_p: u64)

97WriteRef

98CopyLoc[0](Arg0: &mut Tank<Ty0, Ty1>)

99ImmBorrowFieldGeneric[3](Tank.current_scale: u64)

100ReadRef

101LdU64(1)

102Add

103CopyLoc[0](Arg0: &mut Tank<Ty0, Ty1>)

104MutBorrowFieldGeneric[3](Tank.current_scale: u64)

105WriteRef

106CopyLoc[0](Arg0: &mut Tank<Ty0, Ty1>)

107MutBorrowFieldGeneric[6](Tank.epoch_scale_sum_map: Table<EpochAndScale, u64>)

108CopyLoc[0](Arg0: &mut Tank<Ty0, Ty1>)

109ImmBorrowFieldGeneric[2](Tank.current_epoch: u64)

110ReadRef

111CopyLoc[0](Arg0: &mut Tank<Ty0, Ty1>)

112ImmBorrowFieldGeneric[3](Tank.current_scale: u64)

113ReadRef

114Call add_table(&mut Table<EpochAndScale, u64>, u64, u64)

115Branch(120)

B7:

116MoveLoc[6](loc3: u64)

117CopyLoc[0](Arg0: &mut Tank<Ty0, Ty1>)

118MutBorrowFieldGeneric[4](Tank.current_p: u64)

119WriteRef

B8:

120CopyLoc[0](Arg0: &mut Tank<Ty0, Ty1>)

121ImmBorrowFieldGeneric[4](Tank.current_p: u64)

122ReadRef

123LdU64(0)

124Gt

125BrFalse(127)

B9:

126Branch(131)

B10:

127MoveLoc[0](Arg0: &mut Tank<Ty0, Ty1>)

128Pop

129LdConst[3](u64: 4)

130Abort

B11:

131CopyLoc[2](Arg2: u64)

132MoveLoc[3](loc0: u64)

133Call tank_events::emit_absorb<Ty1>(u64, u64)

134CopyLoc[0](Arg0: &mut Tank<Ty0, Ty1>)

135ImmBorrowFieldGeneric[2](Tank.current_epoch: u64)

136ReadRef

137CopyLoc[0](Arg0: &mut Tank<Ty0, Ty1>)

138ImmBorrowFieldGeneric[3](Tank.current_scale: u64)

139ReadRef

140CopyLoc[0](Arg0: &mut Tank<Ty0, Ty1>)

141ImmBorrowFieldGeneric[4](Tank.current_p: u64)

142ReadRef

143Call tank_events::emit_tank_update<Ty1>(u64, u64, u64)

144CopyLoc[0](Arg0: &mut Tank<Ty0, Ty1>)

145MutBorrowFieldGeneric[7](Tank.collateral_pool: Balance<Ty1>)

146MoveLoc[1](Arg1: Balance<Ty1>)

147Call balance::join<Ty1>(&mut Balance<Ty1>, Balance<Ty1>): u64

148Pop

149MoveLoc[0](Arg0: &mut Tank<Ty0, Ty1>)

150MutBorrowFieldGeneric[5](Tank.reserve: Balance<Ty0>)

151MoveLoc[2](Arg2: u64)

152Call balance::split<Ty0>(&mut Balance<Ty0>, u64): Balance<Ty0>

153Ret

}

public(friend) withdraw<Ty0, Ty1>(Arg0: &mut Tank<Ty0, Ty1>, Arg1: &mut BktTreasury, Arg2: ContributorToken<Ty0, Ty1>, Arg3: &TxContext): Balance<Ty0> * Balance<Ty1> * Balance<BKT> {

L4: loc0: &ContributorToken<Ty0, Ty1>

L5: loc1: bool

L6: loc2: Balance<BKT>

L7: loc3: Balance<Ty0>

L8: loc4: u64

L9: loc5: Balance<Ty1>

L10: loc6: vector<u8>

L11: loc7: DigestKey

L12: loc8: UID

B0:

0CopyLoc[0](Arg0: &mut Tank<Ty0, Ty1>)

1ImmBorrowLoc[2](Arg2: ContributorToken<Ty0, Ty1>)

2StLoc[4](loc0: &ContributorToken<Ty0, Ty1>)

3FreezeRef

4MoveLoc[4](loc0: &ContributorToken<Ty0, Ty1>)

5Call get_token_weight<Ty0, Ty1>(&Tank<Ty0, Ty1>, &ContributorToken<Ty0, Ty1>): u64

6StLoc[8](loc4: u64)

7CopyLoc[0](Arg0: &mut Tank<Ty0, Ty1>)

8MutBorrowFieldGeneric[5](Tank.reserve: Balance<Ty0>)

9CopyLoc[8](loc4: u64)

10Call balance::split<Ty0>(&mut Balance<Ty0>, u64): Balance<Ty0>

11StLoc[7](loc3: Balance<Ty0>)

12CopyLoc[0](Arg0: &mut Tank<Ty0, Ty1>)

13MoveLoc[1](Arg1: &mut BktTreasury)

14MutBorrowLoc[2](Arg2: ContributorToken<Ty0, Ty1>)

15CopyLoc[3](Arg3: &TxContext)

16Call claim<Ty0, Ty1>(&mut Tank<Ty0, Ty1>, &mut BktTreasury, &mut ContributorToken<Ty0, Ty1>, &TxContext): Balance<Ty1> * Balance<BKT>

17StLoc[6](loc2: Balance<BKT>)

18StLoc[9](loc5: Balance<Ty1>)

19MoveLoc[2](Arg2: ContributorToken<Ty0, Ty1>)

20UnpackGeneric[1](ContributorToken<Ty0, Ty1>)

21Pop

22Pop

23Pop

24Pop

25Pop

26Pop

27Pop

28StLoc[12](loc8: UID)

29LdFalse

30Pack[4](DigestKey)

31StLoc[11](loc7: DigestKey)

32ImmBorrowLoc[12](loc8: UID)

33CopyLoc[11](loc7: DigestKey)

34Call dynamic_field::exists_with_type<DigestKey, vector<u8>>(&UID, DigestKey): bool

35BrFalse(61)

B1:

36MutBorrowLoc[12](loc8: UID)

37MoveLoc[11](loc7: DigestKey)

38Call dynamic_field::remove<DigestKey, vector<u8>>(&mut UID, DigestKey): vector<u8>

39StLoc[10](loc6: vector<u8>)

40MoveLoc[0](Arg0: &mut Tank<Ty0, Ty1>)

41FreezeRef

42Call get_reserve_balance<Ty0, Ty1>(&Tank<Ty0, Ty1>): u64

43LdU64(0)

44Gt

45BrFalse(53)

B2:

46MoveLoc[10](loc6: vector<u8>)

47MoveLoc[3](Arg3: &TxContext)

48Call tx_context::digest(&TxContext): &vector<u8>

49ReadRef

50Eq

51StLoc[5](loc1: bool)

52Branch(57)

B3:

53MoveLoc[3](Arg3: &TxContext)

54Pop

55LdFalse

56StLoc[5](loc1: bool)

B4:

57MoveLoc[5](loc1: bool)

58BrFalse(60)

B5:

59Call err_deposit_and_withdraw_in_same_txn()

B6:

60Branch(65)

B7:

61MoveLoc[0](Arg0: &mut Tank<Ty0, Ty1>)

62Pop

63MoveLoc[3](Arg3: &TxContext)

64Pop

B8:

65MoveLoc[12](loc8: UID)

66Call object::delete(UID)

67MoveLoc[8](loc4: u64)

68ImmBorrowLoc[7](loc3: Balance<Ty0>)

69Call balance::value<Ty0>(&Balance<Ty0>): u64

70ImmBorrowLoc[6](loc2: Balance<BKT>)

71Call balance::value<BKT>(&Balance<BKT>): u64

72Call tank_events::emit_withdraw<Ty1>(u64, u64, u64)

73MoveLoc[7](loc3: Balance<Ty0>)

74MoveLoc[9](loc5: Balance<Ty1>)

75MoveLoc[6](loc2: Balance<BKT>)

76Ret

}

public claim<Ty0, Ty1>(Arg0: &mut Tank<Ty0, Ty1>, Arg1: &mut BktTreasury, Arg2: &mut ContributorToken<Ty0, Ty1>, Arg3: &TxContext): Balance<Ty1> * Balance<BKT> {

L4: loc0: &mut ContributorToken<Ty0, Ty1>

L5: loc1: &mut ContributorToken<Ty0, Ty1>

L6: loc2: Balance<Ty1>

L7: loc3: Balance<BKT>

L8: loc4: Balance<BKT>

L9: loc5: u64

L10: loc6: &u64

L11: loc7: &u64

B0:

0CopyLoc[0](Arg0: &mut Tank<Ty0, Ty1>)

1CopyLoc[2](Arg2: &mut ContributorToken<Ty0, Ty1>)

2FreezeRef

3Call claim_bkt<Ty0, Ty1>(&mut Tank<Ty0, Ty1>, &ContributorToken<Ty0, Ty1>): Balance<BKT>

4StLoc[8](loc4: Balance<BKT>)

5CopyLoc[0](Arg0: &mut Tank<Ty0, Ty1>)

6MutBorrowFieldGeneric[6](Tank.epoch_scale_sum_map: Table<EpochAndScale, u64>)

7CopyLoc[2](Arg2: &mut ContributorToken<Ty0, Ty1>)

8ImmBorrowFieldGeneric[8](ContributorToken.start_epoch: u64)

9ReadRef

10CopyLoc[2](Arg2: &mut ContributorToken<Ty0, Ty1>)

11ImmBorrowFieldGeneric[9](ContributorToken.start_scale: u64)

12ReadRef

13LdU64(1)

14Add

15Call add_table(&mut Table<EpochAndScale, u64>, u64, u64)

16CopyLoc[0](Arg0: &mut Tank<Ty0, Ty1>)

17CopyLoc[2](Arg2: &mut ContributorToken<Ty0, Ty1>)

18StLoc[4](loc0: &mut ContributorToken<Ty0, Ty1>)

19FreezeRef

20MoveLoc[4](loc0: &mut ContributorToken<Ty0, Ty1>)

21FreezeRef

22Call get_collateral_reward_amount<Ty0, Ty1>(&Tank<Ty0, Ty1>, &ContributorToken<Ty0, Ty1>): u64

23StLoc[9](loc5: u64)

24CopyLoc[0](Arg0: &mut Tank<Ty0, Ty1>)

25ImmBorrowFieldGeneric[6](Tank.epoch_scale_sum_map: Table<EpochAndScale, u64>)

26CopyLoc[0](Arg0: &mut Tank<Ty0, Ty1>)

27ImmBorrowFieldGeneric[2](Tank.current_epoch: u64)

28ReadRef

29CopyLoc[0](Arg0: &mut Tank<Ty0, Ty1>)

30ImmBorrowFieldGeneric[3](Tank.current_scale: u64)

31ReadRef

32Pack[3](EpochAndScale)

33Call table::borrow<EpochAndScale, u64>(&Table<EpochAndScale, u64>, EpochAndScale): &u64

34StLoc[11](loc7: &u64)

35CopyLoc[0](Arg0: &mut Tank<Ty0, Ty1>)

36MutBorrowFieldGeneric[1](Tank.epoch_scale_gain_map: Table<EpochAndScale, u64>)

37CopyLoc[0](Arg0: &mut Tank<Ty0, Ty1>)

38ImmBorrowFieldGeneric[2](Tank.current_epoch: u64)

39ReadRef

40CopyLoc[0](Arg0: &mut Tank<Ty0, Ty1>)

41ImmBorrowFieldGeneric[3](Tank.current_scale: u64)

42ReadRef

43Call add_table(&mut Table<EpochAndScale, u64>, u64, u64)

44CopyLoc[0](Arg0: &mut Tank<Ty0, Ty1>)

45ImmBorrowFieldGeneric[1](Tank.epoch_scale_gain_map: Table<EpochAndScale, u64>)

46CopyLoc[0](Arg0: &mut Tank<Ty0, Ty1>)

47ImmBorrowFieldGeneric[2](Tank.current_epoch: u64)

48ReadRef

49CopyLoc[0](Arg0: &mut Tank<Ty0, Ty1>)

50ImmBorrowFieldGeneric[3](Tank.current_scale: u64)

51ReadRef

52Pack[3](EpochAndScale)

53Call table::borrow<EpochAndScale, u64>(&Table<EpochAndScale, u64>, EpochAndScale): &u64

54StLoc[10](loc6: &u64)

55CopyLoc[0](Arg0: &mut Tank<Ty0, Ty1>)

56CopyLoc[2](Arg2: &mut ContributorToken<Ty0, Ty1>)

57StLoc[5](loc1: &mut ContributorToken<Ty0, Ty1>)

58FreezeRef

59MoveLoc[5](loc1: &mut ContributorToken<Ty0, Ty1>)

60FreezeRef

61Call get_token_weight<Ty0, Ty1>(&Tank<Ty0, Ty1>, &ContributorToken<Ty0, Ty1>): u64

62CopyLoc[2](Arg2: &mut ContributorToken<Ty0, Ty1>)

63MutBorrowFieldGeneric[10](ContributorToken.deposit_amount: u64)

64WriteRef

65MoveLoc[11](loc7: &u64)

66ReadRef

67CopyLoc[2](Arg2: &mut ContributorToken<Ty0, Ty1>)

68MutBorrowFieldGeneric[11](ContributorToken.start_s: u64)

69WriteRef

70CopyLoc[0](Arg0: &mut Tank<Ty0, Ty1>)

71ImmBorrowFieldGeneric[4](Tank.current_p: u64)

72ReadRef

73CopyLoc[2](Arg2: &mut ContributorToken<Ty0, Ty1>)

74MutBorrowFieldGeneric[12](ContributorToken.start_p: u64)

75WriteRef

76MoveLoc[10](loc6: &u64)

77ReadRef

78CopyLoc[2](Arg2: &mut ContributorToken<Ty0, Ty1>)

79MutBorrowFieldGeneric[13](ContributorToken.start_g: u64)

80WriteRef

81CopyLoc[0](Arg0: &mut Tank<Ty0, Ty1>)

82ImmBorrowFieldGeneric[2](Tank.current_epoch: u64)

83ReadRef

84CopyLoc[2](Arg2: &mut ContributorToken<Ty0, Ty1>)

85MutBorrowFieldGeneric[8](ContributorToken.start_epoch: u64)

86WriteRef

87CopyLoc[0](Arg0: &mut Tank<Ty0, Ty1>)

88ImmBorrowFieldGeneric[3](Tank.current_scale: u64)

89ReadRef

90CopyLoc[2](Arg2: &mut ContributorToken<Ty0, Ty1>)

91MutBorrowFieldGeneric[9](ContributorToken.start_scale: u64)

92WriteRef

93LdU64(0)

94CopyLoc[9](loc5: u64)

95ImmBorrowLoc[8](loc4: Balance<BKT>)

96Call balance::value<BKT>(&Balance<BKT>): u64

97Call tank_events::emit_withdraw<Ty1>(u64, u64, u64)

98MoveLoc[3](Arg3: &TxContext)

99Call tx_context::epoch(&TxContext): u64

100MoveLoc[2](Arg2: &mut ContributorToken<Ty0, Ty1>)

101ImmBorrowFieldGeneric[14](ContributorToken.ctx_epoch: u64)

102ReadRef

103Sub

104LdU64(7)

105Gt

106BrFalse(117)

B1:

107MoveLoc[1](Arg1: &mut BktTreasury)

108Pop

109MoveLoc[0](Arg0: &mut Tank<Ty0, Ty1>)

110MutBorrowFieldGeneric[7](Tank.collateral_pool: Balance<Ty1>)

111MoveLoc[9](loc5: u64)

112Call balance::split<Ty1>(&mut Balance<Ty1>, u64): Balance<Ty1>

113MoveLoc[8](loc4: Balance<BKT>)

114StLoc[7](loc3: Balance<BKT>)

115StLoc[6](loc2: Balance<Ty1>)

116Branch(127)

B2:

117MoveLoc[1](Arg1: &mut BktTreasury)

118MoveLoc[8](loc4: Balance<BKT>)

119Call bkt::collect_bkt(&mut BktTreasury, Balance<BKT>)

120MoveLoc[0](Arg0: &mut Tank<Ty0, Ty1>)

121MutBorrowFieldGeneric[7](Tank.collateral_pool: Balance<Ty1>)

122MoveLoc[9](loc5: u64)

123Call balance::split<Ty1>(&mut Balance<Ty1>, u64): Balance<Ty1>

124Call balance::zero<BKT>(): Balance<BKT>

125StLoc[7](loc3: Balance<BKT>)

126StLoc[6](loc2: Balance<Ty1>)

B3:

127MoveLoc[6](loc2: Balance<Ty1>)

128MoveLoc[7](loc3: Balance<BKT>)

129Ret

}

claim_bkt<Ty0, Ty1>(Arg0: &mut Tank<Ty0, Ty1>, Arg1: &ContributorToken<Ty0, Ty1>): Balance<BKT> {

L2: loc0: &ContributorToken<Ty0, Ty1>

L3: loc1: u64

B0:

0CopyLoc[0](Arg0: &mut Tank<Ty0, Ty1>)

1MutBorrowFieldGeneric[1](Tank.epoch_scale_gain_map: Table<EpochAndScale, u64>)

2CopyLoc[1](Arg1: &ContributorToken<Ty0, Ty1>)

3ImmBorrowFieldGeneric[8](ContributorToken.start_epoch: u64)

4ReadRef

5CopyLoc[1](Arg1: &ContributorToken<Ty0, Ty1>)

6ImmBorrowFieldGeneric[9](ContributorToken.start_scale: u64)

7ReadRef

8Call add_table(&mut Table<EpochAndScale, u64>, u64, u64)

9CopyLoc[0](Arg0: &mut Tank<Ty0, Ty1>)

10MutBorrowFieldGeneric[1](Tank.epoch_scale_gain_map: Table<EpochAndScale, u64>)

11CopyLoc[1](Arg1: &ContributorToken<Ty0, Ty1>)

12ImmBorrowFieldGeneric[8](ContributorToken.start_epoch: u64)

13ReadRef

14CopyLoc[1](Arg1: &ContributorToken<Ty0, Ty1>)

15ImmBorrowFieldGeneric[9](ContributorToken.start_scale: u64)

16ReadRef

17LdU64(1)

18Add

19Call add_table(&mut Table<EpochAndScale, u64>, u64, u64)

20CopyLoc[0](Arg0: &mut Tank<Ty0, Ty1>)

21MoveLoc[1](Arg1: &ContributorToken<Ty0, Ty1>)

22StLoc[2](loc0: &ContributorToken<Ty0, Ty1>)

23FreezeRef

24MoveLoc[2](loc0: &ContributorToken<Ty0, Ty1>)

25Call get_bkt_reward_amount<Ty0, Ty1>(&Tank<Ty0, Ty1>, &ContributorToken<Ty0, Ty1>): u64

26StLoc[3](loc1: u64)

27MoveLoc[0](Arg0: &mut Tank<Ty0, Ty1>)

28MutBorrowFieldGeneric[0](Tank.bkt_pool: Balance<BKT>)

29MoveLoc[3](loc1: u64)

30Call balance::split<BKT>(&mut Balance<BKT>, u64): Balance<BKT>

31Ret

}

public airdrop_collateral<Ty0, Ty1>(Arg0: &mut Tank<Ty0, Ty1>, Arg1: Balance<Ty1>) {

B0:

0MoveLoc[0](Arg0: &mut Tank<Ty0, Ty1>)

1MutBorrowFieldGeneric[7](Tank.collateral_pool: Balance<Ty1>)

2MoveLoc[1](Arg1: Balance<Ty1>)

3Call balance::join<Ty1>(&mut Balance<Ty1>, Balance<Ty1>): u64

4Pop

5Ret

}

public airdrop_bkt<Ty0, Ty1>(Arg0: &mut Tank<Ty0, Ty1>, Arg1: Balance<BKT>) {

B0:

0MoveLoc[0](Arg0: &mut Tank<Ty0, Ty1>)

1MutBorrowFieldGeneric[0](Tank.bkt_pool: Balance<BKT>)

2MoveLoc[1](Arg1: Balance<BKT>)

3Call balance::join<BKT>(&mut Balance<BKT>, Balance<BKT>): u64

4Pop

5Ret

}

public get_reserve_balance<Ty0, Ty1>(Arg0: &Tank<Ty0, Ty1>): u64 {

B0:

0MoveLoc[0](Arg0: &Tank<Ty0, Ty1>)

1ImmBorrowFieldGeneric[5](Tank.reserve: Balance<Ty0>)

2Call balance::value<Ty0>(&Balance<Ty0>): u64

3Ret

}

public get_bkt_pool_balance<Ty0, Ty1>(Arg0: &Tank<Ty0, Ty1>): u64 {

B0:

0MoveLoc[0](Arg0: &Tank<Ty0, Ty1>)

1ImmBorrowFieldGeneric[0](Tank.bkt_pool: Balance<BKT>)

2Call balance::value<BKT>(&Balance<BKT>): u64

3Ret

}

public get_collateral_pool_balance<Ty0, Ty1>(Arg0: &Tank<Ty0, Ty1>): u64 {

B0:

0MoveLoc[0](Arg0: &Tank<Ty0, Ty1>)

1ImmBorrowFieldGeneric[7](Tank.collateral_pool: Balance<Ty1>)

2Call balance::value<Ty1>(&Balance<Ty1>): u64

3Ret

}

public get_bkt_reward_amount<Ty0, Ty1>(Arg0: &Tank<Ty0, Ty1>, Arg1: &ContributorToken<Ty0, Ty1>): u64 {

L2: loc0: u64

L3: loc1: &u64

L4: loc2: u64

B0:

0CopyLoc[1](Arg1: &ContributorToken<Ty0, Ty1>)

1ImmBorrowFieldGeneric[10](ContributorToken.deposit_amount: u64)

2ReadRef

3LdU64(0)

4Eq

5BrFalse(12)

B1:

6MoveLoc[1](Arg1: &ContributorToken<Ty0, Ty1>)

7Pop

8MoveLoc[0](Arg0: &Tank<Ty0, Ty1>)

9Pop

10LdU64(0)

11Ret

B2:

12CopyLoc[0](Arg0: &Tank<Ty0, Ty1>)

13ImmBorrowFieldGeneric[1](Tank.epoch_scale_gain_map: Table<EpochAndScale, u64>)

14CopyLoc[1](Arg1: &ContributorToken<Ty0, Ty1>)

15ImmBorrowFieldGeneric[8](ContributorToken.start_epoch: u64)

16ReadRef

17CopyLoc[1](Arg1: &ContributorToken<Ty0, Ty1>)

18ImmBorrowFieldGeneric[9](ContributorToken.start_scale: u64)

19ReadRef

20Pack[3](EpochAndScale)

21Call table::borrow<EpochAndScale, u64>(&Table<EpochAndScale, u64>, EpochAndScale): &u64

22StLoc[3](loc1: &u64)

23CopyLoc[0](Arg0: &Tank<Ty0, Ty1>)

24ImmBorrowFieldGeneric[1](Tank.epoch_scale_gain_map: Table<EpochAndScale, u64>)

25CopyLoc[1](Arg1: &ContributorToken<Ty0, Ty1>)

26ImmBorrowFieldGeneric[8](ContributorToken.start_epoch: u64)

27ReadRef

28CopyLoc[1](Arg1: &ContributorToken<Ty0, Ty1>)

29ImmBorrowFieldGeneric[9](ContributorToken.start_scale: u64)

30ReadRef

31LdU64(1)

32Add

33Pack[3](EpochAndScale)

34Call table::contains<EpochAndScale, u64>(&Table<EpochAndScale, u64>, EpochAndScale): bool

35BrFalse(53)

B3:

36MoveLoc[0](Arg0: &Tank<Ty0, Ty1>)

37ImmBorrowFieldGeneric[1](Tank.epoch_scale_gain_map: Table<EpochAndScale, u64>)

38CopyLoc[1](Arg1: &ContributorToken<Ty0, Ty1>)

39ImmBorrowFieldGeneric[8](ContributorToken.start_epoch: u64)

40ReadRef

41CopyLoc[1](Arg1: &ContributorToken<Ty0, Ty1>)

42ImmBorrowFieldGeneric[9](ContributorToken.start_scale: u64)

43ReadRef

44LdU64(1)

45Add

46Pack[3](EpochAndScale)

47Call table::borrow<EpochAndScale, u64>(&Table<EpochAndScale, u64>, EpochAndScale): &u64

48ReadRef

49Call constants::scale_factor(): u64

50Div

51StLoc[2](loc0: u64)

52Branch(57)

B4:

53MoveLoc[0](Arg0: &Tank<Ty0, Ty1>)

54Pop

55LdU64(0)

56StLoc[2](loc0: u64)

B5:

57MoveLoc[2](loc0: u64)

58StLoc[4](loc2: u64)

59CopyLoc[1](Arg1: &ContributorToken<Ty0, Ty1>)

60ImmBorrowFieldGeneric[10](ContributorToken.deposit_amount: u64)

61ReadRef

62MoveLoc[3](loc1: &u64)

63ReadRef

64CopyLoc[1](Arg1: &ContributorToken<Ty0, Ty1>)

65ImmBorrowFieldGeneric[13](ContributorToken.start_g: u64)

66ReadRef

67Sub

68MoveLoc[4](loc2: u64)

69Add

70MoveLoc[1](Arg1: &ContributorToken<Ty0, Ty1>)

71ImmBorrowFieldGeneric[12](ContributorToken.start_p: u64)

72ReadRef

73Call math::mul_factor(u64, u64, u64): u64

74Ret

}

public get_collateral_reward_amount<Ty0, Ty1>(Arg0: &Tank<Ty0, Ty1>, Arg1: &ContributorToken<Ty0, Ty1>): u64 {

L2: loc0: u64

L3: loc1: EpochAndScale

L4: loc2: u64

L5: loc3: &u64

L6: loc4: u64

B0:

0CopyLoc[1](Arg1: &ContributorToken<Ty0, Ty1>)

1ImmBorrowFieldGeneric[8](ContributorToken.start_epoch: u64)

2ReadRef

3CopyLoc[1](Arg1: &ContributorToken<Ty0, Ty1>)

4ImmBorrowFieldGeneric[9](ContributorToken.start_scale: u64)

5ReadRef

6Pack[3](EpochAndScale)

7StLoc[3](loc1: EpochAndScale)

8CopyLoc[0](Arg0: &Tank<Ty0, Ty1>)

9ImmBorrowFieldGeneric[6](Tank.epoch_scale_sum_map: Table<EpochAndScale, u64>)

10CopyLoc[3](loc1: EpochAndScale)

11Call table::contains<EpochAndScale, u64>(&Table<EpochAndScale, u64>, EpochAndScale): bool

12BrFalse(14)

B1:

13Branch(20)

B2:

14MoveLoc[1](Arg1: &ContributorToken<Ty0, Ty1>)

15Pop

16MoveLoc[0](Arg0: &Tank<Ty0, Ty1>)

17Pop

18LdConst[2](u64: 3)

19Abort

B3:

20CopyLoc[0](Arg0: &Tank<Ty0, Ty1>)

21ImmBorrowFieldGeneric[6](Tank.epoch_scale_sum_map: Table<EpochAndScale, u64>)

22CopyLoc[1](Arg1: &ContributorToken<Ty0, Ty1>)

23ImmBorrowFieldGeneric[8](ContributorToken.start_epoch: u64)

24ReadRef

25CopyLoc[1](Arg1: &ContributorToken<Ty0, Ty1>)

26ImmBorrowFieldGeneric[9](ContributorToken.start_scale: u64)

27ReadRef

28LdU64(1)

29Add

30Pack[3](EpochAndScale)

31Call table::contains<EpochAndScale, u64>(&Table<EpochAndScale, u64>, EpochAndScale): bool

32Not

33BrFalse(37)

B4:

34LdU64(0)

35StLoc[2](loc0: u64)

36Branch(51)

B5:

37CopyLoc[0](Arg0: &Tank<Ty0, Ty1>)

38ImmBorrowFieldGeneric[6](Tank.epoch_scale_sum_map: Table<EpochAndScale, u64>)

39CopyLoc[1](Arg1: &ContributorToken<Ty0, Ty1>)

40ImmBorrowFieldGeneric[8](ContributorToken.start_epoch: u64)

41ReadRef

42CopyLoc[1](Arg1: &ContributorToken<Ty0, Ty1>)

43ImmBorrowFieldGeneric[9](ContributorToken.start_scale: u64)

44ReadRef

45LdU64(1)

46Add

47Pack[3](EpochAndScale)

48Call table::borrow<EpochAndScale, u64>(&Table<EpochAndScale, u64>, EpochAndScale): &u64

49ReadRef

50StLoc[2](loc0: u64)

B6:

51MoveLoc[2](loc0: u64)

52StLoc[4](loc2: u64)

53MoveLoc[0](Arg0: &Tank<Ty0, Ty1>)

54ImmBorrowFieldGeneric[6](Tank.epoch_scale_sum_map: Table<EpochAndScale, u64>)

55MoveLoc[3](loc1: EpochAndScale)

56Call table::borrow<EpochAndScale, u64>(&Table<EpochAndScale, u64>, EpochAndScale): &u64

57StLoc[5](loc3: &u64)

58MoveLoc[4](loc2: u64)

59Call constants::scale_factor(): u64

60Div

61StLoc[6](loc4: u64)

62CopyLoc[1](Arg1: &ContributorToken<Ty0, Ty1>)

63ImmBorrowFieldGeneric[10](ContributorToken.deposit_amount: u64)

64ReadRef

65MoveLoc[5](loc3: &u64)

66ReadRef

67CopyLoc[1](Arg1: &ContributorToken<Ty0, Ty1>)

68ImmBorrowFieldGeneric[11](ContributorToken.start_s: u64)

69ReadRef

70Sub

71MoveLoc[6](loc4: u64)

72Add

73MoveLoc[1](Arg1: &ContributorToken<Ty0, Ty1>)

74ImmBorrowFieldGeneric[12](ContributorToken.start_p: u64)

75ReadRef

76Call math::mul_factor(u64, u64, u64): u64

77Ret

}

public get_token_weight<Ty0, Ty1>(Arg0: &Tank<Ty0, Ty1>, Arg1: &ContributorToken<Ty0, Ty1>): u64 {

L2: loc0: u64

L3: loc1: u64

L4: loc2: u64

B0:

0CopyLoc[1](Arg1: &ContributorToken<Ty0, Ty1>)

1ImmBorrowFieldGeneric[8](ContributorToken.start_epoch: u64)

2ReadRef

3CopyLoc[0](Arg0: &Tank<Ty0, Ty1>)

4ImmBorrowFieldGeneric[2](Tank.current_epoch: u64)

5ReadRef

6Lt

7BrFalse(14)

B1:

8MoveLoc[1](Arg1: &ContributorToken<Ty0, Ty1>)

9Pop

10MoveLoc[0](Arg0: &Tank<Ty0, Ty1>)

11Pop

12LdU64(0)

13Ret

B2:

14CopyLoc[0](Arg0: &Tank<Ty0, Ty1>)

15ImmBorrowFieldGeneric[3](Tank.current_scale: u64)

16ReadRef

17CopyLoc[1](Arg1: &ContributorToken<Ty0, Ty1>)

18ImmBorrowFieldGeneric[9](ContributorToken.start_scale: u64)

19ReadRef

20Sub

21StLoc[4](loc2: u64)

22CopyLoc[4](loc2: u64)

23LdU64(0)

24Eq

25BrFalse(38)

B3:

26CopyLoc[1](Arg1: &ContributorToken<Ty0, Ty1>)

27ImmBorrowFieldGeneric[10](ContributorToken.deposit_amount: u64)

28ReadRef

29MoveLoc[0](Arg0: &Tank<Ty0, Ty1>)

30ImmBorrowFieldGeneric[4](Tank.current_p: u64)

31ReadRef

32MoveLoc[1](Arg1: &ContributorToken<Ty0, Ty1>)

33ImmBorrowFieldGeneric[12](ContributorToken.start_p: u64)

34ReadRef

35Call math::mul_factor(u64, u64, u64): u64

36StLoc[3](loc1: u64)

37Branch(64)

B4:

38MoveLoc[4](loc2: u64)

39LdU64(1)

40Eq

41BrFalse(56)

B5:

42CopyLoc[1](Arg1: &ContributorToken<Ty0, Ty1>)

43ImmBorrowFieldGeneric[10](ContributorToken.deposit_amount: u64)

44ReadRef

45MoveLoc[0](Arg0: &Tank<Ty0, Ty1>)

46ImmBorrowFieldGeneric[4](Tank.current_p: u64)

47ReadRef

48MoveLoc[1](Arg1: &ContributorToken<Ty0, Ty1>)

49ImmBorrowFieldGeneric[12](ContributorToken.start_p: u64)

50ReadRef

51Call math::mul_factor(u64, u64, u64): u64

52Call constants::scale_factor(): u64

53Div

54StLoc[2](loc0: u64)

55Branch(62)

B6:

56MoveLoc[1](Arg1: &ContributorToken<Ty0, Ty1>)

57Pop

58MoveLoc[0](Arg0: &Tank<Ty0, Ty1>)

59Pop

60LdU64(0)

61StLoc[2](loc0: u64)

B7:

62MoveLoc[2](loc0: u64)

63StLoc[3](loc1: u64)

B8:

64MoveLoc[3](loc1: u64)

65Ret

}

public(friend) handle_flash_borrow<Ty0, Ty1>(Arg0: &mut Tank<Ty0, Ty1>, Arg1: u64): Balance<Ty0> * FlashReceipt<Ty0, Ty1> {

L2: loc0: u64

B0:

0CopyLoc[0](Arg0: &mut Tank<Ty0, Ty1>)

1ImmBorrowFieldGeneric[15](Tank.total_flash_loan_amount: u64)

2ReadRef

3CopyLoc[1](Arg1: u64)

4Add

5CopyLoc[0](Arg0: &mut Tank<Ty0, Ty1>)

6MutBorrowFieldGeneric[15](Tank.total_flash_loan_amount: u64)

7WriteRef

8CopyLoc[1](Arg1: u64)

9Call constants::flash_loan_fee(): u64

10Call constants::fee_precision(): u64

11Call math::mul_factor(u64, u64, u64): u64

12StLoc[2](loc0: u64)

13CopyLoc[2](loc0: u64)

14LdU64(0)

15Eq

16BrFalse(19)

B1:

17LdU64(1)

18StLoc[2](loc0: u64)

B2:

19MoveLoc[0](Arg0: &mut Tank<Ty0, Ty1>)

20MutBorrowFieldGeneric[5](Tank.reserve: Balance<Ty0>)

21CopyLoc[1](Arg1: u64)

22Call balance::split<Ty0>(&mut Balance<Ty0>, u64): Balance<Ty0>

23MoveLoc[1](Arg1: u64)

24MoveLoc[2](loc0: u64)

25PackGeneric[2](FlashReceipt<Ty0, Ty1>)

26Ret

}

public(friend) handle_flash_repay<Ty0, Ty1>(Arg0: &mut Tank<Ty0, Ty1>, Arg1: Balance<Ty0>, Arg2: FlashReceipt<Ty0, Ty1>): Balance<Ty0> {

L3: loc0: u64

L4: loc1: u64

L5: loc2: Balance<Ty0>

B0:

0MoveLoc[2](Arg2: FlashReceipt<Ty0, Ty1>)

1UnpackGeneric[2](FlashReceipt<Ty0, Ty1>)

2StLoc[4](loc1: u64)

3StLoc[3](loc0: u64)

4CopyLoc[0](Arg0: &mut Tank<Ty0, Ty1>)

5ImmBorrowFieldGeneric[15](Tank.total_flash_loan_amount: u64)

6ReadRef

7CopyLoc[3](loc0: u64)

8Sub

9CopyLoc[0](Arg0: &mut Tank<Ty0, Ty1>)

10MutBorrowFieldGeneric[15](Tank.total_flash_loan_amount: u64)

11WriteRef

12ImmBorrowLoc[1](Arg1: Balance<Ty0>)

13Call balance::value<Ty0>(&Balance<Ty0>): u64

14CopyLoc[3](loc0: u64)

15MoveLoc[4](loc1: u64)

16Add

17Ge

18BrFalse(20)

B1:

19Branch(24)

B2:

20MoveLoc[0](Arg0: &mut Tank<Ty0, Ty1>)

21Pop

22LdConst[1](u64: 1)

23Abort

B3:

24MutBorrowLoc[1](Arg1: Balance<Ty0>)

25MoveLoc[3](loc0: u64)

26Call balance::split<Ty0>(&mut Balance<Ty0>, u64): Balance<Ty0>

27StLoc[5](loc2: Balance<Ty0>)

28MoveLoc[0](Arg0: &mut Tank<Ty0, Ty1>)

29MutBorrowFieldGeneric[5](Tank.reserve: Balance<Ty0>)

30MoveLoc[5](loc2: Balance<Ty0>)

31Call balance::join<Ty0>(&mut Balance<Ty0>, Balance<Ty0>): u64

32Pop

33MoveLoc[1](Arg1: Balance<Ty0>)

34Ret

}

public is_not_locked<Ty0, Ty1>(Arg0: &Tank<Ty0, Ty1>): bool {

B0:

0MoveLoc[0](Arg0: &Tank<Ty0, Ty1>)

1ImmBorrowFieldGeneric[15](Tank.total_flash_loan_amount: u64)

2ReadRef

3LdU64(0)

4Eq

5Ret

}

public get_total_flash_loan_amount<Ty0, Ty1>(Arg0: &Tank<Ty0, Ty1>): u64 {

B0:

0MoveLoc[0](Arg0: &Tank<Ty0, Ty1>)

1ImmBorrowFieldGeneric[15](Tank.total_flash_loan_amount: u64)

2ReadRef

3Ret

}

public get_receipt_info<Ty0, Ty1>(Arg0: &FlashReceipt<Ty0, Ty1>): u64 * u64 {

B0:

0CopyLoc[0](Arg0: &FlashReceipt<Ty0, Ty1>)

1ImmBorrowFieldGeneric[16](FlashReceipt.amount: u64)

2ReadRef

3MoveLoc[0](Arg0: &FlashReceipt<Ty0, Ty1>)

4ImmBorrowFieldGeneric[17](FlashReceipt.fee: u64)

5ReadRef

6Ret

}

public get_current_p<Ty0, Ty1>(Arg0: &Tank<Ty0, Ty1>): u64 {

B0:

0MoveLoc[0](Arg0: &Tank<Ty0, Ty1>)

1ImmBorrowFieldGeneric[4](Tank.current_p: u64)

2ReadRef

3Ret

}

public get_current_scale<Ty0, Ty1>(Arg0: &Tank<Ty0, Ty1>): u64 {

B0:

0MoveLoc[0](Arg0: &Tank<Ty0, Ty1>)

1ImmBorrowFieldGeneric[3](Tank.current_scale: u64)

2ReadRef

3Ret

}

public get_current_epoch<Ty0, Ty1>(Arg0: &Tank<Ty0, Ty1>): u64 {

B0:

0MoveLoc[0](Arg0: &Tank<Ty0, Ty1>)

1ImmBorrowFieldGeneric[2](Tank.current_epoch: u64)

2ReadRef

3Ret

}

public get_token_ctx_epoch<Ty0, Ty1>(Arg0: &ContributorToken<Ty0, Ty1>): u64 {

B0:

0MoveLoc[0](Arg0: &ContributorToken<Ty0, Ty1>)

1ImmBorrowFieldGeneric[14](ContributorToken.ctx_epoch: u64)

2ReadRef

3Ret

}

public get_epoch_scale_sum_map<Ty0, Ty1>(Arg0: &Tank<Ty0, Ty1>, Arg1: u64, Arg2: u64): u64 {

B0:

0MoveLoc[0](Arg0: &Tank<Ty0, Ty1>)

1ImmBorrowFieldGeneric[6](Tank.epoch_scale_sum_map: Table<EpochAndScale, u64>)

2MoveLoc[1](Arg1: u64)

3MoveLoc[2](Arg2: u64)

4Pack[3](EpochAndScale)

5Call table::borrow<EpochAndScale, u64>(&Table<EpochAndScale, u64>, EpochAndScale): &u64

6ReadRef

7Ret

}

public get_epoch_scale_gain_map<Ty0, Ty1>(Arg0: &Tank<Ty0, Ty1>, Arg1: u64, Arg2: u64): u64 {

B0:

0MoveLoc[0](Arg0: &Tank<Ty0, Ty1>)

1ImmBorrowFieldGeneric[1](Tank.epoch_scale_gain_map: Table<EpochAndScale, u64>)

2MoveLoc[1](Arg1: u64)

3MoveLoc[2](Arg2: u64)

4Pack[3](EpochAndScale)

5Call table::borrow<EpochAndScale, u64>(&Table<EpochAndScale, u64>, EpochAndScale): &u64

6ReadRef

7Ret

}

public get_contributor_token_value<Ty0, Ty1>(Arg0: &ContributorToken<Ty0, Ty1>): u64 * u64 * u64 * u64 * u64 * u64 {

B0:

0CopyLoc[0](Arg0: &ContributorToken<Ty0, Ty1>)

1ImmBorrowFieldGeneric[10](ContributorToken.deposit_amount: u64)

2ReadRef

3CopyLoc[0](Arg0: &ContributorToken<Ty0, Ty1>)

4ImmBorrowFieldGeneric[12](ContributorToken.start_p: u64)

5ReadRef

6CopyLoc[0](Arg0: &ContributorToken<Ty0, Ty1>)

7ImmBorrowFieldGeneric[11](ContributorToken.start_s: u64)

8ReadRef

9CopyLoc[0](Arg0: &ContributorToken<Ty0, Ty1>)

10ImmBorrowFieldGeneric[13](ContributorToken.start_g: u64)

11ReadRef

12CopyLoc[0](Arg0: &ContributorToken<Ty0, Ty1>)

13ImmBorrowFieldGeneric[8](ContributorToken.start_epoch: u64)

14ReadRef

15MoveLoc[0](Arg0: &ContributorToken<Ty0, Ty1>)

16ImmBorrowFieldGeneric[9](ContributorToken.start_scale: u64)

17ReadRef

18Ret

}

Constants [

0 => u64: 0

1 => u64: 1

2 => u64: 3

3 => u64: 4

4 => u64: 6

5 => u64: 7

6 => u64: 8

]

}