bottle

Module0x2153…d9ba

Move path: 0x2153…d9ba::bottle
Functions: 3715 public, 0 entry
Structs: 2
Friend modules: bucket

bottle

Bytecode1293 lines

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

// Move bytecode v6

module 21535b1dd8d3285dc8486394a9f8c6173c1934185dd8a4c1c194036aaba6d9ba.bottle {

use 00db9a10bb9536ab367b7d1ffa404c1d6c55f009076df1139dc108dd86608bbe::linked_table;

use 00db9a10bb9536ab367b7d1ffa404c1d6c55f009076df1139dc108dd86608bbe::math;

use 0336be2a5fbdb2cce40356139c85fdda55d8fd35301ac204fb900a656ac7eaa5::bucket_oracle;

use 21535b1dd8d3285dc8486394a9f8c6173c1934185dd8a4c1c194036aaba6d9ba::constants;

use 0000000000000000000000000000000000000000000000000000000000000001::option;

use 0000000000000000000000000000000000000000000000000000000000000002::clock;

use 0000000000000000000000000000000000000000000000000000000000000002::math as 0math;

use 0000000000000000000000000000000000000000000000000000000000000002::object;

use 0000000000000000000000000000000000000000000000000000000000000002::tx_context;

struct BottleTable has store, key {

id: UID,

table: LinkedTable<address, Bottle>,

total_stake: u64,

total_stake_snapshot: u64,

total_collateral_snapshot: u64,

debt_per_unit_stake: u128,

reward_per_unit_stake: u128,

last_reward_error: u128,

last_debt_error: u128

}

struct Bottle has store, key {

id: UID,

collateral_amount: u64,

buck_amount: u64,

stake_amount: u64,

reward_coll_snapshot: u128,

reward_debt_snapshot: u128

}

public(friend) new(Arg0: &BottleTable, Arg1: &mut TxContext): Bottle {

B0:

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

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

2LdU64(0)

3LdU64(0)

4LdU64(0)

5CopyLoc[0](Arg0: &BottleTable)

6ImmBorrowField[0](BottleTable.reward_per_unit_stake: u128)

7ReadRef

8MoveLoc[0](Arg0: &BottleTable)

9ImmBorrowField[1](BottleTable.debt_per_unit_stake: u128)

10ReadRef

11Pack[1](Bottle)

12Ret

}

public(friend) new_table(Arg0: &mut TxContext): BottleTable {

B0:

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

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

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

3Call linked_table::new<address, Bottle>(&mut TxContext): LinkedTable<address, Bottle>

4LdU64(0)

5LdU64(0)

6LdU64(0)

7LdU128(0)

8LdU128(0)

9LdU128(0)

10LdU128(0)

11Pack[0](BottleTable)

12Ret

}

public(friend) record_borrow(Arg0: &mut Bottle, Arg1: u64, Arg2: u64) {

B0:

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

1ImmBorrowField[2](Bottle.collateral_amount: u64)

2ReadRef

3MoveLoc[1](Arg1: u64)

4Add

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

6MutBorrowField[2](Bottle.collateral_amount: u64)

7WriteRef

8CopyLoc[0](Arg0: &mut Bottle)

9ImmBorrowField[3](Bottle.buck_amount: u64)

10ReadRef

11MoveLoc[2](Arg2: u64)

12Add

13CopyLoc[0](Arg0: &mut Bottle)

14MutBorrowField[3](Bottle.buck_amount: u64)

15WriteRef

16MoveLoc[0](Arg0: &mut Bottle)

17ImmBorrowField[3](Bottle.buck_amount: u64)

18ReadRef

19Call constants::minimal_bottle_size(): u64

20Ge

21BrFalse(23)

B1:

22Branch(25)

B2:

23LdConst[3](u64: 3)

24Abort

B3:

25Ret

}

public(friend) record_top_up(Arg0: &mut Bottle, Arg1: u64) {

B0:

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

1ImmBorrowField[2](Bottle.collateral_amount: u64)

2ReadRef

3MoveLoc[1](Arg1: u64)

4Add

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

6MutBorrowField[2](Bottle.collateral_amount: u64)

7WriteRef

8Ret

}

public(friend) record_repay(Arg0: &mut Bottle, Arg1: u64, Arg2: bool): bool * u64 {

L3: loc0: bool

L4: loc1: u64

L5: loc2: u64

L6: loc3: u64

B0:

0CopyLoc[1](Arg1: u64)

1CopyLoc[0](Arg0: &mut Bottle)

2ImmBorrowField[3](Bottle.buck_amount: u64)

3ReadRef

4Ge

5BrFalse(23)

B1:

6CopyLoc[0](Arg0: &mut Bottle)

7ImmBorrowField[2](Bottle.collateral_amount: u64)

8ReadRef

9StLoc[5](loc2: u64)

10LdU64(0)

11CopyLoc[0](Arg0: &mut Bottle)

12MutBorrowField[2](Bottle.collateral_amount: u64)

13WriteRef

14LdU64(0)

15MoveLoc[0](Arg0: &mut Bottle)

16MutBorrowField[3](Bottle.buck_amount: u64)

17WriteRef

18LdTrue

19MoveLoc[5](loc2: u64)

20StLoc[4](loc1: u64)

21StLoc[3](loc0: bool)

22Branch(66)

B2:

23CopyLoc[0](Arg0: &mut Bottle)

24ImmBorrowField[2](Bottle.collateral_amount: u64)

25ReadRef

26CopyLoc[1](Arg1: u64)

27CopyLoc[0](Arg0: &mut Bottle)

28ImmBorrowField[3](Bottle.buck_amount: u64)

29ReadRef

30Call math::mul_factor(u64, u64, u64): u64

31StLoc[6](loc3: u64)

32CopyLoc[0](Arg0: &mut Bottle)

33ImmBorrowField[2](Bottle.collateral_amount: u64)

34ReadRef

35CopyLoc[6](loc3: u64)

36Sub

37CopyLoc[0](Arg0: &mut Bottle)

38MutBorrowField[2](Bottle.collateral_amount: u64)

39WriteRef

40CopyLoc[0](Arg0: &mut Bottle)

41ImmBorrowField[3](Bottle.buck_amount: u64)

42ReadRef

43MoveLoc[1](Arg1: u64)

44Sub

45CopyLoc[0](Arg0: &mut Bottle)

46MutBorrowField[3](Bottle.buck_amount: u64)

47WriteRef

48MoveLoc[2](Arg2: bool)

49BrFalse(60)

B3:

50MoveLoc[0](Arg0: &mut Bottle)

51ImmBorrowField[3](Bottle.buck_amount: u64)

52ReadRef

53Call constants::minimal_bottle_size(): u64

54Ge

55BrFalse(57)

B4:

56Branch(59)

B5:

57LdConst[3](u64: 3)

58Abort

B6:

59Branch(62)

B7:

60MoveLoc[0](Arg0: &mut Bottle)

61Pop

B8:

62LdFalse

63MoveLoc[6](loc3: u64)

64StLoc[4](loc1: u64)

65StLoc[3](loc0: bool)

B9:

66MoveLoc[3](loc0: bool)

67MoveLoc[4](loc1: u64)

68Ret

}

compute_buck_value_to_collateral(Arg0: u64, Arg1: u8, Arg2: u64, Arg3: u64): u64 {

L4: loc0: u64

L5: loc1: u64

B0:

0MoveLoc[0](Arg0: u64)

1MoveLoc[3](Arg3: u64)

2MoveLoc[2](Arg2: u64)

3Call math::mul_factor(u64, u64, u64): u64

4StLoc[5](loc1: u64)

5Call constants::buck_decimal(): u8

6CopyLoc[1](Arg1: u8)

7Ge

8BrFalse(18)

B1:

9MoveLoc[5](loc1: u64)

10LdU64(10)

11Call constants::buck_decimal(): u8

12MoveLoc[1](Arg1: u8)

13Sub

14Call 0math::pow(u64, u8): u64

15Div

16StLoc[4](loc0: u64)

17Branch(26)

B2:

18MoveLoc[5](loc1: u64)

19LdU64(10)

20MoveLoc[1](Arg1: u8)

21Call constants::buck_decimal(): u8

22Sub

23Call 0math::pow(u64, u8): u64

24Mul

25StLoc[4](loc0: u64)

B3:

26MoveLoc[4](loc0: u64)

27Ret

}

public(friend) record_repay_capped<Ty0>(Arg0: &mut Bottle, Arg1: u64, Arg2: &BucketOracle, Arg3: &Clock, Arg4: u64, Arg5: u8): bool * u64 {

L6: loc0: bool

L7: loc1: u64

L8: loc2: u64

L9: loc3: u64

L10: loc4: u64

L11: loc5: u64

B0:

0MoveLoc[2](Arg2: &BucketOracle)

1MoveLoc[3](Arg3: &Clock)

2Call bucket_oracle::get_price<Ty0>(&BucketOracle, &Clock): u64 * u64

3StLoc[8](loc2: u64)

4StLoc[9](loc3: u64)

5CopyLoc[1](Arg1: u64)

6MoveLoc[4](Arg4: u64)

7Mul

8LdU64(100)

9Div

10MoveLoc[5](Arg5: u8)

11MoveLoc[9](loc3: u64)

12MoveLoc[8](loc2: u64)

13Call compute_buck_value_to_collateral(u64, u8, u64, u64): u64

14StLoc[11](loc5: u64)

15CopyLoc[1](Arg1: u64)

16CopyLoc[0](Arg0: &mut Bottle)

17ImmBorrowField[3](Bottle.buck_amount: u64)

18ReadRef

19Ge

20BrFalse(48)

B1:

21CopyLoc[0](Arg0: &mut Bottle)

22ImmBorrowField[2](Bottle.collateral_amount: u64)

23ReadRef

24CopyLoc[11](loc5: u64)

25Lt

26BrFalse(31)

B2:

27CopyLoc[0](Arg0: &mut Bottle)

28ImmBorrowField[2](Bottle.collateral_amount: u64)

29ReadRef

30StLoc[11](loc5: u64)

B3:

31CopyLoc[0](Arg0: &mut Bottle)

32ImmBorrowField[2](Bottle.collateral_amount: u64)

33ReadRef

34CopyLoc[11](loc5: u64)

35Sub

36CopyLoc[0](Arg0: &mut Bottle)

37MutBorrowField[2](Bottle.collateral_amount: u64)

38WriteRef

39LdU64(0)

40MoveLoc[0](Arg0: &mut Bottle)

41MutBorrowField[3](Bottle.buck_amount: u64)

42WriteRef

43LdTrue

44MoveLoc[11](loc5: u64)

45StLoc[7](loc1: u64)

46StLoc[6](loc0: bool)

47Branch(83)

B4:

48CopyLoc[0](Arg0: &mut Bottle)

49ImmBorrowField[2](Bottle.collateral_amount: u64)

50ReadRef

51CopyLoc[1](Arg1: u64)

52CopyLoc[0](Arg0: &mut Bottle)

53ImmBorrowField[3](Bottle.buck_amount: u64)

54ReadRef

55Call math::mul_factor(u64, u64, u64): u64

56StLoc[10](loc4: u64)

57CopyLoc[10](loc4: u64)

58CopyLoc[11](loc5: u64)

59Lt

60BrFalse(63)

B5:

61MoveLoc[10](loc4: u64)

62StLoc[11](loc5: u64)

B6:

63CopyLoc[0](Arg0: &mut Bottle)

64ImmBorrowField[2](Bottle.collateral_amount: u64)

65ReadRef

66CopyLoc[11](loc5: u64)

67Sub

68CopyLoc[0](Arg0: &mut Bottle)

69MutBorrowField[2](Bottle.collateral_amount: u64)

70WriteRef

71CopyLoc[0](Arg0: &mut Bottle)

72ImmBorrowField[3](Bottle.buck_amount: u64)

73ReadRef

74MoveLoc[1](Arg1: u64)

75Sub

76MoveLoc[0](Arg0: &mut Bottle)

77MutBorrowField[3](Bottle.buck_amount: u64)

78WriteRef

79LdFalse

80MoveLoc[11](loc5: u64)

81StLoc[7](loc1: u64)

82StLoc[6](loc0: bool)

B7:

83MoveLoc[6](loc0: bool)

84MoveLoc[7](loc1: u64)

85Ret

}

public(friend) record_redeem(Arg0: &mut Bottle, Arg1: u64, Arg2: u64) {

B0:

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

1ImmBorrowField[2](Bottle.collateral_amount: u64)

2ReadRef

3CopyLoc[1](Arg1: u64)

4Ge

5BrFalse(7)

B1:

6Branch(11)

B2:

7MoveLoc[0](Arg0: &mut Bottle)

8Pop

9LdConst[1](u64: 1)

10Abort

B3:

11CopyLoc[0](Arg0: &mut Bottle)

12ImmBorrowField[2](Bottle.collateral_amount: u64)

13ReadRef

14MoveLoc[1](Arg1: u64)

15Sub

16CopyLoc[0](Arg0: &mut Bottle)

17MutBorrowField[2](Bottle.collateral_amount: u64)

18WriteRef

19CopyLoc[0](Arg0: &mut Bottle)

20ImmBorrowField[3](Bottle.buck_amount: u64)

21ReadRef

22MoveLoc[2](Arg2: u64)

23Sub

24MoveLoc[0](Arg0: &mut Bottle)

25MutBorrowField[3](Bottle.buck_amount: u64)

26WriteRef

27Ret

}

public(friend) destroy_surplus_bottle(Arg0: Bottle): u64 {

L1: loc0: u64

B0:

0MoveLoc[0](Arg0: Bottle)

1Unpack[1](Bottle)

2Pop

3Pop

4Pop

5Pop

6StLoc[1](loc0: u64)

7Call object::delete(UID)

8MoveLoc[1](loc0: u64)

9Ret

}

public(friend) remove_bottle_stake(Arg0: &mut BottleTable, Arg1: address) {

L2: loc0: &mut Bottle

L3: loc1: u64

B0:

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

1MoveLoc[1](Arg1: address)

2Call borrow_bottle_mut(&mut BottleTable, address): &mut Bottle

3StLoc[2](loc0: &mut Bottle)

4CopyLoc[2](loc0: &mut Bottle)

5ImmBorrowField[4](Bottle.stake_amount: u64)

6ReadRef

7StLoc[3](loc1: u64)

8LdU64(0)

9MoveLoc[2](loc0: &mut Bottle)

10MutBorrowField[4](Bottle.stake_amount: u64)

11WriteRef

12CopyLoc[0](Arg0: &mut BottleTable)

13ImmBorrowField[5](BottleTable.total_stake: u64)

14ReadRef

15MoveLoc[3](loc1: u64)

16Sub

17MoveLoc[0](Arg0: &mut BottleTable)

18MutBorrowField[5](BottleTable.total_stake: u64)

19WriteRef

20Ret

}

public destroy_bottle(Arg0: &mut BottleTable, Arg1: address) {

L2: loc0: bool

L3: loc1: u64

L4: loc2: u64

L5: loc3: UID

L6: loc4: u64

B0:

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

1MoveLoc[1](Arg1: address)

2Call remove_bottle(&mut BottleTable, address): Bottle

3Unpack[1](Bottle)

4Pop

5Pop

6StLoc[6](loc4: u64)

7StLoc[3](loc1: u64)

8StLoc[4](loc2: u64)

9StLoc[5](loc3: UID)

10MoveLoc[4](loc2: u64)

11LdU64(0)

12Eq

13BrFalse(19)

B1:

14MoveLoc[3](loc1: u64)

15LdU64(0)

16Eq

17StLoc[2](loc0: bool)

18Branch(21)

B2:

19LdFalse

20StLoc[2](loc0: bool)

B3:

21MoveLoc[2](loc0: bool)

22BrFalse(24)

B4:

23Branch(28)

B5:

24MoveLoc[0](Arg0: &mut BottleTable)

25Pop

26LdConst[2](u64: 2)

27Abort

B6:

28MoveLoc[5](loc3: UID)

29Call object::delete(UID)

30CopyLoc[0](Arg0: &mut BottleTable)

31ImmBorrowField[5](BottleTable.total_stake: u64)

32ReadRef

33MoveLoc[6](loc4: u64)

34Sub

35MoveLoc[0](Arg0: &mut BottleTable)

36MutBorrowField[5](BottleTable.total_stake: u64)

37WriteRef

38Ret

}

public get_table_length(Arg0: &BottleTable): u64 {

B0:

0MoveLoc[0](Arg0: &BottleTable)

1Call borrow_table(&BottleTable): &LinkedTable<address, Bottle>

2Call linked_table::length<address, Bottle>(&LinkedTable<address, Bottle>): u64

3Ret

}

public bottle_exists(Arg0: &BottleTable, Arg1: address): bool {

B0:

0MoveLoc[0](Arg0: &BottleTable)

1ImmBorrowField[6](BottleTable.table: LinkedTable<address, Bottle>)

2MoveLoc[1](Arg1: address)

3Call linked_table::contains<address, Bottle>(&LinkedTable<address, Bottle>, address): bool

4Ret

}

public borrow_bottle(Arg0: &BottleTable, Arg1: address): &Bottle {

B0:

0CopyLoc[0](Arg0: &BottleTable)

1ImmBorrowField[6](BottleTable.table: LinkedTable<address, Bottle>)

2CopyLoc[1](Arg1: address)

3Call linked_table::contains<address, Bottle>(&LinkedTable<address, Bottle>, address): bool

4BrFalse(6)

B1:

5Branch(10)

B2:

6MoveLoc[0](Arg0: &BottleTable)

7Pop

8LdConst[4](u64: 4)

9Abort

B3:

10MoveLoc[0](Arg0: &BottleTable)

11ImmBorrowField[6](BottleTable.table: LinkedTable<address, Bottle>)

12MoveLoc[1](Arg1: address)

13Call linked_table::borrow<address, Bottle>(&LinkedTable<address, Bottle>, address): &Bottle

14Ret

}

public(friend) borrow_bottle_mut(Arg0: &mut BottleTable, Arg1: address): &mut Bottle {

B0:

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

1ImmBorrowField[6](BottleTable.table: LinkedTable<address, Bottle>)

2CopyLoc[1](Arg1: address)

3Call linked_table::contains<address, Bottle>(&LinkedTable<address, Bottle>, address): bool

4BrFalse(6)

B1:

5Branch(10)

B2:

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

7Pop

8LdConst[4](u64: 4)

9Abort

B3:

10MoveLoc[0](Arg0: &mut BottleTable)

11MutBorrowField[6](BottleTable.table: LinkedTable<address, Bottle>)

12MoveLoc[1](Arg1: address)

13Call linked_table::borrow_mut<address, Bottle>(&mut LinkedTable<address, Bottle>, address): &mut Bottle

14Ret

}

public(friend) remove_bottle(Arg0: &mut BottleTable, Arg1: address): Bottle {

B0:

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

1ImmBorrowField[6](BottleTable.table: LinkedTable<address, Bottle>)

2CopyLoc[1](Arg1: address)

3Call linked_table::contains<address, Bottle>(&LinkedTable<address, Bottle>, address): bool

4BrFalse(6)

B1:

5Branch(10)

B2:

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

7Pop

8LdConst[4](u64: 4)

9Abort

B3:

10MoveLoc[0](Arg0: &mut BottleTable)

11MutBorrowField[6](BottleTable.table: LinkedTable<address, Bottle>)

12MoveLoc[1](Arg1: address)

13Call linked_table::remove<address, Bottle>(&mut LinkedTable<address, Bottle>, address): Bottle

14Ret

}

public(friend) pop_front(Arg0: &mut BottleTable): address * Bottle {

B0:

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

1ImmBorrowField[6](BottleTable.table: LinkedTable<address, Bottle>)

2Call linked_table::front<address, Bottle>(&LinkedTable<address, Bottle>): &Option<address>

3Call option::is_some<address>(&Option<address>): bool

4BrFalse(6)

B1:

5Branch(10)

B2:

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

7Pop

8LdConst[4](u64: 4)

9Abort

B3:

10MoveLoc[0](Arg0: &mut BottleTable)

11MutBorrowField[6](BottleTable.table: LinkedTable<address, Bottle>)

12Call linked_table::pop_front<address, Bottle>(&mut LinkedTable<address, Bottle>): address * Bottle

13Ret

}

public get_lowest_cr_debtor(Arg0: &BottleTable): Option<address> {

B0:

0MoveLoc[0](Arg0: &BottleTable)

1ImmBorrowField[6](BottleTable.table: LinkedTable<address, Bottle>)

2Call linked_table::front<address, Bottle>(&LinkedTable<address, Bottle>): &Option<address>

3ReadRef

4Ret

}

public get_bottle_info(Arg0: &BottleTable, Arg1: &Bottle): u64 * u64 {

L2: loc0: u64

L3: loc1: u64

B0:

0CopyLoc[1](Arg1: &Bottle)

1CopyLoc[0](Arg0: &BottleTable)

2Call get_pending_coll(&Bottle, &BottleTable): u64

3StLoc[2](loc0: u64)

4CopyLoc[1](Arg1: &Bottle)

5MoveLoc[0](Arg0: &BottleTable)

6Call get_pending_debt(&Bottle, &BottleTable): u64

7StLoc[3](loc1: u64)

8CopyLoc[1](Arg1: &Bottle)

9ImmBorrowField[2](Bottle.collateral_amount: u64)

10ReadRef

11MoveLoc[2](loc0: u64)

12Add

13MoveLoc[1](Arg1: &Bottle)

14ImmBorrowField[3](Bottle.buck_amount: u64)

15ReadRef

16MoveLoc[3](loc1: u64)

17Add

18Ret

}

public get_bottle_info_by_debtor(Arg0: &BottleTable, Arg1: address): u64 * u64 {

L2: loc0: &Bottle

L3: loc1: u64

L4: loc2: u64

B0:

0CopyLoc[0](Arg0: &BottleTable)

1MoveLoc[1](Arg1: address)

2Call borrow_bottle(&BottleTable, address): &Bottle

3StLoc[2](loc0: &Bottle)

4CopyLoc[2](loc0: &Bottle)

5CopyLoc[0](Arg0: &BottleTable)

6Call get_pending_coll(&Bottle, &BottleTable): u64

7StLoc[3](loc1: u64)

8CopyLoc[2](loc0: &Bottle)

9MoveLoc[0](Arg0: &BottleTable)

10Call get_pending_debt(&Bottle, &BottleTable): u64

11StLoc[4](loc2: u64)

12CopyLoc[2](loc0: &Bottle)

13ImmBorrowField[2](Bottle.collateral_amount: u64)

14ReadRef

15MoveLoc[3](loc1: u64)

16Add

17MoveLoc[2](loc0: &Bottle)

18ImmBorrowField[3](Bottle.buck_amount: u64)

19ReadRef

20MoveLoc[4](loc2: u64)

21Add

22Ret

}

public get_bottle_raw_info_by_debator(Arg0: &BottleTable, Arg1: address): u64 * u64 {

L2: loc0: &Bottle

B0:

0MoveLoc[0](Arg0: &BottleTable)

1MoveLoc[1](Arg1: address)

2Call borrow_bottle(&BottleTable, address): &Bottle

3StLoc[2](loc0: &Bottle)

4CopyLoc[2](loc0: &Bottle)

5ImmBorrowField[2](Bottle.collateral_amount: u64)

6ReadRef

7MoveLoc[2](loc0: &Bottle)

8ImmBorrowField[3](Bottle.buck_amount: u64)

9ReadRef

10Ret

}

public get_bottle_raw_info(Arg0: &Bottle): u64 * u64 {

B0:

0CopyLoc[0](Arg0: &Bottle)

1ImmBorrowField[2](Bottle.collateral_amount: u64)

2ReadRef

3MoveLoc[0](Arg0: &Bottle)

4ImmBorrowField[3](Bottle.buck_amount: u64)

5ReadRef

6Ret

}

public get_pending_coll(Arg0: &Bottle, Arg1: &BottleTable): u64 {

B0:

0CopyLoc[0](Arg0: &Bottle)

1ImmBorrowField[4](Bottle.stake_amount: u64)

2ReadRef

3CastU128

4MoveLoc[1](Arg1: &BottleTable)

5ImmBorrowField[0](BottleTable.reward_per_unit_stake: u128)

6ReadRef

7MoveLoc[0](Arg0: &Bottle)

8ImmBorrowField[7](Bottle.reward_coll_snapshot: u128)

9ReadRef

10Sub

11CastU128

12Call constants::distribution_precision(): u128

13Call math::mul_factor_u128(u128, u128, u128): u128

14CastU64

15Ret

}

public get_pending_debt(Arg0: &Bottle, Arg1: &BottleTable): u64 {

B0:

0CopyLoc[0](Arg0: &Bottle)

1ImmBorrowField[4](Bottle.stake_amount: u64)

2ReadRef

3CastU128

4MoveLoc[1](Arg1: &BottleTable)

5ImmBorrowField[1](BottleTable.debt_per_unit_stake: u128)

6ReadRef

7MoveLoc[0](Arg0: &Bottle)

8ImmBorrowField[8](Bottle.reward_debt_snapshot: u128)

9ReadRef

10Sub

11CastU128

12Call constants::distribution_precision(): u128

13Call math::mul_factor_u128(u128, u128, u128): u128

14CastU64

15Ret

}

public borrow_table(Arg0: &BottleTable): &LinkedTable<address, Bottle> {

B0:

0MoveLoc[0](Arg0: &BottleTable)

1ImmBorrowField[6](BottleTable.table: LinkedTable<address, Bottle>)

2Ret

}

public(friend) get_bottle_info_after_update(Arg0: &mut BottleTable, Arg1: address): u64 * u64 {

L2: loc0: address

L3: loc1: &Bottle

L4: loc2: &mut Bottle

L5: loc3: u64

L6: loc4: u64

L7: loc5: u128

L8: loc6: u128

B0:

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

1ImmBorrowField[0](BottleTable.reward_per_unit_stake: u128)

2ReadRef

3StLoc[8](loc6: u128)

4CopyLoc[0](Arg0: &mut BottleTable)

5ImmBorrowField[1](BottleTable.debt_per_unit_stake: u128)

6ReadRef

7StLoc[7](loc5: u128)

8CopyLoc[0](Arg0: &mut BottleTable)

9CopyLoc[1](Arg1: address)

10StLoc[2](loc0: address)

11FreezeRef

12MoveLoc[2](loc0: address)

13Call borrow_bottle(&BottleTable, address): &Bottle

14StLoc[3](loc1: &Bottle)

15CopyLoc[3](loc1: &Bottle)

16CopyLoc[0](Arg0: &mut BottleTable)

17FreezeRef

18Call get_pending_coll(&Bottle, &BottleTable): u64

19StLoc[5](loc3: u64)

20MoveLoc[3](loc1: &Bottle)

21CopyLoc[0](Arg0: &mut BottleTable)

22FreezeRef

23Call get_pending_debt(&Bottle, &BottleTable): u64

24StLoc[6](loc4: u64)

25MoveLoc[0](Arg0: &mut BottleTable)

26MoveLoc[1](Arg1: address)

27Call borrow_bottle_mut(&mut BottleTable, address): &mut Bottle

28StLoc[4](loc2: &mut Bottle)

29CopyLoc[4](loc2: &mut Bottle)

30ImmBorrowField[2](Bottle.collateral_amount: u64)

31ReadRef

32MoveLoc[5](loc3: u64)

33Add

34CopyLoc[4](loc2: &mut Bottle)

35MutBorrowField[2](Bottle.collateral_amount: u64)

36WriteRef

37CopyLoc[4](loc2: &mut Bottle)

38ImmBorrowField[3](Bottle.buck_amount: u64)

39ReadRef

40MoveLoc[6](loc4: u64)

41Add

42CopyLoc[4](loc2: &mut Bottle)

43MutBorrowField[3](Bottle.buck_amount: u64)

44WriteRef

45MoveLoc[8](loc6: u128)

46CopyLoc[4](loc2: &mut Bottle)

47MutBorrowField[7](Bottle.reward_coll_snapshot: u128)

48WriteRef

49MoveLoc[7](loc5: u128)

50CopyLoc[4](loc2: &mut Bottle)

51MutBorrowField[8](Bottle.reward_debt_snapshot: u128)

52WriteRef

53CopyLoc[4](loc2: &mut Bottle)

54ImmBorrowField[2](Bottle.collateral_amount: u64)

55ReadRef

56MoveLoc[4](loc2: &mut Bottle)

57ImmBorrowField[3](Bottle.buck_amount: u64)

58ReadRef

59Ret

}

public(friend) update_snapshot(Arg0: &mut BottleTable, Arg1: u64) {

B0:

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

1ImmBorrowField[5](BottleTable.total_stake: u64)

2ReadRef

3CopyLoc[0](Arg0: &mut BottleTable)

4MutBorrowField[9](BottleTable.total_stake_snapshot: u64)

5WriteRef

6MoveLoc[1](Arg1: u64)

7MoveLoc[0](Arg0: &mut BottleTable)

8MutBorrowField[10](BottleTable.total_collateral_snapshot: u64)

9WriteRef

10Ret

}

public(friend) update_stake_and_total_stake(Arg0: &mut BottleTable, Arg1: &mut Bottle) {

L2: loc0: u64

L3: loc1: u64

B0:

0CopyLoc[1](Arg1: &mut Bottle)

1FreezeRef

2Call get_bottle_raw_info(&Bottle): u64 * u64

3Pop

4StLoc[2](loc0: u64)

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

6MoveLoc[2](loc0: u64)

7Call compute_new_stake(&mut BottleTable, u64): u64

8StLoc[3](loc1: u64)

9CopyLoc[0](Arg0: &mut BottleTable)

10ImmBorrowField[5](BottleTable.total_stake: u64)

11ReadRef

12CopyLoc[3](loc1: u64)

13Add

14CopyLoc[1](Arg1: &mut Bottle)

15ImmBorrowField[4](Bottle.stake_amount: u64)

16ReadRef

17Sub

18MoveLoc[0](Arg0: &mut BottleTable)

19MutBorrowField[5](BottleTable.total_stake: u64)

20WriteRef

21MoveLoc[3](loc1: u64)

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

23MutBorrowField[4](Bottle.stake_amount: u64)

24WriteRef

25Ret

}

public(friend) update_stake_and_total_stake_by_debtor(Arg0: &mut BottleTable, Arg1: address) {

L2: loc0: address

L3: loc1: &mut Bottle

L4: loc2: u64

L5: loc3: u64

L6: loc4: u64

B0:

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

1CopyLoc[1](Arg1: address)

2StLoc[2](loc0: address)

3FreezeRef

4MoveLoc[2](loc0: address)

5Call get_bottle_raw_info_by_debator(&BottleTable, address): u64 * u64

6Pop

7StLoc[5](loc3: u64)

8CopyLoc[0](Arg0: &mut BottleTable)

9MoveLoc[5](loc3: u64)

10Call compute_new_stake(&mut BottleTable, u64): u64

11StLoc[6](loc4: u64)

12CopyLoc[0](Arg0: &mut BottleTable)

13MoveLoc[1](Arg1: address)

14Call borrow_bottle_mut(&mut BottleTable, address): &mut Bottle

15StLoc[3](loc1: &mut Bottle)

16CopyLoc[3](loc1: &mut Bottle)

17ImmBorrowField[4](Bottle.stake_amount: u64)

18ReadRef

19StLoc[4](loc2: u64)

20CopyLoc[6](loc4: u64)

21MoveLoc[3](loc1: &mut Bottle)

22MutBorrowField[4](Bottle.stake_amount: u64)

23WriteRef

24CopyLoc[0](Arg0: &mut BottleTable)

25ImmBorrowField[5](BottleTable.total_stake: u64)

26ReadRef

27MoveLoc[6](loc4: u64)

28Add

29MoveLoc[4](loc2: u64)

30Sub

31MoveLoc[0](Arg0: &mut BottleTable)

32MutBorrowField[5](BottleTable.total_stake: u64)

33WriteRef

34Ret

}

compute_new_stake(Arg0: &mut BottleTable, Arg1: u64): u64 {

L2: loc0: u64

B0:

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

1ImmBorrowField[10](BottleTable.total_collateral_snapshot: u64)

2ReadRef

3LdU64(0)

4Eq

5BrFalse(11)

B1:

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

7Pop

8MoveLoc[1](Arg1: u64)

9StLoc[2](loc0: u64)

10Branch(20)

B2:

11MoveLoc[1](Arg1: u64)

12CopyLoc[0](Arg0: &mut BottleTable)

13ImmBorrowField[9](BottleTable.total_stake_snapshot: u64)

14ReadRef

15MoveLoc[0](Arg0: &mut BottleTable)

16ImmBorrowField[10](BottleTable.total_collateral_snapshot: u64)

17ReadRef

18Call math::mul_factor(u64, u64, u64): u64

19StLoc[2](loc0: u64)

B3:

20MoveLoc[2](loc0: u64)

21Ret

}

public(friend) record_redistribution(Arg0: &mut BottleTable, Arg1: u64, Arg2: u64, Arg3: address) {

L4: loc0: &mut Bottle

L5: loc1: u128

L6: loc2: u128

L7: loc3: u128

L8: loc4: u128

L9: loc5: u128

B0:

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

1ImmBorrowField[5](BottleTable.total_stake: u64)

2ReadRef

3CastU128

4StLoc[9](loc5: u128)

5MoveLoc[1](Arg1: u64)

6CastU128

7Call constants::distribution_precision(): u128

8LdU128(1)

9Call math::mul_factor_u128(u128, u128, u128): u128

10CopyLoc[0](Arg0: &mut BottleTable)

11ImmBorrowField[11](BottleTable.last_reward_error: u128)

12ReadRef

13Add

14StLoc[7](loc3: u128)

15MoveLoc[2](Arg2: u64)

16CastU128

17Call constants::distribution_precision(): u128

18LdU128(1)

19Call math::mul_factor_u128(u128, u128, u128): u128

20CopyLoc[0](Arg0: &mut BottleTable)

21ImmBorrowField[12](BottleTable.last_debt_error: u128)

22ReadRef

23Add

24StLoc[5](loc1: u128)

25CopyLoc[7](loc3: u128)

26CopyLoc[9](loc5: u128)

27Div

28StLoc[8](loc4: u128)

29CopyLoc[5](loc1: u128)

30CopyLoc[9](loc5: u128)

31Div

32StLoc[6](loc2: u128)

33MoveLoc[7](loc3: u128)

34CopyLoc[8](loc4: u128)

35CopyLoc[9](loc5: u128)

36Mul

37Sub

38CopyLoc[0](Arg0: &mut BottleTable)

39MutBorrowField[11](BottleTable.last_reward_error: u128)

40WriteRef

41MoveLoc[5](loc1: u128)

42CopyLoc[6](loc2: u128)

43MoveLoc[9](loc5: u128)

44Mul

45Sub

46CopyLoc[0](Arg0: &mut BottleTable)

47MutBorrowField[12](BottleTable.last_debt_error: u128)

48WriteRef

49CopyLoc[0](Arg0: &mut BottleTable)

50ImmBorrowField[0](BottleTable.reward_per_unit_stake: u128)

51ReadRef

52MoveLoc[8](loc4: u128)

53Add

54CopyLoc[0](Arg0: &mut BottleTable)

55MutBorrowField[0](BottleTable.reward_per_unit_stake: u128)

56WriteRef

57CopyLoc[0](Arg0: &mut BottleTable)

58ImmBorrowField[1](BottleTable.debt_per_unit_stake: u128)

59ReadRef

60MoveLoc[6](loc2: u128)

61Add

62CopyLoc[0](Arg0: &mut BottleTable)

63MutBorrowField[1](BottleTable.debt_per_unit_stake: u128)

64WriteRef

65MoveLoc[0](Arg0: &mut BottleTable)

66MoveLoc[3](Arg3: address)

67Call borrow_bottle_mut(&mut BottleTable, address): &mut Bottle

68StLoc[4](loc0: &mut Bottle)

69LdU64(0)

70CopyLoc[4](loc0: &mut Bottle)

71MutBorrowField[3](Bottle.buck_amount: u64)

72WriteRef

73LdU64(0)

74CopyLoc[4](loc0: &mut Bottle)

75MutBorrowField[2](Bottle.collateral_amount: u64)

76WriteRef

77LdU128(0)

78CopyLoc[4](loc0: &mut Bottle)

79MutBorrowField[7](Bottle.reward_coll_snapshot: u128)

80WriteRef

81LdU128(0)

82MoveLoc[4](loc0: &mut Bottle)

83MutBorrowField[8](Bottle.reward_debt_snapshot: u128)

84WriteRef

85Ret

}

public(friend) insert(Arg0: &mut BottleTable, Arg1: address, Arg2: Bottle, Arg3: Option<address>) {

L4: loc0: &Bottle

L5: loc1: &Bottle

L6: loc2: Option<address>

L7: loc3: Option<address>

L8: loc4: Option<address>

L9: loc5: &Bottle

L10: loc6: address

B0:

0ImmBorrowLoc[3](Arg3: Option<address>)

1Call option::is_none<address>(&Option<address>): bool

2BrFalse(14)

B1:

3CopyLoc[0](Arg0: &mut BottleTable)

4ImmBorrowField[6](BottleTable.table: LinkedTable<address, Bottle>)

5Call linked_table::front<address, Bottle>(&LinkedTable<address, Bottle>): &Option<address>

6ReadRef

7StLoc[6](loc2: Option<address>)

8MoveLoc[0](Arg0: &mut BottleTable)

9MoveLoc[1](Arg1: address)

10MoveLoc[2](Arg2: Bottle)

11MoveLoc[6](loc2: Option<address>)

12Call find_upward_and_insert(&mut BottleTable, address, Bottle, Option<address>)

13Ret

B2:

14MoveLoc[3](Arg3: Option<address>)

15Call option::destroy_some<address>(Option<address>): address

16StLoc[10](loc6: address)

17CopyLoc[0](Arg0: &mut BottleTable)

18ImmBorrowField[6](BottleTable.table: LinkedTable<address, Bottle>)

19CopyLoc[1](Arg1: address)

20Call linked_table::contains<address, Bottle>(&LinkedTable<address, Bottle>, address): bool

21Not

22BrFalse(24)

B3:

23Branch(28)

B4:

24MoveLoc[0](Arg0: &mut BottleTable)

25Pop

26LdConst[5](u64: 5)

27Abort

B5:

28CopyLoc[0](Arg0: &mut BottleTable)

29ImmBorrowField[6](BottleTable.table: LinkedTable<address, Bottle>)

30CopyLoc[10](loc6: address)

31Call linked_table::borrow<address, Bottle>(&LinkedTable<address, Bottle>, address): &Bottle

32StLoc[9](loc5: &Bottle)

33CopyLoc[0](Arg0: &mut BottleTable)

34ImmBorrowLoc[2](Arg2: Bottle)

35MoveLoc[9](loc5: &Bottle)

36StLoc[5](loc1: &Bottle)

37StLoc[4](loc0: &Bottle)

38FreezeRef

39MoveLoc[4](loc0: &Bottle)

40MoveLoc[5](loc1: &Bottle)

41Call cr_greater(&BottleTable, &Bottle, &Bottle): bool

42BrFalse(55)

B6:

43CopyLoc[0](Arg0: &mut BottleTable)

44ImmBorrowField[6](BottleTable.table: LinkedTable<address, Bottle>)

45MoveLoc[10](loc6: address)

46Call linked_table::next<address, Bottle>(&LinkedTable<address, Bottle>, address): &Option<address>

47ReadRef

48StLoc[7](loc3: Option<address>)

49MoveLoc[0](Arg0: &mut BottleTable)

50MoveLoc[1](Arg1: address)

51MoveLoc[2](Arg2: Bottle)

52MoveLoc[7](loc3: Option<address>)

53Call find_upward_and_insert(&mut BottleTable, address, Bottle, Option<address>)

54Branch(66)

B7:

55CopyLoc[0](Arg0: &mut BottleTable)

56ImmBorrowField[6](BottleTable.table: LinkedTable<address, Bottle>)

57MoveLoc[10](loc6: address)

58Call linked_table::prev<address, Bottle>(&LinkedTable<address, Bottle>, address): &Option<address>

59ReadRef

60StLoc[8](loc4: Option<address>)

61MoveLoc[0](Arg0: &mut BottleTable)

62MoveLoc[1](Arg1: address)

63MoveLoc[2](Arg2: Bottle)

64MoveLoc[8](loc4: Option<address>)

65Call find_downward_and_insert(&mut BottleTable, address, Bottle, Option<address>)

B8:

66Ret

}

find_upward_and_insert(Arg0: &mut BottleTable, Arg1: address, Arg2: Bottle, Arg3: Option<address>) {

L4: loc0: &Bottle

L5: loc1: &Bottle

L6: loc2: &Bottle

L7: loc3: address

B0:

0ImmBorrowLoc[3](Arg3: Option<address>)

1Call option::is_some<address>(&Option<address>): bool

2BrFalse(37)

B1:

3Branch(4)

B2:

4ImmBorrowLoc[3](Arg3: Option<address>)

5Call option::borrow<address>(&Option<address>): &address

6ReadRef

7StLoc[7](loc3: address)

8CopyLoc[0](Arg0: &mut BottleTable)

9ImmBorrowField[6](BottleTable.table: LinkedTable<address, Bottle>)

10CopyLoc[7](loc3: address)

11Call linked_table::borrow<address, Bottle>(&LinkedTable<address, Bottle>, address): &Bottle

12StLoc[6](loc2: &Bottle)

13CopyLoc[0](Arg0: &mut BottleTable)

14ImmBorrowLoc[2](Arg2: Bottle)

15MoveLoc[6](loc2: &Bottle)

16StLoc[5](loc1: &Bottle)

17StLoc[4](loc0: &Bottle)

18FreezeRef

19MoveLoc[4](loc0: &Bottle)

20MoveLoc[5](loc1: &Bottle)

21Call cr_less_or_equal(&BottleTable, &Bottle, &Bottle): bool

22BrFalse(30)

B3:

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

24MutBorrowField[6](BottleTable.table: LinkedTable<address, Bottle>)

25MoveLoc[3](Arg3: Option<address>)

26MoveLoc[1](Arg1: address)

27MoveLoc[2](Arg2: Bottle)

28Call linked_table::insert_front<address, Bottle>(&mut LinkedTable<address, Bottle>, Option<address>, address, Bottle)

29Ret

B4:

30CopyLoc[0](Arg0: &mut BottleTable)

31ImmBorrowField[6](BottleTable.table: LinkedTable<address, Bottle>)

32MoveLoc[7](loc3: address)

33Call linked_table::next<address, Bottle>(&LinkedTable<address, Bottle>, address): &Option<address>

34ReadRef

35StLoc[3](Arg3: Option<address>)

36Branch(0)

B5:

37MoveLoc[0](Arg0: &mut BottleTable)

38MutBorrowField[6](BottleTable.table: LinkedTable<address, Bottle>)

39MoveLoc[3](Arg3: Option<address>)

40MoveLoc[1](Arg1: address)

41MoveLoc[2](Arg2: Bottle)

42Call linked_table::insert_front<address, Bottle>(&mut LinkedTable<address, Bottle>, Option<address>, address, Bottle)

43Ret

}

find_downward_and_insert(Arg0: &mut BottleTable, Arg1: address, Arg2: Bottle, Arg3: Option<address>) {

L4: loc0: &Bottle

L5: loc1: &Bottle

L6: loc2: &Bottle

L7: loc3: address

B0:

0ImmBorrowLoc[3](Arg3: Option<address>)

1Call option::is_some<address>(&Option<address>): bool

2BrFalse(37)

B1:

3Branch(4)

B2:

4ImmBorrowLoc[3](Arg3: Option<address>)

5Call option::borrow<address>(&Option<address>): &address

6ReadRef

7StLoc[7](loc3: address)

8CopyLoc[0](Arg0: &mut BottleTable)

9ImmBorrowField[6](BottleTable.table: LinkedTable<address, Bottle>)

10CopyLoc[7](loc3: address)

11Call linked_table::borrow<address, Bottle>(&LinkedTable<address, Bottle>, address): &Bottle

12StLoc[6](loc2: &Bottle)

13CopyLoc[0](Arg0: &mut BottleTable)

14ImmBorrowLoc[2](Arg2: Bottle)

15MoveLoc[6](loc2: &Bottle)

16StLoc[5](loc1: &Bottle)

17StLoc[4](loc0: &Bottle)

18FreezeRef

19MoveLoc[4](loc0: &Bottle)

20MoveLoc[5](loc1: &Bottle)

21Call cr_greater(&BottleTable, &Bottle, &Bottle): bool

22BrFalse(30)

B3:

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

24MutBorrowField[6](BottleTable.table: LinkedTable<address, Bottle>)

25MoveLoc[3](Arg3: Option<address>)

26MoveLoc[1](Arg1: address)

27MoveLoc[2](Arg2: Bottle)

28Call linked_table::insert_back<address, Bottle>(&mut LinkedTable<address, Bottle>, Option<address>, address, Bottle)

29Ret

B4:

30CopyLoc[0](Arg0: &mut BottleTable)

31ImmBorrowField[6](BottleTable.table: LinkedTable<address, Bottle>)

32MoveLoc[7](loc3: address)

33Call linked_table::prev<address, Bottle>(&LinkedTable<address, Bottle>, address): &Option<address>

34ReadRef

35StLoc[3](Arg3: Option<address>)

36Branch(0)

B5:

37MoveLoc[0](Arg0: &mut BottleTable)

38MutBorrowField[6](BottleTable.table: LinkedTable<address, Bottle>)

39MoveLoc[3](Arg3: Option<address>)

40MoveLoc[1](Arg1: address)

41MoveLoc[2](Arg2: Bottle)

42Call linked_table::insert_back<address, Bottle>(&mut LinkedTable<address, Bottle>, Option<address>, address, Bottle)

43Ret

}

public cr_greater(Arg0: &BottleTable, Arg1: &Bottle, Arg2: &Bottle): bool {

L3: loc0: u64

L4: loc1: u64

L5: loc2: u64

L6: loc3: u64

B0:

0CopyLoc[0](Arg0: &BottleTable)

1MoveLoc[1](Arg1: &Bottle)

2Call get_bottle_info(&BottleTable, &Bottle): u64 * u64

3StLoc[3](loc0: u64)

4StLoc[5](loc2: u64)

5MoveLoc[0](Arg0: &BottleTable)

6MoveLoc[2](Arg2: &Bottle)

7Call get_bottle_info(&BottleTable, &Bottle): u64 * u64

8StLoc[4](loc1: u64)

9StLoc[6](loc3: u64)

10MoveLoc[5](loc2: u64)

11CastU128

12MoveLoc[4](loc1: u64)

13CastU128

14Mul

15MoveLoc[6](loc3: u64)

16CastU128

17MoveLoc[3](loc0: u64)

18CastU128

19Mul

20Gt

21Ret

}

public cr_less_or_equal(Arg0: &BottleTable, Arg1: &Bottle, Arg2: &Bottle): bool {

L3: loc0: u64

L4: loc1: u64

L5: loc2: u64

L6: loc3: u64

B0:

0CopyLoc[0](Arg0: &BottleTable)

1MoveLoc[1](Arg1: &Bottle)

2Call get_bottle_info(&BottleTable, &Bottle): u64 * u64

3StLoc[3](loc0: u64)

4StLoc[5](loc2: u64)

5MoveLoc[0](Arg0: &BottleTable)

6MoveLoc[2](Arg2: &Bottle)

7Call get_bottle_info(&BottleTable, &Bottle): u64 * u64

8StLoc[4](loc1: u64)

9StLoc[6](loc3: u64)

10MoveLoc[5](loc2: u64)

11CastU128

12MoveLoc[4](loc1: u64)

13CastU128

14Mul

15MoveLoc[6](loc3: u64)

16CastU128

17MoveLoc[3](loc0: u64)

18CastU128

19Mul

20Le

21Ret

}

public re_insert(Arg0: &mut BottleTable, Arg1: address) {

L2: loc0: Bottle

L3: loc1: Option<address>

B0:

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

1ImmBorrowField[6](BottleTable.table: LinkedTable<address, Bottle>)

2CopyLoc[1](Arg1: address)

3Call linked_table::prev<address, Bottle>(&LinkedTable<address, Bottle>, address): &Option<address>

4ReadRef

5StLoc[3](loc1: Option<address>)

6CopyLoc[0](Arg0: &mut BottleTable)

7MutBorrowField[6](BottleTable.table: LinkedTable<address, Bottle>)

8CopyLoc[1](Arg1: address)

9Call linked_table::remove<address, Bottle>(&mut LinkedTable<address, Bottle>, address): Bottle

10StLoc[2](loc0: Bottle)

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

12MoveLoc[1](Arg1: address)

13MoveLoc[2](loc0: Bottle)

14MoveLoc[3](loc1: Option<address>)

15Call insert(&mut BottleTable, address, Bottle, Option<address>)

16Ret

}

Constants [

0 => u64: 0

1 => u64: 1

2 => u64: 2

3 => u64: 3

4 => u64: 4

5 => u64: 5

]

}