parameter (or

            (or

              (or

                (or (address %AdminChange)

                    (pair %AdminOperation (nat %Operation) (address %address)))

                (or

                  (pair %FarmAdminChange (address %AdminAddress) (address %FarmAddress))

                  (address %FarmChangeState)))

              (or

                (or

                  (pair %FarmDeposit (address %address)

                                     (pair (nat %amount) (nat %blocks)))

                  (address %FarmFeeWithdrawl))

                (or

                  (pair %FarmRecoverTokens

                    (pair (address %FarmAddress) (pair (address %address) (nat %id)))

                    (pair (address %token) (pair (nat %type) (nat %value))))

                  (or

                    (pair %FarmUnstakeFeeChange

                      (pair (address %address) (nat %blocksPerCycle))

                      (pair (nat %cycles) (pair (nat %defaultFee) (nat %depositFee))))

                    (unit %MintTokens)))))

            (or

              (or

                (or (address %ModifyDeveloperAddress)

                    (pair %ModifyDeveloperFee (nat %FarmCut) (nat %TokenCut)))

                (or (nat %ModifyMintParameters)

                    (or (nat %SetOperation) (address %TokenAdminChange))))

              (or

                (or (pair %VoteOperation (nat %Operation) (nat %Vote))

                    (unit %VotingHardReset))

                (or

                  (pair %WithdrawFunds (pair (address %TokenAddress) (nat %amount))

                                       (pair (nat %id) (nat %type)))

                  (or (unit %deposit) (nat %deposit_callback))))));

storage (pair

          (pair (pair (set %Accounts address) (address %DeveloperAddress))

                (pair (nat %DeveloperFarmCut)

                      (pair (nat %DeveloperTokenCut) (nat %Operation))))

          (pair (pair (address %Token) (map %Votes address bool))

                (pair (address %admin) (pair (nat %balance) (bool %state)))));

code { UNPAIR ;

       IF_LEFT

         { IF_LEFT

             { IF_LEFT

                 { IF_LEFT

                     { SWAP ;

                       DUP ;

                       DUG 2 ;

                       CAR ;

                       CAR ;

                       CAR ;

                       SENDER ;

                       MEM ;

                       IF {} { PUSH string "Invalid Sender" ; FAILWITH } ;

                       PUSH nat 9 ;

                       DUP 3 ;

                       CAR ;

                       GET 6 ;

                       COMPARE ;

                       EQ ;

                       IF {} { PUSH string "Invalid Operation Value" ; FAILWITH } ;

                       PUSH nat 1 ;

                       PUSH nat 2 ;

                       NIL address ;

                       DUP 5 ;

                       CAR ;

                       CAR ;

                       CAR ;

                       ITER { CONS } ;

                       NIL address ;

                       SWAP ;

                       ITER { CONS } ;

                       SIZE ;

                       EDIV ;

                       IF_NONE { PUSH int 965 ; FAILWITH } { CAR } ;

                       ADD ;

                       NIL address ;

                       DUP 4 ;

                       GET 3 ;

                       CDR ;

                       ITER { CAR ; CONS } ;

                       NIL address ;

                       SWAP ;

                       ITER { CONS } ;

                       SIZE ;

                       COMPARE ;

                       GE ;

                       IF

                         {}

                         { PUSH string "Voting has not reached Decision" ; FAILWITH } ;

                       SWAP ;

                       DUP ;

                       DUG 2 ;

                       UNPAIR ;

                       UNPAIR ;

                       UNPAIR ;

                       PUSH bool False ;

                       DIG 6 ;

                       GET 5 ;

                       UPDATE ;

                       PUSH bool True ;

                       DUP 6 ;

                       UPDATE ;

                       PAIR ;

                       PAIR ;

                       PAIR ;

                       SWAP ;

                       UPDATE 5 ;

                       UNPAIR ;

                       SWAP ;

                       UNPAIR ;

                       CAR ;

                       EMPTY_MAP address bool ;

                       SWAP ;

                       PAIR ;

                       PAIR ;

                       SWAP ;

                       UNPAIR ;

                       SWAP ;

                       UNPAIR ;

                       SWAP ;

                       CAR ;

                       PUSH nat 0 ;

                       SWAP ;

                       PAIR ;

                       SWAP ;

                       PAIR ;

                       SWAP ;

                       PAIR ;

                       PAIR }

                     { SWAP ;

                       DUP ;

                       DUG 2 ;

                       GET 5 ;

                       SENDER ;

                       COMPARE ;

                       EQ ;

                       IF {} { PUSH string "Invalid Sender" ; FAILWITH } ;

                       PUSH nat 10 ;

                       DUP 3 ;

                       CAR ;

                       GET 6 ;

                       COMPARE ;

                       EQ ;

                       IF {} { PUSH string "Voting Already in Progress" ; FAILWITH } ;

                       NIL address ;

                       DUP 3 ;

                       CAR ;

                       CAR ;

                       CAR ;

                       ITER { CONS } ;

                       NIL address ;

                       SWAP ;

                       ITER { CONS } ;

                       SIZE ;

                       NIL address ;

                       DUP 4 ;

                       GET 3 ;

                       CDR ;

                       ITER { CAR ; CONS } ;

                       NIL address ;

                       SWAP ;

                       ITER { CONS } ;

                       SIZE ;

                       COMPARE ;

                       GE ;

                       IF

                         {}

                         { PUSH string "Voting has not reached Decision" ; FAILWITH } ;

                       DUP ;

                       CAR ;

                       PUSH nat 1 ;

                       COMPARE ;

                       EQ ;

                       IF

                         { SWAP ;

                           UNPAIR ;

                           UNPAIR ;

                           UNPAIR ;

                           PUSH bool True ;

                           DIG 5 ;

                           CDR ;

                           UPDATE ;

                           PAIR ;

                           PAIR ;

                           PAIR }

                         { SWAP ;

                           UNPAIR ;

                           UNPAIR ;

                           UNPAIR ;

                           PUSH bool False ;

                           DIG 5 ;

                           CDR ;

                           UPDATE ;

                           PAIR ;

                           PAIR ;

                           PAIR } ;

                       UNPAIR ;

                       SWAP ;

                       UNPAIR ;

                       CAR ;

                       EMPTY_MAP address bool ;

                       SWAP ;

                       PAIR ;

                       PAIR ;

                       SWAP ;

                       UNPAIR ;

                       SWAP ;

                       UNPAIR ;

                       SWAP ;

                       CAR ;

                       PUSH nat 0 ;

                       SWAP ;

                       PAIR ;

                       SWAP ;

                       PAIR ;

                       SWAP ;

                       PAIR ;

                       PAIR } ;

                   NIL operation }

                 { IF_LEFT

                     { SWAP ;

                       DUP ;

                       DUG 2 ;

                       GET 5 ;

                       SENDER ;

                       COMPARE ;

                       EQ ;

                       IF {} { PUSH string "Invalid User" ; FAILWITH } ;

                       PUSH nat 7 ;

                       DUP 3 ;

                       CAR ;

                       GET 6 ;

                       COMPARE ;

                       EQ ;

                       IF {} { PUSH string "Invalid Operation Value" ; FAILWITH } ;

                       NIL address ;

                       DUP 3 ;

                       GET 3 ;

                       CDR ;

                       ITER { CAR ; CONS } ;

                       NIL address ;

                       SWAP ;

                       ITER { CONS } ;

                       SIZE ;

                       NIL address ;

                       DUP 4 ;

                       CAR ;

                       CAR ;

                       CAR ;

                       ITER { CONS } ;

                       NIL address ;

                       SWAP ;

                       ITER { CONS } ;

                       SIZE ;

                       COMPARE ;

                       EQ ;

                       IF {} { PUSH string "EveryOne hasn't voted" ; FAILWITH } ;

                       DUP ;

                       CDR ;

                       CONTRACT %changeAdmin address ;

                       IF_NONE { PUSH int 840 ; FAILWITH } {} ;

                       NIL operation ;

                       SWAP ;

                       PUSH mutez 0 ;

                       DIG 3 ;

                       CAR ;

                       TRANSFER_TOKENS ;

                       CONS ;

                       SWAP ;

                       UNPAIR ;

                       SWAP ;

                       UNPAIR ;

                       CAR ;

                       EMPTY_MAP address bool ;

                       SWAP ;

                       PAIR ;

                       PAIR ;

                       SWAP ;

                       UNPAIR ;

                       SWAP ;

                       UNPAIR ;

                       SWAP ;

                       CAR ;

                       PUSH nat 0 ;

                       SWAP ;

                       PAIR ;

                       SWAP ;

                       PAIR ;

                       SWAP ;

                       PAIR ;

                       PAIR ;

                       SWAP }

                     { SWAP ;

                       DUP ;

                       DUG 2 ;

                       GET 5 ;

                       SENDER ;

                       COMPARE ;

                       EQ ;

                       IF {} { PUSH string "Invalid User" ; FAILWITH } ;

                       PUSH nat 8 ;

                       DUP 3 ;

                       CAR ;

                       GET 6 ;

                       COMPARE ;

                       EQ ;

                       IF {} { PUSH string "Invalid Operation Value" ; FAILWITH } ;

                       NIL address ;

                       DUP 3 ;

                       GET 3 ;

                       CDR ;

                       ITER { CAR ; CONS } ;

                       NIL address ;

                       SWAP ;

                       ITER { CONS } ;

                       SIZE ;

                       NIL address ;

                       DUP 4 ;

                       CAR ;

                       CAR ;

                       CAR ;

                       ITER { CONS } ;

                       NIL address ;

                       SWAP ;

                       ITER { CONS } ;

                       SIZE ;

                       COMPARE ;

                       EQ ;

                       IF {} { PUSH string "EveryOne hasn't voted" ; FAILWITH } ;

                       CONTRACT %changeState unit ;

                       IF_NONE { PUSH int 861 ; FAILWITH } {} ;

                       NIL operation ;

                       SWAP ;

                       PUSH mutez 0 ;

                       UNIT ;

                       TRANSFER_TOKENS ;

                       CONS ;

                       SWAP ;

                       UNPAIR ;

                       SWAP ;

                       UNPAIR ;

                       CAR ;

                       EMPTY_MAP address bool ;

                       SWAP ;

                       PAIR ;

                       PAIR ;

                       SWAP ;

                       UNPAIR ;

                       SWAP ;

                       UNPAIR ;

                       SWAP ;

                       CAR ;

                       PUSH nat 0 ;

                       SWAP ;

                       PAIR ;

                       SWAP ;

                       PAIR ;

                       SWAP ;

                       PAIR ;

                       PAIR ;

                       SWAP } } }

             { IF_LEFT

                 { IF_LEFT

                     { SWAP ;

                       DUP ;

                       DUG 2 ;

                       GET 5 ;

                       SENDER ;

                       COMPARE ;

                       EQ ;

                       IF {} { PUSH string "Invalid User" ; FAILWITH } ;

                       SWAP ;

                       DUP ;

                       DUG 2 ;

                       CAR ;

                       GET 3 ;

                       SWAP ;

                       DUP ;

                       DUG 2 ;

                       GET 3 ;

                       EDIV ;

                       IF_NONE { PUSH int 736 ; FAILWITH } { CAR } ;

                       SWAP ;

                       DUP ;

                       DUG 2 ;

                       GET 3 ;

                       SWAP ;

                       DUP ;

                       DUG 2 ;

                       ADD ;

                       DUP 4 ;

                       GET 7 ;

                       COMPARE ;

                       GE ;

                       IF {} { PUSH string "Insufficient Balance" ; FAILWITH } ;

                       DUP 3 ;

                       DUP 3 ;

                       GET 3 ;

                       DUP 3 ;

                       ADD ;

                       DIG 4 ;

                       GET 7 ;

                       SUB ;

                       ISNAT ;

                       IF_NONE { PUSH int 740 ; FAILWITH } {} ;

                       UPDATE 7 ;

                       DUG 2 ;

                       NIL operation ;

                       DUP 4 ;

                       GET 3 ;

                       CAR ;

                       CONTRACT %transfer (pair address (pair address nat)) ;

                       IF_NONE { PUSH int 720 ; FAILWITH } {} ;

                       PUSH mutez 0 ;

                       DIG 4 ;

                       DUP ;

                       GET 3 ;

                       SWAP ;

                       DUP ;

                       DUG 6 ;

                       CAR ;

                       SELF_ADDRESS ;

                       PAIR 3 ;

                       TRANSFER_TOKENS ;

                       CONS ;

                       DUP 3 ;

                       CAR ;

                       CONTRACT %AddReward (pair nat nat) ;

                       IF_NONE { PUSH int 750 ; FAILWITH } {} ;

                       PUSH mutez 0 ;

                       DIG 4 ;

                       DUP ;

                       GET 3 ;

                       SWAP ;

                       GET 4 ;

                       PAIR ;

                       TRANSFER_TOKENS ;

                       CONS ;

                       DUP 3 ;

                       GET 3 ;

                       CAR ;

                       CONTRACT %transfer (pair address (pair address nat)) ;

                       IF_NONE { PUSH int 720 ; FAILWITH } {} ;

                       PUSH mutez 0 ;

                       DIG 3 ;

                       DUP 5 ;

                       CAR ;

                       CAR ;

                       CDR ;

                       SELF_ADDRESS ;

                       PAIR 3 ;

                       TRANSFER_TOKENS ;

                       CONS }

                     { CONTRACT %WithdrawFee unit ;

                       IF_NONE { PUSH int 768 ; FAILWITH } {} ;

                       NIL operation ;

                       SWAP ;

                       PUSH mutez 0 ;

                       UNIT ;

                       TRANSFER_TOKENS ;

                       CONS } }

                 { IF_LEFT

                     { SWAP ;

                       DUP ;

                       DUG 2 ;

                       GET 5 ;

                       SENDER ;

                       COMPARE ;

                       EQ ;

                       IF {} { PUSH string "Invalid User" ; FAILWITH } ;

                       PUSH nat 5 ;

                       DUP 3 ;

                       CAR ;

                       GET 6 ;

                       COMPARE ;

                       EQ ;

                       IF {} { PUSH string "Invalid Operation Value" ; FAILWITH } ;

                       NIL address ;

                       DUP 3 ;

                       GET 3 ;

                       CDR ;

                       ITER { CAR ; CONS } ;

                       NIL address ;

                       SWAP ;

                       ITER { CONS } ;

                       SIZE ;

                       NIL address ;

                       DUP 4 ;

                       CAR ;

                       CAR ;

                       CAR ;

                       ITER { CONS } ;

                       NIL address ;

                       SWAP ;

                       ITER { CONS } ;

                       SIZE ;

                       COMPARE ;

                       EQ ;

                       IF {} { PUSH string "Not everyone has voted" ; FAILWITH } ;

                       DUP ;

                       CAR ;

                       CAR ;

                       CONTRACT %RecoverExcessToken (pair (pair address nat)

                                                          (pair address (pair nat nat))) ;

                       IF_NONE { PUSH int 790 ; FAILWITH } {} ;

                       NIL operation ;

                       SWAP ;

                       PUSH mutez 0 ;

                       DIG 3 ;

                       DUP ;

                       GET 6 ;

                       SWAP ;

                       DUP ;

                       DUG 5 ;

                       GET 5 ;

                       PAIR ;

                       DUP 5 ;

                       GET 3 ;

                       PAIR ;

                       DIG 4 ;

                       DUP ;

                       GET 5 ;

                       SWAP ;

                       CAR ;

                       GET 3 ;

                       PAIR ;

                       PAIR ;

                       TRANSFER_TOKENS ;

                       CONS ;

                       SWAP ;

                       UNPAIR ;

                       SWAP ;

                       UNPAIR ;

                       CAR ;

                       EMPTY_MAP address bool ;

                       SWAP ;

                       PAIR ;

                       PAIR ;

                       SWAP ;

                       UNPAIR ;

                       SWAP ;

                       UNPAIR ;

                       SWAP ;

                       CAR ;

                       PUSH nat 0 ;

                       SWAP ;

                       PAIR ;

                       SWAP ;

                       PAIR ;

                       SWAP ;

                       PAIR ;

                       PAIR ;

                       SWAP }

                     { IF_LEFT

                         { SWAP ;

                           DUP ;

                           DUG 2 ;

                           GET 5 ;

                           SENDER ;

                           COMPARE ;

                           EQ ;

                           IF {} { PUSH string "Invalid User" ; FAILWITH } ;

                           PUSH nat 6 ;

                           DUP 3 ;

                           CAR ;

                           GET 6 ;

                           COMPARE ;

                           EQ ;

                           IF {} { PUSH string "Invalid Operation Value" ; FAILWITH } ;

                           NIL address ;

                           DUP 3 ;

                           GET 3 ;

                           CDR ;

                           ITER { CAR ; CONS } ;

                           NIL address ;

                           SWAP ;

                           ITER { CONS } ;

                           SIZE ;

                           NIL address ;

                           DUP 4 ;

                           CAR ;

                           CAR ;

                           CAR ;

                           ITER { CONS } ;

                           NIL address ;

                           SWAP ;

                           ITER { CONS } ;

                           SIZE ;

                           COMPARE ;

                           EQ ;

                           IF {} { PUSH string "Not everyone has voted" ; FAILWITH } ;

                           DUP ;

                           CAR ;

                           CAR ;

                           CONTRACT %changeUnstakeFee (pair (pair nat nat)

                                                            (pair nat nat)) ;

                           IF_NONE { PUSH int 814 ; FAILWITH } {} ;

                           NIL operation ;

                           SWAP ;

                           PUSH mutez 0 ;

                           DIG 3 ;

                           DUP ;

                           GET 6 ;

                           SWAP ;

                           DUP ;

                           DUG 5 ;

                           GET 5 ;

                           PAIR ;

                           DIG 4 ;

                           DUP ;

                           GET 3 ;

                           SWAP ;

                           CAR ;

                           CDR ;

                           PAIR ;

                           PAIR ;

                           TRANSFER_TOKENS ;

                           CONS }

                         { DROP ;

                           DUP ;

                           GET 8 ;

                           IF {} { PUSH string " Callback in Progress" ; FAILWITH } ;

                           PUSH bool False ;

                           UPDATE 8 ;

                           DUP ;

                           GET 3 ;

                           CAR ;

                           CONTRACT %mint unit ;

                           IF_NONE { PUSH int 545 ; FAILWITH } {} ;

                           NIL operation ;

                           SWAP ;

                           PUSH mutez 0 ;

                           UNIT ;

                           TRANSFER_TOKENS ;

                           CONS ;

                           SWAP ;

                           DUP ;

                           DUG 2 ;

                           GET 3 ;

                           CAR ;

                           CONTRACT %getBalance (pair address (contract nat)) ;

                           IF_NONE { PUSH int 556 ; FAILWITH } {} ;

                           PUSH mutez 0 ;

                           SELF %deposit_callback ;

                           SELF_ADDRESS ;

                           PAIR ;

                           TRANSFER_TOKENS ;

                           CONS } } } } }

         { IF_LEFT

             { IF_LEFT

                 { IF_LEFT

                     { SWAP ;

                       DUP ;

                       DUG 2 ;

                       GET 5 ;

                       SENDER ;

                       COMPARE ;

                       EQ ;

                       IF {} { PUSH string "Invalid User" ; FAILWITH } ;

                       PUSH nat 3 ;

                       DUP 3 ;

                       CAR ;

                       GET 6 ;

                       COMPARE ;

                       EQ ;

                       IF {} { PUSH string "Invalid Operation Value" ; FAILWITH } ;

                       NIL address ;

                       DUP 3 ;

                       GET 3 ;

                       CDR ;

                       ITER { CAR ; CONS } ;

                       NIL address ;

                       SWAP ;

                       ITER { CONS } ;

                       SIZE ;

                       NIL address ;

                       DUP 4 ;

                       CAR ;

                       CAR ;

                       CAR ;

                       ITER { CONS } ;

                       NIL address ;

                       SWAP ;

                       ITER { CONS } ;

                       SIZE ;

                       COMPARE ;

                       EQ ;

                       IF {} { PUSH string "EveryOne hasn't voted" ; FAILWITH } ;

                       SWAP ;

                       UNPAIR ;

                       UNPAIR ;

                       CAR ;

                       DIG 3 ;

                       SWAP ;

                       PAIR ;

                       PAIR ;

                       SWAP ;

                       UNPAIR ;

                       CAR ;

                       EMPTY_MAP address bool ;

                       SWAP ;

                       PAIR ;

                       PAIR ;

                       SWAP ;

                       UNPAIR ;

                       SWAP ;

                       UNPAIR ;

                       SWAP ;

                       CAR ;

                       PUSH nat 0 ;

                       SWAP ;

                       PAIR ;

                       SWAP ;

                       PAIR ;

                       SWAP ;

                       PAIR ;

                       PAIR }

                     { SWAP ;

                       DUP ;

                       DUG 2 ;

                       GET 5 ;

                       SENDER ;

                       COMPARE ;

                       EQ ;

                       IF {} { PUSH string "Invalid User" ; FAILWITH } ;

                       PUSH nat 4 ;

                       DUP 3 ;

                       CAR ;

                       GET 6 ;

                       COMPARE ;

                       EQ ;

                       IF {} { PUSH string "Invalid Operation Value" ; FAILWITH } ;

                       NIL address ;

                       DUP 3 ;

                       GET 3 ;

                       CDR ;

                       ITER { CAR ; CONS } ;

                       NIL address ;

                       SWAP ;

                       ITER { CONS } ;

                       SIZE ;

                       NIL address ;

                       DUP 4 ;

                       CAR ;

                       CAR ;

                       CAR ;

                       ITER { CONS } ;

                       NIL address ;

                       SWAP ;

                       ITER { CONS } ;

                       SIZE ;

                       COMPARE ;

                       EQ ;

                       IF {} { PUSH string "EveryOne hasn't voted" ; FAILWITH } ;

                       SWAP ;

                       UNPAIR ;

                       UNPAIR ;

                       SWAP ;

                       CDR ;

                       DUP 4 ;

                       CAR ;

                       SWAP ;

                       CDR ;

                       DIG 4 ;

                       CDR ;

                       PAIR ;

                       SWAP ;

                       PAIR ;

                       SWAP ;

                       PAIR ;

                       SWAP ;

                       UNPAIR ;

                       CAR ;

                       EMPTY_MAP address bool ;

                       SWAP ;

                       PAIR ;

                       PAIR ;

                       SWAP ;

                       UNPAIR ;

                       SWAP ;

                       UNPAIR ;

                       SWAP ;

                       CAR ;

                       PUSH nat 0 ;

                       SWAP ;

                       PAIR ;

                       SWAP ;

                       PAIR ;

                       SWAP ;

                       PAIR ;

                       PAIR } ;

                   NIL operation }

                 { IF_LEFT

                     { SWAP ;

                       DUP ;

                       DUG 2 ;

                       GET 5 ;

                       SENDER ;

                       COMPARE ;

                       EQ ;

                       IF {} { PUSH string "Invalid Admin Sender" ; FAILWITH } ;

                       PUSH nat 1 ;

                       DUP 3 ;

                       CAR ;

                       GET 6 ;

                       COMPARE ;

                       EQ ;

                       IF {} { PUSH string "Invalid Operation Value" ; FAILWITH } ;

                       NIL address ;

                       DUP 3 ;

                       GET 3 ;

                       CDR ;

                       ITER { CAR ; CONS } ;

                       NIL address ;

                       SWAP ;

                       ITER { CONS } ;

                       SIZE ;

                       NIL address ;

                       DUP 4 ;

                       CAR ;

                       CAR ;

                       CAR ;

                       ITER { CONS } ;

                       NIL address ;

                       SWAP ;

                       ITER { CONS } ;