tick
Module0x67b3…928a
- Move path
- 0x3492…c267::tick
- Functions
- 2012 public, 0 entry
- Structs
- 2
- Friend modules
- pool
tick
Bytecode640 lines
The on-chain disassembly. Offsets are bytecode positions within each function.
// Move bytecode v6
module 3492c874c1e3b3e2984e8c41b589e642d4d0a5d6459e5a9cfc2d52fd7c89c267.tick {
use 3492c874c1e3b3e2984e8c41b589e642d4d0a5d6459e5a9cfc2d52fd7c89c267::i128H;
use 3492c874c1e3b3e2984e8c41b589e642d4d0a5d6459e5a9cfc2d52fd7c89c267::i32H;
use 3492c874c1e3b3e2984e8c41b589e642d4d0a5d6459e5a9cfc2d52fd7c89c267::i64H;
use 3492c874c1e3b3e2984e8c41b589e642d4d0a5d6459e5a9cfc2d52fd7c89c267::tick_math;
use 3492c874c1e3b3e2984e8c41b589e642d4d0a5d6459e5a9cfc2d52fd7c89c267::utils;
use 03637b7b60978ef4389124f7683456f0050ab015a0590d52b6e6cadb342af34a::i32;
use 03637b7b60978ef4389124f7683456f0050ab015a0590d52b6e6cadb342af34a::math_u128;
use 714a63a0dba6da4f017b42d5d0fb78867f18bcde904868e51d951a5a6f5b7f57::i128;
use 714a63a0dba6da4f017b42d5d0fb78867f18bcde904868e51d951a5a6f5b7f57::i32 as 0i32;
use 714a63a0dba6da4f017b42d5d0fb78867f18bcde904868e51d951a5a6f5b7f57::i64;
use 0000000000000000000000000000000000000000000000000000000000000002::object;
use 0000000000000000000000000000000000000000000000000000000000000002::table;
use 0000000000000000000000000000000000000000000000000000000000000002::tx_context;
struct TickManager has store {
tick_spacing: u32,
ticks: Table<I32, TickInfo>,
bitmap: Table<I32, u256>
}
struct TickInfo has copy, drop, store {
index: I32,
sqrt_price: u128,
liquidity_gross: u128,
liquidity_net: I128,
fee_growth_outside_a: u128,
fee_growth_outside_b: u128,
tick_cumulative_out_side: I64,
seconds_per_liquidity_out_side: u256,
seconds_out_side: u64,
reward_growths_outside: vector<u128>
}
public(friend) initialize_manager(Arg0: u32, Arg1: &mut TxContext): TickManager {
B0:
0MoveLoc[0](Arg0: u32)
1CopyLoc[1](Arg1: &mut TxContext)
2Call table::new<I32, TickInfo>(&mut TxContext): Table<I32, TickInfo>
3MoveLoc[1](Arg1: &mut TxContext)
4Call table::new<I32, u256>(&mut TxContext): Table<I32, u256>
5Pack[0](TickManager)
6Ret
}
public(friend) update(Arg0: &mut TickManager, Arg1: ID, Arg2: I32, Arg3: I32, Arg4: I128, Arg5: u128, Arg6: u128, Arg7: vector<u128>, Arg8: I64, Arg9: u256, Arg10: u64, Arg11: bool): bool {
L12: loc0: I128
L13: loc1: u64
L14: loc2: u128
L15: loc3: I32
L16: loc4: I32
L17: loc5: u128
L18: loc6: &mut TickInfo
B0:
0MoveLoc[0](Arg0: &mut TickManager)
1MutBorrowField[0](TickManager.ticks: Table<I32, TickInfo>)
2CopyLoc[2](Arg2: I32)
3Call get_mutable_tick_from_table(&mut Table<I32, TickInfo>, I32): &mut TickInfo
4StLoc[18](loc6: &mut TickInfo)
5CopyLoc[18](loc6: &mut TickInfo)
6ImmBorrowField[1](TickInfo.liquidity_gross: u128)
7ReadRef
8StLoc[14](loc2: u128)
9CopyLoc[14](loc2: u128)
10CopyLoc[4](Arg4: I128)
11Call utils::add_delta(u128, I128): u128
12StLoc[17](loc5: u128)
13MoveLoc[3](Arg3: I32)
14Call i32H::mate_to_lib(I32): I32
15StLoc[16](loc4: I32)
16MoveLoc[2](Arg2: I32)
17Call i32H::mate_to_lib(I32): I32
18StLoc[15](loc3: I32)
19CopyLoc[14](loc2: u128)
20LdU128(0)
21Eq
22BrFalse(69)
B1:
23MoveLoc[15](loc3: I32)
24MoveLoc[16](loc4: I32)
25Call i32::lte(I32, I32): bool
26BrFalse(52)
B2:
27MoveLoc[5](Arg5: u128)
28CopyLoc[18](loc6: &mut TickInfo)
29MutBorrowField[2](TickInfo.fee_growth_outside_a: u128)
30WriteRef
31MoveLoc[6](Arg6: u128)
32CopyLoc[18](loc6: &mut TickInfo)
33MutBorrowField[3](TickInfo.fee_growth_outside_b: u128)
34WriteRef
35MoveLoc[9](Arg9: u256)
36CopyLoc[18](loc6: &mut TickInfo)
37MutBorrowField[4](TickInfo.seconds_per_liquidity_out_side: u256)
38WriteRef
39MoveLoc[8](Arg8: I64)
40CopyLoc[18](loc6: &mut TickInfo)
41MutBorrowField[5](TickInfo.tick_cumulative_out_side: I64)
42WriteRef
43MoveLoc[10](Arg10: u64)
44CopyLoc[18](loc6: &mut TickInfo)
45MutBorrowField[6](TickInfo.seconds_out_side: u64)
46WriteRef
47MoveLoc[7](Arg7: vector<u128>)
48CopyLoc[18](loc6: &mut TickInfo)
49MutBorrowField[7](TickInfo.reward_growths_outside: vector<u128>)
50WriteRef
51Branch(69)
B3:
52LdU64(0)
53StLoc[13](loc1: u64)
B4:
54CopyLoc[13](loc1: u64)
55ImmBorrowLoc[7](Arg7: vector<u128>)
56VecLen(12)
57Lt
58BrFalse(69)
B5:
59Branch(60)
B6:
60CopyLoc[18](loc6: &mut TickInfo)
61MutBorrowField[7](TickInfo.reward_growths_outside: vector<u128>)
62LdU128(0)
63VecPushBack(12)
64MoveLoc[13](loc1: u64)
65LdU64(1)
66Add
67StLoc[13](loc1: u64)
68Branch(54)
B7:
69CopyLoc[17](loc5: u128)
70CopyLoc[18](loc6: &mut TickInfo)
71MutBorrowField[1](TickInfo.liquidity_gross: u128)
72WriteRef
73MoveLoc[11](Arg11: bool)
74BrFalse(82)
B8:
75CopyLoc[18](loc6: &mut TickInfo)
76ImmBorrowField[8](TickInfo.liquidity_net: I128)
77ReadRef
78MoveLoc[4](Arg4: I128)
79Call i128H::sub(I128, I128): I128
80StLoc[12](loc0: I128)
81Branch(88)
B9:
82CopyLoc[18](loc6: &mut TickInfo)
83ImmBorrowField[8](TickInfo.liquidity_net: I128)
84ReadRef
85MoveLoc[4](Arg4: I128)
86Call i128H::add(I128, I128): I128
87StLoc[12](loc0: I128)
B10:
88MoveLoc[12](loc0: I128)
89MoveLoc[18](loc6: &mut TickInfo)
90MutBorrowField[8](TickInfo.liquidity_net: I128)
91WriteRef
92MoveLoc[17](loc5: u128)
93LdU128(0)
94Eq
95MoveLoc[14](loc2: u128)
96LdU128(0)
97Eq
98Neq
99Ret
}
public(friend) cross(Arg0: &mut TickManager, Arg1: I32, Arg2: u128, Arg3: u128, Arg4: vector<u128>, Arg5: I64, Arg6: u256, Arg7: u64): I128 {
L8: loc0: &mut TickInfo
B0:
0MoveLoc[0](Arg0: &mut TickManager)
1MoveLoc[1](Arg1: I32)
2Call get_mutable_tick_from_manager(&mut TickManager, I32): &mut TickInfo
3StLoc[8](loc0: &mut TickInfo)
4MoveLoc[2](Arg2: u128)
5CopyLoc[8](loc0: &mut TickInfo)
6ImmBorrowField[2](TickInfo.fee_growth_outside_a: u128)
7ReadRef
8Call math_u128::wrapping_sub(u128, u128): u128
9CopyLoc[8](loc0: &mut TickInfo)
10MutBorrowField[2](TickInfo.fee_growth_outside_a: u128)
11WriteRef
12MoveLoc[3](Arg3: u128)
13CopyLoc[8](loc0: &mut TickInfo)
14ImmBorrowField[3](TickInfo.fee_growth_outside_b: u128)
15ReadRef
16Call math_u128::wrapping_sub(u128, u128): u128
17CopyLoc[8](loc0: &mut TickInfo)
18MutBorrowField[3](TickInfo.fee_growth_outside_b: u128)
19WriteRef
20MoveLoc[4](Arg4: vector<u128>)
21CopyLoc[8](loc0: &mut TickInfo)
22ImmBorrowField[7](TickInfo.reward_growths_outside: vector<u128>)
23ReadRef
24Call compute_reward_growths(vector<u128>, vector<u128>): vector<u128>
25CopyLoc[8](loc0: &mut TickInfo)
26MutBorrowField[7](TickInfo.reward_growths_outside: vector<u128>)
27WriteRef
28MoveLoc[6](Arg6: u256)
29CopyLoc[8](loc0: &mut TickInfo)
30ImmBorrowField[4](TickInfo.seconds_per_liquidity_out_side: u256)
31ReadRef
32Sub
33CopyLoc[8](loc0: &mut TickInfo)
34MutBorrowField[4](TickInfo.seconds_per_liquidity_out_side: u256)
35WriteRef
36MoveLoc[5](Arg5: I64)
37CopyLoc[8](loc0: &mut TickInfo)
38ImmBorrowField[5](TickInfo.tick_cumulative_out_side: I64)
39ReadRef
40Call i64H::sub(I64, I64): I64
41CopyLoc[8](loc0: &mut TickInfo)
42MutBorrowField[5](TickInfo.tick_cumulative_out_side: I64)
43WriteRef
44MoveLoc[7](Arg7: u64)
45CopyLoc[8](loc0: &mut TickInfo)
46ImmBorrowField[6](TickInfo.seconds_out_side: u64)
47ReadRef
48Sub
49CopyLoc[8](loc0: &mut TickInfo)
50MutBorrowField[6](TickInfo.seconds_out_side: u64)
51WriteRef
52MoveLoc[8](loc0: &mut TickInfo)
53ImmBorrowField[8](TickInfo.liquidity_net: I128)
54ReadRef
55Ret
}
public(friend) get_mutable_tick_from_table(Arg0: &mut Table<I32, TickInfo>, Arg1: I32): &mut TickInfo {
L2: loc0: I32
B0:
0CopyLoc[0](Arg0: &mut Table<I32, TickInfo>)
1CopyLoc[1](Arg1: I32)
2StLoc[2](loc0: I32)
3FreezeRef
4MoveLoc[2](loc0: I32)
5Call table::contains<I32, TickInfo>(&Table<I32, TickInfo>, I32): bool
6Not
7BrFalse(13)
B1:
8CopyLoc[0](Arg0: &mut Table<I32, TickInfo>)
9CopyLoc[1](Arg1: I32)
10CopyLoc[1](Arg1: I32)
11Call create_tick(I32): TickInfo
12Call table::add<I32, TickInfo>(&mut Table<I32, TickInfo>, I32, TickInfo)
B2:
13MoveLoc[0](Arg0: &mut Table<I32, TickInfo>)
14MoveLoc[1](Arg1: I32)
15Call table::borrow_mut<I32, TickInfo>(&mut Table<I32, TickInfo>, I32): &mut TickInfo
16Ret
}
public(friend) get_mutable_tick_from_manager(Arg0: &mut TickManager, Arg1: I32): &mut TickInfo {
B0:
0MoveLoc[0](Arg0: &mut TickManager)
1MutBorrowField[0](TickManager.ticks: Table<I32, TickInfo>)
2MoveLoc[1](Arg1: I32)
3Call get_mutable_tick_from_table(&mut Table<I32, TickInfo>, I32): &mut TickInfo
4Ret
}
public get_tick_from_table(Arg0: &Table<I32, TickInfo>, Arg1: I32): &TickInfo {
B0:
0MoveLoc[0](Arg0: &Table<I32, TickInfo>)
1MoveLoc[1](Arg1: I32)
2Call table::borrow<I32, TickInfo>(&Table<I32, TickInfo>, I32): &TickInfo
3Ret
}
public get_tick_from_manager(Arg0: &TickManager, Arg1: I32): &TickInfo {
B0:
0MoveLoc[0](Arg0: &TickManager)
1ImmBorrowField[0](TickManager.ticks: Table<I32, TickInfo>)
2MoveLoc[1](Arg1: I32)
3Call get_tick_from_table(&Table<I32, TickInfo>, I32): &TickInfo
4Ret
}
public sqrt_price(Arg0: &TickInfo): u128 {
B0:
0MoveLoc[0](Arg0: &TickInfo)
1ImmBorrowField[9](TickInfo.sqrt_price: u128)
2ReadRef
3Ret
}
public create_tick(Arg0: I32): TickInfo {
B0:
0CopyLoc[0](Arg0: I32)
1MoveLoc[0](Arg0: I32)
2Call tick_math::get_sqrt_price_at_tick(I32): u128
3LdU128(0)
4Call i128::zero(): I128
5LdU128(0)
6LdU128(0)
7Call i64::zero(): I64
8LdU256(0)
9LdU64(0)
10VecPack(12, 0)
11Pack[1](TickInfo)
12Ret
}
public liquidity_gross(Arg0: &TickInfo): u128 {
B0:
0MoveLoc[0](Arg0: &TickInfo)
1ImmBorrowField[1](TickInfo.liquidity_gross: u128)
2ReadRef
3Ret
}
public liquidity_net(Arg0: &TickInfo): I128 {
B0:
0MoveLoc[0](Arg0: &TickInfo)
1ImmBorrowField[8](TickInfo.liquidity_net: I128)
2ReadRef
3Ret
}
public tick_spacing(Arg0: &TickManager): u32 {
B0:
0MoveLoc[0](Arg0: &TickManager)
1ImmBorrowField[10](TickManager.tick_spacing: u32)
2ReadRef
3Ret
}
public get_fee_and_reward_growths_inside(Arg0: &TickManager, Arg1: I32, Arg2: I32, Arg3: I32, Arg4: u128, Arg5: u128, Arg6: vector<u128>): u128 * u128 * vector<u128> {
L7: loc0: u128
L8: loc1: u128
L9: loc2: vector<u128>
L10: loc3: u128
L11: loc4: u128
L12: loc5: vector<u128>
L13: loc6: u128
L14: loc7: u128
L15: loc8: u128
L16: loc9: u128
L17: loc10: I32
L18: loc11: I32
L19: loc12: I32
L20: loc13: u128
L21: loc14: u128
L22: loc15: vector<u128>
L23: loc16: vector<u128>
L24: loc17: vector<u128>
L25: loc18: u128
L26: loc19: u128
L27: loc20: vector<u128>
B0:
0CopyLoc[0](Arg0: &TickManager)
1CopyLoc[1](Arg1: I32)
2Call get_fee_and_reward_growths_outside(&TickManager, I32): u128 * u128 * vector<u128>
3StLoc[22](loc15: vector<u128>)
4StLoc[21](loc14: u128)
5StLoc[20](loc13: u128)
6MoveLoc[0](Arg0: &TickManager)
7CopyLoc[2](Arg2: I32)
8Call get_fee_and_reward_growths_outside(&TickManager, I32): u128 * u128 * vector<u128>
9StLoc[27](loc20: vector<u128>)
10StLoc[26](loc19: u128)
11StLoc[25](loc18: u128)
12MoveLoc[3](Arg3: I32)
13Call i32H::mate_to_lib(I32): I32
14StLoc[17](loc10: I32)
15MoveLoc[1](Arg1: I32)
16Call i32H::mate_to_lib(I32): I32
17StLoc[18](loc11: I32)
18MoveLoc[2](Arg2: I32)
19Call i32H::mate_to_lib(I32): I32
20StLoc[19](loc12: I32)
21CopyLoc[17](loc10: I32)
22MoveLoc[18](loc11: I32)
23Call i32::gte(I32, I32): bool
24BrFalse(32)
B1:
25MoveLoc[20](loc13: u128)
26MoveLoc[21](loc14: u128)
27MoveLoc[22](loc15: vector<u128>)
28StLoc[9](loc2: vector<u128>)
29StLoc[8](loc1: u128)
30StLoc[7](loc0: u128)
31Branch(44)
B2:
32CopyLoc[4](Arg4: u128)
33MoveLoc[20](loc13: u128)
34Call math_u128::wrapping_sub(u128, u128): u128
35CopyLoc[5](Arg5: u128)
36MoveLoc[21](loc14: u128)
37Call math_u128::wrapping_sub(u128, u128): u128
38CopyLoc[6](Arg6: vector<u128>)
39MoveLoc[22](loc15: vector<u128>)
40Call compute_reward_growths(vector<u128>, vector<u128>): vector<u128>
41StLoc[9](loc2: vector<u128>)
42StLoc[8](loc1: u128)
43StLoc[7](loc0: u128)
B3:
44MoveLoc[7](loc0: u128)
45MoveLoc[8](loc1: u128)
46MoveLoc[9](loc2: vector<u128>)
47StLoc[24](loc17: vector<u128>)
48StLoc[16](loc9: u128)
49StLoc[15](loc8: u128)
50MoveLoc[17](loc10: I32)
51MoveLoc[19](loc12: I32)
52Call i32::lt(I32, I32): bool
53BrFalse(61)
B4:
54MoveLoc[25](loc18: u128)
55MoveLoc[26](loc19: u128)
56MoveLoc[27](loc20: vector<u128>)
57StLoc[12](loc5: vector<u128>)
58StLoc[11](loc4: u128)
59StLoc[10](loc3: u128)
60Branch(73)
B5:
61CopyLoc[4](Arg4: u128)
62MoveLoc[25](loc18: u128)
63Call math_u128::wrapping_sub(u128, u128): u128
64CopyLoc[5](Arg5: u128)
65MoveLoc[26](loc19: u128)
66Call math_u128::wrapping_sub(u128, u128): u128
67CopyLoc[6](Arg6: vector<u128>)
68MoveLoc[27](loc20: vector<u128>)
69Call compute_reward_growths(vector<u128>, vector<u128>): vector<u128>
70StLoc[12](loc5: vector<u128>)
71StLoc[11](loc4: u128)
72StLoc[10](loc3: u128)
B6:
73MoveLoc[10](loc3: u128)
74MoveLoc[11](loc4: u128)
75MoveLoc[12](loc5: vector<u128>)
76StLoc[23](loc16: vector<u128>)
77StLoc[14](loc7: u128)
78StLoc[13](loc6: u128)
79MoveLoc[4](Arg4: u128)
80MoveLoc[15](loc8: u128)
81Call math_u128::wrapping_sub(u128, u128): u128
82MoveLoc[13](loc6: u128)
83Call math_u128::wrapping_sub(u128, u128): u128
84MoveLoc[5](Arg5: u128)
85MoveLoc[16](loc9: u128)
86Call math_u128::wrapping_sub(u128, u128): u128
87MoveLoc[14](loc7: u128)
88Call math_u128::wrapping_sub(u128, u128): u128
89MoveLoc[6](Arg6: vector<u128>)
90MoveLoc[24](loc17: vector<u128>)
91Call compute_reward_growths(vector<u128>, vector<u128>): vector<u128>
92MoveLoc[23](loc16: vector<u128>)
93Call compute_reward_growths(vector<u128>, vector<u128>): vector<u128>
94Ret
}
public get_fee_and_reward_growths_outside(Arg0: &TickManager, Arg1: I32): u128 * u128 * vector<u128> {
L2: loc0: u128
L3: loc1: u128
L4: loc2: vector<u128>
L5: loc3: &TickInfo
B0:
0CopyLoc[0](Arg0: &TickManager)
1CopyLoc[1](Arg1: I32)
2Call is_tick_initialized(&TickManager, I32): bool
3Not
4BrFalse(14)
B1:
5MoveLoc[0](Arg0: &TickManager)
6Pop
7LdU128(0)
8LdU128(0)
9VecPack(12, 0)
10StLoc[4](loc2: vector<u128>)
11StLoc[3](loc1: u128)
12StLoc[2](loc0: u128)
13Branch(31)
B2:
14MoveLoc[0](Arg0: &TickManager)
15ImmBorrowField[0](TickManager.ticks: Table<I32, TickInfo>)
16MoveLoc[1](Arg1: I32)
17Call table::borrow<I32, TickInfo>(&Table<I32, TickInfo>, I32): &TickInfo
18StLoc[5](loc3: &TickInfo)
19CopyLoc[5](loc3: &TickInfo)
20ImmBorrowField[2](TickInfo.fee_growth_outside_a: u128)
21ReadRef
22CopyLoc[5](loc3: &TickInfo)
23ImmBorrowField[3](TickInfo.fee_growth_outside_b: u128)
24ReadRef
25MoveLoc[5](loc3: &TickInfo)
26ImmBorrowField[7](TickInfo.reward_growths_outside: vector<u128>)
27ReadRef
28StLoc[4](loc2: vector<u128>)
29StLoc[3](loc1: u128)
30StLoc[2](loc0: u128)
B3:
31MoveLoc[2](loc0: u128)
32MoveLoc[3](loc1: u128)
33MoveLoc[4](loc2: vector<u128>)
34Ret
}
public is_tick_initialized(Arg0: &TickManager, Arg1: I32): bool {
B0:
0MoveLoc[0](Arg0: &TickManager)
1ImmBorrowField[0](TickManager.ticks: Table<I32, TickInfo>)
2MoveLoc[1](Arg1: I32)
3Call table::contains<I32, TickInfo>(&Table<I32, TickInfo>, I32): bool
4Ret
}
public bitmap(Arg0: &TickManager): &Table<I32, u256> {
B0:
0MoveLoc[0](Arg0: &TickManager)
1ImmBorrowField[11](TickManager.bitmap: Table<I32, u256>)
2Ret
}
public fetch_provided_ticks(Arg0: &TickManager, Arg1: vector<u32>): vector<TickInfo> {
L2: loc0: u64
L3: loc1: u64
L4: loc2: I32
L5: loc3: vector<TickInfo>
B0:
0LdU64(0)
1StLoc[3](loc1: u64)
2ImmBorrowLoc[1](Arg1: vector<u32>)
3VecLen(16)
4StLoc[2](loc0: u64)
5VecPack(14, 0)
6StLoc[5](loc3: vector<TickInfo>)
B1:
7CopyLoc[3](loc1: u64)
8CopyLoc[2](loc0: u64)
9Lt
10BrFalse(33)
B2:
11Branch(12)
B3:
12ImmBorrowLoc[1](Arg1: vector<u32>)
13CopyLoc[3](loc1: u64)
14VecImmBorrow(16)
15ReadRef
16Call 0i32::from_u32(u32): I32
17StLoc[4](loc2: I32)
18CopyLoc[0](Arg0: &TickManager)
19CopyLoc[4](loc2: I32)
20Call is_tick_initialized(&TickManager, I32): bool
21BrFalse(28)
B4:
22MutBorrowLoc[5](loc3: vector<TickInfo>)
23CopyLoc[0](Arg0: &TickManager)
24MoveLoc[4](loc2: I32)
25Call get_tick_from_manager(&TickManager, I32): &TickInfo
26ReadRef
27VecPushBack(14)
B5:
28MoveLoc[3](loc1: u64)
29LdU64(1)
30Add
31StLoc[3](loc1: u64)
32Branch(7)
B6:
33MoveLoc[0](Arg0: &TickManager)
34Pop
35MoveLoc[5](loc3: vector<TickInfo>)
36Ret
}
public(friend) mutable_bitmap(Arg0: &mut TickManager): &mut Table<I32, u256> {
B0:
0MoveLoc[0](Arg0: &mut TickManager)
1MutBorrowField[11](TickManager.bitmap: Table<I32, u256>)
2Ret
}
public(friend) remove(Arg0: &mut TickManager, Arg1: I32) {
B0:
0MoveLoc[0](Arg0: &mut TickManager)
1MutBorrowField[0](TickManager.ticks: Table<I32, TickInfo>)
2MoveLoc[1](Arg1: I32)
3Call table::remove<I32, TickInfo>(&mut Table<I32, TickInfo>, I32): TickInfo
4Pop
5Ret
}
compute_reward_growths(Arg0: vector<u128>, Arg1: vector<u128>): vector<u128> {
L2: loc0: u128
L3: loc1: u64
L4: loc2: vector<u128>
L5: loc3: u128
B0:
0LdU64(0)
1StLoc[3](loc1: u64)
2VecPack(12, 0)
3StLoc[4](loc2: vector<u128>)
B1:
4CopyLoc[3](loc1: u64)
5ImmBorrowLoc[0](Arg0: vector<u128>)
6VecLen(12)
7Lt
8BrFalse(38)
B2:
9Branch(10)
B3:
10CopyLoc[3](loc1: u64)
11ImmBorrowLoc[1](Arg1: vector<u128>)
12VecLen(12)
13Ge
14BrFalse(18)
B4:
15LdU128(0)
16StLoc[2](loc0: u128)
17Branch(23)
B5:
18ImmBorrowLoc[1](Arg1: vector<u128>)
19CopyLoc[3](loc1: u64)
20VecImmBorrow(12)
21ReadRef
22StLoc[2](loc0: u128)
B6:
23MoveLoc[2](loc0: u128)
24StLoc[5](loc3: u128)
25MutBorrowLoc[4](loc2: vector<u128>)
26ImmBorrowLoc[0](Arg0: vector<u128>)
27CopyLoc[3](loc1: u64)
28VecImmBorrow(12)
29ReadRef
30MoveLoc[5](loc3: u128)
31Call math_u128::wrapping_sub(u128, u128): u128
32VecPushBack(12)
33MoveLoc[3](loc1: u64)
34LdU64(1)
35Add
36StLoc[3](loc1: u64)
37Branch(4)
B7:
38MoveLoc[4](loc2: vector<u128>)
39Ret
}
}