BCD

Tezos Contract Explorer
Search Networks Deploy
  • Home
  • /
  • Mainnet
  • /
  • Gradients
FA2Ledger
operations (7)Storage Code Interact Tokens Metadata Fork Views Events Statistics Details
Latest
​x
779
1588
 
1
{ parameter (or
2
              (or
3
                (or
4
                  (or (unit %accept_administrator)
5
                      (pair %balance_of
6
                        (list %requests (pair (address %owner) (nat %token_id)))
7
                        (contract %callback (list (pair
8
                                                  (pair %request (address %owner)
9
                                                                 (nat %token_id))
10
                                                  (nat %balance))))))
11
                  (or (nat %cancel_listing)
12
                      (pair %collect (nat %collect_id) (nat %amount))))
13
                (or
14
                  (or
15
                    (pair %create_listing
16
                      (pair
17
                        (pair
18
                          (option %burn_redeem (list (pair (address %fa2_address)
19
                                                         (pair (nat %token_id)
20
                                                               (nat %amount)))))
21
                          (pair (option %duration int) (mutez %edition_price)))
22
                        (pair
23
                          (pair (bool %gate_enabled)
24
                                (list %gate_tokens (pair (address %fa2_address)
25
                                                        (list %token_reqs (pair
26
                                                                           (nat %token_id)
27
                                                                           (nat %min_balance))))))
28
                          (pair (nat %max_editions_per_wallet) (option %metadata string))))
29
                      (pair
30
                        (pair (option %reserve_list (set address))
31
                              (pair (option %reserve_period int)
32
                                    (list %sale_split (pair (address %address)
33
                                                           (nat %split)))))
34
                        (pair
35
                          (pair
36
                            (option %special_split (list (pair (address %address)
37
                                                             (mutez %amount))))
38
                            (bool %start_on_collect))
39
                          (pair (timestamp %start_time) (nat %token_id)))))
40
                    (list %create_tokens (pair (map %metadata string bytes)
41
                                              (list %royalties (pair (address %address)
42
                                                                    (nat %royalties))))))
43
                  (or
44
                    (list %mint (pair (nat %token_id)
45
                                     (list %recipients (pair (address %address)
46
                                                            (nat %amount)))))
47
                    (or (address %propose_administrator)
48
                        (list %receive_balance (pair
49
                                                (pair %request (address %owner)
50
                                                               (nat %token_id))
51
                                                (nat %balance)))))))
52
              (or
53
                (or (or (map %set_metadata string bytes) (bool %set_pause))
54
                    (or
55
                      (list %transfer (pair (address %from_)
56
                                           (list %txs (pair (address %to_)
57
                                                           (pair (nat %token_id)
58
                                                                 (nat %amount))))))
59
                      (pair %update_admins (option %to_add (list address))
60
                                           (option %to_remove (list address)))))
61
                (or
62
                  (or
63
                    (pair %update_collaborators (option %to_add (list address))
64
                                                (option %to_remove (list address)))
65
                    (list %update_info_maps (pair (address %address)
66
                                                 (pair (list %token_ids nat)
67
                                                       (pair (bool %delete)
68
                                                             (bool %is_temp))))))
69
                  (or
70
                    (pair %update_marketplace_contracts (option %to_add (list address))
71
                                                        (option %to_remove (list address)))
72
                    (or
73
                      (list %update_operators (or
74
                                               (pair %add_operator (address %owner)
75
                                                                   (pair
76
                                                                     (address %operator)
77
                                                                     (nat %token_id)))
78
                                               (pair %remove_operator (address %owner)
79
                                                                      (pair
80
                                                                        (address %operator)
81
                                                                        (nat %token_id)))))
82
                      (list %update_token_metadata (pair (nat %token_id)
83
                                                        (map %new_metadata string bytes)))))))) ;
84
  storage (pair
85
            (pair
86
              (pair
87
                (pair (big_map %additional_infos (pair address nat) unit)
88
                      (big_map %admins address unit))
89
                (pair (big_map %collabs address unit)
90
                      (big_map %ledger (pair address nat) nat)))
91
              (pair
92
                (pair
93
                  (big_map %listings nat
94
                                     (pair
95
                                       (pair
96
                                         (pair
97
                                           (pair
98
                                             (option %burn_redeem (list (pair
99
                                                                        (address %fa2_address)
100
                                                                        (pair
101
                                                                          (nat %token_id)
102
                                                                          (nat %amount)))))
103
                                             (option %duration int))
104
                                           (pair (option %duration_start_time timestamp)
105
                                                 (mutez %edition_price)))
106
                                         (pair
107
                                           (pair (nat %editions_sold)
108
                                                 (bool %gate_enabled))
109
                                           (pair
110
                                             (list %gate_tokens (pair
111
                                                                 (address %fa2_address)
112
                                                                 (list %token_reqs (pair
113
                                                                                    (nat %token_id)
114
                                                                                    (nat %min_balance)))))
115
                                             (bool %has_reserve_list))))
116
                                       (pair
117
                                         (pair
118
                                           (pair (nat %max_editions_per_wallet)
119
                                                 (option %metadata string))
120
                                           (pair (option %reserve_period int)
121
                                                 (list %sale_split (pair
122
                                                                    (address %address)
123
                                                                    (nat %split)))))
124
                                         (pair
125
                                           (pair (address %seller)
126
                                                 (option %special_split (list (pair
127
                                                                              (address %address)
128
                                                                              (mutez %amount)))))
129
                                           (pair (bool %start_on_collect)
130
                                                 (pair (timestamp %start_time)
131
                                                       (nat %token_id)))))))
132
                  (set %marketplace_contracts address))
133
                (pair (big_map %metadata string bytes)
134
                      (pair (nat %next_token_id)
135
                            (big_map %operators
136
                              (pair (address %owner)
137
                                    (pair (address %operator) (nat %token_id)))
138
                              unit)))))
139
            (pair
140
              (pair
141
                (pair (bool %paused)
142
                      (big_map %pending address
143
                                        (pair (address %original_sender)
144
                                              (pair
145
                                                (list %gate_checks (pair
146
                                                                    (address %fa2_address)
147
                                                                    (list %token_reqs (pair
148
                                                                                       (nat %token_id)
149
                                                                                       (nat %min_balance)))))
150
                                                (nat %callbacks_remaining)))))
151
                (pair (option %proposed_superadmin address)
152
                      (pair (big_map %reserve_lists nat (set address))
153
                            (address %superadmin))))
154
              (pair
155
                (pair (big_map %supply nat nat)
156
                      (big_map %temp_infos (pair address nat) unit))
157
                (pair (big_map %token_creators nat address)
158
                      (pair
159
                        (big_map %token_metadata nat
160
                                                 (pair (nat %token_id)
161
                                                       (map %token_info string bytes)))
162
                        (big_map %token_royalties nat
163
                                                  (list (pair (address %address)
164
                                                             (nat %royalties))))))))) ;
165
  code { UNPAIR ;
166
         IF_LEFT
167
           { IF_LEFT
168
               { IF_LEFT
169
                   { IF_LEFT
170
                       { DROP ;
171
                         PUSH mutez 0 ;
172
                         AMOUNT ;
173
                         COMPARE ;
174
                         EQ ;
175
                         IF {} { PUSH string "TEZ_TRANSFER" ; FAILWITH } ;
176
                         DUP ;
177
                         GET 3 ;
178
                         GET 3 ;
179
                         IF_NONE
180
                           { PUSH string "NO_SUPERADMIN_PROPOSED" ; FAILWITH }
181
                           { DROP } ;
182
                         DUP ;
183
                         GET 3 ;
184
                         GET 3 ;
185
                         IF_NONE { PUSH int 413 ; FAILWITH } {} ;
186
                         SENDER ;
187
                         COMPARE ;
188
                         EQ ;
189
                         IF {} { PUSH string "NOT_PROPOSED_SUPERADMIN" ; FAILWITH } ;
190
                         UNPAIR ;
191
                         SWAP ;
192
                         UNPAIR ;
193
                         UNPAIR ;
194
                         SWAP ;
195
                         GET 3 ;
196
                         SENDER ;
197
                         SWAP ;
198
                         PAIR ;
199
                         NONE address ;
200
                         PAIR ;
201
                         SWAP ;
202
                         PAIR ;
203
                         PAIR ;
204
                         SWAP ;
205
                         PAIR ;
206
                         NIL operation ;
207
                         DUP 2 ;
208
                         GET 3 ;
209
                         GET 6 ;
210
                         SENDER ;
211
                         PAIR ;
212
                         EMIT %superadmin_accepted (pair (address %new_superadmin)
213
                                                         (address %old_superadmin)) ;
214
                         CONS }
215
                       { NIL (pair (pair address nat) nat) ;
216
                         DUP 2 ;
217
                         CAR ;
218
                         ITER { DUP 4 ;
219
                                GET 9 ;
220
                                DUP 2 ;
221
                                CDR ;
222
                                MEM ;
223
                                IF {} { PUSH string "FA2_TOKEN_UNDEFINED" ; FAILWITH } ;
224
                                SWAP ;
225
                                DUP 4 ;
226
                                CAR ;
227
                                CAR ;
228
                                GET 4 ;
229
                                DUP 3 ;
230
                                CDR ;
231
                                DUP 4 ;
232
                                CAR ;
233
                                PAIR ;
234
                                GET ;
235
                                IF_NONE { PUSH nat 0 } {} ;
236
                                DIG 2 ;
237
                                PAIR ;
238
                                CONS } ;
239
                         NIL operation ;
240
                         DIG 2 ;
241
                         CDR ;
242
                         PUSH mutez 0 ;
243
                         DIG 3 ;
244
                         TRANSFER_TOKENS ;
245
                         CONS } }
246
                   { IF_LEFT
247
                       { PUSH mutez 0 ;
248
                         AMOUNT ;
249
                         COMPARE ;
250
                         EQ ;
251
                         IF {} { PUSH string "TEZ_TRANSFER" ; FAILWITH } ;
252
                         DUP 2 ;
253
                         CAR ;
254
                         GET 3 ;
255
                         CAR ;
256
                         DUP 2 ;
257
                         MEM ;
258
                         IF {} { PUSH string "LISTING_NOT_FOUND" ; FAILWITH } ;
259
                         DUP 2 ;
260
                         CAR ;
261
                         GET 3 ;
262
                         CAR ;
263
                         DUP 2 ;
264
                         GET ;
265
                         IF_NONE { PUSH int 689 ; FAILWITH } {} ;
266
                         GET 5 ;
267
                         CAR ;
268
                         SENDER ;
269
                         COMPARE ;
270
                         EQ ;
271
                         IF
272
                           { PUSH bool True }
273
                           { DUP 2 ; GET 3 ; GET 6 ; SENDER ; COMPARE ; EQ } ;
274
                         IF
275
                           { PUSH bool True }
276
                           { DUP 2 ; CAR ; CAR ; CAR ; CDR ; SENDER ; MEM } ;
277
                         IF {} { PUSH string "NOT_AUTHORIZED_TO_CANCEL" ; FAILWITH } ;
278
                         DUP 2 ;
279
                         CAR ;
280
                         GET 3 ;
281
                         CAR ;
282
                         DUP 2 ;
283
                         GET ;
284
                         IF_NONE { PUSH int 689 ; FAILWITH } {} ;
285
                         CAR ;
286
                         GET 6 ;
287
                         IF
288
                           { DUP 2 ;
289
                             GET 3 ;
290
                             GET 5 ;
291
                             DUP 2 ;
292
                             MEM ;
293
                             IF
294
                               { SWAP ;
295
                                 UNPAIR ;
296
                                 SWAP ;
297
                                 UNPAIR ;
298
                                 UNPAIR ;
299
                                 SWAP ;
300
                                 UNPAIR ;
301
                                 SWAP ;
302
                                 UNPAIR ;
303
                                 NONE (set address) ;
304
                                 DUP 8 ;
305
                                 UPDATE ;
306
                                 PAIR ;
307
                                 SWAP ;
308
                                 PAIR ;
309
                                 SWAP ;
310
                                 PAIR ;
311
                                 PAIR ;
312
                                 SWAP ;
313
                                 PAIR ;
314
                                 SWAP }
315
                               {} }
316
                           {} ;
317
                         SWAP ;
318
                         UNPAIR ;
319
                         UNPAIR ;
320
                         SWAP ;
321
                         UNPAIR ;
322
                         UNPAIR ;
323
                         NONE (pair
324
                                (pair
325
                                  (pair
326
                                    (pair (option (list (pair address (pair nat nat))))
327
                                          (option int))
328
                                    (pair (option timestamp) mutez))
329
                                  (pair (pair nat bool)
330
                                        (pair
331
                                          (list (pair address (list (pair nat nat))))
332
                                          bool)))
333
                                (pair
334
                                  (pair (pair nat (option string))
335
                                        (pair (option int) (list (pair address nat))))
336
                                  (pair
337
                                    (pair address (option (list (pair address mutez))))
338
                                    (pair bool (pair timestamp nat))))) ;
339
                         DIG 6 ;
340
                         UPDATE ;
341
                         PAIR ;
342
                         PAIR ;
343
                         SWAP ;
344
                         PAIR ;
345
                         PAIR ;
346
                         NIL operation }
347
                       { DUP 2 ;
348
                         GET 3 ;
349
                         CAR ;
350
                         CAR ;
351
                         IF { PUSH string "CONTRACT_PAUSED" ; FAILWITH } {} ;
352
                         PUSH nat 0 ;
353
                         DUP 2 ;
354
                         CDR ;
355
                         COMPARE ;
356
                         GT ;
357
                         IF {} { PUSH string "ZERO_AMOUNT_NOT_ALLOWED" ; FAILWITH } ;
358
                         DUP 2 ;
359
                         CAR ;
360
                         GET 3 ;
361
                         CAR ;
362
                         DUP 2 ;
363
                         CAR ;
364
                         MEM ;
365
                         IF {} { PUSH string "COLLECT_ID_NOT_FOUND" ; FAILWITH } ;
366
                         DUP 2 ;
367
                         CAR ;
368
                         GET 3 ;
369
                         CAR ;
370
                         DUP 2 ;
371
                         CAR ;
372
                         GET ;
373
                         IF_NONE { PUSH int 717 ; FAILWITH } {} ;
374
                         GET 7 ;
375
                         IF
376
                           { DUP 2 ;
377
                             CAR ;
378
                             GET 3 ;
379
                             CAR ;
380
                             DUP 2 ;
381
                             CAR ;
382
                             GET ;
383
                             IF_NONE { PUSH int 717 ; FAILWITH } {} ;
384
                             CAR ;
385
                             CAR ;
386
                             CAR ;
387
                             CDR ;
388
                             IF_NONE { PUSH bool False } { DROP ; PUSH bool True } }
389
                           { PUSH bool False } ;
390
                         IF
391
                           { DUP 2 ;
392
                             CAR ;
393
                             GET 3 ;
394
                             CAR ;
395
                             DUP 2 ;
396
                             CAR ;
397
                             GET ;
398
                             IF_NONE { PUSH int 717 ; FAILWITH } {} ;
399
                             CAR ;
400
                             CAR ;
401
                             GET 3 ;
402
                             IF_NONE { PUSH bool True } { DROP ; PUSH bool False } }
403
                           { PUSH bool False } ;
404
                         IF
405
                           { SWAP ;
406
                             UNPAIR ;
407
                             UNPAIR ;
408
                             SWAP ;
409
                             UNPAIR ;
410
                             UNPAIR ;
411
                             DUP ;
412
                             DUP 7 ;
413
                             CAR ;
414
                             DUP ;
415
                             DUG 2 ;
416
                             GET ;
417
                             IF_NONE { PUSH int 721 ; FAILWITH } {} ;
418
                             UNPAIR ;
419
                             UNPAIR ;
420
                             UNPAIR ;
421
                             SWAP ;
422
                             CDR ;
423
                             NOW ;
424
                             SOME ;
425
                             PAIR ;
426
                             SWAP ;
427
                             PAIR ;
428
                             PAIR ;
429
                             PAIR ;
430
                             SOME ;
431
                             SWAP ;
432
                             UPDATE ;
433
                             PAIR ;
434
                             PAIR ;
435
                             SWAP ;
436
                             PAIR ;
437
                             PAIR ;
438
                             SWAP }
439
                           {} ;
440
                         DUP 2 ;
441
                         CAR ;
442
                         GET 3 ;
443
                         CAR ;
444
                         DUP 2 ;
445
                         CAR ;
446
                         GET ;
447
                         IF_NONE { PUSH int 717 ; FAILWITH } {} ;
448
                         GET 9 ;
449
                         NOW ;
450
                         COMPARE ;
451
                         GE ;
452
                         IF {} { PUSH string "LISTING_NOT_STARTED" ; FAILWITH } ;
453
                         DUP 2 ;
454
                         CAR ;
455
                         GET 3 ;
456
                         CAR ;
457
                         DUP 2 ;
458
                         CAR ;
459
                         GET ;
460
                         IF_NONE { PUSH int 717 ; FAILWITH } {} ;
461
                         CAR ;
462
                         CAR ;
463
                         CAR ;
464
                         CDR ;
465
                         IF_NONE
466
                           {}
467
                           { DROP ;
468
                             DUP 2 ;
469
                             CAR ;
470
                             GET 3 ;
471
                             CAR ;
472
                             DUP 2 ;
473
                             CAR ;
474
                             GET ;
475
                             IF_NONE { PUSH int 717 ; FAILWITH } {} ;
476
                             GET 7 ;
477
                             IF
478
                               { DUP 2 ;
479
                                 CAR ;
480
                                 GET 3 ;
481
                                 CAR ;
482
                                 DUP 2 ;
483
                                 CAR ;
484
                                 GET ;
485
                                 IF_NONE { PUSH int 717 ; FAILWITH } {} ;
486
                                 CAR ;
487
                                 CAR ;
488
                                 GET 3 ;
489
                                 IF_NONE
490
                                   {}
491
                                   { DROP ;
492
                                     DUP 2 ;
493
                                     CAR ;
494
                                     GET 3 ;
495
                                     CAR ;
496
                                     DUP 2 ;
497
                                     CAR ;
498
                                     GET ;
499
                                     IF_NONE { PUSH int 717 ; FAILWITH } {} ;
500
                                     CAR ;
501
                                     CAR ;
502
                                     CAR ;
503
                                     CDR ;
504
                                     IF_NONE { PUSH int 255 ; FAILWITH } {} ;
505
                                     DUP 3 ;
506
                                     CAR ;
507
                                     GET 3 ;
508
                                     CAR ;
509
                                     DUP 3 ;
510
                                     CAR ;
511
                                     GET ;
512
                                     IF_NONE { PUSH int 717 ; FAILWITH } {} ;
513
                                     CAR ;
514
                                     CAR ;
515
                                     GET 3 ;
516
                                     IF_NONE { PUSH int 254 ; FAILWITH } {} ;
517
                                     ADD ;
518
                                     NOW ;
519
                                     COMPARE ;
520
                                     LT ;
521
                                     IF {} { PUSH string "LISTING_CLOSED" ; FAILWITH } } }
522
                               { DUP 2 ;
523
                                 CAR ;
524
                                 GET 3 ;
525
                                 CAR ;
526
                                 DUP 2 ;
527
                                 CAR ;
528
                                 GET ;
529
                                 IF_NONE { PUSH int 717 ; FAILWITH } {} ;
530
                                 CAR ;
531
                                 CAR ;
532
                                 CAR ;
533
                                 CDR ;
534
                                 IF_NONE { PUSH int 255 ; FAILWITH } {} ;
535
                                 DUP 3 ;
536
                                 CAR ;
537
                                 GET 3 ;
538
                                 CAR ;
539
                                 DUP 3 ;
540
                                 CAR ;
541
                                 GET ;
542
                                 IF_NONE { PUSH int 717 ; FAILWITH } {} ;
543
                                 GET 9 ;
544
                                 ADD ;
545
                                 NOW ;
546
                                 COMPARE ;
547
                                 LT ;
548
                                 IF {} { PUSH string "LISTING_CLOSED" ; FAILWITH } } } ;
549
                         PUSH nat 0 ;
550
                         DUP 3 ;
551
                         CAR ;
552
                         GET 3 ;
553
                         CAR ;
554
                         DUP 3 ;
555
                         CAR ;
556
                         GET ;
557
                         IF_NONE { PUSH int 717 ; FAILWITH } {} ;
558
                         GET 3 ;
559
                         CAR ;
560
                         CAR ;
561
                         COMPARE ;
562
                         NEQ ;
563
                         IF
564
                           { DUP 2 ;
565
                             CAR ;
566
                             GET 3 ;
567
                             CAR ;
568
                             DUP 2 ;
569
                             CAR ;
570
                             GET ;
571
                             IF_NONE { PUSH int 717 ; FAILWITH } {} ;
572
                             GET 3 ;
573
                             CAR ;
574
                             CAR ;
575
                             DUP 2 ;
576
                             CDR ;
577
                             DUP 4 ;
578
                             CAR ;
579
                             CAR ;
580
                             GET 4 ;
581
                             DUP 5 ;
582
                             CAR ;
583
                             GET 3 ;
584
                             CAR ;
585
                             DUP 5 ;
586
                             CAR ;
587
                             GET ;
588
                             IF_NONE { PUSH int 717 ; FAILWITH } {} ;
589
                             GET 10 ;
590
                             SENDER ;
591
                             PAIR ;
592
                             GET ;
593
                             IF_NONE { PUSH nat 0 } {} ;
594
                             ADD ;
595
                             COMPARE ;
596
                             LE ;
597
                             IF {} { PUSH string "MAX_EDITIONS_EXCEEDED" ; FAILWITH } }
598
                           {} ;
599
                         DUP 2 ;
600
                         CAR ;
601
                         CAR ;
602
                         CAR ;
603
                         CAR ;
604
                         DUP 3 ;
605
                         CAR ;
606
                         GET 3 ;
607
                         CAR ;
608
                         DUP 3 ;
609
                         CAR ;
610
                         GET ;
611
                         IF_NONE { PUSH int 717 ; FAILWITH } {} ;
612
                         GET 10 ;
613
                         SENDER ;
614
                         PAIR ;
615
                         MEM ;
616
                         IF { PUSH string "RESTRICTED_COLLECT" ; FAILWITH } {} ;
617
                         SWAP ;
618
                         UNPAIR ;
619
                         UNPAIR ;
620
                         SWAP ;
621
                         UNPAIR ;
622
                         UNPAIR ;
623
                         DUP ;
624
                         DUP 7 ;
625
                         CAR ;
626
                         DUP ;
627
                         DUG 2 ;
628
                         GET ;
629
                         IF_NONE { PUSH int 735 ; FAILWITH } {} ;
630
                         UNPAIR ;
631
                         UNPAIR ;
632
                         SWAP ;
633
                         UNPAIR ;
634
                         UNPAIR ;
635
                         DUP 12 ;
636
                         CDR ;
637
                         ADD ;
638
                         PAIR ;
639
                         PAIR ;
640
                         SWAP ;
641
                         PAIR ;
642
                         PAIR ;
643
                         SOME ;
644
                         SWAP ;
645
                         UPDATE ;
646
                         PAIR ;
647
                         PAIR ;
648
                         SWAP ;
649
                         PAIR ;
650
                         PAIR ;
651
                         SWAP ;
652
                         DUP 2 ;
653
                         UNPAIR ;
654
                         UNPAIR ;
655
                         SWAP ;
656
                         UNPAIR ;
657
                         UNPAIR ;
658
                         DIG 6 ;
659
                         CAR ;
660
                         GET 3 ;
661
                         CAR ;
662
                         DUP 7 ;
663
                         CAR ;
664
                         GET ;
665
                         IF_NONE { PUSH int 717 ; FAILWITH } {} ;
666
                         SOME ;
667
                         DUP 7 ;
668
                         CAR ;
669
                         UPDATE ;
670
                         PAIR ;
671
                         PAIR ;
672
                         SWAP ;
673
                         PAIR ;
674
                         PAIR ;
675
                         SWAP ;
676
                         PUSH mutez 0 ;
677
                         DUP 3 ;
678
                         CAR ;
679
                         GET 3 ;
680
                         CAR ;
681
                         DUP 3 ;
682
                         CAR ;
683
                         GET ;
684
                         IF_NONE { PUSH int 717 ; FAILWITH } {} ;
685
                         GET 5 ;
686
                         CDR ;
687
                         IF_NONE
688
                           {}
689
                           { DROP ;
690
                             DUP 3 ;
691
                             CAR ;
692
                             GET 3 ;
693
                             CAR ;
694
                             DUP 3 ;
695
                             CAR ;
696
                             GET ;
697
                             IF_NONE { PUSH int 717 ; FAILWITH } {} ;
698
                             GET 5 ;
699
                             CDR ;
700
                             IF_NONE { PUSH int 745 ; FAILWITH } {} ;
701
                             ITER { CDR ; DUP 3 ; CDR ; MUL ; ADD } } ;
702
                         DUP ;
703
                         DUP 4 ;
704
                         CAR ;
705
                         GET 3 ;
706
                         CAR ;
707
                         DUP 4 ;
708
                         CAR ;
709
                         GET ;
710
                         IF_NONE { PUSH int 717 ; FAILWITH } {} ;
711
                         CAR ;
712
                         CAR ;
713
                         GET 4 ;
714
                         DUP 4 ;
715
                         CDR ;
716
                         MUL ;
717
                         ADD ;
718
                         AMOUNT ;
719
                         COMPARE ;
720
                         EQ ;
721
                         IF {} { PUSH string "INCORRECT_AMOUNT_SENT" ; FAILWITH } ;
722
                         DUP 3 ;
723
                         CAR ;
724
                         GET 3 ;
725
                         CAR ;
726
                         DUP 3 ;
727
                         CAR ;
728
                         GET ;
729
                         IF_NONE { PUSH int 717 ; FAILWITH } {} ;
730
                         CAR ;
731
                         GET 6 ;
732
                         IF
733
                           { DUP 3 ;
734
                             GET 3 ;
735
                             GET 5 ;
736
                             DUP 3 ;
737
                             CAR ;
738
                             MEM ;
739
                             IF {} { PUSH string "RESERVE_LIST_NOT_FOUND" ; FAILWITH } ;
740
                             DUP 3 ;
741
                             CAR ;
742
                             GET 3 ;
743
                             CAR ;
744
                             DUP 3 ;
745
                             CAR ;
746
                             GET ;
747
                             IF_NONE { PUSH int 717 ; FAILWITH } {} ;
748
                             GET 3 ;
749
                             GET 3 ;
750
                             IF_NONE
751
                               { DUP 3 ;
752
                                 GET 3 ;
753
                                 GET 5 ;
754
                                 DUP 3 ;
755
                                 CAR ;
756
                                 GET ;
757
                                 IF_NONE { PUSH int 755 ; FAILWITH } {} ;
758
                                 SENDER ;
759
                                 MEM ;
760
                                 IF
761
                                   {}
762
                                   { PUSH string "NOT_ON_RESERVE_LIST" ; FAILWITH } }
763
                               { DROP ;
764
                                 DUP 3 ;
765
                                 CAR ;
766
                                 GET 3 ;
767
                                 CAR ;
768
                                 DUP 3 ;
769
                                 CAR ;
770
                                 GET ;
771
                                 IF_NONE { PUSH int 717 ; FAILWITH } {} ;
772
                                 GET 3 ;
773
                                 GET 3 ;
774
                                 IF_NONE { PUSH int 759 ; FAILWITH } {} ;
775
                                 DUP 4 ;
776
                                 CAR ;
777
                                 GET 3 ;
778
                                 CAR ;
779
                                 DUP 4 ;
780
                                 CAR ;
781
                                 GET ;
782
                                 IF_NONE { PUSH int 717 ; FAILWITH } {} ;
783
                                 GET 9 ;
784
                                 ADD ;
785
                                 NOW ;
786
                                 COMPARE ;
787
                                 LT ;
788
                                 IF
789
                                   { DUP 3 ;
790
                                     GET 3 ;
791
                                     GET 5 ;
792
                                     DUP 3 ;
793
                                     CAR ;
794
                                     GET ;
795
                                     IF_NONE { PUSH int 755 ; FAILWITH } {} ;
796
                                     SENDER ;
797
                                     MEM ;
798
                                     IF
799
                                       {}
800
                                       { PUSH string "NOT_ON_RESERVE_LIST" ; FAILWITH } }
801
                                   {} } }
802
                           {} ;
803
                         DUP 3 ;
804
                         CAR ;
805
                         GET 3 ;
806
                         CAR ;
807
                         DUP 3 ;
808
                         CAR ;
809
                         GET ;
810
                         IF_NONE { PUSH int 717 ; FAILWITH } {} ;
811
                         CAR ;
812
                         CAR ;
813
                         CAR ;
814
                         CAR ;
815
                         IF_NONE
816
                           { NIL operation }
817
                           { DROP ;
818
                             NIL operation ;
819
                             DUP 4 ;
820
                             CAR ;
821
                             GET 3 ;
822
                             CAR ;
823
                             DUP 4 ;
824
                             CAR ;
825
                             GET ;
826
                             IF_NONE { PUSH int 717 ; FAILWITH } {} ;
827
                             CAR ;
828
                             CAR ;
829
                             CAR ;
830
                             CAR ;
831
                             IF_NONE { PUSH int 767 ; FAILWITH } {} ;
832
                             ITER { DUP ;
833
                                    CAR ;
834
                                    CONTRACT %transfer (list (pair (address %from_)
835
                                                                  (list %txs (pair
836
                                                                              (address %to_)
837
                                                                              (pair
838
                                                                                (nat %token_id)
839
                                                                                (nat %amount)))))) ;
840
                                    IF_NONE
841
                                      { PUSH string "INVALID_FA2_CONTRACT" ; FAILWITH }
842
                                      { DROP } ;
843
                                    SWAP ;
844
                                    DUP 2 ;
845
                                    CAR ;
846
                                    CONTRACT %transfer (list (pair (address %from_)
847
                                                                  (list %txs (pair
848
                                                                              (address %to_)
849
                                                                              (pair
850
                                                                                (nat %token_id)
851
                                                                                (nat %amount)))))) ;
852
                                    IF_NONE { PUSH int 245 ; FAILWITH } {} ;
853
                                    PUSH mutez 0 ;
854
                                    NIL (pair address
855
                                              (list (pair address (pair nat nat)))) ;
856
                                    NIL (pair address (pair nat nat)) ;
857
                                    DUP 8 ;
858
                                    CDR ;
859
                                    DUP 7 ;
860
                                    GET 4 ;
861
                                    MUL ;
862
                                    DIG 6 ;
863
                                    GET 3 ;
864
                                    PUSH address "tz1burnburnburnburnburnburnburjAYjjX" ;
865
                                    PAIR 3 ;
866
                                    CONS ;
867
                                    SENDER ;
868
                                    PAIR ;
869
                                    CONS ;
870
                                    TRANSFER_TOKENS ;
871
                                    CONS } } ;
872
                         DUP 4 ;
873
                         CAR ;
874
                         GET 3 ;
875
                         CAR ;
876
                         DUP 4 ;
877
                         CAR ;
878
                         GET ;
879
                         IF_NONE { PUSH int 717 ; FAILWITH } {} ;
880
                         CAR ;
881
                         GET 3 ;
882
                         CDR ;
883
                         IF
884
                           { DUP 4 ;
885
                             GET 3 ;
886
                             CAR ;
887
                             CDR ;
888
                             SENDER ;
889
                             MEM ;
890
                             IF { PUSH string "PENDING_EXISTS" ; FAILWITH } {} ;
891
                             DUP 4 ;
892
                             UNPAIR ;
893
                             SWAP ;
894
                             UNPAIR ;
895
                             UNPAIR ;
896
                             UNPAIR ;
897
                             SWAP ;
898
                             DUP 9 ;
899
                             CAR ;
900
                             GET 3 ;
901
                             CAR ;
902
                             DUP 9 ;
903
                             CAR ;
904
                             GET ;
905
                             IF_NONE { PUSH int 717 ; FAILWITH } {} ;
906
                             CAR ;
907
                             GET 5 ;
908
                             SIZE ;
909
                             DIG 9 ;
910
                             CAR ;
911
                             GET 3 ;
912
                             CAR ;
913
                             DUP 10 ;
914
                             CAR ;
915
                             GET ;
916
                             IF_NONE { PUSH int 717 ; FAILWITH } {} ;
917
                             CAR ;
918
                             GET 5 ;
919
                             SENDER ;
920
                             PAIR 3 ;
921
                             SOME ;
922
                             SENDER ;
923
                             UPDATE ;
924
                             SWAP ;
925
                             PAIR ;
926
                             PAIR ;
927
                             PAIR ;
928
                             SWAP ;
929
                             PAIR ;
930
                             DUG 3 ;
931
                             DUP 4 ;
932
                             CAR ;
933
                             GET 3 ;
934
                             CAR ;
935
                             DUP 4 ;
936
                             CAR ;
937
                             GET ;
938
                             IF_NONE { PUSH int 717 ; FAILWITH } {} ;
939
                             CAR ;
940
                             GET 5 ;
941
                             ITER { NIL (pair address nat) ;
942
                                    DUP 2 ;
943
                                    CDR ;
944
                                    ITER { CAR ; SENDER ; PAIR ; CONS } ;
945
                                    DUG 2 ;
946
                                    CAR ;
947
                                    CONTRACT %balance_of (pair
948
                                                           (list %requests (pair
949
                                                                            (address %owner)
950
                                                                            (nat %token_id)))
951
                                                           (contract %callback (list (pair
952
                                                                                     (pair %request
953
                                                                                       (address %owner)
954
                                                                                       (nat %token_id))
955
                                                                                     (nat %balance))))) ;
956
                                    IF_NONE
957
                                      { PUSH string "FA2_BALANCE_OF_MISSING" ; FAILWITH }
958
                                      {} ;
959
                                    PUSH mutez 0 ;
960
                                    SELF %receive_balance ;
961
                                    DIG 4 ;
962
                                    PAIR ;
963
                                    TRANSFER_TOKENS ;
964
                                    CONS } }
965
                           {} ;
966
                         DUP 4 ;
967
                         UNPAIR ;
968
                         UNPAIR ;
969
                         UNPAIR ;
970
                         SWAP ;
971
                         UNPAIR ;
972
                         SWAP ;
973
                         DUP 8 ;
974
                         CDR ;
975
                         DUP 10 ;
976
                         CAR ;
977
                         CAR ;
978
                         GET 4 ;
979
                         DUP 11 ;
980
                         CAR ;
981
                         GET 3 ;
982
                         CAR ;
983
                         DUP 11 ;
984
                         CAR ;
985
                         GET ;
986
                         IF_NONE { PUSH int 717 ; FAILWITH } {} ;
987
                         GET 10 ;
988
                         SENDER ;
989
                         PAIR ;
990
                         GET ;
991
                         IF_NONE { PUSH nat 0 } {} ;
992
                         ADD ;
993
                         SOME ;
994
                         DIG 9 ;
995
                         CAR ;
996
                         GET 3 ;
997
                         CAR ;
998
                         DUP 10 ;
999
                         CAR ;
1000
                         GET ;
1001
                         IF_NONE { PUSH int 717 ; FAILWITH } {} ;
1002
                         GET 10 ;
1003
                         SENDER ;
1004
                         PAIR ;
1005
                         UPDATE ;
1006
                         SWAP ;
1007
                         PAIR ;
1008
                         SWAP ;
1009
                         PAIR ;
1010
                         PAIR ;
1011
                         PAIR ;
1012
                         DUG 3 ;
1013
                         DUP 4 ;
1014
                         UNPAIR ;
1015
                         SWAP ;
1016
                         UNPAIR ;
1017
                         SWAP ;
1018
                         UNPAIR ;
1019
                         UNPAIR ;
1020
                         DUP 8 ;
1021
                         CDR ;
1022
                         DUP 10 ;
1023
                         GET 5 ;
1024
                         CAR ;
1025
                         DUP 11 ;
1026
                         CAR ;
1027
                         GET 3 ;
1028
                         CAR ;
1029
                         DUP 11 ;
1030
                         CAR ;
1031
                         GET ;
1032
                         IF_NONE { PUSH int 717 ; FAILWITH } {} ;
1033
                         GET 10 ;
1034
                         GET ;
1035
                         IF_NONE { PUSH nat 0 } {} ;
1036
                         ADD ;
1037
                         SOME ;
1038
                         DIG 9 ;
1039
                         CAR ;
1040
                         GET 3 ;
1041
                         CAR ;
1042
                         DUP 10 ;
1043
                         CAR ;
1044
                         GET ;
1045
                         IF_NONE { PUSH int 717 ; FAILWITH } {} ;
1046
                         GET 10 ;
1047
                         UPDATE ;
1048
                         PAIR ;
1049
                         PAIR ;
1050
                         SWAP ;
1051
                         PAIR ;
1052
                         SWAP ;
1053
                         PAIR ;
1054
                         DUG 3 ;
1055
                         PUSH mutez 0 ;
1056
                         DUP 3 ;
1057
                         DUP 6 ;
1058
                         CAR ;
1059
                         GET 3 ;
1060
                         CAR ;
1061
                         DUP 6 ;
1062
                         CAR ;
1063
                         GET ;
1064
                         IF_NONE { PUSH int 717 ; FAILWITH } {} ;
1065
                         CAR ;
1066
                         CAR ;
1067
                         GET 4 ;
1068
                         DUP 6 ;
1069
                         CDR ;
1070
                         MUL ;
1071
                         ADD ;
1072
                         COMPARE ;
1073
                         GT ;
1074
                         IF
1075
                           { PUSH mutez 0 ;
1076
                             DUP 5 ;
1077
                             CAR ;
1078
                             GET 3 ;
1079
                             CAR ;
1080
                             DUP 5 ;
1081
                             CAR ;
1082
                             GET ;
1083
                             IF_NONE { PUSH int 717 ; FAILWITH } {} ;
1084
                             GET 3 ;
1085
                             GET 4 ;
1086
                             ITER { PUSH mutez 0 ;
1087
                                    PUSH nat 10000 ;
1088
                                    DUP 3 ;
1089
                                    CDR ;
1090
                                    DUP 9 ;
1091
                                    CAR ;
1092
                                    GET 3 ;
1093
                                    CAR ;
1094
                                    DUP 9 ;
1095
                                    CAR ;
1096
                                    GET ;
1097
                                    IF_NONE { PUSH int 717 ; FAILWITH } {} ;
1098
                                    CAR ;
1099
                                    CAR ;
1100
                                    GET 4 ;
1101
                                    DUP 9 ;
1102
                                    CDR ;
1103
                                    MUL ;
1104
                                    MUL ;
1105
                                    EDIV ;
1106
                                    IF_NONE { PUSH int 815 ; FAILWITH } {} ;
1107
                                    CAR ;
1108
                                    COMPARE ;
1109
                                    GT ;
1110
                                    IF
1111
                                      { DIG 2 ;
1112
                                        DUP 2 ;
1113
                                        CAR ;
1114
                                        CONTRACT unit ;
1115
                                        IF_NONE { PUSH int 817 ; FAILWITH } {} ;
1116
                                        PUSH nat 10000 ;
1117
                                        DUP 4 ;
1118
                                        CDR ;
1119
                                        DUP 9 ;
1120
                                        CAR ;
1121
                                        GET 3 ;
1122
                                        CAR ;
1123
                                        DUP 9 ;
1124
                                        CAR ;
1125
                                        GET ;
1126
                                        IF_NONE { PUSH int 717 ; FAILWITH } {} ;
1127
                                        CAR ;
1128
                                        CAR ;
1129
                                        GET 4 ;
1130
                                        DUP 9 ;
1131
                                        CDR ;
1132
                                        MUL ;
1133
                                        MUL ;
1134
                                        EDIV ;
1135
                                        IF_NONE { PUSH int 815 ; FAILWITH } {} ;
1136
                                        CAR ;
1137
                                        UNIT ;
1138
                                        TRANSFER_TOKENS ;
1139
                                        CONS ;
1140
                                        DUG 2 ;
1141
                                        SWAP ;
1142
                                        PUSH nat 10000 ;
1143
                                        DIG 2 ;
1144
                                        CDR ;
1145
                                        DUP 7 ;
1146
                                        CAR ;
1147
                                        GET 3 ;
1148
                                        CAR ;
1149
                                        DUP 7 ;
1150
                                        CAR ;
1151
                                        GET ;
1152
                                        IF_NONE { PUSH int 717 ; FAILWITH } {} ;
1153
                                        CAR ;
1154
                                        CAR ;
1155
                                        GET 4 ;
1156
                                        DUP 7 ;
1157
                                        CDR ;
1158
                                        MUL ;
1159
                                        MUL ;
1160
                                        EDIV ;
1161
                                        IF_NONE { PUSH int 815 ; FAILWITH } {} ;
1162
                                        CAR ;
1163
                                        ADD }
1164
                                      { DROP } } ;
1165
                             PUSH mutez 0 ;
1166
                             DUP 2 ;
1167
                             DUP 7 ;
1168
                             CAR ;
1169
                             GET 3 ;
1170
                             CAR ;
1171
                             DUP 7 ;
1172
                             CAR ;
1173
                             GET ;
1174
                             IF_NONE { PUSH int 717 ; FAILWITH } {} ;
1175
                             CAR ;
1176
                             CAR ;
1177
                             GET 4 ;
1178
                             DUP 7 ;
1179
                             CDR ;
1180
                             MUL ;
1181
                             SUB_MUTEZ ;
1182
                             IF_NONE { PUSH int 821 ; FAILWITH } {} ;
1183
                             COMPARE ;
1184
                             GT ;
1185
                             IF
1186
                               { SWAP ;
1187
                                 DUP 5 ;
1188
                                 CAR ;
1189
                                 GET 3 ;
1190
                                 CAR ;
1191
                                 DUP 5 ;
1192
                                 CAR ;
1193
                                 GET ;
1194
                                 IF_NONE { PUSH int 717 ; FAILWITH } {} ;
1195
                                 GET 5 ;
1196
                                 CAR ;
1197
                                 CONTRACT unit ;
1198
                                 IF_NONE { PUSH int 823 ; FAILWITH } {} ;
1199
                                 DIG 2 ;
1200
                                 DUP 6 ;
1201
                                 CAR ;
1202
                                 GET 3 ;
1203
                                 CAR ;
1204
                                 DUP 6 ;
1205
                                 CAR ;
1206
                                 GET ;
1207
                                 IF_NONE { PUSH int 717 ; FAILWITH } {} ;
1208
                                 CAR ;
1209
                                 CAR ;
1210
                                 GET 4 ;
1211
                                 DUP 6 ;
1212
                                 CDR ;
1213
                                 MUL ;
1214
                                 SUB_MUTEZ ;
1215
                                 IF_NONE { PUSH int 821 ; FAILWITH } {} ;
1216
                                 UNIT ;
1217
                                 TRANSFER_TOKENS ;
1218
                                 CONS }
1219
                               { DROP } }
1220
                           {} ;
1221
                         DUP 4 ;
1222
                         CAR ;
1223
                         GET 3 ;
1224
                         CAR ;
1225
                         DUP 4 ;
1226
                         CAR ;
1227
                         GET ;
1228
                         IF_NONE { PUSH int 717 ; FAILWITH } {} ;
1229
                         GET 5 ;
1230
                         CDR ;
1231
                         IF_NONE
1232
                           { SWAP ; DROP }
1233
                           { DROP ;
1234
                             DUP 4 ;
1235
                             CAR ;
1236
                             GET 3 ;
1237
                             CAR ;
1238
                             DUP 4 ;
1239
                             CAR ;
1240
                             GET ;
1241
                             IF_NONE { PUSH int 717 ; FAILWITH } {} ;
1242
                             GET 5 ;
1243
                             CDR ;
1244
                             IF_NONE { PUSH int 745 ; FAILWITH } {} ;
1245
                             ITER { SWAP ;
1246
                                    DUP 2 ;
1247
                                    CAR ;
1248
                                    CONTRACT unit ;
1249
                                    IF_NONE { PUSH int 829 ; FAILWITH } {} ;
1250
                                    DIG 2 ;
1251
                                    CDR ;
1252
                                    DUP 5 ;
1253
                                    CDR ;
1254
                                    MUL ;
1255
                                    UNIT ;
1256
                                    TRANSFER_TOKENS ;
1257
                                    CONS } ;
1258
                             SWAP ;
1259
                             DROP } ;
1260
                         AMOUNT ;
1261
                         DUP 4 ;
1262
                         CAR ;
1263
                         GET 3 ;
1264
                         CAR ;
1265
                         DUP 4 ;
1266
                         CAR ;
1267
                         GET ;
1268
                         IF_NONE { PUSH int 717 ; FAILWITH } {} ;
1269
                         GET 10 ;
1270
                         PAIR ;
1271
                         SENDER ;
1272
                         DIG 3 ;
1273
                         CDR ;
1274
                         PAIR ;
1275
                         PAIR ;
1276
                         EMIT %collect (pair (pair (nat %amount) (address %collector))
1277
                                             (pair (nat %token_id) (mutez %total_paid))) ;
1278
                         CONS } } }
1279
               { IF_LEFT
1280
                   { IF_LEFT
1281
                       { DUP 2 ;
1282
                         GET 3 ;
1283
                         CAR ;
1284
                         CAR ;
1285
                         IF { PUSH string "CONTRACT_PAUSED" ; FAILWITH } {} ;
1286
                         PUSH mutez 0 ;
1287
                         AMOUNT ;
1288
                         COMPARE ;
1289
                         EQ ;
1290
                         IF {} { PUSH string "TEZ_TRANSFER" ; FAILWITH } ;
1291
                         DUP 2 ;
1292
                         GET 9 ;
1293
                         DUP 2 ;
1294
                         GET 8 ;
1295
                         MEM ;
1296
                         IF {} { PUSH string "FA2_TOKEN_UNDEFINED" ; FAILWITH } ;
1297
                         DUP 2 ;
1298
                         GET 7 ;
1299
                         DUP 2 ;
1300
                         GET 8 ;
1301
                         MEM ;
1302
                         IF {} { PUSH string "TOKEN_CREATOR_MISSING" ; FAILWITH } ;
1303
                         DUP 2 ;
1304
                         CAR ;
1305
                         CAR ;
1306
                         CAR ;
1307
                         CDR ;
1308
                         SENDER ;
1309
                         MEM ;
1310
                         IF
1311
                           { PUSH bool True }
1312
                           { DUP 2 ; GET 3 ; GET 6 ; SENDER ; COMPARE ; EQ } ;
1313
                         IF
1314
                           { PUSH bool True }
1315
                           { SENDER ;
1316
                             DUP 3 ;
1317
                             GET 7 ;
1318
                             DUP 3 ;
1319
                             GET 8 ;
1320
                             GET ;
1321
                             IF_NONE { PUSH int 215 ; FAILWITH } {} ;
1322
                             COMPARE ;
1323
                             EQ } ;
1324
                         IF {} { PUSH string "NOT_TOKEN_CREATOR_OR_ADMIN" ; FAILWITH } ;
1325
                         NOW ;
1326
                         DUP 2 ;
1327
                         GET 7 ;
1328
                         COMPARE ;
1329
                         GE ;
1330
                         IF {} { PUSH string "INVALID_START_TIME" ; FAILWITH } ;
1331
                         DUP ;
1332
                         CAR ;
1333
                         CAR ;
1334
                         GET 3 ;
1335
                         IF_NONE
1336
                           {}
1337
                           { DROP ;
1338
                             PUSH nat 3600 ;
1339
                             DUP 2 ;
1340
                             CAR ;
1341
                             CAR ;
1342
                             GET 3 ;
1343
                             IF_NONE { PUSH int 596 ; FAILWITH } {} ;
1344
                             ISNAT ;
1345
                             IF_NONE { PUSH int 596 ; FAILWITH } {} ;
1346
                             COMPARE ;
1347
                             GE ;
1348
                             IF
1349
                               { PUSH nat 2592000 ;
1350
                                 DUP 2 ;
1351
                                 CAR ;
1352
                                 CAR ;
1353
                                 GET 3 ;
1354
                                 IF_NONE { PUSH int 596 ; FAILWITH } {} ;
1355
                                 ISNAT ;
1356
                                 IF_NONE { PUSH int 597 ; FAILWITH } {} ;
1357
                                 COMPARE ;
1358
                                 LE }
1359
                               { PUSH bool False } ;
1360
                             IF {} { PUSH string "INVALID_DURATION" ; FAILWITH } } ;
1361
                         PUSH nat 20 ;
1362
                         DUP 2 ;
1363
                         GET 3 ;
1364
                         GET 4 ;
1365
                         SIZE ;
1366
                         COMPARE ;
1367
                         LE ;
1368
                         IF {} { PUSH string "TOO_MANY_SALE_SPLITS" ; FAILWITH } ;
1369
                         PUSH nat 0 ;
1370
                         EMPTY_SET address ;
1371
                         DUP 3 ;
1372
                         GET 3 ;
1373
                         GET 4 ;
1374
                         ITER { DUP 2 ;
1375
                                DUP 2 ;
1376
                                CAR ;
1377
                                MEM ;
1378
                                IF
1379
                                  { PUSH string "DUPLICATE_SPLIT_ADDRESS" ; FAILWITH }
1380
                                  {} ;
1381
                                PUSH address "KT18amZmM5W7qDWVt2pH6uj7sCEd3kbzLrHT" ;
1382
                                DUP 2 ;
1383
                                CAR ;
1384
                                COMPARE ;
1385
                                LT ;
1386
                                IF
1387
                                  {}
1388
                                  { PUSH string "ONLY_IMPLICIT_ADDRESSES_ALLOWED" ;
1389
                                    FAILWITH } ;
1390
                                SWAP ;
1391
                                PUSH bool True ;
1392
                                DUP 3 ;
1393
                                CAR ;
1394
                                UPDATE ;
1395
                                SWAP ;
1396
                                PUSH nat 0 ;
1397
                                DUP 2 ;
1398
                                CDR ;
1399
                                COMPARE ;
1400
                                GT ;
1401
                                IF
1402
                                  {}
1403
                                  { PUSH string "INVALID_SALE_SPLIT_AMOUNT" ; FAILWITH } ;
1404
                                DIG 2 ;
1405
                                SWAP ;
1406
                                CDR ;
1407
                                ADD ;
1408
                                SWAP } ;
1409
                         PUSH nat 10000 ;
1410
                         DUP 3 ;
1411
                         COMPARE ;
1412
                         EQ ;
1413
                         IF
1414
                           {}
1415
                           { PUSH string "SALE_SPLIT_MUST_BE_100_PERCENT" ; FAILWITH } ;
1416
                         DUP 3 ;
1417
                         GET 5 ;
1418
                         CAR ;
1419
                         IF_NONE
1420
                           {}
1421
                           { DROP 2 ;
1422
                             PUSH nat 10 ;
1423
                             DUP 3 ;
1424
                             GET 5 ;
1425
                             CAR ;
1426
                             IF_NONE { PUSH int 606 ; FAILWITH } {} ;
1427
                             SIZE ;
1428
                             COMPARE ;
1429
                             LE ;
1430
                             IF
1431
                               {}
1432
                               { PUSH string "TOO_MANY_SPECIAL_SPLITS" ; FAILWITH } ;
1433
                             EMPTY_SET address ;
1434
                             DUP 3 ;
1435
                             GET 5 ;
1436
                             CAR ;
1437
                             IF_NONE { PUSH int 606 ; FAILWITH } {} ;
1438
                             ITER { DUP 2 ;
1439
                                    DUP 2 ;
1440
                                    CAR ;
1441
                                    MEM ;
1442
                                    IF
1443
                                      { PUSH string "DUPLICATE_SPLIT_ADDRESS" ; FAILWITH }
1444
                                      {} ;
1445
                                    PUSH address "KT18amZmM5W7qDWVt2pH6uj7sCEd3kbzLrHT" ;
1446
                                    DUP 2 ;
1447
                                    CAR ;
1448
                                    COMPARE ;
1449
                                    LT ;
1450
                                    IF
1451
                                      {}
1452
                                      { PUSH string "ONLY_IMPLICIT_ADDRESSES_ALLOWED" ;
1453
                                        FAILWITH } ;
1454
                                    SWAP ;
1455
                                    PUSH bool True ;
1456
                                    DUP 3 ;
1457
                                    CAR ;
1458
                                    UPDATE ;
1459
                                    SWAP ;
1460
                                    CDR ;
1461
                                    PUSH mutez 0 ;
1462
                                    COMPARE ;
1463
                                    LT ;
1464
                                    IF
1465
                                      {}
1466
                                      { PUSH string "SOME_SPECIAL_SPLIT_IS_ZERO" ;
1467
                                        FAILWITH } } } ;
1468
                         DUP 3 ;
1469
                         GET 3 ;
1470
                         CAR ;
1471
                         IF_NONE
1472
                           {}
1473
                           { DROP ;
1474
                             PUSH nat 0 ;
1475
                             DUP 4 ;
1476
                             GET 3 ;
1477
                             CAR ;
1478
                             IF_NONE { PUSH int 617 ; FAILWITH } {} ;
1479
                             SIZE ;
1480
                             COMPARE ;
1481
                             GT ;
1482
                             IF
1483
                               {}
1484
                               { PUSH string "RESERVE_LIST_CANNOT_BE_EMPTY" ; FAILWITH } ;
1485
                             PUSH nat 100 ;
1486
                             DUP 4 ;
1487
                             GET 3 ;
1488
                             CAR ;
1489
                             IF_NONE { PUSH int 617 ; FAILWITH } {} ;
1490
                             SIZE ;
1491
                             COMPARE ;
1492
                             LE ;
1493
                             IF {} { PUSH string "RESERVE_LIST_TOO_LONG" ; FAILWITH } ;
1494
                             DIG 3 ;
1495
                             UNPAIR ;
1496
                             SWAP ;
1497
                             UNPAIR ;
1498
                             UNPAIR ;
1499
                             SWAP ;
1500
                             UNPAIR ;
1501
                             SWAP ;
1502
                             UNPAIR ;
1503
                             DUP 9 ;
1504
                             GET 3 ;
1505
                             CAR ;
1506
                             IF_NONE { PUSH int 617 ; FAILWITH } {} ;
1507
                             SOME ;
1508
                             DUP 10 ;
1509
                             GET 8 ;
1510
                             UPDATE ;
1511
                             PAIR ;
1512
                             SWAP ;
1513
                             PAIR ;
1514
                             SWAP ;
1515
                             PAIR ;
1516
                             PAIR ;
1517
                             SWAP ;
1518
                             PAIR ;
1519
                             DUG 3 } ;
1520
                         DUP 3 ;
1521
                         GET 3 ;
1522
                         GET 3 ;
1523
                         IF_NONE
1524
                           {}
1525
                           { DROP ;
1526
                             PUSH int 0 ;
1527
                             DUP 4 ;
1528
                             GET 3 ;
1529
                             GET 3 ;
1530
                             IF_NONE { PUSH int 624 ; FAILWITH } {} ;
1531
                             COMPARE ;
1532
                             GT ;
1533
                             IF {} { PUSH string "INVALID_RESERVE_PERIOD" ; FAILWITH } ;
1534
                             DUP 3 ;
1535
                             CAR ;
1536
                             CAR ;
1537
                             GET 3 ;
1538
                             IF_NONE
1539
                               {}
1540
                               { DROP ;
1541
                                 DUP 3 ;
1542
                                 CAR ;
1543
                                 CAR ;
1544
                                 GET 3 ;
1545
                                 IF_NONE { PUSH int 596 ; FAILWITH } {} ;
1546
                                 DUP 4 ;
1547
                                 GET 3 ;
1548
                                 GET 3 ;
1549
                                 IF_NONE { PUSH int 624 ; FAILWITH } {} ;
1550
                                 COMPARE ;
1551
                                 LE ;
1552
                                 IF
1553
                                   {}
1554
                                   { PUSH string "RESERVE_PERIOD_LONGER_AS_DURATION" ;
1555
                                     FAILWITH } } ;
1556
                             DUP 3 ;
1557
                             GET 3 ;
1558
                             CAR ;
1559
                             IF_NONE
1560
                               { PUSH string "RESERVE_PERIOD_REQUIRES_RESERVE_LIST" ;
1561
                                 FAILWITH }
1562
                               { DROP } } ;
1563
                         PUSH nat 20 ;
1564
                         DUP 4 ;
1565
                         CAR ;
1566
                         GET 3 ;
1567
                         CDR ;
1568
                         SIZE ;
1569
                         COMPARE ;
1570
                         LE ;
1571
                         IF {} { PUSH string "GATE_LIST_TOO_LONG" ; FAILWITH } ;
1572
                         DUP 3 ;
1573
                         CAR ;
1574
                         GET 3 ;
1575
                         CAR ;
1576
                         IF
1577
                           { PUSH nat 0 ;
1578
                             DUP 4 ;
1579
                             CAR ;
1580
                             GET 3 ;
1581
                             CDR ;
1582
                             SIZE ;
1583
                             COMPARE ;
1584
                             GT ;
1585
                             IF {} { PUSH string "GATE_TOKENS_REQUIRED" ; FAILWITH } ;
1586
                             DUP 3 ;
1587
                             CAR ;
1588
                             GET 3 ;
1589
                             CDR ;
1590
                             ITER { PUSH nat 0 ;
1591
                                    DUP 2 ;
1592
                                    CDR ;
1593
                                    SIZE ;
1594
                                    COMPARE ;
1595
                                    GT ;
1596
                                    IF
1597
                                      {}
1598
                                      { PUSH string "TOKEN_REQS_REQUIRED" ; FAILWITH } ;
1599
                                    DUP ;
1600
                                    CDR ;
1601
                                    ITER { CDR ;
1602
                                           PUSH nat 0 ;
1603
                                           COMPARE ;
1604
                                           LT ;
1605
                                           IF
1606
                                             {}
1607
                                             { PUSH string "INVALID_MIN_BALANCE" ;
1608
                                               FAILWITH } } ;
1609
                                    DROP } }
1610
                           {} ;
1611
                         DUP 3 ;
1612
                         CAR ;
1613
                         CAR ;
1614
                         CAR ;
1615
                         IF_NONE
1616
                           { DROP 2 }
1617
                           { DROP ;
1618
                             PUSH nat 20 ;
1619
                             DUP 4 ;
1620
                             CAR ;
1621
                             CAR ;
1622
                             CAR ;
1623
                             IF_NONE { PUSH int 648 ; FAILWITH } {} ;
1624
                             SIZE ;
1625
                             COMPARE ;
1626
                             LE ;
1627
                             IF {} { PUSH string "BURN_LIST_TOO_LONG" ; FAILWITH } ;
1628
                             DUP 3 ;
1629
                             CAR ;
1630
                             CAR ;
1631
                             CAR ;
1632
                             IF_NONE { PUSH int 648 ; FAILWITH } {} ;
1633
                             ITER { GET 4 ;
1634
                                    PUSH nat 0 ;
1635
                                    COMPARE ;
1636
                                    LT ;
1637
                                    IF
1638
                                      {}
1639
                                      { PUSH string "BURN_AMOUNT_MUST_BE_POSITIVE" ;
1640
                                        FAILWITH } } ;
1641
                             DROP 2 } ;
1642
                         SWAP ;
1643
                         UNPAIR ;
1644
                         UNPAIR ;
1645
                         SWAP ;
1646
                         UNPAIR ;
1647
                         UNPAIR ;
1648
                         DUP 6 ;
1649
                         GET 8 ;
1650
                         DUP 7 ;
1651
                         GET 7 ;
1652
                         PAIR ;
1653
                         DUP 7 ;
1654
                         GET 5 ;
1655
                         CDR ;
1656
                         PAIR ;
1657
                         DUP 7 ;
1658
                         GET 5 ;
1659
                         CAR ;
1660
                         SENDER ;
1661
                         PAIR ;
1662
                         PAIR ;
1663
                         DUP 7 ;
1664
                         GET 3 ;
1665
                         GET 4 ;
1666
                         DUP 8 ;
1667
                         GET 3 ;
1668
                         GET 3 ;
1669
                         PAIR ;
1670
                         DUP 8 ;
1671
                         CAR ;
1672
                         GET 6 ;
1673
                         DUP 9 ;
1674
                         CAR ;
1675
                         GET 5 ;
1676
                         PAIR ;
1677
                         PAIR ;
1678
                         PAIR ;
1679
                         DUP 7 ;
1680
                         GET 3 ;
1681
                         CAR ;
1682
                         IF_NONE { PUSH bool False } { DROP ; PUSH bool True } ;
1683
                         DUP 8 ;
1684
                         CAR ;
1685
                         GET 3 ;
1686
                         CDR ;
1687
                         PAIR ;
1688
                         DUP 8 ;
1689
                         CAR ;
1690
                         GET 3 ;
1691
                         CAR ;
1692
                         PUSH nat 0 ;
1693
                         PAIR ;
1694
                         PAIR ;
1695
                         DUP 8 ;
1696
                         CAR ;
1697
                         CAR ;
1698
                         GET 4 ;
1699
                         NONE timestamp ;
1700
                         PAIR ;
1701
                         DUP 9 ;
1702
                         CAR ;
1703
                         CAR ;
1704
                         GET 3 ;
1705
                         DUP 10 ;
1706
                         CAR ;
1707
                         CAR ;
1708
                         CAR ;
1709
                         PAIR ;
1710
                         PAIR ;
1711
                         PAIR ;
1712
                         PAIR ;
1713
                         SOME ;
1714
                         DUP 7 ;
1715
                         GET 8 ;
1716
                         UPDATE ;
1717
                         PAIR ;
1718
                         PAIR ;
1719
                         SWAP ;
1720
                         PAIR ;
1721
                         PAIR ;
1722
                         SWAP ;
1723
                         NIL operation ;
1724
                         DUP 2 ;
1725
                         GET 8 ;
1726
                         DUP 3 ;
1727
                         GET 7 ;
1728
                         PAIR ;
1729
                         SENDER ;
1730
                         PAIR ;
1731
                         DIG 2 ;
1732
                         DUP ;
1733
                         CAR ;
1734
                         CAR ;
1735
                         GET 4 ;
1736
                         SWAP ;
1737
                         CAR ;
1738
                         CAR ;
1739
                         GET 3 ;
1740
                         PAIR ;
1741
                         PAIR ;
1742
                         EMIT %listing_created (pair
1743
                                                 (pair (option %duration int)
1744
                                                       (mutez %edition_price))
1745
                                                 (pair (address %seller)
1746
                                                       (pair (timestamp %start_time)
1747
                                                             (nat %token_id)))) ;
1748
                         CONS }
1749
                       { PUSH mutez 0 ;
1750
                         AMOUNT ;
1751
                         COMPARE ;
1752
                         EQ ;
1753
                         IF {} { PUSH string "TEZ_TRANSFER" ; FAILWITH } ;
1754
                         DUP 2 ;
1755
                         GET 3 ;
1756
                         CAR ;
1757
                         CAR ;
1758
                         IF { PUSH string "CONTRACT_PAUSED" ; FAILWITH } {} ;
1759
                         DUP 2 ;
1760
                         CAR ;
1761
                         CAR ;
1762
                         GET 3 ;
1763
                         SENDER ;
1764
                         MEM ;
1765
                         IF
1766
                           { PUSH bool True }
1767
                           { DUP 2 ; CAR ; CAR ; CAR ; CDR ; SENDER ; MEM } ;
1768
                         IF
1769
                           { PUSH bool True }
1770
                           { DUP 2 ; GET 3 ; GET 6 ; SENDER ; COMPARE ; EQ } ;
1771
                         IF {} { PUSH string "NOT_ALLOWED" ; FAILWITH } ;
1772
                         PUSH nat 30 ;
1773
                         DUP 2 ;
1774
                         SIZE ;
1775
                         COMPARE ;
1776
                         LE ;
1777
                         IF {} { PUSH string "TOO_MANY_TOKENS_IN_BATCH" ; FAILWITH } ;
1778
                         NIL operation ;
1779
                         DUP 2 ;
1780
                         ITER { PUSH nat 20 ;
1781
                                DUP 2 ;
1782
                                CDR ;
1783
                                SIZE ;
1784
                                COMPARE ;
1785
                                LE ;
1786
                                IF
1787
                                  {}
1788
                                  { PUSH string "TOO_MANY_ROYALTY_RECIPIENTS" ; FAILWITH } ;
1789
                                PUSH nat 0 ;
1790
                                EMPTY_SET address ;
1791
                                DUP 3 ;
1792
                                CDR ;
1793
                                ITER { DUP 2 ;
1794
                                       DUP 2 ;
1795
                                       CAR ;
1796
                                       MEM ;
1797
                                       IF
1798
                                         { PUSH string "DUPLICATE_SPLIT_ADDRESS" ;
1799
                                           FAILWITH }
1800
                                         {} ;
1801
                                       PUSH address "KT18amZmM5W7qDWVt2pH6uj7sCEd3kbzLrHT" ;
1802
                                       DUP 2 ;
1803
                                       CAR ;
1804
                                       COMPARE ;
1805
                                       LT ;
1806
                                       IF
1807
                                         {}
1808
                                         { PUSH string "ONLY_IMPLICIT_ADDRESSES_ALLOWED" ;
1809
                                           FAILWITH } ;
1810
                                       SWAP ;
1811
                                       PUSH bool True ;
1812
                                       DUP 3 ;
1813
                                       CAR ;
1814
                                       UPDATE ;
1815
                                       SWAP ;
1816
                                       DIG 2 ;
1817
                                       SWAP ;
1818
                                       CDR ;
1819
                                       ADD ;
1820
                                       SWAP } ;
1821
                                DROP ;
1822
                                PUSH nat 10000 ;
1823
                                SWAP ;
1824
                                COMPARE ;
1825
                                LE ;
1826
                                IF
1827
                                  {}
1828
                                  { PUSH string "ROYALTIES_EXCEED_MAX_PERCENTAGE" ;
1829
                                    FAILWITH } ;
1830
                                DUP 4 ;
1831
                                CAR ;
1832
                                GET 7 ;
1833
                                DIG 4 ;
1834
                                DUP ;
1835
                                GET 9 ;
1836
                                DUP 4 ;
1837
                                CAR ;
1838
                                DUP 4 ;
1839
                                PAIR ;
1840
                                SOME ;
1841
                                DUP 4 ;
1842
                                UPDATE ;
1843
                                UPDATE 9 ;
1844
                                DUP ;
1845
                                GET 10 ;
1846
                                DUP 4 ;
1847
                                CDR ;
1848
                                SOME ;
1849
                                DUP 4 ;
1850
                                UPDATE ;
1851
                                UPDATE 10 ;
1852
                                DUP ;
1853
                                GET 7 ;
1854
                                SENDER ;
1855
                                SOME ;
1856
                                DUP 4 ;
1857
                                UPDATE ;
1858
                                UPDATE 7 ;
1859
                                UNPAIR ;
1860
                                UNPAIR ;
1861
                                SWAP ;
1862
                                UNPAIR ;
1863
                                SWAP ;
1864
                                UNPAIR ;
1865
                                SWAP ;
1866
                                UNPAIR ;
1867
                                PUSH nat 1 ;
1868
                                ADD ;
1869
                                PAIR ;
1870
                                SWAP ;
1871
                                PAIR ;
1872
                                SWAP ;
1873
                                PAIR ;
1874
                                SWAP ;
1875
                                PAIR ;
1876
                                PAIR ;
1877
                                DUG 4 ;
1878
                                DIG 2 ;
1879
                                SWAP ;
1880
                                DUP 3 ;
1881
                                CDR ;
1882
                                PAIR ;
1883
                                DIG 2 ;
1884
                                CAR ;
1885
                                SENDER ;
1886
                                PAIR ;
1887
                                PAIR ;
1888
                                EMIT %create_tokens (pair
1889
                                                      (pair (address %creator)
1890
                                                            (map %metadata string bytes))
1891
                                                      (pair
1892
                                                        (list %royalties (pair
1893
                                                                          (address %address)
1894
                                                                          (nat %royalties)))
1895
                                                        (nat %token_id))) ;
1896
                                CONS } ;
1897
                         SWAP ;
1898
                         DROP } }
1899
                   { IF_LEFT
1900
                       { PUSH mutez 0 ;
1901
                         AMOUNT ;
1902
                         COMPARE ;
1903
                         EQ ;
1904
                         IF {} { PUSH string "TEZ_TRANSFER" ; FAILWITH } ;
1905
                         NIL operation ;
1906
                         DUP 2 ;
1907
                         ITER { DUP 4 ;
1908
                                GET 9 ;
1909
                                DUP 2 ;
1910
                                CAR ;
1911
                                MEM ;
1912
                                IF {} { PUSH string "FA2_TOKEN_UNDEFINED" ; FAILWITH } ;
1913
                                DUP 4 ;
1914
                                GET 9 ;
1915
                                DUP 2 ;
1916
                                CAR ;
1917
                                MEM ;
1918
                                IF {} { PUSH string "FA2_TOKEN_UNDEFINED" ; FAILWITH } ;
1919
                                DUP 4 ;
1920
                                GET 7 ;
1921
                                DUP 2 ;
1922
                                CAR ;
1923
                                MEM ;
1924
                                IF
1925
                                  {}
1926
                                  { PUSH string "TOKEN_CREATOR_MISSING" ; FAILWITH } ;
1927
                                DUP 4 ;
1928
                                CAR ;
1929
                                CAR ;
1930
                                CAR ;
1931
                                CDR ;
1932
                                SENDER ;
1933
                                MEM ;
1934
                                IF
1935
                                  { PUSH bool True }
1936
                                  { DUP 4 ; GET 3 ; GET 6 ; SENDER ; COMPARE ; EQ } ;
1937
                                IF
1938
                                  { PUSH bool True }
1939
                                  { SENDER ;
1940
                                    DUP 5 ;
1941
                                    GET 7 ;
1942
                                    DUP 3 ;
1943
                                    CAR ;
1944
                                    GET ;
1945
                                    IF_NONE { PUSH int 215 ; FAILWITH } {} ;
1946
                                    COMPARE ;
1947
                                    EQ } ;
1948
                                IF
1949
                                  {}
1950
                                  { PUSH string "NOT_TOKEN_CREATOR_OR_ADMIN" ; FAILWITH } ;
1951
                                DUP ;
1952
                                CDR ;
1953
                                ITER { DUP 5 ;
1954
                                       UNPAIR ;
1955
                                       UNPAIR ;
1956
                                       UNPAIR ;
1957
                                       SWAP ;
1958
                                       UNPAIR ;
1959
                                       SWAP ;
1960
                                       DUP 6 ;
1961
                                       CDR ;
1962
                                       DIG 10 ;
1963
                                       CAR ;
1964
                                       CAR ;
1965
                                       GET 4 ;
1966
                                       DUP 9 ;
1967
                                       CAR ;
1968
                                       DUP 9 ;
1969
                                       CAR ;
1970
                                       PAIR ;
1971
                                       GET ;
1972
                                       IF_NONE { PUSH nat 0 } {} ;
1973
                                       ADD ;
1974
                                       SOME ;
1975
                                       DUP 8 ;
1976
                                       CAR ;
1977
                                       DUP 8 ;
1978
                                       CAR ;
1979
                                       PAIR ;
1980
                                       UPDATE ;
1981
                                       SWAP ;
1982
                                       PAIR ;
1983
                                       SWAP ;
1984
                                       PAIR ;
1985
                                       PAIR ;
1986
                                       PAIR ;
1987
                                       DUG 4 ;
1988
                                       DUP 5 ;
1989
                                       UNPAIR ;
1990
                                       SWAP ;
1991
                                       UNPAIR ;
1992
                                       SWAP ;
1993
                                       UNPAIR ;
1994
                                       UNPAIR ;
1995
                                       DUP 6 ;
1996
                                       CDR ;
1997
                                       DIG 10 ;
1998
                                       GET 5 ;
1999
                                       CAR ;
2000
                                       DUP 9 ;
2001
                                       CAR ;
2002
                                       GET ;
2003
                                       IF_NONE { PUSH nat 0 } {} ;
2004
                                       ADD ;
2005
                                       SOME ;
2006
                                       DUP 8 ;
2007
                                       CAR ;
2008
                                       UPDATE ;
2009
                                       PAIR ;
2010
                                       PAIR ;
2011
                                       SWAP ;
2012
                                       PAIR ;
2013
                                       SWAP ;
2014
                                       PAIR ;
2015
                                       DUG 4 ;
2016
                                       DIG 2 ;
2017
                                       DUP 3 ;
2018
                                       CAR ;
2019
                                       DUP 3 ;
2020
                                       CAR ;
2021
                                       PAIR ;
2022
                                       SENDER ;
2023
                                       DIG 3 ;
2024
                                       CDR ;
2025
                                       PAIR ;
2026
                                       PAIR ;
2027
                                       EMIT %mint (pair
2028
                                                    (pair (nat %amount)
2029
                                                          (address %minter))
2030
                                                    (pair (address %recipient)
2031
                                                          (nat %token_id))) ;
2032
                                       CONS ;
2033
                                       SWAP } ;
2034
                                DROP } ;
2035
                         SWAP ;
2036
                         DROP }
2037
                       { IF_LEFT
2038
                           { PUSH mutez 0 ;
2039
                             AMOUNT ;
2040
                             COMPARE ;
2041
                             EQ ;
2042
                             IF {} { PUSH string "TEZ_TRANSFER" ; FAILWITH } ;
2043
                             DUP 2 ;
2044
                             GET 3 ;
2045
                             GET 6 ;
2046
                             SENDER ;
2047
                             COMPARE ;
2048
                             EQ ;
2049
                             IF {} { PUSH string "NOT_SUPERADMIN" ; FAILWITH } ;
2050
                             SWAP ;
2051
                             UNPAIR ;
2052
                             SWAP ;
2053
                             UNPAIR ;
2054
                             UNPAIR ;
2055
                             SWAP ;
2056
                             CDR ;
2057
                             DUP 5 ;
2058
                             SOME ;
2059
                             PAIR ;
2060
                             SWAP ;
2061
                             PAIR ;
2062
                             PAIR ;
2063
                             SWAP ;
2064
                             PAIR ;
2065
                             SWAP ;
2066
                             NIL operation ;
2067
                             SWAP ;
2068
                             DUP 3 ;
2069
                             GET 3 ;
2070
                             GET 6 ;
2071
                             PAIR ;
2072
                             EMIT %superadmin_proposed (pair
2073
                                                         (address %current_superadmin)
2074
                                                         (address %proposed_superadmin)) ;
2075
                             CONS }
2076
                           { PUSH nat 1 ;
2077
                             DUP 2 ;
2078
                             SIZE ;
2079
                             COMPARE ;
2080
                             GE ;
2081
                             IF {} { PUSH string "NO_RESPONSES" ; FAILWITH } ;
2082
                             NONE address ;
2083
                             DUP 2 ;
2084
                             ITER { DUP 2 ;
2085
                                    IF_NONE
2086
                                      { SWAP ; DROP ; CAR ; CAR ; SOME }
2087
                                      { DROP 2 } } ;
2088
                             DUP ;
2089
                             IF_NONE { PUSH string "NO_OWNER" ; FAILWITH } { DROP } ;
2090
                             DUP 3 ;
2091
                             GET 3 ;
2092
                             CAR ;
2093
                             CDR ;
2094
                             DUP 2 ;
2095
                             IF_NONE { PUSH int 981 ; FAILWITH } {} ;
2096
                             MEM ;
2097
                             IF {} { PUSH string "NO_PENDING" ; FAILWITH } ;
2098
                             PUSH bool False ;
2099
                             DUP 3 ;
2100
                             ITER { DUP 5 ;
2101
                                    GET 3 ;
2102
                                    CAR ;
2103
                                    CDR ;
2104
                                    DUP 4 ;
2105
                                    IF_NONE { PUSH int 981 ; FAILWITH } {} ;
2106
                                    GET ;
2107
                                    IF_NONE { PUSH int 983 ; FAILWITH } {} ;
2108
                                    GET 3 ;
2109
                                    ITER { SENDER ;
2110
                                           DUP 2 ;
2111
                                           CAR ;
2112
                                           COMPARE ;
2113
                                           EQ ;
2114
                                           IF
2115
                                             { DUP ;
2116
                                               CDR ;
2117
                                               ITER { DUP ;
2118
                                                      CAR ;
2119
                                                      DUP 4 ;
2120
                                                      CAR ;
2121
                                                      CDR ;
2122
                                                      COMPARE ;
2123
                                                      EQ ;
2124
                                                      IF
2125
                                                        { DUP ;
2126
                                                          CDR ;
2127
                                                          DUP 4 ;
2128
                                                          CDR ;
2129
                                                          COMPARE ;
2130
                                                          GE ;
2131
                                                          IF
2132
                                                            { DIG 3 ;
2133
                                                              DROP 2 ;
2134
                                                              PUSH bool True ;
2135
                                                              DUG 2 }
2136
                                                            { DROP } }
2137
                                                        { DROP } } ;
2138
                                               DROP }
2139
                                             { DROP } } ;
2140
                                    DROP } ;
2141
                             PUSH nat 1 ;
2142
                             DUP 5 ;
2143
                             GET 3 ;
2144
                             CAR ;
2145
                             CDR ;
2146
                             DUP 4 ;
2147
                             IF_NONE { PUSH int 981 ; FAILWITH } {} ;
2148
                             GET ;
2149
                             IF_NONE { PUSH int 983 ; FAILWITH } {} ;
2150
                             GET 4 ;
2151
                             SUB ;
2152
                             ISNAT ;
2153
                             IF_NONE { PUSH int 997 ; FAILWITH } {} ;
2154
                             DIG 4 ;
2155
                             UNPAIR ;
2156
                             SWAP ;
2157
                             UNPAIR ;
2158
                             UNPAIR ;
2159
                             UNPAIR ;
2160
                             SWAP ;
2161
                             DUP ;
2162
                             DUP 9 ;
2163
                             IF_NONE { PUSH int 981 ; FAILWITH } {} ;
2164
                             DUP ;
2165
                             DUG 2 ;
2166
                             GET ;
2167
                             IF_NONE { PUSH int 997 ; FAILWITH } {} ;
2168
                             DIG 7 ;
2169
                             UPDATE 4 ;
2170
                             SOME ;
2171
                             SWAP ;
2172
                             UPDATE ;
2173
                             SWAP ;
2174
                             PAIR ;
2175
                             PAIR ;
2176
                             PAIR ;
2177
                             SWAP ;
2178
                             PAIR ;
2179
                             DUG 3 ;
2180
                             DUP ;
2181
                             IF
2182
                               { DIG 3 ;
2183
                                 UNPAIR ;
2184
                                 SWAP ;
2185
                                 UNPAIR ;
2186
                                 UNPAIR ;
2187
                                 UNPAIR ;
2188
                                 SWAP ;
2189
                                 DUP ;
2190
                                 DUP 8 ;
2191
                                 IF_NONE { PUSH int 981 ; FAILWITH } {} ;
2192
                                 DUP ;
2193
                                 DUG 2 ;
2194
                                 GET ;
2195
                                 IF_NONE { PUSH int 1002 ; FAILWITH } {} ;
2196
                                 NIL (pair address (list (pair nat nat))) ;
2197
                                 UPDATE 3 ;
2198
                                 SOME ;
2199
                                 SWAP ;
2200
                                 UPDATE ;
2201
                                 SWAP ;
2202
                                 PAIR ;
2203
                                 PAIR ;
2204
                                 PAIR ;
2205
                                 SWAP ;
2206
                                 PAIR ;
2207
                                 DUG 3 }
2208
                               {} ;
2209
                             PUSH nat 0 ;
2210
                             DUP 5 ;
2211
                             GET 3 ;
2212
                             CAR ;
2213
                             CDR ;
2214
                             DUP 4 ;
2215
                             IF_NONE { PUSH int 981 ; FAILWITH } {} ;
2216
                             GET ;
2217
                             IF_NONE { PUSH int 983 ; FAILWITH } {} ;
2218
                             GET 4 ;
2219
                             COMPARE ;
2220
                             EQ ;
2221
                             IF
2222
                               { PUSH nat 0 ;
2223
                                 DUP 5 ;
2224
                                 GET 3 ;
2225
                                 CAR ;
2226
                                 CDR ;
2227
                                 DUP 4 ;
2228
                                 IF_NONE { PUSH int 981 ; FAILWITH } {} ;
2229
                                 GET ;
2230
                                 IF_NONE { PUSH int 983 ; FAILWITH } {} ;
2231
                                 GET 3 ;
2232
                                 SIZE ;
2233
                                 COMPARE ;
2234
                                 EQ ;
2235
                                 IF
2236
                                   { DROP ;
2237
                                     SWAP ;
2238
                                     DROP ;
2239
                                     SWAP ;
2240
                                     UNPAIR ;
2241
                                     SWAP ;
2242
                                     UNPAIR ;
2243
                                     UNPAIR ;
2244
                                     UNPAIR ;
2245
                                     SWAP ;
2246
                                     NONE (pair address
2247
                                                (pair
2248
                                                  (list (pair address
2249
                                                             (list (pair nat nat))))
2250
                                                  nat)) ;
2251
                                     DIG 6 ;
2252
                                     IF_NONE { PUSH int 981 ; FAILWITH } {} ;
2253
                                     UPDATE ;
2254
                                     SWAP ;
2255
                                     PAIR ;
2256
                                     PAIR ;
2257
                                     PAIR ;
2258
                                     SWAP ;
2259
                                     PAIR }
2260
                                   { DIG 3 ;
2261
                                     UNPAIR ;
2262
                                     SWAP ;
2263
                                     UNPAIR ;
2264
                                     UNPAIR ;
2265
                                     UNPAIR ;
2266
                                     SWAP ;
2267
                                     NONE (pair address
2268
                                                (pair
2269
                                                  (list (pair address
2270
                                                             (list (pair nat nat))))
2271
                                                  nat)) ;
2272
                                     DUP 8 ;
2273
                                     IF_NONE { PUSH int 981 ; FAILWITH } {} ;
2274
                                     PUSH string "GATE_BALANCE_LOW" ;
2275
                                     FAILWITH } }
2276
                               { DROP ;
2277
                                 SWAP ;
2278
                                 DROP ;
2279
                                 DUP 2 ;
2280
                                 UNPAIR ;
2281
                                 SWAP ;
2282
                                 UNPAIR ;
2283
                                 UNPAIR ;
2284
                                 UNPAIR ;
2285
                                 SWAP ;
2286
                                 DIG 6 ;
2287
                                 GET 3 ;
2288
                                 CAR ;
2289
                                 CDR ;
2290
                                 DUP 7 ;
2291
                                 IF_NONE { PUSH int 981 ; FAILWITH } {} ;
2292
                                 GET ;
2293
                                 IF_NONE { PUSH int 983 ; FAILWITH } {} ;
2294
                                 SOME ;
2295
                                 DIG 6 ;
2296
                                 IF_NONE { PUSH int 981 ; FAILWITH } {} ;
2297
                                 UPDATE ;
2298
                                 SWAP ;
2299
                                 PAIR ;
2300
                                 PAIR ;
2301
                                 PAIR ;
2302
                                 SWAP ;
2303
                                 PAIR } ;
2304
                             NIL operation } } } } }
2305
           { IF_LEFT
2306
               { IF_LEFT
2307
                   { IF_LEFT
2308
                       { PUSH mutez 0 ;
2309
                         AMOUNT ;
2310
                         COMPARE ;
2311
                         EQ ;
2312
                         IF {} { PUSH string "TEZ_TRANSFER" ; FAILWITH } ;
2313
                         DUP 2 ;
2314
                         CAR ;
2315
                         CAR ;
2316
                         CAR ;
2317
                         CDR ;
2318
                         SENDER ;
2319
                         MEM ;
2320
                         IF
2321
                           { PUSH bool True }
2322
                           { DUP 2 ; GET 3 ; GET 6 ; SENDER ; COMPARE ; EQ } ;
2323
                         IF {} { PUSH string "NOT_ADMIN" ; FAILWITH } ;
2324
                         DUP ;
2325
                         ITER { DIG 2 ;
2326
                                UNPAIR ;
2327
                                UNPAIR ;
2328
                                SWAP ;
2329
                                UNPAIR ;
2330
                                SWAP ;
2331
                                UNPAIR ;
2332
                                DUP 6 ;
2333
                                CDR ;
2334
                                SOME ;
2335
                                DIG 6 ;
2336
                                CAR ;
2337
                                UPDATE ;
2338
                                PAIR ;
2339
                                SWAP ;
2340
                                PAIR ;
2341
                                SWAP ;
2342
                                PAIR ;
2343
                                PAIR ;
2344
                                SWAP } ;
2345
                         DROP ;
2346
                         NIL operation ;
2347
                         SENDER ;
2348
                         EMIT %metadata_updated address ;
2349
                         CONS }
2350
                       { PUSH mutez 0 ;
2351
                         AMOUNT ;
2352
                         COMPARE ;
2353
                         EQ ;
2354
                         IF {} { PUSH string "TEZ_TRANSFER" ; FAILWITH } ;
2355
                         DUP 2 ;
2356
                         CAR ;
2357
                         CAR ;
2358
                         CAR ;
2359
                         CDR ;
2360
                         SENDER ;
2361
                         MEM ;
2362
                         IF
2363
                           { PUSH bool True }
2364
                           { DUP 2 ; GET 3 ; GET 6 ; SENDER ; COMPARE ; EQ } ;
2365
                         IF {} { PUSH string "NOT_ADMIN" ; FAILWITH } ;
2366
                         SWAP ;
2367
                         UNPAIR ;
2368
                         SWAP ;
2369
                         UNPAIR ;
2370
                         UNPAIR ;
2371
                         CDR ;
2372
                         DUP 5 ;
2373
                         PAIR ;
2374
                         PAIR ;
2375
                         PAIR ;
2376
                         SWAP ;
2377
                         PAIR ;
2378
                         SWAP ;
2379
                         NIL operation ;
2380
                         SENDER ;
2381
                         DIG 2 ;
2382
                         PAIR ;
2383
                         EMIT %contract_paused (pair (bool %paused)
2384
                                                     (address %updated_by)) ;
2385
                         CONS } }
2386
                   { IF_LEFT
2387
                       { DUP ;
2388
                         ITER { DUP ;
2389
                                CDR ;
2390
                                ITER { DUP 4 ;
2391
                                       CAR ;
2392
                                       CAR ;
2393
                                       CAR ;
2394
                                       CAR ;
2395
                                       DUP 2 ;
2396
                                       GET 3 ;
2397
                                       DUP 3 ;
2398
                                       CAR ;
2399
                                       PAIR ;
2400
                                       MEM ;
2401
                                       IF
2402
                                         { PUSH string "RESTRICTED_OPERATOR" ; FAILWITH }
2403
                                         {} ;
2404
                                       DUP 4 ;
2405
                                       GET 5 ;
2406
                                       CDR ;
2407
                                       DUP 2 ;
2408
                                       GET 3 ;
2409
                                       DUP 3 ;
2410
                                       CAR ;
2411
                                       PAIR ;
2412
                                       MEM ;
2413
                                       IF
2414
                                         { DUP 4 ;
2415
                                           CAR ;
2416
                                           GET 3 ;
2417
                                           CAR ;
2418
                                           DUP 2 ;
2419
                                           GET 3 ;
2420
                                           MEM ;
2421
                                           IF
2422
                                             { DUP 4 ;
2423
                                               CAR ;
2424
                                               GET 3 ;
2425
                                               CAR ;
2426
                                               DUP 2 ;
2427
                                               GET 3 ;
2428
                                               GET ;
2429
                                               IF_NONE { PUSH int 858 ; FAILWITH } {} ;
2430
                                               GET 9 ;
2431
                                               NOW ;
2432
                                               COMPARE ;
2433
                                               GE ;
2434
                                               IF
2435
                                                 {}
2436
                                                 { PUSH string "SALE_NOT_STARTED_YET" ;
2437
                                                   FAILWITH } ;
2438
                                               DUP 4 ;
2439
                                               CAR ;
2440
                                               GET 3 ;
2441
                                               CAR ;
2442
                                               DUP 2 ;
2443
                                               GET 3 ;
2444
                                               GET ;
2445
                                               IF_NONE { PUSH int 858 ; FAILWITH } {} ;
2446
                                               CAR ;
2447
                                               CAR ;
2448
                                               CAR ;
2449
                                               CDR ;
2450
                                               IF_NONE
2451
                                                 { PUSH string "PERPETUAL_SALE_ACTIVE" ;
2452
                                                   FAILWITH }
2453
                                                 { DROP ;
2454
                                                   DUP 4 ;
2455
                                                   CAR ;
2456
                                                   GET 3 ;
2457
                                                   CAR ;
2458
                                                   DUP 2 ;
2459
                                                   GET 3 ;
2460
                                                   GET ;
2461
                                                   IF_NONE
2462
                                                     { PUSH int 858 ; FAILWITH }
2463
                                                     {} ;
2464
                                                   GET 7 ;
2465
                                                   IF
2466
                                                     { DUP 4 ;
2467
                                                       CAR ;
2468
                                                       GET 3 ;
2469
                                                       CAR ;
2470
                                                       DUP 2 ;
2471
                                                       GET 3 ;
2472
                                                       GET ;
2473
                                                       IF_NONE
2474
                                                         { PUSH int 858 ; FAILWITH }
2475
                                                         {} ;
2476
                                                       CAR ;
2477
                                                       CAR ;
2478
                                                       GET 3 ;
2479
                                                       IF_NONE
2480
                                                         { PUSH string "SALE_NOT_PROPERLY_STARTED" ;
2481
                                                           FAILWITH }
2482
                                                         { DROP ;
2483
                                                           DUP 4 ;
2484
                                                           CAR ;
2485
                                                           GET 3 ;
2486
                                                           CAR ;
2487
                                                           DUP 2 ;
2488
                                                           GET 3 ;
2489
                                                           GET ;
2490
                                                           IF_NONE
2491
                                                             { PUSH int 858 ; FAILWITH }
2492
                                                             {} ;
2493
                                                           CAR ;
2494
                                                           CAR ;
2495
                                                           CAR ;
2496
                                                           CDR ;
2497
                                                           IF_NONE
2498
                                                             { PUSH int 275 ; FAILWITH }
2499
                                                             {} ;
2500
                                                           DUP 5 ;
2501
                                                           CAR ;
2502
                                                           GET 3 ;
2503
                                                           CAR ;
2504
                                                           DUP 3 ;
2505
                                                           GET 3 ;
2506
                                                           GET ;
2507
                                                           IF_NONE
2508
                                                             { PUSH int 858 ; FAILWITH }
2509
                                                             {} ;
2510
                                                           CAR ;
2511
                                                           CAR ;
2512
                                                           GET 3 ;
2513
                                                           IF_NONE
2514
                                                             { PUSH int 274 ; FAILWITH }
2515
                                                             {} ;
2516
                                                           ADD ;
2517
                                                           NOW ;
2518
                                                           COMPARE ;
2519
                                                           GE ;
2520
                                                           IF
2521
                                                             {}
2522
                                                             { PUSH string "SALE_IS_ACTIVE" ;
2523
                                                               FAILWITH } } }
2524
                                                     { DUP 4 ;
2525
                                                       CAR ;
2526
                                                       GET 3 ;
2527
                                                       CAR ;
2528
                                                       DUP 2 ;
2529
                                                       GET 3 ;
2530
                                                       GET ;
2531
                                                       IF_NONE
2532
                                                         { PUSH int 858 ; FAILWITH }
2533
                                                         {} ;
2534
                                                       CAR ;
2535
                                                       CAR ;
2536
                                                       CAR ;
2537
                                                       CDR ;
2538
                                                       IF_NONE
2539
                                                         { PUSH int 275 ; FAILWITH }
2540
                                                         {} ;
2541
                                                       DUP 5 ;
2542
                                                       CAR ;
2543
                                                       GET 3 ;
2544
                                                       CAR ;
2545
                                                       DUP 3 ;
2546
                                                       GET 3 ;
2547
                                                       GET ;
2548
                                                       IF_NONE
2549
                                                         { PUSH int 858 ; FAILWITH }
2550
                                                         {} ;
2551
                                                       GET 9 ;
2552
                                                       ADD ;
2553
                                                       NOW ;
2554
                                                       COMPARE ;
2555
                                                       GE ;
2556
                                                       IF
2557
                                                         {}
2558
                                                         { PUSH string "SALE_IS_ACTIVE" ;
2559
                                                           FAILWITH } } } }
2560
                                             {} ;
2561
                                           PUSH bool False ;
2562
                                           DUP 5 ;
2563
                                           CAR ;
2564
                                           GET 3 ;
2565
                                           CDR ;
2566
                                           ITER { DUP 2 ;
2567
                                                  IF
2568
                                                    { DROP }
2569
                                                    { DUP ;
2570
                                                      DUP 4 ;
2571
                                                      GET 3 ;
2572
                                                      SELF_ADDRESS ;
2573
                                                      PAIR ;
2574
                                                      VIEW "is_token_locked" bool ;
2575
                                                      IF_NONE
2576
                                                        { DROP }
2577
                                                        { DROP ;
2578
                                                          SWAP ;
2579
                                                          IF
2580
                                                            { DROP ; PUSH bool True }
2581
                                                            { DUP 2 ;
2582
                                                              GET 3 ;
2583
                                                              SELF_ADDRESS ;
2584
                                                              PAIR ;
2585
                                                              VIEW "is_token_locked"
2586
                                                                    bool ;
2587
                                                              IF_NONE
2588
                                                                { PUSH int 877 ;
2589
                                                                  FAILWITH }
2590
                                                                {} } } } } ;
2591
                                           IF
2592
                                             { PUSH string "MARKETPLACE_RESTRICTED" ;
2593
                                               FAILWITH }
2594
                                             {} }
2595
                                         {} ;
2596
                                       DUP 4 ;
2597
                                       GET 9 ;
2598
                                       DUP 2 ;
2599
                                       GET 3 ;
2600
                                       MEM ;
2601
                                       IF
2602
                                         {}
2603
                                         { PUSH string "FA2_TOKEN_UNDEFINED" ; FAILWITH } ;
2604
                                       DUP 2 ;
2605
                                       CAR ;
2606
                                       SENDER ;
2607
                                       COMPARE ;
2608
                                       EQ ;
2609
                                       IF
2610
                                         { PUSH bool True }
2611
                                         { DUP 4 ;
2612
                                           CAR ;
2613
                                           GET 8 ;
2614
                                           DUP 2 ;
2615
                                           GET 3 ;
2616
                                           SENDER ;
2617
                                           DUP 5 ;
2618
                                           CAR ;
2619
                                           PAIR 3 ;
2620
                                           MEM } ;
2621
                                       IF
2622
                                         {}
2623
                                         { PUSH string "FA2_NOT_OPERATOR" ; FAILWITH } ;
2624
                                       PUSH nat 0 ;
2625
                                       DUP 2 ;
2626
                                       GET 4 ;
2627
                                       COMPARE ;
2628
                                       GT ;
2629
                                       IF
2630
                                         { DUP 4 ;
2631
                                           UNPAIR ;
2632
                                           UNPAIR ;
2633
                                           UNPAIR ;
2634
                                           SWAP ;
2635
                                           UNPAIR ;
2636
                                           SWAP ;
2637
                                           DUP 6 ;
2638
                                           GET 4 ;
2639
                                           DIG 9 ;
2640
                                           CAR ;
2641
                                           CAR ;
2642
                                           GET 4 ;
2643
                                           DUP 8 ;
2644
                                           GET 3 ;
2645
                                           DUP 10 ;
2646
                                           CAR ;
2647
                                           PAIR ;
2648
                                           GET ;
2649
                                           IF_NONE { PUSH nat 0 } {} ;
2650
                                           SUB ;
2651
                                           ISNAT ;
2652
                                           IF_NONE
2653
                                             { PUSH string "FA2_INSUFFICIENT_BALANCE" ;
2654
                                               FAILWITH }
2655
                                             {} ;
2656
                                           SOME ;
2657
                                           DUP 7 ;
2658
                                           GET 3 ;
2659
                                           DUP 9 ;
2660
                                           CAR ;
2661
                                           PAIR ;
2662
                                           UPDATE ;
2663
                                           SWAP ;
2664
                                           PAIR ;
2665
                                           SWAP ;
2666
                                           PAIR ;
2667
                                           PAIR ;
2668
                                           PAIR ;
2669
                                           DUG 3 ;
2670
                                           DUP 4 ;
2671
                                           UNPAIR ;
2672
                                           UNPAIR ;
2673
                                           UNPAIR ;
2674
                                           SWAP ;
2675
                                           UNPAIR ;
2676
                                           SWAP ;
2677
                                           DUP 6 ;
2678
                                           GET 4 ;
2679
                                           DIG 9 ;
2680
                                           CAR ;
2681
                                           CAR ;
2682
                                           GET 4 ;
2683
                                           DUP 8 ;
2684
                                           GET 3 ;
2685
                                           DUP 9 ;
2686
                                           CAR ;
2687
                                           PAIR ;
2688
                                           GET ;
2689
                                           IF_NONE { PUSH nat 0 } {} ;
2690
                                           ADD ;
2691
                                           SOME ;
2692
                                           DUP 7 ;
2693
                                           GET 3 ;
2694
                                           DIG 7 ;
2695
                                           CAR ;
2696
                                           PAIR ;
2697
                                           UPDATE ;
2698
                                           SWAP ;
2699
                                           PAIR ;
2700
                                           SWAP ;
2701
                                           PAIR ;
2702
                                           PAIR ;
2703
                                           PAIR ;
2704
                                           DUG 2 }
2705
                                         { DROP } } ;
2706
                                DROP } ;
2707
                         DROP ;
2708
                         NIL operation }
2709
                       { PUSH mutez 0 ;
2710
                         AMOUNT ;
2711
                         COMPARE ;
2712
                         EQ ;
2713
                         IF {} { PUSH string "TEZ_TRANSFER" ; FAILWITH } ;
2714
                         DUP 2 ;
2715
                         GET 3 ;
2716
                         GET 6 ;
2717
                         SENDER ;
2718
                         COMPARE ;
2719
                         EQ ;
2720
                         IF {} { PUSH string "NOT_SUPERADMIN" ; FAILWITH } ;
2721
                         DUP ;
2722
                         CAR ;
2723
                         IF_NONE
2724
                           { DUP ;
2725
                             CDR ;
2726
                             IF_NONE { PUSH bool False } { DROP ; PUSH bool True } }
2727
                           { DROP ; PUSH bool True } ;
2728
                         IF {} { PUSH string "NO_CHANGES_SPECIFIED" ; FAILWITH } ;
2729
                         DUP ;
2730
                         CAR ;
2731
                         IF_NONE
2732
                           { NIL operation }
2733
                           { DROP ;
2734
                             NIL operation ;
2735
                             DUP 2 ;
2736
                             CAR ;
2737
                             IF_NONE { PUSH int 454 ; FAILWITH } {} ;
2738
                             ITER { DIG 3 ;
2739
                                    UNPAIR ;
2740
                                    UNPAIR ;
2741
                                    UNPAIR ;
2742
                                    UNPAIR ;
2743
                                    SWAP ;
2744
                                    PUSH (option unit) (Some Unit) ;
2745
                                    DUP 7 ;
2746
                                    UPDATE ;
2747
                                    SWAP ;
2748
                                    PAIR ;
2749
                                    PAIR ;
2750
                                    PAIR ;
2751
                                    PAIR ;
2752
                                    DUG 3 ;
2753
                                    EMIT %admin_added address ;
2754
                                    CONS } } ;
2755
                         DUP 2 ;
2756
                         CDR ;
2757
                         IF_NONE
2758
                           { SWAP ; DROP }
2759
                           { DROP ;
2760
                             DUP 2 ;
2761
                             CDR ;
2762
                             IF_NONE { PUSH int 460 ; FAILWITH } {} ;
2763
                             ITER { DUP 4 ;
2764
                                    CAR ;
2765
                                    CAR ;
2766
                                    CAR ;
2767
                                    CDR ;
2768
                                    DUP 2 ;
2769
                                    MEM ;
2770
                                    IF {} { PUSH string "NOT_AN_ADMIN" ; FAILWITH } ;
2771
                                    DIG 3 ;
2772
                                    UNPAIR ;
2773
                                    UNPAIR ;
2774
                                    UNPAIR ;
2775
                                    UNPAIR ;
2776
                                    SWAP ;
2777
                                    NONE unit ;
2778
                                    DUP 7 ;
2779
                                    UPDATE ;
2780
                                    SWAP ;
2781
                                    PAIR ;
2782
                                    PAIR ;
2783
                                    PAIR ;
2784
                                    PAIR ;
2785
                                    DUG 3 ;
2786
                                    EMIT %admin_removed address ;
2787
                                    CONS } ;
2788
                             SWAP ;
2789
                             DROP } } } }
2790
               { IF_LEFT
2791
                   { IF_LEFT
2792
                       { PUSH mutez 0 ;
2793
                         AMOUNT ;
2794
                         COMPARE ;
2795
                         EQ ;
2796
                         IF {} { PUSH string "TEZ_TRANSFER" ; FAILWITH } ;
2797
                         DUP 2 ;
2798
                         CAR ;
2799
                         CAR ;
2800
                         CAR ;
2801
                         CDR ;
2802
                         SENDER ;
2803
                         MEM ;
2804
                         IF
2805
                           { PUSH bool True }
2806
                           { DUP 2 ; GET 3 ; GET 6 ; SENDER ; COMPARE ; EQ } ;
2807
                         IF {} { PUSH string "NOT_ADMIN" ; FAILWITH } ;
2808
                         DUP ;
2809
                         CAR ;
2810
                         IF_NONE
2811
                           { DUP ;
2812
                             CDR ;
2813
                             IF_NONE { PUSH bool False } { DROP ; PUSH bool True } }
2814
                           { DROP ; PUSH bool True } ;
2815
                         IF {} { PUSH string "NO_CHANGES_SPECIFIED" ; FAILWITH } ;
2816
                         DUP ;
2817
                         CAR ;
2818
                         IF_NONE
2819
                           { NIL operation }
2820
                           { DROP ;
2821
                             NIL operation ;
2822
                             DUP 2 ;
2823
                             CAR ;
2824
                             IF_NONE { PUSH int 342 ; FAILWITH } {} ;
2825
                             ITER { DIG 3 ;
2826
                                    UNPAIR ;
2827
                                    UNPAIR ;
2828
                                    UNPAIR ;
2829
                                    SWAP ;
2830
                                    UNPAIR ;
2831
                                    PUSH (option unit) (Some Unit) ;
2832
                                    DUP 7 ;
2833
                                    UPDATE ;
2834
                                    PAIR ;
2835
                                    SWAP ;
2836
                                    PAIR ;
2837
                                    PAIR ;
2838
                                    PAIR ;
2839
                                    DUG 3 ;
2840
                                    EMIT %collabs_added address ;
2841
                                    CONS } } ;
2842
                         DUP 2 ;
2843
                         CDR ;
2844
                         IF_NONE
2845
                           { SWAP ; DROP }
2846
                           { DROP ;
2847
                             DUP 2 ;
2848
                             CDR ;
2849
                             IF_NONE { PUSH int 350 ; FAILWITH } {} ;
2850
                             ITER { DUP 4 ;
2851
                                    CAR ;
2852
                                    CAR ;
2853
                                    GET 3 ;
2854
                                    DUP 2 ;
2855
                                    MEM ;
2856
                                    IF {} { PUSH string "NOT_AN_COLLAB" ; FAILWITH } ;
2857
                                    DIG 3 ;
2858
                                    UNPAIR ;
2859
                                    UNPAIR ;
2860
                                    UNPAIR ;
2861
                                    SWAP ;
2862
                                    UNPAIR ;
2863
                                    NONE unit ;
2864
                                    DUP 7 ;
2865
                                    UPDATE ;
2866
                                    PAIR ;
2867
                                    SWAP ;
2868
                                    PAIR ;
2869
                                    PAIR ;
2870
                                    PAIR ;
2871
                                    DUG 3 ;
2872
                                    EMIT %collabs_removed address ;
2873
                                    CONS } ;
2874
                             SWAP ;
2875
                             DROP } }
2876
                       { DUP 2 ;
2877
                         CAR ;
2878
                         CAR ;
2879
                         CAR ;
2880
                         CDR ;
2881
                         SENDER ;
2882
                         MEM ;
2883
                         IF
2884
                           { PUSH bool True }
2885
                           { DUP 2 ; GET 3 ; GET 6 ; SENDER ; COMPARE ; EQ } ;
2886
                         IF {} { PUSH string "NOT_ADMIN" ; FAILWITH } ;
2887
                         DUP ;
2888
                         ITER { DUP ;
2889
                                GET 3 ;
2890
                                ITER { DUP 2 ;
2891
                                       GET 6 ;
2892
                                       IF
2893
                                         { DUP 2 ;
2894
                                           GET 5 ;
2895
                                           IF
2896
                                             { DIG 3 ;
2897
                                               UNPAIR ;
2898
                                               SWAP ;
2899
                                               UNPAIR ;
2900
                                               SWAP ;
2901
                                               UNPAIR ;
2902
                                               UNPAIR ;
2903
                                               SWAP ;
2904
                                               NONE unit ;
2905
                                               DIG 6 ;
2906
                                               DUP 8 ;
2907
                                               CAR ;
2908
                                               PAIR ;
2909
                                               UPDATE ;
2910
                                               SWAP ;
2911
                                               PAIR ;
2912
                                               PAIR ;
2913
                                               SWAP ;
2914
                                               PAIR ;
2915
                                               SWAP ;
2916
                                               PAIR ;
2917
                                               DUG 2 }
2918
                                             { DIG 3 ;
2919
                                               UNPAIR ;
2920
                                               SWAP ;
2921
                                               UNPAIR ;
2922
                                               SWAP ;
2923
                                               UNPAIR ;
2924
                                               UNPAIR ;
2925
                                               SWAP ;
2926
                                               PUSH (option unit) (Some Unit) ;
2927
                                               DIG 6 ;
2928
                                               DUP 8 ;
2929
                                               CAR ;
2930
                                               PAIR ;
2931
                                               UPDATE ;
2932
                                               SWAP ;
2933
                                               PAIR ;
2934
                                               PAIR ;
2935
                                               SWAP ;
2936
                                               PAIR ;
2937
                                               SWAP ;
2938
                                               PAIR ;
2939
                                               DUG 2 } }
2940
                                         { DUP 2 ;
2941
                                           GET 5 ;
2942
                                           IF
2943
                                             { DIG 3 ;
2944
                                               UNPAIR ;
2945
                                               UNPAIR ;
2946
                                               UNPAIR ;
2947
                                               UNPAIR ;
2948
                                               NONE unit ;
2949
                                               DIG 6 ;
2950
                                               DUP 8 ;
2951
                                               CAR ;
2952
                                               PAIR ;
2953
                                               UPDATE ;
2954
                                               PAIR ;
2955
                                               PAIR ;
2956
                                               PAIR ;
2957
                                               PAIR ;
2958
                                               DUG 2 }
2959
                                             { DIG 3 ;
2960
                                               UNPAIR ;
2961
                                               UNPAIR ;
2962
                                               UNPAIR ;
2963
                                               UNPAIR ;
2964
                                               PUSH (option unit) (Some Unit) ;
2965
                                               DIG 6 ;
2966
                                               DUP 8 ;
2967
                                               CAR ;
2968
                                               PAIR ;
2969
                                               UPDATE ;
2970
                                               PAIR ;
2971
                                               PAIR ;
2972
                                               PAIR ;
2973
                                               PAIR ;
2974
                                               DUG 2 } } } ;
2975
                                DROP } ;
2976
                         DROP ;
2977
                         NIL operation } }
2978
                   { IF_LEFT
2979
                       { DUP 2 ;
2980
                         CAR ;
2981
                         CAR ;
2982
                         CAR ;
2983
                         CDR ;
2984
                         SENDER ;
2985
                         MEM ;
2986
                         IF
2987
                           { PUSH bool True }
2988
                           { DUP 2 ; GET 3 ; GET 6 ; SENDER ; COMPARE ; EQ } ;
2989
                         IF {} { PUSH string "NOT_ADMIN" ; FAILWITH } ;
2990
                         DUP ;
2991
                         CAR ;
2992
                         IF_NONE
2993
                           {}
2994
                           { DROP ;
2995
                             DUP ;
2996
                             CAR ;
2997
                             IF_NONE { PUSH int 1066 ; FAILWITH } {} ;
2998
                             ITER { DIG 2 ;
2999
                                    UNPAIR ;
3000
                                    UNPAIR ;
3001
                                    SWAP ;
3002
                                    UNPAIR ;
3003
                                    UNPAIR ;
3004
                                    SWAP ;
3005
                                    PUSH bool True ;
3006
                                    DIG 6 ;
3007
                                    UPDATE ;
3008
                                    SWAP ;
3009
                                    PAIR ;
3010
                                    PAIR ;
3011
                                    SWAP ;
3012
                                    PAIR ;
3013
                                    PAIR ;
3014
                                    SWAP } } ;
3015
                         DUP ;
3016
                         CDR ;
3017
                         IF_NONE
3018
                           { DROP }
3019
                           { DROP ;
3020
                             DUP ;
3021
                             CDR ;
3022
                             IF_NONE { PUSH int 1071 ; FAILWITH } {} ;
3023
                             ITER { DIG 2 ;
3024
                                    UNPAIR ;
3025
                                    UNPAIR ;
3026
                                    SWAP ;
3027
                                    UNPAIR ;
3028
                                    UNPAIR ;
3029
                                    SWAP ;
3030
                                    PUSH bool False ;
3031
                                    DIG 6 ;
3032
                                    UPDATE ;
3033
                                    SWAP ;
3034
                                    PAIR ;
3035
                                    PAIR ;
3036
                                    SWAP ;
3037
                                    PAIR ;
3038
                                    PAIR ;
3039
                                    SWAP } ;
3040
                             DROP } }
3041
                       { IF_LEFT
3042
                           { DUP ;
3043
                             ITER { IF_LEFT
3044
                                      { DUP 3 ;
3045
                                        CAR ;
3046
                                        CAR ;
3047
                                        CAR ;
3048
                                        CAR ;
3049
                                        DUP 2 ;
3050
                                        GET 4 ;
3051
                                        DUP 3 ;
3052
                                        GET 3 ;
3053
                                        PAIR ;
3054
                                        MEM ;
3055
                                        IF
3056
                                          { PUSH string "RESTRICTED_OPERATOR" ; FAILWITH }
3057
                                          {} ;
3058
                                        DUP 3 ;
3059
                                        GET 5 ;
3060
                                        CDR ;
3061
                                        DUP 2 ;
3062
                                        GET 4 ;
3063
                                        DUP 3 ;
3064
                                        GET 3 ;
3065
                                        PAIR ;
3066
                                        MEM ;
3067
                                        IF
3068
                                          { DUP 3 ;
3069
                                            CAR ;
3070
                                            GET 3 ;
3071
                                            CAR ;
3072
                                            DUP 2 ;
3073
                                            GET 4 ;
3074
                                            MEM ;
3075
                                            IF
3076
                                              { DUP 3 ;
3077
                                                CAR ;
3078
                                                GET 3 ;
3079
                                                CAR ;
3080
                                                DUP 2 ;
3081
                                                GET 4 ;
3082
                                                GET ;
3083
                                                IF_NONE { PUSH int 924 ; FAILWITH } {} ;
3084
                                                GET 9 ;
3085
                                                NOW ;
3086
                                                COMPARE ;
3087
                                                GE ;
3088
                                                IF
3089
                                                  {}
3090
                                                  { PUSH string "SALE_NOT_STARTED_YET" ;
3091
                                                    FAILWITH } ;
3092
                                                DUP 3 ;
3093
                                                CAR ;
3094
                                                GET 3 ;
3095
                                                CAR ;
3096
                                                DUP 2 ;
3097
                                                GET 4 ;
3098
                                                GET ;
3099
                                                IF_NONE { PUSH int 924 ; FAILWITH } {} ;
3100
                                                CAR ;
3101
                                                CAR ;
3102
                                                CAR ;
3103
                                                CDR ;
3104
                                                IF_NONE
3105
                                                  { PUSH string "PERPETUAL_SALE_ACTIVE" ;
3106
                                                    FAILWITH }
3107
                                                  { DROP ;
3108
                                                    DUP 3 ;
3109
                                                    CAR ;
3110
                                                    GET 3 ;
3111
                                                    CAR ;
3112
                                                    DUP 2 ;
3113
                                                    GET 4 ;
3114
                                                    GET ;
3115
                                                    IF_NONE
3116
                                                      { PUSH int 924 ; FAILWITH }
3117
                                                      {} ;
3118
                                                    GET 7 ;
3119
                                                    IF
3120
                                                      { DUP 3 ;
3121
                                                        CAR ;
3122
                                                        GET 3 ;
3123
                                                        CAR ;
3124
                                                        DUP 2 ;
3125
                                                        GET 4 ;
3126
                                                        GET ;
3127
                                                        IF_NONE
3128
                                                          { PUSH int 924 ; FAILWITH }
3129
                                                          {} ;
3130
                                                        CAR ;
3131
                                                        CAR ;
3132
                                                        GET 3 ;
3133
                                                        IF_NONE
3134
                                                          { PUSH string "SALE_NOT_PROPERLY_STARTED" ;
3135
                                                            FAILWITH }
3136
                                                          { DROP ;
3137
                                                            DUP 3 ;
3138
                                                            CAR ;
3139
                                                            GET 3 ;
3140
                                                            CAR ;
3141
                                                            DUP 2 ;
3142
                                                            GET 4 ;
3143
                                                            GET ;
3144
                                                            IF_NONE
3145
                                                              { PUSH int 924 ; FAILWITH }
3146
                                                              {} ;
3147
                                                            CAR ;
3148
                                                            CAR ;
3149
                                                            CAR ;
3150
                                                            CDR ;
3151
                                                            IF_NONE
3152
                                                              { PUSH int 275 ; FAILWITH }
3153
                                                              {} ;
3154
                                                            DUP 4 ;
3155
                                                            CAR ;
3156
                                                            GET 3 ;
3157
                                                            CAR ;
3158
                                                            DUP 3 ;
3159
                                                            GET 4 ;
3160
                                                            GET ;
3161
                                                            IF_NONE
3162
                                                              { PUSH int 924 ; FAILWITH }
3163
                                                              {} ;
3164
                                                            CAR ;
3165
                                                            CAR ;
3166
                                                            GET 3 ;
3167
                                                            IF_NONE
3168
                                                              { PUSH int 274 ; FAILWITH }
3169
                                                              {} ;
3170
                                                            ADD ;
3171
                                                            NOW ;
3172
                                                            COMPARE ;
3173
                                                            GE ;
3174
                                                            IF
3175
                                                              {}
3176
                                                              { PUSH string "SALE_IS_ACTIVE" ;
3177
                                                                FAILWITH } } }
3178
                                                      { DUP 3 ;
3179
                                                        CAR ;
3180
                                                        GET 3 ;
3181
                                                        CAR ;
3182
                                                        DUP 2 ;
3183
                                                        GET 4 ;
3184
                                                        GET ;
3185
                                                        IF_NONE
3186
                                                          { PUSH int 924 ; FAILWITH }
3187
                                                          {} ;
3188
                                                        CAR ;
3189
                                                        CAR ;
3190
                                                        CAR ;
3191
                                                        CDR ;
3192
                                                        IF_NONE
3193
                                                          { PUSH int 275 ; FAILWITH }
3194
                                                          {} ;
3195
                                                        DUP 4 ;
3196
                                                        CAR ;
3197
                                                        GET 3 ;
3198
                                                        CAR ;
3199
                                                        DUP 3 ;
3200
                                                        GET 4 ;
3201
                                                        GET ;
3202
                                                        IF_NONE
3203
                                                          { PUSH int 924 ; FAILWITH }
3204
                                                          {} ;
3205
                                                        GET 9 ;
3206
                                                        ADD ;
3207
                                                        NOW ;
3208
                                                        COMPARE ;
3209
                                                        GE ;
3210
                                                        IF
3211
                                                          {}
3212
                                                          { PUSH string "SALE_IS_ACTIVE" ;
3213
                                                            FAILWITH } } } }
3214
                                              {} ;
3215
                                            PUSH bool False ;
3216
                                            DUP 4 ;
3217
                                            CAR ;
3218
                                            GET 3 ;
3219
                                            CDR ;
3220
                                            ITER { DUP 2 ;
3221
                                                   IF
3222
                                                     { DROP }
3223
                                                     { DUP ;
3224
                                                       DUP 4 ;
3225
                                                       GET 4 ;
3226
                                                       SELF_ADDRESS ;
3227
                                                       PAIR ;
3228
                                                       VIEW "is_token_locked" bool ;
3229
                                                       IF_NONE
3230
                                                         { DROP }
3231
                                                         { DROP ;
3232
                                                           SWAP ;
3233
                                                           IF
3234
                                                             { DROP ; PUSH bool True }
3235
                                                             { DUP 2 ;
3236
                                                               GET 4 ;
3237
                                                               SELF_ADDRESS ;
3238
                                                               PAIR ;
3239
                                                               VIEW "is_token_locked"
3240
                                                                     bool ;
3241
                                                               IF_NONE
3242
                                                                 { PUSH int 943 ;
3243
                                                                   FAILWITH }
3244
                                                                 {} } } } } ;
3245
                                            IF
3246
                                              { PUSH string "MARKETPLACE_RESTRICTED" ;
3247
                                                FAILWITH }
3248
                                              {} }
3249
                                          {} ;
3250
                                        SENDER ;
3251
                                        DUP 2 ;
3252
                                        CAR ;
3253
                                        COMPARE ;
3254
                                        EQ ;
3255
                                        IF
3256
                                          {}
3257
                                          { PUSH string "FA2_NOT_OWNER" ; FAILWITH } ;
3258
                                        DIG 2 ;
3259
                                        UNPAIR ;
3260
                                        UNPAIR ;
3261
                                        SWAP ;
3262
                                        UNPAIR ;
3263
                                        SWAP ;
3264
                                        UNPAIR ;
3265
                                        SWAP ;
3266
                                        UNPAIR ;
3267
                                        SWAP ;
3268
                                        PUSH (option unit) (Some Unit) ;
3269
                                        DIG 7 ;
3270
                                        UPDATE ;
3271
                                        SWAP ;
3272
                                        PAIR ;
3273
                                        SWAP ;
3274
                                        PAIR ;
3275
                                        SWAP ;
3276
                                        PAIR ;
3277
                                        SWAP ;
3278
                                        PAIR ;
3279
                                        PAIR ;
3280
                                        SWAP }
3281
                                      { SENDER ;
3282
                                        DUP 2 ;
3283
                                        CAR ;
3284
                                        COMPARE ;
3285
                                        EQ ;
3286
                                        IF
3287
                                          {}
3288
                                          { PUSH string "FA2_NOT_OWNER" ; FAILWITH } ;
3289
                                        DIG 2 ;
3290
                                        UNPAIR ;
3291
                                        UNPAIR ;
3292
                                        SWAP ;
3293
                                        UNPAIR ;
3294
                                        SWAP ;
3295
                                        UNPAIR ;
3296
                                        SWAP ;
3297
                                        UNPAIR ;
3298
                                        SWAP ;
3299
                                        NONE unit ;
3300
                                        DIG 7 ;
3301
                                        UPDATE ;
3302
                                        SWAP ;
3303
                                        PAIR ;
3304
                                        SWAP ;
3305
                                        PAIR ;
3306
                                        SWAP ;
3307
                                        PAIR ;
3308
                                        SWAP ;
3309
                                        PAIR ;
3310
                                        PAIR ;
3311
                                        SWAP } } ;
3312
                             DROP }
3313
                           { PUSH mutez 0 ;
3314
                             AMOUNT ;
3315
                             COMPARE ;
3316
                             EQ ;
3317
                             IF {} { PUSH string "TEZ_TRANSFER" ; FAILWITH } ;
3318
                             DUP ;
3319
                             ITER { DUP 3 ;
3320
                                    GET 9 ;
3321
                                    DUP 2 ;
3322
                                    CAR ;
3323
                                    MEM ;
3324
                                    IF
3325
                                      {}
3326
                                      { PUSH string "FA2_TOKEN_UNDEFINED" ; FAILWITH } ;
3327
                                    DUP 3 ;
3328
                                    GET 9 ;
3329
                                    DUP 2 ;
3330
                                    CAR ;
3331
                                    MEM ;
3332
                                    IF
3333
                                      {}
3334
                                      { PUSH string "FA2_TOKEN_UNDEFINED" ; FAILWITH } ;
3335
                                    DUP 3 ;
3336
                                    GET 7 ;
3337
                                    DUP 2 ;
3338
                                    CAR ;
3339
                                    MEM ;
3340
                                    IF
3341
                                      {}
3342
                                      { PUSH string "TOKEN_CREATOR_MISSING" ; FAILWITH } ;
3343
                                    DUP 3 ;
3344
                                    CAR ;
3345
                                    CAR ;
3346
                                    CAR ;
3347
                                    CDR ;
3348
                                    SENDER ;
3349
                                    MEM ;
3350
                                    IF
3351
                                      { PUSH bool True }
3352
                                      { DUP 3 ; GET 3 ; GET 6 ; SENDER ; COMPARE ; EQ } ;
3353
                                    IF
3354
                                      { PUSH bool True }
3355
                                      { SENDER ;
3356
                                        DUP 4 ;
3357
                                        GET 7 ;
3358
                                        DUP 3 ;
3359
                                        CAR ;
3360
                                        GET ;
3361
                                        IF_NONE { PUSH int 215 ; FAILWITH } {} ;
3362
                                        COMPARE ;
3363
                                        EQ } ;
3364
                                    IF
3365
                                      {}
3366
                                      { PUSH string "NOT_TOKEN_CREATOR_OR_ADMIN" ;
3367
                                        FAILWITH } ;
3368
                                    DIG 2 ;
3369
                                    DUP ;
3370
                                    GET 9 ;
3371
                                    DUP ;
3372
                                    DUP 4 ;
3373
                                    CAR ;
3374
                                    DUP ;
3375
                                    DUG 2 ;
3376
                                    GET ;
3377
                                    IF_NONE { PUSH int 1093 ; FAILWITH } {} ;
3378
                                    DIG 4 ;
3379
                                    CDR ;
3380
                                    UPDATE 2 ;
3381
                                    SOME ;
3382
                                    SWAP ;
3383
                                    UPDATE ;
3384
                                    UPDATE 9 ;
3385
                                    SWAP } ;
3386
                             DROP } } ;
3387
                     NIL operation } } } ;
3388
         NIL operation ;
3389
         SWAP ;
3390
         ITER { CONS } ;
3391
         PAIR } ;
3392
  view "get_balance_of" (list (pair (address %owner) (nat %token_id)))
3393
        (list (pair (pair %request (address %owner) (nat %token_id)) (nat %balance)))
3394
        { UNPAIR ;
3395
          NIL (pair (pair address nat) nat) ;
3396
          DUP 2 ;
3397
          ITER { SWAP ;
3398
                 DUP 4 ;
3399
                 CAR ;
3400
                 CAR ;
3401
                 GET 4 ;
3402
                 DUP 3 ;
3403
                 CDR ;
3404
                 DUP 4 ;
3405
                 CAR ;
3406
                 PAIR ;
3407
                 GET ;
3408
                 IF_NONE { PUSH nat 0 } {} ;
3409
                 DIG 2 ;
3410
                 PAIR ;
3411
                 CONS } ;
3412
          SWAP ;
3413
          DROP ;
3414
          SWAP ;
3415
          DROP } ;
3416
  view "get_token_creator" nat address
3417
        { UNPAIR ;
3418
          DUP 2 ;
3419
          GET 9 ;
3420
          DUP 2 ;
3421
          MEM ;
3422
          IF {} { PUSH string "FA2_TOKEN_UNDEFINED" ; FAILWITH } ;
3423
          SWAP ;
3424
          GET 7 ;
3425
          SWAP ;
3426
          GET ;
3427
          IF_NONE { PUSH int 1124 ; FAILWITH } {} } ;
3428
  view "is_collaborator" address bool
3429
        { UNPAIR ; SWAP ; CAR ; CAR ; GET 3 ; SWAP ; MEM } ;
3430
  view "token_royalties" nat (list (pair (address %address) (nat %royalties)))
3431
        { UNPAIR ; SWAP ; GET 10 ; SWAP ; GET ; IF_NONE { PUSH int 1136 ; FAILWITH } {} } }