pool

Module0xd075…6e9c

Move path: 0x3492…c267::pool
Functions: 7454 public, 0 entry
Structs: 5
Friend modules: admin

pool

Bytecode4619 lines

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

// Move bytecode v6

module 3492c874c1e3b3e2984e8c41b589e642d4d0a5d6459e5a9cfc2d52fd7c89c267.pool {

use 3492c874c1e3b3e2984e8c41b589e642d4d0a5d6459e5a9cfc2d52fd7c89c267::clmm_math;

use 3492c874c1e3b3e2984e8c41b589e642d4d0a5d6459e5a9cfc2d52fd7c89c267::config;

use 3492c874c1e3b3e2984e8c41b589e642d4d0a5d6459e5a9cfc2d52fd7c89c267::constants;

use 3492c874c1e3b3e2984e8c41b589e642d4d0a5d6459e5a9cfc2d52fd7c89c267::errors;

use 3492c874c1e3b3e2984e8c41b589e642d4d0a5d6459e5a9cfc2d52fd7c89c267::events;

use 3492c874c1e3b3e2984e8c41b589e642d4d0a5d6459e5a9cfc2d52fd7c89c267::i128H;

use 3492c874c1e3b3e2984e8c41b589e642d4d0a5d6459e5a9cfc2d52fd7c89c267::i32H;

use 3492c874c1e3b3e2984e8c41b589e642d4d0a5d6459e5a9cfc2d52fd7c89c267::oracle;

use 3492c874c1e3b3e2984e8c41b589e642d4d0a5d6459e5a9cfc2d52fd7c89c267::position;

use 3492c874c1e3b3e2984e8c41b589e642d4d0a5d6459e5a9cfc2d52fd7c89c267::tick;

use 3492c874c1e3b3e2984e8c41b589e642d4d0a5d6459e5a9cfc2d52fd7c89c267::tick_bitmap;

use 3492c874c1e3b3e2984e8c41b589e642d4d0a5d6459e5a9cfc2d52fd7c89c267::tick_math;

use 3492c874c1e3b3e2984e8c41b589e642d4d0a5d6459e5a9cfc2d52fd7c89c267::utils;

use 03637b7b60978ef4389124f7683456f0050ab015a0590d52b6e6cadb342af34a::full_math_u128;

use 03637b7b60978ef4389124f7683456f0050ab015a0590d52b6e6cadb342af34a::full_math_u64;

use 03637b7b60978ef4389124f7683456f0050ab015a0590d52b6e6cadb342af34a::i128;

use 03637b7b60978ef4389124f7683456f0050ab015a0590d52b6e6cadb342af34a::i32;

use 03637b7b60978ef4389124f7683456f0050ab015a0590d52b6e6cadb342af34a::math_u128;

use 714a63a0dba6da4f017b42d5d0fb78867f18bcde904868e51d951a5a6f5b7f57::i128 as 0i128;

use 714a63a0dba6da4f017b42d5d0fb78867f18bcde904868e51d951a5a6f5b7f57::i32 as 0i32;

use 714a63a0dba6da4f017b42d5d0fb78867f18bcde904868e51d951a5a6f5b7f57::i64;

use 0000000000000000000000000000000000000000000000000000000000000001::string;

use 0000000000000000000000000000000000000000000000000000000000000001::u64;

use 0000000000000000000000000000000000000000000000000000000000000002::balance;

use 0000000000000000000000000000000000000000000000000000000000000002::clock;

use 0000000000000000000000000000000000000000000000000000000000000002::dynamic_field;

use 0000000000000000000000000000000000000000000000000000000000000002::event;

use 0000000000000000000000000000000000000000000000000000000000000002::object;

use 0000000000000000000000000000000000000000000000000000000000000002::table;

use 0000000000000000000000000000000000000000000000000000000000000002::transfer;

use 0000000000000000000000000000000000000000000000000000000000000002::tx_context;

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

id: UID,

name: String,

coin_a: Balance<Ty0>,

coin_b: Balance<Ty1>,

fee_rate: u64,

protocol_fee_share: u64,

fee_growth_global_coin_a: u128,

fee_growth_global_coin_b: u128,

protocol_fee_coin_a: u64,

protocol_fee_coin_b: u64,

ticks_manager: TickManager,

observations_manager: ObservationManager,

current_sqrt_price: u128,

current_tick_index: I32,

liquidity: u128,

reward_infos: vector<PoolRewardInfo>,

is_paused: bool,

icon_url: String,

position_index: u128,

sequence_number: u128

}

struct PoolRewardInfo has copy, drop, store {

reward_coin_symbol: String,

reward_coin_decimals: u8,

reward_coin_type: String,

last_update_time: u64,

ended_at_seconds: u64,

total_reward: u64,

total_reward_allocated: u64,

reward_per_seconds: u128,

reward_growth_global: u128

}

struct SwapResult has copy, drop {

a2b: bool,

by_amount_in: bool,

amount_specified: u64,

amount_specified_remaining: u64,

amount_calculated: u64,

fee_growth_global: u128,

fee_amount: u64,

protocol_fee: u64,

start_sqrt_price: u128,

end_sqrt_price: u128,

current_tick_index: I32,

is_exceed: bool,

starting_liquidity: u128,

liquidity: u128,

steps: u64,

step_results: vector<SwapStepResult>

}

struct SwapStepResult has copy, drop, store {

tick_index_next: I32,

initialized: bool,

sqrt_price_start: u128,

sqrt_price_next: u128,

amount_in: u64,

amount_out: u64,

fee_amount: u64,

remaining_amount: u64

}

struct FlashSwapReceipt<phantom Ty0, phantom Ty1> {

pool_id: ID,

a2b: bool,

pay_amount: u64

}

public(friend) set_protocol_fee_amount<Ty0, Ty1>(Arg0: &mut Pool<Ty0, Ty1>, Arg1: u64, Arg2: u64) {

B0:

0MoveLoc[1](Arg1: u64)

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

2MutBorrowFieldGeneric[0](Pool.protocol_fee_coin_a: u64)

3WriteRef

4MoveLoc[2](Arg2: u64)

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

6MutBorrowFieldGeneric[1](Pool.protocol_fee_coin_b: u64)

7WriteRef

8Ret

}

public(friend) withdraw_balances<Ty0, Ty1>(Arg0: &mut Pool<Ty0, Ty1>, Arg1: u64, Arg2: u64): Balance<Ty0> * Balance<Ty1> {

B0:

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

1MutBorrowFieldGeneric[2](Pool.coin_a: Balance<Ty0>)

2MoveLoc[1](Arg1: u64)

3Call utils::withdraw_balance<Ty0>(&mut Balance<Ty0>, u64): Balance<Ty0>

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

5MutBorrowFieldGeneric[3](Pool.coin_b: Balance<Ty1>)

6MoveLoc[2](Arg2: u64)

7Call utils::withdraw_balance<Ty1>(&mut Balance<Ty1>, u64): Balance<Ty1>

8Ret

}

public(friend) increase_sequence_number<Ty0, Ty1>(Arg0: &mut Pool<Ty0, Ty1>): u128 {

B0:

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

1ImmBorrowFieldGeneric[4](Pool.sequence_number: u128)

2ReadRef

3LdU128(1)

4Add

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

6MutBorrowFieldGeneric[4](Pool.sequence_number: u128)

7WriteRef

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

9ImmBorrowFieldGeneric[4](Pool.sequence_number: u128)

10ReadRef

11Ret

}

public(friend) add_reward_info<Ty0, Ty1, Ty2>(Arg0: &mut Pool<Ty0, Ty1>, Arg1: PoolRewardInfo) {

B0:

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

1MutBorrowFieldGeneric[5](Pool.id: UID)

2Call utils::get_type_string<Ty2>(): String

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

4Call dynamic_field::add<String, Balance<Ty2>>(&mut UID, String, Balance<Ty2>)

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

6MutBorrowFieldGeneric[6](Pool.reward_infos: vector<PoolRewardInfo>)

7MoveLoc[1](Arg1: PoolRewardInfo)

8VecPushBack(43)

9Ret

}

public(friend) update_pool_reward_emission<Ty0, Ty1, Ty2>(Arg0: &mut Pool<Ty0, Ty1>, Arg1: Balance<Ty2>, Arg2: u64) {

L3: loc0: u64

L4: loc1: ID

L5: loc2: &mut PoolRewardInfo

L6: loc3: u64

B0:

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

1FreezeRef

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

3StLoc[4](loc1: ID)

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

5FreezeRef

6Call find_reward_info_index<Ty0, Ty1, Ty2>(&Pool<Ty0, Ty1>): u64

7StLoc[6](loc3: u64)

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

9MutBorrowFieldGeneric[6](Pool.reward_infos: vector<PoolRewardInfo>)

10MoveLoc[6](loc3: u64)

11VecMutBorrow(43)

12StLoc[5](loc2: &mut PoolRewardInfo)

13CopyLoc[5](loc2: &mut PoolRewardInfo)

14ImmBorrowField[7](PoolRewardInfo.ended_at_seconds: u64)

15ReadRef

16MoveLoc[2](Arg2: u64)

17Add

18StLoc[3](loc0: u64)

19CopyLoc[3](loc0: u64)

20CopyLoc[5](loc2: &mut PoolRewardInfo)

21ImmBorrowField[8](PoolRewardInfo.last_update_time: u64)

22ReadRef

23Gt

24BrFalse(26)

B1:

25Branch(32)

B2:

26MoveLoc[5](loc2: &mut PoolRewardInfo)

27Pop

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

29Pop

30Call errors::invalid_last_update_time(): u64

31Abort

B3:

32CopyLoc[5](loc2: &mut PoolRewardInfo)

33ImmBorrowField[9](PoolRewardInfo.total_reward: u64)

34ReadRef

35ImmBorrowLoc[1](Arg1: Balance<Ty2>)

36Call balance::value<Ty2>(&Balance<Ty2>): u64

37Add

38CopyLoc[5](loc2: &mut PoolRewardInfo)

39MutBorrowField[9](PoolRewardInfo.total_reward: u64)

40WriteRef

41MoveLoc[3](loc0: u64)

42CopyLoc[5](loc2: &mut PoolRewardInfo)

43MutBorrowField[7](PoolRewardInfo.ended_at_seconds: u64)

44WriteRef

45CopyLoc[5](loc2: &mut PoolRewardInfo)

46ImmBorrowField[9](PoolRewardInfo.total_reward: u64)

47ReadRef

48CopyLoc[5](loc2: &mut PoolRewardInfo)

49ImmBorrowField[10](PoolRewardInfo.total_reward_allocated: u64)

50ReadRef

51Sub

52CastU128

53Call constants::q64(): u128

54CastU128

55CopyLoc[5](loc2: &mut PoolRewardInfo)

56ImmBorrowField[7](PoolRewardInfo.ended_at_seconds: u64)

57ReadRef

58CopyLoc[5](loc2: &mut PoolRewardInfo)

59ImmBorrowField[8](PoolRewardInfo.last_update_time: u64)

60ReadRef

61Sub

62CastU128

63Call full_math_u128::mul_div_floor(u128, u128, u128): u128

64CopyLoc[5](loc2: &mut PoolRewardInfo)

65MutBorrowField[11](PoolRewardInfo.reward_per_seconds: u128)

66WriteRef

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

68MutBorrowFieldGeneric[5](Pool.id: UID)

69Call utils::get_type_string<Ty2>(): String

70Call dynamic_field::borrow_mut<String, Balance<Ty2>>(&mut UID, String): &mut Balance<Ty2>

71MoveLoc[1](Arg1: Balance<Ty2>)

72Call balance::join<Ty2>(&mut Balance<Ty2>, Balance<Ty2>): u64

73Pop

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

75ImmBorrowFieldGeneric[4](Pool.sequence_number: u128)

76ReadRef

77LdU128(1)

78Add

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

80MutBorrowFieldGeneric[4](Pool.sequence_number: u128)

81WriteRef

82MoveLoc[4](loc1: ID)

83CopyLoc[5](loc2: &mut PoolRewardInfo)

84ImmBorrowField[12](PoolRewardInfo.reward_coin_symbol: String)

85ReadRef

86CopyLoc[5](loc2: &mut PoolRewardInfo)

87ImmBorrowField[13](PoolRewardInfo.reward_coin_type: String)

88ReadRef

89CopyLoc[5](loc2: &mut PoolRewardInfo)

90ImmBorrowField[14](PoolRewardInfo.reward_coin_decimals: u8)

91ReadRef

92CopyLoc[5](loc2: &mut PoolRewardInfo)

93ImmBorrowField[9](PoolRewardInfo.total_reward: u64)

94ReadRef

95CopyLoc[5](loc2: &mut PoolRewardInfo)

96ImmBorrowField[7](PoolRewardInfo.ended_at_seconds: u64)

97ReadRef

98CopyLoc[5](loc2: &mut PoolRewardInfo)

99ImmBorrowField[8](PoolRewardInfo.last_update_time: u64)

100ReadRef

101MoveLoc[5](loc2: &mut PoolRewardInfo)

102ImmBorrowField[11](PoolRewardInfo.reward_per_seconds: u128)

103ReadRef

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

105ImmBorrowFieldGeneric[4](Pool.sequence_number: u128)

106ReadRef

107Call events::emit_update_pool_reward_emission_event(ID, String, String, u8, u64, u64, u64, u128, u128)

108Ret

}

public(friend) update_reward_infos<Ty0, Ty1>(Arg0: &mut Pool<Ty0, Ty1>, Arg1: u64): vector<u128> {

L2: loc0: bool

L3: loc1: u64

L4: loc2: u64

L5: loc3: vector<u128>

L6: loc4: &mut PoolRewardInfo

L7: loc5: u256

B0:

0VecPack(4, 0)

1StLoc[5](loc3: vector<u128>)

2LdU64(0)

3StLoc[3](loc1: u64)

B1:

4CopyLoc[3](loc1: u64)

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

6ImmBorrowFieldGeneric[6](Pool.reward_infos: vector<PoolRewardInfo>)

7VecLen(43)

8Lt

9BrFalse(96)

B2:

10Branch(11)

B3:

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

12MutBorrowFieldGeneric[6](Pool.reward_infos: vector<PoolRewardInfo>)

13CopyLoc[3](loc1: u64)

14VecMutBorrow(43)

15StLoc[6](loc4: &mut PoolRewardInfo)

16MoveLoc[3](loc1: u64)

17LdU64(1)

18Add

19StLoc[3](loc1: u64)

20CopyLoc[1](Arg1: u64)

21CopyLoc[6](loc4: &mut PoolRewardInfo)

22ImmBorrowField[8](PoolRewardInfo.last_update_time: u64)

23ReadRef

24Gt

25BrFalse(90)

B4:

26CopyLoc[1](Arg1: u64)

27CopyLoc[6](loc4: &mut PoolRewardInfo)

28ImmBorrowField[7](PoolRewardInfo.ended_at_seconds: u64)

29ReadRef

30Call u64::min(u64, u64): u64

31StLoc[4](loc2: u64)

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

33ImmBorrowFieldGeneric[7](Pool.liquidity: u128)

34ReadRef

35LdU128(0)

36Neq

37BrFalse(45)

B5:

38CopyLoc[4](loc2: u64)

39CopyLoc[6](loc4: &mut PoolRewardInfo)

40ImmBorrowField[8](PoolRewardInfo.last_update_time: u64)

41ReadRef

42Gt

43StLoc[2](loc0: bool)

44Branch(47)

B6:

45LdFalse

46StLoc[2](loc0: bool)

B7:

47MoveLoc[2](loc0: bool)

48BrFalse(86)

B8:

49MoveLoc[4](loc2: u64)

50CopyLoc[6](loc4: &mut PoolRewardInfo)

51ImmBorrowField[8](PoolRewardInfo.last_update_time: u64)

52ReadRef

53Sub

54CastU128

55CopyLoc[6](loc4: &mut PoolRewardInfo)

56ImmBorrowField[11](PoolRewardInfo.reward_per_seconds: u128)

57ReadRef

58Call full_math_u128::full_mul(u128, u128): u256

59StLoc[7](loc5: u256)

60CopyLoc[6](loc4: &mut PoolRewardInfo)

61ImmBorrowField[16](PoolRewardInfo.reward_growth_global: u128)

62ReadRef

63CopyLoc[7](loc5: u256)

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

65ImmBorrowFieldGeneric[7](Pool.liquidity: u128)

66ReadRef

67CastU256

68Div

69CastU128

70Call math_u128::wrapping_add(u128, u128): u128

71CopyLoc[6](loc4: &mut PoolRewardInfo)

72MutBorrowField[16](PoolRewardInfo.reward_growth_global: u128)

73WriteRef

74CopyLoc[6](loc4: &mut PoolRewardInfo)

75ImmBorrowField[10](PoolRewardInfo.total_reward_allocated: u64)

76ReadRef

77MoveLoc[7](loc5: u256)

78Call constants::q64(): u128

79CastU256

80Div

81CastU64

82Add

83CopyLoc[6](loc4: &mut PoolRewardInfo)

84MutBorrowField[10](PoolRewardInfo.total_reward_allocated: u64)

85WriteRef

B9:

86CopyLoc[1](Arg1: u64)

87CopyLoc[6](loc4: &mut PoolRewardInfo)

88MutBorrowField[8](PoolRewardInfo.last_update_time: u64)

89WriteRef

B10:

90MutBorrowLoc[5](loc3: vector<u128>)

91MoveLoc[6](loc4: &mut PoolRewardInfo)

92ImmBorrowField[16](PoolRewardInfo.reward_growth_global: u128)

93ReadRef

94VecPushBack(4)

95Branch(4)

B11:

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

97Pop

98MoveLoc[5](loc3: vector<u128>)

99Ret

}

public(friend) update_pause_status<Ty0, Ty1>(Arg0: &mut Pool<Ty0, Ty1>, Arg1: bool) {

B0:

0MoveLoc[1](Arg1: bool)

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

2MutBorrowFieldGeneric[8](Pool.is_paused: bool)

3WriteRef

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

5ImmBorrowFieldGeneric[4](Pool.sequence_number: u128)

6ReadRef

7LdU128(1)

8Add

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

10MutBorrowFieldGeneric[4](Pool.sequence_number: u128)

11WriteRef

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

13ImmBorrowFieldGeneric[5](Pool.id: UID)

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

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

16ImmBorrowFieldGeneric[8](Pool.is_paused: bool)

17ReadRef

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

19ImmBorrowFieldGeneric[4](Pool.sequence_number: u128)

20ReadRef

21Call events::emit_pool_pause_status_update_event(ID, bool, u128)

22Ret

}

public(friend) set_protocol_fee_share<Ty0, Ty1>(Arg0: &mut Pool<Ty0, Ty1>, Arg1: u64) {

B0:

0MoveLoc[1](Arg1: u64)

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

2MutBorrowFieldGeneric[9](Pool.protocol_fee_share: u64)

3WriteRef

4Ret

}

public(friend) increase_observation_cardinality_next<Ty0, Ty1>(Arg0: &mut Pool<Ty0, Ty1>, Arg1: u64) {

L2: loc0: u64

L3: loc1: u64

B0:

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

1MutBorrowFieldGeneric[10](Pool.observations_manager: ObservationManager)

2MoveLoc[1](Arg1: u64)

3Call oracle::grow(&mut ObservationManager, u64): u64 * u64

4StLoc[2](loc0: u64)

5StLoc[3](loc1: u64)

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

7Call increase_sequence_number<Ty0, Ty1>(&mut Pool<Ty0, Ty1>): u128

8Pop

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

10FreezeRef

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

12MoveLoc[3](loc1: u64)

13MoveLoc[2](loc0: u64)

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

15ImmBorrowFieldGeneric[4](Pool.sequence_number: u128)

16ReadRef

17Call events::emit_observation_cardinality_updated_event(ID, u64, u64, u128)

18Ret

}

public(friend) increase_reward_coin_reserves<Ty0, Ty1, Ty2>(Arg0: &mut Pool<Ty0, Ty1>, Arg1: Balance<Ty2>) {

L2: loc0: u64

L3: loc1: &mut Balance<Ty2>

L4: loc2: String

L5: loc3: u64

L6: loc4: u64

B0:

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

1FreezeRef

2Call is_reward_present<Ty0, Ty1, Ty2>(&Pool<Ty0, Ty1>): bool

3BrFalse(5)

B1:

4Branch(9)

B2:

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

6Pop

7Call errors::reward_index_not_found(): u64

8Abort

B3:

9ImmBorrowLoc[1](Arg1: Balance<Ty2>)

10Call balance::value<Ty2>(&Balance<Ty2>): u64

11StLoc[2](loc0: u64)

12Call utils::get_type_string<Ty2>(): String

13StLoc[4](loc2: String)

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

15MutBorrowFieldGeneric[5](Pool.id: UID)

16CopyLoc[4](loc2: String)

17Call dynamic_field::borrow_mut<String, Balance<Ty2>>(&mut UID, String): &mut Balance<Ty2>

18StLoc[3](loc1: &mut Balance<Ty2>)

19CopyLoc[3](loc1: &mut Balance<Ty2>)

20FreezeRef

21Call balance::value<Ty2>(&Balance<Ty2>): u64

22StLoc[6](loc4: u64)

23CopyLoc[3](loc1: &mut Balance<Ty2>)

24MoveLoc[1](Arg1: Balance<Ty2>)

25Call balance::join<Ty2>(&mut Balance<Ty2>, Balance<Ty2>): u64

26Pop

27MoveLoc[3](loc1: &mut Balance<Ty2>)

28FreezeRef

29Call balance::value<Ty2>(&Balance<Ty2>): u64

30StLoc[5](loc3: u64)

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

32FreezeRef

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

34MoveLoc[4](loc2: String)

35MoveLoc[2](loc0: u64)

36MoveLoc[6](loc4: u64)

37MoveLoc[5](loc3: u64)

38Call events::emit_reward_reserves_increased(ID, String, u64, u64, u64)

39Ret

}

public(friend) set_pool_icon_url<Ty0, Ty1>(Arg0: &mut Pool<Ty0, Ty1>, Arg1: String) {

L2: loc0: u128

B0:

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

1ImmBorrowFieldGeneric[11](Pool.icon_url: String)

2ReadRef

3CopyLoc[1](Arg1: String)

4Neq

5BrFalse(7)

B1:

6Branch(11)

B2:

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

8Pop

9Call errors::same_value_provided(): u64

10Abort

B3:

11CopyLoc[1](Arg1: String)

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

13MutBorrowFieldGeneric[11](Pool.icon_url: String)

14WriteRef

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

16Call increase_sequence_number<Ty0, Ty1>(&mut Pool<Ty0, Ty1>): u128

17StLoc[2](loc0: u128)

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

19ImmBorrowFieldGeneric[5](Pool.id: UID)

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

21MoveLoc[1](Arg1: String)

22MoveLoc[2](loc0: u128)

23Call events::emit_pool_icon_url_update_event(ID, String, u128)

24Ret

}

public create_pool<Ty0, Ty1, Ty2>(Arg0: &Clock, Arg1: &mut GlobalConfig, Arg2: vector<u8>, Arg3: vector<u8>, Arg4: vector<u8>, Arg5: u8, Arg6: vector<u8>, Arg7: vector<u8>, Arg8: u8, Arg9: vector<u8>, Arg10: u32, Arg11: u64, Arg12: u128, Arg13: Balance<Ty2>, Arg14: &mut TxContext): ID {

L15: loc0: vector<u8>

L16: loc1: u32

L17: loc2: u64

L18: loc3: u128

L19: loc4: &mut TxContext

L20: loc5: vector<u8>

L21: loc6: vector<u8>

L22: loc7: vector<u8>

L23: loc8: u8

L24: loc9: vector<u8>

L25: loc10: vector<u8>

L26: loc11: u8

L27: loc12: ID

L28: loc13: Pool<Ty0, Ty1>

B0:

0MoveLoc[0](Arg0: &Clock)

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

2MoveLoc[2](Arg2: vector<u8>)

3MoveLoc[3](Arg3: vector<u8>)

4MoveLoc[4](Arg4: vector<u8>)

5MoveLoc[5](Arg5: u8)

6MoveLoc[6](Arg6: vector<u8>)

7MoveLoc[7](Arg7: vector<u8>)

8MoveLoc[8](Arg8: u8)

9MoveLoc[9](Arg9: vector<u8>)

10MoveLoc[10](Arg10: u32)

11MoveLoc[11](Arg11: u64)

12MoveLoc[12](Arg12: u128)

13CopyLoc[14](Arg14: &mut TxContext)

14StLoc[19](loc4: &mut TxContext)

15StLoc[18](loc3: u128)

16StLoc[17](loc2: u64)

17StLoc[16](loc1: u32)

18StLoc[15](loc0: vector<u8>)

19StLoc[26](loc11: u8)

20StLoc[25](loc10: vector<u8>)

21StLoc[24](loc9: vector<u8>)

22StLoc[23](loc8: u8)

23StLoc[22](loc7: vector<u8>)

24StLoc[21](loc6: vector<u8>)

25StLoc[20](loc5: vector<u8>)

26FreezeRef

27MoveLoc[20](loc5: vector<u8>)

28MoveLoc[21](loc6: vector<u8>)

29MoveLoc[22](loc7: vector<u8>)

30MoveLoc[23](loc8: u8)

31MoveLoc[24](loc9: vector<u8>)

32MoveLoc[25](loc10: vector<u8>)

33MoveLoc[26](loc11: u8)

34MoveLoc[15](loc0: vector<u8>)

35MoveLoc[16](loc1: u32)

36MoveLoc[17](loc2: u64)

37MoveLoc[18](loc3: u128)

38MoveLoc[19](loc4: &mut TxContext)

39Call create_pool_internal<Ty0, Ty1>(&Clock, &GlobalConfig, vector<u8>, vector<u8>, vector<u8>, u8, vector<u8>, vector<u8>, u8, vector<u8>, u32, u64, u128, &mut TxContext): Pool<Ty0, Ty1>

40StLoc[28](loc13: Pool<Ty0, Ty1>)

41ImmBorrowLoc[28](loc13: Pool<Ty0, Ty1>)

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

43StLoc[27](loc12: ID)

44MoveLoc[1](Arg1: &mut GlobalConfig)

45CopyLoc[27](loc12: ID)

46MoveLoc[13](Arg13: Balance<Ty2>)

47MoveLoc[14](Arg14: &mut TxContext)

48FreezeRef

49Call charge_pool_creation_fee<Ty2>(&mut GlobalConfig, ID, Balance<Ty2>, &TxContext)

50MoveLoc[28](loc13: Pool<Ty0, Ty1>)

51Call transfer::share_object<Pool<Ty0, Ty1>>(Pool<Ty0, Ty1>)

52MoveLoc[27](loc12: ID)

53Ret

}

public create_pool_with_liquidity<Ty0, Ty1, Ty2>(Arg0: &Clock, Arg1: &mut GlobalConfig, Arg2: vector<u8>, Arg3: vector<u8>, Arg4: vector<u8>, Arg5: u8, Arg6: vector<u8>, Arg7: vector<u8>, Arg8: u8, Arg9: vector<u8>, Arg10: u32, Arg11: u64, Arg12: u128, Arg13: Balance<Ty2>, Arg14: u32, Arg15: u32, Arg16: Balance<Ty0>, Arg17: Balance<Ty1>, Arg18: u64, Arg19: bool, Arg20: &mut TxContext): ID * Position * u64 * u64 * Balance<Ty0> * Balance<Ty1> {

L21: loc0: vector<u8>

L22: loc1: u32

L23: loc2: u64

L24: loc3: u128

L25: loc4: &mut TxContext

L26: loc5: &mut Pool<Ty0, Ty1>

L27: loc6: u32

L28: loc7: u32

L29: loc8: &mut TxContext

L30: loc9: &mut Pool<Ty0, Ty1>

L31: loc10: &mut Position

L32: loc11: Balance<Ty0>

L33: loc12: Balance<Ty1>

L34: loc13: vector<u8>

L35: loc14: u64

L36: loc15: bool

L37: loc16: vector<u8>

L38: loc17: vector<u8>

L39: loc18: u8

L40: loc19: vector<u8>

L41: loc20: vector<u8>

L42: loc21: u8

L43: loc22: Balance<Ty0>

L44: loc23: Balance<Ty1>

L45: loc24: u64

L46: loc25: u64

L47: loc26: ID

L48: loc27: Pool<Ty0, Ty1>

L49: loc28: Position

B0:

0CopyLoc[0](Arg0: &Clock)

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

2MoveLoc[2](Arg2: vector<u8>)

3MoveLoc[3](Arg3: vector<u8>)

4MoveLoc[4](Arg4: vector<u8>)

5MoveLoc[5](Arg5: u8)

6MoveLoc[6](Arg6: vector<u8>)

7MoveLoc[7](Arg7: vector<u8>)

8MoveLoc[8](Arg8: u8)

9MoveLoc[9](Arg9: vector<u8>)

10MoveLoc[10](Arg10: u32)

11MoveLoc[11](Arg11: u64)

12MoveLoc[12](Arg12: u128)

13CopyLoc[20](Arg20: &mut TxContext)

14StLoc[25](loc4: &mut TxContext)

15StLoc[24](loc3: u128)

16StLoc[23](loc2: u64)

17StLoc[22](loc1: u32)

18StLoc[21](loc0: vector<u8>)

19StLoc[42](loc21: u8)

20StLoc[41](loc20: vector<u8>)

21StLoc[40](loc19: vector<u8>)

22StLoc[39](loc18: u8)

23StLoc[38](loc17: vector<u8>)

24StLoc[37](loc16: vector<u8>)

25StLoc[34](loc13: vector<u8>)

26FreezeRef

27MoveLoc[34](loc13: vector<u8>)

28MoveLoc[37](loc16: vector<u8>)

29MoveLoc[38](loc17: vector<u8>)

30MoveLoc[39](loc18: u8)

31MoveLoc[40](loc19: vector<u8>)

32MoveLoc[41](loc20: vector<u8>)

33MoveLoc[42](loc21: u8)

34MoveLoc[21](loc0: vector<u8>)

35MoveLoc[22](loc1: u32)

36MoveLoc[23](loc2: u64)

37MoveLoc[24](loc3: u128)

38MoveLoc[25](loc4: &mut TxContext)

39Call create_pool_internal<Ty0, Ty1>(&Clock, &GlobalConfig, vector<u8>, vector<u8>, vector<u8>, u8, vector<u8>, vector<u8>, u8, vector<u8>, u32, u64, u128, &mut TxContext): Pool<Ty0, Ty1>

40StLoc[48](loc27: Pool<Ty0, Ty1>)

41ImmBorrowLoc[48](loc27: Pool<Ty0, Ty1>)

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

43StLoc[47](loc26: ID)

44CopyLoc[1](Arg1: &mut GlobalConfig)

45CopyLoc[47](loc26: ID)

46MoveLoc[13](Arg13: Balance<Ty2>)

47CopyLoc[20](Arg20: &mut TxContext)

48FreezeRef

49Call charge_pool_creation_fee<Ty2>(&mut GlobalConfig, ID, Balance<Ty2>, &TxContext)

50CopyLoc[1](Arg1: &mut GlobalConfig)

51MutBorrowLoc[48](loc27: Pool<Ty0, Ty1>)

52MoveLoc[14](Arg14: u32)

53MoveLoc[15](Arg15: u32)

54MoveLoc[20](Arg20: &mut TxContext)

55StLoc[29](loc8: &mut TxContext)

56StLoc[28](loc7: u32)

57StLoc[27](loc6: u32)

58StLoc[26](loc5: &mut Pool<Ty0, Ty1>)

59FreezeRef

60MoveLoc[26](loc5: &mut Pool<Ty0, Ty1>)

61MoveLoc[27](loc6: u32)

62MoveLoc[28](loc7: u32)

63MoveLoc[29](loc8: &mut TxContext)

64Call open_position<Ty0, Ty1>(&GlobalConfig, &mut Pool<Ty0, Ty1>, u32, u32, &mut TxContext): Position

65StLoc[49](loc28: Position)

66MoveLoc[0](Arg0: &Clock)

67MoveLoc[1](Arg1: &mut GlobalConfig)

68MutBorrowLoc[48](loc27: Pool<Ty0, Ty1>)

69MutBorrowLoc[49](loc28: Position)

70MoveLoc[16](Arg16: Balance<Ty0>)

71MoveLoc[17](Arg17: Balance<Ty1>)

72MoveLoc[18](Arg18: u64)

73MoveLoc[19](Arg19: bool)

74StLoc[36](loc15: bool)

75StLoc[35](loc14: u64)

76StLoc[33](loc12: Balance<Ty1>)

77StLoc[32](loc11: Balance<Ty0>)

78StLoc[31](loc10: &mut Position)

79StLoc[30](loc9: &mut Pool<Ty0, Ty1>)

80FreezeRef

81MoveLoc[30](loc9: &mut Pool<Ty0, Ty1>)

82MoveLoc[31](loc10: &mut Position)

83MoveLoc[32](loc11: Balance<Ty0>)

84MoveLoc[33](loc12: Balance<Ty1>)

85MoveLoc[35](loc14: u64)

86MoveLoc[36](loc15: bool)

87Call add_liquidity_with_fixed_amount<Ty0, Ty1>(&Clock, &GlobalConfig, &mut Pool<Ty0, Ty1>, &mut Position, Balance<Ty0>, Balance<Ty1>, u64, bool): u64 * u64 * Balance<Ty0> * Balance<Ty1>

88StLoc[44](loc23: Balance<Ty1>)

89StLoc[43](loc22: Balance<Ty0>)

90StLoc[46](loc25: u64)

91StLoc[45](loc24: u64)

92MoveLoc[48](loc27: Pool<Ty0, Ty1>)

93Call transfer::share_object<Pool<Ty0, Ty1>>(Pool<Ty0, Ty1>)

94MoveLoc[47](loc26: ID)

95MoveLoc[49](loc28: Position)

96MoveLoc[45](loc24: u64)

97MoveLoc[46](loc25: u64)

98MoveLoc[43](loc22: Balance<Ty0>)

99MoveLoc[44](loc23: Balance<Ty1>)

100Ret

}

public create_pool_and_get_object<Ty0, Ty1, Ty2>(Arg0: &Clock, Arg1: &mut GlobalConfig, Arg2: vector<u8>, Arg3: vector<u8>, Arg4: vector<u8>, Arg5: u8, Arg6: vector<u8>, Arg7: vector<u8>, Arg8: u8, Arg9: vector<u8>, Arg10: u32, Arg11: u64, Arg12: u128, Arg13: Balance<Ty2>, Arg14: &mut TxContext): Pool<Ty0, Ty1> {

L15: loc0: vector<u8>

L16: loc1: u32

L17: loc2: u64

L18: loc3: u128

L19: loc4: &mut TxContext

L20: loc5: vector<u8>

L21: loc6: vector<u8>

L22: loc7: vector<u8>

L23: loc8: u8

L24: loc9: vector<u8>

L25: loc10: vector<u8>

L26: loc11: u8

L27: loc12: Pool<Ty0, Ty1>

B0:

0MoveLoc[0](Arg0: &Clock)

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

2MoveLoc[2](Arg2: vector<u8>)

3MoveLoc[3](Arg3: vector<u8>)

4MoveLoc[4](Arg4: vector<u8>)

5MoveLoc[5](Arg5: u8)

6MoveLoc[6](Arg6: vector<u8>)

7MoveLoc[7](Arg7: vector<u8>)

8MoveLoc[8](Arg8: u8)

9MoveLoc[9](Arg9: vector<u8>)

10MoveLoc[10](Arg10: u32)

11MoveLoc[11](Arg11: u64)

12MoveLoc[12](Arg12: u128)

13CopyLoc[14](Arg14: &mut TxContext)

14StLoc[19](loc4: &mut TxContext)

15StLoc[18](loc3: u128)

16StLoc[17](loc2: u64)

17StLoc[16](loc1: u32)

18StLoc[15](loc0: vector<u8>)

19StLoc[26](loc11: u8)

20StLoc[25](loc10: vector<u8>)

21StLoc[24](loc9: vector<u8>)

22StLoc[23](loc8: u8)

23StLoc[22](loc7: vector<u8>)

24StLoc[21](loc6: vector<u8>)

25StLoc[20](loc5: vector<u8>)

26FreezeRef

27MoveLoc[20](loc5: vector<u8>)

28MoveLoc[21](loc6: vector<u8>)

29MoveLoc[22](loc7: vector<u8>)

30MoveLoc[23](loc8: u8)

31MoveLoc[24](loc9: vector<u8>)

32MoveLoc[25](loc10: vector<u8>)

33MoveLoc[26](loc11: u8)

34MoveLoc[15](loc0: vector<u8>)

35MoveLoc[16](loc1: u32)

36MoveLoc[17](loc2: u64)

37MoveLoc[18](loc3: u128)

38MoveLoc[19](loc4: &mut TxContext)

39Call create_pool_internal<Ty0, Ty1>(&Clock, &GlobalConfig, vector<u8>, vector<u8>, vector<u8>, u8, vector<u8>, vector<u8>, u8, vector<u8>, u32, u64, u128, &mut TxContext): Pool<Ty0, Ty1>

40StLoc[27](loc12: Pool<Ty0, Ty1>)

41MoveLoc[1](Arg1: &mut GlobalConfig)

42ImmBorrowLoc[27](loc12: Pool<Ty0, Ty1>)

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

44MoveLoc[13](Arg13: Balance<Ty2>)

45MoveLoc[14](Arg14: &mut TxContext)

46FreezeRef

47Call charge_pool_creation_fee<Ty2>(&mut GlobalConfig, ID, Balance<Ty2>, &TxContext)

48MoveLoc[27](loc12: Pool<Ty0, Ty1>)

49Ret

}

public share_pool_object<Ty0, Ty1>(Arg0: Pool<Ty0, Ty1>) {

B0:

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

1Call transfer::share_object<Pool<Ty0, Ty1>>(Pool<Ty0, Ty1>)

2Ret

}

public new<Ty0, Ty1>(Arg0: &Clock, Arg1: vector<u8>, Arg2: vector<u8>, Arg3: vector<u8>, Arg4: u8, Arg5: vector<u8>, Arg6: vector<u8>, Arg7: u8, Arg8: vector<u8>, Arg9: u32, Arg10: u64, Arg11: u128, Arg12: &mut TxContext) {

B0:

0Call errors::depricated(): u64

1Abort

}

public add_liquidity_with_fixed_amount<Ty0, Ty1>(Arg0: &Clock, Arg1: &GlobalConfig, Arg2: &mut Pool<Ty0, Ty1>, Arg3: &mut Position, Arg4: Balance<Ty0>, Arg5: Balance<Ty1>, Arg6: u64, Arg7: bool): u64 * u64 * Balance<Ty0> * Balance<Ty1> {

L8: loc0: Balance<Ty0>

L9: loc1: Balance<Ty1>

L10: loc2: u64

L11: loc3: u64

L12: loc4: u128

L13: loc5: u128

B0:

0MoveLoc[1](Arg1: &GlobalConfig)

1Call config::verify_version(&GlobalConfig)

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

3FreezeRef

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

5CopyLoc[3](Arg3: &mut Position)

6FreezeRef

7Call position::pool_id(&Position): ID

8Eq

9BrFalse(11)

B1:

10Branch(19)

B2:

11MoveLoc[3](Arg3: &mut Position)

12Pop

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

14Pop

15MoveLoc[0](Arg0: &Clock)

16Pop

17Call errors::position_does_not_belong_to_pool(): u64

18Abort

B3:

19CopyLoc[2](Arg2: &mut Pool<Ty0, Ty1>)

20ImmBorrowFieldGeneric[8](Pool.is_paused: bool)

21ReadRef

22Not

23BrFalse(25)

B4:

24Branch(33)

B5:

25MoveLoc[3](Arg3: &mut Position)

26Pop

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

28Pop

29MoveLoc[0](Arg0: &Clock)

30Pop

31Call errors::pool_is_paused(): u64

32Abort

B6:

33CopyLoc[2](Arg2: &mut Pool<Ty0, Ty1>)

34ImmBorrowFieldGeneric[5](Pool.id: UID)

35Call is_flash_swap_in_progress(&UID): bool

36Not

37BrFalse(39)

B7:

38Branch(47)

B8:

39MoveLoc[3](Arg3: &mut Position)

40Pop

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

42Pop

43MoveLoc[0](Arg0: &Clock)

44Pop

45Call errors::flash_swap_in_progress(): u64

46Abort

B9:

47CopyLoc[6](Arg6: u64)

48LdU64(0)

49Gt

50BrFalse(52)

B10:

51Branch(60)

B11:

52MoveLoc[3](Arg3: &mut Position)

53Pop

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

55Pop

56MoveLoc[0](Arg0: &Clock)

57Pop

58Call errors::zero_amount(): u64

59Abort

B12:

60CopyLoc[2](Arg2: &mut Pool<Ty0, Ty1>)

61ImmBorrowFieldGeneric[7](Pool.liquidity: u128)

62ReadRef

63StLoc[13](loc5: u128)

64CopyLoc[3](Arg3: &mut Position)

65FreezeRef

66Call position::lower_tick(&Position): I32

67CopyLoc[3](Arg3: &mut Position)

68FreezeRef

69Call position::upper_tick(&Position): I32

70CopyLoc[2](Arg2: &mut Pool<Ty0, Ty1>)

71ImmBorrowFieldGeneric[12](Pool.current_tick_index: I32)

72ReadRef

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

74ImmBorrowFieldGeneric[13](Pool.current_sqrt_price: u128)

75ReadRef

76MoveLoc[6](Arg6: u64)

77MoveLoc[7](Arg7: bool)

78Call clmm_math::get_liquidity_by_amount(I32, I32, I32, u128, u64, bool): u128 * u64 * u64

79Pop

80Pop

81StLoc[12](loc4: u128)

82MoveLoc[0](Arg0: &Clock)

83CopyLoc[2](Arg2: &mut Pool<Ty0, Ty1>)

84CopyLoc[3](Arg3: &mut Position)

85CopyLoc[12](loc4: u128)

86Call i128::from(u128): I128

87Call update_data_for_delta_l<Ty0, Ty1>(&Clock, &mut Pool<Ty0, Ty1>, &mut Position, I128): u64 * u64

88StLoc[11](loc3: u64)

89StLoc[10](loc2: u64)

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

91ImmBorrowFieldGeneric[4](Pool.sequence_number: u128)

92ReadRef

93LdU128(1)

94Add

95CopyLoc[2](Arg2: &mut Pool<Ty0, Ty1>)

96MutBorrowFieldGeneric[4](Pool.sequence_number: u128)

97WriteRef

98CopyLoc[2](Arg2: &mut Pool<Ty0, Ty1>)

99MutBorrowFieldGeneric[2](Pool.coin_a: Balance<Ty0>)

100MoveLoc[4](Arg4: Balance<Ty0>)

101CopyLoc[10](loc2: u64)

102Call utils::deposit_balance<Ty0>(&mut Balance<Ty0>, Balance<Ty0>, u64): Balance<Ty0>

103CopyLoc[2](Arg2: &mut Pool<Ty0, Ty1>)

104MutBorrowFieldGeneric[3](Pool.coin_b: Balance<Ty1>)

105MoveLoc[5](Arg5: Balance<Ty1>)

106CopyLoc[11](loc3: u64)

107Call utils::deposit_balance<Ty1>(&mut Balance<Ty1>, Balance<Ty1>, u64): Balance<Ty1>

108StLoc[9](loc1: Balance<Ty1>)

109StLoc[8](loc0: Balance<Ty0>)

110CopyLoc[2](Arg2: &mut Pool<Ty0, Ty1>)

111FreezeRef

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

113CopyLoc[3](Arg3: &mut Position)

114FreezeRef

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

116CopyLoc[10](loc2: u64)

117CopyLoc[11](loc3: u64)

118CopyLoc[2](Arg2: &mut Pool<Ty0, Ty1>)

119ImmBorrowFieldGeneric[2](Pool.coin_a: Balance<Ty0>)

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

121CopyLoc[2](Arg2: &mut Pool<Ty0, Ty1>)

122ImmBorrowFieldGeneric[3](Pool.coin_b: Balance<Ty1>)

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

124MoveLoc[12](loc4: u128)

125MoveLoc[13](loc5: u128)

126CopyLoc[2](Arg2: &mut Pool<Ty0, Ty1>)

127ImmBorrowFieldGeneric[7](Pool.liquidity: u128)

128ReadRef

129CopyLoc[2](Arg2: &mut Pool<Ty0, Ty1>)

130ImmBorrowFieldGeneric[13](Pool.current_sqrt_price: u128)

131ReadRef

132CopyLoc[2](Arg2: &mut Pool<Ty0, Ty1>)

133ImmBorrowFieldGeneric[12](Pool.current_tick_index: I32)

134ReadRef

135CopyLoc[3](Arg3: &mut Position)

136FreezeRef

137Call position::lower_tick(&Position): I32

138MoveLoc[3](Arg3: &mut Position)

139FreezeRef

140Call position::upper_tick(&Position): I32

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

142ImmBorrowFieldGeneric[4](Pool.sequence_number: u128)

143ReadRef

144Call events::emit_liquidity_provided_event(ID, ID, u64, u64, u64, u64, u128, u128, u128, u128, I32, I32, I32, u128)

145MoveLoc[10](loc2: u64)

146MoveLoc[11](loc3: u64)

147MoveLoc[8](loc0: Balance<Ty0>)

148MoveLoc[9](loc1: Balance<Ty1>)

149Ret

}

public add_liquidity<Ty0, Ty1>(Arg0: &Clock, Arg1: &GlobalConfig, Arg2: &mut Pool<Ty0, Ty1>, Arg3: &mut Position, Arg4: Balance<Ty0>, Arg5: Balance<Ty1>, Arg6: u128): u64 * u64 * Balance<Ty0> * Balance<Ty1> {

L7: loc0: bool

L8: loc1: u64

L9: loc2: u64

L10: loc3: u128

B0:

0MoveLoc[1](Arg1: &GlobalConfig)

1Call config::verify_version(&GlobalConfig)

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

3FreezeRef

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

5CopyLoc[3](Arg3: &mut Position)

6FreezeRef

7Call position::pool_id(&Position): ID

8Eq

9BrFalse(11)

B1:

10Branch(19)

B2:

11MoveLoc[3](Arg3: &mut Position)

12Pop

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

14Pop

15MoveLoc[0](Arg0: &Clock)

16Pop

17Call errors::position_does_not_belong_to_pool(): u64

18Abort

B3:

19CopyLoc[2](Arg2: &mut Pool<Ty0, Ty1>)

20ImmBorrowFieldGeneric[8](Pool.is_paused: bool)

21ReadRef

22Not

23BrFalse(25)

B4:

24Branch(33)

B5:

25MoveLoc[3](Arg3: &mut Position)

26Pop

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

28Pop

29MoveLoc[0](Arg0: &Clock)

30Pop

31Call errors::pool_is_paused(): u64

32Abort

B6:

33CopyLoc[2](Arg2: &mut Pool<Ty0, Ty1>)

34ImmBorrowFieldGeneric[5](Pool.id: UID)

35Call is_flash_swap_in_progress(&UID): bool

36Not

37BrFalse(39)

B7:

38Branch(47)

B8:

39MoveLoc[3](Arg3: &mut Position)

40Pop

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

42Pop

43MoveLoc[0](Arg0: &Clock)

44Pop

45Call errors::flash_swap_in_progress(): u64

46Abort

B9:

47CopyLoc[6](Arg6: u128)

48LdU128(0)

49Gt

50BrFalse(52)

B10:

51Branch(60)

B11:

52MoveLoc[3](Arg3: &mut Position)

53Pop

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

55Pop

56MoveLoc[0](Arg0: &Clock)

57Pop

58Call errors::zero_amount(): u64

59Abort

B12:

60CopyLoc[2](Arg2: &mut Pool<Ty0, Ty1>)

61ImmBorrowFieldGeneric[7](Pool.liquidity: u128)

62ReadRef

63StLoc[10](loc3: u128)

64MoveLoc[0](Arg0: &Clock)

65CopyLoc[2](Arg2: &mut Pool<Ty0, Ty1>)

66CopyLoc[3](Arg3: &mut Position)

67CopyLoc[6](Arg6: u128)

68Call i128::from(u128): I128

69Call update_data_for_delta_l<Ty0, Ty1>(&Clock, &mut Pool<Ty0, Ty1>, &mut Position, I128): u64 * u64

70StLoc[9](loc2: u64)

71StLoc[8](loc1: u64)

72ImmBorrowLoc[4](Arg4: Balance<Ty0>)

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

74CopyLoc[8](loc1: u64)

75Ge

76BrFalse(83)

B13:

77ImmBorrowLoc[5](Arg5: Balance<Ty1>)

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

79CopyLoc[9](loc2: u64)

80Ge

81StLoc[7](loc0: bool)

82Branch(85)

B14:

83LdFalse

84StLoc[7](loc0: bool)

B15:

85MoveLoc[7](loc0: bool)

86BrFalse(88)

B16:

87Branch(94)

B17:

88MoveLoc[3](Arg3: &mut Position)

89Pop

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

91Pop

92Call errors::insufficient_amount(): u64

93Abort

B18:

94CopyLoc[2](Arg2: &mut Pool<Ty0, Ty1>)

95ImmBorrowFieldGeneric[4](Pool.sequence_number: u128)

96ReadRef

97LdU128(1)

98Add

99CopyLoc[2](Arg2: &mut Pool<Ty0, Ty1>)

100MutBorrowFieldGeneric[4](Pool.sequence_number: u128)

101WriteRef

102CopyLoc[2](Arg2: &mut Pool<Ty0, Ty1>)

103MutBorrowFieldGeneric[2](Pool.coin_a: Balance<Ty0>)

104MoveLoc[4](Arg4: Balance<Ty0>)

105CopyLoc[8](loc1: u64)

106Call utils::deposit_balance<Ty0>(&mut Balance<Ty0>, Balance<Ty0>, u64): Balance<Ty0>

107CopyLoc[2](Arg2: &mut Pool<Ty0, Ty1>)

108MutBorrowFieldGeneric[3](Pool.coin_b: Balance<Ty1>)

109MoveLoc[5](Arg5: Balance<Ty1>)

110CopyLoc[9](loc2: u64)

111Call utils::deposit_balance<Ty1>(&mut Balance<Ty1>, Balance<Ty1>, u64): Balance<Ty1>

112StLoc[5](Arg5: Balance<Ty1>)

113StLoc[4](Arg4: Balance<Ty0>)

114CopyLoc[2](Arg2: &mut Pool<Ty0, Ty1>)

115FreezeRef

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

117CopyLoc[3](Arg3: &mut Position)

118FreezeRef

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

120CopyLoc[8](loc1: u64)

121CopyLoc[9](loc2: u64)

122CopyLoc[2](Arg2: &mut Pool<Ty0, Ty1>)

123ImmBorrowFieldGeneric[2](Pool.coin_a: Balance<Ty0>)

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

125CopyLoc[2](Arg2: &mut Pool<Ty0, Ty1>)

126ImmBorrowFieldGeneric[3](Pool.coin_b: Balance<Ty1>)

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

128MoveLoc[6](Arg6: u128)

129MoveLoc[10](loc3: u128)

130CopyLoc[2](Arg2: &mut Pool<Ty0, Ty1>)

131ImmBorrowFieldGeneric[7](Pool.liquidity: u128)

132ReadRef

133CopyLoc[2](Arg2: &mut Pool<Ty0, Ty1>)

134ImmBorrowFieldGeneric[13](Pool.current_sqrt_price: u128)

135ReadRef

136CopyLoc[2](Arg2: &mut Pool<Ty0, Ty1>)

137ImmBorrowFieldGeneric[12](Pool.current_tick_index: I32)

138ReadRef

139CopyLoc[3](Arg3: &mut Position)

140FreezeRef

141Call position::lower_tick(&Position): I32

142MoveLoc[3](Arg3: &mut Position)

143FreezeRef

144Call position::upper_tick(&Position): I32

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

146ImmBorrowFieldGeneric[4](Pool.sequence_number: u128)

147ReadRef

148Call events::emit_liquidity_provided_event(ID, ID, u64, u64, u64, u64, u128, u128, u128, u128, I32, I32, I32, u128)

149MoveLoc[8](loc1: u64)

150MoveLoc[9](loc2: u64)

151MoveLoc[4](Arg4: Balance<Ty0>)

152MoveLoc[5](Arg5: Balance<Ty1>)

153Ret

}

public remove_liquidity<Ty0, Ty1>(Arg0: &GlobalConfig, Arg1: &mut Pool<Ty0, Ty1>, Arg2: &mut Position, Arg3: u128, Arg4: &Clock): u64 * u64 * Balance<Ty0> * Balance<Ty1> {

L5: loc0: Balance<Ty0>

L6: loc1: Balance<Ty1>

L7: loc2: u64

L8: loc3: u64

L9: loc4: u128

B0:

0MoveLoc[0](Arg0: &GlobalConfig)

1Call config::verify_version(&GlobalConfig)

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

3FreezeRef

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

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

6FreezeRef

7Call position::pool_id(&Position): ID

8Eq

9BrFalse(11)

B1:

10Branch(19)

B2:

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

12Pop

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

14Pop

15MoveLoc[4](Arg4: &Clock)

16Pop

17Call errors::position_does_not_belong_to_pool(): u64

18Abort

B3:

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

20ImmBorrowFieldGeneric[8](Pool.is_paused: bool)

21ReadRef

22Not

23BrFalse(25)

B4:

24Branch(33)

B5:

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

26Pop

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

28Pop

29MoveLoc[4](Arg4: &Clock)

30Pop

31Call errors::pool_is_paused(): u64

32Abort

B6:

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

34ImmBorrowFieldGeneric[5](Pool.id: UID)

35Call is_flash_swap_in_progress(&UID): bool

36Not

37BrFalse(39)

B7:

38Branch(47)

B8:

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

40Pop

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

42Pop

43MoveLoc[4](Arg4: &Clock)

44Pop

45Call errors::flash_swap_in_progress(): u64

46Abort

B9:

47CopyLoc[3](Arg3: u128)

48LdU128(0)

49Gt

50BrFalse(52)

B10:

51Branch(60)

B11:

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

53Pop

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

55Pop

56MoveLoc[4](Arg4: &Clock)

57Pop

58Call errors::zero_amount(): u64

59Abort

B12:

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

61ImmBorrowFieldGeneric[7](Pool.liquidity: u128)

62ReadRef

63StLoc[9](loc4: u128)

64MoveLoc[4](Arg4: &Clock)

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

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

67CopyLoc[3](Arg3: u128)

68Call i128::neg_from(u128): I128

69Call update_data_for_delta_l<Ty0, Ty1>(&Clock, &mut Pool<Ty0, Ty1>, &mut Position, I128): u64 * u64

70StLoc[8](loc3: u64)

71StLoc[7](loc2: u64)

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

73CopyLoc[7](loc2: u64)

74CopyLoc[8](loc3: u64)

75Call withdraw_balances<Ty0, Ty1>(&mut Pool<Ty0, Ty1>, u64, u64): Balance<Ty0> * Balance<Ty1>

76StLoc[6](loc1: Balance<Ty1>)

77StLoc[5](loc0: Balance<Ty0>)

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

79ImmBorrowFieldGeneric[4](Pool.sequence_number: u128)

80ReadRef

81LdU128(1)

82Add

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

84MutBorrowFieldGeneric[4](Pool.sequence_number: u128)

85WriteRef

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

87FreezeRef

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

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

90FreezeRef

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

92CopyLoc[7](loc2: u64)

93CopyLoc[8](loc3: u64)

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

95ImmBorrowFieldGeneric[2](Pool.coin_a: Balance<Ty0>)

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

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

98ImmBorrowFieldGeneric[3](Pool.coin_b: Balance<Ty1>)

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

100MoveLoc[3](Arg3: u128)

101MoveLoc[9](loc4: u128)

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

103ImmBorrowFieldGeneric[7](Pool.liquidity: u128)

104ReadRef

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

106ImmBorrowFieldGeneric[13](Pool.current_sqrt_price: u128)

107ReadRef

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

109ImmBorrowFieldGeneric[12](Pool.current_tick_index: I32)

110ReadRef

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

112FreezeRef

113Call position::lower_tick(&Position): I32

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

115FreezeRef

116Call position::upper_tick(&Position): I32

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

118ImmBorrowFieldGeneric[4](Pool.sequence_number: u128)

119ReadRef

120Call events::emit_liquidity_removed_event(ID, ID, u64, u64, u64, u64, u128, u128, u128, u128, I32, I32, I32, u128)

121MoveLoc[7](loc2: u64)

122MoveLoc[8](loc3: u64)

123MoveLoc[5](loc0: Balance<Ty0>)

124MoveLoc[6](loc1: Balance<Ty1>)

125Ret

}

public swap<Ty0, Ty1>(Arg0: &Clock, Arg1: &GlobalConfig, Arg2: &mut Pool<Ty0, Ty1>, Arg3: Balance<Ty0>, Arg4: Balance<Ty1>, Arg5: bool, Arg6: bool, Arg7: u64, Arg8: u64, Arg9: u128): Balance<Ty0> * Balance<Ty1> {

L10: loc0: u64

L11: loc1: u64

L12: loc2: u64

L13: loc3: u64

L14: loc4: SwapResult

B0:

0MoveLoc[1](Arg1: &GlobalConfig)

1Call config::verify_version(&GlobalConfig)

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

3ImmBorrowFieldGeneric[8](Pool.is_paused: bool)

4ReadRef

5Not

6BrFalse(8)

B1:

7Branch(14)

B2:

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

9Pop

10MoveLoc[0](Arg0: &Clock)

11Pop

12Call errors::pool_is_paused(): u64

13Abort

B3:

14CopyLoc[2](Arg2: &mut Pool<Ty0, Ty1>)

15ImmBorrowFieldGeneric[5](Pool.id: UID)

16Call is_flash_swap_in_progress(&UID): bool

17Not

18BrFalse(20)

B4:

19Branch(26)

B5:

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

21Pop

22MoveLoc[0](Arg0: &Clock)

23Pop

24Call errors::flash_swap_in_progress(): u64

25Abort

B6:

26CopyLoc[7](Arg7: u64)

27LdU64(0)

28Gt

29BrFalse(31)

B7:

30Branch(37)

B8:

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

32Pop

33MoveLoc[0](Arg0: &Clock)

34Pop

35Call errors::zero_amount(): u64

36Abort

B9:

37MoveLoc[0](Arg0: &Clock)

38CopyLoc[2](Arg2: &mut Pool<Ty0, Ty1>)

39CopyLoc[5](Arg5: bool)

40CopyLoc[6](Arg6: bool)

41MoveLoc[7](Arg7: u64)

42MoveLoc[9](Arg9: u128)

43Call swap_in_pool<Ty0, Ty1>(&Clock, &mut Pool<Ty0, Ty1>, bool, bool, u64, u128): SwapResult

44StLoc[14](loc4: SwapResult)

45MoveLoc[6](Arg6: bool)

46BrFalse(71)

B10:

47ImmBorrowLoc[14](loc4: SwapResult)

48ImmBorrowField[23](SwapResult.amount_calculated: u64)

49ReadRef

50MoveLoc[8](Arg8: u64)

51Ge

52BrFalse(54)

B11:

53Branch(58)

B12:

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

55Pop

56Call errors::slippage_exceeds(): u64

57Abort

B13:

58ImmBorrowLoc[14](loc4: SwapResult)

59ImmBorrowField[24](SwapResult.amount_specified: u64)

60ReadRef

61ImmBorrowLoc[14](loc4: SwapResult)

62ImmBorrowField[25](SwapResult.amount_specified_remaining: u64)

63ReadRef

64Sub

65ImmBorrowLoc[14](loc4: SwapResult)

66ImmBorrowField[23](SwapResult.amount_calculated: u64)

67ReadRef

68StLoc[11](loc1: u64)

69StLoc[10](loc0: u64)

70Branch(94)

B14:

71ImmBorrowLoc[14](loc4: SwapResult)

72ImmBorrowField[23](SwapResult.amount_calculated: u64)

73ReadRef

74MoveLoc[8](Arg8: u64)

75Le

76BrFalse(78)

B15:

77Branch(82)

B16:

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

79Pop

80Call errors::slippage_exceeds(): u64

81Abort

B17:

82ImmBorrowLoc[14](loc4: SwapResult)

83ImmBorrowField[23](SwapResult.amount_calculated: u64)

84ReadRef

85ImmBorrowLoc[14](loc4: SwapResult)

86ImmBorrowField[24](SwapResult.amount_specified: u64)

87ReadRef

88ImmBorrowLoc[14](loc4: SwapResult)

89ImmBorrowField[25](SwapResult.amount_specified_remaining: u64)

90ReadRef

91Sub

92StLoc[11](loc1: u64)

93StLoc[10](loc0: u64)

B18:

94MoveLoc[10](loc0: u64)

95MoveLoc[11](loc1: u64)

96StLoc[13](loc3: u64)

97StLoc[12](loc2: u64)

98CopyLoc[5](Arg5: bool)

99BrFalse(114)

B19:

100CopyLoc[2](Arg2: &mut Pool<Ty0, Ty1>)

101MutBorrowFieldGeneric[2](Pool.coin_a: Balance<Ty0>)

102MoveLoc[3](Arg3: Balance<Ty0>)

103CopyLoc[12](loc2: u64)

104Call utils::deposit_balance<Ty0>(&mut Balance<Ty0>, Balance<Ty0>, u64): Balance<Ty0>

105StLoc[3](Arg3: Balance<Ty0>)

106MoveLoc[4](Arg4: Balance<Ty1>)

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

108CopyLoc[2](Arg2: &mut Pool<Ty0, Ty1>)

109MutBorrowFieldGeneric[3](Pool.coin_b: Balance<Ty1>)

110CopyLoc[13](loc3: u64)

111Call utils::withdraw_balance<Ty1>(&mut Balance<Ty1>, u64): Balance<Ty1>

112StLoc[4](Arg4: Balance<Ty1>)

113Branch(127)

B20:

114CopyLoc[2](Arg2: &mut Pool<Ty0, Ty1>)

115MutBorrowFieldGeneric[3](Pool.coin_b: Balance<Ty1>)

116MoveLoc[4](Arg4: Balance<Ty1>)

117CopyLoc[12](loc2: u64)

118Call utils::deposit_balance<Ty1>(&mut Balance<Ty1>, Balance<Ty1>, u64): Balance<Ty1>

119StLoc[4](Arg4: Balance<Ty1>)

120MoveLoc[3](Arg3: Balance<Ty0>)

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

122CopyLoc[2](Arg2: &mut Pool<Ty0, Ty1>)

123MutBorrowFieldGeneric[2](Pool.coin_a: Balance<Ty0>)

124CopyLoc[13](loc3: u64)

125Call utils::withdraw_balance<Ty0>(&mut Balance<Ty0>, u64): Balance<Ty0>

126StLoc[3](Arg3: Balance<Ty0>)

B21:

127CopyLoc[2](Arg2: &mut Pool<Ty0, Ty1>)

128ImmBorrowFieldGeneric[5](Pool.id: UID)

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

130MoveLoc[5](Arg5: bool)

131MoveLoc[12](loc2: u64)

132MoveLoc[13](loc3: u64)

133CopyLoc[2](Arg2: &mut Pool<Ty0, Ty1>)

134ImmBorrowFieldGeneric[2](Pool.coin_a: Balance<Ty0>)

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

136CopyLoc[2](Arg2: &mut Pool<Ty0, Ty1>)

137ImmBorrowFieldGeneric[3](Pool.coin_b: Balance<Ty1>)

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

139ImmBorrowLoc[14](loc4: SwapResult)

140ImmBorrowField[26](SwapResult.fee_amount: u64)

141ReadRef

142ImmBorrowLoc[14](loc4: SwapResult)

143ImmBorrowField[27](SwapResult.protocol_fee: u64)

144ReadRef

145Add

146ImmBorrowLoc[14](loc4: SwapResult)

147ImmBorrowField[28](SwapResult.starting_liquidity: u128)

148ReadRef

149ImmBorrowLoc[14](loc4: SwapResult)

150ImmBorrowField[29](SwapResult.liquidity: u128)

151ReadRef

152ImmBorrowLoc[14](loc4: SwapResult)

153ImmBorrowField[30](SwapResult.start_sqrt_price: u128)

154ReadRef

155ImmBorrowLoc[14](loc4: SwapResult)

156ImmBorrowField[31](SwapResult.end_sqrt_price: u128)

157ReadRef

158CopyLoc[2](Arg2: &mut Pool<Ty0, Ty1>)

159ImmBorrowFieldGeneric[12](Pool.current_tick_index: I32)

160ReadRef

161ImmBorrowLoc[14](loc4: SwapResult)

162ImmBorrowField[32](SwapResult.is_exceed: bool)

163ReadRef

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

165ImmBorrowFieldGeneric[4](Pool.sequence_number: u128)

166ReadRef

167Call events::emit_swap_event(ID, bool, u64, u64, u64, u64, u64, u128, u128, u128, u128, I32, bool, u128)

168MoveLoc[3](Arg3: Balance<Ty0>)

169MoveLoc[4](Arg4: Balance<Ty1>)

170Ret

}

public flash_swap<Ty0, Ty1>(Arg0: &Clock, Arg1: &GlobalConfig, Arg2: &mut Pool<Ty0, Ty1>, Arg3: bool, Arg4: bool, Arg5: u64, Arg6: u128): Balance<Ty0> * Balance<Ty1> * FlashSwapReceipt<Ty0, Ty1> {

L7: loc0: u64

L8: loc1: u64

L9: loc2: Balance<Ty0>

L10: loc3: Balance<Ty1>

L11: loc4: u64

L12: loc5: u64

L13: loc6: Balance<Ty0>

L14: loc7: Balance<Ty1>

L15: loc8: FlashSwapReceipt<Ty0, Ty1>

L16: loc9: SwapResult

B0:

0MoveLoc[1](Arg1: &GlobalConfig)

1Call config::verify_version(&GlobalConfig)

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

3ImmBorrowFieldGeneric[8](Pool.is_paused: bool)

4ReadRef

5Not

6BrFalse(8)

B1:

7Branch(14)

B2:

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

9Pop

10MoveLoc[0](Arg0: &Clock)

11Pop

12Call errors::pool_is_paused(): u64

13Abort

B3:

14CopyLoc[2](Arg2: &mut Pool<Ty0, Ty1>)

15ImmBorrowFieldGeneric[5](Pool.id: UID)

16Call is_flash_swap_in_progress(&UID): bool

17Not

18BrFalse(20)

B4:

19Branch(26)

B5:

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

21Pop

22MoveLoc[0](Arg0: &Clock)

23Pop

24Call errors::flash_swap_in_progress(): u64

25Abort

B6:

26CopyLoc[2](Arg2: &mut Pool<Ty0, Ty1>)

27MutBorrowFieldGeneric[5](Pool.id: UID)

28Call constants::flash_swap_in_progress_key(): vector<u8>

29LdTrue

30Call dynamic_field::add<vector<u8>, bool>(&mut UID, vector<u8>, bool)

31CopyLoc[5](Arg5: u64)

32LdU64(0)

33Gt

34BrFalse(36)

B7:

35Branch(42)

B8:

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

37Pop

38MoveLoc[0](Arg0: &Clock)

39Pop

40Call errors::zero_amount(): u64

41Abort

B9:

42MoveLoc[0](Arg0: &Clock)

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

44CopyLoc[3](Arg3: bool)

45CopyLoc[4](Arg4: bool)

46MoveLoc[5](Arg5: u64)

47MoveLoc[6](Arg6: u128)

48Call swap_in_pool<Ty0, Ty1>(&Clock, &mut Pool<Ty0, Ty1>, bool, bool, u64, u128): SwapResult

49StLoc[16](loc9: SwapResult)

50MoveLoc[4](Arg4: bool)

51BrFalse(65)

B10:

52ImmBorrowLoc[16](loc9: SwapResult)

53ImmBorrowField[24](SwapResult.amount_specified: u64)

54ReadRef

55ImmBorrowLoc[16](loc9: SwapResult)

56ImmBorrowField[25](SwapResult.amount_specified_remaining: u64)

57ReadRef

58Sub

59ImmBorrowLoc[16](loc9: SwapResult)

60ImmBorrowField[23](SwapResult.amount_calculated: u64)

61ReadRef

62StLoc[8](loc1: u64)

63StLoc[7](loc0: u64)

64Branch(77)

B11:

65ImmBorrowLoc[16](loc9: SwapResult)

66ImmBorrowField[23](SwapResult.amount_calculated: u64)

67ReadRef

68ImmBorrowLoc[16](loc9: SwapResult)

69ImmBorrowField[24](SwapResult.amount_specified: u64)

70ReadRef

71ImmBorrowLoc[16](loc9: SwapResult)

72ImmBorrowField[25](SwapResult.amount_specified_remaining: u64)

73ReadRef

74Sub

75StLoc[8](loc1: u64)

76StLoc[7](loc0: u64)

B12:

77MoveLoc[7](loc0: u64)

78MoveLoc[8](loc1: u64)

79StLoc[12](loc5: u64)

80StLoc[11](loc4: u64)

81CopyLoc[3](Arg3: bool)

82BrFalse(91)

B13:

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

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

85MutBorrowFieldGeneric[3](Pool.coin_b: Balance<Ty1>)

86CopyLoc[12](loc5: u64)

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

88StLoc[10](loc3: Balance<Ty1>)

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

90Branch(98)

B14:

91CopyLoc[2](Arg2: &mut Pool<Ty0, Ty1>)

92MutBorrowFieldGeneric[2](Pool.coin_a: Balance<Ty0>)

93CopyLoc[12](loc5: u64)

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

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

96StLoc[10](loc3: Balance<Ty1>)

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

B15:

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

99MoveLoc[10](loc3: Balance<Ty1>)

100StLoc[14](loc7: Balance<Ty1>)

101StLoc[13](loc6: Balance<Ty0>)

102CopyLoc[2](Arg2: &mut Pool<Ty0, Ty1>)

103ImmBorrowFieldGeneric[5](Pool.id: UID)

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

105CopyLoc[3](Arg3: bool)

106CopyLoc[11](loc4: u64)

107MoveLoc[12](loc5: u64)

108ImmBorrowLoc[16](loc9: SwapResult)

109ImmBorrowField[26](SwapResult.fee_amount: u64)

110ReadRef

111ImmBorrowLoc[16](loc9: SwapResult)

112ImmBorrowField[27](SwapResult.protocol_fee: u64)

113ReadRef

114Add

115ImmBorrowLoc[16](loc9: SwapResult)

116ImmBorrowField[28](SwapResult.starting_liquidity: u128)

117ReadRef

118ImmBorrowLoc[16](loc9: SwapResult)

119ImmBorrowField[29](SwapResult.liquidity: u128)

120ReadRef

121ImmBorrowLoc[16](loc9: SwapResult)

122ImmBorrowField[30](SwapResult.start_sqrt_price: u128)

123ReadRef

124ImmBorrowLoc[16](loc9: SwapResult)

125ImmBorrowField[31](SwapResult.end_sqrt_price: u128)

126ReadRef

127CopyLoc[2](Arg2: &mut Pool<Ty0, Ty1>)

128ImmBorrowFieldGeneric[12](Pool.current_tick_index: I32)

129ReadRef

130ImmBorrowLoc[16](loc9: SwapResult)

131ImmBorrowField[32](SwapResult.is_exceed: bool)

132ReadRef

133CopyLoc[2](Arg2: &mut Pool<Ty0, Ty1>)

134ImmBorrowFieldGeneric[4](Pool.sequence_number: u128)

135ReadRef

136Call events::emit_flash_swap_event(ID, bool, u64, u64, u64, u128, u128, u128, u128, I32, bool, u128)

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

138FreezeRef

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

140MoveLoc[3](Arg3: bool)

141MoveLoc[11](loc4: u64)

142PackGeneric[0](FlashSwapReceipt<Ty0, Ty1>)

143StLoc[15](loc8: FlashSwapReceipt<Ty0, Ty1>)

144MoveLoc[13](loc6: Balance<Ty0>)

145MoveLoc[14](loc7: Balance<Ty1>)

146MoveLoc[15](loc8: FlashSwapReceipt<Ty0, Ty1>)

147Ret

}

public calculate_swap_results<Ty0, Ty1>(Arg0: &Pool<Ty0, Ty1>, Arg1: bool, Arg2: bool, Arg3: u64, Arg4: u128): SwapResult {

L5: loc0: bool

L6: loc1: u128

L7: loc2: u128

L8: loc3: u128

L9: loc4: u128

L10: loc5: I32

L11: loc6: u128

L12: loc7: u128

L13: loc8: vector<SwapStepResult>

L14: loc9: bool

L15: loc10: bool

L16: loc11: u128

L17: loc12: I128

L18: loc13: I32

L19: loc14: bool

L20: loc15: bool

L21: loc16: bool

L22: loc17: u64

L23: loc18: u64

L24: loc19: u64

L25: loc20: u64

L26: loc21: u64

L27: loc22: bool

L28: loc23: I128

L29: loc24: u128

L30: loc25: u64

L31: loc26: SwapStepResult

L32: loc27: SwapResult

L33: loc28: u128

B0:

0CopyLoc[1](Arg1: bool)

1BrFalse(23)

B1:

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

3ImmBorrowFieldGeneric[13](Pool.current_sqrt_price: u128)

4ReadRef

5CopyLoc[4](Arg4: u128)

6Gt

7BrFalse(13)

B2:

8CopyLoc[4](Arg4: u128)

9Call tick_math::min_sqrt_price(): u128

10Ge

11StLoc[5](loc0: bool)

12Branch(15)

B3:

13LdFalse

14StLoc[5](loc0: bool)

B4:

15MoveLoc[5](loc0: bool)

16BrFalse(18)

B5:

17Branch(22)

B6:

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

19Pop

20Call errors::invalid_price_limit(): u64

21Abort

B7:

22Branch(43)

B8:

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

24ImmBorrowFieldGeneric[13](Pool.current_sqrt_price: u128)

25ReadRef

26CopyLoc[4](Arg4: u128)

27Lt

28BrFalse(34)

B9:

29CopyLoc[4](Arg4: u128)

30Call tick_math::max_sqrt_price(): u128

31Le

32StLoc[14](loc9: bool)

33Branch(36)

B10:

34LdFalse

35StLoc[14](loc9: bool)

B11:

36MoveLoc[14](loc9: bool)

37BrFalse(39)

B12:

38Branch(43)

B13:

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

40Pop

41Call errors::invalid_price_limit(): u64

42Abort

B14:

43CopyLoc[1](Arg1: bool)

44StLoc[20](loc15: bool)

45CopyLoc[2](Arg2: bool)

46StLoc[21](loc16: bool)

47CopyLoc[3](Arg3: u64)

48StLoc[22](loc17: u64)

49MoveLoc[3](Arg3: u64)

50StLoc[23](loc18: u64)

51CopyLoc[1](Arg1: bool)

52BrFalse(58)

B15:

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

54ImmBorrowFieldGeneric[14](Pool.fee_growth_global_coin_a: u128)

55ReadRef

56StLoc[6](loc1: u128)

57Branch(62)

B16:

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

59ImmBorrowFieldGeneric[15](Pool.fee_growth_global_coin_b: u128)

60ReadRef

61StLoc[6](loc1: u128)

B17:

62MoveLoc[6](loc1: u128)

63StLoc[7](loc2: u128)

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

65ImmBorrowFieldGeneric[13](Pool.current_sqrt_price: u128)

66ReadRef

67StLoc[8](loc3: u128)

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

69ImmBorrowFieldGeneric[13](Pool.current_sqrt_price: u128)

70ReadRef

71StLoc[9](loc4: u128)

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

73ImmBorrowFieldGeneric[12](Pool.current_tick_index: I32)

74ReadRef

75StLoc[10](loc5: I32)

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

77ImmBorrowFieldGeneric[7](Pool.liquidity: u128)

78ReadRef

79StLoc[11](loc6: u128)

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

81ImmBorrowFieldGeneric[7](Pool.liquidity: u128)

82ReadRef

83StLoc[12](loc7: u128)

84VecPack(105, 0)

85StLoc[13](loc8: vector<SwapStepResult>)

86MoveLoc[20](loc15: bool)

87MoveLoc[21](loc16: bool)

88MoveLoc[22](loc17: u64)

89MoveLoc[23](loc18: u64)

90LdU64(0)

91MoveLoc[7](loc2: u128)

92LdU64(0)

93LdU64(0)

94MoveLoc[8](loc3: u128)

95MoveLoc[9](loc4: u128)

96MoveLoc[10](loc5: I32)

97LdFalse

98MoveLoc[11](loc6: u128)

99MoveLoc[12](loc7: u128)

100LdU64(0)

101MoveLoc[13](loc8: vector<SwapStepResult>)

102Pack[2](SwapResult)

103StLoc[32](loc27: SwapResult)

B18:

104ImmBorrowLoc[32](loc27: SwapResult)

105ImmBorrowField[25](SwapResult.amount_specified_remaining: u64)

106ReadRef

107LdU64(0)

108Gt

109BrFalse(118)

B19:

110Branch(111)

B20:

111ImmBorrowLoc[32](loc27: SwapResult)

112ImmBorrowField[31](SwapResult.end_sqrt_price: u128)

113ReadRef

114CopyLoc[4](Arg4: u128)

115Neq

116StLoc[15](loc10: bool)

117Branch(120)

B21:

118LdFalse

119StLoc[15](loc10: bool)

B22:

120MoveLoc[15](loc10: bool)

121BrFalse(427)

B23:

122Call 0i32::zero(): I32

123LdFalse

124ImmBorrowLoc[32](loc27: SwapResult)

125ImmBorrowField[31](SwapResult.end_sqrt_price: u128)

126ReadRef

127LdU128(0)

128LdU64(0)

129LdU64(0)

130LdU64(0)

131LdU64(0)

132Pack[3](SwapStepResult)

133StLoc[31](loc26: SwapStepResult)

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

135ImmBorrowFieldGeneric[16](Pool.ticks_manager: TickManager)

136Call tick::bitmap(&TickManager): &Table<I32, u256>

137ImmBorrowLoc[32](loc27: SwapResult)

138ImmBorrowField[36](SwapResult.current_tick_index: I32)

139ReadRef

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

141ImmBorrowFieldGeneric[16](Pool.ticks_manager: TickManager)

142Call tick::tick_spacing(&TickManager): u32

143CopyLoc[1](Arg1: bool)

144Call tick_bitmap::next_initialized_tick_within_one_word(&Table<I32, u256>, I32, u32, bool): I32 * bool

145StLoc[27](loc22: bool)

146MutBorrowLoc[31](loc26: SwapStepResult)

147MutBorrowField[37](SwapStepResult.tick_index_next: I32)

148WriteRef

149MoveLoc[27](loc22: bool)

150MutBorrowLoc[31](loc26: SwapStepResult)

151MutBorrowField[38](SwapStepResult.initialized: bool)

152WriteRef

153ImmBorrowLoc[31](loc26: SwapStepResult)

154ImmBorrowField[37](SwapStepResult.tick_index_next: I32)

155ReadRef

156Call tick_math::min_tick(): I32

157Call i32H::lt(I32, I32): bool

158BrFalse(164)

B24:

159Call tick_math::min_tick(): I32

160MutBorrowLoc[31](loc26: SwapStepResult)

161MutBorrowField[37](SwapStepResult.tick_index_next: I32)

162WriteRef

163Branch(174)

B25:

164ImmBorrowLoc[31](loc26: SwapStepResult)

165ImmBorrowField[37](SwapStepResult.tick_index_next: I32)

166ReadRef

167Call tick_math::max_tick(): I32

168Call i32H::gt(I32, I32): bool

169BrFalse(174)

B26:

170Call tick_math::max_tick(): I32

171MutBorrowLoc[31](loc26: SwapStepResult)

172MutBorrowField[37](SwapStepResult.tick_index_next: I32)

173WriteRef

B27:

174ImmBorrowLoc[31](loc26: SwapStepResult)

175ImmBorrowField[37](SwapStepResult.tick_index_next: I32)

176ReadRef

177Call tick_math::get_sqrt_price_at_tick(I32): u128

178MutBorrowLoc[31](loc26: SwapStepResult)

179MutBorrowField[39](SwapStepResult.sqrt_price_next: u128)

180WriteRef

181CopyLoc[1](Arg1: bool)

182BrFalse(190)

B28:

183ImmBorrowLoc[31](loc26: SwapStepResult)

184ImmBorrowField[39](SwapStepResult.sqrt_price_next: u128)

185ReadRef

186CopyLoc[4](Arg4: u128)

187Call math_u128::max(u128, u128): u128

188StLoc[16](loc11: u128)

189Branch(196)

B29:

190ImmBorrowLoc[31](loc26: SwapStepResult)

191ImmBorrowField[39](SwapStepResult.sqrt_price_next: u128)

192ReadRef

193CopyLoc[4](Arg4: u128)

194Call math_u128::min(u128, u128): u128

195StLoc[16](loc11: u128)

B30:

196MoveLoc[16](loc11: u128)

197StLoc[33](loc28: u128)

198ImmBorrowLoc[32](loc27: SwapResult)

199ImmBorrowField[31](SwapResult.end_sqrt_price: u128)

200ReadRef

201MoveLoc[33](loc28: u128)

202ImmBorrowLoc[32](loc27: SwapResult)

203ImmBorrowField[29](SwapResult.liquidity: u128)

204ReadRef

205ImmBorrowLoc[32](loc27: SwapResult)

206ImmBorrowField[25](SwapResult.amount_specified_remaining: u64)

207ReadRef

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

209ImmBorrowFieldGeneric[17](Pool.fee_rate: u64)

210ReadRef

211CopyLoc[1](Arg1: bool)

212CopyLoc[2](Arg2: bool)

213Call clmm_math::compute_swap_step(u128, u128, u128, u64, u64, bool, bool): u64 * u64 * u128 * u64

214StLoc[26](loc21: u64)

215StLoc[29](loc24: u128)

216StLoc[25](loc20: u64)

217StLoc[24](loc19: u64)

218MoveLoc[29](loc24: u128)

219MutBorrowLoc[32](loc27: SwapResult)

220MutBorrowField[31](SwapResult.end_sqrt_price: u128)

221WriteRef

222CopyLoc[2](Arg2: bool)

223BrFalse(243)

B31:

224ImmBorrowLoc[32](loc27: SwapResult)

225ImmBorrowField[25](SwapResult.amount_specified_remaining: u64)

226ReadRef

227CopyLoc[24](loc19: u64)

228Sub

229CopyLoc[26](loc21: u64)

230Sub

231MutBorrowLoc[32](loc27: SwapResult)

232MutBorrowField[25](SwapResult.amount_specified_remaining: u64)

233WriteRef

234ImmBorrowLoc[32](loc27: SwapResult)

235ImmBorrowField[23](SwapResult.amount_calculated: u64)

236ReadRef

237CopyLoc[25](loc20: u64)

238Add

239MutBorrowLoc[32](loc27: SwapResult)

240MutBorrowField[23](SwapResult.amount_calculated: u64)

241WriteRef

242Branch(261)

B32:

243ImmBorrowLoc[32](loc27: SwapResult)

244ImmBorrowField[25](SwapResult.amount_specified_remaining: u64)

245ReadRef

246CopyLoc[25](loc20: u64)

247Sub

248MutBorrowLoc[32](loc27: SwapResult)

249MutBorrowField[25](SwapResult.amount_specified_remaining: u64)

250WriteRef

251ImmBorrowLoc[32](loc27: SwapResult)

252ImmBorrowField[23](SwapResult.amount_calculated: u64)

253ReadRef

254CopyLoc[24](loc19: u64)

255Add

256CopyLoc[26](loc21: u64)

257Add

258MutBorrowLoc[32](loc27: SwapResult)

259MutBorrowField[23](SwapResult.amount_calculated: u64)

260WriteRef

B33:

261MoveLoc[24](loc19: u64)

262MutBorrowLoc[31](loc26: SwapStepResult)

263MutBorrowField[41](SwapStepResult.amount_in: u64)

264WriteRef

265MoveLoc[25](loc20: u64)

266MutBorrowLoc[31](loc26: SwapStepResult)

267MutBorrowField[42](SwapStepResult.amount_out: u64)

268WriteRef

269CopyLoc[26](loc21: u64)

270MutBorrowLoc[31](loc26: SwapStepResult)

271MutBorrowField[43](SwapStepResult.fee_amount: u64)

272WriteRef

273ImmBorrowLoc[32](loc27: SwapResult)

274ImmBorrowField[25](SwapResult.amount_specified_remaining: u64)

275ReadRef

276MutBorrowLoc[31](loc26: SwapStepResult)

277MutBorrowField[44](SwapStepResult.remaining_amount: u64)

278WriteRef

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

280ImmBorrowFieldGeneric[9](Pool.protocol_fee_share: u64)

281ReadRef

282LdU64(0)

283Gt

284BrFalse(308)

B34:

285MoveLoc[26](loc21: u64)

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

287ImmBorrowFieldGeneric[9](Pool.protocol_fee_share: u64)

288ReadRef

289Call clmm_math::fee_rate_denominator(): u64

290Call full_math_u64::mul_div_floor(u64, u64, u64): u64

291StLoc[30](loc25: u64)

292ImmBorrowLoc[31](loc26: SwapStepResult)

293ImmBorrowField[43](SwapStepResult.fee_amount: u64)

294ReadRef

295CopyLoc[30](loc25: u64)

296Sub

297MutBorrowLoc[31](loc26: SwapStepResult)

298MutBorrowField[43](SwapStepResult.fee_amount: u64)

299WriteRef

300ImmBorrowLoc[32](loc27: SwapResult)

301ImmBorrowField[27](SwapResult.protocol_fee: u64)

302ReadRef

303MoveLoc[30](loc25: u64)

304Add

305MutBorrowLoc[32](loc27: SwapResult)

306MutBorrowField[27](SwapResult.protocol_fee: u64)

307WriteRef

B35:

308ImmBorrowLoc[32](loc27: SwapResult)

309ImmBorrowField[29](SwapResult.liquidity: u128)

310ReadRef

311LdU128(0)

312Gt

313BrFalse(330)

B36:

314ImmBorrowLoc[32](loc27: SwapResult)

315ImmBorrowField[45](SwapResult.fee_growth_global: u128)

316ReadRef

317ImmBorrowLoc[31](loc26: SwapStepResult)

318ImmBorrowField[43](SwapStepResult.fee_amount: u64)

319ReadRef

320CastU128

321Call constants::q64(): u128

322ImmBorrowLoc[32](loc27: SwapResult)

323ImmBorrowField[29](SwapResult.liquidity: u128)

324ReadRef

325Call full_math_u128::mul_div_floor(u128, u128, u128): u128

326Call math_u128::wrapping_add(u128, u128): u128

327MutBorrowLoc[32](loc27: SwapResult)

328MutBorrowField[45](SwapResult.fee_growth_global: u128)

329WriteRef

B37:

330ImmBorrowLoc[32](loc27: SwapResult)

331ImmBorrowField[26](SwapResult.fee_amount: u64)

332ReadRef

333ImmBorrowLoc[31](loc26: SwapStepResult)

334ImmBorrowField[43](SwapStepResult.fee_amount: u64)

335ReadRef

336Add

337MutBorrowLoc[32](loc27: SwapResult)

338MutBorrowField[26](SwapResult.fee_amount: u64)

339WriteRef

340ImmBorrowLoc[32](loc27: SwapResult)

341ImmBorrowField[46](SwapResult.steps: u64)

342ReadRef

343LdU64(1)

344Add

345MutBorrowLoc[32](loc27: SwapResult)

346MutBorrowField[46](SwapResult.steps: u64)

347WriteRef

348MutBorrowLoc[32](loc27: SwapResult)

349MutBorrowField[47](SwapResult.step_results: vector<SwapStepResult>)

350CopyLoc[31](loc26: SwapStepResult)

351VecPushBack(105)

352ImmBorrowLoc[32](loc27: SwapResult)

353ImmBorrowField[31](SwapResult.end_sqrt_price: u128)

354ReadRef

355ImmBorrowLoc[31](loc26: SwapStepResult)

356ImmBorrowField[39](SwapStepResult.sqrt_price_next: u128)

357ReadRef

358Eq

359BrFalse(411)

B38:

360ImmBorrowLoc[31](loc26: SwapStepResult)

361ImmBorrowField[38](SwapStepResult.initialized: bool)

362ReadRef

363BrFalse(390)

B39:

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

365ImmBorrowFieldGeneric[16](Pool.ticks_manager: TickManager)

366ImmBorrowLoc[31](loc26: SwapStepResult)

367ImmBorrowField[37](SwapStepResult.tick_index_next: I32)

368ReadRef

369Call tick::get_tick_from_manager(&TickManager, I32): &TickInfo

370Call tick::liquidity_net(&TickInfo): I128

371StLoc[28](loc23: I128)

372CopyLoc[1](Arg1: bool)

373BrFalse(378)

B40:

374MoveLoc[28](loc23: I128)

375Call i128H::neg(I128): I128

376StLoc[17](loc12: I128)

377Branch(380)

B41:

378MoveLoc[28](loc23: I128)

379StLoc[17](loc12: I128)

B42:

380MoveLoc[17](loc12: I128)

381StLoc[28](loc23: I128)

382ImmBorrowLoc[32](loc27: SwapResult)

383ImmBorrowField[29](SwapResult.liquidity: u128)

384ReadRef

385MoveLoc[28](loc23: I128)

386Call utils::add_delta(u128, I128): u128

387MutBorrowLoc[32](loc27: SwapResult)

388MutBorrowField[29](SwapResult.liquidity: u128)

389WriteRef

B43:

390CopyLoc[1](Arg1: bool)

391BrFalse(402)

B44:

392ImmBorrowLoc[31](loc26: SwapStepResult)

393ImmBorrowField[37](SwapStepResult.tick_index_next: I32)

394ReadRef

395Call i32H::mate_to_lib(I32): I32

396LdU32(1)

397Call i32::from(u32): I32

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

399Call i32H::lib_to_mate(I32): I32

400StLoc[18](loc13: I32)

401Branch(406)

B45:

402ImmBorrowLoc[31](loc26: SwapStepResult)

403ImmBorrowField[37](SwapStepResult.tick_index_next: I32)

404ReadRef

405StLoc[18](loc13: I32)

B46:

406MoveLoc[18](loc13: I32)

407MutBorrowLoc[32](loc27: SwapResult)

408MutBorrowField[36](SwapResult.current_tick_index: I32)

409WriteRef

410Branch(104)

B47:

411ImmBorrowLoc[32](loc27: SwapResult)

412ImmBorrowField[31](SwapResult.end_sqrt_price: u128)

413ReadRef

414ImmBorrowLoc[31](loc26: SwapStepResult)

415ImmBorrowField[48](SwapStepResult.sqrt_price_start: u128)

416ReadRef

417Neq

418BrFalse(426)

B48:

419ImmBorrowLoc[32](loc27: SwapResult)

420ImmBorrowField[31](SwapResult.end_sqrt_price: u128)

421ReadRef

422Call tick_math::get_tick_at_sqrt_price(u128): I32

423MutBorrowLoc[32](loc27: SwapResult)

424MutBorrowField[36](SwapResult.current_tick_index: I32)

425WriteRef

B49:

426Branch(104)

B50:

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

428Pop

429ImmBorrowLoc[32](loc27: SwapResult)

430ImmBorrowField[25](SwapResult.amount_specified_remaining: u64)

431ReadRef

432LdU64(0)

433Gt

434BrFalse(438)

B51:

435LdTrue

436StLoc[19](loc14: bool)

437Branch(440)

B52:

438LdFalse

439StLoc[19](loc14: bool)

B53:

440MoveLoc[19](loc14: bool)

441MutBorrowLoc[32](loc27: SwapResult)

442MutBorrowField[32](SwapResult.is_exceed: bool)

443WriteRef

444CopyLoc[32](loc27: SwapResult)

445Call event::emit<SwapResult>(SwapResult)

446MoveLoc[32](loc27: SwapResult)

447Ret

}

public repay_flash_swap<Ty0, Ty1>(Arg0: &GlobalConfig, Arg1: &mut Pool<Ty0, Ty1>, Arg2: Balance<Ty0>, Arg3: Balance<Ty1>, Arg4: FlashSwapReceipt<Ty0, Ty1>) {

L5: loc0: bool

L6: loc1: u64

L7: loc2: ID

B0:

0MoveLoc[0](Arg0: &GlobalConfig)

1Call config::verify_version(&GlobalConfig)

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

3ImmBorrowFieldGeneric[5](Pool.id: UID)

4Call is_flash_swap_in_progress(&UID): bool

5BrFalse(7)

B1:

6Branch(11)

B2:

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

8Pop

9Call errors::no_flash_swap_in_progress(): u64

10Abort

B3:

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

12MutBorrowFieldGeneric[5](Pool.id: UID)

13Call constants::flash_swap_in_progress_key(): vector<u8>

14Call dynamic_field::remove<vector<u8>, bool>(&mut UID, vector<u8>): bool

15Pop

16MoveLoc[4](Arg4: FlashSwapReceipt<Ty0, Ty1>)

17UnpackGeneric[0](FlashSwapReceipt<Ty0, Ty1>)

18StLoc[6](loc1: u64)

19StLoc[5](loc0: bool)

20StLoc[7](loc2: ID)

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

22FreezeRef

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

24MoveLoc[7](loc2: ID)

25Eq

26BrFalse(28)

B4:

27Branch(32)

B5:

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

29Pop

30Call errors::invalid_pool(): u64

31Abort

B6:

32MoveLoc[5](loc0: bool)

33BrFalse(52)

B7:

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

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

36MoveLoc[6](loc1: u64)

37Eq

38BrFalse(40)

B8:

39Branch(44)

B9:

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

41Pop

42LdU64(0)

43Abort

B10:

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

45MutBorrowFieldGeneric[2](Pool.coin_a: Balance<Ty0>)

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

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

48Pop

49MoveLoc[3](Arg3: Balance<Ty1>)

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

51Branch(69)

B11:

52ImmBorrowLoc[3](Arg3: Balance<Ty1>)

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

54MoveLoc[6](loc1: u64)

55Eq

56BrFalse(58)

B12:

57Branch(62)

B13:

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

59Pop

60LdU64(0)

61Abort

B14:

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

63MutBorrowFieldGeneric[3](Pool.coin_b: Balance<Ty1>)

64MoveLoc[3](Arg3: Balance<Ty1>)

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

66Pop

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

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

B15:

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

70ImmBorrowFieldGeneric[4](Pool.sequence_number: u128)

71ReadRef

72LdU128(1)

73Add

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

75MutBorrowFieldGeneric[4](Pool.sequence_number: u128)

76WriteRef

77Ret

}

public set_manager<Ty0, Ty1>(Arg0: &GlobalConfig, Arg1: &mut Pool<Ty0, Ty1>, Arg2: address, Arg3: &TxContext) {

L4: loc0: &mut address

B0:

0MoveLoc[0](Arg0: &GlobalConfig)

1Call config::verify_version(&GlobalConfig)

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

3FreezeRef

4Call get_pool_manager<Ty0, Ty1>(&Pool<Ty0, Ty1>): address

5MoveLoc[3](Arg3: &TxContext)

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

7Eq

8BrFalse(10)

B1:

9Branch(14)

B2:

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

11Pop

12Call errors::not_authorized(): u64

13Abort

B3:

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

15MutBorrowFieldGeneric[5](Pool.id: UID)

16Call constants::manager(): String

17Call dynamic_field::borrow_mut<String, address>(&mut UID, String): &mut address

18StLoc[4](loc0: &mut address)

19CopyLoc[2](Arg2: address)

20MoveLoc[4](loc0: &mut address)

21WriteRef

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

23Call increase_sequence_number<Ty0, Ty1>(&mut Pool<Ty0, Ty1>): u128

24Pop

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

26ImmBorrowFieldGeneric[5](Pool.id: UID)

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

28MoveLoc[2](Arg2: address)

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

30ImmBorrowFieldGeneric[4](Pool.sequence_number: u128)

31ReadRef

32Call events::emit_pool_manager_update_event(ID, address, u128)

33Ret

}

public swap_pay_amount<Ty0, Ty1>(Arg0: &FlashSwapReceipt<Ty0, Ty1>): u64 {

B0:

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

1ImmBorrowFieldGeneric[18](FlashSwapReceipt.pay_amount: u64)

2ReadRef

3Ret

}

public get_pool_manager<Ty0, Ty1>(Arg0: &Pool<Ty0, Ty1>): address {

B0:

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

1ImmBorrowFieldGeneric[5](Pool.id: UID)

2Call constants::manager(): String

3Call dynamic_field::borrow<String, address>(&UID, String): &address

4ReadRef

5Ret

}

public get_protocol_fee_for_coin_a<Ty0, Ty1>(Arg0: &Pool<Ty0, Ty1>): u64 {

B0:

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

1ImmBorrowFieldGeneric[0](Pool.protocol_fee_coin_a: u64)

2ReadRef

3Ret

}

public get_protocol_fee_for_coin_b<Ty0, Ty1>(Arg0: &Pool<Ty0, Ty1>): u64 {

B0:

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

1ImmBorrowFieldGeneric[1](Pool.protocol_fee_coin_b: u64)

2ReadRef

3Ret

}

public open_position<Ty0, Ty1>(Arg0: &GlobalConfig, Arg1: &mut Pool<Ty0, Ty1>, Arg2: u32, Arg3: u32, Arg4: &mut TxContext): Position {

L5: loc0: bool

L6: loc1: String

L7: loc2: String

L8: loc3: I32

L9: loc4: I32

L10: loc5: I32

L11: loc6: ID

L12: loc7: Position

L13: loc8: ID

L14: loc9: u32

L15: loc10: I32

B0:

0CopyLoc[0](Arg0: &GlobalConfig)

1Call config::verify_version(&GlobalConfig)

2MoveLoc[0](Arg0: &GlobalConfig)

3Call config::get_tick_range(&GlobalConfig): I32 * I32

4StLoc[9](loc4: I32)

5StLoc[10](loc5: I32)

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

7ImmBorrowFieldGeneric[16](Pool.ticks_manager: TickManager)

8Call tick::tick_spacing(&TickManager): u32

9StLoc[14](loc9: u32)

10MoveLoc[2](Arg2: u32)

11Call i32::from_u32(u32): I32

12MoveLoc[3](Arg3: u32)

13Call i32::from_u32(u32): I32

14StLoc[15](loc10: I32)

15StLoc[8](loc3: I32)

16CopyLoc[8](loc3: I32)

17CopyLoc[15](loc10: I32)

18Call i32::lt(I32, I32): bool

19BrFalse(54)

B1:

20CopyLoc[8](loc3: I32)

21MoveLoc[10](loc5: I32)

22Call i32H::mate_to_lib(I32): I32

23Call i32::gte(I32, I32): bool

24BrFalse(51)

B2:

25CopyLoc[15](loc10: I32)

26MoveLoc[9](loc4: I32)

27Call i32H::mate_to_lib(I32): I32

28Call i32::lte(I32, I32): bool

29BrFalse(48)

B3:

30CopyLoc[8](loc3: I32)

31Call i32::abs_u32(I32): u32

32CopyLoc[14](loc9: u32)

33Mod

34LdU32(0)

35Eq

36BrFalse(45)

B4:

37CopyLoc[15](loc10: I32)

38Call i32::abs_u32(I32): u32

39MoveLoc[14](loc9: u32)

40Mod

41LdU32(0)

42Eq

43StLoc[5](loc0: bool)

44Branch(47)

B5:

45LdFalse

46StLoc[5](loc0: bool)

B6:

47Branch(50)

B7:

48LdFalse

49StLoc[5](loc0: bool)

B8:

50Branch(53)

B9:

51LdFalse

52StLoc[5](loc0: bool)

B10:

53Branch(56)

B11:

54LdFalse

55StLoc[5](loc0: bool)

B12:

56MoveLoc[5](loc0: bool)

57BrFalse(59)

B13:

58Branch(65)

B14:

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

60Pop

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

62Pop

63Call errors::invalid_tick_range(): u64

64Abort

B15:

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

66FreezeRef

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

68StLoc[11](loc6: ID)

69Call utils::get_type_string<Ty0>(): String

70StLoc[6](loc1: String)

71Call utils::get_type_string<Ty1>(): String

72StLoc[7](loc2: String)

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

74ImmBorrowFieldGeneric[19](Pool.position_index: u128)

75ReadRef

76LdU128(1)

77Add

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

79MutBorrowFieldGeneric[19](Pool.position_index: u128)

80WriteRef

81CopyLoc[11](loc6: ID)

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

83ImmBorrowFieldGeneric[20](Pool.name: String)

84ReadRef

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

86ImmBorrowFieldGeneric[11](Pool.icon_url: String)

87ReadRef

88MoveLoc[6](loc1: String)

89MoveLoc[7](loc2: String)

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

91ImmBorrowFieldGeneric[19](Pool.position_index: u128)

92ReadRef

93CopyLoc[8](loc3: I32)

94Call i32H::lib_to_mate(I32): I32

95CopyLoc[15](loc10: I32)

96Call i32H::lib_to_mate(I32): I32

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

98ImmBorrowFieldGeneric[17](Pool.fee_rate: u64)

99ReadRef

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

101Call position::new(ID, String, String, String, String, u128, I32, I32, u64, &mut TxContext): Position

102StLoc[12](loc7: Position)

103ImmBorrowLoc[12](loc7: Position)

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

105StLoc[13](loc8: ID)

106MoveLoc[11](loc6: ID)

107MoveLoc[13](loc8: ID)

108MoveLoc[8](loc3: I32)

109Call i32H::lib_to_mate(I32): I32

110MoveLoc[15](loc10: I32)

111Call i32H::lib_to_mate(I32): I32

112Call events::emit_position_open_event(ID, ID, I32, I32)

113MoveLoc[12](loc7: Position)

114Ret

}

public close_position<Ty0, Ty1>(Arg0: &Clock, Arg1: &GlobalConfig, Arg2: &mut Pool<Ty0, Ty1>, Arg3: Position): Balance<Ty0> * Balance<Ty1> {

B0:

0Call errors::depricated(): u64

1Abort

}

public close_position_v2<Ty0, Ty1>(Arg0: &Clock, Arg1: &GlobalConfig, Arg2: &mut Pool<Ty0, Ty1>, Arg3: Position) {

L4: loc0: bool

L5: loc1: u64

L6: loc2: I32

L7: loc3: ID

L8: loc4: ID

L9: loc5: I32

B0:

0MoveLoc[1](Arg1: &GlobalConfig)

1Call config::verify_version(&GlobalConfig)

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

3FreezeRef

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

5ImmBorrowLoc[3](Arg3: Position)

6Call position::pool_id(&Position): ID

7Eq

8BrFalse(10)

B1:

9Branch(16)

B2:

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

11Pop

12MoveLoc[0](Arg0: &Clock)

13Pop

14Call errors::position_does_not_belong_to_pool(): u64

15Abort

B3:

16ImmBorrowLoc[3](Arg3: Position)

17Call position::is_empty(&Position): bool

18BrFalse(20)

B4:

19Branch(26)

B5:

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

21Pop

22MoveLoc[0](Arg0: &Clock)

23Pop

24Call errors::non_empty_position(): u64

25Abort

B6:

26MoveLoc[0](Arg0: &Clock)

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

28MutBorrowLoc[3](Arg3: Position)

29Call get_accrued_fee<Ty0, Ty1>(&Clock, &mut Pool<Ty0, Ty1>, &mut Position): u64 * u64

30StLoc[5](loc1: u64)

31LdU64(0)

32Eq

33BrFalse(39)

B7:

34MoveLoc[5](loc1: u64)

35LdU64(0)

36Eq

37StLoc[4](loc0: bool)

38Branch(41)

B8:

39LdFalse

40StLoc[4](loc0: bool)

B9:

41MoveLoc[4](loc0: bool)

42BrFalse(44)

B10:

43Branch(46)

B11:

44Call errors::cannot_close_position_with_fee_to_claim(): u64

45Abort

B12:

46MoveLoc[3](Arg3: Position)

47Call position::del(Position): ID * ID * I32 * I32

48StLoc[9](loc5: I32)

49StLoc[6](loc2: I32)

50StLoc[7](loc3: ID)

51StLoc[8](loc4: ID)

52MoveLoc[7](loc3: ID)

53MoveLoc[8](loc4: ID)

54MoveLoc[6](loc2: I32)

55MoveLoc[9](loc5: I32)

56Call events::emit_position_close_event(ID, ID, I32, I32)

57Ret

}

public collect_fee<Ty0, Ty1>(Arg0: &Clock, Arg1: &GlobalConfig, Arg2: &mut Pool<Ty0, Ty1>, Arg3: &mut Position): u64 * u64 * Balance<Ty0> * Balance<Ty1> {

L4: loc0: bool

L5: loc1: Balance<Ty0>

L6: loc2: Balance<Ty1>

L7: loc3: Balance<Ty0>

L8: loc4: Balance<Ty0>

L9: loc5: Balance<Ty1>

L10: loc6: Balance<Ty1>

L11: loc7: u64

L12: loc8: u64

B0:

0MoveLoc[1](Arg1: &GlobalConfig)

1Call config::verify_version(&GlobalConfig)

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

3FreezeRef

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

5CopyLoc[3](Arg3: &mut Position)

6FreezeRef

7Call position::pool_id(&Position): ID

8Eq

9BrFalse(11)

B1:

10Branch(19)

B2:

11MoveLoc[3](Arg3: &mut Position)

12Pop

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

14Pop

15MoveLoc[0](Arg0: &Clock)

16Pop

17Call errors::position_does_not_belong_to_pool(): u64

18Abort

B3:

19CopyLoc[2](Arg2: &mut Pool<Ty0, Ty1>)

20ImmBorrowFieldGeneric[8](Pool.is_paused: bool)

21ReadRef

22Not

23BrFalse(25)

B4:

24Branch(33)

B5:

25MoveLoc[3](Arg3: &mut Position)

26Pop

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

28Pop

29MoveLoc[0](Arg0: &Clock)

30Pop

31Call errors::pool_is_paused(): u64

32Abort

B6:

33CopyLoc[2](Arg2: &mut Pool<Ty0, Ty1>)

34ImmBorrowFieldGeneric[5](Pool.id: UID)

35Call is_flash_swap_in_progress(&UID): bool

36Not

37BrFalse(39)

B7:

38Branch(47)

B8:

39MoveLoc[3](Arg3: &mut Position)

40Pop

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

42Pop

43MoveLoc[0](Arg0: &Clock)

44Pop

45Call errors::flash_swap_in_progress(): u64

46Abort

B9:

47MoveLoc[0](Arg0: &Clock)

48CopyLoc[2](Arg2: &mut Pool<Ty0, Ty1>)

49CopyLoc[3](Arg3: &mut Position)

50Call get_accrued_fee<Ty0, Ty1>(&Clock, &mut Pool<Ty0, Ty1>, &mut Position): u64 * u64

51StLoc[12](loc8: u64)

52StLoc[11](loc7: u64)

53CopyLoc[11](loc7: u64)

54LdU64(0)

55Gt

56BrFalse(60)

B10:

57LdTrue

58StLoc[4](loc0: bool)

59Branch(64)

B11:

60CopyLoc[12](loc8: u64)

61LdU64(0)

62Gt

63StLoc[4](loc0: bool)

B12:

64MoveLoc[4](loc0: bool)

65BrFalse(98)

B13:

66CopyLoc[2](Arg2: &mut Pool<Ty0, Ty1>)

67CopyLoc[11](loc7: u64)

68CopyLoc[12](loc8: u64)

69Call withdraw_balances<Ty0, Ty1>(&mut Pool<Ty0, Ty1>, u64, u64): Balance<Ty0> * Balance<Ty1>

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

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

72CopyLoc[2](Arg2: &mut Pool<Ty0, Ty1>)

73Call increase_sequence_number<Ty0, Ty1>(&mut Pool<Ty0, Ty1>): u128

74Pop

75CopyLoc[2](Arg2: &mut Pool<Ty0, Ty1>)

76FreezeRef

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

78MoveLoc[3](Arg3: &mut Position)

79FreezeRef

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

81CopyLoc[11](loc7: u64)

82CopyLoc[12](loc8: u64)

83CopyLoc[2](Arg2: &mut Pool<Ty0, Ty1>)

84ImmBorrowFieldGeneric[2](Pool.coin_a: Balance<Ty0>)

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

86CopyLoc[2](Arg2: &mut Pool<Ty0, Ty1>)

87ImmBorrowFieldGeneric[3](Pool.coin_b: Balance<Ty1>)

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

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

90ImmBorrowFieldGeneric[4](Pool.sequence_number: u128)

91ReadRef

92Call events::emit_user_fee_collected(ID, ID, u64, u64, u64, u64, u128)

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

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

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

96StLoc[5](loc1: Balance<Ty0>)

97Branch(106)

B14:

98MoveLoc[3](Arg3: &mut Position)

99Pop

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

101Pop

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

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

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

105StLoc[5](loc1: Balance<Ty0>)

B15:

106MoveLoc[5](loc1: Balance<Ty0>)

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

108StLoc[10](loc6: Balance<Ty1>)

109StLoc[8](loc4: Balance<Ty0>)

110MoveLoc[11](loc7: u64)

111MoveLoc[12](loc8: u64)

112MoveLoc[8](loc4: Balance<Ty0>)

113MoveLoc[10](loc6: Balance<Ty1>)

114Ret

}

public collect_reward<Ty0, Ty1, Ty2>(Arg0: &Clock, Arg1: &GlobalConfig, Arg2: &mut Pool<Ty0, Ty1>, Arg3: &mut Position): Balance<Ty2> {

L4: loc0: Balance<Ty2>

L5: loc1: u64

L6: loc2: PoolRewardInfo

B0:

0MoveLoc[1](Arg1: &GlobalConfig)

1Call config::verify_version(&GlobalConfig)

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

3FreezeRef

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

5CopyLoc[3](Arg3: &mut Position)

6FreezeRef

7Call position::pool_id(&Position): ID

8Eq

9BrFalse(11)

B1:

10Branch(19)

B2:

11MoveLoc[3](Arg3: &mut Position)

12Pop

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

14Pop

15MoveLoc[0](Arg0: &Clock)

16Pop

17Call errors::position_does_not_belong_to_pool(): u64

18Abort

B3:

19CopyLoc[2](Arg2: &mut Pool<Ty0, Ty1>)

20ImmBorrowFieldGeneric[8](Pool.is_paused: bool)

21ReadRef

22Not

23BrFalse(25)

B4:

24Branch(33)

B5:

25MoveLoc[3](Arg3: &mut Position)

26Pop

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

28Pop

29MoveLoc[0](Arg0: &Clock)

30Pop

31Call errors::pool_is_paused(): u64

32Abort

B6:

33CopyLoc[2](Arg2: &mut Pool<Ty0, Ty1>)

34ImmBorrowFieldGeneric[5](Pool.id: UID)

35Call is_flash_swap_in_progress(&UID): bool

36Not

37BrFalse(39)

B7:

38Branch(47)

B8:

39MoveLoc[3](Arg3: &mut Position)

40Pop

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

42Pop

43MoveLoc[0](Arg0: &Clock)

44Pop

45Call errors::flash_swap_in_progress(): u64

46Abort

B9:

47MoveLoc[0](Arg0: &Clock)

48CopyLoc[2](Arg2: &mut Pool<Ty0, Ty1>)

49CopyLoc[3](Arg3: &mut Position)

50Call get_accrued_rewards<Ty0, Ty1, Ty2>(&Clock, &mut Pool<Ty0, Ty1>, &mut Position): u64 * PoolRewardInfo

51StLoc[6](loc2: PoolRewardInfo)

52StLoc[5](loc1: u64)

53CopyLoc[5](loc1: u64)

54LdU64(0)

55Gt

56BrFalse(79)

B10:

57CopyLoc[2](Arg2: &mut Pool<Ty0, Ty1>)

58Call increase_sequence_number<Ty0, Ty1>(&mut Pool<Ty0, Ty1>): u128

59Pop

60CopyLoc[2](Arg2: &mut Pool<Ty0, Ty1>)

61FreezeRef

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

63MoveLoc[3](Arg3: &mut Position)

64FreezeRef

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

66Call utils::get_type_string<Ty2>(): String

67ImmBorrowLoc[6](loc2: PoolRewardInfo)

68ImmBorrowField[12](PoolRewardInfo.reward_coin_symbol: String)

69ReadRef

70ImmBorrowLoc[6](loc2: PoolRewardInfo)

71ImmBorrowField[14](PoolRewardInfo.reward_coin_decimals: u8)

72ReadRef

73CopyLoc[5](loc1: u64)

74CopyLoc[2](Arg2: &mut Pool<Ty0, Ty1>)

75ImmBorrowFieldGeneric[4](Pool.sequence_number: u128)

76ReadRef

77Call events::emit_user_reward_collected(ID, ID, String, String, u8, u64, u128)

78Branch(81)

B11:

79MoveLoc[3](Arg3: &mut Position)

80Pop

B12:

81CopyLoc[5](loc1: u64)

82LdU64(0)

83Eq

84BrFalse(90)

B13:

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

86Pop

87Call balance::zero<Ty2>(): Balance<Ty2>

88StLoc[4](loc0: Balance<Ty2>)

89Branch(97)

B14:

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

91MutBorrowFieldGeneric[5](Pool.id: UID)

92Call utils::get_type_string<Ty2>(): String

93Call dynamic_field::borrow_mut<String, Balance<Ty2>>(&mut UID, String): &mut Balance<Ty2>

94MoveLoc[5](loc1: u64)

95Call utils::withdraw_balance<Ty2>(&mut Balance<Ty2>, u64): Balance<Ty2>

96StLoc[4](loc0: Balance<Ty2>)

B15:

97MoveLoc[4](loc0: Balance<Ty2>)

98Ret

}

public liquidity<Ty0, Ty1>(Arg0: &Pool<Ty0, Ty1>): u128 {

B0:

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

1ImmBorrowFieldGeneric[7](Pool.liquidity: u128)

2ReadRef

3Ret

}

public current_sqrt_price<Ty0, Ty1>(Arg0: &Pool<Ty0, Ty1>): u128 {

B0:

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

1ImmBorrowFieldGeneric[13](Pool.current_sqrt_price: u128)

2ReadRef

3Ret

}

public current_tick_index<Ty0, Ty1>(Arg0: &Pool<Ty0, Ty1>): I32 {

B0:

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

1ImmBorrowFieldGeneric[12](Pool.current_tick_index: I32)

2ReadRef

3Ret

}

public sequence_number<Ty0, Ty1>(Arg0: &Pool<Ty0, Ty1>): u128 {

B0:

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

1ImmBorrowFieldGeneric[4](Pool.sequence_number: u128)

2ReadRef

3Ret

}

public verify_pool_manager<Ty0, Ty1>(Arg0: &Pool<Ty0, Ty1>, Arg1: address): bool {

B0:

0MoveLoc[1](Arg1: address)

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

2ImmBorrowFieldGeneric[5](Pool.id: UID)

3Call constants::manager(): String

4Call dynamic_field::borrow<String, address>(&UID, String): &address

5ReadRef

6Eq

7Ret

}

public coin_reserves<Ty0, Ty1>(Arg0: &Pool<Ty0, Ty1>): u64 * u64 {

B0:

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

1ImmBorrowFieldGeneric[2](Pool.coin_a: Balance<Ty0>)

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

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

4ImmBorrowFieldGeneric[3](Pool.coin_b: Balance<Ty1>)

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

6Ret

}

public protocol_fee_share<Ty0, Ty1>(Arg0: &Pool<Ty0, Ty1>): u64 {

B0:

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

1ImmBorrowFieldGeneric[9](Pool.protocol_fee_share: u64)

2ReadRef

3Ret

}

public reward_infos_length<Ty0, Ty1>(Arg0: &Pool<Ty0, Ty1>): u64 {

B0:

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

1ImmBorrowFieldGeneric[6](Pool.reward_infos: vector<PoolRewardInfo>)

2VecLen(43)

3Ret

}

public is_reward_present<Ty0, Ty1, Ty2>(Arg0: &Pool<Ty0, Ty1>): bool {

L1: loc0: u64

L2: loc1: bool

L3: loc2: u64

L4: loc3: String

B0:

0LdFalse

1StLoc[2](loc1: bool)

2Call utils::get_type_string<Ty2>(): String

3StLoc[4](loc3: String)

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

5ImmBorrowFieldGeneric[6](Pool.reward_infos: vector<PoolRewardInfo>)

6VecLen(43)

7StLoc[1](loc0: u64)

8LdU64(0)

9StLoc[3](loc2: u64)

B1:

10CopyLoc[3](loc2: u64)

11CopyLoc[1](loc0: u64)

12Lt

13BrFalse(34)

B2:

14Branch(15)

B3:

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

16ImmBorrowFieldGeneric[6](Pool.reward_infos: vector<PoolRewardInfo>)

17CopyLoc[3](loc2: u64)

18VecImmBorrow(43)

19ImmBorrowField[13](PoolRewardInfo.reward_coin_type: String)

20ReadRef

21CopyLoc[4](loc3: String)

22Eq

23BrFalse(29)

B4:

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

25Pop

26LdTrue

27StLoc[2](loc1: bool)

28Branch(34)

B5:

29MoveLoc[3](loc2: u64)

30LdU64(1)

31Add

32StLoc[3](loc2: u64)

33Branch(10)

B6:

34MoveLoc[2](loc1: bool)

35Ret

}

public default_reward_info(Arg0: String, Arg1: String, Arg2: u8, Arg3: u64): PoolRewardInfo {

B0:

0MoveLoc[1](Arg1: String)

1MoveLoc[2](Arg2: u8)

2MoveLoc[0](Arg0: String)

3CopyLoc[3](Arg3: u64)

4MoveLoc[3](Arg3: u64)

5LdU64(0)

6LdU64(0)

7LdU128(0)

8LdU128(0)

9Pack[1](PoolRewardInfo)

10Ret

}

public get_tick_manager<Ty0, Ty1>(Arg0: &Pool<Ty0, Ty1>): &TickManager {

B0:

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

1ImmBorrowFieldGeneric[16](Pool.ticks_manager: TickManager)

2Ret

}

public fetch_provided_ticks<Ty0, Ty1>(Arg0: &Pool<Ty0, Ty1>, Arg1: vector<u32>): vector<TickInfo> {

B0:

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

1ImmBorrowFieldGeneric[16](Pool.ticks_manager: TickManager)

2MoveLoc[1](Arg1: vector<u32>)

3Call tick::fetch_provided_ticks(&TickManager, vector<u32>): vector<TickInfo>

4Ret

}

public get_fee_rate<Ty0, Ty1>(Arg0: &Pool<Ty0, Ty1>): u64 {

B0:

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

1ImmBorrowFieldGeneric[17](Pool.fee_rate: u64)

2ReadRef

3Ret

}

public get_tick_spacing<Ty0, Ty1>(Arg0: &Pool<Ty0, Ty1>): u32 {

B0:

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

1ImmBorrowFieldGeneric[16](Pool.ticks_manager: TickManager)

2Call tick::tick_spacing(&TickManager): u32

3Ret

}

public get_swap_result_a2b(Arg0: &SwapResult): bool {

B0:

0MoveLoc[0](Arg0: &SwapResult)

1ImmBorrowField[52](SwapResult.a2b: bool)

2ReadRef

3Ret

}

public get_swap_result_by_amount_in(Arg0: &SwapResult): bool {

B0:

0MoveLoc[0](Arg0: &SwapResult)

1ImmBorrowField[53](SwapResult.by_amount_in: bool)

2ReadRef

3Ret

}

public get_swap_result_amount_specified(Arg0: &SwapResult): u64 {

B0:

0MoveLoc[0](Arg0: &SwapResult)

1ImmBorrowField[24](SwapResult.amount_specified: u64)

2ReadRef

3Ret

}

public get_swap_result_amount_specified_remaining(Arg0: &SwapResult): u64 {

B0:

0MoveLoc[0](Arg0: &SwapResult)

1ImmBorrowField[25](SwapResult.amount_specified_remaining: u64)

2ReadRef

3Ret

}

public get_swap_result_amount_calculated(Arg0: &SwapResult): u64 {

B0:

0MoveLoc[0](Arg0: &SwapResult)

1ImmBorrowField[23](SwapResult.amount_calculated: u64)

2ReadRef

3Ret

}

public get_swap_result_fee_growth_global(Arg0: &SwapResult): u128 {

B0:

0MoveLoc[0](Arg0: &SwapResult)

1ImmBorrowField[45](SwapResult.fee_growth_global: u128)

2ReadRef

3Ret

}

public get_swap_result_fee_amount(Arg0: &SwapResult): u64 {

B0:

0MoveLoc[0](Arg0: &SwapResult)

1ImmBorrowField[26](SwapResult.fee_amount: u64)

2ReadRef

3Ret

}

public get_swap_result_protocol_fee(Arg0: &SwapResult): u64 {

B0:

0MoveLoc[0](Arg0: &SwapResult)

1ImmBorrowField[27](SwapResult.protocol_fee: u64)

2ReadRef

3Ret

}

public get_swap_result_start_sqrt_price(Arg0: &SwapResult): u128 {

B0:

0MoveLoc[0](Arg0: &SwapResult)

1ImmBorrowField[30](SwapResult.start_sqrt_price: u128)

2ReadRef

3Ret

}

public get_swap_result_end_sqrt_price(Arg0: &SwapResult): u128 {

B0:

0MoveLoc[0](Arg0: &SwapResult)

1ImmBorrowField[31](SwapResult.end_sqrt_price: u128)

2ReadRef

3Ret

}

public get_swap_result_current_tick_index(Arg0: &SwapResult): I32 {

B0:

0MoveLoc[0](Arg0: &SwapResult)

1ImmBorrowField[36](SwapResult.current_tick_index: I32)

2ReadRef

3Ret

}

public get_swap_result_is_exceed(Arg0: &SwapResult): bool {

B0:

0MoveLoc[0](Arg0: &SwapResult)

1ImmBorrowField[32](SwapResult.is_exceed: bool)

2ReadRef

3Ret

}

public get_swap_result_starting_liquidity(Arg0: &SwapResult): u128 {

B0:

0MoveLoc[0](Arg0: &SwapResult)

1ImmBorrowField[28](SwapResult.starting_liquidity: u128)

2ReadRef

3Ret

}

public get_swap_result_liquidity(Arg0: &SwapResult): u128 {

B0:

0MoveLoc[0](Arg0: &SwapResult)

1ImmBorrowField[29](SwapResult.liquidity: u128)

2ReadRef

3Ret

}

public get_swap_result_steps(Arg0: &SwapResult): u64 {

B0:

0MoveLoc[0](Arg0: &SwapResult)

1ImmBorrowField[46](SwapResult.steps: u64)

2ReadRef

3Ret

}

public get_liquidity_by_amount(Arg0: I32, Arg1: I32, Arg2: I32, Arg3: u128, Arg4: u64, Arg5: bool): u128 * u64 * u64 {

B0:

0MoveLoc[0](Arg0: I32)

1MoveLoc[1](Arg1: I32)

2MoveLoc[2](Arg2: I32)

3MoveLoc[3](Arg3: u128)

4MoveLoc[4](Arg4: u64)

5MoveLoc[5](Arg5: bool)

6Call clmm_math::get_liquidity_by_amount(I32, I32, I32, u128, u64, bool): u128 * u64 * u64

7Ret

}

public get_amount_by_liquidity(Arg0: I32, Arg1: I32, Arg2: I32, Arg3: u128, Arg4: u128, Arg5: bool): u64 * u64 {

B0:

0MoveLoc[0](Arg0: I32)

1MoveLoc[1](Arg1: I32)

2MoveLoc[2](Arg2: I32)

3MoveLoc[3](Arg3: u128)

4MoveLoc[4](Arg4: u128)

5MoveLoc[5](Arg5: bool)

6Call clmm_math::get_amount_by_liquidity(I32, I32, I32, u128, u128, bool): u64 * u64

7Ret

}

public get_pool_name<Ty0, Ty1>(Arg0: &Pool<Ty0, Ty1>): String {

B0:

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

1ImmBorrowFieldGeneric[20](Pool.name: String)

2ReadRef

3Ret

}

find_reward_info_index<Ty0, Ty1, Ty2>(Arg0: &Pool<Ty0, Ty1>): u64 {

L1: loc0: u64

L2: loc1: bool

L3: loc2: u64

L4: loc3: u64

B0:

0LdU64(0)

1StLoc[4](loc3: u64)

2CopyLoc[4](loc3: u64)

3StLoc[3](loc2: u64)

4LdFalse

5StLoc[2](loc1: bool)

6MoveLoc[4](loc3: u64)

7StLoc[1](loc0: u64)

B1:

8CopyLoc[1](loc0: u64)

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

10ImmBorrowFieldGeneric[6](Pool.reward_infos: vector<PoolRewardInfo>)

11VecLen(43)

12Lt

13BrFalse(36)

B2:

14Branch(15)

B3:

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

16ImmBorrowFieldGeneric[6](Pool.reward_infos: vector<PoolRewardInfo>)

17CopyLoc[1](loc0: u64)

18VecImmBorrow(43)

19ImmBorrowField[13](PoolRewardInfo.reward_coin_type: String)

20ReadRef

21Call utils::get_type_string<Ty2>(): String

22Eq

23BrFalse(31)

B4:

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

25Pop

26MoveLoc[1](loc0: u64)

27StLoc[3](loc2: u64)

28LdTrue

29StLoc[2](loc1: bool)

30Branch(36)

B5:

31MoveLoc[1](loc0: u64)

32LdU64(1)

33Add

34StLoc[1](loc0: u64)

35Branch(8)

B6:

36MoveLoc[2](loc1: bool)

37BrFalse(39)

B7:

38Branch(41)

B8:

39Call errors::reward_index_not_found(): u64

40Abort

B9:

41MoveLoc[3](loc2: u64)

42Ret

}

swap_in_pool<Ty0, Ty1>(Arg0: &Clock, Arg1: &mut Pool<Ty0, Ty1>, Arg2: bool, Arg3: bool, Arg4: u64, Arg5: u128): SwapResult {

L6: loc0: bool

L7: loc1: u128

L8: loc2: u128

L9: loc3: u128

L10: loc4: u128

L11: loc5: I32

L12: loc6: u128

L13: loc7: u128

L14: loc8: vector<SwapStepResult>

L15: loc9: bool

L16: loc10: bool

L17: loc11: u128

L18: loc12: u128

L19: loc13: u128

L20: loc14: I128

L21: loc15: I32

L22: loc16: bool

L23: loc17: bool

L24: loc18: u64

L25: loc19: u64

L26: loc20: u64

L27: loc21: u64

L28: loc22: u64

L29: loc23: u128

L30: loc24: u128

L31: loc25: bool

L32: loc26: I128

L33: loc27: vector<u128>

L34: loc28: u128

L35: loc29: u64

L36: loc30: u256

L37: loc31: SwapStepResult

L38: loc32: SwapResult

L39: loc33: u64

L40: loc34: u128

L41: loc35: I64

B0:

0CopyLoc[2](Arg2: bool)

1BrFalse(25)

B1:

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

3ImmBorrowFieldGeneric[13](Pool.current_sqrt_price: u128)

4ReadRef

5CopyLoc[5](Arg5: u128)

6Gt

7BrFalse(13)

B2:

8CopyLoc[5](Arg5: u128)

9Call tick_math::min_sqrt_price(): u128

10Gt

11StLoc[6](loc0: bool)

12Branch(15)

B3:

13LdFalse

14StLoc[6](loc0: bool)

B4:

15MoveLoc[6](loc0: bool)

16BrFalse(18)

B5:

17Branch(24)

B6:

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

19Pop

20MoveLoc[0](Arg0: &Clock)

21Pop

22Call errors::invalid_price_limit(): u64

23Abort

B7:

24Branch(47)

B8:

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

26ImmBorrowFieldGeneric[13](Pool.current_sqrt_price: u128)

27ReadRef

28CopyLoc[5](Arg5: u128)

29Lt

30BrFalse(36)

B9:

31CopyLoc[5](Arg5: u128)

32Call tick_math::max_sqrt_price(): u128

33Lt

34StLoc[15](loc9: bool)

35Branch(38)

B10:

36LdFalse

37StLoc[15](loc9: bool)

B11:

38MoveLoc[15](loc9: bool)

39BrFalse(41)

B12:

40Branch(47)

B13:

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

42Pop

43MoveLoc[0](Arg0: &Clock)

44Pop

45Call errors::invalid_price_limit(): u64

46Abort

B14:

47CopyLoc[0](Arg0: &Clock)

48Call utils::timestamp_seconds(&Clock): u64

49StLoc[39](loc33: u64)

50CopyLoc[2](Arg2: bool)

51StLoc[22](loc16: bool)

52CopyLoc[3](Arg3: bool)

53StLoc[23](loc17: bool)

54CopyLoc[4](Arg4: u64)

55StLoc[24](loc18: u64)

56MoveLoc[4](Arg4: u64)

57StLoc[25](loc19: u64)

58CopyLoc[2](Arg2: bool)

59BrFalse(65)

B15:

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

61ImmBorrowFieldGeneric[14](Pool.fee_growth_global_coin_a: u128)

62ReadRef

63StLoc[7](loc1: u128)

64Branch(69)

B16:

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

66ImmBorrowFieldGeneric[15](Pool.fee_growth_global_coin_b: u128)

67ReadRef

68StLoc[7](loc1: u128)

B17:

69MoveLoc[7](loc1: u128)

70StLoc[8](loc2: u128)

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

72ImmBorrowFieldGeneric[13](Pool.current_sqrt_price: u128)

73ReadRef

74StLoc[9](loc3: u128)

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

76ImmBorrowFieldGeneric[13](Pool.current_sqrt_price: u128)

77ReadRef

78StLoc[10](loc4: u128)

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

80ImmBorrowFieldGeneric[12](Pool.current_tick_index: I32)

81ReadRef

82StLoc[11](loc5: I32)

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

84ImmBorrowFieldGeneric[7](Pool.liquidity: u128)

85ReadRef

86StLoc[12](loc6: u128)

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

88ImmBorrowFieldGeneric[7](Pool.liquidity: u128)

89ReadRef

90StLoc[13](loc7: u128)

91VecPack(105, 0)

92StLoc[14](loc8: vector<SwapStepResult>)

93MoveLoc[22](loc16: bool)

94MoveLoc[23](loc17: bool)

95MoveLoc[24](loc18: u64)

96MoveLoc[25](loc19: u64)

97LdU64(0)

98MoveLoc[8](loc2: u128)

99LdU64(0)

100LdU64(0)

101MoveLoc[9](loc3: u128)

102MoveLoc[10](loc4: u128)

103MoveLoc[11](loc5: I32)

104LdFalse

105MoveLoc[12](loc6: u128)

106MoveLoc[13](loc7: u128)

107LdU64(0)

108MoveLoc[14](loc8: vector<SwapStepResult>)

109Pack[2](SwapResult)

110StLoc[38](loc32: SwapResult)

B18:

111ImmBorrowLoc[38](loc32: SwapResult)

112ImmBorrowField[25](SwapResult.amount_specified_remaining: u64)

113ReadRef

114LdU64(0)

115Gt

116BrFalse(125)

B19:

117Branch(118)

B20:

118ImmBorrowLoc[38](loc32: SwapResult)

119ImmBorrowField[31](SwapResult.end_sqrt_price: u128)

120ReadRef

121CopyLoc[5](Arg5: u128)

122Neq

123StLoc[16](loc10: bool)

124Branch(127)

B21:

125LdFalse

126StLoc[16](loc10: bool)

B22:

127MoveLoc[16](loc10: bool)

128BrFalse(476)

B23:

129Call 0i32::zero(): I32

130LdFalse

131ImmBorrowLoc[38](loc32: SwapResult)

132ImmBorrowField[31](SwapResult.end_sqrt_price: u128)

133ReadRef

134LdU128(0)

135LdU64(0)

136LdU64(0)

137LdU64(0)

138LdU64(0)

139Pack[3](SwapStepResult)

140StLoc[37](loc31: SwapStepResult)

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

142ImmBorrowFieldGeneric[16](Pool.ticks_manager: TickManager)

143Call tick::bitmap(&TickManager): &Table<I32, u256>

144ImmBorrowLoc[38](loc32: SwapResult)

145ImmBorrowField[36](SwapResult.current_tick_index: I32)

146ReadRef

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

148ImmBorrowFieldGeneric[16](Pool.ticks_manager: TickManager)

149Call tick::tick_spacing(&TickManager): u32

150CopyLoc[2](Arg2: bool)

151Call tick_bitmap::next_initialized_tick_within_one_word(&Table<I32, u256>, I32, u32, bool): I32 * bool

152StLoc[31](loc25: bool)

153MutBorrowLoc[37](loc31: SwapStepResult)

154MutBorrowField[37](SwapStepResult.tick_index_next: I32)

155WriteRef

156MoveLoc[31](loc25: bool)

157MutBorrowLoc[37](loc31: SwapStepResult)

158MutBorrowField[38](SwapStepResult.initialized: bool)

159WriteRef

160ImmBorrowLoc[37](loc31: SwapStepResult)

161ImmBorrowField[37](SwapStepResult.tick_index_next: I32)

162ReadRef

163Call tick_math::min_tick(): I32

164Call i32H::lt(I32, I32): bool

165BrFalse(171)

B24:

166Call tick_math::min_tick(): I32

167MutBorrowLoc[37](loc31: SwapStepResult)

168MutBorrowField[37](SwapStepResult.tick_index_next: I32)

169WriteRef

170Branch(181)

B25:

171ImmBorrowLoc[37](loc31: SwapStepResult)

172ImmBorrowField[37](SwapStepResult.tick_index_next: I32)

173ReadRef

174Call tick_math::max_tick(): I32

175Call i32H::gt(I32, I32): bool

176BrFalse(181)

B26:

177Call tick_math::max_tick(): I32

178MutBorrowLoc[37](loc31: SwapStepResult)

179MutBorrowField[37](SwapStepResult.tick_index_next: I32)

180WriteRef

B27:

181ImmBorrowLoc[37](loc31: SwapStepResult)

182ImmBorrowField[37](SwapStepResult.tick_index_next: I32)

183ReadRef

184Call tick_math::get_sqrt_price_at_tick(I32): u128

185MutBorrowLoc[37](loc31: SwapStepResult)

186MutBorrowField[39](SwapStepResult.sqrt_price_next: u128)

187WriteRef

188CopyLoc[2](Arg2: bool)

189BrFalse(197)

B28:

190ImmBorrowLoc[37](loc31: SwapStepResult)

191ImmBorrowField[39](SwapStepResult.sqrt_price_next: u128)

192ReadRef

193CopyLoc[5](Arg5: u128)

194Call math_u128::max(u128, u128): u128

195StLoc[17](loc11: u128)

196Branch(203)

B29:

197ImmBorrowLoc[37](loc31: SwapStepResult)

198ImmBorrowField[39](SwapStepResult.sqrt_price_next: u128)

199ReadRef

200CopyLoc[5](Arg5: u128)

201Call math_u128::min(u128, u128): u128

202StLoc[17](loc11: u128)

B30:

203MoveLoc[17](loc11: u128)

204StLoc[40](loc34: u128)

205ImmBorrowLoc[38](loc32: SwapResult)

206ImmBorrowField[31](SwapResult.end_sqrt_price: u128)

207ReadRef

208MoveLoc[40](loc34: u128)

209ImmBorrowLoc[38](loc32: SwapResult)

210ImmBorrowField[29](SwapResult.liquidity: u128)

211ReadRef

212ImmBorrowLoc[38](loc32: SwapResult)

213ImmBorrowField[25](SwapResult.amount_specified_remaining: u64)

214ReadRef

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

216ImmBorrowFieldGeneric[17](Pool.fee_rate: u64)

217ReadRef

218CopyLoc[2](Arg2: bool)

219CopyLoc[3](Arg3: bool)

220Call clmm_math::compute_swap_step(u128, u128, u128, u64, u64, bool, bool): u64 * u64 * u128 * u64

221StLoc[28](loc22: u64)

222StLoc[34](loc28: u128)

223StLoc[27](loc21: u64)

224StLoc[26](loc20: u64)

225MoveLoc[34](loc28: u128)

226MutBorrowLoc[38](loc32: SwapResult)

227MutBorrowField[31](SwapResult.end_sqrt_price: u128)

228WriteRef

229CopyLoc[3](Arg3: bool)

230BrFalse(250)

B31:

231ImmBorrowLoc[38](loc32: SwapResult)

232ImmBorrowField[25](SwapResult.amount_specified_remaining: u64)

233ReadRef

234CopyLoc[26](loc20: u64)

235Sub

236CopyLoc[28](loc22: u64)

237Sub

238MutBorrowLoc[38](loc32: SwapResult)

239MutBorrowField[25](SwapResult.amount_specified_remaining: u64)

240WriteRef

241ImmBorrowLoc[38](loc32: SwapResult)

242ImmBorrowField[23](SwapResult.amount_calculated: u64)

243ReadRef

244CopyLoc[27](loc21: u64)

245Add

246MutBorrowLoc[38](loc32: SwapResult)

247MutBorrowField[23](SwapResult.amount_calculated: u64)

248WriteRef

249Branch(268)

B32:

250ImmBorrowLoc[38](loc32: SwapResult)

251ImmBorrowField[25](SwapResult.amount_specified_remaining: u64)

252ReadRef

253CopyLoc[27](loc21: u64)

254Sub

255MutBorrowLoc[38](loc32: SwapResult)

256MutBorrowField[25](SwapResult.amount_specified_remaining: u64)

257WriteRef

258ImmBorrowLoc[38](loc32: SwapResult)

259ImmBorrowField[23](SwapResult.amount_calculated: u64)

260ReadRef

261CopyLoc[26](loc20: u64)

262Add

263CopyLoc[28](loc22: u64)

264Add

265MutBorrowLoc[38](loc32: SwapResult)

266MutBorrowField[23](SwapResult.amount_calculated: u64)

267WriteRef

B33:

268MoveLoc[26](loc20: u64)

269MutBorrowLoc[37](loc31: SwapStepResult)

270MutBorrowField[41](SwapStepResult.amount_in: u64)

271WriteRef

272MoveLoc[27](loc21: u64)

273MutBorrowLoc[37](loc31: SwapStepResult)

274MutBorrowField[42](SwapStepResult.amount_out: u64)

275WriteRef

276CopyLoc[28](loc22: u64)

277MutBorrowLoc[37](loc31: SwapStepResult)

278MutBorrowField[43](SwapStepResult.fee_amount: u64)

279WriteRef

280ImmBorrowLoc[38](loc32: SwapResult)

281ImmBorrowField[25](SwapResult.amount_specified_remaining: u64)

282ReadRef

283MutBorrowLoc[37](loc31: SwapStepResult)

284MutBorrowField[44](SwapStepResult.remaining_amount: u64)

285WriteRef

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

287ImmBorrowFieldGeneric[9](Pool.protocol_fee_share: u64)

288ReadRef

289LdU64(0)

290Gt

291BrFalse(315)

B34:

292MoveLoc[28](loc22: u64)

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

294ImmBorrowFieldGeneric[9](Pool.protocol_fee_share: u64)

295ReadRef

296Call clmm_math::fee_rate_denominator(): u64

297Call full_math_u64::mul_div_floor(u64, u64, u64): u64

298StLoc[35](loc29: u64)

299ImmBorrowLoc[37](loc31: SwapStepResult)

300ImmBorrowField[43](SwapStepResult.fee_amount: u64)

301ReadRef

302CopyLoc[35](loc29: u64)

303Sub

304MutBorrowLoc[37](loc31: SwapStepResult)

305MutBorrowField[43](SwapStepResult.fee_amount: u64)

306WriteRef

307ImmBorrowLoc[38](loc32: SwapResult)

308ImmBorrowField[27](SwapResult.protocol_fee: u64)

309ReadRef

310MoveLoc[35](loc29: u64)

311Add

312MutBorrowLoc[38](loc32: SwapResult)

313MutBorrowField[27](SwapResult.protocol_fee: u64)

314WriteRef

B35:

315ImmBorrowLoc[38](loc32: SwapResult)

316ImmBorrowField[29](SwapResult.liquidity: u128)

317ReadRef

318LdU128(0)

319Gt

320BrFalse(337)

B36:

321ImmBorrowLoc[38](loc32: SwapResult)

322ImmBorrowField[45](SwapResult.fee_growth_global: u128)

323ReadRef

324ImmBorrowLoc[37](loc31: SwapStepResult)

325ImmBorrowField[43](SwapStepResult.fee_amount: u64)

326ReadRef

327CastU128

328Call constants::q64(): u128

329ImmBorrowLoc[38](loc32: SwapResult)

330ImmBorrowField[29](SwapResult.liquidity: u128)

331ReadRef

332Call full_math_u128::mul_div_floor(u128, u128, u128): u128

333Call math_u128::wrapping_add(u128, u128): u128

334MutBorrowLoc[38](loc32: SwapResult)

335MutBorrowField[45](SwapResult.fee_growth_global: u128)

336WriteRef

B37:

337ImmBorrowLoc[38](loc32: SwapResult)

338ImmBorrowField[26](SwapResult.fee_amount: u64)

339ReadRef

340ImmBorrowLoc[37](loc31: SwapStepResult)

341ImmBorrowField[43](SwapStepResult.fee_amount: u64)

342ReadRef

343Add

344MutBorrowLoc[38](loc32: SwapResult)

345MutBorrowField[26](SwapResult.fee_amount: u64)

346WriteRef

347ImmBorrowLoc[38](loc32: SwapResult)

348ImmBorrowField[46](SwapResult.steps: u64)

349ReadRef

350LdU64(1)

351Add

352MutBorrowLoc[38](loc32: SwapResult)

353MutBorrowField[46](SwapResult.steps: u64)

354WriteRef

355ImmBorrowLoc[38](loc32: SwapResult)

356ImmBorrowField[31](SwapResult.end_sqrt_price: u128)

357ReadRef

358ImmBorrowLoc[37](loc31: SwapStepResult)

359ImmBorrowField[39](SwapStepResult.sqrt_price_next: u128)

360ReadRef

361Eq

362BrFalse(460)

B38:

363CopyLoc[2](Arg2: bool)

364BrFalse(374)

B39:

365ImmBorrowLoc[38](loc32: SwapResult)

366ImmBorrowField[45](SwapResult.fee_growth_global: u128)

367ReadRef

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

369ImmBorrowFieldGeneric[15](Pool.fee_growth_global_coin_b: u128)

370ReadRef

371StLoc[19](loc13: u128)

372StLoc[18](loc12: u128)

373Branch(382)

B40:

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

375ImmBorrowFieldGeneric[14](Pool.fee_growth_global_coin_a: u128)

376ReadRef

377ImmBorrowLoc[38](loc32: SwapResult)

378ImmBorrowField[45](SwapResult.fee_growth_global: u128)

379ReadRef

380StLoc[19](loc13: u128)

381StLoc[18](loc12: u128)

B41:

382MoveLoc[18](loc12: u128)

383MoveLoc[19](loc13: u128)

384StLoc[30](loc24: u128)

385StLoc[29](loc23: u128)

386ImmBorrowLoc[37](loc31: SwapStepResult)

387ImmBorrowField[38](SwapStepResult.initialized: bool)

388ReadRef

389BrFalse(439)

B42:

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

391ImmBorrowFieldGeneric[10](Pool.observations_manager: ObservationManager)

392CopyLoc[39](loc33: u64)

393LdU64(0)

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

395ImmBorrowFieldGeneric[12](Pool.current_tick_index: I32)

396ReadRef

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

398ImmBorrowFieldGeneric[7](Pool.liquidity: u128)

399ReadRef

400Call oracle::observe_single(&ObservationManager, u64, u64, I32, u128): I64 * u256

401StLoc[36](loc30: u256)

402StLoc[41](loc35: I64)

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

404CopyLoc[0](Arg0: &Clock)

405Call utils::timestamp_seconds(&Clock): u64

406Call update_reward_infos<Ty0, Ty1>(&mut Pool<Ty0, Ty1>, u64): vector<u128>

407StLoc[33](loc27: vector<u128>)

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

409MutBorrowFieldGeneric[16](Pool.ticks_manager: TickManager)

410ImmBorrowLoc[37](loc31: SwapStepResult)

411ImmBorrowField[37](SwapStepResult.tick_index_next: I32)

412ReadRef

413MoveLoc[29](loc23: u128)

414MoveLoc[30](loc24: u128)

415MoveLoc[33](loc27: vector<u128>)

416MoveLoc[41](loc35: I64)

417MoveLoc[36](loc30: u256)

418CopyLoc[39](loc33: u64)

419Call tick::cross(&mut TickManager, I32, u128, u128, vector<u128>, I64, u256, u64): I128

420StLoc[32](loc26: I128)

421CopyLoc[2](Arg2: bool)

422BrFalse(427)

B43:

423MoveLoc[32](loc26: I128)

424Call i128H::neg(I128): I128

425StLoc[20](loc14: I128)

426Branch(429)

B44:

427MoveLoc[32](loc26: I128)

428StLoc[20](loc14: I128)

B45:

429MoveLoc[20](loc14: I128)

430StLoc[32](loc26: I128)

431ImmBorrowLoc[38](loc32: SwapResult)

432ImmBorrowField[29](SwapResult.liquidity: u128)

433ReadRef

434MoveLoc[32](loc26: I128)

435Call utils::add_delta(u128, I128): u128

436MutBorrowLoc[38](loc32: SwapResult)

437MutBorrowField[29](SwapResult.liquidity: u128)

438WriteRef

B46:

439CopyLoc[2](Arg2: bool)

440BrFalse(451)

B47:

441ImmBorrowLoc[37](loc31: SwapStepResult)

442ImmBorrowField[37](SwapStepResult.tick_index_next: I32)

443ReadRef

444Call i32H::mate_to_lib(I32): I32

445LdU32(1)

446Call i32::from(u32): I32

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

448Call i32H::lib_to_mate(I32): I32

449StLoc[21](loc15: I32)

450Branch(455)

B48:

451ImmBorrowLoc[37](loc31: SwapStepResult)

452ImmBorrowField[37](SwapStepResult.tick_index_next: I32)

453ReadRef

454StLoc[21](loc15: I32)

B49:

455MoveLoc[21](loc15: I32)

456MutBorrowLoc[38](loc32: SwapResult)

457MutBorrowField[36](SwapResult.current_tick_index: I32)

458WriteRef

459Branch(111)

B50:

460ImmBorrowLoc[38](loc32: SwapResult)

461ImmBorrowField[31](SwapResult.end_sqrt_price: u128)

462ReadRef

463ImmBorrowLoc[37](loc31: SwapStepResult)

464ImmBorrowField[48](SwapStepResult.sqrt_price_start: u128)

465ReadRef

466Neq

467BrFalse(475)

B51:

468ImmBorrowLoc[38](loc32: SwapResult)

469ImmBorrowField[31](SwapResult.end_sqrt_price: u128)

470ReadRef

471Call tick_math::get_tick_at_sqrt_price(u128): I32

472MutBorrowLoc[38](loc32: SwapResult)

473MutBorrowField[36](SwapResult.current_tick_index: I32)

474WriteRef

B52:

475Branch(111)

B53:

476MoveLoc[0](Arg0: &Clock)

477Pop

478ImmBorrowLoc[38](loc32: SwapResult)

479ImmBorrowField[25](SwapResult.amount_specified_remaining: u64)

480ReadRef

481LdU64(0)

482Gt

483MutBorrowLoc[38](loc32: SwapResult)

484MutBorrowField[32](SwapResult.is_exceed: bool)

485WriteRef

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

487CopyLoc[38](loc32: SwapResult)

488MoveLoc[39](loc33: u64)

489Call update_pool_state<Ty0, Ty1>(&mut Pool<Ty0, Ty1>, SwapResult, u64)

490MoveLoc[38](loc32: SwapResult)

491Ret

}

update_data_for_delta_l<Ty0, Ty1>(Arg0: &Clock, Arg1: &mut Pool<Ty0, Ty1>, Arg2: &mut Position, Arg3: I128): u64 * u64 {

L4: loc0: bool

L5: loc1: u128

L6: loc2: u128

L7: loc3: ID

L8: loc4: u128

L9: loc5: I32

L10: loc6: bool

L11: loc7: vector<u128>

L12: loc8: vector<u128>

L13: loc9: u256

L14: loc10: u64

L15: loc11: I64

L16: loc12: u32

L17: loc13: I32

L18: loc14: bool

B0:

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

1CopyLoc[0](Arg0: &Clock)

2Call utils::timestamp_seconds(&Clock): u64

3Call update_reward_infos<Ty0, Ty1>(&mut Pool<Ty0, Ty1>, u64): vector<u128>

4StLoc[11](loc7: vector<u128>)

5CopyLoc[3](Arg3: I128)

6Call i128::abs_u128(I128): u128

7StLoc[8](loc4: u128)

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

9FreezeRef

10Call position::lower_tick(&Position): I32

11StLoc[9](loc5: I32)

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

13FreezeRef

14Call position::upper_tick(&Position): I32

15StLoc[17](loc13: I32)

16LdFalse

17LdFalse

18StLoc[18](loc14: bool)

19StLoc[10](loc6: bool)

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

21ImmBorrowFieldGeneric[16](Pool.ticks_manager: TickManager)

22Call tick::tick_spacing(&TickManager): u32

23StLoc[16](loc12: u32)

24MoveLoc[0](Arg0: &Clock)

25Call utils::timestamp_seconds(&Clock): u64

26StLoc[14](loc10: u64)

27CopyLoc[8](loc4: u128)

28LdU128(0)

29Gt

30BrFalse(108)

B1:

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

32FreezeRef

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

34StLoc[7](loc3: ID)

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

36ImmBorrowFieldGeneric[10](Pool.observations_manager: ObservationManager)

37CopyLoc[14](loc10: u64)

38LdU64(0)

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

40ImmBorrowFieldGeneric[12](Pool.current_tick_index: I32)

41ReadRef

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

43ImmBorrowFieldGeneric[7](Pool.liquidity: u128)

44ReadRef

45Call oracle::observe_single(&ObservationManager, u64, u64, I32, u128): I64 * u256

46StLoc[13](loc9: u256)

47StLoc[15](loc11: I64)

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

49MutBorrowFieldGeneric[16](Pool.ticks_manager: TickManager)

50CopyLoc[7](loc3: ID)

51CopyLoc[9](loc5: I32)

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

53ImmBorrowFieldGeneric[12](Pool.current_tick_index: I32)

54ReadRef

55CopyLoc[3](Arg3: I128)

56Call i128H::lib_to_mate(I128): I128

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

58ImmBorrowFieldGeneric[14](Pool.fee_growth_global_coin_a: u128)

59ReadRef

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

61ImmBorrowFieldGeneric[15](Pool.fee_growth_global_coin_b: u128)

62ReadRef

63CopyLoc[11](loc7: vector<u128>)

64CopyLoc[15](loc11: I64)

65CopyLoc[13](loc9: u256)

66CopyLoc[14](loc10: u64)

67LdFalse

68Call tick::update(&mut TickManager, ID, I32, I32, I128, u128, u128, vector<u128>, I64, u256, u64, bool): bool

69StLoc[10](loc6: bool)

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

71MutBorrowFieldGeneric[16](Pool.ticks_manager: TickManager)

72MoveLoc[7](loc3: ID)

73CopyLoc[17](loc13: I32)

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

75ImmBorrowFieldGeneric[12](Pool.current_tick_index: I32)

76ReadRef

77CopyLoc[3](Arg3: I128)

78Call i128H::lib_to_mate(I128): I128

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

80ImmBorrowFieldGeneric[14](Pool.fee_growth_global_coin_a: u128)

81ReadRef

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

83ImmBorrowFieldGeneric[15](Pool.fee_growth_global_coin_b: u128)

84ReadRef

85CopyLoc[11](loc7: vector<u128>)

86MoveLoc[15](loc11: I64)

87MoveLoc[13](loc9: u256)

88CopyLoc[14](loc10: u64)

89LdTrue

90Call tick::update(&mut TickManager, ID, I32, I32, I128, u128, u128, vector<u128>, I64, u256, u64, bool): bool

91StLoc[18](loc14: bool)

92CopyLoc[10](loc6: bool)

93BrFalse(100)

B2:

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

95MutBorrowFieldGeneric[16](Pool.ticks_manager: TickManager)

96Call tick::mutable_bitmap(&mut TickManager): &mut Table<I32, u256>

97CopyLoc[9](loc5: I32)

98CopyLoc[16](loc12: u32)

99Call tick_bitmap::flip_tick(&mut Table<I32, u256>, I32, u32)

B3:

100CopyLoc[18](loc14: bool)

101BrFalse(108)

B4:

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

103MutBorrowFieldGeneric[16](Pool.ticks_manager: TickManager)

104Call tick::mutable_bitmap(&mut TickManager): &mut Table<I32, u256>

105CopyLoc[17](loc13: I32)

106MoveLoc[16](loc12: u32)

107Call tick_bitmap::flip_tick(&mut Table<I32, u256>, I32, u32)

B5:

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

109ImmBorrowFieldGeneric[16](Pool.ticks_manager: TickManager)

110CopyLoc[9](loc5: I32)

111CopyLoc[17](loc13: I32)

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

113ImmBorrowFieldGeneric[12](Pool.current_tick_index: I32)

114ReadRef

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

116ImmBorrowFieldGeneric[14](Pool.fee_growth_global_coin_a: u128)

117ReadRef

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

119ImmBorrowFieldGeneric[15](Pool.fee_growth_global_coin_b: u128)

120ReadRef

121MoveLoc[11](loc7: vector<u128>)

122Call tick::get_fee_and_reward_growths_inside(&TickManager, I32, I32, I32, u128, u128, vector<u128>): u128 * u128 * vector<u128>

123StLoc[12](loc8: vector<u128>)

124StLoc[6](loc2: u128)

125StLoc[5](loc1: u128)

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

127CopyLoc[3](Arg3: I128)

128Call i128H::lib_to_mate(I128): I128

129MoveLoc[5](loc1: u128)

130MoveLoc[6](loc2: u128)

131MoveLoc[12](loc8: vector<u128>)

132Call position::update(&mut Position, I128, u128, u128, vector<u128>)

133CopyLoc[3](Arg3: I128)

134Call i128::zero(): I128

135Call i128::lt(I128, I128): bool

136BrFalse(149)

B6:

137MoveLoc[10](loc6: bool)

138BrFalse(143)

B7:

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

140MutBorrowFieldGeneric[16](Pool.ticks_manager: TickManager)

141CopyLoc[9](loc5: I32)

142Call tick::remove(&mut TickManager, I32)

B8:

143MoveLoc[18](loc14: bool)

144BrFalse(149)

B9:

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

146MutBorrowFieldGeneric[16](Pool.ticks_manager: TickManager)

147CopyLoc[17](loc13: I32)

148Call tick::remove(&mut TickManager, I32)

B10:

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

150ImmBorrowFieldGeneric[12](Pool.current_tick_index: I32)

151ReadRef

152CopyLoc[9](loc5: I32)

153Call i32H::gte(I32, I32): bool

154BrFalse(162)

B11:

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

156ImmBorrowFieldGeneric[12](Pool.current_tick_index: I32)

157ReadRef

158CopyLoc[17](loc13: I32)

159Call i32H::lt(I32, I32): bool

160StLoc[4](loc0: bool)

161Branch(164)

B12:

162LdFalse

163StLoc[4](loc0: bool)

B13:

164MoveLoc[4](loc0: bool)

165BrFalse(185)

B14:

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

167MutBorrowFieldGeneric[10](Pool.observations_manager: ObservationManager)

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

169ImmBorrowFieldGeneric[12](Pool.current_tick_index: I32)

170ReadRef

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

172ImmBorrowFieldGeneric[7](Pool.liquidity: u128)

173ReadRef

174MoveLoc[14](loc10: u64)

175Call oracle::update(&mut ObservationManager, I32, u128, u64)

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

177ImmBorrowFieldGeneric[7](Pool.liquidity: u128)

178ReadRef

179CopyLoc[3](Arg3: I128)

180Call i128H::lib_to_mate(I128): I128

181Call utils::add_delta(u128, I128): u128

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

183MutBorrowFieldGeneric[7](Pool.liquidity: u128)

184WriteRef

B15:

185MoveLoc[9](loc5: I32)

186MoveLoc[17](loc13: I32)

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

188ImmBorrowFieldGeneric[12](Pool.current_tick_index: I32)

189ReadRef

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

191ImmBorrowFieldGeneric[13](Pool.current_sqrt_price: u128)

192ReadRef

193MoveLoc[8](loc4: u128)

194MoveLoc[3](Arg3: I128)

195Call i128::is_neg(I128): bool

196Not

197Call clmm_math::get_amount_by_liquidity(I32, I32, I32, u128, u128, bool): u64 * u64

198Ret

}

update_pool_state<Ty0, Ty1>(Arg0: &mut Pool<Ty0, Ty1>, Arg1: SwapResult, Arg2: u64) {

B0:

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

1ImmBorrowFieldGeneric[12](Pool.current_tick_index: I32)

2ReadRef

3ImmBorrowLoc[1](Arg1: SwapResult)

4ImmBorrowField[36](SwapResult.current_tick_index: I32)

5ReadRef

6Call i32H::eq(I32, I32): bool

7Not

8BrFalse(32)

B1:

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

10MutBorrowFieldGeneric[10](Pool.observations_manager: ObservationManager)

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

12ImmBorrowFieldGeneric[12](Pool.current_tick_index: I32)

13ReadRef

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

15ImmBorrowFieldGeneric[7](Pool.liquidity: u128)

16ReadRef

17MoveLoc[2](Arg2: u64)

18Call oracle::update(&mut ObservationManager, I32, u128, u64)

19ImmBorrowLoc[1](Arg1: SwapResult)

20ImmBorrowField[31](SwapResult.end_sqrt_price: u128)

21ReadRef

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

23MutBorrowFieldGeneric[13](Pool.current_sqrt_price: u128)

24WriteRef

25ImmBorrowLoc[1](Arg1: SwapResult)

26ImmBorrowField[36](SwapResult.current_tick_index: I32)

27ReadRef

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

29MutBorrowFieldGeneric[12](Pool.current_tick_index: I32)

30WriteRef

31Branch(38)

B2:

32ImmBorrowLoc[1](Arg1: SwapResult)

33ImmBorrowField[31](SwapResult.end_sqrt_price: u128)

34ReadRef

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

36MutBorrowFieldGeneric[13](Pool.current_sqrt_price: u128)

37WriteRef

B3:

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

39ImmBorrowFieldGeneric[7](Pool.liquidity: u128)

40ReadRef

41ImmBorrowLoc[1](Arg1: SwapResult)

42ImmBorrowField[29](SwapResult.liquidity: u128)

43ReadRef

44Neq

45BrFalse(52)

B4:

46ImmBorrowLoc[1](Arg1: SwapResult)

47ImmBorrowField[29](SwapResult.liquidity: u128)

48ReadRef

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

50MutBorrowFieldGeneric[7](Pool.liquidity: u128)

51WriteRef

B5:

52ImmBorrowLoc[1](Arg1: SwapResult)

53ImmBorrowField[52](SwapResult.a2b: bool)

54ReadRef

55BrFalse(73)

B6:

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

57ImmBorrowFieldGeneric[0](Pool.protocol_fee_coin_a: u64)

58ReadRef

59ImmBorrowLoc[1](Arg1: SwapResult)

60ImmBorrowField[27](SwapResult.protocol_fee: u64)

61ReadRef

62Add

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

64MutBorrowFieldGeneric[0](Pool.protocol_fee_coin_a: u64)

65WriteRef

66ImmBorrowLoc[1](Arg1: SwapResult)

67ImmBorrowField[45](SwapResult.fee_growth_global: u128)

68ReadRef

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

70MutBorrowFieldGeneric[14](Pool.fee_growth_global_coin_a: u128)

71WriteRef

72Branch(89)

B7:

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

74ImmBorrowFieldGeneric[1](Pool.protocol_fee_coin_b: u64)

75ReadRef

76ImmBorrowLoc[1](Arg1: SwapResult)

77ImmBorrowField[27](SwapResult.protocol_fee: u64)

78ReadRef

79Add

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

81MutBorrowFieldGeneric[1](Pool.protocol_fee_coin_b: u64)

82WriteRef

83ImmBorrowLoc[1](Arg1: SwapResult)

84ImmBorrowField[45](SwapResult.fee_growth_global: u128)

85ReadRef

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

87MutBorrowFieldGeneric[15](Pool.fee_growth_global_coin_b: u128)

88WriteRef

B8:

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

90ImmBorrowFieldGeneric[4](Pool.sequence_number: u128)

91ReadRef

92LdU128(1)

93Add

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

95MutBorrowFieldGeneric[4](Pool.sequence_number: u128)

96WriteRef

97Ret

}

get_accrued_rewards<Ty0, Ty1, Ty2>(Arg0: &Clock, Arg1: &mut Pool<Ty0, Ty1>, Arg2: &mut Position): u64 * PoolRewardInfo {

L3: loc0: u64

L4: loc1: u64

L5: loc2: u64

L6: loc3: u64

L7: loc4: &PoolRewardInfo

B0:

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

1FreezeRef

2Call position::liquidity(&Position): u128

3LdU128(0)

4Gt

5BrFalse(14)

B1:

6MoveLoc[0](Arg0: &Clock)

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

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

9Call i128::zero(): I128

10Call update_data_for_delta_l<Ty0, Ty1>(&Clock, &mut Pool<Ty0, Ty1>, &mut Position, I128): u64 * u64

11Pop

12Pop

13Branch(16)

B2:

14MoveLoc[0](Arg0: &Clock)

15Pop

B3:

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

17FreezeRef

18Call reward_infos_length<Ty0, Ty1>(&Pool<Ty0, Ty1>): u64

19StLoc[4](loc1: u64)

B4:

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

21FreezeRef

22Call position::reward_infos_length(&Position): u64

23CopyLoc[4](loc1: u64)

24Lt

25BrFalse(30)

B5:

26Branch(27)

B6:

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

28Call position::add_reward_info(&mut Position)

29Branch(20)

B7:

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

31FreezeRef

32Call find_reward_info_index<Ty0, Ty1, Ty2>(&Pool<Ty0, Ty1>): u64

33StLoc[6](loc3: u64)

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

35CopyLoc[6](loc3: u64)

36StLoc[3](loc0: u64)

37FreezeRef

38MoveLoc[3](loc0: u64)

39Call position::coins_owed_reward(&Position, u64): u64

40StLoc[5](loc2: u64)

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

42CopyLoc[6](loc3: u64)

43CopyLoc[5](loc2: u64)

44Call position::decrease_reward_amount(&mut Position, u64, u64)

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

46ImmBorrowFieldGeneric[6](Pool.reward_infos: vector<PoolRewardInfo>)

47MoveLoc[6](loc3: u64)

48VecImmBorrow(43)

49StLoc[7](loc4: &PoolRewardInfo)

50MoveLoc[5](loc2: u64)

51MoveLoc[7](loc4: &PoolRewardInfo)

52ReadRef

53Ret

}

get_accrued_fee<Ty0, Ty1>(Arg0: &Clock, Arg1: &mut Pool<Ty0, Ty1>, Arg2: &mut Position): u64 * u64 {

L3: loc0: u64

L4: loc1: u64

B0:

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

1FreezeRef

2Call position::liquidity(&Position): u128

3LdU128(0)

4Gt

5BrFalse(14)

B1:

6MoveLoc[0](Arg0: &Clock)

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

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

9Call i128::zero(): I128

10Call update_data_for_delta_l<Ty0, Ty1>(&Clock, &mut Pool<Ty0, Ty1>, &mut Position, I128): u64 * u64

11Pop

12Pop

13Branch(18)

B2:

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

15Pop

16MoveLoc[0](Arg0: &Clock)

17Pop

B3:

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

19FreezeRef

20Call position::get_accrued_fee(&Position): u64 * u64

21StLoc[4](loc1: u64)

22StLoc[3](loc0: u64)

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

24LdU64(0)

25LdU64(0)

26Call position::set_fee_amounts(&mut Position, u64, u64)

27MoveLoc[3](loc0: u64)

28MoveLoc[4](loc1: u64)

29Ret

}

create_pool_internal<Ty0, Ty1>(Arg0: &Clock, Arg1: &GlobalConfig, Arg2: vector<u8>, Arg3: vector<u8>, Arg4: vector<u8>, Arg5: u8, Arg6: vector<u8>, Arg7: vector<u8>, Arg8: u8, Arg9: vector<u8>, Arg10: u32, Arg11: u64, Arg12: u128, Arg13: &mut TxContext): Pool<Ty0, Ty1> {

L14: loc0: vector<u8>

L15: loc1: TickManager

L16: loc2: ObservationManager

L17: loc3: u128

L18: loc4: I32

L19: loc5: String

L20: loc6: UID

L21: loc7: vector<PoolRewardInfo>

L22: loc8: String

L23: loc9: Balance<Ty0>

L24: loc10: Balance<Ty1>

L25: loc11: u64

L26: loc12: u64

L27: loc13: String

L28: loc14: String

L29: loc15: I32

L30: loc16: vector<u8>

L31: loc17: ID

L32: loc18: ObservationManager

L33: loc19: Pool<Ty0, Ty1>

L34: loc20: TickManager

L35: loc21: UID

B0:

0MoveLoc[1](Arg1: &GlobalConfig)

1Call config::verify_version(&GlobalConfig)

2ImmBorrowLoc[3](Arg3: vector<u8>)

3VecLen(158)

4LdU64(0)

5Eq

6BrFalse(10)

B1:

7LdConst[0](vector<u8>: "htt..)

8StLoc[14](loc0: vector<u8>)

9Branch(12)

B2:

10MoveLoc[3](Arg3: vector<u8>)

11StLoc[14](loc0: vector<u8>)

B3:

12MoveLoc[14](loc0: vector<u8>)

13StLoc[30](loc16: vector<u8>)

14CopyLoc[10](Arg10: u32)

15Call constants::max_allowed_tick_spacing(): u32

16Le

17BrFalse(19)

B4:

18Branch(25)

B5:

19MoveLoc[13](Arg13: &mut TxContext)

20Pop

21MoveLoc[0](Arg0: &Clock)

22Pop

23Call errors::invalid_tick_spacing(): u64

24Abort

B6:

25CopyLoc[11](Arg11: u64)

26Call constants::max_allowed_fee_rate(): u64

27Le

28BrFalse(30)

B7:

29Branch(36)

B8:

30MoveLoc[13](Arg13: &mut TxContext)

31Pop

32MoveLoc[0](Arg0: &Clock)

33Pop

34Call errors::invalid_fee_rate(): u64

35Abort

B9:

36CopyLoc[12](Arg12: u128)

37Call tick_math::max_sqrt_price(): u128

38Lt

39BrFalse(41)

B10:

40Branch(47)

B11:

41MoveLoc[13](Arg13: &mut TxContext)

42Pop

43MoveLoc[0](Arg0: &Clock)

44Pop

45Call errors::invalid_pool_price(): u64

46Abort

B12:

47CopyLoc[13](Arg13: &mut TxContext)

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

49StLoc[35](loc21: UID)

50ImmBorrowLoc[35](loc21: UID)

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

52StLoc[31](loc17: ID)

53CopyLoc[10](Arg10: u32)

54CopyLoc[13](Arg13: &mut TxContext)

55Call tick::initialize_manager(u32, &mut TxContext): TickManager

56StLoc[34](loc20: TickManager)

57MoveLoc[0](Arg0: &Clock)

58Call utils::timestamp_seconds(&Clock): u64

59Call oracle::initialize_manager(u64): ObservationManager

60StLoc[32](loc18: ObservationManager)

61CopyLoc[12](Arg12: u128)

62Call tick_math::get_tick_at_sqrt_price(u128): I32

63StLoc[29](loc15: I32)

64Call utils::get_type_string<Ty0>(): String

65StLoc[27](loc13: String)

66Call utils::get_type_string<Ty1>(): String

67StLoc[28](loc14: String)

68CopyLoc[27](loc13: String)

69CopyLoc[28](loc14: String)

70Neq

71BrFalse(73)

B13:

72Branch(77)

B14:

73MoveLoc[13](Arg13: &mut TxContext)

74Pop

75Call errors::invalid_coins(): u64

76Abort

B15:

77MoveLoc[35](loc21: UID)

78StLoc[20](loc6: UID)

79MoveLoc[2](Arg2: vector<u8>)

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

81StLoc[22](loc8: String)

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

83StLoc[23](loc9: Balance<Ty0>)

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

85StLoc[24](loc10: Balance<Ty1>)

86CopyLoc[11](Arg11: u64)

87StLoc[25](loc11: u64)

88Call constants::protocol_fee_share(): u64

89StLoc[26](loc12: u64)

90MoveLoc[34](loc20: TickManager)

91StLoc[15](loc1: TickManager)

92MoveLoc[32](loc18: ObservationManager)

93StLoc[16](loc2: ObservationManager)

94CopyLoc[12](Arg12: u128)

95StLoc[17](loc3: u128)

96CopyLoc[29](loc15: I32)

97StLoc[18](loc4: I32)

98MoveLoc[30](loc16: vector<u8>)

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

100StLoc[19](loc5: String)

101VecPack(43, 0)

102StLoc[21](loc7: vector<PoolRewardInfo>)

103MoveLoc[20](loc6: UID)

104MoveLoc[22](loc8: String)

105MoveLoc[23](loc9: Balance<Ty0>)

106MoveLoc[24](loc10: Balance<Ty1>)

107MoveLoc[25](loc11: u64)

108MoveLoc[26](loc12: u64)

109LdU128(0)

110LdU128(0)

111LdU64(0)

112LdU64(0)

113MoveLoc[15](loc1: TickManager)

114MoveLoc[16](loc2: ObservationManager)

115MoveLoc[17](loc3: u128)

116MoveLoc[18](loc4: I32)

117LdU128(0)

118MoveLoc[21](loc7: vector<PoolRewardInfo>)

119LdFalse

120MoveLoc[19](loc5: String)

121LdU128(0)

122LdU128(0)

123PackGeneric[1](Pool<Ty0, Ty1>)

124StLoc[33](loc19: Pool<Ty0, Ty1>)

125MutBorrowLoc[33](loc19: Pool<Ty0, Ty1>)

126MutBorrowFieldGeneric[5](Pool.id: UID)

127Call constants::manager(): String

128MoveLoc[13](Arg13: &mut TxContext)

129FreezeRef

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

131Call dynamic_field::add<String, address>(&mut UID, String, address)

132MoveLoc[31](loc17: ID)

133MoveLoc[27](loc13: String)

134MoveLoc[4](Arg4: vector<u8>)

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

136MoveLoc[5](Arg5: u8)

137MoveLoc[6](Arg6: vector<u8>)

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

139MoveLoc[28](loc14: String)

140MoveLoc[7](Arg7: vector<u8>)

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

142MoveLoc[8](Arg8: u8)

143MoveLoc[9](Arg9: vector<u8>)

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

145MoveLoc[12](Arg12: u128)

146MoveLoc[29](loc15: I32)

147MoveLoc[10](Arg10: u32)

148MoveLoc[11](Arg11: u64)

149Call constants::protocol_fee_share(): u64

150Call events::emit_pool_created_event(ID, String, String, u8, String, String, String, u8, String, u128, I32, u32, u64, u64)

151MoveLoc[33](loc19: Pool<Ty0, Ty1>)

152Ret

}

charge_pool_creation_fee<Ty0>(Arg0: &mut GlobalConfig, Arg1: ID, Arg2: Balance<Ty0>, Arg3: &TxContext) {

L4: loc0: String

L5: loc1: &mut Balance<Ty0>

L6: loc2: &mut UID

L7: loc3: u64

L8: loc4: String

L9: loc5: u64

B0:

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

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

2StLoc[7](loc3: u64)

3CopyLoc[0](Arg0: &mut GlobalConfig)

4FreezeRef

5Call config::get_pool_creation_fee_amount<Ty0>(&GlobalConfig): bool * u64

6StLoc[9](loc5: u64)

7BrFalse(9)

B1:

8Branch(15)

B2:

9MoveLoc[0](Arg0: &mut GlobalConfig)

10Pop

11MoveLoc[3](Arg3: &TxContext)

12Pop

13Call errors::fee_coin_not_supported(): u64

14Abort

B3:

15CopyLoc[7](loc3: u64)

16MoveLoc[9](loc5: u64)

17Eq

18BrFalse(20)

B4:

19Branch(26)

B5:

20MoveLoc[0](Arg0: &mut GlobalConfig)

21Pop

22MoveLoc[3](Arg3: &TxContext)

23Pop

24Call errors::invalid_fee_provided(): u64

25Abort

B6:

26MoveLoc[0](Arg0: &mut GlobalConfig)

27Call config::get_config_id(&mut GlobalConfig): &mut UID

28StLoc[6](loc2: &mut UID)

29Call utils::get_type_string<Ty0>(): String

30StLoc[8](loc4: String)

31CopyLoc[6](loc2: &mut UID)

32CopyLoc[8](loc4: String)

33StLoc[4](loc0: String)

34FreezeRef

35MoveLoc[4](loc0: String)

36Call dynamic_field::exists_<String>(&UID, String): bool

37Not

38BrFalse(43)

B7:

39CopyLoc[6](loc2: &mut UID)

40CopyLoc[8](loc4: String)

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

42Call dynamic_field::add<String, Balance<Ty0>>(&mut UID, String, Balance<Ty0>)

B8:

43MoveLoc[6](loc2: &mut UID)

44MoveLoc[8](loc4: String)

45Call dynamic_field::borrow_mut<String, Balance<Ty0>>(&mut UID, String): &mut Balance<Ty0>

46StLoc[5](loc1: &mut Balance<Ty0>)

47CopyLoc[5](loc1: &mut Balance<Ty0>)

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

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

50Pop

51MoveLoc[1](Arg1: ID)

52MoveLoc[3](Arg3: &TxContext)

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

54Call utils::get_type_string<Ty0>(): String

55MoveLoc[7](loc3: u64)

56MoveLoc[5](loc1: &mut Balance<Ty0>)

57FreezeRef

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

59Call events::emit_pool_creation_fee_paid_event(ID, address, String, u64, u64)

60Ret

}

is_flash_swap_in_progress(Arg0: &UID): bool {

B0:

0MoveLoc[0](Arg0: &UID)

1Call constants::flash_swap_in_progress_key(): vector<u8>

2Call dynamic_field::exists_<vector<u8>>(&UID, vector<u8>): bool

3Ret

}

Constants [

0 => vector<u8>: "https://bluefin.io/images/nfts/default.gif" // interpreted as UTF8 string

]

}