{ parameter (or (address %trigger_committee_upgrade)

                (or (string %vote)

                    (or (pair %upvote_proposal (string %public_key) (bytes %l2_address))

                        (pair %new_proposal (string %public_key) (bytes %l2_address))))) ;

  storage (pair

            (pair %config (nat %started_at_level)

                          (pair (nat %period_length)

                                (pair (int %cooldown_period_sec)

                                      (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

                                                 (big_map %upvoters_upvotes_count

                                                   address

                                                   nat)

                                                 (pair

                                                   (big_map %upvoters_proposals

                                                     (pair address bytes)

                                                     unit)

                                                   (pair

                                                     (big_map %proposals bytes

                                                                         (pair

                                                                           (pair %payload

                                                                             (string %public_key)

                                                                             (bytes %l2_address))

                                                                           (pair

                                                                             (address %proposer)

                                                                             (nat %upvotes_voting_power))))

                                                     (pair

                                                       (option %max_upvotes_voting_power nat)

                                                       (pair

                                                         (option %winner_candidate (pair

                                                                                    (string %public_key)

                                                                                    (bytes %l2_address)))

                                                         (nat %total_voting_power))))))

                                               (pair

                                                 (option %promotion_period (pair

                                                                            (big_map %voters

                                                                              address

                                                                              unit)

                                                                            (pair

                                                                              (nat %yay_voting_power)

                                                                              (pair

                                                                                (nat %nay_voting_power)

                                                                                (pair

                                                                                  (nat %pass_voting_power)

                                                                                  (nat %total_voting_power))))))

                                                 (pair

                                                   (option %last_winner_payload (pair

                                                                                 (string %public_key)

                                                                                 (bytes %l2_address)))

                                                   (big_map %last_winner_trigger_history

                                                     address

                                                     unit)))))))

              (big_map %metadata string bytes))) ;

  code { PUSH string "NOT_PROPOSAL_PERIOD" ;

         LAMBDA

           unit

           unit

           { DROP ;

             PUSH string "XTZ_IN_TRANSACTION_DISALLOWED" ;

             PUSH mutez 0 ;

             AMOUNT ;

             COMPARE ;

             EQ ;

             IF { DROP ; UNIT } { FAILWITH } } ;

         LAMBDA

           nat

           unit

           { PUSH nat 0 ;

             SWAP ;

             COMPARE ;

             GT ;

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

         LAMBDA

           address

           key_hash

           { PACK ;

             PUSH string "NOT_IMPLICIT_ADDRESS" ;

             NIL bytes ;

             DUP 3 ;

             PUSH nat 21 ;

             PUSH nat 7 ;

             SLICE ;

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

             CONS ;

             PUSH bytes 0x15 ;

             CONS ;

             DIG 2 ;

             PUSH nat 5 ;

             PUSH nat 0 ;

             SLICE ;

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

             CONS ;

             CONCAT ;

             UNPACK key_hash ;

             IF_NONE { FAILWITH } { SWAP ; DROP } } ;

         LAMBDA nat bytes { BYTES } ;

         PUSH string "yay" ;

         PUSH string "nay" ;

         LAMBDA

           (pair nat

                 (pair nat

                       (pair int

                             (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 } } ;

         DIG 8 ;

         UNPAIR ;

         IF_LEFT

           { DIG 3 ;

             DIG 4 ;

             DIG 6 ;

             DIG 7 ;

             DIG 9 ;

             DROP 5 ;

             DUP 2 ;

             CAR ;

             DIG 3 ;

             SWAP ;

             EXEC ;

             DUP 3 ;

             GET 3 ;

             IF_NONE

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

                 EMPTY_BIG_MAP address unit ;

                 NONE (pair string bytes) ;

                 NONE (pair (big_map address unit) (pair nat (pair nat (pair nat nat)))) ;

                 TOTAL_VOTING_POWER ;

                 NONE (pair string bytes) ;

                 NONE nat ;

                 EMPTY_BIG_MAP bytes (pair (pair string bytes) (pair address nat)) ;

                 EMPTY_BIG_MAP (pair address bytes) unit ;

                 EMPTY_BIG_MAP address nat ;

                 PAIR 6 ;

                 UNIT ;

                 LEFT unit ;

                 DIG 6 ;

                 PAIR 6 }

               { DUP ;

                 CAR ;

                 DUP 3 ;

                 COMPARE ;

                 EQ ;

                 IF

                   { SWAP ;

                     DROP ;

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

                     SWAP }

                   { DUP 4 ;

                     CAR ;

                     DUP 2 ;

                     GET 3 ;

                     IF_LEFT

                       { DROP ;

                         DUP 2 ;

                         GET 5 ;

                         DUP 2 ;

                         GET 13 ;

                         DUP 2 ;

                         GET 10 ;

                         MUL ;

                         DIG 2 ;

                         GET 11 ;

                         DUP 3 ;

                         GET 7 ;

                         IF_NONE { PUSH nat 0 } {} ;

                         MUL ;

                         COMPARE ;

                         GE ;

                         IF { GET 9 } { DROP ; NONE (pair string bytes) } ;

                         IF_NONE

                           { DUP ;

                             GET 5 ;

                             GET 7 ;

                             IF_NONE { PUSH bool False } { DROP ; PUSH bool True } ;

                             IF

                               { NONE (pair string bytes) ;

                                 DUP 2 ;

                                 GET 3 ;

                                 PUSH nat 1 ;

                                 DUP 4 ;

                                 CAR ;

                                 ADD ;

                                 PAIR 3 ;

                                 SOME }

                               { NONE (pair nat

                                            (pair (or unit unit)

                                                  (option (pair string bytes)))) } ;

                             SWAP ;

                             DIG 2 ;

                             UPDATE 1 ;

                             UNIT ;

                             LEFT unit ;

                             UPDATE 3 ;

                             TOTAL_VOTING_POWER ;

                             NONE (pair string bytes) ;

                             NONE nat ;

                             EMPTY_BIG_MAP bytes

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

                             EMPTY_BIG_MAP (pair address bytes) unit ;

                             EMPTY_BIG_MAP address nat ;

                             PAIR 6 ;

                             UPDATE 5 ;

                             NONE (pair (big_map address unit)

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

                             UPDATE 7 }

                           { DROP ;

                             PUSH nat 1 ;

                             DUP 2 ;

                             CAR ;

                             ADD ;

                             DUP ;

                             DUP 4 ;

                             COMPARE ;

                             EQ ;

                             IF

                               { DROP ;

                                 NONE (pair nat

                                            (pair (or unit unit)

                                                  (option (pair string bytes)))) ;

                                 SWAP ;

                                 DIG 2 ;

                                 UPDATE 1 ;

                                 UNIT ;

                                 RIGHT unit ;

                                 UPDATE 3 ;

                                 TOTAL_VOTING_POWER ;

                                 PUSH nat 0 ;

                                 PUSH nat 0 ;

                                 PUSH nat 0 ;

                                 EMPTY_BIG_MAP address unit ;

                                 PAIR 5 ;

                                 SOME ;

                                 UPDATE 7 }

                               { NONE (pair string bytes) ;

                                 UNIT ;

                                 RIGHT unit ;

                                 PUSH nat 1 ;

                                 DIG 3 ;

                                 ADD ;

                                 PAIR 3 ;

                                 SOME ;

                                 SWAP ;

                                 DIG 2 ;

                                 UPDATE 1 ;

                                 UNIT ;

                                 LEFT unit ;

                                 UPDATE 3 ;

                                 TOTAL_VOTING_POWER ;

                                 NONE (pair string bytes) ;

                                 NONE nat ;

                                 EMPTY_BIG_MAP bytes

                                                (pair (pair string bytes)

                                                      (pair address nat)) ;

                                 EMPTY_BIG_MAP (pair address bytes) unit ;

                                 EMPTY_BIG_MAP address nat ;

                                 PAIR 6 ;

                                 UPDATE 5 ;

                                 NONE (pair (big_map address unit)

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

                                 UPDATE 7 } } }

                       { DROP ;

                         DUP 2 ;

                         GET 7 ;

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

                         UNPAIR 5 ;

                         DROP ;

                         DIG 3 ;

                         DUP 5 ;

                         GET 15 ;

                         MUL ;

                         DUP 5 ;

                         GET 11 ;

                         DIG 4 ;

                         DUP 5 ;

                         DUP 5 ;

                         ADD ;

                         ADD ;

                         MUL ;

                         COMPARE ;

                         GE ;

                         DIG 2 ;

                         DUP 3 ;

                         ADD ;

                         PUSH nat 0 ;

                         DUP 2 ;

                         COMPARE ;

                         GT ;

                         IF

                           { DUP 4 ; GET 16 ; MUL ; DIG 3 ; GET 11 ; DIG 3 ; MUL ; COMPARE ; GE }

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

                         AND ;

                         IF { DUP ; GET 5 ; GET 9 } { NONE (pair string bytes) } ;

                         DUP ;

                         DUP 3 ;

                         GET 3 ;

                         PUSH nat 1 ;

                         DUP 5 ;

                         CAR ;

                         ADD ;

                         PAIR 3 ;

                         SOME ;

                         DIG 2 ;

                         DIG 3 ;

                         UPDATE 1 ;

                         UNIT ;

                         LEFT unit ;

                         UPDATE 3 ;

                         TOTAL_VOTING_POWER ;

                         NONE (pair string bytes) ;

                         NONE nat ;

                         EMPTY_BIG_MAP bytes

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

                         EMPTY_BIG_MAP (pair address bytes) unit ;

                         EMPTY_BIG_MAP address nat ;

                         PAIR 6 ;

                         UPDATE 5 ;

                         NONE (pair (big_map address unit)

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

                         UPDATE 7 ;

                         SWAP ;

                         DIG 2 ;

                         IF_NONE

                           { SWAP }

                           { DIG 2 ; SWAP ; SOME ; UPDATE 9 ; EMPTY_BIG_MAP address unit ; UPDATE 10 } } } } ;

             DUP ;

             GET 10 ;

             UNIT ;

             DIG 7 ;

             SWAP ;

             EXEC ;

             DROP ;

             DUP ;

             DUP 5 ;

             MEM ;

             NOT ;

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

             DUP 2 ;

             GET 9 ;

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

             DUP 5 ;

             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 7 ;

             CAR ;

             GET 5 ;

             NOW ;

             ADD ;

             DUP 3 ;

             CAR ;

             PACK ;

             DUP ;

             PUSH nat 4 ;

             PUSH nat 2 ;

             SLICE ;

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

             NAT ;

             PUSH timestamp 0 ;

             DIG 3 ;

             SUB ;

             ABS ;

             DUP 11 ;

             SWAP ;

             EXEC ;

             PUSH bytes 0x ;

             PUSH int 1 ;

             PUSH int 1 ;

             DUP 4 ;

             SIZE ;

             SUB ;

             PUSH int 0 ;

             DUP 2 ;

             DUP 2 ;

             COMPARE ;

             LE ;

             LOOP { DUP ;

                    DUG 3 ;

                    DIP 3

                         { ISNAT ;

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

                           SWAP ;

                           DUP 3 ;

                           PUSH nat 1 ;

                           DIG 3 ;

                           SLICE ;

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

                           CONCAT } ;

                    DUP 3 ;

                    ADD ;

                    DUP 2 ;

                    DUP 2 ;

                    COMPARE ;

                    LE } ;

             DROP 3 ;

             SWAP ;

             DROP ;

             DUP ;

             SIZE ;

             INT ;

             PUSH int 1 ;

             PUSH int 1 ;

             PUSH nat 8 ;

             SUB ;

             DIG 2 ;

             DUP 2 ;

             DUP 2 ;

             COMPARE ;

             LE ;

             LOOP { DUP ;

                    DUG 3 ;

                    DIP 3 { DROP ; PUSH bytes 0x00 ; SWAP ; CONCAT } ;

                    DUP 3 ;

                    ADD ;

                    DUP 2 ;

                    DUP 2 ;

                    COMPARE ;

                    LE } ;

             DROP 3 ;

             PUSH bytes 0x ;

             NIL bytes ;

             DIG 2 ;

             CONS ;

             DIG 5 ;

             CDR ;

             CONS ;

             DIG 3 ;

             DIG 3 ;

             PUSH nat 6 ;

             SLICE ;

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

             CONS ;

             ITER { SWAP ;

                    DUP 2 ;

                    SIZE ;

                    PUSH nat 55 ;

                    DUP 2 ;

                    COMPARE ;

                    LE ;

                    IF

                      { PUSH nat 128 ; ADD ; DUP 10 ; SWAP ; EXEC }

                      { DUP 10 ;

                        SWAP ;

                        EXEC ;

                        NIL bytes ;

                        DUP 2 ;

                        CONS ;

                        PUSH nat 183 ;

                        DIG 2 ;

                        SIZE ;

                        ADD ;

                        DUP 11 ;

                        SWAP ;

                        EXEC ;

                        CONS ;

                        CONCAT } ;

                    DIG 2 ;

                    SWAP ;

                    CONCAT ;

                    SWAP ;

                    CONCAT } ;

             DUP ;

             SIZE ;

             PUSH nat 55 ;

             DUP 2 ;

             COMPARE ;

             LE ;

             IF

               { PUSH nat 192 ; ADD ; DIG 8 ; SWAP ; EXEC }

               { DUP 9 ;

                 SWAP ;

                 EXEC ;

                 NIL bytes ;

                 DUP 2 ;

                 CONS ;

                 PUSH nat 247 ;

                 DIG 2 ;

                 SIZE ;

                 ADD ;

                 DIG 9 ;

                 SWAP ;

                 EXEC ;

                 CONS ;

                 CONCAT } ;

             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 }

               { NIL operation ;

                 SWAP ;

                 EMIT %voting_finished (pair (nat %finished_at_period_index)

                                             (pair

                                               (or %finished_at_period_type

                                                 (unit %proposal)

                                                 (unit %promotion))

                                               (option %winner_proposal_payload (pair

                                                                                 (string %public_key)

                                                                                 (bytes %l2_address))))) ;

                 CONS } ;

             DIG 5 ;

             DIG 4 ;

             DIG 4 ;

             UNIT ;

             DIG 6 ;

             SWAP ;

             SOME ;

             SWAP ;

             UPDATE ;

             UPDATE 10 ;

             SOME ;

             UPDATE 3 ;

             SWAP ;

             DIG 2 ;

             CONS }

           { DIG 5 ;

             DROP ;

             IF_LEFT

               { DIG 8 ;

                 DROP ;

                 DUP 2 ;

                 CAR ;

                 DIG 3 ;

                 SWAP ;

                 EXEC ;

                 DUP 3 ;

                 GET 3 ;

                 IF_NONE

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

                     EMPTY_BIG_MAP address unit ;

                     NONE (pair string bytes) ;

                     NONE (pair (big_map address unit)

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

                     TOTAL_VOTING_POWER ;

                     NONE (pair string bytes) ;

                     NONE nat ;

                     EMPTY_BIG_MAP bytes (pair (pair string bytes) (pair address nat)) ;

                     EMPTY_BIG_MAP (pair address bytes) unit ;

                     EMPTY_BIG_MAP address nat ;

                     PAIR 6 ;

                     UNIT ;

                     LEFT unit ;

                     DIG 6 ;

                     PAIR 6 }

                   { DUP ;

                     CAR ;

                     DUP 3 ;

                     COMPARE ;

                     EQ ;

                     IF

                       { SWAP ;

                         DROP ;

                         NONE (pair nat

                                    (pair (or unit unit) (option (pair string bytes)))) ;

                         SWAP }

                       { DUP 4 ;

                         CAR ;

                         DUP 2 ;

                         GET 3 ;

                         IF_LEFT

                           { DROP ;

                             DUP 2 ;

                             GET 5 ;

                             DUP 2 ;

                             GET 13 ;

                             DUP 2 ;

                             GET 10 ;

                             MUL ;

                             DIG 2 ;

                             GET 11 ;

                             DUP 3 ;

                             GET 7 ;

                             IF_NONE { PUSH nat 0 } {} ;

                             MUL ;

                             COMPARE ;

                             GE ;

                             IF { GET 9 } { DROP ; NONE (pair string bytes) } ;

                             IF_NONE

                               { DUP ;

                                 GET 5 ;

                                 GET 7 ;

                                 IF_NONE { PUSH bool False } { DROP ; PUSH bool True } ;

                                 IF

                                   { NONE (pair string bytes) ;

                                     DUP 2 ;

                                     GET 3 ;

                                     PUSH nat 1 ;

                                     DUP 4 ;

                                     CAR ;

                                     ADD ;

                                     PAIR 3 ;

                                     SOME }

                                   { NONE (pair nat

                                                (pair (or unit unit)

                                                      (option (pair string bytes)))) } ;

                                 SWAP ;

                                 DIG 2 ;

                                 UPDATE 1 ;

                                 UNIT ;

                                 LEFT unit ;

                                 UPDATE 3 ;

                                 TOTAL_VOTING_POWER ;

                                 NONE (pair string bytes) ;

                                 NONE nat ;

                                 EMPTY_BIG_MAP bytes

                                                (pair (pair string bytes)

                                                      (pair address nat)) ;

                                 EMPTY_BIG_MAP (pair address bytes) unit ;

                                 EMPTY_BIG_MAP address nat ;

                                 PAIR 6 ;

                                 UPDATE 5 ;

                                 NONE (pair (big_map address unit)

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

                                 UPDATE 7 }

                               { DROP ;

                                 PUSH nat 1 ;

                                 DUP 2 ;

                                 CAR ;

                                 ADD ;

                                 DUP ;

                                 DUP 4 ;

                                 COMPARE ;

                                 EQ ;

                                 IF

                                   { DROP ;

                                     NONE (pair nat

                                                (pair (or unit unit)

                                                      (option (pair string bytes)))) ;

                                     SWAP ;

                                     DIG 2 ;

                                     UPDATE 1 ;

                                     UNIT ;

                                     RIGHT unit ;

                                     UPDATE 3 ;

                                     TOTAL_VOTING_POWER ;

                                     PUSH nat 0 ;

                                     PUSH nat 0 ;

                                     PUSH nat 0 ;

                                     EMPTY_BIG_MAP address unit ;

                                     PAIR 5 ;

                                     SOME ;

                                     UPDATE 7 }

                                   { NONE (pair string bytes) ;

                                     UNIT ;

                                     RIGHT unit ;

                                     PUSH nat 1 ;

                                     DIG 3 ;

                                     ADD ;

                                     PAIR 3 ;

                                     SOME ;

                                     SWAP ;

                                     DIG 2 ;

                                     UPDATE 1 ;

                                     UNIT ;

                                     LEFT unit ;

                                     UPDATE 3 ;

                                     TOTAL_VOTING_POWER ;

                                     NONE (pair string bytes) ;

                                     NONE nat ;

                                     EMPTY_BIG_MAP bytes

                                                    (pair (pair string bytes)

                                                          (pair address nat)) ;

                                     EMPTY_BIG_MAP (pair address bytes) unit ;

                                     EMPTY_BIG_MAP address nat ;

                                     PAIR 6 ;

                                     UPDATE 5 ;

                                     NONE (pair (big_map address unit)

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

                                     UPDATE 7 } } }

                           { DROP ;

                             DUP 2 ;

                             GET 7 ;

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

                             UNPAIR 5 ;

                             DROP ;

                             DIG 3 ;

                             DUP 5 ;

                             GET 15 ;

                             MUL ;

                             DUP 5 ;

                             GET 11 ;

                             DIG 4 ;

                             DUP 5 ;

                             DUP 5 ;

                             ADD ;

                             ADD ;

                             MUL ;

                             COMPARE ;

                             GE ;

                             DIG 2 ;

                             DUP 3 ;

                             ADD ;

                             PUSH nat 0 ;

                             DUP 2 ;

                             COMPARE ;

                             GT ;

                             IF

                               { DUP 4 ; GET 16 ; MUL ; DIG 3 ; GET 11 ; DIG 3 ; MUL ; COMPARE ; GE }

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

                             AND ;

                             IF { DUP ; GET 5 ; GET 9 } { NONE (pair string bytes) } ;

                             DUP ;

                             DUP 3 ;

                             GET 3 ;

                             PUSH nat 1 ;

                             DUP 5 ;

                             CAR ;

                             ADD ;

                             PAIR 3 ;

                             SOME ;

                             DIG 2 ;

                             DIG 3 ;

                             UPDATE 1 ;

                             UNIT ;

                             LEFT unit ;

                             UPDATE 3 ;

                             TOTAL_VOTING_POWER ;

                             NONE (pair string bytes) ;

                             NONE nat ;

                             EMPTY_BIG_MAP bytes

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

                             EMPTY_BIG_MAP (pair address bytes) unit ;

                             EMPTY_BIG_MAP address nat ;

                             PAIR 6 ;

                             UPDATE 5 ;

                             NONE (pair (big_map address unit)