BCD

Tezos Contract Explorer
Search Networks Deploy
  • Home
  • /
  • Ghostnet
  • /
  • $TESTdao
operations (2)Storage Code Interact Tokens Metadata Fork Views Statistics Details
Latest
​x
925
1829
 
1
parameter (or
2
            (or
3
              (or
4
                (or (or (unit %accept_ownership) (unit %default))
5
                    (or
6
                      (pair %propose (address %from) (nat %frozen_token)
7
                                     (bytes %proposal_metadata))
8
                      (pair %transfer_contract_tokens (address %contract_address)
9
                                                      (list %params (pair
10
                                                                     (address %from_)
11
                                                                     (list %txs (pair
12
                                                                                 (address %to_)
13
                                                                                 (nat %token_id)
14
                                                                                 (nat %amount))))))))
15
                (address %transfer_ownership))
16
              (or %custom_entrypoints
17
                (pair %lookup_registry (string %key) (address %callback))
18
                (unit %registryCepDummy)))
19
            (or
20
              (or (or (bytes %drop_proposal) (nat %flush))
21
                  (or (nat %freeze) (nat %unfreeze)))
22
              (or
23
                (or (list %unstake_vote bytes)
24
                    (list %update_delegate (pair (bool %enable) (address %delegate))))
25
                (list %vote (pair
26
                             (pair %argument
27
                               (pair (address %from) (bytes %proposal_key))
28
                               (nat %vote_amount)
29
                               (bool %vote_type))
30
                             (option %permit (pair (key %key) (signature %signature))))))));
31
storage (pair
32
          (pair
33
            (pair
34
              (pair
35
                (pair (address %admin)
36
                      (pair %config
37
                        (pair
38
                          (pair
39
                            (pair (nat %fixed_proposal_fee_in_token)
40
                                  (nat %governance_total_supply))
41
                            (int %max_quorum_change)
42
                            (int %max_quorum_threshold))
43
                          (pair (int %min_quorum_threshold) (nat %period))
44
                          (nat %proposal_expired_level)
45
                          (nat %proposal_flush_level))
46
                        (int %quorum_change)))
47
                (big_map %delegates (pair (address %owner) (address %delegate)) unit)
48
                (pair %extra (map %handler_storage string bytes)
49
                             (big_map %lambdas string
50
                                               (pair
51
                                                 (pair
52
                                                   (lambda %code
53
                                                     (pair
54
                                                       (pair
55
                                                         (map %handler_storage string
56
                                                                               bytes)
57
                                                         (bytes %packed_argument))
58
                                                       (pair %proposal_info
59
                                                         (address %from)
60
                                                         (nat %frozen_token)
61
                                                         (bytes %proposal_metadata)))
62
                                                     (pair
63
                                                       (pair (option %guardian address)
64
                                                             (map %handler_storage
65
                                                               string
66
                                                               bytes))
67
                                                       (list %operations operation)))
68
                                                   (lambda %handler_check
69
                                                     (pair bytes (map string bytes))
70
                                                     unit))
71
                                                 (bool %is_active)))))
72
              (pair
73
                (big_map %freeze_history address
74
                                         (pair
75
                                           (pair (nat %current_stage_num)
76
                                                 (nat %current_unstaked))
77
                                           (nat %past_unstaked)
78
                                           (nat %staked)))
79
                (nat %frozen_token_id))
80
              (nat %frozen_total_supply)
81
              (pair %governance_token (address %address) (nat %token_id)))
82
            (pair (pair (address %guardian) (big_map %metadata string bytes))
83
                  (option %ongoing_proposals_dlist (pair (bytes %first) (bytes %last)
84
                                                        (big_map %map (pair bytes bool)
85
                                                                      bytes)))
86
                  (address %pending_owner))
87
            (pair (nat %permits_counter)
88
                  (big_map %proposals bytes
89
                                      (pair
90
                                        (pair (pair (nat %downvotes) (bytes %metadata))
91
                                              (address %proposer)
92
                                              (nat %proposer_frozen_token))
93
                                        (pair (nat %quorum_threshold) (nat %start_level))
94
                                        (nat %upvotes)
95
                                        (nat %voting_stage_num))))
96
            (pair %quorum_threshold_at_cycle
97
              (pair (nat %last_updated_cycle) (nat %quorum_threshold))
98
              (nat %staked))
99
            (big_map %staked_votes (pair address bytes) nat))
100
          (nat %start_level));
101
code { LAMBDA
102
         (pair string (map string bytes))
103
         nat
104
         { UNPAIR ;
105
           GET ;
106
           IF_NONE
107
             { PUSH string "expected nat value was not found" ; FAILWITH }
108
             { UNPACK nat ;
109
               IF_NONE { PUSH string "decoding of Nat value failed" ; FAILWITH } {} } } ;
110
       PUSH nat 1000000 ;
111
       PUSH bool False ;
112
       NIL operation ;
113
       LAMBDA
114
         bytes
115
         (or
116
           (or
117
             (pair
118
               (pair
119
                 (lambda (pair (pair (map string bytes) bytes) (pair address nat bytes))
120
                         (pair (pair (option address) (map string bytes))
121
                               (list operation)))
122
                 (lambda (pair bytes (map string bytes)) unit))
123
               string)
124
             (pair string bytes))
125
           string)
126
         { UNPACK (or
127
                    (or
128
                      (pair %add_handler
129
                        (pair
130
                          (lambda %code
131
                            (pair
132
                              (pair (map %handler_storage string bytes)
133
                                    (bytes %packed_argument))
134
                              (pair %proposal_info (address %from) (nat %frozen_token)
135
                                                   (bytes %proposal_metadata)))
136
                            (pair
137
                              (pair (option %guardian address)
138
                                    (map %handler_storage string bytes))
139
                              (list %operations operation)))
140
                          (lambda %handler_check (pair bytes (map string bytes)) unit))
141
                        (string %name))
142
                      (pair %execute_handler (string %handler_name)
143
                                             (bytes %packed_argument)))
144
                    (string %remove_handler)) ;
145
           IF_NONE { PUSH nat 111 ; FAILWITH } {} } ;
146
       PUSH string "PROPOSAL_HANDLER_NOT_FOUND" ;
147
       PUSH string "PROPOSAL_HANDLER_EXISTS" ;
148
       LAMBDA string unit { PUSH nat 102 ; PAIR ; FAILWITH } ;
149
       LAMBDA
150
         (pair string (map string bytes)
151
               (big_map string
152
                        (pair
153
                          (pair
154
                            (lambda
155
                              (pair (pair (map string bytes) bytes)
156
                                    (pair address nat bytes))
157
                              (pair (pair (option address) (map string bytes))
158
                                    (list operation)))
159
                            (lambda (pair bytes (map string bytes)) unit))
160
                          bool)))
161
         bool
162
         { UNPAIR ; SWAP ; CDR ; SWAP ; MEM } ;
163
       LAMBDA
164
         (pair (list (pair address (list (pair address nat nat)))) address)
165
         operation
166
         { UNPAIR ;
167
           SWAP ;
168
           CONTRACT %transfer (list (pair (address %from_)
169
                                         (list %txs (pair (address %to_) (nat %token_id)
170
                                                         (nat %amount))))) ;
171
           IF_NONE { PUSH nat 115 ; FAILWITH } {} ;
172
           PUSH mutez 0 ;
173
           DIG 2 ;
174
           TRANSFER_TOKENS } ;
175
       LAMBDA
176
         (pair nat (pair nat nat) nat nat)
177
         (pair (pair nat nat) nat nat)
178
         { UNPAIR ;
179
           DUP 2 ;
180
           CDR ;
181
           CAR ;
182
           SUB ;
183
           ISNAT ;
184
           IF_NONE
185
             { DROP ; PUSH nat 114 ; FAILWITH }
186
             { DUP 2 ; CDR ; CDR ; SWAP ; PAIR ; SWAP ; CAR ; PAIR } } ;
187
       LAMBDA
188
         (pair nat (pair nat nat) nat nat)
189
         (pair (pair nat nat) nat nat)
190
         { UNPAIR ;
191
           DUP ;
192
           DUP 3 ;
193
           CAR ;
194
           CAR ;
195
           COMPARE ;
196
           LT ;
197
           IF
198
             { DUP 2 ; CDR ; CDR ; DUP 3 ; CDR ; CAR ; DIG 3 ; CAR ; CDR ; ADD ; PAIR ; PUSH nat 0 ; DIG 2 ; PAIR ; PAIR }
199
             { DROP } } ;
200
       LAMBDA
201
         (pair bytes
202
               (pair
203
                 (pair
204
                   (pair
205
                     (pair address
206
                           (pair
207
                             (pair (pair (pair nat nat) int int) (pair int nat) nat nat)
208
                             int))
209
                     (big_map (pair address address) unit)
210
                     (pair (map string bytes)
211
                           (big_map string
212
                                    (pair
213
                                      (pair
214
                                        (lambda
215
                                          (pair (pair (map string bytes) bytes)
216
                                                (pair address nat bytes))
217
                                          (pair
218
                                            (pair (option address) (map string bytes))
219
                                            (list operation)))
220
                                        (lambda (pair bytes (map string bytes)) unit))
221
                                      bool))))
222
                   (pair (big_map address (pair (pair nat nat) nat nat)) nat)
223
                   nat
224
                   (pair address nat))
225
                 (pair (pair address (big_map string bytes))
226
                       (option (pair bytes bytes (big_map (pair bytes bool) bytes)))
227
                       address)
228
                 (pair nat
229
                       (big_map bytes
230
                                (pair (pair (pair nat bytes) address nat) (pair nat nat)
231
                                      nat
232
                                      nat)))
233
                 (pair (pair nat nat) nat)
234
                 (big_map (pair address bytes) nat))
235
               nat)
236
         (pair (pair (pair nat bytes) address nat) (pair nat nat) nat nat)
237
         { UNPAIR ; SWAP ; CAR ; CDR ; CDR ; CAR ; CDR ; SWAP ; GET ; IF_NONE { PUSH nat 103 ; FAILWITH } {} } ;
238
       LAMBDA
239
         (pair nat nat)
240
         nat
241
         { UNPAIR ;
242
           LEVEL ;
243
           SUB ;
244
           ISNAT ;
245
           IF_NONE
246
             { DROP ; PUSH nat 300 ; FAILWITH }
247
             { EDIV ; IF_NONE { PUSH string "DIV by 0" ; FAILWITH } {} ; CAR } } ;
248
       DUP 13 ;
249
       INT ;
250
       LAMBDA
251
         (pair
252
           (pair (lambda (pair nat nat) nat)
253
                 (lambda (pair nat (pair nat nat) nat nat) (pair (pair nat nat) nat nat)))
254
           (pair (pair (pair nat nat) address nat)
255
                 (pair
256
                   (pair
257
                     (pair
258
                       (pair address
259
                             (pair
260
                               (pair (pair (pair nat nat) int int) (pair int nat) nat
261
                                     nat)
262
                               int))
263
                       (big_map (pair address address) unit)
264
                       (pair (map string bytes)
265
                             (big_map string
266
                                      (pair
267
                                        (pair
268
                                          (lambda
269
                                            (pair (pair (map string bytes) bytes)
270
                                                  (pair address nat bytes))
271
                                            (pair
272
                                              (pair (option address) (map string bytes))
273
                                              (list operation)))
274
                                          (lambda (pair bytes (map string bytes)) unit))
275
                                        bool))))
276
                     (pair (big_map address (pair (pair nat nat) nat nat)) nat)
277
                     nat
278
                     (pair address nat))
279
                   (pair (pair address (big_map string bytes))
280
                         (option (pair bytes bytes (big_map (pair bytes bool) bytes)))
281
                         address)
282
                   (pair nat
283
                         (big_map bytes
284
                                  (pair (pair (pair nat bytes) address nat)
285
                                        (pair nat nat)
286
                                        nat
287
                                        nat)))
288
                   (pair (pair nat nat) nat)
289
                   (big_map (pair address bytes) nat))
290
                 nat))
291
         (pair
292
           (pair
293
             (pair
294
               (pair
295
                 (pair address
296
                       (pair (pair (pair (pair nat nat) int int) (pair int nat) nat nat)
297
                             int))
298
                 (big_map (pair address address) unit)
299
                 (pair (map string bytes)
300
                       (big_map string
301
                                (pair
302
                                  (pair
303
                                    (lambda
304
                                      (pair (pair (map string bytes) bytes)
305
                                            (pair address nat bytes))
306
                                      (pair (pair (option address) (map string bytes))
307
                                            (list operation)))
308
                                    (lambda (pair bytes (map string bytes)) unit))
309
                                  bool))))
310
               (pair (big_map address (pair (pair nat nat) nat nat)) nat)
311
               nat
312
               (pair address nat))
313
             (pair (pair address (big_map string bytes))
314
                   (option (pair bytes bytes (big_map (pair bytes bool) bytes)))
315
                   address)
316
             (pair nat
317
                   (big_map bytes
318
                            (pair (pair (pair nat bytes) address nat) (pair nat nat) nat
319
                                  nat)))
320
             (pair (pair nat nat) nat)
321
             (big_map (pair address bytes) nat))
322
           nat)
323
         { UNPAIR ;
324
           UNPAIR ;
325
           DIG 2 ;
326
           UNPAIR ;
327
           UNPAIR ;
328
           UNPAIR ;
329
           DIG 2 ;
330
           UNPAIR ;
331
           SWAP ;
332
           DUP 5 ;
333
           CDR ;
334
           PAIR ;
335
           DIG 5 ;
336
           SWAP ;
337
           EXEC ;
338
           DUP 5 ;
339
           CAR ;
340
           CAR ;
341
           CDR ;
342
           CAR ;
343
           CAR ;
344
           DUP 3 ;
345
           GET ;
346
           IF_NONE
347
             { DROP 6 ; PUSH nat 300 ; FAILWITH }
348
             { SWAP ;
349
               PAIR ;
350
               DIG 5 ;
351
               SWAP ;
352
               EXEC ;
353
               DUP 4 ;
354
               DUP 4 ;
355
               ADD ;
356
               DUP 2 ;
357
               CDR ;
358
               CDR ;
359
               SUB ;
360
               ISNAT ;
361
               IF_NONE
362
                 { DIG 2 ; DROP 2 ; PUSH nat 300 ; FAILWITH }
363
                 { DUP 2 ;
364
                   CDR ;
365
                   CAR ;
366
                   PAIR ;
367
                   DUP 2 ;
368
                   CAR ;
369
                   PAIR ;
370
                   DUP ;
371
                   CDR ;
372
                   CDR ;
373
                   DIG 4 ;
374
                   DIG 3 ;
375
                   CDR ;
376
                   CAR ;
377
                   ADD ;
378
                   PAIR ;
379
                   SWAP ;
380
                   CAR ;
381
                   PAIR } ;
382
               DIG 2 ;
383
               DUP 4 ;
384
               CAR ;
385
               CAR ;
386
               CDR ;
387
               CDR ;
388
               CAR ;
389
               SUB ;
390
               ISNAT ;
391
               IF_NONE { PUSH nat 300 ; FAILWITH } {} ;
392
               DUP 4 ;
393
               CDR ;
394
               DUP 5 ;
395
               CAR ;
396
               CDR ;
397
               DUP 6 ;
398
               CAR ;
399
               CAR ;
400
               CDR ;
401
               CDR ;
402
               DUP 7 ;
403
               CAR ;
404
               CAR ;
405
               CDR ;
406
               CAR ;
407
               CDR ;
408
               DUP 8 ;
409
               CAR ;
410
               CAR ;
411
               CDR ;
412
               CAR ;
413
               CAR ;
414
               DIG 6 ;
415
               SOME ;
416
               DIG 7 ;
417
               UPDATE ;
418
               PAIR ;
419
               PAIR ;
420
               DIG 4 ;
421
               CAR ;
422
               CAR ;
423
               CAR ;
424
               PAIR ;
425
               PAIR ;
426
               PAIR ;
427
               DUP ;
428
               CDR ;
429
               DUP 2 ;
430
               CAR ;
431
               CDR ;
432
               DUP 3 ;
433
               CAR ;
434
               CAR ;
435
               CDR ;
436
               CDR ;
437
               CDR ;
438
               DIG 4 ;
439
               PAIR ;
440
               DUP 4 ;
441
               CAR ;
442
               CAR ;
443
               CDR ;
444
               CAR ;
445
               PAIR ;
446
               DIG 3 ;
447
               CAR ;
448
               CAR ;
449
               CAR ;
450
               PAIR ;
451
               PAIR ;
452
               PAIR } } ;
453
       DUP 5 ;
454
       DUP 4 ;
455
       PAIR ;
456
       APPLY ;
457
       LAMBDA
458
         (pair
459
           (pair (lambda (pair nat nat) nat)
460
                 (lambda (pair nat (pair nat nat) nat nat) (pair (pair nat nat) nat nat))
461
                 (lambda (pair nat (pair nat nat) nat nat) (pair (pair nat nat) nat nat)))
462
           (pair (pair nat address) nat
463
                 (pair
464
                   (pair
465
                     (pair
466
                       (pair address
467
                             (pair
468
                               (pair (pair (pair nat nat) int int) (pair int nat) nat
469
                                     nat)
470
                               int))
471
                       (big_map (pair address address) unit)
472
                       (pair (map string bytes)
473
                             (big_map string
474
                                      (pair
475
                                        (pair
476
                                          (lambda
477
                                            (pair (pair (map string bytes) bytes)
478
                                                  (pair address nat bytes))
479
                                            (pair
480
                                              (pair (option address) (map string bytes))
481
                                              (list operation)))
482
                                          (lambda (pair bytes (map string bytes)) unit))
483
                                        bool))))
484
                     (pair (big_map address (pair (pair nat nat) nat nat)) nat)
485
                     nat
486
                     (pair address nat))
487
                   (pair (pair address (big_map string bytes))
488
                         (option (pair bytes bytes (big_map (pair bytes bool) bytes)))
489
                         address)
490
                   (pair nat
491
                         (big_map bytes
492
                                  (pair (pair (pair nat bytes) address nat)
493
                                        (pair nat nat)
494
                                        nat
495
                                        nat)))
496
                   (pair (pair nat nat) nat)
497
                   (big_map (pair address bytes) nat))
498
                 nat))
499
         (pair
500
           (pair
501
             (pair
502
               (pair
503
                 (pair address
504
                       (pair (pair (pair (pair nat nat) int int) (pair int nat) nat nat)
505
                             int))
506
                 (big_map (pair address address) unit)
507
                 (pair (map string bytes)
508
                       (big_map string
509
                                (pair
510
                                  (pair
511
                                    (lambda
512
                                      (pair (pair (map string bytes) bytes)
513
                                            (pair address nat bytes))
514
                                      (pair (pair (option address) (map string bytes))
515
                                            (list operation)))
516
                                    (lambda (pair bytes (map string bytes)) unit))
517
                                  bool))))
518
               (pair (big_map address (pair (pair nat nat) nat nat)) nat)
519
               nat
520
               (pair address nat))
521
             (pair (pair address (big_map string bytes))
522
                   (option (pair bytes bytes (big_map (pair bytes bool) bytes)))
523
                   address)
524
             (pair nat
525
                   (big_map bytes
526
                            (pair (pair (pair nat bytes) address nat) (pair nat nat) nat
527
                                  nat)))
528
             (pair (pair nat nat) nat)
529
             (big_map (pair address bytes) nat))
530
           nat)
531
         { UNPAIR ;
532
           UNPAIR 3 ;
533
           DIG 3 ;
534
           UNPAIR ;
535
           UNPAIR ;
536
           DIG 2 ;
537
           UNPAIR ;
538
           DUP 2 ;
539
           CDR ;
540
           PAIR ;
541
           DIG 4 ;
542
           SWAP ;
543
           EXEC ;
544
           DUP 3 ;
545
           DUP 3 ;
546
           CAR ;
547
           CDR ;
548
           CDR ;
549
           CDR ;
550
           CAR ;
551
           CDR ;
552
           ADD ;
553
           DUP 3 ;
554
           CAR ;
555
           CAR ;
556
           CDR ;
557
           CAR ;
558
           CAR ;
559
           DUP 6 ;
560
           GET ;
561
           IF_NONE
562
             { SWAP ;
563
               DIG 4 ;
564
               DIG 5 ;
565
               DIG 6 ;
566
               DROP 4 ;
567
               PUSH nat 0 ;
568
               DIG 3 ;
569
               COMPARE ;
570
               EQ ;
571
               IF { DUP 2 ; CAR ; CAR ; CDR ; CAR ; CAR } { PUSH nat 114 ; FAILWITH } }
572
             { DIG 2 ;
573
               PAIR ;
574
               DIG 5 ;
575
               SWAP ;
576
               EXEC ;
577
               DUP 4 ;
578
               PAIR ;
579
               DIG 5 ;
580
               SWAP ;
581
               EXEC ;
582
               DIG 3 ;
583
               DUP 2 ;
584
               CDR ;
585
               CDR ;
586
               ADD ;
587
               DUP 2 ;
588
               CDR ;
589
               CAR ;
590
               PAIR ;
591
               SWAP ;
592
               CAR ;
593
               PAIR ;
594
               DUP 3 ;
595
               CAR ;
596
               CAR ;
597
               CDR ;
598
               CAR ;
599
               CAR ;
600
               SWAP ;
601
               SOME ;
602
               DIG 4 ;
603
               UPDATE } ;
604
           DUP 3 ;
605
           CDR ;
606
           DUP 4 ;
607
           CAR ;
608
           CDR ;
609
           DUP 5 ;
610
           CAR ;
611
           CAR ;
612
           CDR ;
613
           CDR ;
614
           DUP 6 ;
615
           CAR ;
616
           CAR ;
617
           CDR ;
618
           CAR ;
619
           CDR ;
620
           DIG 4 ;
621
           PAIR ;
622
           PAIR ;
623
           DUP 5 ;
624
           CAR ;
625
           CAR ;
626
           CAR ;
627
           PAIR ;
628
           PAIR ;
629
           PAIR ;
630
           DUP ;
631
           CDR ;
632
           DUP 2 ;
633
           CAR ;
634
           CDR ;
635
           CDR ;
636
           CDR ;
637
           CDR ;
638
           DIG 3 ;
639
           DIG 4 ;
640
           CAR ;
641
           CDR ;
642
           CDR ;
643
           CDR ;
644
           CAR ;
645
           CAR ;
646
           PAIR ;
647
           PAIR ;
648
           DUP 3 ;
649
           CAR ;
650
           CDR ;
651
           CDR ;
652
           CAR ;
653
           PAIR ;
654
           DUP 3 ;
655
           CAR ;
656
           CDR ;
657
           CAR ;
658
           PAIR ;
659
           DIG 2 ;
660
           CAR ;
661
           CAR ;
662
           PAIR ;
663
           PAIR } ;
664
       DUP 7 ;
665
       DUP 7 ;
666
       DUP 6 ;
667
       PAIR 3 ;
668
       APPLY ;
669
       LAMBDA
670
         (pair
671
           (pair
672
             (lambda
673
               (pair (pair (pair nat nat) address nat)
674
                     (pair
675
                       (pair
676
                         (pair
677
                           (pair address
678
                                 (pair
679
                                   (pair (pair (pair nat nat) int int) (pair int nat)
680
                                         nat
681
                                         nat)
682
                                   int))
683
                           (big_map (pair address address) unit)
684
                           (pair (map string bytes)
685
                                 (big_map string
686
                                          (pair
687
                                            (pair
688
                                              (lambda
689
                                                (pair (pair (map string bytes) bytes)
690
                                                      (pair address nat bytes))
691
                                                (pair
692
                                                  (pair (option address)
693
                                                        (map string bytes))
694
                                                  (list operation)))
695
                                              (lambda (pair bytes (map string bytes))
696
                                                      unit))
697
                                            bool))))
698
                         (pair (big_map address (pair (pair nat nat) nat nat)) nat)
699
                         nat
700
                         (pair address nat))
701
                       (pair (pair address (big_map string bytes))
702
                             (option (pair bytes bytes (big_map (pair bytes bool) bytes)))
703
                             address)
704
                       (pair nat
705
                             (big_map bytes
706
                                      (pair (pair (pair nat bytes) address nat)
707
                                            (pair nat nat)
708
                                            nat
709
                                            nat)))
710
                       (pair (pair nat nat) nat)
711
                       (big_map (pair address bytes) nat))
712
                     nat)
713
               (pair
714
                 (pair
715
                   (pair
716
                     (pair
717
                       (pair address
718
                             (pair
719
                               (pair (pair (pair nat nat) int int) (pair int nat) nat
720
                                     nat)
721
                               int))
722
                       (big_map (pair address address) unit)
723
                       (pair (map string bytes)
724
                             (big_map string
725
                                      (pair
726
                                        (pair
727
                                          (lambda
728
                                            (pair (pair (map string bytes) bytes)
729
                                                  (pair address nat bytes))
730
                                            (pair
731
                                              (pair (option address) (map string bytes))
732
                                              (list operation)))
733
                                          (lambda (pair bytes (map string bytes)) unit))
734
                                        bool))))
735
                     (pair (big_map address (pair (pair nat nat) nat nat)) nat)
736
                     nat
737
                     (pair address nat))
738
                   (pair (pair address (big_map string bytes))
739
                         (option (pair bytes bytes (big_map (pair bytes bool) bytes)))
740
                         address)
741
                   (pair nat
742
                         (big_map bytes
743
                                  (pair (pair (pair nat bytes) address nat)
744
                                        (pair nat nat)
745
                                        nat
746
                                        nat)))
747
                   (pair (pair nat nat) nat)
748
                   (big_map (pair address bytes) nat))
749
                 nat))
750
             (lambda (pair string (map string bytes)) nat))
751
           (pair
752
             (pair
753
               (pair bool (pair (pair nat bytes) address nat) (pair nat nat) nat nat)
754
               nat
755
               nat)
756
             (pair
757
               (pair
758
                 (pair
759
                   (pair address
760
                         (pair
761
                           (pair (pair (pair nat nat) int int) (pair int nat) nat nat)
762
                           int))
763
                   (big_map (pair address address) unit)
764
                   (pair (map string bytes)
765
                         (big_map string
766
                                  (pair
767
                                    (pair
768
                                      (lambda
769
                                        (pair (pair (map string bytes) bytes)
770
                                              (pair address nat bytes))
771
                                        (pair (pair (option address) (map string bytes))
772
                                              (list operation)))
773
                                      (lambda (pair bytes (map string bytes)) unit))
774
                                    bool))))
775
                 (pair (big_map address (pair (pair nat nat) nat nat)) nat)
776
                 nat
777
                 (pair address nat))
778
               (pair (pair address (big_map string bytes))
779
                     (option (pair bytes bytes (big_map (pair bytes bool) bytes)))
780
                     address)
781
               (pair nat
782
                     (big_map bytes
783
                              (pair (pair (pair nat bytes) address nat) (pair nat nat)
784
                                    nat
785
                                    nat)))
786
               (pair (pair nat nat) nat)
787
               (big_map (pair address bytes) nat))
788
             nat))
789
         (pair
790
           (pair
791
             (pair
792
               (pair
793
                 (pair address
794
                       (pair (pair (pair (pair nat nat) int int) (pair int nat) nat nat)
795
                             int))
796
                 (big_map (pair address address) unit)
797
                 (pair (map string bytes)
798
                       (big_map string
799
                                (pair
800
                                  (pair
801
                                    (lambda
802
                                      (pair (pair (map string bytes) bytes)
803
                                            (pair address nat bytes))
804
                                      (pair (pair (option address) (map string bytes))
805
                                            (list operation)))
806
                                    (lambda (pair bytes (map string bytes)) unit))
807
                                  bool))))
808
               (pair (big_map address (pair (pair nat nat) nat nat)) nat)
809
               nat
810
               (pair address nat))
811
             (pair (pair address (big_map string bytes))
812
                   (option (pair bytes bytes (big_map (pair bytes bool) bytes)))
813
                   address)
814
             (pair nat
815
                   (big_map bytes
816
                            (pair (pair (pair nat bytes) address nat) (pair nat nat) nat
817
                                  nat)))
818
             (pair (pair nat nat) nat)
819
             (big_map (pair address bytes) nat))
820
           nat)
821
         { UNPAIR ;
822
           UNPAIR ;
823
           DIG 2 ;
824
           UNPAIR ;
825
           UNPAIR ;
826
           UNPAIR ;
827
           DIG 2 ;
828
           UNPAIR ;
829
           DIG 2 ;
830
           IF
831
             { DIG 5 ; DROP ; PUSH nat 0 ; DIG 2 ; DUP 4 ; CAR ; CDR ; CDR ; ADD }
832
             { DUP 4 ;
833
               CAR ;
834
               CAR ;
835
               CAR ;
836
               CDR ;
837
               CDR ;
838
               DUP ;
839
               CAR ;
840
               PUSH string "slash_scale_value" ;
841
               PAIR ;
842
               DUP 8 ;
843
               SWAP ;
844
               EXEC ;
845
               SWAP ;
846
               CAR ;
847
               PUSH string "slash_division_value" ;
848
               PAIR ;
849
               DIG 7 ;
850
               SWAP ;
851
               EXEC ;
852
               DUP 5 ;
853
               CAR ;
854
               CDR ;
855
               CDR ;
856
               DIG 2 ;
857
               MUL ;
858
               EDIV ;
859
               IF_NONE { PUSH string "DIV by 0" ; FAILWITH } {} ;
860
               CAR ;
861
               DUP 3 ;
862
               DUP 5 ;
863
               CAR ;
864
               CDR ;
865
               CDR ;
866
               ADD ;
867
               DIG 3 ;
868
               DIG 2 ;
869
               ADD ;
870
               DUP ;
871
               DIG 2 ;
872
               SUB ;
873
               ISNAT ;
874
               IF_NONE { PUSH nat 0 } {} } ;
875
           DIG 4 ;
876
           DIG 3 ;
877
           DIG 4 ;
878
           CAR ;
879
           CDR ;
880
           CAR ;
881
           PAIR ;
882
           DIG 3 ;
883
           DIG 3 ;
884
           PAIR ;
885
           PAIR ;
886
           PAIR ;
887
           EXEC } ;
888
       DUP 18 ;
889
       DUP 4 ;
890
       PAIR ;
891
       APPLY ;
892
       DIG 18 ;
893
       UNPAIR ;
894
       IF_LEFT
895
         { DIG 2 ;
896
           DIG 4 ;
897
           DIG 7 ;
898
           DIG 8 ;
899
           DIG 9 ;
900
           DIG 10 ;
901
           DROP 6 ;
902
           IF_LEFT
903
             { IF_LEFT
904
                 { IF_LEFT
905
                     { DIG 2 ;
906
                       DIG 3 ;
907
                       DIG 4 ;
908
                       DIG 5 ;
909
                       DIG 6 ;
910
                       DIG 7 ;
911
                       DIG 8 ;
912
                       DIG 9 ;
913
                       DIG 11 ;
914
                       DIG 12 ;
915
                       DIG 13 ;
916
                       DROP 11 ;
917
                       IF_LEFT
918
                         { DROP ;
919
                           SENDER ;
920
                           DUP 2 ;
921
                           CAR ;
922
                           CDR ;
923
                           CAR ;
924
                           CDR ;
925
                           CDR ;
926
                           COMPARE ;
927
                           EQ ;
928
                           IF
929
                             { DUP ;
930
                               CDR ;
931
                               DUP 2 ;
932
                               CAR ;
933
                               CDR ;
934
                               DUP 3 ;
935
                               CAR ;
936
                               CAR ;
937
                               CDR ;
938
                               DUP 4 ;
939
                               CAR ;
940
                               CAR ;
941
                               CAR ;
942
                               CDR ;
943
                               DIG 4 ;
944
                               CAR ;
945
                               CAR ;
946
                               CAR ;
947
                               CAR ;
948
                               CDR ;
949
                               SENDER ;
950
                               PAIR ;
951
                               PAIR ;
952
                               PAIR ;
953
                               PAIR ;
954
                               PAIR ;
955
                               SWAP ;
956
                               PAIR }
957
                             { DROP 2 ; PUSH nat 101 ; FAILWITH } }
958
                         { DIG 2 ; DROP 2 ; NIL operation ; PAIR } }
959
                     { IF_LEFT
960
                         { DUP 2 ;
961
                           CAR ;
962
                           CAR ;
963
                           CAR ;
964
                           CAR ;
965
                           CDR ;
966
                           DUP 3 ;
967
                           SENDER ;
968
                           DUP 4 ;
969
                           CAR ;
970
                           DIG 2 ;
971
                           CAR ;
972
                           CAR ;
973
                           CAR ;
974
                           CDR ;
975
                           CAR ;
976
                           DUP 3 ;
977
                           DUP 3 ;
978
                           PAIR ;
979
                           MEM ;
980
                           NOT ;
981
                           DUP 2 ;
982
                           DIG 3 ;
983
                           COMPARE ;
984
                           NEQ ;
985
                           AND ;
986
                           IF { DROP ; PUSH nat 120 ; FAILWITH } {} ;
987
                           DUP 4 ;
988
                           CAR ;
989
                           CAR ;
990
                           CAR ;
991
                           CDR ;
992
                           CDR ;
993
                           DUP 4 ;
994
                           GET 4 ;
995
                           SIZE ;
996
                           DUP 2 ;
997
                           CAR ;
998
                           PUSH string "frozen_scale_value" ;
999
                           PAIR ;
1000
                           DUP 19 ;
1001
                           SWAP ;
1002
                           EXEC ;
1003
                           DUP 3 ;
1004
                           CAR ;
1005
                           PUSH string "frozen_extra_value" ;
1006
                           PAIR ;
1007
                           DUP 20 ;
1008
                           SWAP ;
1009
                           EXEC ;
1010
                           DUP 4 ;
1011
                           CAR ;
1012
                           PUSH string "max_proposal_size" ;
1013
                           PAIR ;
1014
                           DIG 20 ;
1015
                           SWAP ;
1016
                           EXEC ;
1017
                           SWAP ;
1018
                           DUP 4 ;
1019
                           DIG 3 ;
1020
                           MUL ;
1021
                           ADD ;
1022
                           DUP 7 ;
1023
                           GET 3 ;
1024
                           COMPARE ;
1025
                           NEQ ;
1026
                           IF
1027
                             { DROP 2 ; PUSH string "WRONG_TOKEN_AMOUNT" ; SOME }
1028
                             { SWAP ;
1029
                               COMPARE ;
1030
                               GE ;
1031
                               IF
1032
                                 { PUSH string "LARGE_PROPOSAL" ; SOME }
1033
                                 { NONE string } } ;
1034
                           IF_NONE {} { PUSH nat 102 ; PAIR ; FAILWITH } ;
1035
                           DUP 4 ;
1036
                           GET 4 ;
1037
                           DIG 13 ;
1038
                           SWAP ;
1039
                           EXEC ;
1040
                           IF_LEFT
1041
                             { IF_LEFT
1042
                                 { DIG 12 ;
1043
                                   DROP ;
1044
                                   CDR ;
1045
                                   PAIR ;
1046
                                   DIG 8 ;
1047
                                   SWAP ;
1048
                                   EXEC ;
1049
                                   IF
1050
                                     { DIG 8 ; DIG 8 ; SWAP ; EXEC ; DROP }
1051
                                     { DIG 7 ; DIG 8 ; DROP 2 } }
1052
                                 { DIG 9 ;
1053
                                   DIG 11 ;
1054
                                   DROP 2 ;
1055
                                   DUP 2 ;
1056
                                   CDR ;
1057
                                   DUP 2 ;
1058
                                   CAR ;
1059
                                   GET ;
1060
                                   IF_NONE
1061
                                     { DROP 2 ; DIG 8 ; DIG 8 ; SWAP ; EXEC ; DROP }
1062
                                     { DUP ;
1063
                                       CDR ;
1064
                                       IF
1065
                                         { DIG 10 ;
1066
                                           DIG 11 ;
1067
                                           DROP 2 ;
1068
                                           DIG 2 ;
1069
                                           CAR ;
1070
                                           DIG 2 ;
1071
                                           CDR ;
1072
                                           PAIR ;
1073
                                           SWAP ;
1074
                                           CAR ;
1075
                                           CDR ;
1076
                                           SWAP ;
1077
                                           EXEC ;
1078
                                           DROP }
1079
                                         { DROP 3 ; DIG 8 ; DIG 8 ; SWAP ; EXEC ; DROP } } } }
1080
                             { DIG 9 ;
1081
                               DIG 11 ;
1082
                               DROP 2 ;
1083
                               SWAP ;
1084
                               CDR ;
1085
                               SWAP ;
1086
                               GET ;
1087
                               IF_NONE { PUSH bool False } { CDR } ;
1088
                               IF
1089
                                 { DIG 7 ; DIG 8 ; DROP 2 }
1090
                                 { DIG 8 ; DIG 8 ; SWAP ; EXEC ; DROP } } ;
1091
                           DUP 2 ;
1092
                           CAR ;
1093
                           CAR ;
1094
                           CAR ;
1095
                           CAR ;
1096
                           DUP 4 ;
1097
                           GET 3 ;
1098
                           ADD ;
1099
                           DUP 3 ;
1100
                           CAR ;
1101
                           CDR ;
1102
                           CAR ;
1103
                           CDR ;
1104
                           DUP 6 ;
1105
                           CDR ;
1106
                           PAIR ;
1107
                           DUP 9 ;
1108
                           SWAP ;
1109
                           EXEC ;
1110
                           PUSH nat 2 ;
1111
                           PUSH nat 1 ;
1112
                           DIG 2 ;
1113
                           ADD ;
1114
                           EDIV ;
1115
                           IF_NONE { PUSH string "DIV by 0" ; FAILWITH } {} ;
1116
                           CAR ;
1117
                           DUP ;
1118
                           DUP 7 ;
1119
                           CAR ;
1120
                           CDR ;
1121
                           CDR ;
1122
                           CDR ;
1123
                           CAR ;
1124
                           CAR ;
1125
                           CAR ;
1126
                           COMPARE ;
1127
                           EQ ;
1128
                           IF
1129
                             { DIG 7 ; DIG 11 ; DROP 3 ; DIG 4 }
1130
                             { DUP 6 ;
1131
                               CAR ;
1132
                               CDR ;
1133
                               CDR ;
1134
                               CDR ;
1135
                               CAR ;
1136
                               CAR ;
1137
                               CAR ;
1138
                               DUP 2 ;
1139
                               COMPARE ;
1140
                               GT ;
1141
                               IF
1142
                                 { DUP 4 ;
1143
                                   CAR ;
1144
                                   CAR ;
1145
                                   CAR ;
1146
                                   CDR ;
1147
                                   DUP 13 ;
1148
                                   DUP 8 ;
1149
                                   CAR ;
1150
                                   CDR ;
1151
                                   CDR ;
1152
                                   CDR ;
1153
                                   CAR ;
1154
                                   CDR ;
1155
                                   MUL ;
1156
                                   EDIV ;
1157
                                   IF_NONE { PUSH string "DIV by 0" ; FAILWITH } {} ;
1158
                                   CAR ;
1159
                                   INT ;
1160
                                   DUP 7 ;
1161
                                   CAR ;
1162
                                   CDR ;
1163
                                   CDR ;
1164
                                   CDR ;
1165
                                   CAR ;
1166
                                   CAR ;
1167
                                   CDR ;
1168
                                   INT ;
1169
                                   DUP ;
1170
                                   DIG 2 ;
1171
                                   SUB ;
1172
                                   DUP 6 ;
1173
                                   CDR ;
1174
                                   DUP 11 ;
1175
                                   DUG 2 ;
1176
                                   MUL ;
1177
                                   EDIV ;
1178
                                   IF_NONE { PUSH string "DIV by 0" ; FAILWITH } {} ;
1179
                                   CAR ;
1180
                                   DUP 2 ;
1181
                                   ADD ;
1182
                                   DIG 13 ;
1183
                                   DUP 7 ;
1184
                                   CAR ;
1185
                                   CAR ;
1186
                                   CDR ;
1187
                                   CAR ;
1188
                                   ADD ;
1189
                                   DUP ;
1190
                                   DUP 12 ;
1191
                                   DUP 5 ;
1192
                                   MUL ;
1193
                                   EDIV ;
1194
                                   IF_NONE { PUSH string "DIV by 0" ; FAILWITH } {} ;
1195
                                   CAR ;
1196
                                   DIG 11 ;
1197
                                   DIG 2 ;
1198
                                   DIG 4 ;
1199
                                   MUL ;
1200
                                   EDIV ;
1201
                                   IF_NONE { PUSH string "DIV by 0" ; FAILWITH } {} ;
1202
                                   CAR ;
1203
                                   DUP 9 ;
1204
                                   CDR ;
1205
                                   DUP 10 ;
1206
                                   CAR ;
1207
                                   CDR ;
1208
                                   CDR ;
1209
                                   CDR ;
1210
                                   CDR ;
1211
                                   PUSH nat 0 ;
1212
                                   DUP 10 ;
1213
                                   CAR ;
1214
                                   CAR ;
1215
                                   CDR ;
1216
                                   CDR ;
1217
                                   DUP 11 ;
1218
                                   CAR ;
1219
                                   CDR ;
1220
                                   CAR ;
1221
                                   CAR ;
1222
                                   DUP 6 ;
1223
                                   DUP 9 ;
1224
                                   COMPARE ;
1225
                                   GT ;
1226
                                   IF
1227
                                     { DIG 6 ; DIG 7 ; DROP 2 }
1228
                                     { DIG 5 ;
1229
                                       DROP ;
1230
                                       DUP 6 ;
1231
                                       DUP 8 ;
1232
                                       COMPARE ;
1233
                                       LT ;
1234
                                       IF { DIG 6 ; DROP } { DIG 5 ; DROP } } ;
1235
                                   DIG 5 ;
1236
                                   DUP 3 ;
1237
                                   DUP 2 ;
1238
                                   COMPARE ;
1239
                                   GT ;
1240
                                   IF
1241
                                     { DROP 2 }
1242
                                     { DIG 2 ;
1243
                                       DROP ;
1244
                                       DUP 2 ;
1245
                                       DUP 2 ;
1246
                                       COMPARE ;
1247
                                       LT ;
1248
                                       IF { DROP } { SWAP ; DROP } } ;
1249
                                   ISNAT ;
1250
                                   IF_NONE { PUSH nat 300 ; FAILWITH } {} ;
1251
                                   DIG 4 ;
1252
                                   PAIR ;
1253
                                   PAIR ;
1254
                                   PAIR ;
1255
                                   DUP 7 ;
1256
                                   CAR ;
1257
                                   CDR ;
1258
                                   CDR ;
1259
                                   CAR ;
1260
                                   PAIR ;
1261
                                   DUP 7 ;
1262
                                   CAR ;
1263
                                   CDR ;
1264
                                   CAR ;
1265
                                   PAIR ;
1266
                                   DIG 6 ;
1267
                                   CAR ;
1268
                                   CAR ;
1269
                                   PAIR ;
1270
                                   PAIR }
1271
                                 { DIG 7 ; DIG 11 ; DROP 3 ; DIG 4 } } ;
1272
                           DUP 4 ;
1273
                           CAR ;
1274
                           CDR ;
1275
                           CAR ;
1276
                           CDR ;
1277
                           PAIR ;
1278
                           DUG 2 ;
1279
                           PAIR ;
1280
                           PAIR ;
1281
                           DIG 3 ;
1282
                           SWAP ;
1283
                           EXEC ;
1284
                           DUP 3 ;
1285
                           PACK ;
1286
                           BLAKE2B ;
1287
                           DUP 2 ;
1288
                           CAR ;
1289
                           CDR ;
1290
                           CDR ;
1291
                           CAR ;
1292
                           CDR ;
1293
                           DUP 2 ;
1294
                           MEM ;
1295
                           IF { DROP ; PUSH nat 108 ; FAILWITH } {} ;
1296
                           DIG 2 ;
1297
                           CAR ;
1298
                           CDR ;
1299
                           CAR ;
1300
                           CDR ;
1301
                           DUP 3 ;
1302
                           CDR ;
1303
                           PAIR ;
1304
                           DIG 4 ;
1305
                           SWAP ;
1306
                           EXEC ;
1307
                           PUSH nat 1 ;
1308
                           PUSH nat 2 ;
1309
                           DUP 3 ;
1310
                           EDIV ;
1311
                           IF_NONE { PUSH string "MOD by 0" ; FAILWITH } {} ;
1312
                           CDR ;
1313
                           COMPARE ;
1314
                           EQ ;
1315
                           IF { DIG 2 } { DIG 2 ; DROP ; PUSH nat 113 ; FAILWITH } ;
1316
                           PUSH nat 1 ;
1317
                           DIG 2 ;
1318
                           ADD ;
1319
                           PUSH nat 0 ;
1320
                           PAIR ;
1321
                           LEVEL ;
1322
                           DUP 3 ;
1323
                           CAR ;
1324
                           CDR ;
1325
                           CDR ;
1326
                           CDR ;
1327
                           CAR ;
1328
                           CAR ;
1329
                           CDR ;
1330
                           PAIR ;
1331
                           PAIR ;
1332
                           DUP 4 ;
1333
                           GET 3 ;
1334
                           DUP 5 ;
1335
                           CAR ;
1336
                           PAIR ;
1337
                           DIG 4 ;
1338
                           GET 4 ;
1339
                           PUSH nat 0 ;
1340
                           PAIR ;
1341
                           PAIR ;
1342
                           PAIR ;
1343
                           DUP 2 ;
1344
                           CDR ;
1345
                           DUP 3 ;
1346
                           CAR ;
1347
                           CDR ;
1348
                           CDR ;
1349
                           CDR ;
1350
                           DUP 4 ;
1351
                           CAR ;
1352
                           CDR ;
1353
                           CDR ;
1354
                           CAR ;
1355
                           CDR ;
1356
                           DIG 3 ;
1357
                           DUP 6 ;
1358
                           SWAP ;
1359
                           SOME ;
1360
                           SWAP ;
1361
                           UPDATE ;
1362
                           DUP 4 ;
1363
                           CAR ;
1364
                           CDR ;
1365
                           CDR ;
1366
                           CAR ;
1367
                           CAR ;
1368
                           PAIR ;
1369
                           PAIR ;
1370
                           DUP 3 ;
1371
                           CAR ;
1372
                           CDR ;
1373
                           CAR ;
1374
                           PAIR ;
1375
                           DUP 3 ;
1376
                           CAR ;
1377
                           CAR ;
1378
                           PAIR ;
1379
                           PAIR ;
1380
                           DUP ;
1381
                           CDR ;
1382
                           DUP 2 ;
1383
                           CAR ;
1384
                           CDR ;
1385
                           CDR ;
1386
                           DUP 3 ;
1387
                           CAR ;
1388
                           CDR ;
1389
                           CAR ;
1390
                           CDR ;
1391
                           CDR ;
1392
                           DIG 4 ;
1393
                           CAR ;
1394
                           CDR ;
1395
                           CAR ;
1396
                           CDR ;
1397
                           CAR ;
1398
                           IF_NONE
1399
                             { DIG 6 ;
1400
                               DROP ;
1401
                               EMPTY_BIG_MAP (pair bytes bool) bytes ;
1402
                               DUP 6 ;
1403
                               DIG 6 ;
1404
                               PAIR 3 }
1405
                             { DUP ;
1406
                               DUP 7 ;
1407
                               UPDATE 3 ;
1408
                               DUP 2 ;
1409
                               GET 4 ;
1410
                               DUP 3 ;
1411
                               GET 3 ;
1412
                               DIG 10 ;
1413
                               DUP 10 ;
1414
                               PAIR ;
1415
                               SWAP ;
1416
                               SOME ;
1417
                               SWAP ;
1418
                               UPDATE ;
1419
                               DIG 7 ;
1420
                               PUSH bool True ;
1421
                               DIG 4 ;
1422
                               GET 3 ;
1423
                               PAIR ;
1424
                               SWAP ;
1425
                               SOME ;
1426
                               SWAP ;
1427
                               UPDATE ;
1428
                               UPDATE 4 } ;
1429
                           SOME ;
1430
                           PAIR ;
1431
                           DUP 4 ;
1432
                           CAR ;
1433
                           CDR ;
1434
                           CAR ;
1435
                           CAR ;
1436
                           PAIR ;
1437
                           PAIR ;
1438
                           DIG 2 ;
1439
                           CAR ;
1440
                           CAR ;
1441
                           PAIR ;
1442
                           PAIR ;
1443
                           SWAP }
1444
                         { DIG 2 ;
1445
                           DIG 3 ;
1446
                           DIG 4 ;
1447
                           DIG 5 ;
1448
                           DIG 6 ;
1449
                           DIG 7 ;
1450
                           DIG 8 ;
1451
                           DIG 9 ;
1452
                           DIG 10 ;
1453
                           DIG 11 ;
1454
                           DIG 12 ;
1455
                           DIG 13 ;
1456
                           DROP 12 ;
1457
                           DUP 2 ;
1458
                           CAR ;
1459
                           CAR ;
1460
                           CAR ;
1461
                           CAR ;
1462
                           CAR ;
1463
                           SENDER ;
1464
                           COMPARE ;
1465
                           EQ ;
1466
                           IF { SWAP } { SWAP ; DROP ; PUSH nat 100 ; FAILWITH } ;
1467
                           DUP 2 ;
1468
                           CAR ;
1469
                           CONTRACT %transfer (list (pair (address %from_)
1470
                                                         (list %txs (pair (address %to_)
1471
                                                                         (nat %token_id)
1472
                                                                         (nat %amount))))) ;
1473
                           IF_NONE { PUSH nat 115 ; FAILWITH } {} ;
1474
                           PUSH mutez 0 ;
1475
                           DIG 3 ;
1476
                           CDR ;
1477
                           TRANSFER_TOKENS ;
1478
                           SWAP ;
1479
                           NIL operation ;
1480
                           DIG 2 ;
1481
                           CONS } ;
1482
                       PAIR } }
1483
                 { DIG 2 ;
1484
                   DIG 3 ;
1485
                   DIG 4 ;
1486
                   DIG 5 ;
1487
                   DIG 6 ;
1488
                   DIG 7 ;
1489
                   DIG 8 ;
1490
                   DIG 9 ;
1491
                   DIG 11 ;
1492
                   DIG 12 ;
1493
                   DIG 13 ;
1494
                   DROP 11 ;
1495
                   DUP 2 ;
1496
                   CAR ;
1497
                   CAR ;
1498
                   CAR ;
1499
                   CAR ;
1500
                   CAR ;
1501
                   SENDER ;
1502
                   COMPARE ;
1503
                   EQ ;
1504
                   IF { SWAP } { SWAP ; DROP ; PUSH nat 100 ; FAILWITH } ;
1505
                   DUP 2 ;
1506
                   SELF_ADDRESS ;
1507
                   COMPARE ;
1508
                   EQ ;
1509
                   IF
1510
                     { DUP ;
1511
                       CDR ;
1512
                       DUP 2 ;
1513
                       CAR ;
1514
                       CDR ;
1515
                       DUP 3 ;
1516
                       CAR ;
1517
                       CAR ;
1518
                       CDR ;
1519
                       DUP 4 ;
1520
                       CAR ;
1521
                       CAR ;
1522
                       CAR ;
1523
                       CDR ;
1524
                       DIG 4 ;
1525
                       CAR ;
1526
                       CAR ;
1527
                       CAR ;
1528
                       CAR ;
1529
                       CDR ;
1530
                       DIG 5 ;
1531
                       PAIR ;
1532
                       PAIR ;
1533
                       PAIR }
1534
                     { DUP ;
1535
                       CDR ;
1536
                       DUP 2 ;
1537
                       CAR ;
1538
                       CDR ;
1539
                       CDR ;
1540
                       DIG 3 ;
1541
                       DUP 4 ;
1542
                       CAR ;
1543
                       CDR ;
1544
                       CAR ;
1545
                       CDR ;
1546
                       CAR ;
1547
                       PAIR ;
1548
                       DUP 4 ;
1549
                       CAR ;
1550
                       CDR ;
1551
                       CAR ;
1552
                       CAR ;
1553
                       PAIR ;
1554
                       PAIR ;
1555
                       DIG 2 ;
1556
                       CAR ;
1557
                       CAR } ;
1558
                   PAIR ;
1559
                   PAIR ;
1560
                   SWAP ;
1561
                   PAIR } }
1562
             { DIG 2 ;
1563
               DIG 3 ;
1564
               DIG 4 ;
1565
               DIG 5 ;
1566
               DIG 6 ;
1567
               DIG 7 ;
1568
               DIG 8 ;
1569
               DIG 9 ;
1570
               DIG 11 ;
1571
               DIG 12 ;
1572
               DIG 13 ;
1573
               DROP 11 ;
1574
               IF_LEFT
1575
                 { DUP ;
1576
                   CDR ;
1577
                   CONTRACT (pair string (option string)) ;
1578
                   IF_NONE { PUSH nat 116 ; FAILWITH } {} ;
1579
                   DUP 3 ;
1580
                   CAR ;
1581
                   CAR ;
1582
                   CAR ;
1583
                   CDR ;
1584
                   CDR ;
1585
                   CAR ;
1586
                   PUSH string "registry" ;
1587
                   GET ;
1588
                   IF_NONE
1589
                     { PUSH string "registry not found" ; FAILWITH }
1590
                     { UNPACK (map string string) ;
1591
                       IF_NONE
1592
                         { PUSH string "registry decoding failed" ; FAILWITH }
1593
                         {} } ;
1594
                   SWAP ;
1595
                   PUSH mutez 0 ;
1596
                   DIG 2 ;
1597
                   DUP 4 ;
1598
                   CAR ;
1599
                   GET ;
1600
                   DIG 3 ;
1601
                   CAR ;
1602
                   PAIR ;
1603
                   TRANSFER_TOKENS ;
1604
                   SWAP ;
1605
                   DUG 2 ;
1606
                   CONS }
1607
                 { DIG 2 ; DROP 2 ; NIL operation } ;
1608
               PAIR } }
1609
         { DIG 5 ;
1610
           DIG 12 ;
1611
           DIG 14 ;
1612
           DIG 19 ;
1613
           DROP 4 ;
1614
           PUSH mutez 0 ;
1615
           AMOUNT ;
1616
           COMPARE ;
1617
           GT ;
1618
           IF
1619
             { DROP 16 ; PUSH nat 107 ; FAILWITH }
1620
             { IF_LEFT
1621
                 { DIG 3 ;
1622
                   DIG 4 ;
1623
                   DROP 2 ;
1624
                   IF_LEFT
1625
                     { DIG 3 ;
1626
                       DIG 5 ;
1627
                       DIG 6 ;
1628
                       DIG 7 ;
1629
                       DROP 4 ;
1630
                       IF_LEFT
1631
                         { DIG 4 ;
1632
                           DIG 5 ;
1633
                           DIG 6 ;
1634
                           DIG 9 ;
1635
                           DROP 4 ;
1636
                           DUP 2 ;
1637
                           DUP 2 ;
1638
                           PAIR ;
1639
                           DIG 4 ;
1640
                           SWAP ;
1641
                           EXEC ;
1642
                           DUP 3 ;
1643
                           CAR ;
1644
                           CDR ;
1645
                           CAR ;
1646
                           CDR ;
1647
                           CAR ;
1648
                           IF_NONE
1649
                             { PUSH bool False }
1650
                             { DUP ;
1651
                               CAR ;
1652
                               DUP 4 ;
1653
                               COMPARE ;
1654
                               EQ ;
1655
                               IF
1656
                                 { DROP ; PUSH bool True }
1657
                                 { GET 4 ; DUP 7 ; DUP 4 ; PAIR ; MEM } } ;
1658
                           IF {} { DROP ; PUSH nat 103 ; FAILWITH } ;
1659
                           DUP 3 ;
1660
                           CAR ;
1661
                           CAR ;
1662
                           CAR ;
1663
                           CAR ;
1664
                           CDR ;
1665
                           CAR ;
1666
                           CDR ;
1667
                           CDR ;
1668
                           CAR ;
1669
                           DUP 2 ;
1670
                           CDR ;
1671
                           CAR ;
1672
                           CDR ;
1673
                           ADD ;
1674
                           LEVEL ;
1675
                           COMPARE ;
1676
                           GE ;
1677
                           SOURCE ;
1678
                           SENDER ;
1679
                           COMPARE ;
1680
                           NEQ ;
1681
                           DUP 5 ;
1682
                           CAR ;
1683
                           CDR ;
1684
                           CAR ;
1685
                           CAR ;
1686
                           CAR ;
1687
                           SENDER ;
1688
                           COMPARE ;
1689
                           EQ ;
1690
                           AND ;
1691
                           DUP 3 ;
1692
                           CAR ;
1693
                           CDR ;
1694
                           CAR ;
1695
                           SENDER ;
1696
                           COMPARE ;
1697
                           EQ ;
1698
                           OR ;
1699
                           OR ;
1700
                           IF
1701
                             { DUP 3 ;
1702
                               DUP 4 ;
1703
                               CAR ;
1704
                               CAR ;
1705
                               CAR ;
1706
                               CAR ;
1707
                               CDR ;
1708
                               CAR ;
1709
                               CAR ;
1710
                               CAR ;
1711
                               CAR ;
1712
                               DIG 4 ;
1713
                               CAR ;
1714
                               CAR ;
1715
                               CAR ;
1716
                               CAR ;
1717
                               CDR ;
1718
                               CAR ;
1719
                               CDR ;
1720
                               CAR ;
1721
                               CDR ;
1722
                               PAIR ;
1723
                               DIG 2 ;
1724
                               PUSH bool False ;
1725
                               PAIR ;
1726
                               PAIR ;
1727
                               PAIR ;
1728
                               DIG 2 ;
1729
                               SWAP ;
1730
                               EXEC ;
1731
                               DUP ;
1732
                               CDR ;
1733
                               DUP 2 ;
1734
                               CAR ;
1735
                               CDR ;
1736
                               CDR ;
1737
                               DUP 3 ;
1738
                               CAR ;
1739
                               CDR ;
1740
                               CAR ;
1741
                               CDR ;
1742
                               CDR ;
1743
                               DUP 4 ;
1744
                               CAR ;
1745
                               CDR ;
1746
                               CAR ;
1747
                               CDR ;
1748
                               CAR ;
1749
                               DUP ;
1750
                               IF_NONE
1751
                                 { DIG 5 ; DIG 7 ; DROP 2 }
1752
                                 { SWAP ;
1753
                                   DROP ;
1754
                                   DUP ;
1755
                                   GET 3 ;
1756
                                   DUP 2 ;
1757
                                   CAR ;
1758
                                   COMPARE ;
1759
                                   EQ ;
1760
                                   IF
1761
                                     { DIG 7 ;
1762
                                       DROP ;
1763
                                       DUP ;
1764
                                       CAR ;
1765
                                       DIG 6 ;
1766
                                       COMPARE ;
1767
                                       EQ ;
1768
                                       IF
1769
                                         { DROP ;
1770
                                           NONE (pair bytes bytes
1771
                                                      (big_map (pair bytes bool) bytes)) }
1772
                                         { SOME } }
1773
                                     { DUP ;
1774
                                       GET 4 ;
1775
                                       DUP 9 ;
1776
                                       DUP 8 ;
1777
                                       PAIR ;
1778
                                       GET ;
1779
                                       DUP 2 ;
1780
                                       GET 4 ;
1781
                                       PUSH bool True ;
1782
                                       DUP 9 ;
1783
                                       PAIR ;
1784
                                       GET ;
1785
                                       DUP 3 ;
1786
                                       GET 4 ;
1787
                                       PUSH bool True ;
1788
                                       DUP 10 ;
1789
                                       PAIR ;
1790
                                       NONE bytes ;
1791
                                       SWAP ;
1792
                                       UPDATE ;
1793
                                       DUP 11 ;
1794
                                       DUP 10 ;
1795
                                       PAIR ;
1796
                                       NONE bytes ;
1797
                                       SWAP ;
1798
                                       UPDATE ;
1799
                                       DUP 3 ;
1800
                                       IF_NONE
1801
                                         { DUP 4 ; GET 3 }
1802
                                         { SWAP ;
1803
                                           DUP 3 ;
1804
                                           PUSH bool True ;
1805
                                           DUP 4 ;
1806
                                           PAIR ;
1807
                                           UPDATE ;
1808
                                           DUP 10 ;
1809
                                           DUP 6 ;
1810
                                           GET 3 ;
1811
                                           COMPARE ;
1812
                                           EQ ;
1813
                                           IF { SWAP } { SWAP ; DROP ; DUP 4 ; GET 3 } } ;
1814
                                       DIG 2 ;
1815
                                       IF_NONE
1816
                                         { DIG 2 ; DIG 8 ; DIG 10 ; DROP 3 ; SWAP ; DIG 2 ; CAR }
1817
                                         { DIG 2 ;
1818
                                           DIG 3 ;
1819
                                           DIG 11 ;
1820
                                           DUP 4 ;
1821
                                           PAIR ;
1822
                                           UPDATE ;
1823
                                           DIG 8 ;
1824
                                           DUP 5 ;
1825
                                           CAR ;
1826
                                           COMPARE ;
1827
                                           EQ ;
1828
                                           IF
1829
                                             { DIG 3 ; DROP ; SWAP }
1830
                                             { SWAP ; DROP ; DIG 2 ; CAR } } ;
1831
                                       SWAP ;
1832
                                       DUG 2 ;
1833
                                       PAIR 3 ;
1834
                                       SOME } } ;
1835
                               PAIR ;
1836
                               DUP 4 ;
1837
                               CAR ;
1838
                               CDR ;
1839
                               CAR ;
1840
                               CAR ;
1841
                               PAIR ;
1842
                               PAIR ;
1843
                               DIG 2 ;
1844
                               CAR ;
1845
                               CAR ;
1846
                               PAIR ;
1847
                               PAIR ;
1848
                               SWAP ;
1849
                               PAIR }
1850
                             { DROP 6 ; PUSH nat 117 ; FAILWITH } }
1851
                         { DUP 8 ;
1852
                           DIG 2 ;
1853
                           DUP 3 ;
1854
                           INT ;
1855
                           PAIR ;
1856
                           PAIR ;
1857
                           LEFT (pair
1858
                                  (pair (list operation)
1859
                                        (pair
1860
                                          (pair
1861
                                            (pair
1862
                                              (pair address
1863
                                                    (pair
1864
                                                      (pair
1865
                                                        (pair (pair nat nat) int int)
1866
                                                        (pair int nat)
1867
                                                        nat
1868
                                                        nat)
1869
                                                      int))
1870
                                              (big_map (pair address address) unit)
1871
                                              (pair (map string bytes)
1872
                                                    (big_map string
1873
                                                             (pair
1874
                                                               (pair
1875
                                                                 (lambda
1876
                                                                   (pair
1877
                                                                     (pair
1878
                                                                       (map string bytes)
1879
                                                                       bytes)
1880
                                                                     (pair address nat
1881
                                                                           bytes))
1882
                                                                   (pair
1883
                                                                     (pair
1884
                                                                       (option address)
1885
                                                                       (map string bytes))
1886
                                                                     (list operation)))
1887
                                                                 (lambda
1888
                                                                   (pair bytes
1889
                                                                         (map string
1890
                                                                              bytes))
1891
                                                                   unit))
1892
                                                               bool))))
1893
                                            (pair
1894
                                              (big_map address
1895
                                                       (pair (pair nat nat) nat nat))
1896
                                              nat)
1897
                                            nat
1898
                                            (pair address nat))
1899
                                          (pair (pair address (big_map string bytes))
1900
                                                (option (pair bytes bytes
1901
                                                             (big_map (pair bytes bool)
1902
                                                                      bytes)))
1903
                                                address)
1904
                                          (pair nat
1905
                                                (big_map bytes
1906
                                                         (pair
1907
                                                           (pair (pair nat bytes)
1908
                                                                 address
1909
                                                                 nat)
1910
                                                           (pair nat nat)
1911
                                                           nat
1912
                                                           nat)))
1913
                                          (pair (pair nat nat) nat)
1914
                                          (big_map (pair address bytes) nat))
1915
                                        nat)
1916
                                  int) ;
1917
                           LOOP_LEFT { UNPAIR ;
1918
                                       UNPAIR ;
1919
                                       DUP 2 ;
1920
                                       CAR ;
1921
                                       CDR ;
1922
                                       CAR ;
1923
                                       CDR ;
1924
                                       CAR ;
1925
                                       IF_NONE
1926
                                         { NONE (pair bytes bytes
1927
                                                      (big_map (pair bytes bool) bytes)) ;
1928
                                           NONE bytes }
1929
                                         { DUP ;
1930
                                           GET 4 ;
1931
                                           PUSH bool True ;
1932
                                           DUP 3 ;
1933
                                           CAR ;
1934
                                           PAIR ;
1935
                                           GET ;
1936
                                           IF_NONE
1937
                                             { NONE (pair bytes bytes
1938
                                                          (big_map (pair bytes bool)
1939
                                                                   bytes)) }
1940
                                             { DUP 2 ;
1941
                                               DUP 2 ;
1942
                                               UPDATE 1 ;
1943
                                               DUP 3 ;
1944
                                               GET 4 ;
1945
                                               PUSH bool True ;
1946
                                               DUP 5 ;
1947
                                               CAR ;
1948
                                               PAIR ;
1949
                                               NONE bytes ;
1950
                                               SWAP ;
1951
                                               UPDATE ;
1952
                                               DUP 15 ;
1953
                                               DIG 3 ;
1954
                                               PAIR ;
1955
                                               NONE bytes ;
1956
                                               SWAP ;
1957
                                               UPDATE ;
1958
                                               UPDATE 4 ;
1959
                                               SOME } ;
1960
                                           SWAP ;
1961
                                           CAR ;
1962
                                           SOME } ;
1963
                                       IF_NONE
1964
                                         { DROP ;
1965
                                           SWAP ;
1966
                                           DIG 2 ;
1967
                                           PAIR ;
1968
                                           PAIR ;
1969
                                           RIGHT (pair
1970
                                                   (pair int
1971
                                                         (pair
1972
                                                           (pair
1973
                                                             (pair
1974
                                                               (pair address
1975
                                                                     (pair
1976
                                                                       (pair
1977
                                                                         (pair
1978
                                                                           (pair nat nat)
1979
                                                                           int
1980
                                                                           int)
1981
                                                                         (pair int nat)
1982
                                                                         nat
1983
                                                                         nat)
1984
                                                                       int))
1985
                                                               (big_map
1986
                                                                 (pair address address)
1987
                                                                 unit)
1988
                                                               (pair (map string bytes)
1989
                                                                     (big_map string
1990
                                                                              (pair
1991
                                                                                (pair
1992
                                                                                  (lambda
1993
                                                                                    (pair
1994
                                                                                      (pair
1995
                                                                                        (map
1996
                                                                                          string
1997
                                                                                          bytes)
1998
                                                                                        bytes)
1999
                                                                                      (pair
2000
                                                                                        address
2001
                                                                                        nat
2002
                                                                                        bytes))
2003
                                                                                    (pair
2004
                                                                                      (pair
2005
                                                                                        (option address)
2006
                                                                                        (map
2007
                                                                                          string
2008
                                                                                          bytes))
2009
                                                                                      (list operation)))
2010
                                                                                  (lambda
2011
                                                                                    (pair
2012
                                                                                      bytes
2013
                                                                                      (map
2014
                                                                                        string
2015
                                                                                        bytes))
2016
                                                                                    unit))
2017
                                                                                bool))))
2018
                                                             (pair
2019
                                                               (big_map address
2020
                                                                        (pair
2021
                                                                          (pair nat nat)
2022
                                                                          nat
2023
                                                                          nat))
2024
                                                               nat)
2025
                                                             nat
2026
                                                             (pair address nat))
2027
                                                           (pair
2028
                                                             (pair address
2029
                                                                   (big_map string bytes))
2030
                                                             (option (pair bytes bytes
2031
                                                                          (big_map
2032
                                                                            (pair bytes
2033
                                                                                  bool)
2034
                                                                            bytes)))
2035
                                                             address)
2036
                                                           (pair nat
2037
                                                                 (big_map bytes
2038
                                                                          (pair
2039
                                                                            (pair
2040
                                                                              (pair nat
2041
                                                                                    bytes)
2042
                                                                              address
2043
                                                                              nat)
2044
                                                                            (pair nat
2045
                                                                                  nat)
2046
                                                                            nat
2047
                                                                            nat)))
2048
                                                           (pair (pair nat nat) nat)
2049
                                                           (big_map (pair address bytes)
2050
                                                                    nat))
2051
                                                         nat)
2052
                                                   (list operation)) }
2053
                                         { DUP 4 ;
2054
                                           DUP 2 ;
2055
                                           PAIR ;
2056
                                           DUP 9 ;
2057
                                           SWAP ;
2058
                                           EXEC ;
2059
                                           DUP 5 ;
2060
                                           CAR ;
2061
                                           CDR ;
2062
                                           CAR ;
2063
                                           CDR ;
2064
                                           CAR ;
2065
                                           IF_NONE
2066
                                             { SWAP ; DROP ; PUSH bool False }
2067
                                             { DUP ;
2068
                                               CAR ;
2069
                                               DUP 4 ;
2070
                                               COMPARE ;
2071
                                               EQ ;
2072
                                               IF
2073
                                                 { DIG 2 ; DROP 2 ; PUSH bool True }
2074
                                                 { GET 4 ; DUP 15 ; DIG 3 ; PAIR ; MEM } } ;
2075
                                           IF {} { DROP ; PUSH nat 103 ; FAILWITH } ;
2076
                                           DUP 4 ;
2077
                                           CAR ;
2078
                                           CAR ;
2079
                                           CAR ;
2080
                                           CAR ;
2081
                                           CDR ;
2082
                                           CAR ;
2083
                                           CDR ;
2084
                                           CDR ;
2085
                                           CAR ;
2086
                                           DUP 2 ;
2087
                                           CDR ;
2088
                                           CAR ;
2089
                                           CDR ;
2090
                                           ADD ;
2091
                                           LEVEL ;
2092
                                           COMPARE ;
2093
                                           GE ;
2094
                                           IF { PUSH nat 118 ; FAILWITH } {} ;
2095
                                           DUP 4 ;
2096
                                           CAR ;
2097
                                           CAR ;
2098
                                           CAR ;
2099
                                           CAR ;
2100
                                           CDR ;
2101
                                           CAR ;
2102
                                           CDR ;
2103
                                           CDR ;
2104
                                           CDR ;
2105
                                           DUP 2 ;
2106
                                           CDR ;
2107
                                           CAR ;
2108
                                           CDR ;
2109
                                           ADD ;
2110
                                           LEVEL ;
2111
                                           COMPARE ;
2112
                                           GE ;
2113
                                           PUSH int 0 ;
2114
                                           DUP 5 ;
2115
                                           COMPARE ;
2116
                                           GT ;
2117
                                           AND ;
2118
                                           IF
2119
                                             { DUP 4 ;
2120
                                               CAR ;
2121
                                               CAR ;
2122
                                               CAR ;
2123
                                               CAR ;
2124
                                               CDR ;
2125
                                               DUP 2 ;
2126
                                               CAR ;
2127
                                               CAR ;
2128
                                               CAR ;
2129
                                               DUP 3 ;
2130
                                               CDR ;
2131
                                               CDR ;
2132
                                               CAR ;
2133
                                               COMPARE ;
2134
                                               GT ;
2135
                                               DUP 3 ;
2136
                                               CAR ;
2137
                                               CAR ;
2138
                                               CAR ;
2139
                                               DUP 4 ;
2140
                                               CDR ;
2141
                                               CDR ;
2142
                                               CAR ;
2143
                                               ADD ;
2144
                                               DUP 7 ;
2145
                                               CAR ;
2146
                                               CAR ;
2147
                                               CDR ;
2148
                                               CDR ;
2149
                                               CAR ;
2150
                                               DUP 18 ;
2151
                                               DIG 2 ;
2152
                                               MUL ;
2153
                                               EDIV ;
2154
                                               IF_NONE
2155
                                                 { PUSH string "DIV by 0" ; FAILWITH }
2156
                                                 {} ;
2157
                                               CAR ;
2158
                                               DUP 4 ;
2159
                                               CDR ;
2160
                                               CAR ;
2161
                                               CAR ;
2162
                                               SWAP ;
2163
                                               COMPARE ;
2164
                                               GE ;
2165
                                               AND ;
2166
                                               DIG 5 ;
2167
                                               DUP 3 ;
2168
                                               CAR ;
2169
                                               CAR ;
2170
                                               CAR ;
2171
                                               CAR ;
2172
                                               DIG 3 ;
2173
                                               CAR ;
2174
                                               CDR ;
2175
                                               CAR ;
2176
                                               CDR ;
2177
                                               PAIR ;
2178
                                               DUP 4 ;
2179
                                               DUP 4 ;
2180
                                               PAIR ;
2181
                                               PAIR ;
2182
                                               PAIR ;
2183
                                               DUP 8 ;
2184
                                               SWAP ;
2185
                                               EXEC ;
2186
                                               SWAP ;
2187
                                               IF
2188
                                                 { SWAP ;
2189
                                                   DUP 2 ;
2190
                                                   CAR ;
2191
                                                   CAR ;
2192
                                                   CAR ;
2193
                                                   CDR ;
2194
                                                   CDR ;
2195
                                                   PAIR ;
2196
                                                   DUP ;
2197
                                                   CDR ;
2198
                                                   CAR ;
2199
                                                   CAR ;
2200
                                                   CDR ;
2201
                                                   DUP 12 ;
2202
                                                   SWAP ;
2203
                                                   EXEC ;
2204
                                                   IF_LEFT
2205
                                                     { IF_LEFT
2206
                                                         { NONE address ;
2207
                                                           DIG 2 ;
2208
                                                           CAR ;
2209
                                                           DUP ;
2210
                                                           DUP 4 ;
2211
                                                           CDR ;
2212
                                                           PAIR ;
2213
                                                           DUP 12 ;
2214
                                                           SWAP ;
2215
                                                           EXEC ;
2216
                                                           IF
2217
                                                             { DIG 2 ;
2218
                                                               DROP 2 ;
2219
                                                               DUP 10 ;
2220
                                                               FAILWITH }
2221
                                                             { DUP ;
2222
                                                               CDR ;
2223
                                                               PUSH bool True ;
2224
                                                               DUP 5 ;
2225
                                                               CAR ;
2226
                                                               CDR ;
2227
                                                               DUP 6 ;
2228
                                                               CAR ;
2229
                                                               CAR ;
2230
                                                               PAIR ;
2231
                                                               PAIR ;
2232
                                                               DIG 4 ;
2233
                                                               CDR ;
2234
                                                               SWAP ;
2235
                                                               SOME ;
2236
                                                               SWAP ;
2237
                                                               UPDATE ;
2238
                                                               SWAP ;
2239
                                                               CAR ;
2240
                                                               PAIR } ;
2241
                                                           NIL operation ;
2242
                                                           PAIR ;
2243
                                                           PAIR }
2244
                                                         { DUP 2 ;
2245
                                                           CAR ;
2246
                                                           DUP ;
2247
                                                           CDR ;
2248
                                                           DUP 3 ;
2249
                                                           CAR ;
2250
                                                           GET ;
2251
                                                           IF_NONE
2252
                                                             { DROP 3 ;
2253
                                                               PUSH nat 300 ;
2254
                                                               FAILWITH }
2255
                                                             { DUP 4 ;
2256
                                                               CDR ;
2257
                                                               CAR ;
2258
                                                               CAR ;
2259
                                                               CDR ;
2260
                                                               DUP 5 ;
2261
                                                               CDR ;
2262
                                                               CAR ;
2263
                                                               CDR ;
2264
                                                               CDR ;
2265
                                                               DIG 5 ;
2266
                                                               CDR ;
2267
                                                               CAR ;
2268
                                                               CDR ;
2269
                                                               CAR ;
2270
                                                               PAIR 3 ;
2271
                                                               DIG 3 ;
2272
                                                               CDR ;
2273
                                                               DUP 4 ;
2274
                                                               CAR ;
2275
                                                               PAIR ;
2276
                                                               PAIR ;
2277
                                                               SWAP ;
2278
                                                               CAR ;
2279
                                                               CAR ;
2280
                                                               SWAP ;
2281
                                                               EXEC ;
2282
                                                               DUP ;
2283
                                                               CAR ;
2284
                                                               CAR ;
2285
                                                               DIG 2 ;
2286
                                                               CDR ;
2287
                                                               DUP 3 ;
2288
                                                               CAR ;
2289
                                                               CDR ;
2290
                                                               PAIR ;
2291
                                                               DIG 2 ;
2292
                                                               CDR ;
2293
                                                               PAIR ;
2294
                                                               PAIR } } }
2295
                                                     { NONE address ;
2296
                                                       DIG 2 ;
2297
                                                       CAR ;
2298
                                                       DUP ;
2299
                                                       CDR ;
2300
                                                       DUP 4 ;
2301
                                                       GET ;
2302
                                                       IF_NONE
2303
                                                         { DIG 2 ; DROP }
2304
                                                         { DUP 2 ;
2305
                                                           CDR ;
2306
                                                           PUSH bool False ;
2307
                                                           DIG 2 ;
2308
                                                           CAR ;
2309
                                                           PAIR ;
2310
                                                           SOME ;
2311
                                                           DIG 4 ;
2312
                                                           UPDATE ;
2313
                                                           SWAP ;
2314
                                                           CAR ;
2315
                                                           PAIR } ;
2316
                                                       NIL operation ;
2317
                                                       PAIR ;
2318
                                                       PAIR } ;
2319
                                                   UNPAIR ;
2320
                                                   UNPAIR ;
2321
                                                   DUG 2 ;
2322
                                                   PAIR ;
2323
                                                   PAIR ;
2324
                                                   DUP 2 ;
2325
                                                   CDR ;
2326
                                                   DUP 3 ;
2327
                                                   CAR ;
2328
                                                   CDR ;
2329
                                                   DUP 4 ;
2330
                                                   CAR ;
2331
                                                   CAR ;
2332
                                                   CDR ;
2333
                                                   DUP 4 ;
2334
                                                   CAR ;
2335
                                                   CAR ;
2336
                                                   DUP 6 ;
2337
                                                   CAR ;
2338
                                                   CAR ;
2339
                                                   CAR ;
2340
                                                   CDR ;
2341
                                                   CAR ;
2342
                                                   PAIR ;
2343
                                                   DUP 6 ;
2344
                                                   CAR ;
2345
                                                   CAR ;
2346
                                                   CAR ;
2347
                                                   CAR ;
2348
                                                   PAIR ;
2349
                                                   PAIR ;
2350
                                                   PAIR ;
2351
                                                   PAIR ;
2352
                                                   DUP ;
2353
                                                   CDR ;
2354
                                                   DUP 2 ;
2355
                                                   CAR ;
2356
                                                   CDR ;
2357
                                                   CDR ;
2358
                                                   DUP 3 ;
2359
                                                   CAR ;
2360
                                                   CDR ;
2361
                                                   CAR ;
2362
                                                   CDR ;
2363
                                                   DUP 4 ;
2364
                                                   CAR ;
2365
                                                   CDR ;
2366
                                                   CAR ;
2367
                                                   CAR ;
2368
                                                   CDR ;
2369
                                                   DUP 6 ;
2370
                                                   CAR ;
2371
                                                   CDR ;
2372
                                                   IF_NONE
2373
                                                     { DIG 6 ; CAR ; CDR ; CAR ; CAR ; CAR }
2374
                                                     { DIG 7 ; DROP } ;
2375
                                                   PAIR ;
2376
                                                   PAIR ;
2377
                                                   PAIR ;
2378
                                                   DIG 2 ;
2379
                                                   CAR ;
2380
                                                   CAR ;
2381
                                                   PAIR ;
2382
                                                   PAIR ;
2383
                                                   SWAP ;
2384
                                                   CDR }
2385
                                                 { SWAP ; DROP ; DUP 11 } ;
2386
                                               DIG 4 ;
2387
                                               ITER { CONS } ;
2388
                                               DUP 2 ;
2389
                                               CDR ;
2390
                                               DUP 3 ;
2391
                                               CAR ;
2392
                                               CDR ;
2393
                                               CDR ;
2394
                                               DUP 4 ;
2395
                                               CAR ;
2396
                                               CDR ;
2397
                                               CAR ;
2398
                                               CDR ;
2399
                                               CDR ;
2400
                                               DIG 5 ;
2401
                                               PAIR ;
2402
                                               DUP 5 ;
2403
                                               CAR ;
2404
                                               CDR ;
2405
                                               CAR ;
2406
                                               CAR ;
2407
                                               PAIR ;
2408
                                               PAIR ;
2409
                                               DIG 3 ;
2410
                                               CAR ;
2411
                                               CAR ;
2412
                                               PAIR ;
2413
                                               PAIR ;
2414
                                               PUSH int 1 ;
2415
                                               DIG 3 ;
2416
                                               SUB ;
2417
                                               PAIR ;
2418
                                               PAIR ;
2419
                                               LEFT (pair
2420
                                                      (pair (list operation)
2421
                                                            (pair
2422
                                                              (pair
2423
                                                                (pair
2424
                                                                  (pair address
2425
                                                                        (pair
2426
                                                                          (pair
2427
                                                                            (pair
2428
                                                                              (pair nat
2429
                                                                                    nat)
2430
                                                                              int
2431
                                                                              int)
2432
                                                                            (pair int
2433
                                                                                  nat)
2434
                                                                            nat
2435
                                                                            nat)
2436
                                                                          int))
2437
                                                                  (big_map
2438
                                                                    (pair address
2439
                                                                          address)
2440
                                                                    unit)
2441
                                                                  (pair
2442
                                                                    (map string bytes)
2443
                                                                    (big_map string
2444
                                                                             (pair
2445
                                                                               (pair
2446
                                                                                 (lambda
2447
                                                                                   (pair
2448
                                                                                     (pair
2449
                                                                                       (map
2450
                                                                                         string
2451
                                                                                         bytes)
2452
                                                                                       bytes)
2453
                                                                                     (pair
2454
                                                                                       address
2455
                                                                                       nat
2456
                                                                                       bytes))
2457
                                                                                   (pair
2458
                                                                                     (pair
2459
                                                                                       (option address)
2460
                                                                                       (map
2461
                                                                                         string
2462
                                                                                         bytes))
2463
                                                                                     (list operation)))
2464
                                                                                 (lambda
2465
                                                                                   (pair
2466
                                                                                     bytes
2467
                                                                                     (map
2468
                                                                                       string
2469
                                                                                       bytes))
2470
                                                                                   unit))
2471
                                                                               bool))))
2472
                                                                (pair
2473
                                                                  (big_map address
2474
                                                                           (pair
2475
                                                                             (pair nat
2476
                                                                                   nat)
2477
                                                                             nat
2478
                                                                             nat))
2479
                                                                  nat)
2480
                                                                nat
2481
                                                                (pair address nat))
2482
                                                              (pair
2483
                                                                (pair address
2484
                                                                      (big_map string
2485
                                                                               bytes))
2486
                                                                (option (pair bytes bytes
2487
                                                                             (big_map
2488
                                                                               (pair
2489
                                                                                 bytes
2490
                                                                                 bool)
2491
                                                                               bytes)))
2492
                                                                address)
2493
                                                              (pair nat
2494
                                                                    (big_map bytes
2495
                                                                             (pair
2496
                                                                               (pair
2497
                                                                                 (pair
2498
                                                                                   nat
2499
                                                                                   bytes)
2500
                                                                                 address
2501
                                                                                 nat)
2502
                                                                               (pair nat
2503
                                                                                     nat)
2504
                                                                               nat
2505
                                                                               nat)))
2506
                                                              (pair (pair nat nat) nat)
2507
                                                              (big_map
2508
                                                                (pair address bytes)
2509
                                                                nat))
2510
                                                            nat)
2511
                                                      int) }
2512
                                             { DROP 2 ;
2513
                                               SWAP ;
2514
                                               DIG 2 ;
2515
                                               PAIR ;
2516
                                               PAIR ;
2517
                                               RIGHT (pair
2518
                                                       (pair int
2519
                                                             (pair
2520
                                                               (pair
2521
                                                                 (pair
2522
                                                                   (pair address
2523
                                                                         (pair
2524
                                                                           (pair
2525
                                                                             (pair
2526
                                                                               (pair nat
2527
                                                                                     nat)
2528
                                                                               int
2529
                                                                               int)
2530
                                                                             (pair int
2531
                                                                                   nat)
2532
                                                                             nat
2533
                                                                             nat)
2534
                                                                           int))
2535
                                                                   (big_map
2536
                                                                     (pair address
2537
                                                                           address)
2538
                                                                     unit)
2539
                                                                   (pair
2540
                                                                     (map string bytes)
2541
                                                                     (big_map string
2542
                                                                              (pair
2543
                                                                                (pair
2544
                                                                                  (lambda
2545
                                                                                    (pair
2546
                                                                                      (pair
2547
                                                                                        (map
2548
                                                                                          string
2549
                                                                                          bytes)
2550
                                                                                        bytes)
2551
                                                                                      (pair
2552
                                                                                        address
2553
                                                                                        nat
2554
                                                                                        bytes))
2555
                                                                                    (pair
2556
                                                                                      (pair
2557
                                                                                        (option address)
2558
                                                                                        (map
2559
                                                                                          string
2560
                                                                                          bytes))
2561
                                                                                      (list operation)))
2562
                                                                                  (lambda
2563
                                                                                    (pair
2564
                                                                                      bytes
2565
                                                                                      (map
2566
                                                                                        string
2567
                                                                                        bytes))
2568
                                                                                    unit))
2569
                                                                                bool))))
2570
                                                                 (pair
2571
                                                                   (big_map address
2572
                                                                            (pair
2573
                                                                              (pair nat
2574
                                                                                    nat)
2575
                                                                              nat
2576
                                                                              nat))
2577
                                                                   nat)
2578
                                                                 nat
2579
                                                                 (pair address nat))
2580
                                                               (pair
2581
                                                                 (pair address
2582
                                                                       (big_map string
2583
                                                                                bytes))
2584
                                                                 (option (pair bytes
2585
                                                                              bytes
2586
                                                                              (big_map
2587
                                                                                (pair
2588
                                                                                  bytes
2589
                                                                                  bool)
2590
                                                                                bytes)))
2591
                                                                 address)
2592
                                                               (pair nat
2593
                                                                     (big_map bytes
2594
                                                                              (pair
2595
                                                                                (pair
2596
                                                                                  (pair
2597
                                                                                    nat
2598
                                                                                    bytes)
2599
                                                                                  address
2600
                                                                                  nat)
2601
                                                                                (pair
2602
                                                                                  nat
2603
                                                                                  nat)
2604
                                                                                nat
2605
                                                                                nat)))
2606
                                                               (pair (pair nat nat) nat)
2607
                                                               (big_map
2608
                                                                 (pair address bytes)
2609
                                                                 nat))
2610
                                                             nat)
2611
                                                       (list operation)) } } } ;
2612
                           DIG 2 ;
2613
                           DIG 3 ;
2614
                           DIG 4 ;
2615
                           DIG 5 ;
2616
                           DIG 6 ;
2617
                           DIG 7 ;
2618
                           DIG 8 ;
2619
                           DIG 9 ;
2620
                           DROP 8 ;
2621
                           UNPAIR ;
2622
                           UNPAIR ;
2623
                           DIG 3 ;
2624
                           INT ;
2625
                           DIG 3 ;
2626
                           COMPARE ;
2627
                           EQ ;
2628
                           IF { DROP 2 ; PUSH nat 119 ; FAILWITH } { PAIR } } }
2629
                     { DIG 2 ;
2630
                       DIG 4 ;
2631
                       DIG 8 ;
2632
                       DIG 9 ;
2633
                       DIG 10 ;
2634
                       DIG 11 ;
2635
                       DIG 12 ;
2636
                       DIG 13 ;
2637
                       DROP 8 ;
2638
                       IF_LEFT
2639
                         { DIG 4 ;
2640
                           DROP ;
2641
                           SENDER ;
2642
                           DUP 3 ;
2643
                           CAR ;
2644
                           CAR ;
2645
                           CDR ;
2646
                           CDR ;
2647
                           CDR ;
2648
                           NIL (pair address nat nat) ;
2649
                           DUP 4 ;
2650
                           DUP 3 ;
2651
                           CDR ;
2652
                           SELF_ADDRESS ;
2653
                           PAIR 3 ;
2654
                           CONS ;
2655
                           DUP 3 ;
2656
                           PAIR ;
2657
                           SWAP ;
2658
                           CAR ;
2659
                           NIL (pair address (list (pair address nat nat))) ;
2660
                           DIG 2 ;
2661
                           CONS ;
2662
                           PAIR ;
2663
                           DIG 6 ;
2664
                           SWAP ;
2665
                           EXEC ;
2666
                           DUP 3 ;
2667
                           DUP 5 ;
2668
                           CAR ;
2669
                           CAR ;
2670
                           CDR ;
2671
                           CDR ;
2672
                           CAR ;
2673
                           ADD ;
2674
                           NIL operation ;
2675
                           DIG 2 ;
2676
                           CONS ;
2677
                           DUP 5 ;
2678
                           CAR ;
2679
                           CAR ;
2680
                           CAR ;
2681
                           CAR ;
2682
                           CDR ;
2683
                           CAR ;
2684
                           CDR ;
2685
                           CAR ;
2686
                           CDR ;
2687
                           DUP 6 ;
2688
                           CDR ;
2689
                           PAIR ;
2690
                           DIG 6 ;
2691
                           SWAP ;
2692
                           EXEC ;
2693
                           DUP 6 ;
2694
                           CAR ;
2695
                           CAR ;
2696
                           CDR ;
2697
                           CAR ;
2698
                           CAR ;
2699
                           DUP 5 ;
2700
                           GET ;
2701
                           IF_NONE
2702
                             { DIG 6 ; DROP ; PUSH nat 0 ; PUSH nat 0 ; PAIR ; DIG 5 ; DIG 2 }
2703
                             { SWAP ;
2704
                               PAIR ;
2705
                               DIG 6 ;
2706
                               SWAP ;
2707
                               EXEC ;
2708
                               DUP ;
2709
                               CDR ;
2710
                               DIG 5 ;
2711
                               DUP 3 ;
2712
                               CAR ;
2713
                               CDR ;
2714
                               ADD ;
2715
                               DIG 2 ;
2716
                               CAR ;
2717
                               CAR } ;
2718
                           PAIR ;
2719
                           PAIR ;
2720
                           DUP 5 ;
2721
                           CDR ;
2722
                           DUP 6 ;
2723
                           CAR ;
2724
                           CDR ;
2725
                           DUP 7 ;
2726
                           CAR ;
2727
                           CAR ;
2728
                           CDR ;
2729
                           CDR ;
2730
                           CDR ;
2731
                           DIG 5 ;
2732
                           PAIR ;
2733
                           DUP 7 ;
2734
                           CAR ;
2735
                           CAR ;
2736
                           CDR ;
2737
                           CAR ;
2738
                           PAIR ;
2739
                           DUP 7 ;
2740
                           CAR ;
2741
                           CAR ;
2742
                           CAR ;
2743
                           PAIR ;
2744
                           PAIR ;
2745
                           PAIR ;
2746
                           DUP ;
2747
                           CDR ;
2748
                           DUP 2 ;
2749
                           CAR ;
2750
                           CDR ;
2751
                           DUP 3 ;
2752
                           CAR ;
2753
                           CAR ;
2754
                           CDR ;
2755
                           CDR ;
2756
                           DUP 4 ;
2757
                           CAR ;
2758
                           CAR ;
2759
                           CDR ;
2760
                           CAR ;
2761
                           CDR ;
2762
                           DIG 8 ;
2763
                           CAR ;
2764
                           CAR ;
2765
                           CDR ;
2766
                           CAR ;
2767
                           CAR ;
2768
                           DIG 6 ;
2769
                           SOME ;
2770
                           DIG 8 ;
2771
                           UPDATE ;
2772
                           PAIR ;
2773
                           PAIR ;
2774
                           DIG 3 ;
2775
                           CAR ;
2776
                           CAR ;
2777
                           CAR }
2778
                         { SENDER ;
2779
                           DUP 3 ;
2780
                           CAR ;
2781
                           CAR ;
2782
                           CAR ;
2783
                           CAR ;
2784
                           CDR ;
2785
                           CAR ;
2786
                           CDR ;
2787
                           CAR ;
2788
                           CDR ;
2789
                           DUP 4 ;
2790
                           CDR ;
2791
                           PAIR ;
2792
                           DIG 4 ;
2793
                           SWAP ;
2794
                           EXEC ;
2795
                           DUP 4 ;
2796
                           CAR ;
2797
                           CAR ;
2798
                           CDR ;
2799
                           CAR ;
2800
                           CAR ;
2801
                           DUP 3 ;
2802
                           GET ;
2803
                           IF_NONE
2804
                             { SWAP ; DIG 4 ; DIG 5 ; DROP 4 ; PUSH nat 114 ; FAILWITH }
2805
                             { SWAP ;
2806
                               PAIR ;
2807
                               DIG 4 ;
2808
                               SWAP ;
2809
                               EXEC ;
2810
                               DUP 3 ;
2811
                               PAIR ;
2812
                               DIG 4 ;
2813
                               SWAP ;
2814
                               EXEC ;
2815
                               DUP 4 ;
2816
                               CAR ;
2817
                               CAR ;
2818
                               CDR ;
2819
                               CAR ;
2820
                               CAR ;
2821
                               SWAP ;
2822
                               SOME ;
2823
                               DIG 2 ;
2824
                               UPDATE } ;
2825
                           DUP 3 ;
2826
                           CAR ;
2827
                           CAR ;
2828
                           CDR ;
2829
                           CDR ;
2830
                           CDR ;
2831
                           DUP 4 ;
2832
                           CAR ;
2833
                           CAR ;
2834
                           CDR ;
2835
                           CDR ;
2836
                           CAR ;
2837
                           PAIR ;
2838
                           SENDER ;
2839
                           DIG 3 ;
2840
                           DIG 2 ;
2841
                           UNPAIR ;
2842
                           NIL (pair address nat nat) ;
2843
                           DUP 4 ;
2844
                           DUP 4 ;
2845
                           CDR ;
2846
                           DIG 6 ;
2847
                           PAIR 3 ;
2848
                           CONS ;
2849
                           SELF_ADDRESS ;
2850
                           PAIR ;
2851
                           DIG 2 ;
2852
                           CAR ;
2853
                           NIL (pair address (list (pair address nat nat))) ;
2854
                           DIG 2 ;
2855
                           CONS ;
2856
                           PAIR ;
2857
                           DIG 5 ;
2858
                           SWAP ;
2859
                           EXEC ;
2860
                           DUG 2 ;
2861
                           SUB ;
2862
                           ISNAT ;
2863
                           IF_NONE { PUSH nat 300 ; FAILWITH } {} ;
2864
                           NIL operation ;
2865
                           DIG 2 ;
2866
                           CONS ;
2867
                           DUP 4 ;
2868
                           CDR ;
2869
                           DUP 5 ;
2870
                           CAR ;
2871
                           CDR ;
2872
                           DUP 6 ;
2873
                           CAR ;
2874
                           CAR ;
2875
                           CDR ;
2876
                           CDR ;
2877
                           DUP 7 ;
2878
                           CAR ;
2879
                           CAR ;
2880
                           CDR ;
2881
                           CAR ;
2882
                           CDR ;
2883
                           DIG 6 ;
2884
                           PAIR ;
2885
                           PAIR ;
2886
                           DIG 5 ;
2887
                           CAR ;
2888
                           CAR ;
2889
                           CAR ;
2890
                           PAIR ;
2891
                           PAIR ;
2892
                           PAIR ;
2893
                           DUP ;
2894
                           CDR ;
2895
                           DUP 2 ;
2896
                           CAR ;
2897
                           CDR ;
2898
                           DUP 3 ;
2899
                           CAR ;
2900
                           CAR ;
2901
                           CDR ;
2902
                           CDR ;
2903
                           CDR ;
2904
                           DIG 5 ;
2905
                           PAIR ;
2906
                           DUP 4 ;
2907
                           CAR ;
2908
                           CAR ;
2909
                           CDR ;
2910
                           CAR ;
2911
                           PAIR ;
2912
                           DIG 3 ;
2913
                           CAR ;
2914
                           CAR ;
2915
                           CAR } ;
2916
                       PAIR ;
2917
                       PAIR ;
2918
                       PAIR ;
2919
                       SWAP ;
2920
                       PAIR } }
2921
                 { DIG 2 ;
2922
                   DIG 7 ;
2923
                   DIG 8 ;
2924
                   DIG 9 ;
2925
                   DIG 10 ;
2926
                   DIG 11 ;
2927
                   DIG 12 ;
2928
                   DIG 15 ;
2929
                   DROP 8 ;
2930
                   IF_LEFT
2931
                     { DIG 2 ;
2932
                       DIG 4 ;
2933
                       DIG 5 ;
2934
                       DROP 3 ;
2935
                       IF_LEFT
2936
                         { DUP 2 ;
2937
                           SWAP ;
2938
                           ITER { SWAP ;
2939
                                  DUP ;
2940
                                  CAR ;
2941
                                  CDR ;
2942
                                  CAR ;
2943
                                  CDR ;
2944
                                  CAR ;
2945
                                  IF_NONE
2946
                                    { PUSH bool False }
2947
                                    { DUP ;
2948
                                      CAR ;
2949
                                      DUP 4 ;
2950
                                      COMPARE ;
2951
                                      EQ ;
2952
                                      IF
2953
                                        { DROP ; PUSH bool True }
2954
                                        { GET 4 ; DUP 7 ; DUP 4 ; PAIR ; MEM } } ;
2955
                                  IF { PUSH nat 123 ; FAILWITH } {} ;
2956
                                  DUP ;
2957
                                  CAR ;
2958
                                  CDR ;
2959
                                  CDR ;
2960
                                  CDR ;
2961
                                  CDR ;
2962
                                  DUP 3 ;
2963
                                  SENDER ;
2964
                                  PAIR ;
2965
                                  GET ;
2966
                                  IF_NONE { PUSH nat 124 ; FAILWITH } {} ;
2967
                                  SWAP ;
2968
                                  DUP 4 ;
2969
                                  CAR ;
2970
                                  CAR ;
2971
                                  CAR ;
2972
                                  CAR ;
2973
                                  CDR ;
2974
                                  CAR ;
2975
                                  CDR ;
2976
                                  CAR ;
2977
                                  CDR ;
2978
                                  SENDER ;
2979
                                  PAIR ;
2980
                                  PUSH nat 0 ;
2981
                                  DIG 3 ;
2982
                                  PAIR ;
2983
                                  PAIR ;
2984
                                  PAIR ;
2985
                                  DUP 4 ;
2986
                                  SWAP ;
2987
                                  EXEC ;
2988
                                  DUP ;
2989
                                  CDR ;
2990
                                  DUP 2 ;
2991
                                  CAR ;
2992
                                  CDR ;
2993
                                  CDR ;
2994
                                  CDR ;
2995
                                  CDR ;
2996
                                  DIG 3 ;
2997
                                  SENDER ;
2998
                                  PAIR ;
2999
                                  NONE nat ;
3000
                                  SWAP ;
3001
                                  UPDATE ;
3002
                                  DUP 3 ;
3003
                                  CAR ;
3004
                                  CDR ;
3005
                                  CDR ;
3006
                                  CDR ;
3007
                                  CAR ;
3008
                                  PAIR ;
3009
                                  DUP 3 ;
3010
                                  CAR ;
3011
                                  CDR ;
3012
                                  CDR ;
3013
                                  CAR ;
3014
                                  PAIR ;
3015
                                  DUP 3 ;
3016
                                  CAR ;
3017
                                  CDR ;
3018
                                  CAR ;
3019
                                  PAIR ;
3020
                                  DIG 2 ;
3021
                                  CAR ;
3022
                                  CAR ;
3023
                                  PAIR ;
3024
                                  PAIR } ;
3025
                           SWAP ;
3026
                           DIG 2 ;
3027
                           DIG 4 ;
3028
                           DROP 3 }
3029
                         { DIG 2 ;
3030
                           DIG 4 ;
3031
                           DROP 2 ;
3032
                           DUP 2 ;
3033
                           CDR ;
3034
                           DUP 3 ;
3035
                           CAR ;
3036
                           CDR ;
3037
                           DUP 4 ;
3038
                           CAR ;
3039
                           CAR ;
3040
                           CDR ;
3041
                           DUP 5 ;
3042
                           CAR ;
3043
                           CAR ;
3044
                           CAR ;
3045
                           CDR ;
3046
                           CDR ;
3047
                           DUP 6 ;
3048
                           CAR ;
3049
                           CAR ;
3050
                           CAR ;
3051
                           CDR ;
3052
                           CAR ;
3053
                           DIG 5 ;
3054
                           ITER { SWAP ;
3055
                                  DUP 2 ;
3056
                                  CDR ;
3057
                                  SENDER ;
3058
                                  PAIR ;
3059
                                  SWAP ;
3060
                                  DIG 2 ;
3061
                                  CAR ;
3062
                                  IF { UNIT ; SOME } { NONE unit } ;
3063
                                  DIG 2 ;
3064
                                  UPDATE } ;
3065
                           PAIR ;
3066
                           DIG 4 ;
3067
                           CAR ;
3068
                           CAR ;
3069
                           CAR ;
3070
                           CAR ;
3071
                           PAIR ;
3072
                           PAIR ;
3073
                           PAIR ;
3074
                           PAIR } }
3075
                     { DIG 3 ;
3076
                       DROP ;
3077
                       ITER { SWAP ;
3078
                              DUP 2 ;
3079
                              CDR ;
3080
                              IF_NONE
3081
                                { SENDER ; DUP 3 ; CAR }
3082
                                { DUP 3 ;
3083
                                  CAR ;
3084
                                  DUP 3 ;
3085
                                  CDR ;
3086
                                  DUP 4 ;
3087
                                  CAR ;
3088
                                  CDR ;
3089
                                  CDR ;
3090
                                  CDR ;
3091
                                  DUP 5 ;
3092
                                  CAR ;
3093
                                  CDR ;
3094
                                  CDR ;
3095
                                  CAR ;
3096
                                  CDR ;
3097
                                  PUSH nat 1 ;
3098
                                  DUP 7 ;
3099
                                  CAR ;
3100
                                  CDR ;
3101
                                  CDR ;
3102
                                  CAR ;
3103
                                  CAR ;
3104
                                  ADD ;
3105
                                  PAIR ;
3106
                                  PAIR ;
3107
                                  DUP 5 ;
3108
                                  CAR ;
3109
                                  CDR ;
3110
                                  CAR ;
3111
                                  PAIR ;
3112
                                  DUP 5 ;
3113
                                  CAR ;
3114
                                  CAR ;
3115
                                  PAIR ;
3116
                                  PAIR ;
3117
                                  DUP 2 ;
3118
                                  DIG 4 ;
3119
                                  CAR ;
3120
                                  CDR ;
3121
                                  CDR ;
3122
                                  CAR ;
3123
                                  CAR ;
3124
                                  PAIR ;
3125
                                  SELF_ADDRESS ;
3126
                                  CHAIN_ID ;
3127
                                  PAIR ;
3128
                                  PAIR ;
3129
                                  PACK ;
3130
                                  DUP ;
3131
                                  DUP 5 ;
3132
                                  UNPAIR ;
3133
                                  CHECK_SIGNATURE ;
3134
                                  IF
3135
                                    { DROP ; DIG 2 ; CAR ; HASH_KEY ; IMPLICIT_ACCOUNT ; ADDRESS }
3136
                                    { DIG 3 ; DROP ; PUSH nat 109 ; PAIR ; FAILWITH } ;
3137
                                  DIG 2 } ;
3138
                              DIG 3 ;
3139
                              CAR ;
3140
                              CAR ;
3141
                              CAR ;
3142
                              DUP 4 ;
3143
                              CAR ;
3144
                              CAR ;
3145
                              CAR ;
3146
                              CDR ;
3147
                              CAR ;
3148
                              DUP 4 ;
3149
                              DUP 3 ;
3150
                              PAIR ;
3151
                              MEM ;
3152
                              NOT ;
3153
                              DUP 2 ;
3154
                              DIG 4 ;
3155
                              COMPARE ;
3156
                              NEQ ;
3157
                              AND ;
3158
                              IF { DROP ; PUSH nat 120 ; FAILWITH } {} ;
3159
                              DUP 2 ;
3160
                              CAR ;
3161
                              CDR ;
3162
                              DUP 4 ;
3163
                              DUP 2 ;
3164
                              PAIR ;
3165
                              DUP 8 ;
3166
                              SWAP ;
3167
                              EXEC ;
3168
                              DUP 5 ;
3169
                              CAR ;
3170
                              CDR ;
3171
                              CAR ;
3172
                              CDR ;
3173
                              CAR ;
3174
                              IF_NONE
3175
                                { SWAP ; DROP ; PUSH bool False }
3176
                                { DUP ;
3177
                                  CAR ;
3178
                                  DUP 4 ;
3179
                                  COMPARE ;
3180
                                  EQ ;
3181
                                  IF
3182
                                    { DIG 2 ; DROP 2 ; PUSH bool True }
3183
                                    { GET 4 ; DUP 11 ; DIG 3 ; PAIR ; MEM } } ;
3184
                              IF {} { DROP ; PUSH nat 103 ; FAILWITH } ;
3185
                              DUP 4 ;
3186
                              CAR ;
3187
                              CAR ;
3188
                              CAR ;
3189
                              CAR ;
3190
                              CDR ;
3191
                              CAR ;
3192
                              CDR ;
3193
                              CAR ;
3194
                              CDR ;
3195
                              DUP 5 ;
3196
                              CDR ;
3197
                              PAIR ;
3198
                              DUP 7 ;
3199
                              SWAP ;
3200
                              EXEC ;
3201
                              DUP 2 ;
3202
                              CDR ;
3203
                              CDR ;
3204
                              CDR ;
3205
                              SWAP ;
3206
                              COMPARE ;
3207
                              EQ ;
3208
                              IF { DIG 3 } { DIG 3 ; DROP ; PUSH nat 104 ; FAILWITH } ;
3209
                              DUP 4 ;
3210
                              CAR ;
3211
                              CDR ;
3212
                              DUP 5 ;
3213
                              CDR ;
3214
                              CAR ;
3215
                              DUP 3 ;
3216
                              CAR ;
3217
                              CDR ;
3218
                              CDR ;
3219
                              CDR ;
3220
                              CDR ;
3221
                              DUP 3 ;
3222
                              DUP 7 ;
3223
                              PAIR ;
3224
                              GET ;
3225
                              IF_NONE { PUSH nat 0 } {} ;
3226
                              ADD ;
3227
                              DUP 6 ;
3228
                              CDR ;
3229
                              CDR ;
3230
                              IF
3231
                                { DUP 4 ;
3232
                                  CDR ;
3233
                                  CDR ;
3234
                                  CDR ;
3235
                                  DUP 7 ;
3236
                                  CDR ;
3237
                                  CAR ;
3238
                                  DUP 6 ;
3239
                                  CDR ;
3240
                                  CDR ;
3241
                                  CAR ;
3242
                                  ADD ;
3243
                                  PAIR ;
3244
                                  DUP 5 ;
3245
                                  CDR ;
3246
                                  CAR ;
3247
                                  PAIR ;
3248
                                  DIG 4 ;
3249
                                  CAR }
3250
                                { DUP 4 ;
3251
                                  CDR ;
3252
                                  DUP 5 ;
3253
                                  CAR ;
3254
                                  CDR ;
3255
                                  DUP 6 ;
3256
                                  CAR ;
3257
                                  CAR ;
3258
                                  CDR ;
3259
                                  DUP 9 ;
3260
                                  CDR ;
3261
                                  CAR ;
3262
                                  DIG 7 ;
3263
                                  CAR ;
3264
                                  CAR ;
3265
                                  CAR ;
3266
                                  ADD ;
3267
                                  PAIR ;
3268
                                  PAIR } ;
3269
                              PAIR ;
3270
                              DUP 4 ;
3271
                              DIG 4 ;
3272
                              CAR ;
3273
                              CAR ;
3274
                              CAR ;
3275
                              CAR ;
3276
                              CDR ;
3277
                              CAR ;
3278
                              CDR ;
3279
                              CAR ;
3280
                              CDR ;
3281
                              PAIR ;
3282
                              DUP 5 ;
3283
                              DIG 6 ;
3284
                              CDR ;
3285
                              CAR ;
3286
                              PAIR ;
3287
                              PAIR ;
3288
                              DUP 6 ;
3289
                              SWAP ;
3290
                              EXEC ;
3291
                              DUP ;
3292
                              CDR ;
3293
                              DUP 2 ;
3294
                              CAR ;
3295
                              CDR ;
3296
                              CDR ;
3297
                              CDR ;
3298
                              DUP 3 ;
3299
                              CAR ;
3300
                              CDR ;
3301
                              CDR ;
3302
                              CAR ;
3303
                              CDR ;
3304
                              DIG 4 ;
3305
                              DUP 7 ;
3306
                              SWAP ;
3307
                              SOME ;
3308
                              SWAP ;
3309
                              UPDATE ;
3310
                              DUP 4 ;
3311
                              CAR ;
3312
                              CDR ;
3313
                              CDR ;
3314
                              CAR ;
3315
                              CAR ;
3316
                              PAIR ;
3317
                              PAIR ;
3318
                              DUP 3 ;
3319
                              CAR ;
3320
                              CDR ;
3321
                              CAR ;
3322
                              PAIR ;
3323
                              DUP 3 ;
3324
                              CAR ;
3325
                              CAR ;
3326
                              PAIR ;
3327
                              PAIR ;
3328
                              DUP ;
3329
                              CDR ;
3330
                              DIG 2 ;
3331
                              CAR ;
3332
                              CDR ;
3333
                              CDR ;
3334
                              CDR ;
3335
                              CDR ;
3336
                              DIG 3 ;
3337
                              DIG 4 ;
3338
                              DIG 5 ;
3339
                              PAIR ;
3340
                              SWAP ;
3341
                              SOME ;
3342
                              SWAP ;
3343
                              UPDATE ;
3344
                              DUP 3 ;
3345
                              CAR ;
3346
                              CDR ;
3347
                              CDR ;
3348
                              CDR ;
3349
                              CAR ;
3350
                              PAIR ;
3351
                              DUP 3 ;
3352
                              CAR ;
3353
                              CDR ;
3354
                              CDR ;
3355
                              CAR ;
3356
                              PAIR ;
3357
                              DUP 3 ;
3358
                              CAR ;
3359
                              CDR ;
3360
                              CAR ;
3361
                              PAIR ;
3362
                              DIG 2 ;
3363
                              CAR ;
3364
                              CAR ;
3365
                              PAIR ;
3366
                              PAIR } ;
3367
                       SWAP ;
3368
                       DIG 2 ;
3369
                       DIG 3 ;
3370
                       DIG 5 ;
3371
                       DROP 4 } ;
3372
                   SWAP ;
3373
                   PAIR } } } }