BCD

Tezos Contract Explorer
Search Networks Deploy
  • Home
  • /
  • Mainnet
  • /
  • Youves v3 Engine Vault (uXAU with USDt)
operations (8.98K)Storage Code Interact Tokens Fork Views Statistics Details
Latest
​x
641
1264
 
1
{ parameter (or
2
              (or
3
                (or (or (nat %burn) (option %create_vault address))
4
                    (or (nat %deposit)
5
                        (or
6
                          (lambda %execute
7
                            (big_map address
8
                                     (pair (nat %balance)
9
                                           (pair (option %introducer address)
10
                                                 (nat %minted))))
11
                            (pair
12
                              (big_map address
13
                                       (pair (nat %balance)
14
                                             (pair (option %introducer address)
15
                                                   (nat %minted))))
16
                              (list operation)))
17
                          (pair %liquidate (address %vault_owner) (nat %token_amount)))))
18
                (or
19
                  (or (nat %mint)
20
                      (pair %remove_administrator (address %administrator_to_remove)
21
                                                  (nat %token_id)))
22
                  (or
23
                    (pair %set_administrator (address %administrator_to_set)
24
                                             (nat %token_id))
25
                    (or (pair %set_collateral_ratio (nat %numerator) (nat %denominator))
26
                        (pair %set_contracts
27
                          (pair (address %governance_token_contract)
28
                                (pair (address %interest_rate_setter_contract)
29
                                      (address %options_contract)))
30
                          (pair (address %reward_pool_contract)
31
                                (pair (address %savings_pool_contract)
32
                                      (address %target_price_oracle))))))))
33
              (or
34
                (or
35
                  (or (pair %set_introducer_ratio (nat %numerator) (nat %denominator))
36
                      (pair %set_liquidation_payout_ratio (nat %numerator)
37
                                                          (nat %denominator)))
38
                  (or (pair %set_minting_fee_ratio (nat %numerator) (nat %denominator))
39
                      (or (nat %set_reference_interest_rate)
40
                          (pair %set_settlement_payout_ratio (nat %numerator)
41
                                                             (nat %denominator)))))
42
                (or
43
                  (or (pair %set_settlement_ratio (nat %numerator) (nat %denominator))
44
                      (or
45
                        (pair %set_settlement_reward_fee_ratio (nat %numerator)
46
                                                               (nat %denominator))
47
                        (pair %settle_with_vault (address %vault_owner)
48
                                                 (pair (nat %token_amount)
49
                                                       (address %recipient)))))
50
                  (or (list %touch address) (or (unit %update) (nat %withdraw)))))) ;
51
  storage (pair (timestamp %accrual_update_timestamp)
52
                (pair
53
                  (big_map %administrators (pair (address %owner) (nat %token_id)) unit)
54
                  (pair (pair %collateral_ratio (nat %numerator) (nat %denominator))
55
                        (pair (address %collateral_token_contract)
56
                              (pair (nat %collateral_token_id)
57
                                    (pair (nat %compound_interest_rate)
58
                                          (pair (address %governance_token_contract)
59
                                                (pair
60
                                                  (address %interest_rate_setter_contract)
61
                                                  (pair
62
                                                    (pair %introducer_ratio
63
                                                      (nat %numerator)
64
                                                      (nat %denominator))
65
                                                    (pair
66
                                                      (pair %liquidation_payout_ratio
67
                                                        (nat %numerator)
68
                                                        (nat %denominator))
69
                                                      (pair
70
                                                        (pair %minting_fee_ratio
71
                                                          (nat %numerator)
72
                                                          (nat %denominator))
73
                                                        (pair
74
                                                          (address %options_contract)
75
                                                          (pair
76
                                                            (nat %reference_interest_rate)
77
                                                            (pair
78
                                                              (address %reward_pool_contract)
79
                                                              (pair
80
                                                                (address %savings_pool_contract)
81
                                                                (pair
82
                                                                  (pair %settlement_payout_ratio
83
                                                                    (nat %numerator)
84
                                                                    (nat %denominator))
85
                                                                  (pair
86
                                                                    (pair %settlement_ratio
87
                                                                      (nat %numerator)
88
                                                                      (nat %denominator))
89
                                                                    (pair
90
                                                                      (pair %settlement_reward_fee_ratio
91
                                                                        (nat %numerator)
92
                                                                        (nat %denominator))
93
                                                                      (pair
94
                                                                        (nat %spread_rate)
95
                                                                        (pair
96
                                                                          (address %target_price_oracle)
97
                                                                          (pair
98
                                                                            (address %token_contract)
99
                                                                            (pair
100
                                                                              (nat %token_id)
101
                                                                              (pair
102
                                                                                (nat %total_supply)
103
                                                                                (big_map %vault_contexts
104
                                                                                  address
105
                                                                                  (pair
106
                                                                                    (nat %balance)
107
                                                                                    (pair
108
                                                                                      (option %introducer address)
109
                                                                                      (nat %minted))))))))))))))))))))))))))) ;
110
  code { LAMBDA
111
           (pair
112
             (pair address
113
                   (pair nat (pair address (pair (pair nat nat) (pair nat nat)))))
114
             (pair (list operation)
115
                   (pair timestamp
116
                         (pair (big_map (pair address nat) unit)
117
                               (pair (pair nat nat)
118
                                     (pair address
119
                                           (pair nat
120
                                                 (pair nat
121
                                                       (pair address
122
                                                             (pair address
123
                                                                   (pair (pair nat nat)
124
                                                                         (pair
125
                                                                           (pair nat nat)
126
                                                                           (pair
127
                                                                             (pair nat
128
                                                                                   nat)
129
                                                                             (pair
130
                                                                               address
131
                                                                               (pair nat
132
                                                                                     (pair
133
                                                                                       address
134
                                                                                       (pair
135
                                                                                         address
136
                                                                                         (pair
137
                                                                                           (pair
138
                                                                                             nat
139
                                                                                             nat)
140
                                                                                           (pair
141
                                                                                             (pair
142
                                                                                               nat
143
                                                                                               nat)
144
                                                                                             (pair
145
                                                                                               (pair
146
                                                                                                 nat
147
                                                                                                 nat)
148
                                                                                               (pair
149
                                                                                                 nat
150
                                                                                                 (pair
151
                                                                                                   address
152
                                                                                                   (pair
153
                                                                                                     address
154
                                                                                                     (pair
155
                                                                                                       nat
156
                                                                                                       (pair
157
                                                                                                         nat
158
                                                                                                         (big_map
159
                                                                                                           address
160
                                                                                                           (pair
161
                                                                                                             nat
162
                                                                                                             (pair
163
                                                                                                               (option address)
164
                                                                                                               nat))))))))))))))))))))))))))))
165
           (pair unit
166
                 (pair (list operation)
167
                       (pair timestamp
168
                             (pair (big_map (pair address nat) unit)
169
                                   (pair (pair nat nat)
170
                                         (pair address
171
                                               (pair nat
172
                                                     (pair nat
173
                                                           (pair address
174
                                                                 (pair address
175
                                                                       (pair
176
                                                                         (pair nat nat)
177
                                                                         (pair
178
                                                                           (pair nat nat)
179
                                                                           (pair
180
                                                                             (pair nat
181
                                                                                   nat)
182
                                                                             (pair
183
                                                                               address
184
                                                                               (pair nat
185
                                                                                     (pair
186
                                                                                       address
187
                                                                                       (pair
188
                                                                                         address
189
                                                                                         (pair
190
                                                                                           (pair
191
                                                                                             nat
192
                                                                                             nat)
193
                                                                                           (pair
194
                                                                                             (pair
195
                                                                                               nat
196
                                                                                               nat)
197
                                                                                             (pair
198
                                                                                               (pair
199
                                                                                                 nat
200
                                                                                                 nat)
201
                                                                                               (pair
202
                                                                                                 nat
203
                                                                                                 (pair
204
                                                                                                   address
205
                                                                                                   (pair
206
                                                                                                     address
207
                                                                                                     (pair
208
                                                                                                       nat
209
                                                                                                       (pair
210
                                                                                                         nat
211
                                                                                                         (big_map
212
                                                                                                           address
213
                                                                                                           (pair
214
                                                                                                             nat
215
                                                                                                             (pair
216
                                                                                                               (option address)
217
                                                                                                               nat))))))))))))))))))))))))))))
218
           { UNPAIR 3 ;
219
             SWAP ;
220
             DUP 3 ;
221
             GET 46 ;
222
             DUP 3 ;
223
             CAR ;
224
             GET ;
225
             IF_NONE { PUSH int 344 ; FAILWITH } {} ;
226
             DUP ;
227
             CAR ;
228
             DUP 5 ;
229
             GET 11 ;
230
             DUP 3 ;
231
             GET 4 ;
232
             MUL ;
233
             LAMBDA
234
               (pair nat nat)
235
               nat
236
               { UNPAIR ;
237
                 PUSH nat 0 ;
238
                 DUP 3 ;
239
                 DUP 3 ;
240
                 EDIV ;
241
                 IF_NONE { PUSH int 129 ; FAILWITH } { CDR } ;
242
                 COMPARE ;
243
                 EQ ;
244
                 IF
245
                   { EDIV ; IF_NONE { PUSH int 131 ; FAILWITH } { CAR } }
246
                   { PUSH nat 1 ;
247
                     DUG 2 ;
248
                     EDIV ;
249
                     IF_NONE { PUSH int 133 ; FAILWITH } { CAR } ;
250
                     ADD } } ;
251
             DUP ;
252
             PUSH nat 1000000000000 ;
253
             DUP 4 ;
254
             PAIR ;
255
             EXEC ;
256
             PUSH nat 1000000 ;
257
             DUP 9 ;
258
             GET 39 ;
259
             UNIT ;
260
             VIEW "get_price" nat ;
261
             IF_NONE { PUSH int 502 ; FAILWITH } {} ;
262
             DUP 3 ;
263
             MUL ;
264
             MUL ;
265
             PUSH nat 1000000000000 ;
266
             PUSH nat 1 ;
267
             PUSH nat 1000000 ;
268
             DUP ;
269
             DUP 9 ;
270
             MUL ;
271
             MUL ;
272
             MUL ;
273
             MUL ;
274
             EDIV ;
275
             IF_NONE { PUSH int 373 ; FAILWITH } { CAR } ;
276
             DIG 7 ;
277
             DUP ;
278
             GET 7 ;
279
             CDR ;
280
             SWAP ;
281
             DUP ;
282
             DUG 9 ;
283
             GET 7 ;
284
             CAR ;
285
             PUSH nat 1000000 ;
286
             MUL ;
287
             EDIV ;
288
             IF_NONE { PUSH int 382 ; FAILWITH } { CAR } ;
289
             SWAP ;
290
             DUP ;
291
             DUG 2 ;
292
             COMPARE ;
293
             LT ;
294
             IF {} { PUSH int 802 ; FAILWITH } ;
295
             PUSH nat 1000000 ;
296
             DIG 8 ;
297
             DUP ;
298
             GET 10 ;
299
             SWAP ;
300
             DUP ;
301
             DUG 10 ;
302
             GET 9 ;
303
             PUSH nat 1000000 ;
304
             MUL ;
305
             EDIV ;
306
             IF_NONE { PUSH int 377 ; FAILWITH } { CAR } ;
307
             DUP 3 ;
308
             DUP ;
309
             DUP 3 ;
310
             COMPARE ;
311
             LE ;
312
             IF { DROP } { SWAP ; DROP } ;
313
             PUSH nat 1000000000000000000 ;
314
             PUSH nat 1000000 ;
315
             DUP 13 ;
316
             GET 39 ;
317
             UNIT ;
318
             VIEW "get_price" nat ;
319
             IF_NONE { PUSH int 502 ; FAILWITH } {} ;
320
             DUP 13 ;
321
             GET 3 ;
322
             MUL ;
323
             MUL ;
324
             EDIV ;
325
             IF_NONE { PUSH int 395 ; FAILWITH } { CAR } ;
326
             MUL ;
327
             EDIV ;
328
             IF_NONE { PUSH int 407 ; FAILWITH } { CAR } ;
329
             DIG 9 ;
330
             DUP ;
331
             GET 35 ;
332
             CDR ;
333
             SWAP ;
334
             DUP ;
335
             DUG 11 ;
336
             GET 35 ;
337
             CAR ;
338
             PUSH nat 1000000000000000000 ;
339
             PUSH nat 1000000 ;
340
             DUP 14 ;
341
             GET 39 ;
342
             UNIT ;
343
             VIEW "get_price" nat ;
344
             IF_NONE { PUSH int 502 ; FAILWITH } {} ;
345
             DUP 14 ;
346
             GET 3 ;
347
             MUL ;
348
             MUL ;
349
             EDIV ;
350
             IF_NONE { PUSH int 395 ; FAILWITH } { CAR } ;
351
             DUP 4 ;
352
             SUB ;
353
             PUSH int 0 ;
354
             DUP ;
355
             DUP 3 ;
356
             COMPARE ;
357
             LE ;
358
             IF { SWAP ; DROP } { DROP } ;
359
             ISNAT ;
360
             IF_NONE { PUSH int 412 ; FAILWITH } {} ;
361
             MUL ;
362
             EDIV ;
363
             IF_NONE { PUSH int 412 ; FAILWITH } { CAR } ;
364
             DUP 10 ;
365
             GET 3 ;
366
             DUP 5 ;
367
             SUB ;
368
             ISNAT ;
369
             IF_NONE { PUSH int 419 ; FAILWITH } {} ;
370
             PUSH nat 1 ;
371
             DUP 13 ;
372
             GET 39 ;
373
             UNIT ;
374
             VIEW "get_price" nat ;
375
             IF_NONE { PUSH int 502 ; FAILWITH } {} ;
376
             DUP 3 ;
377
             MUL ;
378
             EDIV ;
379
             IF_NONE { PUSH int 423 ; FAILWITH } { CAR } ;
380
             DIG 11 ;
381
             DUP ;
382
             GET 7 ;
383
             CDR ;
384
             SWAP ;
385
             DUP ;
386
             DUG 13 ;
387
             GET 7 ;
388
             CAR ;
389
             PUSH nat 1000000 ;
390
             DIG 3 ;
391
             MUL ;
392
             MUL ;
393
             EDIV ;
394
             IF_NONE { PUSH int 431 ; FAILWITH } { CAR } ;
395
             PUSH nat 1000000000000 ;
396
             PUSH nat 1000000 ;
397
             DUP 6 ;
398
             DUP 12 ;
399
             SUB ;
400
             ISNAT ;
401
             IF_NONE { PUSH int 428 ; FAILWITH } {} ;
402
             MUL ;
403
             MUL ;
404
             COMPARE ;
405
             LT ;
406
             IF {} { PUSH int 803 ; FAILWITH } ;
407
             DIG 9 ;
408
             DUP 12 ;
409
             GET 41 ;
410
             CONTRACT %burn (pair (address %owner)
411
                                  (pair (nat %token_id) (nat %token_amount))) ;
412
             IF_NONE { PUSH int 140 ; FAILWITH } {} ;
413
             PUSH mutez 0 ;
414
             DUP 13 ;
415
             GET 3 ;
416
             DUP 15 ;
417
             GET 43 ;
418
             SENDER ;
419
             PAIR 3 ;
420
             TRANSFER_TOKENS ;
421
             CONS ;
422
             DUG 9 ;
423
             DUP 12 ;
424
             DUP 12 ;
425
             GET 3 ;
426
             DIG 13 ;
427
             GET 45 ;
428
             SUB ;
429
             ISNAT ;
430
             IF_NONE { PUSH int 445 ; FAILWITH } {} ;
431
             UPDATE 45 ;
432
             DUG 11 ;
433
             DIG 8 ;
434
             DUP 12 ;
435
             GET 11 ;
436
             PUSH nat 1000000000000 ;
437
             DIG 3 ;
438
             MUL ;
439
             EDIV ;
440
             IF_NONE { PUSH int 450 ; FAILWITH } { CAR } ;
441
             UPDATE 4 ;
442
             DUP 3 ;
443
             DUP 9 ;
444
             SUB ;
445
             ISNAT ;
446
             IF_NONE { PUSH int 454 ; FAILWITH } {} ;
447
             UPDATE 1 ;
448
             DUG 7 ;
449
             DIG 10 ;
450
             DUP ;
451
             GET 46 ;
452
             DUP 10 ;
453
             SOME ;
454
             DUP 13 ;
455
             CAR ;
456
             UPDATE ;
457
             UPDATE 46 ;
458
             DUG 10 ;
459
             DUP ;
460
             PUSH nat 0 ;
461
             SWAP ;
462
             DUP 4 ;
463
             SUB ;
464
             ISNAT ;
465
             IF_NONE { PUSH int 490 ; FAILWITH } {} ;
466
             COMPARE ;
467
             GT ;
468
             IF
469
               { DIG 8 ;
470
                 DUP 11 ;
471
                 GET 7 ;
472
                 CONTRACT %transfer (list (pair (address %from_)
473
                                               (list %txs (pair (address %to_)
474
                                                               (pair (nat %token_id)
475
                                                                     (nat %amount)))))) ;
476
                 IF_NONE { PUSH int 36 ; FAILWITH } {} ;
477
                 PUSH mutez 0 ;
478
                 NIL (pair address (list (pair address (pair nat nat)))) ;
479
                 NIL (pair address (pair nat nat)) ;
480
                 DUP 6 ;
481
                 DUP 8 ;
482
                 SUB ;
483
                 ISNAT ;
484
                 IF_NONE { PUSH int 490 ; FAILWITH } {} ;
485
                 DUP 16 ;
486
                 GET 9 ;
487
                 DUP 16 ;
488
                 GET 5 ;
489
                 PAIR 3 ;
490
                 CONS ;
491
                 SELF_ADDRESS ;
492
                 PAIR ;
493
                 CONS ;
494
                 TRANSFER_TOKENS ;
495
                 CONS ;
496
                 DUG 8 }
497
               {} ;
498
             DUP ;
499
             PUSH nat 0 ;
500
             COMPARE ;
501
             LT ;
502
             IF
503
               { SWAP ;
504
                 DROP ;
505
                 SWAP ;
506
                 DROP ;
507
                 SWAP ;
508
                 DROP ;
509
                 SWAP ;
510
                 DROP ;
511
                 SWAP ;
512
                 DROP ;
513
                 SWAP ;
514
                 DROP ;
515
                 SWAP ;
516
                 DROP ;
517
                 DIG 2 ;
518
                 DROP ;
519
                 SWAP ;
520
                 DUP 3 ;
521
                 GET 7 ;
522
                 CONTRACT %transfer (list (pair (address %from_)
523
                                               (list %txs (pair (address %to_)
524
                                                               (pair (nat %token_id)
525
                                                                     (nat %amount)))))) ;
526
                 IF_NONE { PUSH int 36 ; FAILWITH } {} ;
527
                 PUSH mutez 0 ;
528
                 NIL (pair address (list (pair address (pair nat nat)))) ;
529
                 NIL (pair address (pair nat nat)) ;
530
                 DIG 5 ;
531
                 DIG 6 ;
532
                 DUP ;
533
                 GET 9 ;
534
                 SWAP ;
535
                 DUP ;
536
                 DUG 8 ;
537
                 GET 27 ;
538
                 PAIR 3 ;
539
                 CONS ;
540
                 SELF_ADDRESS ;
541
                 PAIR ;
542
                 CONS ;
543
                 TRANSFER_TOKENS ;
544
                 CONS }
545
               { DROP 8 ; SWAP ; DROP } ;
546
             UNIT ;
547
             PAIR 3 } ;
548
         SWAP ;
549
         LAMBDA
550
           (pair unit
551
                 (pair (list operation)
552
                       (pair timestamp
553
                             (pair (big_map (pair address nat) unit)
554
                                   (pair (pair nat nat)
555
                                         (pair address
556
                                               (pair nat
557
                                                     (pair nat
558
                                                           (pair address
559
                                                                 (pair address
560
                                                                       (pair
561
                                                                         (pair nat nat)
562
                                                                         (pair
563
                                                                           (pair nat nat)
564
                                                                           (pair
565
                                                                             (pair nat
566
                                                                                   nat)
567
                                                                             (pair
568
                                                                               address
569
                                                                               (pair nat
570
                                                                                     (pair
571
                                                                                       address
572
                                                                                       (pair
573
                                                                                         address
574
                                                                                         (pair
575
                                                                                           (pair
576
                                                                                             nat
577
                                                                                             nat)
578
                                                                                           (pair
579
                                                                                             (pair
580
                                                                                               nat
581
                                                                                               nat)
582
                                                                                             (pair
583
                                                                                               (pair
584
                                                                                                 nat
585
                                                                                                 nat)
586
                                                                                               (pair
587
                                                                                                 nat
588
                                                                                                 (pair
589
                                                                                                   address
590
                                                                                                   (pair
591
                                                                                                     address
592
                                                                                                     (pair
593
                                                                                                       nat
594
                                                                                                       (pair
595
                                                                                                         nat
596
                                                                                                         (big_map
597
                                                                                                           address
598
                                                                                                           (pair
599
                                                                                                             nat
600
                                                                                                             (pair
601
                                                                                                               (option address)
602
                                                                                                               nat))))))))))))))))))))))))))))
603
           (pair unit
604
                 (pair (list operation)
605
                       (pair timestamp
606
                             (pair (big_map (pair address nat) unit)
607
                                   (pair (pair nat nat)
608
                                         (pair address
609
                                               (pair nat
610
                                                     (pair nat
611
                                                           (pair address
612
                                                                 (pair address
613
                                                                       (pair
614
                                                                         (pair nat nat)
615
                                                                         (pair
616
                                                                           (pair nat nat)
617
                                                                           (pair
618
                                                                             (pair nat
619
                                                                                   nat)
620
                                                                             (pair
621
                                                                               address
622
                                                                               (pair nat
623
                                                                                     (pair
624
                                                                                       address
625
                                                                                       (pair
626
                                                                                         address
627
                                                                                         (pair
628
                                                                                           (pair
629
                                                                                             nat
630
                                                                                             nat)
631
                                                                                           (pair
632
                                                                                             (pair
633
                                                                                               nat
634
                                                                                               nat)
635
                                                                                             (pair
636
                                                                                               (pair
637
                                                                                                 nat
638
                                                                                                 nat)
639
                                                                                               (pair
640
                                                                                                 nat
641
                                                                                                 (pair
642
                                                                                                   address
643
                                                                                                   (pair
644
                                                                                                     address
645
                                                                                                     (pair
646
                                                                                                       nat
647
                                                                                                       (pair
648
                                                                                                         nat
649
                                                                                                         (big_map
650
                                                                                                           address
651
                                                                                                           (pair
652
                                                                                                             nat
653
                                                                                                             (pair
654
                                                                                                               (option address)
655
                                                                                                               nat))))))))))))))))))))))))))))
656
           { UNPAIR 3 ;
657
             SWAP ;
658
             DUP 3 ;
659
             CAR ;
660
             NOW ;
661
             SUB ;
662
             ISNAT ;
663
             IF_NONE { PUSH int 235 ; FAILWITH } {} ;
664
             DUP ;
665
             PUSH nat 0 ;
666
             COMPARE ;
667
             LT ;
668
             IF
669
               { DIG 2 ;
670
                 DROP ;
671
                 PUSH nat 1000000000000 ;
672
                 DUP 4 ;
673
                 GET 45 ;
674
                 DUP 3 ;
675
                 DUP 6 ;
676
                 GET 25 ;
677
                 MUL ;
678
                 MUL ;
679
                 EDIV ;
680
                 IF_NONE { PUSH int 240 ; FAILWITH } { CAR } ;
681
                 PUSH nat 1000000000000 ;
682
                 DUP 5 ;
683
                 GET 45 ;
684
                 DUP 4 ;
685
                 DUP 7 ;
686
                 GET 37 ;
687
                 MUL ;
688
                 MUL ;
689
                 EDIV ;
690
                 IF_NONE { PUSH int 249 ; FAILWITH } { CAR } ;
691
                 DUP 5 ;
692
                 PUSH nat 1000000000000 ;
693
                 DIG 4 ;
694
                 DIG 6 ;
695
                 DUP ;
696
                 GET 37 ;
697
                 SWAP ;
698
                 DUP ;
699
                 DUG 8 ;
700
                 GET 25 ;
701
                 ADD ;
702
                 MUL ;
703
                 PUSH nat 1000000000000 ;
704
                 ADD ;
705
                 DIG 6 ;
706
                 GET 11 ;
707
                 MUL ;
708
                 EDIV ;
709
                 IF_NONE { PUSH int 264 ; FAILWITH } { CAR } ;
710
                 UPDATE 11 ;
711
                 DUG 3 ;
712
                 DIG 2 ;
713
                 DUP 4 ;
714
                 GET 41 ;
715
                 CONTRACT %mint (pair (address %owner)
716
                                      (pair (nat %token_id) (nat %token_amount))) ;
717
                 IF_NONE { PUSH int 140 ; FAILWITH } {} ;
718
                 PUSH mutez 0 ;
719
                 DUP 5 ;
720
                 DIG 6 ;
721
                 DUP ;
722
                 GET 43 ;
723
                 SWAP ;
724
                 DUP ;
725
                 DUG 8 ;
726
                 GET 29 ;
727
                 PAIR 3 ;
728
                 TRANSFER_TOKENS ;
729
                 CONS ;
730
                 DUP 4 ;
731
                 GET 41 ;
732
                 CONTRACT %mint (pair (address %owner)
733
                                      (pair (nat %token_id) (nat %token_amount))) ;
734
                 IF_NONE { PUSH int 140 ; FAILWITH } {} ;
735
                 PUSH mutez 0 ;
736
                 DUP 4 ;
737
                 DIG 6 ;
738
                 DUP ;
739
                 GET 43 ;
740
                 SWAP ;
741
                 DUP ;
742
                 DUG 8 ;
743
                 GET 27 ;
744
                 PAIR 3 ;
745
                 TRANSFER_TOKENS ;
746
                 CONS ;
747
                 DUG 2 ;
748
                 DIG 3 ;
749
                 DUP ;
750
                 GET 45 ;
751
                 DIG 2 ;
752
                 DIG 3 ;
753
                 ADD ;
754
                 ADD ;
755
                 UPDATE 45 ;
756
                 NOW ;
757
                 UPDATE 1 ;
758
                 SWAP }
759
               { DROP ; SWAP ; DROP } ;
760
             UNIT ;
761
             PAIR 3 } ;
762
         SWAP ;
763
         LAMBDA
764
           (pair (pair address nat)
765
                 (pair (list operation)
766
                       (pair timestamp
767
                             (pair (big_map (pair address nat) unit)
768
                                   (pair (pair nat nat)
769
                                         (pair address
770
                                               (pair nat
771
                                                     (pair nat
772
                                                           (pair address
773
                                                                 (pair address
774
                                                                       (pair
775
                                                                         (pair nat nat)
776
                                                                         (pair
777
                                                                           (pair nat nat)
778
                                                                           (pair
779
                                                                             (pair nat
780
                                                                                   nat)
781
                                                                             (pair
782
                                                                               address
783
                                                                               (pair nat
784
                                                                                     (pair
785
                                                                                       address
786
                                                                                       (pair
787
                                                                                         address
788
                                                                                         (pair
789
                                                                                           (pair
790
                                                                                             nat
791
                                                                                             nat)
792
                                                                                           (pair
793
                                                                                             (pair
794
                                                                                               nat
795
                                                                                               nat)
796
                                                                                             (pair
797
                                                                                               (pair
798
                                                                                                 nat
799
                                                                                                 nat)
800
                                                                                               (pair
801
                                                                                                 nat
802
                                                                                                 (pair
803
                                                                                                   address
804
                                                                                                   (pair
805
                                                                                                     address
806
                                                                                                     (pair
807
                                                                                                       nat
808
                                                                                                       (pair
809
                                                                                                         nat
810
                                                                                                         (big_map
811
                                                                                                           address
812
                                                                                                           (pair
813
                                                                                                             nat
814
                                                                                                             (pair
815
                                                                                                               (option address)
816
                                                                                                               nat))))))))))))))))))))))))))))
817
           (pair unit
818
                 (pair (list operation)
819
                       (pair timestamp
820
                             (pair (big_map (pair address nat) unit)
821
                                   (pair (pair nat nat)
822
                                         (pair address
823
                                               (pair nat
824
                                                     (pair nat
825
                                                           (pair address
826
                                                                 (pair address
827
                                                                       (pair
828
                                                                         (pair nat nat)
829
                                                                         (pair
830
                                                                           (pair nat nat)
831
                                                                           (pair
832
                                                                             (pair nat
833
                                                                                   nat)
834
                                                                             (pair
835
                                                                               address
836
                                                                               (pair nat
837
                                                                                     (pair
838
                                                                                       address
839
                                                                                       (pair
840
                                                                                         address
841
                                                                                         (pair
842
                                                                                           (pair
843
                                                                                             nat
844
                                                                                             nat)
845
                                                                                           (pair
846
                                                                                             (pair
847
                                                                                               nat
848
                                                                                               nat)
849
                                                                                             (pair
850
                                                                                               (pair
851
                                                                                                 nat
852
                                                                                                 nat)
853
                                                                                               (pair
854
                                                                                                 nat
855
                                                                                                 (pair
856
                                                                                                   address
857
                                                                                                   (pair
858
                                                                                                     address
859
                                                                                                     (pair
860
                                                                                                       nat
861
                                                                                                       (pair
862
                                                                                                         nat
863
                                                                                                         (big_map
864
                                                                                                           address
865
                                                                                                           (pair
866
                                                                                                             nat
867
                                                                                                             (pair
868
                                                                                                               (option address)
869
                                                                                                               nat))))))))))))))))))))))))))))
870
           { UNPAIR 3 ;
871
             SWAP ;
872
             DUP 3 ;
873
             GET 13 ;
874
             CONTRACT %update_stake (pair (address %address) (nat %amount)) ;
875
             IF_NONE { PUSH int 296 ; FAILWITH } {} ;
876
             PUSH mutez 0 ;
877
             DIG 3 ;
878
             TRANSFER_TOKENS ;
879
             CONS ;
880
             UNIT ;
881
             PAIR 3 } ;
882
         SWAP ;
883
         LAMBDA
884
           (pair nat
885
                 (pair (list operation)
886
                       (pair timestamp
887
                             (pair (big_map (pair address nat) unit)
888
                                   (pair (pair nat nat)
889
                                         (pair address
890
                                               (pair nat
891
                                                     (pair nat
892
                                                           (pair address
893
                                                                 (pair address
894
                                                                       (pair
895
                                                                         (pair nat nat)
896
                                                                         (pair
897
                                                                           (pair nat nat)
898
                                                                           (pair
899
                                                                             (pair nat
900
                                                                                   nat)
901
                                                                             (pair
902
                                                                               address
903
                                                                               (pair nat
904
                                                                                     (pair
905
                                                                                       address
906
                                                                                       (pair
907
                                                                                         address
908
                                                                                         (pair
909
                                                                                           (pair
910
                                                                                             nat
911
                                                                                             nat)
912
                                                                                           (pair
913
                                                                                             (pair
914
                                                                                               nat
915
                                                                                               nat)
916
                                                                                             (pair
917
                                                                                               (pair
918
                                                                                                 nat
919
                                                                                                 nat)
920
                                                                                               (pair
921
                                                                                                 nat
922
                                                                                                 (pair
923
                                                                                                   address
924
                                                                                                   (pair
925
                                                                                                     address
926
                                                                                                     (pair
927
                                                                                                       nat
928
                                                                                                       (pair
929
                                                                                                         nat
930
                                                                                                         (big_map
931
                                                                                                           address
932
                                                                                                           (pair
933
                                                                                                             nat
934
                                                                                                             (pair
935
                                                                                                               (option address)
936
                                                                                                               nat))))))))))))))))))))))))))))
937
           (pair unit
938
                 (pair (list operation)
939
                       (pair timestamp
940
                             (pair (big_map (pair address nat) unit)
941
                                   (pair (pair nat nat)
942
                                         (pair address
943
                                               (pair nat
944
                                                     (pair nat
945
                                                           (pair address
946
                                                                 (pair address
947
                                                                       (pair
948
                                                                         (pair nat nat)
949
                                                                         (pair
950
                                                                           (pair nat nat)
951
                                                                           (pair
952
                                                                             (pair nat
953
                                                                                   nat)
954
                                                                             (pair
955
                                                                               address
956
                                                                               (pair nat
957
                                                                                     (pair
958
                                                                                       address
959
                                                                                       (pair
960
                                                                                         address
961
                                                                                         (pair
962
                                                                                           (pair
963
                                                                                             nat
964
                                                                                             nat)
965
                                                                                           (pair
966
                                                                                             (pair
967
                                                                                               nat
968
                                                                                               nat)
969
                                                                                             (pair
970
                                                                                               (pair
971
                                                                                                 nat
972
                                                                                                 nat)
973
                                                                                               (pair
974
                                                                                                 nat
975
                                                                                                 (pair
976
                                                                                                   address
977
                                                                                                   (pair
978
                                                                                                     address
979
                                                                                                     (pair
980
                                                                                                       nat
981
                                                                                                       (pair
982
                                                                                                         nat
983
                                                                                                         (big_map
984
                                                                                                           address
985
                                                                                                           (pair
986
                                                                                                             nat
987
                                                                                                             (pair
988
                                                                                                               (option address)
989
                                                                                                               nat))))))))))))))))))))))))))))
990
           { UNPAIR 3 ;
991
             SWAP ;
992
             DUP 3 ;
993
             GET 3 ;
994
             DIG 2 ;
995
             SENDER ;
996
             PAIR ;
997
             MEM ;
998
             IF {} { PUSH int 401 ; FAILWITH } ;
999
             UNIT ;
1000
             PAIR 3 } ;
1001
         SWAP ;
1002
         UNPAIR ;
1003
         IF_LEFT
1004
           { IF_LEFT
1005
               { IF_LEFT
1006
                   { IF_LEFT
1007
                       { AMOUNT ;
1008
                         PUSH mutez 0 ;
1009
                         COMPARE ;
1010
                         EQ ;
1011
                         IF {} { AMOUNT ; FAILWITH } ;
1012
                         NIL operation ;
1013
                         DUP 6 ;
1014
                         UNIT ;
1015
                         SWAP ;
1016
                         DIG 4 ;
1017
                         DIG 3 ;
1018
                         DIG 3 ;
1019
                         PAIR 3 ;
1020
                         EXEC ;
1021
                         UNPAIR 3 ;
1022
                         DIG 7 ;
1023
                         DIG 7 ;
1024
                         DIG 7 ;
1025
                         DIG 7 ;
1026
                         DIG 6 ;
1027
                         DIG 7 ;
1028
                         DIG 7 ;
1029
                         DIG 7 ;
1030
                         PUSH nat 1000001 ;
1031
                         DUP 4 ;
1032
                         COMPARE ;
1033
                         GE ;
1034
                         IF {} { PUSH int 602 ; FAILWITH } ;
1035
                         DUP 4 ;
1036
                         GET 46 ;
1037
                         SENDER ;
1038
                         GET ;
1039
                         IF_NONE { PUSH int 652 ; FAILWITH } {} ;
1040
                         DUP 5 ;
1041
                         GET 11 ;
1042
                         SWAP ;
1043
                         DUP ;
1044
                         DUG 2 ;
1045
                         GET 4 ;
1046
                         MUL ;
1047
                         LAMBDA
1048
                           (pair nat nat)
1049
                           nat
1050
                           { UNPAIR ;
1051
                             PUSH nat 0 ;
1052
                             DUP 3 ;
1053
                             DUP 3 ;
1054
                             EDIV ;
1055
                             IF_NONE { PUSH int 129 ; FAILWITH } { CDR } ;
1056
                             COMPARE ;
1057
                             EQ ;
1058
                             IF
1059
                               { EDIV ; IF_NONE { PUSH int 131 ; FAILWITH } { CAR } }
1060
                               { PUSH nat 1 ;
1061
                                 DUG 2 ;
1062
                                 EDIV ;
1063
                                 IF_NONE { PUSH int 133 ; FAILWITH } { CAR } ;
1064
                                 ADD } } ;
1065
                         DUP ;
1066
                         PUSH nat 1000000000000 ;
1067
                         DIG 3 ;
1068
                         PAIR ;
1069
                         EXEC ;
1070
                         PUSH nat 1000000000000 ;
1071
                         DUP 7 ;
1072
                         DIG 2 ;
1073
                         SUB ;
1074
                         ISNAT ;
1075
                         IF_NONE { PUSH int 668 ; FAILWITH } {} ;
1076
                         MUL ;
1077
                         DUG 2 ;
1078
                         DUP 7 ;
1079
                         GET 11 ;
1080
                         DIG 3 ;
1081
                         PAIR ;
1082
                         EXEC ;
1083
                         UPDATE 4 ;
1084
                         DIG 4 ;
1085
                         DUP ;
1086
                         GET 46 ;
1087
                         DUP 3 ;
1088
                         SOME ;
1089
                         SENDER ;
1090
                         UPDATE ;
1091
                         UPDATE 46 ;
1092
                         DUG 4 ;
1093
                         DIG 2 ;
1094
                         DUP 5 ;
1095
                         GET 41 ;
1096
                         CONTRACT %burn (pair (address %owner)
1097
                                              (pair (nat %token_id) (nat %token_amount))) ;
1098
                         IF_NONE { PUSH int 140 ; FAILWITH } {} ;
1099
                         PUSH mutez 0 ;
1100
                         DUP 6 ;
1101
                         DUP 8 ;
1102
                         GET 43 ;
1103
                         SENDER ;
1104
                         PAIR 3 ;
1105
                         TRANSFER_TOKENS ;
1106
                         CONS ;
1107
                         DUG 2 ;
1108
                         DUP 5 ;
1109
                         DUP 5 ;
1110
                         DIG 6 ;
1111
                         GET 45 ;
1112
                         SUB ;
1113
                         ISNAT ;
1114
                         IF_NONE { PUSH int 683 ; FAILWITH } {} ;
1115
                         UPDATE 45 ;
1116
                         DUG 4 ;
1117
                         DUP 7 ;
1118
                         SWAP ;
1119
                         DUP ;
1120
                         DUG 2 ;
1121
                         GET 4 ;
1122
                         SENDER ;
1123
                         PAIR ;
1124
                         SWAP ;
1125
                         DIG 6 ;
1126
                         DIG 5 ;
1127
                         DIG 3 ;
1128
                         PAIR 3 ;
1129
                         EXEC ;
1130
                         CDR ;
1131
                         UNPAIR ;
1132
                         DIG 8 ;
1133
                         DIG 8 ;
1134
                         DIG 8 ;
1135
                         DIG 8 ;
1136
                         DIG 5 ;
1137
                         DIG 8 ;
1138
                         DIG 6 ;
1139
                         DIG 8 ;
1140
                         DIG 8 ;
1141
                         DUP ;
1142
                         GET 3 ;
1143
                         IF_NONE
1144
                           { DROP 2 ; SWAP ; DROP ; DIG 2 ; DROP ; DIG 2 ; DROP ; DIG 2 ; DROP ; DIG 2 ; DROP }
1145
                           { DROP ;
1146
                             SWAP ;
1147
                             DROP ;
1148
                             DIG 2 ;
1149
                             DROP ;
1150
                             DIG 3 ;
1151
                             DROP ;
1152
                             DIG 4 ;
1153
                             DROP ;
1154
                             DIG 4 ;
1155
                             DROP ;
1156
                             DIG 3 ;
1157
                             DIG 3 ;
1158
                             DUP ;
1159
                             GET 17 ;
1160
                             CDR ;
1161
                             SWAP ;
1162
                             DUP ;
1163
                             DUG 5 ;
1164
                             GET 17 ;
1165
                             CAR ;
1166
                             DUP 4 ;
1167
                             GET 4 ;
1168
                             MUL ;
1169
                             EDIV ;
1170
                             IF_NONE { PUSH int 692 ; FAILWITH } { CAR } ;
1171
                             DIG 2 ;
1172
                             GET 3 ;
1173
                             IF_NONE { PUSH int 604 ; FAILWITH } {} ;
1174
                             PAIR ;
1175
                             SWAP ;
1176
                             DUG 3 ;
1177
                             PAIR 3 ;
1178
                             EXEC ;
1179
                             CDR ;
1180
                             UNPAIR } }
1181
                       { DIG 2 ;
1182
                         DROP ;
1183
                         DIG 2 ;
1184
                         DROP ;
1185
                         DIG 2 ;
1186
                         DROP ;
1187
                         DIG 2 ;
1188
                         DROP ;
1189
                         AMOUNT ;
1190
                         PUSH mutez 0 ;
1191
                         COMPARE ;
1192
                         EQ ;
1193
                         IF {} { AMOUNT ; FAILWITH } ;
1194
                         SWAP ;
1195
                         DUP ;
1196
                         DUG 2 ;
1197
                         GET 46 ;
1198
                         SENDER ;
1199
                         MEM ;
1200
                         IF
1201
                           { DROP }
1202
                           { SWAP ;
1203
                             DUP ;
1204
                             GET 46 ;
1205
                             PUSH nat 0 ;
1206
                             DIG 3 ;
1207
                             PUSH nat 0 ;
1208
                             PAIR 3 ;
1209
                             SOME ;
1210
                             SENDER ;
1211
                             UPDATE ;
1212
                             UPDATE 46 } ;
1213
                         NIL operation } }
1214
                   { IF_LEFT
1215
                       { DIG 2 ;
1216
                         DROP ;
1217
                         DIG 2 ;
1218
                         DROP ;
1219
                         DIG 2 ;
1220
                         DROP ;
1221
                         DIG 2 ;
1222
                         DROP ;
1223
                         AMOUNT ;
1224
                         PUSH mutez 0 ;
1225
                         COMPARE ;
1226
                         EQ ;
1227
                         IF {} { AMOUNT ; FAILWITH } ;
1228
                         DUP ;
1229
                         PUSH nat 0 ;
1230
                         COMPARE ;
1231
                         LT ;
1232
                         IF
1233
                           { NIL operation ;
1234
                             DUP 3 ;
1235
                             GET 7 ;
1236
                             CONTRACT %transfer (list (pair (address %from_)
1237
                                                           (list %txs (pair
1238
                                                                       (address %to_)
1239
                                                                       (pair
1240
                                                                         (nat %token_id)
1241
                                                                         (nat %amount)))))) ;
1242
                             IF_NONE { PUSH int 36 ; FAILWITH } {} ;
1243
                             PUSH mutez 0 ;
1244
                             NIL (pair address (list (pair address (pair nat nat)))) ;
1245
                             NIL (pair address (pair nat nat)) ;
1246
                             DUP 6 ;
1247
                             DUP 8 ;
1248
                             GET 9 ;
1249
                             SELF_ADDRESS ;
1250
                             PAIR 3 ;
1251
                             CONS ;
1252
                             SENDER ;
1253
                             PAIR ;
1254
                             CONS ;
1255
                             TRANSFER_TOKENS ;
1256
                             CONS }
1257
                           { NIL operation } ;
1258
                         DIG 2 ;
1259
                         DUP ;
1260
                         GET 46 ;
1261
                         DUP ;
1262
                         SENDER ;
1263
                         DUP ;
1264
                         DUG 2 ;
1265
                         GET ;
1266
                         IF_NONE { PUSH int 149 ; FAILWITH } {} ;
1267
                         DUP ;
1268
                         CAR ;
1269
                         DIG 6 ;
1270
                         ADD ;
1271
                         UPDATE 1 ;
1272
                         SOME ;
1273
                         SWAP ;
1274
                         UPDATE ;
1275
                         UPDATE 46 ;
1276
                         SWAP }
1277
                       { IF_LEFT
1278
                           { AMOUNT ;
1279
                             PUSH mutez 0 ;
1280
                             COMPARE ;
1281
                             EQ ;
1282
                             IF {} { AMOUNT ; FAILWITH } ;
1283
                             NIL operation ;
1284
                             DUP 4 ;
1285
                             PUSH nat 0 ;
1286
                             SWAP ;
1287
                             DIG 4 ;
1288
                             DIG 3 ;
1289
                             DIG 3 ;
1290
                             PAIR 3 ;
1291
                             EXEC ;
1292
                             UNPAIR 3 ;
1293
                             DIG 7 ;
1294
                             DIG 7 ;
1295
                             DIG 7 ;
1296
                             DIG 7 ;
1297
                             DIG 6 ;
1298
                             DIG 7 ;
1299
                             DIG 7 ;
1300
                             DIG 7 ;
1301
                             DUP 3 ;
1302
                             DUP 5 ;
1303
                             GET 46 ;
1304
                             EXEC ;
1305
                             DIG 4 ;
1306
                             SWAP ;
1307
                             DUP ;
1308
                             DUG 2 ;
1309
                             CAR ;
1310
                             UPDATE 46 ;
1311
                             DUG 4 ;
1312
                             DUP ;
1313
                             CDR ;
1314
                             NIL operation ;
1315
                             SWAP ;
1316
                             ITER { CONS } ;
1317
                             ITER { DIG 3 ; SWAP ; CONS ; DUG 2 } ;
1318
                             DROP 2 ;
1319
                             SWAP ;
1320
                             DROP ;
1321
                             DIG 2 ;
1322
                             DROP ;
1323
                             DIG 2 ;
1324
                             DROP ;
1325
                             DIG 2 ;
1326
                             DROP ;
1327
                             DIG 2 ;
1328
                             DROP }
1329
                           { AMOUNT ;
1330
                             PUSH mutez 0 ;
1331
                             COMPARE ;
1332
                             EQ ;
1333
                             IF {} { AMOUNT ; FAILWITH } ;
1334
                             NIL operation ;
1335
                             DUP 6 ;
1336
                             UNIT ;
1337
                             SWAP ;
1338
                             DIG 4 ;
1339
                             DIG 3 ;
1340
                             DIG 3 ;
1341
                             PAIR 3 ;
1342
                             EXEC ;
1343
                             UNPAIR 3 ;
1344
                             DIG 7 ;
1345
                             DIG 7 ;
1346
                             DIG 7 ;
1347
                             DIG 7 ;
1348
                             DIG 6 ;
1349
                             DIG 7 ;
1350
                             DIG 7 ;
1351
                             DIG 7 ;
1352
                             DUP 8 ;
1353
                             DIG 4 ;
1354
                             DUP ;
1355
                             GET 19 ;
1356
                             SWAP ;
1357
                             DUP ;
1358
                             DUG 6 ;
1359
                             GET 5 ;
1360
                             SENDER ;
1361
                             DIG 6 ;
1362
                             DUP ;
1363
                             CDR ;
1364
                             SWAP ;
1365
                             DUP ;
1366
                             DUG 8 ;
1367
                             CAR ;
1368
                             PAIR 5 ;
1369
                             SWAP ;
1370
                             DIG 5 ;
1371
                             DIG 4 ;
1372
                             DIG 3 ;
1373
                             PAIR 3 ;
1374
                             EXEC ;
1375
                             UNPAIR 3 ;
1376
                             DIG 8 ;
1377
                             DIG 8 ;
1378
                             DIG 8 ;
1379
                             DIG 8 ;
1380
                             DIG 6 ;
1381
                             DIG 8 ;
1382
                             DIG 7 ;
1383
                             DIG 8 ;
1384
                             DIG 8 ;
1385
                             DUP 5 ;
1386
                             GET 46 ;
1387
                             DUP 5 ;
1388
                             CAR ;
1389
                             GET ;
1390
                             IF_NONE { PUSH int 725 ; FAILWITH } {} ;
1391
                             DUP 8 ;
1392
                             SWAP ;
1393
                             DUP ;
1394
                             DUG 2 ;
1395
                             GET 4 ;
1396
                             DUP 7 ;
1397
                             CAR ;
1398
                             PAIR ;
1399
                             SWAP ;
1400
                             DIG 7 ;
1401
                             DIG 6 ;
1402
                             DIG 3 ;
1403
                             PAIR 3 ;
1404
                             EXEC ;
1405
                             CDR ;
1406
                             UNPAIR ;
1407
                             DIG 9 ;
1408
                             DIG 9 ;
1409
                             DIG 9 ;
1410
                             DIG 9 ;
1411
                             DIG 5 ;
1412
                             DIG 9 ;
1413
                             DIG 6 ;
1414
                             DIG 9 ;
1415
                             DIG 9 ;
1416
                             DIG 9 ;
1417
                             DUP ;
1418
                             GET 3 ;
1419
                             IF_NONE
1420
                               { DROP 3 ; SWAP ; DROP ; DIG 2 ; DROP ; DIG 2 ; DROP ; DIG 2 ; DROP ; DIG 2 ; DROP }
1421
                               { DROP ;
1422
                                 SWAP ;
1423
                                 DROP ;
1424
                                 SWAP ;
1425
                                 DROP ;
1426
                                 DIG 2 ;
1427
                                 DROP ;
1428
                                 DIG 3 ;
1429
                                 DROP ;
1430
                                 DIG 4 ;
1431
                                 DROP ;
1432
                                 DIG 4 ;
1433
                                 DROP ;
1434
                                 DIG 3 ;
1435
                                 DIG 3 ;
1436
                                 DUP ;
1437
                                 GET 17 ;
1438
                                 CDR ;
1439
                                 SWAP ;
1440
                                 DUP ;
1441
                                 DUG 5 ;
1442
                                 GET 17 ;
1443
                                 CAR ;
1444
                                 DUP 4 ;
1445
                                 GET 4 ;
1446
                                 MUL ;
1447
                                 EDIV ;
1448
                                 IF_NONE { PUSH int 736 ; FAILWITH } { CAR } ;
1449
                                 DIG 2 ;
1450
                                 GET 3 ;
1451
                                 IF_NONE { PUSH int 604 ; FAILWITH } {} ;
1452
                                 PAIR ;
1453
                                 SWAP ;
1454
                                 DUG 3 ;
1455
                                 PAIR 3 ;
1456
                                 EXEC ;
1457
                                 CDR ;
1458
                                 UNPAIR } } } } }
1459
               { IF_LEFT
1460
                   { IF_LEFT
1461
                       { AMOUNT ;
1462
                         PUSH mutez 0 ;
1463
                         COMPARE ;
1464
                         EQ ;
1465
                         IF {} { AMOUNT ; FAILWITH } ;
1466
                         NIL operation ;
1467
                         DUP 6 ;
1468
                         UNIT ;
1469
                         SWAP ;
1470
                         DIG 4 ;
1471
                         DIG 3 ;
1472
                         DIG 3 ;
1473
                         PAIR 3 ;
1474
                         EXEC ;
1475
                         UNPAIR 3 ;
1476
                         DIG 7 ;
1477
                         DIG 7 ;
1478
                         DIG 7 ;
1479
                         DIG 7 ;
1480
                         DIG 6 ;
1481
                         DIG 7 ;
1482
                         DIG 7 ;
1483
                         DIG 7 ;
1484
                         PUSH nat 1000001 ;
1485
                         DUP 4 ;
1486
                         COMPARE ;
1487
                         GE ;
1488
                         IF {} { PUSH int 602 ; FAILWITH } ;
1489
                         DUP 4 ;
1490
                         GET 46 ;
1491
                         SENDER ;
1492
                         GET ;
1493
                         IF_NONE { PUSH int 551 ; FAILWITH } {} ;
1494
                         DUP 5 ;
1495
                         GET 11 ;
1496
                         SWAP ;
1497
                         DUP ;
1498
                         DUG 2 ;
1499
                         GET 4 ;
1500
                         MUL ;
1501
                         LAMBDA
1502
                           (pair nat nat)
1503
                           nat
1504
                           { UNPAIR ;
1505
                             PUSH nat 0 ;
1506
                             DUP 3 ;
1507
                             DUP 3 ;
1508
                             EDIV ;
1509
                             IF_NONE { PUSH int 129 ; FAILWITH } { CDR } ;
1510
                             COMPARE ;
1511
                             EQ ;
1512
                             IF
1513
                               { EDIV ; IF_NONE { PUSH int 131 ; FAILWITH } { CAR } }
1514
                               { PUSH nat 1 ;
1515
                                 DUG 2 ;
1516
                                 EDIV ;
1517
                                 IF_NONE { PUSH int 133 ; FAILWITH } { CAR } ;
1518
                                 ADD } } ;
1519
                         PUSH nat 1000000000000 ;
1520
                         DIG 2 ;
1521
                         PAIR ;
1522
                         EXEC ;
1523
                         PUSH nat 1 ;
1524
                         DUP 7 ;
1525
                         GET 39 ;
1526
                         UNIT ;
1527
                         VIEW "get_price" nat ;
1528
                         IF_NONE { PUSH int 502 ; FAILWITH } {} ;
1529
                         DUP 7 ;
1530
                         DIG 3 ;
1531
                         ADD ;
1532
                         MUL ;
1533
                         EDIV ;
1534
                         IF_NONE { PUSH int 572 ; FAILWITH } { CAR } ;
1535
                         PUSH nat 1000000 ;
1536
                         DIG 6 ;
1537
                         DUP ;
1538
                         GET 5 ;
1539
                         CDR ;
1540
                         SWAP ;
1541
                         DUP ;
1542
                         DUG 8 ;
1543
                         GET 5 ;
1544
                         CAR ;
1545
                         DIG 3 ;
1546
                         MUL ;
1547
                         EDIV ;
1548
                         IF_NONE { PUSH int 577 ; FAILWITH } { CAR } ;
1549
                         MUL ;
1550
                         PUSH nat 1000000000000 ;
1551
                         PUSH nat 1000000 ;
1552
                         DUP 4 ;
1553
                         CAR ;
1554
                         MUL ;
1555
                         MUL ;
1556
                         COMPARE ;
1557
                         GE ;
1558
                         IF {} { PUSH int 801 ; FAILWITH } ;
1559
                         DUP ;
1560
                         GET 4 ;
1561
                         DUP 6 ;
1562
                         GET 11 ;
1563
                         PUSH nat 1000000000000 ;
1564
                         DUP 7 ;
1565
                         MUL ;
1566
                         EDIV ;
1567
                         IF_NONE { PUSH int 596 ; FAILWITH } { CAR } ;
1568
                         ADD ;
1569
                         UPDATE 4 ;
1570
                         DIG 4 ;
1571
                         DUP ;
1572
                         GET 46 ;
1573
                         DUP 3 ;
1574
                         SOME ;
1575
                         SENDER ;
1576
                         UPDATE ;
1577
                         UPDATE 46 ;
1578
                         DUG 4 ;
1579
                         DIG 2 ;
1580
                         DUP 5 ;
1581
                         GET 41 ;
1582
                         CONTRACT %mint (pair (address %owner)
1583
                                              (pair (nat %token_id) (nat %token_amount))) ;
1584
                         IF_NONE { PUSH int 140 ; FAILWITH } {} ;
1585
                         PUSH mutez 0 ;
1586
                         DIG 6 ;
1587
                         DUP ;
1588
                         GET 21 ;
1589
                         CDR ;
1590
                         SWAP ;
1591
                         DUP ;
1592
                         DUG 8 ;
1593
                         GET 21 ;
1594
                         CAR ;
1595
                         DUP 8 ;
1596
                         MUL ;
1597
                         EDIV ;
1598
                         IF_NONE { PUSH int 590 ; FAILWITH } { CAR } ;
1599
                         DUP 7 ;
1600
                         SUB ;
1601
                         ISNAT ;
1602
                         IF_NONE { PUSH int 594 ; FAILWITH } {} ;
1603
                         DUP 8 ;
1604
                         GET 43 ;
1605
                         SENDER ;
1606
                         PAIR 3 ;
1607
                         TRANSFER_TOKENS ;
1608
                         CONS ;
1609
                         DUP 5 ;
1610
                         GET 41 ;
1611
                         CONTRACT %mint (pair (address %owner)
1612
                                              (pair (nat %token_id) (nat %token_amount))) ;
1613
                         IF_NONE { PUSH int 140 ; FAILWITH } {} ;
1614
                         PUSH mutez 0 ;
1615
                         DIG 6 ;
1616
                         DUP ;
1617
                         GET 21 ;
1618
                         CDR ;
1619
                         SWAP ;
1620
                         DUP ;
1621
                         DUG 8 ;
1622
                         GET 21 ;
1623
                         CAR ;
1624
                         DUP 8 ;
1625
                         MUL ;
1626
                         EDIV ;
1627
                         IF_NONE { PUSH int 590 ; FAILWITH } { CAR } ;
1628
                         DIG 7 ;
1629
                         DUP ;
1630
                         GET 43 ;
1631
                         SWAP ;
1632
                         DUP ;
1633
                         DUG 9 ;
1634
                         GET 27 ;
1635
                         PAIR 3 ;
1636
                         TRANSFER_TOKENS ;
1637
                         CONS ;
1638
                         DUG 2 ;
1639
                         DIG 4 ;
1640
                         DUP ;
1641
                         GET 45 ;
1642
                         DUP 6 ;
1643
                         ADD ;
1644
                         UPDATE 45 ;
1645
                         DUG 4 ;
1646
                         DUP 7 ;
1647
                         SWAP ;
1648
                         DUP ;
1649
                         DUG 2 ;
1650
                         GET 4 ;
1651
                         SENDER ;
1652
                         PAIR ;
1653
                         SWAP ;
1654
                         DIG 6 ;
1655
                         DIG 5 ;
1656
                         DIG 3 ;
1657
                         PAIR 3 ;
1658
                         EXEC ;
1659
                         CDR ;
1660
                         UNPAIR ;
1661
                         DIG 8 ;
1662
                         DIG 8 ;
1663
                         DIG 8 ;
1664
                         DIG 8 ;
1665
                         DIG 5 ;
1666
                         DIG 8 ;
1667
                         DIG 6 ;
1668
                         DIG 8 ;
1669
                         DIG 8 ;
1670
                         DUP ;
1671
                         GET 3 ;
1672
                         IF_NONE
1673
                           { DROP 2 ; SWAP ; DROP ; DIG 2 ; DROP ; DIG 2 ; DROP ; DIG 2 ; DROP ; DIG 2 ; DROP }
1674
                           { DROP ;
1675
                             SWAP ;
1676
                             DROP ;
1677
                             DIG 2 ;
1678
                             DROP ;
1679
                             DIG 3 ;
1680
                             DROP ;
1681
                             DIG 4 ;
1682
                             DROP ;
1683
                             DIG 4 ;
1684
                             DROP ;
1685
                             DIG 3 ;
1686
                             DIG 3 ;
1687
                             DUP ;
1688
                             GET 17 ;
1689
                             CDR ;
1690
                             SWAP ;
1691
                             DUP ;
1692
                             DUG 5 ;
1693
                             GET 17 ;
1694
                             CAR ;
1695
                             DUP 4 ;
1696
                             GET 4 ;
1697
                             MUL ;
1698
                             EDIV ;
1699
                             IF_NONE { PUSH int 621 ; FAILWITH } { CAR } ;
1700
                             DIG 2 ;
1701
                             GET 3 ;
1702
                             IF_NONE { PUSH int 604 ; FAILWITH } {} ;
1703
                             PAIR ;
1704
                             SWAP ;
1705
                             DUG 3 ;
1706
                             PAIR 3 ;
1707
                             EXEC ;
1708
                             CDR ;
1709
                             UNPAIR } }
1710
                       { DIG 3 ;
1711
                         DROP ;
1712
                         DIG 3 ;
1713
                         DROP ;
1714
                         DIG 3 ;
1715
                         DROP ;
1716
                         AMOUNT ;
1717
                         PUSH mutez 0 ;
1718
                         COMPARE ;
1719
                         EQ ;
1720
                         IF {} { AMOUNT ; FAILWITH } ;
1721
                         NIL operation ;
1722
                         DIG 3 ;
1723
                         DUP 3 ;
1724
                         CDR ;
1725
                         SWAP ;
1726
                         DIG 4 ;
1727
                         DIG 3 ;
1728
                         DIG 3 ;
1729
                         PAIR 3 ;
1730
                         EXEC ;
1731
                         CDR ;
1732
                         UNPAIR ;
1733
                         SWAP ;
1734
                         DUP ;
1735
                         GET 3 ;
1736
                         NONE unit ;
1737
                         DIG 4 ;
1738
                         UPDATE ;
1739
                         UPDATE 3 ;
1740
                         SWAP } }
1741
                   { IF_LEFT
1742
                       { DIG 3 ;
1743
                         DROP ;
1744
                         DIG 3 ;
1745
                         DROP ;
1746
                         DIG 3 ;
1747
                         DROP ;
1748
                         AMOUNT ;
1749
                         PUSH mutez 0 ;
1750
                         COMPARE ;
1751
                         EQ ;
1752
                         IF {} { AMOUNT ; FAILWITH } ;
1753
                         NIL operation ;
1754
                         DIG 3 ;
1755
                         DUP 3 ;
1756
                         CDR ;
1757
                         SWAP ;
1758
                         DIG 4 ;
1759
                         DIG 3 ;
1760
                         DIG 3 ;
1761
                         PAIR 3 ;
1762
                         EXEC ;
1763
                         CDR ;
1764
                         UNPAIR ;
1765
                         SWAP ;
1766
                         DUP ;
1767
                         GET 3 ;
1768
                         PUSH (option unit) (Some Unit) ;
1769
                         DIG 4 ;
1770
                         UPDATE ;
1771
                         UPDATE 3 ;
1772
                         SWAP }
1773
                       { IF_LEFT
1774
                           { DIG 3 ;
1775
                             DROP ;
1776
                             DIG 3 ;
1777
                             DROP ;
1778
                             DIG 3 ;
1779
                             DROP ;
1780
                             AMOUNT ;
1781
                             PUSH mutez 0 ;
1782
                             COMPARE ;
1783
                             EQ ;
1784
                             IF {} { AMOUNT ; FAILWITH } ;
1785
                             NIL operation ;
1786
                             DIG 3 ;
1787
                             PUSH nat 0 ;
1788
                             SWAP ;
1789
                             DIG 4 ;
1790
                             DIG 3 ;
1791
                             DIG 3 ;
1792
                             PAIR 3 ;
1793
                             EXEC ;
1794
                             CDR ;
1795
                             UNPAIR ;
1796
                             SWAP ;
1797
                             DIG 2 ;
1798
                             UPDATE 5 ;
1799
                             SWAP }
1800
                           { DIG 3 ;
1801
                             DROP ;
1802
                             DIG 3 ;
1803
                             DROP ;
1804
                             DIG 3 ;
1805
                             DROP ;
1806
                             AMOUNT ;
1807
                             PUSH mutez 0 ;
1808
                             COMPARE ;
1809
                             EQ ;
1810
                             IF {} { AMOUNT ; FAILWITH } ;
1811
                             NIL operation ;
1812
                             DIG 3 ;
1813
                             PUSH nat 0 ;
1814
                             SWAP ;
1815
                             DIG 4 ;
1816
                             DIG 3 ;
1817
                             DIG 3 ;
1818
                             PAIR 3 ;
1819
                             EXEC ;
1820
                             CDR ;
1821
                             UNPAIR ;
1822
                             SWAP ;
1823
                             DIG 2 ;
1824
                             DUP ;
1825
                             DUG 3 ;
1826
                             GET 6 ;
1827
                             UPDATE 39 ;
1828
                             DUG 2 ;
1829
                             DUG 2 ;
1830
                             DUP ;
1831
                             DUG 3 ;
1832
                             GET 3 ;
1833
                             UPDATE 27 ;
1834
                             DUG 2 ;
1835
                             DUG 2 ;
1836
                             DUP ;
1837
                             DUG 3 ;
1838
                             GET 5 ;
1839
                             UPDATE 29 ;
1840
                             DUG 2 ;
1841
                             DUG 2 ;
1842
                             DUP ;
1843
                             DUG 3 ;
1844
                             CAR ;
1845
                             CAR ;
1846
                             UPDATE 13 ;
1847
                             DUG 2 ;
1848
                             DUG 2 ;
1849
                             DUP ;
1850
                             DUG 3 ;
1851
                             CAR ;
1852
                             GET 4 ;
1853
                             UPDATE 23 ;
1854
                             DUG 2 ;
1855
                             DUG 2 ;
1856
                             CAR ;
1857
                             GET 3 ;
1858
                             UPDATE 15 ;
1859
                             SWAP } } } } }
1860
           { IF_LEFT
1861
               { IF_LEFT
1862
                   { IF_LEFT
1863
                       { DIG 3 ;
1864
                         DROP ;
1865
                         DIG 3 ;
1866
                         DROP ;
1867
                         DIG 3 ;
1868
                         DROP ;
1869
                         AMOUNT ;
1870
                         PUSH mutez 0 ;
1871
                         COMPARE ;
1872
                         EQ ;
1873
                         IF {} { AMOUNT ; FAILWITH } ;
1874
                         NIL operation ;
1875
                         DIG 3 ;
1876
                         PUSH nat 0 ;
1877
                         SWAP ;
1878
                         DIG 4 ;
1879
                         DIG 3 ;
1880
                         DIG 3 ;
1881
                         PAIR 3 ;
1882
                         EXEC ;
1883
                         CDR ;
1884
                         UNPAIR ;
1885
                         SWAP ;
1886
                         DIG 2 ;
1887
                         UPDATE 17 ;
1888
                         SWAP }
1889
                       { DIG 3 ;
1890
                         DROP ;
1891
                         DIG 3 ;
1892
                         DROP ;
1893
                         DIG 3 ;
1894
                         DROP ;
1895
                         AMOUNT ;
1896
                         PUSH mutez 0 ;
1897
                         COMPARE ;
1898
                         EQ ;
1899
                         IF {} { AMOUNT ; FAILWITH } ;
1900
                         NIL operation ;
1901
                         DIG 3 ;
1902
                         PUSH nat 0 ;
1903
                         SWAP ;
1904
                         DIG 4 ;
1905
                         DIG 3 ;
1906
                         DIG 3 ;
1907
                         PAIR 3 ;
1908
                         EXEC ;
1909
                         CDR ;
1910
                         UNPAIR ;
1911
                         SWAP ;
1912
                         DIG 2 ;
1913
                         UPDATE 19 ;
1914
                         SWAP } }
1915
                   { IF_LEFT
1916
                       { DIG 3 ;
1917
                         DROP ;
1918
                         DIG 3 ;
1919
                         DROP ;
1920
                         DIG 3 ;
1921
                         DROP ;
1922
                         AMOUNT ;
1923
                         PUSH mutez 0 ;
1924
                         COMPARE ;
1925
                         EQ ;
1926
                         IF {} { AMOUNT ; FAILWITH } ;
1927
                         NIL operation ;
1928
                         DIG 3 ;
1929
                         PUSH nat 0 ;
1930
                         SWAP ;
1931
                         DIG 4 ;
1932
                         DIG 3 ;
1933
                         DIG 3 ;
1934
                         PAIR 3 ;
1935
                         EXEC ;
1936
                         CDR ;
1937
                         UNPAIR ;
1938
                         SWAP ;
1939
                         DIG 2 ;
1940
                         UPDATE 21 ;
1941
                         SWAP }
1942
                       { IF_LEFT
1943
                           { DIG 2 ;
1944
                             DROP ;
1945
                             DIG 2 ;
1946
                             DROP ;
1947
                             DIG 3 ;
1948
                             DROP ;
1949
                             AMOUNT ;
1950
                             PUSH mutez 0 ;
1951
                             COMPARE ;
1952
                             EQ ;
1953
                             IF {} { AMOUNT ; FAILWITH } ;
1954
                             SWAP ;
1955
                             DUP ;
1956
                             DUG 2 ;
1957
                             GET 15 ;
1958
                             SENDER ;
1959
                             COMPARE ;
1960
                             EQ ;
1961
                             IF {} { PUSH int 401 ; FAILWITH } ;
1962
                             NIL operation ;
1963
                             DIG 3 ;
1964
                             UNIT ;
1965
                             SWAP ;
1966
                             DIG 4 ;
1967
                             DIG 3 ;
1968
                             DIG 3 ;
1969
                             PAIR 3 ;
1970
                             EXEC ;
1971
                             CDR ;
1972
                             UNPAIR ;
1973
                             SWAP ;
1974
                             DIG 2 ;
1975
                             UPDATE 25 ;
1976
                             SWAP }
1977
                           { DIG 3 ;
1978
                             DROP ;
1979
                             DIG 3 ;
1980
                             DROP ;
1981
                             DIG 3 ;
1982
                             DROP ;
1983
                             AMOUNT ;
1984
                             PUSH mutez 0 ;
1985
                             COMPARE ;
1986
                             EQ ;
1987
                             IF {} { AMOUNT ; FAILWITH } ;
1988
                             NIL operation ;
1989
                             DIG 3 ;
1990
                             PUSH nat 0 ;
1991
                             SWAP ;
1992
                             DIG 4 ;
1993
                             DIG 3 ;
1994
                             DIG 3 ;
1995
                             PAIR 3 ;
1996
                             EXEC ;
1997
                             CDR ;
1998
                             UNPAIR ;
1999
                             SWAP ;
2000
                             DIG 2 ;
2001
                             UPDATE 31 ;
2002
                             SWAP } } } }
2003
               { IF_LEFT
2004
                   { IF_LEFT
2005
                       { DIG 3 ;
2006
                         DROP ;
2007
                         DIG 3 ;
2008
                         DROP ;
2009
                         DIG 3 ;
2010
                         DROP ;
2011
                         AMOUNT ;
2012
                         PUSH mutez 0 ;
2013
                         COMPARE ;
2014
                         EQ ;
2015
                         IF {} { AMOUNT ; FAILWITH } ;
2016
                         NIL operation ;
2017
                         DIG 3 ;
2018
                         PUSH nat 0 ;
2019
                         SWAP ;
2020
                         DIG 4 ;
2021
                         DIG 3 ;
2022
                         DIG 3 ;
2023
                         PAIR 3 ;
2024
                         EXEC ;
2025
                         CDR ;
2026
                         UNPAIR ;
2027
                         SWAP ;
2028
                         DIG 2 ;
2029
                         UPDATE 33 ;
2030
                         SWAP }
2031
                       { IF_LEFT
2032
                           { DIG 3 ;
2033
                             DROP ;
2034
                             DIG 3 ;
2035
                             DROP ;
2036
                             DIG 3 ;
2037
                             DROP ;
2038
                             AMOUNT ;
2039
                             PUSH mutez 0 ;
2040
                             COMPARE ;
2041
                             EQ ;
2042
                             IF {} { AMOUNT ; FAILWITH } ;
2043
                             NIL operation ;
2044
                             DIG 3 ;
2045
                             PUSH nat 0 ;
2046
                             SWAP ;
2047
                             DIG 4 ;
2048
                             DIG 3 ;
2049
                             DIG 3 ;
2050
                             PAIR 3 ;
2051
                             EXEC ;
2052
                             CDR ;
2053
                             UNPAIR ;
2054
                             SWAP ;
2055
                             DIG 2 ;
2056
                             UPDATE 35 ;
2057
                             SWAP }
2058
                           { AMOUNT ;
2059
                             PUSH mutez 0 ;
2060
                             COMPARE ;
2061
                             EQ ;
2062
                             IF {} { AMOUNT ; FAILWITH } ;
2063
                             SWAP ;
2064
                             DUP ;
2065
                             DUG 2 ;
2066
                             GET 23 ;
2067
                             SENDER ;
2068
                             COMPARE ;
2069
                             EQ ;
2070
                             IF {} { PUSH int 401 ; FAILWITH } ;
2071
                             NIL operation ;
2072
                             DUP 6 ;
2073
                             UNIT ;
2074
                             SWAP ;
2075
                             DIG 4 ;
2076
                             DIG 3 ;
2077
                             DIG 3 ;
2078
                             PAIR 3 ;
2079
                             EXEC ;
2080
                             UNPAIR 3 ;
2081
                             DIG 7 ;
2082
                             DIG 7 ;
2083
                             DIG 7 ;
2084
                             DIG 7 ;
2085
                             DIG 6 ;
2086
                             DIG 7 ;
2087
                             DIG 7 ;
2088
                             DIG 7 ;
2089
                             DUP 8 ;
2090
                             DIG 4 ;
2091
                             DUP ;
2092
                             GET 31 ;
2093
                             SWAP ;
2094
                             DUP ;
2095
                             DUG 6 ;
2096
                             GET 33 ;
2097
                             DIG 5 ;
2098
                             DUP ;
2099
                             GET 4 ;
2100
                             SWAP ;
2101
                             DUP ;
2102
                             GET 3 ;
2103
                             SWAP ;
2104
                             DUP ;
2105
                             DUG 8 ;
2106
                             CAR ;
2107
                             PAIR 5 ;
2108
                             SWAP ;
2109
                             DIG 5 ;
2110
                             DIG 4 ;
2111
                             DIG 3 ;
2112
                             PAIR 3 ;
2113
                             EXEC ;
2114
                             UNPAIR 3 ;
2115
                             DIG 8 ;
2116
                             DIG 8 ;
2117
                             DIG 8 ;
2118
                             DIG 8 ;
2119
                             DIG 6 ;
2120
                             DIG 8 ;
2121
                             DIG 7 ;
2122
                             DIG 8 ;
2123
                             DIG 8 ;
2124
                             DUP 5 ;
2125
                             GET 46 ;
2126
                             DUP 5 ;
2127
                             CAR ;
2128
                             GET ;
2129
                             IF_NONE { PUSH int 776 ; FAILWITH } {} ;
2130
                             DUP 8 ;
2131
                             SWAP ;
2132
                             DUP ;
2133
                             DUG 2 ;
2134
                             GET 4 ;
2135
                             DUP 7 ;
2136
                             CAR ;
2137
                             PAIR ;
2138
                             SWAP ;
2139
                             DIG 7 ;
2140
                             DIG 6 ;
2141
                             DIG 3 ;
2142
                             PAIR 3 ;
2143
                             EXEC ;
2144
                             CDR ;
2145
                             UNPAIR ;
2146
                             DIG 9 ;
2147
                             DIG 9 ;
2148
                             DIG 9 ;
2149
                             DIG 9 ;
2150
                             DIG 5 ;
2151
                             DIG 9 ;
2152
                             DIG 6 ;
2153
                             DIG 9 ;
2154
                             DIG 9 ;
2155
                             DIG 9 ;
2156
                             DUP ;
2157
                             GET 3 ;
2158
                             IF_NONE
2159
                               { DROP 3 ; SWAP ; DROP ; DIG 2 ; DROP ; DIG 2 ; DROP ; DIG 2 ; DROP ; DIG 2 ; DROP }
2160
                               { DROP ;
2161
                                 SWAP ;
2162
                                 DROP ;
2163
                                 SWAP ;
2164
                                 DROP ;
2165
                                 DIG 2 ;
2166
                                 DROP ;
2167
                                 DIG 3 ;
2168
                                 DROP ;
2169
                                 DIG 4 ;
2170
                                 DROP ;
2171
                                 DIG 4 ;
2172
                                 DROP ;
2173
                                 DIG 3 ;
2174
                                 DIG 3 ;
2175
                                 DUP ;
2176
                                 GET 17 ;
2177
                                 CDR ;
2178
                                 SWAP ;
2179
                                 DUP ;
2180
                                 DUG 5 ;
2181
                                 GET 17 ;
2182
                                 CAR ;
2183
                                 DUP 4 ;
2184
                                 GET 4 ;
2185
                                 MUL ;
2186
                                 EDIV ;
2187
                                 IF_NONE { PUSH int 787 ; FAILWITH } { CAR } ;
2188
                                 DIG 2 ;
2189
                                 GET 3 ;
2190
                                 IF_NONE { PUSH int 604 ; FAILWITH } {} ;
2191
                                 PAIR ;
2192
                                 SWAP ;
2193
                                 DUG 3 ;
2194
                                 PAIR 3 ;
2195
                                 EXEC ;
2196
                                 CDR ;
2197
                                 UNPAIR } } } }
2198
                   { IF_LEFT
2199
                       { AMOUNT ;
2200
                         PUSH mutez 0 ;
2201
                         COMPARE ;
2202
                         EQ ;
2203
                         IF {} { AMOUNT ; FAILWITH } ;
2204
                         NIL operation ;
2205
                         DUP 6 ;
2206
                         UNIT ;
2207
                         SWAP ;
2208
                         DIG 4 ;
2209
                         DIG 3 ;
2210
                         DIG 3 ;
2211
                         PAIR 3 ;
2212
                         EXEC ;
2213
                         UNPAIR 3 ;
2214
                         DIG 7 ;
2215
                         DIG 7 ;
2216
                         DIG 7 ;
2217
                         DIG 7 ;
2218
                         DIG 6 ;
2219
                         DIG 7 ;
2220
                         DIG 7 ;
2221
                         DIG 7 ;
2222
                         DUP 3 ;
2223
                         ITER { DUP 5 ;
2224
                                GET 46 ;
2225
                                SWAP ;
2226
                                DUP ;
2227
                                DUG 2 ;
2228
                                GET ;
2229
                                IF_NONE { PUSH int 875 ; FAILWITH } {} ;
2230
                                DUP 8 ;
2231
                                SWAP ;
2232
                                DUP ;
2233
                                DUG 2 ;
2234
                                GET 4 ;
2235
                                DUP 4 ;
2236
                                PAIR ;
2237
                                SWAP ;
2238
                                DIG 7 ;
2239
                                DIG 6 ;
2240
                                DIG 3 ;
2241
                                PAIR 3 ;
2242
                                EXEC ;
2243
                                CDR ;
2244
                                UNPAIR ;
2245
                                DIG 9 ;
2246
                                DIG 9 ;
2247
                                DIG 9 ;
2248
                                DIG 9 ;
2249
                                DIG 5 ;
2250
                                DIG 9 ;
2251
                                DIG 6 ;
2252
                                DIG 9 ;
2253
                                DIG 9 ;
2254
                                DIG 9 ;
2255
                                DUP ;
2256
                                GET 3 ;
2257
                                IF_NONE
2258
                                  { DROP 2 }
2259
                                  { DROP ;
2260
                                    SWAP ;
2261
                                    DROP ;
2262
                                    DUP 7 ;
2263
                                    DIG 5 ;
2264
                                    DUP ;
2265
                                    GET 17 ;
2266
                                    CDR ;
2267
                                    SWAP ;
2268
                                    DUP ;
2269
                                    DUG 7 ;
2270
                                    GET 17 ;
2271
                                    CAR ;
2272
                                    DUP 4 ;
2273
                                    GET 4 ;
2274
                                    MUL ;
2275
                                    EDIV ;
2276
                                    IF_NONE { PUSH int 885 ; FAILWITH } { CAR } ;
2277
                                    DIG 2 ;
2278
                                    GET 3 ;
2279
                                    IF_NONE { PUSH int 604 ; FAILWITH } {} ;
2280
                                    PAIR ;
2281
                                    SWAP ;
2282
                                    DIG 5 ;
2283
                                    DIG 4 ;
2284
                                    DIG 3 ;
2285
                                    PAIR 3 ;
2286
                                    EXEC ;
2287
                                    CDR ;
2288
                                    UNPAIR ;
2289
                                    DIG 7 ;
2290
                                    DIG 7 ;
2291
                                    DIG 7 ;
2292
                                    DIG 7 ;
2293
                                    DIG 5 ;
2294
                                    DIG 7 ;
2295
                                    DIG 6 ;
2296
                                    DIG 7 } } ;
2297
                         DROP ;
2298
                         SWAP ;
2299
                         DROP ;
2300
                         DIG 2 ;
2301
                         DROP ;
2302
                         DIG 2 ;
2303
                         DROP ;
2304
                         DIG 2 ;
2305
                         DROP ;
2306
                         DIG 2 ;
2307
                         DROP }
2308
                       { IF_LEFT
2309
                           { DROP ;
2310
                             SWAP ;
2311
                             DROP ;
2312
                             SWAP ;
2313
                             DROP ;
2314
                             DIG 2 ;
2315
                             DROP ;
2316
                             AMOUNT ;
2317
                             PUSH mutez 0 ;
2318
                             COMPARE ;
2319
                             EQ ;
2320
                             IF {} { AMOUNT ; FAILWITH } ;
2321
                             NIL operation ;
2322
                             DIG 2 ;
2323
                             UNIT ;
2324
                             SWAP ;
2325
                             DUG 3 ;
2326
                             PAIR 3 ;
2327
                             EXEC ;
2328
                             CDR ;
2329
                             UNPAIR }
2330
                           { AMOUNT ;
2331
                             PUSH mutez 0 ;
2332
                             COMPARE ;
2333
                             EQ ;
2334
                             IF {} { AMOUNT ; FAILWITH } ;
2335
                             NIL operation ;
2336
                             DUP 6 ;
2337
                             UNIT ;
2338
                             SWAP ;
2339
                             DIG 4 ;
2340
                             DIG 3 ;
2341
                             DIG 3 ;
2342
                             PAIR 3 ;
2343
                             EXEC ;
2344
                             CDR ;
2345
                             UNPAIR ;
2346
                             DUG 6 ;
2347
                             DUG 6 ;
2348
                             DUG 6 ;
2349
                             DIG 5 ;
2350
                             DIG 6 ;
2351
                             DIG 6 ;
2352
                             DUP 3 ;
2353
                             GET 46 ;
2354
                             SENDER ;
2355
                             GET ;
2356
                             IF_NONE { PUSH int 811 ; FAILWITH } {} ;
2357
                             PUSH nat 1000000 ;
2358
                             DIG 4 ;
2359
                             DUP ;
2360
                             GET 5 ;
2361
                             CAR ;
2362
                             SWAP ;
2363
                             DUP ;
2364
                             DUG 6 ;
2365
                             GET 39 ;
2366
                             UNIT ;
2367
                             VIEW "get_price" nat ;
2368
                             IF_NONE { PUSH int 502 ; FAILWITH } {} ;
2369
                             DUP 7 ;
2370
                             GET 11 ;
2371
                             DUP 5 ;
2372
                             GET 4 ;
2373
                             MUL ;
2374
                             MUL ;
2375
                             MUL ;
2376
                             MUL ;
2377
                             DUP 5 ;
2378
                             GET 5 ;
2379
                             CDR ;
2380
                             PUSH nat 1000000000000 ;
2381
                             PUSH nat 1 ;
2382
                             PUSH nat 1000000 ;
2383
                             PUSH nat 1000000000000 ;
2384
                             DUP 9 ;
2385
                             DUP 8 ;
2386
                             CAR ;
2387
                             SUB ;
2388
                             ISNAT ;
2389
                             IF_NONE { PUSH int 813 ; FAILWITH } {} ;
2390
                             MUL ;
2391
                             MUL ;
2392
                             MUL ;
2393
                             MUL ;
2394
                             MUL ;
2395
                             COMPARE ;
2396
                             GE ;
2397
                             IF {} { PUSH int 801 ; FAILWITH } ;
2398
                             DUP ;
2399
                             DUP 4 ;
2400
                             DIG 2 ;
2401
                             CAR ;
2402
                             SUB ;
2403
                             ISNAT ;
2404
                             IF_NONE { PUSH int 813 ; FAILWITH } {} ;
2405
                             UPDATE 1 ;
2406
                             DIG 3 ;
2407
                             DUP ;
2408
                             GET 46 ;
2409
                             DIG 2 ;
2410
                             SOME ;
2411
                             SENDER ;
2412
                             UPDATE ;
2413
                             UPDATE 46 ;
2414
                             DUG 2 ;
2415
                             PUSH nat 0 ;
2416
                             DUP 3 ;
2417
                             COMPARE ;
2418
                             GT ;
2419
                             IF
2420
                               { DIG 3 ;
2421
                                 DROP ;
2422
                                 DIG 3 ;
2423
                                 DROP ;
2424
                                 DIG 3 ;
2425
                                 DROP ;
2426
                                 DIG 3 ;
2427
                                 DROP ;
2428
                                 DUP 3 ;
2429
                                 GET 7 ;
2430
                                 CONTRACT %transfer (list (pair (address %from_)
2431
                                                               (list %txs (pair
2432
                                                                           (address %to_)
2433
                                                                           (pair
2434
                                                                             (nat %token_id)
2435
                                                                             (nat %amount)))))) ;
2436
                                 IF_NONE { PUSH int 36 ; FAILWITH } {} ;
2437
                                 PUSH mutez 0 ;
2438
                                 NIL (pair address (list (pair address (pair nat nat)))) ;
2439
                                 NIL (pair address (pair nat nat)) ;
2440
                                 DIG 5 ;
2441
                                 DUP 7 ;
2442
                                 GET 9 ;
2443
                                 SENDER ;
2444
                                 PAIR 3 ;
2445
                                 CONS ;
2446
                                 SELF_ADDRESS ;
2447
                                 PAIR ;
2448
                                 CONS ;
2449
                                 TRANSFER_TOKENS ;
2450
                                 CONS }
2451
                               { SWAP ; DROP ; DIG 2 ; DROP ; DIG 2 ; DROP ; DIG 2 ; DROP ; DIG 2 ; DROP } } } } } } ;
2452
         NIL operation ;
2453
         SWAP ;
2454
         ITER { CONS } ;
2455
         PAIR } ;
2456
  view "accrual_update_timestamp" unit timestamp { CDR ; CAR } ;
2457
  view "collateral_ratio" unit (pair (nat %numerator) (nat %denominator))
2458
        { CDR ; GET 5 } ;
2459
  view "compound_interest_rate" unit nat { CDR ; GET 11 } ;
2460
  view "governance_token_contract" unit address { CDR ; GET 13 } ;
2461
  view "interest_rate_setter_contract" unit address { CDR ; GET 15 } ;
2462
  view "introducer_ratio" unit (pair (nat %numerator) (nat %denominator))
2463
        { CDR ; GET 17 } ;
2464
  view "is_admin" (pair (address %owner) (nat %token_id)) bool
2465
        { UNPAIR ; SWAP ; GET 3 ; SWAP ; MEM } ;
2466
  view "liquidation_payout_ratio" unit (pair (nat %numerator) (nat %denominator))
2467
        { CDR ; GET 19 } ;
2468
  view "minting_fee_ratio" unit (pair (nat %numerator) (nat %denominator))
2469
        { CDR ; GET 21 } ;
2470
  view "options_contract" unit address { CDR ; GET 23 } ;
2471
  view "reference_interest_rate" unit nat { CDR ; GET 25 } ;
2472
  view "reward_pool_contract" unit address { CDR ; GET 27 } ;
2473
  view "savings_pool_contract" unit address { CDR ; GET 29 } ;
2474
  view "settlement_payout_ratio" unit (pair (nat %numerator) (nat %denominator))
2475
        { CDR ; GET 31 } ;
2476
  view "settlement_ratio" unit (pair (nat %numerator) (nat %denominator))
2477
        { CDR ; GET 33 } ;
2478
  view "settlement_reward_fee_ratio" unit (pair (nat %numerator) (nat %denominator))
2479
        { CDR ; GET 35 } ;
2480
  view "spread_rate" unit nat { CDR ; GET 37 } ;
2481
  view "target_price_oracle" unit address { CDR ; GET 39 } ;
2482
  view "total_supply" unit nat { CDR ; GET 45 } ;
2483
  view "vault_context" address
2484
        (option (pair (nat %balance) (pair (option %introducer address) (nat %minted))))
2485
        { UNPAIR ;
2486
          SWAP ;
2487
          DUP ;
2488
          DUG 2 ;
2489
          GET 46 ;
2490
          SWAP ;
2491
          DUP ;
2492
          DUG 2 ;
2493
          MEM ;
2494
          IF
2495
            { SWAP ; GET 46 ; SWAP ; GET ; IF_NONE { PUSH int 1053 ; FAILWITH } {} ; SOME }
2496
            { DROP 2 ; NONE (pair nat (pair (option address) nat)) } } }