{ parameter (or (address %trigger_kernel_upgrade)

                (or (string %vote) (or (bytes %upvote_proposal) (bytes %new_proposal)))) ;

  storage (pair

            (pair %config (nat %started_at_level)

                          (pair (nat %period_length)

                                (pair (nat %adoption_period_sec)

                                      (pair (nat %upvoting_limit)

                                            (pair (nat %scale)

                                                  (pair (nat %proposal_quorum)

                                                        (pair (nat %promotion_quorum)

                                                              (pair

                                                                (nat %promotion_supermajority)

                                                                (address %delegation_contract)))))))))

            (pair

              (option %voting_context (pair (nat %period_index)

                                           (or %period

                                             (pair %proposal

                                               (big_map %upvoters_upvotes_count key_hash

                                                                                nat)

                                               (pair

                                                 (big_map %upvoters_proposals

                                                   (pair key_hash bytes)

                                                   unit)

                                                 (pair

                                                   (big_map %proposals bytes

                                                                       (pair

                                                                         (set %proposers key_hash)

                                                                         (nat %upvotes_voting_power)))

                                                   (pair

                                                     (option %max_upvotes_voting_power nat)

                                                     (pair

                                                       (option %winner_candidate bytes)

                                                       (nat %total_voting_power))))))

                                             (pair %promotion

                                               (big_map %voters key_hash string)

                                               (pair (nat %yea_voting_power)

                                                     (pair (nat %nay_voting_power)

                                                           (pair

                                                             (nat %pass_voting_power)

                                                             (pair

                                                               (nat %total_voting_power)

                                                               (bytes %winner_candidate)))))))))

              (pair

                (option %last_winner (pair (bytes %payload)

                                          (big_map %trigger_history address unit)))

                (big_map %metadata string bytes)))) ;

  code { PUSH string "NOT_PROPOSAL_PERIOD" ;

         PUSH string "NOT_PROMOTION_PERIOD" ;

         PUSH string "UPVOTING_LIMIT_EXCEEDED" ;

         PUSH string "PROPOSAL_ALREADY_UPVOTED" ;

         PUSH string "PROMOTION_ALREADY_VOTED" ;

         LAMBDA

           (pair nat nat)

           bytes

           { UNPAIR ;

             PUSH nat 56 ;

             DUP 2 ;

             COMPARE ;

             LT ;

             IF

               { ADD ; BYTES }

               { BYTES ;

                 DUP ;

                 SIZE ;

                 PUSH nat 9 ;

                 DUP 2 ;

                 COMPARE ;

                 LT ;

                 IF {} { PUSH string "INPUT_TOO_LONG_FOR_RLP" ; FAILWITH } ;

                 SWAP ;

                 PUSH nat 55 ;

                 DIG 3 ;

                 DIG 3 ;

                 ADD ;

                 ADD ;

                 BYTES ;

                 CONCAT } } ;

         LAMBDA

           unit

           unit

           { DROP ;

             PUSH string "TEZ_IN_TRANSACTION_DISALLOWED" ;

             PUSH mutez 0 ;

             AMOUNT ;

             COMPARE ;

             EQ ;

             IF { DROP } { FAILWITH } ;

             UNIT } ;

         LAMBDA

           nat

           unit

           { PUSH nat 0 ;

             COMPARE ;

             LT ;

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

             UNIT } ;

         LAMBDA

           (pair nat

                 (pair nat

                       (pair nat

                             (pair nat

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

           nat

           { DUP ;

             CAR ;

             LEVEL ;

             SUB ;

             ISNAT ;

             IF_NONE

               { PUSH string "CURRENT_LEVEL_LESS_THAN_START_LEVEL" ; FAILWITH }

               { SWAP ;

                 GET 3 ;

                 SWAP ;

                 EDIV ;

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

         LAMBDA

           address

           (list key_hash)

           { SELF_ADDRESS ;

             SOME ;

             SENDER ;

             PAIR ;

             VIEW "list_voters" (list key_hash) ;

             IF_NONE

               { PUSH string "ASSERTION_FAILURE_DELEGATION_CONTRACT_MISSING_OR_INCONSISTENT" ;

                 FAILWITH }

               { SENDER ;

                 DUP ;

                 PACK ;

                 PUSH bytes 0x00 ;

                 DUP 2 ;

                 PUSH nat 1 ;

                 PUSH nat 6 ;

                 SLICE ;

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

                 COMPARE ;

                 EQ ;

                 IF {} { PUSH string "NOT_IMPLICIT_ADDRESS" ; FAILWITH } ;

                 NIL bytes ;

                 DUP 2 ;

                 PUSH nat 21 ;

                 PUSH nat 7 ;

                 SLICE ;

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

                 CONS ;

                 PUSH bytes 0x00000015 ;

                 CONS ;

                 SWAP ;

                 PUSH nat 2 ;

                 PUSH nat 0 ;

                 SLICE ;

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

                 CONS ;

                 CONCAT ;

                 UNPACK key_hash ;

                 PUSH string "FAILED_TO_CAST_ADDRESS_TO_KEY_HASH" ;

                 SWAP ;

                 IF_NONE { FAILWITH } { SWAP ; DROP } ;

                 PUSH string "KEY_HASH_NOT_EQUAL_TO_SOURCE_ADDRESS" ;

                 DIG 2 ;

                 DUP 3 ;

                 IMPLICIT_ACCOUNT ;

                 ADDRESS ;

                 COMPARE ;

                 EQ ;

                 IF { DROP } { FAILWITH } ;

                 CONS } } ;

         DIG 10 ;

         UNPAIR ;

         IF_LEFT

           { DIG 2 ;

             DROP ;

             DIG 3 ;

             DROP ;

             DIG 5 ;

             DROP ;

             DIG 5 ;

             DROP ;

             DIG 5 ;

             DROP ;

             DIG 5 ;

             DROP ;

             DIG 5 ;

             DROP ;

             UNIT ;

             DIG 4 ;

             SWAP ;

             EXEC ;

             DROP ;

             DUP 2 ;

             CAR ;

             DIG 3 ;

             SWAP ;

             EXEC ;

             DUP 3 ;

             GET 3 ;

             IF_NONE

               { NONE (pair nat (pair (or unit unit) (option bytes))) ;

                 TOTAL_VOTING_POWER ;

                 NONE bytes ;

                 NONE nat ;

                 EMPTY_BIG_MAP bytes (pair (set key_hash) nat) ;

                 EMPTY_BIG_MAP (pair key_hash bytes) unit ;

                 EMPTY_BIG_MAP key_hash nat ;

                 PAIR 6 ;

                 LEFT (pair (big_map key_hash string)

                            (pair nat (pair nat (pair nat (pair nat bytes))))) ;

                 DIG 2 ;

                 PAIR }

               { DUP ;

                 CAR ;

                 DUP 3 ;

                 COMPARE ;

                 EQ ;

                 IF

                   { SWAP ; DROP ; NONE (pair nat (pair (or unit unit) (option bytes))) ; SWAP }

                   { DUP 4 ;

                     CAR ;

                     DUP 2 ;

                     CDR ;

                     IF_LEFT

                       { DUP 2 ;

                         GET 11 ;

                         DUP 2 ;

                         GET 10 ;

                         MUL ;

                         DIG 2 ;

                         GET 9 ;

                         DUP 3 ;

                         GET 7 ;

                         IF_NONE { PUSH nat 0 } {} ;

                         MUL ;

                         COMPARE ;

                         GE ;

                         IF { DUP ; GET 9 } { NONE bytes } ;

                         IF_NONE

                           { GET 7 ;

                             IF_NONE

                               { DROP ;

                                 NONE (pair nat (pair (or unit unit) (option bytes))) }

                               { DROP ;

                                 NONE bytes ;

                                 UNIT ;

                                 LEFT unit ;

                                 DIG 2 ;

                                 CAR ;

                                 DUG 2 ;

                                 PUSH nat 1 ;

                                 DIG 3 ;

                                 ADD ;

                                 PAIR 3 ;

                                 SOME } ;

                             TOTAL_VOTING_POWER ;

                             NONE bytes ;

                             NONE nat ;

                             EMPTY_BIG_MAP bytes (pair (set key_hash) nat) ;

                             EMPTY_BIG_MAP (pair key_hash bytes) unit ;

                             EMPTY_BIG_MAP key_hash nat ;

                             PAIR 6 ;

                             LEFT (pair (big_map key_hash string)

                                        (pair nat (pair nat (pair nat (pair nat bytes))))) }

                           { SWAP ;

                             DROP ;

                             PUSH nat 1 ;

                             DIG 2 ;

                             CAR ;

                             ADD ;

                             DUP ;

                             DUP 4 ;

                             COMPARE ;

                             EQ ;

                             IF

                               { DROP ;

                                 NONE (pair nat (pair (or unit unit) (option bytes))) ;

                                 SWAP ;

                                 TOTAL_VOTING_POWER ;

                                 PUSH nat 0 ;

                                 DUP ;

                                 DUP ;

                                 EMPTY_BIG_MAP key_hash string ;

                                 PAIR 6 ;

                                 RIGHT (pair (big_map key_hash nat)

                                             (pair (big_map (pair key_hash bytes) unit)

                                                   (pair

                                                     (big_map bytes

                                                              (pair (set key_hash) nat))

                                                     (pair (option nat)

                                                           (pair (option bytes) nat))))) }

                               { SWAP ;

                                 DROP ;

                                 NONE bytes ;

                                 UNIT ;

                                 RIGHT unit ;

                                 PUSH nat 1 ;

                                 DIG 3 ;

                                 ADD ;

                                 PAIR 3 ;

                                 SOME ;

                                 TOTAL_VOTING_POWER ;

                                 NONE bytes ;

                                 NONE nat ;

                                 EMPTY_BIG_MAP bytes (pair (set key_hash) nat) ;

                                 EMPTY_BIG_MAP (pair key_hash bytes) unit ;

                                 EMPTY_BIG_MAP key_hash nat ;

                                 PAIR 6 ;

                                 LEFT (pair (big_map key_hash string)

                                            (pair nat

                                                  (pair nat (pair nat (pair nat bytes))))) } } }

                       { CDR ;

                         UNPAIR 5 ;

                         DIG 3 ;

                         DUP 6 ;

                         GET 13 ;

                         MUL ;

                         DUP 6 ;

                         GET 9 ;

                         DIG 4 ;

                         DUP 5 ;

                         DUP 5 ;

                         ADD ;

                         ADD ;

                         MUL ;

                         COMPARE ;

                         GE ;

                         DIG 2 ;

                         DUP 3 ;

                         ADD ;

                         DUP ;

                         DUP 6 ;

                         GET 15 ;

                         MUL ;

                         DIG 5 ;

                         GET 9 ;

                         DIG 4 ;

                         MUL ;

                         COMPARE ;

                         GE ;

                         SWAP ;

                         INT ;

                         GT ;

                         AND ;

                         AND ;

                         IF { SOME } { DROP ; NONE bytes } ;

                         UNIT ;

                         RIGHT unit ;

                         DIG 2 ;

                         CAR ;

                         DUG 2 ;

                         PUSH nat 1 ;

                         DIG 3 ;

                         ADD ;

                         PAIR 3 ;

                         SOME ;

                         TOTAL_VOTING_POWER ;

                         NONE bytes ;

                         NONE nat ;

                         EMPTY_BIG_MAP bytes (pair (set key_hash) nat) ;

                         EMPTY_BIG_MAP (pair key_hash bytes) unit ;

                         EMPTY_BIG_MAP key_hash nat ;

                         PAIR 6 ;

                         LEFT (pair (big_map key_hash string)

                                    (pair nat (pair nat (pair nat (pair nat bytes))))) } ;

                     DIG 2 ;

                     PAIR } } ;

             PAIR ;

             UNPAIR ;

             SWAP ;

             DUP ;

             IF_NONE

               { DUP 4 ; GET 5 }

               { GET 4 ;

                 IF_NONE

                   { DUP 4 ; GET 5 }

                   { EMPTY_BIG_MAP address unit ; SWAP ; PAIR ; SOME } } ;

             DIG 2 ;

             SWAP ;

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

             DUP ;

             CDR ;

             DUP 5 ;

             MEM ;

             IF { PUSH string "UPGRADE_FOR_ADDRESS_ALREADY_TRIGGERED" ; FAILWITH } {} ;

             DUP 4 ;

             CONTRACT (or

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

                            (bytes %a))

                        (bytes %u)) ;

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

             DUP 6 ;

             CAR ;

             GET 5 ;

             INT ;

             NOW ;

             ADD ;

             PUSH timestamp 0 ;

             SWAP ;

             SUB ;

             ISNAT ;

             PUSH string "NEGATIVE_TIMESTAMP" ;

             SWAP ;

             IF_NONE { FAILWITH } { SWAP ; DROP } ;

             BYTES ;

             PUSH bytes 0x ;

             PUSH int 0 ;

             PUSH int 1 ;

             DUP 4 ;

             SIZE ;

             SUB ;

             DUP 2 ;

             COMPARE ;

             LE ;

             LOOP { DUP ;

                    ISNAT ;

                    PUSH string "INDEX_NOT_NAT" ;

                    SWAP ;

                    IF_NONE { FAILWITH } { SWAP ; DROP } ;

                    DIG 2 ;

                    DUP 4 ;

                    PUSH nat 1 ;

                    DIG 3 ;

                    SLICE ;

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

                    CONCAT ;

                    SWAP ;

                    PUSH int 1 ;

                    ADD ;

                    PUSH int 1 ;

                    DUP 4 ;

                    SIZE ;

                    SUB ;

                    DUP 2 ;

                    COMPARE ;

                    LE } ;

             DROP ;

             SWAP ;

             DROP ;

             DUP ;

             SIZE ;

             INT ;

             PUSH int 1 ;

             PUSH nat 8 ;

             SUB ;

             DUP 2 ;

             COMPARE ;

             LE ;

             LOOP { PUSH bytes 0x00 ;

                    DIG 2 ;

                    CONCAT ;

                    SWAP ;

                    PUSH int 1 ;

                    ADD ;

                    PUSH int 1 ;

                    PUSH nat 8 ;

                    SUB ;

                    DUP 2 ;

                    COMPARE ;

                    LE } ;

             DROP ;

             NIL bytes ;

             SWAP ;

             CONS ;

             DUP 3 ;

             CAR ;

             CONS ;

             MAP { DUP ;

                   SIZE ;

                   PUSH bytes 0x80 ;

                   DUP 3 ;

                   COMPARE ;

                   LT ;

                   PUSH nat 1 ;

                   DUP 3 ;

                   COMPARE ;

                   EQ ;

                   AND ;

                   IF

                     { DROP ; PUSH bytes 0x }

                     { PUSH nat 128 ; SWAP ; PAIR ; DUP 9 ; SWAP ; EXEC } ;

                   CONCAT } ;

             CONCAT ;

             PUSH nat 192 ;

             DUP 2 ;

             SIZE ;

             PAIR ;

             DIG 8 ;

             SWAP ;

             EXEC ;

             CONCAT ;

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

             SWAP ;

             PUSH mutez 0 ;

             DIG 2 ;

             TRANSFER_TOKENS ;

             DIG 3 ;

             IF_NONE

               { NIL operation }

               { EMIT %voting_finished (pair (nat %finished_at_period_index)

                                             (pair

                                               (or %finished_at_period_type

                                                 (unit %proposal)

                                                 (unit %promotion))

                                               (option %winner_proposal_payload bytes))) ;

                 NIL operation ;

                 SWAP ;

                 CONS } ;

             DIG 5 ;

             DIG 4 ;

             SOME ;

             UPDATE 3 ;

             DIG 3 ;

             DUP ;

             CDR ;

             UNIT ;

             SOME ;

             DIG 6 ;

             UPDATE ;

             UPDATE 2 ;

             SOME ;

             UPDATE 5 ;

             SWAP ;

             DIG 2 ;

             CONS }

           { DIG 6 ;

             DROP ;

             IF_LEFT

               { DIG 7 ;

                 DROP ;

                 DIG 7 ;

                 DROP ;

                 DIG 8 ;

                 DROP ;

                 UNIT ;

                 DIG 6 ;

                 SWAP ;

                 EXEC ;

                 DROP ;

                 DUP 2 ;

                 CAR ;

                 DIG 4 ;

                 SWAP ;

                 EXEC ;

                 DUP 3 ;

                 GET 3 ;

                 IF_NONE

                   { NONE (pair nat (pair (or unit unit) (option bytes))) ;

                     TOTAL_VOTING_POWER ;

                     NONE bytes ;

                     NONE nat ;

                     EMPTY_BIG_MAP bytes (pair (set key_hash) nat) ;

                     EMPTY_BIG_MAP (pair key_hash bytes) unit ;

                     EMPTY_BIG_MAP key_hash nat ;

                     PAIR 6 ;

                     LEFT (pair (big_map key_hash string)

                                (pair nat (pair nat (pair nat (pair nat bytes))))) ;

                     DIG 2 ;

                     PAIR }

                   { DUP ;

                     CAR ;

                     DUP 3 ;

                     COMPARE ;

                     EQ ;

                     IF

                       { SWAP ;

                         DROP ;

                         NONE (pair nat (pair (or unit unit) (option bytes))) ;

                         SWAP }

                       { DUP 4 ;

                         CAR ;

                         DUP 2 ;

                         CDR ;

                         IF_LEFT

                           { DUP 2 ;

                             GET 11 ;

                             DUP 2 ;

                             GET 10 ;

                             MUL ;

                             DIG 2 ;

                             GET 9 ;

                             DUP 3 ;

                             GET 7 ;

                             IF_NONE { PUSH nat 0 } {} ;

                             MUL ;

                             COMPARE ;

                             GE ;

                             IF { DUP ; GET 9 } { NONE bytes } ;

                             IF_NONE

                               { GET 7 ;

                                 IF_NONE

                                   { DROP ;

                                     NONE (pair nat (pair (or unit unit) (option bytes))) }

                                   { DROP ;

                                     NONE bytes ;

                                     UNIT ;

                                     LEFT unit ;

                                     DIG 2 ;

                                     CAR ;

                                     DUG 2 ;

                                     PUSH nat 1 ;

                                     DIG 3 ;

                                     ADD ;

                                     PAIR 3 ;

                                     SOME } ;

                                 TOTAL_VOTING_POWER ;

                                 NONE bytes ;

                                 NONE nat ;

                                 EMPTY_BIG_MAP bytes (pair (set key_hash) nat) ;

                                 EMPTY_BIG_MAP (pair key_hash bytes) unit ;

                                 EMPTY_BIG_MAP key_hash nat ;

                                 PAIR 6 ;

                                 LEFT (pair (big_map key_hash string)

                                            (pair nat

                                                  (pair nat (pair nat (pair nat bytes))))) }

                               { SWAP ;

                                 DROP ;

                                 PUSH nat 1 ;

                                 DIG 2 ;

                                 CAR ;

                                 ADD ;

                                 DUP ;

                                 DUP 4 ;

                                 COMPARE ;

                                 EQ ;

                                 IF

                                   { DROP ;

                                     NONE (pair nat (pair (or unit unit) (option bytes))) ;

                                     SWAP ;

                                     TOTAL_VOTING_POWER ;

                                     PUSH nat 0 ;

                                     DUP ;

                                     DUP ;

                                     EMPTY_BIG_MAP key_hash string ;

                                     PAIR 6 ;

                                     RIGHT (pair (big_map key_hash nat)

                                                 (pair

                                                   (big_map (pair key_hash bytes) unit)

                                                   (pair

                                                     (big_map bytes

                                                              (pair (set key_hash) nat))

                                                     (pair (option nat)

                                                           (pair (option bytes) nat))))) }

                                   { SWAP ;

                                     DROP ;

                                     NONE bytes ;

                                     UNIT ;

                                     RIGHT unit ;

                                     PUSH nat 1 ;

                                     DIG 3 ;

                                     ADD ;

                                     PAIR 3 ;

                                     SOME ;

                                     TOTAL_VOTING_POWER ;

                                     NONE bytes ;

                                     NONE nat ;

                                     EMPTY_BIG_MAP bytes (pair (set key_hash) nat) ;

                                     EMPTY_BIG_MAP (pair key_hash bytes) unit ;

                                     EMPTY_BIG_MAP key_hash nat ;

                                     PAIR 6 ;

                                     LEFT (pair (big_map key_hash string)

                                                (pair nat

                                                      (pair nat

                                                            (pair nat (pair nat bytes))))) } } }

                           { CDR ;

                             UNPAIR 5 ;

                             DIG 3 ;

                             DUP 6 ;

                             GET 13 ;

                             MUL ;

                             DUP 6 ;

                             GET 9 ;

                             DIG 4 ;

                             DUP 5 ;

                             DUP 5 ;

                             ADD ;

                             ADD ;

                             MUL ;

                             COMPARE ;

                             GE ;

                             DIG 2 ;

                             DUP 3 ;

                             ADD ;

                             DUP ;

                             DUP 6 ;

                             GET 15 ;

                             MUL ;

                             DIG 5 ;

                             GET 9 ;

                             DIG 4 ;

                             MUL ;

                             COMPARE ;

                             GE ;

                             SWAP ;

                             INT ;

                             GT ;

                             AND ;

                             AND ;

                             IF { SOME } { DROP ; NONE bytes } ;

                             UNIT ;

                             RIGHT unit ;

                             DIG 2 ;

                             CAR ;

                             DUG 2 ;

                             PUSH nat 1 ;

                             DIG 3 ;

                             ADD ;

                             PAIR 3 ;

                             SOME ;

                             TOTAL_VOTING_POWER ;

                             NONE bytes ;

                             NONE nat ;

                             EMPTY_BIG_MAP bytes (pair (set key_hash) nat) ;

                             EMPTY_BIG_MAP (pair key_hash bytes) unit ;

                             EMPTY_BIG_MAP key_hash nat ;

                             PAIR 6 ;

                             LEFT (pair (big_map key_hash string)

                                        (pair nat (pair nat (pair nat (pair nat bytes))))) } ;

                         DIG 2 ;

                         PAIR } } ;

                 PAIR ;

                 CAR ;

                 DUP 3 ;

                 CAR ;

                 GET 16 ;

                 DIG 4 ;

                 SWAP ;

                 EXEC ;

                 DUP 2 ;

                 CDR ;

                 IF_LEFT { DROP ; DUP 7 ; FAILWITH } {} ;

                 PUSH nat 0 ;

                 PUSH (map key_hash nat) {} ;

                 PAIR ;

                 DIG 2 ;

                 ITER { SWAP ;

                        UNPAIR ;

                        DUP 3 ;

                        VOTING_POWER ;

                        DUP 5 ;

                        CAR ;

                        DUP 5 ;

                        MEM ;

                        NOT ;

                        NOT ;

                        DUP 2 ;

                        INT ;

                        EQ ;

                        OR ;

                        IF

                          { DIG 3 ; DROP ; DIG 2 ; ADD ; SWAP }

                          { DIG 2 ; DUP 2 ; ADD ; DUG 2 ; SOME ; DIG 3 ; UPDATE } ;

                        PAIR } ;

                 SWAP ;

                 DROP ;

                 UNPAIR ;

                 SWAP ;

                 DIG 5 ;

                 SWAP ;

                 EXEC ;

                 DROP ;

                 PUSH nat 0 ;

                 DUP 2 ;

                 SIZE ;

                 COMPARE ;

                 GT ;

                 IF {} { DUP 5 ; FAILWITH } ;

                 DUP 2 ;

                 SWAP ;

                 ITER { UNPAIR ;

                        DIG 2 ;

                        CDR ;

                        IF_LEFT { DROP ; DUP 7 ; FAILWITH } {} ;

                        DUP ;

                        CAR ;

                        DUP 3 ;

                        MEM ;

                        IF { DUP 7 ; FAILWITH } {} ;