{ parameter (or

              (or (or (address %add_user_proposal) (unit %default))

                  (or (nat %execute_proposal)

                      (or (nat %expiration_time_proposal)

                          (lambda %lambda_function_proposal unit (list operation)))))

              (or

                (or (nat %minimum_votes_proposal)

                    (or (address %remove_user_proposal) (bytes %text_proposal)))

                (or

                  (list %transfer_mutez_proposal (pair (mutez %amount)

                                                      (address %destination)))

                  (or

                    (pair %transfer_token_proposal (address %fa2)

                                                   (pair (nat %token_id)

                                                         (list %distribution (pair

                                                                              (nat %amount)

                                                                              (address %destination)))))

                    (pair %vote_proposal (nat %proposal_id) (bool %approval)))))) ;

  storage (pair

            (pair (nat %counter)

                  (pair (nat %expiration_time) (big_map %metadata string bytes)))

            (pair

              (pair (nat %minimum_votes)

                    (big_map %proposals nat

                                        (pair

                                          (or %kind

                                            (or

                                              (or (unit %add_user)

                                                  (unit %expiration_time))

                                              (or (unit %lambda_function)

                                                  (unit %minimum_votes)))

                                            (or (or (unit %remove_user) (unit %text))

                                                (or (unit %transfer_mutez)

                                                    (unit %transfer_token))))

                                          (pair (bool %executed)

                                                (pair (address %issuer)

                                                      (pair (timestamp %timestamp)

                                                            (pair (option %text bytes)

                                                                  (pair

                                                                    (nat %positive_votes)

                                                                    (pair

                                                                      (option %mutez_transfers (list (pair

                                                                                                     (mutez %amount)

                                                                                                     (address %destination))))

                                                                      (pair

                                                                        (option %token_transfers (pair

                                                                                                  (address %fa2)

                                                                                                  (pair

                                                                                                    (nat %token_id)

                                                                                                    (list %distribution (pair

                                                                                                                         (nat %amount)

                                                                                                                         (address %destination))))))

                                                                        (pair

                                                                          (option %minimum_votes nat)

                                                                          (pair

                                                                            (option %expiration_time nat)

                                                                            (pair

                                                                              (option %user address)

                                                                              (option %lambda_function (lambda

                                                                                                        unit

                                                                                                        (list operation))))))))))))))))

              (pair (set %users address) (big_map %votes (pair nat address) bool)))) ;

  code { UNPAIR ;

         IF_LEFT

           { IF_LEFT

               { IF_LEFT

                   { DUP 2 ;

                     GET 5 ;

                     SENDER ;

                     MEM ;

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

                     DUP 2 ;

                     GET 5 ;

                     DUP 2 ;

                     MEM ;

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

                     DUP 2 ;

                     UNPAIR ;

                     SWAP ;

                     UNPAIR ;

                     UNPAIR ;

                     SWAP ;

                     NONE (lambda unit (list operation)) ;

                     DUP 6 ;

                     SOME ;

                     NONE nat ;

                     NONE nat ;

                     NONE (pair address (pair nat (list (pair nat address)))) ;

                     NONE (list (pair mutez address)) ;

                     PUSH nat 0 ;

                     NONE bytes ;

                     NOW ;

                     SENDER ;

                     PUSH bool False ;

                     PUSH (or (or (or unit unit) (or unit unit))

                           (or (or unit unit) (or unit unit))) (Left (Left (Left Unit))) ;

                     PAIR 12 ;

                     DIG 5 ;

                     DROP ;

                     SOME ;

                     DIG 5 ;

                     CAR ;

                     CAR ;

                     UPDATE ;

                     SWAP ;

                     PAIR ;

                     PAIR ;

                     SWAP ;

                     UNPAIR ;

                     PUSH nat 1 ;

                     ADD ;

                     PAIR ;

                     PAIR }

                   { DROP } ;

                 NIL operation }

               { IF_LEFT

                   { DUP 2 ;

                     GET 5 ;

                     SENDER ;

                     MEM ;

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

                     DUP 2 ;

                     GET 3 ;

                     CDR ;

                     DUP 2 ;

                     MEM ;

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

                     DUP 2 ;

                     GET 3 ;

                     CDR ;

                     DUP 2 ;

                     GET ;

                     IF_NONE { PUSH int 196 ; FAILWITH } {} ;

                     GET 3 ;

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

                     PUSH int 86400 ;

                     DUP 3 ;

                     CAR ;

                     GET 3 ;

                     INT ;

                     MUL ;

                     DUP 3 ;

                     GET 3 ;

                     CDR ;

                     DUP 3 ;

                     GET ;

                     IF_NONE { PUSH int 196 ; FAILWITH } {} ;

                     GET 7 ;

                     ADD ;

                     NOW ;

                     COMPARE ;

                     GT ;

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

                     DUP 2 ;

                     GET 3 ;

                     CDR ;

                     DUP 2 ;

                     GET ;

                     IF_NONE { PUSH int 487 ; FAILWITH } {} ;

                     DUP 3 ;

                     GET 3 ;

                     CAR ;

                     DUP 2 ;

                     GET 11 ;

                     COMPARE ;

                     GE ;

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

                     DIG 2 ;

                     UNPAIR ;

                     SWAP ;

                     UNPAIR ;

                     UNPAIR ;

                     SWAP ;

                     DUP ;

                     DIG 6 ;

                     DUP ;

                     DUG 2 ;

                     GET ;

                     IF_NONE { PUSH int 492 ; FAILWITH } {} ;

                     PUSH bool True ;

                     UPDATE 3 ;

                     SOME ;

                     SWAP ;

                     UPDATE ;

                     SWAP ;

                     PAIR ;

                     PAIR ;

                     SWAP ;

                     PAIR ;

                     SWAP ;

                     DUP ;

                     CAR ;

                     IF_LEFT

                       { DROP ; PUSH bool False }

                       { IF_LEFT

                           { DROP ; PUSH bool False }

                           { IF_LEFT

                               { DROP ; PUSH bool True }

                               { DROP ; PUSH bool False } } } ;

                     IF

                       { NIL operation ;

                         DUP 2 ;

                         GET 13 ;

                         IF_NONE { PUSH int 495 ; FAILWITH } {} ;

                         ITER { SWAP ;

                                DUP 2 ;

                                CDR ;

                                CONTRACT unit ;

                                IF_NONE { PUSH int 496 ; FAILWITH } {} ;

                                DIG 2 ;

                                CAR ;

                                UNIT ;

                                TRANSFER_TOKENS ;

                                CONS } }

                       { NIL operation } ;

                     DUP 2 ;

                     CAR ;

                     IF_LEFT

                       { DROP ; PUSH bool False }

                       { IF_LEFT

                           { DROP ; PUSH bool False }

                           { IF_LEFT

                               { DROP ; PUSH bool False }

                               { DROP ; PUSH bool True } } } ;

                     IF

                       { NIL (pair address (pair nat nat)) ;

                         DUP 3 ;

                         GET 15 ;

                         IF_NONE { PUSH int 500 ; FAILWITH } {} ;

                         GET 4 ;

                         ITER { SWAP ;

                                DUP 2 ;

                                CAR ;

                                DUP 5 ;

                                GET 15 ;

                                IF_NONE { PUSH int 500 ; FAILWITH } {} ;

                                GET 3 ;

                                DIG 3 ;

                                CDR ;

                                PAIR 3 ;

                                CONS } ;

                         SWAP ;

                         DUP 3 ;

                         GET 15 ;

                         IF_NONE { PUSH int 500 ; FAILWITH } {} ;

                         CAR ;

                         CONTRACT %transfer (list (pair (address %from_)

                                                       (list %txs (pair (address %to_)

                                                                       (pair

                                                                         (nat %token_id)

                                                                         (nat %amount)))))) ;

                         IF_NONE { PUSH int 706 ; FAILWITH } {} ;

                         PUSH mutez 0 ;

                         NIL (pair address (list (pair address (pair nat nat)))) ;

                         DIG 4 ;

                         SELF_ADDRESS ;

                         PAIR ;

                         CONS ;

                         TRANSFER_TOKENS ;

                         CONS }

                       {} ;

                     DUP 2 ;

                     CAR ;

                     IF_LEFT

                       { IF_LEFT

                           { DROP ; PUSH bool False }

                           { IF_LEFT

                               { DROP ; PUSH bool False }

                               { DROP ; PUSH bool True } } }

                       { DROP ; PUSH bool False } ;

                     IF

                       { NIL address ;

                         DUP 4 ;

                         GET 5 ;

                         ITER { CONS } ;

                         NIL address ;

                         SWAP ;

                         ITER { CONS } ;

                         SIZE ;

                         DUP 3 ;

                         GET 17 ;

                         IF_NONE { PUSH int 511 ; FAILWITH } {} ;

                         COMPARE ;

                         LE ;

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

                         DIG 2 ;

                         UNPAIR ;

                         SWAP ;

                         UNPAIR ;

                         CDR ;

                         DUP 5 ;

                         GET 17 ;

                         IF_NONE { PUSH int 513 ; FAILWITH } {} ;

                         PAIR ;

                         PAIR ;

                         SWAP ;

                         PAIR ;

                         DUG 2 }

                       {} ;

                     DUP 2 ;

                     CAR ;

                     IF_LEFT

                       { IF_LEFT

                           { IF_LEFT

                               { DROP ; PUSH bool False }

                               { DROP ; PUSH bool True } }

                           { DROP ; PUSH bool False } }

                       { DROP ; PUSH bool False } ;

                     IF

                       { DIG 2 ;

                         UNPAIR ;

                         UNPAIR ;

                         SWAP ;

                         CDR ;

                         DUP 5 ;

                         GET 19 ;

                         IF_NONE { PUSH int 516 ; FAILWITH } {} ;

                         PAIR ;

                         SWAP ;

                         PAIR ;

                         PAIR ;

                         DUG 2 }

                       {} ;

                     DUP 2 ;

                     CAR ;

                     IF_LEFT

                       { IF_LEFT

                           { IF_LEFT

                               { DROP ; PUSH bool True }

                               { DROP ; PUSH bool False } }

                           { DROP ; PUSH bool False } }

                       { DROP ; PUSH bool False } ;

                     IF

                       { DIG 2 ;

                         DUP ;

                         GET 5 ;

                         PUSH bool True ;

                         DUP 5 ;

                         GET 21 ;

                         IF_NONE { PUSH int 519 ; FAILWITH } {} ;

                         UPDATE ;

                         UPDATE 5 ;

                         DUG 2 }

                       {} ;

                     DUP 2 ;

                     CAR ;

                     IF_LEFT

                       { DROP ; PUSH bool False }

                       { IF_LEFT

                           { IF_LEFT

                               { DROP ; PUSH bool True }

                               { DROP ; PUSH bool False } }

                           { DROP ; PUSH bool False } } ;

                     IF

                       { PUSH nat 1 ;

                         NIL address ;

                         DUP 5 ;

                         GET 5 ;

                         ITER { CONS } ;

                         NIL address ;

                         SWAP ;

                         ITER { CONS } ;

                         SIZE ;

                         COMPARE ;

                         GT ;

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

                         DIG 2 ;

                         DUP ;

                         GET 5 ;

                         PUSH bool False ;

                         DUP 5 ;

                         GET 21 ;

                         IF_NONE { PUSH int 524 ; FAILWITH } {} ;

                         UPDATE ;

                         UPDATE 5 ;

                         DUG 2 ;

                         NIL address ;

                         DUP 4 ;

                         GET 5 ;

                         ITER { CONS } ;

                         NIL address ;

                         SWAP ;

                         ITER { CONS } ;

                         SIZE ;

                         DUP 4 ;

                         GET 3 ;

                         CAR ;

                         COMPARE ;

                         GT ;

                         IF

                           { NIL address ;

                             DUP 4 ;

                             GET 5 ;

                             ITER { CONS } ;

                             NIL address ;

                             SWAP ;

                             ITER { CONS } ;

                             SIZE ;

                             DIG 3 ;

                             UNPAIR ;

                             SWAP ;

                             UNPAIR ;

                             CDR ;

                             DIG 3 ;

                             PAIR ;

                             PAIR ;

                             SWAP ;

                             PAIR ;

                             DUG 2 }

                           {} }

                       {} ;

                     DUP 2 ;

                     CAR ;

                     IF_LEFT

                       { IF_LEFT

                           { DROP ; PUSH bool False }

                           { IF_LEFT

                               { DROP ; PUSH bool True }

                               { DROP ; PUSH bool False } } }

                       { DROP ; PUSH bool False } ;

                     IF

                       { SWAP ;

                         GET 22 ;

                         IF_NONE { PUSH int 531 ; FAILWITH } {} ;

                         UNIT ;

                         EXEC ;

                         ITER { CONS } }

                       { SWAP ; DROP } }

                   { IF_LEFT

                       { DUP 2 ;

                         GET 5 ;

                         SENDER ;

                         MEM ;

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

                         PUSH nat 1 ;

                         DUP 2 ;

                         COMPARE ;

                         GE ;

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

                         DUP 2 ;

                         UNPAIR ;

                         SWAP ;

                         UNPAIR ;

                         UNPAIR ;

                         SWAP ;

                         NONE (lambda unit (list operation)) ;

                         NONE address ;

                         DUP 7 ;

                         SOME ;

                         NONE nat ;

                         NONE (pair address (pair nat (list (pair nat address)))) ;

                         NONE (list (pair mutez address)) ;

                         PUSH nat 0 ;

                         NONE bytes ;

                         NOW ;

                         SENDER ;

                         PUSH bool False ;

                         PUSH (or (or (or unit unit) (or unit unit))

                               (or (or unit unit) (or unit unit))) (Left (Left (Right Unit))) ;

                         PAIR 12 ;

                         DIG 5 ;

                         DROP ;

                         SOME ;

                         DIG 5 ;

                         CAR ;

                         CAR ;

                         UPDATE ;

                         SWAP ;

                         PAIR ;

                         PAIR ;

                         SWAP ;

                         UNPAIR ;

                         PUSH nat 1 ;

                         ADD ;

                         PAIR ;

                         PAIR }

                       { DUP 2 ;

                         GET 5 ;

                         SENDER ;

                         MEM ;

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

                         DUP 2 ;

                         UNPAIR ;

                         SWAP ;

                         UNPAIR ;

                         UNPAIR ;

                         SWAP ;

                         DUP 5 ;

                         SOME ;

                         NONE address ;

                         NONE nat ;

                         NONE nat ;

                         NONE (pair address (pair nat (list (pair nat address)))) ;

                         NONE (list (pair mutez address)) ;

                         PUSH nat 0 ;

                         NONE bytes ;

                         NOW ;

                         SENDER ;

                         PUSH bool False ;

                         PUSH (or (or (or unit unit) (or unit unit))

                               (or (or unit unit) (or unit unit))) (Left (Right (Left Unit))) ;

                         PAIR 12 ;

                         DIG 5 ;

                         DROP ;

                         SOME ;

                         DIG 5 ;

                         CAR ;

                         CAR ;

                         UPDATE ;

                         SWAP ;

                         PAIR ;

                         PAIR ;

                         SWAP ;

                         UNPAIR ;

                         PUSH nat 1 ;

                         ADD ;

                         PAIR ;

                         PAIR } ;

                     NIL operation } } }

           { IF_LEFT

               { IF_LEFT

                   { DUP 2 ;

                     GET 5 ;

                     SENDER ;

                     MEM ;

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

                     PUSH nat 1 ;

                     DUP 2 ;

                     COMPARE ;

                     GE ;

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

                     DUP 2 ;

                     UNPAIR ;

                     SWAP ;

                     UNPAIR ;

                     UNPAIR ;

                     SWAP ;

                     NONE (lambda unit (list operation)) ;

                     NONE address ;

                     NONE nat ;

                     DUP 8 ;

                     SOME ;

                     NONE (pair address (pair nat (list (pair nat address)))) ;

                     NONE (list (pair mutez address)) ;

                     PUSH nat 0 ;

                     NONE bytes ;

                     NOW ;

                     SENDER ;

                     PUSH bool False ;

                     PUSH (or (or (or unit unit) (or unit unit))

                           (or (or unit unit) (or unit unit))) (Left (Right (Right Unit))) ;

                     PAIR 12 ;

                     DIG 5 ;

                     DROP ;

                     SOME ;

                     DIG 5 ;

                     CAR ;

                     CAR ;

                     UPDATE ;

                     SWAP ;

                     PAIR ;

                     PAIR ;

                     SWAP ;

                     UNPAIR ;

                     PUSH nat 1 ;

                     ADD ;

                     PAIR ;

                     PAIR }

                   { IF_LEFT

                       { DUP 2 ;

                         GET 5 ;

                         SENDER ;

                         MEM ;

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

                         DUP 2 ;

                         GET 5 ;

                         DUP 2 ;

                         MEM ;

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

                         DUP 2 ;

                         UNPAIR ;

                         SWAP ;

                         UNPAIR ;

                         UNPAIR ;

                         SWAP ;

                         NONE (lambda unit (list operation)) ;

                         DUP 6 ;

                         SOME ;

                         NONE nat ;

                         NONE nat ;

                         NONE (pair address (pair nat (list (pair nat address)))) ;

                         NONE (list (pair mutez address)) ;

                         PUSH nat 0 ;

                         NONE bytes ;

                         NOW ;

                         SENDER ;

                         PUSH bool False ;

                         PUSH (or (or (or unit unit) (or unit unit))

                               (or (or unit unit) (or unit unit))) (Right (Left (Left Unit))) ;

                         PAIR 12 ;

                         DIG 5 ;

                         DROP ;

                         SOME ;

                         DIG 5 ;

                         CAR ;

                         CAR ;

                         UPDATE ;

                         SWAP ;

                         PAIR ;

                         PAIR ;

                         SWAP ;

                         UNPAIR ;

                         PUSH nat 1 ;

                         ADD ;

                         PAIR ;

                         PAIR }

                       { DUP 2 ;

                         GET 5 ;

                         SENDER ;

                         MEM ;

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

                         DUP 2 ;

                         UNPAIR ;

                         SWAP ;

                         UNPAIR ;

                         UNPAIR ;

                         SWAP ;

                         NONE (lambda unit (list operation)) ;

                         NONE address ;

                         NONE nat ;

                         NONE nat ;

                         NONE (pair address (pair nat (list (pair nat address)))) ;

                         NONE (list (pair mutez address)) ;

                         PUSH nat 0 ;

                         DUP 12 ;

                         SOME ;

                         NOW ;

                         SENDER ;

                         PUSH bool False ;

                         PUSH (or (or (or unit unit) (or unit unit))

                               (or (or unit unit) (or unit unit))) (Right (Left (Right Unit))) ;

                         PAIR 12 ;

                         DIG 5 ;

                         DROP ;

                         SOME ;

                         DIG 5 ;

                         CAR ;

                         CAR ;

                         UPDATE ;

                         SWAP ;

                         PAIR ;

                         PAIR ;

                         SWAP ;

                         UNPAIR ;

                         PUSH nat 1 ;

                         ADD ;

                         PAIR ;

                         PAIR } } }

               { IF_LEFT

                   { DUP 2 ;

                     GET 5 ;

                     SENDER ;

                     MEM ;

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

                     DUP 2 ;

                     UNPAIR ;

                     SWAP ;

                     UNPAIR ;

                     UNPAIR ;

                     SWAP ;

                     NONE (lambda unit (list operation)) ;

                     NONE address ;

                     NONE nat ;

                     NONE nat ;

                     NONE (pair address (pair nat (list (pair nat address)))) ;

                     DUP 10 ;

                     SOME ;

                     PUSH nat 0 ;

                     NONE bytes ;

                     NOW ;

                     SENDER ;

                     PUSH bool False ;

                     PUSH (or (or (or unit unit) (or unit unit))

                           (or (or unit unit) (or unit unit))) (Right (Right (Left Unit))) ;

                     PAIR 12 ;

                     DIG 5 ;

                     DROP ;

                     SOME ;

                     DIG 5 ;

                     CAR ;

                     CAR ;

                     UPDATE ;

                     SWAP ;

                     PAIR ;

                     PAIR ;

                     SWAP ;

                     UNPAIR ;

                     PUSH nat 1 ;

                     ADD ;

                     PAIR ;

                     PAIR }

                   { IF_LEFT

                       { DUP 2 ;

                         GET 5 ;

                         SENDER ;

                         MEM ;

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

                         DUP 2 ;

                         UNPAIR ;

                         SWAP ;

                         UNPAIR ;

                         UNPAIR ;

                         SWAP ;

                         NONE (lambda unit (list operation)) ;

                         NONE address ;

                         NONE nat ;

                         NONE nat ;

                         DUP 9 ;

                         SOME ;

                         NONE (list (pair mutez address)) ;

                         PUSH nat 0 ;

                         NONE bytes ;

                         NOW ;

                         SENDER ;

                         PUSH bool False ;

                         PUSH (or (or (or unit unit) (or unit unit))

                               (or (or unit unit) (or unit unit))) (Right (Right (Right Unit))) ;

                         PAIR 12 ;

                         DIG 5 ;

                         DROP ;

                         SOME ;

                         DIG 5 ;

                         CAR ;

                         CAR ;

                         UPDATE ;

                         SWAP ;

                         PAIR ;

                         PAIR ;

                         SWAP ;

                         UNPAIR ;

                         PUSH nat 1 ;

                         ADD ;

                         PAIR ;

                         PAIR }

                       { DUP 2 ;

                         GET 5 ;

                         SENDER ;

                         MEM ;

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

                         DUP 2 ;

                         GET 3 ;

                         CDR ;

                         DUP 2 ;

                         CAR ;

                         MEM ;

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

                         DUP 2 ;

                         GET 3 ;

                         CDR ;

                         DUP 2 ;

                         CAR ;

                         GET ;

                         IF_NONE { PUSH int 196 ; FAILWITH } {} ;

                         GET 3 ;