BCD

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