nest

Module0xff3e…279d

Move path: 0x61e6…e413::nest
Functions: 3123 public, 7 entry
Structs: 15
Friend modules: nestv2

nest

Bytecode3758 lines

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

// Move bytecode v6

module 61e6afef2cafd54a7f9824e5301a02224bd2cf9ab9c52ce4e780d2ae6f09e413.nest {

use 61e6afef2cafd54a7f9824e5301a02224bd2cf9ab9c52ce4e780d2ae6f09e413::duck_nft;

use 61e6afef2cafd54a7f9824e5301a02224bd2cf9ab9c52ce4e780d2ae6f09e413::shttoken;

use 434b5bd8f6a7b05fede0ff46c6e511d71ea326ed38056e3bcd681d2d7c2a7879::kiosk_lock_rule;

use 434b5bd8f6a7b05fede0ff46c6e511d71ea326ed38056e3bcd681d2d7c2a7879::royalty_rule;

use 0000000000000000000000000000000000000000000000000000000000000001::option;

use 0000000000000000000000000000000000000000000000000000000000000002::clock;

use 0000000000000000000000000000000000000000000000000000000000000002::coin;

use 0000000000000000000000000000000000000000000000000000000000000002::dynamic_field;

use 0000000000000000000000000000000000000000000000000000000000000002::event;

use 0000000000000000000000000000000000000000000000000000000000000002::kiosk;

use 0000000000000000000000000000000000000000000000000000000000000002::object;

use 0000000000000000000000000000000000000000000000000000000000000002::package;

use 0000000000000000000000000000000000000000000000000000000000000002::random;

use 0000000000000000000000000000000000000000000000000000000000000002::sui;

use 0000000000000000000000000000000000000000000000000000000000000002::table;

use 0000000000000000000000000000000000000000000000000000000000000002::transfer;

use 0000000000000000000000000000000000000000000000000000000000000002::transfer_policy;

use 0000000000000000000000000000000000000000000000000000000000000002::tx_context;

struct NestAdminCap has key {

id: UID

}

struct StakingKiosk has key {

id: UID,

kiosk: Kiosk,

cap: KioskOwnerCap

}

struct NestRegistry has key {

id: UID,

user_nests: Table<address, Table<u8, ID>>,

is_initialized: bool

}

struct Nest has key {

id: UID,

owner: address,

nest_index: u8,

level: u8,

staked_duck_id: Option<ID>

}

struct StakedDuck has key {

id: UID,

duck_id: ID,

owner: address,

nest_id: ID,

staked_at: u64,

last_harvest_time: u64,

duck_rarity: u8,

duck_multiplier: u8

}

struct HarvestStats has key {

id: UID,

total_sht_harvested: u64,

total_harvest_attempts: u64,

total_successful_harvests: u64,

active_ducks_staked: u64,

sht_harvested_today: u64,

last_harvest_reset_day: u64,

leaderboard: vector<LeaderboardEntry>

}

struct LeaderboardEntry has copy, drop, store {

user: address,

total_harvested: u64

}

struct UserHarvestStats has copy, drop, store {

lifetime_sht_earned: u64,

total_harvest_attempts: u64,

successful_harvests: u64,

current_ducks_staked: u64,

sht_earned_today: u64,

last_activity_day: u64

}

struct DuckStaked has copy, drop {

nest_id: ID,

duck_id: ID,

staked_duck_id: ID,

owner: address,

slot_index: u8

}

struct DuckUnstaked has copy, drop {

nest_id: ID,

duck_id: ID,

staked_duck_id: ID,

owner: address,

slot_index: u8

}

struct HarvestAttempted has copy, drop {

nest_id: ID,

duck_id: ID,

owner: address,

success: bool,

sht_earned: u64,

luck_used: u8

}

struct SlotUpgraded has copy, drop {

nest_id: ID,

owner: address,

slot_index: u8,

old_level: u8,

new_level: u8,

sht_cost: u64

}

struct AccumulatedHarvest has copy, drop {

nest_id: ID,

duck_id: ID,

owner: address,

cycles_harvested: u64,

total_sht_earned: u64,

harvest_results: vector<HarvestResult>

}

struct HarvestResult has copy, drop {

cycle_number: u64,

success: bool,

sht_earned: u64,

luck_used: u8

}

struct NestCreated has copy, drop {

nest_id: ID,

owner: address

}

struct BatchHarvestCompleted has copy, drop {

owner: address,

ducks_harvested: u64,

total_cycles: u64,

total_sht_earned: u64

}

init(Arg0: &mut TxContext) {

L1: loc0: KioskOwnerCap

L2: loc1: address

L3: loc2: Kiosk

B0:

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

1FreezeRef

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

3StLoc[2](loc1: address)

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

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

6Pack[0](NestAdminCap)

7MoveLoc[2](loc1: address)

8Call transfer::transfer<NestAdminCap>(NestAdminCap, address)

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

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

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

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

13LdFalse

14Pack[2](NestRegistry)

15Call transfer::share_object<NestRegistry>(NestRegistry)

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

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

18LdU64(0)

19LdU64(0)

20LdU64(0)

21LdU64(0)

22LdU64(0)

23LdU64(0)

24VecPack(58, 0)

25Pack[5](HarvestStats)

26Call transfer::share_object<HarvestStats>(HarvestStats)

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

28Call kiosk::new(&mut TxContext): Kiosk * KioskOwnerCap

29StLoc[1](loc0: KioskOwnerCap)

30StLoc[3](loc2: Kiosk)

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

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

33MoveLoc[3](loc2: Kiosk)

34MoveLoc[1](loc0: KioskOwnerCap)

35Pack[1](StakingKiosk)

36Call transfer::share_object<StakingKiosk>(StakingKiosk)

37Ret

}

entry public initialize_nest(Arg0: &NestAdminCap, Arg1: &mut NestRegistry) {

B0:

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

1ImmBorrowField[0](NestRegistry.is_initialized: bool)

2ReadRef

3Not

4BrFalse(6)

B1:

5Branch(10)

B2:

6MoveLoc[1](Arg1: &mut NestRegistry)

7Pop

8LdConst[10](u64: 11)

9Abort

B3:

10LdTrue

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

12MutBorrowField[0](NestRegistry.is_initialized: bool)

13WriteRef

14Ret

}

entry public create_staking_transfer_policy(Arg0: &NestAdminCap, Arg1: &Publisher, Arg2: &mut TxContext) {

L3: loc0: TransferPolicyCap<DuckNFT>

L4: loc1: TransferPolicy<DuckNFT>

B0:

0MoveLoc[1](Arg1: &Publisher)

1CopyLoc[2](Arg2: &mut TxContext)

2Call transfer_policy::new<DuckNFT>(&Publisher, &mut TxContext): TransferPolicy<DuckNFT> * TransferPolicyCap<DuckNFT>

3StLoc[3](loc0: TransferPolicyCap<DuckNFT>)

4StLoc[4](loc1: TransferPolicy<DuckNFT>)

5MutBorrowLoc[4](loc1: TransferPolicy<DuckNFT>)

6ImmBorrowLoc[3](loc0: TransferPolicyCap<DuckNFT>)

7Call kiosk_lock_rule::add<DuckNFT>(&mut TransferPolicy<DuckNFT>, &TransferPolicyCap<DuckNFT>)

8MutBorrowLoc[4](loc1: TransferPolicy<DuckNFT>)

9ImmBorrowLoc[3](loc0: TransferPolicyCap<DuckNFT>)

10LdU16(0)

11LdU64(0)

12Call royalty_rule::add<DuckNFT>(&mut TransferPolicy<DuckNFT>, &TransferPolicyCap<DuckNFT>, u16, u64)

13MoveLoc[4](loc1: TransferPolicy<DuckNFT>)

14Call transfer::public_share_object<TransferPolicy<DuckNFT>>(TransferPolicy<DuckNFT>)

15MoveLoc[3](loc0: TransferPolicyCap<DuckNFT>)

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

17FreezeRef

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

19Call transfer::public_transfer<TransferPolicyCap<DuckNFT>>(TransferPolicyCap<DuckNFT>, address)

20Ret

}

public is_nest_initialized(Arg0: &NestRegistry): bool {

B0:

0MoveLoc[0](Arg0: &NestRegistry)

1ImmBorrowField[0](NestRegistry.is_initialized: bool)

2ReadRef

3Ret

}

entry public create_nest(Arg0: &mut NestRegistry, Arg1: u8, Arg2: &mut TxContext) {

L3: loc0: Nest

L4: loc1: UID

L5: loc2: ID

L6: loc3: address

L7: loc4: &mut Table<u8, ID>

B0:

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

1ImmBorrowField[0](NestRegistry.is_initialized: bool)

2ReadRef

3BrFalse(5)

B1:

4Branch(11)

B2:

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

6Pop

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

8Pop

9LdConst[9](u64: 10)

10Abort

B3:

11CopyLoc[2](Arg2: &mut TxContext)

12FreezeRef

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

14StLoc[6](loc3: address)

15CopyLoc[1](Arg1: u8)

16LdConst[14](u8: 5)

17Lt

18BrFalse(20)

B4:

19Branch(26)

B5:

20MoveLoc[0](Arg0: &mut NestRegistry)

21Pop

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

23Pop

24LdConst[8](u64: 9)

25Abort

B6:

26CopyLoc[0](Arg0: &mut NestRegistry)

27ImmBorrowField[1](NestRegistry.user_nests: Table<address, Table<u8, ID>>)

28CopyLoc[6](loc3: address)

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

30Not

31BrFalse(38)

B7:

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

33MutBorrowField[1](NestRegistry.user_nests: Table<address, Table<u8, ID>>)

34CopyLoc[6](loc3: address)

35CopyLoc[2](Arg2: &mut TxContext)

36Call table::new<u8, ID>(&mut TxContext): Table<u8, ID>

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

B8:

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

39MutBorrowField[1](NestRegistry.user_nests: Table<address, Table<u8, ID>>)

40CopyLoc[6](loc3: address)

41Call table::borrow_mut<address, Table<u8, ID>>(&mut Table<address, Table<u8, ID>>, address): &mut Table<u8, ID>

42StLoc[7](loc4: &mut Table<u8, ID>)

43CopyLoc[7](loc4: &mut Table<u8, ID>)

44FreezeRef

45Call table::length<u8, ID>(&Table<u8, ID>): u64

46LdConst[14](u8: 5)

47CastU64

48Lt

49BrFalse(51)

B9:

50Branch(57)

B10:

51MoveLoc[7](loc4: &mut Table<u8, ID>)

52Pop

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

54Pop

55LdConst[6](u64: 7)

56Abort

B11:

57CopyLoc[7](loc4: &mut Table<u8, ID>)

58FreezeRef

59CopyLoc[1](Arg1: u8)

60Call table::contains<u8, ID>(&Table<u8, ID>, u8): bool

61Not

62BrFalse(64)

B12:

63Branch(70)

B13:

64MoveLoc[7](loc4: &mut Table<u8, ID>)

65Pop

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

67Pop

68LdConst[7](u64: 8)

69Abort

B14:

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

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

72StLoc[4](loc1: UID)

73ImmBorrowLoc[4](loc1: UID)

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

75StLoc[5](loc2: ID)

76MoveLoc[4](loc1: UID)

77CopyLoc[6](loc3: address)

78CopyLoc[1](Arg1: u8)

79LdU8(1)

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

81Pack[3](Nest)

82StLoc[3](loc0: Nest)

83MoveLoc[7](loc4: &mut Table<u8, ID>)

84MoveLoc[1](Arg1: u8)

85CopyLoc[5](loc2: ID)

86Call table::add<u8, ID>(&mut Table<u8, ID>, u8, ID)

87MoveLoc[5](loc2: ID)

88CopyLoc[6](loc3: address)

89Pack[14](NestCreated)

90Call event::emit<NestCreated>(NestCreated)

91MoveLoc[3](loc0: Nest)

92MoveLoc[6](loc3: address)

93Call transfer::transfer<Nest>(Nest, address)

94Ret

}

entry public stake_duck(Arg0: &mut Kiosk, Arg1: &KioskOwnerCap, Arg2: ID, Arg3: &mut Nest, Arg4: &mut StakingKiosk, Arg5: &mut TransferPolicy<DuckNFT>, Arg6: &mut HarvestStats, Arg7: &Clock, Arg8: &mut TxContext) {

L9: loc0: u64

L10: loc1: DuckNFT

L11: loc2: u8

L12: loc3: ID

L13: loc4: u8

L14: loc5: TransferRequest<DuckNFT>

L15: loc6: address

L16: loc7: StakedDuck

L17: loc8: ID

L18: loc9: UID

B0:

0CopyLoc[8](Arg8: &mut TxContext)

1FreezeRef

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

3StLoc[15](loc6: address)

4CopyLoc[3](Arg3: &mut Nest)

5ImmBorrowField[2](Nest.owner: address)

6ReadRef

7CopyLoc[15](loc6: address)

8Eq

9BrFalse(11)

B1:

10Branch(29)

B2:

11MoveLoc[1](Arg1: &KioskOwnerCap)

12Pop

13MoveLoc[0](Arg0: &mut Kiosk)

14Pop

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

16Pop

17MoveLoc[5](Arg5: &mut TransferPolicy<DuckNFT>)

18Pop

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

20Pop

21MoveLoc[6](Arg6: &mut HarvestStats)

22Pop

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

24Pop

25MoveLoc[7](Arg7: &Clock)

26Pop

27LdConst[5](u64: 6)

28Abort

B3:

29CopyLoc[3](Arg3: &mut Nest)

30ImmBorrowField[3](Nest.staked_duck_id: Option<ID>)

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

32BrFalse(34)

B4:

33Branch(52)

B5:

34MoveLoc[1](Arg1: &KioskOwnerCap)

35Pop

36MoveLoc[0](Arg0: &mut Kiosk)

37Pop

38MoveLoc[4](Arg4: &mut StakingKiosk)

39Pop

40MoveLoc[5](Arg5: &mut TransferPolicy<DuckNFT>)

41Pop

42MoveLoc[3](Arg3: &mut Nest)

43Pop

44MoveLoc[6](Arg6: &mut HarvestStats)

45Pop

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

47Pop

48MoveLoc[7](Arg7: &Clock)

49Pop

50LdConst[11](u64: 12)

51Abort

B6:

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

53MoveLoc[1](Arg1: &KioskOwnerCap)

54CopyLoc[2](Arg2: ID)

55LdU64(0)

56Call kiosk::list<DuckNFT>(&mut Kiosk, &KioskOwnerCap, ID, u64)

57MoveLoc[0](Arg0: &mut Kiosk)

58CopyLoc[2](Arg2: ID)

59CopyLoc[8](Arg8: &mut TxContext)

60Call coin::zero<SUI>(&mut TxContext): Coin<SUI>

61Call kiosk::purchase<DuckNFT>(&mut Kiosk, ID, Coin<SUI>): DuckNFT * TransferRequest<DuckNFT>

62StLoc[14](loc5: TransferRequest<DuckNFT>)

63StLoc[10](loc1: DuckNFT)

64ImmBorrowLoc[10](loc1: DuckNFT)

65Call duck_nft::get_rarity_level(&DuckNFT): u8

66StLoc[13](loc4: u8)

67CopyLoc[13](loc4: u8)

68Call get_duck_multiplier(u8): u8

69StLoc[11](loc2: u8)

70CopyLoc[7](Arg7: &Clock)

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

72StLoc[9](loc0: u64)

73MutBorrowLoc[10](loc1: DuckNFT)

74CopyLoc[9](loc0: u64)

75CopyLoc[3](Arg3: &mut Nest)

76ImmBorrowField[4](Nest.level: u8)

77ReadRef

78Call duck_nft::mark_as_staked(&mut DuckNFT, u64, u8)

79CopyLoc[4](Arg4: &mut StakingKiosk)

80MutBorrowField[5](StakingKiosk.kiosk: Kiosk)

81CopyLoc[4](Arg4: &mut StakingKiosk)

82ImmBorrowField[6](StakingKiosk.cap: KioskOwnerCap)

83CopyLoc[5](Arg5: &mut TransferPolicy<DuckNFT>)

84FreezeRef

85MoveLoc[10](loc1: DuckNFT)

86Call kiosk::lock<DuckNFT>(&mut Kiosk, &KioskOwnerCap, &TransferPolicy<DuckNFT>, DuckNFT)

87MutBorrowLoc[14](loc5: TransferRequest<DuckNFT>)

88MoveLoc[4](Arg4: &mut StakingKiosk)

89ImmBorrowField[5](StakingKiosk.kiosk: Kiosk)

90Call kiosk_lock_rule::prove<DuckNFT>(&mut TransferRequest<DuckNFT>, &Kiosk)

91CopyLoc[5](Arg5: &mut TransferPolicy<DuckNFT>)

92FreezeRef

93LdU64(0)

94Call royalty_rule::fee_amount<DuckNFT>(&TransferPolicy<DuckNFT>, u64): u64

95LdU64(0)

96Gt

97BrFalse(110)

B7:

98MoveLoc[5](Arg5: &mut TransferPolicy<DuckNFT>)

99Pop

100MoveLoc[3](Arg3: &mut Nest)

101Pop

102MoveLoc[6](Arg6: &mut HarvestStats)

103Pop

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

105Pop

106MoveLoc[7](Arg7: &Clock)

107Pop

108LdU64(100)

109Abort

B8:

110CopyLoc[5](Arg5: &mut TransferPolicy<DuckNFT>)

111MutBorrowLoc[14](loc5: TransferRequest<DuckNFT>)

112CopyLoc[8](Arg8: &mut TxContext)

113Call coin::zero<SUI>(&mut TxContext): Coin<SUI>

114Call royalty_rule::pay<DuckNFT>(&mut TransferPolicy<DuckNFT>, &mut TransferRequest<DuckNFT>, Coin<SUI>)

115MoveLoc[5](Arg5: &mut TransferPolicy<DuckNFT>)

116FreezeRef

117MoveLoc[14](loc5: TransferRequest<DuckNFT>)

118Call transfer_policy::confirm_request<DuckNFT>(&TransferPolicy<DuckNFT>, TransferRequest<DuckNFT>): ID * u64 * ID

119Pop

120Pop

121Pop

122CopyLoc[3](Arg3: &mut Nest)

123FreezeRef

124Call object::id<Nest>(&Nest): ID

125StLoc[12](loc3: ID)

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

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

128StLoc[18](loc9: UID)

129ImmBorrowLoc[18](loc9: UID)

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

131StLoc[17](loc8: ID)

132MoveLoc[18](loc9: UID)

133CopyLoc[2](Arg2: ID)

134CopyLoc[15](loc6: address)

135CopyLoc[12](loc3: ID)

136CopyLoc[9](loc0: u64)

137MoveLoc[9](loc0: u64)

138MoveLoc[13](loc4: u8)

139MoveLoc[11](loc2: u8)

140Pack[4](StakedDuck)

141StLoc[16](loc7: StakedDuck)

142CopyLoc[3](Arg3: &mut Nest)

143MutBorrowField[3](Nest.staked_duck_id: Option<ID>)

144CopyLoc[17](loc8: ID)

145Call option::fill<ID>(&mut Option<ID>, ID)

146CopyLoc[6](Arg6: &mut HarvestStats)

147ImmBorrowField[7](HarvestStats.active_ducks_staked: u64)

148ReadRef

149LdU64(1)

150Add

151CopyLoc[6](Arg6: &mut HarvestStats)

152MutBorrowField[7](HarvestStats.active_ducks_staked: u64)

153WriteRef

154MoveLoc[6](Arg6: &mut HarvestStats)

155CopyLoc[15](loc6: address)

156LdTrue

157MoveLoc[7](Arg7: &Clock)

158Call update_user_stake_stats(&mut HarvestStats, address, bool, &Clock)

159MoveLoc[12](loc3: ID)

160MoveLoc[2](Arg2: ID)

161MoveLoc[17](loc8: ID)

162CopyLoc[15](loc6: address)

163MoveLoc[3](Arg3: &mut Nest)

164ImmBorrowField[8](Nest.nest_index: u8)

165ReadRef

166Pack[8](DuckStaked)

167Call event::emit<DuckStaked>(DuckStaked)

168MoveLoc[16](loc7: StakedDuck)

169MoveLoc[15](loc6: address)

170Call transfer::transfer<StakedDuck>(StakedDuck, address)

171Ret

}

entry public unstake_duck(Arg0: StakedDuck, Arg1: &mut Nest, Arg2: &mut Kiosk, Arg3: &KioskOwnerCap, Arg4: &mut StakingKiosk, Arg5: &mut TransferPolicy<DuckNFT>, Arg6: &mut HarvestStats, Arg7: &NestMintCap, Arg8: &mut SharedTreasury, Arg9: &Random, Arg10: &Clock, Arg11: &mut TxContext) {

L12: loc0: u64

L13: loc1: u8

L14: loc2: u64

L15: loc3: u8

L16: loc4: u64

L17: loc5: u64

L18: loc6: u64

L19: loc7: DuckNFT

L20: loc8: ID

L21: loc9: u8

L22: loc10: u8

L23: loc11: RandomGenerator

L24: loc12: vector<HarvestResult>

L25: loc13: u64

L26: loc14: u8

L27: loc15: ID

L28: loc16: u64

L29: loc17: TransferRequest<DuckNFT>

L30: loc18: address

L31: loc19: u64

L32: loc20: ID

L33: loc21: bool

L34: loc22: u64

L35: loc23: u8

L36: loc24: u64

B0:

0CopyLoc[11](Arg11: &mut TxContext)

1FreezeRef

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

3StLoc[30](loc18: address)

4CopyLoc[1](Arg1: &mut Nest)

5ImmBorrowField[2](Nest.owner: address)

6ReadRef

7CopyLoc[30](loc18: address)

8Eq

9BrFalse(11)

B1:

10Branch(35)

B2:

11MoveLoc[3](Arg3: &KioskOwnerCap)

12Pop

13MoveLoc[2](Arg2: &mut Kiosk)

14Pop

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

16Pop

17MoveLoc[8](Arg8: &mut SharedTreasury)

18Pop

19MoveLoc[9](Arg9: &Random)

20Pop

21MoveLoc[5](Arg5: &mut TransferPolicy<DuckNFT>)

22Pop

23MoveLoc[7](Arg7: &NestMintCap)

24Pop

25MoveLoc[1](Arg1: &mut Nest)

26Pop

27MoveLoc[6](Arg6: &mut HarvestStats)

28Pop

29MoveLoc[11](Arg11: &mut TxContext)

30Pop

31MoveLoc[10](Arg10: &Clock)

32Pop

33LdConst[5](u64: 6)

34Abort

B3:

35ImmBorrowLoc[0](Arg0: StakedDuck)

36ImmBorrowField[9](StakedDuck.owner: address)

37ReadRef

38CopyLoc[30](loc18: address)

39Eq

40BrFalse(42)

B4:

41Branch(66)

B5:

42MoveLoc[3](Arg3: &KioskOwnerCap)

43Pop

44MoveLoc[2](Arg2: &mut Kiosk)

45Pop

46MoveLoc[4](Arg4: &mut StakingKiosk)

47Pop

48MoveLoc[8](Arg8: &mut SharedTreasury)

49Pop

50MoveLoc[9](Arg9: &Random)

51Pop

52MoveLoc[5](Arg5: &mut TransferPolicy<DuckNFT>)

53Pop

54MoveLoc[7](Arg7: &NestMintCap)

55Pop

56MoveLoc[1](Arg1: &mut Nest)

57Pop

58MoveLoc[6](Arg6: &mut HarvestStats)

59Pop

60MoveLoc[11](Arg11: &mut TxContext)

61Pop

62MoveLoc[10](Arg10: &Clock)

63Pop

64LdConst[5](u64: 6)

65Abort

B6:

66ImmBorrowLoc[0](Arg0: StakedDuck)

67Call object::id<StakedDuck>(&StakedDuck): ID

68StLoc[32](loc20: ID)

69CopyLoc[1](Arg1: &mut Nest)

70ImmBorrowField[3](Nest.staked_duck_id: Option<ID>)

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

72BrFalse(74)

B7:

73Branch(98)

B8:

74MoveLoc[3](Arg3: &KioskOwnerCap)

75Pop

76MoveLoc[2](Arg2: &mut Kiosk)

77Pop

78MoveLoc[4](Arg4: &mut StakingKiosk)

79Pop

80MoveLoc[8](Arg8: &mut SharedTreasury)

81Pop

82MoveLoc[9](Arg9: &Random)

83Pop

84MoveLoc[5](Arg5: &mut TransferPolicy<DuckNFT>)

85Pop

86MoveLoc[7](Arg7: &NestMintCap)

87Pop

88MoveLoc[1](Arg1: &mut Nest)

89Pop

90MoveLoc[6](Arg6: &mut HarvestStats)

91Pop

92MoveLoc[11](Arg11: &mut TxContext)

93Pop

94MoveLoc[10](Arg10: &Clock)

95Pop

96LdConst[12](u64: 13)

97Abort

B9:

98CopyLoc[1](Arg1: &mut Nest)

99ImmBorrowField[3](Nest.staked_duck_id: Option<ID>)

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

101ReadRef

102CopyLoc[32](loc20: ID)

103Eq

104BrFalse(106)

B10:

105Branch(130)

B11:

106MoveLoc[3](Arg3: &KioskOwnerCap)

107Pop

108MoveLoc[2](Arg2: &mut Kiosk)

109Pop

110MoveLoc[4](Arg4: &mut StakingKiosk)

111Pop

112MoveLoc[8](Arg8: &mut SharedTreasury)

113Pop

114MoveLoc[9](Arg9: &Random)

115Pop

116MoveLoc[5](Arg5: &mut TransferPolicy<DuckNFT>)

117Pop

118MoveLoc[7](Arg7: &NestMintCap)

119Pop

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

121Pop

122MoveLoc[6](Arg6: &mut HarvestStats)

123Pop

124MoveLoc[11](Arg11: &mut TxContext)

125Pop

126MoveLoc[10](Arg10: &Clock)

127Pop

128LdConst[13](u64: 14)

129Abort

B12:

130CopyLoc[1](Arg1: &mut Nest)

131FreezeRef

132Call object::id<Nest>(&Nest): ID

133StLoc[27](loc15: ID)

134CopyLoc[10](Arg10: &Clock)

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

136StLoc[16](loc4: u64)

137ImmBorrowLoc[0](Arg0: StakedDuck)

138ImmBorrowField[10](StakedDuck.duck_id: ID)

139ReadRef

140StLoc[20](loc8: ID)

141ImmBorrowLoc[0](Arg0: StakedDuck)

142ImmBorrowField[11](StakedDuck.last_harvest_time: u64)

143ReadRef

144StLoc[25](loc13: u64)

145ImmBorrowLoc[0](Arg0: StakedDuck)

146ImmBorrowField[12](StakedDuck.duck_rarity: u8)

147ReadRef

148StLoc[22](loc10: u8)

149ImmBorrowLoc[0](Arg0: StakedDuck)

150ImmBorrowField[13](StakedDuck.duck_multiplier: u8)

151ReadRef

152StLoc[21](loc9: u8)

153MoveLoc[16](loc4: u64)

154MoveLoc[25](loc13: u64)

155Sub

156LdConst[15](u64: 1440..)

157Div

158StLoc[28](loc16: u64)

159CopyLoc[28](loc16: u64)

160LdU64(0)

161Gt

162BrFalse(285)

B13:

163CopyLoc[28](loc16: u64)

164LdConst[17](u64: 30)

165Gt

166BrFalse(170)

B14:

167LdConst[17](u64: 30)

168StLoc[12](loc0: u64)

169Branch(172)

B15:

170MoveLoc[28](loc16: u64)

171StLoc[12](loc0: u64)

B16:

172MoveLoc[12](loc0: u64)

173StLoc[18](loc6: u64)

174MoveLoc[22](loc10: u8)

175Call get_duck_base_luck(u8): u8

176StLoc[15](loc3: u8)

177CopyLoc[1](Arg1: &mut Nest)

178ImmBorrowField[4](Nest.level: u8)

179ReadRef

180Call get_nest_luck_bonus(u8): u8

181StLoc[26](loc14: u8)

182CopyLoc[15](loc3: u8)

183CopyLoc[26](loc14: u8)

184Add

185LdU8(100)

186Gt

187BrFalse(191)

B17:

188LdU8(100)

189StLoc[13](loc1: u8)

190Branch(195)

B18:

191MoveLoc[15](loc3: u8)

192MoveLoc[26](loc14: u8)

193Add

194StLoc[13](loc1: u8)

B19:

195MoveLoc[13](loc1: u8)

196StLoc[35](loc23: u8)

197MoveLoc[9](Arg9: &Random)

198CopyLoc[11](Arg11: &mut TxContext)

199Call random::new_generator(&Random, &mut TxContext): RandomGenerator

200StLoc[23](loc11: RandomGenerator)

201LdU64(0)

202StLoc[36](loc24: u64)

203VecPack(103, 0)

204StLoc[24](loc12: vector<HarvestResult>)

205LdU64(1)

206StLoc[17](loc5: u64)

207LdU64(0)

208StLoc[34](loc22: u64)

B20:

209CopyLoc[17](loc5: u64)

210CopyLoc[18](loc6: u64)

211Le

212BrFalse(253)

B21:

213MutBorrowLoc[23](loc11: RandomGenerator)

214LdU64(0)

215LdU64(99)

216Call random::generate_u64_in_range(&mut RandomGenerator, u64, u64): u64

217CopyLoc[35](loc23: u8)

218CastU64

219Lt

220StLoc[33](loc21: bool)

221CopyLoc[33](loc21: bool)

222BrFalse(233)

B22:

223MoveLoc[34](loc22: u64)

224LdU64(1)

225Add

226StLoc[34](loc22: u64)

227LdConst[16](u64: 1000..)

228CopyLoc[21](loc9: u8)

229CastU64

230Mul

231StLoc[14](loc2: u64)

232Branch(235)

B23:

233LdU64(0)

234StLoc[14](loc2: u64)

B24:

235MoveLoc[14](loc2: u64)

236StLoc[31](loc19: u64)

237MoveLoc[36](loc24: u64)

238CopyLoc[31](loc19: u64)

239Add

240StLoc[36](loc24: u64)

241MutBorrowLoc[24](loc12: vector<HarvestResult>)

242CopyLoc[17](loc5: u64)

243MoveLoc[33](loc21: bool)

244MoveLoc[31](loc19: u64)

245CopyLoc[35](loc23: u8)

246Pack[13](HarvestResult)

247VecPushBack(103)

248MoveLoc[17](loc5: u64)

249LdU64(1)

250Add

251StLoc[17](loc5: u64)

252Branch(209)

B25:

253CopyLoc[36](loc24: u64)

254LdU64(0)

255Gt

256BrFalse(265)

B26:

257MoveLoc[7](Arg7: &NestMintCap)

258MoveLoc[8](Arg8: &mut SharedTreasury)

259CopyLoc[36](loc24: u64)

260CopyLoc[11](Arg11: &mut TxContext)

261Call shttoken::mint_for_nest(&NestMintCap, &mut SharedTreasury, u64, &mut TxContext): Coin<SHTTOKEN>

262CopyLoc[30](loc18: address)

263Call transfer::public_transfer<Coin<SHTTOKEN>>(Coin<SHTTOKEN>, address)

264Branch(269)

B27:

265MoveLoc[8](Arg8: &mut SharedTreasury)

266Pop

267MoveLoc[7](Arg7: &NestMintCap)

268Pop

B28:

269CopyLoc[6](Arg6: &mut HarvestStats)

270CopyLoc[30](loc18: address)

271CopyLoc[18](loc6: u64)

272MoveLoc[34](loc22: u64)

273CopyLoc[36](loc24: u64)

274CopyLoc[10](Arg10: &Clock)

275Call update_harvest_stats(&mut HarvestStats, address, u64, u64, u64, &Clock)

276CopyLoc[27](loc15: ID)

277CopyLoc[20](loc8: ID)

278CopyLoc[30](loc18: address)

279MoveLoc[18](loc6: u64)

280MoveLoc[36](loc24: u64)

281MoveLoc[24](loc12: vector<HarvestResult>)

282Pack[12](AccumulatedHarvest)

283Call event::emit<AccumulatedHarvest>(AccumulatedHarvest)

284Branch(291)

B29:

285MoveLoc[8](Arg8: &mut SharedTreasury)

286Pop

287MoveLoc[9](Arg9: &Random)

288Pop

289MoveLoc[7](Arg7: &NestMintCap)

290Pop

B30:

291CopyLoc[4](Arg4: &mut StakingKiosk)

292MutBorrowField[5](StakingKiosk.kiosk: Kiosk)

293CopyLoc[4](Arg4: &mut StakingKiosk)

294ImmBorrowField[6](StakingKiosk.cap: KioskOwnerCap)

295CopyLoc[20](loc8: ID)

296LdU64(0)

297Call kiosk::list<DuckNFT>(&mut Kiosk, &KioskOwnerCap, ID, u64)

298MoveLoc[4](Arg4: &mut StakingKiosk)

299MutBorrowField[5](StakingKiosk.kiosk: Kiosk)

300CopyLoc[20](loc8: ID)

301CopyLoc[11](Arg11: &mut TxContext)

302Call coin::zero<SUI>(&mut TxContext): Coin<SUI>

303Call kiosk::purchase<DuckNFT>(&mut Kiosk, ID, Coin<SUI>): DuckNFT * TransferRequest<DuckNFT>

304StLoc[29](loc17: TransferRequest<DuckNFT>)

305StLoc[19](loc7: DuckNFT)

306MutBorrowLoc[19](loc7: DuckNFT)

307Call duck_nft::mark_as_unstaked(&mut DuckNFT)

308CopyLoc[2](Arg2: &mut Kiosk)

309MoveLoc[3](Arg3: &KioskOwnerCap)

310CopyLoc[5](Arg5: &mut TransferPolicy<DuckNFT>)

311FreezeRef

312MoveLoc[19](loc7: DuckNFT)

313Call kiosk::lock<DuckNFT>(&mut Kiosk, &KioskOwnerCap, &TransferPolicy<DuckNFT>, DuckNFT)

314MutBorrowLoc[29](loc17: TransferRequest<DuckNFT>)

315MoveLoc[2](Arg2: &mut Kiosk)

316FreezeRef

317Call kiosk_lock_rule::prove<DuckNFT>(&mut TransferRequest<DuckNFT>, &Kiosk)

318CopyLoc[5](Arg5: &mut TransferPolicy<DuckNFT>)

319FreezeRef

320LdU64(0)

321Call royalty_rule::fee_amount<DuckNFT>(&TransferPolicy<DuckNFT>, u64): u64

322LdU64(0)

323Gt

324BrFalse(337)

B31:

325MoveLoc[5](Arg5: &mut TransferPolicy<DuckNFT>)

326Pop

327MoveLoc[1](Arg1: &mut Nest)

328Pop

329MoveLoc[6](Arg6: &mut HarvestStats)

330Pop

331MoveLoc[11](Arg11: &mut TxContext)

332Pop

333MoveLoc[10](Arg10: &Clock)

334Pop

335LdU64(100)

336Abort

B32:

337CopyLoc[5](Arg5: &mut TransferPolicy<DuckNFT>)

338MutBorrowLoc[29](loc17: TransferRequest<DuckNFT>)

339MoveLoc[11](Arg11: &mut TxContext)

340Call coin::zero<SUI>(&mut TxContext): Coin<SUI>

341Call royalty_rule::pay<DuckNFT>(&mut TransferPolicy<DuckNFT>, &mut TransferRequest<DuckNFT>, Coin<SUI>)

342MoveLoc[5](Arg5: &mut TransferPolicy<DuckNFT>)

343FreezeRef

344MoveLoc[29](loc17: TransferRequest<DuckNFT>)

345Call transfer_policy::confirm_request<DuckNFT>(&TransferPolicy<DuckNFT>, TransferRequest<DuckNFT>): ID * u64 * ID

346Pop

347Pop

348Pop

349MoveLoc[0](Arg0: StakedDuck)

350Unpack[4](StakedDuck)

351Pop

352Pop

353Pop

354Pop

355Pop

356Pop

357Pop

358Call object::delete(UID)

359CopyLoc[1](Arg1: &mut Nest)

360MutBorrowField[3](Nest.staked_duck_id: Option<ID>)

361Call option::extract<ID>(&mut Option<ID>): ID

362Pop

363CopyLoc[6](Arg6: &mut HarvestStats)

364ImmBorrowField[7](HarvestStats.active_ducks_staked: u64)

365ReadRef

366LdU64(0)

367Gt

368BrFalse(377)

B33:

369CopyLoc[6](Arg6: &mut HarvestStats)

370ImmBorrowField[7](HarvestStats.active_ducks_staked: u64)

371ReadRef

372LdU64(1)

373Sub

374CopyLoc[6](Arg6: &mut HarvestStats)

375MutBorrowField[7](HarvestStats.active_ducks_staked: u64)

376WriteRef

B34:

377MoveLoc[6](Arg6: &mut HarvestStats)

378CopyLoc[30](loc18: address)

379LdFalse

380MoveLoc[10](Arg10: &Clock)

381Call update_user_stake_stats(&mut HarvestStats, address, bool, &Clock)

382MoveLoc[27](loc15: ID)

383MoveLoc[20](loc8: ID)

384MoveLoc[32](loc20: ID)

385MoveLoc[30](loc18: address)

386MoveLoc[1](Arg1: &mut Nest)

387ImmBorrowField[8](Nest.nest_index: u8)

388ReadRef

389Pack[9](DuckUnstaked)

390Call event::emit<DuckUnstaked>(DuckUnstaked)

391Ret

}

entry public harvest_duck(Arg0: &mut StakedDuck, Arg1: &Nest, Arg2: &mut HarvestStats, Arg3: &NestMintCap, Arg4: &mut SharedTreasury, Arg5: &Random, Arg6: &Clock, Arg7: &mut TxContext) {

L8: loc0: u64

L9: loc1: u8

L10: loc2: u64

L11: loc3: u64

L12: loc4: u8

L13: loc5: u64

L14: loc6: u64

L15: loc7: u64

L16: loc8: ID

L17: loc9: &HarvestResult

L18: loc10: RandomGenerator

L19: loc11: vector<HarvestResult>

L20: loc12: u64

L21: loc13: u64

L22: loc14: u8

L23: loc15: u8

L24: loc16: ID

L25: loc17: u64

L26: loc18: address

L27: loc19: u64

L28: loc20: ID

L29: loc21: bool

L30: loc22: u64

L31: loc23: u8

L32: loc24: u64

B0:

0CopyLoc[7](Arg7: &mut TxContext)

1FreezeRef

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

3StLoc[26](loc18: address)

4CopyLoc[1](Arg1: &Nest)

5ImmBorrowField[2](Nest.owner: address)

6ReadRef

7CopyLoc[26](loc18: address)

8Eq

9BrFalse(11)

B1:

10Branch(29)

B2:

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

12Pop

13MoveLoc[4](Arg4: &mut SharedTreasury)

14Pop

15MoveLoc[5](Arg5: &Random)

16Pop

17MoveLoc[3](Arg3: &NestMintCap)

18Pop

19MoveLoc[1](Arg1: &Nest)

20Pop

21MoveLoc[2](Arg2: &mut HarvestStats)

22Pop

23MoveLoc[7](Arg7: &mut TxContext)

24Pop

25MoveLoc[6](Arg6: &Clock)

26Pop

27LdConst[5](u64: 6)

28Abort

B3:

29CopyLoc[0](Arg0: &mut StakedDuck)

30ImmBorrowField[9](StakedDuck.owner: address)

31ReadRef

32CopyLoc[26](loc18: address)

33Eq

34BrFalse(36)

B4:

35Branch(54)

B5:

36MoveLoc[0](Arg0: &mut StakedDuck)

37Pop

38MoveLoc[4](Arg4: &mut SharedTreasury)

39Pop

40MoveLoc[5](Arg5: &Random)

41Pop

42MoveLoc[3](Arg3: &NestMintCap)

43Pop

44MoveLoc[1](Arg1: &Nest)

45Pop

46MoveLoc[2](Arg2: &mut HarvestStats)

47Pop

48MoveLoc[7](Arg7: &mut TxContext)

49Pop

50MoveLoc[6](Arg6: &Clock)

51Pop

52LdConst[5](u64: 6)

53Abort

B6:

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

55FreezeRef

56Call object::id<StakedDuck>(&StakedDuck): ID

57StLoc[28](loc20: ID)

58CopyLoc[1](Arg1: &Nest)

59ImmBorrowField[3](Nest.staked_duck_id: Option<ID>)

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

61BrFalse(63)

B7:

62Branch(81)

B8:

63MoveLoc[0](Arg0: &mut StakedDuck)

64Pop

65MoveLoc[4](Arg4: &mut SharedTreasury)

66Pop

67MoveLoc[5](Arg5: &Random)

68Pop

69MoveLoc[3](Arg3: &NestMintCap)

70Pop

71MoveLoc[1](Arg1: &Nest)

72Pop

73MoveLoc[2](Arg2: &mut HarvestStats)

74Pop

75MoveLoc[7](Arg7: &mut TxContext)

76Pop

77MoveLoc[6](Arg6: &Clock)

78Pop

79LdConst[12](u64: 13)

80Abort

B9:

81CopyLoc[1](Arg1: &Nest)

82ImmBorrowField[3](Nest.staked_duck_id: Option<ID>)

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

84ReadRef

85MoveLoc[28](loc20: ID)

86Eq

87BrFalse(89)

B10:

88Branch(107)

B11:

89MoveLoc[0](Arg0: &mut StakedDuck)

90Pop

91MoveLoc[4](Arg4: &mut SharedTreasury)

92Pop

93MoveLoc[5](Arg5: &Random)

94Pop

95MoveLoc[3](Arg3: &NestMintCap)

96Pop

97MoveLoc[1](Arg1: &Nest)

98Pop

99MoveLoc[2](Arg2: &mut HarvestStats)

100Pop

101MoveLoc[7](Arg7: &mut TxContext)

102Pop

103MoveLoc[6](Arg6: &Clock)

104Pop

105LdConst[13](u64: 14)

106Abort

B12:

107CopyLoc[1](Arg1: &Nest)

108Call object::id<Nest>(&Nest): ID

109StLoc[24](loc16: ID)

110CopyLoc[0](Arg0: &mut StakedDuck)

111ImmBorrowField[10](StakedDuck.duck_id: ID)

112ReadRef

113StLoc[16](loc8: ID)

114CopyLoc[6](Arg6: &Clock)

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

116StLoc[13](loc5: u64)

117CopyLoc[0](Arg0: &mut StakedDuck)

118ImmBorrowField[11](StakedDuck.last_harvest_time: u64)

119ReadRef

120StLoc[21](loc13: u64)

121CopyLoc[13](loc5: u64)

122CopyLoc[21](loc13: u64)

123LdConst[15](u64: 1440..)

124Add

125Ge

126BrFalse(128)

B13:

127Branch(146)

B14:

128MoveLoc[0](Arg0: &mut StakedDuck)

129Pop

130MoveLoc[4](Arg4: &mut SharedTreasury)

131Pop

132MoveLoc[5](Arg5: &Random)

133Pop

134MoveLoc[3](Arg3: &NestMintCap)

135Pop

136MoveLoc[1](Arg1: &Nest)

137Pop

138MoveLoc[2](Arg2: &mut HarvestStats)

139Pop

140MoveLoc[7](Arg7: &mut TxContext)

141Pop

142MoveLoc[6](Arg6: &Clock)

143Pop

144LdConst[2](u64: 3)

145Abort

B15:

146CopyLoc[13](loc5: u64)

147CopyLoc[21](loc13: u64)

148Sub

149LdConst[15](u64: 1440..)

150Div

151StLoc[25](loc17: u64)

152CopyLoc[25](loc17: u64)

153LdConst[17](u64: 30)

154Gt

155BrFalse(159)

B16:

156LdConst[17](u64: 30)

157StLoc[8](loc0: u64)

158Branch(161)

B17:

159CopyLoc[25](loc17: u64)

160StLoc[8](loc0: u64)

B18:

161MoveLoc[8](loc0: u64)

162StLoc[15](loc7: u64)

163CopyLoc[0](Arg0: &mut StakedDuck)

164ImmBorrowField[12](StakedDuck.duck_rarity: u8)

165ReadRef

166Call get_duck_base_luck(u8): u8

167StLoc[12](loc4: u8)

168CopyLoc[0](Arg0: &mut StakedDuck)

169ImmBorrowField[13](StakedDuck.duck_multiplier: u8)

170ReadRef

171StLoc[22](loc14: u8)

172MoveLoc[1](Arg1: &Nest)

173ImmBorrowField[4](Nest.level: u8)

174ReadRef

175Call get_nest_luck_bonus(u8): u8

176StLoc[23](loc15: u8)

177CopyLoc[12](loc4: u8)

178CopyLoc[23](loc15: u8)

179Add

180LdU8(100)

181Gt

182BrFalse(186)

B19:

183LdU8(100)

184StLoc[9](loc1: u8)

185Branch(190)

B20:

186MoveLoc[12](loc4: u8)

187MoveLoc[23](loc15: u8)

188Add

189StLoc[9](loc1: u8)

B21:

190MoveLoc[9](loc1: u8)

191StLoc[31](loc23: u8)

192MoveLoc[5](Arg5: &Random)

193CopyLoc[7](Arg7: &mut TxContext)

194Call random::new_generator(&Random, &mut TxContext): RandomGenerator

195StLoc[18](loc10: RandomGenerator)

196LdU64(0)

197StLoc[32](loc24: u64)

198VecPack(103, 0)

199StLoc[19](loc11: vector<HarvestResult>)

200LdU64(1)

201StLoc[14](loc6: u64)

B22:

202CopyLoc[14](loc6: u64)

203CopyLoc[15](loc7: u64)

204Le

205BrFalse(242)

B23:

206MutBorrowLoc[18](loc10: RandomGenerator)

207LdU64(0)

208LdU64(99)

209Call random::generate_u64_in_range(&mut RandomGenerator, u64, u64): u64

210CopyLoc[31](loc23: u8)

211CastU64

212Lt

213StLoc[29](loc21: bool)

214CopyLoc[29](loc21: bool)

215BrFalse(222)

B24:

216LdConst[16](u64: 1000..)

217CopyLoc[22](loc14: u8)

218CastU64

219Mul

220StLoc[10](loc2: u64)

221Branch(224)

B25:

222LdU64(0)

223StLoc[10](loc2: u64)

B26:

224MoveLoc[10](loc2: u64)

225StLoc[27](loc19: u64)

226MoveLoc[32](loc24: u64)

227CopyLoc[27](loc19: u64)

228Add

229StLoc[32](loc24: u64)

230MutBorrowLoc[19](loc11: vector<HarvestResult>)

231CopyLoc[14](loc6: u64)

232MoveLoc[29](loc21: bool)

233MoveLoc[27](loc19: u64)

234CopyLoc[31](loc23: u8)

235Pack[13](HarvestResult)

236VecPushBack(103)

237MoveLoc[14](loc6: u64)

238LdU64(1)

239Add

240StLoc[14](loc6: u64)

241Branch(202)

B27:

242LdU64(0)

243StLoc[30](loc22: u64)

244LdU64(0)

245StLoc[20](loc12: u64)

246Branch(247)

B28:

247CopyLoc[20](loc12: u64)

248ImmBorrowLoc[19](loc11: vector<HarvestResult>)

249VecLen(103)

250Lt

251BrFalse(267)

B29:

252ImmBorrowLoc[19](loc11: vector<HarvestResult>)

253CopyLoc[20](loc12: u64)

254VecImmBorrow(103)

255ImmBorrowField[14](HarvestResult.success: bool)

256ReadRef

257BrFalse(262)

B30:

258MoveLoc[30](loc22: u64)

259LdU64(1)

260Add

261StLoc[30](loc22: u64)

B31:

262MoveLoc[20](loc12: u64)

263LdU64(1)

264Add

265StLoc[20](loc12: u64)

266Branch(247)

B32:

267CopyLoc[32](loc24: u64)

268LdU64(0)

269Gt

270BrFalse(279)

B33:

271MoveLoc[3](Arg3: &NestMintCap)

272MoveLoc[4](Arg4: &mut SharedTreasury)

273CopyLoc[32](loc24: u64)

274MoveLoc[7](Arg7: &mut TxContext)

275Call shttoken::mint_for_nest(&NestMintCap, &mut SharedTreasury, u64, &mut TxContext): Coin<SHTTOKEN>

276CopyLoc[26](loc18: address)

277Call transfer::public_transfer<Coin<SHTTOKEN>>(Coin<SHTTOKEN>, address)

278Branch(285)

B34:

279MoveLoc[4](Arg4: &mut SharedTreasury)

280Pop

281MoveLoc[3](Arg3: &NestMintCap)

282Pop

283MoveLoc[7](Arg7: &mut TxContext)

284Pop

B35:

285MoveLoc[2](Arg2: &mut HarvestStats)

286CopyLoc[26](loc18: address)

287CopyLoc[15](loc7: u64)

288MoveLoc[30](loc22: u64)

289CopyLoc[32](loc24: u64)

290MoveLoc[6](Arg6: &Clock)

291Call update_harvest_stats(&mut HarvestStats, address, u64, u64, u64, &Clock)

292CopyLoc[25](loc17: u64)

293LdConst[17](u64: 30)

294Gt

295BrFalse(299)

B36:

296MoveLoc[13](loc5: u64)

297StLoc[11](loc3: u64)

298Branch(305)

B37:

299MoveLoc[21](loc13: u64)

300MoveLoc[25](loc17: u64)

301LdConst[15](u64: 1440..)

302Mul

303Add

304StLoc[11](loc3: u64)

B38:

305MoveLoc[11](loc3: u64)

306MoveLoc[0](Arg0: &mut StakedDuck)

307MutBorrowField[11](StakedDuck.last_harvest_time: u64)

308WriteRef

309CopyLoc[15](loc7: u64)

310LdU64(1)

311Gt

312BrFalse(322)

B39:

313MoveLoc[24](loc16: ID)

314MoveLoc[16](loc8: ID)

315MoveLoc[26](loc18: address)

316MoveLoc[15](loc7: u64)

317MoveLoc[32](loc24: u64)

318MoveLoc[19](loc11: vector<HarvestResult>)

319Pack[12](AccumulatedHarvest)

320Call event::emit<AccumulatedHarvest>(AccumulatedHarvest)

321Branch(340)

B40:

322ImmBorrowLoc[19](loc11: vector<HarvestResult>)

323LdU64(0)

324VecImmBorrow(103)

325StLoc[17](loc9: &HarvestResult)

326MoveLoc[24](loc16: ID)

327MoveLoc[16](loc8: ID)

328MoveLoc[26](loc18: address)

329CopyLoc[17](loc9: &HarvestResult)

330ImmBorrowField[14](HarvestResult.success: bool)

331ReadRef

332CopyLoc[17](loc9: &HarvestResult)

333ImmBorrowField[15](HarvestResult.sht_earned: u64)

334ReadRef

335MoveLoc[17](loc9: &HarvestResult)

336ImmBorrowField[16](HarvestResult.luck_used: u8)

337ReadRef

338Pack[10](HarvestAttempted)

339Call event::emit<HarvestAttempted>(HarvestAttempted)

B41:

340Ret

}

entry public upgrade_nest(Arg0: &mut Nest, Arg1: &mut Coin<SHTTOKEN>, Arg2: &mut SharedTreasury, Arg3: &mut TxContext) {

L4: loc0: u64

L5: loc1: u8

L6: loc2: u8

L7: loc3: Coin<SHTTOKEN>

L8: loc4: address

B0:

0CopyLoc[3](Arg3: &mut TxContext)

1FreezeRef

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

3StLoc[8](loc4: address)

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

5ImmBorrowField[2](Nest.owner: address)

6ReadRef

7CopyLoc[8](loc4: address)

8Eq

9BrFalse(11)

B1:

10Branch(21)

B2:

11MoveLoc[1](Arg1: &mut Coin<SHTTOKEN>)

12Pop

13MoveLoc[2](Arg2: &mut SharedTreasury)

14Pop

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

16Pop

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

18Pop

19LdConst[5](u64: 6)

20Abort

B3:

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

22ImmBorrowField[4](Nest.level: u8)

23ReadRef

24StLoc[5](loc1: u8)

25CopyLoc[5](loc1: u8)

26LdU8(4)

27Lt

28BrFalse(30)

B4:

29Branch(40)

B5:

30MoveLoc[1](Arg1: &mut Coin<SHTTOKEN>)

31Pop

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

33Pop

34MoveLoc[0](Arg0: &mut Nest)

35Pop

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

37Pop

38LdConst[3](u64: 4)

39Abort

B6:

40CopyLoc[5](loc1: u8)

41LdU8(1)

42Add

43StLoc[6](loc2: u8)

44CopyLoc[6](loc2: u8)

45Call get_upgrade_cost(u8): u64

46StLoc[4](loc0: u64)

47CopyLoc[1](Arg1: &mut Coin<SHTTOKEN>)

48FreezeRef

49Call coin::value<SHTTOKEN>(&Coin<SHTTOKEN>): u64

50CopyLoc[4](loc0: u64)

51Ge

52BrFalse(54)

B7:

53Branch(64)

B8:

54MoveLoc[1](Arg1: &mut Coin<SHTTOKEN>)

55Pop

56MoveLoc[2](Arg2: &mut SharedTreasury)

57Pop

58MoveLoc[0](Arg0: &mut Nest)

59Pop

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

61Pop

62LdConst[4](u64: 5)

63Abort

B9:

64MoveLoc[1](Arg1: &mut Coin<SHTTOKEN>)

65CopyLoc[4](loc0: u64)

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

67Call coin::split<SHTTOKEN>(&mut Coin<SHTTOKEN>, u64, &mut TxContext): Coin<SHTTOKEN>

68StLoc[7](loc3: Coin<SHTTOKEN>)

69MoveLoc[2](Arg2: &mut SharedTreasury)

70MoveLoc[7](loc3: Coin<SHTTOKEN>)

71Call shttoken::burn(&mut SharedTreasury, Coin<SHTTOKEN>)

72CopyLoc[6](loc2: u8)

73CopyLoc[0](Arg0: &mut Nest)

74MutBorrowField[4](Nest.level: u8)

75WriteRef

76CopyLoc[0](Arg0: &mut Nest)

77FreezeRef

78Call object::id<Nest>(&Nest): ID

79MoveLoc[8](loc4: address)

80MoveLoc[0](Arg0: &mut Nest)

81ImmBorrowField[8](Nest.nest_index: u8)

82ReadRef

83MoveLoc[5](loc1: u8)

84MoveLoc[6](loc2: u8)

85MoveLoc[4](loc0: u64)

86Pack[11](SlotUpgraded)

87Call event::emit<SlotUpgraded>(SlotUpgraded)

88Ret

}

process_single_harvest(Arg0: &mut StakedDuck, Arg1: &Nest, Arg2: &mut HarvestStats, Arg3: &mut RandomGenerator, Arg4: &Clock, Arg5: address): u64 * u64 {

L6: loc0: u64

L7: loc1: u8

L8: loc2: u64

L9: loc3: u8

L10: loc4: u64

L11: loc5: u64

L12: loc6: u64

L13: loc7: u64

L14: loc8: u8

L15: loc9: u8

L16: loc10: u64

L17: loc11: ID

L18: loc12: u64

L19: loc13: u8

L20: loc14: u64

B0:

0CopyLoc[1](Arg1: &Nest)

1ImmBorrowField[2](Nest.owner: address)

2ReadRef

3CopyLoc[5](Arg5: address)

4Eq

5BrFalse(7)

B1:

6Branch(19)

B2:

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

8Pop

9MoveLoc[1](Arg1: &Nest)

10Pop

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

12Pop

13MoveLoc[3](Arg3: &mut RandomGenerator)

14Pop

15MoveLoc[4](Arg4: &Clock)

16Pop

17LdConst[5](u64: 6)

18Abort

B3:

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

20ImmBorrowField[9](StakedDuck.owner: address)

21ReadRef

22CopyLoc[5](Arg5: address)

23Eq

24BrFalse(26)

B4:

25Branch(38)

B5:

26MoveLoc[0](Arg0: &mut StakedDuck)

27Pop

28MoveLoc[1](Arg1: &Nest)

29Pop

30MoveLoc[2](Arg2: &mut HarvestStats)

31Pop

32MoveLoc[3](Arg3: &mut RandomGenerator)

33Pop

34MoveLoc[4](Arg4: &Clock)

35Pop

36LdConst[5](u64: 6)

37Abort

B6:

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

39FreezeRef

40Call object::id<StakedDuck>(&StakedDuck): ID

41StLoc[17](loc11: ID)

42CopyLoc[1](Arg1: &Nest)

43ImmBorrowField[3](Nest.staked_duck_id: Option<ID>)

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

45BrFalse(47)

B7:

46Branch(59)

B8:

47MoveLoc[0](Arg0: &mut StakedDuck)

48Pop

49MoveLoc[1](Arg1: &Nest)

50Pop

51MoveLoc[2](Arg2: &mut HarvestStats)

52Pop

53MoveLoc[3](Arg3: &mut RandomGenerator)

54Pop

55MoveLoc[4](Arg4: &Clock)

56Pop

57LdConst[12](u64: 13)

58Abort

B9:

59CopyLoc[1](Arg1: &Nest)

60ImmBorrowField[3](Nest.staked_duck_id: Option<ID>)

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

62ReadRef

63MoveLoc[17](loc11: ID)

64Eq

65BrFalse(67)

B10:

66Branch(79)

B11:

67MoveLoc[0](Arg0: &mut StakedDuck)

68Pop

69MoveLoc[1](Arg1: &Nest)

70Pop

71MoveLoc[2](Arg2: &mut HarvestStats)

72Pop

73MoveLoc[3](Arg3: &mut RandomGenerator)

74Pop

75MoveLoc[4](Arg4: &Clock)

76Pop

77LdConst[13](u64: 14)

78Abort

B12:

79CopyLoc[4](Arg4: &Clock)

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

81StLoc[10](loc4: u64)

82CopyLoc[0](Arg0: &mut StakedDuck)

83ImmBorrowField[11](StakedDuck.last_harvest_time: u64)

84ReadRef

85StLoc[13](loc7: u64)

86CopyLoc[10](loc4: u64)

87CopyLoc[13](loc7: u64)

88LdConst[15](u64: 1440..)

89Add

90Lt

91BrFalse(105)

B13:

92MoveLoc[0](Arg0: &mut StakedDuck)

93Pop

94MoveLoc[1](Arg1: &Nest)

95Pop

96MoveLoc[2](Arg2: &mut HarvestStats)

97Pop

98MoveLoc[3](Arg3: &mut RandomGenerator)

99Pop

100MoveLoc[4](Arg4: &Clock)

101Pop

102LdU64(0)

103LdU64(0)

104Ret

B14:

105CopyLoc[10](loc4: u64)

106CopyLoc[13](loc7: u64)

107Sub

108LdConst[15](u64: 1440..)

109Div

110StLoc[16](loc10: u64)

111CopyLoc[16](loc10: u64)

112LdConst[17](u64: 30)

113Gt

114BrFalse(118)

B15:

115LdConst[17](u64: 30)

116StLoc[6](loc0: u64)

117Branch(120)

B16:

118CopyLoc[16](loc10: u64)

119StLoc[6](loc0: u64)

B17:

120MoveLoc[6](loc0: u64)

121StLoc[12](loc6: u64)

122CopyLoc[0](Arg0: &mut StakedDuck)

123ImmBorrowField[12](StakedDuck.duck_rarity: u8)

124ReadRef

125Call get_duck_base_luck(u8): u8

126StLoc[9](loc3: u8)

127CopyLoc[0](Arg0: &mut StakedDuck)

128ImmBorrowField[13](StakedDuck.duck_multiplier: u8)

129ReadRef

130StLoc[14](loc8: u8)

131MoveLoc[1](Arg1: &Nest)

132ImmBorrowField[4](Nest.level: u8)

133ReadRef

134Call get_nest_luck_bonus(u8): u8

135StLoc[15](loc9: u8)

136CopyLoc[9](loc3: u8)

137CopyLoc[15](loc9: u8)

138Add

139LdU8(100)

140Gt

141BrFalse(145)

B18:

142LdU8(100)

143StLoc[7](loc1: u8)

144Branch(149)

B19:

145MoveLoc[9](loc3: u8)

146MoveLoc[15](loc9: u8)

147Add

148StLoc[7](loc1: u8)

B20:

149MoveLoc[7](loc1: u8)

150StLoc[19](loc13: u8)

151LdU64(0)

152StLoc[20](loc14: u64)

153LdU64(0)

154StLoc[18](loc12: u64)

155LdU64(1)

156StLoc[11](loc5: u64)

B21:

157CopyLoc[11](loc5: u64)

158CopyLoc[12](loc6: u64)

159Le

160BrFalse(185)

B22:

161CopyLoc[3](Arg3: &mut RandomGenerator)

162LdU64(0)

163LdU64(99)

164Call random::generate_u64_in_range(&mut RandomGenerator, u64, u64): u64

165CopyLoc[19](loc13: u8)

166CastU64

167Lt

168BrFalse(180)

B23:

169MoveLoc[18](loc12: u64)

170LdU64(1)

171Add

172StLoc[18](loc12: u64)

173MoveLoc[20](loc14: u64)

174LdConst[16](u64: 1000..)

175CopyLoc[14](loc8: u8)

176CastU64

177Mul

178Add

179StLoc[20](loc14: u64)

B24:

180MoveLoc[11](loc5: u64)

181LdU64(1)

182Add

183StLoc[11](loc5: u64)

184Branch(157)

B25:

185MoveLoc[3](Arg3: &mut RandomGenerator)

186Pop

187MoveLoc[2](Arg2: &mut HarvestStats)

188MoveLoc[5](Arg5: address)

189CopyLoc[12](loc6: u64)

190MoveLoc[18](loc12: u64)

191CopyLoc[20](loc14: u64)

192MoveLoc[4](Arg4: &Clock)

193Call update_harvest_stats(&mut HarvestStats, address, u64, u64, u64, &Clock)

194CopyLoc[16](loc10: u64)

195LdConst[17](u64: 30)

196Gt

197BrFalse(201)

B26:

198MoveLoc[10](loc4: u64)

199StLoc[8](loc2: u64)

200Branch(207)

B27:

201MoveLoc[13](loc7: u64)

202MoveLoc[16](loc10: u64)

203LdConst[15](u64: 1440..)

204Mul

205Add

206StLoc[8](loc2: u64)

B28:

207MoveLoc[8](loc2: u64)

208MoveLoc[0](Arg0: &mut StakedDuck)

209MutBorrowField[11](StakedDuck.last_harvest_time: u64)

210WriteRef

211MoveLoc[20](loc14: u64)

212MoveLoc[12](loc6: u64)

213Ret

}

entry harvest_2(Arg0: &mut StakedDuck, Arg1: &Nest, Arg2: &mut StakedDuck, Arg3: &Nest, Arg4: &mut HarvestStats, Arg5: &NestMintCap, Arg6: &mut SharedTreasury, Arg7: &Random, Arg8: &Clock, Arg9: &mut TxContext) {

L10: loc0: u64

L11: loc1: u64

L12: loc2: u64

L13: loc3: u64

L14: loc4: u64

L15: loc5: u64

L16: loc6: RandomGenerator

L17: loc7: address

L18: loc8: u64

L19: loc9: u64

L20: loc10: u64

L21: loc11: u64

B0:

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

1FreezeRef

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

3StLoc[17](loc7: address)

4MoveLoc[7](Arg7: &Random)

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

6Call random::new_generator(&Random, &mut TxContext): RandomGenerator

7StLoc[16](loc6: RandomGenerator)

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

9MoveLoc[1](Arg1: &Nest)

10CopyLoc[4](Arg4: &mut HarvestStats)

11MutBorrowLoc[16](loc6: RandomGenerator)

12CopyLoc[8](Arg8: &Clock)

13CopyLoc[17](loc7: address)

14Call process_single_harvest(&mut StakedDuck, &Nest, &mut HarvestStats, &mut RandomGenerator, &Clock, address): u64 * u64

15StLoc[13](loc3: u64)

16StLoc[18](loc8: u64)

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

18MoveLoc[3](Arg3: &Nest)

19MoveLoc[4](Arg4: &mut HarvestStats)

20MutBorrowLoc[16](loc6: RandomGenerator)

21MoveLoc[8](Arg8: &Clock)

22CopyLoc[17](loc7: address)

23Call process_single_harvest(&mut StakedDuck, &Nest, &mut HarvestStats, &mut RandomGenerator, &Clock, address): u64 * u64

24StLoc[14](loc4: u64)

25StLoc[19](loc9: u64)

26MoveLoc[18](loc8: u64)

27MoveLoc[19](loc9: u64)

28Add

29StLoc[21](loc11: u64)

30CopyLoc[13](loc3: u64)

31CopyLoc[14](loc4: u64)

32Add

33StLoc[20](loc10: u64)

34MoveLoc[13](loc3: u64)

35LdU64(0)

36Gt

37BrFalse(41)

B1:

38LdU64(1)

39StLoc[10](loc0: u64)

40Branch(43)

B2:

41LdU64(0)

42StLoc[10](loc0: u64)

B3:

43MoveLoc[10](loc0: u64)

44StLoc[12](loc2: u64)

45MoveLoc[14](loc4: u64)

46LdU64(0)

47Gt

48BrFalse(52)

B4:

49LdU64(1)

50StLoc[11](loc1: u64)

51Branch(54)

B5:

52LdU64(0)

53StLoc[11](loc1: u64)

B6:

54MoveLoc[12](loc2: u64)

55MoveLoc[11](loc1: u64)

56Add

57StLoc[15](loc5: u64)

58CopyLoc[21](loc11: u64)

59LdU64(0)

60Gt

61BrFalse(70)

B7:

62MoveLoc[5](Arg5: &NestMintCap)

63MoveLoc[6](Arg6: &mut SharedTreasury)

64CopyLoc[21](loc11: u64)

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

66Call shttoken::mint_for_nest(&NestMintCap, &mut SharedTreasury, u64, &mut TxContext): Coin<SHTTOKEN>

67CopyLoc[17](loc7: address)

68Call transfer::public_transfer<Coin<SHTTOKEN>>(Coin<SHTTOKEN>, address)

69Branch(76)

B8:

70MoveLoc[6](Arg6: &mut SharedTreasury)

71Pop

72MoveLoc[5](Arg5: &NestMintCap)

73Pop

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

75Pop

B9:

76MoveLoc[17](loc7: address)

77MoveLoc[15](loc5: u64)

78MoveLoc[20](loc10: u64)

79MoveLoc[21](loc11: u64)

80Pack[15](BatchHarvestCompleted)

81Call event::emit<BatchHarvestCompleted>(BatchHarvestCompleted)

82Ret

}

entry harvest_3(Arg0: &mut StakedDuck, Arg1: &Nest, Arg2: &mut StakedDuck, Arg3: &Nest, Arg4: &mut StakedDuck, Arg5: &Nest, Arg6: &mut HarvestStats, Arg7: &NestMintCap, Arg8: &mut SharedTreasury, Arg9: &Random, Arg10: &Clock, Arg11: &mut TxContext) {

L12: loc0: u64

L13: loc1: u64

L14: loc2: u64

L15: loc3: u64

L16: loc4: u64

L17: loc5: u64

L18: loc6: u64

L19: loc7: u64

L20: loc8: u64

L21: loc9: RandomGenerator

L22: loc10: address

L23: loc11: u64

L24: loc12: u64

L25: loc13: u64

L26: loc14: u64

L27: loc15: u64

B0:

0CopyLoc[11](Arg11: &mut TxContext)

1FreezeRef

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

3StLoc[22](loc10: address)

4MoveLoc[9](Arg9: &Random)

5CopyLoc[11](Arg11: &mut TxContext)

6Call random::new_generator(&Random, &mut TxContext): RandomGenerator

7StLoc[21](loc9: RandomGenerator)

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

9MoveLoc[1](Arg1: &Nest)

10CopyLoc[6](Arg6: &mut HarvestStats)

11MutBorrowLoc[21](loc9: RandomGenerator)

12CopyLoc[10](Arg10: &Clock)

13CopyLoc[22](loc10: address)

14Call process_single_harvest(&mut StakedDuck, &Nest, &mut HarvestStats, &mut RandomGenerator, &Clock, address): u64 * u64

15StLoc[17](loc5: u64)

16StLoc[23](loc11: u64)

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

18MoveLoc[3](Arg3: &Nest)

19CopyLoc[6](Arg6: &mut HarvestStats)

20MutBorrowLoc[21](loc9: RandomGenerator)

21CopyLoc[10](Arg10: &Clock)

22CopyLoc[22](loc10: address)

23Call process_single_harvest(&mut StakedDuck, &Nest, &mut HarvestStats, &mut RandomGenerator, &Clock, address): u64 * u64

24StLoc[18](loc6: u64)

25StLoc[24](loc12: u64)

26MoveLoc[4](Arg4: &mut StakedDuck)

27MoveLoc[5](Arg5: &Nest)

28MoveLoc[6](Arg6: &mut HarvestStats)

29MutBorrowLoc[21](loc9: RandomGenerator)

30MoveLoc[10](Arg10: &Clock)

31CopyLoc[22](loc10: address)

32Call process_single_harvest(&mut StakedDuck, &Nest, &mut HarvestStats, &mut RandomGenerator, &Clock, address): u64 * u64

33StLoc[19](loc7: u64)

34StLoc[25](loc13: u64)

35MoveLoc[23](loc11: u64)

36MoveLoc[24](loc12: u64)

37Add

38MoveLoc[25](loc13: u64)

39Add

40StLoc[27](loc15: u64)

41CopyLoc[17](loc5: u64)

42CopyLoc[18](loc6: u64)

43Add

44CopyLoc[19](loc7: u64)

45Add

46StLoc[26](loc14: u64)

47MoveLoc[17](loc5: u64)

48LdU64(0)

49Gt

50BrFalse(54)

B1:

51LdU64(1)

52StLoc[12](loc0: u64)

53Branch(56)

B2:

54LdU64(0)

55StLoc[12](loc0: u64)

B3:

56MoveLoc[12](loc0: u64)

57StLoc[16](loc4: u64)

58MoveLoc[18](loc6: u64)

59LdU64(0)

60Gt

61BrFalse(65)

B4:

62LdU64(1)

63StLoc[13](loc1: u64)

64Branch(67)

B5:

65LdU64(0)

66StLoc[13](loc1: u64)

B6:

67MoveLoc[13](loc1: u64)

68StLoc[15](loc3: u64)

69MoveLoc[19](loc7: u64)

70LdU64(0)

71Gt

72BrFalse(76)

B7:

73LdU64(1)

74StLoc[14](loc2: u64)

75Branch(78)

B8:

76LdU64(0)

77StLoc[14](loc2: u64)

B9:

78MoveLoc[16](loc4: u64)

79MoveLoc[15](loc3: u64)

80MoveLoc[14](loc2: u64)

81Add

82Add

83StLoc[20](loc8: u64)

84CopyLoc[27](loc15: u64)

85LdU64(0)

86Gt

87BrFalse(96)

B10:

88MoveLoc[7](Arg7: &NestMintCap)

89MoveLoc[8](Arg8: &mut SharedTreasury)

90CopyLoc[27](loc15: u64)

91MoveLoc[11](Arg11: &mut TxContext)

92Call shttoken::mint_for_nest(&NestMintCap, &mut SharedTreasury, u64, &mut TxContext): Coin<SHTTOKEN>

93CopyLoc[22](loc10: address)

94Call transfer::public_transfer<Coin<SHTTOKEN>>(Coin<SHTTOKEN>, address)

95Branch(102)

B11:

96MoveLoc[8](Arg8: &mut SharedTreasury)

97Pop

98MoveLoc[7](Arg7: &NestMintCap)

99Pop

100MoveLoc[11](Arg11: &mut TxContext)

101Pop

B12:

102MoveLoc[22](loc10: address)

103MoveLoc[20](loc8: u64)

104MoveLoc[26](loc14: u64)

105MoveLoc[27](loc15: u64)

106Pack[15](BatchHarvestCompleted)

107Call event::emit<BatchHarvestCompleted>(BatchHarvestCompleted)

108Ret

}

entry harvest_4(Arg0: &mut StakedDuck, Arg1: &Nest, Arg2: &mut StakedDuck, Arg3: &Nest, Arg4: &mut StakedDuck, Arg5: &Nest, Arg6: &mut StakedDuck, Arg7: &Nest, Arg8: &mut HarvestStats, Arg9: &NestMintCap, Arg10: &mut SharedTreasury, Arg11: &Random, Arg12: &Clock, Arg13: &mut TxContext) {

L14: loc0: u64

L15: loc1: u64

L16: loc2: u64

L17: loc3: u64

L18: loc4: u64

L19: loc5: u64

L20: loc6: u64

L21: loc7: u64

L22: loc8: u64

L23: loc9: u64

L24: loc10: u64

L25: loc11: u64

L26: loc12: RandomGenerator

L27: loc13: address

L28: loc14: u64

L29: loc15: u64

L30: loc16: u64

L31: loc17: u64

L32: loc18: u64

L33: loc19: u64

B0:

0CopyLoc[13](Arg13: &mut TxContext)

1FreezeRef

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

3StLoc[27](loc13: address)

4MoveLoc[11](Arg11: &Random)

5CopyLoc[13](Arg13: &mut TxContext)

6Call random::new_generator(&Random, &mut TxContext): RandomGenerator

7StLoc[26](loc12: RandomGenerator)

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

9MoveLoc[1](Arg1: &Nest)

10CopyLoc[8](Arg8: &mut HarvestStats)

11MutBorrowLoc[26](loc12: RandomGenerator)

12CopyLoc[12](Arg12: &Clock)

13CopyLoc[27](loc13: address)

14Call process_single_harvest(&mut StakedDuck, &Nest, &mut HarvestStats, &mut RandomGenerator, &Clock, address): u64 * u64

15StLoc[21](loc7: u64)

16StLoc[28](loc14: u64)

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

18MoveLoc[3](Arg3: &Nest)

19CopyLoc[8](Arg8: &mut HarvestStats)

20MutBorrowLoc[26](loc12: RandomGenerator)

21CopyLoc[12](Arg12: &Clock)

22CopyLoc[27](loc13: address)

23Call process_single_harvest(&mut StakedDuck, &Nest, &mut HarvestStats, &mut RandomGenerator, &Clock, address): u64 * u64

24StLoc[22](loc8: u64)

25StLoc[29](loc15: u64)

26MoveLoc[4](Arg4: &mut StakedDuck)

27MoveLoc[5](Arg5: &Nest)

28CopyLoc[8](Arg8: &mut HarvestStats)

29MutBorrowLoc[26](loc12: RandomGenerator)

30CopyLoc[12](Arg12: &Clock)

31CopyLoc[27](loc13: address)

32Call process_single_harvest(&mut StakedDuck, &Nest, &mut HarvestStats, &mut RandomGenerator, &Clock, address): u64 * u64

33StLoc[23](loc9: u64)

34StLoc[30](loc16: u64)

35MoveLoc[6](Arg6: &mut StakedDuck)

36MoveLoc[7](Arg7: &Nest)

37MoveLoc[8](Arg8: &mut HarvestStats)

38MutBorrowLoc[26](loc12: RandomGenerator)

39MoveLoc[12](Arg12: &Clock)

40CopyLoc[27](loc13: address)

41Call process_single_harvest(&mut StakedDuck, &Nest, &mut HarvestStats, &mut RandomGenerator, &Clock, address): u64 * u64

42StLoc[24](loc10: u64)

43StLoc[31](loc17: u64)

44MoveLoc[28](loc14: u64)

45MoveLoc[29](loc15: u64)

46Add

47MoveLoc[30](loc16: u64)

48Add

49MoveLoc[31](loc17: u64)

50Add

51StLoc[33](loc19: u64)

52CopyLoc[21](loc7: u64)

53CopyLoc[22](loc8: u64)

54Add

55CopyLoc[23](loc9: u64)

56Add

57CopyLoc[24](loc10: u64)

58Add

59StLoc[32](loc18: u64)

60MoveLoc[21](loc7: u64)

61LdU64(0)

62Gt

63BrFalse(67)

B1:

64LdU64(1)

65StLoc[14](loc0: u64)

66Branch(69)

B2:

67LdU64(0)

68StLoc[14](loc0: u64)

B3:

69MoveLoc[14](loc0: u64)

70StLoc[20](loc6: u64)

71MoveLoc[22](loc8: u64)

72LdU64(0)

73Gt

74BrFalse(78)

B4:

75LdU64(1)

76StLoc[15](loc1: u64)

77Branch(80)

B5:

78LdU64(0)

79StLoc[15](loc1: u64)

B6:

80MoveLoc[15](loc1: u64)

81StLoc[19](loc5: u64)

82MoveLoc[23](loc9: u64)

83LdU64(0)

84Gt

85BrFalse(89)

B7:

86LdU64(1)

87StLoc[16](loc2: u64)

88Branch(91)

B8:

89LdU64(0)

90StLoc[16](loc2: u64)

B9:

91MoveLoc[16](loc2: u64)

92StLoc[18](loc4: u64)

93MoveLoc[24](loc10: u64)

94LdU64(0)

95Gt

96BrFalse(100)

B10:

97LdU64(1)

98StLoc[17](loc3: u64)

99Branch(102)

B11:

100LdU64(0)

101StLoc[17](loc3: u64)

B12:

102MoveLoc[20](loc6: u64)

103MoveLoc[19](loc5: u64)

104MoveLoc[18](loc4: u64)

105MoveLoc[17](loc3: u64)

106Add

107Add

108Add

109StLoc[25](loc11: u64)

110CopyLoc[33](loc19: u64)

111LdU64(0)

112Gt

113BrFalse(122)

B13:

114MoveLoc[9](Arg9: &NestMintCap)

115MoveLoc[10](Arg10: &mut SharedTreasury)

116CopyLoc[33](loc19: u64)

117MoveLoc[13](Arg13: &mut TxContext)

118Call shttoken::mint_for_nest(&NestMintCap, &mut SharedTreasury, u64, &mut TxContext): Coin<SHTTOKEN>

119CopyLoc[27](loc13: address)

120Call transfer::public_transfer<Coin<SHTTOKEN>>(Coin<SHTTOKEN>, address)

121Branch(128)

B14:

122MoveLoc[10](Arg10: &mut SharedTreasury)

123Pop

124MoveLoc[9](Arg9: &NestMintCap)

125Pop

126MoveLoc[13](Arg13: &mut TxContext)

127Pop

B15:

128MoveLoc[27](loc13: address)

129MoveLoc[25](loc11: u64)

130MoveLoc[32](loc18: u64)

131MoveLoc[33](loc19: u64)

132Pack[15](BatchHarvestCompleted)

133Call event::emit<BatchHarvestCompleted>(BatchHarvestCompleted)

134Ret

}

entry harvest_5(Arg0: &mut StakedDuck, Arg1: &Nest, Arg2: &mut StakedDuck, Arg3: &Nest, Arg4: &mut StakedDuck, Arg5: &Nest, Arg6: &mut StakedDuck, Arg7: &Nest, Arg8: &mut StakedDuck, Arg9: &Nest, Arg10: &mut HarvestStats, Arg11: &NestMintCap, Arg12: &mut SharedTreasury, Arg13: &Random, Arg14: &Clock, Arg15: &mut TxContext) {

L16: loc0: u64

L17: loc1: u64

L18: loc2: u64

L19: loc3: u64

L20: loc4: u64

L21: loc5: u64

L22: loc6: u64

L23: loc7: u64

L24: loc8: u64

L25: loc9: u64

L26: loc10: u64

L27: loc11: u64

L28: loc12: u64

L29: loc13: u64

L30: loc14: u64

L31: loc15: RandomGenerator

L32: loc16: address

L33: loc17: u64

L34: loc18: u64

L35: loc19: u64

L36: loc20: u64

L37: loc21: u64

L38: loc22: u64

L39: loc23: u64

B0:

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

1FreezeRef

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

3StLoc[32](loc16: address)

4MoveLoc[13](Arg13: &Random)

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

6Call random::new_generator(&Random, &mut TxContext): RandomGenerator

7StLoc[31](loc15: RandomGenerator)

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

9MoveLoc[1](Arg1: &Nest)

10CopyLoc[10](Arg10: &mut HarvestStats)

11MutBorrowLoc[31](loc15: RandomGenerator)

12CopyLoc[14](Arg14: &Clock)

13CopyLoc[32](loc16: address)

14Call process_single_harvest(&mut StakedDuck, &Nest, &mut HarvestStats, &mut RandomGenerator, &Clock, address): u64 * u64

15StLoc[25](loc9: u64)

16StLoc[33](loc17: u64)

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

18MoveLoc[3](Arg3: &Nest)

19CopyLoc[10](Arg10: &mut HarvestStats)

20MutBorrowLoc[31](loc15: RandomGenerator)

21CopyLoc[14](Arg14: &Clock)

22CopyLoc[32](loc16: address)

23Call process_single_harvest(&mut StakedDuck, &Nest, &mut HarvestStats, &mut RandomGenerator, &Clock, address): u64 * u64

24StLoc[26](loc10: u64)

25StLoc[34](loc18: u64)

26MoveLoc[4](Arg4: &mut StakedDuck)

27MoveLoc[5](Arg5: &Nest)

28CopyLoc[10](Arg10: &mut HarvestStats)

29MutBorrowLoc[31](loc15: RandomGenerator)

30CopyLoc[14](Arg14: &Clock)

31CopyLoc[32](loc16: address)

32Call process_single_harvest(&mut StakedDuck, &Nest, &mut HarvestStats, &mut RandomGenerator, &Clock, address): u64 * u64

33StLoc[27](loc11: u64)

34StLoc[35](loc19: u64)

35MoveLoc[6](Arg6: &mut StakedDuck)

36MoveLoc[7](Arg7: &Nest)

37CopyLoc[10](Arg10: &mut HarvestStats)

38MutBorrowLoc[31](loc15: RandomGenerator)

39CopyLoc[14](Arg14: &Clock)

40CopyLoc[32](loc16: address)

41Call process_single_harvest(&mut StakedDuck, &Nest, &mut HarvestStats, &mut RandomGenerator, &Clock, address): u64 * u64

42StLoc[28](loc12: u64)

43StLoc[36](loc20: u64)

44MoveLoc[8](Arg8: &mut StakedDuck)

45MoveLoc[9](Arg9: &Nest)

46MoveLoc[10](Arg10: &mut HarvestStats)

47MutBorrowLoc[31](loc15: RandomGenerator)

48MoveLoc[14](Arg14: &Clock)

49CopyLoc[32](loc16: address)

50Call process_single_harvest(&mut StakedDuck, &Nest, &mut HarvestStats, &mut RandomGenerator, &Clock, address): u64 * u64

51StLoc[29](loc13: u64)

52StLoc[37](loc21: u64)

53MoveLoc[33](loc17: u64)

54MoveLoc[34](loc18: u64)

55Add

56MoveLoc[35](loc19: u64)

57Add

58MoveLoc[36](loc20: u64)

59Add

60MoveLoc[37](loc21: u64)

61Add

62StLoc[39](loc23: u64)

63CopyLoc[25](loc9: u64)

64CopyLoc[26](loc10: u64)

65Add

66CopyLoc[27](loc11: u64)

67Add

68CopyLoc[28](loc12: u64)

69Add

70CopyLoc[29](loc13: u64)

71Add

72StLoc[38](loc22: u64)

73MoveLoc[25](loc9: u64)

74LdU64(0)

75Gt

76BrFalse(80)

B1:

77LdU64(1)

78StLoc[16](loc0: u64)

79Branch(82)

B2:

80LdU64(0)

81StLoc[16](loc0: u64)

B3:

82MoveLoc[16](loc0: u64)

83StLoc[24](loc8: u64)

84MoveLoc[26](loc10: u64)

85LdU64(0)

86Gt

87BrFalse(91)

B4:

88LdU64(1)

89StLoc[17](loc1: u64)

90Branch(93)

B5:

91LdU64(0)

92StLoc[17](loc1: u64)

B6:

93MoveLoc[17](loc1: u64)

94StLoc[23](loc7: u64)

95MoveLoc[27](loc11: u64)

96LdU64(0)

97Gt

98BrFalse(102)

B7:

99LdU64(1)

100StLoc[18](loc2: u64)

101Branch(104)

B8:

102LdU64(0)

103StLoc[18](loc2: u64)

B9:

104MoveLoc[18](loc2: u64)

105StLoc[22](loc6: u64)

106MoveLoc[28](loc12: u64)

107LdU64(0)

108Gt

109BrFalse(113)

B10:

110LdU64(1)

111StLoc[19](loc3: u64)

112Branch(115)

B11:

113LdU64(0)

114StLoc[19](loc3: u64)

B12:

115MoveLoc[19](loc3: u64)

116StLoc[21](loc5: u64)

117MoveLoc[29](loc13: u64)

118LdU64(0)

119Gt

120BrFalse(124)

B13:

121LdU64(1)

122StLoc[20](loc4: u64)

123Branch(126)

B14:

124LdU64(0)

125StLoc[20](loc4: u64)

B15:

126MoveLoc[24](loc8: u64)

127MoveLoc[23](loc7: u64)

128MoveLoc[22](loc6: u64)

129MoveLoc[21](loc5: u64)

130MoveLoc[20](loc4: u64)

131Add

132Add

133Add

134Add

135StLoc[30](loc14: u64)

136CopyLoc[39](loc23: u64)

137LdU64(0)

138Gt

139BrFalse(148)

B16:

140MoveLoc[11](Arg11: &NestMintCap)

141MoveLoc[12](Arg12: &mut SharedTreasury)

142CopyLoc[39](loc23: u64)

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

144Call shttoken::mint_for_nest(&NestMintCap, &mut SharedTreasury, u64, &mut TxContext): Coin<SHTTOKEN>

145CopyLoc[32](loc16: address)

146Call transfer::public_transfer<Coin<SHTTOKEN>>(Coin<SHTTOKEN>, address)

147Branch(154)

B17:

148MoveLoc[12](Arg12: &mut SharedTreasury)

149Pop

150MoveLoc[11](Arg11: &NestMintCap)

151Pop

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

153Pop

B18:

154MoveLoc[32](loc16: address)

155MoveLoc[30](loc14: u64)

156MoveLoc[38](loc22: u64)

157MoveLoc[39](loc23: u64)

158Pack[15](BatchHarvestCompleted)

159Call event::emit<BatchHarvestCompleted>(BatchHarvestCompleted)

160Ret

}

get_duck_base_luck(Arg0: u8): u8 {

L1: loc0: u8

L2: loc1: u8

L3: loc2: u8

B0:

0CopyLoc[0](Arg0: u8)

1LdConst[23](u8: 3)

2Eq

3BrFalse(7)

B1:

4LdConst[21](u8: 85)

5StLoc[3](loc2: u8)

6Branch(27)

B2:

7CopyLoc[0](Arg0: u8)

8LdConst[31](u8: 2)

9Eq

10BrFalse(14)

B3:

11LdConst[20](u8: 60)

12StLoc[2](loc1: u8)

13Branch(25)

B4:

14MoveLoc[0](Arg0: u8)

15LdConst[22](u8: 1)

16Eq

17BrFalse(21)

B5:

18LdConst[19](u8: 50)

19StLoc[1](loc0: u8)

20Branch(23)

B6:

21LdConst[18](u8: 40)

22StLoc[1](loc0: u8)

B7:

23MoveLoc[1](loc0: u8)

24StLoc[2](loc1: u8)

B8:

25MoveLoc[2](loc1: u8)

26StLoc[3](loc2: u8)

B9:

27MoveLoc[3](loc2: u8)

28Ret

}

get_duck_multiplier(Arg0: u8): u8 {

L1: loc0: u8

L2: loc1: u8

L3: loc2: u8

B0:

0CopyLoc[0](Arg0: u8)

1LdConst[23](u8: 3)

2Eq

3BrFalse(7)

B1:

4LdConst[24](u8: 7)

5StLoc[3](loc2: u8)

6Branch(27)

B2:

7CopyLoc[0](Arg0: u8)

8LdConst[31](u8: 2)

9Eq

10BrFalse(14)

B3:

11LdConst[14](u8: 5)

12StLoc[2](loc1: u8)

13Branch(25)

B4:

14MoveLoc[0](Arg0: u8)

15LdConst[22](u8: 1)

16Eq

17BrFalse(21)

B5:

18LdConst[23](u8: 3)

19StLoc[1](loc0: u8)

20Branch(23)

B6:

21LdConst[22](u8: 1)

22StLoc[1](loc0: u8)

B7:

23MoveLoc[1](loc0: u8)

24StLoc[2](loc1: u8)

B8:

25MoveLoc[2](loc1: u8)

26StLoc[3](loc2: u8)

B9:

27MoveLoc[3](loc2: u8)

28Ret

}

get_nest_luck_bonus(Arg0: u8): u8 {

L1: loc0: u8

L2: loc1: u8

L3: loc2: u8

B0:

0CopyLoc[0](Arg0: u8)

1LdU8(4)

2Eq

3BrFalse(7)

B1:

4LdConst[29](u8: 15)

5StLoc[3](loc2: u8)

6Branch(27)

B2:

7CopyLoc[0](Arg0: u8)

8LdU8(3)

9Eq

10BrFalse(14)

B3:

11LdConst[28](u8: 10)

12StLoc[2](loc1: u8)

13Branch(25)

B4:

14MoveLoc[0](Arg0: u8)

15LdU8(2)

16Eq

17BrFalse(21)

B5:

18LdConst[14](u8: 5)

19StLoc[1](loc0: u8)

20Branch(23)

B6:

21LdU8(0)

22StLoc[1](loc0: u8)

B7:

23MoveLoc[1](loc0: u8)

24StLoc[2](loc1: u8)

B8:

25MoveLoc[2](loc1: u8)

26StLoc[3](loc2: u8)

B9:

27MoveLoc[3](loc2: u8)

28Ret

}

get_upgrade_cost(Arg0: u8): u64 {

L1: loc0: u64

L2: loc1: u64

L3: loc2: u64

B0:

0CopyLoc[0](Arg0: u8)

1LdU8(2)

2Eq

3BrFalse(7)

B1:

4LdConst[25](u64: 4000..)

5StLoc[3](loc2: u64)

6Branch(27)

B2:

7CopyLoc[0](Arg0: u8)

8LdU8(3)

9Eq

10BrFalse(14)

B3:

11LdConst[26](u64: 6000..)

12StLoc[2](loc1: u64)

13Branch(25)

B4:

14MoveLoc[0](Arg0: u8)

15LdU8(4)

16Eq

17BrFalse(21)

B5:

18LdConst[27](u64: 1000..)

19StLoc[1](loc0: u64)

20Branch(23)

B6:

21LdU64(0)

22StLoc[1](loc0: u64)

B7:

23MoveLoc[1](loc0: u64)

24StLoc[2](loc1: u64)

B8:

25MoveLoc[2](loc1: u64)

26StLoc[3](loc2: u64)

B9:

27MoveLoc[3](loc2: u64)

28Ret

}

public get_nest_info(Arg0: &Nest): u8 * u8 * bool * address {

B0:

0CopyLoc[0](Arg0: &Nest)

1ImmBorrowField[8](Nest.nest_index: u8)

2ReadRef

3CopyLoc[0](Arg0: &Nest)

4ImmBorrowField[4](Nest.level: u8)

5ReadRef

6CopyLoc[0](Arg0: &Nest)

7ImmBorrowField[3](Nest.staked_duck_id: Option<ID>)

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

9MoveLoc[0](Arg0: &Nest)

10ImmBorrowField[2](Nest.owner: address)

11ReadRef

12Ret

}

public get_nest_level(Arg0: &Nest): u8 {

B0:

0MoveLoc[0](Arg0: &Nest)

1ImmBorrowField[4](Nest.level: u8)

2ReadRef

3Ret

}

public get_staked_duck_id(Arg0: &Nest): Option<ID> {

B0:

0MoveLoc[0](Arg0: &Nest)

1ImmBorrowField[3](Nest.staked_duck_id: Option<ID>)

2ReadRef

3Ret

}

public get_staked_duck_info(Arg0: &StakedDuck): ID * address * ID * u64 * u64 * u8 * u8 {

B0:

0CopyLoc[0](Arg0: &StakedDuck)

1ImmBorrowField[10](StakedDuck.duck_id: ID)

2ReadRef

3CopyLoc[0](Arg0: &StakedDuck)

4ImmBorrowField[9](StakedDuck.owner: address)

5ReadRef

6CopyLoc[0](Arg0: &StakedDuck)

7ImmBorrowField[17](StakedDuck.nest_id: ID)

8ReadRef

9CopyLoc[0](Arg0: &StakedDuck)

10ImmBorrowField[18](StakedDuck.staked_at: u64)

11ReadRef

12CopyLoc[0](Arg0: &StakedDuck)

13ImmBorrowField[11](StakedDuck.last_harvest_time: u64)

14ReadRef

15CopyLoc[0](Arg0: &StakedDuck)

16ImmBorrowField[12](StakedDuck.duck_rarity: u8)

17ReadRef

18MoveLoc[0](Arg0: &StakedDuck)

19ImmBorrowField[13](StakedDuck.duck_multiplier: u8)

20ReadRef

21Ret

}

public get_original_duck_id(Arg0: &StakedDuck): ID {

B0:

0MoveLoc[0](Arg0: &StakedDuck)

1ImmBorrowField[10](StakedDuck.duck_id: ID)

2ReadRef

3Ret

}

public is_staked_duck_ready_to_harvest(Arg0: &StakedDuck, Arg1: &Clock): bool {

B0:

0MoveLoc[1](Arg1: &Clock)

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

2MoveLoc[0](Arg0: &StakedDuck)

3ImmBorrowField[11](StakedDuck.last_harvest_time: u64)

4ReadRef

5LdConst[15](u64: 1440..)

6Add

7Ge

8Ret

}

public get_available_harvest_cycles(Arg0: &StakedDuck, Arg1: &Clock): u64 {

L2: loc0: u64

L3: loc1: u64

L4: loc2: u64

L5: loc3: u64

B0:

0MoveLoc[1](Arg1: &Clock)

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

2StLoc[3](loc1: u64)

3MoveLoc[0](Arg0: &StakedDuck)

4ImmBorrowField[11](StakedDuck.last_harvest_time: u64)

5ReadRef

6StLoc[4](loc2: u64)

7CopyLoc[3](loc1: u64)

8CopyLoc[4](loc2: u64)

9Le

10BrFalse(13)

B1:

11LdU64(0)

12Ret

B2:

13MoveLoc[3](loc1: u64)

14MoveLoc[4](loc2: u64)

15Sub

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

17Div

18StLoc[5](loc3: u64)

19CopyLoc[5](loc3: u64)

20LdConst[17](u64: 30)

21Gt

22BrFalse(26)

B3:

23LdConst[17](u64: 30)

24StLoc[2](loc0: u64)

25Branch(28)

B4:

26MoveLoc[5](loc3: u64)

27StLoc[2](loc0: u64)

B5:

28MoveLoc[2](loc0: u64)

29Ret

}

public get_time_until_harvest(Arg0: &StakedDuck, Arg1: &Clock): u64 {

L2: loc0: u64

L3: loc1: u64

L4: loc2: u64

B0:

0MoveLoc[1](Arg1: &Clock)

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

2StLoc[3](loc1: u64)

3MoveLoc[0](Arg0: &StakedDuck)

4ImmBorrowField[11](StakedDuck.last_harvest_time: u64)

5ReadRef

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

7Add

8StLoc[4](loc2: u64)

9CopyLoc[3](loc1: u64)

10CopyLoc[4](loc2: u64)

11Ge

12BrFalse(16)

B1:

13LdU64(0)

14StLoc[2](loc0: u64)

15Branch(20)

B2:

16MoveLoc[4](loc2: u64)

17MoveLoc[3](loc1: u64)

18Sub

19StLoc[2](loc0: u64)

B3:

20MoveLoc[2](loc0: u64)

21Ret

}

public get_harvest_info(Arg0: &StakedDuck, Arg1: &Nest, Arg2: &Clock): u64 * u64 * bool * u64 {

L3: loc0: u64

L4: loc1: bool

L5: loc2: u64

L6: loc3: u64

B0:

0CopyLoc[0](Arg0: &StakedDuck)

1CopyLoc[2](Arg2: &Clock)

2Call get_available_harvest_cycles(&StakedDuck, &Clock): u64

3StLoc[3](loc0: u64)

4CopyLoc[0](Arg0: &StakedDuck)

5MoveLoc[2](Arg2: &Clock)

6Call get_time_until_harvest(&StakedDuck, &Clock): u64

7StLoc[6](loc3: u64)

8CopyLoc[3](loc0: u64)

9LdU64(0)

10Gt

11StLoc[4](loc1: bool)

12CopyLoc[3](loc0: u64)

13LdConst[16](u64: 1000..)

14Mul

15MoveLoc[0](Arg0: &StakedDuck)

16ImmBorrowField[13](StakedDuck.duck_multiplier: u8)

17ReadRef

18CastU64

19Mul

20StLoc[5](loc2: u64)

21MoveLoc[3](loc0: u64)

22MoveLoc[6](loc3: u64)

23MoveLoc[4](loc1: bool)

24MoveLoc[5](loc2: u64)

25Ret

}

update_harvest_stats(Arg0: &mut HarvestStats, Arg1: address, Arg2: u64, Arg3: u64, Arg4: u64, Arg5: &Clock) {

L6: loc0: u64

L7: loc1: &mut UserHarvestStats

L8: loc2: UserHarvestStats

B0:

0MoveLoc[5](Arg5: &Clock)

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

2LdU64(86400000)

3Div

4StLoc[6](loc0: u64)

5CopyLoc[6](loc0: u64)

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

7ImmBorrowField[19](HarvestStats.last_harvest_reset_day: u64)

8ReadRef

9Gt

10BrFalse(19)

B1:

11LdU64(0)

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

13MutBorrowField[20](HarvestStats.sht_harvested_today: u64)

14WriteRef

15CopyLoc[6](loc0: u64)

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

17MutBorrowField[19](HarvestStats.last_harvest_reset_day: u64)

18WriteRef

B2:

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

20ImmBorrowField[21](HarvestStats.total_harvest_attempts: u64)

21ReadRef

22CopyLoc[2](Arg2: u64)

23Add

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

25MutBorrowField[21](HarvestStats.total_harvest_attempts: u64)

26WriteRef

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

28ImmBorrowField[22](HarvestStats.total_successful_harvests: u64)

29ReadRef

30CopyLoc[3](Arg3: u64)

31Add

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

33MutBorrowField[22](HarvestStats.total_successful_harvests: u64)

34WriteRef

35CopyLoc[0](Arg0: &mut HarvestStats)

36ImmBorrowField[23](HarvestStats.total_sht_harvested: u64)

37ReadRef

38CopyLoc[4](Arg4: u64)

39Add

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

41MutBorrowField[23](HarvestStats.total_sht_harvested: u64)

42WriteRef

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

44ImmBorrowField[20](HarvestStats.sht_harvested_today: u64)

45ReadRef

46CopyLoc[4](Arg4: u64)

47Add

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

49MutBorrowField[20](HarvestStats.sht_harvested_today: u64)

50WriteRef

51CopyLoc[0](Arg0: &mut HarvestStats)

52ImmBorrowField[24](HarvestStats.id: UID)

53CopyLoc[1](Arg1: address)

54Call dynamic_field::exists_<address>(&UID, address): bool

55BrFalse(108)

B3:

56CopyLoc[0](Arg0: &mut HarvestStats)

57MutBorrowField[24](HarvestStats.id: UID)

58CopyLoc[1](Arg1: address)

59Call dynamic_field::borrow_mut<address, UserHarvestStats>(&mut UID, address): &mut UserHarvestStats

60StLoc[7](loc1: &mut UserHarvestStats)

61CopyLoc[6](loc0: u64)

62CopyLoc[7](loc1: &mut UserHarvestStats)

63ImmBorrowField[25](UserHarvestStats.last_activity_day: u64)

64ReadRef

65Gt

66BrFalse(71)

B4:

67LdU64(0)

68CopyLoc[7](loc1: &mut UserHarvestStats)

69MutBorrowField[26](UserHarvestStats.sht_earned_today: u64)

70WriteRef

B5:

71CopyLoc[7](loc1: &mut UserHarvestStats)

72ImmBorrowField[27](UserHarvestStats.lifetime_sht_earned: u64)

73ReadRef

74CopyLoc[4](Arg4: u64)

75Add

76CopyLoc[7](loc1: &mut UserHarvestStats)

77MutBorrowField[27](UserHarvestStats.lifetime_sht_earned: u64)

78WriteRef

79CopyLoc[7](loc1: &mut UserHarvestStats)

80ImmBorrowField[28](UserHarvestStats.total_harvest_attempts: u64)

81ReadRef

82MoveLoc[2](Arg2: u64)

83Add

84CopyLoc[7](loc1: &mut UserHarvestStats)

85MutBorrowField[28](UserHarvestStats.total_harvest_attempts: u64)

86WriteRef

87CopyLoc[7](loc1: &mut UserHarvestStats)

88ImmBorrowField[29](UserHarvestStats.successful_harvests: u64)

89ReadRef

90MoveLoc[3](Arg3: u64)

91Add

92CopyLoc[7](loc1: &mut UserHarvestStats)

93MutBorrowField[29](UserHarvestStats.successful_harvests: u64)

94WriteRef

95CopyLoc[7](loc1: &mut UserHarvestStats)

96ImmBorrowField[26](UserHarvestStats.sht_earned_today: u64)

97ReadRef

98CopyLoc[4](Arg4: u64)

99Add

100CopyLoc[7](loc1: &mut UserHarvestStats)

101MutBorrowField[26](UserHarvestStats.sht_earned_today: u64)

102WriteRef

103MoveLoc[6](loc0: u64)

104MoveLoc[7](loc1: &mut UserHarvestStats)

105MutBorrowField[25](UserHarvestStats.last_activity_day: u64)

106WriteRef

107Branch(121)

B6:

108CopyLoc[4](Arg4: u64)

109MoveLoc[2](Arg2: u64)

110MoveLoc[3](Arg3: u64)

111LdU64(0)

112CopyLoc[4](Arg4: u64)

113MoveLoc[6](loc0: u64)

114Pack[7](UserHarvestStats)

115StLoc[8](loc2: UserHarvestStats)

116CopyLoc[0](Arg0: &mut HarvestStats)

117MutBorrowField[24](HarvestStats.id: UID)

118CopyLoc[1](Arg1: address)

119MoveLoc[8](loc2: UserHarvestStats)

120Call dynamic_field::add<address, UserHarvestStats>(&mut UID, address, UserHarvestStats)

B7:

121MoveLoc[4](Arg4: u64)

122LdU64(0)

123Gt

124BrFalse(129)

B8:

125MoveLoc[0](Arg0: &mut HarvestStats)

126MoveLoc[1](Arg1: address)

127Call update_leaderboard(&mut HarvestStats, address)

128Branch(131)

B9:

129MoveLoc[0](Arg0: &mut HarvestStats)

130Pop

B10:

131Ret

}

update_user_stake_stats(Arg0: &mut HarvestStats, Arg1: address, Arg2: bool, Arg3: &Clock) {

L4: loc0: u64

L5: loc1: u64

L6: loc2: &mut UserHarvestStats

L7: loc3: UserHarvestStats

B0:

0MoveLoc[3](Arg3: &Clock)

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

2LdU64(86400000)

3Div

4StLoc[5](loc1: u64)

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

6ImmBorrowField[24](HarvestStats.id: UID)

7CopyLoc[1](Arg1: address)

8Call dynamic_field::exists_<address>(&UID, address): bool

9BrFalse(45)

B1:

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

11MutBorrowField[24](HarvestStats.id: UID)

12MoveLoc[1](Arg1: address)

13Call dynamic_field::borrow_mut<address, UserHarvestStats>(&mut UID, address): &mut UserHarvestStats

14StLoc[6](loc2: &mut UserHarvestStats)

15MoveLoc[2](Arg2: bool)

16BrFalse(26)

B2:

17CopyLoc[6](loc2: &mut UserHarvestStats)

18ImmBorrowField[30](UserHarvestStats.current_ducks_staked: u64)

19ReadRef

20LdU64(1)

21Add

22CopyLoc[6](loc2: &mut UserHarvestStats)

23MutBorrowField[30](UserHarvestStats.current_ducks_staked: u64)

24WriteRef

25Branch(40)

B3:

26CopyLoc[6](loc2: &mut UserHarvestStats)

27ImmBorrowField[30](UserHarvestStats.current_ducks_staked: u64)

28ReadRef

29LdU64(0)

30Gt

31BrFalse(40)

B4:

32CopyLoc[6](loc2: &mut UserHarvestStats)

33ImmBorrowField[30](UserHarvestStats.current_ducks_staked: u64)

34ReadRef

35LdU64(1)

36Sub

37CopyLoc[6](loc2: &mut UserHarvestStats)

38MutBorrowField[30](UserHarvestStats.current_ducks_staked: u64)

39WriteRef

B5:

40MoveLoc[5](loc1: u64)

41MoveLoc[6](loc2: &mut UserHarvestStats)

42MutBorrowField[25](UserHarvestStats.last_activity_day: u64)

43WriteRef

44Branch(65)

B6:

45MoveLoc[2](Arg2: bool)

46BrFalse(50)

B7:

47LdU64(1)

48StLoc[4](loc0: u64)

49Branch(52)

B8:

50LdU64(0)

51StLoc[4](loc0: u64)

B9:

52LdU64(0)

53LdU64(0)

54LdU64(0)

55MoveLoc[4](loc0: u64)

56LdU64(0)

57MoveLoc[5](loc1: u64)

58Pack[7](UserHarvestStats)

59StLoc[7](loc3: UserHarvestStats)

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

61MutBorrowField[24](HarvestStats.id: UID)

62MoveLoc[1](Arg1: address)

63MoveLoc[7](loc3: UserHarvestStats)

64Call dynamic_field::add<address, UserHarvestStats>(&mut UID, address, UserHarvestStats)

B10:

65Ret

}

update_leaderboard(Arg0: &mut HarvestStats, Arg1: address) {

L2: loc0: u64

L3: loc1: &mut LeaderboardEntry

L4: loc2: &mut LeaderboardEntry

L5: loc3: u64

L6: loc4: Option<u64>

L7: loc5: u64

L8: loc6: u64

L9: loc7: u64

L10: loc8: u64

L11: loc9: u64

L12: loc10: u64

L13: loc11: u64

L14: loc12: u64

L15: loc13: u64

L16: loc14: u64

L17: loc15: u64

B0:

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

1ImmBorrowField[24](HarvestStats.id: UID)

2CopyLoc[1](Arg1: address)

3Call dynamic_field::exists_<address>(&UID, address): bool

4BrFalse(6)

B1:

5Branch(9)

B2:

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

7Pop

8Ret

B3:

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

10ImmBorrowField[24](HarvestStats.id: UID)

11CopyLoc[1](Arg1: address)

12Call dynamic_field::borrow<address, UserHarvestStats>(&UID, address): &UserHarvestStats

13ImmBorrowField[27](UserHarvestStats.lifetime_sht_earned: u64)

14ReadRef

15StLoc[17](loc15: u64)

16Call option::none<u64>(): Option<u64>

17StLoc[6](loc4: Option<u64>)

18LdU64(0)

19StLoc[7](loc5: u64)

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

21ImmBorrowField[31](HarvestStats.leaderboard: vector<LeaderboardEntry>)

22VecLen(58)

23StLoc[12](loc10: u64)

B4:

24CopyLoc[7](loc5: u64)

25CopyLoc[12](loc10: u64)

26Lt

27BrFalse(47)

B5:

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

29ImmBorrowField[31](HarvestStats.leaderboard: vector<LeaderboardEntry>)

30CopyLoc[7](loc5: u64)

31VecImmBorrow(58)

32ImmBorrowField[32](LeaderboardEntry.user: address)

33ReadRef

34CopyLoc[1](Arg1: address)

35Eq

36BrFalse(42)

B6:

37Branch(38)

B7:

38MoveLoc[7](loc5: u64)

39Call option::some<u64>(u64): Option<u64>

40StLoc[6](loc4: Option<u64>)

41Branch(47)

B8:

42MoveLoc[7](loc5: u64)

43LdU64(1)

44Add

45StLoc[7](loc5: u64)

46Branch(24)

B9:

47ImmBorrowLoc[6](loc4: Option<u64>)

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

49BrFalse(64)

B10:

50ImmBorrowLoc[6](loc4: Option<u64>)

51Call option::borrow<u64>(&Option<u64>): &u64

52ReadRef

53StLoc[8](loc6: u64)

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

55MutBorrowField[31](HarvestStats.leaderboard: vector<LeaderboardEntry>)

56MoveLoc[8](loc6: u64)

57VecMutBorrow(58)

58StLoc[3](loc1: &mut LeaderboardEntry)

59MoveLoc[17](loc15: u64)

60MoveLoc[3](loc1: &mut LeaderboardEntry)

61MutBorrowField[33](LeaderboardEntry.total_harvested: u64)

62WriteRef

63Branch(128)

B11:

64CopyLoc[12](loc10: u64)

65LdU64(10)

66Lt

67BrFalse(75)

B12:

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

69MutBorrowField[31](HarvestStats.leaderboard: vector<LeaderboardEntry>)

70MoveLoc[1](Arg1: address)

71MoveLoc[17](loc15: u64)

72Pack[6](LeaderboardEntry)

73VecPushBack(58)

74Branch(128)

B13:

75LdU64(0)

76StLoc[13](loc11: u64)

77CopyLoc[0](Arg0: &mut HarvestStats)

78ImmBorrowField[31](HarvestStats.leaderboard: vector<LeaderboardEntry>)

79LdU64(0)

80VecImmBorrow(58)

81ImmBorrowField[33](LeaderboardEntry.total_harvested: u64)

82ReadRef

83StLoc[14](loc12: u64)

84LdU64(1)

85StLoc[10](loc8: u64)

B14:

86CopyLoc[10](loc8: u64)

87CopyLoc[12](loc10: u64)

88Lt

89BrFalse(111)

B15:

90CopyLoc[0](Arg0: &mut HarvestStats)

91ImmBorrowField[31](HarvestStats.leaderboard: vector<LeaderboardEntry>)

92CopyLoc[10](loc8: u64)

93VecImmBorrow(58)

94ImmBorrowField[33](LeaderboardEntry.total_harvested: u64)

95ReadRef

96StLoc[5](loc3: u64)

97CopyLoc[5](loc3: u64)

98CopyLoc[14](loc12: u64)

99Lt

100BrFalse(106)

B16:

101MoveLoc[5](loc3: u64)

102StLoc[14](loc12: u64)

103CopyLoc[10](loc8: u64)

104StLoc[13](loc11: u64)

105Branch(106)

B17:

106MoveLoc[10](loc8: u64)

107LdU64(1)

108Add

109StLoc[10](loc8: u64)

110Branch(86)

B18:

111CopyLoc[17](loc15: u64)

112MoveLoc[14](loc12: u64)

113Gt

114BrFalse(128)

B19:

115CopyLoc[0](Arg0: &mut HarvestStats)

116MutBorrowField[31](HarvestStats.leaderboard: vector<LeaderboardEntry>)

117MoveLoc[13](loc11: u64)

118VecMutBorrow(58)

119StLoc[4](loc2: &mut LeaderboardEntry)

120MoveLoc[1](Arg1: address)

121CopyLoc[4](loc2: &mut LeaderboardEntry)

122MutBorrowField[32](LeaderboardEntry.user: address)

123WriteRef

124MoveLoc[17](loc15: u64)

125MoveLoc[4](loc2: &mut LeaderboardEntry)

126MutBorrowField[33](LeaderboardEntry.total_harvested: u64)

127WriteRef

B20:

128CopyLoc[0](Arg0: &mut HarvestStats)

129ImmBorrowField[31](HarvestStats.leaderboard: vector<LeaderboardEntry>)

130VecLen(58)

131StLoc[11](loc9: u64)

132CopyLoc[11](loc9: u64)

133LdU64(1)

134Gt

135BrFalse(194)

B21:

136LdU64(0)

137StLoc[16](loc14: u64)

B22:

138CopyLoc[16](loc14: u64)

139CopyLoc[11](loc9: u64)

140LdU64(1)

141Sub

142Lt

143BrFalse(191)

B23:

144LdU64(0)

145StLoc[9](loc7: u64)

B24:

146CopyLoc[9](loc7: u64)

147CopyLoc[11](loc9: u64)

148CopyLoc[16](loc14: u64)

149Sub

150LdU64(1)

151Sub

152Lt

153BrFalse(186)

B25:

154CopyLoc[0](Arg0: &mut HarvestStats)

155ImmBorrowField[31](HarvestStats.leaderboard: vector<LeaderboardEntry>)

156CopyLoc[9](loc7: u64)

157VecImmBorrow(58)

158ImmBorrowField[33](LeaderboardEntry.total_harvested: u64)

159ReadRef

160StLoc[2](loc0: u64)

161CopyLoc[0](Arg0: &mut HarvestStats)

162ImmBorrowField[31](HarvestStats.leaderboard: vector<LeaderboardEntry>)

163CopyLoc[9](loc7: u64)

164LdU64(1)

165Add

166VecImmBorrow(58)

167ImmBorrowField[33](LeaderboardEntry.total_harvested: u64)

168ReadRef

169StLoc[15](loc13: u64)

170MoveLoc[2](loc0: u64)

171MoveLoc[15](loc13: u64)

172Lt

173BrFalse(181)

B26:

174CopyLoc[0](Arg0: &mut HarvestStats)

175MutBorrowField[31](HarvestStats.leaderboard: vector<LeaderboardEntry>)

176CopyLoc[9](loc7: u64)

177CopyLoc[9](loc7: u64)

178LdU64(1)

179Add

180VecSwap(58)

B27:

181MoveLoc[9](loc7: u64)

182LdU64(1)

183Add

184StLoc[9](loc7: u64)

185Branch(146)

B28:

186MoveLoc[16](loc14: u64)

187LdU64(1)

188Add

189StLoc[16](loc14: u64)

190Branch(138)

B29:

191MoveLoc[0](Arg0: &mut HarvestStats)

192Pop

193Branch(197)

B30:

194MoveLoc[0](Arg0: &mut HarvestStats)

195Pop

196Branch(197)

B31:

197Ret

}

public get_harvest_stats(Arg0: &HarvestStats): u64 * u64 * u64 * u64 * u64 {

B0:

0CopyLoc[0](Arg0: &HarvestStats)

1ImmBorrowField[23](HarvestStats.total_sht_harvested: u64)

2ReadRef

3CopyLoc[0](Arg0: &HarvestStats)

4ImmBorrowField[21](HarvestStats.total_harvest_attempts: u64)

5ReadRef

6CopyLoc[0](Arg0: &HarvestStats)

7ImmBorrowField[22](HarvestStats.total_successful_harvests: u64)

8ReadRef

9CopyLoc[0](Arg0: &HarvestStats)

10ImmBorrowField[7](HarvestStats.active_ducks_staked: u64)

11ReadRef

12MoveLoc[0](Arg0: &HarvestStats)

13ImmBorrowField[20](HarvestStats.sht_harvested_today: u64)

14ReadRef

15Ret

}

public get_user_harvest_stats(Arg0: &HarvestStats, Arg1: address): u64 * u64 * u64 * u64 * u64 {

L2: loc0: u64

L3: loc1: u64

L4: loc2: u64

L5: loc3: u64

L6: loc4: u64

L7: loc5: &UserHarvestStats

B0:

0CopyLoc[0](Arg0: &HarvestStats)

1ImmBorrowField[24](HarvestStats.id: UID)

2CopyLoc[1](Arg1: address)

3Call dynamic_field::exists_<address>(&UID, address): bool

4BrFalse(31)

B1:

5MoveLoc[0](Arg0: &HarvestStats)

6ImmBorrowField[24](HarvestStats.id: UID)

7MoveLoc[1](Arg1: address)

8Call dynamic_field::borrow<address, UserHarvestStats>(&UID, address): &UserHarvestStats

9StLoc[7](loc5: &UserHarvestStats)

10CopyLoc[7](loc5: &UserHarvestStats)

11ImmBorrowField[27](UserHarvestStats.lifetime_sht_earned: u64)

12ReadRef

13CopyLoc[7](loc5: &UserHarvestStats)

14ImmBorrowField[28](UserHarvestStats.total_harvest_attempts: u64)

15ReadRef

16CopyLoc[7](loc5: &UserHarvestStats)

17ImmBorrowField[29](UserHarvestStats.successful_harvests: u64)

18ReadRef

19CopyLoc[7](loc5: &UserHarvestStats)

20ImmBorrowField[30](UserHarvestStats.current_ducks_staked: u64)

21ReadRef

22MoveLoc[7](loc5: &UserHarvestStats)

23ImmBorrowField[26](UserHarvestStats.sht_earned_today: u64)

24ReadRef

25StLoc[6](loc4: u64)

26StLoc[5](loc3: u64)

27StLoc[4](loc2: u64)

28StLoc[3](loc1: u64)

29StLoc[2](loc0: u64)

30Branch(43)

B2:

31MoveLoc[0](Arg0: &HarvestStats)

32Pop

33LdU64(0)

34LdU64(0)

35LdU64(0)

36LdU64(0)

37LdU64(0)

38StLoc[6](loc4: u64)

39StLoc[5](loc3: u64)

40StLoc[4](loc2: u64)

41StLoc[3](loc1: u64)

42StLoc[2](loc0: u64)

B3:

43MoveLoc[2](loc0: u64)

44MoveLoc[3](loc1: u64)

45MoveLoc[4](loc2: u64)

46MoveLoc[5](loc3: u64)

47MoveLoc[6](loc4: u64)

48Ret

}

public has_user_harvest_stats(Arg0: &HarvestStats, Arg1: address): bool {

B0:

0MoveLoc[0](Arg0: &HarvestStats)

1ImmBorrowField[24](HarvestStats.id: UID)

2MoveLoc[1](Arg1: address)

3Call dynamic_field::exists_<address>(&UID, address): bool

4Ret

}

public get_leaderboard(Arg0: &HarvestStats): vector<LeaderboardEntry> {

B0:

0MoveLoc[0](Arg0: &HarvestStats)

1ImmBorrowField[31](HarvestStats.leaderboard: vector<LeaderboardEntry>)

2ReadRef

3Ret

}

public get_leaderboard_entry(Arg0: &HarvestStats, Arg1: u64): address * u64 {

L2: loc0: &LeaderboardEntry

B0:

0MoveLoc[0](Arg0: &HarvestStats)

1ImmBorrowField[31](HarvestStats.leaderboard: vector<LeaderboardEntry>)

2MoveLoc[1](Arg1: u64)

3VecImmBorrow(58)

4StLoc[2](loc0: &LeaderboardEntry)

5CopyLoc[2](loc0: &LeaderboardEntry)

6ImmBorrowField[32](LeaderboardEntry.user: address)

7ReadRef

8MoveLoc[2](loc0: &LeaderboardEntry)

9ImmBorrowField[33](LeaderboardEntry.total_harvested: u64)

10ReadRef

11Ret

}

public get_leaderboard_length(Arg0: &HarvestStats): u64 {

B0:

0MoveLoc[0](Arg0: &HarvestStats)

1ImmBorrowField[31](HarvestStats.leaderboard: vector<LeaderboardEntry>)

2VecLen(58)

3Ret

}

public(friend) get_nest_owner(Arg0: &Nest): address {

B0:

0MoveLoc[0](Arg0: &Nest)

1ImmBorrowField[2](Nest.owner: address)

2ReadRef

3Ret

}

public(friend) get_staked_duck_owner(Arg0: &StakedDuck): address {

B0:

0MoveLoc[0](Arg0: &StakedDuck)

1ImmBorrowField[9](StakedDuck.owner: address)

2ReadRef

3Ret

}

public(friend) get_nest_staked_duck_id(Arg0: &Nest): Option<ID> {

B0:

0MoveLoc[0](Arg0: &Nest)

1ImmBorrowField[3](Nest.staked_duck_id: Option<ID>)

2ReadRef

3Ret

}

public(friend) get_staked_duck_duck_id(Arg0: &StakedDuck): ID {

B0:

0MoveLoc[0](Arg0: &StakedDuck)

1ImmBorrowField[10](StakedDuck.duck_id: ID)

2ReadRef

3Ret

}

public(friend) get_staked_duck_last_harvest(Arg0: &StakedDuck): u64 {

B0:

0MoveLoc[0](Arg0: &StakedDuck)

1ImmBorrowField[11](StakedDuck.last_harvest_time: u64)

2ReadRef

3Ret

}

public(friend) get_staked_duck_rarity(Arg0: &StakedDuck): u8 {

B0:

0MoveLoc[0](Arg0: &StakedDuck)

1ImmBorrowField[12](StakedDuck.duck_rarity: u8)

2ReadRef

3Ret

}

public(friend) set_staked_duck_last_harvest(Arg0: &mut StakedDuck, Arg1: u64) {

B0:

0MoveLoc[1](Arg1: u64)

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

2MutBorrowField[11](StakedDuck.last_harvest_time: u64)

3WriteRef

4Ret

}

public(friend) get_staked_duck_uid_mut(Arg0: &mut StakedDuck): &mut UID {

B0:

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

1MutBorrowField[34](StakedDuck.id: UID)

2Ret

}

public(friend) set_nest_level(Arg0: &mut Nest, Arg1: u8) {

B0:

0MoveLoc[1](Arg1: u8)

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

2MutBorrowField[4](Nest.level: u8)

3WriteRef

4Ret

}

public(friend) get_staking_kiosk_mut(Arg0: &mut StakingKiosk): &mut Kiosk * &KioskOwnerCap {

B0:

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

1MutBorrowField[5](StakingKiosk.kiosk: Kiosk)

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

3ImmBorrowField[6](StakingKiosk.cap: KioskOwnerCap)

4Ret

}

public(friend) update_harvest_stats_v2(Arg0: &mut HarvestStats, Arg1: address, Arg2: u64, Arg3: u64, Arg4: u64, Arg5: &Clock) {

L6: loc0: u64

L7: loc1: &mut UserHarvestStats

L8: loc2: UserHarvestStats

B0:

0MoveLoc[5](Arg5: &Clock)

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

2LdU64(86400000)

3Div

4StLoc[6](loc0: u64)

5CopyLoc[6](loc0: u64)

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

7ImmBorrowField[19](HarvestStats.last_harvest_reset_day: u64)

8ReadRef

9Gt

10BrFalse(19)

B1:

11LdU64(0)

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

13MutBorrowField[20](HarvestStats.sht_harvested_today: u64)

14WriteRef

15CopyLoc[6](loc0: u64)

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

17MutBorrowField[19](HarvestStats.last_harvest_reset_day: u64)

18WriteRef

B2:

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

20ImmBorrowField[21](HarvestStats.total_harvest_attempts: u64)

21ReadRef

22CopyLoc[2](Arg2: u64)

23Add

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

25MutBorrowField[21](HarvestStats.total_harvest_attempts: u64)

26WriteRef

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

28ImmBorrowField[22](HarvestStats.total_successful_harvests: u64)

29ReadRef

30CopyLoc[3](Arg3: u64)

31Add

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

33MutBorrowField[22](HarvestStats.total_successful_harvests: u64)

34WriteRef

35CopyLoc[0](Arg0: &mut HarvestStats)

36ImmBorrowField[23](HarvestStats.total_sht_harvested: u64)

37ReadRef

38CopyLoc[4](Arg4: u64)

39Add

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

41MutBorrowField[23](HarvestStats.total_sht_harvested: u64)

42WriteRef

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

44ImmBorrowField[20](HarvestStats.sht_harvested_today: u64)

45ReadRef

46CopyLoc[4](Arg4: u64)

47Add

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

49MutBorrowField[20](HarvestStats.sht_harvested_today: u64)

50WriteRef

51CopyLoc[0](Arg0: &mut HarvestStats)

52ImmBorrowField[24](HarvestStats.id: UID)

53CopyLoc[1](Arg1: address)

54Call dynamic_field::exists_<address>(&UID, address): bool

55BrFalse(108)

B3:

56CopyLoc[0](Arg0: &mut HarvestStats)

57MutBorrowField[24](HarvestStats.id: UID)

58CopyLoc[1](Arg1: address)

59Call dynamic_field::borrow_mut<address, UserHarvestStats>(&mut UID, address): &mut UserHarvestStats

60StLoc[7](loc1: &mut UserHarvestStats)

61CopyLoc[6](loc0: u64)

62CopyLoc[7](loc1: &mut UserHarvestStats)

63ImmBorrowField[25](UserHarvestStats.last_activity_day: u64)

64ReadRef

65Gt

66BrFalse(71)

B4:

67LdU64(0)

68CopyLoc[7](loc1: &mut UserHarvestStats)

69MutBorrowField[26](UserHarvestStats.sht_earned_today: u64)

70WriteRef

B5:

71CopyLoc[7](loc1: &mut UserHarvestStats)

72ImmBorrowField[27](UserHarvestStats.lifetime_sht_earned: u64)

73ReadRef

74CopyLoc[4](Arg4: u64)

75Add

76CopyLoc[7](loc1: &mut UserHarvestStats)

77MutBorrowField[27](UserHarvestStats.lifetime_sht_earned: u64)

78WriteRef

79CopyLoc[7](loc1: &mut UserHarvestStats)

80ImmBorrowField[28](UserHarvestStats.total_harvest_attempts: u64)

81ReadRef

82MoveLoc[2](Arg2: u64)

83Add

84CopyLoc[7](loc1: &mut UserHarvestStats)

85MutBorrowField[28](UserHarvestStats.total_harvest_attempts: u64)

86WriteRef

87CopyLoc[7](loc1: &mut UserHarvestStats)

88ImmBorrowField[29](UserHarvestStats.successful_harvests: u64)

89ReadRef

90MoveLoc[3](Arg3: u64)

91Add

92CopyLoc[7](loc1: &mut UserHarvestStats)

93MutBorrowField[29](UserHarvestStats.successful_harvests: u64)

94WriteRef

95CopyLoc[7](loc1: &mut UserHarvestStats)

96ImmBorrowField[26](UserHarvestStats.sht_earned_today: u64)

97ReadRef

98CopyLoc[4](Arg4: u64)

99Add

100CopyLoc[7](loc1: &mut UserHarvestStats)

101MutBorrowField[26](UserHarvestStats.sht_earned_today: u64)

102WriteRef

103MoveLoc[6](loc0: u64)

104MoveLoc[7](loc1: &mut UserHarvestStats)

105MutBorrowField[25](UserHarvestStats.last_activity_day: u64)

106WriteRef

107Branch(121)

B6:

108CopyLoc[4](Arg4: u64)

109MoveLoc[2](Arg2: u64)

110MoveLoc[3](Arg3: u64)

111LdU64(0)

112CopyLoc[4](Arg4: u64)

113MoveLoc[6](loc0: u64)

114Pack[7](UserHarvestStats)

115StLoc[8](loc2: UserHarvestStats)

116CopyLoc[0](Arg0: &mut HarvestStats)

117MutBorrowField[24](HarvestStats.id: UID)

118CopyLoc[1](Arg1: address)

119MoveLoc[8](loc2: UserHarvestStats)

120Call dynamic_field::add<address, UserHarvestStats>(&mut UID, address, UserHarvestStats)

B7:

121MoveLoc[4](Arg4: u64)

122LdU64(0)

123Gt

124BrFalse(129)

B8:

125MoveLoc[0](Arg0: &mut HarvestStats)

126MoveLoc[1](Arg1: address)

127Call update_leaderboard(&mut HarvestStats, address)

128Branch(131)

B9:

129MoveLoc[0](Arg0: &mut HarvestStats)

130Pop

B10:

131Ret

}

public(friend) delete_staked_duck_v2(Arg0: StakedDuck): ID * ID * ID {

L1: loc0: ID

L2: loc1: ID

L3: loc2: ID

L4: loc3: UID

B0:

0MoveLoc[0](Arg0: StakedDuck)

1Unpack[4](StakedDuck)

2Pop

3Pop

4Pop

5Pop

6StLoc[2](loc1: ID)

7Pop

8StLoc[1](loc0: ID)

9StLoc[4](loc3: UID)

10ImmBorrowLoc[4](loc3: UID)

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

12StLoc[3](loc2: ID)

13MoveLoc[4](loc3: UID)

14Call object::delete(UID)

15MoveLoc[3](loc2: ID)

16MoveLoc[1](loc0: ID)

17MoveLoc[2](loc1: ID)

18Ret

}

public(friend) clear_nest_staked_duck(Arg0: &mut Nest) {

B0:

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

1MutBorrowField[3](Nest.staked_duck_id: Option<ID>)

2Call option::extract<ID>(&mut Option<ID>): ID

3Pop

4Ret

}

public(friend) decrement_active_ducks(Arg0: &mut HarvestStats) {

B0:

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

1ImmBorrowField[7](HarvestStats.active_ducks_staked: u64)

2ReadRef

3LdU64(0)

4Gt

5BrFalse(15)

B1:

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

7ImmBorrowField[7](HarvestStats.active_ducks_staked: u64)

8ReadRef

9LdU64(1)

10Sub

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

12MutBorrowField[7](HarvestStats.active_ducks_staked: u64)

13WriteRef

14Branch(17)

B2:

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

16Pop

B3:

17Ret

}

public(friend) update_user_stake_stats_v2(Arg0: &mut HarvestStats, Arg1: address, Arg2: bool, Arg3: &Clock) {

B0:

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

1MoveLoc[1](Arg1: address)

2MoveLoc[2](Arg2: bool)

3MoveLoc[3](Arg3: &Clock)

4Call update_user_stake_stats(&mut HarvestStats, address, bool, &Clock)

5Ret

}

public(friend) get_nest_index(Arg0: &Nest): u8 {

B0:

0MoveLoc[0](Arg0: &Nest)

1ImmBorrowField[8](Nest.nest_index: u8)

2ReadRef

3Ret

}

public(friend) get_staked_duck_multiplier(Arg0: &StakedDuck): u8 {

B0:

0MoveLoc[0](Arg0: &StakedDuck)

1ImmBorrowField[13](StakedDuck.duck_multiplier: u8)

2ReadRef

3Ret

}

public(friend) return_staked_duck(Arg0: StakedDuck, Arg1: address) {

B0:

0MoveLoc[0](Arg0: StakedDuck)

1MoveLoc[1](Arg1: address)

2Call transfer::transfer<StakedDuck>(StakedDuck, address)

3Ret

}

Constants [

0 => u64: 1

1 => u64: 2

2 => u64: 3

3 => u64: 4

4 => u64: 5

5 => u64: 6

6 => u64: 7

7 => u64: 8

8 => u64: 9

9 => u64: 10

10 => u64: 11

11 => u64: 12

12 => u64: 13

13 => u64: 14

14 => u8: 5

15 => u64: 14400000

16 => u64: 100000000000

17 => u64: 30

18 => u8: 40

19 => u8: 50

20 => u8: 60

21 => u8: 85

22 => u8: 1

23 => u8: 3

24 => u8: 7

25 => u64: 4000000000000

26 => u64: 6000000000000

27 => u64: 10000000000000

28 => u8: 10

29 => u8: 15

30 => u8: 0

31 => u8: 2

]

}