BCD

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