BCD

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