cm

Module0xfd90…2443

Move path: 0x048a…3ca6::cm
Functions: 103 public, 0 entry
Structs: 0
Friend modules: None

Bytecode876 lines

The on-chain disassembly. Offsets are bytecode positions within each function.

// Move bytecode v7

module 48af3fa32897e1215518a1135f429f385b8293f1d942aa02685b3fec20a3ca6.cm {

use 048af3fa32897e1215518a1135f429f385b8293f1d942aa02685b3fec20a3ca6::admin;

use 048af3fa32897e1215518a1135f429f385b8293f1d942aa02685b3fec20a3ca6::common;

use 048af3fa32897e1215518a1135f429f385b8293f1d942aa02685b3fec20a3ca6::f_max;

use 048af3fa32897e1215518a1135f429f385b8293f1d942aa02685b3fec20a3ca6::i128;

use 1eabed72c53feb3805120a081dc15963c204dc8d091542592abaf7a35689b2fb::config;

use 1eabed72c53feb3805120a081dc15963c204dc8d091542592abaf7a35689b2fb::pool;

use 70285592c97965e811e0c6f98dccc3a9c2b4ad854b3594faab9597ada267b860::pool as 0pool;

use 70285592c97965e811e0c6f98dccc3a9c2b4ad854b3594faab9597ada267b860::trade;

use 70285592c97965e811e0c6f98dccc3a9c2b4ad854b3594faab9597ada267b860::version;

use 0000000000000000000000000000000000000000000000000000000000000002::balance;

use 0000000000000000000000000000000000000000000000000000000000000002::clock;

use 0000000000000000000000000000000000000000000000000000000000000002::sui;

use 0000000000000000000000000000000000000000000000000000000000000002::tx_context;

init(Arg0: &mut TxContext) {

B0:

0Ret

}

calc_cm0<Ty0>(Arg0: &Pool<Ty0, SUI>, Arg1: &Pool<Ty0, SUI>, Arg2: u64): I128 {

L3: loc0: CalculatedSwapResult

L4: loc1: SwapState

L5: loc2: u64

B0:

0MoveLoc[0](Arg0: &Pool<Ty0, SUI>)

1LdTrue

2LdTrue

3CopyLoc[2](Arg2: u64)

4Call pool::calculate_swap_result<Ty0, SUI>(&Pool<Ty0, SUI>, bool, bool, u64): CalculatedSwapResult

5StLoc[3](loc0: CalculatedSwapResult)

6ImmBorrowLoc[3](loc0: CalculatedSwapResult)

7Call pool::calculated_swap_result_amount_out(&CalculatedSwapResult): u64

8StLoc[5](loc2: u64)

9MoveLoc[1](Arg1: &Pool<Ty0, SUI>)

10LdFalse

11LdTrue

12LdU128(79226673515401279992447579054)

13MoveLoc[5](loc2: u64)

14Call trade::compute_swap_result<Ty0, SUI>(&Pool<Ty0, SUI>, bool, bool, u128, u64): SwapState

15StLoc[4](loc1: SwapState)

16ImmBorrowLoc[4](loc1: SwapState)

17Call trade::get_state_amount_calculated(&SwapState): u64

18CastU128

19Call i128::from(u128): I128

20MoveLoc[2](Arg2: u64)

21CastU128

22Call i128::from(u128): I128

23Call i128::sub(I128, I128): I128

24Ret

}

calc_cm0r<Ty0>(Arg0: &Pool<Ty0, SUI>, Arg1: &Pool<Ty0, SUI>, Arg2: u64): I128 {

L3: loc0: CalculatedSwapResult

L4: loc1: SwapState

L5: loc2: u64

B0:

0MoveLoc[1](Arg1: &Pool<Ty0, SUI>)

1LdTrue

2LdTrue

3LdU128(4295048017)

4CopyLoc[2](Arg2: u64)

5Call trade::compute_swap_result<Ty0, SUI>(&Pool<Ty0, SUI>, bool, bool, u128, u64): SwapState

6StLoc[4](loc1: SwapState)

7ImmBorrowLoc[4](loc1: SwapState)

8Call trade::get_state_amount_calculated(&SwapState): u64

9StLoc[5](loc2: u64)

10MoveLoc[0](Arg0: &Pool<Ty0, SUI>)

11LdFalse

12LdTrue

13MoveLoc[5](loc2: u64)

14Call pool::calculate_swap_result<Ty0, SUI>(&Pool<Ty0, SUI>, bool, bool, u64): CalculatedSwapResult

15StLoc[3](loc0: CalculatedSwapResult)

16ImmBorrowLoc[3](loc0: CalculatedSwapResult)

17Call pool::calculated_swap_result_amount_out(&CalculatedSwapResult): u64

18CastU128

19Call i128::from(u128): I128

20MoveLoc[2](Arg2: u64)

21CastU128

22Call i128::from(u128): I128

23Call i128::sub(I128, I128): I128

24Ret

}

public cm0p<Ty0>(Arg0: &AdminCap, Arg1: &GlobalConfig, Arg2: &mut Pool<Ty0, SUI>, Arg3: &Version, Arg4: &mut Pool<Ty0, SUI>, Arg5: &Clock, Arg6: u64, Arg7: u64, Arg8: u64, Arg9: &mut TxContext) {

B0:

0MoveLoc[0](Arg0: &AdminCap)

1MoveLoc[1](Arg1: &GlobalConfig)

2MoveLoc[2](Arg2: &mut Pool<Ty0, SUI>)

3MoveLoc[3](Arg3: &Version)

4MoveLoc[4](Arg4: &mut Pool<Ty0, SUI>)

5MoveLoc[5](Arg5: &Clock)

6MoveLoc[6](Arg6: u64)

7MoveLoc[7](Arg7: u64)

8LdU64(1000000000)

9MoveLoc[8](Arg8: u64)

10MoveLoc[9](Arg9: &mut TxContext)

11Call cm0p_w_s<Ty0>(&AdminCap, &GlobalConfig, &mut Pool<Ty0, SUI>, &Version, &mut Pool<Ty0, SUI>, &Clock, u64, u64, u64, u64, &mut TxContext)

12Ret

}

public cm0p_w_s<Ty0>(Arg0: &AdminCap, Arg1: &GlobalConfig, Arg2: &mut Pool<Ty0, SUI>, Arg3: &Version, Arg4: &mut Pool<Ty0, SUI>, Arg5: &Clock, Arg6: u64, Arg7: u64, Arg8: u64, Arg9: u64, Arg10: &mut TxContext) {

L11: loc0: bool

L12: loc1: bool

L13: loc2: u64

L14: loc3: u64

L15: loc4: FMaxState

L16: loc5: FMaxState

L17: loc6: I128

L18: loc7: I128

L19: loc8: I128

L20: loc9: I128

L21: loc10: u64

L22: loc11: u64

L23: loc12: u64

L24: loc13: u64

B0:

0CopyLoc[6](Arg6: u64)

1CopyLoc[7](Arg7: u64)

2Le

3BrFalse(5)

B1:

4Branch(19)

B2:

5MoveLoc[3](Arg3: &Version)

6Pop

7MoveLoc[10](Arg10: &mut TxContext)

8Pop

9MoveLoc[5](Arg5: &Clock)

10Pop

11MoveLoc[1](Arg1: &GlobalConfig)

12Pop

13MoveLoc[4](Arg4: &mut Pool<Ty0, SUI>)

14Pop

15MoveLoc[2](Arg2: &mut Pool<Ty0, SUI>)

16Pop

17LdConst[4](u64: 40)

18Abort

B3:

19CopyLoc[9](Arg9: u64)

20LdU64(0)

21Gt

22BrFalse(24)

B4:

23Branch(38)

B5:

24MoveLoc[3](Arg3: &Version)

25Pop

26MoveLoc[10](Arg10: &mut TxContext)

27Pop

28MoveLoc[5](Arg5: &Clock)

29Pop

30MoveLoc[1](Arg1: &GlobalConfig)

31Pop

32MoveLoc[4](Arg4: &mut Pool<Ty0, SUI>)

33Pop

34MoveLoc[2](Arg2: &mut Pool<Ty0, SUI>)

35Pop

36LdConst[5](u64: 41)

37Abort

B6:

38CopyLoc[6](Arg6: u64)

39CopyLoc[7](Arg7: u64)

40CopyLoc[8](Arg8: u64)

41CopyLoc[9](Arg9: u64)

42Call f_max::new_f_max(u64, u64, u64, u64): FMaxState

43StLoc[15](loc4: FMaxState)

44CopyLoc[2](Arg2: &mut Pool<Ty0, SUI>)

45FreezeRef

46CopyLoc[4](Arg4: &mut Pool<Ty0, SUI>)

47FreezeRef

48CopyLoc[6](Arg6: u64)

49Call calc_cm0<Ty0>(&Pool<Ty0, SUI>, &Pool<Ty0, SUI>, u64): I128

50StLoc[17](loc6: I128)

51CopyLoc[17](loc6: I128)

52Call i128::zero(): I128

53Call i128::gt(I128, I128): bool

54BrFalse(106)

B7:

55MutBorrowLoc[15](loc4: FMaxState)

56MoveLoc[6](Arg6: u64)

57MoveLoc[17](loc6: I128)

58Call f_max::f_max_init(&mut FMaxState, u64, I128)

59LdU64(0)

60StLoc[21](loc10: u64)

B8:

61CopyLoc[21](loc10: u64)

62LdConst[0](u64: 10)

63Lt

64BrFalse(70)

B9:

65ImmBorrowLoc[15](loc4: FMaxState)

66Call f_max::f_max_has_converged(&FMaxState): bool

67Not

68StLoc[11](loc0: bool)

69Branch(73)

B10:

70LdFalse

71StLoc[11](loc0: bool)

72Branch(73)

B11:

73MoveLoc[11](loc0: bool)

74BrFalse(93)

B12:

75MutBorrowLoc[15](loc4: FMaxState)

76Call f_max::f_max_next_step_prep_u(&mut FMaxState): u64

77StLoc[23](loc12: u64)

78CopyLoc[2](Arg2: &mut Pool<Ty0, SUI>)

79FreezeRef

80CopyLoc[4](Arg4: &mut Pool<Ty0, SUI>)

81FreezeRef

82MoveLoc[23](loc12: u64)

83Call calc_cm0<Ty0>(&Pool<Ty0, SUI>, &Pool<Ty0, SUI>, u64): I128

84StLoc[19](loc8: I128)

85MutBorrowLoc[15](loc4: FMaxState)

86MoveLoc[19](loc8: I128)

87Call f_max::f_max_next_step_complete(&mut FMaxState, I128)

88MoveLoc[21](loc10: u64)

89LdU64(1)

90Add

91StLoc[21](loc10: u64)

92Branch(61)

B13:

93ImmBorrowLoc[15](loc4: FMaxState)

94Call f_max::f_max_result(&FMaxState): u64 * I128

95Pop

96StLoc[13](loc2: u64)

97MoveLoc[1](Arg1: &GlobalConfig)

98MoveLoc[2](Arg2: &mut Pool<Ty0, SUI>)

99MoveLoc[3](Arg3: &Version)

100MoveLoc[4](Arg4: &mut Pool<Ty0, SUI>)

101MoveLoc[5](Arg5: &Clock)

102MoveLoc[13](loc2: u64)

103MoveLoc[10](Arg10: &mut TxContext)

104Call cm0<Ty0>(&GlobalConfig, &mut Pool<Ty0, SUI>, &Version, &mut Pool<Ty0, SUI>, &Clock, u64, &mut TxContext)

105Ret

B14:

106CopyLoc[6](Arg6: u64)

107MoveLoc[7](Arg7: u64)

108MoveLoc[8](Arg8: u64)

109MoveLoc[9](Arg9: u64)

110Call f_max::new_f_max(u64, u64, u64, u64): FMaxState

111StLoc[16](loc5: FMaxState)

112CopyLoc[2](Arg2: &mut Pool<Ty0, SUI>)

113FreezeRef

114CopyLoc[4](Arg4: &mut Pool<Ty0, SUI>)

115FreezeRef

116CopyLoc[6](Arg6: u64)

117Call calc_cm0r<Ty0>(&Pool<Ty0, SUI>, &Pool<Ty0, SUI>, u64): I128

118StLoc[18](loc7: I128)

119CopyLoc[18](loc7: I128)

120Call i128::zero(): I128

121Call i128::gt(I128, I128): bool

122BrFalse(174)

B15:

123MutBorrowLoc[16](loc5: FMaxState)

124MoveLoc[6](Arg6: u64)

125MoveLoc[18](loc7: I128)

126Call f_max::f_max_init(&mut FMaxState, u64, I128)

127LdU64(0)

128StLoc[22](loc11: u64)

B16:

129CopyLoc[22](loc11: u64)

130LdConst[0](u64: 10)

131Lt

132BrFalse(138)

B17:

133ImmBorrowLoc[16](loc5: FMaxState)

134Call f_max::f_max_has_converged(&FMaxState): bool

135Not

136StLoc[12](loc1: bool)

137Branch(140)

B18:

138LdFalse

139StLoc[12](loc1: bool)

B19:

140MoveLoc[12](loc1: bool)

141BrFalse(161)

B20:

142Branch(143)

B21:

143MutBorrowLoc[16](loc5: FMaxState)

144Call f_max::f_max_next_step_prep_u(&mut FMaxState): u64

145StLoc[24](loc13: u64)

146CopyLoc[2](Arg2: &mut Pool<Ty0, SUI>)

147FreezeRef

148CopyLoc[4](Arg4: &mut Pool<Ty0, SUI>)

149FreezeRef

150MoveLoc[24](loc13: u64)

151Call calc_cm0r<Ty0>(&Pool<Ty0, SUI>, &Pool<Ty0, SUI>, u64): I128

152StLoc[20](loc9: I128)

153MutBorrowLoc[16](loc5: FMaxState)

154MoveLoc[20](loc9: I128)

155Call f_max::f_max_next_step_complete(&mut FMaxState, I128)

156MoveLoc[22](loc11: u64)

157LdU64(1)

158Add

159StLoc[22](loc11: u64)

160Branch(129)

B22:

161ImmBorrowLoc[16](loc5: FMaxState)

162Call f_max::f_max_result(&FMaxState): u64 * I128

163Pop

164StLoc[14](loc3: u64)

165MoveLoc[1](Arg1: &GlobalConfig)

166MoveLoc[2](Arg2: &mut Pool<Ty0, SUI>)

167MoveLoc[3](Arg3: &Version)

168MoveLoc[4](Arg4: &mut Pool<Ty0, SUI>)

169MoveLoc[5](Arg5: &Clock)

170MoveLoc[14](loc3: u64)

171MoveLoc[10](Arg10: &mut TxContext)

172Call cm0r<Ty0>(&GlobalConfig, &mut Pool<Ty0, SUI>, &Version, &mut Pool<Ty0, SUI>, &Clock, u64, &mut TxContext)

173Ret

B23:

174MoveLoc[3](Arg3: &Version)

175Pop

176MoveLoc[10](Arg10: &mut TxContext)

177Pop

178MoveLoc[5](Arg5: &Clock)

179Pop

180MoveLoc[1](Arg1: &GlobalConfig)

181Pop

182MoveLoc[4](Arg4: &mut Pool<Ty0, SUI>)

183Pop

184MoveLoc[2](Arg2: &mut Pool<Ty0, SUI>)

185Pop

186LdConst[3](u64: 25)

187Abort

}

public cm0p_ls<Ty0>(Arg0: &AdminCap, Arg1: &GlobalConfig, Arg2: &mut Pool<Ty0, SUI>, Arg3: &Version, Arg4: &mut Pool<Ty0, SUI>, Arg5: &Clock, Arg6: u64, Arg7: &mut TxContext) {

L8: loc0: u64

L9: loc1: u64

L10: loc2: I128

L11: loc3: I128

L12: loc4: u64

L13: loc5: u64

L14: loc6: I128

L15: loc7: I128

L16: loc8: u64

L17: loc9: u64

L18: loc10: u64

L19: loc11: u64

L20: loc12: vector<u64>

L21: loc13: u64

B0:

0CopyLoc[6](Arg6: u64)

1LdU64(0)

2Gt

3BrFalse(5)

B1:

4Branch(19)

B2:

5MoveLoc[3](Arg3: &Version)

6Pop

7MoveLoc[7](Arg7: &mut TxContext)

8Pop

9MoveLoc[5](Arg5: &Clock)

10Pop

11MoveLoc[1](Arg1: &GlobalConfig)

12Pop

13MoveLoc[4](Arg4: &mut Pool<Ty0, SUI>)

14Pop

15MoveLoc[2](Arg2: &mut Pool<Ty0, SUI>)

16Pop

17LdConst[6](u64: 42)

18Abort

B3:

19LdConst[10](vector<u64>: 1001..)

20StLoc[20](loc12: vector<u64>)

21ImmBorrowLoc[20](loc12: vector<u64>)

22VecLen(17)

23StLoc[21](loc13: u64)

24LdU64(0)

25StLoc[12](loc4: u64)

26Call i128::zero(): I128

27StLoc[14](loc6: I128)

28LdU64(0)

29StLoc[16](loc8: u64)

B4:

30CopyLoc[16](loc8: u64)

31CopyLoc[21](loc13: u64)

32Lt

33BrFalse(64)

B5:

34ImmBorrowLoc[20](loc12: vector<u64>)

35CopyLoc[16](loc8: u64)

36VecImmBorrow(17)

37ReadRef

38StLoc[18](loc10: u64)

39CopyLoc[6](Arg6: u64)

40MoveLoc[18](loc10: u64)

41Mul

42StLoc[8](loc0: u64)

43CopyLoc[2](Arg2: &mut Pool<Ty0, SUI>)

44FreezeRef

45CopyLoc[4](Arg4: &mut Pool<Ty0, SUI>)

46FreezeRef

47CopyLoc[8](loc0: u64)

48Call calc_cm0<Ty0>(&Pool<Ty0, SUI>, &Pool<Ty0, SUI>, u64): I128

49StLoc[10](loc2: I128)

50CopyLoc[10](loc2: I128)

51CopyLoc[14](loc6: I128)

52Call i128::gt(I128, I128): bool

53BrFalse(64)

B6:

54Branch(55)

B7:

55MoveLoc[8](loc0: u64)

56StLoc[12](loc4: u64)

57MoveLoc[10](loc2: I128)

58StLoc[14](loc6: I128)

59MoveLoc[16](loc8: u64)

60LdU64(1)

61Add

62StLoc[16](loc8: u64)

63Branch(30)

B8:

64MoveLoc[14](loc6: I128)

65Call i128::zero(): I128

66Call i128::gt(I128, I128): bool

67BrFalse(77)

B9:

68MoveLoc[1](Arg1: &GlobalConfig)

69MoveLoc[2](Arg2: &mut Pool<Ty0, SUI>)

70MoveLoc[3](Arg3: &Version)

71MoveLoc[4](Arg4: &mut Pool<Ty0, SUI>)

72MoveLoc[5](Arg5: &Clock)

73MoveLoc[12](loc4: u64)

74MoveLoc[7](Arg7: &mut TxContext)

75Call cm0<Ty0>(&GlobalConfig, &mut Pool<Ty0, SUI>, &Version, &mut Pool<Ty0, SUI>, &Clock, u64, &mut TxContext)

76Ret

B10:

77LdU64(0)

78StLoc[13](loc5: u64)

79Call i128::zero(): I128

80StLoc[15](loc7: I128)

81LdU64(0)

82StLoc[17](loc9: u64)

B11:

83CopyLoc[17](loc9: u64)

84CopyLoc[21](loc13: u64)

85Lt

86BrFalse(116)

B12:

87ImmBorrowLoc[20](loc12: vector<u64>)

88CopyLoc[17](loc9: u64)

89VecImmBorrow(17)

90ReadRef

91StLoc[19](loc11: u64)

92CopyLoc[6](Arg6: u64)

93MoveLoc[19](loc11: u64)

94Mul

95StLoc[9](loc1: u64)

96CopyLoc[2](Arg2: &mut Pool<Ty0, SUI>)

97FreezeRef

98CopyLoc[4](Arg4: &mut Pool<Ty0, SUI>)

99FreezeRef

100CopyLoc[9](loc1: u64)

101Call calc_cm0r<Ty0>(&Pool<Ty0, SUI>, &Pool<Ty0, SUI>, u64): I128

102StLoc[11](loc3: I128)

103CopyLoc[11](loc3: I128)

104CopyLoc[15](loc7: I128)

105Call i128::gt(I128, I128): bool

106BrFalse(116)

B13:

107MoveLoc[9](loc1: u64)

108StLoc[13](loc5: u64)

109MoveLoc[11](loc3: I128)

110StLoc[15](loc7: I128)

111MoveLoc[17](loc9: u64)

112LdU64(1)

113Add

114StLoc[17](loc9: u64)

115Branch(83)

B14:

116MoveLoc[15](loc7: I128)

117Call i128::zero(): I128

118Call i128::gt(I128, I128): bool

119BrFalse(129)

B15:

120MoveLoc[1](Arg1: &GlobalConfig)

121MoveLoc[2](Arg2: &mut Pool<Ty0, SUI>)

122MoveLoc[3](Arg3: &Version)

123MoveLoc[4](Arg4: &mut Pool<Ty0, SUI>)

124MoveLoc[5](Arg5: &Clock)

125MoveLoc[13](loc5: u64)

126MoveLoc[7](Arg7: &mut TxContext)

127Call cm0r<Ty0>(&GlobalConfig, &mut Pool<Ty0, SUI>, &Version, &mut Pool<Ty0, SUI>, &Clock, u64, &mut TxContext)

128Ret

B16:

129MoveLoc[3](Arg3: &Version)

130Pop

131MoveLoc[7](Arg7: &mut TxContext)

132Pop

133MoveLoc[5](Arg5: &Clock)

134Pop

135MoveLoc[1](Arg1: &GlobalConfig)

136Pop

137MoveLoc[4](Arg4: &mut Pool<Ty0, SUI>)

138Pop

139MoveLoc[2](Arg2: &mut Pool<Ty0, SUI>)

140Pop

141LdConst[3](u64: 25)

142Abort

}

cm0r<Ty0>(Arg0: &GlobalConfig, Arg1: &mut Pool<Ty0, SUI>, Arg2: &Version, Arg3: &mut Pool<Ty0, SUI>, Arg4: &Clock, Arg5: u64, Arg6: &mut TxContext) {

L7: loc0: Balance<Ty0>

L8: loc1: FlashSwapReceipt<Ty0, SUI>

L9: loc2: Balance<Ty0>

L10: loc3: u64

L11: loc4: Balance<SUI>

L12: loc5: Balance<Ty0>

L13: loc6: Balance<SUI>

L14: loc7: Balance<SUI>

B0:

0CopyLoc[0](Arg0: &GlobalConfig)

1CopyLoc[1](Arg1: &mut Pool<Ty0, SUI>)

2LdFalse

3LdFalse

4CopyLoc[5](Arg5: u64)

5LdU128(79226673515401279992447579055)

6CopyLoc[4](Arg4: &Clock)

7Call pool::flash_swap<Ty0, SUI>(&GlobalConfig, &mut Pool<Ty0, SUI>, bool, bool, u64, u128, &Clock): Balance<Ty0> * Balance<SUI> * FlashSwapReceipt<Ty0, SUI>

8StLoc[8](loc1: FlashSwapReceipt<Ty0, SUI>)

9StLoc[11](loc4: Balance<SUI>)

10StLoc[9](loc2: Balance<Ty0>)

11ImmBorrowLoc[9](loc2: Balance<Ty0>)

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

13MoveLoc[5](Arg5: u64)

14Eq

15BrFalse(17)

B1:

16Branch(31)

B2:

17MoveLoc[2](Arg2: &Version)

18Pop

19MoveLoc[6](Arg6: &mut TxContext)

20Pop

21MoveLoc[4](Arg4: &Clock)

22Pop

23MoveLoc[0](Arg0: &GlobalConfig)

24Pop

25MoveLoc[3](Arg3: &mut Pool<Ty0, SUI>)

26Pop

27MoveLoc[1](Arg1: &mut Pool<Ty0, SUI>)

28Pop

29LdConst[1](u64: 15)

30Abort

B3:

31MoveLoc[2](Arg2: &Version)

32MoveLoc[3](Arg3: &mut Pool<Ty0, SUI>)

33MoveLoc[9](loc2: Balance<Ty0>)

34MoveLoc[4](Arg4: &Clock)

35CopyLoc[6](Arg6: &mut TxContext)

36FreezeRef

37Call sbm_a_b<Ty0, SUI>(&Version, &mut Pool<Ty0, SUI>, Balance<Ty0>, &Clock, &TxContext): Balance<Ty0> * Balance<SUI>

38StLoc[14](loc7: Balance<SUI>)

39StLoc[7](loc0: Balance<Ty0>)

40ImmBorrowLoc[14](loc7: Balance<SUI>)

41Call balance::value<SUI>(&Balance<SUI>): u64

42LdU64(0)

43Gt

44BrFalse(46)

B4:

45Branch(54)

B5:

46MoveLoc[6](Arg6: &mut TxContext)

47Pop

48MoveLoc[0](Arg0: &GlobalConfig)

49Pop

50MoveLoc[1](Arg1: &mut Pool<Ty0, SUI>)

51Pop

52LdConst[7](u64: 50)

53Abort

B6:

54ImmBorrowLoc[8](loc1: FlashSwapReceipt<Ty0, SUI>)

55Call pool::swap_pay_amount<Ty0, SUI>(&FlashSwapReceipt<Ty0, SUI>): u64

56StLoc[10](loc3: u64)

57ImmBorrowLoc[14](loc7: Balance<SUI>)

58Call balance::value<SUI>(&Balance<SUI>): u64

59CopyLoc[10](loc3: u64)

60Gt

61BrFalse(63)

B7:

62Branch(71)

B8:

63MoveLoc[6](Arg6: &mut TxContext)

64Pop

65MoveLoc[0](Arg0: &GlobalConfig)

66Pop

67MoveLoc[1](Arg1: &mut Pool<Ty0, SUI>)

68Pop

69LdConst[2](u64: 20)

70Abort

B9:

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

72StLoc[12](loc5: Balance<Ty0>)

73MutBorrowLoc[14](loc7: Balance<SUI>)

74MoveLoc[10](loc3: u64)

75Call balance::split<SUI>(&mut Balance<SUI>, u64): Balance<SUI>

76StLoc[13](loc6: Balance<SUI>)

77MoveLoc[0](Arg0: &GlobalConfig)

78MoveLoc[1](Arg1: &mut Pool<Ty0, SUI>)

79MoveLoc[12](loc5: Balance<Ty0>)

80MoveLoc[13](loc6: Balance<SUI>)

81MoveLoc[8](loc1: FlashSwapReceipt<Ty0, SUI>)

82Call pool::repay_flash_swap<Ty0, SUI>(&GlobalConfig, &mut Pool<Ty0, SUI>, Balance<Ty0>, Balance<SUI>, FlashSwapReceipt<Ty0, SUI>)

83MoveLoc[11](loc4: Balance<SUI>)

84Call balance::destroy_zero<SUI>(Balance<SUI>)

85MoveLoc[7](loc0: Balance<Ty0>)

86CopyLoc[6](Arg6: &mut TxContext)

87Call common::tb<Ty0>(Balance<Ty0>, &mut TxContext)

88MoveLoc[14](loc7: Balance<SUI>)

89MoveLoc[6](Arg6: &mut TxContext)

90Call common::tb<SUI>(Balance<SUI>, &mut TxContext)

91Ret

}

cm0<Ty0>(Arg0: &GlobalConfig, Arg1: &mut Pool<Ty0, SUI>, Arg2: &Version, Arg3: &mut Pool<Ty0, SUI>, Arg4: &Clock, Arg5: u64, Arg6: &mut TxContext) {

L7: loc0: Balance<SUI>

L8: loc1: FlashSwapReceipt<Ty0, SUI>

L9: loc2: u64

L10: loc3: Balance<SUI>

L11: loc4: Balance<Ty0>

L12: loc5: Balance<Ty0>

L13: loc6: Balance<SUI>

L14: loc7: Balance<Ty0>

B0:

0CopyLoc[0](Arg0: &GlobalConfig)

1CopyLoc[1](Arg1: &mut Pool<Ty0, SUI>)

2LdTrue

3LdTrue

4MoveLoc[5](Arg5: u64)

5LdU128(4295048016)

6CopyLoc[4](Arg4: &Clock)

7Call pool::flash_swap<Ty0, SUI>(&GlobalConfig, &mut Pool<Ty0, SUI>, bool, bool, u64, u128, &Clock): Balance<Ty0> * Balance<SUI> * FlashSwapReceipt<Ty0, SUI>

8StLoc[8](loc1: FlashSwapReceipt<Ty0, SUI>)

9StLoc[10](loc3: Balance<SUI>)

10StLoc[11](loc4: Balance<Ty0>)

11ImmBorrowLoc[8](loc1: FlashSwapReceipt<Ty0, SUI>)

12Call pool::swap_pay_amount<Ty0, SUI>(&FlashSwapReceipt<Ty0, SUI>): u64

13StLoc[9](loc2: u64)

14MoveLoc[2](Arg2: &Version)

15MoveLoc[3](Arg3: &mut Pool<Ty0, SUI>)

16MoveLoc[10](loc3: Balance<SUI>)

17CopyLoc[9](loc2: u64)

18MoveLoc[4](Arg4: &Clock)

19CopyLoc[6](Arg6: &mut TxContext)

20FreezeRef

21Call sbm_b_a_bao<Ty0, SUI>(&Version, &mut Pool<Ty0, SUI>, Balance<SUI>, u64, &Clock, &TxContext): Balance<SUI> * Balance<Ty0>

22StLoc[14](loc7: Balance<Ty0>)

23StLoc[7](loc0: Balance<SUI>)

24ImmBorrowLoc[14](loc7: Balance<Ty0>)

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

26CopyLoc[9](loc2: u64)

27Ge

28BrFalse(30)

B1:

29Branch(38)

B2:

30MoveLoc[6](Arg6: &mut TxContext)

31Pop

32MoveLoc[0](Arg0: &GlobalConfig)

33Pop

34MoveLoc[1](Arg1: &mut Pool<Ty0, SUI>)

35Pop

36LdConst[2](u64: 20)

37Abort

B3:

38MutBorrowLoc[14](loc7: Balance<Ty0>)

39MoveLoc[9](loc2: u64)

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

41StLoc[12](loc5: Balance<Ty0>)

42Call balance::zero<SUI>(): Balance<SUI>

43StLoc[13](loc6: Balance<SUI>)

44MoveLoc[0](Arg0: &GlobalConfig)

45MoveLoc[1](Arg1: &mut Pool<Ty0, SUI>)

46MoveLoc[12](loc5: Balance<Ty0>)

47MoveLoc[13](loc6: Balance<SUI>)

48MoveLoc[8](loc1: FlashSwapReceipt<Ty0, SUI>)

49Call pool::repay_flash_swap<Ty0, SUI>(&GlobalConfig, &mut Pool<Ty0, SUI>, Balance<Ty0>, Balance<SUI>, FlashSwapReceipt<Ty0, SUI>)

50MoveLoc[11](loc4: Balance<Ty0>)

51Call balance::destroy_zero<Ty0>(Balance<Ty0>)

52MoveLoc[14](loc7: Balance<Ty0>)

53CopyLoc[6](Arg6: &mut TxContext)

54Call common::tb<Ty0>(Balance<Ty0>, &mut TxContext)

55MoveLoc[7](loc0: Balance<SUI>)

56MoveLoc[6](Arg6: &mut TxContext)

57Call common::tb<SUI>(Balance<SUI>, &mut TxContext)

58Ret

}

sbm_a_b<Ty0, Ty1>(Arg0: &Version, Arg1: &mut Pool<Ty0, Ty1>, Arg2: Balance<Ty0>, Arg3: &Clock, Arg4: &TxContext): Balance<Ty0> * Balance<Ty1> {

L5: loc0: Balance<Ty1>

L6: loc1: Balance<Ty0>

L7: loc2: Balance<Ty0>

L8: loc3: FlashSwapReceipt

L9: loc4: u64

B0:

0ImmBorrowLoc[2](Arg2: Balance<Ty0>)

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

2LdU64(0)

3Eq

4BrFalse(16)

B1:

5MoveLoc[0](Arg0: &Version)

6Pop

7MoveLoc[4](Arg4: &TxContext)

8Pop

9MoveLoc[3](Arg3: &Clock)

10Pop

11MoveLoc[1](Arg1: &mut Pool<Ty0, Ty1>)

12Pop

13MoveLoc[2](Arg2: Balance<Ty0>)

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

15Ret

B2:

16CopyLoc[1](Arg1: &mut Pool<Ty0, Ty1>)

17LdTrue

18LdTrue

19ImmBorrowLoc[2](Arg2: Balance<Ty0>)

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

21LdU128(4295048016)

22MoveLoc[3](Arg3: &Clock)

23CopyLoc[0](Arg0: &Version)

24CopyLoc[4](Arg4: &TxContext)

25Call trade::flash_swap<Ty0, Ty1>(&mut Pool<Ty0, Ty1>, bool, bool, u64, u128, &Clock, &Version, &TxContext): Balance<Ty0> * Balance<Ty1> * FlashSwapReceipt

26StLoc[8](loc3: FlashSwapReceipt)

27StLoc[5](loc0: Balance<Ty1>)

28StLoc[6](loc1: Balance<Ty0>)

29ImmBorrowLoc[8](loc3: FlashSwapReceipt)

30Call trade::swap_receipt_debts(&FlashSwapReceipt): u64 * u64

31Pop

32StLoc[9](loc4: u64)

33ImmBorrowLoc[2](Arg2: Balance<Ty0>)

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

35CopyLoc[9](loc4: u64)

36Ge

37BrFalse(39)

B3:

38Branch(47)

B4:

39MoveLoc[0](Arg0: &Version)

40Pop

41MoveLoc[4](Arg4: &TxContext)

42Pop

43MoveLoc[1](Arg1: &mut Pool<Ty0, Ty1>)

44Pop

45LdConst[8](u64: 30)

46Abort

B5:

47MutBorrowLoc[2](Arg2: Balance<Ty0>)

48MoveLoc[9](loc4: u64)

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

50StLoc[7](loc2: Balance<Ty0>)

51MoveLoc[1](Arg1: &mut Pool<Ty0, Ty1>)

52MoveLoc[8](loc3: FlashSwapReceipt)

53MoveLoc[7](loc2: Balance<Ty0>)

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

55MoveLoc[0](Arg0: &Version)

56MoveLoc[4](Arg4: &TxContext)

57Call trade::repay_flash_swap<Ty0, Ty1>(&mut Pool<Ty0, Ty1>, FlashSwapReceipt, Balance<Ty0>, Balance<Ty1>, &Version, &TxContext)

58MoveLoc[6](loc1: Balance<Ty0>)

59Call balance::destroy_zero<Ty0>(Balance<Ty0>)

60MoveLoc[2](Arg2: Balance<Ty0>)

61MoveLoc[5](loc0: Balance<Ty1>)

62Ret

}

sbm_b_a_bao<Ty0, Ty1>(Arg0: &Version, Arg1: &mut Pool<Ty0, Ty1>, Arg2: Balance<Ty1>, Arg3: u64, Arg4: &Clock, Arg5: &TxContext): Balance<Ty1> * Balance<Ty0> {

L6: loc0: bool

L7: loc1: Balance<Ty0>

L8: loc2: Balance<Ty1>

L9: loc3: Balance<Ty1>

L10: loc4: FlashSwapReceipt

L11: loc5: u64

B0:

0ImmBorrowLoc[2](Arg2: Balance<Ty1>)

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

2LdU64(0)

3Eq

4BrFalse(8)

B1:

5LdTrue

6StLoc[6](loc0: bool)

7Branch(12)

B2:

8CopyLoc[3](Arg3: u64)

9LdU64(0)

10Eq

11StLoc[6](loc0: bool)

B3:

12MoveLoc[6](loc0: bool)

13BrFalse(25)

B4:

14MoveLoc[0](Arg0: &Version)

15Pop

16MoveLoc[5](Arg5: &TxContext)

17Pop

18MoveLoc[4](Arg4: &Clock)

19Pop

20MoveLoc[1](Arg1: &mut Pool<Ty0, Ty1>)

21Pop

22MoveLoc[2](Arg2: Balance<Ty1>)

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

24Ret

B5:

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

26LdFalse

27LdFalse

28MoveLoc[3](Arg3: u64)

29LdU128(79226673515401279992447579055)

30MoveLoc[4](Arg4: &Clock)

31CopyLoc[0](Arg0: &Version)

32CopyLoc[5](Arg5: &TxContext)

33Call trade::flash_swap<Ty0, Ty1>(&mut Pool<Ty0, Ty1>, bool, bool, u64, u128, &Clock, &Version, &TxContext): Balance<Ty0> * Balance<Ty1> * FlashSwapReceipt

34StLoc[10](loc4: FlashSwapReceipt)

35StLoc[8](loc2: Balance<Ty1>)

36StLoc[7](loc1: Balance<Ty0>)

37ImmBorrowLoc[10](loc4: FlashSwapReceipt)

38Call trade::swap_receipt_debts(&FlashSwapReceipt): u64 * u64

39StLoc[11](loc5: u64)

40Pop

41ImmBorrowLoc[2](Arg2: Balance<Ty1>)

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

43CopyLoc[11](loc5: u64)

44Ge

45BrFalse(47)

B6:

46Branch(55)

B7:

47MoveLoc[0](Arg0: &Version)

48Pop

49MoveLoc[5](Arg5: &TxContext)

50Pop

51MoveLoc[1](Arg1: &mut Pool<Ty0, Ty1>)

52Pop

53LdConst[9](u64: 33)

54Abort

B8:

55MutBorrowLoc[2](Arg2: Balance<Ty1>)

56MoveLoc[11](loc5: u64)

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

58StLoc[9](loc3: Balance<Ty1>)

59MoveLoc[1](Arg1: &mut Pool<Ty0, Ty1>)

60MoveLoc[10](loc4: FlashSwapReceipt)

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

62MoveLoc[9](loc3: Balance<Ty1>)

63MoveLoc[0](Arg0: &Version)

64MoveLoc[5](Arg5: &TxContext)

65Call trade::repay_flash_swap<Ty0, Ty1>(&mut Pool<Ty0, Ty1>, FlashSwapReceipt, Balance<Ty0>, Balance<Ty1>, &Version, &TxContext)

66MoveLoc[8](loc2: Balance<Ty1>)

67Call balance::destroy_zero<Ty1>(Balance<Ty1>)

68MoveLoc[2](Arg2: Balance<Ty1>)

69MoveLoc[7](loc1: Balance<Ty0>)

70Ret

}

Constants [

0 => u64: 10

1 => u64: 15

2 => u64: 20

3 => u64: 25

4 => u64: 40

5 => u64: 41

6 => u64: 42

7 => u64: 50

8 => u64: 30

9 => u64: 33

10 => vector<u64>: 100100000000000000020000000000000005000000000000000a00000000000000140000000000000032000000000000006400000000000000c800000000000000f401000000000000e803000000000000d00700000000000088130000000000001027000000000000204e00000000000050c3000000000000a086010000000000

]

}