BCD

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