launch

Module0xea36…3e21

Move path: 0x60e6…fb75::launch
Functions: 5038 public, 0 entry
Structs: 14
Friend modules: mint phase whitelist

launch

Bytecode2075 lines

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

// Move bytecode v7

module 60e688bb4071cd6ea5aed6f22b2dc717e067bbcbe60b73c931a0be728c3cfb75.launch {

use 0000000000000000000000000000000000000000000000000000000000000001::type_name;

use 0000000000000000000000000000000000000000000000000000000000000001::u64;

use 0000000000000000000000000000000000000000000000000000000000000002::bag;

use 0000000000000000000000000000000000000000000000000000000000000002::balance;

use 0000000000000000000000000000000000000000000000000000000000000002::clock;

use 0000000000000000000000000000000000000000000000000000000000000002::coin;

use 0000000000000000000000000000000000000000000000000000000000000002::dynamic_field;

use 0000000000000000000000000000000000000000000000000000000000000002::event;

use 0000000000000000000000000000000000000000000000000000000000000002::kiosk;

use 0000000000000000000000000000000000000000000000000000000000000002::object;

use 0000000000000000000000000000000000000000000000000000000000000002::package;

use 0000000000000000000000000000000000000000000000000000000000000002::table_vec;

use 0000000000000000000000000000000000000000000000000000000000000002::transfer;

use 0000000000000000000000000000000000000000000000000000000000000002::transfer_policy;

use 0000000000000000000000000000000000000000000000000000000000000002::tx_context;

use 0000000000000000000000000000000000000000000000000000000000000002::vec_set;

struct LAUNCH has drop {

dummy_field: bool

}

struct Launch<phantom Ty0: store + key> has key {

id: UID,

state: LaunchState,

items: TableVec<Ty0>,

phase_ids: VecSet<ID>,

revenue: Bag,

kiosk_requirement: KioskRequirement,

operators: VecSet<address>

}

struct LaunchAdminCap has store, key {

id: UID,

launch_id: ID,

is_withdrew_revenue: bool

}

struct LaunchOperatorCap has drop {

launch_id: ID

}

struct ShareLaunchPromise {

launch_id: ID

}

struct LaunchLink<phantom Ty0: key> has copy, drop, store {

dummy_field: bool

}

struct LaunchCreatedEvent has copy, drop {

launch_id: ID,

launch_admin_cap_id: ID,

launch_type: TypeName

}

struct ItemAddedEvent has copy, drop {

launch_id: ID,

item_type: TypeName

}

struct ItemsAddedEvent has copy, drop {

launch_id: ID,

item_type: TypeName,

quantity: u64

}

struct ItemsRemovedEvent has copy, drop {

launch_id: ID,

item_type: TypeName,

quantity: u64

}

struct SchedulingStateSetEvent has copy, drop {

launch_id: ID

}

struct CompletedStateSetEvent has copy, drop {

launch_id: ID,

ts: u64

}

enum KioskRequirement has copy, drop, store {

NONE { },

PLACE { },

LOCK { }

}

enum LaunchState has copy, drop, store {

SUPPLYING { total_supply: u64 },

ACTIVE { minted_supply: u64 },

PAUSED { minted_supply: u64 },

COMPLETED { }

}

init(Arg0: LAUNCH, Arg1: &mut TxContext) {

B0:

0MoveLoc[0](Arg0: LAUNCH)

1CopyLoc[1](Arg1: &mut TxContext)

2Call package::claim<LAUNCH>(LAUNCH, &mut TxContext): Publisher

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

4FreezeRef

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

6Call transfer::public_transfer<Publisher>(Publisher, address)

7Ret

}

public new<Ty0: store + key>(Arg0: &Publisher, Arg1: u64, Arg2: KioskRequirement, Arg3: &mut TxContext): Launch<Ty0> * LaunchAdminCap * ShareLaunchPromise {

L4: loc0: Launch<Ty0>

L5: loc1: LaunchAdminCap

L6: loc2: ShareLaunchPromise

B0:

0MoveLoc[0](Arg0: &Publisher)

1Call package::from_module<Ty0>(&Publisher): bool

2LdTrue

3Eq

4BrFalse(6)

B1:

5Branch(10)

B2:

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

7Pop

8LdConst[6](u64: 10006)

9Abort

B3:

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

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

12MoveLoc[1](Arg1: u64)

13PackVariant(VariantHandleIndex(0))

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

15Call table_vec::empty<Ty0>(&mut TxContext): TableVec<Ty0>

16Call vec_set::empty<ID>(): VecSet<ID>

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

18Call bag::new(&mut TxContext): Bag

19MoveLoc[2](Arg2: KioskRequirement)

20Call vec_set::empty<address>(): VecSet<address>

21PackGeneric[0](Launch<Ty0>)

22StLoc[4](loc0: Launch<Ty0>)

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

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

25ImmBorrowLoc[4](loc0: Launch<Ty0>)

26Call id<Ty0>(&Launch<Ty0>): ID

27LdFalse

28Pack[2](LaunchAdminCap)

29StLoc[5](loc1: LaunchAdminCap)

30ImmBorrowLoc[4](loc0: Launch<Ty0>)

31Call id<Ty0>(&Launch<Ty0>): ID

32Pack[4](ShareLaunchPromise)

33StLoc[6](loc2: ShareLaunchPromise)

34MutBorrowLoc[4](loc0: Launch<Ty0>)

35ImmBorrowLoc[5](loc1: LaunchAdminCap)

36ImmBorrowLoc[5](loc1: LaunchAdminCap)

37Call new_launch_link<Ty0, LaunchAdminCap>(&mut Launch<Ty0>, &LaunchAdminCap, &LaunchAdminCap)

38ImmBorrowLoc[4](loc0: Launch<Ty0>)

39Call id<Ty0>(&Launch<Ty0>): ID

40ImmBorrowLoc[5](loc1: LaunchAdminCap)

41ImmBorrowField[0](LaunchAdminCap.id: UID)

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

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

44Pack[6](LaunchCreatedEvent)

45Call event::emit<LaunchCreatedEvent>(LaunchCreatedEvent)

46MoveLoc[4](loc0: Launch<Ty0>)

47MoveLoc[5](loc1: LaunchAdminCap)

48MoveLoc[6](loc2: ShareLaunchPromise)

49Ret

}

public new_kiosk_requirement_none(): KioskRequirement {

B0:

0PackVariant(VariantHandleIndex(1))

1Ret

}

public new_kiosk_requirement_place(): KioskRequirement {

B0:

0PackVariant(VariantHandleIndex(2))

1Ret

}

public new_kiosk_requirement_lock(): KioskRequirement {

B0:

0PackVariant(VariantHandleIndex(3))

1Ret

}

B0:

0ImmBorrowLoc[1](Arg1: ShareLaunchPromise)

1ImmBorrowField[1](ShareLaunchPromise.launch_id: ID)

2ReadRef

3ImmBorrowLoc[0](Arg0: Launch<Ty0>)

4Call id<Ty0>(&Launch<Ty0>): ID

5Eq

6BrFalse(8)

B1:

7Branch(10)

B2:

8LdConst[4](u64: 10004)

9Abort

B3:

10MoveLoc[1](Arg1: ShareLaunchPromise)

11Unpack[4](ShareLaunchPromise)

12Pop

13MoveLoc[0](Arg0: Launch<Ty0>)

14Call transfer::share_object<Launch<Ty0>>(Launch<Ty0>)

15Ret

}

public add_item<Ty0: store + key>(Arg0: &mut Launch<Ty0>, Arg1: &LaunchOperatorCap, Arg2: Ty0) {

L3: loc0: &LaunchState

L4: loc1: LaunchState

L5: loc2: u64

B0:

0MoveLoc[1](Arg1: &LaunchOperatorCap)

1CopyLoc[0](Arg0: &mut Launch<Ty0>)

2FreezeRef

3Call id<Ty0>(&Launch<Ty0>): ID

4Call launch_operator_cap_authorize(&LaunchOperatorCap, ID)

5CopyLoc[0](Arg0: &mut Launch<Ty0>)

6ImmBorrowFieldGeneric[0](Launch.state: LaunchState)

7ReadRef

8StLoc[4](loc1: LaunchState)

9ImmBorrowLoc[4](loc1: LaunchState)

10StLoc[3](loc0: &LaunchState)

11CopyLoc[3](loc0: &LaunchState)

12VariantSwitch(VariantJumpTableIndex(0))

B1:

13MoveLoc[3](loc0: &LaunchState)

14UnpackVariantImmRef(VariantHandleIndex(0))

15Pop

16MoveLoc[4](loc1: LaunchState)

17UnpackVariant(VariantHandleIndex(0))

18StLoc[5](loc2: u64)

19CopyLoc[0](Arg0: &mut Launch<Ty0>)

20ImmBorrowFieldGeneric[1](Launch.items: TableVec<Ty0>)

21Call table_vec::length<Ty0>(&TableVec<Ty0>): u64

22LdU64(1)

23Add

24MoveLoc[5](loc2: u64)

25Le

26BrFalse(28)

B2:

27Branch(50)

B3:

28MoveLoc[0](Arg0: &mut Launch<Ty0>)

29Pop

30LdConst[2](u64: 10002)

31Abort

B4:

32MoveLoc[0](Arg0: &mut Launch<Ty0>)

33Pop

34MoveLoc[3](loc0: &LaunchState)

35Pop

36LdConst[7](u64: 10007)

37Abort

B5:

38MoveLoc[0](Arg0: &mut Launch<Ty0>)

39Pop

40MoveLoc[3](loc0: &LaunchState)

41Pop

42LdConst[7](u64: 10007)

43Abort

B6:

44MoveLoc[0](Arg0: &mut Launch<Ty0>)

45Pop

46MoveLoc[3](loc0: &LaunchState)

47Pop

48LdConst[7](u64: 10007)

49Abort

B7:

50CopyLoc[0](Arg0: &mut Launch<Ty0>)

51FreezeRef

52Call id<Ty0>(&Launch<Ty0>): ID

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

54Pack[7](ItemAddedEvent)

55Call event::emit<ItemAddedEvent>(ItemAddedEvent)

56MoveLoc[0](Arg0: &mut Launch<Ty0>)

57MutBorrowFieldGeneric[1](Launch.items: TableVec<Ty0>)

58MoveLoc[2](Arg2: Ty0)

59Call table_vec::push_back<Ty0>(&mut TableVec<Ty0>, Ty0)

60Ret

Jump tables:

[0]: variant_switch LaunchState {

Variant0 => jump 13

Variant1 => jump 32

Variant2 => jump 38

Variant3 => jump 44

}

public add_items<Ty0: store + key>(Arg0: &mut Launch<Ty0>, Arg1: &LaunchOperatorCap, Arg2: vector<Ty0>) {

L3: loc0: u64

L4: loc1: &LaunchState

L5: loc2: LaunchState

L6: loc3: u64

L7: loc4: Ty0

L8: loc5: u64

L9: loc6: u64

L10: loc7: vector<Ty0>

B0:

0MoveLoc[1](Arg1: &LaunchOperatorCap)

1CopyLoc[0](Arg0: &mut Launch<Ty0>)

2FreezeRef

3Call id<Ty0>(&Launch<Ty0>): ID

4Call launch_operator_cap_authorize(&LaunchOperatorCap, ID)

5CopyLoc[0](Arg0: &mut Launch<Ty0>)

6ImmBorrowFieldGeneric[0](Launch.state: LaunchState)

7ReadRef

8StLoc[5](loc2: LaunchState)

9ImmBorrowLoc[5](loc2: LaunchState)

10StLoc[4](loc1: &LaunchState)

11CopyLoc[4](loc1: &LaunchState)

12VariantSwitch(VariantJumpTableIndex(0))

B1:

13MoveLoc[4](loc1: &LaunchState)

14UnpackVariantImmRef(VariantHandleIndex(0))

15Pop

16MoveLoc[5](loc2: LaunchState)

17UnpackVariant(VariantHandleIndex(0))

18StLoc[9](loc6: u64)

19CopyLoc[0](Arg0: &mut Launch<Ty0>)

20ImmBorrowFieldGeneric[1](Launch.items: TableVec<Ty0>)

21Call table_vec::length<Ty0>(&TableVec<Ty0>): u64

22ImmBorrowLoc[2](Arg2: vector<Ty0>)

23VecLen(47)

24Add

25MoveLoc[9](loc6: u64)

26Le

27BrFalse(29)

B2:

28Branch(33)

B3:

29MoveLoc[0](Arg0: &mut Launch<Ty0>)

30Pop

31LdConst[2](u64: 10002)

32Abort

B4:

33CopyLoc[0](Arg0: &mut Launch<Ty0>)

34FreezeRef

35Call id<Ty0>(&Launch<Ty0>): ID

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

37ImmBorrowLoc[2](Arg2: vector<Ty0>)

38VecLen(47)

39Pack[8](ItemsAddedEvent)

40Call event::emit<ItemsAddedEvent>(ItemsAddedEvent)

41MoveLoc[2](Arg2: vector<Ty0>)

42StLoc[10](loc7: vector<Ty0>)

43ImmBorrowLoc[10](loc7: vector<Ty0>)

44VecLen(47)

45StLoc[3](loc0: u64)

46LdU64(0)

47StLoc[6](loc3: u64)

48MoveLoc[3](loc0: u64)

49StLoc[8](loc5: u64)

B5:

50CopyLoc[6](loc3: u64)

51CopyLoc[8](loc5: u64)

52Lt

53BrFalse(86)

B6:

54CopyLoc[6](loc3: u64)

55Pop

56MutBorrowLoc[10](loc7: vector<Ty0>)

57VecPopBack(47)

58StLoc[7](loc4: Ty0)

59CopyLoc[0](Arg0: &mut Launch<Ty0>)

60MutBorrowFieldGeneric[1](Launch.items: TableVec<Ty0>)

61MoveLoc[7](loc4: Ty0)

62Call table_vec::push_back<Ty0>(&mut TableVec<Ty0>, Ty0)

63MoveLoc[6](loc3: u64)

64LdU64(1)

65Add

66StLoc[6](loc3: u64)

67Branch(50)

B7:

68MoveLoc[0](Arg0: &mut Launch<Ty0>)

69Pop

70MoveLoc[4](loc1: &LaunchState)

71Pop

72LdConst[7](u64: 10007)

73Abort

B8:

74MoveLoc[0](Arg0: &mut Launch<Ty0>)

75Pop

76MoveLoc[4](loc1: &LaunchState)

77Pop

78LdConst[7](u64: 10007)

79Abort

B9:

80MoveLoc[0](Arg0: &mut Launch<Ty0>)

81Pop

82MoveLoc[4](loc1: &LaunchState)

83Pop

84LdConst[7](u64: 10007)

85Abort

B10:

86MoveLoc[0](Arg0: &mut Launch<Ty0>)

87Pop

88MoveLoc[10](loc7: vector<Ty0>)

89VecUnpack(47, 0)

90Ret

Jump tables:

[0]: variant_switch LaunchState {

Variant0 => jump 13

Variant1 => jump 68

Variant2 => jump 74

Variant3 => jump 80

}

public remove_items<Ty0: store + key>(Arg0: &mut Launch<Ty0>, Arg1: &LaunchOperatorCap, Arg2: u64): vector<Ty0> {

L3: loc0: u64

L4: loc1: Ty0

L5: loc2: &mut vector<Ty0>

L6: loc3: &LaunchState

L7: loc4: LaunchState

L8: loc5: u64

L9: loc6: u64

L10: loc7: u64

L11: loc8: vector<Ty0>

L12: loc9: u64

B0:

0MoveLoc[1](Arg1: &LaunchOperatorCap)

1CopyLoc[0](Arg0: &mut Launch<Ty0>)

2FreezeRef

3Call id<Ty0>(&Launch<Ty0>): ID

4Call launch_operator_cap_authorize(&LaunchOperatorCap, ID)

5CopyLoc[0](Arg0: &mut Launch<Ty0>)

6ImmBorrowFieldGeneric[0](Launch.state: LaunchState)

7ReadRef

8StLoc[7](loc4: LaunchState)

9ImmBorrowLoc[7](loc4: LaunchState)

10StLoc[6](loc3: &LaunchState)

11CopyLoc[6](loc3: &LaunchState)

12VariantSwitch(VariantJumpTableIndex(0))

B1:

13MoveLoc[6](loc3: &LaunchState)

14UnpackVariantImmRef(VariantHandleIndex(0))

15Pop

16MoveLoc[7](loc4: LaunchState)

17UnpackVariant(VariantHandleIndex(0))

18Pop

19CopyLoc[2](Arg2: u64)

20CopyLoc[0](Arg0: &mut Launch<Ty0>)

21ImmBorrowFieldGeneric[1](Launch.items: TableVec<Ty0>)

22Call table_vec::length<Ty0>(&TableVec<Ty0>): u64

23Call u64::min(u64, u64): u64

24StLoc[12](loc9: u64)

25CopyLoc[0](Arg0: &mut Launch<Ty0>)

26FreezeRef

27Call id<Ty0>(&Launch<Ty0>): ID

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

29MoveLoc[2](Arg2: u64)

30Pack[9](ItemsRemovedEvent)

31Call event::emit<ItemsRemovedEvent>(ItemsRemovedEvent)

32VecPack(47, 0)

33StLoc[11](loc8: vector<Ty0>)

34MoveLoc[12](loc9: u64)

35StLoc[3](loc0: u64)

36LdU64(0)

37StLoc[9](loc6: u64)

38MoveLoc[3](loc0: u64)

39StLoc[10](loc7: u64)

B2:

40CopyLoc[9](loc6: u64)

41CopyLoc[10](loc7: u64)

42Lt

43BrFalse(80)

B3:

44CopyLoc[9](loc6: u64)

45StLoc[8](loc5: u64)

46MutBorrowLoc[11](loc8: vector<Ty0>)

47StLoc[5](loc2: &mut vector<Ty0>)

48MoveLoc[8](loc5: u64)

49Pop

50CopyLoc[0](Arg0: &mut Launch<Ty0>)

51MutBorrowFieldGeneric[1](Launch.items: TableVec<Ty0>)

52Call table_vec::pop_back<Ty0>(&mut TableVec<Ty0>): Ty0

53StLoc[4](loc1: Ty0)

54MoveLoc[5](loc2: &mut vector<Ty0>)

55MoveLoc[4](loc1: Ty0)

56VecPushBack(47)

57MoveLoc[9](loc6: u64)

58LdU64(1)

59Add

60StLoc[9](loc6: u64)

61Branch(40)

B4:

62MoveLoc[0](Arg0: &mut Launch<Ty0>)

63Pop

64MoveLoc[6](loc3: &LaunchState)

65Pop

66LdConst[7](u64: 10007)

67Abort

B5:

68MoveLoc[0](Arg0: &mut Launch<Ty0>)

69Pop

70MoveLoc[6](loc3: &LaunchState)

71Pop

72LdConst[7](u64: 10007)

73Abort

B6:

74MoveLoc[0](Arg0: &mut Launch<Ty0>)

75Pop

76MoveLoc[6](loc3: &LaunchState)

77Pop

78LdConst[7](u64: 10007)

79Abort

B7:

80MoveLoc[0](Arg0: &mut Launch<Ty0>)

81Pop

82MoveLoc[11](loc8: vector<Ty0>)

83Ret

Jump tables:

[0]: variant_switch LaunchState {

Variant0 => jump 13

Variant1 => jump 62

Variant2 => jump 68

Variant3 => jump 74

}

public set_active_state<Ty0: store + key>(Arg0: &mut Launch<Ty0>, Arg1: &LaunchOperatorCap) {

L2: loc0: &LaunchState

L3: loc1: LaunchState

L4: loc2: u64

B0:

0MoveLoc[1](Arg1: &LaunchOperatorCap)

1CopyLoc[0](Arg0: &mut Launch<Ty0>)

2FreezeRef

3Call id<Ty0>(&Launch<Ty0>): ID

4Call launch_operator_cap_authorize(&LaunchOperatorCap, ID)

5CopyLoc[0](Arg0: &mut Launch<Ty0>)

6ImmBorrowFieldGeneric[0](Launch.state: LaunchState)

7ReadRef

8StLoc[3](loc1: LaunchState)

9ImmBorrowLoc[3](loc1: LaunchState)

10StLoc[2](loc0: &LaunchState)

11CopyLoc[2](loc0: &LaunchState)

12VariantSwitch(VariantJumpTableIndex(0))

B1:

13MoveLoc[2](loc0: &LaunchState)

14UnpackVariantImmRef(VariantHandleIndex(0))

15Pop

16MoveLoc[3](loc1: LaunchState)

17UnpackVariant(VariantHandleIndex(0))

18StLoc[4](loc2: u64)

19CopyLoc[0](Arg0: &mut Launch<Ty0>)

20ImmBorrowFieldGeneric[1](Launch.items: TableVec<Ty0>)

21Call table_vec::length<Ty0>(&TableVec<Ty0>): u64

22MoveLoc[4](loc2: u64)

23Eq

24BrFalse(26)

B2:

25Branch(30)

B3:

26MoveLoc[0](Arg0: &mut Launch<Ty0>)

27Pop

28LdConst[15](u64: 10015)

29Abort

B4:

30CopyLoc[0](Arg0: &mut Launch<Ty0>)

31FreezeRef

32Call id<Ty0>(&Launch<Ty0>): ID

33Pack[10](SchedulingStateSetEvent)

34Call event::emit<SchedulingStateSetEvent>(SchedulingStateSetEvent)

35LdU64(0)

36PackVariant(VariantHandleIndex(4))

37MoveLoc[0](Arg0: &mut Launch<Ty0>)

38MutBorrowFieldGeneric[0](Launch.state: LaunchState)

39WriteRef

40Branch(63)

B5:

41MoveLoc[0](Arg0: &mut Launch<Ty0>)

42Pop

43MoveLoc[2](loc0: &LaunchState)

44Pop

45LdConst[7](u64: 10007)

46Abort

B6:

47MoveLoc[2](loc0: &LaunchState)

48UnpackVariantImmRef(VariantHandleIndex(5))

49Pop

50MoveLoc[3](loc1: LaunchState)

51UnpackVariant(VariantHandleIndex(5))

52PackVariant(VariantHandleIndex(4))

53MoveLoc[0](Arg0: &mut Launch<Ty0>)

54MutBorrowFieldGeneric[0](Launch.state: LaunchState)

55WriteRef

56Branch(63)

B7:

57MoveLoc[0](Arg0: &mut Launch<Ty0>)

58Pop

59MoveLoc[2](loc0: &LaunchState)

60Pop

61LdConst[7](u64: 10007)

62Abort

B8:

63Ret

Jump tables:

[0]: variant_switch LaunchState {

Variant0 => jump 13

Variant1 => jump 41

Variant2 => jump 47

Variant3 => jump 57

}

public set_paused_state<Ty0: store + key>(Arg0: &mut Launch<Ty0>, Arg1: &LaunchOperatorCap) {

L2: loc0: &LaunchState

L3: loc1: LaunchState

B0:

0MoveLoc[1](Arg1: &LaunchOperatorCap)

1CopyLoc[0](Arg0: &mut Launch<Ty0>)

2FreezeRef

3Call id<Ty0>(&Launch<Ty0>): ID

4Call launch_operator_cap_authorize(&LaunchOperatorCap, ID)

5CopyLoc[0](Arg0: &mut Launch<Ty0>)

6ImmBorrowFieldGeneric[0](Launch.state: LaunchState)

7ReadRef

8StLoc[3](loc1: LaunchState)

9ImmBorrowLoc[3](loc1: LaunchState)

10StLoc[2](loc0: &LaunchState)

11CopyLoc[2](loc0: &LaunchState)

12VariantSwitch(VariantJumpTableIndex(0))

B1:

13MoveLoc[0](Arg0: &mut Launch<Ty0>)

14Pop

15MoveLoc[2](loc0: &LaunchState)

16Pop

17Branch(37)

B2:

18MoveLoc[2](loc0: &LaunchState)

19UnpackVariantImmRef(VariantHandleIndex(4))

20Pop

21MoveLoc[3](loc1: LaunchState)

22UnpackVariant(VariantHandleIndex(4))

23PackVariant(VariantHandleIndex(5))

24MoveLoc[0](Arg0: &mut Launch<Ty0>)

25MutBorrowFieldGeneric[0](Launch.state: LaunchState)

26WriteRef

27Branch(37)

B3:

28MoveLoc[0](Arg0: &mut Launch<Ty0>)

29Pop

30MoveLoc[2](loc0: &LaunchState)

31Pop

32Branch(37)

B4:

33MoveLoc[0](Arg0: &mut Launch<Ty0>)

34Pop

35MoveLoc[2](loc0: &LaunchState)

36Pop

B5:

37Ret

Jump tables:

[0]: variant_switch LaunchState {

Variant0 => jump 13

Variant1 => jump 18

Variant2 => jump 28

Variant3 => jump 33

}

public set_completed_state<Ty0: store + key>(Arg0: &mut Launch<Ty0>, Arg1: &LaunchOperatorCap, Arg2: &Clock) {

L3: loc0: &LaunchState

L4: loc1: LaunchState

B0:

0MoveLoc[1](Arg1: &LaunchOperatorCap)

1CopyLoc[0](Arg0: &mut Launch<Ty0>)

2FreezeRef

3Call id<Ty0>(&Launch<Ty0>): ID

4Call launch_operator_cap_authorize(&LaunchOperatorCap, ID)

5CopyLoc[0](Arg0: &mut Launch<Ty0>)

6ImmBorrowFieldGeneric[0](Launch.state: LaunchState)

7ReadRef

8StLoc[4](loc1: LaunchState)

9ImmBorrowLoc[4](loc1: LaunchState)

10StLoc[3](loc0: &LaunchState)

11CopyLoc[3](loc0: &LaunchState)

12VariantSwitch(VariantJumpTableIndex(0))

B1:

13MoveLoc[0](Arg0: &mut Launch<Ty0>)

14Pop

15MoveLoc[2](Arg2: &Clock)

16Pop

17MoveLoc[3](loc0: &LaunchState)

18Pop

19LdConst[7](u64: 10007)

20Abort

B2:

21MoveLoc[3](loc0: &LaunchState)

22UnpackVariantImmRef(VariantHandleIndex(4))

23Pop

24MoveLoc[4](loc1: LaunchState)

25UnpackVariant(VariantHandleIndex(4))

26Pop

27CopyLoc[0](Arg0: &mut Launch<Ty0>)

28ImmBorrowFieldGeneric[1](Launch.items: TableVec<Ty0>)

29Call table_vec::is_empty<Ty0>(&TableVec<Ty0>): bool

30BrFalse(32)

B3:

31Branch(54)

B4:

32MoveLoc[0](Arg0: &mut Launch<Ty0>)

33Pop

34MoveLoc[2](Arg2: &Clock)

35Pop

36LdConst[12](u64: 10012)

37Abort

B5:

38MoveLoc[0](Arg0: &mut Launch<Ty0>)

39Pop

40MoveLoc[2](Arg2: &Clock)

41Pop

42MoveLoc[3](loc0: &LaunchState)

43Pop

44LdConst[7](u64: 10007)

45Abort

B6:

46MoveLoc[0](Arg0: &mut Launch<Ty0>)

47Pop

48MoveLoc[2](Arg2: &Clock)

49Pop

50MoveLoc[3](loc0: &LaunchState)

51Pop

52LdConst[7](u64: 10007)

53Abort

B7:

54PackVariant(VariantHandleIndex(6))

55CopyLoc[0](Arg0: &mut Launch<Ty0>)

56MutBorrowFieldGeneric[0](Launch.state: LaunchState)

57WriteRef

58MoveLoc[0](Arg0: &mut Launch<Ty0>)

59FreezeRef

60Call id<Ty0>(&Launch<Ty0>): ID

61MoveLoc[2](Arg2: &Clock)

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

63Pack[11](CompletedStateSetEvent)

64Call event::emit<CompletedStateSetEvent>(CompletedStateSetEvent)

65Ret

Jump tables:

[0]: variant_switch LaunchState {

Variant0 => jump 13

Variant1 => jump 21

Variant2 => jump 38

Variant3 => jump 46

}

public withdraw_items<Ty0: store + key>(Arg0: &mut Launch<Ty0>, Arg1: &mut LaunchOperatorCap, Arg2: u64): vector<Ty0> {

L3: loc0: u64

L4: loc1: Ty0

L5: loc2: &mut vector<Ty0>

L6: loc3: &LaunchState

L7: loc4: LaunchState

L8: loc5: u64

L9: loc6: u64

L10: loc7: u64

L11: loc8: vector<Ty0>

B0:

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

1FreezeRef

2CopyLoc[0](Arg0: &mut Launch<Ty0>)

3FreezeRef

4Call id<Ty0>(&Launch<Ty0>): ID

5Call launch_operator_cap_authorize(&LaunchOperatorCap, ID)

6CopyLoc[0](Arg0: &mut Launch<Ty0>)

7FreezeRef

8Call assert_kiosk_requirement_none<Ty0>(&Launch<Ty0>)

9CopyLoc[0](Arg0: &mut Launch<Ty0>)

10ImmBorrowFieldGeneric[0](Launch.state: LaunchState)

11ReadRef

12StLoc[7](loc4: LaunchState)

13ImmBorrowLoc[7](loc4: LaunchState)

14StLoc[6](loc3: &LaunchState)

15CopyLoc[6](loc3: &LaunchState)

16VariantSwitch(VariantJumpTableIndex(0))

B1:

17MoveLoc[0](Arg0: &mut Launch<Ty0>)

18Pop

19MoveLoc[6](loc3: &LaunchState)

20Pop

21LdConst[7](u64: 10007)

22Abort

B2:

23MoveLoc[6](loc3: &LaunchState)

24UnpackVariantImmRef(VariantHandleIndex(4))

25Pop

26MoveLoc[7](loc4: LaunchState)

27UnpackVariant(VariantHandleIndex(4))

28Pop

29CopyLoc[0](Arg0: &mut Launch<Ty0>)

30ImmBorrowFieldGeneric[1](Launch.items: TableVec<Ty0>)

31Call table_vec::is_empty<Ty0>(&TableVec<Ty0>): bool

32Not

33BrFalse(35)

B3:

34Branch(39)

B4:

35MoveLoc[0](Arg0: &mut Launch<Ty0>)

36Pop

37LdConst[13](u64: 10013)

38Abort

B5:

39MoveLoc[2](Arg2: u64)

40CopyLoc[0](Arg0: &mut Launch<Ty0>)

41ImmBorrowFieldGeneric[1](Launch.items: TableVec<Ty0>)

42Call table_vec::length<Ty0>(&TableVec<Ty0>): u64

43Call u64::min(u64, u64): u64

44StLoc[2](Arg2: u64)

45VecPack(47, 0)

46StLoc[11](loc8: vector<Ty0>)

47MoveLoc[2](Arg2: u64)

48StLoc[3](loc0: u64)

49LdU64(0)

50StLoc[9](loc6: u64)

51MoveLoc[3](loc0: u64)

52StLoc[10](loc7: u64)

B6:

53CopyLoc[9](loc6: u64)

54CopyLoc[10](loc7: u64)

55Lt

56BrFalse(87)

B7:

57CopyLoc[9](loc6: u64)

58StLoc[8](loc5: u64)

59MutBorrowLoc[11](loc8: vector<Ty0>)

60StLoc[5](loc2: &mut vector<Ty0>)

61MoveLoc[8](loc5: u64)

62Pop

63CopyLoc[0](Arg0: &mut Launch<Ty0>)

64MutBorrowFieldGeneric[1](Launch.items: TableVec<Ty0>)

65Call table_vec::pop_back<Ty0>(&mut TableVec<Ty0>): Ty0

66StLoc[4](loc1: Ty0)

67MoveLoc[5](loc2: &mut vector<Ty0>)

68MoveLoc[4](loc1: Ty0)

69VecPushBack(47)

70MoveLoc[9](loc6: u64)

71LdU64(1)

72Add

73StLoc[9](loc6: u64)

74Branch(53)

B8:

75MoveLoc[0](Arg0: &mut Launch<Ty0>)

76Pop

77MoveLoc[6](loc3: &LaunchState)

78Pop

79LdConst[7](u64: 10007)

80Abort

B9:

81MoveLoc[0](Arg0: &mut Launch<Ty0>)

82Pop

83MoveLoc[6](loc3: &LaunchState)

84Pop

85LdConst[7](u64: 10007)

86Abort

B10:

87MoveLoc[0](Arg0: &mut Launch<Ty0>)

88Pop

89MoveLoc[11](loc8: vector<Ty0>)

90Ret

Jump tables:

[0]: variant_switch LaunchState {

Variant0 => jump 17

Variant1 => jump 23

Variant2 => jump 75

Variant3 => jump 81

}

public withdraw_items_and_place_in_kiosk<Ty0: store + key>(Arg0: &mut Launch<Ty0>, Arg1: &mut LaunchOperatorCap, Arg2: u64, Arg3: &mut Kiosk, Arg4: &KioskOwnerCap) {

L5: loc0: u64

L6: loc1: u64

L7: loc2: Ty0

L8: loc3: &mut vector<Ty0>

L9: loc4: &LaunchState

L10: loc5: LaunchState

L11: loc6: u64

L12: loc7: u64

L13: loc8: u64

L14: loc9: Ty0

L15: loc10: u64

L16: loc11: u64

L17: loc12: vector<Ty0>

L18: loc13: vector<Ty0>

B0:

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

1FreezeRef

2CopyLoc[0](Arg0: &mut Launch<Ty0>)

3FreezeRef

4Call id<Ty0>(&Launch<Ty0>): ID

5Call launch_operator_cap_authorize(&LaunchOperatorCap, ID)

6CopyLoc[0](Arg0: &mut Launch<Ty0>)

7FreezeRef

8Call assert_kiosk_requirement_place<Ty0>(&Launch<Ty0>)

9CopyLoc[0](Arg0: &mut Launch<Ty0>)

10ImmBorrowFieldGeneric[0](Launch.state: LaunchState)

11ReadRef

12StLoc[10](loc5: LaunchState)

13ImmBorrowLoc[10](loc5: LaunchState)

14StLoc[9](loc4: &LaunchState)

15CopyLoc[9](loc4: &LaunchState)

16VariantSwitch(VariantJumpTableIndex(0))

B1:

17MoveLoc[0](Arg0: &mut Launch<Ty0>)

18Pop

19MoveLoc[4](Arg4: &KioskOwnerCap)

20Pop

21MoveLoc[3](Arg3: &mut Kiosk)

22Pop

23MoveLoc[9](loc4: &LaunchState)

24Pop

25LdConst[7](u64: 10007)

26Abort

B2:

27MoveLoc[9](loc4: &LaunchState)

28UnpackVariantImmRef(VariantHandleIndex(4))

29Pop

30MoveLoc[10](loc5: LaunchState)

31UnpackVariant(VariantHandleIndex(4))

32Pop

33CopyLoc[0](Arg0: &mut Launch<Ty0>)

34ImmBorrowFieldGeneric[1](Launch.items: TableVec<Ty0>)

35Call table_vec::is_empty<Ty0>(&TableVec<Ty0>): bool

36Not

37BrFalse(39)

B3:

38Branch(47)

B4:

39MoveLoc[0](Arg0: &mut Launch<Ty0>)

40Pop

41MoveLoc[4](Arg4: &KioskOwnerCap)

42Pop

43MoveLoc[3](Arg3: &mut Kiosk)

44Pop

45LdConst[13](u64: 10013)

46Abort

B5:

47MoveLoc[2](Arg2: u64)

48CopyLoc[0](Arg0: &mut Launch<Ty0>)

49ImmBorrowFieldGeneric[1](Launch.items: TableVec<Ty0>)

50Call table_vec::length<Ty0>(&TableVec<Ty0>): u64

51Call u64::min(u64, u64): u64

52StLoc[2](Arg2: u64)

53VecPack(47, 0)

54StLoc[17](loc12: vector<Ty0>)

55MoveLoc[2](Arg2: u64)

56StLoc[6](loc1: u64)

57LdU64(0)

58StLoc[13](loc8: u64)

59MoveLoc[6](loc1: u64)

60StLoc[16](loc11: u64)

B6:

61CopyLoc[13](loc8: u64)

62CopyLoc[16](loc11: u64)

63Lt

64BrFalse(83)

B7:

65CopyLoc[13](loc8: u64)

66StLoc[11](loc6: u64)

67MutBorrowLoc[17](loc12: vector<Ty0>)

68StLoc[8](loc3: &mut vector<Ty0>)

69MoveLoc[11](loc6: u64)

70Pop

71CopyLoc[0](Arg0: &mut Launch<Ty0>)

72MutBorrowFieldGeneric[1](Launch.items: TableVec<Ty0>)

73Call table_vec::pop_back<Ty0>(&mut TableVec<Ty0>): Ty0

74StLoc[7](loc2: Ty0)

75MoveLoc[8](loc3: &mut vector<Ty0>)

76MoveLoc[7](loc2: Ty0)

77VecPushBack(47)

78MoveLoc[13](loc8: u64)

79LdU64(1)

80Add

81StLoc[13](loc8: u64)

82Branch(61)

B8:

83MoveLoc[0](Arg0: &mut Launch<Ty0>)

84Pop

85MoveLoc[17](loc12: vector<Ty0>)

86StLoc[18](loc13: vector<Ty0>)

87ImmBorrowLoc[18](loc13: vector<Ty0>)

88VecLen(47)

89StLoc[5](loc0: u64)

90LdU64(0)

91StLoc[12](loc7: u64)

92MoveLoc[5](loc0: u64)

93StLoc[15](loc10: u64)

B9:

94CopyLoc[12](loc7: u64)

95CopyLoc[15](loc10: u64)

96Lt

97BrFalse(132)

B10:

98CopyLoc[12](loc7: u64)

99Pop

100MutBorrowLoc[18](loc13: vector<Ty0>)

101VecPopBack(47)

102StLoc[14](loc9: Ty0)

103CopyLoc[3](Arg3: &mut Kiosk)

104CopyLoc[4](Arg4: &KioskOwnerCap)

105MoveLoc[14](loc9: Ty0)

106Call kiosk::place<Ty0>(&mut Kiosk, &KioskOwnerCap, Ty0)

107MoveLoc[12](loc7: u64)

108LdU64(1)

109Add

110StLoc[12](loc7: u64)

111Branch(94)

B11:

112MoveLoc[0](Arg0: &mut Launch<Ty0>)

113Pop

114MoveLoc[4](Arg4: &KioskOwnerCap)

115Pop

116MoveLoc[3](Arg3: &mut Kiosk)

117Pop

118MoveLoc[9](loc4: &LaunchState)

119Pop

120LdConst[7](u64: 10007)

121Abort

B12:

122MoveLoc[0](Arg0: &mut Launch<Ty0>)

123Pop

124MoveLoc[4](Arg4: &KioskOwnerCap)

125Pop

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

127Pop

128MoveLoc[9](loc4: &LaunchState)

129Pop

130LdConst[7](u64: 10007)

131Abort

B13:

132MoveLoc[4](Arg4: &KioskOwnerCap)

133Pop

134MoveLoc[3](Arg3: &mut Kiosk)

135Pop

136MoveLoc[18](loc13: vector<Ty0>)

137VecUnpack(47, 0)

138Ret

Jump tables:

[0]: variant_switch LaunchState {

Variant0 => jump 17

Variant1 => jump 27

Variant2 => jump 112

Variant3 => jump 122

}

public withdraw_items_and_lock_in_kiosk<Ty0: store + key>(Arg0: &mut Launch<Ty0>, Arg1: &mut LaunchOperatorCap, Arg2: u64, Arg3: &mut Kiosk, Arg4: &KioskOwnerCap, Arg5: &TransferPolicy<Ty0>) {

L6: loc0: u64

L7: loc1: u64

L8: loc2: Ty0

L9: loc3: &mut vector<Ty0>

L10: loc4: &LaunchState

L11: loc5: LaunchState

L12: loc6: u64

L13: loc7: u64

L14: loc8: u64

L15: loc9: Ty0

L16: loc10: u64

L17: loc11: u64

L18: loc12: vector<Ty0>

L19: loc13: vector<Ty0>

B0:

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

1FreezeRef

2CopyLoc[0](Arg0: &mut Launch<Ty0>)

3FreezeRef

4Call id<Ty0>(&Launch<Ty0>): ID

5Call launch_operator_cap_authorize(&LaunchOperatorCap, ID)

6CopyLoc[0](Arg0: &mut Launch<Ty0>)

7FreezeRef

8Call assert_kiosk_requirement_lock<Ty0>(&Launch<Ty0>)

9CopyLoc[0](Arg0: &mut Launch<Ty0>)

10ImmBorrowFieldGeneric[0](Launch.state: LaunchState)

11ReadRef

12StLoc[11](loc5: LaunchState)

13ImmBorrowLoc[11](loc5: LaunchState)

14StLoc[10](loc4: &LaunchState)

15CopyLoc[10](loc4: &LaunchState)

16VariantSwitch(VariantJumpTableIndex(0))

B1:

17MoveLoc[0](Arg0: &mut Launch<Ty0>)

18Pop

19MoveLoc[5](Arg5: &TransferPolicy<Ty0>)

20Pop

21MoveLoc[4](Arg4: &KioskOwnerCap)

22Pop

23MoveLoc[3](Arg3: &mut Kiosk)

24Pop

25MoveLoc[10](loc4: &LaunchState)

26Pop

27LdConst[7](u64: 10007)

28Abort

B2:

29MoveLoc[10](loc4: &LaunchState)

30UnpackVariantImmRef(VariantHandleIndex(4))

31Pop

32MoveLoc[11](loc5: LaunchState)

33UnpackVariant(VariantHandleIndex(4))

34Pop

35CopyLoc[0](Arg0: &mut Launch<Ty0>)

36ImmBorrowFieldGeneric[1](Launch.items: TableVec<Ty0>)

37Call table_vec::is_empty<Ty0>(&TableVec<Ty0>): bool

38Not

39BrFalse(41)

B3:

40Branch(51)

B4:

41MoveLoc[0](Arg0: &mut Launch<Ty0>)

42Pop

43MoveLoc[5](Arg5: &TransferPolicy<Ty0>)

44Pop

45MoveLoc[4](Arg4: &KioskOwnerCap)

46Pop

47MoveLoc[3](Arg3: &mut Kiosk)

48Pop

49LdConst[13](u64: 10013)

50Abort

B5:

51MoveLoc[2](Arg2: u64)

52CopyLoc[0](Arg0: &mut Launch<Ty0>)

53ImmBorrowFieldGeneric[1](Launch.items: TableVec<Ty0>)

54Call table_vec::length<Ty0>(&TableVec<Ty0>): u64

55Call u64::min(u64, u64): u64

56StLoc[2](Arg2: u64)

57VecPack(47, 0)

58StLoc[18](loc12: vector<Ty0>)

59MoveLoc[2](Arg2: u64)

60StLoc[7](loc1: u64)

61LdU64(0)

62StLoc[14](loc8: u64)

63MoveLoc[7](loc1: u64)

64StLoc[17](loc11: u64)

B6:

65CopyLoc[14](loc8: u64)

66CopyLoc[17](loc11: u64)

67Lt

68BrFalse(87)

B7:

69CopyLoc[14](loc8: u64)

70StLoc[12](loc6: u64)

71MutBorrowLoc[18](loc12: vector<Ty0>)

72StLoc[9](loc3: &mut vector<Ty0>)

73MoveLoc[12](loc6: u64)

74Pop

75CopyLoc[0](Arg0: &mut Launch<Ty0>)

76MutBorrowFieldGeneric[1](Launch.items: TableVec<Ty0>)

77Call table_vec::pop_back<Ty0>(&mut TableVec<Ty0>): Ty0

78StLoc[8](loc2: Ty0)

79MoveLoc[9](loc3: &mut vector<Ty0>)

80MoveLoc[8](loc2: Ty0)

81VecPushBack(47)

82MoveLoc[14](loc8: u64)

83LdU64(1)

84Add

85StLoc[14](loc8: u64)

86Branch(65)

B8:

87MoveLoc[0](Arg0: &mut Launch<Ty0>)

88Pop

89MoveLoc[18](loc12: vector<Ty0>)

90StLoc[19](loc13: vector<Ty0>)

91ImmBorrowLoc[19](loc13: vector<Ty0>)

92VecLen(47)

93StLoc[6](loc0: u64)

94LdU64(0)

95StLoc[13](loc7: u64)

96MoveLoc[6](loc0: u64)

97StLoc[16](loc10: u64)

B9:

98CopyLoc[13](loc7: u64)

99CopyLoc[16](loc10: u64)

100Lt

101BrFalse(141)

B10:

102CopyLoc[13](loc7: u64)

103Pop

104MutBorrowLoc[19](loc13: vector<Ty0>)

105VecPopBack(47)

106StLoc[15](loc9: Ty0)

107CopyLoc[3](Arg3: &mut Kiosk)

108CopyLoc[4](Arg4: &KioskOwnerCap)

109CopyLoc[5](Arg5: &TransferPolicy<Ty0>)

110MoveLoc[15](loc9: Ty0)

111Call kiosk::lock<Ty0>(&mut Kiosk, &KioskOwnerCap, &TransferPolicy<Ty0>, Ty0)

112MoveLoc[13](loc7: u64)

113LdU64(1)

114Add

115StLoc[13](loc7: u64)

116Branch(98)

B11:

117MoveLoc[0](Arg0: &mut Launch<Ty0>)

118Pop

119MoveLoc[5](Arg5: &TransferPolicy<Ty0>)

120Pop

121MoveLoc[4](Arg4: &KioskOwnerCap)

122Pop

123MoveLoc[3](Arg3: &mut Kiosk)

124Pop

125MoveLoc[10](loc4: &LaunchState)

126Pop

127LdConst[7](u64: 10007)

128Abort

B12:

129MoveLoc[0](Arg0: &mut Launch<Ty0>)

130Pop

131MoveLoc[5](Arg5: &TransferPolicy<Ty0>)

132Pop

133MoveLoc[4](Arg4: &KioskOwnerCap)

134Pop

135MoveLoc[3](Arg3: &mut Kiosk)

136Pop

137MoveLoc[10](loc4: &LaunchState)

138Pop

139LdConst[7](u64: 10007)

140Abort

B13:

141MoveLoc[5](Arg5: &TransferPolicy<Ty0>)

142Pop

143MoveLoc[4](Arg4: &KioskOwnerCap)

144Pop

145MoveLoc[3](Arg3: &mut Kiosk)

146Pop

147MoveLoc[19](loc13: vector<Ty0>)

148VecUnpack(47, 0)

149Ret

Jump tables:

[0]: variant_switch LaunchState {

Variant0 => jump 17

Variant1 => jump 29

Variant2 => jump 117

Variant3 => jump 129

}

public withdraw_revenue<Ty0: store + key, Ty1>(Arg0: &mut Launch<Ty0>, Arg1: &mut LaunchAdminCap, Arg2: &mut TxContext): Coin<Ty1> {

L3: loc0: Balance<Ty1>

B0:

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

1FreezeRef

2CopyLoc[0](Arg0: &mut Launch<Ty0>)

3FreezeRef

4Call id<Ty0>(&Launch<Ty0>): ID

5Call launch_admin_cap_authorize(&LaunchAdminCap, ID)

6CopyLoc[0](Arg0: &mut Launch<Ty0>)

7MutBorrowFieldGeneric[2](Launch.revenue: Bag)

8Call type_name::get<Ty1>(): TypeName

9Call bag::remove<TypeName, Balance<Ty1>>(&mut Bag, TypeName): Balance<Ty1>

10StLoc[3](loc0: Balance<Ty1>)

11MoveLoc[0](Arg0: &mut Launch<Ty0>)

12ImmBorrowFieldGeneric[2](Launch.revenue: Bag)

13Call bag::is_empty(&Bag): bool

14BrFalse(20)

B1:

15LdTrue

16MoveLoc[1](Arg1: &mut LaunchAdminCap)

17MutBorrowField[5](LaunchAdminCap.is_withdrew_revenue: bool)

18WriteRef

19Branch(22)

B2:

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

21Pop

B3:

22MoveLoc[3](loc0: Balance<Ty1>)

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

24Call coin::from_balance<Ty1>(Balance<Ty1>, &mut TxContext): Coin<Ty1>

25Ret

}

public destroy<Ty0: store + key>(Arg0: Launch<Ty0>, Arg1: &LaunchOperatorCap) {

L2: loc0: &LaunchState

L3: loc1: LaunchState

L4: loc2: TableVec<Ty0>

L5: loc3: Bag

B0:

0MoveLoc[1](Arg1: &LaunchOperatorCap)

1ImmBorrowLoc[0](Arg0: Launch<Ty0>)

2Call id<Ty0>(&Launch<Ty0>): ID

3Call launch_operator_cap_authorize(&LaunchOperatorCap, ID)

4ImmBorrowLoc[0](Arg0: Launch<Ty0>)

5ImmBorrowFieldGeneric[0](Launch.state: LaunchState)

6ReadRef

7StLoc[3](loc1: LaunchState)

8ImmBorrowLoc[3](loc1: LaunchState)

9StLoc[2](loc0: &LaunchState)

10CopyLoc[2](loc0: &LaunchState)

11VariantSwitch(VariantJumpTableIndex(0))

B1:

12MoveLoc[2](loc0: &LaunchState)

13Pop

14LdConst[7](u64: 10007)

15Abort

B2:

16MoveLoc[2](loc0: &LaunchState)

17Pop

18LdConst[7](u64: 10007)

19Abort

B3:

20MoveLoc[2](loc0: &LaunchState)

21Pop

22LdConst[7](u64: 10007)

23Abort

B4:

24MoveLoc[2](loc0: &LaunchState)

25UnpackVariantImmRef(VariantHandleIndex(6))

26MoveLoc[3](loc1: LaunchState)

27UnpackVariant(VariantHandleIndex(6))

28ImmBorrowLoc[0](Arg0: Launch<Ty0>)

29ImmBorrowFieldGeneric[3](Launch.phase_ids: VecSet<ID>)

30Call vec_set::is_empty<ID>(&VecSet<ID>): bool

31BrFalse(33)

B5:

32Branch(35)

B6:

33LdConst[14](u64: 10014)

34Abort

B7:

35MoveLoc[0](Arg0: Launch<Ty0>)

36UnpackGeneric[0](Launch<Ty0>)

37Pop

38Pop

39StLoc[5](loc3: Bag)

40Pop

41StLoc[4](loc2: TableVec<Ty0>)

42Pop

43Call object::delete(UID)

44MoveLoc[4](loc2: TableVec<Ty0>)

45Call table_vec::destroy_empty<Ty0>(TableVec<Ty0>)

46MoveLoc[5](loc3: Bag)

47Call bag::destroy_empty(Bag)

48Ret

Jump tables:

[0]: variant_switch LaunchState {

Variant0 => jump 12

Variant1 => jump 16

Variant2 => jump 20

Variant3 => jump 24

}

public add_operator<Ty0: store + key>(Arg0: &mut Launch<Ty0>, Arg1: &LaunchAdminCap, Arg2: address) {

B0:

0MoveLoc[1](Arg1: &LaunchAdminCap)

1CopyLoc[0](Arg0: &mut Launch<Ty0>)

2FreezeRef

3Call id<Ty0>(&Launch<Ty0>): ID

4Call launch_admin_cap_authorize(&LaunchAdminCap, ID)

5MoveLoc[0](Arg0: &mut Launch<Ty0>)

6MutBorrowFieldGeneric[4](Launch.operators: VecSet<address>)

7MoveLoc[2](Arg2: address)

8Call vec_set::insert<address>(&mut VecSet<address>, address)

9Ret

}

public remove_operator<Ty0: store + key>(Arg0: &mut Launch<Ty0>, Arg1: &LaunchAdminCap, Arg2: address) {

B0:

0MoveLoc[1](Arg1: &LaunchAdminCap)

1CopyLoc[0](Arg0: &mut Launch<Ty0>)

2FreezeRef

3Call id<Ty0>(&Launch<Ty0>): ID

4Call launch_admin_cap_authorize(&LaunchAdminCap, ID)

5MoveLoc[0](Arg0: &mut Launch<Ty0>)

6MutBorrowFieldGeneric[4](Launch.operators: VecSet<address>)

7ImmBorrowLoc[2](Arg2: address)

8Call vec_set::remove<address>(&mut VecSet<address>, &address)

9Ret

}

public request_operator_cap<Ty0: store + key>(Arg0: &Launch<Ty0>, Arg1: &TxContext): LaunchOperatorCap {

L2: loc0: address

L3: loc1: &VecSet<address>

B0:

0CopyLoc[0](Arg0: &Launch<Ty0>)

1ImmBorrowFieldGeneric[4](Launch.operators: VecSet<address>)

2StLoc[3](loc1: &VecSet<address>)

3MoveLoc[1](Arg1: &TxContext)

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

5StLoc[2](loc0: address)

6MoveLoc[3](loc1: &VecSet<address>)

7ImmBorrowLoc[2](loc0: address)

8Call vec_set::contains<address>(&VecSet<address>, &address): bool

9BrFalse(11)

B1:

10Branch(15)

B2:

11MoveLoc[0](Arg0: &Launch<Ty0>)

12Pop

13LdConst[17](u64: 10017)

14Abort

B3:

15MoveLoc[0](Arg0: &Launch<Ty0>)

16Call id<Ty0>(&Launch<Ty0>): ID

17Pack[3](LaunchOperatorCap)

18Ret

}

public new_launch_link<Ty0: store + key, Ty1: key>(Arg0: &mut Launch<Ty0>, Arg1: &LaunchAdminCap, Arg2: &Ty1) {

B0:

0MoveLoc[1](Arg1: &LaunchAdminCap)

1CopyLoc[0](Arg0: &mut Launch<Ty0>)

2FreezeRef

3Call id<Ty0>(&Launch<Ty0>): ID

4Call launch_admin_cap_authorize(&LaunchAdminCap, ID)

5MoveLoc[0](Arg0: &mut Launch<Ty0>)

6MutBorrowFieldGeneric[5](Launch.id: UID)

7LdFalse

8PackGeneric[1](LaunchLink<Ty1>)

9MoveLoc[2](Arg2: &Ty1)

10Call object::id<Ty1>(&Ty1): ID

11Call dynamic_field::add<LaunchLink<Ty1>, ID>(&mut UID, LaunchLink<Ty1>, ID)

12Ret

}

public remove_launch_link<Ty0: store + key, Ty1: key>(Arg0: &mut Launch<Ty0>, Arg1: &LaunchAdminCap) {

B0:

0MoveLoc[1](Arg1: &LaunchAdminCap)

1CopyLoc[0](Arg0: &mut Launch<Ty0>)

2FreezeRef

3Call id<Ty0>(&Launch<Ty0>): ID

4Call launch_admin_cap_authorize(&LaunchAdminCap, ID)

5MoveLoc[0](Arg0: &mut Launch<Ty0>)

6MutBorrowFieldGeneric[5](Launch.id: UID)

7LdFalse

8PackGeneric[1](LaunchLink<Ty1>)

9Call dynamic_field::remove<LaunchLink<Ty1>, ID>(&mut UID, LaunchLink<Ty1>): ID

10Pop

11Ret

}

public launch_admin_cap_destroy(Arg0: LaunchAdminCap) {

B0:

0ImmBorrowLoc[0](Arg0: LaunchAdminCap)

1ImmBorrowField[5](LaunchAdminCap.is_withdrew_revenue: bool)

2ReadRef

3LdTrue

4Eq

5BrFalse(7)

B1:

6Branch(9)

B2:

7LdConst[16](u64: 10016)

8Abort

B3:

9MoveLoc[0](Arg0: LaunchAdminCap)

10Unpack[2](LaunchAdminCap)

11Pop

12Pop

13Call object::delete(UID)

14Ret

}

public receive<Ty0: store + key, Ty1: store + key>(Arg0: &mut Launch<Ty0>, Arg1: &LaunchOperatorCap, Arg2: Receiving<Ty1>): Ty1 {

B0:

0MoveLoc[1](Arg1: &LaunchOperatorCap)

1CopyLoc[0](Arg0: &mut Launch<Ty0>)

2FreezeRef

3Call id<Ty0>(&Launch<Ty0>): ID

4Call launch_operator_cap_authorize(&LaunchOperatorCap, ID)

5MoveLoc[0](Arg0: &mut Launch<Ty0>)

6MutBorrowFieldGeneric[5](Launch.id: UID)

7MoveLoc[2](Arg2: Receiving<Ty1>)

8Call transfer::public_receive<Ty1>(&mut UID, Receiving<Ty1>): Ty1

9Ret

}

public(friend) register_phase<Ty0: store + key>(Arg0: &mut Launch<Ty0>, Arg1: ID) {

B0:

0CopyLoc[0](Arg0: &mut Launch<Ty0>)

1ImmBorrowFieldGeneric[3](Launch.phase_ids: VecSet<ID>)

2Call vec_set::size<ID>(&VecSet<ID>): u64

3LdConst[0](u64: 50)

4Lt

5BrFalse(7)

B1:

6Branch(11)

B2:

7MoveLoc[0](Arg0: &mut Launch<Ty0>)

8Pop

9LdConst[1](u64: 10001)

10Abort

B3:

11MoveLoc[0](Arg0: &mut Launch<Ty0>)

12MutBorrowFieldGeneric[3](Launch.phase_ids: VecSet<ID>)

13MoveLoc[1](Arg1: ID)

14Call vec_set::insert<ID>(&mut VecSet<ID>, ID)

15Ret

}

public(friend) unregister_phase<Ty0: store + key>(Arg0: &mut Launch<Ty0>, Arg1: ID) {

B0:

0MoveLoc[0](Arg0: &mut Launch<Ty0>)

1MutBorrowFieldGeneric[3](Launch.phase_ids: VecSet<ID>)

2ImmBorrowLoc[1](Arg1: ID)

3Call vec_set::remove<ID>(&mut VecSet<ID>, &ID)

4Ret

}

public(friend) deposit_revenue<Ty0: store + key, Ty1>(Arg0: &mut Launch<Ty0>, Arg1: Balance<Ty1>) {

L2: loc0: TypeName

B0:

0Call type_name::get<Ty1>(): TypeName

1StLoc[2](loc0: TypeName)

2CopyLoc[0](Arg0: &mut Launch<Ty0>)

3ImmBorrowFieldGeneric[2](Launch.revenue: Bag)

4CopyLoc[2](loc0: TypeName)

5Call bag::contains<TypeName>(&Bag, TypeName): bool

6Not

7BrFalse(14)

B1:

8MoveLoc[0](Arg0: &mut Launch<Ty0>)

9MutBorrowFieldGeneric[2](Launch.revenue: Bag)

10MoveLoc[2](loc0: TypeName)

11MoveLoc[1](Arg1: Balance<Ty1>)

12Call bag::add<TypeName, Balance<Ty1>>(&mut Bag, TypeName, Balance<Ty1>)

13Branch(21)

B2:

14MoveLoc[0](Arg0: &mut Launch<Ty0>)

15MutBorrowFieldGeneric[2](Launch.revenue: Bag)

16MoveLoc[2](loc0: TypeName)

17Call bag::borrow_mut<TypeName, Balance<Ty1>>(&mut Bag, TypeName): &mut Balance<Ty1>

18MoveLoc[1](Arg1: Balance<Ty1>)

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

20Pop

B3:

21Ret

}

public(friend) increment_minted_supply<Ty0: store + key>(Arg0: &mut Launch<Ty0>) {

L1: loc0: &LaunchState

L2: loc1: LaunchState

B0:

0CopyLoc[0](Arg0: &mut Launch<Ty0>)

1ImmBorrowFieldGeneric[0](Launch.state: LaunchState)

2ReadRef

3StLoc[2](loc1: LaunchState)

4ImmBorrowLoc[2](loc1: LaunchState)

5StLoc[1](loc0: &LaunchState)

6CopyLoc[1](loc0: &LaunchState)

7VariantSwitch(VariantJumpTableIndex(0))

B1:

8MoveLoc[0](Arg0: &mut Launch<Ty0>)

9Pop

10MoveLoc[1](loc0: &LaunchState)

11Pop

12LdConst[7](u64: 10007)

13Abort

B2:

14MoveLoc[0](Arg0: &mut Launch<Ty0>)

15Pop

16MoveLoc[1](loc0: &LaunchState)

17Pop

18LdConst[7](u64: 10007)

19Abort

B3:

20MoveLoc[0](Arg0: &mut Launch<Ty0>)

21Pop

22MoveLoc[1](loc0: &LaunchState)

23Pop

24LdConst[7](u64: 10007)

25Abort

B4:

26MoveLoc[1](loc0: &LaunchState)

27UnpackVariantImmRef(VariantHandleIndex(4))

28Pop

29MoveLoc[2](loc1: LaunchState)

30UnpackVariant(VariantHandleIndex(4))

31LdU64(1)

32Add

33PackVariant(VariantHandleIndex(4))

34MoveLoc[0](Arg0: &mut Launch<Ty0>)

35MutBorrowFieldGeneric[0](Launch.state: LaunchState)

36WriteRef

37Ret

Jump tables:

[0]: variant_switch LaunchState {

Variant0 => jump 8

Variant1 => jump 26

Variant2 => jump 14

Variant3 => jump 20

}

public(friend) supply<Ty0: store + key>(Arg0: &Launch<Ty0>): u64 {

B0:

0MoveLoc[0](Arg0: &Launch<Ty0>)

1ImmBorrowFieldGeneric[1](Launch.items: TableVec<Ty0>)

2Call table_vec::length<Ty0>(&TableVec<Ty0>): u64

3Ret

}

public(friend) items<Ty0: store + key>(Arg0: &Launch<Ty0>): &TableVec<Ty0> {

B0:

0MoveLoc[0](Arg0: &Launch<Ty0>)

1ImmBorrowFieldGeneric[1](Launch.items: TableVec<Ty0>)

2Ret

}

public(friend) items_mut<Ty0: store + key>(Arg0: &mut Launch<Ty0>): &mut TableVec<Ty0> {

B0:

0MoveLoc[0](Arg0: &mut Launch<Ty0>)

1MutBorrowFieldGeneric[1](Launch.items: TableVec<Ty0>)

2Ret

}

public(friend) revenue<Ty0: store + key>(Arg0: &Launch<Ty0>): &Bag {

B0:

0MoveLoc[0](Arg0: &Launch<Ty0>)

1ImmBorrowFieldGeneric[2](Launch.revenue: Bag)

2Ret

}

public(friend) revenue_mut<Ty0: store + key>(Arg0: &mut Launch<Ty0>): &mut Bag {

B0:

0MoveLoc[0](Arg0: &mut Launch<Ty0>)

1MutBorrowFieldGeneric[2](Launch.revenue: Bag)

2Ret

}

public(friend) launch_admin_cap_authorize(Arg0: &LaunchAdminCap, Arg1: ID) {

B0:

0MoveLoc[0](Arg0: &LaunchAdminCap)

1ImmBorrowField[9](LaunchAdminCap.launch_id: ID)

2ReadRef

3MoveLoc[1](Arg1: ID)

4Eq

5BrFalse(7)

B1:

6Branch(9)

B2:

7LdConst[3](u64: 10003)

8Abort

B3:

9Ret

}

public(friend) launch_operator_cap_authorize(Arg0: &LaunchOperatorCap, Arg1: ID) {

B0:

0MoveLoc[0](Arg0: &LaunchOperatorCap)

1ImmBorrowField[10](LaunchOperatorCap.launch_id: ID)

2ReadRef

3MoveLoc[1](Arg1: ID)

4Eq

5BrFalse(7)

B1:

6Branch(9)

B2:

7LdConst[5](u64: 10005)

8Abort

B3:

9Ret

}

public id<Ty0: store + key>(Arg0: &Launch<Ty0>): ID {

B0:

0MoveLoc[0](Arg0: &Launch<Ty0>)

1ImmBorrowFieldGeneric[5](Launch.id: UID)

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

3Ret

}

public launch_admin_cap_launch_id(Arg0: &LaunchAdminCap): ID {

B0:

0MoveLoc[0](Arg0: &LaunchAdminCap)

1ImmBorrowField[9](LaunchAdminCap.launch_id: ID)

2ReadRef

3Ret

}

public launch_operator_cap_launch_id(Arg0: &LaunchOperatorCap): ID {

B0:

0MoveLoc[0](Arg0: &LaunchOperatorCap)

1ImmBorrowField[10](LaunchOperatorCap.launch_id: ID)

2ReadRef

3Ret

}

public is_supplying_state<Ty0: store + key>(Arg0: &Launch<Ty0>): bool {

L1: loc0: bool

L2: loc1: &LaunchState

L3: loc2: LaunchState

B0:

0MoveLoc[0](Arg0: &Launch<Ty0>)

1ImmBorrowFieldGeneric[0](Launch.state: LaunchState)

2ReadRef

3StLoc[3](loc2: LaunchState)

4ImmBorrowLoc[3](loc2: LaunchState)

5StLoc[2](loc1: &LaunchState)

6CopyLoc[2](loc1: &LaunchState)

7VariantSwitch(VariantJumpTableIndex(0))

B1:

8MoveLoc[2](loc1: &LaunchState)

9UnpackVariantImmRef(VariantHandleIndex(0))

10Pop

11MoveLoc[3](loc2: LaunchState)

12UnpackVariant(VariantHandleIndex(0))

13Pop

14LdTrue

15StLoc[1](loc0: bool)

16Branch(31)

B2:

17MoveLoc[2](loc1: &LaunchState)

18Pop

19LdFalse

20StLoc[1](loc0: bool)

21Branch(31)

B3:

22MoveLoc[2](loc1: &LaunchState)

23Pop

24LdFalse

25StLoc[1](loc0: bool)

26Branch(31)

B4:

27MoveLoc[2](loc1: &LaunchState)

28Pop

29LdFalse

30StLoc[1](loc0: bool)

B5:

31MoveLoc[1](loc0: bool)

32Ret

Jump tables:

[0]: variant_switch LaunchState {

Variant0 => jump 8

Variant1 => jump 17

Variant2 => jump 22

Variant3 => jump 27

}

public is_active_state<Ty0: store + key>(Arg0: &Launch<Ty0>): bool {

L1: loc0: bool

L2: loc1: &LaunchState

L3: loc2: LaunchState

B0:

0MoveLoc[0](Arg0: &Launch<Ty0>)

1ImmBorrowFieldGeneric[0](Launch.state: LaunchState)

2ReadRef

3StLoc[3](loc2: LaunchState)

4ImmBorrowLoc[3](loc2: LaunchState)

5StLoc[2](loc1: &LaunchState)

6CopyLoc[2](loc1: &LaunchState)

7VariantSwitch(VariantJumpTableIndex(0))

B1:

8MoveLoc[2](loc1: &LaunchState)

9Pop

10LdFalse

11StLoc[1](loc0: bool)

12Branch(31)

B2:

13MoveLoc[2](loc1: &LaunchState)

14UnpackVariantImmRef(VariantHandleIndex(4))

15Pop

16MoveLoc[3](loc2: LaunchState)

17UnpackVariant(VariantHandleIndex(4))

18Pop

19LdTrue

20StLoc[1](loc0: bool)

21Branch(31)

B3:

22MoveLoc[2](loc1: &LaunchState)

23Pop

24LdFalse

25StLoc[1](loc0: bool)

26Branch(31)

B4:

27MoveLoc[2](loc1: &LaunchState)

28Pop

29LdFalse

30StLoc[1](loc0: bool)

B5:

31MoveLoc[1](loc0: bool)

32Ret

Jump tables:

[0]: variant_switch LaunchState {

Variant0 => jump 8

Variant1 => jump 13

Variant2 => jump 22

Variant3 => jump 27

}

public is_paused_state<Ty0: store + key>(Arg0: &Launch<Ty0>): bool {

L1: loc0: bool

L2: loc1: &LaunchState

L3: loc2: LaunchState

B0:

0MoveLoc[0](Arg0: &Launch<Ty0>)

1ImmBorrowFieldGeneric[0](Launch.state: LaunchState)

2ReadRef

3StLoc[3](loc2: LaunchState)

4ImmBorrowLoc[3](loc2: LaunchState)

5StLoc[2](loc1: &LaunchState)

6CopyLoc[2](loc1: &LaunchState)

7VariantSwitch(VariantJumpTableIndex(0))

B1:

8MoveLoc[2](loc1: &LaunchState)

9Pop

10LdFalse

11StLoc[1](loc0: bool)

12Branch(31)

B2:

13MoveLoc[2](loc1: &LaunchState)

14Pop

15LdFalse

16StLoc[1](loc0: bool)

17Branch(31)

B3:

18MoveLoc[2](loc1: &LaunchState)

19UnpackVariantImmRef(VariantHandleIndex(5))

20Pop

21MoveLoc[3](loc2: LaunchState)

22UnpackVariant(VariantHandleIndex(5))

23Pop

24LdTrue

25StLoc[1](loc0: bool)

26Branch(31)

B4:

27MoveLoc[2](loc1: &LaunchState)

28Pop

29LdFalse

30StLoc[1](loc0: bool)

B5:

31MoveLoc[1](loc0: bool)

32Ret

Jump tables:

[0]: variant_switch LaunchState {

Variant0 => jump 8

Variant1 => jump 13

Variant2 => jump 18

Variant3 => jump 27

}

public is_completed_state<Ty0: store + key>(Arg0: &Launch<Ty0>): bool {

L1: loc0: bool

L2: loc1: &LaunchState

L3: loc2: LaunchState

B0:

0MoveLoc[0](Arg0: &Launch<Ty0>)

1ImmBorrowFieldGeneric[0](Launch.state: LaunchState)

2ReadRef

3StLoc[3](loc2: LaunchState)

4ImmBorrowLoc[3](loc2: LaunchState)

5StLoc[2](loc1: &LaunchState)

6CopyLoc[2](loc1: &LaunchState)

7VariantSwitch(VariantJumpTableIndex(0))

B1:

8MoveLoc[2](loc1: &LaunchState)

9Pop

10LdFalse

11StLoc[1](loc0: bool)

12Branch(29)

B2:

13MoveLoc[2](loc1: &LaunchState)

14Pop

15LdFalse

16StLoc[1](loc0: bool)

17Branch(29)

B3:

18MoveLoc[2](loc1: &LaunchState)

19Pop

20LdFalse

21StLoc[1](loc0: bool)

22Branch(29)

B4:

23MoveLoc[2](loc1: &LaunchState)

24UnpackVariantImmRef(VariantHandleIndex(6))

25MoveLoc[3](loc2: LaunchState)

26UnpackVariant(VariantHandleIndex(6))

27LdTrue

28StLoc[1](loc0: bool)

B5:

29MoveLoc[1](loc0: bool)

30Ret

Jump tables:

[0]: variant_switch LaunchState {

Variant0 => jump 8

Variant1 => jump 13

Variant2 => jump 18

Variant3 => jump 23

}

public assert_kiosk_requirement_none<Ty0: store + key>(Arg0: &Launch<Ty0>) {

B0:

0MoveLoc[0](Arg0: &Launch<Ty0>)

1ImmBorrowFieldGeneric[6](Launch.kiosk_requirement: KioskRequirement)

2ReadRef

3PackVariant(VariantHandleIndex(1))

4Eq

5BrFalse(7)

B1:

6Branch(9)

B2:

7LdConst[9](u64: 10009)

8Abort

B3:

9Ret

}

public assert_kiosk_requirement_place<Ty0: store + key>(Arg0: &Launch<Ty0>) {

B0:

0MoveLoc[0](Arg0: &Launch<Ty0>)

1ImmBorrowFieldGeneric[6](Launch.kiosk_requirement: KioskRequirement)

2ReadRef

3PackVariant(VariantHandleIndex(2))

4Eq

5BrFalse(7)

B1:

6Branch(9)

B2:

7LdConst[10](u64: 10010)

8Abort

B3:

9Ret

}

public assert_kiosk_requirement_lock<Ty0: store + key>(Arg0: &Launch<Ty0>) {

B0:

0MoveLoc[0](Arg0: &Launch<Ty0>)

1ImmBorrowFieldGeneric[6](Launch.kiosk_requirement: KioskRequirement)

2ReadRef

3PackVariant(VariantHandleIndex(3))

4Eq

5BrFalse(7)

B1:

6Branch(9)

B2:

7LdConst[8](u64: 10008)

8Abort

B3:

9Ret

}

public assert_is_supplying_state<Ty0: store + key>(Arg0: &Launch<Ty0>) {

B0:

0MoveLoc[0](Arg0: &Launch<Ty0>)

1Call is_supplying_state<Ty0>(&Launch<Ty0>): bool

2BrFalse(4)

B1:

3Branch(6)

B2:

4LdConst[7](u64: 10007)

5Abort

B3:

6Ret

}

public assert_is_active_state<Ty0: store + key>(Arg0: &Launch<Ty0>) {

B0:

0MoveLoc[0](Arg0: &Launch<Ty0>)

1Call is_active_state<Ty0>(&Launch<Ty0>): bool

2BrFalse(4)

B1:

3Branch(6)

B2:

4LdConst[7](u64: 10007)

5Abort

B3:

6Ret

}

public assert_is_paused_state<Ty0: store + key>(Arg0: &Launch<Ty0>) {

B0:

0MoveLoc[0](Arg0: &Launch<Ty0>)

1Call is_paused_state<Ty0>(&Launch<Ty0>): bool

2BrFalse(4)

B1:

3Branch(6)

B2:

4LdConst[7](u64: 10007)

5Abort

B3:

6Ret

}

public assert_is_completed_state<Ty0: store + key>(Arg0: &Launch<Ty0>) {

B0:

0MoveLoc[0](Arg0: &Launch<Ty0>)

1Call is_completed_state<Ty0>(&Launch<Ty0>): bool

2BrFalse(4)

B1:

3Branch(6)

B2:

4LdConst[7](u64: 10007)

5Abort

B3:

6Ret

}

public assert_is_mintable<Ty0: store + key>(Arg0: &Launch<Ty0>) {

L1: loc0: &LaunchState

L2: loc1: LaunchState

B0:

0CopyLoc[0](Arg0: &Launch<Ty0>)

1ImmBorrowFieldGeneric[0](Launch.state: LaunchState)

2ReadRef

3StLoc[2](loc1: LaunchState)

4ImmBorrowLoc[2](loc1: LaunchState)

5StLoc[1](loc0: &LaunchState)

6CopyLoc[1](loc0: &LaunchState)

7VariantSwitch(VariantJumpTableIndex(0))

B1:

8MoveLoc[0](Arg0: &Launch<Ty0>)

9Pop

10MoveLoc[1](loc0: &LaunchState)

11Pop

12LdConst[11](u64: 10011)

13Abort

B2:

14MoveLoc[1](loc0: &LaunchState)

15UnpackVariantImmRef(VariantHandleIndex(4))

16Pop

17MoveLoc[2](loc1: LaunchState)

18UnpackVariant(VariantHandleIndex(4))

19Pop

20MoveLoc[0](Arg0: &Launch<Ty0>)

21ImmBorrowFieldGeneric[1](Launch.items: TableVec<Ty0>)

22Call table_vec::length<Ty0>(&TableVec<Ty0>): u64

23LdU64(0)

24Gt

25BrFalse(27)

B3:

26Branch(41)

B4:

27LdConst[13](u64: 10013)

28Abort

B5:

29MoveLoc[0](Arg0: &Launch<Ty0>)

30Pop

31MoveLoc[1](loc0: &LaunchState)

32Pop

33LdConst[11](u64: 10011)

34Abort

B6:

35MoveLoc[0](Arg0: &Launch<Ty0>)

36Pop

37MoveLoc[1](loc0: &LaunchState)

38Pop

39LdConst[11](u64: 10011)

40Abort

B7:

41Ret

Jump tables:

[0]: variant_switch LaunchState {

Variant0 => jump 8

Variant1 => jump 14

Variant2 => jump 29

Variant3 => jump 35

}

Constants [

0 => u64: 50

1 => u64: 10001

2 => u64: 10002

3 => u64: 10003

4 => u64: 10004

5 => u64: 10005

6 => u64: 10006

7 => u64: 10007

8 => u64: 10008

9 => u64: 10009

10 => u64: 10010

11 => u64: 10011

12 => u64: 10012

13 => u64: 10013

14 => u64: 10014

15 => u64: 10015

16 => u64: 10016

17 => u64: 10017

]

}