BCD

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