redemption_queue

Module0x6533…8d3d

Move path: 0x5dc5…5f15::redemption_queue
Functions: 2822 public, 0 entry
Structs: 5
Friend modules: None

redemption_queue

Bytecode642 lines

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

// Move bytecode v6

module 5dc5ef7bcbcf4031b7012e58b6fa4f7fa4643e26ba25f54365da2ad73e845f15.redemption_queue {

use ce7ff77a83ea0cb6fd39bd8748e2ec89a3f41e8efdc3f4eb123e0ca37b184db2::buck;

use 0000000000000000000000000000000000000000000000000000000000000001::option;

use 0000000000000000000000000000000000000000000000000000000000000001::type_name;

use 0000000000000000000000000000000000000000000000000000000000000001::u64;

use 0000000000000000000000000000000000000000000000000000000000000002::address;

use 0000000000000000000000000000000000000000000000000000000000000002::balance;

use 0000000000000000000000000000000000000000000000000000000000000002::clock;

use 0000000000000000000000000000000000000000000000000000000000000002::coin;

use 0000000000000000000000000000000000000000000000000000000000000002::linked_table;

use 0000000000000000000000000000000000000000000000000000000000000002::object;

use 0000000000000000000000000000000000000000000000000000000000000002::transfer;

use 0000000000000000000000000000000000000000000000000000000000000002::tx_context;

use 5dc5ef7bcbcf4031b7012e58b6fa4f7fa4643e26ba25f54365da2ad73e845f15::event;

struct RedemptionQueueW has drop {

dummy_field: bool

}

struct RedemptionTicket has store {

recipient: address,

balance: Balance<BUCK>,

time_to_redeem: u64

}

struct RedemptionQueue<phantom Ty0, phantom Ty1> has key {

id: UID,

delay: u64,

counter: u64,

inner_table: LinkedTable<u64, RedemptionTicket>,

redeemer: Option<address>,

is_active: bool

}

struct RedeemRequest<phantom Ty0, phantom Ty1> {

max_amount: u64,

balance: Balance<BUCK>

}

struct RedemptionTicketInfo has copy, drop {

ticket_id: u64,

recipient: address,

balance: u64,

time_to_redeem: u64

}

err_queue_is_not_active() {

B0:

0LdConst[0](u64: 0)

1Abort

}

err_exceed_max_amount_to_redeem() {

B0:

0LdConst[1](u64: 1)

1Abort

}

err_invalid_redeemer() {

B0:

0LdConst[2](u64: 2)

1Abort

}

err_index_exceed_size() {

B0:

0LdConst[3](u64: 3)

1Abort

}

err_zero_batch_size() {

B0:

0LdConst[3](u64: 3)

1Abort

}

err_invalid_address() {

B0:

0LdConst[4](u64: 4)

1Abort

}

public redeem_request_max_amount<Ty0, Ty1>(Arg0: &RedeemRequest<Ty0, Ty1>): u64 {

B0:

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

1ImmBorrowFieldGeneric[0](RedeemRequest.max_amount: u64)

2ReadRef

3Ret

}

public request<Ty0, Ty1: drop>(Arg0: Ty1, Arg1: u64): RedeemRequest<Ty0, Ty1> {

B0:

0MoveLoc[1](Arg1: u64)

1Call balance::zero<BUCK>(): Balance<BUCK>

2PackGeneric[0](RedeemRequest<Ty0, Ty1>)

3Ret

}

public add_balance<Ty0, Ty1>(Arg0: &mut RedeemRequest<Ty0, Ty1>, Arg1: Balance<BUCK>) {

B0:

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

1MutBorrowFieldGeneric[1](RedeemRequest.balance: Balance<BUCK>)

2MoveLoc[1](Arg1: Balance<BUCK>)

3Call balance::join<BUCK>(&mut Balance<BUCK>, Balance<BUCK>): u64

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

5ImmBorrowFieldGeneric[0](RedeemRequest.max_amount: u64)

6ReadRef

7Gt

8BrFalse(10)

B1:

9Call err_exceed_max_amount_to_redeem()

B2:

10Ret

}

public create_ticket<Ty0, Ty1>(Arg0: &mut RedemptionQueue<Ty0, Ty1>, Arg1: &Clock, Arg2: RedeemRequest<Ty0, Ty1>, Arg3: address) {

L4: loc0: u64

L5: loc1: Balance<BUCK>

L6: loc2: u64

L7: loc3: RedemptionTicket

L8: loc4: u64

B0:

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

1FreezeRef

2Call assert_is_active<Ty0, Ty1>(&RedemptionQueue<Ty0, Ty1>)

3CopyLoc[3](Arg3: address)

4LdU256(0)

5Call address::from_u256(u256): address

6Eq

7BrFalse(9)

B1:

8Call err_invalid_address()

B2:

9MoveLoc[2](Arg2: RedeemRequest<Ty0, Ty1>)

10UnpackGeneric[0](RedeemRequest<Ty0, Ty1>)

11StLoc[5](loc1: Balance<BUCK>)

12StLoc[6](loc2: u64)

13ImmBorrowLoc[5](loc1: Balance<BUCK>)

14Call balance::value<BUCK>(&Balance<BUCK>): u64

15StLoc[4](loc0: u64)

16CopyLoc[4](loc0: u64)

17LdU64(0)

18Eq

19BrFalse(27)

B3:

20MoveLoc[0](Arg0: &mut RedemptionQueue<Ty0, Ty1>)

21Pop

22MoveLoc[1](Arg1: &Clock)

23Pop

24MoveLoc[5](loc1: Balance<BUCK>)

25Call balance::destroy_zero<BUCK>(Balance<BUCK>)

26Branch(63)

B4:

27MoveLoc[1](Arg1: &Clock)

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

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

30FreezeRef

31Call delay<Ty0, Ty1>(&RedemptionQueue<Ty0, Ty1>): u64

32Add

33StLoc[8](loc4: u64)

34CopyLoc[3](Arg3: address)

35MoveLoc[5](loc1: Balance<BUCK>)

36CopyLoc[8](loc4: u64)

37Pack[1](RedemptionTicket)

38StLoc[7](loc3: RedemptionTicket)

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

40MutBorrowFieldGeneric[2](RedemptionQueue.inner_table: LinkedTable<u64, RedemptionTicket>)

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

42ImmBorrowFieldGeneric[3](RedemptionQueue.counter: u64)

43ReadRef

44MoveLoc[7](loc3: RedemptionTicket)

45Call linked_table::push_back<u64, RedemptionTicket>(&mut LinkedTable<u64, RedemptionTicket>, u64, RedemptionTicket)

46Call type_name::get<Ty0>(): TypeName

47MoveLoc[6](loc2: u64)

48MoveLoc[4](loc0: u64)

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

50ImmBorrowFieldGeneric[3](RedemptionQueue.counter: u64)

51ReadRef

52MoveLoc[8](loc4: u64)

53MoveLoc[3](Arg3: address)

54Call event::emit_create_queue_ticket_event<Ty1>(TypeName, u64, u64, u64, u64, address)

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

56ImmBorrowFieldGeneric[3](RedemptionQueue.counter: u64)

57ReadRef

58LdU64(1)

59Add

60MoveLoc[0](Arg0: &mut RedemptionQueue<Ty0, Ty1>)

61MutBorrowFieldGeneric[3](RedemptionQueue.counter: u64)

62WriteRef

B5:

63Ret

}

public batch_redeem<Ty0, Ty1>(Arg0: &mut RedemptionQueue<Ty0, Ty1>, Arg1: &mut BucketProtocol, Arg2: &Clock, Arg3: Option<u64>, Arg4: u64, Arg5: &mut TxContext) {

L6: loc0: u64

L7: loc1: u64

L8: loc2: bool

L9: loc3: Balance<BUCK>

L10: loc4: u64

L11: loc5: u64

L12: loc6: u64

L13: loc7: &Option<u64>

L14: loc8: u64

L15: loc9: u64

L16: loc10: address

L17: loc11: u64

L18: loc12: u64

L19: loc13: u64

L20: loc14: &mut LinkedTable<u64, RedemptionTicket>

L21: loc15: u64

L22: loc16: u64

L23: loc17: Coin<Ty0>

B0:

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

1FreezeRef

2CopyLoc[5](Arg5: &mut TxContext)

3FreezeRef

4Call assert_is_redeemer<Ty0, Ty1>(&RedemptionQueue<Ty0, Ty1>, &TxContext)

5CopyLoc[4](Arg4: u64)

6LdU64(0)

7Eq

8BrFalse(10)

B1:

9Call err_zero_batch_size()

B2:

10CopyLoc[2](Arg2: &Clock)

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

12StLoc[12](loc6: u64)

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

14ImmBorrowFieldGeneric[3](RedemptionQueue.counter: u64)

15ReadRef

16StLoc[11](loc5: u64)

17MoveLoc[0](Arg0: &mut RedemptionQueue<Ty0, Ty1>)

18MutBorrowFieldGeneric[2](RedemptionQueue.inner_table: LinkedTable<u64, RedemptionTicket>)

19StLoc[20](loc14: &mut LinkedTable<u64, RedemptionTicket>)

20ImmBorrowLoc[3](Arg3: Option<u64>)

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

22BrFalse(34)

B3:

23MoveLoc[3](Arg3: Option<u64>)

24Call option::destroy_some<u64>(Option<u64>): u64

25StLoc[17](loc11: u64)

26CopyLoc[17](loc11: u64)

27CopyLoc[11](loc5: u64)

28Gt

29BrFalse(31)

B4:

30Call err_index_exceed_size()

B5:

31MoveLoc[17](loc11: u64)

32StLoc[7](loc1: u64)

33Branch(57)

B6:

34CopyLoc[20](loc14: &mut LinkedTable<u64, RedemptionTicket>)

35FreezeRef

36Call linked_table::front<u64, RedemptionTicket>(&LinkedTable<u64, RedemptionTicket>): &Option<u64>

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

38CopyLoc[13](loc7: &Option<u64>)

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

40BrFalse(42)

B7:

41Branch(53)

B8:

42MoveLoc[20](loc14: &mut LinkedTable<u64, RedemptionTicket>)

43Pop

44MoveLoc[13](loc7: &Option<u64>)

45Pop

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

47Pop

48MoveLoc[2](Arg2: &Clock)

49Pop

50MoveLoc[1](Arg1: &mut BucketProtocol)

51Pop

52Ret

B9:

53MoveLoc[13](loc7: &Option<u64>)

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

55ReadRef

56StLoc[7](loc1: u64)

B10:

57MoveLoc[7](loc1: u64)

58StLoc[18](loc12: u64)

59MoveLoc[4](Arg4: u64)

60MoveLoc[11](loc5: u64)

61CopyLoc[18](loc12: u64)

62Sub

63Call u64::min(u64, u64): u64

64StLoc[6](loc0: u64)

65LdU64(0)

66StLoc[14](loc8: u64)

67MoveLoc[6](loc0: u64)

68StLoc[19](loc13: u64)

B11:

69CopyLoc[14](loc8: u64)

70CopyLoc[19](loc13: u64)

71Lt

72BrFalse(132)

B12:

73CopyLoc[14](loc8: u64)

74StLoc[15](loc9: u64)

75CopyLoc[18](loc12: u64)

76MoveLoc[15](loc9: u64)

77Add

78StLoc[21](loc15: u64)

79CopyLoc[20](loc14: &mut LinkedTable<u64, RedemptionTicket>)

80FreezeRef

81CopyLoc[21](loc15: u64)

82Call linked_table::contains<u64, RedemptionTicket>(&LinkedTable<u64, RedemptionTicket>, u64): bool

83BrFalse(93)

B13:

84CopyLoc[20](loc14: &mut LinkedTable<u64, RedemptionTicket>)

85FreezeRef

86CopyLoc[21](loc15: u64)

87Call linked_table::borrow<u64, RedemptionTicket>(&LinkedTable<u64, RedemptionTicket>, u64): &RedemptionTicket

88Call time_to_redeem(&RedemptionTicket): u64

89CopyLoc[12](loc6: u64)

90Le

91StLoc[8](loc2: bool)

92Branch(95)

B14:

93LdFalse

94StLoc[8](loc2: bool)

B15:

95MoveLoc[8](loc2: bool)

96BrFalse(127)

B16:

97CopyLoc[20](loc14: &mut LinkedTable<u64, RedemptionTicket>)

98CopyLoc[21](loc15: u64)

99Call linked_table::remove<u64, RedemptionTicket>(&mut LinkedTable<u64, RedemptionTicket>, u64): RedemptionTicket

100Unpack[1](RedemptionTicket)

101StLoc[22](loc16: u64)

102StLoc[9](loc3: Balance<BUCK>)

103StLoc[16](loc10: address)

104ImmBorrowLoc[9](loc3: Balance<BUCK>)

105Call balance::value<BUCK>(&Balance<BUCK>): u64

106StLoc[10](loc4: u64)

107CopyLoc[1](Arg1: &mut BucketProtocol)

108MoveLoc[9](loc3: Balance<BUCK>)

109LdFalse

110Pack[0](RedemptionQueueW)

111Call buck::discharge_reservoir_by_partner<Ty0, RedemptionQueueW>(&mut BucketProtocol, Balance<BUCK>, RedemptionQueueW): Balance<Ty0>

112CopyLoc[5](Arg5: &mut TxContext)

113Call coin::from_balance<Ty0>(Balance<Ty0>, &mut TxContext): Coin<Ty0>

114StLoc[23](loc17: Coin<Ty0>)

115Call type_name::get<Ty0>(): TypeName

116MoveLoc[10](loc4: u64)

117ImmBorrowLoc[23](loc17: Coin<Ty0>)

118Call coin::value<Ty0>(&Coin<Ty0>): u64

119MoveLoc[21](loc15: u64)

120MoveLoc[22](loc16: u64)

121CopyLoc[2](Arg2: &Clock)

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

123Call event::emit_redeem_event<Ty1>(TypeName, u64, u64, u64, u64, u64)

124MoveLoc[23](loc17: Coin<Ty0>)

125MoveLoc[16](loc10: address)

126Call transfer::public_transfer<Coin<Ty0>>(Coin<Ty0>, address)

B17:

127MoveLoc[14](loc8: u64)

128LdU64(1)

129Add

130StLoc[14](loc8: u64)

131Branch(69)

B18:

132MoveLoc[20](loc14: &mut LinkedTable<u64, RedemptionTicket>)

133Pop

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

135Pop

136MoveLoc[2](Arg2: &Clock)

137Pop

138MoveLoc[1](Arg1: &mut BucketProtocol)

139Pop

140Ret

}

public create<Ty0, Ty1>(Arg0: &AdminCap, Arg1: u64, Arg2: Option<address>, Arg3: &mut TxContext) {

B0:

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

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

2MoveLoc[1](Arg1: u64)

3LdU64(0)

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

5Call linked_table::new<u64, RedemptionTicket>(&mut TxContext): LinkedTable<u64, RedemptionTicket>

6MoveLoc[2](Arg2: Option<address>)

7LdTrue

8PackGeneric[1](RedemptionQueue<Ty0, Ty1>)

9Call transfer::share_object<RedemptionQueue<Ty0, Ty1>>(RedemptionQueue<Ty0, Ty1>)

10Ret

}

public set_redeemer<Ty0, Ty1>(Arg0: &mut RedemptionQueue<Ty0, Ty1>, Arg1: &AdminCap, Arg2: Option<address>) {

B0:

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

1FreezeRef

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

3CopyLoc[2](Arg2: Option<address>)

4Call event::emit_set_redeemer<Ty1>(ID, Option<address>)

5MoveLoc[2](Arg2: Option<address>)

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

7MutBorrowFieldGeneric[4](RedemptionQueue.redeemer: Option<address>)

8WriteRef

9Ret

}

public set_delay<Ty0, Ty1>(Arg0: &mut RedemptionQueue<Ty0, Ty1>, Arg1: &AdminCap, Arg2: u64) {

B0:

0MoveLoc[2](Arg2: u64)

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

2MutBorrowFieldGeneric[5](RedemptionQueue.delay: u64)

3WriteRef

4Ret

}

public toggle_active<Ty0, Ty1>(Arg0: &mut RedemptionQueue<Ty0, Ty1>, Arg1: &AdminCap) {

B0:

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

1ImmBorrowFieldGeneric[6](RedemptionQueue.is_active: bool)

2ReadRef

3Not

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

5MutBorrowFieldGeneric[6](RedemptionQueue.is_active: bool)

6WriteRef

7Ret

}

public is_active<Ty0, Ty1>(Arg0: &RedemptionQueue<Ty0, Ty1>): bool {

B0:

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

1ImmBorrowFieldGeneric[6](RedemptionQueue.is_active: bool)

2ReadRef

3Ret

}

public assert_is_active<Ty0, Ty1>(Arg0: &RedemptionQueue<Ty0, Ty1>) {

B0:

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

1Call is_active<Ty0, Ty1>(&RedemptionQueue<Ty0, Ty1>): bool

2Not

3BrFalse(5)

B1:

4Call err_queue_is_not_active()

B2:

5Ret

}

public assert_is_redeemer<Ty0, Ty1>(Arg0: &RedemptionQueue<Ty0, Ty1>, Arg1: &TxContext) {

L2: loc0: bool

L3: loc1: address

L4: loc2: &Option<address>

L5: loc3: &address

B0:

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

1ImmBorrowFieldGeneric[4](RedemptionQueue.redeemer: Option<address>)

2StLoc[4](loc2: &Option<address>)

3CopyLoc[4](loc2: &Option<address>)

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

5BrFalse(17)

B1:

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

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

8StLoc[5](loc3: &address)

9MoveLoc[1](Arg1: &TxContext)

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

11StLoc[3](loc1: address)

12ImmBorrowLoc[3](loc1: address)

13MoveLoc[5](loc3: &address)

14Neq

15StLoc[2](loc0: bool)

16Branch(23)

B2:

17MoveLoc[4](loc2: &Option<address>)

18Pop

19MoveLoc[1](Arg1: &TxContext)

20Pop

21LdFalse

22StLoc[2](loc0: bool)

B3:

23MoveLoc[2](loc0: bool)

24BrFalse(26)

B4:

25Call err_invalid_redeemer()

B5:

26Ret

}

public inner_table<Ty0, Ty1>(Arg0: &RedemptionQueue<Ty0, Ty1>): &LinkedTable<u64, RedemptionTicket> {

B0:

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

1ImmBorrowFieldGeneric[2](RedemptionQueue.inner_table: LinkedTable<u64, RedemptionTicket>)

2Ret

}

public delay<Ty0, Ty1>(Arg0: &RedemptionQueue<Ty0, Ty1>): u64 {

B0:

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

1ImmBorrowFieldGeneric[5](RedemptionQueue.delay: u64)

2ReadRef

3Ret

}

public ticket_recipient(Arg0: &RedemptionTicket): address {

B0:

0MoveLoc[0](Arg0: &RedemptionTicket)

1ImmBorrowField[7](RedemptionTicket.recipient: address)

2ReadRef

3Ret

}

public ticket_balance(Arg0: &RedemptionTicket): &Balance<BUCK> {

B0:

0MoveLoc[0](Arg0: &RedemptionTicket)

1ImmBorrowField[8](RedemptionTicket.balance: Balance<BUCK>)

2Ret

}

public time_to_redeem(Arg0: &RedemptionTicket): u64 {

B0:

0MoveLoc[0](Arg0: &RedemptionTicket)

1ImmBorrowField[9](RedemptionTicket.time_to_redeem: u64)

2ReadRef

3Ret

}

public ticket_info_id(Arg0: &RedemptionTicketInfo): u64 {

B0:

0MoveLoc[0](Arg0: &RedemptionTicketInfo)

1ImmBorrowField[10](RedemptionTicketInfo.ticket_id: u64)

2ReadRef

3Ret

}

public ticket_info_recipient(Arg0: &RedemptionTicketInfo): address {

B0:

0MoveLoc[0](Arg0: &RedemptionTicketInfo)

1ImmBorrowField[11](RedemptionTicketInfo.recipient: address)

2ReadRef

3Ret

}

public ticket_info_balance(Arg0: &RedemptionTicketInfo): u64 {

B0:

0MoveLoc[0](Arg0: &RedemptionTicketInfo)

1ImmBorrowField[12](RedemptionTicketInfo.balance: u64)

2ReadRef

3Ret

}

public ticket_info_time_to_redeem(Arg0: &RedemptionTicketInfo): u64 {

B0:

0MoveLoc[0](Arg0: &RedemptionTicketInfo)

1ImmBorrowField[13](RedemptionTicketInfo.time_to_redeem: u64)

2ReadRef

3Ret

}

public get_tickets<Ty0, Ty1>(Arg0: &RedemptionQueue<Ty0, Ty1>, Arg1: Option<u64>, Arg2: u64): vector<RedemptionTicketInfo> * Option<u64> {

L3: loc0: bool

L4: loc1: u64

L5: loc2: vector<RedemptionTicketInfo>

L6: loc3: &LinkedTable<u64, RedemptionTicket>

L7: loc4: &RedemptionTicket

L8: loc5: u64

B0:

0VecPack(61, 0)

1StLoc[5](loc2: vector<RedemptionTicketInfo>)

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

3ImmBorrowFieldGeneric[2](RedemptionQueue.inner_table: LinkedTable<u64, RedemptionTicket>)

4StLoc[6](loc3: &LinkedTable<u64, RedemptionTicket>)

5ImmBorrowLoc[1](Arg1: Option<u64>)

6Call option::is_none<u64>(&Option<u64>): bool

7BrFalse(12)

B1:

8CopyLoc[6](loc3: &LinkedTable<u64, RedemptionTicket>)

9Call linked_table::front<u64, RedemptionTicket>(&LinkedTable<u64, RedemptionTicket>): &Option<u64>

10ReadRef

11StLoc[1](Arg1: Option<u64>)

B2:

12LdU64(0)

13StLoc[4](loc1: u64)

B3:

14ImmBorrowLoc[1](Arg1: Option<u64>)

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

16BrFalse(22)

B4:

17CopyLoc[4](loc1: u64)

18CopyLoc[2](Arg2: u64)

19Lt

20StLoc[3](loc0: bool)

21Branch(24)

B5:

22LdFalse

23StLoc[3](loc0: bool)

B6:

24MoveLoc[3](loc0: bool)

25BrFalse(55)

B7:

26ImmBorrowLoc[1](Arg1: Option<u64>)

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

28ReadRef

29StLoc[8](loc5: u64)

30CopyLoc[6](loc3: &LinkedTable<u64, RedemptionTicket>)

31CopyLoc[8](loc5: u64)

32Call linked_table::borrow<u64, RedemptionTicket>(&LinkedTable<u64, RedemptionTicket>, u64): &RedemptionTicket

33StLoc[7](loc4: &RedemptionTicket)

34MutBorrowLoc[5](loc2: vector<RedemptionTicketInfo>)

35CopyLoc[8](loc5: u64)

36CopyLoc[7](loc4: &RedemptionTicket)

37Call ticket_recipient(&RedemptionTicket): address

38CopyLoc[7](loc4: &RedemptionTicket)

39Call ticket_balance(&RedemptionTicket): &Balance<BUCK>

40Call balance::value<BUCK>(&Balance<BUCK>): u64

41MoveLoc[7](loc4: &RedemptionTicket)

42Call time_to_redeem(&RedemptionTicket): u64

43Pack[4](RedemptionTicketInfo)

44VecPushBack(61)

45MoveLoc[4](loc1: u64)

46LdU64(1)

47Add

48StLoc[4](loc1: u64)

49CopyLoc[6](loc3: &LinkedTable<u64, RedemptionTicket>)

50MoveLoc[8](loc5: u64)

51Call linked_table::next<u64, RedemptionTicket>(&LinkedTable<u64, RedemptionTicket>, u64): &Option<u64>

52ReadRef

53StLoc[1](Arg1: Option<u64>)

54Branch(14)

B8:

55MoveLoc[6](loc3: &LinkedTable<u64, RedemptionTicket>)

56Pop

57MoveLoc[5](loc2: vector<RedemptionTicketInfo>)

58MoveLoc[1](Arg1: Option<u64>)

59Ret

}

Constants [

0 => u64: 0

1 => u64: 1

2 => u64: 2

3 => u64: 3

4 => u64: 4

]

}