BCD

Tezos Contract Explorer
Search Networks Deploy
  • Home
  • /
  • Mainnet
  • /
  • KT1Xnpg...maFa
operations (7)Storage Code Interact Tokens Metadata Fork Views Statistics Details
Latest
​x
618
1355
 
1
{ parameter (or
2
              (or
3
                (or
4
                  (or
5
                    (or
6
                      (pair %_burn_tokens
7
                        (list %burn_items (pair (address %from_)
8
                                               (pair (nat %token_id) (nat %amount))))
9
                        (address %fa2))
10
                      (pair %_create_token (address %fa2) (map %metadata string bytes)))
11
                    (or
12
                      (pair %_increase_mint_capacity (set %creators address)
13
                                                     (nat %mint_invite_id))
14
                      (or
15
                        (pair %_lock_token (pair (address %fa2) (bool %lock_metadata))
16
                                           (pair (bool %lock_mint) (nat %token_id)))
17
                        (pair %_mint_tokens (address %fa2)
18
                                            (pair
19
                                              (list %mint_items (pair (nat %amount)
20
                                                                     (address %to_)))
21
                                              (nat %token_id))))))
22
                  (or
23
                    (or
24
                      (pair %_update_sales (nat %amount)
25
                                           (pair %token (address %address)
26
                                                        (pair (nat %exhibition_id)
27
                                                              (nat %token_id))))
28
                      (pair %_update_token_metadata (address %fa2)
29
                                                    (list %token_updates (pair
30
                                                                          (nat %token_id)
31
                                                                          (map %token_info
32
                                                                            string
33
                                                                            bytes)))))
34
                    (or (unit %accept_admin)
35
                        (or
36
                          (pair %accept_list_invite
37
                            (pair (option %condition_extra bytes) (nat %invite_id))
38
                            (pair (map %split address nat)
39
                                  (pair %token (address %address)
40
                                               (pair (nat %exhibition_id)
41
                                                     (nat %token_id)))))
42
                          (pair %accept_offer (option %condition_extra bytes)
43
                                              (pair (nat %offer_id)
44
                                                    (pair %token (address %address)
45
                                                                 (pair
46
                                                                   (nat %exhibition_id)
47
                                                                   (nat %token_id)))))))))
48
                (or
49
                  (or (or (address %add_gallerist) (address %add_mint_module))
50
                      (or
51
                        (pair %airdrop_tokens
52
                          (pair %token (address %address)
53
                                       (pair (nat %exhibition_id) (nat %token_id)))
54
                          (list %txs (pair (nat %amount) (address %to_))))
55
                        (or
56
                          (pair %burn_le (nat %editions)
57
                                         (pair %token (address %address)
58
                                                      (pair (nat %exhibition_id)
59
                                                            (nat %token_id))))
60
                          (pair %eject_fa2 (address %fa2) (address %new_admin)))))
61
                  (or
62
                    (or
63
                      (pair %init_external
64
                        (pair (map %collaborators address nat)
65
                              (pair (option %condition_extra bytes) (address %contract)))
66
                        (pair (bytes %data)
67
                              (pair (nat %invite_id) (address %mint_module))))
68
                      (pair %invite_list
69
                        (pair
70
                          (pair (nat %airdrop_capacity)
71
                                (pair (bool %allow_gallery_list)
72
                                      (bool %allow_holder_list)))
73
                          (pair (option %capacity nat)
74
                                (pair
75
                                  (option %condition (pair (address %address) (bytes %id)))
76
                                  (nat %editions))))
77
                        (pair
78
                          (pair (nat %exhibition_id)
79
                                (pair (option %expiry timestamp) (set %holders address)))
80
                          (pair
81
                            (option %price_minimum (map
82
                                                    (or (address %fa12)
83
                                                        (or
84
                                                          (pair %fa2 (address %address)
85
                                                                     (nat %token_id))
86
                                                          (unit %tez)))
87
                                                    nat))
88
                            (pair
89
                              (pair %sales_split (pair (nat %curators) (nat %gallery))
90
                                                 (pair (nat %holder)
91
                                                       (pair (map %other address nat)
92
                                                             (map %royalties address nat))))
93
                              (map %tokens address (option nat)))))))
94
                    (or
95
                      (pair %invite_mint
96
                        (pair
97
                          (pair (nat %airdrop_capacity)
98
                                (pair (bool %allow_creator_list)
99
                                      (bool %allow_gallery_list)))
100
                          (pair (pair (set %artists address) (option %capacity nat))
101
                                (pair
102
                                  (option %condition (pair (address %address) (bytes %id)))
103
                                  (set %contracts address))))
104
                        (pair
105
                          (pair (nat %exhibition_id)
106
                                (pair (option %expiry timestamp)
107
                                      (option %individual_capacity nat)))
108
                          (pair
109
                            (pair
110
                              (pair %mint_types
111
                                (option %external (map address (option bytes)))
112
                                (option %limited_edition nat))
113
                              (option %price_minimum (map
114
                                                      (or (address %fa12)
115
                                                          (or
116
                                                            (pair %fa2
117
                                                              (address %address)
118
                                                              (nat %token_id))
119
                                                            (unit %tez)))
120
                                                      nat)))
121
                            (pair
122
                              (option %royalty_split (pair
123
                                                      (pair (option %creators nat)
124
                                                            (option %curators nat))
125
                                                      (pair (option %gallery nat)
126
                                                            (option %other (map address
127
                                                                               nat)))))
128
                              (option %sales_split (pair
129
                                                    (pair (nat %creators)
130
                                                          (nat %curators))
131
                                                    (pair (nat %gallery)
132
                                                          (map %other address nat))))))))
133
                      (or
134
                        (pair %list_auction
135
                          (pair
136
                            (pair
137
                              (option %condition (pair (address %address) (bytes %id)))
138
                              (or %currency (address %fa12)
139
                                            (or
140
                                              (pair %fa2 (address %address)
141
                                                         (nat %token_id))
142
                                              (unit %tez))))
143
                            (pair (nat %duration) (nat %extension_time)))
144
                          (pair (pair (nat %price_increment) (nat %reserve))
145
                                (pair (option %start_time timestamp)
146
                                      (pair %token (address %address)
147
                                                   (pair (nat %exhibition_id)
148
                                                         (nat %token_id))))))
149
                        (pair %list_token
150
                          (pair
151
                            (option %condition (pair (address %address) (bytes %id)))
152
                            (pair
153
                              (or %currency (address %fa12)
154
                                            (or
155
                                              (pair %fa2 (address %address)
156
                                                         (nat %token_id))
157
                                              (unit %tez)))
158
                              (nat %editions)))
159
                          (pair (nat %price)
160
                                (pair (option %start_time timestamp)
161
                                      (pair %token (address %address)
162
                                                   (pair (nat %exhibition_id)
163
                                                         (nat %token_id)))))))))))
164
              (or
165
                (or
166
                  (or
167
                    (or
168
                      (pair %lock_token_metadata (address %address)
169
                                                 (pair (nat %exhibition_id)
170
                                                       (nat %token_id)))
171
                      (pair %mint_le
172
                        (pair (nat %amount)
173
                              (pair (map %collaborators address nat)
174
                                    (option %condition_extra bytes)))
175
                        (pair (address %contract)
176
                              (pair (nat %invite_id) (map %metadata string bytes)))))
177
                    (or (address %remove_gallerist)
178
                        (or (address %remove_mint_module) (nat %retract_list_invite))))
179
                  (or
180
                    (or (nat %retract_mint_invite)
181
                        (pair %retrieve_token (nat %editions)
182
                                              (pair %token (address %address)
183
                                                           (pair (nat %exhibition_id)
184
                                                                 (nat %token_id)))))
185
                    (or
186
                      (pair %set_exhibition
187
                        (pair (map %assigned_curators address nat)
188
                              (pair (set %contracts address) (option %exhibition_id nat)))
189
                        (pair (pair (bytes %metadata) (bool %paused))
190
                              (pair
191
                                (pair %royalty_split
192
                                  (pair (option %creators nat) (option %curators nat))
193
                                  (pair (option %gallery nat)
194
                                        (option %other (map address nat))))
195
                                (pair %sales_split
196
                                  (pair (nat %creators) (nat %curators))
197
                                  (pair (nat %gallery) (map %other address nat))))))
198
                      (or
199
                        (pair %set_exhibition_metadata (nat %exhibition_id)
200
                                                       (bytes %metadata))
201
                        (pair %set_fa2_metadata (address %fa2)
202
                                                (big_map %metadata string bytes))))))
203
                (or
204
                  (or (or (big_map %set_metadata string bytes) (address %set_treasury))
205
                      (or
206
                        (pair %sign_token (address %address)
207
                                          (pair (nat %exhibition_id) (nat %token_id)))
208
                        (or (address %suggest_admin)
209
                            (pair %unlist_auction (nat %auction_id)
210
                                                  (pair %token (address %address)
211
                                                               (pair
212
                                                                 (nat %exhibition_id)
213
                                                                 (nat %token_id)))))))
214
                  (or
215
                    (or
216
                      (pair %unlist_token (nat %ask_id)
217
                                          (pair %token (address %address)
218
                                                       (pair (nat %exhibition_id)
219
                                                             (nat %token_id))))
220
                      (address %update_auction_contract))
221
                    (or (address %update_fee_sharing_registry)
222
                        (or (address %update_marketplace_contract)
223
                            (pair %update_token_metadata (map %metadata string bytes)
224
                                                         (pair %token (address %address)
225
                                                                      (pair
226
                                                                        (nat %exhibition_id)
227
                                                                        (nat %token_id)))))))))) ;
228
  storage (pair
229
            (pair
230
              (pair (pair (address %admin) (address %auction_contract))
231
                    (pair
232
                      (big_map %exhibitions nat
233
                                            (pair
234
                                              (pair (map %assigned_curators address nat)
235
                                                    (set %contracts address))
236
                                              (pair (bytes %metadata)
237
                                                    (pair (bool %paused)
238
                                                          (pair %sales_split
239
                                                            (pair (nat %creators)
240
                                                                  (nat %curators))
241
                                                            (pair (nat %gallery)
242
                                                                  (map %other address
243
                                                                              nat)))))))
244
                      (address %fee_sharing_registry)))
245
              (pair
246
                (pair (big_map %gallerists address unit)
247
                      (big_map %list_invites nat
248
                                             (pair
249
                                               (pair
250
                                                 (pair (nat %airdrop_capacity)
251
                                                       (pair (bool %allow_gallery_list)
252
                                                             (bool %allow_holder_list)))
253
                                                 (pair (option %capacity nat)
254
                                                       (pair
255
                                                         (option %condition (pair
256
                                                                             (address %address)
257
                                                                             (bytes %id)))
258
                                                         (nat %editions))))
259
                                               (pair
260
                                                 (pair (nat %exhibition_id)
261
                                                       (pair (option %expiry timestamp)
262
                                                             (set %holders address)))
263
                                                 (pair
264
                                                   (option %price_minimum (map
265
                                                                           (or
266
                                                                             (address %fa12)
267
                                                                             (or
268
                                                                               (pair %fa2
269
                                                                                 (address %address)
270
                                                                                 (nat %token_id))
271
                                                                               (unit %tez)))
272
                                                                           nat))
273
                                                   (pair
274
                                                     (pair %sales_split
275
                                                       (pair (nat %curators)
276
                                                             (nat %gallery))
277
                                                       (pair (nat %holder)
278
                                                             (pair
279
                                                               (map %other address nat)
280
                                                               (map %royalties address
281
                                                                               nat))))
282
                                                     (map %tokens address (option nat))))))))
283
                (pair (address %marketplace_contract)
284
                      (pair (big_map %metadata string bytes)
285
                            (big_map %mint_invites nat
286
                                                   (pair
287
                                                     (pair
288
                                                       (pair (nat %airdrop_capacity)
289
                                                             (pair
290
                                                               (bool %allow_creator_list)
291
                                                               (bool %allow_gallery_list)))
292
                                                       (pair
293
                                                         (pair (set %artists address)
294
                                                               (option %capacity nat))
295
                                                         (pair
296
                                                           (option %condition (pair
297
                                                                               (address %address)
298
                                                                               (bytes %id)))
299
                                                           (set %contracts address))))
300
                                                     (pair
301
                                                       (pair (nat %exhibition_id)
302
                                                             (pair
303
                                                               (option %expiry timestamp)
304
                                                               (option %individual_capacity nat)))
305
                                                       (pair
306
                                                         (pair
307
                                                           (pair %mint_types
308
                                                             (option %external (map
309
                                                                                address
310
                                                                                (option bytes)))
311
                                                             (option %limited_edition nat))
312
                                                           (option %price_minimum (map
313
                                                                                   (or
314
                                                                                     (address %fa12)
315
                                                                                     (or
316
                                                                                       (pair %fa2
317
                                                                                         (address %address)
318
                                                                                         (nat %token_id))
319
                                                                                       (unit %tez)))
320
                                                                                   nat)))
321
                                                         (pair (bool %retracted)
322
                                                               (pair %sales_split
323
                                                                 (pair (nat %creators)
324
                                                                       (nat %curators))
325
                                                                 (pair (nat %gallery)
326
                                                                       (map %other
327
                                                                         address
328
                                                                         nat))))))))))))
329
            (pair
330
              (pair
331
                (pair (address %mint_module_registry)
332
                      (big_map %mint_modules address unit))
333
                (pair (nat %next_exhibition_id)
334
                      (pair (nat %next_list_invite_id) (nat %next_mint_invite_id))))
335
              (pair (pair (address %permission_module) (address %suggested_admin))
336
                    (pair
337
                      (big_map %token_metas
338
                        (pair (address %address)
339
                              (pair (nat %exhibition_id) (nat %token_id)))
340
                        (pair
341
                          (pair
342
                            (pair (nat %airdrop_capacity)
343
                                  (pair (bool %allow_creator_holder_list)
344
                                        (bool %allow_gallery_list)))
345
                            (pair (pair (set %auctions nat) (set %creators address))
346
                                  (pair (bool %external) (nat %invite_id))))
347
                          (pair
348
                            (pair (nat %listed_editions)
349
                                  (pair (set %listings nat)
350
                                        (option %price_minimum (map
351
                                                                (or (address %fa12)
352
                                                                    (or
353
                                                                      (pair %fa2
354
                                                                        (address %address)
355
                                                                        (nat %token_id))
356
                                                                      (unit %tez)))
357
                                                                nat))))
358
                            (pair
359
                              (pair (map %sales_split address nat) (set %signed address))
360
                              (pair (nat %sold_editions) (nat %unlisted_editions))))))
361
                      (pair (address %treasury)
362
                            (big_map %used_mint_capacities
363
                              (pair (address %artist) (nat %mint_invite_id))
364
                              nat)))))) ;
365
  code { UNPAIR ;
366
         IF_LEFT
367
           { IF_LEFT
368
               { IF_LEFT
369
                   { IF_LEFT
370
                       { IF_LEFT
371
                           { SWAP ;
372
                             DUP ;
373
                             DUG 2 ;
374
                             GET 3 ;
375
                             CAR ;
376
                             CDR ;
377
                             SENDER ;
378
                             MEM ;
379
                             IF {} { PUSH int 1443 ; FAILWITH } ;
380
                             DUP ;
381
                             CDR ;
382
                             CONTRACT %burn (list (pair (address %from_)
383
                                                       (pair (nat %token_id)
384
                                                             (nat %amount)))) ;
385
                             IF_NONE { PUSH int 1451 ; FAILWITH } {} ;
386
                             NIL operation ;
387
                             SWAP ;
388
                             PUSH mutez 0 ;
389
                             DIG 3 ;
390
                             CAR ;
391
                             TRANSFER_TOKENS ;
392
                             CONS }
393
                           { SWAP ;
394
                             DUP ;
395
                             DUG 2 ;
396
                             GET 3 ;
397
                             CAR ;
398
                             CDR ;
399
                             SENDER ;
400
                             MEM ;
401
                             IF {} { PUSH int 1325 ; FAILWITH } ;
402
                             DUP ;
403
                             CAR ;
404
                             CONTRACT %create_token (map string bytes) ;
405
                             IF_NONE { PUSH int 1333 ; FAILWITH } {} ;
406
                             NIL operation ;
407
                             SWAP ;
408
                             PUSH mutez 0 ;
409
                             DIG 3 ;
410
                             CDR ;
411
                             TRANSFER_TOKENS ;
412
                             CONS } }
413
                       { IF_LEFT
414
                           { SWAP ;
415
                             DUP ;
416
                             DUG 2 ;
417
                             CAR ;
418
                             GET 8 ;
419
                             SWAP ;
420
                             DUP ;
421
                             DUG 2 ;
422
                             CDR ;
423
                             GET ;
424
                             IF_NONE { PUSH int 1387 ; FAILWITH } {} ;
425
                             DUP ;
426
                             GET 3 ;
427
                             GET 4 ;
428
                             IF_NONE
429
                               {}
430
                               { DUP 3 ;
431
                                 CAR ;
432
                                 ITER { DUP 4 ;
433
                                        CDR ;
434
                                        SWAP ;
435
                                        PAIR ;
436
                                        DUP 5 ;
437
                                        DUP ;
438
                                        GET 10 ;
439
                                        PUSH nat 1 ;
440
                                        DIG 7 ;
441
                                        GET 10 ;
442
                                        DUP 5 ;
443
                                        GET ;
444
                                        IF_NONE { PUSH int 1393 ; FAILWITH } {} ;
445
                                        SUB ;
446
                                        ISNAT ;
447
                                        IF_NONE { PUSH int 1393 ; FAILWITH } {} ;
448
                                        SOME ;
449
                                        DIG 3 ;
450
                                        UPDATE ;
451
                                        UPDATE 10 ;
452
                                        DUG 3 } ;
453
                                 DROP } ;
454
                             CAR ;
455
                             GET 3 ;
456
                             CDR ;
457
                             IF_NONE
458
                               { DROP }
459
                               { DIG 2 ;
460
                                 UNPAIR ;
461
                                 UNPAIR ;
462
                                 SWAP ;
463
                                 UNPAIR ;
464
                                 SWAP ;
465
                                 UNPAIR ;
466
                                 SWAP ;
467
                                 UNPAIR ;
468
                                 SWAP ;
469
                                 DUP ;
470
                                 DIG 8 ;
471
                                 CDR ;
472
                                 DUP ;
473
                                 DUG 2 ;
474
                                 GET ;
475
                                 IF_NONE { PUSH int 1397 ; FAILWITH } {} ;
476
                                 UNPAIR ;
477
                                 UNPAIR ;
478
                                 SWAP ;
479
                                 UNPAIR ;
480
                                 CAR ;
481
                                 PUSH nat 1 ;
482
                                 DIG 12 ;
483
                                 ADD ;
484
                                 SOME ;
485
                                 SWAP ;
486
                                 PAIR ;
487
                                 PAIR ;
488
                                 SWAP ;
489
                                 PAIR ;
490
                                 PAIR ;
491
                                 SOME ;
492
                                 SWAP ;
493
                                 UPDATE ;
494
                                 SWAP ;
495
                                 PAIR ;
496
                                 SWAP ;
497
                                 PAIR ;
498
                                 SWAP ;
499
                                 PAIR ;
500
                                 SWAP ;
501
                                 PAIR ;
502
                                 PAIR } ;
503
                             NIL operation }
504
                           { IF_LEFT
505
                               { SWAP ;
506
                                 DUP ;
507
                                 DUG 2 ;
508
                                 GET 3 ;
509
                                 CAR ;
510
                                 CDR ;
511
                                 SENDER ;
512
                                 MEM ;
513
                                 IF {} { PUSH int 1372 ; FAILWITH } ;
514
                                 DUP ;
515
                                 CAR ;
516
                                 CAR ;
517
                                 CONTRACT %lock (pair (bool %metadata)
518
                                                      (pair (bool %mint) (nat %token_id))) ;
519
                                 IF_NONE { PUSH int 1403 ; FAILWITH } {} ;
520
                                 NIL operation ;
521
                                 SWAP ;
522
                                 PUSH mutez 0 ;
523
                                 DIG 3 ;
524
                                 DUP ;
525
                                 GET 4 ;
526
                                 SWAP ;
527
                                 DUP ;
528
                                 GET 3 ;
529
                                 SWAP ;
530
                                 CAR ;
531
                                 CDR ;
532
                                 PAIR 3 ;
533
                                 TRANSFER_TOKENS ;
534
                                 CONS }
535
                               { SWAP ;
536
                                 DUP ;
537
                                 DUG 2 ;
538
                                 GET 3 ;
539
                                 CAR ;
540
                                 CDR ;
541
                                 SENDER ;
542
                                 MEM ;
543
                                 IF {} { PUSH int 1419 ; FAILWITH } ;
544
                                 DUP ;
545
                                 CAR ;
546
                                 CONTRACT %mint (pair
547
                                                  (list %mint_items (pair (nat %amount)
548
                                                                         (address %to_)))
549
                                                  (nat %token_id)) ;
550
                                 IF_NONE { PUSH int 1426 ; FAILWITH } {} ;
551
                                 NIL operation ;
552
                                 SWAP ;
553
                                 PUSH mutez 0 ;
554
                                 DIG 3 ;
555
                                 DUP ;
556
                                 GET 4 ;
557
                                 SWAP ;
558
                                 GET 3 ;
559
                                 PAIR ;
560
                                 TRANSFER_TOKENS ;
561
                                 CONS } } } }
562
                   { IF_LEFT
563
                       { IF_LEFT
564
                           { SWAP ;
565
                             DUP ;
566
                             DUG 2 ;
567
                             CAR ;
568
                             GET 5 ;
569
                             SENDER ;
570
                             COMPARE ;
571
                             EQ ;
572
                             IF
573
                               { PUSH bool True }
574
                               { SWAP ; DUP ; DUG 2 ; CAR ; CAR ; CAR ; CDR ; SENDER ; COMPARE ; EQ } ;
575
                             IF {} { PUSH int 1039 ; FAILWITH } ;
576
                             SWAP ;
577
                             DUP ;
578
                             DUG 2 ;
579
                             DUP ;
580
                             GET 7 ;
581
                             DUP ;
582
                             DUP 4 ;
583
                             CDR ;
584
                             DUP ;
585
                             DUG 2 ;
586
                             GET ;
587
                             IF_NONE { PUSH int 1040 ; FAILWITH } {} ;
588
                             UNPAIR ;
589
                             SWAP ;
590
                             UNPAIR ;
591
                             CDR ;
592
                             DUP 7 ;
593
                             CAR ;
594
                             DIG 8 ;
595
                             GET 7 ;
596
                             DUP 9 ;
597
                             CDR ;
598
                             GET ;
599
                             IF_NONE { PUSH int 1040 ; FAILWITH } {} ;
600
                             GET 3 ;
601
                             CAR ;
602
                             SUB ;
603
                             ISNAT ;
604
                             IF_NONE { PUSH int 1040 ; FAILWITH } {} ;
605
                             PAIR ;
606
                             PAIR ;
607
                             SWAP ;
608
                             PAIR ;
609
                             SOME ;
610
                             SWAP ;
611
                             UPDATE ;
612
                             UPDATE 7 ;
613
                             DUP ;
614
                             GET 7 ;
615
                             DUP ;
616
                             DUP 4 ;
617
                             CDR ;
618
                             DUP ;
619
                             DUG 2 ;
620
                             GET ;
621
                             IF_NONE { PUSH int 1041 ; FAILWITH } {} ;
622
                             DUP ;
623
                             GET 7 ;
624
                             DIG 5 ;
625
                             CAR ;
626
                             ADD ;
627
                             UPDATE 7 ;
628
                             SOME ;
629
                             SWAP ;
630
                             UPDATE ;
631
                             UPDATE 7 ;
632
                             NIL operation }
633
                           { SWAP ;
634
                             DUP ;
635
                             DUG 2 ;
636
                             GET 3 ;
637
                             CAR ;
638
                             CDR ;
639
                             SENDER ;
640
                             MEM ;
641
                             IF {} { PUSH int 1348 ; FAILWITH } ;
642
                             DUP ;
643
                             CAR ;
644
                             CONTRACT %update_token_metadata (list (pair (nat %token_id)
645
                                                                        (map %token_info
646
                                                                          string
647
                                                                          bytes))) ;
648
                             IF_NONE { PUSH int 1355 ; FAILWITH } {} ;
649
                             NIL operation ;
650
                             SWAP ;
651
                             PUSH mutez 0 ;
652
                             DIG 3 ;
653
                             CDR ;
654
                             TRANSFER_TOKENS ;
655
                             CONS } }
656
                       { IF_LEFT
657
                           { DROP ;
658
                             DUP ;
659
                             GET 5 ;
660
                             CDR ;
661
                             SENDER ;
662
                             COMPARE ;
663
                             EQ ;
664
                             IF {} { PUSH int 1102 ; FAILWITH } ;
665
                             DUP ;
666
                             UNPAIR ;
667
                             UNPAIR ;
668
                             UNPAIR ;
669
                             CDR ;
670
                             DIG 4 ;
671
                             GET 5 ;
672
                             CDR ;
673
                             PAIR ;
674
                             PAIR ;
675
                             PAIR ;
676
                             PAIR ;
677
                             NIL operation }
678
                           { IF_LEFT
679
                               { SWAP ;
680
                                 DUP ;
681
                                 DUG 2 ;
682
                                 GET 7 ;
683
                                 SWAP ;
684
                                 DUP ;
685
                                 DUG 2 ;
686
                                 GET 4 ;
687
                                 MEM ;
688
                                 IF { PUSH int 446 ; FAILWITH } {} ;
689
                                 SWAP ;
690
                                 DUP ;
691
                                 DUG 2 ;
692
                                 CAR ;
693
                                 GET 3 ;
694
                                 CDR ;
695
                                 SWAP ;
696
                                 DUP ;
697
                                 DUG 2 ;
698
                                 CAR ;
699
                                 CDR ;
700
                                 GET ;
701
                                 IF_NONE { PUSH int 447 ; FAILWITH } {} ;
702
                                 DUP 3 ;
703
                                 CAR ;
704
                                 CAR ;
705
                                 GET 3 ;
706
                                 SWAP ;
707
                                 DUP ;
708
                                 DUG 2 ;
709
                                 GET 3 ;
710
                                 CAR ;
711
                                 GET ;
712
                                 IF_NONE { PUSH int 448 ; FAILWITH } {} ;
713
                                 DUP ;
714
                                 GET 5 ;
715
                                 IF { PUSH int 449 ; FAILWITH } {} ;
716
                                 SWAP ;
717
                                 DUP ;
718
                                 DUG 2 ;
719
                                 GET 3 ;
720
                                 GET 3 ;
721
                                 IF_NONE
722
                                   {}
723
                                   { NOW ; COMPARE ; LT ; IF {} { PUSH int 453 ; FAILWITH } } ;
724
                                 PUSH nat 0 ;
725
                                 DUP 3 ;
726
                                 GET 3 ;
727
                                 GET 4 ;
728
                                 SIZE ;
729
                                 COMPARE ;
730
                                 GT ;
731
                                 IF
732
                                   { SWAP ;
733
                                     DUP ;
734
                                     DUG 2 ;
735
                                     GET 3 ;
736
                                     GET 4 ;
737
                                     SENDER ;
738
                                     MEM ;
739
                                     IF {} { PUSH int 457 ; FAILWITH } }
740
                                   {} ;
741
                                 SWAP ;
742
                                 DUP ;
743
                                 DUG 2 ;
744
                                 CAR ;
745
                                 GET 3 ;
746
                                 IF_NONE
747
                                   {}
748
                                   { DUP ;
749
                                     PUSH nat 0 ;
750
                                     COMPARE ;
751
                                     LT ;
752
                                     IF {} { PUSH int 461 ; FAILWITH } ;
753
                                     DIG 4 ;
754
                                     UNPAIR ;
755
                                     UNPAIR ;
756
                                     SWAP ;
757
                                     UNPAIR ;
758
                                     UNPAIR ;
759
                                     SWAP ;
760
                                     DUP ;
761
                                     DUP 10 ;
762
                                     CAR ;
763
                                     CDR ;
764
                                     DUP ;
765
                                     DUG 2 ;
766
                                     GET ;
767
                                     IF_NONE { PUSH int 464 ; FAILWITH } {} ;
768
                                     UNPAIR ;
769
                                     UNPAIR ;
770
                                     SWAP ;
771
                                     CDR ;
772
                                     PUSH nat 1 ;
773
                                     DIG 10 ;
774
                                     SUB ;
775
                                     ISNAT ;
776
                                     IF_NONE { PUSH int 464 ; FAILWITH } {} ;
777
                                     SOME ;
778
                                     PAIR ;
779
                                     SWAP ;
780
                                     PAIR ;
781
                                     PAIR ;
782
                                     SOME ;
783
                                     SWAP ;
784
                                     UPDATE ;
785
                                     SWAP ;
786
                                     PAIR ;
787
                                     PAIR ;
788
                                     SWAP ;
789
                                     PAIR ;
790
                                     PAIR ;
791
                                     DUG 3 } ;
792
                                 SWAP ;
793
                                 DUP ;
794
                                 DUG 2 ;
795
                                 GET 8 ;
796
                                 DUP 4 ;
797
                                 GET 5 ;
798
                                 MEM ;
799
                                 IF {} { PUSH int 467 ; FAILWITH } ;
800
                                 SWAP ;
801
                                 DUP ;
802
                                 DUG 2 ;
803
                                 GET 8 ;
804
                                 DUP 4 ;
805
                                 GET 5 ;
806
                                 GET ;
807
                                 IF_NONE { PUSH int 468 ; FAILWITH } {} ;
808
                                 IF_NONE
809
                                   {}
810
                                   { DUP 4 ;
811
                                     GET 8 ;
812
                                     COMPARE ;
813
                                     EQ ;
814
                                     IF {} { PUSH int 469 ; FAILWITH } } ;
815
                                 EMPTY_MAP address nat ;
816
                                 DUP 3 ;
817
                                 GET 7 ;
818
                                 CAR ;
819
                                 CDR ;
820
                                 SOME ;
821
                                 DUP 6 ;
822
                                 GET 9 ;
823
                                 UPDATE ;
824
                                 DUP 3 ;
825
                                 GET 7 ;
826
                                 CAR ;
827
                                 CAR ;
828
                                 DUP 3 ;
829
                                 CAR ;
830
                                 CAR ;
831
                                 ITER { DUP 3 ;
832
                                        PUSH nat 10000 ;
833
                                        DUP 3 ;
834
                                        CDR ;
835
                                        DUP 5 ;
836
                                        MUL ;
837
                                        EDIV ;
838
                                        IF_NONE { PUSH int 480 ; FAILWITH } { CAR } ;
839
                                        DIG 4 ;
840
                                        DUP 4 ;
841
                                        CAR ;
842
                                        GET ;
843
                                        IF_NONE { PUSH nat 0 } {} ;
844
                                        ADD ;
845
                                        SOME ;
846
                                        DIG 2 ;
847
                                        CAR ;
848
                                        UPDATE ;
849
                                        SWAP } ;
850
                                 DUP 4 ;
851
                                 GET 7 ;
852
                                 GET 3 ;
853
                                 DUP 6 ;
854
                                 GET 3 ;
855
                                 ITER { DUP 4 ;
856
                                        PUSH nat 10000 ;
857
                                        DUP 3 ;
858
                                        CDR ;
859
                                        DUP 5 ;
860
                                        MUL ;
861
                                        EDIV ;
862
                                        IF_NONE { PUSH int 485 ; FAILWITH } { CAR } ;
863
                                        DIG 5 ;
864
                                        DUP 4 ;
865
                                        CAR ;
866
                                        GET ;
867
                                        IF_NONE { PUSH nat 0 } {} ;
868
                                        ADD ;
869
                                        SOME ;
870
                                        DIG 2 ;
871
                                        CAR ;
872
                                        UPDATE ;
873
                                        DUG 2 } ;
874
                                 DUP 5 ;
875
                                 GET 7 ;
876
                                 GET 6 ;
877
                                 ITER { DUP 4 ;
878
                                        SWAP ;
879
                                        DUP ;
880
                                        DUG 2 ;
881
                                        CDR ;
882
                                        DIG 5 ;
883
                                        DUP 4 ;
884
                                        CAR ;
885
                                        GET ;
886
                                        IF_NONE { PUSH nat 0 } {} ;
887
                                        ADD ;
888
                                        SOME ;
889
                                        DIG 2 ;
890
                                        CAR ;
891
                                        UPDATE ;
892
                                        DUG 2 } ;
893
                                 DUP 5 ;
894
                                 GET 7 ;
895
                                 GET 5 ;
896
                                 ITER { DUP 4 ;
897
                                        SWAP ;
898
                                        DUP ;
899
                                        DUG 2 ;
900
                                        CDR ;
901
                                        DIG 5 ;
902
                                        DUP 4 ;
903
                                        CAR ;
904
                                        GET ;
905
                                        IF_NONE { PUSH nat 0 } {} ;
906
                                        ADD ;
907
                                        SOME ;
908
                                        DIG 2 ;
909
                                        CAR ;
910
                                        UPDATE ;
911
                                        DUG 2 } ;
912
                                 DROP 2 ;
913
                                 DUP 3 ;
914
                                 CAR ;
915
                                 GET 5 ;
916
                                 IF_NONE
917
                                   { SWAP ; DROP ; NIL operation }
918
                                   { DIG 2 ;
919
                                     DROP ;
920
                                     DUP ;
921
                                     CAR ;
922
                                     CONTRACT %enforce_conditions (list (pair
923
                                                                         (pair
924
                                                                           (nat %amount)
925
                                                                           (pair
926
                                                                             (address %claimer)
927
                                                                             (bytes %condition_id)))
928
                                                                         (pair
929
                                                                           (address %creator)
930
                                                                           (pair
931
                                                                             (option %extra bytes)
932
                                                                             (pair %token
933
                                                                               (address %address)
934
                                                                               (nat %token_id)))))) ;
935
                                     IF_NONE { PUSH int 517 ; FAILWITH } {} ;
936
                                     NIL operation ;
937
                                     SWAP ;
938
                                     PUSH mutez 0 ;
939
                                     NIL (pair (pair nat (pair address bytes))
940
                                               (pair address
941
                                                     (pair (option bytes)
942
                                                           (pair address nat)))) ;
943
                                     DIG 7 ;
944
                                     DUP ;
945
                                     GET 8 ;
946
                                     SWAP ;
947
                                     DUP ;
948
                                     DUG 9 ;
949
                                     GET 5 ;
950
                                     PAIR ;
951
                                     DUP 9 ;
952
                                     CAR ;
953
                                     CAR ;
954
                                     PAIR ;
955
                                     DUP 10 ;
956
                                     CAR ;
957
                                     CAR ;
958
                                     CAR ;
959
                                     CAR ;
960
                                     PAIR ;
961
                                     DIG 5 ;
962
                                     CDR ;
963
                                     SENDER ;
964
                                     PAIR ;
965
                                     PUSH nat 1 ;
966
                                     PAIR ;
967
                                     PAIR ;
968
                                     CONS ;
969
                                     TRANSFER_TOKENS ;
970
                                     CONS } ;
971
                                 DUP 4 ;
972
                                 GET 5 ;
973
                                 CONTRACT %transfer (list (pair (address %from_)
974
                                                               (list %txs (pair
975
                                                                           (address %to_)
976
                                                                           (pair
977
                                                                             (nat %token_id)
978
                                                                             (nat %amount)))))) ;
979
                                 IF_NONE { PUSH int 1462 ; FAILWITH } {} ;
980
                                 PUSH mutez 0 ;
981
                                 NIL (pair address (list (pair address (pair nat nat)))) ;
982
                                 NIL (pair address (pair nat nat)) ;
983
                                 DUP 7 ;
984
                                 CAR ;
985
                                 GET 6 ;
986
                                 DUP 9 ;
987
                                 GET 8 ;
988
                                 SELF_ADDRESS ;
989
                                 PAIR 3 ;
990
                                 CONS ;
991
                                 SENDER ;
992
                                 PAIR ;
993
                                 CONS ;
994
                                 TRANSFER_TOKENS ;
995
                                 CONS ;
996
                                 DIG 4 ;
997
                                 DUP ;
998
                                 GET 7 ;
999
                                 DUP 5 ;
1000
                                 CAR ;
1001
                                 GET 6 ;
1002
                                 PUSH nat 0 ;
1003
                                 PAIR ;
1004
                                 EMPTY_SET address ;
1005
                                 PUSH bool True ;
1006
                                 SENDER ;
1007
                                 UPDATE ;
1008
                                 DIG 5 ;
1009
                                 PAIR ;
1010
                                 PAIR ;
1011
                                 DUP 5 ;
1012
                                 GET 5 ;
1013
                                 EMPTY_SET nat ;
1014
                                 PAIR ;
1015
                                 PUSH nat 0 ;
1016
                                 PAIR ;
1017
                                 PAIR ;
1018
                                 DUP 6 ;
1019
                                 CAR ;
1020
                                 CDR ;
1021
                                 PUSH bool True ;
1022
                                 PAIR ;
1023
                                 EMPTY_SET address ;
1024
                                 PUSH bool True ;
1025
                                 SENDER ;
1026
                                 UPDATE ;
1027
                                 EMPTY_SET nat ;
1028
                                 PAIR ;
1029
                                 PAIR ;
1030
                                 DIG 5 ;
1031
                                 DUP ;
1032
                                 CAR ;
1033
                                 CAR ;
1034
                                 GET 3 ;
1035
                                 SWAP ;
1036
                                 DUP ;
1037
                                 DUG 7 ;
1038
                                 CAR ;
1039
                                 CAR ;
1040
                                 GET 4 ;
1041
                                 PAIR ;
1042
                                 DIG 6 ;
1043
                                 CAR ;
1044
                                 CAR ;
1045
                                 CAR ;
1046
                                 PAIR ;
1047
                                 PAIR ;
1048
                                 PAIR ;
1049
                                 SOME ;
1050
                                 DIG 4 ;
1051
                                 GET 4 ;
1052
                                 UPDATE ;
1053
                                 UPDATE 7 ;
1054
                                 SWAP }
1055
                               { SWAP ;
1056
                                 DUP ;
1057
                                 DUG 2 ;
1058
                                 GET 7 ;
1059
                                 SWAP ;
1060
                                 DUP ;
1061
                                 DUG 2 ;
1062
                                 GET 4 ;
1063
                                 GET ;
1064
                                 IF_NONE { PUSH int 1013 ; FAILWITH } {} ;
1065
                                 DUP 3 ;
1066
                                 CAR ;
1067
                                 CAR ;
1068
                                 GET 3 ;
1069
                                 DUP 3 ;
1070
                                 GET 7 ;
1071
                                 GET ;
1072
                                 IF_NONE { PUSH int 1014 ; FAILWITH } {} ;
1073
                                 DUP ;
1074
                                 GET 5 ;
1075
                                 IF { PUSH int 1015 ; FAILWITH } {} ;
1076
                                 SWAP ;
1077
                                 DUP ;
1078
                                 DUG 2 ;
1079
                                 CAR ;
1080
                                 CAR ;
1081
                                 GET 3 ;
1082
                                 IF
1083
                                   { SWAP ; DUP ; DUG 2 ; CAR ; GET 3 ; CDR ; SENDER ; MEM }
1084
                                   { PUSH bool False } ;
1085
                                 IF
1086
                                   { PUSH bool True }
1087
                                   { SWAP ;
1088
                                     DUP ;
1089
                                     DUG 2 ;
1090
                                     CAR ;
1091
                                     CAR ;
1092
                                     GET 4 ;
1093
                                     IF
1094
                                       { DUP ;
1095
                                         CAR ;
1096
                                         CAR ;
1097
                                         SENDER ;
1098
                                         MEM ;
1099
                                         IF
1100
                                           { PUSH bool True }
1101
                                           { DUP 4 ; CAR ; GET 3 ; CAR ; SENDER ; MEM } ;
1102
                                         IF
1103
                                           { PUSH bool True }
1104
                                           { DUP 4 ; CAR ; CAR ; CAR ; CAR ; SENDER ; COMPARE ; EQ } }
1105
                                       { PUSH bool False } } ;
1106
                                 IF {} { PUSH int 1601 ; FAILWITH } ;
1107
                                 NIL operation ;
1108
                                 DUP 4 ;
1109
                                 GET 5 ;
1110
                                 CONTRACT %update_operators (list (or
1111
                                                                   (pair %add_operator
1112
                                                                     (address %owner)
1113
                                                                     (pair
1114
                                                                       (address %operator)
1115
                                                                       (nat %token_id)))
1116
                                                                   (pair %remove_operator
1117
                                                                     (address %owner)
1118
                                                                     (pair
1119
                                                                       (address %operator)
1120
                                                                       (nat %token_id))))) ;
1121
                                 IF_NONE { PUSH int 1476 ; FAILWITH } {} ;
1122
                                 PUSH mutez 0 ;
1123
                                 NIL (or (pair address (pair address nat))
1124
                                         (pair address (pair address nat))) ;
1125
                                 DUP 7 ;
1126
                                 GET 8 ;
1127
                                 DUP 9 ;
1128
                                 CAR ;
1129
                                 GET 5 ;
1130
                                 SELF_ADDRESS ;
1131
                                 PAIR 3 ;
1132
                                 LEFT (pair address (pair address nat)) ;
1133
                                 CONS ;
1134
                                 TRANSFER_TOKENS ;
1135
                                 CONS ;
1136
                                 DUP ;
1137
                                 DUP 6 ;
1138
                                 CAR ;
1139
                                 GET 5 ;
1140
                                 CONTRACT %fulfill_offer_gallery (pair (nat %offer_id)
1141
                                                                       (pair
1142
                                                                         (nat %exhibition_id)
1143
                                                                         (pair
1144
                                                                           (option %token_id nat)
1145
                                                                           (pair
1146
                                                                             (option %condition_extra bytes)
1147
                                                                             (option %price_minimum (map
1148
                                                                                                     (or
1149
                                                                                                       (address %fa12)
1150
                                                                                                       (or
1151
                                                                                                         (pair %fa2
1152
                                                                                                           (address %address)
1153
                                                                                                           (nat %token_id))
1154
                                                                                                         (unit %tez)))
1155
                                                                                                     nat)))))) ;
1156
                                 IF_NONE { PUSH int 1534 ; FAILWITH } {} ;
1157
                                 PUSH mutez 0 ;
1158
                                 DUP 6 ;
1159
                                 GET 3 ;
1160
                                 GET 4 ;
1161
                                 DIG 7 ;
1162
                                 DUP ;
1163
                                 CAR ;
1164
                                 SWAP ;
1165
                                 DUP ;
1166
                                 DUG 9 ;
1167
                                 GET 8 ;
1168
                                 SOME ;
1169
                                 DIG 9 ;
1170
                                 DUP ;
1171
                                 GET 7 ;
1172
                                 SWAP ;
1173
                                 DUP ;
1174
                                 DUG 11 ;
1175
                                 GET 3 ;
1176
                                 PAIR 5 ;
1177
                                 DIG 4 ;
1178
                                 DROP ;
1179
                                 DIG 4 ;
1180
                                 DROP ;
1181
                                 TRANSFER_TOKENS ;
1182
                                 CONS ;
1183
                                 PUSH nat 1 ;
1184
                                 DIG 2 ;
1185
                                 GET 8 ;
1186
                                 COMPARE ;
1187
                                 GE ;
1188
                                 IF {} { PUSH int 1023 ; FAILWITH } ;
1189
                                 DUP 3 ;
1190
                                 DUP ;
1191
                                 GET 7 ;
1192
                                 DUP ;
1193
                                 DUP 5 ;
1194
                                 GET 4 ;
1195
                                 DUP ;
1196
                                 DUG 2 ;
1197
                                 GET ;
1198
                                 IF_NONE { PUSH int 1024 ; FAILWITH } {} ;
1199
                                 PUSH nat 1 ;
1200
                                 DIG 7 ;
1201
                                 GET 7 ;
1202
                                 DUP 8 ;
1203
                                 GET 4 ;
1204
                                 GET ;
1205
                                 IF_NONE { PUSH int 1024 ; FAILWITH } {} ;
1206
                                 GET 8 ;
1207
                                 SUB ;
1208
                                 ISNAT ;
1209
                                 IF_NONE { PUSH int 1024 ; FAILWITH } {} ;
1210
                                 UPDATE 8 ;
1211
                                 SOME ;
1212
                                 SWAP ;
1213
                                 UPDATE ;
1214
                                 UPDATE 7 ;
1215
                                 DUP ;
1216
                                 GET 7 ;
1217
                                 DUP ;
1218
                                 DIG 4 ;
1219
                                 GET 4 ;
1220
                                 DUP ;
1221
                                 DUG 2 ;
1222
                                 GET ;
1223
                                 IF_NONE { PUSH int 1025 ; FAILWITH } {} ;
1224
                                 DUP ;
1225
                                 GET 7 ;
1226
                                 PUSH nat 1 ;
1227
                                 ADD ;
1228
                                 UPDATE 7 ;
1229
                                 SOME ;
1230
                                 SWAP ;
1231
                                 UPDATE ;
1232
                                 UPDATE 7 ;
1233
                                 SWAP } } } } }
1234
               { IF_LEFT
1235
                   { IF_LEFT
1236
                       { IF_LEFT
1237
                           { SWAP ;
1238
                             DUP ;
1239
                             DUG 2 ;
1240
                             CAR ;
1241
                             CAR ;
1242
                             CAR ;
1243
                             CAR ;
1244
                             SENDER ;
1245
                             COMPARE ;
1246
                             EQ ;
1247
                             IF {} { PUSH int 1142 ; FAILWITH } ;
1248
                             SWAP ;
1249
                             UNPAIR ;
1250
                             UNPAIR ;
1251
                             SWAP ;
1252
                             UNPAIR ;
1253
                             UNPAIR ;
1254
                             PUSH (option unit) (Some Unit) ;
1255
                             DIG 6 ;
1256
                             UPDATE ;
1257
                             PAIR ;
1258
                             PAIR ;
1259
                             SWAP ;
1260
                             PAIR ;
1261
                             PAIR }
1262
                           { SWAP ;
1263
                             DUP ;
1264
                             DUG 2 ;
1265
                             CAR ;
1266
                             CAR ;
1267
                             CAR ;
1268
                             CAR ;
1269
                             SENDER ;
1270
                             COMPARE ;
1271
                             EQ ;
1272
                             IF {} { PUSH int 1142 ; FAILWITH } ;
1273
                             SWAP ;
1274
                             DUP ;
1275
                             DUG 2 ;
1276
                             GET 3 ;
1277
                             CAR ;
1278
                             CAR ;
1279
                             SWAP ;
1280
                             DUP ;
1281
                             DUG 2 ;
1282
                             VIEW "is_allowed_mint_adapter" bool ;
1283
                             IF_NONE { PUSH int 51 ; FAILWITH } {} ;
1284
                             IF {} { PUSH int 1300 ; FAILWITH } ;
1285
                             SWAP ;
1286
                             UNPAIR ;
1287
                             SWAP ;
1288
                             UNPAIR ;
1289
                             UNPAIR ;
1290
                             UNPAIR ;
1291
                             SWAP ;
1292
                             PUSH (option unit) (Some Unit) ;
1293
                             DIG 6 ;
1294
                             UPDATE ;
1295
                             SWAP ;
1296
                             PAIR ;
1297
                             PAIR ;
1298
                             PAIR ;
1299
                             SWAP ;
1300
                             PAIR } ;
1301
                         NIL operation }
1302
                       { IF_LEFT
1303
                           { SWAP ;
1304
                             DUP ;
1305
                             DUG 2 ;
1306
                             GET 7 ;
1307
                             SWAP ;
1308
                             DUP ;
1309
                             DUG 2 ;
1310
                             CAR ;
1311
                             GET ;
1312
                             IF_NONE { PUSH int 833 ; FAILWITH } {} ;
1313
                             DUP 3 ;
1314
                             CAR ;
1315
                             GET 8 ;
1316
                             SWAP ;
1317
                             DUP ;
1318
                             DUG 2 ;
1319
                             CAR ;
1320
                             GET 6 ;
1321
                             GET ;
1322
                             IF_NONE { PUSH int 834 ; FAILWITH } {} ;
1323
                             DUP 4 ;
1324
                             CAR ;
1325
                             CAR ;
1326
                             GET 3 ;
1327
                             SWAP ;
1328
                             DUP ;
1329
                             DUG 2 ;
1330
                             GET 3 ;
1331
                             CAR ;
1332
                             GET ;
1333
                             IF_NONE { PUSH int 835 ; FAILWITH } {} ;
1334
                             PUSH nat 0 ;
1335
                             NIL (pair address (pair nat nat)) ;
1336
                             DUP 6 ;
1337
                             CDR ;
1338
                             ITER { DUP ;
1339
                                    DUG 2 ;
1340
                                    CAR ;
1341
                                    DUP 8 ;
1342
                                    CAR ;
1343
                                    GET 4 ;
1344
                                    DUP 4 ;
1345
                                    CDR ;
1346
                                    PAIR 3 ;
1347
                                    CONS ;
1348
                                    SWAP ;
1349
                                    DIG 2 ;
1350
                                    SWAP ;
1351
                                    CAR ;
1352
                                    ADD ;
1353
                                    SWAP } ;
1354
                             SWAP ;
1355
                             DUP ;
1356
                             DUG 2 ;
1357
                             DUP 6 ;
1358
                             GET 8 ;
1359
                             COMPARE ;
1360
                             GE ;
1361
                             IF {} { PUSH int 843 ; FAILWITH } ;
1362
                             DUP 5 ;
1363
                             CAR ;
1364
                             CAR ;
1365
                             GET 3 ;
1366
                             IF
1367
                               { DUP 5 ; CAR ; GET 3 ; CDR ; SENDER ; MEM }
1368
                               { PUSH bool False } ;
1369
                             IF
1370
                               { DIG 2 ; DROP ; DIG 2 ; DROP ; DIG 2 ; DROP ; PUSH bool True }
1371
                               { DUP 5 ;
1372
                                 CAR ;
1373
                                 CAR ;
1374
                                 GET 4 ;
1375
                                 IF
1376
                                   { DIG 3 ;
1377
                                     DROP ;
1378
                                     DIG 3 ;
1379
                                     DROP ;
1380
                                     DIG 2 ;
1381
                                     CAR ;
1382
                                     CAR ;
1383
                                     SENDER ;
1384
                                     MEM ;
1385
                                     IF
1386
                                       { PUSH bool True }
1387
                                       { DUP 4 ; CAR ; GET 3 ; CAR ; SENDER ; MEM } ;
1388
                                     IF
1389
                                       { PUSH bool True }
1390
                                       { DUP 4 ; CAR ; CAR ; CAR ; CAR ; SENDER ; COMPARE ; EQ } }
1391
                                   { DIG 2 ; DROP ; DIG 2 ; DROP ; DIG 2 ; DROP ; PUSH bool False } } ;
1392
                             IF {} { PUSH int 1601 ; FAILWITH } ;
1393
                             NIL operation ;
1394
                             DUP 4 ;
1395
                             CAR ;
1396
                             CAR ;
1397
                             CONTRACT %transfer (list (pair (address %from_)
1398
                                                           (list %txs (pair
1399
                                                                       (address %to_)
1400
                                                                       (pair
1401
                                                                         (nat %token_id)
1402
                                                                         (nat %amount)))))) ;
1403
                             IF_NONE { PUSH int 1462 ; FAILWITH } {} ;
1404
                             PUSH mutez 0 ;
1405
                             NIL (pair address (list (pair address (pair nat nat)))) ;
1406
                             DIG 4 ;
1407
                             SELF_ADDRESS ;
1408
                             PAIR ;
1409
                             CONS ;
1410
                             TRANSFER_TOKENS ;
1411
                             CONS ;
1412
                             DUP 4 ;
1413
                             DUP ;
1414
                             GET 7 ;
1415
                             DUP ;
1416
                             DUP 6 ;
1417
                             CAR ;
1418
                             DUP ;
1419
                             DUG 2 ;
1420
                             GET ;
1421
                             IF_NONE { PUSH int 848 ; FAILWITH } {} ;
1422
                             DUP 6 ;
1423
                             DIG 8 ;
1424
                             GET 7 ;
1425
                             DUP 9 ;
1426
                             CAR ;
1427
                             GET ;
1428
                             IF_NONE { PUSH int 848 ; FAILWITH } {} ;
1429
                             GET 8 ;
1430
                             SUB ;
1431
                             ISNAT ;
1432
                             IF_NONE { PUSH int 848 ; FAILWITH } {} ;
1433
                             UPDATE 8 ;
1434
                             SOME ;
1435
                             SWAP ;
1436
                             UPDATE ;
1437
                             UPDATE 7 ;
1438
                             DUP ;
1439
                             GET 7 ;
1440
                             DUP ;
1441
                             DIG 5 ;
1442
                             CAR ;
1443
                             DUP ;
1444
                             DUG 2 ;
1445
                             GET ;
1446
                             IF_NONE { PUSH int 849 ; FAILWITH } {} ;
1447
                             DUP ;
1448
                             GET 7 ;
1449
                             DIG 6 ;
1450
                             ADD ;
1451
                             UPDATE 7 ;
1452
                             SOME ;
1453
                             SWAP ;
1454
                             UPDATE ;
1455
                             UPDATE 7 ;
1456
                             SWAP }
1457
                           { IF_LEFT
1458
                               { SWAP ;
1459
                                 DUP ;
1460
                                 DUG 2 ;
1461
                                 GET 7 ;
1462
                                 SWAP ;
1463
                                 DUP ;
1464
                                 DUG 2 ;
1465
                                 CDR ;
1466
                                 GET ;
1467
                                 IF_NONE { PUSH int 796 ; FAILWITH } {} ;
1468
                                 DUP 3 ;
1469
                                 CAR ;
1470
                                 GET 8 ;
1471
                                 SWAP ;
1472
                                 DUP ;
1473
                                 DUG 2 ;
1474
                                 CAR ;
1475
                                 GET 6 ;
1476
                                 GET ;
1477
                                 IF_NONE { PUSH int 797 ; FAILWITH } {} ;
1478
                                 DUP 4 ;
1479
                                 CAR ;
1480
                                 CAR ;
1481
                                 GET 3 ;
1482
                                 SWAP ;
1483
                                 DUP ;
1484
                                 DUG 2 ;
1485
                                 GET 3 ;
1486
                                 CAR ;
1487
                                 GET ;
1488
                                 IF_NONE { PUSH int 798 ; FAILWITH } {} ;
1489
                                 DUP 3 ;
1490
                                 CAR ;
1491
                                 GET 3 ;
1492
                                 CDR ;
1493
                                 SENDER ;
1494
                                 MEM ;
1495
                                 IF
1496
                                   { PUSH bool True }
1497
                                   { DUP ; CAR ; CAR ; SENDER ; MEM } ;
1498
                                 IF
1499
                                   { PUSH bool True }
1500
                                   { DUP 5 ; CAR ; GET 3 ; CAR ; SENDER ; MEM } ;
1501
                                 IF
1502
                                   { PUSH bool True }
1503
                                   { SENDER ; DUP 6 ; CAR ; CAR ; CAR ; CAR ; COMPARE ; EQ } ;
1504
                                 IF {} { PUSH int 801 ; FAILWITH } ;
1505
                                 DUP 3 ;
1506
                                 CAR ;
1507
                                 GET 5 ;
1508
                                 IF { PUSH int 803 ; FAILWITH } {} ;
1509
                                 DUP 4 ;
1510
                                 CAR ;
1511
                                 DUP 4 ;
1512
                                 GET 8 ;
1513
                                 COMPARE ;
1514
                                 GE ;
1515
                                 IF {} { PUSH int 805 ; FAILWITH } ;
1516
                                 NIL operation ;
1517
                                 DUP 5 ;
1518
                                 GET 3 ;
1519
                                 CONTRACT %burn (list (pair (address %from_)
1520
                                                           (pair (nat %token_id)
1521
                                                                 (nat %amount)))) ;
1522
                                 IF_NONE { PUSH int 1451 ; FAILWITH } {} ;
1523
                                 PUSH mutez 0 ;
1524
                                 NIL (pair address (pair nat nat)) ;
1525
                                 DIG 7 ;
1526
                                 DUP ;
1527
                                 CAR ;
1528
                                 SWAP ;
1529
                                 DUP ;
1530
                                 DUG 9 ;
1531
                                 GET 6 ;
1532
                                 SELF_ADDRESS ;
1533
                                 PAIR 3 ;
1534
                                 CONS ;
1535
                                 TRANSFER_TOKENS ;
1536
                                 CONS ;
1537
                                 PUSH nat 0 ;
1538
                                 DIG 4 ;
1539
                                 DUP ;
1540
                                 GET 7 ;
1541
                                 SWAP ;
1542
                                 DUP ;
1543
                                 DUG 6 ;
1544
                                 GET 3 ;
1545
                                 CAR ;
1546
                                 ADD ;
1547
                                 COMPARE ;
1548
                                 EQ ;
1549
                                 IF
1550
                                   { DUP 4 ; GET 8 ; DUP 6 ; CAR ; COMPARE ; EQ }
1551
                                   { PUSH bool False } ;
1552
                                 IF
1553
                                   { DUP 3 ;
1554
                                     GET 3 ;
1555
                                     GET 4 ;
1556
                                     IF_NONE
1557
                                       {}
1558
                                       { DUP 5 ;
1559
                                         CAR ;
1560
                                         GET 3 ;
1561
                                         CDR ;
1562
                                         ITER { DUP 6 ;
1563
                                                CAR ;
1564
                                                GET 6 ;
1565
                                                SWAP ;
1566
                                                PAIR ;
1567
                                                DUP 8 ;
1568
                                                DUP ;
1569
                                                GET 10 ;
1570
                                                PUSH nat 1 ;
1571
                                                DIG 10 ;
1572
                                                GET 10 ;
1573
                                                DUP 5 ;
1574
                                                GET ;
1575
                                                IF_NONE { PUSH int 815 ; FAILWITH } {} ;
1576
                                                SUB ;
1577
                                                ISNAT ;
1578
                                                IF_NONE { PUSH int 815 ; FAILWITH } {} ;
1579
                                                SOME ;
1580
                                                DIG 3 ;
1581
                                                UPDATE ;
1582
                                                UPDATE 10 ;
1583
                                                DUG 6 } ;
1584
                                         DROP } ;
1585
                                     DUP 3 ;
1586
                                     CAR ;
1587
                                     GET 3 ;
1588
                                     CDR ;
1589
                                     IF_NONE
1590
                                       { SWAP ; DROP ; SWAP ; DROP ; SWAP ; DROP }
1591
                                       { DIG 2 ;
1592
                                         DROP ;
1593
                                         DIG 2 ;
1594
                                         DROP ;
1595
                                         DIG 4 ;
1596
                                         UNPAIR ;
1597
                                         UNPAIR ;
1598
                                         SWAP ;
1599
                                         UNPAIR ;
1600
                                         SWAP ;
1601
                                         UNPAIR ;
1602
                                         SWAP ;
1603
                                         UNPAIR ;
1604
                                         SWAP ;
1605
                                         DUP ;
1606
                                         DIG 9 ;
1607
                                         CAR ;
1608
                                         GET 6 ;
1609
                                         DUP ;
1610
                                         DUG 2 ;
1611
                                         GET ;
1612
                                         IF_NONE { PUSH int 819 ; FAILWITH } {} ;
1613
                                         UNPAIR ;
1614
                                         UNPAIR ;
1615
                                         SWAP ;
1616
                                         UNPAIR ;
1617
                                         CAR ;
1618
                                         PUSH nat 1 ;
1619
                                         DIG 12 ;
1620
                                         ADD ;
1621
                                         SOME ;
1622
                                         SWAP ;
1623
                                         PAIR ;
1624
                                         PAIR ;
1625
                                         SWAP ;
1626
                                         PAIR ;
1627
                                         PAIR ;
1628
                                         SOME ;
1629
                                         SWAP ;
1630
                                         UPDATE ;
1631
                                         SWAP ;
1632
                                         PAIR ;
1633
                                         SWAP ;
1634
                                         PAIR ;
1635
                                         SWAP ;
1636
                                         PAIR ;
1637
                                         SWAP ;
1638
                                         PAIR ;
1639
                                         PAIR ;
1640
                                         DUG 2 } ;
1641
                                     DIG 2 ;
1642
                                     DUP ;
1643
                                     GET 7 ;
1644
                                     NONE (pair
1645
                                            (pair (pair nat (pair bool bool))
1646
                                                  (pair (pair (set nat) (set address))
1647
                                                        (pair bool nat)))
1648
                                            (pair
1649
                                              (pair nat
1650
                                                    (pair (set nat)
1651
                                                          (option (map
1652
                                                                   (or address
1653
                                                                       (or
1654
                                                                         (pair address
1655
                                                                               nat)
1656
                                                                         unit))
1657
                                                                   nat))))
1658
                                              (pair
1659
                                                (pair (map address nat) (set address))
1660
                                                (pair nat nat)))) ;
1661
                                     DIG 4 ;
1662
                                     CDR ;
1663
                                     UPDATE ;
1664
                                     UPDATE 7 ;
1665
                                     SWAP }
1666
                                   { SWAP ;
1667
                                     DROP ;
1668
                                     SWAP ;
1669
                                     DROP ;
1670
                                     SWAP ;
1671
                                     DROP ;
1672
                                     DUP 3 ;
1673
                                     DUP ;
1674
                                     GET 7 ;
1675
                                     DUP ;
1676
                                     DUP 5 ;
1677
                                     CDR ;
1678
                                     DUP ;
1679
                                     DUG 2 ;
1680
                                     GET ;
1681
                                     IF_NONE { PUSH int 824 ; FAILWITH } {} ;
1682
                                     DUP 6 ;
1683
                                     CAR ;
1684
                                     DIG 7 ;
1685
                                     GET 7 ;
1686
                                     DIG 7 ;
1687
                                     CDR ;
1688
                                     GET ;
1689
                                     IF_NONE { PUSH int 824 ; FAILWITH } {} ;
1690
                                     GET 8 ;
1691
                                     SUB ;
1692
                                     ISNAT ;
1693
                                     IF_NONE { PUSH int 824 ; FAILWITH } {} ;
1694
                                     UPDATE 8 ;
1695
                                     SOME ;
1696
                                     SWAP ;
1697
                                     UPDATE ;
1698
                                     UPDATE 7 ;
1699
                                     SWAP } }
1700
                               { SWAP ;
1701
                                 DUP ;
1702
                                 DUG 2 ;
1703
                                 CAR ;
1704
                                 CAR ;
1705
                                 CAR ;
1706
                                 CAR ;
1707
                                 SENDER ;
1708
                                 COMPARE ;
1709
                                 EQ ;
1710
                                 IF
1711
                                   { PUSH bool True }
1712
                                   { SWAP ; DUP ; DUG 2 ; CAR ; GET 3 ; CAR ; SENDER ; MEM } ;
1713
                                 IF {} { PUSH int 1137 ; FAILWITH } ;
1714
                                 DUP ;
1715
                                 CAR ;
1716
                                 CONTRACT %set_administrator address ;
1717
                                 IF_NONE { PUSH int 199 ; FAILWITH } {} ;
1718
                                 NIL operation ;
1719
                                 SWAP ;
1720
                                 PUSH mutez 0 ;
1721
                                 DIG 3 ;
1722
                                 CDR ;
1723
                                 TRANSFER_TOKENS ;
1724
                                 CONS } } } }
1725
                   { IF_LEFT
1726
                       { IF_LEFT
1727
                           { SWAP ;
1728
                             DUP ;
1729
                             DUG 2 ;
1730
                             CAR ;
1731
                             GET 8 ;
1732
                             SWAP ;
1733
                             DUP ;
1734
                             DUG 2 ;
1735
                             GET 5 ;
1736
                             GET ;
1737
                             IF_NONE { PUSH int 581 ; FAILWITH } {} ;
1738
                             DUP ;
1739
                             GET 7 ;
1740
                             IF { PUSH int 582 ; FAILWITH } {} ;
1741
                             DUP 3 ;
1742
                             CAR ;
1743
                             CAR ;
1744
                             GET 3 ;
1745
                             SWAP ;
1746
                             DUP ;
1747
                             DUG 2 ;
1748
                             GET 3 ;
1749
                             CAR ;
1750
                             GET ;
1751
                             IF_NONE { PUSH int 583 ; FAILWITH } {} ;
1752
                             DUP ;
1753
                             GET 5 ;
1754
                             IF { PUSH int 584 ; FAILWITH } {} ;
1755
                             SWAP ;
1756
                             DUP ;
1757
                             DUG 2 ;
1758
                             GET 3 ;
1759
                             GET 3 ;
1760
                             IF_NONE
1761
                               {}
1762
                               { NOW ; COMPARE ; LT ; IF {} { PUSH int 588 ; FAILWITH } } ;
1763
                             SWAP ;
1764
                             DUP ;
1765
                             DUG 2 ;
1766
                             CAR ;
1767
                             GET 6 ;
1768
                             DUP 4 ;
1769
                             CAR ;
1770
                             GET 4 ;
1771
                             MEM ;
1772
                             IF {} { PUSH int 591 ; FAILWITH } ;
1773
                             PUSH nat 0 ;
1774
                             DUP 3 ;
1775
                             CAR ;
1776
                             GET 3 ;
1777
                             CAR ;
1778
                             SIZE ;
1779
                             COMPARE ;
1780
                             GT ;
1781
                             IF
1782
                               { SWAP ;
1783
                                 DUP ;
1784
                                 DUG 2 ;
1785
                                 CAR ;
1786
                                 GET 3 ;
1787
                                 CAR ;
1788
                                 SENDER ;
1789
                                 MEM ;
1790
                                 IF
1791
                                   { PUSH bool True }
1792
                                   { DUP ;
1793
                                     CAR ;
1794
                                     CAR ;
1795
                                     SENDER ;
1796
                                     MEM ;
1797
                                     IF
1798
                                       { PUSH bool True }
1799
                                       { DUP 4 ; CAR ; GET 3 ; CAR ; SENDER ; MEM } ;
1800
                                     IF
1801
                                       { PUSH bool True }
1802
                                       { SENDER ; DUP 5 ; CAR ; CAR ; CAR ; CAR ; COMPARE ; EQ } } ;
1803
                                 IF {} { PUSH int 595 ; FAILWITH } ;
1804
                                 DUP 3 ;
1805
                                 CAR ;
1806
                                 CAR ;
1807
                                 ITER { CAR ;
1808
                                        DUP 3 ;
1809
                                        CAR ;
1810
                                        GET 3 ;
1811
                                        CAR ;
1812
                                        SWAP ;
1813
                                        MEM ;
1814
                                        IF {} { PUSH int 598 ; FAILWITH } } }
1815
                               {} ;
1816
                             EMPTY_MAP address nat ;
1817
                             DUP 3 ;
1818
                             GET 11 ;
1819
                             SOME ;
1820
                             DUP 6 ;
1821
                             GET 9 ;
1822
                             UPDATE ;
1823
                             DUP 3 ;
1824
                             GET 9 ;
1825
                             CDR ;
1826
                             DUP 3 ;
1827
                             CAR ;
1828
                             CAR ;
1829
                             ITER { DUP 3 ;
1830
                                    PUSH nat 10000 ;
1831
                                    DUP 3 ;
1832
                                    CDR ;
1833
                                    DUP 5 ;
1834
                                    MUL ;
1835
                                    EDIV ;
1836
                                    IF_NONE { PUSH int 607 ; FAILWITH } { CAR } ;
1837
                                    DIG 4 ;
1838
                                    DUP 4 ;
1839
                                    CAR ;
1840
                                    GET ;
1841
                                    IF_NONE { PUSH nat 0 } {} ;
1842
                                    ADD ;
1843
                                    SOME ;
1844
                                    DIG 2 ;
1845
                                    CAR ;
1846
                                    UPDATE ;
1847
                                    SWAP } ;
1848
                             DUP 4 ;
1849
                             GET 9 ;
1850
                             CAR ;
1851
                             DUP 6 ;
1852
                             CAR ;
1853
                             CAR ;
1854
                             ITER { DUP 4 ;
1855
                                    PUSH nat 10000 ;
1856
                                    DUP 3 ;
1857
                                    CDR ;
1858
                                    DUP 5 ;
1859
                                    MUL ;
1860
                                    EDIV ;
1861
                                    IF_NONE { PUSH int 611 ; FAILWITH } { CAR } ;
1862
                                    DIG 5 ;
1863
                                    DUP 4 ;
1864
                                    CAR ;
1865
                                    GET ;
1866
                                    IF_NONE { PUSH nat 0 } {} ;
1867
                                    ADD ;
1868
                                    SOME ;
1869
                                    DIG 2 ;
1870
                                    CAR ;
1871
                                    UPDATE ;
1872
                                    DUG 2 } ;
1873
                             DUP 5 ;
1874
                             GET 12 ;
1875
                             ITER { DUP 4 ;
1876
                                    SWAP ;
1877
                                    DUP ;
1878
                                    DUG 2 ;
1879
                                    CDR ;
1880
                                    DIG 5 ;
1881
                                    DUP 4 ;
1882
                                    CAR ;
1883
                                    GET ;
1884
                                    IF_NONE { PUSH nat 0 } {} ;
1885
                                    ADD ;
1886
                                    SOME ;
1887
                                    DIG 2 ;
1888
                                    CAR ;
1889
                                    UPDATE ;
1890
                                    DUG 2 } ;
1891
                             EMPTY_SET address ;
1892
                             DUP 7 ;
1893
                             CAR ;
1894
                             CAR ;
1895
                             ITER { CAR ; SWAP ; PUSH bool True ; DIG 2 ; UPDATE } ;
1896
                             NIL operation ;
1897
                             DUP 8 ;
1898
                             GET 6 ;
1899
                             CONTRACT %init_mint (pair
1900
                                                   (pair
1901
                                                     (pair (nat %airdrop_capacity)
1902
                                                           (set %creators address))
1903
                                                     (pair (bytes %data)
1904
                                                           (option %extra bytes)))
1905
                                                   (pair
1906
                                                     (pair (address %fa2)
1907
                                                           (nat %mint_invite_id))
1908
                                                     (pair
1909
                                                       (option %price_minimum (map
1910
                                                                               (or
1911
                                                                                 (address %fa12)
1912
                                                                                 (or
1913
                                                                                   (pair %fa2
1914
                                                                                     (address %address)
1915
                                                                                     (nat %token_id))
1916
                                                                                   (unit %tez)))
1917
                                                                               nat))
1918
                                                       (map %sales_split address nat)))) ;
1919
                             IF_NONE { PUSH int 1287 ; FAILWITH } {} ;
1920
                             PUSH mutez 0 ;
1921
                             DUP 7 ;
1922
                             DUP 10 ;
1923
                             GET 5 ;
1924
                             CDR ;
1925
                             PAIR ;
1926
                             DIG 10 ;
1927
                             DUP ;
1928
                             GET 5 ;
1929
                             SWAP ;
1930
                             DUP ;
1931
                             DUG 12 ;
1932
                             CAR ;
1933
                             GET 4 ;
1934
                             PAIR ;
1935
                             PAIR ;
1936
                             DUP 10 ;
1937
                             GET 5 ;
1938
                             CAR ;
1939
                             CAR ;
1940
                             IF_NONE { PUSH int 621 ; FAILWITH } {} ;
1941
                             DUP 12 ;
1942
                             GET 6 ;
1943
                             GET ;
1944
                             IF_NONE { PUSH int 622 ; FAILWITH } {} ;
1945
                             DUP 12 ;
1946
                             GET 3 ;
1947
                             PAIR ;
1948
                             DUP 6 ;
1949
                             DUP 12 ;
1950
                             CAR ;
1951
                             CAR ;
1952
                             CAR ;
1953
                             PAIR ;
1954
                             PAIR ;
1955
                             PAIR ;
1956
                             TRANSFER_TOKENS ;
1957
                             CONS ;
1958
                             DUP 7 ;
1959
                             GET 3 ;
1960
                             GET 4 ;
1961
                             IF_NONE
1962
                               {}
1963
                               { DUP 9 ;
1964
                                 CAR ;
1965
                                 CAR ;
1966
                                 ITER { CAR ;
1967
                                        DUP 10 ;
1968
                                        GET 5 ;
1969
                                        SWAP ;
1970
                                        PAIR ;
1971
                                        DUP 11 ;
1972
                                        GET 10 ;
1973
                                        SWAP ;
1974
                                        DUP ;
1975
                                        DUG 2 ;
1976
                                        GET ;
1977
                                        IF_NONE { PUSH nat 0 } {} ;
1978
                                        DUP 3 ;
1979
                                        SWAP ;
1980
                                        DUP ;
1981
                                        DUG 2 ;
1982
                                        COMPARE ;
1983
                                        LT ;
1984
                                        IF {} { PUSH int 629 ; FAILWITH } ;
1985
                                        DIG 11 ;
1986
                                        DUP ;
1987
                                        GET 10 ;
1988
                                        PUSH nat 1 ;
1989
                                        DIG 3 ;
1990
                                        ADD ;
1991
                                        SOME ;
1992
                                        DIG 3 ;
1993
                                        UPDATE ;
1994
                                        UPDATE 10 ;
1995
                                        DUG 9 } ;
1996
                                 DROP } ;
1997
                             DUP 7 ;
1998
                             CAR ;
1999
                             GET 3 ;
2000
                             CDR ;
2001
                             IF_NONE
2002
                               {}
2003
                               { DUP ;
2004
                                 PUSH nat 0 ;
2005
                                 COMPARE ;
2006
                                 LT ;
2007
                                 IF {} { PUSH int 634 ; FAILWITH } ;
2008
                                 DIG 9 ;
2009
                                 UNPAIR ;
2010
                                 UNPAIR ;
2011
                                 SWAP ;
2012
                                 UNPAIR ;
2013
                                 SWAP ;
2014
                                 UNPAIR ;
2015
                                 SWAP ;
2016
                                 UNPAIR ;
2017
                                 SWAP ;
2018
                                 DUP ;
2019
                                 DUP 16 ;
2020
                                 GET 5 ;
2021
                                 DUP ;
2022
                                 DUG 2 ;
2023
                                 GET ;
2024
                                 IF_NONE { PUSH int 635 ; FAILWITH } {} ;
2025
                                 UNPAIR ;
2026
                                 UNPAIR ;
2027
                                 SWAP ;
2028
                                 UNPAIR ;
2029
                                 CAR ;
2030
                                 PUSH nat 1 ;
2031
                                 DIG 12 ;
2032
                                 SUB ;
2033
                                 ISNAT ;
2034
                                 IF_NONE { PUSH int 635 ; FAILWITH } {} ;
2035
                                 SOME ;
2036
                                 SWAP ;
2037
                                 PAIR ;
2038
                                 PAIR ;
2039
                                 SWAP ;
2040
                                 PAIR ;
2041
                                 PAIR ;
2042
                                 SOME ;
2043
                                 SWAP ;
2044
                                 UPDATE ;
2045
                                 SWAP ;
2046
                                 PAIR ;
2047
                                 SWAP ;
2048
                                 PAIR ;
2049
                                 SWAP ;
2050
                                 PAIR ;
2051
                                 SWAP ;
2052
                                 PAIR ;
2053
                                 PAIR ;
2054
                                 DUG 8 } ;
2055
                             DUP 7 ;
2056
                             CAR ;
2057
                             GET 5 ;
2058
                             IF_NONE
2059
                               { SWAP ;
2060
                                 DROP ;
2061
                                 SWAP ;
2062
                                 DROP ;
2063
                                 SWAP ;
2064
                                 DROP ;
2065
                                 SWAP ;
2066
                                 DROP ;
2067
                                 SWAP ;
2068
                                 DROP ;
2069
                                 SWAP ;
2070
                                 DROP ;
2071
                                 SWAP ;
2072
                                 DROP }
2073
                               { DIG 2 ;
2074
                                 DROP ;
2075
                                 DIG 2 ;
2076
                                 DROP ;
2077
                                 DIG 2 ;
2078
                                 DROP ;
2079
                                 DIG 2 ;
2080
                                 DROP ;
2081
                                 DIG 2 ;
2082
                                 DROP ;
2083
                                 DIG 2 ;
2084
                                 DROP ;
2085
                                 DUP ;
2086
                                 DUG 2 ;
2087
                                 CAR ;
2088
                                 CONTRACT %enforce_conditions (list (pair
2089
                                                                     (pair (nat %amount)
2090
                                                                           (pair
2091
                                                                             (address %claimer)
2092
                                                                             (bytes %condition_id)))
2093
                                                                     (pair
2094
                                                                       (address %creator)
2095
                                                                       (pair
2096
                                                                         (option %extra bytes)
2097
                                                                         (pair %token
2098
                                                                           (address %address)
2099
                                                                           (nat %token_id)))))) ;
2100
                                 IF_NONE { PUSH int 517 ; FAILWITH } {} ;
2101
                                 PUSH mutez 0 ;
2102
                                 NIL (pair (pair nat (pair address bytes))
2103
                                           (pair address
2104
                                                 (pair (option bytes) (pair address nat)))) ;
2105
                                 PUSH (pair address nat) (Pair
2106
                                         0x0000b28066369a8ed09ba9d3d47f19598440266013f0
2107
                                         0) ;
2108
                                 DIG 6 ;
2109
                                 CAR ;
2110
                                 GET 3 ;
2111
                                 PAIR ;
2112
                                 DUP 7 ;
2113
                                 CAR ;
2114
                                 CAR ;
2115
                                 CAR ;
2116
                                 CAR ;
2117
                                 PAIR ;
2118
                                 DIG 5 ;
2119
                                 CDR ;
2120
                                 SENDER ;
2121
                                 PAIR ;
2122
                                 PUSH nat 0 ;
2123
                                 PAIR ;
2124
                                 PAIR ;
2125
                                 CONS ;
2126
                                 TRANSFER_TOKENS ;
2127
                                 CONS } }
2128
                           { SWAP ;
2129
                             DUP ;
2130
                             DUG 2 ;
2131
                             CAR ;
2132
                             CAR ;
2133
                             GET 3 ;
2134
                             SWAP ;
2135
                             DUP ;
2136
                             DUG 2 ;
2137
                             GET 3 ;
2138
                             CAR ;
2139
                             GET ;
2140
                             IF_NONE { PUSH int 380 ; FAILWITH } {} ;
2141
                             DUP ;
2142
                             GET 5 ;
2143
                             IF { PUSH int 381 ; FAILWITH } {} ;
2144
                             DUP ;
2145
                             GET 9 ;
2146
                             DUP 3 ;
2147
                             GET 7 ;
2148
                             CAR ;
2149
                             CDR ;
2150
                             COMPARE ;
2151
                             NEQ ;
2152
                             IF
2153
                               { PUSH bool True }
2154
                               { DUP ; GET 7 ; CDR ; DUP 3 ; GET 7 ; CAR ; CAR ; COMPARE ; NEQ } ;
2155
                             IF
2156
                               { DUP 3 ;
2157
                                 CAR ;
2158
                                 CAR ;
2159
                                 CAR ;
2160
                                 CAR ;
2161
                                 SENDER ;
2162
                                 COMPARE ;
2163
                                 EQ ;
2164
                                 IF
2165
                                   { PUSH bool True }
2166
                                   { DUP 3 ; CAR ; GET 3 ; CAR ; SENDER ; MEM } ;
2167
                                 IF {} { PUSH int 1137 ; FAILWITH } }
2168
                               {} ;
2169
                             SWAP ;
2170
                             DUP ;
2171
                             GET 7 ;
2172
                             CAR ;
2173
                             CDR ;
2174
                             SWAP ;
2175
                             DUP ;
2176
                             DUG 3 ;
2177
                             GET 7 ;
2178
                             CAR ;
2179
                             CAR ;
2180
                             ADD ;
2181
                             DUP 3 ;
2182
                             GET 7 ;
2183
                             GET 3 ;
2184
                             ADD ;
2185
                             DUP 3 ;
2186
                             GET 7 ;
2187
                             GET 6 ;
2188
                             ITER { CDR ; ADD } ;
2189
                             DUP 3 ;
2190
                             GET 7 ;
2191
                             GET 5 ;
2192
                             ITER { CDR ; ADD } ;
2193
                             DUP 4 ;
2194
                             CAR ;
2195
                             CAR ;
2196
                             GET 4 ;
2197
                             UNIT ;
2198
                             VIEW "get_management_fee" nat ;
2199
                             IF_NONE { PUSH int 1578 ; FAILWITH } {} ;
2200
                             PUSH nat 10000 ;
2201
                             SUB ;
2202
                             ISNAT ;
2203
                             IF_NONE { PUSH int 396 ; FAILWITH } {} ;
2204
                             COMPARE ;
2205
                             EQ ;
2206
                             IF {} { PUSH int 396 ; FAILWITH } ;
2207
                             CAR ;
2208
                             CAR ;
2209
                             SENDER ;
2210
                             MEM ;
2211
                             IF
2212
                               { PUSH bool True }
2213
                               { SWAP ; DUP ; DUG 2 ; CAR ; GET 3 ; CAR ; SENDER ; MEM } ;
2214
                             IF
2215
                               { PUSH bool True }
2216
                               { SWAP ; DUP ; DUG 2 ; CAR ; CAR ; CAR ; CAR ; SENDER ; COMPARE ; EQ } ;
2217
                             IF {} { PUSH int 399 ; FAILWITH } ;
2218
                             SWAP ;
2219
                             DUP ;
2220
                             DUG 2 ;
2221
                             UNPAIR ;
2222
                             UNPAIR ;
2223
                             SWAP ;
2224
                             UNPAIR ;
2225
                             UNPAIR ;
2226
                             SWAP ;
2227
                             DIG 5 ;
2228
                             DUP ;
2229
                             GET 8 ;
2230
                             SWAP ;
2231
                             DUP ;
2232
                             DUG 7 ;
2233
                             GET 7 ;
2234
                             PAIR ;
2235
                             DUP 7 ;
2236
                             GET 5 ;
2237
                             PAIR ;
2238
                             DIG 6 ;
2239
                             DUP ;
2240
                             GET 3 ;
2241
                             GET 4 ;
2242
                             SWAP ;
2243
                             DUP ;
2244
                             DUG 8 ;
2245
                             GET 3 ;
2246
                             GET 3 ;
2247
                             PAIR ;
2248
                             DUP 8 ;
2249
                             GET 3 ;
2250
                             CAR ;
2251
                             PAIR ;
2252
                             PAIR ;
2253
                             DIG 6 ;
2254
                             DUP ;
2255
                             CAR ;
2256
                             GET 6 ;
2257
                             SWAP ;
2258
                             DUP ;
2259
                             DUG 8 ;
2260
                             CAR ;
2261
                             GET 5 ;
2262
                             PAIR ;
2263
                             DUP 8 ;
2264
                             CAR ;
2265
                             GET 3 ;
2266
                             PAIR ;
2267
                             DIG 7 ;
2268
                             DUP ;
2269
                             CAR ;
2270
                             CAR ;
2271
                             GET 4 ;
2272
                             SWAP ;
2273
                             DUP ;
2274
                             DUG 9 ;
2275
                             CAR ;
2276
                             CAR ;
2277
                             GET 3 ;
2278
                             PAIR ;
2279
                             DIG 8 ;
2280
                             CAR ;
2281
                             CAR ;
2282
                             CAR ;
2283
                             PAIR ;
2284
                             PAIR ;
2285
                             PAIR ;
2286
                             SOME ;
2287
                             DIG 6 ;
2288
                             GET 3 ;
2289
                             GET 5 ;
2290
                             UPDATE ;
2291
                             SWAP ;
2292
                             PAIR ;
2293
                             PAIR ;
2294
                             SWAP ;
2295
                             PAIR ;
2296
                             SWAP ;
2297
                             UNPAIR ;
2298
                             UNPAIR ;
2299
                             SWAP ;
2300
                             UNPAIR ;
2301
                             SWAP ;
2302
                             UNPAIR ;
2303
                             PUSH nat 1 ;
2304
                             ADD ;
2305
                             PAIR ;
2306
                             SWAP ;
2307
                             PAIR ;
2308
                             SWAP ;
2309
                             PAIR ;
2310
                             PAIR ;
2311
                             SWAP ;
2312
                             PAIR ;
2313
                             NIL operation } }
2314
                       { IF_LEFT
2315
                           { SWAP ;
2316
                             DUP ;
2317
                             DUG 2 ;
2318
                             CAR ;
2319
                             CAR ;
2320
                             GET 3 ;
2321
                             SWAP ;
2322
                             DUP ;
2323
                             DUG 2 ;
2324
                             GET 3 ;
2325
                             CAR ;
2326
                             GET ;
2327
                             IF_NONE { PUSH int 303 ; FAILWITH } {} ;
2328
                             DUP ;
2329
                             CAR ;
2330
                             CAR ;
2331
                             SENDER ;
2332
                             MEM ;
2333
                             IF
2334
                               { PUSH bool True }
2335
                               { DUP 3 ; CAR ; GET 3 ; CAR ; SENDER ; MEM } ;
2336
                             IF
2337
                               { PUSH bool True }
2338
                               { DUP 3 ; CAR ; CAR ; CAR ; CAR ; SENDER ; COMPARE ; EQ } ;
2339
                             IF {} { PUSH int 304 ; FAILWITH } ;
2340
                             DUP ;
2341
                             GET 5 ;
2342
                             IF { PUSH int 305 ; FAILWITH } {} ;
2343
                             PUSH nat 0 ;
2344
                             DUP 3 ;
2345
                             CAR ;
2346
                             GET 6 ;
2347
                             SIZE ;
2348
                             COMPARE ;
2349
                             GT ;
2350
                             IF {} { PUSH int 307 ; FAILWITH } ;
2351
                             SWAP ;
2352
                             DUP ;
2353
                             DUG 2 ;
2354
                             CAR ;
2355
                             GET 6 ;
2356
                             ITER { SWAP ;
2357
                                    DUP ;
2358
                                    DUG 2 ;
2359
                                    CAR ;
2360
                                    CDR ;
2361
                                    SWAP ;
2362
                                    MEM ;
2363
                                    IF {} { PUSH int 309 ; FAILWITH } } ;
2364
                             DUP ;
2365
                             GET 6 ;
2366
                             DUP 3 ;
2367
                             GET 5 ;
2368
                             CAR ;
2369
                             CAR ;
2370
                             IF_NONE
2371
                               {}
2372
                               { DUP ;
2373
                                 ITER { CAR ;
2374
                                        DUP 6 ;
2375
                                        GET 3 ;
2376
                                        CAR ;
2377
                                        CDR ;
2378
                                        SWAP ;
2379
                                        MEM ;
2380
                                        IF {} { PUSH int 316 ; FAILWITH } } ;
2381
                                 DROP } ;
2382
                             DUP 3 ;
2383
                             GET 8 ;
2384
                             IF_NONE
2385
                               { SWAP ; DROP }
2386
                               { SWAP ;
2387
                                 DROP ;
2388
                                 SWAP ;
2389
                                 DROP ;
2390
                                 DUP 3 ;
2391
                                 CAR ;
2392
                                 CAR ;
2393
                                 CAR ;
2394
                                 CAR ;
2395
                                 SENDER ;
2396
                                 COMPARE ;
2397
                                 EQ ;
2398
                                 IF
2399
                                   { PUSH bool True }
2400
                                   { DUP 3 ; CAR ; GET 3 ; CAR ; SENDER ; MEM } ;
2401
                                 IF {} { PUSH int 1137 ; FAILWITH } ;
2402
                                 DUP ;
2403
                                 GET 3 ;
2404
                                 SWAP ;
2405
                                 DUP ;
2406
                                 DUG 2 ;
2407
                                 CAR ;
2408
                                 CDR ;
2409
                                 ADD ;
2410
                                 SWAP ;
2411
                                 DUP ;
2412
                                 DUG 2 ;
2413
                                 CAR ;
2414
                                 CAR ;
2415
                                 ADD ;
2416
                                 SWAP ;
2417
                                 DUP ;
2418
                                 DUG 2 ;
2419
                                 GET 4 ;
2420
                                 ITER { CDR ; ADD } ;
2421
                                 DUP 4 ;
2422
                                 CAR ;
2423
                                 CAR ;
2424
                                 GET 4 ;
2425
                                 UNIT ;
2426
                                 VIEW "get_management_fee" nat ;
2427
                                 IF_NONE { PUSH int 1578 ; FAILWITH } {} ;
2428
                                 PUSH nat 10000 ;
2429
                                 SUB ;
2430
                                 ISNAT ;
2431
                                 IF_NONE { PUSH int 1621 ; FAILWITH } {} ;
2432
                                 COMPARE ;
2433
                                 EQ ;
2434
                                 IF {} { PUSH int 1621 ; FAILWITH } } ;
2435
                             DUP 3 ;
2436
                             UNPAIR ;
2437
                             UNPAIR ;
2438
                             SWAP ;
2439
                             UNPAIR ;
2440
                             SWAP ;
2441
                             UNPAIR ;
2442
                             SWAP ;
2443
                             UNPAIR ;
2444
                             SWAP ;
2445
                             DIG 6 ;
2446
                             PUSH bool False ;
2447
                             PAIR ;
2448
                             DIG 7 ;
2449
                             DUP ;
2450
                             GET 5 ;
2451
                             CDR ;
2452
                             SWAP ;
2453
                             DUP ;
2454
                             DUG 9 ;
2455
                             GET 5 ;
2456
                             CAR ;
2457
                             PAIR ;
2458
                             PAIR ;
2459
                             DIG 7 ;
2460
                             DUP ;
2461
                             GET 3 ;
2462
                             GET 4 ;
2463
                             SWAP ;
2464
                             DUP ;
2465
                             DUG 9 ;
2466
                             GET 3 ;
2467
                             GET 3 ;
2468
                             PAIR ;
2469
                             DUP 9 ;
2470
                             GET 3 ;
2471
                             CAR ;
2472
                             PAIR ;
2473
                             PAIR ;
2474
                             DIG 7 ;
2475
                             DUP ;
2476
                             CAR ;
2477
                             GET 6 ;
2478
                             SWAP ;
2479
                             DUP ;
2480
                             DUG 9 ;
2481
                             CAR ;
2482
                             GET 5 ;
2483
                             PAIR ;
2484
                             DIG 8 ;
2485
                             DUP ;
2486
                             CAR ;
2487
                             GET 3 ;
2488
                             CDR ;
2489
                             SWAP ;
2490
                             DUP ;
2491
                             DUG 10 ;
2492
                             CAR ;
2493
                             GET 3 ;
2494
                             CAR ;
2495
                             PAIR ;
2496
                             PAIR ;
2497
                             DIG 8 ;
2498
                             DUP ;
2499
                             CAR ;
2500
                             CAR ;
2501
                             GET 4 ;
2502
                             SWAP ;
2503
                             DUP ;
2504
                             DUG 10 ;
2505
                             CAR ;
2506
                             CAR ;
2507
                             GET 3 ;
2508
                             PAIR ;
2509
                             DIG 9 ;
2510
                             CAR ;
2511
                             CAR ;
2512
                             CAR ;
2513
                             PAIR ;
2514
                             PAIR ;
2515
                             PAIR ;
2516
                             SOME ;
2517
                             DIG 7 ;
2518
                             GET 3 ;
2519
                             GET 6 ;
2520
                             UPDATE ;
2521
                             SWAP ;
2522
                             PAIR ;
2523
                             SWAP ;
2524
                             PAIR ;
2525
                             SWAP ;
2526
                             PAIR ;
2527
                             SWAP ;
2528
                             PAIR ;
2529
                             SWAP ;
2530
                             UNPAIR ;
2531
                             UNPAIR ;
2532
                             SWAP ;
2533
                             UNPAIR ;
2534
                             SWAP ;
2535
                             UNPAIR ;
2536
                             SWAP ;
2537
                             PUSH nat 1 ;
2538
                             ADD ;
2539
                             SWAP ;
2540
                             PAIR ;
2541
                             SWAP ;
2542
                             PAIR ;
2543
                             SWAP ;
2544
                             PAIR ;
2545
                             PAIR ;
2546
                             SWAP ;
2547
                             PAIR ;
2548
                             NIL operation }
2549
                           { IF_LEFT
2550
                               { SWAP ;
2551
                                 DUP ;
2552
                                 DUG 2 ;
2553
                                 GET 7 ;
2554
                                 SWAP ;
2555
                                 DUP ;
2556
                                 DUG 2 ;
2557
                                 GET 6 ;
2558
                                 GET ;
2559
                                 IF_NONE { PUSH int 958 ; FAILWITH } {} ;
2560
                                 DUP 3 ;
2561
                                 CAR ;
2562
                                 CAR ;
2563
                                 GET 3 ;
2564
                                 DUP 3 ;
2565
                                 GET 9 ;
2566
                                 GET ;
2567
                                 IF_NONE { PUSH int 959 ; FAILWITH } {} ;
2568
                                 DUP ;
2569
                                 GET 5 ;
2570
                                 IF { PUSH int 960 ; FAILWITH } {} ;
2571
                                 SWAP ;
2572
                                 DUP ;
2573
                                 DUG 2 ;
2574
                                 CAR ;
2575
                                 CAR ;
2576
                                 GET 3 ;
2577
                                 IF
2578
                                   { SWAP ; DUP ; DUG 2 ; CAR ; GET 3 ; CDR ; SENDER ; MEM }
2579
                                   { PUSH bool False } ;
2580
                                 IF
2581
                                   { PUSH bool True }
2582
                                   { SWAP ;
2583
                                     DUP ;
2584
                                     DUG 2 ;
2585
                                     CAR ;
2586
                                     CAR ;
2587
                                     GET 4 ;
2588
                                     IF
2589
                                       { DUP ;
2590
                                         CAR ;
2591
                                         CAR ;
2592
                                         SENDER ;
2593
                                         MEM ;
2594
                                         IF
2595
                                           { PUSH bool True }
2596
                                           { DUP 4 ; CAR ; GET 3 ; CAR ; SENDER ; MEM } ;
2597
                                         IF
2598
                                           { PUSH bool True }
2599
                                           { DUP 4 ; CAR ; CAR ; CAR ; CAR ; SENDER ; COMPARE ; EQ } }
2600
                                       { PUSH bool False } } ;
2601
                                 IF {} { PUSH int 1601 ; FAILWITH } ;
2602
                                 PUSH nat 1 ;
2603
                                 DUP 3 ;
2604
                                 GET 8 ;
2605
                                 COMPARE ;
2606
                                 GE ;
2607
                                 IF {} { PUSH int 965 ; FAILWITH } ;
2608
                                 SWAP ;
2609
                                 DUP ;
2610
                                 DUG 2 ;
2611
                                 GET 3 ;
2612
                                 GET 4 ;
2613
                                 IF_NONE
2614
                                   {}
2615
                                   { DUP ;
2616
                                     DUP 5 ;
2617
                                     CAR ;
2618
                                     CAR ;
2619
                                     CDR ;
2620
                                     MEM ;
2621
                                     IF {} { PUSH int 969 ; FAILWITH } ;
2622
                                     DUP 4 ;
2623
                                     CAR ;
2624
                                     CAR ;
2625
                                     CDR ;
2626
                                     GET ;
2627
                                     IF_NONE { PUSH int 970 ; FAILWITH } {} ;
2628
                                     DUP 4 ;
2629
                                     GET 3 ;
2630
                                     CDR ;
2631
                                     COMPARE ;
2632
                                     GE ;
2633
                                     IF {} { PUSH int 970 ; FAILWITH } } ;
2634
                                 DUP 3 ;
2635
                                 CAR ;
2636
                                 CAR ;
2637
                                 CDR ;
2638
                                 IF_LEFT
2639
                                   { LEFT (pair address nat) }
2640
                                   { IF_LEFT
2641
                                       { RIGHT address }
2642
                                       { PUSH int 980 ; FAILWITH } } ;
2643
                                 NIL operation ;
2644
                                 DUP 5 ;
2645
                                 GET 7 ;
2646
                                 CONTRACT %update_operators (list (or
2647
                                                                   (pair %add_operator
2648
                                                                     (address %owner)
2649
                                                                     (pair
2650
                                                                       (address %operator)
2651
                                                                       (nat %token_id)))
2652
                                                                   (pair %remove_operator
2653
                                                                     (address %owner)
2654
                                                                     (pair
2655
                                                                       (address %operator)
2656
                                                                       (nat %token_id))))) ;
2657
                                 IF_NONE { PUSH int 1476 ; FAILWITH } {} ;
2658
                                 PUSH mutez 0 ;
2659
                                 NIL (or (pair address (pair address nat))
2660
                                         (pair address (pair address nat))) ;
2661
                                 DUP 8 ;
2662
                                 GET 10 ;
2663
                                 DUP 10 ;
2664
                                 CAR ;
2665
                                 CAR ;
2666
                                 CAR ;
2667
                                 CDR ;
2668
                                 SELF_ADDRESS ;
2669
                                 PAIR 3 ;
2670
                                 LEFT (pair address (pair address nat)) ;
2671
                                 CONS ;
2672
                                 TRANSFER_TOKENS ;
2673
                                 CONS ;
2674
                                 DUP ;
2675
                                 DUP 7 ;
2676
                                 CAR ;
2677
                                 CAR ;
2678
                                 CAR ;
2679
                                 CDR ;
2680
                                 CONTRACT %create_auction (pair
2681
                                                            (pair %token
2682
                                                              (address %address)
2683
                                                              (nat %token_id))
2684
                                                            (pair
2685
                                                              (or %currency
2686
                                                                (address %fa12)
2687
                                                                (pair %fa2
2688
                                                                  (address %address)
2689
                                                                  (nat %token_id)))
2690
                                                              (pair (nat %reserve)
2691
                                                                    (pair
2692
                                                                      (option %start_time timestamp)
2693
                                                                      (pair
2694
                                                                        (nat %duration)
2695
                                                                        (pair
2696
                                                                          (nat %extension_time)
2697
                                                                          (pair
2698
                                                                            (nat %price_increment)
2699
                                                                            (pair
2700
                                                                              (map %shares
2701
                                                                                address
2702
                                                                                nat)
2703
                                                                              (pair
2704
                                                                                (nat %referral_bonus)
2705
                                                                                (option %condition (pair
2706
                                                                                                    (address %address)
2707
                                                                                                    (bytes %id)))))))))))) ;
2708
                                 IF_NONE { PUSH int 1197 ; FAILWITH } {} ;
2709
                                 PUSH mutez 0 ;
2710
                                 DUP 8 ;
2711
                                 CAR ;
2712
                                 CAR ;
2713
                                 CAR ;
2714
                                 PUSH nat 0 ;
2715
                                 DUP 9 ;
2716
                                 GET 5 ;
2717
                                 CAR ;
2718
                                 DIG 10 ;
2719
                                 DUP ;
2720
                                 GET 3 ;
2721
                                 CAR ;
2722
                                 SWAP ;
2723
                                 DUP ;
2724
                                 CAR ;
2725
                                 GET 4 ;
2726
                                 SWAP ;
2727
                                 DUP ;
2728
                                 CAR ;
2729
                                 GET 3 ;
2730
                                 SWAP ;
2731
                                 DUP ;
2732
                                 GET 5 ;
2733
                                 SWAP ;
2734
                                 DUP ;
2735
                                 DUG 15 ;
2736
                                 GET 3 ;
2737
                                 CDR ;
2738
                                 DUP 13 ;
2739
                                 DIG 16 ;
2740
                                 DUP ;
2741
                                 GET 10 ;
2742
                                 SWAP ;
2743
                                 DUP ;
2744
                                 DUG 18 ;
2745
                                 GET 7 ;
2746
                                 PAIR ;
2747
                                 PAIR 10 ;
2748
                                 DIG 4 ;
2749
                                 DROP ;
2750
                                 DIG 4 ;
2751
                                 DROP ;
2752
                                 DIG 4 ;
2753
                                 DROP ;
2754
                                 DIG 4 ;
2755
                                 DROP ;
2756
                                 TRANSFER_TOKENS ;
2757
                                 CONS ;
2758
                                 DIG 2 ;
2759
                                 DUP ;
2760
                                 GET 7 ;
2761
                                 DUP ;
2762
                                 DUP 5 ;
2763
                                 GET 6 ;
2764
                                 DUP ;
2765
                                 DUG 2 ;
2766
                                 GET ;
2767
                                 IF_NONE { PUSH int 996 ; FAILWITH } {} ;
2768
                                 UNPAIR ;
2769
                                 SWAP ;
2770
                                 UNPAIR ;
2771
                                 UNPAIR ;
2772
                                 PUSH nat 1 ;
2773
                                 ADD ;
2774
                                 PAIR ;
2775
                                 PAIR ;
2776
                                 SWAP ;
2777
                                 PAIR ;
2778
                                 SOME ;
2779
                                 SWAP ;
2780
                                 UPDATE ;
2781
                                 UPDATE 7 ;
2782
                                 DUP ;
2783
                                 DUG 3 ;
2784
                                 DUP ;
2785
                                 GET 7 ;
2786
                                 DUP ;
2787
                                 DUP 5 ;
2788
                                 GET 6 ;
2789
                                 DUP ;
2790
                                 DUG 2 ;
2791
                                 GET ;
2792
                                 IF_NONE { PUSH int 997 ; FAILWITH } {} ;
2793
                                 PUSH nat 1 ;
2794
                                 DIG 7 ;
2795
                                 GET 7 ;
2796
                                 DUP 8 ;
2797
                                 GET 6 ;
2798
                                 GET ;
2799
                                 IF_NONE { PUSH int 997 ; FAILWITH } {} ;
2800
                                 GET 8 ;
2801
                                 SUB ;
2802
                                 ISNAT ;
2803
                                 IF_NONE { PUSH int 997 ; FAILWITH } {} ;
2804
                                 UPDATE 8 ;
2805
                                 SOME ;
2806
                                 SWAP ;
2807
                                 UPDATE ;
2808
                                 UPDATE 7 ;
2809
                                 DUP ;
2810
                                 DUG 3 ;
2811
                                 DUP ;
2812
                                 GET 7 ;
2813
                                 DUP ;
2814
                                 DIG 4 ;
2815
                                 GET 6 ;
2816
                                 DUP ;
2817
                                 DUG 2 ;
2818
                                 GET ;
2819
                                 IF_NONE { PUSH int 998 ; FAILWITH } {} ;
2820
                                 UNPAIR ;
2821
                                 UNPAIR ;
2822
                                 SWAP ;
2823
                                 UNPAIR ;
2824
                                 UNPAIR ;
2825
                                 PUSH bool True ;
2826
                                 DIG 10 ;
2827
                                 CAR ;
2828
                                 CAR ;
2829
                                 CAR ;
2830
                                 CDR ;
2831
                                 UNIT ;
2832
                                 VIEW "get_next_auction_id" nat ;
2833
                                 IF_NONE { PUSH int 1591 ; FAILWITH } {} ;
2834
                                 UPDATE ;
2835
                                 PAIR ;
2836
                                 PAIR ;
2837
                                 SWAP ;
2838
                                 PAIR ;
2839
                                 PAIR ;
2840
                                 SOME ;
2841
                                 SWAP ;
2842
                                 UPDATE ;
2843
                                 UPDATE 7 ;
2844
                                 SWAP }
2845
                               { SWAP ;
2846
                                 DUP ;
2847
                                 DUG 2 ;
2848
                                 GET 7 ;
2849
                                 SWAP ;
2850
                                 DUP ;
2851
                                 DUG 2 ;
2852
                                 GET 6 ;
2853
                                 GET ;
2854
                                 IF_NONE { PUSH int 866 ; FAILWITH } {} ;
2855
                                 DUP 3 ;
2856
                                 CAR ;
2857
                                 CAR ;
2858
                                 GET 3 ;
2859
                                 DUP 3 ;
2860
                                 GET 9 ;
2861
                                 GET ;
2862
                                 IF_NONE { PUSH int 867 ; FAILWITH } {} ;
2863
                                 DUP ;
2864
                                 GET 5 ;
2865
                                 IF { PUSH int 868 ; FAILWITH } {} ;
2866
                                 SWAP ;
2867
                                 DUP ;
2868
                                 DUG 2 ;
2869
                                 CAR ;
2870
                                 CAR ;
2871
                                 GET 3 ;
2872
                                 IF
2873
                                   { SWAP ; DUP ; DUG 2 ; CAR ; GET 3 ; CDR ; SENDER ; MEM }
2874
                                   { PUSH bool False } ;
2875
                                 IF
2876
                                   { PUSH bool True }
2877
                                   { SWAP ;
2878
                                     DUP ;
2879
                                     DUG 2 ;
2880
                                     CAR ;
2881
                                     CAR ;
2882
                                     GET 4 ;
2883
                                     IF
2884
                                       { DUP ;
2885
                                         CAR ;
2886
                                         CAR ;
2887
                                         SENDER ;
2888
                                         MEM ;
2889
                                         IF
2890
                                           { PUSH bool True }
2891
                                           { DUP 4 ; CAR ; GET 3 ; CAR ; SENDER ; MEM } ;
2892
                                         IF
2893
                                           { PUSH bool True }
2894
                                           { DUP 4 ; CAR ; CAR ; CAR ; CAR ; SENDER ; COMPARE ; EQ } }
2895
                                       { PUSH bool False } } ;
2896
                                 IF {} { PUSH int 1601 ; FAILWITH } ;
2897
                                 SWAP ;
2898
                                 DUP ;
2899
                                 DUG 2 ;
2900
                                 GET 8 ;
2901
                                 DUP 4 ;
2902
                                 CAR ;
2903
                                 GET 4 ;
2904
                                 COMPARE ;
2905
                                 LE ;
2906
                                 IF {} { PUSH int 874 ; FAILWITH } ;
2907
                                 SWAP ;
2908
                                 DUP ;
2909
                                 DUG 2 ;
2910
                                 GET 3 ;
2911
                                 GET 4 ;
2912
                                 IF_NONE
2913
                                   {}
2914
                                   { DUP ;
2915
                                     DUP 5 ;
2916
                                     CAR ;
2917
                                     GET 3 ;
2918
                                     MEM ;
2919
                                     IF {} { PUSH int 878 ; FAILWITH } ;
2920
                                     DUP 4 ;
2921
                                     CAR ;
2922
                                     GET 3 ;
2923
                                     GET ;
2924
                                     IF_NONE { PUSH int 879 ; FAILWITH } {} ;
2925
                                     DUP 4 ;
2926
                                     GET 3 ;
2927
                                     COMPARE ;
2928
                                     GE ;
2929
                                     IF {} { PUSH int 879 ; FAILWITH } } ;
2930
                                 NIL operation ;
2931
                                 DUP 4 ;
2932
                                 GET 7 ;
2933
                                 CONTRACT %update_operators (list (or
2934
                                                                   (pair %add_operator
2935
                                                                     (address %owner)
2936
                                                                     (pair
2937
                                                                       (address %operator)
2938
                                                                       (nat %token_id)))
2939
                                                                   (pair %remove_operator
2940
                                                                     (address %owner)
2941
                                                                     (pair
2942
                                                                       (address %operator)
2943
                                                                       (nat %token_id))))) ;
2944
                                 IF_NONE { PUSH int 1476 ; FAILWITH } {} ;
2945
                                 PUSH mutez 0 ;
2946
                                 NIL (or (pair address (pair address nat))
2947
                                         (pair address (pair address nat))) ;
2948
                                 DUP 7 ;
2949
                                 GET 10 ;
2950
                                 DUP 9 ;
2951
                                 CAR ;
2952
                                 GET 5 ;
2953
                                 SELF_ADDRESS ;
2954
                                 PAIR 3 ;
2955
                                 LEFT (pair address (pair address nat)) ;
2956
                                 CONS ;
2957
                                 TRANSFER_TOKENS ;
2958
                                 CONS ;
2959
                                 DUP ;
2960
                                 DUP 6 ;
2961
                                 CAR ;
2962
                                 GET 5 ;
2963
                                 CONTRACT %ask_gallery (pair
2964
                                                         (pair %token (address %address)
2965
                                                                      (nat %token_id))
2966
                                                         (pair (nat %exhibition_id)
2967
                                                               (pair
2968
                                                                 (or %currency
2969
                                                                   (address %fa12)
2970
                                                                   (or
2971
                                                                     (pair %fa2
2972
                                                                       (address %address)
2973
                                                                       (nat %token_id))
2974
                                                                     (unit %tez)))
2975
                                                                 (pair (nat %amount)
2976
                                                                       (pair
2977
                                                                         (nat %editions)
2978
                                                                         (pair
2979
                                                                           (map %shares
2980
                                                                             address
2981
                                                                             nat)
2982
                                                                           (pair
2983
                                                                             (option %start_time timestamp)
2984
                                                                             (pair
2985
                                                                               (option %expiry_time timestamp)
2986
                                                                               (pair
2987
                                                                                 (nat %referral_bonus)
2988
                                                                                 (option %condition (pair
2989
                                                                                                     (address %address)
2990
                                                                                                     (bytes %id)))))))))))) ;
2991
                                 IF_NONE { PUSH int 1256 ; FAILWITH } {} ;
2992
                                 PUSH mutez 0 ;
2993
                                 DUP 7 ;
2994
                                 CAR ;
2995
                                 CAR ;
2996
                                 PUSH nat 0 ;
2997
                                 NONE timestamp ;
2998
                                 DUP 10 ;
2999
                                 GET 5 ;
3000
                                 DUP 10 ;
3001
                                 GET 5 ;
3002
                                 CAR ;
3003
                                 DIG 11 ;
3004
                                 DUP ;
3005
                                 CAR ;
3006
                                 GET 4 ;
3007
                                 SWAP ;
3008
                                 DUP ;
3009
                                 GET 3 ;
3010
                                 SWAP ;
3011
                                 DUP ;
3012
                                 CAR ;
3013
                                 GET 3 ;
3014
                                 SWAP ;
3015
                                 DUP ;
3016
                                 GET 9 ;
3017
                                 SWAP ;
3018
                                 DUP ;
3019
                                 GET 10 ;
3020
                                 SWAP ;
3021
                                 DUP ;
3022
                                 DUG 17 ;
3023
                                 GET 7 ;
3024
                                 PAIR ;
3025
                                 PAIR 10 ;
3026
                                 DIG 4 ;
3027
                                 DROP ;
3028
                                 DIG 4 ;
3029
                                 DROP ;
3030
                                 DIG 4 ;
3031
                                 DROP ;
3032
                                 TRANSFER_TOKENS ;
3033
                                 CONS ;
3034
                                 DUP 3 ;
3035
                                 DUP ;
3036
                                 GET 7 ;
3037
                                 DUP ;
3038
                                 DUP 5 ;
3039
                                 GET 6 ;
3040
                                 DUP ;
3041
                                 DUG 2 ;
3042
                                 GET ;
3043
                                 IF_NONE { PUSH int 892 ; FAILWITH } {} ;
3044
                                 UNPAIR ;
3045
                                 SWAP ;
3046
                                 UNPAIR ;
3047
                                 UNPAIR ;
3048
                                 SWAP ;
3049
                                 UNPAIR ;
3050
                                 PUSH bool True ;
3051
                                 DIG 11 ;
3052
                                 CAR ;
3053
                                 GET 5 ;
3054
                                 UNIT ;
3055
                                 VIEW "get_next_ask_id" nat ;
3056
                                 IF_NONE { PUSH int 1597 ; FAILWITH } {} ;
3057
                                 UPDATE ;
3058
                                 PAIR ;
3059
                                 SWAP ;
3060
                                 PAIR ;
3061
                                 PAIR ;
3062
                                 SWAP ;
3063
                                 PAIR ;
3064
                                 SOME ;
3065
                                 SWAP ;
3066
                                 UPDATE ;
3067
                                 UPDATE 7 ;
3068
                                 DUP ;
3069
                                 GET 7 ;
3070
                                 DUP ;
3071
                                 DUP 5 ;
3072
                                 GET 6 ;
3073
                                 DUP ;
3074
                                 DUG 2 ;
3075
                                 GET ;
3076
                                 IF_NONE { PUSH int 893 ; FAILWITH } {} ;
3077
                                 UNPAIR ;
3078
                                 SWAP ;
3079
                                 UNPAIR ;
3080
                                 UNPAIR ;
3081
                                 DUP 9 ;
3082
                                 CAR ;
3083
                                 GET 4 ;
3084
                                 ADD ;
3085
                                 PAIR ;
3086
                                 PAIR ;
3087
                                 SWAP ;
3088
                                 PAIR ;
3089
                                 SOME ;
3090
                                 SWAP ;
3091
                                 UPDATE ;
3092
                                 UPDATE 7 ;
3093
                                 DUP ;
3094
                                 DUG 3 ;
3095
                                 DUP ;
3096
                                 GET 7 ;
3097
                                 DUP ;
3098
                                 DUP 5 ;
3099
                                 GET 6 ;
3100
                                 DUP ;
3101
                                 DUG 2 ;
3102
                                 GET ;
3103
                                 IF_NONE { PUSH int 894 ; FAILWITH } {} ;
3104
                                 DUP 6 ;
3105
                                 CAR ;
3106
                                 GET 4 ;
3107
                                 DIG 7 ;
3108
                                 GET 7 ;
3109
                                 DIG 7 ;
3110
                                 GET 6 ;
3111
                                 GET ;
3112
                                 IF_NONE { PUSH int 894 ; FAILWITH } {} ;
3113
                                 GET 8 ;
3114
                                 SUB ;
3115
                                 ISNAT ;
3116
                                 IF_NONE { PUSH int 894 ; FAILWITH } {} ;
3117
                                 UPDATE 8 ;
3118
                                 SOME ;
3119
                                 SWAP ;
3120
                                 UPDATE ;
3121
                                 UPDATE 7 ;
3122
                                 SWAP } } } } } }
3123
           { IF_LEFT
3124
               { IF_LEFT
3125
                   { IF_LEFT
3126
                       { IF_LEFT
3127
                           { SWAP ;
3128
                             DUP ;
3129
                             DUG 2 ;
3130
                             GET 7 ;
3131
                             SWAP ;
3132
                             DUP ;
3133
                             DUG 2 ;
3134
                             GET ;
3135
                             IF_NONE { PUSH int 1077 ; FAILWITH } {} ;
3136
                             DUP ;
3137
                             CAR ;
3138
                             GET 3 ;
3139
                             CDR ;
3140
                             SENDER ;
3141
                             MEM ;
3142
                             IF {} { PUSH int 1078 ; FAILWITH } ;
3143
                             DUP ;
3144
                             CAR ;
3145
                             GET 3 ;
3146
                             CDR ;
3147
                             ITER { SWAP ;
3148
                                    DUP ;
3149
                                    DUG 2 ;
3150
                                    GET 5 ;
3151
                                    CDR ;
3152
                                    SWAP ;
3153
                                    MEM ;
3154
                                    IF {} { PUSH int 1081 ; FAILWITH } } ;
3155
                             DROP ;
3156
                             DUP ;
3157
                             CAR ;
3158
                             CONTRACT %lock (pair (bool %metadata)
3159
                                                  (pair (bool %mint) (nat %token_id))) ;
3160
                             IF_NONE { PUSH int 1403 ; FAILWITH } {} ;
3161
                             NIL operation ;
3162
                             SWAP ;
3163
                             PUSH mutez 0 ;
3164
                             DIG 3 ;
3165
                             GET 4 ;
3166
                             PUSH bool False ;
3167
                             PUSH bool True ;
3168
                             PAIR 3 ;
3169
                             TRANSFER_TOKENS ;
3170
                             CONS }
3171
                           { SWAP ;
3172
                             DUP ;
3173
                             DUG 2 ;
3174
                             CAR ;
3175
                             GET 8 ;
3176
                             SWAP ;
3177
                             DUP ;
3178
                             DUG 2 ;
3179
                             GET 5 ;
3180
                             GET ;
3181
                             IF_NONE { PUSH int 668 ; FAILWITH } {} ;
3182
                             DUP ;
3183
                             GET 7 ;
3184
                             IF { PUSH int 669 ; FAILWITH } {} ;
3185
                             DUP 3 ;
3186
                             CAR ;
3187
                             CAR ;
3188
                             GET 3 ;
3189
                             SWAP ;
3190
                             DUP ;
3191
                             DUG 2 ;
3192
                             GET 3 ;
3193
                             CAR ;
3194
                             GET ;
3195
                             IF_NONE { PUSH int 670 ; FAILWITH } {} ;
3196
                             DUP ;
3197
                             GET 5 ;
3198
                             IF { PUSH int 671 ; FAILWITH } {} ;
3199
                             SWAP ;
3200
                             DUP ;
3201
                             DUG 2 ;
3202
                             GET 3 ;
3203
                             GET 3 ;
3204
                             IF_NONE
3205
                               {}
3206
                               { NOW ; COMPARE ; LT ; IF {} { PUSH int 675 ; FAILWITH } } ;
3207
                             SWAP ;
3208
                             DUP ;
3209
                             DUG 2 ;
3210
                             CAR ;
3211
                             GET 6 ;
3212
                             DUP 4 ;
3213
                             GET 3 ;
3214
                             MEM ;
3215
                             IF {} { PUSH int 678 ; FAILWITH } ;
3216
                             PUSH nat 0 ;
3217
                             DUP 3 ;
3218
                             CAR ;
3219
                             GET 3 ;
3220
                             CAR ;
3221
                             SIZE ;
3222
                             COMPARE ;
3223
                             GT ;
3224
                             IF
3225
                               { SWAP ;
3226
                                 DUP ;
3227
                                 DUG 2 ;
3228
                                 CAR ;
3229
                                 GET 3 ;
3230
                                 CAR ;
3231
                                 SENDER ;
3232
                                 MEM ;
3233
                                 IF
3234
                                   { PUSH bool True }
3235
                                   { DUP ;
3236
                                     CAR ;
3237
                                     CAR ;
3238
                                     SENDER ;
3239
                                     MEM ;
3240
                                     IF
3241
                                       { PUSH bool True }
3242
                                       { DUP 4 ; CAR ; GET 3 ; CAR ; SENDER ; MEM } ;
3243
                                     IF
3244
                                       { PUSH bool True }
3245
                                       { SENDER ; DUP 5 ; CAR ; CAR ; CAR ; CAR ; COMPARE ; EQ } } ;
3246
                                 IF {} { PUSH int 682 ; FAILWITH } ;
3247
                                 DUP 3 ;
3248
                                 CAR ;
3249
                                 GET 3 ;
3250
                                 ITER { CAR ;
3251
                                        DUP 3 ;
3252
                                        CAR ;
3253
                                        GET 3 ;
3254
                                        CAR ;
3255
                                        SWAP ;
3256
                                        MEM ;
3257
                                        IF {} { PUSH int 685 ; FAILWITH } } }
3258
                               {} ;
3259
                             PUSH nat 0 ;
3260
                             DUP 3 ;
3261
                             GET 5 ;
3262
                             CAR ;
3263
                             CDR ;
3264
                             IF_NONE { PUSH int 688 ; FAILWITH } {} ;
3265
                             COMPARE ;
3266
                             GT ;
3267
                             IF
3268
                               { SWAP ;
3269
                                 DUP ;
3270
                                 DUG 2 ;
3271
                                 GET 5 ;
3272
                                 CAR ;
3273
                                 CDR ;
3274
                                 IF_NONE { PUSH int 688 ; FAILWITH } {} ;
3275
                                 DUP 4 ;
3276
                                 CAR ;
3277
                                 CAR ;
3278
                                 COMPARE ;
3279
                                 EQ ;
3280
                                 IF {} { PUSH int 690 ; FAILWITH } }
3281
                               {} ;
3282
                             SWAP ;
3283
                             DUP ;
3284
                             DUG 2 ;
3285
                             GET 3 ;
3286
                             GET 4 ;
3287
                             IF_NONE
3288
                               {}
3289
                               { DUP 4 ;
3290
                                 CAR ;
3291
                                 GET 3 ;
3292
                                 ITER { CAR ;
3293
                                        DUP 5 ;
3294
                                        GET 5 ;
3295
                                        SWAP ;
3296
                                        PAIR ;
3297
                                        DUP 6 ;
3298
                                        GET 10 ;
3299
                                        SWAP ;
3300
                                        DUP ;
3301
                                        DUG 2 ;
3302
                                        GET ;
3303
                                        IF_NONE { PUSH nat 0 } {} ;
3304
                                        DUP 3 ;
3305
                                        SWAP ;
3306
                                        DUP ;
3307
                                        DUG 2 ;
3308
                                        COMPARE ;
3309
                                        LT ;
3310
                                        IF {} { PUSH int 697 ; FAILWITH } ;
3311
                                        DIG 6 ;
3312
                                        DUP ;
3313
                                        GET 10 ;
3314
                                        PUSH nat 1 ;
3315
                                        DIG 3 ;
3316
                                        ADD ;
3317
                                        SOME ;
3318
                                        DIG 3 ;
3319
                                        UPDATE ;
3320
                                        UPDATE 10 ;
3321
                                        DUG 4 } ;
3322
                                 DROP } ;
3323
                             SWAP ;
3324
                             DUP ;
3325
                             DUG 2 ;
3326
                             CAR ;
3327
                             GET 3 ;
3328
                             CDR ;
3329
                             IF_NONE
3330
                               {}
3331
                               { DUP ;
3332
                                 PUSH nat 0 ;
3333
                                 COMPARE ;
3334
                                 LT ;
3335
                                 IF {} { PUSH int 702 ; FAILWITH } ;
3336
                                 DIG 4 ;
3337
                                 UNPAIR ;
3338
                                 UNPAIR ;
3339
                                 SWAP ;
3340
                                 UNPAIR ;
3341
                                 SWAP ;
3342
                                 UNPAIR ;
3343
                                 SWAP ;
3344
                                 UNPAIR ;
3345
                                 SWAP ;
3346
                                 DUP ;
3347
                                 DUP 11 ;
3348
                                 GET 5 ;
3349
                                 DUP ;
3350
                                 DUG 2 ;
3351
                                 GET ;
3352
                                 IF_NONE { PUSH int 703 ; FAILWITH } {} ;
3353
                                 UNPAIR ;
3354
                                 UNPAIR ;
3355
                                 SWAP ;
3356
                                 UNPAIR ;
3357
                                 CAR ;
3358
                                 PUSH nat 1 ;
3359
                                 DIG 12 ;
3360
                                 SUB ;
3361
                                 ISNAT ;
3362
                                 IF_NONE { PUSH int 703 ; FAILWITH } {} ;
3363
                                 SOME ;
3364
                                 SWAP ;
3365
                                 PAIR ;
3366
                                 PAIR ;
3367
                                 SWAP ;
3368
                                 PAIR ;
3369
                                 PAIR ;
3370
                                 SOME ;
3371
                                 SWAP ;
3372
                                 UPDATE ;
3373
                                 SWAP ;
3374
                                 PAIR ;
3375
                                 SWAP ;
3376
                                 PAIR ;
3377
                                 SWAP ;
3378
                                 PAIR ;
3379
                                 SWAP ;
3380
                                 PAIR ;
3381
                                 PAIR ;
3382
                                 DUG 3 } ;
3383
                             NIL operation ;
3384
                             DUP 4 ;
3385
                             GET 3 ;
3386
                             CONTRACT %create_token (map string bytes) ;
3387
                             IF_NONE { PUSH int 1333 ; FAILWITH } {} ;
3388
                             PUSH mutez 0 ;
3389
                             DUP 6 ;
3390
                             GET 6 ;
3391
                             TRANSFER_TOKENS ;
3392
                             CONS ;
3393
                             DUP 4 ;
3394
                             GET 3 ;
3395
                             CONTRACT %mint (pair
3396
                                              (list %mint_items (pair (nat %amount)
3397
                                                                     (address %to_)))
3398
                                              (nat %token_id)) ;
3399
                             IF_NONE { PUSH int 1426 ; FAILWITH } {} ;
3400
                             PUSH mutez 0 ;
3401
                             PUSH nat 1 ;
3402
                             DUP 7 ;
3403
                             GET 3 ;
3404
                             UNIT ;
3405
                             VIEW "get_last_token_id" nat ;
3406
                             IF_NONE { PUSH int 1612 ; FAILWITH } {} ;
3407
                             ADD ;
3408
                             NIL (pair nat address) ;
3409
                             SELF_ADDRESS ;
3410
                             DUP 9 ;
3411
                             CAR ;
3412
                             CAR ;
3413
                             PAIR ;
3414
                             CONS ;
3415
                             PAIR ;
3416
                             TRANSFER_TOKENS ;
3417
                             CONS ;
3418
                             DUP 4 ;
3419
                             GET 3 ;
3420
                             CONTRACT %lock (pair (bool %metadata)
3421
                                                  (pair (bool %mint) (nat %token_id))) ;
3422
                             IF_NONE { PUSH int 1403 ; FAILWITH } {} ;
3423
                             PUSH mutez 0 ;
3424
                             PUSH nat 1 ;
3425
                             DUP 7 ;
3426
                             GET 3 ;
3427
                             UNIT ;
3428
                             VIEW "get_last_token_id" nat ;
3429
                             IF_NONE { PUSH int 1612 ; FAILWITH } {} ;
3430
                             ADD ;
3431
                             PUSH bool True ;
3432
                             PUSH bool False ;
3433
                             PAIR 3 ;
3434
                             TRANSFER_TOKENS ;
3435
                             CONS ;
3436
                             PUSH nat 0 ;
3437
                             DUP 5 ;
3438
                             CAR ;
3439
                             GET 3 ;
3440
                             ITER { CDR ; ADD } ;
3441
                             DUP ;
3442
                             PUSH nat 10000 ;
3443
                             COMPARE ;
3444
                             EQ ;
3445
                             IF {} { PUSH int 714 ; FAILWITH } ;
3446
                             EMPTY_MAP address nat ;
3447
                             DUP 5 ;
3448
                             GET 11 ;
3449
                             SOME ;
3450
                             DUP 8 ;
3451
                             GET 9 ;
3452
                             UPDATE ;
3453
                             DUP 5 ;
3454
                             GET 9 ;
3455
                             CDR ;
3456
                             DUP 5 ;
3457
                             CAR ;
3458
                             CAR ;
3459
                             ITER { DUP 3 ;
3460
                                    PUSH nat 10000 ;
3461
                                    DUP 3 ;
3462
                                    CDR ;
3463
                                    DUP 5 ;
3464
                                    MUL ;
3465
                                    EDIV ;
3466
                                    IF_NONE { PUSH int 723 ; FAILWITH } { CAR } ;
3467
                                    DIG 4 ;
3468
                                    DUP 4 ;
3469
                                    CAR ;
3470
                                    GET ;
3471
                                    IF_NONE { PUSH nat 0 } {} ;
3472
                                    ADD ;
3473
                                    SOME ;
3474
                                    DIG 2 ;
3475
                                    CAR ;
3476
                                    UPDATE ;
3477
                                    SWAP } ;
3478
                             DUP 6 ;
3479
                             GET 9 ;
3480
                             CAR ;
3481
                             DUP 8 ;
3482
                             CAR ;
3483
                             GET 3 ;
3484
                             ITER { DUP 4 ;
3485
                                    PUSH nat 10000 ;
3486
                                    DUP 3 ;
3487
                                    CDR ;
3488
                                    DUP 5 ;
3489
                                    MUL ;
3490
                                    EDIV ;
3491
                                    IF_NONE { PUSH int 727 ; FAILWITH } { CAR } ;
3492
                                    DIG 5 ;
3493
                                    DUP 4 ;
3494
                                    CAR ;
3495
                                    GET ;
3496
                                    IF_NONE { PUSH nat 0 } {} ;
3497
                                    ADD ;
3498
                                    SOME ;
3499
                                    DIG 2 ;
3500
                                    CAR ;
3501
                                    UPDATE ;
3502
                                    DUG 2 } ;
3503
                             DUP 7 ;
3504
                             GET 12 ;
3505
                             ITER { DUP 4 ;
3506
                                    SWAP ;
3507
                                    DUP ;
3508
                                    DUG 2 ;
3509
                                    CDR ;
3510
                                    DIG 5 ;
3511
                                    DUP 4 ;
3512
                                    CAR ;
3513
                                    GET ;
3514
                                    IF_NONE { PUSH nat 0 } {} ;
3515
                                    ADD ;
3516
                                    SOME ;
3517
                                    DIG 2 ;
3518
                                    CAR ;
3519
                                    UPDATE ;
3520
                                    DUG 2 } ;
3521
                             EMPTY_SET address ;
3522
                             DUP 9 ;
3523
                             CAR ;
3524
                             GET 3 ;
3525
                             ITER { CAR ; SWAP ; PUSH bool True ; DIG 2 ; UPDATE } ;
3526
                             DUP 8 ;
3527
                             CAR ;
3528
                             GET 5 ;
3529
                             IF_NONE
3530
                               { SWAP ; DROP ; SWAP ; DROP ; DIG 2 ; DROP ; DIG 3 ; DROP }
3531
                               { DIG 2 ;
3532
                                 DROP ;
3533
                                 DIG 2 ;
3534
                                 DROP ;
3535
                                 DIG 3 ;
3536
                                 DROP ;
3537
                                 DIG 4 ;
3538
                                 DROP ;
3539
                                 DUP ;
3540
                                 DIG 4 ;
3541
                                 SWAP ;
3542
                                 CAR ;
3543
                                 CONTRACT %enforce_conditions (list (pair
3544
                                                                     (pair (nat %amount)
3545
                                                                           (pair
3546
                                                                             (address %claimer)
3547
                                                                             (bytes %condition_id)))
3548
                                                                     (pair
3549
                                                                       (address %creator)
3550
                                                                       (pair
3551
                                                                         (option %extra bytes)
3552
                                                                         (pair %token
3553
                                                                           (address %address)
3554
                                                                           (nat %token_id)))))) ;
3555
                                 IF_NONE { PUSH int 517 ; FAILWITH } {} ;
3556
                                 PUSH mutez 0 ;
3557
                                 NIL (pair (pair nat (pair address bytes))
3558
                                           (pair address
3559
                                                 (pair (option bytes) (pair address nat)))) ;
3560
                                 PUSH nat 1 ;
3561
                                 DUP 10 ;
3562
                                 GET 3 ;
3563
                                 UNIT ;
3564
                                 VIEW "get_last_token_id" nat ;
3565
                                 IF_NONE { PUSH int 1612 ; FAILWITH } {} ;
3566
                                 ADD ;
3567
                                 DUP 10 ;
3568
                                 GET 3 ;
3569
                                 PAIR ;
3570
                                 DUP 10 ;
3571
                                 CAR ;
3572
                                 GET 4 ;
3573
                                 PAIR ;
3574
                                 DUP 11 ;
3575
                                 CAR ;
3576
                                 CAR ;
3577
                                 CAR ;
3578
                                 CAR ;
3579
                                 PAIR ;
3580
                                 DIG 5 ;
3581
                                 CDR ;
3582
                                 SENDER ;
3583
                                 PAIR ;
3584
                                 DUP 10 ;
3585
                                 CAR ;
3586
                                 CAR ;
3587
                                 PAIR ;
3588
                                 PAIR ;
3589
                                 CONS ;
3590
                                 TRANSFER_TOKENS ;
3591
                                 CONS ;
3592
                                 DUG 2 } ;
3593
                             DIG 5 ;
3594
                             DUP ;
3595
                             GET 7 ;
3596
                             DUP 7 ;
3597
                             CAR ;
3598
                             CAR ;
3599
                             PUSH nat 0 ;
3600
                             PAIR ;
3601
                             EMPTY_SET address ;
3602
                             PUSH bool True ;
3603
                             SENDER ;
3604
                             UPDATE ;
3605
                             DIG 5 ;
3606
                             PAIR ;
3607
                             PAIR ;
3608
                             DUP 6 ;
3609
                             GET 5 ;
3610
                             CDR ;
3611
                             EMPTY_SET nat ;
3612
                             PAIR ;
3613
                             PUSH nat 0 ;
3614
                             PAIR ;
3615
                             PAIR ;
3616
                             DUP 7 ;
3617
                             GET 5 ;
3618
                             PUSH bool False ;
3619
                             PAIR ;
3620
                             DIG 4 ;
3621
                             EMPTY_SET nat ;
3622
                             PAIR ;
3623
                             PAIR ;
3624
                             DIG 5 ;
3625
                             DUP ;
3626
                             CAR ;
3627
                             CAR ;
3628
                             GET 4 ;
3629
                             SWAP ;
3630
                             DUP ;
3631
                             DUG 7 ;
3632
                             CAR ;
3633
                             CAR ;
3634
                             GET 3 ;
3635
                             PAIR ;
3636
                             DUP 7 ;
3637
                             CAR ;
3638
                             CAR ;
3639
                             CAR ;
3640
                             PAIR ;
3641
                             PAIR ;
3642
                             PAIR ;
3643
                             SOME ;
3644
                             PUSH nat 1 ;
3645
                             DUP 7 ;
3646
                             GET 3 ;
3647
                             UNIT ;
3648
                             VIEW "get_last_token_id" nat ;
3649
                             IF_NONE { PUSH int 1612 ; FAILWITH } {} ;
3650
                             ADD ;
3651
                             DIG 5 ;
3652
                             GET 3 ;
3653
                             CAR ;
3654
                             DIG 6 ;
3655
                             GET 3 ;
3656
                             PAIR 3 ;
3657
                             UPDATE ;
3658
                             UPDATE 7 ;
3659
                             SWAP } }
3660
                       { IF_LEFT
3661
                           { SWAP ;
3662
                             DUP ;
3663
                             DUG 2 ;
3664
                             CAR ;
3665
                             CAR ;
3666
                             CAR ;
3667
                             CAR ;
3668
                             SENDER ;
3669
                             COMPARE ;
3670
                             EQ ;
3671
                             IF {} { PUSH int 1142 ; FAILWITH } ;
3672
                             SWAP ;
3673
                             UNPAIR ;
3674
                             UNPAIR ;
3675
                             SWAP ;
3676
                             UNPAIR ;
3677
                             UNPAIR ;
3678
                             NONE unit ;
3679
                             DIG 6 ;
3680
                             UPDATE ;
3681
                             PAIR ;
3682
                             PAIR ;
3683
                             SWAP ;
3684
                             PAIR ;
3685
                             PAIR }
3686
                           { IF_LEFT
3687
                               { SWAP ;
3688
                                 DUP ;
3689
                                 DUG 2 ;
3690
                                 CAR ;
3691
                                 CAR ;
3692
                                 CAR ;
3693
                                 CAR ;
3694
                                 SENDER ;
3695
                                 COMPARE ;
3696
                                 EQ ;
3697
                                 IF {} { PUSH int 1142 ; FAILWITH } ;
3698
                                 SWAP ;
3699
                                 UNPAIR ;
3700
                                 SWAP ;
3701
                                 UNPAIR ;
3702
                                 UNPAIR ;
3703
                                 UNPAIR ;
3704
                                 SWAP ;
3705
                                 NONE unit ;
3706
                                 DIG 6 ;
3707
                                 UPDATE ;
3708
                                 SWAP ;
3709
                                 PAIR ;
3710
                                 PAIR ;
3711
                                 PAIR ;
3712
                                 SWAP ;
3713
                                 PAIR }
3714
                               { SWAP ;
3715
                                 DUP ;
3716
                                 DUG 2 ;
3717
                                 CAR ;
3718
                                 GET 3 ;
3719
                                 CDR ;
3720
                                 SWAP ;
3721
                                 DUP ;
3722
                                 DUG 2 ;
3723
                                 GET ;
3724
                                 IF_NONE { PUSH int 423 ; FAILWITH } {} ;
3725
                                 DUP 3 ;
3726
                                 CAR ;
3727
                                 CAR ;
3728
                                 GET 3 ;
3729
                                 SWAP ;
3730
                                 GET 3 ;
3731
                                 CAR ;
3732
                                 GET ;
3733
                                 IF_NONE { PUSH int 424 ; FAILWITH } {} ;
3734
                                 CAR ;
3735
                                 CAR ;
3736
                                 SENDER ;
3737
                                 MEM ;
3738
                                 IF
3739
                                   { PUSH bool True }
3740
                                   { SWAP ; DUP ; DUG 2 ; CAR ; GET 3 ; CAR ; SENDER ; MEM } ;
3741
                                 IF
3742
                                   { PUSH bool True }
3743
                                   { SENDER ; DUP 3 ; CAR ; CAR ; CAR ; CAR ; COMPARE ; EQ } ;
3744
                                 IF {} { PUSH int 425 ; FAILWITH } ;
3745
                                 SWAP ;
3746
                                 UNPAIR ;
3747
                                 UNPAIR ;
3748
                                 SWAP ;
3749
                                 UNPAIR ;
3750
                                 UNPAIR ;
3751
                                 SWAP ;
3752
                                 NONE (pair
3753
                                        (pair (pair nat (pair bool bool))
3754
                                              (pair (option nat)
3755
                                                    (pair (option (pair address bytes))
3756
                                                          nat)))
3757
                                        (pair
3758
                                          (pair nat
3759
                                                (pair (option timestamp) (set address)))
3760
                                          (pair
3761
                                            (option (map
3762
                                                     (or address
3763
                                                         (or (pair address nat) unit))
3764
                                                     nat))
3765
                                            (pair
3766
                                              (pair (pair nat nat)
3767
                                                    (pair nat
3768
                                                          (pair (map address nat)
3769
                                                                (map address nat))))
3770
                                              (map address (option nat)))))) ;
3771
                                 DIG 6 ;
3772
                                 UPDATE ;
3773
                                 SWAP ;
3774
                                 PAIR ;
3775
                                 PAIR ;
3776
                                 SWAP ;
3777
                                 PAIR ;
3778
                                 PAIR } } ;
3779
                         NIL operation } }
3780
                   { IF_LEFT
3781
                       { IF_LEFT
3782
                           { SWAP ;
3783
                             DUP ;
3784
                             DUG 2 ;
3785
                             CAR ;
3786
                             GET 8 ;
3787
                             SWAP ;
3788
                             DUP ;
3789
                             DUG 2 ;
3790
                             GET ;
3791
                             IF_NONE { PUSH int 351 ; FAILWITH } {} ;
3792
                             DUP 3 ;
3793
                             CAR ;
3794
                             CAR ;
3795
                             GET 3 ;
3796
                             SWAP ;
3797
                             GET 3 ;
3798
                             CAR ;
3799
                             GET ;
3800
                             IF_NONE { PUSH int 352 ; FAILWITH } {} ;
3801
                             CAR ;
3802
                             CAR ;
3803
                             SENDER ;
3804
                             MEM ;
3805
                             IF
3806
                               { PUSH bool True }
3807
                               { SWAP ; DUP ; DUG 2 ; CAR ; GET 3 ; CAR ; SENDER ; MEM } ;
3808
                             IF
3809
                               { PUSH bool True }
3810
                               { SENDER ; DUP 3 ; CAR ; CAR ; CAR ; CAR ; COMPARE ; EQ } ;
3811
                             IF {} { PUSH int 353 ; FAILWITH } ;
3812
                             SWAP ;
3813
                             UNPAIR ;
3814
                             UNPAIR ;
3815
                             SWAP ;
3816
                             UNPAIR ;
3817
                             SWAP ;
3818
                             UNPAIR ;
3819
                             SWAP ;
3820
                             UNPAIR ;
3821
                             SWAP ;
3822
                             DUP ;
3823
                             DIG 7 ;
3824
                             DUP ;
3825
                             DUG 2 ;
3826
                             GET ;
3827
                             IF_NONE { PUSH int 354 ; FAILWITH } {} ;
3828
                             PUSH bool True ;
3829
                             UPDATE 7 ;
3830
                             SOME ;
3831
                             SWAP ;
3832
                             UPDATE ;
3833
                             SWAP ;
3834
                             PAIR ;
3835
                             SWAP ;
3836
                             PAIR ;
3837
                             SWAP ;
3838
                             PAIR ;
3839
                             SWAP ;
3840
                             PAIR ;
3841
                             PAIR ;
3842
                             NIL operation }
3843
                           { SWAP ;
3844
                             DUP ;
3845
                             DUG 2 ;
3846
                             GET 7 ;
3847
                             SWAP ;
3848
                             DUP ;
3849
                             DUG 2 ;
3850
                             CDR ;
3851
                             MEM ;
3852
                             IF {} { PUSH int 544 ; FAILWITH } ;
3853
                             SWAP ;
3854
                             DUP ;
3855
                             DUG 2 ;
3856
                             GET 7 ;
3857
                             SWAP ;
3858
                             DUP ;
3859
                             DUG 2 ;
3860
                             CDR ;
3861
                             GET ;
3862
                             IF_NONE { PUSH int 545 ; FAILWITH } {} ;
3863
                             DUP 3 ;
3864
                             CAR ;
3865
                             GET 3 ;
3866
                             CDR ;
3867
                             SWAP ;
3868
                             DUP ;
3869
                             DUG 2 ;
3870
                             CAR ;
3871
                             GET 6 ;
3872
                             GET ;
3873
                             IF_NONE { PUSH int 547 ; FAILWITH } {} ;
3874
                             DUP 3 ;
3875
                             CAR ;
3876
                             DUP 3 ;
3877
                             GET 8 ;
3878
                             COMPARE ;
3879
                             GE ;
3880
                             IF {} { PUSH int 549 ; FAILWITH } ;
3881
                             NIL operation ;
3882
                             DUP 4 ;
3883
                             GET 3 ;
3884
                             CONTRACT %transfer (list (pair (address %from_)
3885
                                                           (list %txs (pair
3886
                                                                       (address %to_)
3887
                                                                       (pair
3888
                                                                         (nat %token_id)
3889
                                                                         (nat %amount)))))) ;
3890
                             IF_NONE { PUSH int 1462 ; FAILWITH } {} ;
3891
                             PUSH mutez 0 ;
3892
                             NIL (pair address (list (pair address (pair nat nat)))) ;
3893
                             NIL (pair address (pair nat nat)) ;
3894
                             DIG 7 ;
3895
                             DUP ;
3896
                             CAR ;
3897
                             SWAP ;
3898
                             DUP ;
3899
                             DUG 9 ;
3900
                             GET 6 ;
3901
                             SENDER ;
3902
                             PAIR 3 ;
3903
                             CONS ;
3904
                             SELF_ADDRESS ;
3905
                             PAIR ;
3906
                             CONS ;
3907
                             TRANSFER_TOKENS ;
3908
                             CONS ;
3909
                             DUP 3 ;
3910
                             CAR ;
3911
                             GET 3 ;
3912
                             CDR ;
3913
                             SENDER ;
3914
                             MEM ;
3915
                             IF {} { PUSH int 551 ; FAILWITH } ;
3916
                             PUSH nat 0 ;
3917
                             DIG 3 ;
3918
                             DUP ;
3919
                             GET 3 ;
3920
                             CAR ;
3921
                             SWAP ;
3922
                             DUP ;
3923
                             DUG 5 ;
3924
                             GET 7 ;
3925
                             ADD ;
3926
                             COMPARE ;
3927
                             EQ ;
3928
                             IF
3929
                               { DUP 3 ; GET 8 ; DUP 5 ; CAR ; COMPARE ; EQ }
3930
                               { PUSH bool False } ;
3931
                             IF
3932
                               { SWAP ;
3933
                                 DUP ;
3934
                                 DUG 2 ;
3935
                                 CAR ;
3936
                                 GET 3 ;
3937
                                 IF_NONE
3938
                                   { SWAP ; DROP ; SWAP ; DROP }
3939
                                   { DIG 2 ;
3940
                                     DROP ;
3941
                                     DIG 4 ;
3942
                                     UNPAIR ;
3943
                                     UNPAIR ;
3944
                                     SWAP ;
3945
                                     UNPAIR ;
3946
                                     UNPAIR ;
3947
                                     SWAP ;
3948
                                     DUP ;
3949
                                     DIG 8 ;
3950
                                     CAR ;
3951
                                     GET 6 ;
3952
                                     DUP ;
3953
                                     DUG 2 ;
3954
                                     GET ;
3955
                                     IF_NONE { PUSH int 557 ; FAILWITH } {} ;
3956
                                     UNPAIR ;
3957
                                     UNPAIR ;
3958
                                     SWAP ;
3959
                                     CDR ;
3960
                                     PUSH nat 1 ;
3961
                                     DIG 10 ;
3962
                                     ADD ;
3963
                                     SOME ;
3964
                                     PAIR ;
3965
                                     SWAP ;
3966
                                     PAIR ;
3967
                                     PAIR ;
3968
                                     SOME ;
3969
                                     SWAP ;
3970
                                     UPDATE ;
3971
                                     SWAP ;
3972
                                     PAIR ;
3973
                                     PAIR ;
3974
                                     SWAP ;
3975
                                     PAIR ;
3976
                                     PAIR ;
3977
                                     DUG 2 } ;
3978
                                 DIG 2 ;
3979
                                 DUP ;
3980
                                 GET 7 ;
3981
                                 NONE (pair
3982
                                        (pair (pair nat (pair bool bool))
3983
                                              (pair (pair (set nat) (set address))
3984
                                                    (pair bool nat)))
3985
                                        (pair
3986
                                          (pair nat
3987
                                                (pair (set nat)
3988
                                                      (option (map
3989
                                                               (or address
3990
                                                                   (or
3991
                                                                     (pair address nat)
3992
                                                                     unit))
3993
                                                               nat))))
3994
                                          (pair (pair (map address nat) (set address))
3995
                                                (pair nat nat)))) ;
3996
                                 DIG 4 ;
3997
                                 CDR ;
3998
                                 UPDATE ;
3999
                                 UPDATE 7 ;
4000
                                 SWAP }
4001
                               { SWAP ;
4002
                                 DROP ;
4003
                                 SWAP ;
4004
                                 DROP ;
4005
                                 DUP 3 ;
4006
                                 DUP ;
4007
                                 GET 7 ;
4008
                                 DUP ;
4009
                                 DUP 5 ;
4010
                                 CDR ;
4011
                                 DUP ;
4012
                                 DUG 2 ;
4013
                                 GET ;
4014
                                 IF_NONE { PUSH int 561 ; FAILWITH } {} ;
4015
                                 DUP 6 ;
4016
                                 CAR ;
4017
                                 DIG 7 ;
4018
                                 GET 7 ;
4019
                                 DIG 7 ;
4020
                                 CDR ;
4021
                                 GET ;
4022
                                 IF_NONE { PUSH int 561 ; FAILWITH } {} ;
4023
                                 GET 8 ;
4024
                                 SUB ;
4025
                                 ISNAT ;
4026
                                 IF_NONE { PUSH int 561 ; FAILWITH } {} ;
4027
                                 UPDATE 8 ;
4028
                                 SOME ;
4029
                                 SWAP ;
4030
                                 UPDATE ;
4031
                                 UPDATE 7 ;
4032
                                 SWAP } } }
4033
                       { IF_LEFT
4034
                           { SWAP ;
4035
                             DUP ;
4036
                             DUG 2 ;
4037
                             CAR ;
4038
                             CAR ;
4039
                             CAR ;
4040
                             CAR ;
4041
                             SENDER ;
4042
                             COMPARE ;
4043
                             EQ ;
4044
                             IF
4045
                               { PUSH bool True }
4046
                               { SWAP ; DUP ; DUG 2 ; CAR ; GET 3 ; CAR ; SENDER ; MEM } ;
4047
                             IF {} { PUSH int 1137 ; FAILWITH } ;
4048
                             DUP ;
4049
                             CAR ;
4050
                             CAR ;
4051
                             SIZE ;
4052
                             PUSH nat 0 ;
4053
                             COMPARE ;
4054
                             EQ ;
4055
                             IF
4056
                               { DUP ;
4057
                                 GET 7 ;
4058
                                 CDR ;
4059
                                 PUSH nat 0 ;
4060
                                 COMPARE ;
4061
                                 EQ ;
4062
                                 IF {} { PUSH int 255 ; FAILWITH } }
4063
                               {} ;
4064
                             DUP ;
4065
                             GET 9 ;
4066
                             SWAP ;
4067
                             DUP ;
4068
                             DUG 2 ;
4069
                             GET 7 ;
4070
                             CDR ;
4071
                             ADD ;
4072
                             SWAP ;
4073
                             DUP ;
4074
                             DUG 2 ;
4075
                             GET 7 ;
4076
                             CAR ;
4077
                             ADD ;
4078
                             SWAP ;
4079
                             DUP ;
4080
                             DUG 2 ;
4081
                             GET 10 ;
4082
                             ITER { CDR ; ADD } ;
4083
                             DUP 3 ;
4084
                             CAR ;
4085
                             CAR ;
4086
                             GET 4 ;
4087
                             UNIT ;
4088
                             VIEW "get_management_fee" nat ;
4089
                             IF_NONE { PUSH int 1578 ; FAILWITH } {} ;
4090
                             PUSH nat 10000 ;
4091
                             SUB ;
4092
                             ISNAT ;
4093
                             IF_NONE { PUSH int 1621 ; FAILWITH } {} ;
4094
                             SWAP ;
4095
                             DUP ;
4096
                             DUG 2 ;
4097
                             COMPARE ;
4098
                             EQ ;
4099
                             IF {} { PUSH int 1621 ; FAILWITH } ;
4100
                             DUP 3 ;
4101
                             GET 3 ;
4102
                             GET 3 ;
4103
                             DUP 3 ;
4104
                             CAR ;
4105
                             GET 4 ;
4106
                             IF_NONE
4107
                               { SWAP ;
4108
                                 DROP ;
4109
                                 DIG 2 ;
4110
                                 UNPAIR ;
4111
                                 SWAP ;
4112
                                 UNPAIR ;
4113
                                 UNPAIR ;
4114
                                 SWAP ;
4115
                                 UNPAIR ;
4116
                                 PUSH nat 1 ;
4117
                                 ADD ;
4118
                                 PAIR ;
4119
                                 SWAP ;
4120
                                 PAIR ;
4121
                                 PAIR ;
4122
                                 SWAP ;
4123
                                 PAIR ;
4124
                                 DUG 2 }
4125
                               { SWAP ;
4126
                                 DROP ;
4127
                                 SWAP ;
4128
                                 DROP ;
4129
                                 DUP 3 ;
4130
                                 CAR ;
4131
                                 CAR ;
4132
                                 GET 3 ;
4133
                                 SWAP ;
4134
                                 DUP ;
4135
                                 DUG 2 ;
4136
                                 MEM ;
4137
                                 IF {} { PUSH int 263 ; FAILWITH } } ;
4138
                             DIG 2 ;
4139
                             UNPAIR ;
4140
                             UNPAIR ;
4141
                             UNPAIR ;
4142
                             SWAP ;
4143
                             UNPAIR ;
4144
                             DIG 6 ;
4145
                             DUP ;
4146
                             GET 6 ;
4147
                             SWAP ;
4148
                             DUP ;
4149
                             DUG 8 ;
4150
                             GET 3 ;
4151
                             CDR ;
4152
                             PAIR ;
4153
                             DUP 8 ;
4154
                             GET 3 ;
4155
                             CAR ;
4156
                             PAIR ;
4157
                             DIG 7 ;
4158
                             DUP ;
4159
                             CAR ;
4160
                             GET 3 ;
4161
                             SWAP ;
4162
                             CAR ;
4163
                             CAR ;
4164
                             PAIR ;
4165
                             PAIR ;
4166
                             SOME ;
4167
                             DIG 6 ;
4168
                             UPDATE ;
4169
                             PAIR ;
4170
                             SWAP ;
4171
                             PAIR ;
4172
                             PAIR ;
4173
                             PAIR ;
4174
                             NIL operation }
4175
                           { IF_LEFT
4176
                               { SWAP ;
4177
                                 DUP ;
4178
                                 DUG 2 ;
4179
                                 CAR ;
4180
                                 CAR ;
4181
                                 GET 3 ;
4182
                                 SWAP ;
4183
                                 DUP ;
4184
                                 DUG 2 ;
4185
                                 CAR ;
4186
                                 GET ;
4187
                                 IF_NONE { PUSH int 229 ; FAILWITH } {} ;
4188
                                 DUP ;
4189
                                 GET 5 ;
4190
                                 IF { PUSH int 230 ; FAILWITH } {} ;
4191
                                 CAR ;
4192
                                 CAR ;
4193
                                 SENDER ;
4194
                                 MEM ;
4195
                                 IF
4196
                                   { PUSH bool True }
4197
                                   { SWAP ; DUP ; DUG 2 ; CAR ; GET 3 ; CAR ; SENDER ; MEM } ;
4198
                                 IF
4199
                                   { PUSH bool True }
4200
                                   { SENDER ; DUP 3 ; CAR ; CAR ; CAR ; CAR ; COMPARE ; EQ } ;
4201
                                 IF {} { PUSH int 231 ; FAILWITH } ;
4202
                                 SWAP ;
4203
                                 UNPAIR ;
4204
                                 UNPAIR ;
4205
                                 UNPAIR ;
4206
                                 SWAP ;
4207
                                 UNPAIR ;
4208
                                 DUP ;
4209
                                 DUP 7 ;
4210
                                 CAR ;
4211
                                 DUP ;
4212
                                 DUG 2 ;
4213
                                 GET ;
4214
                                 IF_NONE { PUSH int 232 ; FAILWITH } {} ;
4215
                                 DIG 7 ;
4216
                                 CDR ;
4217
                                 UPDATE 3 ;
4218
                                 SOME ;
4219
                                 SWAP ;
4220
                                 UPDATE ;
4221
                                 PAIR ;
4222
                                 SWAP ;
4223
                                 PAIR ;
4224
                                 PAIR ;
4225
                                 PAIR ;
4226
                                 NIL operation }
4227
                               { SWAP ;
4228
                                 DUP ;
4229
                                 DUG 2 ;
4230
                                 CAR ;
4231
                                 CAR ;
4232
                                 CAR ;
4233
                                 CAR ;
4234
                                 SENDER ;
4235
                                 COMPARE ;
4236
                                 EQ ;
4237
                                 IF
4238
                                   { PUSH bool True }
4239
                                   { SWAP ; DUP ; DUG 2 ; CAR ; GET 3 ; CAR ; SENDER ; MEM } ;
4240
                                 IF {} { PUSH int 1137 ; FAILWITH } ;
4241
                                 DUP ;
4242
                                 CAR ;
4243
                                 CONTRACT %set_metadata (big_map string bytes) ;
4244
                                 IF_NONE { PUSH int 215 ; FAILWITH } {} ;
4245
                                 NIL operation ;
4246
                                 SWAP ;
4247
                                 PUSH mutez 0 ;
4248
                                 DIG 3 ;
4249
                                 CDR ;
4250
                                 TRANSFER_TOKENS ;
4251
                                 CONS } } } } }
4252
               { IF_LEFT
4253
                   { IF_LEFT
4254
                       { IF_LEFT
4255
                           { SWAP ;
4256
                             DUP ;
4257
                             DUG 2 ;
4258
                             CAR ;
4259
                             CAR ;
4260
                             CAR ;
4261
                             CAR ;
4262
                             SENDER ;
4263
                             COMPARE ;
4264
                             EQ ;
4265
                             IF
4266
                               { PUSH bool True }
4267
                               { SWAP ; DUP ; DUG 2 ; CAR ; GET 3 ; CAR ; SENDER ; MEM } ;
4268
                             IF {} { PUSH int 1137 ; FAILWITH } ;
4269
                             SWAP ;
4270
                             UNPAIR ;
4271
                             UNPAIR ;
4272
                             SWAP ;
4273
                             UNPAIR ;
4274
                             SWAP ;
4275
                             UNPAIR ;
4276
                             SWAP ;
4277
                             CDR ;
4278
                             DIG 5 ;
4279
                             PAIR ;
4280
                             SWAP ;
4281
                             PAIR ;
4282
                             SWAP ;
4283
                             PAIR ;
4284
                             SWAP ;
4285
                             PAIR ;
4286
                             PAIR }
4287
                           { SWAP ;
4288
                             DUP ;
4289
                             DUG 2 ;
4290
                             CAR ;
4291
                             CAR ;
4292
                             CAR ;
4293
                             CAR ;
4294
                             SENDER ;
4295
                             COMPARE ;
4296
                             EQ ;
4297
                             IF
4298
                               { PUSH bool True }
4299
                               { SWAP ; DUP ; DUG 2 ; CAR ; GET 3 ; CAR ; SENDER ; MEM } ;
4300
                             IF {} { PUSH int 1137 ; FAILWITH } ;
4301
                             UPDATE 9 } ;
4302
                         NIL operation }
4303
                       { IF_LEFT
4304
                           { SWAP ;
4305
                             DUP ;
4306
                             DUG 2 ;
4307
                             GET 7 ;
4308
                             SWAP ;
4309
                             DUP ;
4310
                             DUG 2 ;
4311
                             GET ;
4312
                             IF_NONE { PUSH int 780 ; FAILWITH } {} ;
4313
                             CAR ;
4314
                             GET 3 ;
4315
                             CDR ;
4316
                             SENDER ;
4317
                             MEM ;
4318
                             IF
4319
                               { SWAP ;
4320
                                 DUP ;
4321
                                 GET 7 ;
4322
                                 DUP ;
4323
                                 DIG 3 ;
4324
                                 DUP ;
4325
                                 DUG 2 ;
4326
                                 GET ;
4327
                                 IF_NONE { PUSH int 781 ; FAILWITH } {} ;
4328
                                 UNPAIR ;
4329
                                 SWAP ;
4330
                                 UNPAIR ;
4331
                                 SWAP ;
4332
                                 UNPAIR ;
4333
                                 UNPAIR ;
4334
                                 SWAP ;
4335
                                 PUSH bool True ;
4336
                                 SENDER ;
4337
                                 UPDATE ;
4338
                                 SWAP ;
4339
                                 PAIR ;
4340
                                 PAIR ;
4341
                                 SWAP ;
4342
                                 PAIR ;
4343
                                 SWAP ;
4344
                                 PAIR ;
4345
                                 SOME ;
4346
                                 SWAP ;
4347
                                 UPDATE ;
4348
                                 UPDATE 7 }
4349
                               { PUSH int 783 ; FAILWITH } ;
4350
                             NIL operation }
4351
                           { IF_LEFT
4352
                               { SWAP ;
4353
                                 DUP ;
4354
                                 DUG 2 ;
4355
                                 CAR ;
4356
                                 CAR ;
4357
                                 CAR ;
4358
                                 CAR ;
4359
                                 SENDER ;
4360
                                 COMPARE ;
4361
                                 EQ ;
4362
                                 IF {} { PUSH int 1092 ; FAILWITH } ;
4363
                                 SWAP ;
4364
                                 UNPAIR ;
4365
                                 SWAP ;
4366
                                 UNPAIR ;
4367
                                 SWAP ;
4368
                                 UNPAIR ;
4369
                                 CAR ;
4370
                                 DIG 4 ;
4371
                                 SWAP ;
4372
                                 PAIR ;
4373
                                 PAIR ;
4374
                                 SWAP ;
4375
                                 PAIR ;
4376
                                 SWAP ;
4377
                                 PAIR ;
4378
                                 NIL operation }
4379
                               { SWAP ;
4380
                                 DUP ;
4381
                                 DUG 2 ;
4382
                                 GET 7 ;
4383
                                 SWAP ;
4384
                                 DUP ;
4385
                                 DUG 2 ;
4386
                                 CDR ;
4387
                                 GET ;
4388
                                 IF_NONE { PUSH int 931 ; FAILWITH } {} ;
4389
                                 DUP 3 ;
4390
                                 CAR ;
4391
                                 CAR ;
4392
                                 GET 3 ;
4393
                                 DUP 3 ;
4394
                                 GET 5 ;
4395
                                 GET ;
4396
                                 IF_NONE { PUSH int 932 ; FAILWITH } {} ;
4397
                                 SWAP ;
4398
                                 CAR ;
4399
                                 GET 3 ;
4400
                                 CDR ;
4401
                                 SENDER ;
4402
                                 MEM ;
4403
                                 IF
4404
                                   { DROP ; PUSH bool True }
4405
                                   { CAR ; CAR ; SENDER ; MEM } ;
4406
                                 IF
4407
                                   { PUSH bool True }
4408
                                   { SWAP ; DUP ; DUG 2 ; CAR ; GET 3 ; CAR ; SENDER ; MEM } ;
4409
                                 IF
4410
                                   { PUSH bool True }
4411
                                   { SWAP ; DUP ; DUG 2 ; CAR ; CAR ; CAR ; CAR ; SENDER ; COMPARE ; EQ } ;
4412
                                 IF {} { PUSH int 1606 ; FAILWITH } ;
4413
                                 NIL operation ;
4414
                                 DUP 3 ;
4415
                                 CAR ;
4416
                                 CAR ;
4417
                                 CAR ;
4418
                                 CDR ;
4419
                                 CONTRACT %cancel_auction nat ;
4420
                                 IF_NONE { PUSH int 1567 ; FAILWITH } {} ;
4421
                                 PUSH mutez 0 ;
4422
                                 DUP 4 ;
4423
                                 CAR ;
4424
                                 TRANSFER_TOKENS ;
4425
                                 CONS ;
4426
                                 DUP 3 ;
4427
                                 DUP ;
4428
                                 GET 7 ;
4429
                                 DUP ;
4430
                                 DUP 5 ;
4431
                                 CDR ;
4432
                                 DUP ;
4433
                                 DUG 2 ;
4434
                                 GET ;
4435
                                 IF_NONE { PUSH int 937 ; FAILWITH } {} ;
4436
                                 UNPAIR ;
4437
                                 SWAP ;
4438
                                 UNPAIR ;
4439
                                 CDR ;
4440
                                 PUSH nat 1 ;
4441
                                 DIG 9 ;
4442
                                 GET 7 ;
4443
                                 DUP 10 ;
4444
                                 CDR ;
4445
                                 GET ;
4446
                                 IF_NONE { PUSH int 937 ; FAILWITH } {} ;
4447
                                 GET 3 ;
4448
                                 CAR ;
4449
                                 SUB ;
4450
                                 ISNAT ;
4451
                                 IF_NONE { PUSH int 937 ; FAILWITH } {} ;
4452
                                 PAIR ;
4453
                                 PAIR ;
4454
                                 SWAP ;
4455
                                 PAIR ;
4456
                                 SOME ;
4457
                                 SWAP ;
4458
                                 UPDATE ;
4459
                                 UPDATE 7 ;
4460
                                 DUP ;
4461
                                 GET 7 ;
4462
                                 DUP ;
4463
                                 DUP 5 ;
4464
                                 CDR ;
4465
                                 DUP ;
4466
                                 DUG 2 ;
4467
                                 GET ;
4468
                                 IF_NONE { PUSH int 938 ; FAILWITH } {} ;
4469
                                 DUP ;
4470
                                 GET 8 ;
4471
                                 PUSH nat 1 ;
4472
                                 ADD ;
4473
                                 UPDATE 8 ;
4474
                                 SOME ;
4475
                                 SWAP ;
4476
                                 UPDATE ;
4477
                                 UPDATE 7 ;
4478
                                 DUP ;
4479
                                 GET 7 ;
4480
                                 DUP ;
4481
                                 DUP 5 ;
4482
                                 CDR ;
4483
                                 DUP ;
4484
                                 DUG 2 ;
4485
                                 GET ;
4486
                                 IF_NONE { PUSH int 939 ; FAILWITH } {} ;
4487
                                 UNPAIR ;
4488
                                 UNPAIR ;
4489
                                 SWAP ;
4490
                                 UNPAIR ;
4491
                                 UNPAIR ;
4492
                                 PUSH bool False ;
4493
                                 DIG 10 ;
4494
                                 CAR ;
4495
                                 UPDATE ;
4496
                                 PAIR ;
4497
                                 PAIR ;
4498
                                 SWAP ;
4499
                                 PAIR ;
4500
                                 PAIR ;
4501
                                 SOME ;
4502
                                 SWAP ;
4503
                                 UPDATE ;
4504
                                 UPDATE 7 ;
4505
                                 SWAP } } } }
4506
                   { IF_LEFT
4507
                       { IF_LEFT
4508
                           { SWAP ;
4509
                             DUP ;
4510
                             DUG 2 ;
4511
                             GET 7 ;
4512
                             SWAP ;
4513
                             DUP ;
4514
                             DUG 2 ;
4515
                             CDR ;
4516
                             GET ;
4517
                             IF_NONE { PUSH int 907 ; FAILWITH } {} ;
4518
                             DUP 3 ;
4519
                             CAR ;
4520
                             CAR ;
4521
                             GET 3 ;
4522
                             DUP 3 ;
4523
                             GET 5 ;
4524
                             GET ;
4525
                             IF_NONE { PUSH int 908 ; FAILWITH } {} ;
4526
                             SWAP ;
4527
                             CAR ;
4528
                             GET 3 ;
4529
                             CDR ;
4530
                             SENDER ;
4531
                             MEM ;
4532
                             IF { DROP ; PUSH bool True } { CAR ; CAR ; SENDER ; MEM } ;
4533
                             IF
4534
                               { PUSH bool True }
4535
                               { SWAP ; DUP ; DUG 2 ; CAR ; GET 3 ; CAR ; SENDER ; MEM } ;
4536
                             IF
4537
                               { PUSH bool True }
4538
                               { SWAP ; DUP ; DUG 2 ; CAR ; CAR ; CAR ; CAR ; SENDER ; COMPARE ; EQ } ;
4539
                             IF {} { PUSH int 1606 ; FAILWITH } ;
4540
                             SWAP ;
4541
                             DUP ;
4542
                             DUG 2 ;
4543
                             CAR ;
4544
                             GET 5 ;
4545
                             SWAP ;
4546
                             DUP ;
4547
                             DUG 2 ;
4548
                             CAR ;
4549
                             VIEW "get_remaining_editions" nat ;
4550
                             IF_NONE { PUSH int 1499 ; FAILWITH } {} ;
4551
                             NIL operation ;
4552
                             DUP 4 ;
4553
                             CAR ;
4554
                             GET 5 ;
4555
                             CONTRACT %retract_ask nat ;
4556
                             IF_NONE { PUSH int 1554 ; FAILWITH } {} ;
4557
                             PUSH mutez 0 ;
4558
                             DUP 5 ;
4559
                             CAR ;
4560
                             TRANSFER_TOKENS ;
4561
                             CONS ;
4562
                             DUP 4 ;
4563
                             DUP ;
4564
                             GET 7 ;
4565
                             DUP ;
4566
                             DUP 6 ;
4567
                             CDR ;
4568
                             DUP ;
4569
                             DUG 2 ;
4570
                             GET ;
4571
                             IF_NONE { PUSH int 916 ; FAILWITH } {} ;
4572
                             UNPAIR ;
4573
                             SWAP ;
4574
                             UNPAIR ;
4575
                             CDR ;
4576
                             DUP 8 ;
4577
                             DIG 10 ;
4578
                             GET 7 ;
4579
                             DUP 11 ;
4580
                             CDR ;
4581
                             GET ;
4582
                             IF_NONE { PUSH int 916 ; FAILWITH } {} ;
4583
                             GET 3 ;
4584
                             CAR ;
4585
                             SUB ;
4586
                             ISNAT ;
4587
                             IF_NONE { PUSH int 916 ; FAILWITH } {} ;
4588
                             PAIR ;
4589
                             PAIR ;
4590
                             SWAP ;
4591
                             PAIR ;
4592
                             SOME ;
4593
                             SWAP ;
4594
                             UPDATE ;
4595
                             UPDATE 7 ;
4596
                             DUP ;
4597
                             GET 7 ;
4598
                             DUP ;
4599
                             DUP 6 ;
4600
                             CDR ;
4601
                             DUP ;
4602
                             DUG 2 ;
4603
                             GET ;
4604
                             IF_NONE { PUSH int 917 ; FAILWITH } {} ;
4605
                             DUP ;
4606
                             GET 8 ;
4607
                             DIG 6 ;
4608
                             ADD ;
4609
                             UPDATE 8 ;
4610
                             SOME ;
4611
                             SWAP ;
4612
                             UPDATE ;
4613
                             UPDATE 7 ;
4614
                             DUP ;
4615
                             GET 7 ;
4616
                             DUP ;
4617
                             DUP 5 ;
4618
                             CDR ;
4619
                             DUP ;
4620
                             DUG 2 ;
4621
                             GET ;
4622
                             IF_NONE { PUSH int 918 ; FAILWITH } {} ;
4623
                             UNPAIR ;
4624
                             SWAP ;
4625
                             UNPAIR ;
4626
                             UNPAIR ;
4627
                             SWAP ;
4628
                             UNPAIR ;
4629
                             PUSH bool False ;
4630
                             DIG 10 ;
4631
                             CAR ;
4632
                             UPDATE ;
4633
                             PAIR ;
4634
                             SWAP ;
4635
                             PAIR ;
4636
                             PAIR ;
4637
                             SWAP ;
4638
                             PAIR ;
4639
                             SOME ;
4640
                             SWAP ;
4641
                             UPDATE ;
4642
                             UPDATE 7 ;
4643
                             SWAP }
4644
                           { SWAP ;
4645
                             DUP ;
4646
                             DUG 2 ;
4647
                             CAR ;
4648
                             CAR ;
4649
                             CAR ;
4650
                             CAR ;
4651
                             SENDER ;
4652
                             COMPARE ;
4653
                             EQ ;
4654
                             IF {} { PUSH int 1142 ; FAILWITH } ;
4655
                             SWAP ;
4656
                             UNPAIR ;
4657
                             UNPAIR ;
4658
                             UNPAIR ;
4659
                             CAR ;
4660
                             DIG 4 ;
4661
                             SWAP ;
4662
                             PAIR ;
4663
                             PAIR ;
4664
                             PAIR ;
4665
                             PAIR ;
4666
                             NIL operation } }
4667
                       { IF_LEFT
4668
                           { SWAP ;
4669
                             DUP ;
4670
                             DUG 2 ;
4671
                             CAR ;
4672
                             CAR ;
4673
                             CAR ;
4674
                             CAR ;
4675
                             SENDER ;
4676
                             COMPARE ;
4677
                             EQ ;
4678
                             IF {} { PUSH int 1142 ; FAILWITH } ;
4679
                             SWAP ;
4680
                             UNPAIR ;
4681
                             UNPAIR ;
4682
                             UNPAIR ;
4683
                             SWAP ;
4684
                             CAR ;
4685
                             DIG 4 ;
4686
                             SWAP ;
4687
                             PAIR ;
4688
                             SWAP ;
4689
                             PAIR ;
4690
                             PAIR ;
4691
                             PAIR ;
4692
                             NIL operation }
4693
                           { IF_LEFT
4694
                               { SWAP ;
4695
                                 DUP ;
4696
                                 DUG 2 ;
4697
                                 CAR ;
4698
                                 CAR ;
4699
                                 CAR ;
4700
                                 CAR ;
4701
                                 SENDER ;
4702
                                 COMPARE ;
4703
                                 EQ ;
4704
                                 IF {} { PUSH int 1142 ; FAILWITH } ;
4705
                                 SWAP ;
4706
                                 UNPAIR ;
4707
                                 UNPAIR ;
4708
                                 SWAP ;
4709
                                 UNPAIR ;
4710
                                 SWAP ;
4711
                                 CDR ;
4712
                                 DIG 4 ;
4713
                                 PAIR ;
4714
                                 SWAP ;
4715
                                 PAIR ;
4716
                                 SWAP ;
4717
                                 PAIR ;
4718
                                 PAIR ;
4719
                                 NIL operation }
4720
                               { SWAP ;
4721
                                 DUP ;
4722
                                 DUG 2 ;
4723
                                 GET 7 ;
4724
                                 SWAP ;
4725
                                 DUP ;
4726
                                 DUG 2 ;
4727
                                 CDR ;
4728
                                 GET ;
4729
                                 IF_NONE { PUSH int 1057 ; FAILWITH } {} ;
4730
                                 CAR ;
4731
                                 GET 3 ;
4732
                                 CDR ;
4733
                                 SENDER ;
4734
                                 MEM ;
4735
                                 IF {} { PUSH int 1058 ; FAILWITH } ;
4736
                                 DUP ;
4737
                                 GET 3 ;
4738
                                 CONTRACT %update_token_metadata (list (pair
4739
                                                                        (nat %token_id)
4740
                                                                        (map %token_info
4741
                                                                          string
4742
                                                                          bytes))) ;
4743
                                 IF_NONE { PUSH int 1355 ; FAILWITH } {} ;
4744
                                 NIL operation ;
4745
                                 SWAP ;
4746
                                 PUSH mutez 0 ;
4747
                                 NIL (pair nat (map string bytes)) ;
4748
                                 DIG 4 ;
4749
                                 DUP ;
4750
                                 CAR ;
4751
                                 SWAP ;
4752
                                 DUP ;
4753
                                 DUG 6 ;
4754
                                 GET 6 ;
4755
                                 PAIR ;
4756
                                 CONS ;
4757
                                 TRANSFER_TOKENS ;
4758
                                 CONS ;
4759
                                 DIG 2 ;
4760
                                 DUP ;
4761
                                 GET 7 ;
4762
                                 DUP ;
4763
                                 DIG 4 ;
4764
                                 CDR ;
4765
                                 DUP ;
4766
                                 DUG 2 ;
4767
                                 GET ;
4768
                                 IF_NONE { PUSH int 1062 ; FAILWITH } {} ;
4769
                                 UNPAIR ;
4770
                                 SWAP ;
4771
                                 UNPAIR ;
4772
                                 SWAP ;
4773
                                 UNPAIR ;
4774
                                 CAR ;
4775
                                 EMPTY_SET address ;
4776
                                 PUSH bool True ;
4777
                                 SENDER ;
4778
                                 UPDATE ;
4779
                                 SWAP ;
4780
                                 PAIR ;
4781
                                 PAIR ;
4782
                                 SWAP ;
4783
                                 PAIR ;
4784
                                 SWAP ;
4785
                                 PAIR ;
4786
                                 SOME ;
4787
                                 SWAP ;
4788
                                 UPDATE ;
4789
                                 UPDATE 7 ;
4790
                                 SWAP } } } } } } ;
4791
         NIL operation ;
4792
         SWAP ;
4793
         ITER { CONS } ;
4794
         PAIR } ;
4795
  view "_chk_lp"
4796
        (pair (address %address) (pair (set %creators address) (nat %mint_invite_id)))
4797
        bool
4798
        { UNPAIR ;
4799
          SWAP ;
4800
          DUP ;
4801
          DUG 2 ;
4802
          CAR ;
4803
          GET 8 ;
4804
          SWAP ;
4805
          DUP ;
4806
          DUG 2 ;
4807
          GET 4 ;
4808
          GET ;
4809
          IF_NONE { PUSH int 1631 ; FAILWITH } {} ;
4810
          DUP ;
4811
          CAR ;
4812
          CAR ;
4813
          GET 3 ;
4814
          IF
4815
            { SWAP ; DUP ; GET 3 ; SWAP ; DUP ; DUG 3 ; CAR ; MEM }
4816
            { PUSH bool False } ;
4817
          IF
4818
            { DROP 3 ; PUSH bool True }
4819
            { DUP ;
4820
              CAR ;
4821
              CAR ;
4822
              GET 4 ;
4823
              IF
4824
                { DUP 3 ;
4825
                  CAR ;
4826
                  CAR ;
4827
                  GET 3 ;
4828
                  SWAP ;
4829
                  GET 3 ;
4830
                  CAR ;
4831
                  GET ;
4832
                  IF_NONE { PUSH int 1632 ; FAILWITH } {} ;
4833
                  CAR ;
4834
                  CAR ;
4835
                  SWAP ;
4836
                  DUP ;
4837
                  DUG 2 ;
4838
                  CAR ;
4839
                  MEM ;
4840
                  IF
4841
                    { PUSH bool True }
4842
                    { SWAP ; DUP ; DUG 2 ; CAR ; GET 3 ; CAR ; SWAP ; DUP ; DUG 2 ; CAR ; MEM } ;
4843
                  IF
4844
                    { DROP 2 ; PUSH bool True }
4845
                    { SWAP ; CAR ; CAR ; CAR ; CAR ; SWAP ; CAR ; COMPARE ; EQ } }
4846
                { DROP 3 ; PUSH bool False } } } ;
4847
  view "_chk_ulp"
4848
        (pair (address %address) (pair (set %creators address) (nat %mint_invite_id)))
4849
        bool
4850
        { UNPAIR ;
4851
          SWAP ;
4852
          DUP ;
4853
          DUG 2 ;
4854
          CAR ;
4855
          GET 8 ;
4856
          SWAP ;
4857
          DUP ;
4858
          DUG 2 ;
4859
          GET 4 ;
4860
          GET ;
4861
          IF_NONE { PUSH int 1645 ; FAILWITH } {} ;
4862
          SWAP ;
4863
          DUP ;
4864
          GET 3 ;
4865
          SWAP ;
4866
          DUP ;
4867
          DUG 3 ;
4868
          CAR ;
4869
          MEM ;
4870
          IF
4871
            { DROP ; PUSH bool True }
4872
            { DUP 3 ;
4873
              CAR ;
4874
              CAR ;
4875
              GET 3 ;
4876
              SWAP ;
4877
              GET 3 ;
4878
              CAR ;
4879
              GET ;
4880
              IF_NONE { PUSH int 1646 ; FAILWITH } {} ;
4881
              CAR ;
4882
              CAR ;
4883
              SWAP ;
4884
              DUP ;
4885
              DUG 2 ;
4886
              CAR ;
4887
              MEM } ;
4888
          IF
4889
            { PUSH bool True }
4890
            { SWAP ; DUP ; DUG 2 ; CAR ; GET 3 ; CAR ; SWAP ; DUP ; DUG 2 ; CAR ; MEM } ;
4891
          IF
4892
            { DROP 2 ; PUSH bool True }
4893
            { SWAP ; CAR ; CAR ; CAR ; CAR ; SWAP ; CAR ; COMPARE ; EQ } } ;
4894
  view "_get_shares"
4895
        (pair (address %address) (pair (nat %exhibition_id) (nat %token_id)))
4896
        (map address nat)
4897
        { UNPAIR ; SWAP ; GET 7 ; SWAP ; GET ; IF_NONE { PUSH int 1653 ; FAILWITH } {} ; GET 5 ; CAR } }