pool

Module0x497a…a881

Move path: 0xe741…b239::pool
Functions: 11193 public, 0 entry
Structs: 33
Friend modules: factory

pool

Bytecode5651 lines

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

// Move bytecode v6

module e74104c66dd9f16b3096db2cc00300e556aa92edc871be4bc052b5dfb80db239.pool {

use e74104c66dd9f16b3096db2cc00300e556aa92edc871be4bc052b5dfb80db239::clmm_math;

use e74104c66dd9f16b3096db2cc00300e556aa92edc871be4bc052b5dfb80db239::config;

use e74104c66dd9f16b3096db2cc00300e556aa92edc871be4bc052b5dfb80db239::partner;

use e74104c66dd9f16b3096db2cc00300e556aa92edc871be4bc052b5dfb80db239::position;

use e74104c66dd9f16b3096db2cc00300e556aa92edc871be4bc052b5dfb80db239::rewarder;

use e74104c66dd9f16b3096db2cc00300e556aa92edc871be4bc052b5dfb80db239::stats;

use e74104c66dd9f16b3096db2cc00300e556aa92edc871be4bc052b5dfb80db239::tick;

use e74104c66dd9f16b3096db2cc00300e556aa92edc871be4bc052b5dfb80db239::tick_math;

use fc5ce91b953f03c30e3e48ac1d2a7706d66697c25979aeb978f9fff3fbcde5b2::gauge_cap;

use 6b904ae739b2baad330aae14991abcd3b7354d3dc3db72507ed8dabeeb7a36de::full_math_u128;

use 6b904ae739b2baad330aae14991abcd3b7354d3dc3db72507ed8dabeeb7a36de::full_math_u64;

use 6b904ae739b2baad330aae14991abcd3b7354d3dc3db72507ed8dabeeb7a36de::i128;

use 6b904ae739b2baad330aae14991abcd3b7354d3dc3db72507ed8dabeeb7a36de::i32;

use 6b904ae739b2baad330aae14991abcd3b7354d3dc3db72507ed8dabeeb7a36de::math_u128;

use 6b904ae739b2baad330aae14991abcd3b7354d3dc3db72507ed8dabeeb7a36de::math_u64;

use 2d8a7d4c585f1c20758f9b2c500477e1be35e178e79efb6ddf9d14a0dceff211::option_u64;

use b49be008cf304b1dae7e7ece661b5f1b0e15324bc1422ec8c73b10eb4a6dcb19::price_provider;

use 0000000000000000000000000000000000000000000000000000000000000001::ascii;

use 0000000000000000000000000000000000000000000000000000000000000001::option;

use 0000000000000000000000000000000000000000000000000000000000000001::string;

use 0000000000000000000000000000000000000000000000000000000000000001::type_name;

use 0000000000000000000000000000000000000000000000000000000000000002::balance;

use 0000000000000000000000000000000000000000000000000000000000000002::clock;

use 0000000000000000000000000000000000000000000000000000000000000002::display;

use 0000000000000000000000000000000000000000000000000000000000000002::event;

use 0000000000000000000000000000000000000000000000000000000000000002::object;

use 0000000000000000000000000000000000000000000000000000000000000002::package;

use 0000000000000000000000000000000000000000000000000000000000000002::transfer;

use 0000000000000000000000000000000000000000000000000000000000000002::tx_context;

struct POOL has drop {

dummy_field: bool

}

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

id: UID,

coin_a: Balance<Ty0>,

coin_b: Balance<Ty1>,

tick_spacing: u32,

fee_rate: u64,

liquidity: u128,

current_sqrt_price: u128,

current_tick_index: I32,

fee_growth_global_a: u128,

fee_growth_global_b: u128,

fee_protocol_coin_a: u64,

fee_protocol_coin_b: u64,

tick_manager: TickManager,

rewarder_manager: RewarderManager,

position_manager: PositionManager,

is_pause: bool,

index: u64,

url: String,

unstaked_liquidity_fee_rate: u64,

fullsail_distribution_gauger_id: Option<ID>,

fullsail_distribution_growth_global: u128,

fullsail_distribution_rate: u128,

fullsail_distribution_reserve: u64,

fullsail_distribution_period_finish: u64,

fullsail_distribution_rollover: u64,

fullsail_distribution_last_updated: u64,

fullsail_distribution_staked_liquidity: u128,

fullsail_distribution_gauger_fee: PoolFee,

volume: PoolVolume,

feed_id: PoolFeedId,

auto_calculation_volumes: bool

}

struct PoolFee has drop, store {

coin_a: u64,

coin_b: u64

}

struct PoolVolume has drop, store {

volume_usd_coin_a: u128,

volume_usd_coin_b: u128

}

struct PoolFeedId has drop, store {

feed_id_coin_a: address,

feed_id_coin_b: address

}

struct SwapResult has copy, drop {

amount_in: u64,

amount_out: u64,

fee_amount: u64,

protocol_fee_amount: u64,

ref_fee_amount: u64,

gauge_fee_amount: u64,

steps: u64

}

struct FlashSwapReceipt<phantom Ty0, phantom Ty1> {

pool_id: ID,

a2b: bool,

partner_id: Option<ID>,

pay_amount: u64,

fee_amount: u64,

protocol_fee_amount: u64,

ref_fee_amount: u64,

gauge_fee_amount: u64

}

struct AddLiquidityReceipt<phantom Ty0, phantom Ty1> {

pool_id: ID,

amount_a: u64,

amount_b: u64

}

struct CalculatedSwapResult has copy, drop, store {

amount_in: u64,

amount_out: u64,

fee_amount: u64,

fee_rate: u64,

ref_fee_amount: u64,

gauge_fee_amount: u64,

protocol_fee_amount: u64,

after_sqrt_price: u128,

is_exceed: bool,

step_results: vector<SwapStepResult>

}

struct SwapStepResult has copy, drop, store {

current_sqrt_price: u128,

target_sqrt_price: u128,

current_liquidity: u128,

amount_in: u64,

amount_out: u64,

fee_amount: u64,

remainder_amount: u64

}

struct OpenPositionEvent has copy, drop, store {

pool: ID,

tick_lower: I32,

tick_upper: I32,

position: ID

}

struct ClosePositionEvent has copy, drop, store {

pool: ID,

position: ID

}

struct AddLiquidityEvent has copy, drop, store {

pool: ID,

position: ID,

tick_lower: I32,

tick_upper: I32,

liquidity: u128,

after_liquidity: u128,

amount_a: u64,

amount_b: u64

}

struct RemoveLiquidityEvent has copy, drop, store {

pool: ID,

position: ID,

tick_lower: I32,

tick_upper: I32,

liquidity: u128,

after_liquidity: u128,

amount_a: u64,

amount_b: u64

}

struct SwapEvent has copy, drop, store {

atob: bool,

pool: ID,

partner: ID,

amount_in: u64,

amount_out: u64,

fullsail_fee_amount: u64,

protocol_fee_amount: u64,

ref_fee_amount: u64,

fee_amount: u64,

vault_a_amount: u64,

vault_b_amount: u64,

before_sqrt_price: u128,

after_sqrt_price: u128,

steps: u64

}

struct CollectProtocolFeeEvent has copy, drop, store {

pool: ID,

amount_a: u64,

amount_b: u64

}

struct CollectFeeEvent has copy, drop, store {

position: ID,

pool: ID,

amount_a: u64,

amount_b: u64

}

struct UpdateFeeRateEvent has copy, drop, store {

pool: ID,

old_fee_rate: u64,

new_fee_rate: u64

}

struct UpdateEmissionEvent has copy, drop, store {

pool: ID,

rewarder_type: TypeName,

emissions_per_second: u128

}

struct AddRewarderEvent has copy, drop, store {

pool: ID,

rewarder_type: TypeName

}

struct CollectRewardEvent has copy, drop, store {

position: ID,

pool: ID,

amount: u64

}

struct CollectRewardEventV2 has copy, drop, store {

position: ID,

pool: ID,

amount: u64,

token_type: TypeName

}

struct CollectGaugeFeeEvent has copy, drop, store {

pool: ID,

amount_a: u64,

amount_b: u64

}

struct UpdateUnstakedLiquidityFeeRateEvent has copy, drop, store {

pool: ID,

old_fee_rate: u64,

new_fee_rate: u64

}

struct UpdatePoolUrlEvent has copy, drop, store {

pool: ID,

new_url: String

}

struct InitFullsailDistributionGaugeEvent has copy, drop, store {

pool_id: ID,

gauge_id: ID

}

struct SyncFullsailDistributionRewardEvent has copy, drop, store {

pool_id: ID,

gauge_id: ID,

distribution_rate: u128,

distribution_reserve: u64,

period_finish: u64,

rollover: u64

}

struct PausePoolEvent has copy, drop, store {

pool_id: ID

}

struct UnpausePoolEvent has copy, drop, store {

pool_id: ID

}

struct UpdateFeeGrowthGlobalEvent has copy, drop, store {

pool_id: ID,

fee_growth_global_a: u128,

fee_growth_global_b: u128

}

struct UpdateFullsailDistributionGrowthGlobalEvent has copy, drop, store {

pool_id: ID,

growth_global: u128,

reserve: u64,

rollover: u64

}

struct UpdateFullsailDistributionStakedLiquidityEvent has copy, drop, store {

pool_id: ID,

staked_liquidity: u128

}

struct RestoreStakedLiquidityEvent has copy, drop, store {

pool_id: ID,

staked_liquidity_before: u128,

staked_liquidity_after: u128,

liquidity: u128

}

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

L10: loc0: PoolFeedId

B0:

0MoveLoc[5](Arg5: address)

1MoveLoc[6](Arg6: address)

2Pack[4](PoolFeedId)

3StLoc[10](loc0: PoolFeedId)

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

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

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

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

8CopyLoc[0](Arg0: u32)

9MoveLoc[2](Arg2: u64)

10LdU128(0)

11CopyLoc[1](Arg1: u128)

12MoveLoc[1](Arg1: u128)

13Call tick_math::get_tick_at_sqrt_price(u128): I32

14LdU128(0)

15LdU128(0)

16LdU64(0)

17LdU64(0)

18CopyLoc[0](Arg0: u32)

19CopyLoc[8](Arg8: &Clock)

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

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

22Call tick::new(u32, u64, &mut TxContext): TickManager

23Call rewarder::new(): RewarderManager

24MoveLoc[0](Arg0: u32)

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

26Call position::new(u32, &mut TxContext): PositionManager

27LdFalse

28MoveLoc[4](Arg4: u64)

29MoveLoc[3](Arg3: String)

30Call config::default_unstaked_fee_rate(): u64

31Call option::none<ID>(): Option<ID>

32LdU128(0)

33LdU128(0)

34LdU64(0)

35LdU64(0)

36LdU64(0)

37MoveLoc[8](Arg8: &Clock)

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

39LdU64(1000)

40Div

41LdU128(0)

42LdU64(0)

43LdU64(0)

44Pack[2](PoolFee)

45LdU128(0)

46LdU128(0)

47Pack[3](PoolVolume)

48MoveLoc[10](loc0: PoolFeedId)

49MoveLoc[7](Arg7: bool)

50PackGeneric[0](Pool<Ty0, Ty1>)

51Ret

}

public unstaked_liquidity_fee_rate<Ty0, Ty1>(Arg0: &Pool<Ty0, Ty1>): u64 {

B0:

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

1ImmBorrowFieldGeneric[0](Pool.unstaked_liquidity_fee_rate: u64)

2ReadRef

3Ret

}

public borrow_position_info<Ty0, Ty1>(Arg0: &Pool<Ty0, Ty1>, Arg1: ID): &PositionInfo {

B0:

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

1ImmBorrowFieldGeneric[1](Pool.position_manager: PositionManager)

2CopyLoc[1](Arg1: ID)

3Call position::validate_position_exists(&PositionManager, ID)

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

5ImmBorrowFieldGeneric[1](Pool.position_manager: PositionManager)

6MoveLoc[1](Arg1: ID)

7Call position::borrow_position_info(&PositionManager, ID): &PositionInfo

8Ret

}

public close_position<Ty0, Ty1>(Arg0: &GlobalConfig, Arg1: &mut Pool<Ty0, Ty1>, Arg2: Position) {

L3: loc0: ID

B0:

0MoveLoc[0](Arg0: &GlobalConfig)

1Call config::checked_package_version(&GlobalConfig)

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

3ImmBorrowFieldGeneric[2](Pool.is_pause: bool)

4ReadRef

5Not

6BrFalse(8)

B1:

7Branch(12)

B2:

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

9Pop

10LdConst[15](u64: 9283..)

11Abort

B3:

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

13FreezeRef

14ImmBorrowLoc[2](Arg2: Position)

15Call validate_pool_position<Ty0, Ty1>(&Pool<Ty0, Ty1>, &Position)

16ImmBorrowLoc[2](Arg2: Position)

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

18StLoc[3](loc0: ID)

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

20MutBorrowFieldGeneric[1](Pool.position_manager: PositionManager)

21MoveLoc[2](Arg2: Position)

22Call position::close_position(&mut PositionManager, Position)

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

24FreezeRef

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

26MoveLoc[3](loc0: ID)

27Pack[11](ClosePositionEvent)

28Call event::emit<ClosePositionEvent>(ClosePositionEvent)

29Ret

}

public fetch_positions<Ty0, Ty1>(Arg0: &Pool<Ty0, Ty1>, Arg1: Option<ID>, Arg2: u64): vector<PositionInfo> {

B0:

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

1ImmBorrowFieldGeneric[1](Pool.position_manager: PositionManager)

2MoveLoc[1](Arg1: Option<ID>)

3MoveLoc[2](Arg2: u64)

4Call position::fetch_positions(&PositionManager, Option<ID>, u64): vector<PositionInfo>

5Ret

}

public is_position_exist<Ty0, Ty1>(Arg0: &Pool<Ty0, Ty1>, Arg1: ID): bool {

B0:

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

1ImmBorrowFieldGeneric[1](Pool.position_manager: PositionManager)

2MoveLoc[1](Arg1: ID)

3Call position::is_position_exist(&PositionManager, ID): bool

4Ret

}

public liquidity<Ty0, Ty1>(Arg0: &Pool<Ty0, Ty1>): u128 {

B0:

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

1ImmBorrowFieldGeneric[3](Pool.liquidity: u128)

2ReadRef

3Ret

}

public open_position<Ty0, Ty1>(Arg0: &GlobalConfig, Arg1: &mut Pool<Ty0, Ty1>, Arg2: u32, Arg3: u32, Arg4: &mut TxContext): Position {

L5: loc0: ID

L6: loc1: Position

L7: loc2: I32

L8: loc3: I32

B0:

0MoveLoc[0](Arg0: &GlobalConfig)

1Call config::checked_package_version(&GlobalConfig)

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

3ImmBorrowFieldGeneric[2](Pool.is_pause: bool)

4ReadRef

5Not

6BrFalse(8)

B1:

7Branch(14)

B2:

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

9Pop

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

11Pop

12LdConst[15](u64: 9283..)

13Abort

B3:

14MoveLoc[2](Arg2: u32)

15Call i32::from_u32(u32): I32

16StLoc[7](loc2: I32)

17MoveLoc[3](Arg3: u32)

18Call i32::from_u32(u32): I32

19StLoc[8](loc3: I32)

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

21FreezeRef

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

23StLoc[5](loc0: ID)

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

25MutBorrowFieldGeneric[1](Pool.position_manager: PositionManager)

26CopyLoc[5](loc0: ID)

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

28ImmBorrowFieldGeneric[4](Pool.index: u64)

29ReadRef

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

31ImmBorrowFieldGeneric[5](Pool.url: String)

32ReadRef

33CopyLoc[7](loc2: I32)

34CopyLoc[8](loc3: I32)

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

36Call position::open_position<Ty0, Ty1>(&mut PositionManager, ID, u64, String, I32, I32, &mut TxContext): Position

37StLoc[6](loc1: Position)

38MoveLoc[5](loc0: ID)

39MoveLoc[7](loc2: I32)

40MoveLoc[8](loc3: I32)

41ImmBorrowLoc[6](loc1: Position)

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

43Pack[10](OpenPositionEvent)

44Call event::emit<OpenPositionEvent>(OpenPositionEvent)

45MoveLoc[6](loc1: Position)

46Ret

}

public update_emission<Ty0, Ty1, Ty2>(Arg0: &GlobalConfig, Arg1: &mut Pool<Ty0, Ty1>, Arg2: &mut RewarderGlobalVault, Arg3: u128, Arg4: &Clock, Arg5: &mut TxContext) {

B0:

0CopyLoc[0](Arg0: &GlobalConfig)

1Call config::checked_package_version(&GlobalConfig)

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

3ImmBorrowFieldGeneric[2](Pool.is_pause: bool)

4ReadRef

5Not

6BrFalse(8)

B1:

7Branch(20)

B2:

8MoveLoc[2](Arg2: &mut RewarderGlobalVault)

9Pop

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

11Pop

12MoveLoc[0](Arg0: &GlobalConfig)

13Pop

14MoveLoc[5](Arg5: &mut TxContext)

15Pop

16MoveLoc[4](Arg4: &Clock)

17Pop

18LdConst[15](u64: 9283..)

19Abort

B3:

20MoveLoc[0](Arg0: &GlobalConfig)

21MoveLoc[5](Arg5: &mut TxContext)

22FreezeRef

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

24Call config::check_rewarder_manager_role(&GlobalConfig, address)

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

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

27MutBorrowFieldGeneric[6](Pool.rewarder_manager: RewarderManager)

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

29ImmBorrowFieldGeneric[3](Pool.liquidity: u128)

30ReadRef

31CopyLoc[3](Arg3: u128)

32MoveLoc[4](Arg4: &Clock)

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

34LdU64(1000)

35Div

36Call rewarder::update_emission<Ty2>(&mut RewarderGlobalVault, &mut RewarderManager, u128, u128, u64)

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

38FreezeRef

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

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

41MoveLoc[3](Arg3: u128)

42Pack[18](UpdateEmissionEvent)

43Call event::emit<UpdateEmissionEvent>(UpdateEmissionEvent)

44Ret

}

public borrow_tick<Ty0, Ty1>(Arg0: &Pool<Ty0, Ty1>, Arg1: I32): &Tick {

B0:

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

1ImmBorrowFieldGeneric[7](Pool.tick_manager: TickManager)

2MoveLoc[1](Arg1: I32)

3Call tick::borrow_tick(&TickManager, I32): &Tick

4Ret

}

public fetch_ticks<Ty0, Ty1>(Arg0: &Pool<Ty0, Ty1>, Arg1: Option<u32>, Arg2: u64): vector<Tick> {

B0:

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

1ImmBorrowFieldGeneric[7](Pool.tick_manager: TickManager)

2MoveLoc[1](Arg1: Option<u32>)

3MoveLoc[2](Arg2: u64)

4Call tick::fetch_ticks(&TickManager, Option<u32>, u64): vector<Tick>

5Ret

}

public index<Ty0, Ty1>(Arg0: &Pool<Ty0, Ty1>): u64 {

B0:

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

1ImmBorrowFieldGeneric[4](Pool.index: u64)

2ReadRef

3Ret

}

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

B0:

0MoveLoc[0](Arg0: &GlobalConfig)

1Call config::checked_package_version(&GlobalConfig)

2CopyLoc[4](Arg4: u128)

3LdU128(0)

4Neq

5BrFalse(7)

B1:

6Branch(17)

B2:

7MoveLoc[1](Arg1: &mut RewarderGlobalVault)

8Pop

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

10Pop

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

12Pop

13MoveLoc[5](Arg5: &Clock)

14Pop

15LdConst[6](u64: 9328..)

16Abort

B3:

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

18FreezeRef

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

20FreezeRef

21Call validate_pool_position<Ty0, Ty1>(&Pool<Ty0, Ty1>, &Position)

22MoveLoc[1](Arg1: &mut RewarderGlobalVault)

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

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

25LdFalse

26MoveLoc[4](Arg4: u128)

27LdU64(0)

28LdFalse

29MoveLoc[5](Arg5: &Clock)

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

31LdU64(1000)

32Div

33Call add_liquidity_internal<Ty0, Ty1>(&mut RewarderGlobalVault, &mut Pool<Ty0, Ty1>, &mut Position, bool, u128, u64, bool, u64): AddLiquidityReceipt<Ty0, Ty1>

34Ret

}

public add_liquidity_fix_coin<Ty0, Ty1>(Arg0: &GlobalConfig, Arg1: &mut RewarderGlobalVault, Arg2: &mut Pool<Ty0, Ty1>, Arg3: &mut Position, Arg4: u64, Arg5: bool, Arg6: &Clock): AddLiquidityReceipt<Ty0, Ty1> {

B0:

0MoveLoc[0](Arg0: &GlobalConfig)

1Call config::checked_package_version(&GlobalConfig)

2CopyLoc[4](Arg4: u64)

3LdU64(0)

4Gt

5BrFalse(7)

B1:

6Branch(17)

B2:

7MoveLoc[1](Arg1: &mut RewarderGlobalVault)

8Pop

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

10Pop

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

12Pop

13MoveLoc[6](Arg6: &Clock)

14Pop

15LdConst[3](u64: 9236..)

16Abort

B3:

17MoveLoc[1](Arg1: &mut RewarderGlobalVault)

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

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

20LdTrue

21LdU128(0)

22MoveLoc[4](Arg4: u64)

23MoveLoc[5](Arg5: bool)

24MoveLoc[6](Arg6: &Clock)

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

26LdU64(1000)

27Div

28Call add_liquidity_internal<Ty0, Ty1>(&mut RewarderGlobalVault, &mut Pool<Ty0, Ty1>, &mut Position, bool, u128, u64, bool, u64): AddLiquidityReceipt<Ty0, Ty1>

29Ret

}

add_liquidity_internal<Ty0, Ty1>(Arg0: &mut RewarderGlobalVault, Arg1: &mut Pool<Ty0, Ty1>, Arg2: &mut Position, Arg3: bool, Arg4: u128, Arg5: u64, Arg6: bool, Arg7: u64): AddLiquidityReceipt<Ty0, Ty1> {

L8: loc0: u128

L9: loc1: u64

L10: loc2: u64

L11: loc3: bool

L12: loc4: u64

L13: loc5: u64

L14: loc6: u64

L15: loc7: u64

L16: loc8: u128

L17: loc9: u128

L18: loc10: u128

L19: loc11: u128

L20: loc12: u128

L21: loc13: ID

L22: loc14: vector<u128>

L23: loc15: I32

L24: loc16: I32

B0:

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

1ImmBorrowFieldGeneric[2](Pool.is_pause: bool)

2ReadRef

3Not

4BrFalse(6)

B1:

5Branch(14)

B2:

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

7Pop

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

9Pop

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

11Pop

12LdConst[15](u64: 9283..)

13Abort

B3:

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

15FreezeRef

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

17FreezeRef

18Call validate_pool_position<Ty0, Ty1>(&Pool<Ty0, Ty1>, &Position)

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

20FreezeRef

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

22StLoc[21](loc13: ID)

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

24ImmBorrowFieldGeneric[1](Pool.position_manager: PositionManager)

25MoveLoc[21](loc13: ID)

26Call position::is_position_staked(&PositionManager, ID): bool

27Not

28BrFalse(30)

B4:

29Branch(38)

B5:

30MoveLoc[0](Arg0: &mut RewarderGlobalVault)

31Pop

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

33Pop

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

35Pop

36LdConst[8](u64: 8945..)

37Abort

B6:

38MoveLoc[0](Arg0: &mut RewarderGlobalVault)

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

40MutBorrowFieldGeneric[6](Pool.rewarder_manager: RewarderManager)

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

42ImmBorrowFieldGeneric[3](Pool.liquidity: u128)

43ReadRef

44MoveLoc[7](Arg7: u64)

45Call rewarder::settle(&mut RewarderGlobalVault, &mut RewarderManager, u128, u64)

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

47FreezeRef

48Call position::tick_range(&Position): I32 * I32

49StLoc[24](loc16: I32)

50StLoc[23](loc15: I32)

51MoveLoc[3](Arg3: bool)

52BrFalse(68)

B7:

53CopyLoc[23](loc15: I32)

54CopyLoc[24](loc16: I32)

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

56ImmBorrowFieldGeneric[8](Pool.current_tick_index: I32)

57ReadRef

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

59ImmBorrowFieldGeneric[9](Pool.current_sqrt_price: u128)

60ReadRef

61MoveLoc[5](Arg5: u64)

62MoveLoc[6](Arg6: bool)

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

64StLoc[10](loc2: u64)

65StLoc[9](loc1: u64)

66StLoc[8](loc0: u128)

67Branch(87)

B8:

68CopyLoc[23](loc15: I32)

69CopyLoc[24](loc16: I32)

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

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

72ReadRef

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

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

75ReadRef

76CopyLoc[4](Arg4: u128)

77LdTrue

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

79StLoc[15](loc7: u64)

80StLoc[13](loc5: u64)

81CopyLoc[4](Arg4: u128)

82MoveLoc[13](loc5: u64)

83MoveLoc[15](loc7: u64)

84StLoc[10](loc2: u64)

85StLoc[9](loc1: u64)

86StLoc[8](loc0: u128)

B9:

87MoveLoc[8](loc0: u128)

88MoveLoc[9](loc1: u64)

89MoveLoc[10](loc2: u64)

90StLoc[14](loc6: u64)

91StLoc[12](loc4: u64)

92StLoc[19](loc11: u128)

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

94FreezeRef

95CopyLoc[23](loc15: I32)

96CopyLoc[24](loc16: I32)

97Call get_all_growths_in_tick_range<Ty0, Ty1>(&Pool<Ty0, Ty1>, I32, I32): u128 * u128 * vector<u128> * u128 * u128

98StLoc[18](loc10: u128)

99StLoc[20](loc12: u128)

100StLoc[22](loc14: vector<u128>)

101StLoc[17](loc9: u128)

102StLoc[16](loc8: u128)

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

104MutBorrowFieldGeneric[7](Pool.tick_manager: TickManager)

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

106ImmBorrowFieldGeneric[8](Pool.current_tick_index: I32)

107ReadRef

108CopyLoc[23](loc15: I32)

109CopyLoc[24](loc16: I32)

110CopyLoc[19](loc11: u128)

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

112ImmBorrowFieldGeneric[10](Pool.fee_growth_global_a: u128)

113ReadRef

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

115ImmBorrowFieldGeneric[11](Pool.fee_growth_global_b: u128)

116ReadRef

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

118ImmBorrowFieldGeneric[6](Pool.rewarder_manager: RewarderManager)

119Call rewarder::points_growth_global(&RewarderManager): u128

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

121ImmBorrowFieldGeneric[6](Pool.rewarder_manager: RewarderManager)

122Call rewarder::rewards_growth_global(&RewarderManager): vector<u128>

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

124ImmBorrowFieldGeneric[12](Pool.fullsail_distribution_growth_global: u128)

125ReadRef

126Call tick::increase_liquidity(&mut TickManager, I32, I32, I32, u128, u128, u128, u128, vector<u128>, u128)

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

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

129ReadRef

130CopyLoc[23](loc15: I32)

131Call i32::gte(I32, I32): bool

132BrFalse(140)

B10:

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

134ImmBorrowFieldGeneric[8](Pool.current_tick_index: I32)

135ReadRef

136CopyLoc[24](loc16: I32)

137Call i32::lt(I32, I32): bool

138StLoc[11](loc3: bool)

139Branch(142)

B11:

140LdFalse

141StLoc[11](loc3: bool)

B12:

142MoveLoc[11](loc3: bool)

143BrFalse(165)

B13:

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

145ImmBorrowFieldGeneric[3](Pool.liquidity: u128)

146ReadRef

147CopyLoc[19](loc11: u128)

148Call math_u128::add_check(u128, u128): bool

149BrFalse(151)

B14:

150Branch(157)

B15:

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

152Pop

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

154Pop

155LdConst[4](u64: 9342..)

156Abort

B16:

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

158ImmBorrowFieldGeneric[3](Pool.liquidity: u128)

159ReadRef

160CopyLoc[19](loc11: u128)

161Add

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

163MutBorrowFieldGeneric[3](Pool.liquidity: u128)

164WriteRef

B17:

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

166FreezeRef

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

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

169FreezeRef

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

171MoveLoc[23](loc15: I32)

172MoveLoc[24](loc16: I32)

173MoveLoc[4](Arg4: u128)

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

175MutBorrowFieldGeneric[1](Pool.position_manager: PositionManager)

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

177MoveLoc[19](loc11: u128)

178MoveLoc[16](loc8: u128)

179MoveLoc[17](loc9: u128)

180MoveLoc[20](loc12: u128)

181MoveLoc[22](loc14: vector<u128>)

182MoveLoc[18](loc10: u128)

183Call position::increase_liquidity(&mut PositionManager, &mut Position, u128, u128, u128, u128, vector<u128>, u128): u128

184CopyLoc[12](loc4: u64)

185CopyLoc[14](loc6: u64)

186Pack[12](AddLiquidityEvent)

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

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

189FreezeRef

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

191MoveLoc[12](loc4: u64)

192MoveLoc[14](loc6: u64)

193PackGeneric[1](AddLiquidityReceipt<Ty0, Ty1>)

194Ret

}

public add_liquidity_pay_amount<Ty0, Ty1>(Arg0: &AddLiquidityReceipt<Ty0, Ty1>): u64 * u64 {

B0:

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

1ImmBorrowFieldGeneric[13](AddLiquidityReceipt.amount_a: u64)

2ReadRef

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

4ImmBorrowFieldGeneric[14](AddLiquidityReceipt.amount_b: u64)

5ReadRef

6Ret

}

public balances<Ty0, Ty1>(Arg0: &Pool<Ty0, Ty1>): u64 * u64 {

B0:

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

1ImmBorrowFieldGeneric[15](Pool.coin_a: Balance<Ty0>)

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

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

4ImmBorrowFieldGeneric[16](Pool.coin_b: Balance<Ty1>)

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

6Ret

}

public calculate_and_update_fee<Ty0, Ty1>(Arg0: &GlobalConfig, Arg1: &mut Pool<Ty0, Ty1>, Arg2: ID): u64 * u64 {

L3: loc0: u64

L4: loc1: u64

L5: loc2: u128

L6: loc3: u128

L7: loc4: &PositionInfo

L8: loc5: I32

L9: loc6: I32

B0:

0MoveLoc[0](Arg0: &GlobalConfig)

1Call config::checked_package_version(&GlobalConfig)

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

3ImmBorrowFieldGeneric[2](Pool.is_pause: bool)

4ReadRef

5Not

6BrFalse(8)

B1:

7Branch(12)

B2:

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

9Pop

10LdConst[15](u64: 9283..)

11Abort

B3:

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

13ImmBorrowFieldGeneric[1](Pool.position_manager: PositionManager)

14CopyLoc[2](Arg2: ID)

15Call position::validate_position_exists(&PositionManager, ID)

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

17ImmBorrowFieldGeneric[1](Pool.position_manager: PositionManager)

18CopyLoc[2](Arg2: ID)

19Call position::borrow_position_info(&PositionManager, ID): &PositionInfo

20StLoc[7](loc4: &PositionInfo)

21CopyLoc[7](loc4: &PositionInfo)

22Call position::info_liquidity(&PositionInfo): u128

23LdU128(0)

24Neq

25BrFalse(46)

B4:

26MoveLoc[7](loc4: &PositionInfo)

27Call position::info_tick_range(&PositionInfo): I32 * I32

28StLoc[9](loc6: I32)

29StLoc[8](loc5: I32)

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

31FreezeRef

32MoveLoc[8](loc5: I32)

33MoveLoc[9](loc6: I32)

34Call get_fee_in_tick_range<Ty0, Ty1>(&Pool<Ty0, Ty1>, I32, I32): u128 * u128

35StLoc[6](loc3: u128)

36StLoc[5](loc2: u128)

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

38MutBorrowFieldGeneric[1](Pool.position_manager: PositionManager)

39MoveLoc[2](Arg2: ID)

40MoveLoc[5](loc2: u128)

41MoveLoc[6](loc3: u128)

42Call position::update_fee(&mut PositionManager, ID, u128, u128): u64 * u64

43StLoc[4](loc1: u64)

44StLoc[3](loc0: u64)

45Branch(52)

B5:

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

47Pop

48MoveLoc[7](loc4: &PositionInfo)

49Call position::info_fee_owned(&PositionInfo): u64 * u64

50StLoc[4](loc1: u64)

51StLoc[3](loc0: u64)

B6:

52MoveLoc[3](loc0: u64)

53MoveLoc[4](loc1: u64)

54Ret

}

public calculate_and_update_fullsail_distribution<Ty0, Ty1>(Arg0: &GlobalConfig, Arg1: &mut Pool<Ty0, Ty1>, Arg2: ID): u64 {

L3: loc0: u64

L4: loc1: &PositionInfo

L5: loc2: I32

L6: loc3: I32

B0:

0MoveLoc[0](Arg0: &GlobalConfig)

1Call config::checked_package_version(&GlobalConfig)

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

3ImmBorrowFieldGeneric[2](Pool.is_pause: bool)

4ReadRef

5Not

6BrFalse(8)

B1:

7Branch(12)

B2:

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

9Pop

10LdConst[15](u64: 9283..)

11Abort

B3:

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

13ImmBorrowFieldGeneric[1](Pool.position_manager: PositionManager)

14CopyLoc[2](Arg2: ID)

15Call position::validate_position_exists(&PositionManager, ID)

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

17ImmBorrowFieldGeneric[1](Pool.position_manager: PositionManager)

18CopyLoc[2](Arg2: ID)

19Call position::borrow_position_info(&PositionManager, ID): &PositionInfo

20StLoc[4](loc1: &PositionInfo)

21CopyLoc[4](loc1: &PositionInfo)

22Call position::info_liquidity(&PositionInfo): u128

23LdU128(0)

24Neq

25BrFalse(51)

B4:

26MoveLoc[4](loc1: &PositionInfo)

27Call position::info_tick_range(&PositionInfo): I32 * I32

28StLoc[6](loc3: I32)

29StLoc[5](loc2: I32)

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

31MutBorrowFieldGeneric[1](Pool.position_manager: PositionManager)

32MoveLoc[2](Arg2: ID)

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

34ImmBorrowFieldGeneric[8](Pool.current_tick_index: I32)

35ReadRef

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

37ImmBorrowFieldGeneric[12](Pool.fullsail_distribution_growth_global: u128)

38ReadRef

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

40ImmBorrowFieldGeneric[7](Pool.tick_manager: TickManager)

41MoveLoc[5](loc2: I32)

42Call tick::try_borrow_tick(&TickManager, I32): Option<Tick>

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

44ImmBorrowFieldGeneric[7](Pool.tick_manager: TickManager)

45MoveLoc[6](loc3: I32)

46Call tick::try_borrow_tick(&TickManager, I32): Option<Tick>

47Call tick::get_fullsail_distribution_growth_in_range(I32, u128, Option<Tick>, Option<Tick>): u128

48Call position::update_fullsail_distribution(&mut PositionManager, ID, u128): u64

49StLoc[3](loc0: u64)

50Branch(56)

B5:

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

52Pop

53MoveLoc[4](loc1: &PositionInfo)

54Call position::info_fullsail_distribution_owned(&PositionInfo): u64

55StLoc[3](loc0: u64)

B6:

56MoveLoc[3](loc0: u64)

57Ret

}

public calculate_and_update_points<Ty0, Ty1>(Arg0: &GlobalConfig, Arg1: &mut RewarderGlobalVault, Arg2: &mut Pool<Ty0, Ty1>, Arg3: ID, Arg4: &Clock): u128 {

L5: loc0: u128

L6: loc1: u128

L7: loc2: &PositionInfo

L8: loc3: I32

L9: loc4: I32

B0:

0MoveLoc[0](Arg0: &GlobalConfig)

1Call config::checked_package_version(&GlobalConfig)

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

3ImmBorrowFieldGeneric[2](Pool.is_pause: bool)

4ReadRef

5Not

6BrFalse(8)

B1:

7Branch(16)

B2:

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

9Pop

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

11Pop

12MoveLoc[4](Arg4: &Clock)

13Pop

14LdConst[15](u64: 9283..)

15Abort

B3:

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

17ImmBorrowFieldGeneric[1](Pool.position_manager: PositionManager)

18CopyLoc[3](Arg3: ID)

19Call position::validate_position_exists(&PositionManager, ID)

20MoveLoc[1](Arg1: &mut RewarderGlobalVault)

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

22MutBorrowFieldGeneric[6](Pool.rewarder_manager: RewarderManager)

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

24ImmBorrowFieldGeneric[3](Pool.liquidity: u128)

25ReadRef

26MoveLoc[4](Arg4: &Clock)

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

28LdU64(1000)

29Div

30Call rewarder::settle(&mut RewarderGlobalVault, &mut RewarderManager, u128, u64)

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

32ImmBorrowFieldGeneric[1](Pool.position_manager: PositionManager)

33CopyLoc[3](Arg3: ID)

34Call position::borrow_position_info(&PositionManager, ID): &PositionInfo

35StLoc[7](loc2: &PositionInfo)

36CopyLoc[7](loc2: &PositionInfo)

37Call position::info_liquidity(&PositionInfo): u128

38LdU128(0)

39Neq

40BrFalse(58)

B4:

41MoveLoc[7](loc2: &PositionInfo)

42Call position::info_tick_range(&PositionInfo): I32 * I32

43StLoc[9](loc4: I32)

44StLoc[8](loc3: I32)

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

46FreezeRef

47MoveLoc[8](loc3: I32)

48MoveLoc[9](loc4: I32)

49Call get_points_in_tick_range<Ty0, Ty1>(&Pool<Ty0, Ty1>, I32, I32): u128

50StLoc[6](loc1: u128)

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

52MutBorrowFieldGeneric[1](Pool.position_manager: PositionManager)

53MoveLoc[3](Arg3: ID)

54MoveLoc[6](loc1: u128)

55Call position::update_points(&mut PositionManager, ID, u128): u128

56StLoc[5](loc0: u128)

57Branch(66)

B5:

58MoveLoc[7](loc2: &PositionInfo)

59Pop

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

61ImmBorrowFieldGeneric[1](Pool.position_manager: PositionManager)

62MoveLoc[3](Arg3: ID)

63Call position::borrow_position_info(&PositionManager, ID): &PositionInfo

64Call position::info_points_owned(&PositionInfo): u128

65StLoc[5](loc0: u128)

B6:

66MoveLoc[5](loc0: u128)

67Ret

}

public calculate_and_update_reward<Ty0, Ty1, Ty2>(Arg0: &GlobalConfig, Arg1: &mut RewarderGlobalVault, Arg2: &mut Pool<Ty0, Ty1>, Arg3: ID, Arg4: &Clock): u64 {

L5: loc0: Option<u64>

L6: loc1: vector<u64>

B0:

0CopyLoc[0](Arg0: &GlobalConfig)

1Call config::checked_package_version(&GlobalConfig)

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

3ImmBorrowFieldGeneric[6](Pool.rewarder_manager: RewarderManager)

4Call rewarder::rewarder_index<Ty2>(&RewarderManager): Option<u64>

5StLoc[5](loc0: Option<u64>)

6ImmBorrowLoc[5](loc0: Option<u64>)

7Call option::is_some<u64>(&Option<u64>): bool

8BrFalse(10)

B1:

9Branch(20)

B2:

10MoveLoc[1](Arg1: &mut RewarderGlobalVault)

11Pop

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

13Pop

14MoveLoc[0](Arg0: &GlobalConfig)

15Pop

16MoveLoc[4](Arg4: &Clock)

17Pop

18LdConst[19](u64: 9839..)

19Abort

B3:

20MoveLoc[0](Arg0: &GlobalConfig)

21MoveLoc[1](Arg1: &mut RewarderGlobalVault)

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

23MoveLoc[3](Arg3: ID)

24MoveLoc[4](Arg4: &Clock)

25Call calculate_and_update_rewards<Ty0, Ty1>(&GlobalConfig, &mut RewarderGlobalVault, &mut Pool<Ty0, Ty1>, ID, &Clock): vector<u64>

26StLoc[6](loc1: vector<u64>)

27ImmBorrowLoc[6](loc1: vector<u64>)

28MutBorrowLoc[5](loc0: Option<u64>)

29Call option::extract<u64>(&mut Option<u64>): u64

30VecImmBorrow(3)

31ReadRef

32Ret

}

public calculate_and_update_rewards<Ty0, Ty1>(Arg0: &GlobalConfig, Arg1: &mut RewarderGlobalVault, Arg2: &mut Pool<Ty0, Ty1>, Arg3: ID, Arg4: &Clock): vector<u64> {

L5: loc0: vector<u64>

L6: loc1: &PositionInfo

L7: loc2: vector<u128>

L8: loc3: I32

L9: loc4: I32

B0:

0MoveLoc[0](Arg0: &GlobalConfig)

1Call config::checked_package_version(&GlobalConfig)

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

3ImmBorrowFieldGeneric[2](Pool.is_pause: bool)

4ReadRef

5Not

6BrFalse(8)

B1:

7Branch(16)

B2:

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

9Pop

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

11Pop

12MoveLoc[4](Arg4: &Clock)

13Pop

14LdConst[15](u64: 9283..)

15Abort

B3:

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

17ImmBorrowFieldGeneric[1](Pool.position_manager: PositionManager)

18CopyLoc[3](Arg3: ID)

19Call position::validate_position_exists(&PositionManager, ID)

20MoveLoc[1](Arg1: &mut RewarderGlobalVault)

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

22MutBorrowFieldGeneric[6](Pool.rewarder_manager: RewarderManager)

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

24ImmBorrowFieldGeneric[3](Pool.liquidity: u128)

25ReadRef

26MoveLoc[4](Arg4: &Clock)

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

28LdU64(1000)

29Div

30Call rewarder::settle(&mut RewarderGlobalVault, &mut RewarderManager, u128, u64)

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

32ImmBorrowFieldGeneric[1](Pool.position_manager: PositionManager)

33CopyLoc[3](Arg3: ID)

34Call position::borrow_position_info(&PositionManager, ID): &PositionInfo

35StLoc[6](loc1: &PositionInfo)

36CopyLoc[6](loc1: &PositionInfo)

37Call position::info_liquidity(&PositionInfo): u128

38LdU128(0)

39Neq

40BrFalse(58)

B4:

41MoveLoc[6](loc1: &PositionInfo)

42Call position::info_tick_range(&PositionInfo): I32 * I32

43StLoc[9](loc4: I32)

44StLoc[8](loc3: I32)

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

46FreezeRef

47MoveLoc[8](loc3: I32)

48MoveLoc[9](loc4: I32)

49Call get_rewards_in_tick_range<Ty0, Ty1>(&Pool<Ty0, Ty1>, I32, I32): vector<u128>

50StLoc[7](loc2: vector<u128>)

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

52MutBorrowFieldGeneric[1](Pool.position_manager: PositionManager)

53MoveLoc[3](Arg3: ID)

54MoveLoc[7](loc2: vector<u128>)

55Call position::update_rewards(&mut PositionManager, ID, vector<u128>): vector<u64>

56StLoc[5](loc0: vector<u64>)

57Branch(65)

B5:

58MoveLoc[6](loc1: &PositionInfo)

59Pop

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

61ImmBorrowFieldGeneric[1](Pool.position_manager: PositionManager)

62MoveLoc[3](Arg3: ID)

63Call position::rewards_amount_owned(&PositionManager, ID): vector<u64>

64StLoc[5](loc0: vector<u64>)

B6:

65MoveLoc[5](loc0: vector<u64>)

66Ret

}

calculate_fees(Arg0: u64, Arg1: u128, Arg2: u128, Arg3: u64): u128 * u64 {

L4: loc0: u128

L5: loc1: u64

L6: loc2: u128

L7: loc3: u64

L8: loc4: u128

L9: loc5: u64

B0:

0CopyLoc[2](Arg2: u128)

1CopyLoc[1](Arg1: u128)

2Ge

3BrFalse(9)

B1:

4LdU128(0)

5MoveLoc[0](Arg0: u64)

6StLoc[7](loc3: u64)

7StLoc[6](loc2: u128)

8Branch(46)

B2:

9CopyLoc[2](Arg2: u128)

10LdU128(0)

11Eq

12BrFalse(27)

B3:

13MoveLoc[0](Arg0: u64)

14CastU128

15LdU128(0)

16MoveLoc[3](Arg3: u64)

17Call apply_unstaked_fees(u128, u128, u64): u128 * u128

18StLoc[8](loc4: u128)

19LdConst[2](u128: 1844..)

20MoveLoc[1](Arg1: u128)

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

22MoveLoc[8](loc4: u128)

23CastU64

24StLoc[5](loc1: u64)

25StLoc[4](loc0: u128)

26Branch(42)

B4:

27MoveLoc[0](Arg0: u64)

28CopyLoc[1](Arg1: u128)

29CopyLoc[2](Arg2: u128)

30MoveLoc[3](Arg3: u64)

31Call split_fees(u64, u128, u128, u64): u64 * u64

32StLoc[9](loc5: u64)

33CastU128

34LdConst[2](u128: 1844..)

35MoveLoc[1](Arg1: u128)

36MoveLoc[2](Arg2: u128)

37Sub

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

39MoveLoc[9](loc5: u64)

40StLoc[5](loc1: u64)

41StLoc[4](loc0: u128)

B5:

42MoveLoc[4](loc0: u128)

43MoveLoc[5](loc1: u64)

44StLoc[7](loc3: u64)

45StLoc[6](loc2: u128)

B6:

46MoveLoc[6](loc2: u128)

47MoveLoc[7](loc3: u64)

48Ret

}

split_fees(Arg0: u64, Arg1: u128, Arg2: u128, Arg3: u64): u64 * u64 {

L4: loc0: u128

L5: loc1: u128

B0:

0CopyLoc[0](Arg0: u64)

1CastU128

2MoveLoc[2](Arg2: u128)

3MoveLoc[1](Arg1: u128)

4Call full_math_u128::mul_div_ceil(u128, u128, u128): u128

5StLoc[5](loc1: u128)

6MoveLoc[0](Arg0: u64)

7CastU128

8CopyLoc[5](loc1: u128)

9Sub

10MoveLoc[5](loc1: u128)

11MoveLoc[3](Arg3: u64)

12Call apply_unstaked_fees(u128, u128, u64): u128 * u128

13StLoc[4](loc0: u128)

14CastU64

15MoveLoc[4](loc0: u128)

16CastU64

17Ret

}

apply_unstaked_fees(Arg0: u128, Arg1: u128, Arg2: u64): u128 * u128 {

L3: loc0: u128

B0:

0CopyLoc[0](Arg0: u128)

1MoveLoc[2](Arg2: u64)

2CastU128

3Call config::unstaked_liquidity_fee_rate_denom(): u64

4CastU128

5Call full_math_u128::mul_div_ceil(u128, u128, u128): u128

6StLoc[3](loc0: u128)

7MoveLoc[0](Arg0: u128)

8CopyLoc[3](loc0: u128)

9Sub

10MoveLoc[1](Arg1: u128)

11MoveLoc[3](loc0: u128)

12Add

13Ret

}

public calculate_swap_result<Ty0, Ty1>(Arg0: &GlobalConfig, Arg1: &Pool<Ty0, Ty1>, Arg2: bool, Arg3: bool, Arg4: u64): CalculatedSwapResult {

B0:

0CopyLoc[0](Arg0: &GlobalConfig)

1Call config::checked_package_version(&GlobalConfig)

2MoveLoc[0](Arg0: &GlobalConfig)

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

4MoveLoc[2](Arg2: bool)

5MoveLoc[3](Arg3: bool)

6MoveLoc[4](Arg4: u64)

7LdU64(0)

8Call calculate_swap_result_internal<Ty0, Ty1>(&GlobalConfig, &Pool<Ty0, Ty1>, bool, bool, u64, u64): CalculatedSwapResult

9Ret

}

public calculate_swap_result_with_partner<Ty0, Ty1>(Arg0: &GlobalConfig, Arg1: &Pool<Ty0, Ty1>, Arg2: bool, Arg3: bool, Arg4: u64, Arg5: u64): CalculatedSwapResult {

B0:

0CopyLoc[0](Arg0: &GlobalConfig)

1Call config::checked_package_version(&GlobalConfig)

2MoveLoc[0](Arg0: &GlobalConfig)

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

4MoveLoc[2](Arg2: bool)

5MoveLoc[3](Arg3: bool)

6MoveLoc[4](Arg4: u64)

7MoveLoc[5](Arg5: u64)

8Call calculate_swap_result_internal<Ty0, Ty1>(&GlobalConfig, &Pool<Ty0, Ty1>, bool, bool, u64, u64): CalculatedSwapResult

9Ret

}

calculate_swap_result_internal<Ty0, Ty1>(Arg0: &GlobalConfig, Arg1: &Pool<Ty0, Ty1>, Arg2: bool, Arg3: bool, Arg4: u64, Arg5: u64): CalculatedSwapResult {

L6: loc0: u64

L7: loc1: bool

L8: loc2: u64

L9: loc3: I128

L10: loc4: I128

L11: loc5: u64

L12: loc6: u64

L13: loc7: CalculatedSwapResult

L14: loc8: u128

L15: loc9: u128

L16: loc10: u64

L17: loc11: u64

L18: loc12: u64

L19: loc13: u64

L20: loc14: u128

L21: loc15: I128

L22: loc16: u128

L23: loc17: OptionU64

L24: loc18: OptionU64

L25: loc19: u64

L26: loc20: u64

L27: loc21: u64

L28: loc22: u64

L29: loc23: u64

L30: loc24: u128

L31: loc25: u128

L32: loc26: I128

L33: loc27: SwapStepResult

L34: loc28: SwapResult

L35: loc29: u128

L36: loc30: &Tick

L37: loc31: u64

B0:

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

1ImmBorrowFieldGeneric[9](Pool.current_sqrt_price: u128)

2ReadRef

3StLoc[15](loc9: u128)

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

5ImmBorrowFieldGeneric[3](Pool.liquidity: u128)

6ReadRef

7StLoc[14](loc8: u128)

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

9ImmBorrowFieldGeneric[17](Pool.fullsail_distribution_staked_liquidity: u128)

10ReadRef

11StLoc[30](loc24: u128)

12Call default_swap_result(): SwapResult

13StLoc[34](loc28: SwapResult)

14MoveLoc[4](Arg4: u64)

15StLoc[28](loc22: u64)

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

17ImmBorrowFieldGeneric[7](Pool.tick_manager: TickManager)

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

19ImmBorrowFieldGeneric[8](Pool.current_tick_index: I32)

20ReadRef

21CopyLoc[2](Arg2: bool)

22Call tick::first_score_for_swap(&TickManager, I32, bool): OptionU64

23StLoc[23](loc17: OptionU64)

24LdU64(0)

25LdU64(0)

26LdU64(0)

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

28ImmBorrowFieldGeneric[18](Pool.fee_rate: u64)

29ReadRef

30LdU64(0)

31LdU64(0)

32LdU64(0)

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

34ImmBorrowFieldGeneric[9](Pool.current_sqrt_price: u128)

35ReadRef

36LdFalse

37VecPack(145, 0)

38Pack[8](CalculatedSwapResult)

39StLoc[13](loc7: CalculatedSwapResult)

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

41ImmBorrowFieldGeneric[0](Pool.unstaked_liquidity_fee_rate: u64)

42ReadRef

43Call config::default_unstaked_fee_rate(): u64

44Eq

45BrFalse(50)

B1:

46CopyLoc[0](Arg0: &GlobalConfig)

47Call config::unstaked_liquidity_fee_rate(&GlobalConfig): u64

48StLoc[6](loc0: u64)

49Branch(54)

B2:

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

51ImmBorrowFieldGeneric[0](Pool.unstaked_liquidity_fee_rate: u64)

52ReadRef

53StLoc[6](loc0: u64)

B3:

54MoveLoc[6](loc0: u64)

55StLoc[37](loc31: u64)

B4:

56CopyLoc[28](loc22: u64)

57LdU64(0)

58Gt

59BrFalse(300)

B5:

60Branch(61)

B6:

61ImmBorrowLoc[23](loc17: OptionU64)

62Call option_u64::is_none(&OptionU64): bool

63BrFalse(73)

B7:

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

65Pop

66MoveLoc[0](Arg0: &GlobalConfig)

67Pop

68LdTrue

69MutBorrowLoc[13](loc7: CalculatedSwapResult)

70MutBorrowField[19](CalculatedSwapResult.is_exceed: bool)

71WriteRef

72Branch(300)

B8:

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

74ImmBorrowFieldGeneric[7](Pool.tick_manager: TickManager)

75ImmBorrowLoc[23](loc17: OptionU64)

76Call option_u64::borrow(&OptionU64): u64

77CopyLoc[2](Arg2: bool)

78Call tick::borrow_tick_for_swap(&TickManager, u64, bool): &Tick * OptionU64

79StLoc[24](loc18: OptionU64)

80StLoc[36](loc30: &Tick)

81MoveLoc[24](loc18: OptionU64)

82StLoc[23](loc17: OptionU64)

83CopyLoc[36](loc30: &Tick)

84Call tick::sqrt_price(&Tick): u128

85StLoc[35](loc29: u128)

86CopyLoc[15](loc9: u128)

87CopyLoc[35](loc29: u128)

88CopyLoc[14](loc8: u128)

89CopyLoc[28](loc22: u64)

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

91ImmBorrowFieldGeneric[18](Pool.fee_rate: u64)

92ReadRef

93CopyLoc[2](Arg2: bool)

94CopyLoc[3](Arg3: bool)

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

96StLoc[17](loc11: u64)

97StLoc[22](loc16: u128)

98StLoc[12](loc6: u64)

99StLoc[11](loc5: u64)

100CopyLoc[11](loc5: u64)

101LdU64(0)

102Neq

103BrFalse(107)

B9:

104LdTrue

105StLoc[7](loc1: bool)

106Branch(111)

B10:

107CopyLoc[17](loc11: u64)

108LdU64(0)

109Neq

110StLoc[7](loc1: bool)

B11:

111MoveLoc[7](loc1: bool)

112BrFalse(178)

B12:

113CopyLoc[3](Arg3: bool)

114BrFalse(122)

B13:

115MoveLoc[28](loc22: u64)

116CopyLoc[11](loc5: u64)

117Call check_remainer_amount_sub(u64, u64): u64

118CopyLoc[17](loc11: u64)

119Call check_remainer_amount_sub(u64, u64): u64

120StLoc[8](loc2: u64)

121Branch(126)

B14:

122MoveLoc[28](loc22: u64)

123CopyLoc[12](loc6: u64)

124Call check_remainer_amount_sub(u64, u64): u64

125StLoc[8](loc2: u64)

B15:

126MoveLoc[8](loc2: u64)

127StLoc[28](loc22: u64)

128LdU64(0)

129StLoc[18](loc12: u64)

130LdU64(0)

131StLoc[25](loc19: u64)

132CopyLoc[17](loc11: u64)

133CopyLoc[5](Arg5: u64)

134Call config::protocol_fee_rate_denom(): u64

135Call full_math_u64::mul_div_ceil(u64, u64, u64): u64

136StLoc[27](loc21: u64)

137CopyLoc[17](loc11: u64)

138CopyLoc[27](loc21: u64)

139Sub

140StLoc[29](loc23: u64)

141CopyLoc[29](loc23: u64)

142LdU64(0)

143Gt

144BrFalse(170)

B16:

145CopyLoc[29](loc23: u64)

146CopyLoc[0](Arg0: &GlobalConfig)

147Call config::protocol_fee_rate(&GlobalConfig): u64

148Call config::protocol_fee_rate_denom(): u64

149Call full_math_u64::mul_div_ceil(u64, u64, u64): u64

150StLoc[26](loc20: u64)

151CopyLoc[26](loc20: u64)

152StLoc[25](loc19: u64)

153MoveLoc[29](loc23: u64)

154MoveLoc[26](loc20: u64)

155Sub

156StLoc[16](loc10: u64)

157CopyLoc[16](loc10: u64)

158LdU64(0)

159Gt

160BrFalse(170)

B17:

161MoveLoc[16](loc10: u64)

162CopyLoc[14](loc8: u128)

163CopyLoc[30](loc24: u128)

164CopyLoc[37](loc31: u64)

165Call calculate_fees(u64, u128, u128, u64): u128 * u64

166StLoc[19](loc13: u64)

167Pop

168MoveLoc[19](loc13: u64)

169StLoc[18](loc12: u64)

B18:

170MutBorrowLoc[34](loc28: SwapResult)

171CopyLoc[11](loc5: u64)

172CopyLoc[12](loc6: u64)

173CopyLoc[17](loc11: u64)

174MoveLoc[25](loc19: u64)

175MoveLoc[27](loc21: u64)

176MoveLoc[18](loc12: u64)

177Call update_swap_result(&mut SwapResult, u64, u64, u64, u64, u64, u64)

B19:

178MoveLoc[15](loc9: u128)

179CopyLoc[35](loc29: u128)

180CopyLoc[14](loc8: u128)

181MoveLoc[11](loc5: u64)

182MoveLoc[12](loc6: u64)

183MoveLoc[17](loc11: u64)

184CopyLoc[28](loc22: u64)

185Pack[9](SwapStepResult)

186StLoc[33](loc27: SwapStepResult)

187MutBorrowLoc[13](loc7: CalculatedSwapResult)

188MutBorrowField[20](CalculatedSwapResult.step_results: vector<SwapStepResult>)

189MoveLoc[33](loc27: SwapStepResult)

190VecPushBack(145)

191CopyLoc[22](loc16: u128)

192CopyLoc[35](loc29: u128)

193Eq

194BrFalse(295)

B20:

195MoveLoc[35](loc29: u128)

196StLoc[15](loc9: u128)

197CopyLoc[2](Arg2: bool)

198BrFalse(208)

B21:

199CopyLoc[36](loc30: &Tick)

200Call tick::liquidity_net(&Tick): I128

201Call i128::neg(I128): I128

202MoveLoc[36](loc30: &Tick)

203Call tick::fullsail_distribution_staked_liquidity_net(&Tick): I128

204Call i128::neg(I128): I128

205StLoc[10](loc4: I128)

206StLoc[9](loc3: I128)

207Branch(214)

B22:

208CopyLoc[36](loc30: &Tick)

209Call tick::liquidity_net(&Tick): I128

210MoveLoc[36](loc30: &Tick)

211Call tick::fullsail_distribution_staked_liquidity_net(&Tick): I128

212StLoc[10](loc4: I128)

213StLoc[9](loc3: I128)

B23:

214MoveLoc[9](loc3: I128)

215MoveLoc[10](loc4: I128)

216StLoc[32](loc26: I128)

217StLoc[21](loc15: I128)

218CopyLoc[21](loc15: I128)

219Call i128::abs_u128(I128): u128

220StLoc[20](loc14: u128)

221CopyLoc[32](loc26: I128)

222Call i128::abs_u128(I128): u128

223StLoc[31](loc25: u128)

224MoveLoc[21](loc15: I128)

225Call i128::is_neg(I128): bool

226Not

227BrFalse(244)

B24:

228CopyLoc[14](loc8: u128)

229CopyLoc[20](loc14: u128)

230Call math_u128::add_check(u128, u128): bool

231BrFalse(233)

B25:

232Branch(239)

B26:

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

234Pop

235MoveLoc[0](Arg0: &GlobalConfig)

236Pop

237LdConst[4](u64: 9342..)

238Abort

B27:

239MoveLoc[14](loc8: u128)

240MoveLoc[20](loc14: u128)

241Add

242StLoc[14](loc8: u128)

243Branch(259)

B28:

244CopyLoc[14](loc8: u128)

245CopyLoc[20](loc14: u128)

246Ge

247BrFalse(249)

B29:

248Branch(255)

B30:

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

250Pop

251MoveLoc[0](Arg0: &GlobalConfig)

252Pop

253LdConst[4](u64: 9342..)

254Abort

B31:

255MoveLoc[14](loc8: u128)

256MoveLoc[20](loc14: u128)

257Sub

258StLoc[14](loc8: u128)

B32:

259MoveLoc[32](loc26: I128)

260Call i128::is_neg(I128): bool

261Not

262BrFalse(279)

B33:

263CopyLoc[30](loc24: u128)

264CopyLoc[31](loc25: u128)

265Call math_u128::add_check(u128, u128): bool

266BrFalse(268)

B34:

267Branch(274)

B35:

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

269Pop

270MoveLoc[0](Arg0: &GlobalConfig)

271Pop

272LdConst[31](u64: 9223..)

273Abort

B36:

274MoveLoc[30](loc24: u128)

275MoveLoc[31](loc25: u128)

276Add

277StLoc[30](loc24: u128)

278Branch(56)

B37:

279CopyLoc[30](loc24: u128)

280CopyLoc[31](loc25: u128)

281Ge

282BrFalse(284)

B38:

283Branch(290)

B39:

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

285Pop

286MoveLoc[0](Arg0: &GlobalConfig)

287Pop

288LdConst[31](u64: 9223..)

289Abort

B40:

290MoveLoc[30](loc24: u128)

291MoveLoc[31](loc25: u128)

292Sub

293StLoc[30](loc24: u128)

294Branch(56)

B41:

295MoveLoc[36](loc30: &Tick)

296Pop

297MoveLoc[22](loc16: u128)

298StLoc[15](loc9: u128)

299Branch(56)

B42:

300ImmBorrowLoc[34](loc28: SwapResult)

301ImmBorrowField[21](SwapResult.amount_in: u64)

302ReadRef

303MutBorrowLoc[13](loc7: CalculatedSwapResult)

304MutBorrowField[22](CalculatedSwapResult.amount_in: u64)

305WriteRef

306ImmBorrowLoc[34](loc28: SwapResult)

307ImmBorrowField[23](SwapResult.amount_out: u64)

308ReadRef

309MutBorrowLoc[13](loc7: CalculatedSwapResult)

310MutBorrowField[24](CalculatedSwapResult.amount_out: u64)

311WriteRef

312ImmBorrowLoc[34](loc28: SwapResult)

313ImmBorrowField[25](SwapResult.fee_amount: u64)

314ReadRef

315MutBorrowLoc[13](loc7: CalculatedSwapResult)

316MutBorrowField[26](CalculatedSwapResult.fee_amount: u64)

317WriteRef

318ImmBorrowLoc[34](loc28: SwapResult)

319ImmBorrowField[27](SwapResult.gauge_fee_amount: u64)

320ReadRef

321MutBorrowLoc[13](loc7: CalculatedSwapResult)

322MutBorrowField[28](CalculatedSwapResult.gauge_fee_amount: u64)

323WriteRef

324ImmBorrowLoc[34](loc28: SwapResult)

325ImmBorrowField[29](SwapResult.protocol_fee_amount: u64)

326ReadRef

327MutBorrowLoc[13](loc7: CalculatedSwapResult)

328MutBorrowField[30](CalculatedSwapResult.protocol_fee_amount: u64)

329WriteRef

330ImmBorrowLoc[34](loc28: SwapResult)

331ImmBorrowField[31](SwapResult.ref_fee_amount: u64)

332ReadRef

333MutBorrowLoc[13](loc7: CalculatedSwapResult)

334MutBorrowField[32](CalculatedSwapResult.ref_fee_amount: u64)

335WriteRef

336MoveLoc[15](loc9: u128)

337MutBorrowLoc[13](loc7: CalculatedSwapResult)

338MutBorrowField[33](CalculatedSwapResult.after_sqrt_price: u128)

339WriteRef

340MoveLoc[13](loc7: CalculatedSwapResult)

341Ret

}

public calculate_swap_result_step_results(Arg0: &CalculatedSwapResult): &vector<SwapStepResult> {

B0:

0MoveLoc[0](Arg0: &CalculatedSwapResult)

1ImmBorrowField[20](CalculatedSwapResult.step_results: vector<SwapStepResult>)

2Ret

}

public calculated_swap_result_after_sqrt_price(Arg0: &CalculatedSwapResult): u128 {

B0:

0MoveLoc[0](Arg0: &CalculatedSwapResult)

1ImmBorrowField[33](CalculatedSwapResult.after_sqrt_price: u128)

2ReadRef

3Ret

}

public calculated_swap_result_amount_in(Arg0: &CalculatedSwapResult): u64 {

B0:

0MoveLoc[0](Arg0: &CalculatedSwapResult)

1ImmBorrowField[22](CalculatedSwapResult.amount_in: u64)

2ReadRef

3Ret

}

public calculated_swap_result_amount_out(Arg0: &CalculatedSwapResult): u64 {

B0:

0MoveLoc[0](Arg0: &CalculatedSwapResult)

1ImmBorrowField[24](CalculatedSwapResult.amount_out: u64)

2ReadRef

3Ret

}

public calculated_swap_result_fees_amount(Arg0: &CalculatedSwapResult): u64 * u64 * u64 * u64 {

B0:

0CopyLoc[0](Arg0: &CalculatedSwapResult)

1ImmBorrowField[26](CalculatedSwapResult.fee_amount: u64)

2ReadRef

3CopyLoc[0](Arg0: &CalculatedSwapResult)

4ImmBorrowField[32](CalculatedSwapResult.ref_fee_amount: u64)

5ReadRef

6CopyLoc[0](Arg0: &CalculatedSwapResult)

7ImmBorrowField[30](CalculatedSwapResult.protocol_fee_amount: u64)

8ReadRef

9MoveLoc[0](Arg0: &CalculatedSwapResult)

10ImmBorrowField[28](CalculatedSwapResult.gauge_fee_amount: u64)

11ReadRef

12Ret

}

public calculated_swap_result_is_exceed(Arg0: &CalculatedSwapResult): bool {

B0:

0MoveLoc[0](Arg0: &CalculatedSwapResult)

1ImmBorrowField[19](CalculatedSwapResult.is_exceed: bool)

2ReadRef

3Ret

}

public calculated_swap_result_step_swap_result(Arg0: &CalculatedSwapResult, Arg1: u64): &SwapStepResult {

B0:

0MoveLoc[0](Arg0: &CalculatedSwapResult)

1ImmBorrowField[20](CalculatedSwapResult.step_results: vector<SwapStepResult>)

2MoveLoc[1](Arg1: u64)

3VecImmBorrow(145)

4Ret

}

public calculated_swap_result_steps_length(Arg0: &CalculatedSwapResult): u64 {

B0:

0MoveLoc[0](Arg0: &CalculatedSwapResult)

1ImmBorrowField[20](CalculatedSwapResult.step_results: vector<SwapStepResult>)

2VecLen(145)

3Ret

}

check_gauge_cap<Ty0, Ty1>(Arg0: &Pool<Ty0, Ty1>, Arg1: &GaugeCap) {

L2: loc0: bool

L3: loc1: bool

L4: loc2: ID

L5: loc3: &Option<ID>

B0:

0CopyLoc[1](Arg1: &GaugeCap)

1Call gauge_cap::get_pool_id(&GaugeCap): ID

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

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

4Eq

5BrFalse(30)

B1:

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

7ImmBorrowFieldGeneric[19](Pool.fullsail_distribution_gauger_id: Option<ID>)

8StLoc[5](loc3: &Option<ID>)

9CopyLoc[5](loc3: &Option<ID>)

10Call option::is_some<ID>(&Option<ID>): bool

11BrFalse(21)

B2:

12MoveLoc[1](Arg1: &GaugeCap)

13Call gauge_cap::get_gauge_id(&GaugeCap): ID

14StLoc[4](loc2: ID)

15MoveLoc[5](loc3: &Option<ID>)

16Call option::borrow<ID>(&Option<ID>): &ID

17ImmBorrowLoc[4](loc2: ID)

18Eq

19StLoc[2](loc0: bool)

20Branch(27)

B3:

21MoveLoc[5](loc3: &Option<ID>)

22Pop

23MoveLoc[1](Arg1: &GaugeCap)

24Pop

25LdFalse

26StLoc[2](loc0: bool)

B4:

27MoveLoc[2](loc0: bool)

28StLoc[3](loc1: bool)

29Branch(36)

B5:

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

31Pop

32MoveLoc[1](Arg1: &GaugeCap)

33Pop

34LdFalse

35StLoc[3](loc1: bool)

B6:

36MoveLoc[3](loc1: bool)

37BrFalse(39)

B7:

38Branch(41)

B8:

39LdConst[28](u64: 9223..)

40Abort

B9:

41Ret

}

check_remainer_amount_sub(Arg0: u64, Arg1: u64): u64 {

B0:

0CopyLoc[0](Arg0: u64)

1CopyLoc[1](Arg1: u64)

2Ge

3BrFalse(5)

B1:

4Branch(7)

B2:

5LdConst[7](u64: 9239..)

6Abort

B3:

7MoveLoc[0](Arg0: u64)

8MoveLoc[1](Arg1: u64)

9Sub

10Ret

}

check_tick_range(Arg0: I32, Arg1: I32): bool {

L2: loc0: bool

L3: loc1: bool

B0:

0CopyLoc[0](Arg0: I32)

1CopyLoc[1](Arg1: I32)

2Call i32::gte(I32, I32): bool

3BrFalse(7)

B1:

4LdTrue

5StLoc[3](loc1: bool)

6Branch(20)

B2:

7MoveLoc[0](Arg0: I32)

8Call tick_math::min_tick(): I32

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

10BrFalse(14)

B3:

11LdTrue

12StLoc[2](loc0: bool)

13Branch(18)

B4:

14MoveLoc[1](Arg1: I32)

15Call tick_math::max_tick(): I32

16Call i32::gt(I32, I32): bool

17StLoc[2](loc0: bool)

B5:

18MoveLoc[2](loc0: bool)

19StLoc[3](loc1: bool)

B6:

20MoveLoc[3](loc1: bool)

21BrFalse(24)

B7:

22LdFalse

23Ret

B8:

24LdTrue

25Ret

}

public collect_fee<Ty0, Ty1>(Arg0: &GlobalConfig, Arg1: &mut Pool<Ty0, Ty1>, Arg2: &Position, Arg3: bool): Balance<Ty0> * Balance<Ty1> {

L4: loc0: bool

L5: loc1: u64

L6: loc2: u64

L7: loc3: u64

L8: loc4: u64

L9: loc5: u128

L10: loc6: u128

L11: loc7: ID

L12: loc8: I32

L13: loc9: I32

B0:

0MoveLoc[0](Arg0: &GlobalConfig)

1Call config::checked_package_version(&GlobalConfig)

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

3ImmBorrowFieldGeneric[2](Pool.is_pause: bool)

4ReadRef

5Not

6BrFalse(8)

B1:

7Branch(14)

B2:

8MoveLoc[2](Arg2: &Position)

9Pop

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

11Pop

12LdConst[15](u64: 9283..)

13Abort

B3:

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

15FreezeRef

16CopyLoc[2](Arg2: &Position)

17Call validate_pool_position<Ty0, Ty1>(&Pool<Ty0, Ty1>, &Position)

18CopyLoc[2](Arg2: &Position)

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

20StLoc[11](loc7: ID)

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

22FreezeRef

23CopyLoc[11](loc7: ID)

24Call borrow_position_info<Ty0, Ty1>(&Pool<Ty0, Ty1>, ID): &PositionInfo

25Call position::is_staked(&PositionInfo): bool

26BrFalse(34)

B4:

27MoveLoc[2](Arg2: &Position)

28Pop

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

30Pop

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

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

33Ret

B5:

34CopyLoc[2](Arg2: &Position)

35Call position::tick_range(&Position): I32 * I32

36StLoc[13](loc9: I32)

37StLoc[12](loc8: I32)

38MoveLoc[3](Arg3: bool)

39BrFalse(46)

B6:

40MoveLoc[2](Arg2: &Position)

41Call position::liquidity(&Position): u128

42LdU128(0)

43Neq

44StLoc[4](loc0: bool)

45Branch(50)

B7:

46MoveLoc[2](Arg2: &Position)

47Pop

48LdFalse

49StLoc[4](loc0: bool)

B8:

50MoveLoc[4](loc0: bool)

51BrFalse(68)

B9:

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

53FreezeRef

54MoveLoc[12](loc8: I32)

55MoveLoc[13](loc9: I32)

56Call get_fee_in_tick_range<Ty0, Ty1>(&Pool<Ty0, Ty1>, I32, I32): u128 * u128

57StLoc[10](loc6: u128)

58StLoc[9](loc5: u128)

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

60MutBorrowFieldGeneric[1](Pool.position_manager: PositionManager)

61CopyLoc[11](loc7: ID)

62MoveLoc[9](loc5: u128)

63MoveLoc[10](loc6: u128)

64Call position::update_and_reset_fee(&mut PositionManager, ID, u128, u128): u64 * u64

65StLoc[6](loc2: u64)

66StLoc[5](loc1: u64)

67Branch(74)

B10:

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

69MutBorrowFieldGeneric[1](Pool.position_manager: PositionManager)

70CopyLoc[11](loc7: ID)

71Call position::reset_fee(&mut PositionManager, ID): u64 * u64

72StLoc[6](loc2: u64)

73StLoc[5](loc1: u64)

B11:

74MoveLoc[5](loc1: u64)

75MoveLoc[6](loc2: u64)

76StLoc[8](loc4: u64)

77StLoc[7](loc3: u64)

78MoveLoc[11](loc7: ID)

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

80FreezeRef

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

82CopyLoc[7](loc3: u64)

83CopyLoc[8](loc4: u64)

84Pack[16](CollectFeeEvent)

85Call event::emit<CollectFeeEvent>(CollectFeeEvent)

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

87MutBorrowFieldGeneric[15](Pool.coin_a: Balance<Ty0>)

88MoveLoc[7](loc3: u64)

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

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

91MutBorrowFieldGeneric[16](Pool.coin_b: Balance<Ty1>)

92MoveLoc[8](loc4: u64)

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

94Ret

}

public collect_fullsail_distribution_gauger_fees<Ty0, Ty1>(Arg0: &mut Pool<Ty0, Ty1>, Arg1: &GaugeCap): Balance<Ty0> * Balance<Ty1> {

L2: loc0: Balance<Ty0>

L3: loc1: Balance<Ty1>

B0:

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

1ImmBorrowFieldGeneric[2](Pool.is_pause: bool)

2ReadRef

3Not

4BrFalse(6)

B1:

5Branch(12)

B2:

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

7Pop

8MoveLoc[1](Arg1: &GaugeCap)

9Pop

10LdConst[15](u64: 9283..)

11Abort

B3:

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

13FreezeRef

14MoveLoc[1](Arg1: &GaugeCap)

15Call check_gauge_cap<Ty0, Ty1>(&Pool<Ty0, Ty1>, &GaugeCap)

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

17StLoc[2](loc0: Balance<Ty0>)

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

19StLoc[3](loc1: Balance<Ty1>)

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

21ImmBorrowFieldGeneric[20](Pool.fullsail_distribution_gauger_fee: PoolFee)

22ImmBorrowField[36](PoolFee.coin_a: u64)

23ReadRef

24LdU64(0)

25Gt

26BrFalse(42)

B4:

27MutBorrowLoc[2](loc0: Balance<Ty0>)

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

29MutBorrowFieldGeneric[15](Pool.coin_a: Balance<Ty0>)

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

31ImmBorrowFieldGeneric[20](Pool.fullsail_distribution_gauger_fee: PoolFee)

32ImmBorrowField[36](PoolFee.coin_a: u64)

33ReadRef

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

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

36Pop

37LdU64(0)

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

39MutBorrowFieldGeneric[20](Pool.fullsail_distribution_gauger_fee: PoolFee)

40MutBorrowField[36](PoolFee.coin_a: u64)

41WriteRef

B5:

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

43ImmBorrowFieldGeneric[20](Pool.fullsail_distribution_gauger_fee: PoolFee)

44ImmBorrowField[37](PoolFee.coin_b: u64)

45ReadRef

46LdU64(0)

47Gt

48BrFalse(64)

B6:

49MutBorrowLoc[3](loc1: Balance<Ty1>)

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

51MutBorrowFieldGeneric[16](Pool.coin_b: Balance<Ty1>)

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

53ImmBorrowFieldGeneric[20](Pool.fullsail_distribution_gauger_fee: PoolFee)

54ImmBorrowField[37](PoolFee.coin_b: u64)

55ReadRef

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

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

58Pop

59LdU64(0)

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

61MutBorrowFieldGeneric[20](Pool.fullsail_distribution_gauger_fee: PoolFee)

62MutBorrowField[37](PoolFee.coin_b: u64)

63WriteRef

B7:

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

65FreezeRef

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

67ImmBorrowLoc[2](loc0: Balance<Ty0>)

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

69ImmBorrowLoc[3](loc1: Balance<Ty1>)

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

71Pack[22](CollectGaugeFeeEvent)

72Call event::emit<CollectGaugeFeeEvent>(CollectGaugeFeeEvent)

73MoveLoc[2](loc0: Balance<Ty0>)

74MoveLoc[3](loc1: Balance<Ty1>)

75Ret

}

public collect_protocol_fee<Ty0, Ty1>(Arg0: &GlobalConfig, Arg1: &mut Pool<Ty0, Ty1>, Arg2: &mut TxContext): Balance<Ty0> * Balance<Ty1> {

L3: loc0: u64

L4: loc1: u64

B0:

0CopyLoc[0](Arg0: &GlobalConfig)

1Call config::checked_package_version(&GlobalConfig)

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

3ImmBorrowFieldGeneric[2](Pool.is_pause: bool)

4ReadRef

5Not

6BrFalse(8)

B1:

7Branch(16)

B2:

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

9Pop

10MoveLoc[0](Arg0: &GlobalConfig)

11Pop

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

13Pop

14LdConst[15](u64: 9283..)

15Abort

B3:

16MoveLoc[0](Arg0: &GlobalConfig)

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

18FreezeRef

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

20Call config::check_protocol_fee_claim_role(&GlobalConfig, address)

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

22ImmBorrowFieldGeneric[21](Pool.fee_protocol_coin_a: u64)

23ReadRef

24StLoc[3](loc0: u64)

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

26ImmBorrowFieldGeneric[22](Pool.fee_protocol_coin_b: u64)

27ReadRef

28StLoc[4](loc1: u64)

29LdU64(0)

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

31MutBorrowFieldGeneric[21](Pool.fee_protocol_coin_a: u64)

32WriteRef

33LdU64(0)

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

35MutBorrowFieldGeneric[22](Pool.fee_protocol_coin_b: u64)

36WriteRef

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

38FreezeRef

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

40CopyLoc[3](loc0: u64)

41CopyLoc[4](loc1: u64)

42Pack[15](CollectProtocolFeeEvent)

43Call event::emit<CollectProtocolFeeEvent>(CollectProtocolFeeEvent)

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

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

46MoveLoc[3](loc0: u64)

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

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

49MutBorrowFieldGeneric[16](Pool.coin_b: Balance<Ty1>)

50MoveLoc[4](loc1: u64)

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

52Ret

}

public collect_reward<Ty0, Ty1, Ty2>(Arg0: &GlobalConfig, Arg1: &mut Pool<Ty0, Ty1>, Arg2: &Position, Arg3: &mut RewarderGlobalVault, Arg4: bool, Arg5: &Clock): Balance<Ty2> {

L6: loc0: bool

L7: loc1: bool

L8: loc2: u64

L9: loc3: CollectRewardEvent

L10: loc4: CollectRewardEventV2

L11: loc5: ID

L12: loc6: u64

L13: loc7: Option<u64>

L14: loc8: u64

L15: loc9: vector<u128>

L16: loc10: I32

L17: loc11: I32

B0:

0MoveLoc[0](Arg0: &GlobalConfig)

1Call config::checked_package_version(&GlobalConfig)

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

3ImmBorrowFieldGeneric[2](Pool.is_pause: bool)

4ReadRef

5Not

6BrFalse(8)

B1:

7Branch(18)

B2:

8MoveLoc[3](Arg3: &mut RewarderGlobalVault)

9Pop

10MoveLoc[2](Arg2: &Position)

11Pop

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

13Pop

14MoveLoc[5](Arg5: &Clock)

15Pop

16LdConst[15](u64: 9283..)

17Abort

B3:

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

19FreezeRef

20CopyLoc[2](Arg2: &Position)

21Call validate_pool_position<Ty0, Ty1>(&Pool<Ty0, Ty1>, &Position)

22CopyLoc[3](Arg3: &mut RewarderGlobalVault)

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

24MutBorrowFieldGeneric[6](Pool.rewarder_manager: RewarderManager)

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

26ImmBorrowFieldGeneric[3](Pool.liquidity: u128)

27ReadRef

28MoveLoc[5](Arg5: &Clock)

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

30LdU64(1000)

31Div

32Call rewarder::settle(&mut RewarderGlobalVault, &mut RewarderManager, u128, u64)

33CopyLoc[2](Arg2: &Position)

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

35StLoc[11](loc5: ID)

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

37ImmBorrowFieldGeneric[6](Pool.rewarder_manager: RewarderManager)

38Call rewarder::rewarder_index<Ty2>(&RewarderManager): Option<u64>

39StLoc[13](loc7: Option<u64>)

40ImmBorrowLoc[13](loc7: Option<u64>)

41Call option::is_some<u64>(&Option<u64>): bool

42BrFalse(44)

B4:

43Branch(52)

B5:

44MoveLoc[3](Arg3: &mut RewarderGlobalVault)

45Pop

46MoveLoc[2](Arg2: &Position)

47Pop

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

49Pop

50LdConst[19](u64: 9839..)

51Abort

B6:

52MutBorrowLoc[13](loc7: Option<u64>)

53Call option::extract<u64>(&mut Option<u64>): u64

54StLoc[14](loc8: u64)

55MoveLoc[4](Arg4: bool)

56BrFalse(63)

B7:

57CopyLoc[2](Arg2: &Position)

58Call position::liquidity(&Position): u128

59LdU128(0)

60Neq

61StLoc[7](loc1: bool)

62Branch(65)

B8:

63LdFalse

64StLoc[7](loc1: bool)

B9:

65MoveLoc[7](loc1: bool)

66BrFalse(70)

B10:

67LdTrue

68StLoc[6](loc0: bool)

69Branch(77)

B11:

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

71ImmBorrowFieldGeneric[1](Pool.position_manager: PositionManager)

72CopyLoc[11](loc5: ID)

73Call position::inited_rewards_count(&PositionManager, ID): u64

74CopyLoc[14](loc8: u64)

75Le

76StLoc[6](loc0: bool)

B12:

77MoveLoc[6](loc0: bool)

78BrFalse(97)

B13:

79MoveLoc[2](Arg2: &Position)

80Call position::tick_range(&Position): I32 * I32

81StLoc[17](loc11: I32)

82StLoc[16](loc10: I32)

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

84FreezeRef

85MoveLoc[16](loc10: I32)

86MoveLoc[17](loc11: I32)

87Call get_rewards_in_tick_range<Ty0, Ty1>(&Pool<Ty0, Ty1>, I32, I32): vector<u128>

88StLoc[15](loc9: vector<u128>)

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

90MutBorrowFieldGeneric[1](Pool.position_manager: PositionManager)

91CopyLoc[11](loc5: ID)

92MoveLoc[15](loc9: vector<u128>)

93MoveLoc[14](loc8: u64)

94Call position::update_and_reset_rewards(&mut PositionManager, ID, vector<u128>, u64): u64

95StLoc[8](loc2: u64)

96Branch(105)

B14:

97MoveLoc[2](Arg2: &Position)

98Pop

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

100MutBorrowFieldGeneric[1](Pool.position_manager: PositionManager)

101CopyLoc[11](loc5: ID)

102MoveLoc[14](loc8: u64)

103Call position::reset_rewarder(&mut PositionManager, ID, u64): u64

104StLoc[8](loc2: u64)

B15:

105MoveLoc[8](loc2: u64)

106StLoc[12](loc6: u64)

107CopyLoc[11](loc5: ID)

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

109FreezeRef

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

111CopyLoc[12](loc6: u64)

112Pack[20](CollectRewardEvent)

113StLoc[9](loc3: CollectRewardEvent)

114MoveLoc[11](loc5: ID)

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

116FreezeRef

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

118CopyLoc[12](loc6: u64)

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

120Pack[21](CollectRewardEventV2)

121StLoc[10](loc4: CollectRewardEventV2)

122MoveLoc[9](loc3: CollectRewardEvent)

123Call event::emit<CollectRewardEvent>(CollectRewardEvent)

124MoveLoc[10](loc4: CollectRewardEventV2)

125Call event::emit<CollectRewardEventV2>(CollectRewardEventV2)

126MoveLoc[3](Arg3: &mut RewarderGlobalVault)

127MoveLoc[12](loc6: u64)

128Call rewarder::withdraw_reward<Ty2>(&mut RewarderGlobalVault, u64): Balance<Ty2>

129Ret

}

public current_sqrt_price<Ty0, Ty1>(Arg0: &Pool<Ty0, Ty1>): u128 {

B0:

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

1ImmBorrowFieldGeneric[9](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[8](Pool.current_tick_index: I32)

2ReadRef

3Ret

}

default_swap_result(): SwapResult {

B0:

0LdU64(0)

1LdU64(0)

2LdU64(0)

3LdU64(0)

4LdU64(0)

5LdU64(0)

6LdU64(0)

7Pack[5](SwapResult)

8Ret

}

public fee_rate<Ty0, Ty1>(Arg0: &Pool<Ty0, Ty1>): u64 {

B0:

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

1ImmBorrowFieldGeneric[18](Pool.fee_rate: u64)

2ReadRef

3Ret

}

public fees_amount<Ty0, Ty1>(Arg0: &FlashSwapReceipt<Ty0, Ty1>): u64 * u64 * u64 * u64 {

B0:

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

1ImmBorrowFieldGeneric[23](FlashSwapReceipt.fee_amount: u64)

2ReadRef

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

4ImmBorrowFieldGeneric[24](FlashSwapReceipt.ref_fee_amount: u64)

5ReadRef

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

7ImmBorrowFieldGeneric[25](FlashSwapReceipt.protocol_fee_amount: u64)

8ReadRef

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

10ImmBorrowFieldGeneric[26](FlashSwapReceipt.gauge_fee_amount: u64)

11ReadRef

12Ret

}

public fees_growth_global<Ty0, Ty1>(Arg0: &Pool<Ty0, Ty1>): u128 * u128 {

B0:

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

1ImmBorrowFieldGeneric[10](Pool.fee_growth_global_a: u128)

2ReadRef

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

4ImmBorrowFieldGeneric[11](Pool.fee_growth_global_b: u128)

5ReadRef

6Ret

}

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

B0:

0CopyLoc[0](Arg0: &GlobalConfig)

1Call config::checked_package_version(&GlobalConfig)

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

3ImmBorrowFieldGeneric[2](Pool.is_pause: bool)

4ReadRef

5Not

6BrFalse(8)

B1:

7Branch(22)

B2:

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

9Pop

10MoveLoc[7](Arg7: &mut Stats)

11Pop

12MoveLoc[8](Arg8: &PriceProvider)

13Pop

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

15Pop

16MoveLoc[0](Arg0: &GlobalConfig)

17Pop

18MoveLoc[9](Arg9: &Clock)

19Pop

20LdConst[15](u64: 9283..)

21Abort

B3:

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

23MoveLoc[0](Arg0: &GlobalConfig)

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

25Call option::none<ID>(): Option<ID>

26LdU64(0)

27MoveLoc[3](Arg3: bool)

28MoveLoc[4](Arg4: bool)

29MoveLoc[5](Arg5: u64)

30MoveLoc[6](Arg6: u128)

31MoveLoc[7](Arg7: &mut Stats)

32MoveLoc[8](Arg8: &PriceProvider)

33MoveLoc[9](Arg9: &Clock)

34Call flash_swap_internal<Ty0, Ty1>(&mut Pool<Ty0, Ty1>, &GlobalConfig, &mut RewarderGlobalVault, Option<ID>, u64, bool, bool, u64, u128, &mut Stats, &PriceProvider, &Clock): Balance<Ty0> * Balance<Ty1> * FlashSwapReceipt<Ty0, Ty1>

35Ret

}

flash_swap_internal<Ty0, Ty1>(Arg0: &mut Pool<Ty0, Ty1>, Arg1: &GlobalConfig, Arg2: &mut RewarderGlobalVault, Arg3: Option<ID>, Arg4: u64, Arg5: bool, Arg6: bool, Arg7: u64, Arg8: u128, Arg9: &mut Stats, Arg10: &PriceProvider, Arg11: &Clock): Balance<Ty0> * Balance<Ty1> * FlashSwapReceipt<Ty0, Ty1> {

L12: loc0: bool

L13: loc1: bool

L14: loc2: u64

L15: loc3: Balance<Ty1>

L16: loc4: Balance<Ty0>

L17: loc5: ID

L18: loc6: Balance<Ty0>

L19: loc7: Balance<Ty1>

L20: loc8: u128

L21: loc9: u128

L22: loc10: u64

L23: loc11: ID

L24: loc12: ID

L25: loc13: FlashSwapReceipt<Ty0, Ty1>

L26: loc14: SwapResult

L27: loc15: u64

B0:

0CopyLoc[7](Arg7: u64)

1LdU64(0)

2Gt

3BrFalse(5)

B1:

4Branch(15)

B2:

5MoveLoc[2](Arg2: &mut RewarderGlobalVault)

6Pop

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

8Pop

9MoveLoc[1](Arg1: &GlobalConfig)

10Pop

11MoveLoc[11](Arg11: &Clock)

12Pop

13LdConst[3](u64: 9236..)

14Abort

B3:

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

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

17MutBorrowFieldGeneric[6](Pool.rewarder_manager: RewarderManager)

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

19ImmBorrowFieldGeneric[3](Pool.liquidity: u128)

20ReadRef

21CopyLoc[11](Arg11: &Clock)

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

23LdU64(1000)

24Div

25Call rewarder::settle(&mut RewarderGlobalVault, &mut RewarderManager, u128, u64)

26CopyLoc[5](Arg5: bool)

27BrFalse(52)

B4:

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

29ImmBorrowFieldGeneric[9](Pool.current_sqrt_price: u128)

30ReadRef

31CopyLoc[8](Arg8: u128)

32Gt

33BrFalse(39)

B5:

34CopyLoc[8](Arg8: u128)

35Call tick_math::min_sqrt_price(): u128

36Ge

37StLoc[12](loc0: bool)

38Branch(41)

B6:

39LdFalse

40StLoc[12](loc0: bool)

B7:

41MoveLoc[12](loc0: bool)

42BrFalse(44)

B8:

43Branch(76)

B9:

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

45Pop

46MoveLoc[1](Arg1: &GlobalConfig)

47Pop

48MoveLoc[11](Arg11: &Clock)

49Pop

50LdConst[13](u64: 9239..)

51Abort

B10:

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

53ImmBorrowFieldGeneric[9](Pool.current_sqrt_price: u128)

54ReadRef

55CopyLoc[8](Arg8: u128)

56Lt

57BrFalse(63)

B11:

58CopyLoc[8](Arg8: u128)

59Call tick_math::max_sqrt_price(): u128

60Le

61StLoc[13](loc1: bool)

62Branch(65)

B12:

63LdFalse

64StLoc[13](loc1: bool)

B13:

65MoveLoc[13](loc1: bool)

66BrFalse(68)

B14:

67Branch(76)

B15:

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

69Pop

70MoveLoc[1](Arg1: &GlobalConfig)

71Pop

72MoveLoc[11](Arg11: &Clock)

73Pop

74LdConst[13](u64: 9239..)

75Abort

B16:

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

77ImmBorrowFieldGeneric[9](Pool.current_sqrt_price: u128)

78ReadRef

79StLoc[20](loc8: u128)

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

81ImmBorrowFieldGeneric[0](Pool.unstaked_liquidity_fee_rate: u64)

82ReadRef

83StLoc[27](loc15: u64)

84CopyLoc[27](loc15: u64)

85Call config::default_unstaked_fee_rate(): u64

86Eq

87BrFalse(92)

B17:

88CopyLoc[1](Arg1: &GlobalConfig)

89Call config::unstaked_liquidity_fee_rate(&GlobalConfig): u64

90StLoc[14](loc2: u64)

91Branch(94)

B18:

92MoveLoc[27](loc15: u64)

93StLoc[14](loc2: u64)

B19:

94MoveLoc[14](loc2: u64)

95StLoc[22](loc10: u64)

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

97CopyLoc[5](Arg5: bool)

98MoveLoc[6](Arg6: bool)

99MoveLoc[8](Arg8: u128)

100MoveLoc[7](Arg7: u64)

101MoveLoc[22](loc10: u64)

102MoveLoc[1](Arg1: &GlobalConfig)

103Call config::protocol_fee_rate(&GlobalConfig): u64

104MoveLoc[4](Arg4: u64)

105MoveLoc[11](Arg11: &Clock)

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

107StLoc[21](loc9: u128)

108StLoc[26](loc14: SwapResult)

109ImmBorrowLoc[26](loc14: SwapResult)

110ImmBorrowField[23](SwapResult.amount_out: u64)

111ReadRef

112LdU64(0)

113Gt

114BrFalse(116)

B20:

115Branch(120)

B21:

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

117Pop

118LdConst[20](u64: 9349..)

119Abort

B22:

120CopyLoc[5](Arg5: bool)

121BrFalse(132)

B23:

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

123MutBorrowFieldGeneric[16](Pool.coin_b: Balance<Ty1>)

124ImmBorrowLoc[26](loc14: SwapResult)

125ImmBorrowField[23](SwapResult.amount_out: u64)

126ReadRef

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

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

129StLoc[16](loc4: Balance<Ty0>)

130StLoc[15](loc3: Balance<Ty1>)

131Branch(141)

B24:

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

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

134MutBorrowFieldGeneric[15](Pool.coin_a: Balance<Ty0>)

135ImmBorrowLoc[26](loc14: SwapResult)

136ImmBorrowField[23](SwapResult.amount_out: u64)

137ReadRef

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

139StLoc[16](loc4: Balance<Ty0>)

140StLoc[15](loc3: Balance<Ty1>)

B25:

141MoveLoc[15](loc3: Balance<Ty1>)

142MoveLoc[16](loc4: Balance<Ty0>)

143StLoc[18](loc6: Balance<Ty0>)

144StLoc[19](loc7: Balance<Ty1>)

145ImmBorrowLoc[3](Arg3: Option<ID>)

146Call option::is_none<ID>(&Option<ID>): bool

147BrFalse(152)

B26:

148LdConst[36](address: 0x00..)

149Call object::id_from_address(address): ID

150StLoc[17](loc5: ID)

151Branch(156)

B27:

152ImmBorrowLoc[3](Arg3: Option<ID>)

153Call option::borrow<ID>(&Option<ID>): &ID

154ReadRef

155StLoc[17](loc5: ID)

B28:

156MoveLoc[17](loc5: ID)

157StLoc[23](loc11: ID)

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

159FreezeRef

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

161StLoc[24](loc12: ID)

162CopyLoc[5](Arg5: bool)

163CopyLoc[24](loc12: ID)

164MoveLoc[23](loc11: ID)

165ImmBorrowLoc[26](loc14: SwapResult)

166ImmBorrowField[21](SwapResult.amount_in: u64)

167ReadRef

168ImmBorrowLoc[26](loc14: SwapResult)

169ImmBorrowField[25](SwapResult.fee_amount: u64)

170ReadRef

171Add

172ImmBorrowLoc[26](loc14: SwapResult)

173ImmBorrowField[23](SwapResult.amount_out: u64)

174ReadRef

175ImmBorrowLoc[26](loc14: SwapResult)

176ImmBorrowField[27](SwapResult.gauge_fee_amount: u64)

177ReadRef

178ImmBorrowLoc[26](loc14: SwapResult)

179ImmBorrowField[29](SwapResult.protocol_fee_amount: u64)

180ReadRef

181ImmBorrowLoc[26](loc14: SwapResult)

182ImmBorrowField[31](SwapResult.ref_fee_amount: u64)

183ReadRef

184ImmBorrowLoc[26](loc14: SwapResult)

185ImmBorrowField[25](SwapResult.fee_amount: u64)

186ReadRef

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

188ImmBorrowFieldGeneric[15](Pool.coin_a: Balance<Ty0>)

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

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

191ImmBorrowFieldGeneric[16](Pool.coin_b: Balance<Ty1>)

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

193MoveLoc[20](loc8: u128)

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

195ImmBorrowFieldGeneric[9](Pool.current_sqrt_price: u128)

196ReadRef

197ImmBorrowLoc[26](loc14: SwapResult)

198ImmBorrowField[44](SwapResult.steps: u64)

199ReadRef

200Pack[14](SwapEvent)

201Call event::emit<SwapEvent>(SwapEvent)

202MoveLoc[21](loc9: u128)

203LdU128(0)

204Gt

205BrFalse(216)

B29:

206CopyLoc[24](loc12: ID)

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

208ImmBorrowFieldGeneric[10](Pool.fee_growth_global_a: u128)

209ReadRef

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

211ImmBorrowFieldGeneric[11](Pool.fee_growth_global_b: u128)

212ReadRef

213Pack[29](UpdateFeeGrowthGlobalEvent)

214Call event::emit<UpdateFeeGrowthGlobalEvent>(UpdateFeeGrowthGlobalEvent)

215Branch(218)

B30:

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

217Pop

B31:

218MoveLoc[24](loc12: ID)

219MoveLoc[5](Arg5: bool)

220MoveLoc[3](Arg3: Option<ID>)

221ImmBorrowLoc[26](loc14: SwapResult)

222ImmBorrowField[21](SwapResult.amount_in: u64)

223ReadRef

224ImmBorrowLoc[26](loc14: SwapResult)

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

226ReadRef

227Add

228ImmBorrowLoc[26](loc14: SwapResult)

229ImmBorrowField[25](SwapResult.fee_amount: u64)

230ReadRef

231ImmBorrowLoc[26](loc14: SwapResult)

232ImmBorrowField[29](SwapResult.protocol_fee_amount: u64)

233ReadRef

234ImmBorrowLoc[26](loc14: SwapResult)

235ImmBorrowField[31](SwapResult.ref_fee_amount: u64)

236ReadRef

237ImmBorrowLoc[26](loc14: SwapResult)

238ImmBorrowField[27](SwapResult.gauge_fee_amount: u64)

239ReadRef

240PackGeneric[2](FlashSwapReceipt<Ty0, Ty1>)

241StLoc[25](loc13: FlashSwapReceipt<Ty0, Ty1>)

242MoveLoc[18](loc6: Balance<Ty0>)

243MoveLoc[19](loc7: Balance<Ty1>)

244MoveLoc[25](loc13: FlashSwapReceipt<Ty0, Ty1>)

245Ret

}

public flash_swap_with_partner<Ty0, Ty1>(Arg0: &GlobalConfig, Arg1: &mut RewarderGlobalVault, Arg2: &mut Pool<Ty0, Ty1>, Arg3: &Partner, Arg4: bool, Arg5: bool, Arg6: u64, Arg7: u128, Arg8: &mut Stats, Arg9: &PriceProvider, Arg10: &Clock): Balance<Ty0> * Balance<Ty1> * FlashSwapReceipt<Ty0, Ty1> {

B0:

0CopyLoc[0](Arg0: &GlobalConfig)

1Call config::checked_package_version(&GlobalConfig)

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

3ImmBorrowFieldGeneric[2](Pool.is_pause: bool)

4ReadRef

5Not

6BrFalse(8)

B1:

7Branch(24)

B2:

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

9Pop

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

11Pop

12MoveLoc[9](Arg9: &PriceProvider)

13Pop

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

15Pop

16MoveLoc[3](Arg3: &Partner)

17Pop

18MoveLoc[0](Arg0: &GlobalConfig)

19Pop

20MoveLoc[10](Arg10: &Clock)

21Pop

22LdConst[15](u64: 9283..)

23Abort

B3:

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

25MoveLoc[0](Arg0: &GlobalConfig)

26MoveLoc[1](Arg1: &mut RewarderGlobalVault)

27CopyLoc[3](Arg3: &Partner)

28Call object::id<Partner>(&Partner): ID

29Call option::some<ID>(ID): Option<ID>

30MoveLoc[3](Arg3: &Partner)

31CopyLoc[10](Arg10: &Clock)

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

33LdU64(1000)

34Div

35Call partner::current_ref_fee_rate(&Partner, u64): u64

36MoveLoc[4](Arg4: bool)

37MoveLoc[5](Arg5: bool)

38MoveLoc[6](Arg6: u64)

39MoveLoc[7](Arg7: u128)

40MoveLoc[8](Arg8: &mut Stats)

41MoveLoc[9](Arg9: &PriceProvider)

42MoveLoc[10](Arg10: &Clock)

43Call flash_swap_internal<Ty0, Ty1>(&mut Pool<Ty0, Ty1>, &GlobalConfig, &mut RewarderGlobalVault, Option<ID>, u64, bool, bool, u64, u128, &mut Stats, &PriceProvider, &Clock): Balance<Ty0> * Balance<Ty1> * FlashSwapReceipt<Ty0, Ty1>

44Ret

}

public get_all_growths_in_tick_range<Ty0, Ty1>(Arg0: &Pool<Ty0, Ty1>, Arg1: I32, Arg2: I32): u128 * u128 * vector<u128> * u128 * u128 {

L3: loc0: Option<Tick>

L4: loc1: Option<Tick>

B0:

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

1ImmBorrowFieldGeneric[7](Pool.tick_manager: TickManager)

2MoveLoc[1](Arg1: I32)

3Call tick::try_borrow_tick(&TickManager, I32): Option<Tick>

4StLoc[3](loc0: Option<Tick>)

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

6ImmBorrowFieldGeneric[7](Pool.tick_manager: TickManager)

7MoveLoc[2](Arg2: I32)

8Call tick::try_borrow_tick(&TickManager, I32): Option<Tick>

9StLoc[4](loc1: Option<Tick>)

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

11ImmBorrowFieldGeneric[8](Pool.current_tick_index: I32)

12ReadRef

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

14ImmBorrowFieldGeneric[10](Pool.fee_growth_global_a: u128)

15ReadRef

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

17ImmBorrowFieldGeneric[11](Pool.fee_growth_global_b: u128)

18ReadRef

19CopyLoc[3](loc0: Option<Tick>)

20CopyLoc[4](loc1: Option<Tick>)

21Call tick::get_fee_in_range(I32, u128, u128, Option<Tick>, Option<Tick>): u128 * u128

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

23ImmBorrowFieldGeneric[8](Pool.current_tick_index: I32)

24ReadRef

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

26ImmBorrowFieldGeneric[6](Pool.rewarder_manager: RewarderManager)

27Call rewarder::rewards_growth_global(&RewarderManager): vector<u128>

28CopyLoc[3](loc0: Option<Tick>)

29CopyLoc[4](loc1: Option<Tick>)

30Call tick::get_rewards_in_range(I32, vector<u128>, Option<Tick>, Option<Tick>): vector<u128>

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

32ImmBorrowFieldGeneric[8](Pool.current_tick_index: I32)

33ReadRef

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

35ImmBorrowFieldGeneric[6](Pool.rewarder_manager: RewarderManager)

36Call rewarder::points_growth_global(&RewarderManager): u128

37CopyLoc[3](loc0: Option<Tick>)

38CopyLoc[4](loc1: Option<Tick>)

39Call tick::get_points_in_range(I32, u128, Option<Tick>, Option<Tick>): u128

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

41ImmBorrowFieldGeneric[8](Pool.current_tick_index: I32)

42ReadRef

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

44ImmBorrowFieldGeneric[12](Pool.fullsail_distribution_growth_global: u128)

45ReadRef

46MoveLoc[3](loc0: Option<Tick>)

47MoveLoc[4](loc1: Option<Tick>)

48Call tick::get_fullsail_distribution_growth_in_range(I32, u128, Option<Tick>, Option<Tick>): u128

49Ret

}

public get_fee_in_tick_range<Ty0, Ty1>(Arg0: &Pool<Ty0, Ty1>, Arg1: I32, Arg2: I32): u128 * u128 {

B0:

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

1ImmBorrowFieldGeneric[8](Pool.current_tick_index: I32)

2ReadRef

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

4ImmBorrowFieldGeneric[10](Pool.fee_growth_global_a: u128)

5ReadRef

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

7ImmBorrowFieldGeneric[11](Pool.fee_growth_global_b: u128)

8ReadRef

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

10ImmBorrowFieldGeneric[7](Pool.tick_manager: TickManager)

11MoveLoc[1](Arg1: I32)

12Call tick::try_borrow_tick(&TickManager, I32): Option<Tick>

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

14ImmBorrowFieldGeneric[7](Pool.tick_manager: TickManager)

15MoveLoc[2](Arg2: I32)

16Call tick::try_borrow_tick(&TickManager, I32): Option<Tick>

17Call tick::get_fee_in_range(I32, u128, u128, Option<Tick>, Option<Tick>): u128 * u128

18Ret

}

public get_fullsail_distribution_gauger_id<Ty0, Ty1>(Arg0: &Pool<Ty0, Ty1>): ID {

B0:

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

1ImmBorrowFieldGeneric[19](Pool.fullsail_distribution_gauger_id: Option<ID>)

2Call option::is_some<ID>(&Option<ID>): bool

3BrFalse(5)

B1:

4Branch(9)

B2:

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

6Pop

7LdConst[27](u64: 9223..)

8Abort

B3:

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

10ImmBorrowFieldGeneric[19](Pool.fullsail_distribution_gauger_id: Option<ID>)

11Call option::borrow<ID>(&Option<ID>): &ID

12ReadRef

13Ret

}

public get_fullsail_distribution_growth_global<Ty0, Ty1>(Arg0: &Pool<Ty0, Ty1>): u128 {

B0:

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

1ImmBorrowFieldGeneric[12](Pool.fullsail_distribution_growth_global: u128)

2ReadRef

3Ret

}

public get_pool_volumes<Ty0, Ty1>(Arg0: &Pool<Ty0, Ty1>): u128 * u128 {

B0:

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

1ImmBorrowFieldGeneric[27](Pool.volume: PoolVolume)

2ImmBorrowField[46](PoolVolume.volume_usd_coin_a: u128)

3ReadRef

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

5ImmBorrowFieldGeneric[27](Pool.volume: PoolVolume)

6ImmBorrowField[47](PoolVolume.volume_usd_coin_b: u128)

7ReadRef

8Ret

}

public get_fullsail_distribution_growth_inside<Ty0, Ty1>(Arg0: &Pool<Ty0, Ty1>, Arg1: I32, Arg2: I32, Arg3: u128): u128 {

B0:

0CopyLoc[1](Arg1: I32)

1CopyLoc[2](Arg2: I32)

2Call check_tick_range(I32, I32): bool

3BrFalse(5)

B1:

4Branch(9)

B2:

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

6Pop

7LdConst[25](u64: 9223..)

8Abort

B3:

9CopyLoc[3](Arg3: u128)

10LdU128(0)

11Eq

12BrFalse(17)

B4:

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

14ImmBorrowFieldGeneric[12](Pool.fullsail_distribution_growth_global: u128)

15ReadRef

16StLoc[3](Arg3: u128)

B5:

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

18ImmBorrowFieldGeneric[8](Pool.current_tick_index: I32)

19ReadRef

20MoveLoc[3](Arg3: u128)

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

22MoveLoc[1](Arg1: I32)

23Call borrow_tick<Ty0, Ty1>(&Pool<Ty0, Ty1>, I32): &Tick

24ReadRef

25Call option::some<Tick>(Tick): Option<Tick>

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

27MoveLoc[2](Arg2: I32)

28Call borrow_tick<Ty0, Ty1>(&Pool<Ty0, Ty1>, I32): &Tick

29ReadRef

30Call option::some<Tick>(Tick): Option<Tick>

31Call tick::get_fullsail_distribution_growth_in_range(I32, u128, Option<Tick>, Option<Tick>): u128

32Ret

}

public get_fullsail_distribution_last_updated<Ty0, Ty1>(Arg0: &Pool<Ty0, Ty1>): u64 {

B0:

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

1ImmBorrowFieldGeneric[28](Pool.fullsail_distribution_last_updated: u64)

2ReadRef

3Ret

}

public get_fullsail_distribution_reserve<Ty0, Ty1>(Arg0: &Pool<Ty0, Ty1>): u64 {

B0:

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

1ImmBorrowFieldGeneric[29](Pool.fullsail_distribution_reserve: u64)

2ReadRef

3Ret

}

public get_fullsail_distribution_period_finish<Ty0, Ty1>(Arg0: &Pool<Ty0, Ty1>): u64 {

B0:

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

1ImmBorrowFieldGeneric[30](Pool.fullsail_distribution_period_finish: u64)

2ReadRef

3Ret

}

public get_fullsail_distribution_rollover<Ty0, Ty1>(Arg0: &Pool<Ty0, Ty1>): u64 {

B0:

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

1ImmBorrowFieldGeneric[31](Pool.fullsail_distribution_rollover: u64)

2ReadRef

3Ret

}

public get_fullsail_distribution_staked_liquidity<Ty0, Ty1>(Arg0: &Pool<Ty0, Ty1>): u128 {

B0:

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

1ImmBorrowFieldGeneric[17](Pool.fullsail_distribution_staked_liquidity: u128)

2ReadRef

3Ret

}

public get_points_in_tick_range<Ty0, Ty1>(Arg0: &Pool<Ty0, Ty1>, Arg1: I32, Arg2: I32): u128 {

B0:

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

1ImmBorrowFieldGeneric[8](Pool.current_tick_index: I32)

2ReadRef

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

4ImmBorrowFieldGeneric[6](Pool.rewarder_manager: RewarderManager)

5Call rewarder::points_growth_global(&RewarderManager): u128

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

7ImmBorrowFieldGeneric[7](Pool.tick_manager: TickManager)

8MoveLoc[1](Arg1: I32)

9Call tick::try_borrow_tick(&TickManager, I32): Option<Tick>

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

11ImmBorrowFieldGeneric[7](Pool.tick_manager: TickManager)

12MoveLoc[2](Arg2: I32)

13Call tick::try_borrow_tick(&TickManager, I32): Option<Tick>

14Call tick::get_points_in_range(I32, u128, Option<Tick>, Option<Tick>): u128

15Ret

}

public get_position_amounts<Ty0, Ty1>(Arg0: &Pool<Ty0, Ty1>, Arg1: ID): u64 * u64 {

L2: loc0: &PositionInfo

B0:

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

1ImmBorrowFieldGeneric[1](Pool.position_manager: PositionManager)

2CopyLoc[1](Arg1: ID)

3Call position::validate_position_exists(&PositionManager, ID)

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

5ImmBorrowFieldGeneric[1](Pool.position_manager: PositionManager)

6MoveLoc[1](Arg1: ID)

7Call position::borrow_position_info(&PositionManager, ID): &PositionInfo

8StLoc[2](loc0: &PositionInfo)

9CopyLoc[2](loc0: &PositionInfo)

10Call position::info_tick_range(&PositionInfo): I32 * I32

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

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

13ReadRef

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

15ImmBorrowFieldGeneric[9](Pool.current_sqrt_price: u128)

16ReadRef

17MoveLoc[2](loc0: &PositionInfo)

18Call position::info_liquidity(&PositionInfo): u128

19LdFalse

20Call clmm_math::get_amount_by_liquidity(I32, I32, I32, u128, u128, bool): u64 * u64

21Ret

}

public get_position_fee<Ty0, Ty1>(Arg0: &Pool<Ty0, Ty1>, Arg1: ID): u64 * u64 {

B0:

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

1ImmBorrowFieldGeneric[1](Pool.position_manager: PositionManager)

2CopyLoc[1](Arg1: ID)

3Call position::validate_position_exists(&PositionManager, ID)

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

5ImmBorrowFieldGeneric[1](Pool.position_manager: PositionManager)

6MoveLoc[1](Arg1: ID)

7Call position::borrow_position_info(&PositionManager, ID): &PositionInfo

8Call position::info_fee_owned(&PositionInfo): u64 * u64

9Ret

}

public get_position_points<Ty0, Ty1>(Arg0: &Pool<Ty0, Ty1>, Arg1: ID): u128 {

B0:

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

1ImmBorrowFieldGeneric[1](Pool.position_manager: PositionManager)

2CopyLoc[1](Arg1: ID)

3Call position::validate_position_exists(&PositionManager, ID)

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

5ImmBorrowFieldGeneric[1](Pool.position_manager: PositionManager)

6MoveLoc[1](Arg1: ID)

7Call position::borrow_position_info(&PositionManager, ID): &PositionInfo

8Call position::info_points_owned(&PositionInfo): u128

9Ret

}

public get_position_reward<Ty0, Ty1, Ty2>(Arg0: &Pool<Ty0, Ty1>, Arg1: ID): u64 {

L2: loc0: Option<u64>

L3: loc1: vector<u64>

B0:

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

1ImmBorrowFieldGeneric[1](Pool.position_manager: PositionManager)

2CopyLoc[1](Arg1: ID)

3Call position::validate_position_exists(&PositionManager, ID)

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

5ImmBorrowFieldGeneric[6](Pool.rewarder_manager: RewarderManager)

6Call rewarder::rewarder_index<Ty2>(&RewarderManager): Option<u64>

7StLoc[2](loc0: Option<u64>)

8ImmBorrowLoc[2](loc0: Option<u64>)

9Call option::is_some<u64>(&Option<u64>): bool

10BrFalse(12)

B1:

11Branch(16)

B2:

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

13Pop

14LdConst[19](u64: 9839..)

15Abort

B3:

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

17ImmBorrowFieldGeneric[1](Pool.position_manager: PositionManager)

18MoveLoc[1](Arg1: ID)

19Call position::rewards_amount_owned(&PositionManager, ID): vector<u64>

20StLoc[3](loc1: vector<u64>)

21ImmBorrowLoc[3](loc1: vector<u64>)

22MutBorrowLoc[2](loc0: Option<u64>)

23Call option::extract<u64>(&mut Option<u64>): u64

24VecImmBorrow(3)

25ReadRef

26Ret

}

public get_position_rewards<Ty0, Ty1>(Arg0: &Pool<Ty0, Ty1>, Arg1: ID): vector<u64> {

B0:

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

1ImmBorrowFieldGeneric[1](Pool.position_manager: PositionManager)

2CopyLoc[1](Arg1: ID)

3Call position::validate_position_exists(&PositionManager, ID)

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

5ImmBorrowFieldGeneric[1](Pool.position_manager: PositionManager)

6MoveLoc[1](Arg1: ID)

7Call position::rewards_amount_owned(&PositionManager, ID): vector<u64>

8Ret

}

public get_rewards_in_tick_range<Ty0, Ty1>(Arg0: &Pool<Ty0, Ty1>, Arg1: I32, Arg2: I32): vector<u128> {

B0:

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

1ImmBorrowFieldGeneric[8](Pool.current_tick_index: I32)

2ReadRef

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

4ImmBorrowFieldGeneric[6](Pool.rewarder_manager: RewarderManager)

5Call rewarder::rewards_growth_global(&RewarderManager): vector<u128>

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

7ImmBorrowFieldGeneric[7](Pool.tick_manager: TickManager)

8MoveLoc[1](Arg1: I32)

9Call tick::try_borrow_tick(&TickManager, I32): Option<Tick>

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

11ImmBorrowFieldGeneric[7](Pool.tick_manager: TickManager)

12MoveLoc[2](Arg2: I32)

13Call tick::try_borrow_tick(&TickManager, I32): Option<Tick>

14Call tick::get_rewards_in_range(I32, vector<u128>, Option<Tick>, Option<Tick>): vector<u128>

15Ret

}

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

B0:

0MoveLoc[0](Arg0: POOL)

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

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

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

4FreezeRef

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

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

7Ret

}

public init_fullsail_distribution_gauge<Ty0, Ty1>(Arg0: &mut Pool<Ty0, Ty1>, Arg1: &GaugeCap) {

B0:

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

1ImmBorrowFieldGeneric[2](Pool.is_pause: bool)

2ReadRef

3Not

4BrFalse(6)

B1:

5Branch(12)

B2:

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

7Pop

8MoveLoc[1](Arg1: &GaugeCap)

9Pop

10LdConst[15](u64: 9283..)

11Abort

B3:

12CopyLoc[1](Arg1: &GaugeCap)

13Call gauge_cap::get_pool_id(&GaugeCap): ID

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

15FreezeRef

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

17Eq

18BrFalse(20)

B4:

19Branch(26)

B5:

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

21Pop

22MoveLoc[1](Arg1: &GaugeCap)

23Pop

24LdConst[16](u64: 9238..)

25Abort

B6:

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

27MutBorrowFieldGeneric[19](Pool.fullsail_distribution_gauger_id: Option<ID>)

28CopyLoc[1](Arg1: &GaugeCap)

29Call gauge_cap::get_gauge_id(&GaugeCap): ID

30Call option::fill<ID>(&mut Option<ID>, ID)

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

32FreezeRef

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

34MoveLoc[1](Arg1: &GaugeCap)

35Call gauge_cap::get_gauge_id(&GaugeCap): ID

36Pack[25](InitFullsailDistributionGaugeEvent)

37Call event::emit<InitFullsailDistributionGaugeEvent>(InitFullsailDistributionGaugeEvent)

38Ret

}

public initialize_rewarder<Ty0, Ty1, Ty2>(Arg0: &GlobalConfig, Arg1: &mut Pool<Ty0, Ty1>, Arg2: &mut TxContext) {

B0:

0CopyLoc[0](Arg0: &GlobalConfig)

1Call config::checked_package_version(&GlobalConfig)

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

3ImmBorrowFieldGeneric[2](Pool.is_pause: bool)

4ReadRef

5Not

6BrFalse(8)

B1:

7Branch(16)

B2:

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

9Pop

10MoveLoc[0](Arg0: &GlobalConfig)

11Pop

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

13Pop

14LdConst[15](u64: 9283..)

15Abort

B3:

16MoveLoc[0](Arg0: &GlobalConfig)

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

18FreezeRef

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

20Call config::check_rewarder_manager_role(&GlobalConfig, address)

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

22MutBorrowFieldGeneric[6](Pool.rewarder_manager: RewarderManager)

23Call rewarder::add_rewarder<Ty2>(&mut RewarderManager)

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

25FreezeRef

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

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

28Pack[19](AddRewarderEvent)

29Call event::emit<AddRewarderEvent>(AddRewarderEvent)

30Ret

}

public is_pause<Ty0, Ty1>(Arg0: &Pool<Ty0, Ty1>): bool {

B0:

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

1ImmBorrowFieldGeneric[2](Pool.is_pause: bool)

2ReadRef

3Ret

}

public fullsail_distribution_gauger_fee<Ty0, Ty1>(Arg0: &Pool<Ty0, Ty1>): PoolFee {

B0:

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

1ImmBorrowFieldGeneric[20](Pool.fullsail_distribution_gauger_fee: PoolFee)

2ImmBorrowField[36](PoolFee.coin_a: u64)

3ReadRef

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

5ImmBorrowFieldGeneric[20](Pool.fullsail_distribution_gauger_fee: PoolFee)

6ImmBorrowField[37](PoolFee.coin_b: u64)

7ReadRef

8Pack[2](PoolFee)

9Ret

}

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

B0:

0CopyLoc[0](Arg0: &GlobalConfig)

1Call config::checked_package_version(&GlobalConfig)

2MoveLoc[0](Arg0: &GlobalConfig)

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

4FreezeRef

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

6Call config::check_pool_manager_role(&GlobalConfig, address)

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

8ImmBorrowFieldGeneric[2](Pool.is_pause: bool)

9ReadRef

10Not

11BrFalse(13)

B1:

12Branch(17)

B2:

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

14Pop

15LdConst[30](u64: 9223..)

16Abort

B3:

17LdTrue

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

19MutBorrowFieldGeneric[2](Pool.is_pause: bool)

20WriteRef

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

22FreezeRef

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

24Pack[27](PausePoolEvent)

25Call event::emit<PausePoolEvent>(PausePoolEvent)

26Ret

}

public pool_fee_a_b(Arg0: &PoolFee): u64 * u64 {

B0:

0CopyLoc[0](Arg0: &PoolFee)

1ImmBorrowField[36](PoolFee.coin_a: u64)

2ReadRef

3MoveLoc[0](Arg0: &PoolFee)

4ImmBorrowField[37](PoolFee.coin_b: u64)

5ReadRef

6Ret

}

public position_manager<Ty0, Ty1>(Arg0: &Pool<Ty0, Ty1>): &PositionManager {

B0:

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

1ImmBorrowFieldGeneric[1](Pool.position_manager: PositionManager)

2Ret

}

public protocol_fee<Ty0, Ty1>(Arg0: &Pool<Ty0, Ty1>): u64 * u64 {

B0:

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

1ImmBorrowFieldGeneric[21](Pool.fee_protocol_coin_a: u64)

2ReadRef

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

4ImmBorrowFieldGeneric[22](Pool.fee_protocol_coin_b: u64)

5ReadRef

6Ret

}

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

L6: loc0: bool

L7: loc1: u64

L8: loc2: u64

L9: loc3: u128

L10: loc4: u128

L11: loc5: u128

L12: loc6: u128

L13: loc7: ID

L14: loc8: vector<u128>

L15: loc9: I32

L16: loc10: I32

B0:

0MoveLoc[0](Arg0: &GlobalConfig)

1Call config::checked_package_version(&GlobalConfig)

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

3ImmBorrowFieldGeneric[2](Pool.is_pause: bool)

4ReadRef

5Not

6BrFalse(8)

B1:

7Branch(18)

B2:

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

9Pop

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

11Pop

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

13Pop

14MoveLoc[5](Arg5: &Clock)

15Pop

16LdConst[15](u64: 9283..)

17Abort

B3:

18CopyLoc[4](Arg4: u128)

19LdU128(0)

20Gt

21BrFalse(23)

B4:

22Branch(33)

B5:

23MoveLoc[1](Arg1: &mut RewarderGlobalVault)

24Pop

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

26Pop

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

28Pop

29MoveLoc[5](Arg5: &Clock)

30Pop

31LdConst[6](u64: 9328..)

32Abort

B6:

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

34FreezeRef

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

36FreezeRef

37Call validate_pool_position<Ty0, Ty1>(&Pool<Ty0, Ty1>, &Position)

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

39FreezeRef

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

41StLoc[13](loc7: ID)

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

43ImmBorrowFieldGeneric[1](Pool.position_manager: PositionManager)

44CopyLoc[13](loc7: ID)

45Call position::is_position_staked(&PositionManager, ID): bool

46Not

47BrFalse(49)

B7:

48Branch(59)

B8:

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

50Pop

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

52Pop

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

54Pop

55MoveLoc[5](Arg5: &Clock)

56Pop

57LdConst[8](u64: 8945..)

58Abort

B9:

59MoveLoc[1](Arg1: &mut RewarderGlobalVault)

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

61MutBorrowFieldGeneric[6](Pool.rewarder_manager: RewarderManager)

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

63ImmBorrowFieldGeneric[3](Pool.liquidity: u128)

64ReadRef

65MoveLoc[5](Arg5: &Clock)

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

67LdU64(1000)

68Div

69Call rewarder::settle(&mut RewarderGlobalVault, &mut RewarderManager, u128, u64)

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

71FreezeRef

72Call position::tick_range(&Position): I32 * I32

73StLoc[16](loc10: I32)

74StLoc[15](loc9: I32)

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

76FreezeRef

77CopyLoc[15](loc9: I32)

78CopyLoc[16](loc10: I32)

79Call get_all_growths_in_tick_range<Ty0, Ty1>(&Pool<Ty0, Ty1>, I32, I32): u128 * u128 * vector<u128> * u128 * u128

80StLoc[11](loc5: u128)

81StLoc[12](loc6: u128)

82StLoc[14](loc8: vector<u128>)

83StLoc[10](loc4: u128)

84StLoc[9](loc3: u128)

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

86MutBorrowFieldGeneric[7](Pool.tick_manager: TickManager)

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

88ImmBorrowFieldGeneric[8](Pool.current_tick_index: I32)

89ReadRef

90CopyLoc[15](loc9: I32)

91CopyLoc[16](loc10: I32)

92CopyLoc[4](Arg4: u128)

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

94ImmBorrowFieldGeneric[10](Pool.fee_growth_global_a: u128)

95ReadRef

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

97ImmBorrowFieldGeneric[11](Pool.fee_growth_global_b: u128)

98ReadRef

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

100ImmBorrowFieldGeneric[6](Pool.rewarder_manager: RewarderManager)

101Call rewarder::points_growth_global(&RewarderManager): u128

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

103ImmBorrowFieldGeneric[6](Pool.rewarder_manager: RewarderManager)

104Call rewarder::rewards_growth_global(&RewarderManager): vector<u128>

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

106ImmBorrowFieldGeneric[12](Pool.fullsail_distribution_growth_global: u128)

107ReadRef

108Call tick::decrease_liquidity(&mut TickManager, I32, I32, I32, u128, u128, u128, u128, vector<u128>, u128)

109CopyLoc[15](loc9: I32)

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

111ImmBorrowFieldGeneric[8](Pool.current_tick_index: I32)

112ReadRef

113Call i32::lte(I32, I32): bool

114BrFalse(122)

B10:

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

116ImmBorrowFieldGeneric[8](Pool.current_tick_index: I32)

117ReadRef

118CopyLoc[16](loc10: I32)

119Call i32::lt(I32, I32): bool

120StLoc[6](loc0: bool)

121Branch(124)

B11:

122LdFalse

123StLoc[6](loc0: bool)

B12:

124MoveLoc[6](loc0: bool)

125BrFalse(134)

B13:

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

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

128ReadRef

129CopyLoc[4](Arg4: u128)

130Sub

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

132MutBorrowFieldGeneric[3](Pool.liquidity: u128)

133WriteRef

B14:

134CopyLoc[15](loc9: I32)

135CopyLoc[16](loc10: I32)

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

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

138ReadRef

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

140ImmBorrowFieldGeneric[9](Pool.current_sqrt_price: u128)

141ReadRef

142CopyLoc[4](Arg4: u128)

143LdFalse

144Call clmm_math::get_amount_by_liquidity(I32, I32, I32, u128, u128, bool): u64 * u64

145StLoc[8](loc2: u64)

146StLoc[7](loc1: u64)

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

148FreezeRef

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

150MoveLoc[13](loc7: ID)

151MoveLoc[15](loc9: I32)

152MoveLoc[16](loc10: I32)

153CopyLoc[4](Arg4: u128)

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

155MutBorrowFieldGeneric[1](Pool.position_manager: PositionManager)

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

157MoveLoc[4](Arg4: u128)

158MoveLoc[9](loc3: u128)

159MoveLoc[10](loc4: u128)

160MoveLoc[12](loc6: u128)

161MoveLoc[14](loc8: vector<u128>)

162MoveLoc[11](loc5: u128)

163Call position::decrease_liquidity(&mut PositionManager, &mut Position, u128, u128, u128, u128, vector<u128>, u128): u128

164CopyLoc[7](loc1: u64)

165CopyLoc[8](loc2: u64)

166Pack[13](RemoveLiquidityEvent)

167Call event::emit<RemoveLiquidityEvent>(RemoveLiquidityEvent)

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

169MutBorrowFieldGeneric[15](Pool.coin_a: Balance<Ty0>)

170MoveLoc[7](loc1: u64)

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

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

173MutBorrowFieldGeneric[16](Pool.coin_b: Balance<Ty1>)

174MoveLoc[8](loc2: u64)

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

176Ret

}

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

L5: loc0: u64

L6: loc1: u64

L7: loc2: ID

B0:

0MoveLoc[0](Arg0: &GlobalConfig)

1Call config::checked_package_version(&GlobalConfig)

2MoveLoc[4](Arg4: AddLiquidityReceipt<Ty0, Ty1>)

3UnpackGeneric[1](AddLiquidityReceipt<Ty0, Ty1>)

4StLoc[6](loc1: u64)

5StLoc[5](loc0: u64)

6StLoc[7](loc2: ID)

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

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

9MoveLoc[5](loc0: u64)

10Eq

11BrFalse(13)

B1:

12Branch(17)

B2:

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

14Pop

15LdConst[3](u64: 9236..)

16Abort

B3:

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

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

19MoveLoc[6](loc1: u64)

20Eq

21BrFalse(23)

B4:

22Branch(27)

B5:

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

24Pop

25LdConst[3](u64: 9236..)

26Abort

B6:

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

28FreezeRef

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

30MoveLoc[7](loc2: ID)

31Eq

32BrFalse(34)

B7:

33Branch(38)

B8:

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

35Pop

36LdConst[14](u64: 9834..)

37Abort

B9:

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

39MutBorrowFieldGeneric[15](Pool.coin_a: Balance<Ty0>)

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

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

42Pop

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

44MutBorrowFieldGeneric[16](Pool.coin_b: Balance<Ty1>)

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

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

47Pop

48Ret

}

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: Option<ID>

L7: loc2: u64

L8: loc3: ID

L9: loc4: u64

B0:

0MoveLoc[0](Arg0: &GlobalConfig)

1Call config::checked_package_version(&GlobalConfig)

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

3ImmBorrowFieldGeneric[2](Pool.is_pause: bool)

4ReadRef

5Not

6BrFalse(8)

B1:

7Branch(12)

B2:

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

9Pop

10LdConst[15](u64: 9283..)

11Abort

B3:

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

13UnpackGeneric[2](FlashSwapReceipt<Ty0, Ty1>)

14Pop

15StLoc[9](loc4: u64)

16Pop

17Pop

18StLoc[7](loc2: u64)

19StLoc[6](loc1: Option<ID>)

20StLoc[5](loc0: bool)

21StLoc[8](loc3: ID)

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

23FreezeRef

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

25MoveLoc[8](loc3: ID)

26Eq

27BrFalse(29)

B4:

28Branch(33)

B5:

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

30Pop

31LdConst[16](u64: 9238..)

32Abort

B6:

33ImmBorrowLoc[6](loc1: Option<ID>)

34Call option::is_none<ID>(&Option<ID>): bool

35BrFalse(37)

B7:

36Branch(41)

B8:

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

38Pop

39LdConst[23](u64: 9203..)

40Abort

B9:

41MoveLoc[9](loc4: u64)

42LdU64(0)

43Eq

44BrFalse(46)

B10:

45Branch(50)

B11:

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

47Pop

48LdConst[22](u64: 9207..)

49Abort

B12:

50MoveLoc[5](loc0: bool)

51BrFalse(70)

B13:

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

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

54MoveLoc[7](loc2: u64)

55Eq

56BrFalse(58)

B14:

57Branch(62)

B15:

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

59Pop

60LdConst[3](u64: 9236..)

61Abort

B16:

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

63MutBorrowFieldGeneric[15](Pool.coin_a: Balance<Ty0>)

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

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

66Pop

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

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

69Branch(87)

B17:

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

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

72MoveLoc[7](loc2: u64)

73Eq

74BrFalse(76)

B18:

75Branch(80)

B19:

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

77Pop

78LdConst[3](u64: 9236..)

79Abort

B20:

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

81MutBorrowFieldGeneric[16](Pool.coin_b: Balance<Ty1>)

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

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

84Pop

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

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

B21:

87Ret

}

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

L6: loc0: bool

L7: loc1: ID

L8: loc2: bool

L9: loc3: Option<ID>

L10: loc4: u64

L11: loc5: ID

L12: loc6: u64

B0:

0MoveLoc[0](Arg0: &GlobalConfig)

1Call config::checked_package_version(&GlobalConfig)

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

3ImmBorrowFieldGeneric[2](Pool.is_pause: bool)

4ReadRef

5Not

6BrFalse(8)

B1:

7Branch(14)

B2:

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

9Pop

10MoveLoc[2](Arg2: &mut Partner)

11Pop

12LdConst[15](u64: 9283..)

13Abort

B3:

14MoveLoc[5](Arg5: FlashSwapReceipt<Ty0, Ty1>)

15UnpackGeneric[2](FlashSwapReceipt<Ty0, Ty1>)

16Pop

17StLoc[12](loc6: u64)

18Pop

19Pop

20StLoc[10](loc4: u64)

21StLoc[9](loc3: Option<ID>)

22StLoc[8](loc2: bool)

23StLoc[11](loc5: ID)

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

25FreezeRef

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

27MoveLoc[11](loc5: ID)

28Eq

29BrFalse(31)

B4:

30Branch(37)

B5:

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

32Pop

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

34Pop

35LdConst[16](u64: 9238..)

36Abort

B6:

37ImmBorrowLoc[9](loc3: Option<ID>)

38Call option::is_none<ID>(&Option<ID>): bool

39Not

40BrFalse(51)

B7:

41CopyLoc[2](Arg2: &mut Partner)

42FreezeRef

43Call object::id<Partner>(&Partner): ID

44StLoc[7](loc1: ID)

45ImmBorrowLoc[7](loc1: ID)

46ImmBorrowLoc[9](loc3: Option<ID>)

47Call option::borrow<ID>(&Option<ID>): &ID

48Eq

49StLoc[6](loc0: bool)

50Branch(53)

B8:

51LdFalse

52StLoc[6](loc0: bool)

B9:

53MoveLoc[6](loc0: bool)

54BrFalse(56)

B10:

55Branch(62)

B11:

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

57Pop

58MoveLoc[2](Arg2: &mut Partner)

59Pop

60LdConst[17](u64: 9283..)

61Abort

B12:

62MoveLoc[8](loc2: bool)

63BrFalse(96)

B13:

64ImmBorrowLoc[3](Arg3: Balance<Ty0>)

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

66MoveLoc[10](loc4: u64)

67Eq

68BrFalse(70)

B14:

69Branch(76)

B15:

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

71Pop

72MoveLoc[2](Arg2: &mut Partner)

73Pop

74LdConst[3](u64: 9236..)

75Abort

B16:

76CopyLoc[12](loc6: u64)

77LdU64(0)

78Gt

79BrFalse(86)

B17:

80MoveLoc[2](Arg2: &mut Partner)

81MutBorrowLoc[3](Arg3: Balance<Ty0>)

82MoveLoc[12](loc6: u64)

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

84Call partner::receive_ref_fee<Ty0>(&mut Partner, Balance<Ty0>)

85Branch(88)

B18:

86MoveLoc[2](Arg2: &mut Partner)

87Pop

B19:

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

89MutBorrowFieldGeneric[15](Pool.coin_a: Balance<Ty0>)

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

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

92Pop

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

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

95Branch(127)

B20:

96ImmBorrowLoc[4](Arg4: Balance<Ty1>)

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

98MoveLoc[10](loc4: u64)

99Eq

100BrFalse(102)

B21:

101Branch(108)

B22:

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

103Pop

104MoveLoc[2](Arg2: &mut Partner)

105Pop

106LdConst[3](u64: 9236..)

107Abort

B23:

108CopyLoc[12](loc6: u64)

109LdU64(0)

110Gt

111BrFalse(118)

B24:

112MoveLoc[2](Arg2: &mut Partner)

113MutBorrowLoc[4](Arg4: Balance<Ty1>)

114MoveLoc[12](loc6: u64)

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

116Call partner::receive_ref_fee<Ty1>(&mut Partner, Balance<Ty1>)

117Branch(120)

B25:

118MoveLoc[2](Arg2: &mut Partner)

119Pop

B26:

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

121MutBorrowFieldGeneric[16](Pool.coin_b: Balance<Ty1>)

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

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

124Pop

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

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

B27:

127Ret

}

public rewarder_manager<Ty0, Ty1>(Arg0: &Pool<Ty0, Ty1>): &RewarderManager {

B0:

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

1ImmBorrowFieldGeneric[6](Pool.rewarder_manager: RewarderManager)

2Ret

}

public set_display<Ty0, Ty1>(Arg0: &GlobalConfig, Arg1: &Publisher, Arg2: String, Arg3: String, Arg4: String, Arg5: String, Arg6: String, Arg7: String, Arg8: &mut TxContext) {

L9: loc0: Display<Pool<Ty0, Ty1>>

L10: loc1: vector<String>

L11: loc2: vector<String>

B0:

0CopyLoc[1](Arg1: &Publisher)

1Call package::from_module<Pool<Ty0, Ty1>>(&Publisher): bool

2BrFalse(4)

B1:

3Branch(12)

B2:

4MoveLoc[1](Arg1: &Publisher)

5Pop

6MoveLoc[0](Arg0: &GlobalConfig)

7Pop

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

9Pop

10LdConst[5](u64: 9843..)

11Abort

B3:

12MoveLoc[0](Arg0: &GlobalConfig)

13Call config::checked_package_version(&GlobalConfig)

14VecPack(82, 0)

15StLoc[10](loc1: vector<String>)

16MutBorrowLoc[10](loc1: vector<String>)

17LdConst[37](vector<u8>: "nam..)

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

19VecPushBack(82)

20MutBorrowLoc[10](loc1: vector<String>)

21LdConst[38](vector<u8>: "coi..)

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

23VecPushBack(82)

24MutBorrowLoc[10](loc1: vector<String>)

25LdConst[39](vector<u8>: "coi..)

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

27VecPushBack(82)

28MutBorrowLoc[10](loc1: vector<String>)

29LdConst[40](vector<u8>: "lin..)

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

31VecPushBack(82)

32MutBorrowLoc[10](loc1: vector<String>)

33LdConst[41](vector<u8>: "ima..)

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

35VecPushBack(82)

36MutBorrowLoc[10](loc1: vector<String>)

37LdConst[42](vector<u8>: "des..)

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

39VecPushBack(82)

40MutBorrowLoc[10](loc1: vector<String>)

41LdConst[43](vector<u8>: "pro..)

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

43VecPushBack(82)

44MutBorrowLoc[10](loc1: vector<String>)

45LdConst[44](vector<u8>: "cre..)

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

47VecPushBack(82)

48VecPack(82, 0)

49StLoc[11](loc2: vector<String>)

50MutBorrowLoc[11](loc2: vector<String>)

51MoveLoc[2](Arg2: String)

52VecPushBack(82)

53MutBorrowLoc[11](loc2: vector<String>)

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

55Call type_name::into_string(TypeName): String

56Call string::from_ascii(String): String

57VecPushBack(82)

58MutBorrowLoc[11](loc2: vector<String>)

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

60Call type_name::into_string(TypeName): String

61Call string::from_ascii(String): String

62VecPushBack(82)

63MutBorrowLoc[11](loc2: vector<String>)

64MoveLoc[5](Arg5: String)

65VecPushBack(82)

66MutBorrowLoc[11](loc2: vector<String>)

67MoveLoc[4](Arg4: String)

68VecPushBack(82)

69MutBorrowLoc[11](loc2: vector<String>)

70MoveLoc[3](Arg3: String)

71VecPushBack(82)

72MutBorrowLoc[11](loc2: vector<String>)

73MoveLoc[6](Arg6: String)

74VecPushBack(82)

75MutBorrowLoc[11](loc2: vector<String>)

76MoveLoc[7](Arg7: String)

77VecPushBack(82)

78MoveLoc[1](Arg1: &Publisher)

79MoveLoc[10](loc1: vector<String>)

80MoveLoc[11](loc2: vector<String>)

81CopyLoc[8](Arg8: &mut TxContext)

82Call display::new_with_fields<Pool<Ty0, Ty1>>(&Publisher, vector<String>, vector<String>, &mut TxContext): Display<Pool<Ty0, Ty1>>

83StLoc[9](loc0: Display<Pool<Ty0, Ty1>>)

84MutBorrowLoc[9](loc0: Display<Pool<Ty0, Ty1>>)

85Call display::update_version<Pool<Ty0, Ty1>>(&mut Display<Pool<Ty0, Ty1>>)

86MoveLoc[9](loc0: Display<Pool<Ty0, Ty1>>)

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

88FreezeRef

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

90Call transfer::public_transfer<Display<Pool<Ty0, Ty1>>>(Display<Pool<Ty0, Ty1>>, address)

91Ret

}

public stake_in_fullsail_distribution<Ty0, Ty1>(Arg0: &mut Pool<Ty0, Ty1>, Arg1: &GaugeCap, Arg2: &Position, Arg3: &Clock) {

L4: loc0: u128

L5: loc1: u128

L6: loc2: u128

L7: loc3: u128

L8: loc4: ID

L9: loc5: I32

L10: loc6: I32

B0:

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

1ImmBorrowFieldGeneric[2](Pool.is_pause: bool)

2ReadRef

3Not

4BrFalse(6)

B1:

5Branch(16)

B2:

6MoveLoc[2](Arg2: &Position)

7Pop

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

9Pop

10MoveLoc[1](Arg1: &GaugeCap)

11Pop

12MoveLoc[3](Arg3: &Clock)

13Pop

14LdConst[15](u64: 9283..)

15Abort

B3:

16CopyLoc[2](Arg2: &Position)

17Call position::liquidity(&Position): u128

18StLoc[7](loc3: u128)

19CopyLoc[7](loc3: u128)

20LdU128(0)

21Neq

22BrFalse(24)

B4:

23Branch(34)

B5:

24MoveLoc[2](Arg2: &Position)

25Pop

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

27Pop

28MoveLoc[1](Arg1: &GaugeCap)

29Pop

30MoveLoc[3](Arg3: &Clock)

31Pop

32LdConst[6](u64: 9328..)

33Abort

B6:

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

35FreezeRef

36MoveLoc[1](Arg1: &GaugeCap)

37Call check_gauge_cap<Ty0, Ty1>(&Pool<Ty0, Ty1>, &GaugeCap)

38CopyLoc[2](Arg2: &Position)

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

40StLoc[8](loc4: ID)

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

42ImmBorrowFieldGeneric[1](Pool.position_manager: PositionManager)

43CopyLoc[8](loc4: ID)

44Call position::validate_position_exists(&PositionManager, ID)

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

46ImmBorrowFieldGeneric[1](Pool.position_manager: PositionManager)

47CopyLoc[8](loc4: ID)

48Call position::is_position_staked(&PositionManager, ID): bool

49Not

50BrFalse(52)

B7:

51Branch(60)

B8:

52MoveLoc[2](Arg2: &Position)

53Pop

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

55Pop

56MoveLoc[3](Arg3: &Clock)

57Pop

58LdConst[34](u64: 2720..)

59Abort

B9:

60MoveLoc[2](Arg2: &Position)

61Call position::tick_range(&Position): I32 * I32

62StLoc[10](loc6: I32)

63StLoc[9](loc5: I32)

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

65MoveLoc[7](loc3: u128)

66Call i128::from(u128): I128

67CopyLoc[9](loc5: I32)

68CopyLoc[10](loc6: I32)

69MoveLoc[3](Arg3: &Clock)

70Call update_fullsail_distribution_internal<Ty0, Ty1>(&mut Pool<Ty0, Ty1>, I128, I32, I32, &Clock)

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

72FreezeRef

73MoveLoc[9](loc5: I32)

74MoveLoc[10](loc6: I32)

75Call get_all_growths_in_tick_range<Ty0, Ty1>(&Pool<Ty0, Ty1>, I32, I32): u128 * u128 * vector<u128> * u128 * u128

76StLoc[6](loc2: u128)

77Pop

78Pop

79StLoc[5](loc1: u128)

80StLoc[4](loc0: u128)

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

82MutBorrowFieldGeneric[1](Pool.position_manager: PositionManager)

83MoveLoc[8](loc4: ID)

84MoveLoc[4](loc0: u128)

85MoveLoc[5](loc1: u128)

86MoveLoc[6](loc2: u128)

87LdTrue

88Call position::mark_position_staked(&mut PositionManager, ID, u128, u128, u128, bool)

89Ret

}

public step_swap_result_amount_in(Arg0: &SwapStepResult): u64 {

B0:

0MoveLoc[0](Arg0: &SwapStepResult)

1ImmBorrowField[52](SwapStepResult.amount_in: u64)

2ReadRef

3Ret

}

public step_swap_result_amount_out(Arg0: &SwapStepResult): u64 {

B0:

0MoveLoc[0](Arg0: &SwapStepResult)

1ImmBorrowField[53](SwapStepResult.amount_out: u64)

2ReadRef

3Ret

}

public step_swap_result_current_liquidity(Arg0: &SwapStepResult): u128 {

B0:

0MoveLoc[0](Arg0: &SwapStepResult)

1ImmBorrowField[54](SwapStepResult.current_liquidity: u128)

2ReadRef

3Ret

}

public step_swap_result_current_sqrt_price(Arg0: &SwapStepResult): u128 {

B0:

0MoveLoc[0](Arg0: &SwapStepResult)

1ImmBorrowField[55](SwapStepResult.current_sqrt_price: u128)

2ReadRef

3Ret

}

public step_swap_result_fee_amount(Arg0: &SwapStepResult): u64 {

B0:

0MoveLoc[0](Arg0: &SwapStepResult)

1ImmBorrowField[56](SwapStepResult.fee_amount: u64)

2ReadRef

3Ret

}

public step_swap_result_remainder_amount(Arg0: &SwapStepResult): u64 {

B0:

0MoveLoc[0](Arg0: &SwapStepResult)

1ImmBorrowField[57](SwapStepResult.remainder_amount: u64)

2ReadRef

3Ret

}

public step_swap_result_target_sqrt_price(Arg0: &SwapStepResult): u128 {

B0:

0MoveLoc[0](Arg0: &SwapStepResult)

1ImmBorrowField[58](SwapStepResult.target_sqrt_price: u128)

2ReadRef

3Ret

}

swap_in_pool<Ty0, Ty1>(Arg0: &mut Pool<Ty0, Ty1>, Arg1: bool, Arg2: bool, Arg3: u128, Arg4: u64, Arg5: u64, Arg6: u64, Arg7: u64, Arg8: &Clock): SwapResult * u128 {

L9: loc0: bool

L10: loc1: u128

L11: loc2: bool

L12: loc3: I32

L13: loc4: u64

L14: loc5: u64

L15: loc6: u64

L16: loc7: u128

L17: loc8: u128

L18: loc9: u128

L19: loc10: u64

L20: loc11: u64

L21: loc12: u128

L22: loc13: OptionU64

L23: loc14: u128

L24: loc15: OptionU64

L25: loc16: u64

L26: loc17: u64

L27: loc18: u64

L28: loc19: u64

L29: loc20: u64

L30: loc21: u64

L31: loc22: SwapResult

L32: loc23: u128

L33: loc24: I32

L34: loc25: &Tick

L35: loc26: u128

B0:

0CopyLoc[7](Arg7: u64)

1Call config::protocol_fee_rate_denom(): u64

2Le

3BrFalse(5)

B1:

4Branch(11)

B2:

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

6Pop

7MoveLoc[8](Arg8: &Clock)

8Pop

9LdConst[18](u64: 9439..)

10Abort

B3:

11Call default_swap_result(): SwapResult

12StLoc[31](loc22: SwapResult)

13LdU128(0)

14StLoc[17](loc8: u128)

15MoveLoc[4](Arg4: u64)

16StLoc[28](loc19: u64)

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

18ImmBorrowFieldGeneric[7](Pool.tick_manager: TickManager)

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

20ImmBorrowFieldGeneric[8](Pool.current_tick_index: I32)

21ReadRef

22CopyLoc[1](Arg1: bool)

23Call tick::first_score_for_swap(&TickManager, I32, bool): OptionU64

24StLoc[24](loc15: OptionU64)

B4:

25CopyLoc[28](loc19: u64)

26LdU64(0)

27Gt

28BrFalse(36)

B5:

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

30ImmBorrowFieldGeneric[9](Pool.current_sqrt_price: u128)

31ReadRef

32CopyLoc[3](Arg3: u128)

33Neq

34StLoc[9](loc0: bool)

35Branch(38)

B6:

36LdFalse

37StLoc[9](loc0: bool)

B7:

38MoveLoc[9](loc0: bool)

39BrFalse(268)

B8:

40ImmBorrowLoc[24](loc15: OptionU64)

41Call option_u64::is_none(&OptionU64): bool

42BrFalse(49)

B9:

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

44Pop

45MoveLoc[8](Arg8: &Clock)

46Pop

47LdConst[21](u64: 9293..)

48Abort

B10:

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

50ImmBorrowFieldGeneric[7](Pool.tick_manager: TickManager)

51ImmBorrowLoc[24](loc15: OptionU64)

52Call option_u64::borrow(&OptionU64): u64

53CopyLoc[1](Arg1: bool)

54Call tick::borrow_tick_for_swap(&TickManager, u64, bool): &Tick * OptionU64

55StLoc[22](loc13: OptionU64)

56StLoc[34](loc25: &Tick)

57MoveLoc[22](loc13: OptionU64)

58StLoc[24](loc15: OptionU64)

59CopyLoc[34](loc25: &Tick)

60Call tick::index(&Tick): I32

61StLoc[33](loc24: I32)

62MoveLoc[34](loc25: &Tick)

63Call tick::sqrt_price(&Tick): u128

64StLoc[35](loc26: u128)

65CopyLoc[1](Arg1: bool)

66BrFalse(72)

B11:

67CopyLoc[3](Arg3: u128)

68CopyLoc[35](loc26: u128)

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

70StLoc[10](loc1: u128)

71Branch(76)

B12:

72CopyLoc[3](Arg3: u128)

73CopyLoc[35](loc26: u128)

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

75StLoc[10](loc1: u128)

B13:

76MoveLoc[10](loc1: u128)

77StLoc[32](loc23: u128)

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

79ImmBorrowFieldGeneric[9](Pool.current_sqrt_price: u128)

80ReadRef

81CopyLoc[32](loc23: u128)

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

83ImmBorrowFieldGeneric[3](Pool.liquidity: u128)

84ReadRef

85CopyLoc[28](loc19: u64)

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

87ImmBorrowFieldGeneric[18](Pool.fee_rate: u64)

88ReadRef

89CopyLoc[1](Arg1: bool)

90CopyLoc[2](Arg2: bool)

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

92StLoc[15](loc6: u64)

93StLoc[23](loc14: u128)

94StLoc[14](loc5: u64)

95StLoc[13](loc4: u64)

96CopyLoc[13](loc4: u64)

97LdU64(0)

98Neq

99BrFalse(103)

B14:

100LdTrue

101StLoc[11](loc2: bool)

102Branch(107)

B15:

103CopyLoc[15](loc6: u64)

104LdU64(0)

105Neq

106StLoc[11](loc2: bool)

B16:

107MoveLoc[11](loc2: bool)

108BrFalse(191)

B17:

109CopyLoc[2](Arg2: bool)

110BrFalse(118)

B18:

111MoveLoc[28](loc19: u64)

112CopyLoc[13](loc4: u64)

113Call check_remainer_amount_sub(u64, u64): u64

114CopyLoc[15](loc6: u64)

115Call check_remainer_amount_sub(u64, u64): u64

116StLoc[28](loc19: u64)

117Branch(122)

B19:

118MoveLoc[28](loc19: u64)

119CopyLoc[14](loc5: u64)

120Call check_remainer_amount_sub(u64, u64): u64

121StLoc[28](loc19: u64)

B20:

122CopyLoc[15](loc6: u64)

123CopyLoc[7](Arg7: u64)

124Call config::protocol_fee_rate_denom(): u64

125Call full_math_u64::mul_div_ceil(u64, u64, u64): u64

126StLoc[27](loc18: u64)

127CopyLoc[15](loc6: u64)

128CopyLoc[27](loc18: u64)

129Sub

130StLoc[29](loc20: u64)

131LdU64(0)

132StLoc[19](loc10: u64)

133LdU64(0)

134StLoc[25](loc16: u64)

135LdU128(0)

136StLoc[18](loc9: u128)

137CopyLoc[29](loc20: u64)

138LdU64(0)

139Gt

140BrFalse(171)

B21:

141CopyLoc[29](loc20: u64)

142CopyLoc[6](Arg6: u64)

143Call config::protocol_fee_rate_denom(): u64

144Call full_math_u64::mul_div_ceil(u64, u64, u64): u64

145StLoc[26](loc17: u64)

146CopyLoc[26](loc17: u64)

147StLoc[25](loc16: u64)

148MoveLoc[29](loc20: u64)

149MoveLoc[26](loc17: u64)

150Sub

151StLoc[30](loc21: u64)

152CopyLoc[30](loc21: u64)

153LdU64(0)

154Gt

155BrFalse(171)

B22:

156MoveLoc[30](loc21: u64)

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

158ImmBorrowFieldGeneric[3](Pool.liquidity: u128)

159ReadRef

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

161ImmBorrowFieldGeneric[17](Pool.fullsail_distribution_staked_liquidity: u128)

162ReadRef

163CopyLoc[5](Arg5: u64)

164Call calculate_fees(u64, u128, u128, u64): u128 * u64

165StLoc[20](loc11: u64)

166StLoc[16](loc7: u128)

167MoveLoc[20](loc11: u64)

168StLoc[19](loc10: u64)

169MoveLoc[16](loc7: u128)

170StLoc[18](loc9: u128)

B23:

171MutBorrowLoc[31](loc22: SwapResult)

172MoveLoc[13](loc4: u64)

173MoveLoc[14](loc5: u64)

174MoveLoc[15](loc6: u64)

175MoveLoc[25](loc16: u64)

176MoveLoc[27](loc18: u64)

177MoveLoc[19](loc10: u64)

178Call update_swap_result(&mut SwapResult, u64, u64, u64, u64, u64, u64)

179CopyLoc[18](loc9: u128)

180LdU128(0)

181Gt

182BrFalse(191)

B24:

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

184CopyLoc[18](loc9: u128)

185CopyLoc[1](Arg1: bool)

186Call update_fee_growth_global<Ty0, Ty1>(&mut Pool<Ty0, Ty1>, u128, bool)

187MoveLoc[17](loc8: u128)

188MoveLoc[18](loc9: u128)

189Add

190StLoc[17](loc8: u128)

B25:

191CopyLoc[23](loc14: u128)

192MoveLoc[35](loc26: u128)

193Eq

194BrFalse(252)

B26:

195MoveLoc[32](loc23: u128)

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

197MutBorrowFieldGeneric[9](Pool.current_sqrt_price: u128)

198WriteRef

199CopyLoc[1](Arg1: bool)

200BrFalse(207)

B27:

201CopyLoc[33](loc24: I32)

202LdU32(1)

203Call i32::from(u32): I32

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

205StLoc[12](loc3: I32)

206Branch(209)

B28:

207CopyLoc[33](loc24: I32)

208StLoc[12](loc3: I32)

B29:

209MoveLoc[12](loc3: I32)

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

211MutBorrowFieldGeneric[8](Pool.current_tick_index: I32)

212WriteRef

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

214CopyLoc[8](Arg8: &Clock)

215Call update_fullsail_distribution_growth_global_internal<Ty0, Ty1>(&mut Pool<Ty0, Ty1>, &Clock): u64

216Pop

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

218MutBorrowFieldGeneric[7](Pool.tick_manager: TickManager)

219MoveLoc[33](loc24: I32)

220CopyLoc[1](Arg1: bool)

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

222ImmBorrowFieldGeneric[3](Pool.liquidity: u128)

223ReadRef

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

225ImmBorrowFieldGeneric[17](Pool.fullsail_distribution_staked_liquidity: u128)

226ReadRef

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

228ImmBorrowFieldGeneric[10](Pool.fee_growth_global_a: u128)

229ReadRef

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

231ImmBorrowFieldGeneric[11](Pool.fee_growth_global_b: u128)

232ReadRef

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

234ImmBorrowFieldGeneric[6](Pool.rewarder_manager: RewarderManager)

235Call rewarder::points_growth_global(&RewarderManager): u128

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

237ImmBorrowFieldGeneric[6](Pool.rewarder_manager: RewarderManager)

238Call rewarder::rewards_growth_global(&RewarderManager): vector<u128>

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

240ImmBorrowFieldGeneric[12](Pool.fullsail_distribution_growth_global: u128)

241ReadRef

242Call tick::cross_by_swap(&mut TickManager, I32, bool, u128, u128, u128, u128, u128, vector<u128>, u128): u128 * u128

243StLoc[21](loc12: u128)

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

245MutBorrowFieldGeneric[3](Pool.liquidity: u128)

246WriteRef

247MoveLoc[21](loc12: u128)

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

249MutBorrowFieldGeneric[17](Pool.fullsail_distribution_staked_liquidity: u128)

250WriteRef

251Branch(25)

B30:

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

253ImmBorrowFieldGeneric[9](Pool.current_sqrt_price: u128)

254ReadRef

255CopyLoc[23](loc14: u128)

256Neq

257BrFalse(25)

B31:

258CopyLoc[23](loc14: u128)

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

260MutBorrowFieldGeneric[9](Pool.current_sqrt_price: u128)

261WriteRef

262MoveLoc[23](loc14: u128)

263Call tick_math::get_tick_at_sqrt_price(u128): I32

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

265MutBorrowFieldGeneric[8](Pool.current_tick_index: I32)

266WriteRef

267Branch(25)

B32:

268MoveLoc[8](Arg8: &Clock)

269Pop

270MoveLoc[1](Arg1: bool)

271BrFalse(295)

B33:

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

273ImmBorrowFieldGeneric[21](Pool.fee_protocol_coin_a: u64)

274ReadRef

275ImmBorrowLoc[31](loc22: SwapResult)

276ImmBorrowField[29](SwapResult.protocol_fee_amount: u64)

277ReadRef

278Add

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

280MutBorrowFieldGeneric[21](Pool.fee_protocol_coin_a: u64)

281WriteRef

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

283ImmBorrowFieldGeneric[20](Pool.fullsail_distribution_gauger_fee: PoolFee)

284ImmBorrowField[36](PoolFee.coin_a: u64)

285ReadRef

286ImmBorrowLoc[31](loc22: SwapResult)

287ImmBorrowField[27](SwapResult.gauge_fee_amount: u64)

288ReadRef

289Add

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

291MutBorrowFieldGeneric[20](Pool.fullsail_distribution_gauger_fee: PoolFee)

292MutBorrowField[36](PoolFee.coin_a: u64)

293WriteRef

294Branch(317)

B34:

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

296ImmBorrowFieldGeneric[22](Pool.fee_protocol_coin_b: u64)

297ReadRef

298ImmBorrowLoc[31](loc22: SwapResult)

299ImmBorrowField[29](SwapResult.protocol_fee_amount: u64)

300ReadRef

301Add

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

303MutBorrowFieldGeneric[22](Pool.fee_protocol_coin_b: u64)

304WriteRef

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

306ImmBorrowFieldGeneric[20](Pool.fullsail_distribution_gauger_fee: PoolFee)

307ImmBorrowField[37](PoolFee.coin_b: u64)

308ReadRef

309ImmBorrowLoc[31](loc22: SwapResult)

310ImmBorrowField[27](SwapResult.gauge_fee_amount: u64)

311ReadRef

312Add

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

314MutBorrowFieldGeneric[20](Pool.fullsail_distribution_gauger_fee: PoolFee)

315MutBorrowField[37](PoolFee.coin_b: u64)

316WriteRef

B35:

317MoveLoc[31](loc22: SwapResult)

318MoveLoc[17](loc8: u128)

319Ret

}

public swap_pay_amount<Ty0, Ty1>(Arg0: &FlashSwapReceipt<Ty0, Ty1>): u64 {

B0:

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

1ImmBorrowFieldGeneric[32](FlashSwapReceipt.pay_amount: u64)

2ReadRef

3Ret

}

public sync_fullsail_distribution_reward<Ty0, Ty1>(Arg0: &mut Pool<Ty0, Ty1>, Arg1: &GaugeCap, Arg2: u128, Arg3: u64, Arg4: u64, Arg5: &Clock) {

B0:

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

1ImmBorrowFieldGeneric[2](Pool.is_pause: bool)

2ReadRef

3Not

4BrFalse(6)

B1:

5Branch(14)

B2:

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

7Pop

8MoveLoc[1](Arg1: &GaugeCap)

9Pop

10MoveLoc[5](Arg5: &Clock)

11Pop

12LdConst[15](u64: 9283..)

13Abort

B3:

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

15FreezeRef

16CopyLoc[1](Arg1: &GaugeCap)

17Call check_gauge_cap<Ty0, Ty1>(&Pool<Ty0, Ty1>, &GaugeCap)

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

19ImmBorrowFieldGeneric[28](Pool.fullsail_distribution_last_updated: u64)

20ReadRef

21MoveLoc[5](Arg5: &Clock)

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

23LdU64(1000)

24Div

25Eq

26BrFalse(28)

B4:

27Branch(34)

B5:

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

29Pop

30MoveLoc[1](Arg1: &GaugeCap)

31Pop

32LdConst[32](u64: 9326..)

33Abort

B6:

34MoveLoc[2](Arg2: u128)

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

36MutBorrowFieldGeneric[33](Pool.fullsail_distribution_rate: u128)

37WriteRef

38MoveLoc[3](Arg3: u64)

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

40MutBorrowFieldGeneric[29](Pool.fullsail_distribution_reserve: u64)

41WriteRef

42MoveLoc[4](Arg4: u64)

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

44MutBorrowFieldGeneric[30](Pool.fullsail_distribution_period_finish: u64)

45WriteRef

46LdU64(0)

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

48MutBorrowFieldGeneric[31](Pool.fullsail_distribution_rollover: u64)

49WriteRef

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

51FreezeRef

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

53MoveLoc[1](Arg1: &GaugeCap)

54Call gauge_cap::get_gauge_id(&GaugeCap): ID

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

56ImmBorrowFieldGeneric[33](Pool.fullsail_distribution_rate: u128)

57ReadRef

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

59ImmBorrowFieldGeneric[29](Pool.fullsail_distribution_reserve: u64)

60ReadRef

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

62ImmBorrowFieldGeneric[30](Pool.fullsail_distribution_period_finish: u64)

63ReadRef

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

65ImmBorrowFieldGeneric[31](Pool.fullsail_distribution_rollover: u64)

66ReadRef

67Pack[26](SyncFullsailDistributionRewardEvent)

68Call event::emit<SyncFullsailDistributionRewardEvent>(SyncFullsailDistributionRewardEvent)

69Ret

}

public tick_manager<Ty0, Ty1>(Arg0: &Pool<Ty0, Ty1>): &TickManager {

B0:

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

1ImmBorrowFieldGeneric[7](Pool.tick_manager: TickManager)

2Ret

}

public tick_spacing<Ty0, Ty1>(Arg0: &Pool<Ty0, Ty1>): u32 {

B0:

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

1ImmBorrowFieldGeneric[34](Pool.tick_spacing: u32)

2ReadRef

3Ret

}

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

B0:

0CopyLoc[0](Arg0: &GlobalConfig)

1Call config::checked_package_version(&GlobalConfig)

2MoveLoc[0](Arg0: &GlobalConfig)

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

4FreezeRef

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

6Call config::check_pool_manager_role(&GlobalConfig, address)

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

8ImmBorrowFieldGeneric[2](Pool.is_pause: bool)

9ReadRef

10BrFalse(12)

B1:

11Branch(16)

B2:

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

13Pop

14LdConst[29](u64: 9223..)

15Abort

B3:

16LdFalse

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

18MutBorrowFieldGeneric[2](Pool.is_pause: bool)

19WriteRef

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

21FreezeRef

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

23Pack[28](UnpausePoolEvent)

24Call event::emit<UnpausePoolEvent>(UnpausePoolEvent)

25Ret

}

public unstake_from_fullsail_distribution<Ty0, Ty1>(Arg0: &mut Pool<Ty0, Ty1>, Arg1: &GaugeCap, Arg2: &Position, Arg3: &Clock) {

L4: loc0: u128

L5: loc1: u128

L6: loc2: u128

L7: loc3: u128

L8: loc4: ID

L9: loc5: I32

L10: loc6: I32

B0:

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

1ImmBorrowFieldGeneric[2](Pool.is_pause: bool)

2ReadRef

3Not

4BrFalse(6)

B1:

5Branch(16)

B2:

6MoveLoc[2](Arg2: &Position)

7Pop

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

9Pop

10MoveLoc[1](Arg1: &GaugeCap)

11Pop

12MoveLoc[3](Arg3: &Clock)

13Pop

14LdConst[15](u64: 9283..)

15Abort

B3:

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

17FreezeRef

18MoveLoc[1](Arg1: &GaugeCap)

19Call check_gauge_cap<Ty0, Ty1>(&Pool<Ty0, Ty1>, &GaugeCap)

20CopyLoc[2](Arg2: &Position)

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

22StLoc[8](loc4: ID)

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

24ImmBorrowFieldGeneric[1](Pool.position_manager: PositionManager)

25CopyLoc[8](loc4: ID)

26Call position::validate_position_exists(&PositionManager, ID)

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

28ImmBorrowFieldGeneric[1](Pool.position_manager: PositionManager)

29CopyLoc[8](loc4: ID)

30Call position::is_position_staked(&PositionManager, ID): bool

31BrFalse(33)

B4:

32Branch(41)

B5:

33MoveLoc[2](Arg2: &Position)

34Pop

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

36Pop

37MoveLoc[3](Arg3: &Clock)

38Pop

39LdConst[33](u64: 1696..)

40Abort

B6:

41CopyLoc[2](Arg2: &Position)

42Call position::liquidity(&Position): u128

43StLoc[7](loc3: u128)

44MoveLoc[2](Arg2: &Position)

45Call position::tick_range(&Position): I32 * I32

46StLoc[10](loc6: I32)

47StLoc[9](loc5: I32)

48CopyLoc[7](loc3: u128)

49LdU128(0)

50Gt

51BrFalse(61)

B7:

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

53MoveLoc[7](loc3: u128)

54Call i128::from(u128): I128

55Call i128::neg(I128): I128

56CopyLoc[9](loc5: I32)

57CopyLoc[10](loc6: I32)

58MoveLoc[3](Arg3: &Clock)

59Call update_fullsail_distribution_internal<Ty0, Ty1>(&mut Pool<Ty0, Ty1>, I128, I32, I32, &Clock)

60Branch(63)

B8:

61MoveLoc[3](Arg3: &Clock)

62Pop

B9:

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

64FreezeRef

65MoveLoc[9](loc5: I32)

66MoveLoc[10](loc6: I32)

67Call get_all_growths_in_tick_range<Ty0, Ty1>(&Pool<Ty0, Ty1>, I32, I32): u128 * u128 * vector<u128> * u128 * u128

68StLoc[6](loc2: u128)

69Pop

70Pop

71StLoc[5](loc1: u128)

72StLoc[4](loc0: u128)

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

74MutBorrowFieldGeneric[1](Pool.position_manager: PositionManager)

75MoveLoc[8](loc4: ID)

76MoveLoc[4](loc0: u128)

77MoveLoc[5](loc1: u128)

78MoveLoc[6](loc2: u128)

79LdFalse

80Call position::mark_position_staked(&mut PositionManager, ID, u128, u128, u128, bool)

81Ret

}

update_fee_growth_global<Ty0, Ty1>(Arg0: &mut Pool<Ty0, Ty1>, Arg1: u128, Arg2: bool) {

L3: loc0: bool

B0:

0CopyLoc[1](Arg1: u128)

1LdU128(0)

2Eq

3BrFalse(7)

B1:

4LdTrue

5StLoc[3](loc0: bool)

6Branch(13)

B2:

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

8ImmBorrowFieldGeneric[3](Pool.liquidity: u128)

9ReadRef

10LdU128(0)

11Eq

12StLoc[3](loc0: bool)

B3:

13MoveLoc[3](loc0: bool)

14BrFalse(18)

B4:

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

16Pop

17Ret

B5:

18MoveLoc[2](Arg2: bool)

19BrFalse(29)

B6:

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

21ImmBorrowFieldGeneric[10](Pool.fee_growth_global_a: u128)

22ReadRef

23MoveLoc[1](Arg1: u128)

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

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

26MutBorrowFieldGeneric[10](Pool.fee_growth_global_a: u128)

27WriteRef

28Branch(37)

B7:

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

30ImmBorrowFieldGeneric[11](Pool.fee_growth_global_b: u128)

31ReadRef

32MoveLoc[1](Arg1: u128)

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

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

35MutBorrowFieldGeneric[11](Pool.fee_growth_global_b: u128)

36WriteRef

B8:

37Ret

}

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

L4: loc0: UpdateFeeRateEvent

B0:

0CopyLoc[0](Arg0: &GlobalConfig)

1Call config::checked_package_version(&GlobalConfig)

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

3ImmBorrowFieldGeneric[2](Pool.is_pause: bool)

4ReadRef

5Not

6BrFalse(8)

B1:

7Branch(16)

B2:

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

9Pop

10MoveLoc[0](Arg0: &GlobalConfig)

11Pop

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

13Pop

14LdConst[15](u64: 9283..)

15Abort

B3:

16CopyLoc[2](Arg2: u64)

17Call config::max_fee_rate(): u64

18Le

19BrFalse(21)

B4:

20Branch(29)

B5:

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

22Pop

23MoveLoc[0](Arg0: &GlobalConfig)

24Pop

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

26Pop

27LdConst[12](u64: 9239..)

28Abort

B6:

29CopyLoc[2](Arg2: u64)

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

31ImmBorrowFieldGeneric[18](Pool.fee_rate: u64)

32ReadRef

33Neq

34BrFalse(36)

B7:

35Branch(44)

B8:

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

37Pop

38MoveLoc[0](Arg0: &GlobalConfig)

39Pop

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

41Pop

42LdConst[12](u64: 9239..)

43Abort

B9:

44MoveLoc[0](Arg0: &GlobalConfig)

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

46FreezeRef

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

48Call config::check_pool_manager_role(&GlobalConfig, address)

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

50FreezeRef

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

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

53ImmBorrowFieldGeneric[18](Pool.fee_rate: u64)

54ReadRef

55CopyLoc[2](Arg2: u64)

56Pack[17](UpdateFeeRateEvent)

57StLoc[4](loc0: UpdateFeeRateEvent)

58MoveLoc[2](Arg2: u64)

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

60MutBorrowFieldGeneric[18](Pool.fee_rate: u64)

61WriteRef

62MoveLoc[4](loc0: UpdateFeeRateEvent)

63Call event::emit<UpdateFeeRateEvent>(UpdateFeeRateEvent)

64Ret

}

public update_fullsail_distribution_growth_global<Ty0, Ty1>(Arg0: &mut Pool<Ty0, Ty1>, Arg1: &GaugeCap, Arg2: &Clock) {

B0:

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

1ImmBorrowFieldGeneric[2](Pool.is_pause: bool)

2ReadRef

3Not

4BrFalse(6)

B1:

5Branch(14)

B2:

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

7Pop

8MoveLoc[1](Arg1: &GaugeCap)

9Pop

10MoveLoc[2](Arg2: &Clock)

11Pop

12LdConst[15](u64: 9283..)

13Abort

B3:

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

15FreezeRef

16MoveLoc[1](Arg1: &GaugeCap)

17Call check_gauge_cap<Ty0, Ty1>(&Pool<Ty0, Ty1>, &GaugeCap)

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

19MoveLoc[2](Arg2: &Clock)

20Call update_fullsail_distribution_growth_global_internal<Ty0, Ty1>(&mut Pool<Ty0, Ty1>, &Clock): u64

21Pop

22Ret

}

update_fullsail_distribution_growth_global_internal<Ty0, Ty1>(Arg0: &mut Pool<Ty0, Ty1>, Arg1: &Clock): u64 {

L2: loc0: u64

L3: loc1: u64

L4: loc2: u64

L5: loc3: u64

L6: loc4: u64

B0:

0MoveLoc[1](Arg1: &Clock)

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

2LdU64(1000)

3Div

4StLoc[4](loc2: u64)

5CopyLoc[4](loc2: u64)

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

7ImmBorrowFieldGeneric[28](Pool.fullsail_distribution_last_updated: u64)

8ReadRef

9Sub

10StLoc[6](loc4: u64)

11LdU64(0)

12StLoc[5](loc3: u64)

13CopyLoc[6](loc4: u64)

14LdU64(0)

15Neq

16BrFalse(102)

B1:

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

18ImmBorrowFieldGeneric[29](Pool.fullsail_distribution_reserve: u64)

19ReadRef

20LdU64(0)

21Gt

22BrFalse(97)

B2:

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

24ImmBorrowFieldGeneric[33](Pool.fullsail_distribution_rate: u128)

25ReadRef

26MoveLoc[6](loc4: u64)

27CastU128

28LdConst[2](u128: 1844..)

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

30CastU64

31StLoc[3](loc1: u64)

32CopyLoc[3](loc1: u64)

33StLoc[2](loc0: u64)

34MoveLoc[3](loc1: u64)

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

36ImmBorrowFieldGeneric[29](Pool.fullsail_distribution_reserve: u64)

37ReadRef

38Gt

39BrFalse(44)

B3:

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

41ImmBorrowFieldGeneric[29](Pool.fullsail_distribution_reserve: u64)

42ReadRef

43StLoc[2](loc0: u64)

B4:

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

45ImmBorrowFieldGeneric[29](Pool.fullsail_distribution_reserve: u64)

46ReadRef

47CopyLoc[2](loc0: u64)

48Sub

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

50MutBorrowFieldGeneric[29](Pool.fullsail_distribution_reserve: u64)

51WriteRef

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

53ImmBorrowFieldGeneric[17](Pool.fullsail_distribution_staked_liquidity: u128)

54ReadRef

55LdU128(0)

56Gt

57BrFalse(73)

B5:

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

59ImmBorrowFieldGeneric[12](Pool.fullsail_distribution_growth_global: u128)

60ReadRef

61CopyLoc[2](loc0: u64)

62CastU128

63LdConst[2](u128: 1844..)

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

65ImmBorrowFieldGeneric[17](Pool.fullsail_distribution_staked_liquidity: u128)

66ReadRef

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

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

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

70MutBorrowFieldGeneric[12](Pool.fullsail_distribution_growth_global: u128)

71WriteRef

72Branch(81)

B6:

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

74ImmBorrowFieldGeneric[31](Pool.fullsail_distribution_rollover: u64)

75ReadRef

76CopyLoc[2](loc0: u64)

77Add

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

79MutBorrowFieldGeneric[31](Pool.fullsail_distribution_rollover: u64)

80WriteRef

B7:

81MoveLoc[2](loc0: u64)

82StLoc[5](loc3: u64)

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

84FreezeRef

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

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

87ImmBorrowFieldGeneric[12](Pool.fullsail_distribution_growth_global: u128)

88ReadRef

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

90ImmBorrowFieldGeneric[29](Pool.fullsail_distribution_reserve: u64)

91ReadRef

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

93ImmBorrowFieldGeneric[31](Pool.fullsail_distribution_rollover: u64)

94ReadRef

95Pack[30](UpdateFullsailDistributionGrowthGlobalEvent)

96Call event::emit<UpdateFullsailDistributionGrowthGlobalEvent>(UpdateFullsailDistributionGrowthGlobalEvent)

B8:

97MoveLoc[4](loc2: u64)

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

99MutBorrowFieldGeneric[28](Pool.fullsail_distribution_last_updated: u64)

100WriteRef

101Branch(104)

B9:

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

103Pop

B10:

104MoveLoc[5](loc3: u64)

105Ret

}

update_fullsail_distribution_internal<Ty0, Ty1>(Arg0: &mut Pool<Ty0, Ty1>, Arg1: I128, Arg2: I32, Arg3: I32, Arg4: &Clock) {

L5: loc0: bool

L6: loc1: bool

L7: loc2: Option<Tick>

L8: loc3: Option<Tick>

B0:

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

1ImmBorrowFieldGeneric[8](Pool.current_tick_index: I32)

2ReadRef

3CopyLoc[2](Arg2: I32)

4Call i32::gte(I32, I32): bool

5BrFalse(13)

B1:

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

7ImmBorrowFieldGeneric[8](Pool.current_tick_index: I32)

8ReadRef

9CopyLoc[3](Arg3: I32)

10Call i32::lt(I32, I32): bool

11StLoc[5](loc0: bool)

12Branch(15)

B2:

13LdFalse

14StLoc[5](loc0: bool)

B3:

15MoveLoc[5](loc0: bool)

16BrFalse(71)

B4:

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

18MoveLoc[4](Arg4: &Clock)

19Call update_fullsail_distribution_growth_global_internal<Ty0, Ty1>(&mut Pool<Ty0, Ty1>, &Clock): u64

20Pop

21CopyLoc[1](Arg1: I128)

22Call i128::is_neg(I128): bool

23BrFalse(36)

B5:

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

25ImmBorrowFieldGeneric[17](Pool.fullsail_distribution_staked_liquidity: u128)

26ReadRef

27CopyLoc[1](Arg1: I128)

28Call i128::abs_u128(I128): u128

29Ge

30BrFalse(32)

B6:

31Branch(52)

B7:

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

33Pop

34LdConst[31](u64: 9223..)

35Abort

B8:

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

37ImmBorrowFieldGeneric[17](Pool.fullsail_distribution_staked_liquidity: u128)

38ReadRef

39Call i128::from(u128): I128

40CopyLoc[1](Arg1: I128)

41Call i128::overflowing_add(I128, I128): I128 * bool

42StLoc[6](loc1: bool)

43Pop

44MoveLoc[6](loc1: bool)

45Not

46BrFalse(48)

B9:

47Branch(52)

B10:

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

49Pop

50LdConst[26](u64: 9223..)

51Abort

B11:

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

53ImmBorrowFieldGeneric[17](Pool.fullsail_distribution_staked_liquidity: u128)

54ReadRef

55Call i128::from(u128): I128

56CopyLoc[1](Arg1: I128)

57Call i128::add(I128, I128): I128

58Call i128::as_u128(I128): u128

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

60MutBorrowFieldGeneric[17](Pool.fullsail_distribution_staked_liquidity: u128)

61WriteRef

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

63FreezeRef

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

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

66ImmBorrowFieldGeneric[17](Pool.fullsail_distribution_staked_liquidity: u128)

67ReadRef

68Pack[31](UpdateFullsailDistributionStakedLiquidityEvent)

69Call event::emit<UpdateFullsailDistributionStakedLiquidityEvent>(UpdateFullsailDistributionStakedLiquidityEvent)

70Branch(73)

B12:

71MoveLoc[4](Arg4: &Clock)

72Pop

B13:

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

74ImmBorrowFieldGeneric[7](Pool.tick_manager: TickManager)

75CopyLoc[2](Arg2: I32)

76Call tick::try_borrow_tick(&TickManager, I32): Option<Tick>

77StLoc[7](loc2: Option<Tick>)

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

79ImmBorrowFieldGeneric[7](Pool.tick_manager: TickManager)

80CopyLoc[3](Arg3: I32)

81Call tick::try_borrow_tick(&TickManager, I32): Option<Tick>

82StLoc[8](loc3: Option<Tick>)

83ImmBorrowLoc[7](loc2: Option<Tick>)

84Call option::is_some<Tick>(&Option<Tick>): bool

85BrFalse(92)

B14:

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

87MutBorrowFieldGeneric[7](Pool.tick_manager: TickManager)

88MoveLoc[2](Arg2: I32)

89CopyLoc[1](Arg1: I128)

90LdFalse

91Call tick::update_fullsail_stake(&mut TickManager, I32, I128, bool)

B15:

92ImmBorrowLoc[8](loc3: Option<Tick>)

93Call option::is_some<Tick>(&Option<Tick>): bool

94BrFalse(102)

B16:

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

96MutBorrowFieldGeneric[7](Pool.tick_manager: TickManager)

97MoveLoc[3](Arg3: I32)

98MoveLoc[1](Arg1: I128)

99LdTrue

100Call tick::update_fullsail_stake(&mut TickManager, I32, I128, bool)

101Branch(104)

B17:

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

103Pop

B18:

104Ret

}

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

B0:

0CopyLoc[0](Arg0: &GlobalConfig)

1Call config::checked_package_version(&GlobalConfig)

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

3ImmBorrowFieldGeneric[2](Pool.is_pause: bool)

4ReadRef

5Not

6BrFalse(8)

B1:

7Branch(16)

B2:

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

9Pop

10MoveLoc[0](Arg0: &GlobalConfig)

11Pop

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

13Pop

14LdConst[15](u64: 9283..)

15Abort

B3:

16MoveLoc[0](Arg0: &GlobalConfig)

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

18FreezeRef

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

20Call config::check_pool_manager_role(&GlobalConfig, address)

21CopyLoc[2](Arg2: String)

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

23MutBorrowFieldGeneric[5](Pool.url: String)

24WriteRef

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

26FreezeRef

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

28MoveLoc[2](Arg2: String)

29Pack[24](UpdatePoolUrlEvent)

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

31Ret

}

update_swap_result(Arg0: &mut SwapResult, Arg1: u64, Arg2: u64, Arg3: u64, Arg4: u64, Arg5: u64, Arg6: u64) {

B0:

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

1ImmBorrowField[21](SwapResult.amount_in: u64)

2ReadRef

3CopyLoc[1](Arg1: u64)

4Call math_u64::add_check(u64, u64): bool

5BrFalse(7)

B1:

6Branch(11)

B2:

7MoveLoc[0](Arg0: &mut SwapResult)

8Pop

9LdConst[9](u64: 9283..)

10Abort

B3:

11CopyLoc[0](Arg0: &mut SwapResult)

12ImmBorrowField[23](SwapResult.amount_out: u64)

13ReadRef

14CopyLoc[2](Arg2: u64)

15Call math_u64::add_check(u64, u64): bool

16BrFalse(18)

B4:

17Branch(22)

B5:

18MoveLoc[0](Arg0: &mut SwapResult)

19Pop

20LdConst[10](u64: 9328..)

21Abort

B6:

22CopyLoc[0](Arg0: &mut SwapResult)

23ImmBorrowField[25](SwapResult.fee_amount: u64)

24ReadRef

25CopyLoc[3](Arg3: u64)

26Call math_u64::add_check(u64, u64): bool

27BrFalse(29)

B7:

28Branch(33)

B8:

29MoveLoc[0](Arg0: &mut SwapResult)

30Pop

31LdConst[11](u64: 9860..)

32Abort

B9:

33CopyLoc[0](Arg0: &mut SwapResult)

34ImmBorrowField[21](SwapResult.amount_in: u64)

35ReadRef

36MoveLoc[1](Arg1: u64)

37Add

38CopyLoc[0](Arg0: &mut SwapResult)

39MutBorrowField[21](SwapResult.amount_in: u64)

40WriteRef

41CopyLoc[0](Arg0: &mut SwapResult)

42ImmBorrowField[23](SwapResult.amount_out: u64)

43ReadRef

44MoveLoc[2](Arg2: u64)

45Add

46CopyLoc[0](Arg0: &mut SwapResult)

47MutBorrowField[23](SwapResult.amount_out: u64)

48WriteRef

49CopyLoc[0](Arg0: &mut SwapResult)

50ImmBorrowField[25](SwapResult.fee_amount: u64)

51ReadRef

52MoveLoc[3](Arg3: u64)

53Add

54CopyLoc[0](Arg0: &mut SwapResult)

55MutBorrowField[25](SwapResult.fee_amount: u64)

56WriteRef

57CopyLoc[0](Arg0: &mut SwapResult)

58ImmBorrowField[29](SwapResult.protocol_fee_amount: u64)

59ReadRef

60MoveLoc[4](Arg4: u64)

61Add

62CopyLoc[0](Arg0: &mut SwapResult)

63MutBorrowField[29](SwapResult.protocol_fee_amount: u64)

64WriteRef

65CopyLoc[0](Arg0: &mut SwapResult)

66ImmBorrowField[27](SwapResult.gauge_fee_amount: u64)

67ReadRef

68MoveLoc[6](Arg6: u64)

69Add

70CopyLoc[0](Arg0: &mut SwapResult)

71MutBorrowField[27](SwapResult.gauge_fee_amount: u64)

72WriteRef

73CopyLoc[0](Arg0: &mut SwapResult)

74ImmBorrowField[31](SwapResult.ref_fee_amount: u64)

75ReadRef

76MoveLoc[5](Arg5: u64)

77Add

78CopyLoc[0](Arg0: &mut SwapResult)

79MutBorrowField[31](SwapResult.ref_fee_amount: u64)

80WriteRef

81CopyLoc[0](Arg0: &mut SwapResult)

82ImmBorrowField[44](SwapResult.steps: u64)

83ReadRef

84LdU64(1)

85Add

86MoveLoc[0](Arg0: &mut SwapResult)

87MutBorrowField[44](SwapResult.steps: u64)

88WriteRef

89Ret

}

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

L4: loc0: bool

L5: loc1: UpdateUnstakedLiquidityFeeRateEvent

B0:

0CopyLoc[0](Arg0: &GlobalConfig)

1Call config::checked_package_version(&GlobalConfig)

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

3ImmBorrowFieldGeneric[2](Pool.is_pause: bool)

4ReadRef

5Not

6BrFalse(8)

B1:

7Branch(16)

B2:

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

9Pop

10MoveLoc[0](Arg0: &GlobalConfig)

11Pop

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

13Pop

14LdConst[15](u64: 9283..)

15Abort

B3:

16CopyLoc[2](Arg2: u64)

17Call config::default_unstaked_fee_rate(): u64

18Eq

19BrFalse(23)

B4:

20LdTrue

21StLoc[4](loc0: bool)

22Branch(27)

B5:

23CopyLoc[2](Arg2: u64)

24Call config::max_unstaked_liquidity_fee_rate(): u64

25Le

26StLoc[4](loc0: bool)

B6:

27MoveLoc[4](loc0: bool)

28BrFalse(30)

B7:

29Branch(38)

B8:

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

31Pop

32MoveLoc[0](Arg0: &GlobalConfig)

33Pop

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

35Pop

36LdConst[12](u64: 9239..)

37Abort

B9:

38CopyLoc[2](Arg2: u64)

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

40ImmBorrowFieldGeneric[0](Pool.unstaked_liquidity_fee_rate: u64)

41ReadRef

42Neq

43BrFalse(45)

B10:

44Branch(53)

B11:

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

46Pop

47MoveLoc[0](Arg0: &GlobalConfig)

48Pop

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

50Pop

51LdConst[12](u64: 9239..)

52Abort

B12:

53MoveLoc[0](Arg0: &GlobalConfig)

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

55FreezeRef

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

57Call config::check_pool_manager_role(&GlobalConfig, address)

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

59FreezeRef

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

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

62ImmBorrowFieldGeneric[0](Pool.unstaked_liquidity_fee_rate: u64)

63ReadRef

64CopyLoc[2](Arg2: u64)

65Pack[23](UpdateUnstakedLiquidityFeeRateEvent)

66StLoc[5](loc1: UpdateUnstakedLiquidityFeeRateEvent)

67MoveLoc[2](Arg2: u64)

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

69MutBorrowFieldGeneric[0](Pool.unstaked_liquidity_fee_rate: u64)

70WriteRef

71MoveLoc[5](loc1: UpdateUnstakedLiquidityFeeRateEvent)

72Call event::emit<UpdateUnstakedLiquidityFeeRateEvent>(UpdateUnstakedLiquidityFeeRateEvent)

73Ret

}

public url<Ty0, Ty1>(Arg0: &Pool<Ty0, Ty1>): String {

B0:

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

1ImmBorrowFieldGeneric[5](Pool.url: String)

2ReadRef

3Ret

}

validate_pool_position<Ty0, Ty1>(Arg0: &Pool<Ty0, Ty1>, Arg1: &Position) {

B0:

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

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

2MoveLoc[1](Arg1: &Position)

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

4Eq

5BrFalse(7)

B1:

6Branch(9)

B2:

7LdConst[24](u64: 9223..)

8Abort

B3:

9Ret

}

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

L3: loc0: u128

B0:

0CopyLoc[1](Arg1: &GlobalConfig)

1Call config::checked_package_version(&GlobalConfig)

2MoveLoc[1](Arg1: &GlobalConfig)

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

4FreezeRef

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

6Call config::check_pool_manager_role(&GlobalConfig, address)

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

8ImmBorrowFieldGeneric[7](Pool.tick_manager: TickManager)

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

10ImmBorrowFieldGeneric[8](Pool.current_tick_index: I32)

11ReadRef

12Call tick::calc_current_liquidity(&TickManager, I32): u128 * u128

13StLoc[3](loc0: u128)

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

15ImmBorrowFieldGeneric[3](Pool.liquidity: u128)

16ReadRef

17Eq

18BrFalse(20)

B1:

19Branch(24)

B2:

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

21Pop

22LdConst[35](u64: 2054..)

23Abort

B3:

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

25FreezeRef

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

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

28ImmBorrowFieldGeneric[17](Pool.fullsail_distribution_staked_liquidity: u128)

29ReadRef

30CopyLoc[3](loc0: u128)

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

32ImmBorrowFieldGeneric[3](Pool.liquidity: u128)

33ReadRef

34Pack[32](RestoreStakedLiquidityEvent)

35Call event::emit<RestoreStakedLiquidityEvent>(RestoreStakedLiquidityEvent)

36MoveLoc[3](loc0: u128)

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

38MutBorrowFieldGeneric[17](Pool.fullsail_distribution_staked_liquidity: u128)

39WriteRef

40Ret

}

Constants [

1 => vector<u8>: "Patent pending - U.S. Patent Application No. 63/861,982" // interpreted as UTF8 string

2 => u128: 18446744073709551616

3 => u64: 923603470923486023

4 => u64: 934264306820934862

5 => u64: 9843325239567326443

6 => u64: 932860927360234786

7 => u64: 923946802368230946

8 => u64: 894506706118488600

9 => u64: 928346890236709234

10 => u64: 932847098437837467

11 => u64: 986092346024366377

12 => u64: 923949369432090349

13 => u64: 923968203463984585

14 => u64: 983406230673426324

15 => u64: 928340672346982340

16 => u64: 923860238604780344

17 => u64: 928346702740340762

18 => u64: 943963409693460349

19 => u64: 983960239692604363

20 => u64: 934962834703470457

21 => u64: 929345720697230670

22 => u64: 920792045376347233

23 => u64: 920354934523526751

24 => u64: 922337380638130175

25 => u64: 922337894745715507

26 => u64: 922337903335787727

27 => u64: 922337929534950604

28 => u64: 922337935547904819

29 => u64: 922337820442781286

30 => u64: 922337673984396492

31 => u64: 922337902476656639

32 => u64: 932630496306302321

33 => u64: 169617512974258300

34 => u64: 272018139339630820

35 => u64: 20546486390749852

36 => address: 0x0000000000000000000000000000000000000000000000000000000000000000

37 => vector<u8>: "name" // interpreted as UTF8 string

38 => vector<u8>: "coin_a" // interpreted as UTF8 string

39 => vector<u8>: "coin_b" // interpreted as UTF8 string

40 => vector<u8>: "link" // interpreted as UTF8 string

41 => vector<u8>: "image_url" // interpreted as UTF8 string

42 => vector<u8>: "description" // interpreted as UTF8 string

43 => vector<u8>: "project_url" // interpreted as UTF8 string

44 => vector<u8>: "creator" // interpreted as UTF8 string

]

}