position_manager

Module0x1a3c…cad9

Move path: 0x91bf…9ca1::position_manager
Functions: 3413 public, 7 entry
Structs: 7
Friend modules: pool_factory

position_manager

Bytecode2355 lines

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

// Move bytecode v6

module 91bfbc386a41afcfd9b2533058d7e915a1d3829089cc268ff4333d54d6339ca1.position_manager {

use 0000000000000000000000000000000000000000000000000000000000000001::ascii;

use 0000000000000000000000000000000000000000000000000000000000000001::string;

use 0000000000000000000000000000000000000000000000000000000000000001::type_name;

use 0000000000000000000000000000000000000000000000000000000000000002::clock;

use 0000000000000000000000000000000000000000000000000000000000000002::coin;

use 0000000000000000000000000000000000000000000000000000000000000002::dynamic_object_field;

use 0000000000000000000000000000000000000000000000000000000000000002::event;

use 0000000000000000000000000000000000000000000000000000000000000002::object;

use 0000000000000000000000000000000000000000000000000000000000000002::table;

use 0000000000000000000000000000000000000000000000000000000000000002::transfer;

use 0000000000000000000000000000000000000000000000000000000000000002::tx_context;

use 0000000000000000000000000000000000000000000000000000000000000002::url;

use 91bfbc386a41afcfd9b2533058d7e915a1d3829089cc268ff4333d54d6339ca1::i32;

use 91bfbc386a41afcfd9b2533058d7e915a1d3829089cc268ff4333d54d6339ca1::math_liquidity;

use 91bfbc386a41afcfd9b2533058d7e915a1d3829089cc268ff4333d54d6339ca1::math_tick;

use 91bfbc386a41afcfd9b2533058d7e915a1d3829089cc268ff4333d54d6339ca1::pool;

use 91bfbc386a41afcfd9b2533058d7e915a1d3829089cc268ff4333d54d6339ca1::position_nft;

struct TurbosPositionBurnNFT has store, key {

id: UID,

name: String,

description: String,

img_url: Url,

position_nft: TurbosPositionNFT,

position_id: ID,

pool_id: ID,

coin_type_a: TypeName,

coin_type_b: TypeName,

fee_type: TypeName

}

struct PositionRewardInfo has store {

reward_growth_inside: u128,

amount_owed: u64

}

struct Position has store, key {

id: UID,

tick_lower_index: I32,

tick_upper_index: I32,

liquidity: u128,

fee_growth_inside_a: u128,

fee_growth_inside_b: u128,

tokens_owed_a: u64,

tokens_owed_b: u64,

reward_infos: vector<PositionRewardInfo>

}

struct Positions has store, key {

id: UID,

nft_minted: u64,

user_position: Table<address, ID>,

nft_name: String,

nft_description: String,

nft_img_url: String

}

struct IncreaseLiquidityEvent has copy, drop {

pool: ID,

amount_a: u64,

amount_b: u64,

liquidity: u128

}

struct DecreaseLiquidityEvent has copy, drop {

pool: ID,

amount_a: u64,

amount_b: u64,

liquidity: u128

}

struct CollectEvent has copy, drop {

pool: ID,

amount_a: u64,

amount_b: u64,

recipient: address

}

struct CollectRewardEvent has copy, drop {

pool: ID,

amount: u64,

vault: ID,

reward_index: u64,

recipient: address

}

struct BurnPositionEvent has copy, drop {

nft_address: address,

position_id: ID,

pool_id: ID,

burn_nft_address: address

}

struct MintNftEvent has copy, drop {

nft_address: address,

position_id: ID,

pool_id: ID

}

struct BurnNftEvent has copy, drop {

nft_address: address,

position_id: ID,

pool_id: ID

}

init(Arg0: &mut TxContext) {

B0:

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

1Call init_(&mut TxContext)

2Ret

}

init_(Arg0: &mut TxContext) {

B0:

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

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

2LdU64(0)

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

4Call table::new<address, ID>(&mut TxContext): Table<address, ID>

5LdConst[13](vector<u8>: "Tur..)

6Call string::utf8(vector<u8>): String

7LdConst[14](vector<u8>: "An ..)

8Call string::utf8(vector<u8>): String

9LdConst[15](vector<u8>: "htt..)

10Call string::utf8(vector<u8>): String

11Pack[3](Positions)

12Call transfer::share_object<Positions>(Positions)

13Ret

}

entry public mint<Ty0, Ty1, Ty2>(Arg0: &mut Pool<Ty0, Ty1, Ty2>, Arg1: &mut Positions, Arg2: vector<Coin<Ty0>>, Arg3: vector<Coin<Ty1>>, Arg4: u32, Arg5: bool, Arg6: u32, Arg7: bool, Arg8: u64, Arg9: u64, Arg10: u64, Arg11: u64, Arg12: address, Arg13: u64, Arg14: &Clock, Arg15: &Versioned, Arg16: &mut TxContext) {

L17: loc0: Coin<Ty0>

L18: loc1: Coin<Ty1>

L19: loc2: TurbosPositionNFT

B0:

0CopyLoc[15](Arg15: &Versioned)

1Call pool::check_version(&Versioned)

2MoveLoc[0](Arg0: &mut Pool<Ty0, Ty1, Ty2>)

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

4MoveLoc[2](Arg2: vector<Coin<Ty0>>)

5MoveLoc[3](Arg3: vector<Coin<Ty1>>)

6MoveLoc[4](Arg4: u32)

7MoveLoc[5](Arg5: bool)

8MoveLoc[6](Arg6: u32)

9MoveLoc[7](Arg7: bool)

10MoveLoc[8](Arg8: u64)

11MoveLoc[9](Arg9: u64)

12MoveLoc[10](Arg10: u64)

13MoveLoc[11](Arg11: u64)

14MoveLoc[13](Arg13: u64)

15MoveLoc[14](Arg14: &Clock)

16MoveLoc[15](Arg15: &Versioned)

17CopyLoc[16](Arg16: &mut TxContext)

18Call mint_with_return_<Ty0, Ty1, Ty2>(&mut Pool<Ty0, Ty1, Ty2>, &mut Positions, vector<Coin<Ty0>>, vector<Coin<Ty1>>, u32, bool, u32, bool, u64, u64, u64, u64, u64, &Clock, &Versioned, &mut TxContext): TurbosPositionNFT * Coin<Ty0> * Coin<Ty1>

19StLoc[18](loc1: Coin<Ty1>)

20StLoc[17](loc0: Coin<Ty0>)

21StLoc[19](loc2: TurbosPositionNFT)

22ImmBorrowLoc[17](loc0: Coin<Ty0>)

23Call coin::value<Ty0>(&Coin<Ty0>): u64

24LdU64(0)

25Eq

26BrFalse(30)

B1:

27MoveLoc[17](loc0: Coin<Ty0>)

28Call coin::destroy_zero<Ty0>(Coin<Ty0>)

29Branch(35)

B2:

30MoveLoc[17](loc0: Coin<Ty0>)

31CopyLoc[16](Arg16: &mut TxContext)

32FreezeRef

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

34Call transfer::public_transfer<Coin<Ty0>>(Coin<Ty0>, address)

B3:

35ImmBorrowLoc[18](loc1: Coin<Ty1>)

36Call coin::value<Ty1>(&Coin<Ty1>): u64

37LdU64(0)

38Eq

39BrFalse(45)

B4:

40MoveLoc[16](Arg16: &mut TxContext)

41Pop

42MoveLoc[18](loc1: Coin<Ty1>)

43Call coin::destroy_zero<Ty1>(Coin<Ty1>)

44Branch(50)

B5:

45MoveLoc[18](loc1: Coin<Ty1>)

46MoveLoc[16](Arg16: &mut TxContext)

47FreezeRef

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

49Call transfer::public_transfer<Coin<Ty1>>(Coin<Ty1>, address)

B6:

50MoveLoc[19](loc2: TurbosPositionNFT)

51MoveLoc[12](Arg12: address)

52Call transfer::public_transfer<TurbosPositionNFT>(TurbosPositionNFT, address)

53Ret

}

public mint_with_return_<Ty0, Ty1, Ty2>(Arg0: &mut Pool<Ty0, Ty1, Ty2>, Arg1: &mut Positions, Arg2: vector<Coin<Ty0>>, Arg3: vector<Coin<Ty1>>, Arg4: u32, Arg5: bool, Arg6: u32, Arg7: bool, Arg8: u64, Arg9: u64, Arg10: u64, Arg11: u64, Arg12: u64, Arg13: &Clock, Arg14: &Versioned, Arg15: &mut TxContext): TurbosPositionNFT * Coin<Ty0> * Coin<Ty1> {

L16: loc0: address

L17: loc1: I32

L18: loc2: I32

L19: loc3: bool

L20: loc4: String

L21: loc5: &mut Position

L22: loc6: u64

L23: loc7: u64

L24: loc8: Coin<Ty0>

L25: loc9: Coin<Ty1>

L26: loc10: u128

L27: loc11: TurbosPositionNFT

L28: loc12: address

L29: loc13: UID

L30: loc14: ID

L31: loc15: String

L32: loc16: Position

L33: loc17: I32

L34: loc18: I32

B0:

0MoveLoc[14](Arg14: &Versioned)

1Call pool::check_version(&Versioned)

2CopyLoc[13](Arg13: &Clock)

3Call clock::timestamp_ms(&Clock): u64

4MoveLoc[12](Arg12: u64)

5Le

6BrFalse(8)

B1:

7Branch(18)

B2:

8MoveLoc[1](Arg1: &mut Positions)

9Pop

10MoveLoc[0](Arg0: &mut Pool<Ty0, Ty1, Ty2>)

11Pop

12MoveLoc[15](Arg15: &mut TxContext)

13Pop

14MoveLoc[13](Arg13: &Clock)

15Pop

16LdConst[4](u64: 8)

17Abort

B3:

18ImmBorrowLoc[2](Arg2: vector<Coin<Ty0>>)

19VecLen(50)

20LdU64(0)

21Gt

22BrFalse(24)

B4:

23Branch(34)

B5:

24MoveLoc[1](Arg1: &mut Positions)

25Pop

26MoveLoc[0](Arg0: &mut Pool<Ty0, Ty1, Ty2>)

27Pop

28MoveLoc[15](Arg15: &mut TxContext)

29Pop

30MoveLoc[13](Arg13: &Clock)

31Pop

32LdConst[0](u64: 4)

33Abort

B6:

34ImmBorrowLoc[3](Arg3: vector<Coin<Ty1>>)

35VecLen(54)

36LdU64(0)

37Gt

38BrFalse(40)

B7:

39Branch(50)

B8:

40MoveLoc[1](Arg1: &mut Positions)

41Pop

42MoveLoc[0](Arg0: &mut Pool<Ty0, Ty1, Ty2>)

43Pop

44MoveLoc[15](Arg15: &mut TxContext)

45Pop

46MoveLoc[13](Arg13: &Clock)

47Pop

48LdConst[0](u64: 4)

49Abort

B9:

50MoveLoc[4](Arg4: u32)

51MoveLoc[5](Arg5: bool)

52Call i32::from_u32_neg(u32, bool): I32

53StLoc[33](loc17: I32)

54MoveLoc[6](Arg6: u32)

55MoveLoc[7](Arg7: bool)

56Call i32::from_u32_neg(u32, bool): I32

57StLoc[34](loc18: I32)

58CopyLoc[15](Arg15: &mut TxContext)

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

60StLoc[29](loc13: UID)

61ImmBorrowLoc[29](loc13: UID)

62Call object::uid_to_inner(&UID): ID

63StLoc[30](loc14: ID)

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

65FreezeRef

66Call object::id<Pool<Ty0, Ty1, Ty2>>(&Pool<Ty0, Ty1, Ty2>): ID

67CopyLoc[30](loc14: ID)

68CopyLoc[1](Arg1: &mut Positions)

69CopyLoc[15](Arg15: &mut TxContext)

70Call mint_nft_with_return_<Ty0, Ty1, Ty2>(ID, ID, &mut Positions, &mut TxContext): TurbosPositionNFT

71StLoc[27](loc11: TurbosPositionNFT)

72ImmBorrowLoc[27](loc11: TurbosPositionNFT)

73Call object::id_address<TurbosPositionNFT>(&TurbosPositionNFT): address

74StLoc[28](loc12: address)

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

76CopyLoc[28](loc12: address)

77CopyLoc[33](loc17: I32)

78CopyLoc[34](loc18: I32)

79StLoc[18](loc2: I32)

80StLoc[17](loc1: I32)

81StLoc[16](loc0: address)

82FreezeRef

83MoveLoc[16](loc0: address)

84MoveLoc[17](loc1: I32)

85MoveLoc[18](loc2: I32)

86Call pool::get_position_key_fix<Ty0, Ty1, Ty2>(&Pool<Ty0, Ty1, Ty2>, address, I32, I32): String

87StLoc[31](loc15: String)

88CopyLoc[0](Arg0: &mut Pool<Ty0, Ty1, Ty2>)

89MoveLoc[2](Arg2: vector<Coin<Ty0>>)

90Call pool::merge_coin<Ty0>(vector<Coin<Ty0>>): Coin<Ty0>

91MoveLoc[3](Arg3: vector<Coin<Ty1>>)

92Call pool::merge_coin<Ty1>(vector<Coin<Ty1>>): Coin<Ty1>

93CopyLoc[28](loc12: address)

94CopyLoc[33](loc17: I32)

95CopyLoc[34](loc18: I32)

96MoveLoc[8](Arg8: u64)

97MoveLoc[9](Arg9: u64)

98MoveLoc[13](Arg13: &Clock)

99MoveLoc[15](Arg15: &mut TxContext)

100Call add_liquidity_with_return_<Ty0, Ty1, Ty2>(&mut Pool<Ty0, Ty1, Ty2>, Coin<Ty0>, Coin<Ty1>, address, I32, I32, u64, u64, &Clock, &mut TxContext): u128 * u64 * u64 * Coin<Ty0> * Coin<Ty1>

101StLoc[25](loc9: Coin<Ty1>)

102StLoc[24](loc8: Coin<Ty0>)

103StLoc[23](loc7: u64)

104StLoc[22](loc6: u64)

105StLoc[26](loc10: u128)

106CopyLoc[22](loc6: u64)

107MoveLoc[10](Arg10: u64)

108Ge

109BrFalse(115)

B10:

110CopyLoc[23](loc7: u64)

111MoveLoc[11](Arg11: u64)

112Ge

113StLoc[19](loc3: bool)

114Branch(117)

B11:

115LdFalse

116StLoc[19](loc3: bool)

B12:

117MoveLoc[19](loc3: bool)

118BrFalse(120)

B13:

119Branch(126)

B14:

120MoveLoc[1](Arg1: &mut Positions)

121Pop

122MoveLoc[0](Arg0: &mut Pool<Ty0, Ty1, Ty2>)

123Pop

124LdConst[1](u64: 5)

125Abort

B15:

126MoveLoc[29](loc13: UID)

127MoveLoc[33](loc17: I32)

128MoveLoc[34](loc18: I32)

129CopyLoc[26](loc10: u128)

130LdU128(0)

131LdU128(0)

132LdU64(0)

133LdU64(0)

134VecPack(65, 0)

135Pack[2](Position)

136StLoc[32](loc16: Position)

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

138MoveLoc[31](loc15: String)

139MutBorrowLoc[32](loc16: Position)

140StLoc[21](loc5: &mut Position)

141StLoc[20](loc4: String)

142FreezeRef

143MoveLoc[20](loc4: String)

144MoveLoc[21](loc5: &mut Position)

145Call copy_position<Ty0, Ty1, Ty2>(&Pool<Ty0, Ty1, Ty2>, String, &mut Position)

146CopyLoc[1](Arg1: &mut Positions)

147MutBorrowField[0](Positions.id: UID)

148CopyLoc[28](loc12: address)

149MoveLoc[32](loc16: Position)

150Call dynamic_object_field::add<address, Position>(&mut UID, address, Position)

151MoveLoc[1](Arg1: &mut Positions)

152MoveLoc[30](loc14: ID)

153MoveLoc[28](loc12: address)

154Call insert_user_position(&mut Positions, ID, address)

155MoveLoc[0](Arg0: &mut Pool<Ty0, Ty1, Ty2>)

156FreezeRef

157Call object::id<Pool<Ty0, Ty1, Ty2>>(&Pool<Ty0, Ty1, Ty2>): ID

158MoveLoc[22](loc6: u64)

159MoveLoc[23](loc7: u64)

160MoveLoc[26](loc10: u128)

161Pack[4](IncreaseLiquidityEvent)

162Call event::emit<IncreaseLiquidityEvent>(IncreaseLiquidityEvent)

163MoveLoc[27](loc11: TurbosPositionNFT)

164MoveLoc[24](loc8: Coin<Ty0>)

165MoveLoc[25](loc9: Coin<Ty1>)

166Ret

}

entry public burn<Ty0, Ty1, Ty2>(Arg0: &mut Positions, Arg1: TurbosPositionNFT, Arg2: &Versioned, Arg3: &mut TxContext) {

L4: loc0: bool

L5: loc1: u64

L6: loc2: u64

L7: loc3: address

L8: loc4: &mut Position

B0:

0MoveLoc[2](Arg2: &Versioned)

1Call pool::check_version(&Versioned)

2ImmBorrowLoc[1](Arg1: TurbosPositionNFT)

3Call object::id_address<TurbosPositionNFT>(&TurbosPositionNFT): address

4StLoc[7](loc3: address)

5CopyLoc[0](Arg0: &mut Positions)

6MutBorrowField[0](Positions.id: UID)

7CopyLoc[7](loc3: address)

8Call dynamic_object_field::borrow_mut<address, Position>(&mut UID, address): &mut Position

9StLoc[8](loc4: &mut Position)

10CopyLoc[8](loc4: &mut Position)

11FreezeRef

12Call object::id<Position>(&Position): ID

13Pop

14ImmBorrowLoc[1](Arg1: TurbosPositionNFT)

15Call position_nft::pool_id(&TurbosPositionNFT): ID

16Pop

17CopyLoc[8](loc4: &mut Position)

18ImmBorrowField[1](Position.liquidity: u128)

19ReadRef

20LdU128(0)

21Eq

22BrFalse(39)

B1:

23CopyLoc[8](loc4: &mut Position)

24ImmBorrowField[2](Position.tokens_owed_a: u64)

25ReadRef

26LdU64(0)

27Eq

28BrFalse(36)

B2:

29CopyLoc[8](loc4: &mut Position)

30ImmBorrowField[3](Position.tokens_owed_b: u64)

31ReadRef

32LdU64(0)

33Eq

34StLoc[4](loc0: bool)

35Branch(38)

B3:

36LdFalse

37StLoc[4](loc0: bool)

B4:

38Branch(41)

B5:

39LdFalse

40StLoc[4](loc0: bool)

B6:

41MoveLoc[4](loc0: bool)

42BrFalse(44)

B7:

43Branch(50)

B8:

44MoveLoc[0](Arg0: &mut Positions)

45Pop

46MoveLoc[8](loc4: &mut Position)

47Pop

48LdConst[2](u64: 6)

49Abort

B9:

50LdU64(0)

51StLoc[5](loc1: u64)

52CopyLoc[8](loc4: &mut Position)

53ImmBorrowField[4](Position.reward_infos: vector<PositionRewardInfo>)

54VecLen(65)

55StLoc[6](loc2: u64)

B10:

56CopyLoc[5](loc1: u64)

57CopyLoc[6](loc2: u64)

58Lt

59BrFalse(82)

B11:

60Branch(61)

B12:

61CopyLoc[8](loc4: &mut Position)

62ImmBorrowField[4](Position.reward_infos: vector<PositionRewardInfo>)

63CopyLoc[5](loc1: u64)

64VecImmBorrow(65)

65ImmBorrowField[5](PositionRewardInfo.amount_owed: u64)

66ReadRef

67LdU64(0)

68Eq

69BrFalse(71)

B13:

70Branch(77)

B14:

71MoveLoc[0](Arg0: &mut Positions)

72Pop

73MoveLoc[8](loc4: &mut Position)

74Pop

75LdConst[2](u64: 6)

76Abort

B15:

77MoveLoc[5](loc1: u64)

78LdU64(1)

79Add

80StLoc[5](loc1: u64)

81Branch(56)

B16:

82MoveLoc[8](loc4: &mut Position)

83Pop

84MoveLoc[0](Arg0: &mut Positions)

85MoveLoc[7](loc3: address)

86Call delete_user_position(&mut Positions, address)

87MoveLoc[1](Arg1: TurbosPositionNFT)

88Call burn_nft(TurbosPositionNFT)

89Ret

}

add_liquidity<Ty0, Ty1, Ty2>(Arg0: &mut Pool<Ty0, Ty1, Ty2>, Arg1: Coin<Ty0>, Arg2: Coin<Ty1>, Arg3: address, Arg4: I32, Arg5: I32, Arg6: u64, Arg7: u64, Arg8: &Clock, Arg9: &mut TxContext): u128 * u64 * u64 {

B0:

0LdU64(0)

1Abort

}

add_liquidity_with_return_<Ty0, Ty1, Ty2>(Arg0: &mut Pool<Ty0, Ty1, Ty2>, Arg1: Coin<Ty0>, Arg2: Coin<Ty1>, Arg3: address, Arg4: I32, Arg5: I32, Arg6: u64, Arg7: u64, Arg8: &Clock, Arg9: &mut TxContext): u128 * u64 * u64 * Coin<Ty0> * Coin<Ty1> {

L10: loc0: u64

L11: loc1: u64

L12: loc2: u64

L13: loc3: u64

L14: loc4: u64

L15: loc5: u64

L16: loc6: Coin<Ty0>

L17: loc7: Coin<Ty1>

L18: loc8: u128

L19: loc9: u128

L20: loc10: u128

B0:

0CopyLoc[4](Arg4: I32)

1Call math_tick::sqrt_price_from_tick_index(I32): u128

2StLoc[19](loc9: u128)

3CopyLoc[5](Arg5: I32)

4Call math_tick::sqrt_price_from_tick_index(I32): u128

5StLoc[20](loc10: u128)

6CopyLoc[0](Arg0: &mut Pool<Ty0, Ty1, Ty2>)

7FreezeRef

8Call pool::get_pool_sqrt_price<Ty0, Ty1, Ty2>(&Pool<Ty0, Ty1, Ty2>): u128

9MoveLoc[19](loc9: u128)

10MoveLoc[20](loc10: u128)

11MoveLoc[6](Arg6: u64)

12CastU128

13MoveLoc[7](Arg7: u64)

14CastU128

15Call math_liquidity::get_liquidity_for_amounts(u128, u128, u128, u128, u128): u128

16StLoc[18](loc8: u128)

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

18MoveLoc[3](Arg3: address)

19MoveLoc[4](Arg4: I32)

20MoveLoc[5](Arg5: I32)

21CopyLoc[18](loc8: u128)

22MoveLoc[8](Arg8: &Clock)

23CopyLoc[9](Arg9: &mut TxContext)

24Call pool::mint<Ty0, Ty1, Ty2>(&mut Pool<Ty0, Ty1, Ty2>, address, I32, I32, u128, &Clock, &mut TxContext): u64 * u64

25StLoc[11](loc1: u64)

26StLoc[10](loc0: u64)

27CopyLoc[0](Arg0: &mut Pool<Ty0, Ty1, Ty2>)

28FreezeRef

29Call pool::get_pool_balance<Ty0, Ty1, Ty2>(&Pool<Ty0, Ty1, Ty2>): u64 * u64

30StLoc[14](loc4: u64)

31StLoc[12](loc2: u64)

32CopyLoc[0](Arg0: &mut Pool<Ty0, Ty1, Ty2>)

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

34CopyLoc[10](loc0: u64)

35MoveLoc[2](Arg2: Coin<Ty1>)

36CopyLoc[11](loc1: u64)

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

38Call pool::split_and_return_<Ty0, Ty1, Ty2>(&mut Pool<Ty0, Ty1, Ty2>, Coin<Ty0>, u64, Coin<Ty1>, u64, &mut TxContext): Coin<Ty0> * Coin<Ty1>

39StLoc[17](loc7: Coin<Ty1>)

40StLoc[16](loc6: Coin<Ty0>)

41MoveLoc[0](Arg0: &mut Pool<Ty0, Ty1, Ty2>)

42FreezeRef

43Call pool::get_pool_balance<Ty0, Ty1, Ty2>(&Pool<Ty0, Ty1, Ty2>): u64 * u64

44StLoc[15](loc5: u64)

45StLoc[13](loc3: u64)

46MoveLoc[12](loc2: u64)

47CopyLoc[10](loc0: u64)

48Add

49MoveLoc[13](loc3: u64)

50Le

51BrFalse(53)

B1:

52Branch(55)

B2:

53LdConst[3](u64: 7)

54Abort

B3:

55MoveLoc[14](loc4: u64)

56CopyLoc[11](loc1: u64)

57Add

58MoveLoc[15](loc5: u64)

59Le

60BrFalse(62)

B4:

61Branch(64)

B5:

62LdConst[3](u64: 7)

63Abort

B6:

64MoveLoc[18](loc8: u128)

65MoveLoc[10](loc0: u64)

66MoveLoc[11](loc1: u64)

67MoveLoc[16](loc6: Coin<Ty0>)

68MoveLoc[17](loc7: Coin<Ty1>)

69Ret

}

entry public increase_liquidity<Ty0, Ty1, Ty2>(Arg0: &mut Pool<Ty0, Ty1, Ty2>, Arg1: &mut Positions, Arg2: vector<Coin<Ty0>>, Arg3: vector<Coin<Ty1>>, Arg4: &mut TurbosPositionNFT, Arg5: u64, Arg6: u64, Arg7: u64, Arg8: u64, Arg9: u64, Arg10: &Clock, Arg11: &Versioned, Arg12: &mut TxContext) {

L13: loc0: Coin<Ty0>

L14: loc1: Coin<Ty1>

B0:

0CopyLoc[11](Arg11: &Versioned)

1Call pool::check_version(&Versioned)

2MoveLoc[0](Arg0: &mut Pool<Ty0, Ty1, Ty2>)

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

4MoveLoc[2](Arg2: vector<Coin<Ty0>>)

5MoveLoc[3](Arg3: vector<Coin<Ty1>>)

6MoveLoc[4](Arg4: &mut TurbosPositionNFT)

7MoveLoc[5](Arg5: u64)

8MoveLoc[6](Arg6: u64)

9MoveLoc[7](Arg7: u64)

10MoveLoc[8](Arg8: u64)

11MoveLoc[9](Arg9: u64)

12MoveLoc[10](Arg10: &Clock)

13MoveLoc[11](Arg11: &Versioned)

14CopyLoc[12](Arg12: &mut TxContext)

15Call increase_liquidity_with_return_<Ty0, Ty1, Ty2>(&mut Pool<Ty0, Ty1, Ty2>, &mut Positions, vector<Coin<Ty0>>, vector<Coin<Ty1>>, &mut TurbosPositionNFT, u64, u64, u64, u64, u64, &Clock, &Versioned, &mut TxContext): Coin<Ty0> * Coin<Ty1>

16StLoc[14](loc1: Coin<Ty1>)

17StLoc[13](loc0: Coin<Ty0>)

18ImmBorrowLoc[13](loc0: Coin<Ty0>)

19Call coin::value<Ty0>(&Coin<Ty0>): u64

20LdU64(0)

21Eq

22BrFalse(26)

B1:

23MoveLoc[13](loc0: Coin<Ty0>)

24Call coin::destroy_zero<Ty0>(Coin<Ty0>)

25Branch(31)

B2:

26MoveLoc[13](loc0: Coin<Ty0>)

27CopyLoc[12](Arg12: &mut TxContext)

28FreezeRef

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

30Call transfer::public_transfer<Coin<Ty0>>(Coin<Ty0>, address)

B3:

31ImmBorrowLoc[14](loc1: Coin<Ty1>)

32Call coin::value<Ty1>(&Coin<Ty1>): u64

33LdU64(0)

34Eq

35BrFalse(41)

B4:

36MoveLoc[12](Arg12: &mut TxContext)

37Pop

38MoveLoc[14](loc1: Coin<Ty1>)

39Call coin::destroy_zero<Ty1>(Coin<Ty1>)

40Branch(46)

B5:

41MoveLoc[14](loc1: Coin<Ty1>)

42MoveLoc[12](Arg12: &mut TxContext)

43FreezeRef

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

45Call transfer::public_transfer<Coin<Ty1>>(Coin<Ty1>, address)

B6:

46Ret

}

public increase_liquidity_with_return_<Ty0, Ty1, Ty2>(Arg0: &mut Pool<Ty0, Ty1, Ty2>, Arg1: &mut Positions, Arg2: vector<Coin<Ty0>>, Arg3: vector<Coin<Ty1>>, Arg4: &mut TurbosPositionNFT, Arg5: u64, Arg6: u64, Arg7: u64, Arg8: u64, Arg9: u64, Arg10: &Clock, Arg11: &Versioned, Arg12: &mut TxContext): Coin<Ty0> * Coin<Ty1> {

L13: loc0: String

L14: loc1: &mut Position

L15: loc2: address

L16: loc3: I32

L17: loc4: I32

L18: loc5: bool

L19: loc6: address

L20: loc7: I32

L21: loc8: I32

L22: loc9: u64

L23: loc10: u64

L24: loc11: Coin<Ty0>

L25: loc12: Coin<Ty1>

L26: loc13: u128

L27: loc14: address

L28: loc15: &mut Position

L29: loc16: String

L30: loc17: address

L31: loc18: address

B0:

0MoveLoc[11](Arg11: &Versioned)

1Call pool::check_version(&Versioned)

2CopyLoc[0](Arg0: &mut Pool<Ty0, Ty1, Ty2>)

3FreezeRef

4Call object::id<Pool<Ty0, Ty1, Ty2>>(&Pool<Ty0, Ty1, Ty2>): ID

5CopyLoc[4](Arg4: &mut TurbosPositionNFT)

6FreezeRef

7Call position_nft::pool_id(&TurbosPositionNFT): ID

8Eq

9BrFalse(11)

B1:

10Branch(23)

B2:

11MoveLoc[1](Arg1: &mut Positions)

12Pop

13MoveLoc[0](Arg0: &mut Pool<Ty0, Ty1, Ty2>)

14Pop

15MoveLoc[4](Arg4: &mut TurbosPositionNFT)

16Pop

17MoveLoc[12](Arg12: &mut TxContext)

18Pop

19MoveLoc[10](Arg10: &Clock)

20Pop

21LdConst[10](u64: 15)

22Abort

B3:

23CopyLoc[10](Arg10: &Clock)

24Call clock::timestamp_ms(&Clock): u64

25MoveLoc[9](Arg9: u64)

26Le

27BrFalse(29)

B4:

28Branch(41)

B5:

29MoveLoc[1](Arg1: &mut Positions)

30Pop

31MoveLoc[0](Arg0: &mut Pool<Ty0, Ty1, Ty2>)

32Pop

33MoveLoc[4](Arg4: &mut TurbosPositionNFT)

34Pop

35MoveLoc[12](Arg12: &mut TxContext)

36Pop

37MoveLoc[10](Arg10: &Clock)

38Pop

39LdConst[4](u64: 8)

40Abort

B6:

41ImmBorrowLoc[2](Arg2: vector<Coin<Ty0>>)

42VecLen(50)

43LdU64(0)

44Gt

45BrFalse(47)

B7:

46Branch(59)

B8:

47MoveLoc[1](Arg1: &mut Positions)

48Pop

49MoveLoc[0](Arg0: &mut Pool<Ty0, Ty1, Ty2>)

50Pop

51MoveLoc[4](Arg4: &mut TurbosPositionNFT)

52Pop

53MoveLoc[12](Arg12: &mut TxContext)

54Pop

55MoveLoc[10](Arg10: &Clock)

56Pop

57LdConst[0](u64: 4)

58Abort

B9:

59ImmBorrowLoc[3](Arg3: vector<Coin<Ty1>>)

60VecLen(54)

61LdU64(0)

62Gt

63BrFalse(65)

B10:

64Branch(77)

B11:

65MoveLoc[1](Arg1: &mut Positions)

66Pop

67MoveLoc[0](Arg0: &mut Pool<Ty0, Ty1, Ty2>)

68Pop

69MoveLoc[4](Arg4: &mut TurbosPositionNFT)

70Pop

71MoveLoc[12](Arg12: &mut TxContext)

72Pop

73MoveLoc[10](Arg10: &Clock)

74Pop

75LdConst[0](u64: 4)

76Abort

B12:

77MoveLoc[4](Arg4: &mut TurbosPositionNFT)

78FreezeRef

79Call object::id_address<TurbosPositionNFT>(&TurbosPositionNFT): address

80StLoc[27](loc14: address)

81CopyLoc[12](Arg12: &mut TxContext)

82FreezeRef

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

84StLoc[31](loc18: address)

85MoveLoc[1](Arg1: &mut Positions)

86MutBorrowField[0](Positions.id: UID)

87CopyLoc[27](loc14: address)

88Call dynamic_object_field::borrow_mut<address, Position>(&mut UID, address): &mut Position

89StLoc[28](loc15: &mut Position)

90CopyLoc[0](Arg0: &mut Pool<Ty0, Ty1, Ty2>)

91CopyLoc[27](loc14: address)

92CopyLoc[28](loc15: &mut Position)

93ImmBorrowField[6](Position.tick_lower_index: I32)

94ReadRef

95CopyLoc[28](loc15: &mut Position)

96ImmBorrowField[7](Position.tick_upper_index: I32)

97ReadRef

98StLoc[17](loc4: I32)

99StLoc[16](loc3: I32)

100StLoc[15](loc2: address)

101FreezeRef

102MoveLoc[15](loc2: address)

103MoveLoc[16](loc3: I32)

104MoveLoc[17](loc4: I32)

105Call pool::check_position_exists<Ty0, Ty1, Ty2>(&Pool<Ty0, Ty1, Ty2>, address, I32, I32): bool

106BrFalse(110)

B13:

107MoveLoc[27](loc14: address)

108StLoc[30](loc17: address)

109Branch(112)

B14:

110MoveLoc[31](loc18: address)

111StLoc[30](loc17: address)

B15:

112CopyLoc[0](Arg0: &mut Pool<Ty0, Ty1, Ty2>)

113MoveLoc[2](Arg2: vector<Coin<Ty0>>)

114Call pool::merge_coin<Ty0>(vector<Coin<Ty0>>): Coin<Ty0>

115MoveLoc[3](Arg3: vector<Coin<Ty1>>)

116Call pool::merge_coin<Ty1>(vector<Coin<Ty1>>): Coin<Ty1>

117CopyLoc[30](loc17: address)

118CopyLoc[28](loc15: &mut Position)

119ImmBorrowField[6](Position.tick_lower_index: I32)

120ReadRef

121CopyLoc[28](loc15: &mut Position)

122ImmBorrowField[7](Position.tick_upper_index: I32)

123ReadRef

124MoveLoc[5](Arg5: u64)

125MoveLoc[6](Arg6: u64)

126MoveLoc[10](Arg10: &Clock)

127MoveLoc[12](Arg12: &mut TxContext)

128Call add_liquidity_with_return_<Ty0, Ty1, Ty2>(&mut Pool<Ty0, Ty1, Ty2>, Coin<Ty0>, Coin<Ty1>, address, I32, I32, u64, u64, &Clock, &mut TxContext): u128 * u64 * u64 * Coin<Ty0> * Coin<Ty1>

129StLoc[25](loc12: Coin<Ty1>)

130StLoc[24](loc11: Coin<Ty0>)

131StLoc[23](loc10: u64)

132StLoc[22](loc9: u64)

133StLoc[26](loc13: u128)

134CopyLoc[22](loc9: u64)

135MoveLoc[7](Arg7: u64)

136Ge

137BrFalse(143)

B16:

138CopyLoc[23](loc10: u64)

139MoveLoc[8](Arg8: u64)

140Ge

141StLoc[18](loc5: bool)

142Branch(145)

B17:

143LdFalse

144StLoc[18](loc5: bool)

B18:

145MoveLoc[18](loc5: bool)

146BrFalse(148)

B19:

147Branch(154)

B20:

148MoveLoc[28](loc15: &mut Position)

149Pop

150MoveLoc[0](Arg0: &mut Pool<Ty0, Ty1, Ty2>)

151Pop

152LdConst[1](u64: 5)

153Abort

B21:

154CopyLoc[0](Arg0: &mut Pool<Ty0, Ty1, Ty2>)

155MoveLoc[30](loc17: address)

156CopyLoc[28](loc15: &mut Position)

157ImmBorrowField[6](Position.tick_lower_index: I32)

158ReadRef

159CopyLoc[28](loc15: &mut Position)

160ImmBorrowField[7](Position.tick_upper_index: I32)

161ReadRef

162StLoc[21](loc8: I32)

163StLoc[20](loc7: I32)

164StLoc[19](loc6: address)

165FreezeRef

166MoveLoc[19](loc6: address)

167MoveLoc[20](loc7: I32)

168MoveLoc[21](loc8: I32)

169Call pool::get_position_key_fix<Ty0, Ty1, Ty2>(&Pool<Ty0, Ty1, Ty2>, address, I32, I32): String

170StLoc[29](loc16: String)

171CopyLoc[0](Arg0: &mut Pool<Ty0, Ty1, Ty2>)

172MoveLoc[29](loc16: String)

173MoveLoc[28](loc15: &mut Position)

174StLoc[14](loc1: &mut Position)

175StLoc[13](loc0: String)

176FreezeRef

177MoveLoc[13](loc0: String)

178MoveLoc[14](loc1: &mut Position)

179Call copy_position<Ty0, Ty1, Ty2>(&Pool<Ty0, Ty1, Ty2>, String, &mut Position)

180MoveLoc[0](Arg0: &mut Pool<Ty0, Ty1, Ty2>)

181FreezeRef

182Call object::id<Pool<Ty0, Ty1, Ty2>>(&Pool<Ty0, Ty1, Ty2>): ID

183MoveLoc[22](loc9: u64)

184MoveLoc[23](loc10: u64)

185MoveLoc[26](loc13: u128)

186Pack[4](IncreaseLiquidityEvent)

187Call event::emit<IncreaseLiquidityEvent>(IncreaseLiquidityEvent)

188MoveLoc[24](loc11: Coin<Ty0>)

189MoveLoc[25](loc12: Coin<Ty1>)

190Ret

}

entry public decrease_liquidity<Ty0, Ty1, Ty2>(Arg0: &mut Pool<Ty0, Ty1, Ty2>, Arg1: &mut Positions, Arg2: &mut TurbosPositionNFT, Arg3: u128, Arg4: u64, Arg5: u64, Arg6: u64, Arg7: &Clock, Arg8: &Versioned, Arg9: &mut TxContext) {

L10: loc0: Coin<Ty0>

L11: loc1: Coin<Ty1>

L12: loc2: address

B0:

0CopyLoc[8](Arg8: &Versioned)

1Call pool::check_version(&Versioned)

2MoveLoc[0](Arg0: &mut Pool<Ty0, Ty1, Ty2>)

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

4MoveLoc[2](Arg2: &mut TurbosPositionNFT)

5MoveLoc[3](Arg3: u128)

6MoveLoc[4](Arg4: u64)

7MoveLoc[5](Arg5: u64)

8MoveLoc[6](Arg6: u64)

9MoveLoc[7](Arg7: &Clock)

10MoveLoc[8](Arg8: &Versioned)

11CopyLoc[9](Arg9: &mut TxContext)

12Call decrease_liquidity_with_return_<Ty0, Ty1, Ty2>(&mut Pool<Ty0, Ty1, Ty2>, &mut Positions, &mut TurbosPositionNFT, u128, u64, u64, u64, &Clock, &Versioned, &mut TxContext): Coin<Ty0> * Coin<Ty1>

13StLoc[11](loc1: Coin<Ty1>)

14StLoc[10](loc0: Coin<Ty0>)

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

16FreezeRef

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

18StLoc[12](loc2: address)

19MoveLoc[10](loc0: Coin<Ty0>)

20CopyLoc[12](loc2: address)

21Call transfer::public_transfer<Coin<Ty0>>(Coin<Ty0>, address)

22MoveLoc[11](loc1: Coin<Ty1>)

23MoveLoc[12](loc2: address)

24Call transfer::public_transfer<Coin<Ty1>>(Coin<Ty1>, address)

25Ret

}

public decrease_liquidity_with_return_<Ty0, Ty1, Ty2>(Arg0: &mut Pool<Ty0, Ty1, Ty2>, Arg1: &mut Positions, Arg2: &mut TurbosPositionNFT, Arg3: u128, Arg4: u64, Arg5: u64, Arg6: u64, Arg7: &Clock, Arg8: &Versioned, Arg9: &mut TxContext): Coin<Ty0> * Coin<Ty1> {

L10: loc0: String

L11: loc1: &mut Position

L12: loc2: address

L13: loc3: I32

L14: loc4: I32

L15: loc5: bool

L16: loc6: address

L17: loc7: I32

L18: loc8: I32

L19: loc9: u64

L20: loc10: u64

L21: loc11: Coin<Ty0>

L22: loc12: Coin<Ty1>

L23: loc13: address

L24: loc14: &mut Position

L25: loc15: String

L26: loc16: address

L27: loc17: address

B0:

0MoveLoc[8](Arg8: &Versioned)

1Call pool::check_version(&Versioned)

2CopyLoc[0](Arg0: &mut Pool<Ty0, Ty1, Ty2>)

3FreezeRef

4Call object::id<Pool<Ty0, Ty1, Ty2>>(&Pool<Ty0, Ty1, Ty2>): ID

5CopyLoc[2](Arg2: &mut TurbosPositionNFT)

6FreezeRef

7Call position_nft::pool_id(&TurbosPositionNFT): ID

8Eq

9BrFalse(11)

B1:

10Branch(23)

B2:

11MoveLoc[1](Arg1: &mut Positions)

12Pop

13MoveLoc[0](Arg0: &mut Pool<Ty0, Ty1, Ty2>)

14Pop

15MoveLoc[2](Arg2: &mut TurbosPositionNFT)

16Pop

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

18Pop

19MoveLoc[7](Arg7: &Clock)

20Pop

21LdConst[10](u64: 15)

22Abort

B3:

23CopyLoc[7](Arg7: &Clock)

24Call clock::timestamp_ms(&Clock): u64

25MoveLoc[6](Arg6: u64)

26Le

27BrFalse(29)

B4:

28Branch(41)

B5:

29MoveLoc[1](Arg1: &mut Positions)

30Pop

31MoveLoc[0](Arg0: &mut Pool<Ty0, Ty1, Ty2>)

32Pop

33MoveLoc[2](Arg2: &mut TurbosPositionNFT)

34Pop

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

36Pop

37MoveLoc[7](Arg7: &Clock)

38Pop

39LdConst[4](u64: 8)

40Abort

B6:

41MoveLoc[2](Arg2: &mut TurbosPositionNFT)

42FreezeRef

43Call object::id_address<TurbosPositionNFT>(&TurbosPositionNFT): address

44StLoc[23](loc13: address)

45CopyLoc[9](Arg9: &mut TxContext)

46FreezeRef

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

48StLoc[27](loc17: address)

49MoveLoc[1](Arg1: &mut Positions)

50MutBorrowField[0](Positions.id: UID)

51CopyLoc[23](loc13: address)

52Call dynamic_object_field::borrow_mut<address, Position>(&mut UID, address): &mut Position

53StLoc[24](loc14: &mut Position)

54CopyLoc[24](loc14: &mut Position)

55ImmBorrowField[1](Position.liquidity: u128)

56ReadRef

57CopyLoc[3](Arg3: u128)

58Ge

59BrFalse(61)

B7:

60Branch(71)

B8:

61MoveLoc[24](loc14: &mut Position)

62Pop

63MoveLoc[0](Arg0: &mut Pool<Ty0, Ty1, Ty2>)

64Pop

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

66Pop

67MoveLoc[7](Arg7: &Clock)

68Pop

69LdConst[5](u64: 9)

70Abort

B9:

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

72CopyLoc[23](loc13: address)

73CopyLoc[24](loc14: &mut Position)

74ImmBorrowField[6](Position.tick_lower_index: I32)

75ReadRef

76CopyLoc[24](loc14: &mut Position)

77ImmBorrowField[7](Position.tick_upper_index: I32)

78ReadRef

79StLoc[14](loc4: I32)

80StLoc[13](loc3: I32)

81StLoc[12](loc2: address)

82FreezeRef

83MoveLoc[12](loc2: address)

84MoveLoc[13](loc3: I32)

85MoveLoc[14](loc4: I32)

86Call pool::check_position_exists<Ty0, Ty1, Ty2>(&Pool<Ty0, Ty1, Ty2>, address, I32, I32): bool

87BrFalse(91)

B10:

88MoveLoc[23](loc13: address)

89StLoc[26](loc16: address)

90Branch(93)

B11:

91MoveLoc[27](loc17: address)

92StLoc[26](loc16: address)

B12:

93CopyLoc[0](Arg0: &mut Pool<Ty0, Ty1, Ty2>)

94CopyLoc[26](loc16: address)

95CopyLoc[24](loc14: &mut Position)

96ImmBorrowField[6](Position.tick_lower_index: I32)

97ReadRef

98CopyLoc[24](loc14: &mut Position)

99ImmBorrowField[7](Position.tick_upper_index: I32)

100ReadRef

101CopyLoc[3](Arg3: u128)

102MoveLoc[7](Arg7: &Clock)

103CopyLoc[9](Arg9: &mut TxContext)

104Call pool::burn<Ty0, Ty1, Ty2>(&mut Pool<Ty0, Ty1, Ty2>, address, I32, I32, u128, &Clock, &mut TxContext): u64 * u64

105StLoc[20](loc10: u64)

106StLoc[19](loc9: u64)

107CopyLoc[19](loc9: u64)

108MoveLoc[4](Arg4: u64)

109Ge

110BrFalse(116)

B13:

111CopyLoc[20](loc10: u64)

112MoveLoc[5](Arg5: u64)

113Ge

114StLoc[15](loc5: bool)

115Branch(118)

B14:

116LdFalse

117StLoc[15](loc5: bool)

B15:

118MoveLoc[15](loc5: bool)

119BrFalse(121)

B16:

120Branch(129)

B17:

121MoveLoc[24](loc14: &mut Position)

122Pop

123MoveLoc[0](Arg0: &mut Pool<Ty0, Ty1, Ty2>)

124Pop

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

126Pop

127LdConst[1](u64: 5)

128Abort

B18:

129CopyLoc[0](Arg0: &mut Pool<Ty0, Ty1, Ty2>)

130MoveLoc[26](loc16: address)

131CopyLoc[24](loc14: &mut Position)

132ImmBorrowField[6](Position.tick_lower_index: I32)

133ReadRef

134CopyLoc[24](loc14: &mut Position)

135ImmBorrowField[7](Position.tick_upper_index: I32)

136ReadRef

137StLoc[18](loc8: I32)

138StLoc[17](loc7: I32)

139StLoc[16](loc6: address)

140FreezeRef

141MoveLoc[16](loc6: address)

142MoveLoc[17](loc7: I32)

143MoveLoc[18](loc8: I32)

144Call pool::get_position_key_fix<Ty0, Ty1, Ty2>(&Pool<Ty0, Ty1, Ty2>, address, I32, I32): String

145StLoc[25](loc15: String)

146CopyLoc[0](Arg0: &mut Pool<Ty0, Ty1, Ty2>)

147MoveLoc[25](loc15: String)

148MoveLoc[24](loc14: &mut Position)

149StLoc[11](loc1: &mut Position)

150StLoc[10](loc0: String)

151FreezeRef

152MoveLoc[10](loc0: String)

153MoveLoc[11](loc1: &mut Position)

154Call copy_position<Ty0, Ty1, Ty2>(&Pool<Ty0, Ty1, Ty2>, String, &mut Position)

155CopyLoc[0](Arg0: &mut Pool<Ty0, Ty1, Ty2>)

156CopyLoc[19](loc9: u64)

157CopyLoc[20](loc10: u64)

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

159Call pool::split_out_and_return_<Ty0, Ty1, Ty2>(&mut Pool<Ty0, Ty1, Ty2>, u64, u64, &mut TxContext): Coin<Ty0> * Coin<Ty1>

160StLoc[22](loc12: Coin<Ty1>)

161StLoc[21](loc11: Coin<Ty0>)

162MoveLoc[0](Arg0: &mut Pool<Ty0, Ty1, Ty2>)

163FreezeRef

164Call object::id<Pool<Ty0, Ty1, Ty2>>(&Pool<Ty0, Ty1, Ty2>): ID

165MoveLoc[19](loc9: u64)

166MoveLoc[20](loc10: u64)

167MoveLoc[3](Arg3: u128)

168Pack[5](DecreaseLiquidityEvent)

169Call event::emit<DecreaseLiquidityEvent>(DecreaseLiquidityEvent)

170MoveLoc[21](loc11: Coin<Ty0>)

171MoveLoc[22](loc12: Coin<Ty1>)

172Ret

}

entry public collect<Ty0, Ty1, Ty2>(Arg0: &mut Pool<Ty0, Ty1, Ty2>, Arg1: &mut Positions, Arg2: &mut TurbosPositionNFT, Arg3: u64, Arg4: u64, Arg5: address, Arg6: u64, Arg7: &Clock, Arg8: &Versioned, Arg9: &mut TxContext) {

L10: loc0: Coin<Ty1>

B0:

0CopyLoc[8](Arg8: &Versioned)

1Call pool::check_version(&Versioned)

2MoveLoc[0](Arg0: &mut Pool<Ty0, Ty1, Ty2>)

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

4MoveLoc[2](Arg2: &mut TurbosPositionNFT)

5MoveLoc[3](Arg3: u64)

6MoveLoc[4](Arg4: u64)

7CopyLoc[5](Arg5: address)

8MoveLoc[6](Arg6: u64)

9MoveLoc[7](Arg7: &Clock)

10MoveLoc[8](Arg8: &Versioned)

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

12Call collect_with_return_<Ty0, Ty1, Ty2>(&mut Pool<Ty0, Ty1, Ty2>, &mut Positions, &mut TurbosPositionNFT, u64, u64, address, u64, &Clock, &Versioned, &mut TxContext): Coin<Ty0> * Coin<Ty1>

13StLoc[10](loc0: Coin<Ty1>)

14CopyLoc[5](Arg5: address)

15Call transfer::public_transfer<Coin<Ty0>>(Coin<Ty0>, address)

16MoveLoc[10](loc0: Coin<Ty1>)

17MoveLoc[5](Arg5: address)

18Call transfer::public_transfer<Coin<Ty1>>(Coin<Ty1>, address)

19Ret

}

public collect_with_return_<Ty0, Ty1, Ty2>(Arg0: &mut Pool<Ty0, Ty1, Ty2>, Arg1: &mut Positions, Arg2: &mut TurbosPositionNFT, Arg3: u64, Arg4: u64, Arg5: address, Arg6: u64, Arg7: &Clock, Arg8: &Versioned, Arg9: &mut TxContext): Coin<Ty0> * Coin<Ty1> {

L10: loc0: String

L11: loc1: &mut Position

L12: loc2: u64

L13: loc3: u64

L14: loc4: u64

L15: loc5: address

L16: loc6: I32

L17: loc7: I32

L18: loc8: address

L19: loc9: I32

L20: loc10: I32

L21: loc11: u64

L22: loc12: u64

L23: loc13: u64

L24: loc14: u64

L25: loc15: Coin<Ty0>

L26: loc16: Coin<Ty1>

L27: loc17: address

L28: loc18: &mut Position

L29: loc19: String

L30: loc20: address

L31: loc21: address

L32: loc22: u64

L33: loc23: u64

B0:

0MoveLoc[8](Arg8: &Versioned)

1Call pool::check_version(&Versioned)

2CopyLoc[0](Arg0: &mut Pool<Ty0, Ty1, Ty2>)

3FreezeRef

4Call object::id<Pool<Ty0, Ty1, Ty2>>(&Pool<Ty0, Ty1, Ty2>): ID

5CopyLoc[2](Arg2: &mut TurbosPositionNFT)

6FreezeRef

7Call position_nft::pool_id(&TurbosPositionNFT): ID

8Eq

9BrFalse(11)

B1:

10Branch(23)

B2:

11MoveLoc[1](Arg1: &mut Positions)

12Pop

13MoveLoc[0](Arg0: &mut Pool<Ty0, Ty1, Ty2>)

14Pop

15MoveLoc[2](Arg2: &mut TurbosPositionNFT)

16Pop

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

18Pop

19MoveLoc[7](Arg7: &Clock)

20Pop

21LdConst[10](u64: 15)

22Abort

B3:

23CopyLoc[7](Arg7: &Clock)

24Call clock::timestamp_ms(&Clock): u64

25MoveLoc[6](Arg6: u64)

26Le

27BrFalse(29)

B4:

28Branch(41)

B5:

29MoveLoc[1](Arg1: &mut Positions)

30Pop

31MoveLoc[0](Arg0: &mut Pool<Ty0, Ty1, Ty2>)

32Pop

33MoveLoc[2](Arg2: &mut TurbosPositionNFT)

34Pop

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

36Pop

37MoveLoc[7](Arg7: &Clock)

38Pop

39LdConst[4](u64: 8)

40Abort

B6:

41MoveLoc[2](Arg2: &mut TurbosPositionNFT)

42FreezeRef

43Call object::id_address<TurbosPositionNFT>(&TurbosPositionNFT): address

44StLoc[27](loc17: address)

45CopyLoc[9](Arg9: &mut TxContext)

46FreezeRef

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

48StLoc[31](loc21: address)

49MoveLoc[1](Arg1: &mut Positions)

50MutBorrowField[0](Positions.id: UID)

51CopyLoc[27](loc17: address)

52Call dynamic_object_field::borrow_mut<address, Position>(&mut UID, address): &mut Position

53StLoc[28](loc18: &mut Position)

54CopyLoc[0](Arg0: &mut Pool<Ty0, Ty1, Ty2>)

55CopyLoc[27](loc17: address)

56CopyLoc[28](loc18: &mut Position)

57ImmBorrowField[6](Position.tick_lower_index: I32)

58ReadRef

59CopyLoc[28](loc18: &mut Position)

60ImmBorrowField[7](Position.tick_upper_index: I32)

61ReadRef

62StLoc[17](loc7: I32)

63StLoc[16](loc6: I32)

64StLoc[15](loc5: address)

65FreezeRef

66MoveLoc[15](loc5: address)

67MoveLoc[16](loc6: I32)

68MoveLoc[17](loc7: I32)

69Call pool::check_position_exists<Ty0, Ty1, Ty2>(&Pool<Ty0, Ty1, Ty2>, address, I32, I32): bool

70BrFalse(74)

B7:

71MoveLoc[27](loc17: address)

72StLoc[30](loc20: address)

73Branch(76)

B8:

74MoveLoc[31](loc21: address)

75StLoc[30](loc20: address)

B9:

76CopyLoc[28](loc18: &mut Position)

77ImmBorrowField[1](Position.liquidity: u128)

78ReadRef

79LdU128(0)

80Gt

81BrFalse(123)

B10:

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

83CopyLoc[30](loc20: address)

84CopyLoc[28](loc18: &mut Position)

85ImmBorrowField[6](Position.tick_lower_index: I32)

86ReadRef

87CopyLoc[28](loc18: &mut Position)

88ImmBorrowField[7](Position.tick_upper_index: I32)

89ReadRef

90LdU128(0)

91MoveLoc[7](Arg7: &Clock)

92CopyLoc[9](Arg9: &mut TxContext)

93Call pool::burn<Ty0, Ty1, Ty2>(&mut Pool<Ty0, Ty1, Ty2>, address, I32, I32, u128, &Clock, &mut TxContext): u64 * u64

94Pop

95Pop

96CopyLoc[0](Arg0: &mut Pool<Ty0, Ty1, Ty2>)

97CopyLoc[30](loc20: address)

98CopyLoc[28](loc18: &mut Position)

99ImmBorrowField[6](Position.tick_lower_index: I32)

100ReadRef

101CopyLoc[28](loc18: &mut Position)

102ImmBorrowField[7](Position.tick_upper_index: I32)

103ReadRef

104StLoc[20](loc10: I32)

105StLoc[19](loc9: I32)

106StLoc[18](loc8: address)

107FreezeRef

108MoveLoc[18](loc8: address)

109MoveLoc[19](loc9: I32)

110MoveLoc[20](loc10: I32)

111Call pool::get_position_key_fix<Ty0, Ty1, Ty2>(&Pool<Ty0, Ty1, Ty2>, address, I32, I32): String

112StLoc[29](loc19: String)

113CopyLoc[0](Arg0: &mut Pool<Ty0, Ty1, Ty2>)

114MoveLoc[29](loc19: String)

115CopyLoc[28](loc18: &mut Position)

116StLoc[11](loc1: &mut Position)

117StLoc[10](loc0: String)

118FreezeRef

119MoveLoc[10](loc0: String)

120MoveLoc[11](loc1: &mut Position)

121Call copy_position<Ty0, Ty1, Ty2>(&Pool<Ty0, Ty1, Ty2>, String, &mut Position)

122Branch(125)

B11:

123MoveLoc[7](Arg7: &Clock)

124Pop

B12:

125CopyLoc[28](loc18: &mut Position)

126ImmBorrowField[2](Position.tokens_owed_a: u64)

127ReadRef

128CopyLoc[28](loc18: &mut Position)

129ImmBorrowField[3](Position.tokens_owed_b: u64)

130ReadRef

131StLoc[33](loc23: u64)

132StLoc[32](loc22: u64)

133CopyLoc[3](Arg3: u64)

134CopyLoc[32](loc22: u64)

135Gt

136BrFalse(140)

B13:

137MoveLoc[32](loc22: u64)

138StLoc[13](loc3: u64)

139Branch(142)

B14:

140MoveLoc[3](Arg3: u64)

141StLoc[13](loc3: u64)

B15:

142MoveLoc[13](loc3: u64)

143StLoc[14](loc4: u64)

144CopyLoc[4](Arg4: u64)

145CopyLoc[33](loc23: u64)

146Gt

147BrFalse(151)

B16:

148MoveLoc[33](loc23: u64)

149StLoc[12](loc2: u64)

150Branch(153)

B17:

151MoveLoc[4](Arg4: u64)

152StLoc[12](loc2: u64)

B18:

153MoveLoc[14](loc4: u64)

154MoveLoc[12](loc2: u64)

155StLoc[24](loc14: u64)

156StLoc[22](loc12: u64)

157CopyLoc[0](Arg0: &mut Pool<Ty0, Ty1, Ty2>)

158MoveLoc[5](Arg5: address)

159MoveLoc[30](loc20: address)

160CopyLoc[28](loc18: &mut Position)

161ImmBorrowField[6](Position.tick_lower_index: I32)

162ReadRef

163CopyLoc[28](loc18: &mut Position)

164ImmBorrowField[7](Position.tick_upper_index: I32)

165ReadRef

166CopyLoc[22](loc12: u64)

167CopyLoc[24](loc14: u64)

168CopyLoc[9](Arg9: &mut TxContext)

169Call pool::collect_v2<Ty0, Ty1, Ty2>(&mut Pool<Ty0, Ty1, Ty2>, address, address, I32, I32, u64, u64, &mut TxContext): u64 * u64

170StLoc[23](loc13: u64)

171StLoc[21](loc11: u64)

172MoveLoc[0](Arg0: &mut Pool<Ty0, Ty1, Ty2>)

173MoveLoc[21](loc11: u64)

174MoveLoc[23](loc13: u64)

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

176Call pool::split_out_and_return_<Ty0, Ty1, Ty2>(&mut Pool<Ty0, Ty1, Ty2>, u64, u64, &mut TxContext): Coin<Ty0> * Coin<Ty1>

177StLoc[26](loc16: Coin<Ty1>)

178StLoc[25](loc15: Coin<Ty0>)

179CopyLoc[28](loc18: &mut Position)

180ImmBorrowField[2](Position.tokens_owed_a: u64)

181ReadRef

182MoveLoc[22](loc12: u64)

183Sub

184CopyLoc[28](loc18: &mut Position)

185MutBorrowField[2](Position.tokens_owed_a: u64)

186WriteRef

187CopyLoc[28](loc18: &mut Position)

188ImmBorrowField[3](Position.tokens_owed_b: u64)

189ReadRef

190MoveLoc[24](loc14: u64)

191Sub

192MoveLoc[28](loc18: &mut Position)

193MutBorrowField[3](Position.tokens_owed_b: u64)

194WriteRef

195MoveLoc[25](loc15: Coin<Ty0>)

196MoveLoc[26](loc16: Coin<Ty1>)

197Ret

}

entry public collect_reward<Ty0, Ty1, Ty2, Ty3>(Arg0: &mut Pool<Ty0, Ty1, Ty2>, Arg1: &mut Positions, Arg2: &mut TurbosPositionNFT, Arg3: &mut PoolRewardVault<Ty3>, Arg4: u64, Arg5: u64, Arg6: address, Arg7: u64, Arg8: &Clock, Arg9: &Versioned, Arg10: &mut TxContext) {

B0:

0CopyLoc[9](Arg9: &Versioned)

1Call pool::check_version(&Versioned)

2MoveLoc[0](Arg0: &mut Pool<Ty0, Ty1, Ty2>)

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

4MoveLoc[2](Arg2: &mut TurbosPositionNFT)

5MoveLoc[3](Arg3: &mut PoolRewardVault<Ty3>)

6MoveLoc[4](Arg4: u64)

7MoveLoc[5](Arg5: u64)

8CopyLoc[6](Arg6: address)

9MoveLoc[7](Arg7: u64)

10MoveLoc[8](Arg8: &Clock)

11MoveLoc[9](Arg9: &Versioned)

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

13Call collect_reward_with_return_<Ty0, Ty1, Ty2, Ty3>(&mut Pool<Ty0, Ty1, Ty2>, &mut Positions, &mut TurbosPositionNFT, &mut PoolRewardVault<Ty3>, u64, u64, address, u64, &Clock, &Versioned, &mut TxContext): Coin<Ty3>

14MoveLoc[6](Arg6: address)

15Call transfer::public_transfer<Coin<Ty3>>(Coin<Ty3>, address)

16Ret

}

public collect_reward_with_return_<Ty0, Ty1, Ty2, Ty3>(Arg0: &mut Pool<Ty0, Ty1, Ty2>, Arg1: &mut Positions, Arg2: &mut TurbosPositionNFT, Arg3: &mut PoolRewardVault<Ty3>, Arg4: u64, Arg5: u64, Arg6: address, Arg7: u64, Arg8: &Clock, Arg9: &Versioned, Arg10: &mut TxContext): Coin<Ty3> {

L11: loc0: String

L12: loc1: &mut Position

L13: loc2: u64

L14: loc3: address

L15: loc4: I32

L16: loc5: I32

L17: loc6: address

L18: loc7: I32

L19: loc8: I32

L20: loc9: u64

L21: loc10: Coin<Ty3>

L22: loc11: address

L23: loc12: &mut Position

L24: loc13: String

L25: loc14: address

L26: loc15: &mut PositionRewardInfo

L27: loc16: address

B0:

0MoveLoc[9](Arg9: &Versioned)

1Call pool::check_version(&Versioned)

2CopyLoc[0](Arg0: &mut Pool<Ty0, Ty1, Ty2>)

3FreezeRef

4Call object::id<Pool<Ty0, Ty1, Ty2>>(&Pool<Ty0, Ty1, Ty2>): ID

5CopyLoc[2](Arg2: &mut TurbosPositionNFT)

6FreezeRef

7Call position_nft::pool_id(&TurbosPositionNFT): ID

8Eq

9BrFalse(11)

B1:

10Branch(25)

B2:

11MoveLoc[3](Arg3: &mut PoolRewardVault<Ty3>)

12Pop

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

14Pop

15MoveLoc[0](Arg0: &mut Pool<Ty0, Ty1, Ty2>)

16Pop

17MoveLoc[2](Arg2: &mut TurbosPositionNFT)

18Pop

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

20Pop

21MoveLoc[8](Arg8: &Clock)

22Pop

23LdConst[10](u64: 15)

24Abort

B3:

25CopyLoc[8](Arg8: &Clock)

26Call clock::timestamp_ms(&Clock): u64

27MoveLoc[7](Arg7: u64)

28Le

29BrFalse(31)

B4:

30Branch(45)

B5:

31MoveLoc[3](Arg3: &mut PoolRewardVault<Ty3>)

32Pop

33MoveLoc[1](Arg1: &mut Positions)

34Pop

35MoveLoc[0](Arg0: &mut Pool<Ty0, Ty1, Ty2>)

36Pop

37MoveLoc[2](Arg2: &mut TurbosPositionNFT)

38Pop

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

40Pop

41MoveLoc[8](Arg8: &Clock)

42Pop

43LdConst[4](u64: 8)

44Abort

B6:

45MoveLoc[2](Arg2: &mut TurbosPositionNFT)

46FreezeRef

47Call object::id_address<TurbosPositionNFT>(&TurbosPositionNFT): address

48StLoc[22](loc11: address)

49CopyLoc[10](Arg10: &mut TxContext)

50FreezeRef

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

52StLoc[27](loc16: address)

53MoveLoc[1](Arg1: &mut Positions)

54MutBorrowField[0](Positions.id: UID)

55CopyLoc[22](loc11: address)

56Call dynamic_object_field::borrow_mut<address, Position>(&mut UID, address): &mut Position

57StLoc[23](loc12: &mut Position)

58CopyLoc[0](Arg0: &mut Pool<Ty0, Ty1, Ty2>)

59CopyLoc[22](loc11: address)

60CopyLoc[23](loc12: &mut Position)

61ImmBorrowField[6](Position.tick_lower_index: I32)

62ReadRef

63CopyLoc[23](loc12: &mut Position)

64ImmBorrowField[7](Position.tick_upper_index: I32)

65ReadRef

66StLoc[16](loc5: I32)

67StLoc[15](loc4: I32)

68StLoc[14](loc3: address)

69FreezeRef

70MoveLoc[14](loc3: address)

71MoveLoc[15](loc4: I32)

72MoveLoc[16](loc5: I32)

73Call pool::check_position_exists<Ty0, Ty1, Ty2>(&Pool<Ty0, Ty1, Ty2>, address, I32, I32): bool

74BrFalse(78)

B7:

75MoveLoc[22](loc11: address)

76StLoc[25](loc14: address)

77Branch(80)

B8:

78MoveLoc[27](loc16: address)

79StLoc[25](loc14: address)

B9:

80CopyLoc[23](loc12: &mut Position)

81ImmBorrowField[1](Position.liquidity: u128)

82ReadRef

83LdU128(0)

84Gt

85BrFalse(127)

B10:

86CopyLoc[0](Arg0: &mut Pool<Ty0, Ty1, Ty2>)

87CopyLoc[25](loc14: address)

88CopyLoc[23](loc12: &mut Position)

89ImmBorrowField[6](Position.tick_lower_index: I32)

90ReadRef

91CopyLoc[23](loc12: &mut Position)

92ImmBorrowField[7](Position.tick_upper_index: I32)

93ReadRef

94LdU128(0)

95MoveLoc[8](Arg8: &Clock)

96CopyLoc[10](Arg10: &mut TxContext)

97Call pool::burn<Ty0, Ty1, Ty2>(&mut Pool<Ty0, Ty1, Ty2>, address, I32, I32, u128, &Clock, &mut TxContext): u64 * u64

98Pop

99Pop

100CopyLoc[0](Arg0: &mut Pool<Ty0, Ty1, Ty2>)

101CopyLoc[25](loc14: address)

102CopyLoc[23](loc12: &mut Position)

103ImmBorrowField[6](Position.tick_lower_index: I32)

104ReadRef

105CopyLoc[23](loc12: &mut Position)

106ImmBorrowField[7](Position.tick_upper_index: I32)

107ReadRef

108StLoc[19](loc8: I32)

109StLoc[18](loc7: I32)

110StLoc[17](loc6: address)

111FreezeRef

112MoveLoc[17](loc6: address)

113MoveLoc[18](loc7: I32)

114MoveLoc[19](loc8: I32)

115Call pool::get_position_key_fix<Ty0, Ty1, Ty2>(&Pool<Ty0, Ty1, Ty2>, address, I32, I32): String

116StLoc[24](loc13: String)

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

118MoveLoc[24](loc13: String)

119CopyLoc[23](loc12: &mut Position)

120StLoc[12](loc1: &mut Position)

121StLoc[11](loc0: String)

122FreezeRef

123MoveLoc[11](loc0: String)

124MoveLoc[12](loc1: &mut Position)

125Call copy_position<Ty0, Ty1, Ty2>(&Pool<Ty0, Ty1, Ty2>, String, &mut Position)

126Branch(129)

B11:

127MoveLoc[8](Arg8: &Clock)

128Pop

B12:

129CopyLoc[4](Arg4: u64)

130CopyLoc[23](loc12: &mut Position)

131ImmBorrowField[4](Position.reward_infos: vector<PositionRewardInfo>)

132VecLen(65)

133Lt

134BrFalse(136)

B13:

135Branch(146)

B14:

136MoveLoc[3](Arg3: &mut PoolRewardVault<Ty3>)

137Pop

138MoveLoc[23](loc12: &mut Position)

139Pop

140MoveLoc[0](Arg0: &mut Pool<Ty0, Ty1, Ty2>)

141Pop

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

143Pop

144LdConst[6](u64: 10)

145Abort

B15:

146CopyLoc[23](loc12: &mut Position)

147MutBorrowField[4](Position.reward_infos: vector<PositionRewardInfo>)

148CopyLoc[4](Arg4: u64)

149VecMutBorrow(65)

150StLoc[26](loc15: &mut PositionRewardInfo)

151CopyLoc[5](Arg5: u64)

152CopyLoc[26](loc15: &mut PositionRewardInfo)

153ImmBorrowField[5](PositionRewardInfo.amount_owed: u64)

154ReadRef

155Gt

156BrFalse(162)

B16:

157CopyLoc[26](loc15: &mut PositionRewardInfo)

158ImmBorrowField[5](PositionRewardInfo.amount_owed: u64)

159ReadRef

160StLoc[13](loc2: u64)

161Branch(164)

B17:

162MoveLoc[5](Arg5: u64)

163StLoc[13](loc2: u64)

B18:

164MoveLoc[13](loc2: u64)

165StLoc[20](loc9: u64)

166MoveLoc[0](Arg0: &mut Pool<Ty0, Ty1, Ty2>)

167MoveLoc[3](Arg3: &mut PoolRewardVault<Ty3>)

168MoveLoc[6](Arg6: address)

169MoveLoc[25](loc14: address)

170CopyLoc[23](loc12: &mut Position)

171ImmBorrowField[6](Position.tick_lower_index: I32)

172ReadRef

173MoveLoc[23](loc12: &mut Position)

174ImmBorrowField[7](Position.tick_upper_index: I32)

175ReadRef

176CopyLoc[20](loc9: u64)

177MoveLoc[4](Arg4: u64)

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

179Call pool::collect_reward_with_return_<Ty0, Ty1, Ty2, Ty3>(&mut Pool<Ty0, Ty1, Ty2>, &mut PoolRewardVault<Ty3>, address, address, I32, I32, u64, u64, &mut TxContext): Coin<Ty3>

180StLoc[21](loc10: Coin<Ty3>)

181ImmBorrowLoc[21](loc10: Coin<Ty3>)

182Call coin::value<Ty3>(&Coin<Ty3>): u64

183Pop

184CopyLoc[26](loc15: &mut PositionRewardInfo)

185ImmBorrowField[5](PositionRewardInfo.amount_owed: u64)

186ReadRef

187MoveLoc[20](loc9: u64)

188Sub

189MoveLoc[26](loc15: &mut PositionRewardInfo)

190MutBorrowField[5](PositionRewardInfo.amount_owed: u64)

191WriteRef

192MoveLoc[21](loc10: Coin<Ty3>)

193Ret

}

public burn_position_nft_with_return_<Ty0, Ty1, Ty2>(Arg0: &mut Pool<Ty0, Ty1, Ty2>, Arg1: &mut Positions, Arg2: TurbosPositionNFT, Arg3: &Versioned, Arg4: &mut TxContext): TurbosPositionBurnNFT {

L5: loc0: TurbosPositionBurnNFT

L6: loc1: I32

L7: loc2: address

L8: loc3: ID

L9: loc4: ID

L10: loc5: &mut Position

L11: loc6: u32

B0:

0MoveLoc[3](Arg3: &Versioned)

1Call pool::check_version(&Versioned)

2ImmBorrowLoc[2](Arg2: TurbosPositionNFT)

3Call position_nft::pool_id(&TurbosPositionNFT): ID

4StLoc[8](loc3: ID)

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

6FreezeRef

7Call object::id<Pool<Ty0, Ty1, Ty2>>(&Pool<Ty0, Ty1, Ty2>): ID

8ImmBorrowLoc[2](Arg2: TurbosPositionNFT)

9Call position_nft::pool_id(&TurbosPositionNFT): ID

10Eq

11BrFalse(13)

B1:

12Branch(21)

B2:

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

14Pop

15MoveLoc[0](Arg0: &mut Pool<Ty0, Ty1, Ty2>)

16Pop

17MoveLoc[4](Arg4: &mut TxContext)

18Pop

19LdConst[10](u64: 15)

20Abort

B3:

21ImmBorrowLoc[2](Arg2: TurbosPositionNFT)

22Call object::id_address<TurbosPositionNFT>(&TurbosPositionNFT): address

23StLoc[7](loc2: address)

24MoveLoc[1](Arg1: &mut Positions)

25MutBorrowField[0](Positions.id: UID)

26CopyLoc[7](loc2: address)

27Call dynamic_object_field::borrow_mut<address, Position>(&mut UID, address): &mut Position

28StLoc[10](loc5: &mut Position)

29MoveLoc[0](Arg0: &mut Pool<Ty0, Ty1, Ty2>)

30FreezeRef

31Call pool::get_pool_tick_spacing<Ty0, Ty1, Ty2>(&Pool<Ty0, Ty1, Ty2>): u32

32StLoc[11](loc6: u32)

33LdConst[12](u32: 443636)

34MoveLoc[11](loc6: u32)

35Mod

36Call i32::from(u32): I32

37StLoc[6](loc1: I32)

38CopyLoc[10](loc5: &mut Position)

39ImmBorrowField[6](Position.tick_lower_index: I32)

40ReadRef

41CopyLoc[6](loc1: I32)

42Call i32::sub(I32, I32): I32

43LdConst[12](u32: 443636)

44Call i32::neg_from(u32): I32

45Call i32::eq(I32, I32): bool

46BrFalse(48)

B4:

47Branch(54)

B5:

48MoveLoc[10](loc5: &mut Position)

49Pop

50MoveLoc[4](Arg4: &mut TxContext)

51Pop

52LdConst[11](u64: 16)

53Abort

B6:

54MoveLoc[10](loc5: &mut Position)

55ImmBorrowField[7](Position.tick_upper_index: I32)

56ReadRef

57MoveLoc[6](loc1: I32)

58Call i32::add(I32, I32): I32

59LdConst[12](u32: 443636)

60Call i32::from(u32): I32

61Call i32::eq(I32, I32): bool

62BrFalse(64)

B7:

63Branch(68)

B8:

64MoveLoc[4](Arg4: &mut TxContext)

65Pop

66LdConst[11](u64: 16)

67Abort

B9:

68ImmBorrowLoc[2](Arg2: TurbosPositionNFT)

69Call position_nft::position_id(&TurbosPositionNFT): ID

70StLoc[9](loc4: ID)

71MoveLoc[4](Arg4: &mut TxContext)

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

73LdConst[16](vector<u8>: "Pro..)

74Call string::utf8(vector<u8>): String

75LdConst[16](vector<u8>: "Pro..)

76Call string::utf8(vector<u8>): String

77LdConst[17](vector<u8>: "htt..)

78Call string::utf8(vector<u8>): String

79Call string::to_ascii(String): String

80Call url::new_unsafe(String): Url

81MoveLoc[2](Arg2: TurbosPositionNFT)

82CopyLoc[9](loc4: ID)

83CopyLoc[8](loc3: ID)

84Call type_name::get<Ty0>(): TypeName

85Call type_name::get<Ty1>(): TypeName

86Call type_name::get<Ty2>(): TypeName

87Pack[0](TurbosPositionBurnNFT)

88StLoc[5](loc0: TurbosPositionBurnNFT)

89MoveLoc[7](loc2: address)

90MoveLoc[9](loc4: ID)

91MoveLoc[8](loc3: ID)

92ImmBorrowLoc[5](loc0: TurbosPositionBurnNFT)

93Call object::id_address<TurbosPositionBurnNFT>(&TurbosPositionBurnNFT): address

94Pack[8](BurnPositionEvent)

95Call event::emit<BurnPositionEvent>(BurnPositionEvent)

96MoveLoc[5](loc0: TurbosPositionBurnNFT)

97Ret

}

public burn_nft_collect_reward_with_return_<Ty0, Ty1, Ty2, Ty3>(Arg0: &mut Pool<Ty0, Ty1, Ty2>, Arg1: &mut Positions, Arg2: &mut TurbosPositionBurnNFT, Arg3: &mut PoolRewardVault<Ty3>, Arg4: u64, Arg5: u64, Arg6: u64, Arg7: &Clock, Arg8: &Versioned, Arg9: &mut TxContext): Coin<Ty3> {

B0:

0CopyLoc[8](Arg8: &Versioned)

1Call pool::check_version(&Versioned)

2MoveLoc[0](Arg0: &mut Pool<Ty0, Ty1, Ty2>)

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

4MoveLoc[2](Arg2: &mut TurbosPositionBurnNFT)

5MutBorrowField[8](TurbosPositionBurnNFT.position_nft: TurbosPositionNFT)

6MoveLoc[3](Arg3: &mut PoolRewardVault<Ty3>)

7MoveLoc[4](Arg4: u64)

8MoveLoc[5](Arg5: u64)

9LdConst[18](address: 0x00..)

10MoveLoc[6](Arg6: u64)

11MoveLoc[7](Arg7: &Clock)

12MoveLoc[8](Arg8: &Versioned)

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

14Call collect_reward_with_return_<Ty0, Ty1, Ty2, Ty3>(&mut Pool<Ty0, Ty1, Ty2>, &mut Positions, &mut TurbosPositionNFT, &mut PoolRewardVault<Ty3>, u64, u64, address, u64, &Clock, &Versioned, &mut TxContext): Coin<Ty3>

15Ret

}

public burn_nft_collect_fee_with_return_<Ty0, Ty1, Ty2>(Arg0: &mut Pool<Ty0, Ty1, Ty2>, Arg1: &mut Positions, Arg2: &mut TurbosPositionBurnNFT, Arg3: u64, Arg4: u64, Arg5: u64, Arg6: &Clock, Arg7: &Versioned, Arg8: &mut TxContext): Coin<Ty0> * Coin<Ty1> {

B0:

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

1MoveLoc[1](Arg1: &mut Positions)

2MoveLoc[2](Arg2: &mut TurbosPositionBurnNFT)

3MutBorrowField[8](TurbosPositionBurnNFT.position_nft: TurbosPositionNFT)

4MoveLoc[3](Arg3: u64)

5MoveLoc[4](Arg4: u64)

6LdConst[18](address: 0x00..)

7MoveLoc[5](Arg5: u64)

8MoveLoc[6](Arg6: &Clock)

9MoveLoc[7](Arg7: &Versioned)

10MoveLoc[8](Arg8: &mut TxContext)

11Call collect_with_return_<Ty0, Ty1, Ty2>(&mut Pool<Ty0, Ty1, Ty2>, &mut Positions, &mut TurbosPositionNFT, u64, u64, address, u64, &Clock, &Versioned, &mut TxContext): Coin<Ty0> * Coin<Ty1>

12Ret

}

public(friend) decrease_liquidity_admin<Ty0, Ty1, Ty2>(Arg0: &mut Pool<Ty0, Ty1, Ty2>, Arg1: &mut Positions, Arg2: address, Arg3: u128, Arg4: u32, Arg5: bool, Arg6: u32, Arg7: bool, Arg8: address, Arg9: &Clock, Arg10: &mut TxContext) {

B0:

0LdU64(0)

1Abort

}

public(friend) migrate_position<Ty0, Ty1, Ty2>(Arg0: &mut Pool<Ty0, Ty1, Ty2>, Arg1: &mut Positions, Arg2: vector<address>, Arg3: address, Arg4: &mut TxContext) {

B0:

0LdU64(0)

1Abort

}

public(friend) modify_position_reward_inside(Arg0: &mut Positions, Arg1: address, Arg2: u64, Arg3: u128) {

L4: loc0: &mut PositionRewardInfo

B0:

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

1MutBorrowField[0](Positions.id: UID)

2MoveLoc[1](Arg1: address)

3Call dynamic_object_field::borrow_mut<address, Position>(&mut UID, address): &mut Position

4MutBorrowField[4](Position.reward_infos: vector<PositionRewardInfo>)

5MoveLoc[2](Arg2: u64)

6VecMutBorrow(65)

7StLoc[4](loc0: &mut PositionRewardInfo)

8MoveLoc[3](Arg3: u128)

9CopyLoc[4](loc0: &mut PositionRewardInfo)

10MutBorrowField[9](PositionRewardInfo.reward_growth_inside: u128)

11WriteRef

12LdU64(0)

13MoveLoc[4](loc0: &mut PositionRewardInfo)

14MutBorrowField[5](PositionRewardInfo.amount_owed: u64)

15WriteRef

16Ret

}

get_position_tick_info(Arg0: &mut Positions, Arg1: address): I32 * I32 {

L2: loc0: &Position

B0:

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

1ImmBorrowField[0](Positions.id: UID)

2MoveLoc[1](Arg1: address)

3Call dynamic_object_field::borrow<address, Position>(&UID, address): &Position

4StLoc[2](loc0: &Position)

5CopyLoc[2](loc0: &Position)

6ImmBorrowField[6](Position.tick_lower_index: I32)

7ReadRef

8MoveLoc[2](loc0: &Position)

9ImmBorrowField[7](Position.tick_upper_index: I32)

10ReadRef

11Ret

}

copy_position_with_address<Ty0, Ty1, Ty2>(Arg0: &Pool<Ty0, Ty1, Ty2>, Arg1: &mut Positions, Arg2: String, Arg3: address) {

L4: loc0: &mut Position

B0:

0MoveLoc[1](Arg1: &mut Positions)

1MutBorrowField[0](Positions.id: UID)

2MoveLoc[3](Arg3: address)

3Call dynamic_object_field::borrow_mut<address, Position>(&mut UID, address): &mut Position

4StLoc[4](loc0: &mut Position)

5MoveLoc[0](Arg0: &Pool<Ty0, Ty1, Ty2>)

6MoveLoc[2](Arg2: String)

7MoveLoc[4](loc0: &mut Position)

8Call copy_position<Ty0, Ty1, Ty2>(&Pool<Ty0, Ty1, Ty2>, String, &mut Position)

9Ret

}

clean_position(Arg0: &mut Positions, Arg1: I32, Arg2: I32, Arg3: address) {

L4: loc0: bool

L5: loc1: u64

L6: loc2: u64

L7: loc3: &mut Position

L8: loc4: &mut PositionRewardInfo

B0:

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

1MutBorrowField[0](Positions.id: UID)

2CopyLoc[3](Arg3: address)

3Call dynamic_object_field::borrow_mut<address, Position>(&mut UID, address): &mut Position

4StLoc[7](loc3: &mut Position)

5CopyLoc[7](loc3: &mut Position)

6ImmBorrowField[6](Position.tick_lower_index: I32)

7ReadRef

8MoveLoc[1](Arg1: I32)

9Call i32::eq(I32, I32): bool

10BrFalse(18)

B1:

11CopyLoc[7](loc3: &mut Position)

12ImmBorrowField[7](Position.tick_upper_index: I32)

13ReadRef

14MoveLoc[2](Arg2: I32)

15Call i32::eq(I32, I32): bool

16StLoc[4](loc0: bool)

17Branch(20)

B2:

18LdFalse

19StLoc[4](loc0: bool)

B3:

20MoveLoc[4](loc0: bool)

21BrFalse(23)

B4:

22Branch(29)

B5:

23MoveLoc[0](Arg0: &mut Positions)

24Pop

25MoveLoc[7](loc3: &mut Position)

26Pop

27LdConst[9](u64: 14)

28Abort

B6:

29LdU128(0)

30CopyLoc[7](loc3: &mut Position)

31MutBorrowField[1](Position.liquidity: u128)

32WriteRef

33Call i32::zero(): I32

34CopyLoc[7](loc3: &mut Position)

35MutBorrowField[6](Position.tick_lower_index: I32)

36WriteRef

37Call i32::zero(): I32

38CopyLoc[7](loc3: &mut Position)

39MutBorrowField[7](Position.tick_upper_index: I32)

40WriteRef

41LdU128(0)

42CopyLoc[7](loc3: &mut Position)

43MutBorrowField[10](Position.fee_growth_inside_a: u128)

44WriteRef

45LdU128(0)

46CopyLoc[7](loc3: &mut Position)

47MutBorrowField[11](Position.fee_growth_inside_b: u128)

48WriteRef

49LdU64(0)

50CopyLoc[7](loc3: &mut Position)

51MutBorrowField[2](Position.tokens_owed_a: u64)

52WriteRef

53LdU64(0)

54CopyLoc[7](loc3: &mut Position)

55MutBorrowField[3](Position.tokens_owed_b: u64)

56WriteRef

57CopyLoc[7](loc3: &mut Position)

58ImmBorrowField[4](Position.reward_infos: vector<PositionRewardInfo>)

59VecLen(65)

60StLoc[6](loc2: u64)

61LdU64(0)

62StLoc[5](loc1: u64)

B7:

63CopyLoc[5](loc1: u64)

64CopyLoc[6](loc2: u64)

65Lt

66BrFalse(86)

B8:

67Branch(68)

B9:

68CopyLoc[7](loc3: &mut Position)

69MutBorrowField[4](Position.reward_infos: vector<PositionRewardInfo>)

70CopyLoc[5](loc1: u64)

71VecMutBorrow(65)

72StLoc[8](loc4: &mut PositionRewardInfo)

73LdU128(0)

74CopyLoc[8](loc4: &mut PositionRewardInfo)

75MutBorrowField[9](PositionRewardInfo.reward_growth_inside: u128)

76WriteRef

77LdU64(0)

78MoveLoc[8](loc4: &mut PositionRewardInfo)

79MutBorrowField[5](PositionRewardInfo.amount_owed: u64)

80WriteRef

81MoveLoc[5](loc1: u64)

82LdU64(1)

83Add

84StLoc[5](loc1: u64)

85Branch(63)

B10:

86MoveLoc[7](loc3: &mut Position)

87Pop

88CopyLoc[0](Arg0: &mut Positions)

89ImmBorrowField[12](Positions.user_position: Table<address, ID>)

90CopyLoc[3](Arg3: address)

91Call table::contains<address, ID>(&Table<address, ID>, address): bool

92BrFalse(99)

B11:

93MoveLoc[0](Arg0: &mut Positions)

94MutBorrowField[12](Positions.user_position: Table<address, ID>)

95MoveLoc[3](Arg3: address)

96Call table::remove<address, ID>(&mut Table<address, ID>, address): ID

97Pop

98Branch(101)

B12:

99MoveLoc[0](Arg0: &mut Positions)

100Pop

B13:

101Ret

}

get_mut_position(Arg0: &mut Positions, Arg1: address): &mut Position {

B0:

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

1MutBorrowField[0](Positions.id: UID)

2MoveLoc[1](Arg1: address)

3Call dynamic_object_field::borrow_mut<address, Position>(&mut UID, address): &mut Position

4Ret

}

public get_position_info(Arg0: &Positions, Arg1: address): I32 * I32 * u128 {

L2: loc0: &Position

B0:

0MoveLoc[0](Arg0: &Positions)

1ImmBorrowField[0](Positions.id: UID)

2MoveLoc[1](Arg1: address)

3Call dynamic_object_field::borrow<address, Position>(&UID, address): &Position

4StLoc[2](loc0: &Position)

5CopyLoc[2](loc0: &Position)

6ImmBorrowField[6](Position.tick_lower_index: I32)

7ReadRef

8CopyLoc[2](loc0: &Position)

9ImmBorrowField[7](Position.tick_upper_index: I32)

10ReadRef

11MoveLoc[2](loc0: &Position)

12ImmBorrowField[1](Position.liquidity: u128)

13ReadRef

14Ret

}

public(friend) update_nft_name(Arg0: &mut Positions, Arg1: String) {

B0:

0MoveLoc[1](Arg1: String)

1MoveLoc[0](Arg0: &mut Positions)

2MutBorrowField[13](Positions.nft_name: String)

3WriteRef

4Ret

}

public(friend) update_nft_description(Arg0: &mut Positions, Arg1: String) {

B0:

0MoveLoc[1](Arg1: String)

1MoveLoc[0](Arg0: &mut Positions)

2MutBorrowField[14](Positions.nft_description: String)

3WriteRef

4Ret

}

public(friend) update_nft_img_url(Arg0: &mut Positions, Arg1: String) {

B0:

0MoveLoc[1](Arg1: String)

1MoveLoc[0](Arg0: &mut Positions)

2MutBorrowField[15](Positions.nft_img_url: String)

3WriteRef

4Ret

}

mint_nft<Ty0, Ty1, Ty2>(Arg0: ID, Arg1: ID, Arg2: &mut Positions, Arg3: address, Arg4: &mut TxContext): address {

L5: loc0: TurbosPositionNFT

L6: loc1: address

B0:

0MoveLoc[0](Arg0: ID)

1MoveLoc[1](Arg1: ID)

2MoveLoc[2](Arg2: &mut Positions)

3MoveLoc[4](Arg4: &mut TxContext)

4Call mint_nft_with_return_<Ty0, Ty1, Ty2>(ID, ID, &mut Positions, &mut TxContext): TurbosPositionNFT

5StLoc[5](loc0: TurbosPositionNFT)

6ImmBorrowLoc[5](loc0: TurbosPositionNFT)

7Call object::id_address<TurbosPositionNFT>(&TurbosPositionNFT): address

8StLoc[6](loc1: address)

9MoveLoc[5](loc0: TurbosPositionNFT)

10MoveLoc[3](Arg3: address)

11Call transfer::public_transfer<TurbosPositionNFT>(TurbosPositionNFT, address)

12MoveLoc[6](loc1: address)

13Ret

}

mint_nft_with_return_<Ty0, Ty1, Ty2>(Arg0: ID, Arg1: ID, Arg2: &mut Positions, Arg3: &mut TxContext): TurbosPositionNFT {

L4: loc0: TurbosPositionNFT

B0:

0CopyLoc[2](Arg2: &mut Positions)

1ImmBorrowField[13](Positions.nft_name: String)

2ReadRef

3CopyLoc[2](Arg2: &mut Positions)

4ImmBorrowField[14](Positions.nft_description: String)

5ReadRef

6CopyLoc[2](Arg2: &mut Positions)

7ImmBorrowField[15](Positions.nft_img_url: String)

8ReadRef

9CopyLoc[0](Arg0: ID)

10CopyLoc[1](Arg1: ID)

11Call type_name::get<Ty0>(): TypeName

12Call type_name::get<Ty1>(): TypeName

13Call type_name::get<Ty2>(): TypeName

14MoveLoc[3](Arg3: &mut TxContext)

15Call position_nft::mint(String, String, String, ID, ID, TypeName, TypeName, TypeName, &mut TxContext): TurbosPositionNFT

16StLoc[4](loc0: TurbosPositionNFT)

17CopyLoc[2](Arg2: &mut Positions)

18ImmBorrowField[16](Positions.nft_minted: u64)

19ReadRef

20LdU64(1)

21Add

22MoveLoc[2](Arg2: &mut Positions)

23MutBorrowField[16](Positions.nft_minted: u64)

24WriteRef

25ImmBorrowLoc[4](loc0: TurbosPositionNFT)

26Call object::id_address<TurbosPositionNFT>(&TurbosPositionNFT): address

27MoveLoc[1](Arg1: ID)

28MoveLoc[0](Arg0: ID)

29Pack[9](MintNftEvent)

30Call event::emit<MintNftEvent>(MintNftEvent)

31MoveLoc[4](loc0: TurbosPositionNFT)

32Ret

}

burn_nft(Arg0: TurbosPositionNFT) {

L1: loc0: address

L2: loc1: ID

L3: loc2: ID

B0:

0ImmBorrowLoc[0](Arg0: TurbosPositionNFT)

1Call object::id_address<TurbosPositionNFT>(&TurbosPositionNFT): address

2StLoc[1](loc0: address)

3ImmBorrowLoc[0](Arg0: TurbosPositionNFT)

4Call position_nft::position_id(&TurbosPositionNFT): ID

5StLoc[3](loc2: ID)

6ImmBorrowLoc[0](Arg0: TurbosPositionNFT)

7Call position_nft::pool_id(&TurbosPositionNFT): ID

8StLoc[2](loc1: ID)

9MoveLoc[0](Arg0: TurbosPositionNFT)

10Call position_nft::burn(TurbosPositionNFT)

11MoveLoc[1](loc0: address)

12MoveLoc[3](loc2: ID)

13MoveLoc[2](loc1: ID)

14Pack[10](BurnNftEvent)

15Call event::emit<BurnNftEvent>(BurnNftEvent)

16Ret

}

entry public burn_nft_directly(Arg0: TurbosPositionNFT) {

B0:

0MoveLoc[0](Arg0: TurbosPositionNFT)

1Call burn_nft(TurbosPositionNFT)

2Ret

}

insert_user_position(Arg0: &mut Positions, Arg1: ID, Arg2: address) {

B0:

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

1ImmBorrowField[12](Positions.user_position: Table<address, ID>)

2CopyLoc[2](Arg2: address)

3Call table::contains<address, ID>(&Table<address, ID>, address): bool

4Not

5BrFalse(12)

B1:

6MoveLoc[0](Arg0: &mut Positions)

7MutBorrowField[12](Positions.user_position: Table<address, ID>)

8MoveLoc[2](Arg2: address)

9MoveLoc[1](Arg1: ID)

10Call table::add<address, ID>(&mut Table<address, ID>, address, ID)

11Branch(14)

B2:

12MoveLoc[0](Arg0: &mut Positions)

13Pop

B3:

14Ret

}

delete_user_position(Arg0: &mut Positions, Arg1: address) {

B0:

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

1ImmBorrowField[12](Positions.user_position: Table<address, ID>)

2CopyLoc[1](Arg1: address)

3Call table::contains<address, ID>(&Table<address, ID>, address): bool

4BrFalse(11)

B1:

5MoveLoc[0](Arg0: &mut Positions)

6MutBorrowField[12](Positions.user_position: Table<address, ID>)

7MoveLoc[1](Arg1: address)

8Call table::remove<address, ID>(&mut Table<address, ID>, address): ID

9Pop

10Branch(13)

B2:

11MoveLoc[0](Arg0: &mut Positions)

12Pop

B3:

13Ret

}

copy_position<Ty0, Ty1, Ty2>(Arg0: &Pool<Ty0, Ty1, Ty2>, Arg1: String, Arg2: &mut Position) {

L3: loc0: u128

L4: loc1: u128

L5: loc2: &vector<PositionRewardInfo>

L6: loc3: u64

L7: loc4: u64

B0:

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

1MoveLoc[1](Arg1: String)

2Call pool::get_position_base_info<Ty0, Ty1, Ty2>(&Pool<Ty0, Ty1, Ty2>, String): u128 * u128 * u128 * u64 * u64 * &vector<PositionRewardInfo>

3StLoc[5](loc2: &vector<PositionRewardInfo>)

4StLoc[7](loc4: u64)

5StLoc[6](loc3: u64)

6StLoc[4](loc1: u128)

7StLoc[3](loc0: u128)

8CopyLoc[2](Arg2: &mut Position)

9MutBorrowField[1](Position.liquidity: u128)

10WriteRef

11MoveLoc[3](loc0: u128)

12CopyLoc[2](Arg2: &mut Position)

13MutBorrowField[10](Position.fee_growth_inside_a: u128)

14WriteRef

15MoveLoc[4](loc1: u128)

16CopyLoc[2](Arg2: &mut Position)

17MutBorrowField[11](Position.fee_growth_inside_b: u128)

18WriteRef

19MoveLoc[6](loc3: u64)

20CopyLoc[2](Arg2: &mut Position)

21MutBorrowField[2](Position.tokens_owed_a: u64)

22WriteRef

23MoveLoc[7](loc4: u64)

24CopyLoc[2](Arg2: &mut Position)

25MutBorrowField[3](Position.tokens_owed_b: u64)

26WriteRef

27MoveLoc[5](loc2: &vector<PositionRewardInfo>)

28MoveLoc[2](Arg2: &mut Position)

29MutBorrowField[4](Position.reward_infos: vector<PositionRewardInfo>)

30Call copy_reward_info(&vector<PositionRewardInfo>, &mut vector<PositionRewardInfo>)

31Ret

}

copy_reward_info(Arg0: &vector<PositionRewardInfo>, Arg1: &mut vector<PositionRewardInfo>) {

L2: loc0: u64

L3: loc1: u64

L4: loc2: u64

L5: loc3: u128

L6: loc4: &mut PositionRewardInfo

B0:

0CopyLoc[0](Arg0: &vector<PositionRewardInfo>)

1VecLen(117)

2StLoc[4](loc2: u64)

3LdU64(0)

4StLoc[3](loc1: u64)

B1:

5CopyLoc[3](loc1: u64)

6CopyLoc[4](loc2: u64)

7Lt

8BrFalse(36)

B2:

9Branch(10)

B3:

10CopyLoc[0](Arg0: &vector<PositionRewardInfo>)

11CopyLoc[3](loc1: u64)

12VecImmBorrow(117)

13Call pool::get_position_reward_info(&PositionRewardInfo): u128 * u64

14StLoc[2](loc0: u64)

15StLoc[5](loc3: u128)

16CopyLoc[1](Arg1: &mut vector<PositionRewardInfo>)

17CopyLoc[3](loc1: u64)

18Call try_init_reward_infos(&mut vector<PositionRewardInfo>, u64)

19CopyLoc[1](Arg1: &mut vector<PositionRewardInfo>)

20CopyLoc[3](loc1: u64)

21VecMutBorrow(65)

22StLoc[6](loc4: &mut PositionRewardInfo)

23MoveLoc[5](loc3: u128)

24CopyLoc[6](loc4: &mut PositionRewardInfo)

25MutBorrowField[9](PositionRewardInfo.reward_growth_inside: u128)

26WriteRef

27MoveLoc[2](loc0: u64)

28MoveLoc[6](loc4: &mut PositionRewardInfo)

29MutBorrowField[5](PositionRewardInfo.amount_owed: u64)

30WriteRef

31MoveLoc[3](loc1: u64)

32LdU64(1)

33Add

34StLoc[3](loc1: u64)

35Branch(5)

B4:

36MoveLoc[1](Arg1: &mut vector<PositionRewardInfo>)

37Pop

38MoveLoc[0](Arg0: &vector<PositionRewardInfo>)

39Pop

40Ret

}

try_init_reward_infos(Arg0: &mut vector<PositionRewardInfo>, Arg1: u64) {

L2: loc0: u64

B0:

0CopyLoc[0](Arg0: &mut vector<PositionRewardInfo>)

1FreezeRef

2VecLen(65)

3StLoc[2](loc0: u64)

4MoveLoc[1](Arg1: u64)

5MoveLoc[2](loc0: u64)

6Eq

7BrFalse(14)

B1:

8MoveLoc[0](Arg0: &mut vector<PositionRewardInfo>)

9LdU128(0)

10LdU64(0)

11Pack[1](PositionRewardInfo)

12VecPushBack(65)

13Branch(16)

B2:

14MoveLoc[0](Arg0: &mut vector<PositionRewardInfo>)

15Pop

B3:

16Ret

}

Constants [

0 => u64: 4

1 => u64: 5

2 => u64: 6

3 => u64: 7

4 => u64: 8

5 => u64: 9

6 => u64: 10

7 => u64: 11

8 => u64: 12

9 => u64: 14

10 => u64: 15

11 => u64: 16

12 => u32: 443636

13 => vector<u8>: "Turbos Position's NFT" // interpreted as UTF8 string

14 => vector<u8>: "An NFT created by Turbos CLMM" // interpreted as UTF8 string

15 => vector<u8>: "https://ipfs.io/ipfs/QmTxRsWbrLG6mkjg375wW77Lfzm38qsUQjRBj3b2K3t8q1?filename=Turbos_nft.png" // interpreted as UTF8 string

16 => vector<u8>: "Proof of Turbos Position Burn" // interpreted as UTF8 string

17 => vector<u8>: "https://app.turbos.finance/icon/turbos-position-burn-nft.png" // interpreted as UTF8 string

18 => address: 0x0000000000000000000000000000000000000000000000000000000000000000

]

}