rising

Module0xbd2e…e190

Move path: 0xee0e…d45f::rising
Functions: 181 public, 12 entry
Structs: 12
Friend modules: None

rising

Bytecode1921 lines

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

// Move bytecode v7

module ee0e96c6dcfa447bd5e026be5c995fca0c058e12530c8b5dfef57aa390c8d45f.rising {

use 434b5bd8f6a7b05fede0ff46c6e511d71ea326ed38056e3bcd681d2d7c2a7879::personal_kiosk;

use ee0e96c6dcfa447bd5e026be5c995fca0c058e12530c8b5dfef57aa390c8d45f::collection;

use 0000000000000000000000000000000000000000000000000000000000000001::bcs;

use 0000000000000000000000000000000000000000000000000000000000000001::hash;

use 0000000000000000000000000000000000000000000000000000000000000001::option;

use 0000000000000000000000000000000000000000000000000000000000000001::string;

use 0000000000000000000000000000000000000000000000000000000000000001::vector;

use 0000000000000000000000000000000000000000000000000000000000000002::clock;

use 0000000000000000000000000000000000000000000000000000000000000002::dynamic_field;

use 0000000000000000000000000000000000000000000000000000000000000002::event;

use 0000000000000000000000000000000000000000000000000000000000000002::kiosk;

use 0000000000000000000000000000000000000000000000000000000000000002::object;

use 0000000000000000000000000000000000000000000000000000000000000002::random;

use 0000000000000000000000000000000000000000000000000000000000000002::table;

use 0000000000000000000000000000000000000000000000000000000000000002::tx_context;

use 0000000000000000000000000000000000000000000000000000000000000002::vec_map;

struct RegistryKey has copy, drop, store {

dummy_field: bool

}

struct Registry has store {

pieces: Table<u64, Piece>,

piece_size: u64,

bound: Table<ID, u64>,

reserved: u64

}

struct Piece has store {

name: String,

attributes: VecMap<String, String>,

rank: u16,

pad: vector<u8>

}

struct RelicsKey has copy, drop, store {

dummy_field: bool

}

struct Relics has store {

images: Table<u64, vector<u8>>,

graves: Table<u64, ID>,

loaded: u64

}

struct Seeded has copy, drop {

collection: ID,

from: u64,

to: u64,

running_hash: vector<u8>

}

struct Sealed has copy, drop {

collection: ID,

provenance_hash: vector<u8>

}

struct Bound has copy, drop {

collection: ID,

grave: ID,

index: u64

}

struct Unbound has copy, drop {

collection: ID,

grave: ID,

index: u64

}

struct RelicAdded has copy, drop {

collection: ID,

index: u64,

name: String,

image_sha256: vector<u8>

}

struct RelicRemoved has copy, drop {

collection: ID,

index: u64

}

struct Risen has copy, drop {

collection: ID,

grave: ID,

number: u64,

index: u64,

luck: u8,

second_draw: bool

}

entry seed(Arg0: &AdminCap, Arg1: &mut Collection, Arg2: u64, Arg3: vector<u64>, Arg4: vector<String>, Arg5: vector<vector<String>>, Arg6: vector<vector<String>>, Arg7: vector<u16>, Arg8: vector<vector<u8>>, Arg9: &mut TxContext) {

L10: loc0: bool

L11: loc1: bool

L12: loc2: vector<u16>

L13: loc3: VecMap<String, String>

L14: loc4: vector<u8>

L15: loc5: ID

L16: loc6: vector<u8>

L17: loc7: u64

L18: loc8: u64

L19: loc9: u64

L20: loc10: String

L21: loc11: u16

L22: loc12: &mut Registry

L23: loc13: bool

L24: loc14: u64

L25: loc15: &mut UID

B0:

0MoveLoc[0](Arg0: &AdminCap)

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

2FreezeRef

3Call collection::check_admin(&AdminCap, &Collection)

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

5FreezeRef

6Call collection::rising_state(&Collection): bool * u64 * u64 * u64 * bool

7StLoc[23](loc13: bool)

8Pop

9StLoc[24](loc14: u64)

10Pop

11Pop

12MoveLoc[23](loc13: bool)

13Not

14BrFalse(16)

B1:

15Branch(22)

B2:

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

17Pop

18MoveLoc[1](Arg1: &mut Collection)

19Pop

20LdConst[1](u64: 301)

21Abort

B3:

22ImmBorrowLoc[3](Arg3: vector<u64>)

23VecLen(24)

24StLoc[19](loc9: u64)

25CopyLoc[19](loc9: u64)

26LdU64(0)

27Gt

28BrFalse(51)

B4:

29ImmBorrowLoc[4](Arg4: vector<String>)

30VecLen(25)

31CopyLoc[19](loc9: u64)

32Eq

33BrFalse(48)

B5:

34ImmBorrowLoc[5](Arg5: vector<vector<String>>)

35VecLen(26)

36CopyLoc[19](loc9: u64)

37Eq

38BrFalse(45)

B6:

39ImmBorrowLoc[6](Arg6: vector<vector<String>>)

40VecLen(26)

41CopyLoc[19](loc9: u64)

42Eq

43StLoc[10](loc0: bool)

44Branch(53)

B7:

45LdFalse

46StLoc[10](loc0: bool)

47Branch(53)

B8:

48LdFalse

49StLoc[10](loc0: bool)

50Branch(53)

B9:

51LdFalse

52StLoc[10](loc0: bool)

B10:

53MoveLoc[10](loc0: bool)

54BrFalse(56)

B11:

55Branch(62)

B12:

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

57Pop

58MoveLoc[1](Arg1: &mut Collection)

59Pop

60LdConst[2](u64: 302)

61Abort

B13:

62ImmBorrowLoc[7](Arg7: vector<u16>)

63VecLen(27)

64CopyLoc[19](loc9: u64)

65Eq

66BrFalse(73)

B14:

67ImmBorrowLoc[8](Arg8: vector<vector<u8>>)

68VecLen(28)

69CopyLoc[19](loc9: u64)

70Eq

71StLoc[11](loc1: bool)

72Branch(75)

B15:

73LdFalse

74StLoc[11](loc1: bool)

B16:

75MoveLoc[11](loc1: bool)

76BrFalse(78)

B17:

77Branch(84)

B18:

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

79Pop

80MoveLoc[1](Arg1: &mut Collection)

81Pop

82LdConst[2](u64: 302)

83Abort

B19:

84CopyLoc[24](loc14: u64)

85CopyLoc[19](loc9: u64)

86Add

87CopyLoc[1](Arg1: &mut Collection)

88FreezeRef

89Call collection::supply(&Collection): u64

90Le

91BrFalse(93)

B20:

92Branch(99)

B21:

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

94Pop

95MoveLoc[1](Arg1: &mut Collection)

96Pop

97LdConst[2](u64: 302)

98Abort

B22:

99CopyLoc[1](Arg1: &mut Collection)

100FreezeRef

101Call collection::running_hash(&Collection): vector<u8>

102StLoc[16](loc6: vector<u8>)

103CopyLoc[1](Arg1: &mut Collection)

104FreezeRef

105Call object::id<Collection>(&Collection): ID

106StLoc[15](loc5: ID)

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

108Call collection::collection_uid_mut(&mut Collection): &mut UID

109StLoc[25](loc15: &mut UID)

110CopyLoc[25](loc15: &mut UID)

111FreezeRef

112LdFalse

113Pack[0](RegistryKey)

114Call dynamic_field::exists<RegistryKey>(&UID, RegistryKey): bool

115Not

116BrFalse(129)

B23:

117CopyLoc[25](loc15: &mut UID)

118LdFalse

119Pack[0](RegistryKey)

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

121Call table::new<u64, Piece>(&mut TxContext): Table<u64, Piece>

122CopyLoc[2](Arg2: u64)

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

124Call table::new<ID, u64>(&mut TxContext): Table<ID, u64>

125LdU64(0)

126Pack[1](Registry)

127Call dynamic_field::add<RegistryKey, Registry>(&mut UID, RegistryKey, Registry)

128Branch(131)

B24:

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

130Pop

B25:

131MoveLoc[25](loc15: &mut UID)

132LdFalse

133Pack[0](RegistryKey)

134Call dynamic_field::borrow_mut<RegistryKey, Registry>(&mut UID, RegistryKey): &mut Registry

135StLoc[22](loc12: &mut Registry)

136CopyLoc[22](loc12: &mut Registry)

137ImmBorrowField[0](Registry.piece_size: u64)

138ReadRef

139CopyLoc[2](Arg2: u64)

140Eq

141BrFalse(143)

B26:

142Branch(149)

B27:

143MoveLoc[22](loc12: &mut Registry)

144Pop

145MoveLoc[1](Arg1: &mut Collection)

146Pop

147LdConst[8](u64: 308)

148Abort

B28:

149LdConst[20](vector<u16>: 00)

150StLoc[12](loc2: vector<u16>)

151LdU64(0)

152StLoc[17](loc7: u64)

B29:

153CopyLoc[17](loc7: u64)

154CopyLoc[19](loc9: u64)

155Lt

156BrFalse(244)

B30:

157ImmBorrowLoc[3](Arg3: vector<u64>)

158CopyLoc[17](loc7: u64)

159VecImmBorrow(24)

160ReadRef

161StLoc[18](loc8: u64)

162CopyLoc[18](loc8: u64)

163CopyLoc[24](loc14: u64)

164LdU64(1)

165Add

166CopyLoc[17](loc7: u64)

167Add

168Eq

169BrFalse(171)

B31:

170Branch(177)

B32:

171MoveLoc[22](loc12: &mut Registry)

172Pop

173MoveLoc[1](Arg1: &mut Collection)

174Pop

175LdConst[2](u64: 302)

176Abort

B33:

177ImmBorrowLoc[4](Arg4: vector<String>)

178CopyLoc[17](loc7: u64)

179VecImmBorrow(25)

180ReadRef

181StLoc[20](loc10: String)

182ImmBorrowLoc[5](Arg5: vector<vector<String>>)

183CopyLoc[17](loc7: u64)

184VecImmBorrow(26)

185ReadRef

186ImmBorrowLoc[6](Arg6: vector<vector<String>>)

187CopyLoc[17](loc7: u64)

188VecImmBorrow(26)

189ReadRef

190Call vec_map::from_keys_values<String, String>(vector<String>, vector<String>): VecMap<String, String>

191StLoc[13](loc3: VecMap<String, String>)

192ImmBorrowLoc[7](Arg7: vector<u16>)

193CopyLoc[17](loc7: u64)

194VecImmBorrow(27)

195ReadRef

196StLoc[21](loc11: u16)

197MoveLoc[16](loc6: vector<u8>)

198StLoc[14](loc4: vector<u8>)

199MutBorrowLoc[14](loc4: vector<u8>)

200ImmBorrowLoc[18](loc8: u64)

201Call bcs::to_bytes<u64>(&u64): vector<u8>

202Call vector::append<u8>(&mut vector<u8>, vector<u8>)

203MutBorrowLoc[14](loc4: vector<u8>)

204ImmBorrowLoc[20](loc10: String)

205Call bcs::to_bytes<String>(&String): vector<u8>

206Call vector::append<u8>(&mut vector<u8>, vector<u8>)

207MutBorrowLoc[14](loc4: vector<u8>)

208ImmBorrowLoc[13](loc3: VecMap<String, String>)

209Call bcs::to_bytes<VecMap<String, String>>(&VecMap<String, String>): vector<u8>

210Call vector::append<u8>(&mut vector<u8>, vector<u8>)

211MutBorrowLoc[14](loc4: vector<u8>)

212ImmBorrowLoc[21](loc11: u16)

213Call bcs::to_bytes<u16>(&u16): vector<u8>

214Call vector::append<u8>(&mut vector<u8>, vector<u8>)

215MutBorrowLoc[14](loc4: vector<u8>)

216ImmBorrowLoc[8](Arg8: vector<vector<u8>>)

217CopyLoc[17](loc7: u64)

218VecImmBorrow(28)

219Call bcs::to_bytes<vector<u8>>(&vector<u8>): vector<u8>

220Call vector::append<u8>(&mut vector<u8>, vector<u8>)

221MoveLoc[14](loc4: vector<u8>)

222Call hash::sha3_256(vector<u8>): vector<u8>

223StLoc[16](loc6: vector<u8>)

224CopyLoc[22](loc12: &mut Registry)

225MutBorrowField[1](Registry.pieces: Table<u64, Piece>)

226CopyLoc[18](loc8: u64)

227MoveLoc[20](loc10: String)

228MoveLoc[13](loc3: VecMap<String, String>)

229MoveLoc[21](loc11: u16)

230LdConst[21](vector<u8>: "" /..)

231Pack[2](Piece)

232CopyLoc[2](Arg2: u64)

233Call padded(Piece, u64): Piece

234Call table::add<u64, Piece>(&mut Table<u64, Piece>, u64, Piece)

235MutBorrowLoc[12](loc2: vector<u16>)

236MoveLoc[18](loc8: u64)

237CastU16

238VecPushBack(27)

239MoveLoc[17](loc7: u64)

240LdU64(1)

241Add

242StLoc[17](loc7: u64)

243Branch(153)

B34:

244MoveLoc[22](loc12: &mut Registry)

245Pop

246MoveLoc[1](Arg1: &mut Collection)

247MoveLoc[12](loc2: vector<u16>)

248CopyLoc[16](loc6: vector<u8>)

249Call collection::record_seeds(&mut Collection, vector<u16>, vector<u8>)

250MoveLoc[15](loc5: ID)

251CopyLoc[24](loc14: u64)

252LdU64(1)

253Add

254MoveLoc[24](loc14: u64)

255MoveLoc[19](loc9: u64)

256Add

257MoveLoc[16](loc6: vector<u8>)

258Pack[5](Seeded)

259Call event::emit<Seeded>(Seeded)

260Ret

}

entry bind(Arg0: &AdminCap, Arg1: &mut Collection, Arg2: ID, Arg3: u64) {

L4: loc0: bool

L5: loc1: u16

L6: loc2: &vector<u16>

L7: loc3: u64

L8: loc4: ID

L9: loc5: &mut vector<u16>

L10: loc6: &mut Registry

L11: loc7: bool

L12: loc8: u64

B0:

0MoveLoc[0](Arg0: &AdminCap)

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

2FreezeRef

3Call collection::check_admin(&AdminCap, &Collection)

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

5FreezeRef

6Call collection::rising_state(&Collection): bool * u64 * u64 * u64 * bool

7StLoc[11](loc7: bool)

8Pop

9StLoc[12](loc8: u64)

10Pop

11Pop

12MoveLoc[11](loc7: bool)

13Not

14BrFalse(16)

B1:

15Branch(20)

B2:

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

17Pop

18LdConst[1](u64: 301)

19Abort

B3:

20CopyLoc[3](Arg3: u64)

21LdU64(1)

22Ge

23BrFalse(29)

B4:

24CopyLoc[3](Arg3: u64)

25MoveLoc[12](loc8: u64)

26Le

27StLoc[4](loc0: bool)

28Branch(31)

B5:

29LdFalse

30StLoc[4](loc0: bool)

B6:

31MoveLoc[4](loc0: bool)

32BrFalse(34)

B7:

33Branch(38)

B8:

34MoveLoc[1](Arg1: &mut Collection)

35Pop

36LdConst[10](u64: 310)

37Abort

B9:

38CopyLoc[1](Arg1: &mut Collection)

39Call collection::pool_mut(&mut Collection): &mut vector<u16>

40StLoc[9](loc5: &mut vector<u16>)

41CopyLoc[9](loc5: &mut vector<u16>)

42FreezeRef

43StLoc[6](loc2: &vector<u16>)

44CopyLoc[3](Arg3: u64)

45CastU16

46StLoc[5](loc1: u16)

47MoveLoc[6](loc2: &vector<u16>)

48ImmBorrowLoc[5](loc1: u16)

49Call vector::index_of<u16>(&vector<u16>, &u16): bool * u64

50StLoc[7](loc3: u64)

51BrFalse(53)

B10:

52Branch(59)

B11:

53MoveLoc[9](loc5: &mut vector<u16>)

54Pop

55MoveLoc[1](Arg1: &mut Collection)

56Pop

57LdConst[10](u64: 310)

58Abort

B12:

59MoveLoc[9](loc5: &mut vector<u16>)

60MoveLoc[7](loc3: u64)

61Call vector::swap_remove<u16>(&mut vector<u16>, u64): u16

62Pop

63CopyLoc[1](Arg1: &mut Collection)

64FreezeRef

65Call object::id<Collection>(&Collection): ID

66StLoc[8](loc4: ID)

67MoveLoc[1](Arg1: &mut Collection)

68Call collection::collection_uid_mut(&mut Collection): &mut UID

69LdFalse

70Pack[0](RegistryKey)

71Call dynamic_field::borrow_mut<RegistryKey, Registry>(&mut UID, RegistryKey): &mut Registry

72StLoc[10](loc6: &mut Registry)

73CopyLoc[10](loc6: &mut Registry)

74ImmBorrowField[2](Registry.bound: Table<ID, u64>)

75CopyLoc[2](Arg2: ID)

76Call table::contains<ID, u64>(&Table<ID, u64>, ID): bool

77Not

78BrFalse(80)

B13:

79Branch(84)

B14:

80MoveLoc[10](loc6: &mut Registry)

81Pop

82LdConst[11](u64: 311)

83Abort

B15:

84CopyLoc[10](loc6: &mut Registry)

85MutBorrowField[2](Registry.bound: Table<ID, u64>)

86CopyLoc[2](Arg2: ID)

87CopyLoc[3](Arg3: u64)

88Call table::add<ID, u64>(&mut Table<ID, u64>, ID, u64)

89CopyLoc[10](loc6: &mut Registry)

90ImmBorrowField[3](Registry.reserved: u64)

91ReadRef

92LdU64(1)

93Add

94MoveLoc[10](loc6: &mut Registry)

95MutBorrowField[3](Registry.reserved: u64)

96WriteRef

97MoveLoc[8](loc4: ID)

98MoveLoc[2](Arg2: ID)

99MoveLoc[3](Arg3: u64)

100Pack[7](Bound)

101Call event::emit<Bound>(Bound)

102Ret

}

entry unbind(Arg0: &AdminCap, Arg1: &mut Collection, Arg2: ID) {

L3: loc0: ID

L4: loc1: u64

L5: loc2: &mut Registry

L6: loc3: bool

L7: loc4: &mut UID

B0:

0MoveLoc[0](Arg0: &AdminCap)

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

2FreezeRef

3Call collection::check_admin(&AdminCap, &Collection)

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

5FreezeRef

6Call collection::rising_state(&Collection): bool * u64 * u64 * u64 * bool

7StLoc[6](loc3: bool)

8Pop

9Pop

10Pop

11Pop

12MoveLoc[6](loc3: bool)

13Not

14BrFalse(16)

B1:

15Branch(20)

B2:

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

17Pop

18LdConst[1](u64: 301)

19Abort

B3:

20CopyLoc[1](Arg1: &mut Collection)

21FreezeRef

22Call object::id<Collection>(&Collection): ID

23StLoc[3](loc0: ID)

24CopyLoc[1](Arg1: &mut Collection)

25Call collection::collection_uid_mut(&mut Collection): &mut UID

26StLoc[7](loc4: &mut UID)

27CopyLoc[7](loc4: &mut UID)

28FreezeRef

29LdFalse

30Pack[0](RegistryKey)

31Call dynamic_field::exists<RegistryKey>(&UID, RegistryKey): bool

32BrFalse(34)

B4:

33Branch(40)

B5:

34MoveLoc[7](loc4: &mut UID)

35Pop

36MoveLoc[1](Arg1: &mut Collection)

37Pop

38LdConst[12](u64: 312)

39Abort

B6:

40MoveLoc[7](loc4: &mut UID)

41LdFalse

42Pack[0](RegistryKey)

43Call dynamic_field::borrow_mut<RegistryKey, Registry>(&mut UID, RegistryKey): &mut Registry

44StLoc[5](loc2: &mut Registry)

45CopyLoc[5](loc2: &mut Registry)

46ImmBorrowField[2](Registry.bound: Table<ID, u64>)

47CopyLoc[2](Arg2: ID)

48Call table::contains<ID, u64>(&Table<ID, u64>, ID): bool

49BrFalse(51)

B7:

50Branch(57)

B8:

51MoveLoc[5](loc2: &mut Registry)

52Pop

53MoveLoc[1](Arg1: &mut Collection)

54Pop

55LdConst[12](u64: 312)

56Abort

B9:

57CopyLoc[5](loc2: &mut Registry)

58MutBorrowField[2](Registry.bound: Table<ID, u64>)

59CopyLoc[2](Arg2: ID)

60Call table::remove<ID, u64>(&mut Table<ID, u64>, ID): u64

61StLoc[4](loc1: u64)

62CopyLoc[5](loc2: &mut Registry)

63ImmBorrowField[3](Registry.reserved: u64)

64ReadRef

65LdU64(1)

66Sub

67MoveLoc[5](loc2: &mut Registry)

68MutBorrowField[3](Registry.reserved: u64)

69WriteRef

70MoveLoc[1](Arg1: &mut Collection)

71Call collection::pool_mut(&mut Collection): &mut vector<u16>

72CopyLoc[4](loc1: u64)

73CastU16

74VecPushBack(27)

75MoveLoc[3](loc0: ID)

76MoveLoc[2](Arg2: ID)

77MoveLoc[4](loc1: u64)

78Pack[8](Unbound)

79Call event::emit<Unbound>(Unbound)

80Ret

}

public bound_index(Arg0: &Collection, Arg1: ID): Option<u64> {

L2: loc0: Option<u64>

L3: loc1: &Registry

L4: loc2: &UID

B0:

0MoveLoc[0](Arg0: &Collection)

1Call collection::collection_uid(&Collection): &UID

2StLoc[4](loc2: &UID)

3CopyLoc[4](loc2: &UID)

4LdFalse

5Pack[0](RegistryKey)

6Call dynamic_field::exists<RegistryKey>(&UID, RegistryKey): bool

7Not

8BrFalse(13)

B1:

9MoveLoc[4](loc2: &UID)

10Pop

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

12Ret

B2:

13MoveLoc[4](loc2: &UID)

14LdFalse

15Pack[0](RegistryKey)

16Call dynamic_field::borrow<RegistryKey, Registry>(&UID, RegistryKey): &Registry

17StLoc[3](loc1: &Registry)

18CopyLoc[3](loc1: &Registry)

19ImmBorrowField[2](Registry.bound: Table<ID, u64>)

20CopyLoc[1](Arg1: ID)

21Call table::contains<ID, u64>(&Table<ID, u64>, ID): bool

22BrFalse(31)

B3:

23MoveLoc[3](loc1: &Registry)

24ImmBorrowField[2](Registry.bound: Table<ID, u64>)

25MoveLoc[1](Arg1: ID)

26Call table::borrow<ID, u64>(&Table<ID, u64>, ID): &u64

27ReadRef

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

29StLoc[2](loc0: Option<u64>)

30Branch(35)

B4:

31MoveLoc[3](loc1: &Registry)

32Pop

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

34StLoc[2](loc0: Option<u64>)

B5:

35MoveLoc[2](loc0: Option<u64>)

36Ret

}

entry add_relic(Arg0: &AdminCap, Arg1: &mut Collection, Arg2: String, Arg3: vector<String>, Arg4: vector<String>, Arg5: vector<u8>, Arg6: &mut TxContext) {

L7: loc0: VecMap<String, String>

L8: loc1: ID

L9: loc2: u64

L10: loc3: u64

L11: loc4: &mut Registry

L12: loc5: &mut Relics

L13: loc6: bool

L14: loc7: u64

L15: loc8: &mut UID

B0:

0MoveLoc[0](Arg0: &AdminCap)

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

2FreezeRef

3Call collection::check_admin(&AdminCap, &Collection)

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

5FreezeRef

6Call collection::rising_state(&Collection): bool * u64 * u64 * u64 * bool

7StLoc[13](loc6: bool)

8Pop

9Pop

10Pop

11Pop

12MoveLoc[13](loc6: bool)

13BrFalse(15)

B1:

14Branch(21)

B2:

15MoveLoc[6](Arg6: &mut TxContext)

16Pop

17MoveLoc[1](Arg1: &mut Collection)

18Pop

19LdConst[0](u64: 300)

20Abort

B3:

21ImmBorrowLoc[5](Arg5: vector<u8>)

22VecLen(48)

23LdU64(32)

24Eq

25BrFalse(27)

B4:

26Branch(33)

B5:

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

28Pop

29MoveLoc[1](Arg1: &mut Collection)

30Pop

31LdConst[2](u64: 302)

32Abort

B6:

33MoveLoc[3](Arg3: vector<String>)

34MoveLoc[4](Arg4: vector<String>)

35Call vec_map::from_keys_values<String, String>(vector<String>, vector<String>): VecMap<String, String>

36StLoc[7](loc0: VecMap<String, String>)

37CopyLoc[1](Arg1: &mut Collection)

38FreezeRef

39Call collection::supply(&Collection): u64

40StLoc[14](loc7: u64)

41CopyLoc[1](Arg1: &mut Collection)

42FreezeRef

43Call object::id<Collection>(&Collection): ID

44StLoc[8](loc1: ID)

45MoveLoc[1](Arg1: &mut Collection)

46Call collection::collection_uid_mut(&mut Collection): &mut UID

47StLoc[15](loc8: &mut UID)

48CopyLoc[15](loc8: &mut UID)

49FreezeRef

50LdFalse

51Pack[3](RelicsKey)

52Call dynamic_field::exists<RelicsKey>(&UID, RelicsKey): bool

53Not

54BrFalse(66)

B7:

55CopyLoc[15](loc8: &mut UID)

56LdFalse

57Pack[3](RelicsKey)

58CopyLoc[6](Arg6: &mut TxContext)

59Call table::new<u64, vector<u8>>(&mut TxContext): Table<u64, vector<u8>>

60MoveLoc[6](Arg6: &mut TxContext)

61Call table::new<u64, ID>(&mut TxContext): Table<u64, ID>

62LdU64(0)

63Pack[4](Relics)

64Call dynamic_field::add<RelicsKey, Relics>(&mut UID, RelicsKey, Relics)

65Branch(68)

B8:

66MoveLoc[6](Arg6: &mut TxContext)

67Pop

B9:

68CopyLoc[15](loc8: &mut UID)

69LdFalse

70Pack[3](RelicsKey)

71Call dynamic_field::borrow_mut<RelicsKey, Relics>(&mut UID, RelicsKey): &mut Relics

72StLoc[12](loc5: &mut Relics)

73CopyLoc[12](loc5: &mut Relics)

74ImmBorrowField[4](Relics.loaded: u64)

75ReadRef

76LdConst[18](u64: 13)

77Lt

78BrFalse(80)

B10:

79Branch(86)

B11:

80MoveLoc[15](loc8: &mut UID)

81Pop

82MoveLoc[12](loc5: &mut Relics)

83Pop

84LdConst[15](u64: 315)

85Abort

B12:

86CopyLoc[12](loc5: &mut Relics)

87ImmBorrowField[4](Relics.loaded: u64)

88ReadRef

89LdU64(1)

90Add

91CopyLoc[12](loc5: &mut Relics)

92MutBorrowField[4](Relics.loaded: u64)

93WriteRef

94MoveLoc[14](loc7: u64)

95CopyLoc[12](loc5: &mut Relics)

96ImmBorrowField[4](Relics.loaded: u64)

97ReadRef

98Add

99StLoc[9](loc2: u64)

100MoveLoc[12](loc5: &mut Relics)

101MutBorrowField[5](Relics.images: Table<u64, vector<u8>>)

102CopyLoc[9](loc2: u64)

103CopyLoc[5](Arg5: vector<u8>)

104Call table::add<u64, vector<u8>>(&mut Table<u64, vector<u8>>, u64, vector<u8>)

105MoveLoc[9](loc2: u64)

106StLoc[10](loc3: u64)

107MoveLoc[15](loc8: &mut UID)

108LdFalse

109Pack[0](RegistryKey)

110Call dynamic_field::borrow_mut<RegistryKey, Registry>(&mut UID, RegistryKey): &mut Registry

111StLoc[11](loc4: &mut Registry)

112CopyLoc[11](loc4: &mut Registry)

113MutBorrowField[1](Registry.pieces: Table<u64, Piece>)

114CopyLoc[10](loc3: u64)

115CopyLoc[2](Arg2: String)

116MoveLoc[7](loc0: VecMap<String, String>)

117MoveLoc[11](loc4: &mut Registry)

118ImmBorrowField[0](Registry.piece_size: u64)

119ReadRef

120Call relic_piece(String, VecMap<String, String>, u64): Piece

121Call table::add<u64, Piece>(&mut Table<u64, Piece>, u64, Piece)

122MoveLoc[8](loc1: ID)

123MoveLoc[10](loc3: u64)

124MoveLoc[2](Arg2: String)

125MoveLoc[5](Arg5: vector<u8>)

126Pack[9](RelicAdded)

127Call event::emit<RelicAdded>(RelicAdded)

128Ret

}

entry bind_relic(Arg0: &AdminCap, Arg1: &mut Collection, Arg2: ID, Arg3: u64) {

L4: loc0: ID

L5: loc1: &mut Registry

L6: loc2: &mut Relics

L7: loc3: &mut UID

B0:

0MoveLoc[0](Arg0: &AdminCap)

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

2FreezeRef

3Call collection::check_admin(&AdminCap, &Collection)

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

5FreezeRef

6Call object::id<Collection>(&Collection): ID

7StLoc[4](loc0: ID)

8MoveLoc[1](Arg1: &mut Collection)

9Call collection::collection_uid_mut(&mut Collection): &mut UID

10StLoc[7](loc3: &mut UID)

11CopyLoc[7](loc3: &mut UID)

12FreezeRef

13LdFalse

14Pack[3](RelicsKey)

15Call dynamic_field::exists<RelicsKey>(&UID, RelicsKey): bool

16BrFalse(18)

B1:

17Branch(22)

B2:

18MoveLoc[7](loc3: &mut UID)

19Pop

20LdConst[13](u64: 313)

21Abort

B3:

22CopyLoc[7](loc3: &mut UID)

23LdFalse

24Pack[3](RelicsKey)

25Call dynamic_field::borrow_mut<RelicsKey, Relics>(&mut UID, RelicsKey): &mut Relics

26StLoc[6](loc2: &mut Relics)

27CopyLoc[6](loc2: &mut Relics)

28ImmBorrowField[5](Relics.images: Table<u64, vector<u8>>)

29CopyLoc[3](Arg3: u64)

30Call table::contains<u64, vector<u8>>(&Table<u64, vector<u8>>, u64): bool

31BrFalse(33)

B4:

32Branch(39)

B5:

33MoveLoc[7](loc3: &mut UID)

34Pop

35MoveLoc[6](loc2: &mut Relics)

36Pop

37LdConst[13](u64: 313)

38Abort

B6:

39CopyLoc[6](loc2: &mut Relics)

40ImmBorrowField[6](Relics.graves: Table<u64, ID>)

41CopyLoc[3](Arg3: u64)

42Call table::contains<u64, ID>(&Table<u64, ID>, u64): bool

43Not

44BrFalse(46)

B7:

45Branch(52)

B8:

46MoveLoc[7](loc3: &mut UID)

47Pop

48MoveLoc[6](loc2: &mut Relics)

49Pop

50LdConst[14](u64: 314)

51Abort

B9:

52MoveLoc[6](loc2: &mut Relics)

53MutBorrowField[6](Relics.graves: Table<u64, ID>)

54CopyLoc[3](Arg3: u64)

55CopyLoc[2](Arg2: ID)

56Call table::add<u64, ID>(&mut Table<u64, ID>, u64, ID)

57MoveLoc[7](loc3: &mut UID)

58LdFalse

59Pack[0](RegistryKey)

60Call dynamic_field::borrow_mut<RegistryKey, Registry>(&mut UID, RegistryKey): &mut Registry

61StLoc[5](loc1: &mut Registry)

62CopyLoc[5](loc1: &mut Registry)

63ImmBorrowField[2](Registry.bound: Table<ID, u64>)

64CopyLoc[2](Arg2: ID)

65Call table::contains<ID, u64>(&Table<ID, u64>, ID): bool

66Not

67BrFalse(69)

B10:

68Branch(73)

B11:

69MoveLoc[5](loc1: &mut Registry)

70Pop

71LdConst[11](u64: 311)

72Abort

B12:

73CopyLoc[5](loc1: &mut Registry)

74MutBorrowField[2](Registry.bound: Table<ID, u64>)

75CopyLoc[2](Arg2: ID)

76CopyLoc[3](Arg3: u64)

77Call table::add<ID, u64>(&mut Table<ID, u64>, ID, u64)

78CopyLoc[5](loc1: &mut Registry)

79ImmBorrowField[3](Registry.reserved: u64)

80ReadRef

81LdU64(1)

82Add

83MoveLoc[5](loc1: &mut Registry)

84MutBorrowField[3](Registry.reserved: u64)

85WriteRef

86MoveLoc[4](loc0: ID)

87MoveLoc[2](Arg2: ID)

88MoveLoc[3](Arg3: u64)

89Pack[7](Bound)

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

91Ret

}

entry unbind_relic(Arg0: &AdminCap, Arg1: &mut Collection, Arg2: ID) {

L3: loc0: ID

L4: loc1: u64

L5: loc2: u64

L6: loc3: &Registry

L7: loc4: &mut Registry

L8: loc5: &mut Relics

L9: loc6: &mut UID

B0:

0MoveLoc[0](Arg0: &AdminCap)

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

2FreezeRef

3Call collection::check_admin(&AdminCap, &Collection)

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

5FreezeRef

6Call object::id<Collection>(&Collection): ID

7StLoc[3](loc0: ID)

8MoveLoc[1](Arg1: &mut Collection)

9Call collection::collection_uid_mut(&mut Collection): &mut UID

10StLoc[9](loc6: &mut UID)

11CopyLoc[9](loc6: &mut UID)

12FreezeRef

13LdFalse

14Pack[3](RelicsKey)

15Call dynamic_field::exists<RelicsKey>(&UID, RelicsKey): bool

16BrFalse(18)

B1:

17Branch(22)

B2:

18MoveLoc[9](loc6: &mut UID)

19Pop

20LdConst[13](u64: 313)

21Abort

B3:

22CopyLoc[9](loc6: &mut UID)

23FreezeRef

24LdFalse

25Pack[0](RegistryKey)

26Call dynamic_field::borrow<RegistryKey, Registry>(&UID, RegistryKey): &Registry

27StLoc[6](loc3: &Registry)

28CopyLoc[6](loc3: &Registry)

29ImmBorrowField[2](Registry.bound: Table<ID, u64>)

30CopyLoc[2](Arg2: ID)

31Call table::contains<ID, u64>(&Table<ID, u64>, ID): bool

32BrFalse(34)

B4:

33Branch(40)

B5:

34MoveLoc[9](loc6: &mut UID)

35Pop

36MoveLoc[6](loc3: &Registry)

37Pop

38LdConst[12](u64: 312)

39Abort

B6:

40CopyLoc[6](loc3: &Registry)

41ImmBorrowField[2](Registry.bound: Table<ID, u64>)

42CopyLoc[2](Arg2: ID)

43Call table::borrow<ID, u64>(&Table<ID, u64>, ID): &u64

44ReadRef

45StLoc[4](loc1: u64)

46MoveLoc[6](loc3: &Registry)

47ImmBorrowField[1](Registry.pieces: Table<u64, Piece>)

48CopyLoc[4](loc1: u64)

49Call table::contains<u64, Piece>(&Table<u64, Piece>, u64): bool

50BrFalse(52)

B7:

51Branch(56)

B8:

52MoveLoc[9](loc6: &mut UID)

53Pop

54LdConst[5](u64: 305)

55Abort

B9:

56MoveLoc[4](loc1: u64)

57StLoc[5](loc2: u64)

58CopyLoc[9](loc6: &mut UID)

59LdFalse

60Pack[3](RelicsKey)

61Call dynamic_field::borrow_mut<RelicsKey, Relics>(&mut UID, RelicsKey): &mut Relics

62StLoc[8](loc5: &mut Relics)

63CopyLoc[8](loc5: &mut Relics)

64ImmBorrowField[5](Relics.images: Table<u64, vector<u8>>)

65CopyLoc[5](loc2: u64)

66Call table::contains<u64, vector<u8>>(&Table<u64, vector<u8>>, u64): bool

67BrFalse(69)

B10:

68Branch(75)

B11:

69MoveLoc[9](loc6: &mut UID)

70Pop

71MoveLoc[8](loc5: &mut Relics)

72Pop

73LdConst[13](u64: 313)

74Abort

B12:

75MoveLoc[8](loc5: &mut Relics)

76MutBorrowField[6](Relics.graves: Table<u64, ID>)

77CopyLoc[5](loc2: u64)

78Call table::remove<u64, ID>(&mut Table<u64, ID>, u64): ID

79Pop

80MoveLoc[9](loc6: &mut UID)

81LdFalse

82Pack[0](RegistryKey)

83Call dynamic_field::borrow_mut<RegistryKey, Registry>(&mut UID, RegistryKey): &mut Registry

84StLoc[7](loc4: &mut Registry)

85CopyLoc[7](loc4: &mut Registry)

86MutBorrowField[2](Registry.bound: Table<ID, u64>)

87CopyLoc[2](Arg2: ID)

88Call table::remove<ID, u64>(&mut Table<ID, u64>, ID): u64

89Pop

90CopyLoc[7](loc4: &mut Registry)

91ImmBorrowField[3](Registry.reserved: u64)

92ReadRef

93LdU64(1)

94Sub

95MoveLoc[7](loc4: &mut Registry)

96MutBorrowField[3](Registry.reserved: u64)

97WriteRef

98MoveLoc[3](loc0: ID)

99MoveLoc[2](Arg2: ID)

100MoveLoc[5](loc2: u64)

101Pack[8](Unbound)

102Call event::emit<Unbound>(Unbound)

103Ret

}

entry remove_relic(Arg0: &AdminCap, Arg1: &mut Collection, Arg2: u64) {

L3: loc0: ID

L4: loc1: &mut Relics

L5: loc2: &mut UID

B0:

0MoveLoc[0](Arg0: &AdminCap)

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

2FreezeRef

3Call collection::check_admin(&AdminCap, &Collection)

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

5FreezeRef

6Call object::id<Collection>(&Collection): ID

7StLoc[3](loc0: ID)

8MoveLoc[1](Arg1: &mut Collection)

9Call collection::collection_uid_mut(&mut Collection): &mut UID

10StLoc[5](loc2: &mut UID)

11CopyLoc[5](loc2: &mut UID)

12FreezeRef

13LdFalse

14Pack[3](RelicsKey)

15Call dynamic_field::exists<RelicsKey>(&UID, RelicsKey): bool

16BrFalse(18)

B1:

17Branch(22)

B2:

18MoveLoc[5](loc2: &mut UID)

19Pop

20LdConst[13](u64: 313)

21Abort

B3:

22CopyLoc[5](loc2: &mut UID)

23LdFalse

24Pack[3](RelicsKey)

25Call dynamic_field::borrow_mut<RelicsKey, Relics>(&mut UID, RelicsKey): &mut Relics

26StLoc[4](loc1: &mut Relics)

27CopyLoc[4](loc1: &mut Relics)

28ImmBorrowField[5](Relics.images: Table<u64, vector<u8>>)

29CopyLoc[2](Arg2: u64)

30Call table::contains<u64, vector<u8>>(&Table<u64, vector<u8>>, u64): bool

31BrFalse(33)

B4:

32Branch(39)

B5:

33MoveLoc[5](loc2: &mut UID)

34Pop

35MoveLoc[4](loc1: &mut Relics)

36Pop

37LdConst[13](u64: 313)

38Abort

B6:

39CopyLoc[4](loc1: &mut Relics)

40ImmBorrowField[6](Relics.graves: Table<u64, ID>)

41CopyLoc[2](Arg2: u64)

42Call table::contains<u64, ID>(&Table<u64, ID>, u64): bool

43Not

44BrFalse(46)

B7:

45Branch(52)

B8:

46MoveLoc[5](loc2: &mut UID)

47Pop

48MoveLoc[4](loc1: &mut Relics)

49Pop

50LdConst[14](u64: 314)

51Abort

B9:

52MoveLoc[4](loc1: &mut Relics)

53MutBorrowField[5](Relics.images: Table<u64, vector<u8>>)

54CopyLoc[2](Arg2: u64)

55Call table::remove<u64, vector<u8>>(&mut Table<u64, vector<u8>>, u64): vector<u8>

56Pop

57MoveLoc[5](loc2: &mut UID)

58LdFalse

59Pack[0](RegistryKey)

60Call dynamic_field::borrow_mut<RegistryKey, Registry>(&mut UID, RegistryKey): &mut Registry

61MutBorrowField[1](Registry.pieces: Table<u64, Piece>)

62CopyLoc[2](Arg2: u64)

63Call table::remove<u64, Piece>(&mut Table<u64, Piece>, u64): Piece

64Unpack[2](Piece)

65Pop

66Pop

67Pop

68Pop

69MoveLoc[3](loc0: ID)

70MoveLoc[2](Arg2: u64)

71Pack[10](RelicRemoved)

72Call event::emit<RelicRemoved>(RelicRemoved)

73Ret

}

entry seal(Arg0: &AdminCap, Arg1: &mut Collection, Arg2: vector<u8>) {

L3: loc0: bool

L4: loc1: u64

B0:

0MoveLoc[0](Arg0: &AdminCap)

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

2FreezeRef

3Call collection::check_admin(&AdminCap, &Collection)

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

5FreezeRef

6Call collection::rising_state(&Collection): bool * u64 * u64 * u64 * bool

7StLoc[3](loc0: bool)

8Pop

9StLoc[4](loc1: u64)

10Pop

11Pop

12MoveLoc[3](loc0: bool)

13Not

14BrFalse(16)

B1:

15Branch(20)

B2:

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

17Pop

18LdConst[1](u64: 301)

19Abort

B3:

20MoveLoc[4](loc1: u64)

21CopyLoc[1](Arg1: &mut Collection)

22FreezeRef

23Call collection::supply(&Collection): u64

24Eq

25BrFalse(27)

B4:

26Branch(31)

B5:

27MoveLoc[1](Arg1: &mut Collection)

28Pop

29LdConst[2](u64: 302)

30Abort

B6:

31CopyLoc[1](Arg1: &mut Collection)

32FreezeRef

33Call collection::running_hash(&Collection): vector<u8>

34CopyLoc[2](Arg2: vector<u8>)

35Eq

36BrFalse(38)

B7:

37Branch(42)

B8:

38MoveLoc[1](Arg1: &mut Collection)

39Pop

40LdConst[3](u64: 303)

41Abort

B9:

42CopyLoc[1](Arg1: &mut Collection)

43CopyLoc[2](Arg2: vector<u8>)

44LdConst[19](vector<u8>: "mor..)

45Call string::utf8(vector<u8>): String

46Call collection::seal_seeding(&mut Collection, vector<u8>, String)

47MoveLoc[1](Arg1: &mut Collection)

48FreezeRef

49Call object::id<Collection>(&Collection): ID

50MoveLoc[2](Arg2: vector<u8>)

51Pack[6](Sealed)

52Call event::emit<Sealed>(Sealed)

53Ret

}

entry set_rising_open(Arg0: &AdminCap, Arg1: &mut Collection, Arg2: bool) {

L3: loc0: bool

B0:

0MoveLoc[0](Arg0: &AdminCap)

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

2FreezeRef

3Call collection::check_admin(&AdminCap, &Collection)

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

5FreezeRef

6Call collection::rising_state(&Collection): bool * u64 * u64 * u64 * bool

7StLoc[3](loc0: bool)

8Pop

9Pop

10Pop

11Pop

12MoveLoc[3](loc0: bool)

13BrFalse(15)

B1:

14Branch(19)

B2:

15MoveLoc[1](Arg1: &mut Collection)

16Pop

17LdConst[0](u64: 300)

18Abort

B3:

19MoveLoc[1](Arg1: &mut Collection)

20MoveLoc[2](Arg2: bool)

21Call collection::set_reveal_open(&mut Collection, bool)

22Ret

}

entry call_the_dead(Arg0: &mut Collection, Arg1: &Clock) {

L2: loc0: u64

L3: loc1: bool

L4: loc2: u64

B0:

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

1FreezeRef

2Call collection::check_current(&Collection)

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

4FreezeRef

5Call collection::rising_state(&Collection): bool * u64 * u64 * u64 * bool

6StLoc[3](loc1: bool)

7Pop

8Pop

9StLoc[4](loc2: u64)

10Pop

11MoveLoc[3](loc1: bool)

12BrFalse(14)

B1:

13Branch(20)

B2:

14MoveLoc[1](Arg1: &Clock)

15Pop

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

17Pop

18LdConst[0](u64: 300)

19Abort

B3:

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

21FreezeRef

22Call collection::minted(&Collection): u64

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

24FreezeRef

25Call collection::supply(&Collection): u64

26Eq

27BrFalse(29)

B4:

28Branch(35)

B5:

29MoveLoc[1](Arg1: &Clock)

30Pop

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

32Pop

33LdConst[9](u64: 309)

34Abort

B6:

35MoveLoc[1](Arg1: &Clock)

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

37LdConst[16](u64: 780000)

38Add

39StLoc[2](loc0: u64)

40CopyLoc[2](loc0: u64)

41MoveLoc[4](loc2: u64)

42Lt

43BrFalse(48)

B7:

44MoveLoc[0](Arg0: &mut Collection)

45MoveLoc[2](loc0: u64)

46Call collection::move_reveal_start(&mut Collection, u64)

47Branch(50)

B8:

48MoveLoc[0](Arg0: &mut Collection)

49Pop

B9:

50Ret

}

entry rise_in_kiosk(Arg0: &mut Collection, Arg1: &mut Kiosk, Arg2: &KioskOwnerCap, Arg3: ID, Arg4: &Clock, Arg5: &Random, Arg6: &mut TxContext) {

L7: loc0: &mut Mortem

L8: loc1: RandomGenerator

B0:

0MoveLoc[5](Arg5: &Random)

1MoveLoc[6](Arg6: &mut TxContext)

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

3StLoc[8](loc1: RandomGenerator)

4MoveLoc[1](Arg1: &mut Kiosk)

5MoveLoc[2](Arg2: &KioskOwnerCap)

6MoveLoc[3](Arg3: ID)

7Call kiosk::borrow_mut<Mortem>(&mut Kiosk, &KioskOwnerCap, ID): &mut Mortem

8StLoc[7](loc0: &mut Mortem)

9MoveLoc[0](Arg0: &mut Collection)

10MoveLoc[7](loc0: &mut Mortem)

11MoveLoc[4](Arg4: &Clock)

12MutBorrowLoc[8](loc1: RandomGenerator)

13Call rise(&mut Collection, &mut Mortem, &Clock, &mut RandomGenerator)

14Ret

}

entry rise_in_personal_kiosk(Arg0: &mut Collection, Arg1: &mut Kiosk, Arg2: &mut PersonalKioskCap, Arg3: ID, Arg4: &Clock, Arg5: &Random, Arg6: &mut TxContext) {

L7: loc0: Borrow

L8: loc1: RandomGenerator

L9: loc2: KioskOwnerCap

B0:

0MoveLoc[5](Arg5: &Random)

1MoveLoc[6](Arg6: &mut TxContext)

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

3StLoc[8](loc1: RandomGenerator)

4CopyLoc[2](Arg2: &mut PersonalKioskCap)

5Call personal_kiosk::borrow_val(&mut PersonalKioskCap): KioskOwnerCap * Borrow

6StLoc[7](loc0: Borrow)

7StLoc[9](loc2: KioskOwnerCap)

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

9MoveLoc[1](Arg1: &mut Kiosk)

10ImmBorrowLoc[9](loc2: KioskOwnerCap)

11MoveLoc[3](Arg3: ID)

12Call kiosk::borrow_mut<Mortem>(&mut Kiosk, &KioskOwnerCap, ID): &mut Mortem

13MoveLoc[4](Arg4: &Clock)

14MutBorrowLoc[8](loc1: RandomGenerator)

15Call rise(&mut Collection, &mut Mortem, &Clock, &mut RandomGenerator)

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

17MoveLoc[9](loc2: KioskOwnerCap)

18MoveLoc[7](loc0: Borrow)

19Call personal_kiosk::return_val(&mut PersonalKioskCap, KioskOwnerCap, Borrow)

20Ret

}

rise(Arg0: &mut Collection, Arg1: &mut Mortem, Arg2: &Clock, Arg3: &mut RandomGenerator) {

L4: loc0: u64

L5: loc1: bool

L6: loc2: VecMap<String, String>

L7: loc3: Option<u64>

L8: loc4: u64

L9: loc5: u8

L10: loc6: String

L11: loc7: bool

L12: loc8: vector<u8>

L13: loc9: bool

L14: loc10: bool

L15: loc11: u64

B0:

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

1FreezeRef

2Call collection::check_current(&Collection)

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

4FreezeRef

5Call collection::rising_state(&Collection): bool * u64 * u64 * u64 * bool

6StLoc[13](loc9: bool)

7Pop

8Pop

9StLoc[15](loc11: u64)

10StLoc[11](loc7: bool)

11MoveLoc[13](loc9: bool)

12BrFalse(14)

B1:

13Branch(24)

B2:

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

15Pop

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

17Pop

18MoveLoc[2](Arg2: &Clock)

19Pop

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

21Pop

22LdConst[0](u64: 300)

23Abort

B3:

24MoveLoc[11](loc7: bool)

25BrFalse(27)

B4:

26Branch(37)

B5:

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

28Pop

29MoveLoc[1](Arg1: &mut Mortem)

30Pop

31MoveLoc[2](Arg2: &Clock)

32Pop

33MoveLoc[0](Arg0: &mut Collection)

34Pop

35LdConst[6](u64: 306)

36Abort

B6:

37MoveLoc[2](Arg2: &Clock)

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

39MoveLoc[15](loc11: u64)

40Ge

41BrFalse(43)

B7:

42Branch(51)

B8:

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

44Pop

45MoveLoc[1](Arg1: &mut Mortem)

46Pop

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

48Pop

49LdConst[4](u64: 304)

50Abort

B9:

51CopyLoc[1](Arg1: &mut Mortem)

52FreezeRef

53Call collection::grave_metadata_version(&Mortem): u64

54LdU64(0)

55Eq

56BrFalse(58)

B10:

57Branch(66)

B11:

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

59Pop

60MoveLoc[1](Arg1: &mut Mortem)

61Pop

62MoveLoc[0](Arg0: &mut Collection)

63Pop

64LdConst[5](u64: 305)

65Abort

B12:

66CopyLoc[1](Arg1: &mut Mortem)

67FreezeRef

68Call collection::grave_luck(&Mortem): u8

69StLoc[9](loc5: u8)

70CopyLoc[0](Arg0: &mut Collection)

71CopyLoc[1](Arg1: &mut Mortem)

72FreezeRef

73Call object::id<Mortem>(&Mortem): ID

74Call claim_binding(&mut Collection, ID): Option<u64>

75StLoc[7](loc3: Option<u64>)

76ImmBorrowLoc[7](loc3: Option<u64>)

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

78BrFalse(87)

B13:

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

80Pop

81MoveLoc[7](loc3: Option<u64>)

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

83LdFalse

84StLoc[5](loc1: bool)

85StLoc[4](loc0: u64)

86Branch(93)

B14:

87CopyLoc[0](Arg0: &mut Collection)

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

89CopyLoc[9](loc5: u8)

90Call draw(&mut Collection, &mut RandomGenerator, u8): u64 * bool

91StLoc[5](loc1: bool)

92StLoc[4](loc0: u64)

B15:

93MoveLoc[4](loc0: u64)

94MoveLoc[5](loc1: bool)

95StLoc[14](loc10: bool)

96StLoc[8](loc4: u64)

97CopyLoc[0](Arg0: &mut Collection)

98Call collection::collection_uid_mut(&mut Collection): &mut UID

99LdFalse

100Pack[0](RegistryKey)

101Call dynamic_field::borrow_mut<RegistryKey, Registry>(&mut UID, RegistryKey): &mut Registry

102MutBorrowField[1](Registry.pieces: Table<u64, Piece>)

103CopyLoc[8](loc4: u64)

104Call table::remove<u64, Piece>(&mut Table<u64, Piece>, u64): Piece

105Unpack[2](Piece)

106StLoc[12](loc8: vector<u8>)

107Pop

108StLoc[6](loc2: VecMap<String, String>)

109StLoc[10](loc6: String)

110CopyLoc[1](Arg1: &mut Mortem)

111CopyLoc[8](loc4: u64)

112MoveLoc[10](loc6: String)

113MoveLoc[6](loc2: VecMap<String, String>)

114MoveLoc[12](loc8: vector<u8>)

115Call collection::raise_grave(&mut Mortem, u64, String, VecMap<String, String>, vector<u8>)

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

117Call collection::count_drawn(&mut Collection)

118MoveLoc[0](Arg0: &mut Collection)

119FreezeRef

120Call object::id<Collection>(&Collection): ID

121CopyLoc[1](Arg1: &mut Mortem)

122FreezeRef

123Call object::id<Mortem>(&Mortem): ID

124MoveLoc[1](Arg1: &mut Mortem)

125FreezeRef

126Call collection::grave_number(&Mortem): u64

127MoveLoc[8](loc4: u64)

128MoveLoc[9](loc5: u8)

129MoveLoc[14](loc10: bool)

130Pack[11](Risen)

131Call event::emit<Risen>(Risen)

132Ret

}

claim_binding(Arg0: &mut Collection, Arg1: ID): Option<u64> {

L2: loc0: &mut Registry

B0:

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

1Call collection::collection_uid_mut(&mut Collection): &mut UID

2LdFalse

3Pack[0](RegistryKey)

4Call dynamic_field::borrow_mut<RegistryKey, Registry>(&mut UID, RegistryKey): &mut Registry

5StLoc[2](loc0: &mut Registry)

6CopyLoc[2](loc0: &mut Registry)

7ImmBorrowField[2](Registry.bound: Table<ID, u64>)

8CopyLoc[1](Arg1: ID)

9Call table::contains<ID, u64>(&Table<ID, u64>, ID): bool

10Not

11BrFalse(16)

B1:

12MoveLoc[2](loc0: &mut Registry)

13Pop

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

15Ret

B2:

16CopyLoc[2](loc0: &mut Registry)

17ImmBorrowField[3](Registry.reserved: u64)

18ReadRef

19LdU64(1)

20Sub

21CopyLoc[2](loc0: &mut Registry)

22MutBorrowField[3](Registry.reserved: u64)

23WriteRef

24MoveLoc[2](loc0: &mut Registry)

25ImmBorrowField[2](Registry.bound: Table<ID, u64>)

26MoveLoc[1](Arg1: ID)

27Call table::borrow<ID, u64>(&Table<ID, u64>, ID): &u64

28ReadRef

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

30Ret

}

draw(Arg0: &mut Collection, Arg1: &mut RandomGenerator, Arg2: u8): u64 * bool {

L3: loc0: u64

L4: loc1: &mut RandomGenerator

L5: loc2: bool

L6: loc3: u64

L7: loc4: u64

L8: loc5: u64

L9: loc6: u16

L10: loc7: u64

L11: loc8: u64

L12: loc9: u64

L13: loc10: u64

L14: loc11: u64

L15: loc12: u16

L16: loc13: &mut vector<u16>

L17: loc14: &Registry

L18: loc15: u8

L19: loc16: bool

L20: loc17: u64

B0:

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

1Call collection::pool_mut(&mut Collection): &mut vector<u16>

2FreezeRef

3VecLen(27)

4StLoc[12](loc9: u64)

5CopyLoc[12](loc9: u64)

6LdU64(0)

7Gt

8BrFalse(10)

B1:

9Branch(16)

B2:

10MoveLoc[1](Arg1: &mut RandomGenerator)

11Pop

12MoveLoc[0](Arg0: &mut Collection)

13Pop

14LdConst[7](u64: 307)

15Abort

B3:

16CopyLoc[1](Arg1: &mut RandomGenerator)

17LdU64(0)

18CopyLoc[12](loc9: u64)

19LdU64(1)

20Sub

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

22StLoc[10](loc7: u64)

23CopyLoc[1](Arg1: &mut RandomGenerator)

24StLoc[4](loc1: &mut RandomGenerator)

25CopyLoc[12](loc9: u64)

26LdU64(1)

27Gt

28BrFalse(34)

B4:

29CopyLoc[12](loc9: u64)

30LdU64(2)

31Sub

32StLoc[3](loc0: u64)

33Branch(36)

B5:

34LdU64(0)

35StLoc[3](loc0: u64)

B6:

36MoveLoc[4](loc1: &mut RandomGenerator)

37LdU64(0)

38MoveLoc[3](loc0: u64)

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

40StLoc[11](loc8: u64)

41MoveLoc[1](Arg1: &mut RandomGenerator)

42LdU8(0)

43LdU8(99)

44Call random::generate_u8_in_range(&mut RandomGenerator, u8, u8): u8

45StLoc[18](loc15: u8)

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

47Call collection::pool_mut(&mut Collection): &mut vector<u16>

48StLoc[16](loc13: &mut vector<u16>)

49CopyLoc[16](loc13: &mut vector<u16>)

50MoveLoc[10](loc7: u64)

51Call vector::swap_remove<u16>(&mut vector<u16>, u64): u16

52CastU64

53StLoc[8](loc5: u64)

54MoveLoc[12](loc9: u64)

55LdU64(1)

56Eq

57BrFalse(65)

B7:

58MoveLoc[16](loc13: &mut vector<u16>)

59Pop

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

61Pop

62MoveLoc[8](loc5: u64)

63LdFalse

64Ret

B8:

65MoveLoc[16](loc13: &mut vector<u16>)

66MoveLoc[11](loc8: u64)

67Call vector::swap_remove<u16>(&mut vector<u16>, u64): u16

68CastU64

69StLoc[14](loc11: u64)

70CopyLoc[0](Arg0: &mut Collection)

71FreezeRef

72Call collection::collection_uid(&Collection): &UID

73LdFalse

74Pack[0](RegistryKey)

75Call dynamic_field::borrow<RegistryKey, Registry>(&UID, RegistryKey): &Registry

76StLoc[17](loc14: &Registry)

77CopyLoc[17](loc14: &Registry)

78ImmBorrowField[1](Registry.pieces: Table<u64, Piece>)

79CopyLoc[8](loc5: u64)

80Call table::borrow<u64, Piece>(&Table<u64, Piece>, u64): &Piece

81ImmBorrowField[7](Piece.rank: u16)

82ReadRef

83StLoc[9](loc6: u16)

84MoveLoc[17](loc14: &Registry)

85ImmBorrowField[1](Registry.pieces: Table<u64, Piece>)

86CopyLoc[14](loc11: u64)

87Call table::borrow<u64, Piece>(&Table<u64, Piece>, u64): &Piece

88ImmBorrowField[7](Piece.rank: u16)

89ReadRef

90StLoc[15](loc12: u16)

91MoveLoc[18](loc15: u8)

92MoveLoc[2](Arg2: u8)

93Lt

94StLoc[19](loc16: bool)

95CopyLoc[19](loc16: bool)

96BrFalse(102)

B9:

97MoveLoc[15](loc12: u16)

98MoveLoc[9](loc6: u16)

99Lt

100StLoc[5](loc2: bool)

101Branch(104)

B10:

102LdFalse

103StLoc[5](loc2: bool)

B11:

104MoveLoc[5](loc2: bool)

105BrFalse(111)

B12:

106MoveLoc[14](loc11: u64)

107MoveLoc[8](loc5: u64)

108StLoc[7](loc4: u64)

109StLoc[6](loc3: u64)

110Branch(115)

B13:

111MoveLoc[8](loc5: u64)

112MoveLoc[14](loc11: u64)

113StLoc[7](loc4: u64)

114StLoc[6](loc3: u64)

B14:

115MoveLoc[6](loc3: u64)

116MoveLoc[7](loc4: u64)

117StLoc[13](loc10: u64)

118StLoc[20](loc17: u64)

119MoveLoc[0](Arg0: &mut Collection)

120Call collection::pool_mut(&mut Collection): &mut vector<u16>

121MoveLoc[13](loc10: u64)

122CastU16

123VecPushBack(27)

124MoveLoc[20](loc17: u64)

125MoveLoc[19](loc16: bool)

126Ret

}

padded(Arg0: Piece, Arg1: u64): Piece {

L2: loc0: vector<u8>

L3: loc1: u64

L4: loc2: u64

L5: loc3: u64

L6: loc4: u64

L7: loc5: u64

B0:

0ImmBorrowLoc[0](Arg0: Piece)

1Call bcs::to_bytes<Piece>(&Piece): vector<u8>

2StLoc[2](loc0: vector<u8>)

3ImmBorrowLoc[2](loc0: vector<u8>)

4VecLen(48)

5LdU64(1)

6Sub

7StLoc[4](loc2: u64)

8CopyLoc[1](Arg1: u64)

9CopyLoc[4](loc2: u64)

10Gt

11BrFalse(13)

B1:

12Branch(15)

B2:

13LdConst[8](u64: 308)

14Abort

B3:

15MoveLoc[1](Arg1: u64)

16MoveLoc[4](loc2: u64)

17Sub

18LdU64(1)

19Sub

20StLoc[5](loc3: u64)

21CopyLoc[5](loc3: u64)

22LdU64(128)

23Neq

24BrFalse(26)

B4:

25Branch(28)

B5:

26LdConst[8](u64: 308)

27Abort

B6:

28CopyLoc[5](loc3: u64)

29LdU64(128)

30Lt

31BrFalse(35)

B7:

32MoveLoc[5](loc3: u64)

33StLoc[3](loc1: u64)

34Branch(39)

B8:

35MoveLoc[5](loc3: u64)

36LdU64(1)

37Sub

38StLoc[3](loc1: u64)

B9:

39MoveLoc[3](loc1: u64)

40StLoc[7](loc5: u64)

41CopyLoc[7](loc5: u64)

42LdConst[17](u64: 16383)

43Le

44BrFalse(46)

B10:

45Branch(48)

B11:

46LdConst[8](u64: 308)

47Abort

B12:

48LdU64(0)

49StLoc[6](loc4: u64)

B13:

50CopyLoc[6](loc4: u64)

51CopyLoc[7](loc5: u64)

52Lt

53BrFalse(63)

B14:

54MutBorrowLoc[0](Arg0: Piece)

55MutBorrowField[8](Piece.pad: vector<u8>)

56LdU8(0)

57VecPushBack(48)

58MoveLoc[6](loc4: u64)

59LdU64(1)

60Add

61StLoc[6](loc4: u64)

62Branch(50)

B15:

63MoveLoc[0](Arg0: Piece)

64Ret

}

relic_piece(Arg0: String, Arg1: VecMap<String, String>, Arg2: u64): Piece {

L3: loc0: vector<u8>

L4: loc1: bool

L5: loc2: Piece

L6: loc3: u64

L7: loc4: Piece

B0:

0MoveLoc[0](Arg0: String)

1MoveLoc[1](Arg1: VecMap<String, String>)

2LdU16(0)

3LdConst[21](vector<u8>: "" /..)

4Pack[2](Piece)

5StLoc[7](loc4: Piece)

6ImmBorrowLoc[7](loc4: Piece)

7Call bcs::to_bytes<Piece>(&Piece): vector<u8>

8StLoc[3](loc0: vector<u8>)

9ImmBorrowLoc[3](loc0: vector<u8>)

10VecLen(48)

11LdU64(1)

12Sub

13StLoc[6](loc3: u64)

14CopyLoc[2](Arg2: u64)

15CopyLoc[6](loc3: u64)

16Gt

17BrFalse(27)

B1:

18CopyLoc[2](Arg2: u64)

19MoveLoc[6](loc3: u64)

20Sub

21LdU64(1)

22Sub

23LdU64(128)

24Neq

25StLoc[4](loc1: bool)

26Branch(29)

B2:

27LdFalse

28StLoc[4](loc1: bool)

B3:

29MoveLoc[4](loc1: bool)

30BrFalse(36)

B4:

31MoveLoc[7](loc4: Piece)

32MoveLoc[2](Arg2: u64)

33Call padded(Piece, u64): Piece

34StLoc[5](loc2: Piece)

35Branch(38)

B5:

36MoveLoc[7](loc4: Piece)

37StLoc[5](loc2: Piece)

B6:

38MoveLoc[5](loc2: Piece)

39Ret

}

Constants [

0 => u64: 300

1 => u64: 301

2 => u64: 302

3 => u64: 303

4 => u64: 304

5 => u64: 305

6 => u64: 306

7 => u64: 307

8 => u64: 308

9 => u64: 309

10 => u64: 310

11 => u64: 311

12 => u64: 312

13 => u64: 313

14 => u64: 314

15 => u64: 315

16 => u64: 780000

17 => u64: 16383

18 => u64: 13

19 => vector<u8>: "mortem-rising-v1: h0 = empty; h(i) = sha3_256(h(i-1) || bcs(index: u64) || bcs(name: String) || bcs(attributes: VecMap<String,String>) || bcs(rank: u16) || bcs(image_sha256: vector<u8>)), index 1..666 in order" // interpreted as UTF8 string

20 => vector<u16>: 00

21 => vector<u8>: "" // interpreted as UTF8 string

]

}