BCD

Tezos Contract Explorer
Search Networks Deploy
  • Home
  • /
  • Mainnet
  • /
  • KT1XUwJ...X3tM
FA2
operations (42)Storage Code Interact Tokens Fork Views Statistics Details
Latest
​x
867
1748
 
1
{ parameter (or
2
              (or
3
                (or
4
                  (pair %balance_of
5
                    (list %requests (pair (address %owner) (nat %token_id)))
6
                    (contract %callback (list (pair
7
                                              (pair %request (address %owner)
8
                                                             (nat %token_id))
9
                                              (nat %balance)))))
10
                  (or (pair %deposit (nat %stake_id) (nat %token_amount))
11
                      (pair %internal_deposit (nat %stake_id) (nat %token_amount))))
12
                (or
13
                  (or
14
                    (pair %internal_withdraw (nat %ratio_denominator)
15
                                             (pair (nat %ratio_numerator)
16
                                                   (nat %stake_id)))
17
                    (address %propose_administrator))
18
                  (or (address %remove_administrator)
19
                      (pair %remove_exchange (nat %src_token_id)
20
                                             (pair (address %src_token_address)
21
                                                   (pair (nat %dst_token_id)
22
                                                         (address %dst_token_address)))))))
23
              (or
24
                (or
25
                  (or (unit %set_administrator)
26
                      (list %set_balance (pair
27
                                          (pair %request (address %owner)
28
                                                         (nat %token_id))
29
                                          (nat %balance))))
30
                  (or
31
                    (pair %set_exchange
32
                      (pair %exchange_key (nat %src_token_id)
33
                                          (pair (address %src_token_address)
34
                                                (pair (nat %dst_token_id)
35
                                                      (address %dst_token_address))))
36
                      (pair %exchange_value (address %oracle_address)
37
                                            (lambda %execution_lambda (pair nat nat)
38
                                                                      (list operation))))
39
                    (list %swap (pair
40
                                 (pair %exchange_key (nat %src_token_id)
41
                                                     (pair (address %src_token_address)
42
                                                           (pair (nat %dst_token_id)
43
                                                                 (address %dst_token_address))))
44
                                 (nat %token_amount)))))
45
                (or
46
                  (or
47
                    (list %transfer (pair (address %from_)
48
                                         (list %txs (pair (address %to_)
49
                                                         (pair (nat %token_id)
50
                                                               (nat %amount))))))
51
                    (nat %update_max_release_period))
52
                  (or
53
                    (list %update_operators (or
54
                                             (pair %add_operator (address %owner)
55
                                                                 (pair
56
                                                                   (address %operator)
57
                                                                   (nat %token_id)))
58
                                             (pair %remove_operator (address %owner)
59
                                                                    (pair
60
                                                                      (address %operator)
61
                                                                      (nat %token_id)))))
62
                    (pair %withdraw (nat %ratio_denominator)
63
                                    (pair (nat %ratio_numerator) (nat %stake_id))))))) ;
64
  storage (pair
65
            (pair
66
              (pair (big_map %administrators address int)
67
                    (pair (nat %current_token_balance) (nat %disc_factor)))
68
              (pair
69
                (pair
70
                  (big_map %exchanges
71
                    (pair (nat %src_token_id)
72
                          (pair (address %src_token_address)
73
                                (pair (nat %dst_token_id) (address %dst_token_address))))
74
                    (pair (address %oracle_address)
75
                          (lambda %execution_lambda (pair nat nat) (list operation))))
76
                  (nat %last_stake_id))
77
                (pair (nat %last_token_balance) (nat %max_release_period))))
78
            (pair
79
              (pair
80
                (big_map %operators
81
                  (pair (address %owner) (pair (address %operator) (nat %token_id)))
82
                  unit)
83
                (pair (address %sender)
84
                      (big_map %stakes nat
85
                                       (pair (nat %token_amount)
86
                                             (pair (nat %stake)
87
                                                   (timestamp %age_timestamp))))))
88
              (pair
89
                (pair (big_map %stakes_owner_lookup address (set nat))
90
                      (address %token_address))
91
                (pair (nat %token_id) (nat %total_stake))))) ;
92
  code { LAMBDA
93
           (pair unit
94
                 (pair (list operation)
95
                       (pair
96
                         (pair (pair (big_map address int) (pair nat nat))
97
                               (pair
98
                                 (pair
99
                                   (big_map (pair nat (pair address (pair nat address)))
100
                                            (pair address
101
                                                  (lambda (pair nat nat)
102
                                                          (list operation))))
103
                                   nat)
104
                                 (pair nat nat)))
105
                         (pair
106
                           (pair (big_map (pair address (pair address nat)) unit)
107
                                 (pair address
108
                                       (big_map nat (pair nat (pair nat timestamp)))))
109
                           (pair (pair (big_map address (set nat)) address)
110
                                 (pair nat nat))))))
111
           (pair unit
112
                 (pair (list operation)
113
                       (pair
114
                         (pair (pair (big_map address int) (pair nat nat))
115
                               (pair
116
                                 (pair
117
                                   (big_map (pair nat (pair address (pair nat address)))
118
                                            (pair address
119
                                                  (lambda (pair nat nat)
120
                                                          (list operation))))
121
                                   nat)
122
                                 (pair nat nat)))
123
                         (pair
124
                           (pair (big_map (pair address (pair address nat)) unit)
125
                                 (pair address
126
                                       (big_map nat (pair nat (pair nat timestamp)))))
127
                           (pair (pair (big_map address (set nat)) address)
128
                                 (pair nat nat))))))
129
           { CDR ;
130
             UNPAIR ;
131
             SWAP ;
132
             DUP ;
133
             DUG 2 ;
134
             GET 5 ;
135
             CDR ;
136
             CONTRACT %balance_of (pair
137
                                    (list %requests (pair (address %owner)
138
                                                         (nat %token_id)))
139
                                    (contract %callback (list (pair
140
                                                              (pair %request
141
                                                                (address %owner)
142
                                                                (nat %token_id))
143
                                                              (nat %balance))))) ;
144
             IF_NONE { PUSH int 138 ; FAILWITH } {} ;
145
             PUSH mutez 0 ;
146
             SELF_ADDRESS ;
147
             CONTRACT %set_balance (list (pair
148
                                          (pair %request (address %owner)
149
                                                         (nat %token_id))
150
                                          (nat %balance))) ;
151
             IF_NONE { PUSH int 139 ; FAILWITH } {} ;
152
             NIL (pair address nat) ;
153
             DUP 6 ;
154
             GET 7 ;
155
             SELF_ADDRESS ;
156
             PAIR ;
157
             CONS ;
158
             PAIR ;
159
             TRANSFER_TOKENS ;
160
             CONS ;
161
             UNIT ;
162
             PAIR 3 } ;
163
         SWAP ;
164
         LAMBDA
165
           (pair unit
166
                 (pair
167
                   (pair (pair (big_map address int) (pair nat nat))
168
                         (pair
169
                           (pair
170
                             (big_map (pair nat (pair address (pair nat address)))
171
                                      (pair address
172
                                            (lambda (pair nat nat) (list operation))))
173
                             nat)
174
                           (pair nat nat)))
175
                   (pair
176
                     (pair (big_map (pair address (pair address nat)) unit)
177
                           (pair address (big_map nat (pair nat (pair nat timestamp)))))
178
                     (pair (pair (big_map address (set nat)) address) (pair nat nat)))))
179
           (pair unit
180
                 (pair
181
                   (pair (pair (big_map address int) (pair nat nat))
182
                         (pair
183
                           (pair
184
                             (big_map (pair nat (pair address (pair nat address)))
185
                                      (pair address
186
                                            (lambda (pair nat nat) (list operation))))
187
                             nat)
188
                           (pair nat nat)))
189
                   (pair
190
                     (pair (big_map (pair address (pair address nat)) unit)
191
                           (pair address (big_map nat (pair nat (pair nat timestamp)))))
192
                     (pair (pair (big_map address (set nat)) address) (pair nat nat)))))
193
           { CDR ;
194
             DUP ;
195
             GET 8 ;
196
             PUSH nat 0 ;
197
             COMPARE ;
198
             LT ;
199
             IF
200
               { DUP ;
201
                 UNPAIR ;
202
                 UNPAIR ;
203
                 UNPAIR ;
204
                 SWAP ;
205
                 UNPAIR ;
206
                 SWAP ;
207
                 DUP 6 ;
208
                 GET 8 ;
209
                 PUSH nat 1000000000000 ;
210
                 DIG 7 ;
211
                 DUP ;
212
                 CAR ;
213
                 GET 5 ;
214
                 SWAP ;
215
                 CAR ;
216
                 CAR ;
217
                 GET 3 ;
218
                 SUB ;
219
                 ISNAT ;
220
                 IF_NONE { PUSH int 146 ; FAILWITH } {} ;
221
                 MUL ;
222
                 EDIV ;
223
                 IF_NONE { PUSH int 147 ; FAILWITH } { CAR } ;
224
                 ADD ;
225
                 SWAP ;
226
                 PAIR ;
227
                 SWAP ;
228
                 PAIR ;
229
                 PAIR ;
230
                 PAIR ;
231
                 DUP ;
232
                 UNPAIR ;
233
                 UNPAIR ;
234
                 SWAP ;
235
                 UNPAIR ;
236
                 SWAP ;
237
                 CDR ;
238
                 DIG 4 ;
239
                 CAR ;
240
                 CAR ;
241
                 GET 3 ;
242
                 PAIR ;
243
                 SWAP ;
244
                 PAIR ;
245
                 SWAP ;
246
                 PAIR ;
247
                 PAIR }
248
               {} ;
249
             UNIT ;
250
             PAIR } ;
251
         SWAP ;
252
         LAMBDA
253
           unit
254
           unit
255
           { DROP ; SELF_ADDRESS ; SENDER ; COMPARE ; EQ ; IF {} { PUSH int 400 ; FAILWITH } ; UNIT } ;
256
         SWAP ;
257
         LAMBDA
258
           (pair unit
259
                 (pair
260
                   (pair (pair (big_map address int) (pair nat nat))
261
                         (pair
262
                           (pair
263
                             (big_map (pair nat (pair address (pair nat address)))
264
                                      (pair address
265
                                            (lambda (pair nat nat) (list operation))))
266
                             nat)
267
                           (pair nat nat)))
268
                   (pair
269
                     (pair (big_map (pair address (pair address nat)) unit)
270
                           (pair address (big_map nat (pair nat (pair nat timestamp)))))
271
                     (pair (pair (big_map address (set nat)) address) (pair nat nat)))))
272
           (pair unit
273
                 (pair
274
                   (pair (pair (big_map address int) (pair nat nat))
275
                         (pair
276
                           (pair
277
                             (big_map (pair nat (pair address (pair nat address)))
278
                                      (pair address
279
                                            (lambda (pair nat nat) (list operation))))
280
                             nat)
281
                           (pair nat nat)))
282
                   (pair
283
                     (pair (big_map (pair address (pair address nat)) unit)
284
                           (pair address (big_map nat (pair nat (pair nat timestamp)))))
285
                     (pair (pair (big_map address (set nat)) address) (pair nat nat)))))
286
           { CDR ;
287
             DUP ;
288
             CAR ;
289
             CAR ;
290
             CAR ;
291
             PUSH int 1 ;
292
             SWAP ;
293
             SENDER ;
294
             GET ;
295
             IF_NONE { PUSH int 35 ; FAILWITH } {} ;
296
             COMPARE ;
297
             EQ ;
298
             IF {} { PUSH int 401 ; FAILWITH } ;
299
             UNIT ;
300
             PAIR } ;
301
         SWAP ;
302
         UNPAIR ;
303
         IF_LEFT
304
           { IF_LEFT
305
               { IF_LEFT
306
                   { NIL (pair (pair address nat) nat) ;
307
                     SWAP ;
308
                     DUP ;
309
                     DUG 2 ;
310
                     CAR ;
311
                     ITER { DUP 4 ;
312
                            GET 3 ;
313
                            GET 4 ;
314
                            SWAP ;
315
                            DUP ;
316
                            DUG 2 ;
317
                            CDR ;
318
                            MEM ;
319
                            IF {} { PUSH string "FA2_TOKEN_UNDEFINED" ; FAILWITH } ;
320
                            DUP 4 ;
321
                            GET 3 ;
322
                            GET 4 ;
323
                            SWAP ;
324
                            DUP ;
325
                            DUG 2 ;
326
                            CDR ;
327
                            GET ;
328
                            IF_NONE { PUSH int 322 ; FAILWITH } { DROP } ;
329
                            DUP 4 ;
330
                            GET 5 ;
331
                            CAR ;
332
                            SWAP ;
333
                            DUP ;
334
                            DUG 2 ;
335
                            CAR ;
336
                            MEM ;
337
                            IF
338
                              { DUP 4 ;
339
                                GET 5 ;
340
                                CAR ;
341
                                SWAP ;
342
                                DUP ;
343
                                DUG 2 ;
344
                                CAR ;
345
                                GET ;
346
                                IF_NONE { PUSH int 324 ; FAILWITH } {} ;
347
                                SWAP ;
348
                                DUP ;
349
                                DUG 2 ;
350
                                CDR ;
351
                                MEM ;
352
                                IF
353
                                  { SWAP ; PUSH nat 1 ; DIG 2 ; PAIR ; CONS }
354
                                  { DROP } }
355
                              { SWAP ; PUSH nat 0 ; DIG 2 ; PAIR ; CONS } } ;
356
                     DIG 3 ;
357
                     DROP ;
358
                     DIG 3 ;
359
                     DROP ;
360
                     DIG 3 ;
361
                     DROP ;
362
                     DIG 3 ;
363
                     DROP ;
364
                     NIL operation ;
365
                     DIG 2 ;
366
                     CDR ;
367
                     PUSH mutez 0 ;
368
                     DIG 3 ;
369
                     TRANSFER_TOKENS ;
370
                     CONS }
371
                   { IF_LEFT
372
                       { DIG 2 ;
373
                         DROP ;
374
                         DIG 2 ;
375
                         DROP ;
376
                         DIG 2 ;
377
                         DROP ;
378
                         SWAP ;
379
                         UNPAIR ;
380
                         SWAP ;
381
                         UNPAIR ;
382
                         UNPAIR ;
383
                         SWAP ;
384
                         CDR ;
385
                         SENDER ;
386
                         PAIR ;
387
                         SWAP ;
388
                         PAIR ;
389
                         PAIR ;
390
                         SWAP ;
391
                         PAIR ;
392
                         SWAP ;
393
                         NIL operation ;
394
                         DIG 3 ;
395
                         UNIT ;
396
                         SWAP ;
397
                         DIG 4 ;
398
                         DIG 3 ;
399
                         DIG 3 ;
400
                         PAIR 3 ;
401
                         EXEC ;
402
                         CDR ;
403
                         UNPAIR ;
404
                         SWAP ;
405
                         DUG 2 ;
406
                         SELF %internal_deposit ;
407
                         PUSH mutez 0 ;
408
                         DIG 3 ;
409
                         TRANSFER_TOKENS ;
410
                         CONS }
411
                       { DUP 4 ;
412
                         UNIT ;
413
                         EXEC ;
414
                         DUP 6 ;
415
                         UNIT ;
416
                         SWAP ;
417
                         DIG 4 ;
418
                         DIG 2 ;
419
                         PAIR ;
420
                         EXEC ;
421
                         UNPAIR ;
422
                         DIG 7 ;
423
                         DIG 7 ;
424
                         DIG 7 ;
425
                         DIG 7 ;
426
                         DIG 5 ;
427
                         DIG 7 ;
428
                         DIG 7 ;
429
                         DIG 7 ;
430
                         DUP 3 ;
431
                         CDR ;
432
                         NIL operation ;
433
                         DUP 6 ;
434
                         GET 5 ;
435
                         CDR ;
436
                         CONTRACT %transfer (list (pair (address %from_)
437
                                                       (list %txs (pair (address %to_)
438
                                                                       (pair
439
                                                                         (nat %token_id)
440
                                                                         (nat %amount)))))) ;
441
                         IF_NONE { PUSH int 109 ; FAILWITH } {} ;
442
                         PUSH mutez 0 ;
443
                         NIL (pair address (list (pair address (pair nat nat)))) ;
444
                         NIL (pair address (pair nat nat)) ;
445
                         DUP 6 ;
446
                         DUP 11 ;
447
                         GET 7 ;
448
                         SELF_ADDRESS ;
449
                         PAIR 3 ;
450
                         CONS ;
451
                         DUP 10 ;
452
                         GET 3 ;
453
                         GET 3 ;
454
                         PAIR ;
455
                         CONS ;
456
                         TRANSFER_TOKENS ;
457
                         CONS ;
458
                         DIG 5 ;
459
                         UNPAIR ;
460
                         UNPAIR ;
461
                         SWAP ;
462
                         UNPAIR ;
463
                         SWAP ;
464
                         UNPAIR ;
465
                         DUP 7 ;
466
                         ADD ;
467
                         PAIR ;
468
                         SWAP ;
469
                         PAIR ;
470
                         SWAP ;
471
                         PAIR ;
472
                         PAIR ;
473
                         DUP ;
474
                         DUG 6 ;
475
                         CAR ;
476
                         CAR ;
477
                         GET 4 ;
478
                         PUSH nat 1000000000000 ;
479
                         DUP 4 ;
480
                         MUL ;
481
                         EDIV ;
482
                         IF_NONE { PUSH int 199 ; FAILWITH } { CAR } ;
483
                         DUP 6 ;
484
                         CAR ;
485
                         DUP ;
486
                         PUSH nat 0 ;
487
                         COMPARE ;
488
                         LT ;
489
                         IF
490
                           { DIG 4 ;
491
                             DROP ;
492
                             DIG 4 ;
493
                             DROP ;
494
                             DIG 4 ;
495
                             DROP ;
496
                             DIG 5 ;
497
                             DROP ;
498
                             DIG 5 ;
499
                             DROP ;
500
                             DIG 5 ;
501
                             DROP ;
502
                             DIG 5 ;
503
                             DROP ;
504
                             DIG 4 ;
505
                             DUP ;
506
                             GET 5 ;
507
                             CAR ;
508
                             SWAP ;
509
                             DUP ;
510
                             DUG 6 ;
511
                             GET 3 ;
512
                             GET 3 ;
513
                             GET ;
514
                             IF_NONE { PUSH int 203 ; FAILWITH } {} ;
515
                             SWAP ;
516
                             DUP ;
517
                             DUG 2 ;
518
                             MEM ;
519
                             IF {} { PUSH int 404 ; FAILWITH } }
520
                           { DROP ;
521
                             DIG 3 ;
522
                             DROP ;
523
                             DIG 3 ;
524
                             DROP ;
525
                             DIG 3 ;
526
                             DROP ;
527
                             DIG 4 ;
528
                             DROP ;
529
                             DIG 4 ;
530
                             DROP ;
531
                             DIG 4 ;
532
                             DROP ;
533
                             DIG 4 ;
534
                             DROP ;
535
                             DIG 3 ;
536
                             UNPAIR ;
537
                             UNPAIR ;
538
                             SWAP ;
539
                             UNPAIR ;
540
                             UNPAIR ;
541
                             SWAP ;
542
                             PUSH nat 1 ;
543
                             ADD ;
544
                             SWAP ;
545
                             PAIR ;
546
                             PAIR ;
547
                             SWAP ;
548
                             PAIR ;
549
                             PAIR ;
550
                             DUP ;
551
                             DUG 4 ;
552
                             CAR ;
553
                             GET 3 ;
554
                             CDR } ;
555
                         DUP 5 ;
556
                         GET 3 ;
557
                         GET 4 ;
558
                         SWAP ;
559
                         DUP ;
560
                         DUG 2 ;
561
                         MEM ;
562
                         IF
563
                           { DUP 5 ;
564
                             GET 3 ;
565
                             GET 4 ;
566
                             SWAP ;
567
                             DUP ;
568
                             DUG 2 ;
569
                             GET ;
570
                             IF_NONE { PUSH int 209 ; FAILWITH } {} ;
571
                             DUP 3 ;
572
                             SWAP ;
573
                             DUP ;
574
                             DUG 2 ;
575
                             GET 3 ;
576
                             ADD ;
577
                             DUP 7 ;
578
                             CAR ;
579
                             GET 6 ;
580
                             DUP 3 ;
581
                             GET 4 ;
582
                             NOW ;
583
                             SUB ;
584
                             ISNAT ;
585
                             IF_NONE { PUSH int 210 ; FAILWITH } {} ;
586
                             DUP ;
587
                             DUP 3 ;
588
                             COMPARE ;
589
                             LE ;
590
                             IF { DROP } { SWAP ; DROP } ;
591
                             DUP 3 ;
592
                             GET 3 ;
593
                             MUL ;
594
                             EDIV ;
595
                             IF_NONE { PUSH int 212 ; FAILWITH } { CAR } ;
596
                             INT ;
597
                             PUSH int -1 ;
598
                             MUL ;
599
                             NOW ;
600
                             ADD ;
601
                             SWAP ;
602
                             DUP ;
603
                             DUG 2 ;
604
                             DUP 5 ;
605
                             DIG 3 ;
606
                             GET 3 ;
607
                             ADD ;
608
                             UPDATE 3 ;
609
                             DUP ;
610
                             CAR ;
611
                             DIG 6 ;
612
                             ADD ;
613
                             UPDATE 1 ;
614
                             SWAP ;
615
                             UPDATE 4 ;
616
                             DIG 4 ;
617
                             UNPAIR ;
618
                             SWAP ;
619
                             UNPAIR ;
620
                             UNPAIR ;
621
                             SWAP ;
622
                             UNPAIR ;
623
                             SWAP ;
624
                             DIG 5 ;
625
                             SOME ;
626
                             DIG 6 ;
627
                             UPDATE ;
628
                             SWAP ;
629
                             PAIR ;
630
                             SWAP ;
631
                             PAIR ;
632
                             PAIR ;
633
                             SWAP ;
634
                             PAIR ;
635
                             DUG 2 }
636
                           { DIG 4 ;
637
                             DUP ;
638
                             GET 5 ;
639
                             CAR ;
640
                             SWAP ;
641
                             DUP ;
642
                             DUG 6 ;
643
                             GET 3 ;
644
                             GET 3 ;
645
                             MEM ;
646
                             IF
647
                               {}
648
                               { DUP 5 ;
649
                                 UNPAIR ;
650
                                 SWAP ;
651
                                 UNPAIR ;
652
                                 SWAP ;
653
                                 UNPAIR ;
654
                                 UNPAIR ;
655
                                 PUSH (option (set nat)) (Some {}) ;
656
                                 DIG 10 ;
657
                                 GET 3 ;
658
                                 GET 3 ;
659
                                 UPDATE ;
660
                                 PAIR ;
661
                                 PAIR ;
662
                                 SWAP ;
663
                                 PAIR ;
664
                                 SWAP ;
665
                                 PAIR ;
666
                                 DUG 4 } ;
667
                             DUP 5 ;
668
                             UNPAIR ;
669
                             SWAP ;
670
                             UNPAIR ;
671
                             SWAP ;
672
                             UNPAIR ;
673
                             UNPAIR ;
674
                             DUP ;
675
                             DIG 10 ;
676
                             GET 3 ;
677
                             GET 3 ;
678
                             DUP ;
679
                             DUG 2 ;
680
                             GET ;
681
                             IF_NONE { PUSH int 220 ; FAILWITH } {} ;
682
                             PUSH bool True ;
683
                             DUP 9 ;
684
                             UPDATE ;
685
                             SOME ;
686
                             SWAP ;
687
                             UPDATE ;
688
                             PAIR ;
689
                             PAIR ;
690
                             SWAP ;
691
                             UNPAIR ;
692
                             SWAP ;
693
                             UNPAIR ;
694
                             SWAP ;
695
                             NOW ;
696
                             DUP 8 ;
697
                             DIG 10 ;
698
                             PAIR 3 ;
699
                             SOME ;
700
                             DIG 6 ;
701
                             UPDATE ;
702
                             SWAP ;
703
                             PAIR ;
704
                             SWAP ;
705
                             PAIR ;
706
                             PAIR ;
707
                             SWAP ;
708
                             PAIR ;
709
                             DUG 2 } ;
710
                         DIG 2 ;
711
                         DUP ;
712
                         GET 8 ;
713
                         DIG 2 ;
714
                         ADD ;
715
                         UPDATE 8 ;
716
                         SWAP } } }
717
               { IF_LEFT
718
                   { IF_LEFT
719
                       { DUP 4 ;
720
                         UNIT ;
721
                         EXEC ;
722
                         DUP 6 ;
723
                         UNIT ;
724
                         SWAP ;
725
                         DIG 4 ;
726
                         DIG 2 ;
727
                         PAIR ;
728
                         EXEC ;
729
                         UNPAIR ;
730
                         DIG 7 ;
731
                         DIG 7 ;
732
                         DIG 7 ;
733
                         DIG 7 ;
734
                         DIG 5 ;
735
                         DIG 7 ;
736
                         DIG 7 ;
737
                         DIG 7 ;
738
                         DUP 4 ;
739
                         GET 3 ;
740
                         GET 4 ;
741
                         DUP 4 ;
742
                         GET 4 ;
743
                         GET ;
744
                         IF_NONE { PUSH int 244 ; FAILWITH } {} ;
745
                         DIG 4 ;
746
                         DUP ;
747
                         GET 5 ;
748
                         CAR ;
749
                         SWAP ;
750
                         DUP ;
751
                         DUG 6 ;
752
                         GET 3 ;
753
                         GET 3 ;
754
                         GET ;
755
                         IF_NONE { PUSH int 246 ; FAILWITH } {} ;
756
                         DUP 5 ;
757
                         GET 4 ;
758
                         MEM ;
759
                         IF {} { PUSH int 404 ; FAILWITH } ;
760
                         DIG 3 ;
761
                         DUP ;
762
                         CAR ;
763
                         SWAP ;
764
                         DUP ;
765
                         DUG 5 ;
766
                         GET 3 ;
767
                         COMPARE ;
768
                         LE ;
769
                         IF {} { PUSH int 603 ; FAILWITH } ;
770
                         DIG 3 ;
771
                         DUP ;
772
                         CAR ;
773
                         SWAP ;
774
                         DUP ;
775
                         DUG 5 ;
776
                         GET 3 ;
777
                         DUP 3 ;
778
                         CAR ;
779
                         MUL ;
780
                         EDIV ;
781
                         IF_NONE { PUSH int 251 ; FAILWITH } { CAR } ;
782
                         DIG 4 ;
783
                         DUP ;
784
                         CAR ;
785
                         SWAP ;
786
                         DUP ;
787
                         DUG 6 ;
788
                         GET 3 ;
789
                         DUP 4 ;
790
                         GET 3 ;
791
                         MUL ;
792
                         EDIV ;
793
                         IF_NONE { PUSH int 252 ; FAILWITH } { CAR } ;
794
                         PUSH nat 1000000000000 ;
795
                         DUP 8 ;
796
                         CAR ;
797
                         CAR ;
798
                         GET 4 ;
799
                         DUP 3 ;
800
                         MUL ;
801
                         EDIV ;
802
                         IF_NONE { PUSH int 253 ; FAILWITH } { CAR } ;
803
                         PUSH nat 0 ;
804
                         DUP 4 ;
805
                         DUP 3 ;
806
                         COMPARE ;
807
                         GT ;
808
                         IF
809
                           { DROP ;
810
                             DUP 3 ;
811
                             SWAP ;
812
                             DUP ;
813
                             DUG 2 ;
814
                             SUB ;
815
                             ISNAT ;
816
                             IF_NONE { PUSH int 256 ; FAILWITH } {} }
817
                           {} ;
818
                         NIL operation ;
819
                         DUP 10 ;
820
                         GET 5 ;
821
                         CDR ;
822
                         CONTRACT %transfer (list (pair (address %from_)
823
                                                       (list %txs (pair (address %to_)
824
                                                                       (pair
825
                                                                         (nat %token_id)
826
                                                                         (nat %amount)))))) ;
827
                         IF_NONE { PUSH int 109 ; FAILWITH } {} ;
828
                         PUSH mutez 0 ;
829
                         NIL (pair address (list (pair address (pair nat nat)))) ;
830
                         NIL (pair address (pair nat nat)) ;
831
                         DIG 13 ;
832
                         DUP ;
833
                         CAR ;
834
                         GET 6 ;
835
                         SWAP ;
836
                         DUP ;
837
                         DUG 15 ;
838
                         CAR ;
839
                         GET 6 ;
840
                         DUP 12 ;
841
                         GET 4 ;
842
                         NOW ;
843
                         SUB ;
844
                         ISNAT ;
845
                         IF_NONE { PUSH int 249 ; FAILWITH } {} ;
846
                         DUP ;
847
                         DUP 3 ;
848
                         COMPARE ;
849
                         LE ;
850
                         IF { DROP } { SWAP ; DROP } ;
851
                         DIG 7 ;
852
                         MUL ;
853
                         EDIV ;
854
                         IF_NONE { PUSH int 257 ; FAILWITH } { CAR } ;
855
                         DUP 9 ;
856
                         ADD ;
857
                         DIG 13 ;
858
                         DUP ;
859
                         GET 7 ;
860
                         SWAP ;
861
                         DUP ;
862
                         DUG 15 ;
863
                         GET 3 ;
864
                         GET 3 ;
865
                         PAIR 3 ;
866
                         CONS ;
867
                         SELF_ADDRESS ;
868
                         PAIR ;
869
                         CONS ;
870
                         TRANSFER_TOKENS ;
871
                         CONS ;
872
                         DUP 9 ;
873
                         UNPAIR ;
874
                         UNPAIR ;
875
                         SWAP ;
876
                         UNPAIR ;
877
                         SWAP ;
878
                         CDR ;
879
                         DIG 5 ;
880
                         DIG 12 ;
881
                         CAR ;
882
                         GET 5 ;
883
                         SUB ;
884
                         ISNAT ;
885
                         IF_NONE { PUSH int 261 ; FAILWITH } {} ;
886
                         PAIR ;
887
                         SWAP ;
888
                         PAIR ;
889
                         SWAP ;
890
                         PAIR ;
891
                         PAIR ;
892
                         DUP ;
893
                         DUG 8 ;
894
                         DUP 3 ;
895
                         DIG 9 ;
896
                         GET 8 ;
897
                         SUB ;
898
                         ISNAT ;
899
                         IF_NONE { PUSH int 262 ; FAILWITH } {} ;
900
                         UPDATE 8 ;
901
                         DUG 7 ;
902
                         PUSH nat 0 ;
903
                         DUP 3 ;
904
                         DUP 6 ;
905
                         GET 3 ;
906
                         SUB ;
907
                         ISNAT ;
908
                         IF_NONE { PUSH int 265 ; FAILWITH } {} ;
909
                         COMPARE ;
910
                         EQ ;
911
                         IF
912
                           { SWAP ;
913
                             DROP ;
914
                             SWAP ;
915
                             DROP ;
916
                             SWAP ;
917
                             DROP ;
918
                             SWAP ;
919
                             DROP ;
920
                             SWAP ;
921
                             DROP ;
922
                             DIG 3 ;
923
                             DROP ;
924
                             DIG 3 ;
925
                             DROP ;
926
                             DIG 3 ;
927
                             DROP ;
928
                             DIG 3 ;
929
                             DROP ;
930
                             DIG 2 ;
931
                             UNPAIR ;
932
                             SWAP ;
933
                             UNPAIR ;
934
                             UNPAIR ;
935
                             SWAP ;
936
                             UNPAIR ;
937
                             SWAP ;
938
                             NONE (pair nat (pair nat timestamp)) ;
939
                             DUP 8 ;
940
                             GET 4 ;
941
                             UPDATE ;
942
                             SWAP ;
943
                             PAIR ;
944
                             SWAP ;
945
                             PAIR ;
946
                             PAIR ;
947
                             SWAP ;
948
                             PAIR ;
949
                             DUP ;
950
                             DUG 3 ;
951
                             UNPAIR ;
952
                             SWAP ;
953
                             UNPAIR ;
954
                             SWAP ;
955
                             UNPAIR ;
956
                             UNPAIR ;
957
                             DUP ;
958
                             DIG 8 ;
959
                             GET 3 ;
960
                             GET 3 ;
961
                             DUP ;
962
                             DUG 2 ;
963
                             GET ;
964
                             IF_NONE { PUSH int 269 ; FAILWITH } {} ;
965
                             PUSH bool False ;
966
                             DIG 9 ;
967
                             GET 4 ;
968
                             UPDATE ;
969
                             SOME ;
970
                             SWAP ;
971
                             UPDATE ;
972
                             PAIR ;
973
                             PAIR ;
974
                             SWAP ;
975
                             PAIR ;
976
                             SWAP ;
977
                             PAIR ;
978
                             SWAP }
979
                           { DIG 4 ;
980
                             DROP ;
981
                             DIG 4 ;
982
                             DROP ;
983
                             DIG 6 ;
984
                             DROP ;
985
                             DIG 6 ;
986
                             DROP ;
987
                             DIG 6 ;
988
                             DROP ;
989
                             DIG 6 ;
990
                             DROP ;
991
                             DIG 5 ;
992
                             UNPAIR ;
993
                             SWAP ;
994
                             UNPAIR ;
995
                             UNPAIR ;
996
                             SWAP ;
997
                             UNPAIR ;
998
                             SWAP ;
999
                             DUP ;
1000
                             DUP 11 ;
1001
                             GET 4 ;
1002
                             DUP ;
1003
                             DUG 2 ;
1004
                             GET ;
1005
                             IF_NONE { PUSH int 271 ; FAILWITH } {} ;
1006
                             DIG 9 ;
1007
                             DUP 11 ;
1008
                             CAR ;
1009
                             SUB ;
1010
                             ISNAT ;
1011
                             IF_NONE { PUSH int 264 ; FAILWITH } {} ;
1012
                             UPDATE 1 ;
1013
                             SOME ;
1014
                             SWAP ;
1015
                             UPDATE ;
1016
                             DUP ;
1017
                             DIG 9 ;
1018
                             GET 4 ;
1019
                             DUP ;
1020
                             DUG 2 ;
1021
                             GET ;
1022
                             IF_NONE { PUSH int 272 ; FAILWITH } {} ;
1023
                             DIG 8 ;
1024
                             DIG 9 ;
1025
                             GET 3 ;
1026
                             SUB ;
1027
                             ISNAT ;
1028
                             IF_NONE { PUSH int 265 ; FAILWITH } {} ;
1029
                             UPDATE 3 ;
1030
                             SOME ;
1031
                             SWAP ;
1032
                             UPDATE ;
1033
                             SWAP ;
1034
                             PAIR ;
1035
                             SWAP ;
1036
                             PAIR ;
1037
                             PAIR ;
1038
                             SWAP ;
1039
                             PAIR ;
1040
                             SWAP } }
1041
                       { DIG 3 ;
1042
                         DROP ;
1043
                         DIG 3 ;
1044
                         DROP ;
1045
                         DIG 3 ;
1046
                         DROP ;
1047
                         DIG 2 ;
1048
                         UNIT ;
1049
                         SWAP ;
1050
                         DIG 3 ;
1051
                         DIG 2 ;
1052
                         PAIR ;
1053
                         EXEC ;
1054
                         CDR ;
1055
                         UNPAIR ;
1056
                         UNPAIR ;
1057
                         UNPAIR ;
1058
                         PUSH (option int) (Some 0) ;
1059
                         DIG 5 ;
1060
                         UPDATE ;
1061
                         PAIR ;
1062
                         PAIR ;
1063
                         PAIR ;
1064
                         NIL operation } }
1065
                   { IF_LEFT
1066
                       { DIG 3 ;
1067
                         DROP ;
1068
                         DIG 3 ;
1069
                         DROP ;
1070
                         DIG 3 ;
1071
                         DROP ;
1072
                         DIG 2 ;
1073
                         UNIT ;
1074
                         SWAP ;
1075
                         DIG 3 ;
1076
                         DIG 2 ;
1077
                         PAIR ;
1078
                         EXEC ;
1079
                         CDR ;
1080
                         UNPAIR ;
1081
                         UNPAIR ;
1082
                         UNPAIR ;
1083
                         NONE int ;
1084
                         DIG 5 ;
1085
                         UPDATE ;
1086
                         PAIR ;
1087
                         PAIR ;
1088
                         PAIR }
1089
                       { DIG 3 ;
1090
                         DROP ;
1091
                         DIG 3 ;
1092
                         DROP ;
1093
                         DIG 3 ;
1094
                         DROP ;
1095
                         DIG 2 ;
1096
                         UNIT ;
1097
                         SWAP ;
1098
                         DIG 3 ;
1099
                         DIG 2 ;
1100
                         PAIR ;
1101
                         EXEC ;
1102
                         CDR ;
1103
                         UNPAIR ;
1104
                         UNPAIR ;
1105
                         SWAP ;
1106
                         UNPAIR ;
1107
                         UNPAIR ;
1108
                         NONE (pair address (lambda (pair nat nat) (list operation))) ;
1109
                         DIG 6 ;
1110
                         UPDATE ;
1111
                         PAIR ;
1112
                         PAIR ;
1113
                         SWAP ;
1114
                         PAIR ;
1115
                         PAIR } ;
1116
                     NIL operation } } }
1117
           { IF_LEFT
1118
               { IF_LEFT
1119
                   { IF_LEFT
1120
                       { DROP ;
1121
                         SWAP ;
1122
                         DROP ;
1123
                         SWAP ;
1124
                         DROP ;
1125
                         SWAP ;
1126
                         DROP ;
1127
                         SWAP ;
1128
                         DROP ;
1129
                         DUP ;
1130
                         CAR ;
1131
                         CAR ;
1132
                         CAR ;
1133
                         PUSH int 0 ;
1134
                         SWAP ;
1135
                         SENDER ;
1136
                         GET ;
1137
                         IF_NONE { PUSH int 57 ; FAILWITH } {} ;
1138
                         COMPARE ;
1139
                         EQ ;
1140
                         IF {} { PUSH int 405 ; FAILWITH } ;
1141
                         UNPAIR ;
1142
                         UNPAIR ;
1143
                         UNPAIR ;
1144
                         PUSH (option int) (Some 1) ;
1145
                         SENDER ;
1146
                         UPDATE ;
1147
                         PAIR ;
1148
                         PAIR ;
1149
                         PAIR }
1150
                       { SWAP ;
1151
                         DUP ;
1152
                         DUG 2 ;
1153
                         GET 5 ;
1154
                         CDR ;
1155
                         SENDER ;
1156
                         COMPARE ;
1157
                         EQ ;
1158
                         IF {} { PUSH int 504 ; FAILWITH } ;
1159
                         DUP ;
1160
                         IF_CONS
1161
                           { SWAP ;
1162
                             DROP ;
1163
                             SWAP ;
1164
                             DROP ;
1165
                             DIG 2 ;
1166
                             DROP ;
1167
                             DIG 2 ;
1168
                             DROP ;
1169
                             DIG 2 ;
1170
                             DROP ;
1171
                             DIG 2 ;
1172
                             DROP ;
1173
                             DUP ;
1174
                             CAR ;
1175
                             CAR ;
1176
                             SELF_ADDRESS ;
1177
                             COMPARE ;
1178
                             EQ ;
1179
                             IF {} { PUSH int 503 ; FAILWITH } ;
1180
                             SWAP ;
1181
                             UNPAIR ;
1182
                             UNPAIR ;
1183
                             UNPAIR ;
1184
                             SWAP ;
1185
                             CDR ;
1186
                             DIG 4 ;
1187
                             CDR ;
1188
                             PAIR ;
1189
                             SWAP ;
1190
                             PAIR ;
1191
                             PAIR ;
1192
                             PAIR }
1193
                           { DROP ; SWAP ; DROP ; SWAP ; DROP ; SWAP ; DROP ; SWAP ; DROP } } ;
1194
                     NIL operation }
1195
                   { IF_LEFT
1196
                       { DIG 3 ;
1197
                         DROP ;
1198
                         DIG 3 ;
1199
                         DROP ;
1200
                         DIG 3 ;
1201
                         DROP ;
1202
                         DIG 2 ;
1203
                         UNIT ;
1204
                         SWAP ;
1205
                         DIG 3 ;
1206
                         DIG 2 ;
1207
                         PAIR ;
1208
                         EXEC ;
1209
                         CDR ;
1210
                         UNPAIR ;
1211
                         UNPAIR ;
1212
                         SWAP ;
1213
                         UNPAIR ;
1214
                         UNPAIR ;
1215
                         DUP 6 ;
1216
                         CDR ;
1217
                         SOME ;
1218
                         DIG 6 ;
1219
                         CAR ;
1220
                         UPDATE ;
1221
                         PAIR ;
1222
                         PAIR ;
1223
                         SWAP ;
1224
                         PAIR ;
1225
                         PAIR ;
1226
                         NIL operation }
1227
                       { PUSH nat 300 ;
1228
                         PUSH nat 60 ;
1229
                         PUSH nat 86400 ;
1230
                         PUSH timestamp "1970-01-01T00:00:00Z" ;
1231
                         NOW ;
1232
                         SUB ;
1233
                         ISNAT ;
1234
                         IF_NONE { PUSH int 334 ; FAILWITH } {} ;
1235
                         EDIV ;
1236
                         IF_NONE { PUSH int 334 ; FAILWITH } { CDR } ;
1237
                         EDIV ;
1238
                         IF_NONE { PUSH int 335 ; FAILWITH } { CAR } ;
1239
                         COMPARE ;
1240
                         GE ;
1241
                         IF
1242
                           { PUSH nat 305 ;
1243
                             PUSH nat 60 ;
1244
                             PUSH nat 86400 ;
1245
                             PUSH timestamp "1970-01-01T00:00:00Z" ;
1246
                             NOW ;
1247
                             SUB ;
1248
                             ISNAT ;
1249
                             IF_NONE { PUSH int 334 ; FAILWITH } {} ;
1250
                             EDIV ;
1251
                             IF_NONE { PUSH int 334 ; FAILWITH } { CDR } ;
1252
                             EDIV ;
1253
                             IF_NONE { PUSH int 335 ; FAILWITH } { CAR } ;
1254
                             COMPARE ;
1255
                             LE }
1256
                           { PUSH bool False } ;
1257
                         IF
1258
                           { PUSH bool True }
1259
                           { PUSH nat 660 ;
1260
                             PUSH nat 60 ;
1261
                             PUSH nat 86400 ;
1262
                             PUSH timestamp "1970-01-01T00:00:00Z" ;
1263
                             NOW ;
1264
                             SUB ;
1265
                             ISNAT ;
1266
                             IF_NONE { PUSH int 334 ; FAILWITH } {} ;
1267
                             EDIV ;
1268
                             IF_NONE { PUSH int 334 ; FAILWITH } { CDR } ;
1269
                             EDIV ;
1270
                             IF_NONE { PUSH int 335 ; FAILWITH } { CAR } ;
1271
                             COMPARE ;
1272
                             GE ;
1273
                             IF
1274
                               { PUSH nat 665 ;
1275
                                 PUSH nat 60 ;
1276
                                 PUSH nat 86400 ;
1277
                                 PUSH timestamp "1970-01-01T00:00:00Z" ;
1278
                                 NOW ;
1279
                                 SUB ;
1280
                                 ISNAT ;
1281
                                 IF_NONE { PUSH int 334 ; FAILWITH } {} ;
1282
                                 EDIV ;
1283
                                 IF_NONE { PUSH int 334 ; FAILWITH } { CDR } ;
1284
                                 EDIV ;
1285
                                 IF_NONE { PUSH int 335 ; FAILWITH } { CAR } ;
1286
                                 COMPARE ;
1287
                                 LE }
1288
                               { PUSH bool False } } ;
1289
                         IF
1290
                           { PUSH bool True }
1291
                           { PUSH nat 1020 ;
1292
                             PUSH nat 60 ;
1293
                             PUSH nat 86400 ;
1294
                             PUSH timestamp "1970-01-01T00:00:00Z" ;
1295
                             NOW ;
1296
                             SUB ;
1297
                             ISNAT ;
1298
                             IF_NONE { PUSH int 334 ; FAILWITH } {} ;
1299
                             EDIV ;
1300
                             IF_NONE { PUSH int 334 ; FAILWITH } { CDR } ;
1301
                             EDIV ;
1302
                             IF_NONE { PUSH int 335 ; FAILWITH } { CAR } ;
1303
                             COMPARE ;
1304
                             GE ;
1305
                             IF
1306
                               { PUSH nat 1025 ;
1307
                                 PUSH nat 60 ;
1308
                                 PUSH nat 86400 ;
1309
                                 PUSH timestamp "1970-01-01T00:00:00Z" ;
1310
                                 NOW ;
1311
                                 SUB ;
1312
                                 ISNAT ;
1313
                                 IF_NONE { PUSH int 334 ; FAILWITH } {} ;
1314
                                 EDIV ;
1315
                                 IF_NONE { PUSH int 334 ; FAILWITH } { CDR } ;
1316
                                 EDIV ;
1317
                                 IF_NONE { PUSH int 335 ; FAILWITH } { CAR } ;
1318
                                 COMPARE ;
1319
                                 LE }
1320
                               { PUSH bool False } } ;
1321
                         IF
1322
                           { PUSH bool True }
1323
                           { PUSH nat 1380 ;
1324
                             PUSH nat 60 ;
1325
                             PUSH nat 86400 ;
1326
                             PUSH timestamp "1970-01-01T00:00:00Z" ;
1327
                             NOW ;
1328
                             SUB ;
1329
                             ISNAT ;
1330
                             IF_NONE { PUSH int 334 ; FAILWITH } {} ;
1331
                             EDIV ;
1332
                             IF_NONE { PUSH int 334 ; FAILWITH } { CDR } ;
1333
                             EDIV ;
1334
                             IF_NONE { PUSH int 335 ; FAILWITH } { CAR } ;
1335
                             COMPARE ;
1336
                             GE ;
1337
                             IF
1338
                               { PUSH nat 1385 ;
1339
                                 PUSH nat 60 ;
1340
                                 PUSH nat 86400 ;
1341
                                 PUSH timestamp "1970-01-01T00:00:00Z" ;
1342
                                 NOW ;
1343
                                 SUB ;
1344
                                 ISNAT ;
1345
                                 IF_NONE { PUSH int 334 ; FAILWITH } {} ;
1346
                                 EDIV ;
1347
                                 IF_NONE { PUSH int 334 ; FAILWITH } { CDR } ;
1348
                                 EDIV ;
1349
                                 IF_NONE { PUSH int 335 ; FAILWITH } { CAR } ;
1350
                                 COMPARE ;
1351
                                 LE }
1352
                               { PUSH bool False } } ;
1353
                         IF {} { PUSH int 505 ; FAILWITH } ;
1354
                         DUP ;
1355
                         NIL operation ;
1356
                         SWAP ;
1357
                         ITER { DUP 4 ;
1358
                                CAR ;
1359
                                GET 3 ;
1360
                                CAR ;
1361
                                SWAP ;
1362
                                DUP ;
1363
                                DUG 2 ;
1364
                                CAR ;
1365
                                MEM ;
1366
                                IF
1367
                                  {}
1368
                                  { PUSH string "WrongCondition: self.data.exchanges.contains(exchange.exchange_key)" ;
1369
                                    FAILWITH } ;
1370
                                DUP 4 ;
1371
                                CAR ;
1372
                                GET 3 ;
1373
                                CAR ;
1374
                                SWAP ;
1375
                                DUP ;
1376
                                DUG 2 ;
1377
                                CAR ;
1378
                                GET ;
1379
                                IF_NONE { PUSH int 344 ; FAILWITH } {} ;
1380
                                CDR ;
1381
                                DUP 5 ;
1382
                                CAR ;
1383
                                GET 3 ;
1384
                                CAR ;
1385
                                DUP 3 ;
1386
                                CAR ;
1387
                                GET ;
1388
                                IF_NONE { PUSH int 344 ; FAILWITH } {} ;
1389
                                CAR ;
1390
                                DUP 3 ;
1391
                                CDR ;
1392
                                VIEW "get_min_out" nat ;
1393
                                IF_NONE { PUSH int 345 ; FAILWITH } {} ;
1394
                                DUP 3 ;
1395
                                CDR ;
1396
                                PAIR ;
1397
                                EXEC ;
1398
                                NIL operation ;
1399
                                SWAP ;
1400
                                ITER { CONS } ;
1401
                                ITER { DIG 2 ; SWAP ; CONS ; SWAP } ;
1402
                                DROP } ;
1403
                         SWAP ;
1404
                         DROP ;
1405
                         DIG 2 ;
1406
                         DROP ;
1407
                         DIG 2 ;
1408
                         DROP ;
1409
                         DIG 2 ;
1410
                         DROP ;
1411
                         DIG 2 ;
1412
                         DROP } } }
1413
               { IF_LEFT
1414
                   { IF_LEFT
1415
                       { DUP ;
1416
                         ITER { DUP ;
1417
                                CDR ;
1418
                                ITER { DUP 4 ;
1419
                                       GET 3 ;
1420
                                       GET 4 ;
1421
                                       SWAP ;
1422
                                       DUP ;
1423
                                       DUG 2 ;
1424
                                       GET 3 ;
1425
                                       GET ;
1426
                                       IF_NONE { PUSH int 299 ; FAILWITH } { DROP } ;
1427
                                       SWAP ;
1428
                                       DUP ;
1429
                                       DUG 2 ;
1430
                                       CAR ;
1431
                                       SENDER ;
1432
                                       COMPARE ;
1433
                                       EQ ;
1434
                                       IF
1435
                                         { PUSH bool True }
1436
                                         { DUP 4 ;
1437
                                           GET 3 ;
1438
                                           CAR ;
1439
                                           SWAP ;
1440
                                           DUP ;
1441
                                           DUG 2 ;
1442
                                           GET 3 ;
1443
                                           SENDER ;
1444
                                           DUP 5 ;
1445
                                           CAR ;
1446
                                           PAIR 3 ;
1447
                                           MEM } ;
1448
                                       IF
1449
                                         {}
1450
                                         { PUSH string "FA2_NOT_OPERATOR" ; FAILWITH } ;
1451
                                       DUP ;
1452
                                       GET 4 ;
1453
                                       PUSH nat 1 ;
1454
                                       COMPARE ;
1455
                                       EQ ;
1456
                                       IF
1457
                                         { DUP 4 ;
1458
                                           GET 5 ;
1459
                                           CAR ;
1460
                                           DUP 3 ;
1461
                                           CAR ;
1462
                                           GET ;
1463
                                           IF_NONE { PUSH int 302 ; FAILWITH } {} ;
1464
                                           SWAP ;
1465
                                           DUP ;
1466
                                           DUG 2 ;
1467
                                           GET 3 ;
1468
                                           MEM }
1469
                                         { PUSH bool False } ;
1470
                                       IF
1471
                                         {}
1472
                                         { PUSH string "FA2_INSUFFICIENT_BALANCE" ;
1473
                                           FAILWITH } ;
1474
                                       DUP 4 ;
1475
                                       GET 5 ;
1476
                                       CAR ;
1477
                                       SWAP ;
1478
                                       DUP ;
1479
                                       DUG 2 ;
1480
                                       CAR ;
1481
                                       MEM ;
1482
                                       IF
1483
                                         {}
1484
                                         { DIG 3 ;
1485
                                           UNPAIR ;
1486
                                           SWAP ;
1487
                                           UNPAIR ;
1488
                                           SWAP ;
1489
                                           UNPAIR ;
1490
                                           UNPAIR ;
1491
                                           PUSH (option (set nat)) (Some {}) ;
1492
                                           DUP 7 ;
1493
                                           CAR ;
1494
                                           UPDATE ;
1495
                                           PAIR ;
1496
                                           PAIR ;
1497
                                           SWAP ;
1498
                                           PAIR ;
1499
                                           SWAP ;
1500
                                           PAIR ;
1501
                                           DUG 3 } ;
1502
                                       DIG 3 ;
1503
                                       UNPAIR ;
1504
                                       SWAP ;
1505
                                       UNPAIR ;
1506
                                       SWAP ;
1507
                                       UNPAIR ;
1508
                                       UNPAIR ;
1509
                                       DUP ;
1510
                                       DUP 8 ;
1511
                                       CAR ;
1512
                                       DUP ;
1513
                                       DUG 2 ;
1514
                                       GET ;
1515
                                       IF_NONE { PUSH int 306 ; FAILWITH } {} ;
1516
                                       PUSH bool False ;
1517
                                       DUP 9 ;
1518
                                       GET 3 ;
1519
                                       UPDATE ;
1520
                                       SOME ;
1521
                                       SWAP ;
1522
                                       UPDATE ;
1523
                                       DUP ;
1524
                                       DUP 7 ;
1525
                                       CAR ;
1526
                                       DUP ;
1527
                                       DUG 2 ;
1528
                                       GET ;
1529
                                       IF_NONE { PUSH int 307 ; FAILWITH } {} ;
1530
                                       PUSH bool True ;
1531
                                       DIG 8 ;
1532
                                       GET 3 ;
1533
                                       UPDATE ;
1534
                                       SOME ;
1535
                                       SWAP ;
1536
                                       UPDATE ;
1537
                                       PAIR ;
1538
                                       PAIR ;
1539
                                       SWAP ;
1540
                                       PAIR ;
1541
                                       SWAP ;
1542
                                       PAIR ;
1543
                                       DUG 2 } ;
1544
                                DROP } ;
1545
                         DROP ;
1546
                         SWAP ;
1547
                         DROP ;
1548
                         SWAP ;
1549
                         DROP ;
1550
                         SWAP ;
1551
                         DROP ;
1552
                         SWAP ;
1553
                         DROP }
1554
                       { DIG 3 ;
1555
                         DROP ;
1556
                         DIG 3 ;
1557
                         DROP ;
1558
                         DIG 3 ;
1559
                         DROP ;
1560
                         DIG 2 ;
1561
                         UNIT ;
1562
                         SWAP ;
1563
                         DIG 3 ;
1564
                         DIG 2 ;
1565
                         PAIR ;
1566
                         EXEC ;
1567
                         CDR ;
1568
                         UNPAIR ;
1569
                         UNPAIR ;
1570
                         SWAP ;
1571
                         UNPAIR ;
1572
                         SWAP ;
1573
                         CAR ;
1574
                         DIG 4 ;
1575
                         SWAP ;
1576
                         PAIR ;
1577
                         SWAP ;
1578
                         PAIR ;
1579
                         SWAP ;
1580
                         PAIR ;
1581
                         PAIR } ;
1582
                     NIL operation }
1583
                   { IF_LEFT
1584
                       { DUP ;
1585
                         ITER { IF_LEFT
1586
                                  { DUP ;
1587
                                    CAR ;
1588
                                    SENDER ;
1589
                                    COMPARE ;
1590
                                    EQ ;
1591
                                    IF {} { PUSH string "FA2_NOT_OWNER" ; FAILWITH } ;
1592
                                    DIG 2 ;
1593
                                    UNPAIR ;
1594
                                    SWAP ;
1595
                                    UNPAIR ;
1596
                                    UNPAIR ;
1597
                                    PUSH (option unit) (Some Unit) ;
1598
                                    DIG 5 ;
1599
                                    DUP ;
1600
                                    GET 4 ;
1601
                                    SWAP ;
1602
                                    DUP ;
1603
                                    GET 3 ;
1604
                                    SWAP ;
1605
                                    CAR ;
1606
                                    PAIR 3 ;
1607
                                    UPDATE ;
1608
                                    PAIR ;
1609
                                    PAIR ;
1610
                                    SWAP ;
1611
                                    PAIR ;
1612
                                    SWAP }
1613
                                  { DUP ;
1614
                                    CAR ;
1615
                                    SENDER ;
1616
                                    COMPARE ;
1617
                                    EQ ;
1618
                                    IF {} { PUSH string "FA2_NOT_OWNER" ; FAILWITH } ;
1619
                                    DIG 2 ;
1620
                                    UNPAIR ;
1621
                                    SWAP ;
1622
                                    UNPAIR ;
1623
                                    UNPAIR ;
1624
                                    NONE unit ;
1625
                                    DIG 5 ;
1626
                                    DUP ;
1627
                                    GET 4 ;
1628
                                    SWAP ;
1629
                                    DUP ;
1630
                                    GET 3 ;
1631
                                    SWAP ;
1632
                                    CAR ;
1633
                                    PAIR 3 ;
1634
                                    UPDATE ;
1635
                                    PAIR ;
1636
                                    PAIR ;
1637
                                    SWAP ;
1638
                                    PAIR ;
1639
                                    SWAP } } ;
1640
                         DROP ;
1641
                         SWAP ;
1642
                         DROP ;
1643
                         SWAP ;
1644
                         DROP ;
1645
                         SWAP ;
1646
                         DROP ;
1647
                         SWAP ;
1648
                         DROP ;
1649
                         NIL operation }
1650
                       { DIG 2 ;
1651
                         DROP ;
1652
                         DIG 2 ;
1653
                         DROP ;
1654
                         DIG 2 ;
1655
                         DROP ;
1656
                         SWAP ;
1657
                         UNPAIR ;
1658
                         SWAP ;
1659
                         UNPAIR ;
1660
                         UNPAIR ;
1661
                         SWAP ;
1662
                         CDR ;
1663
                         SENDER ;
1664
                         PAIR ;
1665
                         SWAP ;
1666
                         PAIR ;
1667
                         PAIR ;
1668
                         SWAP ;
1669
                         PAIR ;
1670
                         SWAP ;
1671
                         NIL operation ;
1672
                         DIG 3 ;
1673
                         UNIT ;
1674
                         SWAP ;
1675
                         DIG 4 ;
1676
                         DIG 3 ;
1677
                         DIG 3 ;
1678
                         PAIR 3 ;
1679
                         EXEC ;
1680
                         CDR ;
1681
                         UNPAIR ;
1682
                         SWAP ;
1683
                         DUG 2 ;
1684
                         SELF %internal_withdraw ;
1685
                         PUSH mutez 0 ;
1686
                         DIG 3 ;
1687
                         TRANSFER_TOKENS ;
1688
                         CONS } } } } ;
1689
         NIL operation ;
1690
         SWAP ;
1691
         ITER { CONS } ;
1692
         PAIR } ;
1693
  view "view_administrator_state" address int
1694
        { UNPAIR ;
1695
          SWAP ;
1696
          DUP ;
1697
          DUG 2 ;
1698
          CAR ;
1699
          CAR ;
1700
          CAR ;
1701
          SWAP ;
1702
          DUP ;
1703
          DUG 2 ;
1704
          MEM ;
1705
          IF
1706
            { SWAP ; CAR ; CAR ; CAR ; SWAP ; GET ; IF_NONE { PUSH int 402 ; FAILWITH } {} }
1707
            { DROP 2 ; PUSH int -1 } } ;
1708
  view "view_balance" (pair (address %address) (nat %token_id)) int
1709
        { UNPAIR ;
1710
          SWAP ;
1711
          DUP ;
1712
          DUG 2 ;
1713
          GET 3 ;
1714
          GET 4 ;
1715
          SWAP ;
1716
          DUP ;
1717
          DUG 2 ;
1718
          CDR ;
1719
          MEM ;
1720
          IF {} { PUSH string "FA2_TOKEN_UNDEFINED" ; FAILWITH } ;
1721
          SWAP ;
1722
          DUP ;
1723
          DUG 2 ;
1724
          GET 5 ;
1725
          CAR ;
1726
          SWAP ;
1727
          DUP ;
1728
          DUG 2 ;
1729
          CAR ;
1730
          MEM ;
1731
          IF
1732
            { SWAP ;
1733
              GET 5 ;
1734
              CAR ;
1735
              SWAP ;
1736
              DUP ;
1737
              DUG 2 ;
1738
              CAR ;
1739
              GET ;
1740
              IF_NONE { PUSH int 368 ; FAILWITH } {} ;
1741
              SWAP ;
1742
              CDR ;
1743
              MEM }
1744
            { DROP 2 ; PUSH bool False } ;
1745
          IF { PUSH int 1 } { PUSH int 0 } } ;
1746
  view "view_disc_factor" unit nat { CDR ; CAR ; CAR ; GET 4 } ;
1747
  view "view_is_operator"
1748
        (pair (address %owner) (pair (address %operator) (nat %token_id)))
1749
        bool
1750
        { UNPAIR ; SWAP ; GET 3 ; CAR ; SWAP ; DUP ; GET 4 ; SWAP ; DUP ; GET 3 ; SWAP ; CAR ; PAIR 3 ; MEM } ;
1751
  view "view_last_stake_id" unit nat { CDR ; CAR ; GET 3 ; CDR } ;
1752
  view "view_max_release_period" unit nat { CDR ; CAR ; GET 6 } ;
1753
  view "view_owner_stakes" address (set nat)
1754
        { UNPAIR ;
1755
          SWAP ;
1756
          DUP ;
1757
          DUG 2 ;
1758
          GET 5 ;
1759
          CAR ;
1760
          SWAP ;
1761
          DUP ;
1762
          DUG 2 ;
1763
          MEM ;
1764
          IF
1765
            { SWAP ; GET 5 ; CAR ; SWAP ; GET ; IF_NONE { PUSH int 385 ; FAILWITH } {} }
1766
            { DROP 2 ; EMPTY_SET nat } } ;
1767
  view "view_stake" nat
1768
        (pair (nat %token_amount) (pair (nat %stake) (timestamp %age_timestamp)))
1769
        { UNPAIR ;
1770
          SWAP ;
1771
          DUP ;
1772
          DUG 2 ;
1773
          GET 3 ;
1774
          GET 4 ;
1775
          SWAP ;
1776
          DUP ;
1777
          DUG 2 ;
1778
          MEM ;
1779
          IF
1780
            { SWAP ; GET 3 ; GET 4 ; SWAP ; GET ; IF_NONE { PUSH int 393 ; FAILWITH } {} }
1781
            { DROP 2 ; PUSH timestamp "1970-01-01T00:00:00Z" ; PUSH nat 0 ; DUP ; PAIR 3 } } ;
1782
  view "view_total_stake" unit nat { CDR ; GET 8 } }