BCD

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