BCD

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