{ parameter (or (address %trigger_kernel_upgrade)

                (or (pair %vote (key_hash %sender_key_hash) (string %vote))

                    (or

                      (pair %upvote_proposal (key_hash %sender_key_hash) (bytes %hash))

                      (pair %new_proposal (key_hash %sender_key_hash) (bytes %hash))))) ;

  storage (pair

            (pair %config (nat %started_at_level)

                          (pair (nat %period_length)

                                (pair (nat %upvoting_limit)

                                      (pair (set %allowed_proposers address)

                                            (pair (nat %scale)

                                                  (pair (nat %proposal_quorum)

                                                        (pair (nat %promotion_quorum)

                                                              (nat %promotion_supermajority))))))))

            (pair

              (option %voting_context (pair (nat %period_index)

                                           (pair

                                             (or %period_type (unit %proposal)

                                                              (unit %promotion))

                                             (pair

                                               (pair %proposal_period

                                                 (map %proposals bytes

                                                                 (pair (bytes %payload)

                                                                       (pair

                                                                         (address %proposer)

                                                                         (map %votes

                                                                           address

                                                                           nat))))

                                                 (nat %total_voting_power))

                                               (pair

                                                 (option %promotion_period (pair

                                                                            (bytes %payload)

                                                                            (pair

                                                                              (map %votes

                                                                                address

                                                                                (pair

                                                                                  (string %vote)

                                                                                  (nat %voting_power)))

                                                                              (nat %total_voting_power))))

                                                 (option %last_winner_payload bytes))))))

              (big_map %metadata string bytes))) ;

  code { PUSH string "NOT_PROPOSAL_PERIOD" ;

         PUSH string "UPVOTING_LIMIT_EXCEEDED" ;

         PUSH string "yay" ;

         PUSH string "nay" ;

         LAMBDA

           unit

           unit

           { DROP ;

             PUSH string "XTZ_IN_TRANSACTION_DISALLOWED" ;

             PUSH mutez 0 ;

             AMOUNT ;

             COMPARE ;

             EQ ;

             IF { DROP ; UNIT } { FAILWITH } } ;

         LAMBDA

           key_hash

           unit

           { IMPLICIT_ACCOUNT ;

             ADDRESS ;

             PUSH string "SENDER_NOT_KEY_HASH_OWNER" ;

             SENDER ;

             DIG 2 ;

             COMPARE ;

             EQ ;

             IF { DROP ; UNIT } { FAILWITH } } ;

         LAMBDA

           nat

           unit

           { PUSH nat 0 ;

             SWAP ;

             COMPARE ;

             GT ;

             IF { UNIT } { PUSH string "NO_VOTING_POWER" ; FAILWITH } } ;

         LAMBDA

           (pair nat

                 (pair nat

                       (pair nat

                             (pair (set address) (pair nat (pair nat (pair nat nat)))))))

           nat

           { DUP ;

             CAR ;

             LEVEL ;

             SUB ;

             ISNAT ;

             IF_NONE

               { DROP ; PUSH string "CURRENT_LEVEL_LESS_THAN_START_LEVEL" ; FAILWITH }

               { SWAP ; GET 3 ; SWAP ; EDIV ; IF_NONE { PUSH string "DIV by 0" ; FAILWITH } {} ; CAR } } ;

         LAMBDA (map address nat) nat { PUSH nat 0 ; SWAP ; ITER { CDR ; ADD } } ;

         LAMBDA

           (pair (pair string string) (map address (pair string nat)))

           (pair nat (pair nat nat))

           { UNPAIR ;

             UNPAIR ;

             DIG 2 ;

             PUSH nat 0 ;

             PUSH nat 0 ;

             PUSH nat 0 ;

             PAIR 3 ;

             SWAP ;

             ITER { CDR ;

                    DUP 4 ;

                    DUP 2 ;

                    CAR ;

                    COMPARE ;

                    EQ ;

                    IF

                      { DUP 2 ; SWAP ; CDR ; DIG 2 ; CAR ; ADD ; UPDATE 1 }

                      { DUP 3 ;

                        DUP 2 ;

                        CAR ;

                        COMPARE ;

                        EQ ;

                        IF

                          { DUP 2 ; SWAP ; CDR ; DIG 2 ; GET 3 ; ADD ; UPDATE 3 }

                          { DUP 2 ; SWAP ; CDR ; DIG 2 ; GET 4 ; ADD ; UPDATE 4 } } } ;

             SWAP ;

             DIG 2 ;

             DROP 2 } ;

         DUP 8 ;

         DUP 8 ;

         PAIR ;

         APPLY ;

         DIG 10 ;

         UNPAIR ;

         IF_LEFT

           { DIG 5 ;

             DIG 6 ;

             DIG 8 ;

             DIG 9 ;

             DIG 10 ;

             DIG 11 ;

             DROP 6 ;

             UNIT ;

             DIG 6 ;

             SWAP ;

             EXEC ;

             DROP ;

             DUP 2 ;

             CAR ;

             DIG 5 ;

             SWAP ;

             EXEC ;

             DUP 3 ;

             GET 3 ;

             IF_NONE

               { DIG 3 ;

                 DIG 4 ;

                 DROP 2 ;

                 NONE (pair nat

                            (pair

                              (pair

                                (map bytes (pair bytes (pair address (map address nat))))

                                nat)

                              (pair

                                (option (pair bytes

                                             (pair (map address (pair string nat)) nat)))

                                (option bytes)))) ;

                 NONE bytes ;

                 NONE (pair bytes (pair (map address (pair string nat)) nat)) ;

                 TOTAL_VOTING_POWER ;

                 EMPTY_MAP bytes (pair bytes (pair address (map address nat))) ;

                 PAIR ;

                 UNIT ;

                 LEFT unit ;

                 DIG 5 ;

                 PAIR 5 }

               { DUP ;

                 CAR ;

                 DUP 3 ;

                 COMPARE ;

                 EQ ;

                 IF

                   { SWAP ;

                     DIG 4 ;

                     DIG 5 ;

                     DROP 3 ;

                     NONE (pair nat

                                (pair

                                  (pair

                                    (map bytes

                                         (pair bytes (pair address (map address nat))))

                                    nat)

                                  (pair

                                    (option (pair bytes

                                                 (pair (map address (pair string nat))

                                                       nat)))

                                    (option bytes)))) ;

                     SWAP }

                   { DUP 4 ;

                     CAR ;

                     DUP 2 ;

                     GET 3 ;

                     IF_LEFT

                       { DIG 6 ;

                         DROP 2 ;

                         DUP 2 ;

                         GET 5 ;

                         PUSH nat 0 ;

                         NONE bytes ;

                         PAIR ;

                         DUP 2 ;

                         CAR ;

                         ITER { CDR ;

                                SWAP ;

                                UNPAIR ;

                                DUP 3 ;

                                GET 4 ;

                                DUP 11 ;

                                SWAP ;

                                EXEC ;

                                DUP 3 ;

                                DUP 2 ;

                                COMPARE ;

                                GT ;

                                IF

                                  { SWAP ; DIG 2 ; DROP 2 ; SWAP ; CAR ; SOME }

                                  { DIG 3 ;

                                    DROP ;

                                    DUP 3 ;

                                    SWAP ;

                                    COMPARE ;

                                    EQ ;

                                    IF { DROP ; NONE bytes } {} } ;

                                PAIR } ;

                         DIG 7 ;

                         DROP ;

                         UNPAIR ;

                         DUP 4 ;

                         GET 11 ;

                         DIG 3 ;

                         CDR ;

                         MUL ;

                         DIG 3 ;

                         GET 9 ;

                         DIG 3 ;

                         MUL ;

                         COMPARE ;

                         GE ;

                         IF {} { DROP ; NONE bytes } ;

                         IF_NONE

                           { PUSH nat 0 ;

                             DUP 2 ;

                             GET 5 ;

                             CAR ;

                             SIZE ;

                             COMPARE ;

                             GT ;

                             IF

                               { NONE bytes ;

                                 DUP 2 ;

                                 GET 7 ;

                                 DUP 3 ;

                                 GET 5 ;

                                 PUSH nat 1 ;

                                 DUP 5 ;

                                 CAR ;

                                 ADD ;

                                 PAIR 4 ;

                                 SOME }

                               { NONE (pair nat

                                            (pair

                                              (pair

                                                (map bytes

                                                     (pair bytes

                                                           (pair address

                                                                 (map address nat))))

                                                nat)

                                              (pair

                                                (option (pair bytes

                                                             (pair

                                                               (map address

                                                                    (pair string nat))

                                                               nat)))

                                                (option bytes)))) } ;

                             SWAP ;

                             GET 8 ;

                             NONE (pair bytes (pair (map address (pair string nat)) nat)) ;

                             TOTAL_VOTING_POWER ;

                             EMPTY_MAP bytes

                                        (pair bytes (pair address (map address nat))) ;

                             PAIR ;

                             UNIT ;

                             LEFT unit ;

                             DIG 5 ;

                             PAIR 5 }

                           { PUSH nat 1 ;

                             DUP 3 ;

                             CAR ;

                             ADD ;

                             DUP ;

                             DUP 5 ;

                             COMPARE ;

                             EQ ;

                             IF

                               { DROP ;

                                 NONE (pair nat

                                            (pair

                                              (pair

                                                (map bytes

                                                     (pair bytes

                                                           (pair address

                                                                 (map address nat))))

                                                nat)

                                              (pair

                                                (option (pair bytes

                                                             (pair

                                                               (map address

                                                                    (pair string nat))

                                                               nat)))

                                                (option bytes)))) ;

                                 DIG 2 ;

                                 DIG 3 ;

                                 UPDATE 1 ;

                                 UNIT ;

                                 RIGHT unit ;

                                 UPDATE 3 ;

                                 TOTAL_VOTING_POWER ;

                                 EMPTY_MAP address (pair string nat) ;

                                 DIG 4 ;

                                 PAIR 3 ;

                                 SOME ;

                                 UPDATE 7 }

                               { DUP 3 ;

                                 SWAP ;

                                 UPDATE 1 ;

                                 UNIT ;

                                 RIGHT unit ;

                                 UPDATE 3 ;

                                 TOTAL_VOTING_POWER ;

                                 EMPTY_MAP address (pair string nat) ;

                                 DIG 3 ;

                                 PAIR 3 ;

                                 SOME ;

                                 UPDATE 7 ;

                                 NONE bytes ;

                                 DUP 2 ;

                                 GET 7 ;

                                 DUP 3 ;

                                 GET 5 ;

                                 PUSH nat 1 ;

                                 DIG 4 ;

                                 CAR ;

                                 ADD ;

                                 PAIR 4 ;

                                 SOME ;

                                 SWAP ;

                                 GET 8 ;

                                 NONE (pair bytes

                                            (pair (map address (pair string nat)) nat)) ;

                                 TOTAL_VOTING_POWER ;

                                 EMPTY_MAP bytes

                                            (pair bytes (pair address (map address nat))) ;

                                 PAIR ;

                                 UNIT ;

                                 LEFT unit ;

                                 DIG 5 ;

                                 PAIR 5 } } }

                       { DIG 7 ;

                         DROP 2 ;

                         DUP 2 ;

                         GET 8 ;

                         NONE (pair bytes (pair (map address (pair string nat)) nat)) ;

                         TOTAL_VOTING_POWER ;

                         EMPTY_MAP bytes (pair bytes (pair address (map address nat))) ;

                         PAIR ;

                         UNIT ;

                         LEFT unit ;

                         DIG 6 ;

                         PAIR 5 ;

                         DUP 3 ;

                         GET 7 ;

                         IF_NONE { PUSH string "option is None" ; FAILWITH } {} ;

                         UNPAIR 3 ;

                         SWAP ;

                         DIG 8 ;

                         SWAP ;

                         EXEC ;

                         UNPAIR 3 ;

                         DUP 7 ;

                         GET 13 ;

                         DIG 5 ;

                         DUP 8 ;

                         GET 9 ;

                         DIG 5 ;

                         DUP 6 ;

                         DUP 6 ;

                         ADD ;

                         ADD ;

                         MUL ;

                         EDIV ;

                         IF_NONE { PUSH string "DIV by 0" ; FAILWITH } {} ;

                         CAR ;

                         COMPARE ;

                         GE ;

                         DIG 2 ;

                         DUP 3 ;

                         ADD ;

                         PUSH nat 0 ;

                         DUP 2 ;

                         COMPARE ;

                         GT ;

                         IF

                           { DUP 6 ;

                             GET 14 ;

                             SWAP ;

                             DIG 6 ;

                             GET 9 ;

                             DIG 4 ;

                             MUL ;

                             EDIV ;

                             IF_NONE { PUSH string "DIV by 0" ; FAILWITH } {} ;

                             CAR ;

                             COMPARE ;

                             GE }

                           { DIG 2 ; DIG 5 ; DROP 3 ; PUSH bool False } ;

                         AND ;

                         IF { SOME } { DROP ; NONE bytes } ;

                         DUP ;

                         DUP 4 ;

                         GET 7 ;

                         DUP 5 ;

                         GET 5 ;

                         PUSH nat 1 ;

                         DIG 6 ;

                         CAR ;

                         ADD ;

                         PAIR 4 ;

                         SOME ;

                         SWAP ;

                         IF_NONE { SWAP } { DIG 2 ; SWAP ; SOME ; UPDATE 8 } } } } ;

             DUP ;

             GET 8 ;

             IF_NONE { PUSH string "LAST_WINNER_PAYLOAD_NOT_FOUND" ; FAILWITH } {} ;

             DIG 3 ;

             CONTRACT (or

                        (or (pair %d bytes (ticket (pair nat (option bytes))))

                            (bytes %a))

                        (bytes %u)) ;

             IF_NONE { PUSH string "ROLLUP_ENTRYPOINT_NOT_FOUND" ; FAILWITH } {} ;

             SWAP ;

             RIGHT (or (pair bytes (ticket (pair nat (option bytes)))) bytes) ;

             SWAP ;

             PUSH mutez 0 ;

             DIG 2 ;

             TRANSFER_TOKENS ;

             DIG 2 ;

             IF_NONE

               { NIL operation }

               { NIL operation ;

                 SWAP ;

                 EMIT %voting_finished (pair (nat %finished_at_period_index)

                                             (pair

                                               (pair %proposal_period

                                                 (map %proposals bytes

                                                                 (pair (bytes %payload)

                                                                       (pair

                                                                         (address %proposer)

                                                                         (map %votes

                                                                           address

                                                                           nat))))

                                                 (nat %total_voting_power))

                                               (pair

                                                 (option %promotion_period (pair

                                                                            (bytes %payload)

                                                                            (pair

                                                                              (map %votes

                                                                                address

                                                                                (pair

                                                                                  (string %vote)

                                                                                  (nat %voting_power)))

                                                                              (nat %total_voting_power))))

                                                 (option %winner_payload bytes)))) ;

                 CONS } ;

             DIG 3 ;

             DIG 3 ;

             SOME ;

             UPDATE 3 ;

             SWAP ;

             DIG 2 ;

             CONS }

           { IF_LEFT

               { DIG 10 ;

                 DIG 11 ;

                 DROP 2 ;

                 UNPAIR ;

                 DUP ;

                 VOTING_POWER ;

                 DUP 4 ;

                 CAR ;

                 DIG 7 ;

                 SWAP ;

                 EXEC ;

                 DUP 5 ;

                 GET 3 ;

                 IF_NONE

                   { DIG 5 ;

                     DIG 6 ;

                     DROP 2 ;

                     NONE (pair nat

                                (pair

                                  (pair

                                    (map bytes

                                         (pair bytes (pair address (map address nat))))

                                    nat)

                                  (pair

                                    (option (pair bytes

                                                 (pair (map address (pair string nat))

                                                       nat)))

                                    (option bytes)))) ;

                     NONE bytes ;

                     NONE (pair bytes (pair (map address (pair string nat)) nat)) ;

                     TOTAL_VOTING_POWER ;

                     EMPTY_MAP bytes (pair bytes (pair address (map address nat))) ;

                     PAIR ;

                     UNIT ;

                     LEFT unit ;

                     DIG 5 ;

                     PAIR 5 }

                   { DUP ;

                     CAR ;

                     DUP 3 ;

                     COMPARE ;

                     EQ ;

                     IF

                       { SWAP ;

                         DIG 6 ;

                         DIG 7 ;

                         DROP 3 ;

                         NONE (pair nat

                                    (pair

                                      (pair

                                        (map bytes

                                             (pair bytes

                                                   (pair address (map address nat))))

                                        nat)

                                      (pair

                                        (option (pair bytes

                                                     (pair

                                                       (map address (pair string nat))

                                                       nat)))

                                        (option bytes)))) ;

                         SWAP }

                       { DUP 6 ;

                         CAR ;

                         DUP 2 ;

                         GET 3 ;

                         IF_LEFT

                           { DIG 8 ;

                             DROP 2 ;

                             DUP 2 ;

                             GET 5 ;

                             PUSH nat 0 ;

                             NONE bytes ;

                             PAIR ;

                             DUP 2 ;

                             CAR ;

                             ITER { CDR ;

                                    SWAP ;

                                    UNPAIR ;

                                    DUP 3 ;

                                    GET 4 ;

                                    DUP 13 ;

                                    SWAP ;

                                    EXEC ;

                                    DUP 3 ;

                                    DUP 2 ;

                                    COMPARE ;

                                    GT ;

                                    IF

                                      { SWAP ; DIG 2 ; DROP 2 ; SWAP ; CAR ; SOME }

                                      { DIG 3 ;

                                        DROP ;

                                        DUP 3 ;

                                        SWAP ;

                                        COMPARE ;

                                        EQ ;

                                        IF { DROP ; NONE bytes } {} } ;

                                    PAIR } ;

                             DIG 9 ;

                             DROP ;

                             UNPAIR ;

                             DUP 4 ;

                             GET 11 ;

                             DIG 3 ;

                             CDR ;

                             MUL ;

                             DIG 3 ;

                             GET 9 ;

                             DIG 3 ;

                             MUL ;

                             COMPARE ;

                             GE ;

                             IF {} { DROP ; NONE bytes } ;

                             IF_NONE

                               { PUSH nat 0 ;

                                 DUP 2 ;

                                 GET 5 ;

                                 CAR ;

                                 SIZE ;

                                 COMPARE ;

                                 GT ;

                                 IF

                                   { NONE bytes ;

                                     DUP 2 ;

                                     GET 7 ;

                                     DUP 3 ;

                                     GET 5 ;

                                     PUSH nat 1 ;

                                     DUP 5 ;

                                     CAR ;

                                     ADD ;

                                     PAIR 4 ;

                                     SOME }

                                   { NONE (pair nat

                                                (pair

                                                  (pair

                                                    (map bytes

                                                         (pair bytes

                                                               (pair address

                                                                     (map address nat))))

                                                    nat)

                                                  (pair

                                                    (option (pair bytes

                                                                 (pair

                                                                   (map address

                                                                        (pair string nat))

                                                                   nat)))

                                                    (option bytes)))) } ;

                                 SWAP ;

                                 GET 8 ;

                                 NONE (pair bytes

                                            (pair (map address (pair string nat)) nat)) ;

                                 TOTAL_VOTING_POWER ;

                                 EMPTY_MAP bytes

                                            (pair bytes (pair address (map address nat))) ;

                                 PAIR ;

                                 UNIT ;

                                 LEFT unit ;

                                 DIG 5 ;

                                 PAIR 5 }

                               { PUSH nat 1 ;

                                 DUP 3 ;

                                 CAR ;

                                 ADD ;

                                 DUP ;

                                 DUP 5 ;

                                 COMPARE ;

                                 EQ ;

                                 IF

                                   { DROP ;

                                     NONE (pair nat

                                                (pair

                                                  (pair

                                                    (map bytes

                                                         (pair bytes

                                                               (pair address

                                                                     (map address nat))))

                                                    nat)

                                                  (pair

                                                    (option (pair bytes

                                                                 (pair

                                                                   (map address

                                                                        (pair string nat))

                                                                   nat)))

                                                    (option bytes)))) ;

                                     DIG 2 ;

                                     DIG 3 ;

                                     UPDATE 1 ;

                                     UNIT ;

                                     RIGHT unit ;

                                     UPDATE 3 ;

                                     TOTAL_VOTING_POWER ;

                                     EMPTY_MAP address (pair string nat) ;

                                     DIG 4 ;

                                     PAIR 3 ;

                                     SOME ;

                                     UPDATE 7 }

                                   { DUP 3 ;

                                     SWAP ;

                                     UPDATE 1 ;

                                     UNIT ;

                                     RIGHT unit ;

                                     UPDATE 3 ;

                                     TOTAL_VOTING_POWER ;

                                     EMPTY_MAP address (pair string nat) ;

                                     DIG 3 ;

                                     PAIR 3 ;

                                     SOME ;

                                     UPDATE 7 ;

                                     NONE bytes ;

                                     DUP 2 ;

                                     GET 7 ;

                                     DUP 3 ;

                                     GET 5 ;

                                     PUSH nat 1 ;

                                     DIG 4 ;

                                     CAR ;

                                     ADD ;

                                     PAIR 4 ;

                                     SOME ;

                                     SWAP ;

                                     GET 8 ;

                                     NONE (pair bytes

                                                (pair (map address (pair string nat))

                                                      nat)) ;

                                     TOTAL_VOTING_POWER ;

                                     EMPTY_MAP bytes

                                                (pair bytes

                                                      (pair address (map address nat))) ;

                                     PAIR ;

                                     UNIT ;

                                     LEFT unit ;

                                     DIG 5 ;

                                     PAIR 5 } } }

                           { DIG 9 ;

                             DROP 2 ;

                             DUP 2 ;

                             GET 8 ;

                             NONE (pair bytes (pair (map address (pair string nat)) nat)) ;

                             TOTAL_VOTING_POWER ;

                             EMPTY_MAP bytes

                                        (pair bytes (pair address (map address nat))) ;

                             PAIR ;

                             UNIT ;

                             LEFT unit ;

                             DIG 6 ;

                             PAIR 5 ;

                             DUP 3 ;

                             GET 7 ;

                             IF_NONE { PUSH string "option is None" ; FAILWITH } {} ;

                             UNPAIR 3 ;

                             SWAP ;

                             DIG 10 ;

                             SWAP ;

                             EXEC ;

                             UNPAIR 3 ;

                             DUP 7 ;

                             GET 13 ;

                             DIG 5 ;

                             DUP 8 ;

                             GET 9 ;

                             DIG 5 ;

                             DUP 6 ;

                             DUP 6 ;

                             ADD ;

                             ADD ;

                             MUL ;

                             EDIV ;

                             IF_NONE { PUSH string "DIV by 0" ; FAILWITH } {} ;

                             CAR ;

                             COMPARE ;

                             GE ;

                             DIG 2 ;

                             DUP 3 ;

                             ADD ;

                             PUSH nat 0 ;

                             DUP 2 ;

                             COMPARE ;

                             GT ;

                             IF

                               { DUP 6 ;

                                 GET 14 ;

                                 SWAP ;

                                 DIG 6 ;

                                 GET 9 ;

                                 DIG 4 ;

                                 MUL ;

                                 EDIV ;

                                 IF_NONE { PUSH string "DIV by 0" ; FAILWITH } {} ;

                                 CAR ;

                                 COMPARE ;

                                 GE }

                               { DIG 2 ; DIG 5 ; DROP 3 ; PUSH bool False } ;

                             AND ;

                             IF { SOME } { DROP ; NONE bytes } ;

                             DUP ;

                             DUP 4 ;

                             GET 7 ;

                             DUP 5 ;

                             GET 5 ;

                             PUSH nat 1 ;