BCD

Tezos Contract Explorer
Search Networks Deploy
  • Home
  • /
  • Mainnet
  • /
  • Youves v3 Engine Vault (uUSD with SIRS)
operations (16.6K)Storage Code Interact Tokens Fork Views Statistics Details
Latest
​x
629
1276
 
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 1 ;
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 1 ;
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 1 ;
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 1 ;
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 125 ; 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 504 ; FAILWITH } {} ;
466
             COMPARE ;
467
             GT ;
468
             IF
469
               { DIG 8 ;
470
                 DUP 11 ;
471
                 GET 7 ;
472
                 CONTRACT %transfer (pair (address %from)
473
                                          (pair (address %to) (nat %value))) ;
474
                 IF_NONE { PUSH int 19 ; FAILWITH } {} ;
475
                 PUSH mutez 0 ;
476
                 DUP 4 ;
477
                 DUP 6 ;
478
                 SUB ;
479
                 ISNAT ;
480
                 IF_NONE { PUSH int 504 ; FAILWITH } {} ;
481
                 DUP 13 ;
482
                 GET 5 ;
483
                 SELF_ADDRESS ;
484
                 PAIR 3 ;
485
                 TRANSFER_TOKENS ;
486
                 CONS ;
487
                 DUG 8 }
488
               {} ;
489
             DUP ;
490
             PUSH nat 0 ;
491
             COMPARE ;
492
             LT ;
493
             IF
494
               { SWAP ;
495
                 DROP ;
496
                 SWAP ;
497
                 DROP ;
498
                 SWAP ;
499
                 DROP ;
500
                 SWAP ;
501
                 DROP ;
502
                 SWAP ;
503
                 DROP ;
504
                 SWAP ;
505
                 DROP ;
506
                 SWAP ;
507
                 DROP ;
508
                 DIG 2 ;
509
                 DROP ;
510
                 SWAP ;
511
                 DUP 3 ;
512
                 GET 7 ;
513
                 CONTRACT %transfer (pair (address %from)
514
                                          (pair (address %to) (nat %value))) ;
515
                 IF_NONE { PUSH int 19 ; FAILWITH } {} ;
516
                 PUSH mutez 0 ;
517
                 DIG 3 ;
518
                 DUP 5 ;
519
                 GET 27 ;
520
                 SELF_ADDRESS ;
521
                 PAIR 3 ;
522
                 TRANSFER_TOKENS ;
523
                 CONS }
524
               { DROP 8 ; SWAP ; DROP } ;
525
             UNIT ;
526
             PAIR 3 } ;
527
         SWAP ;
528
         LAMBDA
529
           (pair unit
530
                 (pair (list operation)
531
                       (pair timestamp
532
                             (pair (big_map (pair address nat) unit)
533
                                   (pair (pair nat nat)
534
                                         (pair address
535
                                               (pair nat
536
                                                     (pair nat
537
                                                           (pair address
538
                                                                 (pair address
539
                                                                       (pair
540
                                                                         (pair nat nat)
541
                                                                         (pair
542
                                                                           (pair nat nat)
543
                                                                           (pair
544
                                                                             (pair nat
545
                                                                                   nat)
546
                                                                             (pair
547
                                                                               address
548
                                                                               (pair nat
549
                                                                                     (pair
550
                                                                                       address
551
                                                                                       (pair
552
                                                                                         address
553
                                                                                         (pair
554
                                                                                           (pair
555
                                                                                             nat
556
                                                                                             nat)
557
                                                                                           (pair
558
                                                                                             (pair
559
                                                                                               nat
560
                                                                                               nat)
561
                                                                                             (pair
562
                                                                                               (pair
563
                                                                                                 nat
564
                                                                                                 nat)
565
                                                                                               (pair
566
                                                                                                 nat
567
                                                                                                 (pair
568
                                                                                                   address
569
                                                                                                   (pair
570
                                                                                                     address
571
                                                                                                     (pair
572
                                                                                                       nat
573
                                                                                                       (pair
574
                                                                                                         nat
575
                                                                                                         (big_map
576
                                                                                                           address
577
                                                                                                           (pair
578
                                                                                                             nat
579
                                                                                                             (pair
580
                                                                                                               (option address)
581
                                                                                                               nat))))))))))))))))))))))))))))
582
           (pair unit
583
                 (pair (list operation)
584
                       (pair timestamp
585
                             (pair (big_map (pair address nat) unit)
586
                                   (pair (pair nat nat)
587
                                         (pair address
588
                                               (pair nat
589
                                                     (pair nat
590
                                                           (pair address
591
                                                                 (pair address
592
                                                                       (pair
593
                                                                         (pair nat nat)
594
                                                                         (pair
595
                                                                           (pair nat nat)
596
                                                                           (pair
597
                                                                             (pair nat
598
                                                                                   nat)
599
                                                                             (pair
600
                                                                               address
601
                                                                               (pair nat
602
                                                                                     (pair
603
                                                                                       address
604
                                                                                       (pair
605
                                                                                         address
606
                                                                                         (pair
607
                                                                                           (pair
608
                                                                                             nat
609
                                                                                             nat)
610
                                                                                           (pair
611
                                                                                             (pair
612
                                                                                               nat
613
                                                                                               nat)
614
                                                                                             (pair
615
                                                                                               (pair
616
                                                                                                 nat
617
                                                                                                 nat)
618
                                                                                               (pair
619
                                                                                                 nat
620
                                                                                                 (pair
621
                                                                                                   address
622
                                                                                                   (pair
623
                                                                                                     address
624
                                                                                                     (pair
625
                                                                                                       nat
626
                                                                                                       (pair
627
                                                                                                         nat
628
                                                                                                         (big_map
629
                                                                                                           address
630
                                                                                                           (pair
631
                                                                                                             nat
632
                                                                                                             (pair
633
                                                                                                               (option address)
634
                                                                                                               nat))))))))))))))))))))))))))))
635
           { UNPAIR 3 ;
636
             SWAP ;
637
             DUP 3 ;
638
             CAR ;
639
             NOW ;
640
             SUB ;
641
             ISNAT ;
642
             IF_NONE { PUSH int 235 ; FAILWITH } {} ;
643
             DUP ;
644
             PUSH nat 0 ;
645
             COMPARE ;
646
             LT ;
647
             IF
648
               { DIG 2 ;
649
                 DROP ;
650
                 PUSH nat 1000000000000 ;
651
                 DUP 4 ;
652
                 GET 45 ;
653
                 DUP 3 ;
654
                 DUP 6 ;
655
                 GET 25 ;
656
                 MUL ;
657
                 MUL ;
658
                 EDIV ;
659
                 IF_NONE { PUSH int 240 ; FAILWITH } { CAR } ;
660
                 PUSH nat 1000000000000 ;
661
                 DUP 5 ;
662
                 GET 45 ;
663
                 DUP 4 ;
664
                 DUP 7 ;
665
                 GET 37 ;
666
                 MUL ;
667
                 MUL ;
668
                 EDIV ;
669
                 IF_NONE { PUSH int 249 ; FAILWITH } { CAR } ;
670
                 DUP 5 ;
671
                 PUSH nat 1000000000000 ;
672
                 DIG 4 ;
673
                 DIG 6 ;
674
                 DUP ;
675
                 GET 37 ;
676
                 SWAP ;
677
                 DUP ;
678
                 DUG 8 ;
679
                 GET 25 ;
680
                 ADD ;
681
                 MUL ;
682
                 PUSH nat 1000000000000 ;
683
                 ADD ;
684
                 DIG 6 ;
685
                 GET 11 ;
686
                 MUL ;
687
                 EDIV ;
688
                 IF_NONE { PUSH int 264 ; FAILWITH } { CAR } ;
689
                 UPDATE 11 ;
690
                 DUG 3 ;
691
                 DIG 2 ;
692
                 DUP 4 ;
693
                 GET 41 ;
694
                 CONTRACT %mint (pair (address %owner)
695
                                      (pair (nat %token_id) (nat %token_amount))) ;
696
                 IF_NONE { PUSH int 125 ; FAILWITH } {} ;
697
                 PUSH mutez 0 ;
698
                 DUP 5 ;
699
                 DIG 6 ;
700
                 DUP ;
701
                 GET 43 ;
702
                 SWAP ;
703
                 DUP ;
704
                 DUG 8 ;
705
                 GET 29 ;
706
                 PAIR 3 ;
707
                 TRANSFER_TOKENS ;
708
                 CONS ;
709
                 DUP 4 ;
710
                 GET 41 ;
711
                 CONTRACT %mint (pair (address %owner)
712
                                      (pair (nat %token_id) (nat %token_amount))) ;
713
                 IF_NONE { PUSH int 125 ; FAILWITH } {} ;
714
                 PUSH mutez 0 ;
715
                 DUP 4 ;
716
                 DIG 6 ;
717
                 DUP ;
718
                 GET 43 ;
719
                 SWAP ;
720
                 DUP ;
721
                 DUG 8 ;
722
                 GET 27 ;
723
                 PAIR 3 ;
724
                 TRANSFER_TOKENS ;
725
                 CONS ;
726
                 DUG 2 ;
727
                 DIG 3 ;
728
                 DUP ;
729
                 GET 45 ;
730
                 DIG 2 ;
731
                 DIG 3 ;
732
                 ADD ;
733
                 ADD ;
734
                 UPDATE 45 ;
735
                 NOW ;
736
                 UPDATE 1 ;
737
                 SWAP }
738
               { DROP ; SWAP ; DROP } ;
739
             UNIT ;
740
             PAIR 3 } ;
741
         SWAP ;
742
         LAMBDA
743
           (pair (pair address nat)
744
                 (pair (list operation)
745
                       (pair timestamp
746
                             (pair (big_map (pair address nat) unit)
747
                                   (pair (pair nat nat)
748
                                         (pair address
749
                                               (pair nat
750
                                                     (pair nat
751
                                                           (pair address
752
                                                                 (pair address
753
                                                                       (pair
754
                                                                         (pair nat nat)
755
                                                                         (pair
756
                                                                           (pair nat nat)
757
                                                                           (pair
758
                                                                             (pair nat
759
                                                                                   nat)
760
                                                                             (pair
761
                                                                               address
762
                                                                               (pair nat
763
                                                                                     (pair
764
                                                                                       address
765
                                                                                       (pair
766
                                                                                         address
767
                                                                                         (pair
768
                                                                                           (pair
769
                                                                                             nat
770
                                                                                             nat)
771
                                                                                           (pair
772
                                                                                             (pair
773
                                                                                               nat
774
                                                                                               nat)
775
                                                                                             (pair
776
                                                                                               (pair
777
                                                                                                 nat
778
                                                                                                 nat)
779
                                                                                               (pair
780
                                                                                                 nat
781
                                                                                                 (pair
782
                                                                                                   address
783
                                                                                                   (pair
784
                                                                                                     address
785
                                                                                                     (pair
786
                                                                                                       nat
787
                                                                                                       (pair
788
                                                                                                         nat
789
                                                                                                         (big_map
790
                                                                                                           address
791
                                                                                                           (pair
792
                                                                                                             nat
793
                                                                                                             (pair
794
                                                                                                               (option address)
795
                                                                                                               nat))))))))))))))))))))))))))))
796
           (pair unit
797
                 (pair (list operation)
798
                       (pair timestamp
799
                             (pair (big_map (pair address nat) unit)
800
                                   (pair (pair nat nat)
801
                                         (pair address
802
                                               (pair nat
803
                                                     (pair nat
804
                                                           (pair address
805
                                                                 (pair address
806
                                                                       (pair
807
                                                                         (pair nat nat)
808
                                                                         (pair
809
                                                                           (pair nat nat)
810
                                                                           (pair
811
                                                                             (pair nat
812
                                                                                   nat)
813
                                                                             (pair
814
                                                                               address
815
                                                                               (pair nat
816
                                                                                     (pair
817
                                                                                       address
818
                                                                                       (pair
819
                                                                                         address
820
                                                                                         (pair
821
                                                                                           (pair
822
                                                                                             nat
823
                                                                                             nat)
824
                                                                                           (pair
825
                                                                                             (pair
826
                                                                                               nat
827
                                                                                               nat)
828
                                                                                             (pair
829
                                                                                               (pair
830
                                                                                                 nat
831
                                                                                                 nat)
832
                                                                                               (pair
833
                                                                                                 nat
834
                                                                                                 (pair
835
                                                                                                   address
836
                                                                                                   (pair
837
                                                                                                     address
838
                                                                                                     (pair
839
                                                                                                       nat
840
                                                                                                       (pair
841
                                                                                                         nat
842
                                                                                                         (big_map
843
                                                                                                           address
844
                                                                                                           (pair
845
                                                                                                             nat
846
                                                                                                             (pair
847
                                                                                                               (option address)
848
                                                                                                               nat))))))))))))))))))))))))))))
849
           { UNPAIR 3 ;
850
             SWAP ;
851
             DUP 3 ;
852
             GET 13 ;
853
             CONTRACT %update_stake (pair (address %address) (nat %amount)) ;
854
             IF_NONE { PUSH int 296 ; FAILWITH } {} ;
855
             PUSH mutez 0 ;
856
             DIG 3 ;
857
             TRANSFER_TOKENS ;
858
             CONS ;
859
             UNIT ;
860
             PAIR 3 } ;
861
         SWAP ;
862
         LAMBDA
863
           (pair nat
864
                 (pair (list operation)
865
                       (pair timestamp
866
                             (pair (big_map (pair address nat) unit)
867
                                   (pair (pair nat nat)
868
                                         (pair address
869
                                               (pair nat
870
                                                     (pair nat
871
                                                           (pair address
872
                                                                 (pair address
873
                                                                       (pair
874
                                                                         (pair nat nat)
875
                                                                         (pair
876
                                                                           (pair nat nat)
877
                                                                           (pair
878
                                                                             (pair nat
879
                                                                                   nat)
880
                                                                             (pair
881
                                                                               address
882
                                                                               (pair nat
883
                                                                                     (pair
884
                                                                                       address
885
                                                                                       (pair
886
                                                                                         address
887
                                                                                         (pair
888
                                                                                           (pair
889
                                                                                             nat
890
                                                                                             nat)
891
                                                                                           (pair
892
                                                                                             (pair
893
                                                                                               nat
894
                                                                                               nat)
895
                                                                                             (pair
896
                                                                                               (pair
897
                                                                                                 nat
898
                                                                                                 nat)
899
                                                                                               (pair
900
                                                                                                 nat
901
                                                                                                 (pair
902
                                                                                                   address
903
                                                                                                   (pair
904
                                                                                                     address
905
                                                                                                     (pair
906
                                                                                                       nat
907
                                                                                                       (pair
908
                                                                                                         nat
909
                                                                                                         (big_map
910
                                                                                                           address
911
                                                                                                           (pair
912
                                                                                                             nat
913
                                                                                                             (pair
914
                                                                                                               (option address)
915
                                                                                                               nat))))))))))))))))))))))))))))
916
           (pair unit
917
                 (pair (list operation)
918
                       (pair timestamp
919
                             (pair (big_map (pair address nat) unit)
920
                                   (pair (pair nat nat)
921
                                         (pair address
922
                                               (pair nat
923
                                                     (pair nat
924
                                                           (pair address
925
                                                                 (pair address
926
                                                                       (pair
927
                                                                         (pair nat nat)
928
                                                                         (pair
929
                                                                           (pair nat nat)
930
                                                                           (pair
931
                                                                             (pair nat
932
                                                                                   nat)
933
                                                                             (pair
934
                                                                               address
935
                                                                               (pair nat
936
                                                                                     (pair
937
                                                                                       address
938
                                                                                       (pair
939
                                                                                         address
940
                                                                                         (pair
941
                                                                                           (pair
942
                                                                                             nat
943
                                                                                             nat)
944
                                                                                           (pair
945
                                                                                             (pair
946
                                                                                               nat
947
                                                                                               nat)
948
                                                                                             (pair
949
                                                                                               (pair
950
                                                                                                 nat
951
                                                                                                 nat)
952
                                                                                               (pair
953
                                                                                                 nat
954
                                                                                                 (pair
955
                                                                                                   address
956
                                                                                                   (pair
957
                                                                                                     address
958
                                                                                                     (pair
959
                                                                                                       nat
960
                                                                                                       (pair
961
                                                                                                         nat
962
                                                                                                         (big_map
963
                                                                                                           address
964
                                                                                                           (pair
965
                                                                                                             nat
966
                                                                                                             (pair
967
                                                                                                               (option address)
968
                                                                                                               nat))))))))))))))))))))))))))))
969
           { UNPAIR 3 ;
970
             SWAP ;
971
             DUP 3 ;
972
             GET 3 ;
973
             DIG 2 ;
974
             SENDER ;
975
             PAIR ;
976
             MEM ;
977
             IF {} { PUSH int 401 ; FAILWITH } ;
978
             UNIT ;
979
             PAIR 3 } ;
980
         SWAP ;
981
         UNPAIR ;
982
         IF_LEFT
983
           { IF_LEFT
984
               { IF_LEFT
985
                   { IF_LEFT
986
                       { AMOUNT ;
987
                         PUSH mutez 0 ;
988
                         COMPARE ;
989
                         EQ ;
990
                         IF {} { AMOUNT ; FAILWITH } ;
991
                         NIL operation ;
992
                         DUP 6 ;
993
                         UNIT ;
994
                         SWAP ;
995
                         DIG 4 ;
996
                         DIG 3 ;
997
                         DIG 3 ;
998
                         PAIR 3 ;
999
                         EXEC ;
1000
                         UNPAIR 3 ;
1001
                         DIG 7 ;
1002
                         DIG 7 ;
1003
                         DIG 7 ;
1004
                         DIG 7 ;
1005
                         DIG 6 ;
1006
                         DIG 7 ;
1007
                         DIG 7 ;
1008
                         DIG 7 ;
1009
                         PUSH nat 1000001 ;
1010
                         DUP 4 ;
1011
                         COMPARE ;
1012
                         GE ;
1013
                         IF {} { PUSH int 602 ; FAILWITH } ;
1014
                         DUP 4 ;
1015
                         GET 46 ;
1016
                         SENDER ;
1017
                         GET ;
1018
                         IF_NONE { PUSH int 652 ; FAILWITH } {} ;
1019
                         DUP 5 ;
1020
                         GET 11 ;
1021
                         SWAP ;
1022
                         DUP ;
1023
                         DUG 2 ;
1024
                         GET 4 ;
1025
                         MUL ;
1026
                         LAMBDA
1027
                           (pair nat nat)
1028
                           nat
1029
                           { UNPAIR ;
1030
                             PUSH nat 0 ;
1031
                             DUP 3 ;
1032
                             DUP 3 ;
1033
                             EDIV ;
1034
                             IF_NONE { PUSH int 129 ; FAILWITH } { CDR } ;
1035
                             COMPARE ;
1036
                             EQ ;
1037
                             IF
1038
                               { EDIV ; IF_NONE { PUSH int 131 ; FAILWITH } { CAR } }
1039
                               { PUSH nat 1 ;
1040
                                 DUG 2 ;
1041
                                 EDIV ;
1042
                                 IF_NONE { PUSH int 133 ; FAILWITH } { CAR } ;
1043
                                 ADD } } ;
1044
                         DUP ;
1045
                         PUSH nat 1000000000000 ;
1046
                         DIG 3 ;
1047
                         PAIR ;
1048
                         EXEC ;
1049
                         PUSH nat 1000000000000 ;
1050
                         DUP 7 ;
1051
                         DIG 2 ;
1052
                         SUB ;
1053
                         ISNAT ;
1054
                         IF_NONE { PUSH int 668 ; FAILWITH } {} ;
1055
                         MUL ;
1056
                         DUG 2 ;
1057
                         DUP 7 ;
1058
                         GET 11 ;
1059
                         DIG 3 ;
1060
                         PAIR ;
1061
                         EXEC ;
1062
                         UPDATE 4 ;
1063
                         DIG 4 ;
1064
                         DUP ;
1065
                         GET 46 ;
1066
                         DUP 3 ;
1067
                         SOME ;
1068
                         SENDER ;
1069
                         UPDATE ;
1070
                         UPDATE 46 ;
1071
                         DUG 4 ;
1072
                         DIG 2 ;
1073
                         DUP 5 ;
1074
                         GET 41 ;
1075
                         CONTRACT %burn (pair (address %owner)
1076
                                              (pair (nat %token_id) (nat %token_amount))) ;
1077
                         IF_NONE { PUSH int 125 ; FAILWITH } {} ;
1078
                         PUSH mutez 0 ;
1079
                         DUP 6 ;
1080
                         DUP 8 ;
1081
                         GET 43 ;
1082
                         SENDER ;
1083
                         PAIR 3 ;
1084
                         TRANSFER_TOKENS ;
1085
                         CONS ;
1086
                         DUG 2 ;
1087
                         DUP 5 ;
1088
                         DUP 5 ;
1089
                         DIG 6 ;
1090
                         GET 45 ;
1091
                         SUB ;
1092
                         ISNAT ;
1093
                         IF_NONE { PUSH int 683 ; FAILWITH } {} ;
1094
                         UPDATE 45 ;
1095
                         DUG 4 ;
1096
                         DUP 7 ;
1097
                         SWAP ;
1098
                         DUP ;
1099
                         DUG 2 ;
1100
                         GET 4 ;
1101
                         SENDER ;
1102
                         PAIR ;
1103
                         SWAP ;
1104
                         DIG 6 ;
1105
                         DIG 5 ;
1106
                         DIG 3 ;
1107
                         PAIR 3 ;
1108
                         EXEC ;
1109
                         CDR ;
1110
                         UNPAIR ;
1111
                         DIG 8 ;
1112
                         DIG 8 ;
1113
                         DIG 8 ;
1114
                         DIG 8 ;
1115
                         DIG 5 ;
1116
                         DIG 8 ;
1117
                         DIG 6 ;
1118
                         DIG 8 ;
1119
                         DIG 8 ;
1120
                         DUP ;
1121
                         GET 3 ;
1122
                         IF_NONE
1123
                           { DROP 2 ; SWAP ; DROP ; DIG 2 ; DROP ; DIG 2 ; DROP ; DIG 2 ; DROP ; DIG 2 ; DROP }
1124
                           { DROP ;
1125
                             SWAP ;
1126
                             DROP ;
1127
                             DIG 2 ;
1128
                             DROP ;
1129
                             DIG 3 ;
1130
                             DROP ;
1131
                             DIG 4 ;
1132
                             DROP ;
1133
                             DIG 4 ;
1134
                             DROP ;
1135
                             DIG 3 ;
1136
                             DIG 3 ;
1137
                             DUP ;
1138
                             GET 17 ;
1139
                             CDR ;
1140
                             SWAP ;
1141
                             DUP ;
1142
                             DUG 5 ;
1143
                             GET 17 ;
1144
                             CAR ;
1145
                             DUP 4 ;
1146
                             GET 4 ;
1147
                             MUL ;
1148
                             EDIV ;
1149
                             IF_NONE { PUSH int 692 ; FAILWITH } { CAR } ;
1150
                             DIG 2 ;
1151
                             GET 3 ;
1152
                             IF_NONE { PUSH int 604 ; FAILWITH } {} ;
1153
                             PAIR ;
1154
                             SWAP ;
1155
                             DUG 3 ;
1156
                             PAIR 3 ;
1157
                             EXEC ;
1158
                             CDR ;
1159
                             UNPAIR } }
1160
                       { DIG 2 ;
1161
                         DROP ;
1162
                         DIG 2 ;
1163
                         DROP ;
1164
                         DIG 2 ;
1165
                         DROP ;
1166
                         DIG 2 ;
1167
                         DROP ;
1168
                         AMOUNT ;
1169
                         PUSH mutez 0 ;
1170
                         COMPARE ;
1171
                         EQ ;
1172
                         IF {} { AMOUNT ; FAILWITH } ;
1173
                         SWAP ;
1174
                         DUP ;
1175
                         DUG 2 ;
1176
                         GET 46 ;
1177
                         SENDER ;
1178
                         MEM ;
1179
                         IF
1180
                           { DROP }
1181
                           { SWAP ;
1182
                             DUP ;
1183
                             GET 46 ;
1184
                             PUSH nat 0 ;
1185
                             DIG 3 ;
1186
                             PUSH nat 0 ;
1187
                             PAIR 3 ;
1188
                             SOME ;
1189
                             SENDER ;
1190
                             UPDATE ;
1191
                             UPDATE 46 } ;
1192
                         NIL operation } }
1193
                   { IF_LEFT
1194
                       { DIG 2 ;
1195
                         DROP ;
1196
                         DIG 2 ;
1197
                         DROP ;
1198
                         DIG 2 ;
1199
                         DROP ;
1200
                         DIG 2 ;
1201
                         DROP ;
1202
                         AMOUNT ;
1203
                         PUSH mutez 0 ;
1204
                         COMPARE ;
1205
                         EQ ;
1206
                         IF {} { AMOUNT ; FAILWITH } ;
1207
                         DUP ;
1208
                         PUSH nat 0 ;
1209
                         COMPARE ;
1210
                         LT ;
1211
                         IF
1212
                           { NIL operation ;
1213
                             DUP 3 ;
1214
                             GET 7 ;
1215
                             CONTRACT %transfer (pair (address %from)
1216
                                                      (pair (address %to) (nat %value))) ;
1217
                             IF_NONE { PUSH int 19 ; FAILWITH } {} ;
1218
                             PUSH mutez 0 ;
1219
                             DUP 4 ;
1220
                             SELF_ADDRESS ;
1221
                             SENDER ;
1222
                             PAIR 3 ;
1223
                             TRANSFER_TOKENS ;
1224
                             CONS }
1225
                           { NIL operation } ;
1226
                         DIG 2 ;
1227
                         DUP ;
1228
                         GET 46 ;
1229
                         DUP ;
1230
                         SENDER ;
1231
                         DUP ;
1232
                         DUG 2 ;
1233
                         GET ;
1234
                         IF_NONE { PUSH int 149 ; FAILWITH } {} ;
1235
                         DUP ;
1236
                         CAR ;
1237
                         DIG 6 ;
1238
                         ADD ;
1239
                         UPDATE 1 ;
1240
                         SOME ;
1241
                         SWAP ;
1242
                         UPDATE ;
1243
                         UPDATE 46 ;
1244
                         SWAP }
1245
                       { IF_LEFT
1246
                           { AMOUNT ;
1247
                             PUSH mutez 0 ;
1248
                             COMPARE ;
1249
                             EQ ;
1250
                             IF {} { AMOUNT ; FAILWITH } ;
1251
                             NIL operation ;
1252
                             DUP 4 ;
1253
                             PUSH nat 0 ;
1254
                             SWAP ;
1255
                             DIG 4 ;
1256
                             DIG 3 ;
1257
                             DIG 3 ;
1258
                             PAIR 3 ;
1259
                             EXEC ;
1260
                             UNPAIR 3 ;
1261
                             DIG 7 ;
1262
                             DIG 7 ;
1263
                             DIG 7 ;
1264
                             DIG 7 ;
1265
                             DIG 6 ;
1266
                             DIG 7 ;
1267
                             DIG 7 ;
1268
                             DIG 7 ;
1269
                             DUP 3 ;
1270
                             DUP 5 ;
1271
                             GET 46 ;
1272
                             EXEC ;
1273
                             DIG 4 ;
1274
                             SWAP ;
1275
                             DUP ;
1276
                             DUG 2 ;
1277
                             CAR ;
1278
                             UPDATE 46 ;
1279
                             DUG 4 ;
1280
                             DUP ;
1281
                             CDR ;
1282
                             NIL operation ;
1283
                             SWAP ;
1284
                             ITER { CONS } ;
1285
                             ITER { DIG 3 ; SWAP ; CONS ; DUG 2 } ;
1286
                             DROP 2 ;
1287
                             SWAP ;
1288
                             DROP ;
1289
                             DIG 2 ;
1290
                             DROP ;
1291
                             DIG 2 ;
1292
                             DROP ;
1293
                             DIG 2 ;
1294
                             DROP ;
1295
                             DIG 2 ;
1296
                             DROP }
1297
                           { AMOUNT ;
1298
                             PUSH mutez 0 ;
1299
                             COMPARE ;
1300
                             EQ ;
1301
                             IF {} { AMOUNT ; FAILWITH } ;
1302
                             NIL operation ;
1303
                             DUP 6 ;
1304
                             UNIT ;
1305
                             SWAP ;
1306
                             DIG 4 ;
1307
                             DIG 3 ;
1308
                             DIG 3 ;
1309
                             PAIR 3 ;
1310
                             EXEC ;
1311
                             UNPAIR 3 ;
1312
                             DIG 7 ;
1313
                             DIG 7 ;
1314
                             DIG 7 ;
1315
                             DIG 7 ;
1316
                             DIG 6 ;
1317
                             DIG 7 ;
1318
                             DIG 7 ;
1319
                             DIG 7 ;
1320
                             DUP 8 ;
1321
                             DIG 4 ;
1322
                             DUP ;
1323
                             GET 19 ;
1324
                             SWAP ;
1325
                             DUP ;
1326
                             DUG 6 ;
1327
                             GET 5 ;
1328
                             SENDER ;
1329
                             DIG 6 ;
1330
                             DUP ;
1331
                             CDR ;
1332
                             SWAP ;
1333
                             DUP ;
1334
                             DUG 8 ;
1335
                             CAR ;
1336
                             PAIR 5 ;
1337
                             SWAP ;
1338
                             DIG 5 ;
1339
                             DIG 4 ;
1340
                             DIG 3 ;
1341
                             PAIR 3 ;
1342
                             EXEC ;
1343
                             UNPAIR 3 ;
1344
                             DIG 8 ;
1345
                             DIG 8 ;
1346
                             DIG 8 ;
1347
                             DIG 8 ;
1348
                             DIG 6 ;
1349
                             DIG 8 ;
1350
                             DIG 7 ;
1351
                             DIG 8 ;
1352
                             DIG 8 ;
1353
                             DUP 5 ;
1354
                             GET 46 ;
1355
                             DUP 5 ;
1356
                             CAR ;
1357
                             GET ;
1358
                             IF_NONE { PUSH int 725 ; FAILWITH } {} ;
1359
                             DUP 8 ;
1360
                             SWAP ;
1361
                             DUP ;
1362
                             DUG 2 ;
1363
                             GET 4 ;
1364
                             DUP 7 ;
1365
                             CAR ;
1366
                             PAIR ;
1367
                             SWAP ;
1368
                             DIG 7 ;
1369
                             DIG 6 ;
1370
                             DIG 3 ;
1371
                             PAIR 3 ;
1372
                             EXEC ;
1373
                             CDR ;
1374
                             UNPAIR ;
1375
                             DIG 9 ;
1376
                             DIG 9 ;
1377
                             DIG 9 ;
1378
                             DIG 9 ;
1379
                             DIG 5 ;
1380
                             DIG 9 ;
1381
                             DIG 6 ;
1382
                             DIG 9 ;
1383
                             DIG 9 ;
1384
                             DIG 9 ;
1385
                             DUP ;
1386
                             GET 3 ;
1387
                             IF_NONE
1388
                               { DROP 3 ; SWAP ; DROP ; DIG 2 ; DROP ; DIG 2 ; DROP ; DIG 2 ; DROP ; DIG 2 ; DROP }
1389
                               { DROP ;
1390
                                 SWAP ;
1391
                                 DROP ;
1392
                                 SWAP ;
1393
                                 DROP ;
1394
                                 DIG 2 ;
1395
                                 DROP ;
1396
                                 DIG 3 ;
1397
                                 DROP ;
1398
                                 DIG 4 ;
1399
                                 DROP ;
1400
                                 DIG 4 ;
1401
                                 DROP ;
1402
                                 DIG 3 ;
1403
                                 DIG 3 ;
1404
                                 DUP ;
1405
                                 GET 17 ;
1406
                                 CDR ;
1407
                                 SWAP ;
1408
                                 DUP ;
1409
                                 DUG 5 ;
1410
                                 GET 17 ;
1411
                                 CAR ;
1412
                                 DUP 4 ;
1413
                                 GET 4 ;
1414
                                 MUL ;
1415
                                 EDIV ;
1416
                                 IF_NONE { PUSH int 736 ; FAILWITH } { CAR } ;
1417
                                 DIG 2 ;
1418
                                 GET 3 ;
1419
                                 IF_NONE { PUSH int 604 ; FAILWITH } {} ;
1420
                                 PAIR ;
1421
                                 SWAP ;
1422
                                 DUG 3 ;
1423
                                 PAIR 3 ;
1424
                                 EXEC ;
1425
                                 CDR ;
1426
                                 UNPAIR } } } } }
1427
               { IF_LEFT
1428
                   { IF_LEFT
1429
                       { AMOUNT ;
1430
                         PUSH mutez 0 ;
1431
                         COMPARE ;
1432
                         EQ ;
1433
                         IF {} { AMOUNT ; FAILWITH } ;
1434
                         NIL operation ;
1435
                         DUP 6 ;
1436
                         UNIT ;
1437
                         SWAP ;
1438
                         DIG 4 ;
1439
                         DIG 3 ;
1440
                         DIG 3 ;
1441
                         PAIR 3 ;
1442
                         EXEC ;
1443
                         UNPAIR 3 ;
1444
                         DIG 7 ;
1445
                         DIG 7 ;
1446
                         DIG 7 ;
1447
                         DIG 7 ;
1448
                         DIG 6 ;
1449
                         DIG 7 ;
1450
                         DIG 7 ;
1451
                         DIG 7 ;
1452
                         PUSH nat 1000001 ;
1453
                         DUP 4 ;
1454
                         COMPARE ;
1455
                         GE ;
1456
                         IF {} { PUSH int 602 ; FAILWITH } ;
1457
                         DUP 4 ;
1458
                         GET 46 ;
1459
                         SENDER ;
1460
                         GET ;
1461
                         IF_NONE { PUSH int 551 ; FAILWITH } {} ;
1462
                         DUP 5 ;
1463
                         GET 11 ;
1464
                         SWAP ;
1465
                         DUP ;
1466
                         DUG 2 ;
1467
                         GET 4 ;
1468
                         MUL ;
1469
                         LAMBDA
1470
                           (pair nat nat)
1471
                           nat
1472
                           { UNPAIR ;
1473
                             PUSH nat 0 ;
1474
                             DUP 3 ;
1475
                             DUP 3 ;
1476
                             EDIV ;
1477
                             IF_NONE { PUSH int 129 ; FAILWITH } { CDR } ;
1478
                             COMPARE ;
1479
                             EQ ;
1480
                             IF
1481
                               { EDIV ; IF_NONE { PUSH int 131 ; FAILWITH } { CAR } }
1482
                               { PUSH nat 1 ;
1483
                                 DUG 2 ;
1484
                                 EDIV ;
1485
                                 IF_NONE { PUSH int 133 ; FAILWITH } { CAR } ;
1486
                                 ADD } } ;
1487
                         PUSH nat 1000000000000 ;
1488
                         DIG 2 ;
1489
                         PAIR ;
1490
                         EXEC ;
1491
                         PUSH nat 1 ;
1492
                         DUP 7 ;
1493
                         GET 39 ;
1494
                         UNIT ;
1495
                         VIEW "get_price" nat ;
1496
                         IF_NONE { PUSH int 502 ; FAILWITH } {} ;
1497
                         DUP 7 ;
1498
                         DIG 3 ;
1499
                         ADD ;
1500
                         MUL ;
1501
                         EDIV ;
1502
                         IF_NONE { PUSH int 572 ; FAILWITH } { CAR } ;
1503
                         PUSH nat 1 ;
1504
                         DIG 6 ;
1505
                         DUP ;
1506
                         GET 5 ;
1507
                         CDR ;
1508
                         SWAP ;
1509
                         DUP ;
1510
                         DUG 8 ;
1511
                         GET 5 ;
1512
                         CAR ;
1513
                         DIG 3 ;
1514
                         MUL ;
1515
                         EDIV ;
1516
                         IF_NONE { PUSH int 577 ; FAILWITH } { CAR } ;
1517
                         MUL ;
1518
                         PUSH nat 1000000000000 ;
1519
                         PUSH nat 1000000 ;
1520
                         DUP 4 ;
1521
                         CAR ;
1522
                         MUL ;
1523
                         MUL ;
1524
                         COMPARE ;
1525
                         GE ;
1526
                         IF {} { PUSH int 801 ; FAILWITH } ;
1527
                         DUP ;
1528
                         GET 4 ;
1529
                         DUP 6 ;
1530
                         GET 11 ;
1531
                         PUSH nat 1000000000000 ;
1532
                         DUP 7 ;
1533
                         MUL ;
1534
                         EDIV ;
1535
                         IF_NONE { PUSH int 596 ; FAILWITH } { CAR } ;
1536
                         ADD ;
1537
                         UPDATE 4 ;
1538
                         DIG 4 ;
1539
                         DUP ;
1540
                         GET 46 ;
1541
                         DUP 3 ;
1542
                         SOME ;
1543
                         SENDER ;
1544
                         UPDATE ;
1545
                         UPDATE 46 ;
1546
                         DUG 4 ;
1547
                         DIG 2 ;
1548
                         DUP 5 ;
1549
                         GET 41 ;
1550
                         CONTRACT %mint (pair (address %owner)
1551
                                              (pair (nat %token_id) (nat %token_amount))) ;
1552
                         IF_NONE { PUSH int 125 ; FAILWITH } {} ;
1553
                         PUSH mutez 0 ;
1554
                         DIG 6 ;
1555
                         DUP ;
1556
                         GET 21 ;
1557
                         CDR ;
1558
                         SWAP ;
1559
                         DUP ;
1560
                         DUG 8 ;
1561
                         GET 21 ;
1562
                         CAR ;
1563
                         DUP 8 ;
1564
                         MUL ;
1565
                         EDIV ;
1566
                         IF_NONE { PUSH int 590 ; FAILWITH } { CAR } ;
1567
                         DUP 7 ;
1568
                         SUB ;
1569
                         ISNAT ;
1570
                         IF_NONE { PUSH int 594 ; FAILWITH } {} ;
1571
                         DUP 8 ;
1572
                         GET 43 ;
1573
                         SENDER ;
1574
                         PAIR 3 ;
1575
                         TRANSFER_TOKENS ;
1576
                         CONS ;
1577
                         DUP 5 ;
1578
                         GET 41 ;
1579
                         CONTRACT %mint (pair (address %owner)
1580
                                              (pair (nat %token_id) (nat %token_amount))) ;
1581
                         IF_NONE { PUSH int 125 ; FAILWITH } {} ;
1582
                         PUSH mutez 0 ;
1583
                         DIG 6 ;
1584
                         DUP ;
1585
                         GET 21 ;
1586
                         CDR ;
1587
                         SWAP ;
1588
                         DUP ;
1589
                         DUG 8 ;
1590
                         GET 21 ;
1591
                         CAR ;
1592
                         DUP 8 ;
1593
                         MUL ;
1594
                         EDIV ;
1595
                         IF_NONE { PUSH int 590 ; FAILWITH } { CAR } ;
1596
                         DIG 7 ;
1597
                         DUP ;
1598
                         GET 43 ;
1599
                         SWAP ;
1600
                         DUP ;
1601
                         DUG 9 ;
1602
                         GET 27 ;
1603
                         PAIR 3 ;
1604
                         TRANSFER_TOKENS ;
1605
                         CONS ;
1606
                         DUG 2 ;
1607
                         DIG 4 ;
1608
                         DUP ;
1609
                         GET 45 ;
1610
                         DUP 6 ;
1611
                         ADD ;
1612
                         UPDATE 45 ;
1613
                         DUG 4 ;
1614
                         DUP 7 ;
1615
                         SWAP ;
1616
                         DUP ;
1617
                         DUG 2 ;
1618
                         GET 4 ;
1619
                         SENDER ;
1620
                         PAIR ;
1621
                         SWAP ;
1622
                         DIG 6 ;
1623
                         DIG 5 ;
1624
                         DIG 3 ;
1625
                         PAIR 3 ;
1626
                         EXEC ;
1627
                         CDR ;
1628
                         UNPAIR ;
1629
                         DIG 8 ;
1630
                         DIG 8 ;
1631
                         DIG 8 ;
1632
                         DIG 8 ;
1633
                         DIG 5 ;
1634
                         DIG 8 ;
1635
                         DIG 6 ;
1636
                         DIG 8 ;
1637
                         DIG 8 ;
1638
                         DUP ;
1639
                         GET 3 ;
1640
                         IF_NONE
1641
                           { DROP 2 ; SWAP ; DROP ; DIG 2 ; DROP ; DIG 2 ; DROP ; DIG 2 ; DROP ; DIG 2 ; DROP }
1642
                           { DROP ;
1643
                             SWAP ;
1644
                             DROP ;
1645
                             DIG 2 ;
1646
                             DROP ;
1647
                             DIG 3 ;
1648
                             DROP ;
1649
                             DIG 4 ;
1650
                             DROP ;
1651
                             DIG 4 ;
1652
                             DROP ;
1653
                             DIG 3 ;
1654
                             DIG 3 ;
1655
                             DUP ;
1656
                             GET 17 ;
1657
                             CDR ;
1658
                             SWAP ;
1659
                             DUP ;
1660
                             DUG 5 ;
1661
                             GET 17 ;
1662
                             CAR ;
1663
                             DUP 4 ;
1664
                             GET 4 ;
1665
                             MUL ;
1666
                             EDIV ;
1667
                             IF_NONE { PUSH int 621 ; FAILWITH } { CAR } ;
1668
                             DIG 2 ;
1669
                             GET 3 ;
1670
                             IF_NONE { PUSH int 604 ; FAILWITH } {} ;
1671
                             PAIR ;
1672
                             SWAP ;
1673
                             DUG 3 ;
1674
                             PAIR 3 ;
1675
                             EXEC ;
1676
                             CDR ;
1677
                             UNPAIR } }
1678
                       { DIG 3 ;
1679
                         DROP ;
1680
                         DIG 3 ;
1681
                         DROP ;
1682
                         DIG 3 ;
1683
                         DROP ;
1684
                         AMOUNT ;
1685
                         PUSH mutez 0 ;
1686
                         COMPARE ;
1687
                         EQ ;
1688
                         IF {} { AMOUNT ; FAILWITH } ;
1689
                         NIL operation ;
1690
                         DIG 3 ;
1691
                         DUP 3 ;
1692
                         CDR ;
1693
                         SWAP ;
1694
                         DIG 4 ;
1695
                         DIG 3 ;
1696
                         DIG 3 ;
1697
                         PAIR 3 ;
1698
                         EXEC ;
1699
                         CDR ;
1700
                         UNPAIR ;
1701
                         SWAP ;
1702
                         DUP ;
1703
                         GET 3 ;
1704
                         NONE unit ;
1705
                         DIG 4 ;
1706
                         UPDATE ;
1707
                         UPDATE 3 ;
1708
                         SWAP } }
1709
                   { IF_LEFT
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
                         PUSH (option unit) (Some 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
                             PUSH nat 0 ;
1756
                             SWAP ;
1757
                             DIG 4 ;
1758
                             DIG 3 ;
1759
                             DIG 3 ;
1760
                             PAIR 3 ;
1761
                             EXEC ;
1762
                             CDR ;
1763
                             UNPAIR ;
1764
                             SWAP ;
1765
                             DIG 2 ;
1766
                             UPDATE 5 ;
1767
                             SWAP }
1768
                           { DIG 3 ;
1769
                             DROP ;
1770
                             DIG 3 ;
1771
                             DROP ;
1772
                             DIG 3 ;
1773
                             DROP ;
1774
                             AMOUNT ;
1775
                             PUSH mutez 0 ;
1776
                             COMPARE ;
1777
                             EQ ;
1778
                             IF {} { AMOUNT ; FAILWITH } ;
1779
                             NIL operation ;
1780
                             DIG 3 ;
1781
                             PUSH nat 0 ;
1782
                             SWAP ;
1783
                             DIG 4 ;
1784
                             DIG 3 ;
1785
                             DIG 3 ;
1786
                             PAIR 3 ;
1787
                             EXEC ;
1788
                             CDR ;
1789
                             UNPAIR ;
1790
                             SWAP ;
1791
                             DIG 2 ;
1792
                             DUP ;
1793
                             DUG 3 ;
1794
                             GET 6 ;
1795
                             UPDATE 39 ;
1796
                             DUG 2 ;
1797
                             DUG 2 ;
1798
                             DUP ;
1799
                             DUG 3 ;
1800
                             GET 3 ;
1801
                             UPDATE 27 ;
1802
                             DUG 2 ;
1803
                             DUG 2 ;
1804
                             DUP ;
1805
                             DUG 3 ;
1806
                             GET 5 ;
1807
                             UPDATE 29 ;
1808
                             DUG 2 ;
1809
                             DUG 2 ;
1810
                             DUP ;
1811
                             DUG 3 ;
1812
                             CAR ;
1813
                             CAR ;
1814
                             UPDATE 13 ;
1815
                             DUG 2 ;
1816
                             DUG 2 ;
1817
                             DUP ;
1818
                             DUG 3 ;
1819
                             CAR ;
1820
                             GET 4 ;
1821
                             UPDATE 23 ;
1822
                             DUG 2 ;
1823
                             DUG 2 ;
1824
                             CAR ;
1825
                             GET 3 ;
1826
                             UPDATE 15 ;
1827
                             SWAP } } } } }
1828
           { IF_LEFT
1829
               { IF_LEFT
1830
                   { IF_LEFT
1831
                       { DIG 3 ;
1832
                         DROP ;
1833
                         DIG 3 ;
1834
                         DROP ;
1835
                         DIG 3 ;
1836
                         DROP ;
1837
                         AMOUNT ;
1838
                         PUSH mutez 0 ;
1839
                         COMPARE ;
1840
                         EQ ;
1841
                         IF {} { AMOUNT ; FAILWITH } ;
1842
                         NIL operation ;
1843
                         DIG 3 ;
1844
                         PUSH nat 0 ;
1845
                         SWAP ;
1846
                         DIG 4 ;
1847
                         DIG 3 ;
1848
                         DIG 3 ;
1849
                         PAIR 3 ;
1850
                         EXEC ;
1851
                         CDR ;
1852
                         UNPAIR ;
1853
                         SWAP ;
1854
                         DIG 2 ;
1855
                         UPDATE 17 ;
1856
                         SWAP }
1857
                       { DIG 3 ;
1858
                         DROP ;
1859
                         DIG 3 ;
1860
                         DROP ;
1861
                         DIG 3 ;
1862
                         DROP ;
1863
                         AMOUNT ;
1864
                         PUSH mutez 0 ;
1865
                         COMPARE ;
1866
                         EQ ;
1867
                         IF {} { AMOUNT ; FAILWITH } ;
1868
                         NIL operation ;
1869
                         DIG 3 ;
1870
                         PUSH nat 0 ;
1871
                         SWAP ;
1872
                         DIG 4 ;
1873
                         DIG 3 ;
1874
                         DIG 3 ;
1875
                         PAIR 3 ;
1876
                         EXEC ;
1877
                         CDR ;
1878
                         UNPAIR ;
1879
                         SWAP ;
1880
                         DIG 2 ;
1881
                         UPDATE 19 ;
1882
                         SWAP } }
1883
                   { IF_LEFT
1884
                       { DIG 3 ;
1885
                         DROP ;
1886
                         DIG 3 ;
1887
                         DROP ;
1888
                         DIG 3 ;
1889
                         DROP ;
1890
                         AMOUNT ;
1891
                         PUSH mutez 0 ;
1892
                         COMPARE ;
1893
                         EQ ;
1894
                         IF {} { AMOUNT ; FAILWITH } ;
1895
                         NIL operation ;
1896
                         DIG 3 ;
1897
                         PUSH nat 0 ;
1898
                         SWAP ;
1899
                         DIG 4 ;
1900
                         DIG 3 ;
1901
                         DIG 3 ;
1902
                         PAIR 3 ;
1903
                         EXEC ;
1904
                         CDR ;
1905
                         UNPAIR ;
1906
                         SWAP ;
1907
                         DIG 2 ;
1908
                         UPDATE 21 ;
1909
                         SWAP }
1910
                       { IF_LEFT
1911
                           { DIG 2 ;
1912
                             DROP ;
1913
                             DIG 2 ;
1914
                             DROP ;
1915
                             DIG 3 ;
1916
                             DROP ;
1917
                             AMOUNT ;
1918
                             PUSH mutez 0 ;
1919
                             COMPARE ;
1920
                             EQ ;
1921
                             IF {} { AMOUNT ; FAILWITH } ;
1922
                             SWAP ;
1923
                             DUP ;
1924
                             DUG 2 ;
1925
                             GET 15 ;
1926
                             SENDER ;
1927
                             COMPARE ;
1928
                             EQ ;
1929
                             IF {} { PUSH int 401 ; FAILWITH } ;
1930
                             NIL operation ;
1931
                             DIG 3 ;
1932
                             UNIT ;
1933
                             SWAP ;
1934
                             DIG 4 ;
1935
                             DIG 3 ;
1936
                             DIG 3 ;
1937
                             PAIR 3 ;
1938
                             EXEC ;
1939
                             CDR ;
1940
                             UNPAIR ;
1941
                             SWAP ;
1942
                             DIG 2 ;
1943
                             UPDATE 25 ;
1944
                             SWAP }
1945
                           { DIG 3 ;
1946
                             DROP ;
1947
                             DIG 3 ;
1948
                             DROP ;
1949
                             DIG 3 ;
1950
                             DROP ;
1951
                             AMOUNT ;
1952
                             PUSH mutez 0 ;
1953
                             COMPARE ;
1954
                             EQ ;
1955
                             IF {} { AMOUNT ; FAILWITH } ;
1956
                             NIL operation ;
1957
                             DIG 3 ;
1958
                             PUSH nat 0 ;
1959
                             SWAP ;
1960
                             DIG 4 ;
1961
                             DIG 3 ;
1962
                             DIG 3 ;
1963
                             PAIR 3 ;
1964
                             EXEC ;
1965
                             CDR ;
1966
                             UNPAIR ;
1967
                             SWAP ;
1968
                             DIG 2 ;
1969
                             UPDATE 31 ;
1970
                             SWAP } } } }
1971
               { IF_LEFT
1972
                   { IF_LEFT
1973
                       { DIG 3 ;
1974
                         DROP ;
1975
                         DIG 3 ;
1976
                         DROP ;
1977
                         DIG 3 ;
1978
                         DROP ;
1979
                         AMOUNT ;
1980
                         PUSH mutez 0 ;
1981
                         COMPARE ;
1982
                         EQ ;
1983
                         IF {} { AMOUNT ; FAILWITH } ;
1984
                         NIL operation ;
1985
                         DIG 3 ;
1986
                         PUSH nat 0 ;
1987
                         SWAP ;
1988
                         DIG 4 ;
1989
                         DIG 3 ;
1990
                         DIG 3 ;
1991
                         PAIR 3 ;
1992
                         EXEC ;
1993
                         CDR ;
1994
                         UNPAIR ;
1995
                         SWAP ;
1996
                         DIG 2 ;
1997
                         UPDATE 33 ;
1998
                         SWAP }
1999
                       { IF_LEFT
2000
                           { DIG 3 ;
2001
                             DROP ;
2002
                             DIG 3 ;
2003
                             DROP ;
2004
                             DIG 3 ;
2005
                             DROP ;
2006
                             AMOUNT ;
2007
                             PUSH mutez 0 ;
2008
                             COMPARE ;
2009
                             EQ ;
2010
                             IF {} { AMOUNT ; FAILWITH } ;
2011
                             NIL operation ;
2012
                             DIG 3 ;
2013
                             PUSH nat 0 ;
2014
                             SWAP ;
2015
                             DIG 4 ;
2016
                             DIG 3 ;
2017
                             DIG 3 ;
2018
                             PAIR 3 ;
2019
                             EXEC ;
2020
                             CDR ;
2021
                             UNPAIR ;
2022
                             SWAP ;
2023
                             DIG 2 ;
2024
                             UPDATE 35 ;
2025
                             SWAP }
2026
                           { AMOUNT ;
2027
                             PUSH mutez 0 ;
2028
                             COMPARE ;
2029
                             EQ ;
2030
                             IF {} { AMOUNT ; FAILWITH } ;
2031
                             SWAP ;
2032
                             DUP ;
2033
                             DUG 2 ;
2034
                             GET 23 ;
2035
                             SENDER ;
2036
                             COMPARE ;
2037
                             EQ ;
2038
                             IF {} { PUSH int 401 ; FAILWITH } ;
2039
                             NIL operation ;
2040
                             DUP 6 ;
2041
                             UNIT ;
2042
                             SWAP ;
2043
                             DIG 4 ;
2044
                             DIG 3 ;
2045
                             DIG 3 ;
2046
                             PAIR 3 ;
2047
                             EXEC ;
2048
                             UNPAIR 3 ;
2049
                             DIG 7 ;
2050
                             DIG 7 ;
2051
                             DIG 7 ;
2052
                             DIG 7 ;
2053
                             DIG 6 ;
2054
                             DIG 7 ;
2055
                             DIG 7 ;
2056
                             DIG 7 ;
2057
                             DUP 8 ;
2058
                             DIG 4 ;
2059
                             DUP ;
2060
                             GET 31 ;
2061
                             SWAP ;
2062
                             DUP ;
2063
                             DUG 6 ;
2064
                             GET 33 ;
2065
                             DIG 5 ;
2066
                             DUP ;
2067
                             GET 4 ;
2068
                             SWAP ;
2069
                             DUP ;
2070
                             GET 3 ;
2071
                             SWAP ;
2072
                             DUP ;
2073
                             DUG 8 ;
2074
                             CAR ;
2075
                             PAIR 5 ;
2076
                             SWAP ;
2077
                             DIG 5 ;
2078
                             DIG 4 ;
2079
                             DIG 3 ;
2080
                             PAIR 3 ;
2081
                             EXEC ;
2082
                             UNPAIR 3 ;
2083
                             DIG 8 ;
2084
                             DIG 8 ;
2085
                             DIG 8 ;
2086
                             DIG 8 ;
2087
                             DIG 6 ;
2088
                             DIG 8 ;
2089
                             DIG 7 ;
2090
                             DIG 8 ;
2091
                             DIG 8 ;
2092
                             DUP 5 ;
2093
                             GET 46 ;
2094
                             DUP 5 ;
2095
                             CAR ;
2096
                             GET ;
2097
                             IF_NONE { PUSH int 776 ; FAILWITH } {} ;
2098
                             DUP 8 ;
2099
                             SWAP ;
2100
                             DUP ;
2101
                             DUG 2 ;
2102
                             GET 4 ;
2103
                             DUP 7 ;
2104
                             CAR ;
2105
                             PAIR ;
2106
                             SWAP ;
2107
                             DIG 7 ;
2108
                             DIG 6 ;
2109
                             DIG 3 ;
2110
                             PAIR 3 ;
2111
                             EXEC ;
2112
                             CDR ;
2113
                             UNPAIR ;
2114
                             DIG 9 ;
2115
                             DIG 9 ;
2116
                             DIG 9 ;
2117
                             DIG 9 ;
2118
                             DIG 5 ;
2119
                             DIG 9 ;
2120
                             DIG 6 ;
2121
                             DIG 9 ;
2122
                             DIG 9 ;
2123
                             DIG 9 ;
2124
                             DUP ;
2125
                             GET 3 ;
2126
                             IF_NONE
2127
                               { DROP 3 ; SWAP ; DROP ; DIG 2 ; DROP ; DIG 2 ; DROP ; DIG 2 ; DROP ; DIG 2 ; DROP }
2128
                               { DROP ;
2129
                                 SWAP ;
2130
                                 DROP ;
2131
                                 SWAP ;
2132
                                 DROP ;
2133
                                 DIG 2 ;
2134
                                 DROP ;
2135
                                 DIG 3 ;
2136
                                 DROP ;
2137
                                 DIG 4 ;
2138
                                 DROP ;
2139
                                 DIG 4 ;
2140
                                 DROP ;
2141
                                 DIG 3 ;
2142
                                 DIG 3 ;
2143
                                 DUP ;
2144
                                 GET 17 ;
2145
                                 CDR ;
2146
                                 SWAP ;
2147
                                 DUP ;
2148
                                 DUG 5 ;
2149
                                 GET 17 ;
2150
                                 CAR ;
2151
                                 DUP 4 ;
2152
                                 GET 4 ;
2153
                                 MUL ;
2154
                                 EDIV ;
2155
                                 IF_NONE { PUSH int 787 ; FAILWITH } { CAR } ;
2156
                                 DIG 2 ;
2157
                                 GET 3 ;
2158
                                 IF_NONE { PUSH int 604 ; FAILWITH } {} ;
2159
                                 PAIR ;
2160
                                 SWAP ;
2161
                                 DUG 3 ;
2162
                                 PAIR 3 ;
2163
                                 EXEC ;
2164
                                 CDR ;
2165
                                 UNPAIR } } } }
2166
                   { IF_LEFT
2167
                       { AMOUNT ;
2168
                         PUSH mutez 0 ;
2169
                         COMPARE ;
2170
                         EQ ;
2171
                         IF {} { AMOUNT ; FAILWITH } ;
2172
                         NIL operation ;
2173
                         DUP 6 ;
2174
                         UNIT ;
2175
                         SWAP ;
2176
                         DIG 4 ;
2177
                         DIG 3 ;
2178
                         DIG 3 ;
2179
                         PAIR 3 ;
2180
                         EXEC ;
2181
                         UNPAIR 3 ;
2182
                         DIG 7 ;
2183
                         DIG 7 ;
2184
                         DIG 7 ;
2185
                         DIG 7 ;
2186
                         DIG 6 ;
2187
                         DIG 7 ;
2188
                         DIG 7 ;
2189
                         DIG 7 ;
2190
                         DUP 3 ;
2191
                         ITER { DUP 5 ;
2192
                                GET 46 ;
2193
                                SWAP ;
2194
                                DUP ;
2195
                                DUG 2 ;
2196
                                GET ;
2197
                                IF_NONE { PUSH int 875 ; FAILWITH } {} ;
2198
                                DUP 8 ;
2199
                                SWAP ;
2200
                                DUP ;
2201
                                DUG 2 ;
2202
                                GET 4 ;
2203
                                DUP 4 ;
2204
                                PAIR ;
2205
                                SWAP ;
2206
                                DIG 7 ;
2207
                                DIG 6 ;
2208
                                DIG 3 ;
2209
                                PAIR 3 ;
2210
                                EXEC ;
2211
                                CDR ;
2212
                                UNPAIR ;
2213
                                DIG 9 ;
2214
                                DIG 9 ;
2215
                                DIG 9 ;
2216
                                DIG 9 ;
2217
                                DIG 5 ;
2218
                                DIG 9 ;
2219
                                DIG 6 ;
2220
                                DIG 9 ;
2221
                                DIG 9 ;
2222
                                DIG 9 ;
2223
                                DUP ;
2224
                                GET 3 ;
2225
                                IF_NONE
2226
                                  { DROP 2 }
2227
                                  { DROP ;
2228
                                    SWAP ;
2229
                                    DROP ;
2230
                                    DUP 7 ;
2231
                                    DIG 5 ;
2232
                                    DUP ;
2233
                                    GET 17 ;
2234
                                    CDR ;
2235
                                    SWAP ;
2236
                                    DUP ;
2237
                                    DUG 7 ;
2238
                                    GET 17 ;
2239
                                    CAR ;
2240
                                    DUP 4 ;
2241
                                    GET 4 ;
2242
                                    MUL ;
2243
                                    EDIV ;
2244
                                    IF_NONE { PUSH int 885 ; FAILWITH } { CAR } ;
2245
                                    DIG 2 ;
2246
                                    GET 3 ;
2247
                                    IF_NONE { PUSH int 604 ; FAILWITH } {} ;
2248
                                    PAIR ;
2249
                                    SWAP ;
2250
                                    DIG 5 ;
2251
                                    DIG 4 ;
2252
                                    DIG 3 ;
2253
                                    PAIR 3 ;
2254
                                    EXEC ;
2255
                                    CDR ;
2256
                                    UNPAIR ;
2257
                                    DIG 7 ;
2258
                                    DIG 7 ;
2259
                                    DIG 7 ;
2260
                                    DIG 7 ;
2261
                                    DIG 5 ;
2262
                                    DIG 7 ;
2263
                                    DIG 6 ;
2264
                                    DIG 7 } } ;
2265
                         DROP ;
2266
                         SWAP ;
2267
                         DROP ;
2268
                         DIG 2 ;
2269
                         DROP ;
2270
                         DIG 2 ;
2271
                         DROP ;
2272
                         DIG 2 ;
2273
                         DROP ;
2274
                         DIG 2 ;
2275
                         DROP }
2276
                       { IF_LEFT
2277
                           { DROP ;
2278
                             SWAP ;
2279
                             DROP ;
2280
                             SWAP ;
2281
                             DROP ;
2282
                             DIG 2 ;
2283
                             DROP ;
2284
                             AMOUNT ;
2285
                             PUSH mutez 0 ;
2286
                             COMPARE ;
2287
                             EQ ;
2288
                             IF {} { AMOUNT ; FAILWITH } ;
2289
                             NIL operation ;
2290
                             DIG 2 ;
2291
                             UNIT ;
2292
                             SWAP ;
2293
                             DUG 3 ;
2294
                             PAIR 3 ;
2295
                             EXEC ;
2296
                             CDR ;
2297
                             UNPAIR }
2298
                           { AMOUNT ;
2299
                             PUSH mutez 0 ;
2300
                             COMPARE ;
2301
                             EQ ;
2302
                             IF {} { AMOUNT ; FAILWITH } ;
2303
                             NIL operation ;
2304
                             DUP 6 ;
2305
                             UNIT ;
2306
                             SWAP ;
2307
                             DIG 4 ;
2308
                             DIG 3 ;
2309
                             DIG 3 ;
2310
                             PAIR 3 ;
2311
                             EXEC ;
2312
                             CDR ;
2313
                             UNPAIR ;
2314
                             DUG 6 ;
2315
                             DUG 6 ;
2316
                             DUG 6 ;
2317
                             DIG 5 ;
2318
                             DIG 6 ;
2319
                             DIG 6 ;
2320
                             DUP 3 ;
2321
                             GET 46 ;
2322
                             SENDER ;
2323
                             GET ;
2324
                             IF_NONE { PUSH int 811 ; FAILWITH } {} ;
2325
                             PUSH nat 1 ;
2326
                             DIG 4 ;
2327
                             DUP ;
2328
                             GET 5 ;
2329
                             CAR ;
2330
                             SWAP ;
2331
                             DUP ;
2332
                             DUG 6 ;
2333
                             GET 39 ;
2334
                             UNIT ;
2335
                             VIEW "get_price" nat ;
2336
                             IF_NONE { PUSH int 502 ; FAILWITH } {} ;
2337
                             DUP 7 ;
2338
                             GET 11 ;
2339
                             DUP 5 ;
2340
                             GET 4 ;
2341
                             MUL ;
2342
                             MUL ;
2343
                             MUL ;
2344
                             MUL ;
2345
                             DUP 5 ;
2346
                             GET 5 ;
2347
                             CDR ;
2348
                             PUSH nat 1000000000000 ;
2349
                             PUSH nat 1 ;
2350
                             PUSH nat 1000000 ;
2351
                             PUSH nat 1000000000000 ;
2352
                             DUP 9 ;
2353
                             DUP 8 ;
2354
                             CAR ;
2355
                             SUB ;
2356
                             ISNAT ;
2357
                             IF_NONE { PUSH int 813 ; FAILWITH } {} ;
2358
                             MUL ;
2359
                             MUL ;
2360
                             MUL ;
2361
                             MUL ;
2362
                             MUL ;
2363
                             COMPARE ;
2364
                             GE ;
2365
                             IF {} { PUSH int 801 ; FAILWITH } ;
2366
                             DUP ;
2367
                             DUP 4 ;
2368
                             DIG 2 ;
2369
                             CAR ;
2370
                             SUB ;
2371
                             ISNAT ;
2372
                             IF_NONE { PUSH int 813 ; FAILWITH } {} ;
2373
                             UPDATE 1 ;
2374
                             DIG 3 ;
2375
                             DUP ;
2376
                             GET 46 ;
2377
                             DIG 2 ;
2378
                             SOME ;
2379
                             SENDER ;
2380
                             UPDATE ;
2381
                             UPDATE 46 ;
2382
                             DUG 2 ;
2383
                             PUSH nat 0 ;
2384
                             DUP 3 ;
2385
                             COMPARE ;
2386
                             GT ;
2387
                             IF
2388
                               { DIG 3 ;
2389
                                 DROP ;
2390
                                 DIG 3 ;
2391
                                 DROP ;
2392
                                 DIG 3 ;
2393
                                 DROP ;
2394
                                 DIG 3 ;
2395
                                 DROP ;
2396
                                 DUP 3 ;
2397
                                 GET 7 ;
2398
                                 CONTRACT %transfer (pair (address %from)
2399
                                                          (pair (address %to)
2400
                                                                (nat %value))) ;
2401
                                 IF_NONE { PUSH int 19 ; FAILWITH } {} ;
2402
                                 PUSH mutez 0 ;
2403
                                 DIG 3 ;
2404
                                 SENDER ;
2405
                                 SELF_ADDRESS ;
2406
                                 PAIR 3 ;
2407
                                 TRANSFER_TOKENS ;
2408
                                 CONS }
2409
                               { SWAP ; DROP ; DIG 2 ; DROP ; DIG 2 ; DROP ; DIG 2 ; DROP ; DIG 2 ; DROP } } } } } } ;
2410
         NIL operation ;
2411
         SWAP ;
2412
         ITER { CONS } ;
2413
         PAIR } ;
2414
  view "accrual_update_timestamp" unit timestamp { CDR ; CAR } ;
2415
  view "collateral_ratio" unit (pair (nat %numerator) (nat %denominator))
2416
        { CDR ; GET 5 } ;
2417
  view "compound_interest_rate" unit nat { CDR ; GET 11 } ;
2418
  view "governance_token_contract" unit address { CDR ; GET 13 } ;
2419
  view "interest_rate_setter_contract" unit address { CDR ; GET 15 } ;
2420
  view "introducer_ratio" unit (pair (nat %numerator) (nat %denominator))
2421
        { CDR ; GET 17 } ;
2422
  view "is_admin" (pair (address %owner) (nat %token_id)) bool
2423
        { UNPAIR ; SWAP ; GET 3 ; SWAP ; MEM } ;
2424
  view "liquidation_payout_ratio" unit (pair (nat %numerator) (nat %denominator))
2425
        { CDR ; GET 19 } ;
2426
  view "minting_fee_ratio" unit (pair (nat %numerator) (nat %denominator))
2427
        { CDR ; GET 21 } ;
2428
  view "options_contract" unit address { CDR ; GET 23 } ;
2429
  view "reference_interest_rate" unit nat { CDR ; GET 25 } ;
2430
  view "reward_pool_contract" unit address { CDR ; GET 27 } ;
2431
  view "savings_pool_contract" unit address { CDR ; GET 29 } ;
2432
  view "settlement_payout_ratio" unit (pair (nat %numerator) (nat %denominator))
2433
        { CDR ; GET 31 } ;
2434
  view "settlement_ratio" unit (pair (nat %numerator) (nat %denominator))
2435
        { CDR ; GET 33 } ;
2436
  view "settlement_reward_fee_ratio" unit (pair (nat %numerator) (nat %denominator))
2437
        { CDR ; GET 35 } ;
2438
  view "spread_rate" unit nat { CDR ; GET 37 } ;
2439
  view "target_price_oracle" unit address { CDR ; GET 39 } ;
2440
  view "total_supply" unit nat { CDR ; GET 45 } ;
2441
  view "vault_context" address
2442
        (option (pair (nat %balance) (pair (option %introducer address) (nat %minted))))
2443
        { UNPAIR ;
2444
          SWAP ;
2445
          DUP ;
2446
          DUG 2 ;
2447
          GET 46 ;
2448
          SWAP ;
2449
          DUP ;
2450
          DUG 2 ;
2451
          MEM ;
2452
          IF
2453
            { SWAP ; GET 46 ; SWAP ; GET ; IF_NONE { PUSH int 1053 ; FAILWITH } {} ; SOME }
2454
            { DROP 2 ; NONE (pair nat (pair (option address) nat)) } } }