BCD

Tezos Contract Explorer
Search Networks Deploy
  • Home
  • /
  • Mainnet
  • /
  • Youves DAO
operations (789)Storage Code Interact Tokens Fork Views Statistics Details
Latest
​x
757
1531
 
1
{ parameter (or
2
              (or
3
                (or (unit %cancel_timelock)
4
                    (pair %change_vote (nat %vote) (nat %vote_id)))
5
                (or (unit %end_vote)
6
                    (or (unit %execute_timelock)
7
                        (pair %propose (string %title)
8
                                       (pair (string %description_link)
9
                                             (pair (string %description_hash)
10
                                                   (lambda %proposal_lambda unit
11
                                                                            (list operation))))))))
12
              (or
13
                (or
14
                  (list %return_stakes (pair (address %voter)
15
                                            (pair (nat %vote_id) (nat %proposal_id))))
16
                  (or (option %set_break_glass_contract address)
17
                      (address %set_community_fund_address)))
18
                (or
19
                  (pair %set_governance_params (nat %escrow_amount)
20
                                               (pair (nat %vote_delay_blocks)
21
                                                     (pair (nat %vote_length_blocks)
22
                                                           (pair
23
                                                             (nat %min_yes_votes_percentage_for_escrow_return)
24
                                                             (pair
25
                                                               (nat %timelock_execution_delay_blocks)
26
                                                               (pair
27
                                                                 (nat %timelock_cancelation_delay_blocks)
28
                                                                 (pair
29
                                                                   (nat %super_majority_percentage)
30
                                                                   (pair %quorum_cap
31
                                                                     (nat %lower)
32
                                                                     (nat %upper)))))))))
33
                  (or (unit %veto_timelock) (pair %vote (nat %vote) (nat %vote_id)))))) ;
34
  storage (pair
35
            (pair
36
              (pair (option %break_glass_contract address)
37
                    (pair (address %community_fund_address)
38
                          (or %escrow_contract (address %fa1)
39
                                               (or
40
                                                 (pair %fa2 (address %contract)
41
                                                            (nat %token_id))
42
                                                 (unit %tez)))))
43
              (pair
44
                (pair %governance_params (nat %escrow_amount)
45
                                         (pair (nat %vote_delay_blocks)
46
                                               (pair (nat %vote_length_blocks)
47
                                                     (pair
48
                                                       (nat %min_yes_votes_percentage_for_escrow_return)
49
                                                       (pair
50
                                                         (nat %timelock_execution_delay_blocks)
51
                                                         (pair
52
                                                           (nat %timelock_cancelation_delay_blocks)
53
                                                           (pair
54
                                                             (nat %super_majority_percentage)
55
                                                             (pair %quorum_cap
56
                                                               (nat %lower)
57
                                                               (nat %upper)))))))))
58
                (pair
59
                  (big_map %historical_outcomes nat
60
                                                (pair (nat %outcome)
61
                                                      (pair %poll (nat %id)
62
                                                                  (pair
63
                                                                    (pair %proposal
64
                                                                      (string %title)
65
                                                                      (pair
66
                                                                        (string %description_link)
67
                                                                        (pair
68
                                                                          (string %description_hash)
69
                                                                          (lambda %proposal_lambda
70
                                                                            unit
71
                                                                            (list operation)))))
72
                                                                    (pair
73
                                                                      (nat %voting_start_block)
74
                                                                      (pair
75
                                                                        (nat %voting_end_block)
76
                                                                        (pair
77
                                                                          (map %votes
78
                                                                            nat
79
                                                                            nat)
80
                                                                          (pair
81
                                                                            (nat %total_votes)
82
                                                                            (pair
83
                                                                              (address %author)
84
                                                                              (pair
85
                                                                                (nat %escrow_amount)
86
                                                                                (pair
87
                                                                                  (nat %quorum)
88
                                                                                  (pair %quorum_cap
89
                                                                                    (nat %lower)
90
                                                                                    (nat %upper)))))))))))))
91
                  (big_map %metadata string bytes))))
92
            (pair
93
              (pair (nat %next_proposal_id)
94
                    (pair
95
                      (option %poll (pair (nat %id)
96
                                         (pair
97
                                           (pair %proposal (string %title)
98
                                                           (pair
99
                                                             (string %description_link)
100
                                                             (pair
101
                                                               (string %description_hash)
102
                                                               (lambda %proposal_lambda
103
                                                                 unit
104
                                                                 (list operation)))))
105
                                           (pair (nat %voting_start_block)
106
                                                 (pair (nat %voting_end_block)
107
                                                       (pair (map %votes nat nat)
108
                                                             (pair (nat %total_votes)
109
                                                                   (pair
110
                                                                     (address %author)
111
                                                                     (pair
112
                                                                       (nat %escrow_amount)
113
                                                                       (pair
114
                                                                         (nat %quorum)
115
                                                                         (pair %quorum_cap
116
                                                                           (nat %lower)
117
                                                                           (nat %upper))))))))))))
118
                      (nat %quorum)))
119
              (pair
120
                (option %timelock (pair (nat %id)
121
                                       (pair
122
                                         (pair %proposal (string %title)
123
                                                         (pair
124
                                                           (string %description_link)
125
                                                           (pair
126
                                                             (string %description_hash)
127
                                                             (lambda %proposal_lambda
128
                                                               unit
129
                                                               (list operation)))))
130
                                         (pair (nat %execution_start_block)
131
                                               (pair (nat %cancelation_start_block)
132
                                                     (address %author))))))
133
                (pair
134
                  (big_map %vote_tracker
135
                    (pair (address %voter) (pair (nat %vote_id) (nat %proposal_id)))
136
                    (pair (nat %vote_value) (nat %weight)))
137
                  (address %voting_contract))))) ;
138
  code { LAMBDA
139
           (pair (pair nat nat)
140
                 (pair
141
                   (pair
142
                     (pair (option address)
143
                           (pair address (or address (or (pair address nat) unit))))
144
                     (pair
145
                       (pair nat
146
                             (pair nat
147
                                   (pair nat
148
                                         (pair nat
149
                                               (pair nat
150
                                                     (pair nat (pair nat (pair nat nat))))))))
151
                       (pair
152
                         (big_map nat
153
                                  (pair nat
154
                                        (pair nat
155
                                              (pair
156
                                                (pair string
157
                                                      (pair string
158
                                                            (pair string
159
                                                                  (lambda unit
160
                                                                          (list operation)))))
161
                                                (pair nat
162
                                                      (pair nat
163
                                                            (pair (map nat nat)
164
                                                                  (pair nat
165
                                                                        (pair address
166
                                                                              (pair nat
167
                                                                                    (pair
168
                                                                                      nat
169
                                                                                      (pair
170
                                                                                        nat
171
                                                                                        nat))))))))))))
172
                         (big_map string bytes))))
173
                   (pair
174
                     (pair nat
175
                           (pair
176
                             (option (pair nat
177
                                          (pair
178
                                            (pair string
179
                                                  (pair string
180
                                                        (pair string
181
                                                              (lambda unit
182
                                                                      (list operation)))))
183
                                            (pair nat
184
                                                  (pair nat
185
                                                        (pair (map nat nat)
186
                                                              (pair nat
187
                                                                    (pair address
188
                                                                          (pair nat
189
                                                                                (pair
190
                                                                                  nat
191
                                                                                  (pair
192
                                                                                    nat
193
                                                                                    nat)))))))))))
194
                             nat))
195
                     (pair
196
                       (option (pair nat
197
                                    (pair
198
                                      (pair string
199
                                            (pair string
200
                                                  (pair string
201
                                                        (lambda unit (list operation)))))
202
                                      (pair nat (pair nat address)))))
203
                       (pair (big_map (pair address (pair nat nat)) (pair nat nat))
204
                             address)))))
205
           (pair
206
             (pair nat
207
                   (pair
208
                     (pair string
209
                           (pair string (pair string (lambda unit (list operation)))))
210
                     (pair nat
211
                           (pair nat
212
                                 (pair (map nat nat)
213
                                       (pair nat
214
                                             (pair address
215
                                                   (pair nat (pair nat (pair nat nat))))))))))
216
             (pair
217
               (pair
218
                 (pair (option address)
219
                       (pair address (or address (or (pair address nat) unit))))
220
                 (pair
221
                   (pair nat
222
                         (pair nat
223
                               (pair nat
224
                                     (pair nat
225
                                           (pair nat
226
                                                 (pair nat (pair nat (pair nat nat))))))))
227
                   (pair
228
                     (big_map nat
229
                              (pair nat
230
                                    (pair nat
231
                                          (pair
232
                                            (pair string
233
                                                  (pair string
234
                                                        (pair string
235
                                                              (lambda unit
236
                                                                      (list operation)))))
237
                                            (pair nat
238
                                                  (pair nat
239
                                                        (pair (map nat nat)
240
                                                              (pair nat
241
                                                                    (pair address
242
                                                                          (pair nat
243
                                                                                (pair
244
                                                                                  nat
245
                                                                                  (pair
246
                                                                                    nat
247
                                                                                    nat))))))))))))
248
                     (big_map string bytes))))
249
               (pair
250
                 (pair nat
251
                       (pair
252
                         (option (pair nat
253
                                      (pair
254
                                        (pair string
255
                                              (pair string
256
                                                    (pair string
257
                                                          (lambda unit (list operation)))))
258
                                        (pair nat
259
                                              (pair nat
260
                                                    (pair (map nat nat)
261
                                                          (pair nat
262
                                                                (pair address
263
                                                                      (pair nat
264
                                                                            (pair nat
265
                                                                                  (pair
266
                                                                                    nat
267
                                                                                    nat)))))))))))
268
                         nat))
269
                 (pair
270
                   (option (pair nat
271
                                (pair
272
                                  (pair string
273
                                        (pair string
274
                                              (pair string
275
                                                    (lambda unit (list operation)))))
276
                                  (pair nat (pair nat address)))))
277
                   (pair (big_map (pair address (pair nat nat)) (pair nat nat)) address)))))
278
           { UNPAIR ;
279
             SWAP ;
280
             DUP ;
281
             DUG 2 ;
282
             GET 3 ;
283
             GET 3 ;
284
             IF_NONE { PUSH string "NO_POLL" ; FAILWITH } {} ;
285
             DUP ;
286
             GET 7 ;
287
             LEVEL ;
288
             COMPARE ;
289
             LE ;
290
             IF {} { PUSH string "VOTING_FINISHED" ; FAILWITH } ;
291
             DUP ;
292
             GET 5 ;
293
             LEVEL ;
294
             COMPARE ;
295
             GE ;
296
             IF {} { PUSH string "VOTING_NOT_STARTED" ; FAILWITH } ;
297
             PUSH nat 3 ;
298
             DIG 2 ;
299
             CAR ;
300
             COMPARE ;
301
             LT ;
302
             IF {} { PUSH string "BAD_VOTE_VALUE" ; FAILWITH } ;
303
             PAIR } ;
304
         SWAP ;
305
         UNPAIR ;
306
         IF_LEFT
307
           { IF_LEFT
308
               { IF_LEFT
309
                   { AMOUNT ;
310
                     PUSH mutez 0 ;
311
                     COMPARE ;
312
                     EQ ;
313
                     IF {} { AMOUNT ; FAILWITH } ;
314
                     SWAP ;
315
                     DUP ;
316
                     DUG 2 ;
317
                     GET 5 ;
318
                     IF_NONE { PUSH string "NO_ITEM_IN_TIMELOCK" ; FAILWITH } {} ;
319
                     DUP ;
320
                     GET 7 ;
321
                     LEVEL ;
322
                     DIG 3 ;
323
                     DROP ;
324
                     DIG 4 ;
325
                     DROP ;
326
                     COMPARE ;
327
                     GE ;
328
                     IF {} { PUSH string "TOO_SOON" ; FAILWITH } ;
329
                     CAR ;
330
                     SWAP ;
331
                     DUP ;
332
                     DUG 2 ;
333
                     CAR ;
334
                     GET 5 ;
335
                     SWAP ;
336
                     DUP ;
337
                     DUG 2 ;
338
                     GET ;
339
                     IF_NONE { PUSH int 423 ; FAILWITH } {} ;
340
                     DIG 2 ;
341
                     UNPAIR ;
342
                     UNPAIR ;
343
                     SWAP ;
344
                     UNPAIR ;
345
                     SWAP ;
346
                     UNPAIR ;
347
                     DIG 5 ;
348
                     CDR ;
349
                     PUSH nat 3 ;
350
                     PAIR ;
351
                     SOME ;
352
                     DIG 6 ;
353
                     UPDATE ;
354
                     PAIR ;
355
                     SWAP ;
356
                     PAIR ;
357
                     SWAP ;
358
                     PAIR ;
359
                     PAIR ;
360
                     NONE (pair nat
361
                                (pair
362
                                  (pair string
363
                                        (pair string
364
                                              (pair string
365
                                                    (lambda unit (list operation)))))
366
                                  (pair nat (pair nat address)))) ;
367
                     UPDATE 5 }
368
                   { AMOUNT ;
369
                     PUSH mutez 0 ;
370
                     COMPARE ;
371
                     EQ ;
372
                     IF {} { AMOUNT ; FAILWITH } ;
373
                     DIG 2 ;
374
                     SWAP ;
375
                     DUP ;
376
                     DUG 2 ;
377
                     SWAP ;
378
                     DIG 3 ;
379
                     DIG 2 ;
380
                     PAIR ;
381
                     EXEC ;
382
                     UNPAIR ;
383
                     SWAP ;
384
                     DUP ;
385
                     DUG 3 ;
386
                     GET 7 ;
387
                     SWAP ;
388
                     DUP ;
389
                     DUG 2 ;
390
                     CAR ;
391
                     DUP 4 ;
392
                     CDR ;
393
                     SENDER ;
394
                     PAIR 3 ;
395
                     MEM ;
396
                     IF {} { PUSH string "MUST_VOTE_FIRST" ; FAILWITH } ;
397
                     DUP 3 ;
398
                     GET 7 ;
399
                     SWAP ;
400
                     DUP ;
401
                     DUG 2 ;
402
                     CAR ;
403
                     DUP 4 ;
404
                     CDR ;
405
                     SENDER ;
406
                     PAIR 3 ;
407
                     GET ;
408
                     IF_NONE { PUSH int 233 ; FAILWITH } {} ;
409
                     DUP 3 ;
410
                     CAR ;
411
                     SWAP ;
412
                     DUP ;
413
                     DUG 2 ;
414
                     CAR ;
415
                     COMPARE ;
416
                     NEQ ;
417
                     IF {} { PUSH string "BAD_VOTE_VALUE" ; FAILWITH } ;
418
                     SWAP ;
419
                     DUP ;
420
                     GET 9 ;
421
                     DUP ;
422
                     DUP 5 ;
423
                     CAR ;
424
                     DUP ;
425
                     DUG 2 ;
426
                     GET ;
427
                     IF_NONE { PUSH int 237 ; FAILWITH } {} ;
428
                     DUP 5 ;
429
                     CDR ;
430
                     ADD ;
431
                     SOME ;
432
                     SWAP ;
433
                     UPDATE ;
434
                     UPDATE 9 ;
435
                     DUP ;
436
                     DUG 2 ;
437
                     DUP ;
438
                     GET 9 ;
439
                     DUP 3 ;
440
                     CDR ;
441
                     DIG 4 ;
442
                     GET 9 ;
443
                     DUP 5 ;
444
                     CAR ;
445
                     GET ;
446
                     IF_NONE { PUSH int 239 ; FAILWITH } {} ;
447
                     SUB ;
448
                     ISNAT ;
449
                     IF_NONE { PUSH int 238 ; FAILWITH } {} ;
450
                     SOME ;
451
                     DUP 4 ;
452
                     CAR ;
453
                     UPDATE ;
454
                     UPDATE 9 ;
455
                     SWAP ;
456
                     DIG 3 ;
457
                     DUP ;
458
                     GET 7 ;
459
                     DIG 2 ;
460
                     CDR ;
461
                     DUP 5 ;
462
                     CAR ;
463
                     PAIR ;
464
                     SOME ;
465
                     DUP 4 ;
466
                     CAR ;
467
                     DIG 5 ;
468
                     CDR ;
469
                     SENDER ;
470
                     PAIR 3 ;
471
                     UPDATE ;
472
                     UPDATE 7 ;
473
                     UNPAIR ;
474
                     SWAP ;
475
                     UNPAIR ;
476
                     UNPAIR ;
477
                     SWAP ;
478
                     CDR ;
479
                     DIG 4 ;
480
                     SOME ;
481
                     PAIR ;
482
                     SWAP ;
483
                     PAIR ;
484
                     PAIR ;
485
                     SWAP ;
486
                     PAIR } ;
487
                 NIL operation }
488
               { IF_LEFT
489
                   { AMOUNT ;
490
                     PUSH mutez 0 ;
491
                     COMPARE ;
492
                     EQ ;
493
                     IF {} { AMOUNT ; FAILWITH } ;
494
                     SWAP ;
495
                     DUP ;
496
                     DUG 2 ;
497
                     GET 5 ;
498
                     IF_NONE {} { PUSH string "ITEM_IN_TIMELOCK" ; FAILWITH } ;
499
                     SWAP ;
500
                     DUP ;
501
                     DUG 2 ;
502
                     GET 3 ;
503
                     GET 3 ;
504
                     IF_NONE { PUSH string "NO_POLL" ; FAILWITH } {} ;
505
                     DUP ;
506
                     GET 7 ;
507
                     LEVEL ;
508
                     COMPARE ;
509
                     GT ;
510
                     IF {} { PUSH string "VOTING_NOT_FINISHED" ; FAILWITH } ;
511
                     DUP 3 ;
512
                     GET 8 ;
513
                     UNIT ;
514
                     VIEW "view_disc_factor" nat ;
515
                     IF_NONE
516
                       { PUSH string "Invalue View: view_disc_factor" ; FAILWITH }
517
                       {} ;
518
                     PUSH nat 100 ;
519
                     DUP 5 ;
520
                     CAR ;
521
                     GET 3 ;
522
                     GET 7 ;
523
                     PUSH nat 1000000000000 ;
524
                     DUP 4 ;
525
                     DUP 6 ;
526
                     GET 9 ;
527
                     PUSH nat 0 ;
528
                     GET ;
529
                     IF_NONE { PUSH int 318 ; FAILWITH } {} ;
530
                     MUL ;
531
                     EDIV ;
532
                     IF_NONE { PUSH int 318 ; FAILWITH } { CAR } ;
533
                     PUSH nat 1000000000000 ;
534
                     DUP 5 ;
535
                     DUP 7 ;
536
                     GET 9 ;
537
                     PUSH nat 1 ;
538
                     GET ;
539
                     IF_NONE { PUSH int 317 ; FAILWITH } {} ;
540
                     MUL ;
541
                     EDIV ;
542
                     IF_NONE { PUSH int 317 ; FAILWITH } { CAR } ;
543
                     ADD ;
544
                     MUL ;
545
                     EDIV ;
546
                     IF_NONE { PUSH int 325 ; FAILWITH } { CAR } ;
547
                     PUSH nat 100 ;
548
                     DUP 6 ;
549
                     CAR ;
550
                     GET 3 ;
551
                     GET 13 ;
552
                     PUSH nat 1000000000000 ;
553
                     DUP 5 ;
554
                     DUP 7 ;
555
                     GET 9 ;
556
                     PUSH nat 0 ;
557
                     GET ;
558
                     IF_NONE { PUSH int 318 ; FAILWITH } {} ;
559
                     MUL ;
560
                     EDIV ;
561
                     IF_NONE { PUSH int 318 ; FAILWITH } { CAR } ;
562
                     PUSH nat 1000000000000 ;
563
                     DUP 6 ;
564
                     DUP 8 ;
565
                     GET 9 ;
566
                     PUSH nat 1 ;
567
                     GET ;
568
                     IF_NONE { PUSH int 317 ; FAILWITH } {} ;
569
                     MUL ;
570
                     EDIV ;
571
                     IF_NONE { PUSH int 317 ; FAILWITH } { CAR } ;
572
                     ADD ;
573
                     MUL ;
574
                     EDIV ;
575
                     IF_NONE { PUSH int 328 ; FAILWITH } { CAR } ;
576
                     DUP 6 ;
577
                     CAR ;
578
                     CAR ;
579
                     GET 3 ;
580
                     DUP 3 ;
581
                     PUSH nat 1000000000000 ;
582
                     DUP 6 ;
583
                     DUP 8 ;
584
                     GET 9 ;
585
                     PUSH nat 1 ;
586
                     GET ;
587
                     IF_NONE { PUSH int 317 ; FAILWITH } {} ;
588
                     MUL ;
589
                     EDIV ;
590
                     IF_NONE { PUSH int 317 ; FAILWITH } { CAR } ;
591
                     COMPARE ;
592
                     GE ;
593
                     IF { DROP ; DUP 4 ; GET 13 } {} ;
594
                     DUP 7 ;
595
                     CAR ;
596
                     CAR ;
597
                     GET 4 ;
598
                     IF_LEFT
599
                       { PUSH nat 0 ;
600
                         DUP 9 ;
601
                         CAR ;
602
                         GET 3 ;
603
                         CAR ;
604
                         COMPARE ;
605
                         GT ;
606
                         IF
607
                           { CONTRACT %transfer (pair (address %from)
608
                                                      (pair (address %to) (nat %value))) ;
609
                             IF_NONE { PUSH int 19 ; FAILWITH } {} ;
610
                             NIL operation ;
611
                             SWAP ;
612
                             PUSH mutez 0 ;
613
                             DUP 10 ;
614
                             CAR ;
615
                             GET 3 ;
616
                             CAR ;
617
                             DUP 5 ;
618
                             SELF_ADDRESS ;
619
                             PAIR 3 ;
620
                             TRANSFER_TOKENS ;
621
                             CONS }
622
                           { DROP ; NIL operation } }
623
                       { IF_LEFT
624
                           { PUSH nat 0 ;
625
                             DUP 9 ;
626
                             CAR ;
627
                             GET 3 ;
628
                             CAR ;
629
                             COMPARE ;
630
                             GT ;
631
                             IF
632
                               { DUP ;
633
                                 CAR ;
634
                                 CONTRACT %transfer (list (pair (address %from_)
635
                                                               (list %txs (pair
636
                                                                           (address %to_)
637
                                                                           (pair
638
                                                                             (nat %token_id)
639
                                                                             (nat %amount)))))) ;
640
                                 IF_NONE { PUSH int 36 ; FAILWITH } {} ;
641
                                 NIL operation ;
642
                                 SWAP ;
643
                                 PUSH mutez 0 ;
644
                                 NIL (pair address (list (pair address (pair nat nat)))) ;
645
                                 NIL (pair address (pair nat nat)) ;
646
                                 DUP 13 ;
647
                                 CAR ;
648
                                 GET 3 ;
649
                                 CAR ;
650
                                 DIG 6 ;
651
                                 CDR ;
652
                                 DUP 8 ;
653
                                 PAIR 3 ;
654
                                 CONS ;
655
                                 SELF_ADDRESS ;
656
                                 PAIR ;
657
                                 CONS ;
658
                                 TRANSFER_TOKENS ;
659
                                 CONS }
660
                               { DROP ; NIL operation } }
661
                           { DROP ;
662
                             DUP ;
663
                             CONTRACT unit ;
664
                             IF_NONE { PUSH int 340 ; FAILWITH } {} ;
665
                             NIL operation ;
666
                             SWAP ;
667
                             PUSH mutez 1 ;
668
                             DUP 10 ;
669
                             CAR ;
670
                             GET 3 ;
671
                             CAR ;
672
                             MUL ;
673
                             UNIT ;
674
                             TRANSFER_TOKENS ;
675
                             CONS } } ;
676
                     DUP 3 ;
677
                     PUSH nat 1000000000000 ;
678
                     DUP 7 ;
679
                     DUP 9 ;
680
                     GET 9 ;
681
                     PUSH nat 1 ;
682
                     GET ;
683
                     IF_NONE { PUSH int 317 ; FAILWITH } {} ;
684
                     MUL ;
685
                     EDIV ;
686
                     IF_NONE { PUSH int 317 ; FAILWITH } { CAR } ;
687
                     COMPARE ;
688
                     GE ;
689
                     IF
690
                       { DUP 8 ;
691
                         GET 3 ;
692
                         GET 4 ;
693
                         PUSH nat 1000000000000 ;
694
                         DUP 7 ;
695
                         DUP 9 ;
696
                         GET 11 ;
697
                         MUL ;
698
                         EDIV ;
699
                         IF_NONE { PUSH int 320 ; FAILWITH } { CAR } ;
700
                         COMPARE ;
701
                         GE }
702
                       { PUSH bool False } ;
703
                     IF
704
                       { DUP 8 ;
705
                         DUP 7 ;
706
                         GET 13 ;
707
                         DUP 10 ;
708
                         CAR ;
709
                         GET 3 ;
710
                         GET 11 ;
711
                         LEVEL ;
712
                         ADD ;
713
                         DUP 11 ;
714
                         CAR ;
715
                         GET 3 ;
716
                         GET 9 ;
717
                         LEVEL ;
718
                         ADD ;
719
                         DIG 9 ;
720
                         DUP ;
721
                         GET 3 ;
722
                         SWAP ;
723
                         DUP ;
724
                         DUG 11 ;
725
                         CAR ;
726
                         PAIR 5 ;
727
                         DIG 3 ;
728
                         DROP ;
729
                         DIG 3 ;
730
                         DROP ;
731
                         DIG 3 ;
732
                         DROP ;
733
                         DIG 5 ;
734
                         DROP ;
735
                         DIG 5 ;
736
                         DROP ;
737
                         DIG 5 ;
738
                         DROP ;
739
                         SOME ;
740
                         UPDATE 5 ;
741
                         UNPAIR ;
742
                         UNPAIR ;
743
                         SWAP ;
744
                         UNPAIR ;
745
                         SWAP ;
746
                         UNPAIR ;
747
                         DUP 8 ;
748
                         PUSH nat 1 ;
749
                         PAIR ;
750
                         SOME ;
751
                         DUP 9 ;
752
                         CAR ;
753
                         UPDATE ;
754
                         PAIR ;
755
                         SWAP ;
756
                         PAIR ;
757
                         SWAP ;
758
                         PAIR ;
759
                         PAIR ;
760
                         DUG 3 }
761
                       { SWAP ;
762
                         DROP ;
763
                         SWAP ;
764
                         DROP ;
765
                         SWAP ;
766
                         DROP ;
767
                         DIG 3 ;
768
                         DROP ;
769
                         DIG 4 ;
770
                         DROP ;
771
                         DIG 3 ;
772
                         UNPAIR ;
773
                         UNPAIR ;
774
                         SWAP ;
775
                         UNPAIR ;
776
                         SWAP ;
777
                         UNPAIR ;
778
                         DUP 8 ;
779
                         PUSH nat 0 ;
780
                         PAIR ;
781
                         SOME ;
782
                         DUP 9 ;
783
                         CAR ;
784
                         UPDATE ;
785
                         PAIR ;
786
                         SWAP ;
787
                         PAIR ;
788
                         SWAP ;
789
                         PAIR ;
790
                         PAIR ;
791
                         DUG 3 } ;
792
                     PUSH nat 100 ;
793
                     PUSH nat 20 ;
794
                     PUSH nat 1000000000000 ;
795
                     DIG 4 ;
796
                     DUP 6 ;
797
                     GET 11 ;
798
                     MUL ;
799
                     EDIV ;
800
                     IF_NONE { PUSH int 320 ; FAILWITH } { CAR } ;
801
                     MUL ;
802
                     PUSH nat 80 ;
803
                     DUP 5 ;
804
                     GET 17 ;
805
                     MUL ;
806
                     ADD ;
807
                     EDIV ;
808
                     IF_NONE { PUSH int 362 ; FAILWITH } { CAR } ;
809
                     DUP 3 ;
810
                     GET 20 ;
811
                     DUP ;
812
                     DUP 3 ;
813
                     COMPARE ;
814
                     LE ;
815
                     IF { DROP } { SWAP ; DROP } ;
816
                     DIG 2 ;
817
                     GET 19 ;
818
                     DUP ;
819
                     DUP 3 ;
820
                     COMPARE ;
821
                     LE ;
822
                     IF { SWAP ; DROP } { DROP } ;
823
                     DIG 2 ;
824
                     UNPAIR ;
825
                     SWAP ;
826
                     UNPAIR ;
827
                     CAR ;
828
                     DIG 3 ;
829
                     NONE (pair nat
830
                                (pair
831
                                  (pair string
832
                                        (pair string
833
                                              (pair string
834
                                                    (lambda unit (list operation)))))
835
                                  (pair nat
836
                                        (pair nat
837
                                              (pair (map nat nat)
838
                                                    (pair nat
839
                                                          (pair address
840
                                                                (pair nat
841
                                                                      (pair nat
842
                                                                            (pair nat
843
                                                                                  nat)))))))))) ;
844
                     PAIR ;
845
                     SWAP ;
846
                     PAIR ;
847
                     PAIR ;
848
                     SWAP ;
849
                     PAIR ;
850
                     SWAP }
851
                   { IF_LEFT
852
                       { AMOUNT ;
853
                         PUSH mutez 0 ;
854
                         COMPARE ;
855
                         EQ ;
856
                         IF {} { AMOUNT ; FAILWITH } ;
857
                         SWAP ;
858
                         DUP ;
859
                         DUG 2 ;
860
                         GET 5 ;
861
                         IF_NONE { PUSH string "NO_ITEM_IN_TIMELOCK" ; FAILWITH } {} ;
862
                         DUP ;
863
                         GET 8 ;
864
                         SENDER ;
865
                         COMPARE ;
866
                         EQ ;
867
                         IF {} { PUSH string "NOT_AUTHOR" ; FAILWITH } ;
868
                         DUP ;
869
                         GET 5 ;
870
                         LEVEL ;
871
                         DIG 3 ;
872
                         DROP ;
873
                         DIG 4 ;
874
                         DROP ;
875
                         COMPARE ;
876
                         GE ;
877
                         IF {} { PUSH string "TOO_SOON" ; FAILWITH } ;
878
                         DUP ;
879
                         GET 3 ;
880
                         GET 6 ;
881
                         NIL operation ;
882
                         SWAP ;
883
                         UNIT ;
884
                         EXEC ;
885
                         ITER { CONS } ;
886
                         SWAP ;
887
                         CAR ;
888
                         DUP 3 ;
889
                         CAR ;
890
                         GET 5 ;
891
                         SWAP ;
892
                         DUP ;
893
                         DUG 2 ;
894
                         GET ;
895
                         IF_NONE { PUSH int 396 ; FAILWITH } {} ;
896
                         DIG 3 ;
897
                         UNPAIR ;
898
                         UNPAIR ;
899
                         SWAP ;
900
                         UNPAIR ;
901
                         SWAP ;
902
                         UNPAIR ;
903
                         DIG 5 ;
904
                         CDR ;
905
                         PUSH nat 2 ;
906
                         PAIR ;
907
                         SOME ;
908
                         DIG 6 ;
909
                         UPDATE ;
910
                         PAIR ;
911
                         SWAP ;
912
                         PAIR ;
913
                         SWAP ;
914
                         PAIR ;
915
                         PAIR ;
916
                         NONE (pair nat
917
                                    (pair
918
                                      (pair string
919
                                            (pair string
920
                                                  (pair string
921
                                                        (lambda unit (list operation)))))
922
                                      (pair nat (pair nat address)))) ;
923
                         UPDATE 5 ;
924
                         SWAP }
925
                       { SWAP ;
926
                         DUP ;
927
                         DUG 2 ;
928
                         GET 3 ;
929
                         GET 3 ;
930
                         IF_NONE {} { PUSH string "POLL_UNDERWAY" ; FAILWITH } ;
931
                         SWAP ;
932
                         DUP ;
933
                         DUG 2 ;
934
                         CAR ;
935
                         CAR ;
936
                         GET 4 ;
937
                         IF_LEFT
938
                           { PUSH nat 0 ;
939
                             DUP 4 ;
940
                             CAR ;
941
                             GET 3 ;
942
                             CAR ;
943
                             COMPARE ;
944
                             GT ;
945
                             IF
946
                               { CONTRACT %transfer (pair (address %from)
947
                                                          (pair (address %to)
948
                                                                (nat %value))) ;
949
                                 IF_NONE { PUSH int 19 ; FAILWITH } {} ;
950
                                 NIL operation ;
951
                                 SWAP ;
952
                                 PUSH mutez 0 ;
953
                                 DUP 5 ;
954
                                 CAR ;
955
                                 GET 3 ;
956
                                 CAR ;
957
                                 SELF_ADDRESS ;
958
                                 SENDER ;
959
                                 PAIR 3 ;
960
                                 TRANSFER_TOKENS ;
961
                                 CONS }
962
                               { DROP ; NIL operation } }
963
                           { IF_LEFT
964
                               { PUSH nat 0 ;
965
                                 DUP 4 ;
966
                                 CAR ;
967
                                 GET 3 ;
968
                                 CAR ;
969
                                 COMPARE ;
970
                                 GT ;
971
                                 IF
972
                                   { DUP ;
973
                                     CAR ;
974
                                     CONTRACT %transfer (list (pair (address %from_)
975
                                                                   (list %txs (pair
976
                                                                               (address %to_)
977
                                                                               (pair
978
                                                                                 (nat %token_id)
979
                                                                                 (nat %amount)))))) ;
980
                                     IF_NONE { PUSH int 36 ; FAILWITH } {} ;
981
                                     NIL operation ;
982
                                     SWAP ;
983
                                     PUSH mutez 0 ;
984
                                     NIL (pair address
985
                                               (list (pair address (pair nat nat)))) ;
986
                                     NIL (pair address (pair nat nat)) ;
987
                                     DUP 8 ;
988
                                     CAR ;
989
                                     GET 3 ;
990
                                     CAR ;
991
                                     DIG 6 ;
992
                                     CDR ;
993
                                     SELF_ADDRESS ;
994
                                     PAIR 3 ;
995
                                     CONS ;
996
                                     SENDER ;
997
                                     PAIR ;
998
                                     CONS ;
999
                                     TRANSFER_TOKENS ;
1000
                                     CONS }
1001
                                   { DROP ; NIL operation } }
1002
                               { DROP ;
1003
                                 PUSH mutez 1 ;
1004
                                 DUP 3 ;
1005
                                 CAR ;
1006
                                 GET 3 ;
1007
                                 CAR ;
1008
                                 MUL ;
1009
                                 AMOUNT ;
1010
                                 COMPARE ;
1011
                                 EQ ;
1012
                                 IF {} { PUSH string "NOT_ENOUGH_ESCROW" ; FAILWITH } ;
1013
                                 NIL operation } } ;
1014
                         DUP 3 ;
1015
                         CAR ;
1016
                         GET 3 ;
1017
                         GET 3 ;
1018
                         LEVEL ;
1019
                         ADD ;
1020
                         DUP 4 ;
1021
                         CAR ;
1022
                         GET 3 ;
1023
                         GET 5 ;
1024
                         SWAP ;
1025
                         DUP ;
1026
                         DUG 2 ;
1027
                         ADD ;
1028
                         DUP 5 ;
1029
                         UNPAIR ;
1030
                         SWAP ;
1031
                         UNPAIR ;
1032
                         UNPAIR ;
1033
                         SWAP ;
1034
                         CDR ;
1035
                         DIG 8 ;
1036
                         DUP ;
1037
                         CAR ;
1038
                         GET 3 ;
1039
                         GET 14 ;
1040
                         SWAP ;
1041
                         DUP ;
1042
                         GET 3 ;
1043
                         GET 4 ;
1044
                         SWAP ;
1045
                         DUP ;
1046
                         DUG 11 ;
1047
                         CAR ;
1048
                         GET 3 ;
1049
                         CAR ;
1050
                         SENDER ;
1051
                         PUSH nat 0 ;
1052
                         PUSH (map nat nat) { Elt 0 0 ; Elt 1 0 ; Elt 2 0 } ;
1053
                         DUP 11 ;
1054
                         DUP 13 ;
1055
                         DUP 16 ;
1056
                         DUP 18 ;
1057
                         GET 3 ;
1058
                         CAR ;
1059
                         PAIR 10 ;
1060
                         DIG 5 ;
1061
                         DROP ;
1062
                         DIG 5 ;
1063
                         DROP ;
1064
                         DIG 6 ;
1065
                         DROP ;
1066
                         DIG 6 ;
1067
                         DROP ;
1068
                         DIG 6 ;
1069
                         DROP ;
1070
                         SOME ;
1071
                         PAIR ;
1072
                         SWAP ;
1073
                         PUSH nat 1 ;
1074
                         ADD ;
1075
                         PAIR ;
1076
                         PAIR ;
1077
                         SWAP ;
1078
                         PAIR ;
1079
                         SWAP } } } }
1080
           { IF_LEFT
1081
               { IF_LEFT
1082
                   { AMOUNT ;
1083
                     PUSH mutez 0 ;
1084
                     COMPARE ;
1085
                     EQ ;
1086
                     IF {} { AMOUNT ; FAILWITH } ;
1087
                     DUP ;
1088
                     SIZE ;
1089
                     PUSH nat 50 ;
1090
                     SWAP ;
1091
                     COMPARE ;
1092
                     LE ;
1093
                     IF {} { PUSH string "TOO_MANY_STAKES_TO_RETURN" ; FAILWITH } ;
1094
                     SWAP ;
1095
                     DUP ;
1096
                     DUG 2 ;
1097
                     GET 3 ;
1098
                     CAR ;
1099
                     DUP 3 ;
1100
                     GET 3 ;
1101
                     GET 3 ;
1102
                     IF_NONE
1103
                       {}
1104
                       { DROP 2 ;
1105
                         SWAP ;
1106
                         DUP ;
1107
                         DUG 2 ;
1108
                         GET 3 ;
1109
                         GET 3 ;
1110
                         IF_NONE { PUSH int 263 ; FAILWITH } {} ;
1111
                         CAR } ;
1112
                     NIL (pair address (list (pair address (pair nat nat)))) ;
1113
                     DUP 3 ;
1114
                     ITER { DUP 3 ;
1115
                            SWAP ;
1116
                            DUP ;
1117
                            DUG 2 ;
1118
                            GET 4 ;
1119
                            COMPARE ;
1120
                            LT ;
1121
                            IF {} { PUSH string "NOT_ALLOWED" ; FAILWITH } ;
1122
                            DUP 5 ;
1123
                            GET 7 ;
1124
                            SWAP ;
1125
                            DUP ;
1126
                            DUG 2 ;
1127
                            MEM ;
1128
                            IF {} { PUSH string "NOT_ALLOWED" ; FAILWITH } ;
1129
                            SWAP ;
1130
                            NIL (pair address (pair nat nat)) ;
1131
                            PUSH nat 1 ;
1132
                            DIG 3 ;
1133
                            DUP ;
1134
                            GET 3 ;
1135
                            SWAP ;
1136
                            DUP ;
1137
                            DUG 5 ;
1138
                            CAR ;
1139
                            PAIR 3 ;
1140
                            CONS ;
1141
                            SELF_ADDRESS ;
1142
                            PAIR ;
1143
                            CONS ;
1144
                            SWAP ;
1145
                            DIG 4 ;
1146
                            DUP ;
1147
                            GET 7 ;
1148
                            NONE (pair nat nat) ;
1149
                            DIG 3 ;
1150
                            UPDATE ;
1151
                            UPDATE 7 ;
1152
                            DUG 3 } ;
1153
                     SWAP ;
1154
                     DROP ;
1155
                     SWAP ;
1156
                     DROP ;
1157
                     DIG 2 ;
1158
                     DROP ;
1159
                     NIL operation ;
1160
                     DUP 3 ;
1161
                     GET 8 ;
1162
                     CONTRACT %transfer (list (pair (address %from_)
1163
                                                   (list %txs (pair (address %to_)
1164
                                                                   (pair (nat %token_id)
1165
                                                                         (nat %amount)))))) ;
1166
                     IF_NONE { PUSH string "NOT_TOKEN_CONTRACT" ; FAILWITH } {} ;
1167
                     PUSH mutez 0 ;
1168
                     DIG 3 ;
1169
                     TRANSFER_TOKENS ;
1170
                     CONS }
1171
                   { DIG 2 ;
1172
                     DROP ;
1173
                     IF_LEFT
1174
                       { AMOUNT ;
1175
                         PUSH mutez 0 ;
1176
                         COMPARE ;
1177
                         EQ ;
1178
                         IF {} { AMOUNT ; FAILWITH } ;
1179
                         SELF_ADDRESS ;
1180
                         SENDER ;
1181
                         COMPARE ;
1182
                         EQ ;
1183
                         IF {} { PUSH string "NOT_ALLOWED" ; FAILWITH } ;
1184
                         SWAP ;
1185
                         UNPAIR ;
1186
                         UNPAIR ;
1187
                         CDR ;
1188
                         DIG 3 ;
1189
                         PAIR ;
1190
                         PAIR ;
1191
                         PAIR }
1192
                       { AMOUNT ;
1193
                         PUSH mutez 0 ;
1194
                         COMPARE ;
1195
                         EQ ;
1196
                         IF {} { AMOUNT ; FAILWITH } ;
1197
                         SELF_ADDRESS ;
1198
                         SENDER ;
1199
                         COMPARE ;
1200
                         EQ ;
1201
                         IF {} { PUSH string "NOT_ALLOWED" ; FAILWITH } ;
1202
                         SWAP ;
1203
                         UNPAIR ;
1204
                         UNPAIR ;
1205
                         UNPAIR ;
1206
                         SWAP ;
1207
                         CDR ;
1208
                         DIG 4 ;
1209
                         PAIR ;
1210
                         SWAP ;
1211
                         PAIR ;
1212
                         PAIR ;
1213
                         PAIR } ;
1214
                     NIL operation } }
1215
               { IF_LEFT
1216
                   { DIG 2 ;
1217
                     DROP ;
1218
                     AMOUNT ;
1219
                     PUSH mutez 0 ;
1220
                     COMPARE ;
1221
                     EQ ;
1222
                     IF {} { AMOUNT ; FAILWITH } ;
1223
                     SWAP ;
1224
                     DUP ;
1225
                     DUG 2 ;
1226
                     CAR ;
1227
                     CAR ;
1228
                     CAR ;
1229
                     IF_NONE
1230
                       { SELF_ADDRESS ;
1231
                         SENDER ;
1232
                         COMPARE ;
1233
                         EQ ;
1234
                         IF {} { PUSH string "NOT_ALLOWED" ; FAILWITH } }
1235
                       { DROP ;
1236
                         SWAP ;
1237
                         DUP ;
1238
                         DUG 2 ;
1239
                         CAR ;
1240
                         CAR ;
1241
                         CAR ;
1242
                         IF_NONE
1243
                           { PUSH string "NO_BREAK_GLASS_CONTRACT_SET" ; FAILWITH }
1244
                           {} ;
1245
                         SELF_ADDRESS ;
1246
                         SENDER ;
1247
                         COMPARE ;
1248
                         EQ ;
1249
                         IF { DROP ; PUSH bool True } { SENDER ; COMPARE ; EQ } ;
1250
                         IF {} { PUSH string "NOT_ALLOWED" ; FAILWITH } } ;
1251
                     SWAP ;
1252
                     UNPAIR ;
1253
                     UNPAIR ;
1254
                     SWAP ;
1255
                     CDR ;
1256
                     DIG 3 ;
1257
                     PAIR ;
1258
                     SWAP ;
1259
                     PAIR ;
1260
                     PAIR ;
1261
                     NIL operation }
1262
                   { IF_LEFT
1263
                       { AMOUNT ;
1264
                         PUSH mutez 0 ;
1265
                         COMPARE ;
1266
                         EQ ;
1267
                         IF {} { AMOUNT ; FAILWITH } ;
1268
                         SWAP ;
1269
                         DUP ;
1270
                         DUG 2 ;
1271
                         CAR ;
1272
                         CAR ;
1273
                         CAR ;
1274
                         IF_NONE
1275
                           { PUSH string "NO_BREAK_GLASS_CONTRACT_SET" ; FAILWITH }
1276
                           {} ;
1277
                         DUP ;
1278
                         SENDER ;
1279
                         COMPARE ;
1280
                         EQ ;
1281
                         IF {} { PUSH string "NOT_ALLOWED" ; FAILWITH } ;
1282
                         DUP 3 ;
1283
                         GET 5 ;
1284
                         IF_NONE { PUSH string "NO_ITEM_IN_TIMELOCK" ; FAILWITH } {} ;
1285
                         DUP ;
1286
                         GET 5 ;
1287
                         LEVEL ;
1288
                         DIG 3 ;
1289
                         DROP ;
1290
                         DIG 3 ;
1291
                         DROP ;
1292
                         DIG 4 ;
1293
                         DROP ;
1294
                         COMPARE ;
1295
                         LT ;
1296
                         IF {} { PUSH string "TOO_LATE" ; FAILWITH } ;
1297
                         CAR ;
1298
                         SWAP ;
1299
                         DUP ;
1300
                         DUG 2 ;
1301
                         CAR ;
1302
                         GET 5 ;
1303
                         SWAP ;
1304
                         DUP ;
1305
                         DUG 2 ;
1306
                         GET ;
1307
                         IF_NONE { PUSH int 454 ; FAILWITH } {} ;
1308
                         DIG 2 ;
1309
                         UNPAIR ;
1310
                         UNPAIR ;
1311
                         SWAP ;
1312
                         UNPAIR ;
1313
                         SWAP ;
1314
                         UNPAIR ;
1315
                         DIG 5 ;
1316
                         CDR ;
1317
                         PUSH nat 4 ;
1318
                         PAIR ;
1319
                         SOME ;
1320
                         DIG 6 ;
1321
                         UPDATE ;
1322
                         PAIR ;
1323
                         SWAP ;
1324
                         PAIR ;
1325
                         SWAP ;
1326
                         PAIR ;
1327
                         PAIR ;
1328
                         NONE (pair nat
1329
                                    (pair
1330
                                      (pair string
1331
                                            (pair string
1332
                                                  (pair string
1333
                                                        (lambda unit (list operation)))))
1334
                                      (pair nat (pair nat address)))) ;
1335
                         UPDATE 5 ;
1336
                         NIL operation }
1337
                       { AMOUNT ;
1338
                         PUSH mutez 0 ;
1339
                         COMPARE ;
1340
                         EQ ;
1341
                         IF {} { AMOUNT ; FAILWITH } ;
1342
                         DIG 2 ;
1343
                         SWAP ;
1344
                         DUP ;
1345
                         DUG 2 ;
1346
                         SWAP ;
1347
                         DIG 3 ;
1348
                         DIG 2 ;
1349
                         PAIR ;
1350
                         EXEC ;
1351
                         UNPAIR ;
1352
                         SWAP ;
1353
                         DUP ;
1354
                         DUG 3 ;
1355
                         GET 7 ;
1356
                         SWAP ;
1357
                         DUP ;
1358
                         DUG 2 ;
1359
                         CAR ;
1360
                         DUP 4 ;
1361
                         CDR ;
1362
                         SENDER ;
1363
                         PAIR 3 ;
1364
                         MEM ;
1365
                         IF { PUSH string "ALREADY_VOTED" ; FAILWITH } {} ;
1366
                         DUP 3 ;
1367
                         GET 8 ;
1368
                         SENDER ;
1369
                         VIEW "view_owner_stakes" (set nat) ;
1370
                         IF_NONE
1371
                           { PUSH string "Invalid View: view_owner_stakes" ; FAILWITH }
1372
                           {} ;
1373
                         DUP 3 ;
1374
                         CDR ;
1375
                         MEM ;
1376
                         IF {} { PUSH string "NOT_OWNER" ; FAILWITH } ;
1377
                         DUP 3 ;
1378
                         GET 8 ;
1379
                         DUP 3 ;
1380
                         CDR ;
1381
                         VIEW "view_stake"
1382
                               (pair (nat %token_amount)
1383
                                     (pair (nat %stake) (timestamp %age_timestamp))) ;
1384
                         IF_NONE
1385
                           { PUSH string "Invalid View: view_stake" ; FAILWITH }
1386
                           {} ;
1387
                         SWAP ;
1388
                         DUP ;
1389
                         GET 9 ;
1390
                         DUP ;
1391
                         DUP 5 ;
1392
                         CAR ;
1393
                         DUP ;
1394
                         DUG 2 ;
1395
                         GET ;
1396
                         IF_NONE { PUSH int 194 ; FAILWITH } {} ;
1397
                         DUP 5 ;
1398
                         GET 3 ;
1399
                         ADD ;
1400
                         SOME ;
1401
                         SWAP ;
1402
                         UPDATE ;
1403
                         UPDATE 9 ;
1404
                         DUP ;
1405
                         GET 11 ;
1406
                         DUP 3 ;
1407
                         GET 3 ;
1408
                         ADD ;
1409
                         UPDATE 11 ;
1410
                         SWAP ;
1411
                         DIG 3 ;
1412
                         UNPAIR ;
1413
                         SWAP ;
1414
                         UNPAIR ;
1415
                         UNPAIR ;
1416
                         SWAP ;
1417
                         CDR ;
1418
                         DUP 6 ;
1419
                         SOME ;
1420
                         PAIR ;
1421
                         SWAP ;
1422
                         PAIR ;
1423
                         PAIR ;
1424
                         SWAP ;
1425
                         PAIR ;
1426
                         DUP ;
1427
                         GET 7 ;
1428
                         DIG 2 ;
1429
                         GET 3 ;
1430
                         DUP 5 ;
1431
                         CAR ;
1432
                         PAIR ;
1433
                         SOME ;
1434
                         DIG 3 ;
1435
                         CAR ;
1436
                         DUP 5 ;
1437
                         CDR ;
1438
                         SENDER ;
1439
                         PAIR 3 ;
1440
                         UPDATE ;
1441
                         UPDATE 7 ;
1442
                         SWAP ;
1443
                         NIL operation ;
1444
                         DUP 3 ;
1445
                         GET 8 ;
1446
                         CONTRACT %transfer (list (pair (address %from_)
1447
                                                       (list %txs (pair (address %to_)
1448
                                                                       (pair
1449
                                                                         (nat %token_id)
1450
                                                                         (nat %amount)))))) ;
1451
                         IF_NONE { PUSH string "NOT_TOKEN_CONTRACT" ; FAILWITH } {} ;
1452
                         PUSH mutez 0 ;
1453
                         NIL (pair address (list (pair address (pair nat nat)))) ;
1454
                         NIL (pair address (pair nat nat)) ;
1455
                         PUSH nat 1 ;
1456
                         DIG 6 ;
1457
                         CDR ;
1458
                         SELF_ADDRESS ;
1459
                         PAIR 3 ;
1460
                         CONS ;
1461
                         SENDER ;
1462
                         PAIR ;
1463
                         CONS ;
1464
                         TRANSFER_TOKENS ;
1465
                         CONS } } } } ;
1466
         NIL operation ;
1467
         SWAP ;
1468
         ITER { CONS } ;
1469
         PAIR } ;
1470
  view "get_current_poll_stats" unit (option (map nat nat))
1471
        { CDR ;
1472
          DUP ;
1473
          GET 3 ;
1474
          GET 3 ;
1475
          IF_NONE
1476
            { DROP ; NONE (map nat nat) }
1477
            { DROP ;
1478
              DUP ;
1479
              GET 3 ;
1480
              GET 3 ;
1481
              IF_NONE { PUSH int 523 ; FAILWITH } {} ;
1482
              GET 9 ;
1483
              SWAP ;
1484
              GET 8 ;
1485
              UNIT ;
1486
              VIEW "view_disc_factor" nat ;
1487
              IF_NONE { PUSH string "Invalue View: view_disc_factor" ; FAILWITH } {} ;
1488
              SWAP ;
1489
              DUP ;
1490
              DUG 2 ;
1491
              PUSH nat 1000000000000 ;
1492
              DUP 3 ;
1493
              DIG 4 ;
1494
              PUSH nat 1 ;
1495
              GET ;
1496
              IF_NONE { PUSH int 528 ; FAILWITH } {} ;
1497
              MUL ;
1498
              EDIV ;
1499
              IF_NONE { PUSH int 528 ; FAILWITH } { CAR } ;
1500
              SOME ;
1501
              PUSH nat 1 ;
1502
              UPDATE ;
1503
              DUP ;
1504
              DUG 2 ;
1505
              PUSH nat 1000000000000 ;
1506
              DUP 3 ;
1507
              DIG 4 ;
1508
              PUSH nat 0 ;
1509
              GET ;
1510
              IF_NONE { PUSH int 529 ; FAILWITH } {} ;
1511
              MUL ;
1512
              EDIV ;
1513
              IF_NONE { PUSH int 529 ; FAILWITH } { CAR } ;
1514
              SOME ;
1515
              PUSH nat 0 ;
1516
              UPDATE ;
1517
              DUP ;
1518
              DUG 2 ;
1519
              PUSH nat 1000000000000 ;
1520
              DIG 2 ;
1521
              DIG 3 ;
1522
              PUSH nat 2 ;
1523
              GET ;
1524
              IF_NONE { PUSH int 530 ; FAILWITH } {} ;
1525
              MUL ;
1526
              EDIV ;
1527
              IF_NONE { PUSH int 530 ; FAILWITH } { CAR } ;
1528
              SOME ;
1529
              PUSH nat 2 ;
1530
              UPDATE ;
1531
              SOME } } }