parameter (or

            (or

              (or (pair %approve (address %spender) (nat %value))

                  (or (unit %bet) (address %changeAdmin)))

              (or

                (or (unit %default)

                    (pair %getAllowance (pair (address %owner) (address %spender))

                                        (contract nat)))

                (or (pair %getBalance address (contract nat))

                    (pair %getTotalSupply unit (contract nat)))))

            (or

              (or

                (or (pair %mint (address %address) (nat %value))

                    (address %setBakerValidatorContract))

                (or (address %setLiqAddress) (nat %stake)))

              (or

                (or (pair %transfer (address %from) (pair (address %to) (nat %value)))

                    (nat %unstake))

                (or (unit %unvote) (key_hash %vote)))));

storage (pair

          (pair

            (pair

              (pair (address %admin)

                    (pair (address %bakerValidatorContract) (address %bestUser)))

              (pair (map %candidates address key_hash)

                    (pair (key_hash %currentBaker) (nat %dividends))))

            (pair

              (pair (timestamp %finishTime) (pair (nat %lastPot) (address %lastWinner)))

              (pair

                (big_map %ledger address

                                 (pair

                                   (pair (map %approvals address nat)

                                         (pair (nat %balance) (nat %frozenBalance)))

                                   (pair (nat %reward)

                                         (pair (nat %rewardDebt) (nat %usedVotes)))))

                (pair (address %liqAddress) (nat %maxGameSupply)))))

          (pair

            (pair

              (pair (big_map %metadata string bytes)

                    (pair (nat %piggyBank) (timestamp %piggyBankBreakTime)))

              (pair (nat %rewardPerToken)

                    (pair (key_hash %secondNextBaker)

                          (big_map %token_metadata nat

                                                   (pair (nat %token_id)

                                                         (map %token_info string bytes))))))

            (pair (pair (nat %totalIssued) (pair (nat %totalPot) (nat %totalStaked)))

                  (pair (pair (nat %totalSupply) (nat %usedLiqSupply))

                        (pair (nat %usedSupply) (map %votes key_hash nat))))));

code { UNPAIR ;

       IF_LEFT

         { IF_LEFT

             { IF_LEFT

                 { SWAP ;

                   DUP ;

                   DUG 2 ;

                   CAR ;

                   GET 5 ;

                   SENDER ;

                   GET ;

                   { IF_NONE { PUSH int 116 ; FAILWITH } {} } ;

                   CAR ;

                   CAR ;

                   SWAP ;

                   DUP ;

                   DUG 2 ;

                   CAR ;

                   GET ;

                   { IF_NONE { PUSH nat 0 } {} } ;

                   PUSH nat 0 ;

                   COMPARE ;

                   EQ ;

                   IF { PUSH bool True } { DUP ; CDR ; PUSH nat 0 ; COMPARE ; EQ } ;

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

                   SWAP ;

                   UNPAIR ;

                   UNPAIR ;

                   SWAP ;

                   UNPAIR ;

                   SWAP ;

                   UNPAIR ;

                   DUP ;

                   SENDER ;

                   DUP ;

                   DUG 2 ;

                   GET ;

                   { IF_NONE { PUSH int 118 ; FAILWITH } {} } ;

                   UNPAIR ;

                   UNPAIR ;

                   DUP 10 ;

                   CDR ;

                   SOME ;

                   DIG 10 ;

                   CAR ;

                   UPDATE ;

                   PAIR ;

                   PAIR ;

                   SOME ;

                   SWAP ;

                   UPDATE ;

                   PAIR ;

                   SWAP ;

                   PAIR ;

                   SWAP ;

                   PAIR ;

                   PAIR ;

                   NIL operation }

                 { IF_LEFT

                     { NOW ;

                       DUP 3 ;

                       CAR ;

                       GET 3 ;

                       CAR ;

                       COMPARE ;

                       LT ;

                       IF

                         { PUSH nat 0 ;

                           DUP 3 ;

                           GET 5 ;

                           GET 3 ;

                           COMPARE ;

                           GT ;

                           IF

                             { NIL operation ;

                               DUP 3 ;

                               CAR ;

                               CAR ;

                               CAR ;

                               GET 4 ;

                               CONTRACT unit ;

                               { IF_NONE { PUSH int 202 ; FAILWITH } {} } ;

                               PUSH mutez 1 ;

                               DUP 5 ;

                               GET 5 ;

                               GET 3 ;

                               MUL ;

                               UNIT ;

                               TRANSFER_TOKENS ;

                               CONS ;

                               DUP 3 ;

                               UNPAIR ;

                               UNPAIR ;

                               SWAP ;

                               UNPAIR ;

                               UNPAIR ;

                               SWAP ;

                               CDR ;

                               DIG 7 ;

                               GET 5 ;

                               GET 3 ;

                               PAIR ;

                               SWAP ;

                               PAIR ;

                               PAIR ;

                               SWAP ;

                               PAIR ;

                               SWAP ;

                               UNPAIR ;

                               SWAP ;

                               UNPAIR ;

                               UNPAIR ;

                               SWAP ;

                               CDR ;

                               PUSH nat 0 ;

                               PAIR ;

                               SWAP ;

                               PAIR ;

                               PAIR ;

                               SWAP ;

                               PAIR ;

                               SWAP ;

                               PAIR ;

                               DUP ;

                               DUG 3 ;

                               UNPAIR ;

                               UNPAIR ;

                               SWAP ;

                               UNPAIR ;

                               UNPAIR ;

                               SWAP ;

                               CAR ;

                               DIG 7 ;

                               CAR ;

                               CAR ;

                               CAR ;

                               GET 4 ;

                               SWAP ;

                               PAIR ;

                               SWAP ;

                               PAIR ;

                               PAIR ;

                               SWAP ;

                               PAIR ;

                               PAIR ;

                               DUG 2 }

                             { NIL operation } ;

                           DIG 2 ;

                           UNPAIR ;

                           UNPAIR ;

                           SWAP ;

                           UNPAIR ;

                           CDR ;

                           NOW ;

                           PUSH int 360000 ;

                           ADD ;

                           PAIR ;

                           PAIR ;

                           SWAP ;

                           PAIR ;

                           PAIR ;

                           DUG 2 }

                         { NIL operation } ;

                       PUSH mutez 1 ;

                       AMOUNT ;

                       EDIV ;

                       { IF_NONE { PUSH int 165 ; FAILWITH } {} } ;

                       CAR ;

                       DUP ;

                       PUSH nat 0 ;

                       COMPARE ;

                       EQ ;

                       IF

                         { DROP ;

                           SWAP ;

                           DROP ;

                           PUSH nat 10000000 ;

                           DUP 3 ;

                           CAR ;

                           GET 5 ;

                           SENDER ;

                           GET ;

                           { IF_NONE { PUSH int 168 ; FAILWITH } {} } ;

                           CAR ;

                           GET 3 ;

                           COMPARE ;

                           GE ;

                           IF {} { PUSH string "Wrong token amount" ; FAILWITH } ;

                           SWAP ;

                           DUP ;

                           DUG 2 ;

                           CAR ;

                           GET 5 ;

                           SENDER ;

                           GET ;

                           { IF_NONE { PUSH int 157 ; FAILWITH } {} } ;

                           CAR ;

                           GET 3 ;

                           DUP ;

                           PUSH nat 10000000 ;

                           SWAP ;

                           COMPARE ;

                           GE ;

                           IF

                             {}

                             { PUSH string "WrongCondition: balance.value >= 10000000" ;

                               FAILWITH } ;

                           DIG 2 ;

                           UNPAIR ;

                           UNPAIR ;

                           SWAP ;

                           UNPAIR ;

                           SWAP ;

                           UNPAIR ;

                           DUP ;

                           SENDER ;

                           DUP ;

                           DUG 2 ;

                           GET ;

                           { IF_NONE { PUSH int 159 ; FAILWITH } {} } ;

                           UNPAIR ;

                           UNPAIR ;

                           SWAP ;

                           CDR ;

                           PUSH nat 10000000 ;

                           DIG 10 ;

                           SUB ;

                           ISNAT ;

                           { IF_NONE { PUSH int 159 ; FAILWITH } {} } ;

                           PAIR ;

                           SWAP ;

                           PAIR ;

                           PAIR ;

                           SOME ;

                           SWAP ;

                           UPDATE ;

                           PAIR ;

                           SWAP ;

                           PAIR ;

                           SWAP ;

                           PAIR ;

                           PAIR ;

                           DUP ;

                           DUG 2 ;

                           UNPAIR ;

                           SWAP ;

                           UNPAIR ;

                           SWAP ;

                           UNPAIR ;

                           SWAP ;

                           UNPAIR ;

                           CDR ;

                           PUSH nat 10000000 ;

                           DIG 7 ;

                           GET 7 ;

                           CAR ;

                           SUB ;

                           ISNAT ;

                           { IF_NONE { PUSH int 160 ; FAILWITH } {} } ;

                           PAIR ;

                           PAIR ;

                           SWAP ;

                           PAIR ;

                           SWAP ;

                           PAIR ;

                           SWAP ;

                           UNPAIR ;

                           UNPAIR ;

                           UNPAIR ;

                           SWAP ;

                           CAR ;

                           SENDER ;

                           SWAP ;

                           PAIR ;

                           SWAP ;

                           PAIR ;

                           PAIR ;

                           PAIR ;

                           PAIR ;

                           SWAP ;

                           NOW ;

                           PUSH int 3600 ;

                           ADD ;

                           DUP 3 ;

                           CAR ;

                           GET 3 ;

                           CAR ;

                           COMPARE ;

                           LE ;

                           IF

                             { PUSH nat 25000000 ;

                               DUP 3 ;

                               GET 5 ;

                               GET 3 ;

                               COMPARE ;

                               GT ;

                               IF

                                 { PUSH nat 100000000 ; DUP 3 ; GET 5 ; GET 3 ; COMPARE ; LE }

                                 { PUSH bool False } ;

                               IF

                                 { SWAP ;

                                   UNPAIR ;

                                   UNPAIR ;

                                   SWAP ;

                                   UNPAIR ;

                                   CDR ;

                                   NOW ;

                                   PUSH int 3600 ;

                                   ADD ;

                                   PAIR ;

                                   PAIR ;

                                   SWAP ;

                                   PAIR ;

                                   PAIR ;

                                   SWAP }

                                 {} }

                             {} ;

                           NOW ;

                           PUSH int 2700 ;

                           ADD ;

                           DUP 3 ;

                           CAR ;

                           GET 3 ;

                           CAR ;

                           COMPARE ;

                           LE ;

                           IF

                             { PUSH nat 100000000 ;

                               DUP 3 ;

                               GET 5 ;

                               GET 3 ;

                               COMPARE ;

                               GT ;

                               IF

                                 { PUSH nat 1000000000 ; DUP 3 ; GET 5 ; GET 3 ; COMPARE ; LE }

                                 { PUSH bool False } ;

                               IF

                                 { SWAP ;

                                   UNPAIR ;

                                   UNPAIR ;

                                   SWAP ;

                                   UNPAIR ;

                                   CDR ;

                                   NOW ;

                                   PUSH int 2700 ;

                                   ADD ;

                                   PAIR ;

                                   PAIR ;

                                   SWAP ;

                                   PAIR ;

                                   PAIR ;

                                   SWAP }

                                 {} }

                             {} ;

                           NOW ;

                           PUSH int 1800 ;

                           ADD ;

                           DUP 3 ;

                           CAR ;

                           GET 3 ;

                           CAR ;

                           COMPARE ;

                           LE ;

                           IF

                             { PUSH nat 1000000000 ;

                               DUP 3 ;

                               GET 5 ;

                               GET 3 ;

                               COMPARE ;

                               GT ;

                               IF

                                 { PUSH nat 2000000000 ; DUP 3 ; GET 5 ; GET 3 ; COMPARE ; LE }

                                 { PUSH bool False } ;

                               IF

                                 { SWAP ;

                                   UNPAIR ;

                                   UNPAIR ;

                                   SWAP ;

                                   UNPAIR ;

                                   CDR ;

                                   NOW ;

                                   PUSH int 1800 ;

                                   ADD ;

                                   PAIR ;

                                   PAIR ;

                                   SWAP ;

                                   PAIR ;

                                   PAIR ;

                                   SWAP }

                                 {} }

                             {} ;

                           NOW ;

                           PUSH int 900 ;

                           ADD ;

                           DUP 3 ;

                           CAR ;

                           GET 3 ;

                           CAR ;

                           COMPARE ;

                           LE ;

                           IF

                             { PUSH nat 2000000000 ;

                               DUP 3 ;

                               GET 5 ;

                               GET 3 ;

                               COMPARE ;

                               GT ;

                               IF

                                 { PUSH nat 5000000000 ; DUP 3 ; GET 5 ; GET 3 ; COMPARE ; LE }

                                 { PUSH bool False } ;

                               IF

                                 { SWAP ;

                                   UNPAIR ;

                                   UNPAIR ;

                                   SWAP ;

                                   UNPAIR ;

                                   CDR ;

                                   NOW ;

                                   PUSH int 900 ;

                                   ADD ;

                                   PAIR ;

                                   PAIR ;

                                   SWAP ;

                                   PAIR ;

                                   PAIR ;

                                   SWAP }

                                 {} }

                             {} ;

                           NOW ;

                           PUSH int 300 ;

                           ADD ;

                           DUP 3 ;

                           CAR ;

                           GET 3 ;

                           CAR ;

                           COMPARE ;

                           LE ;

                           IF

                             { PUSH nat 5000000000 ;

                               DUP 3 ;

                               GET 5 ;

                               GET 3 ;

                               COMPARE ;

                               GT ;

                               IF

                                 { SWAP ;

                                   UNPAIR ;

                                   UNPAIR ;

                                   SWAP ;

                                   UNPAIR ;

                                   CDR ;

                                   NOW ;

                                   PUSH int 300 ;

                                   ADD ;

                                   PAIR ;

                                   PAIR ;

                                   SWAP ;

                                   PAIR ;

                                   PAIR ;

                                   SWAP }

                                 {} }

                             {} }

                         { DIG 2 ;

                           DROP ;

                           DUP ;

                           PUSH nat 100000 ;

                           COMPARE ;

                           EQ ;

                           IF {} { PUSH string "Wrong tezos amount" ; FAILWITH } ;

                           DUP 3 ;

                           CAR ;

                           GET 8 ;

                           PUSH nat 1000000 ;

                           DUP 5 ;

                           GET 9 ;

                           ADD ;

                           COMPARE ;

                           LE ;

                           IF

                             { DUP 3 ;

                               CAR ;

                               GET 5 ;

                               SENDER ;

                               MEM ;

                               IF

                                 {}

                                 { DIG 2 ;

                                   UNPAIR ;

                                   UNPAIR ;

                                   SWAP ;

                                   UNPAIR ;

                                   SWAP ;

                                   UNPAIR ;

                                   PUSH (option (pair

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

                                              (pair nat (pair nat nat)))) (Some (Pair (Pair {} (Pair 0 0))

                                                    (Pair 0 (Pair 0 0)))) ;

                                   SENDER ;

                                   UPDATE ;

                                   PAIR ;

                                   SWAP ;

                                   PAIR ;

                                   SWAP ;

                                   PAIR ;

                                   PAIR ;

                                   DUG 2 } ;

                               DIG 2 ;

                               UNPAIR ;

                               UNPAIR ;

                               SWAP ;

                               UNPAIR ;

                               SWAP ;

                               UNPAIR ;

                               DUP ;

                               SENDER ;

                               DUP ;

                               DUG 2 ;

                               GET ;

                               { IF_NONE { PUSH int 152 ; FAILWITH } {} } ;

                               UNPAIR ;

                               UNPAIR ;

                               SWAP ;

                               UNPAIR ;

                               PUSH nat 1000000 ;

                               ADD ;

                               PAIR ;

                               SWAP ;

                               PAIR ;

                               PAIR ;

                               SOME ;

                               SWAP ;

                               UPDATE ;

                               PAIR ;

                               SWAP ;

                               PAIR ;

                               SWAP ;

                               PAIR ;

                               PAIR ;

                               DUP ;

                               GET 9 ;

                               PUSH nat 1000000 ;

                               ADD ;

                               UPDATE 9 ;

                               UNPAIR ;

                               SWAP ;

                               UNPAIR ;

                               SWAP ;

                               UNPAIR ;

                               SWAP ;

                               UNPAIR ;

                               UNPAIR ;

                               PUSH nat 1000000 ;

                               ADD ;

                               PAIR ;

                               PAIR ;

                               SWAP ;

                               PAIR ;

                               SWAP ;

                               PAIR ;

                               SWAP ;

                               PAIR ;

                               DUG 2 }

                             {} ;

                           DIG 2 ;

                           UNPAIR ;

                           UNPAIR ;

                           UNPAIR ;

                           UNPAIR ;

                           SWAP ;

                           CAR ;

                           SENDER ;

                           SWAP ;

                           PAIR ;

                           SWAP ;

                           PAIR ;

                           PAIR ;

                           PAIR ;

                           PAIR ;

                           DUG 2 ;

                           PUSH int 10 ;

                           ISNAT ;

                           { IF_NONE { PUSH int 181 ; FAILWITH } {} } ;

                           SWAP ;

                           DUP ;

                           DUG 2 ;

                           EDIV ;

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

                           DIG 3 ;

                           UNPAIR ;

                           SWAP ;

                           UNPAIR ;

                           SWAP ;

                           UNPAIR ;

                           UNPAIR ;

                           SWAP ;

                           UNPAIR ;

                           DIG 6 ;

                           DUP ;

                           DUP ;

                           DUG 8 ;

                           ADD ;

                           DIG 8 ;

                           SUB ;

                           ISNAT ;

                           { IF_NONE { PUSH int 182 ; FAILWITH } {} } ;

                           ADD ;

                           PAIR ;

                           SWAP ;

                           PAIR ;

                           PAIR ;

                           SWAP ;

                           PAIR ;

                           SWAP ;

                           PAIR ;

                           DUG 2 ;

                           NOW ;

                           DUP 4 ;

                           GET 3 ;

                           CAR ;

                           GET 4 ;

                           COMPARE ;

                           LT ;

                           IF

                             { PUSH nat 0 ;

                               DUP 4 ;

                               GET 5 ;

                               GET 4 ;

                               COMPARE ;

                               EQ ;

                               IF

                                 { DIG 2 ;

                                   UNPAIR ;

                                   SWAP ;

                                   UNPAIR ;

                                   SWAP ;

                                   UNPAIR ;

                                   UNPAIR ;

                                   SWAP ;

                                   UNPAIR ;

                                   DIG 6 ;

                                   DUP ;

                                   ADD ;

                                   ADD ;

                                   PAIR ;

                                   SWAP ;

                                   PAIR ;

                                   PAIR ;

                                   SWAP ;

                                   UNPAIR ;

                                   SWAP ;

                                   CDR ;

                                   PUSH nat 0 ;

                                   PAIR ;

                                   SWAP ;

                                   UNPAIR ;

                                   SWAP ;

                                   CDR ;

                                   PUSH nat 0 ;

                                   PAIR ;

                                   SWAP ;

                                   PAIR ;

                                   PAIR ;

                                   PAIR ;

                                   SWAP ;

                                   PAIR ;

                                   SWAP }

                                 { DUP 3 ;

                                   UNPAIR ;

                                   UNPAIR ;

                                   UNPAIR ;

                                   SWAP ;

                                   UNPAIR ;

                                   SWAP ;

                                   UNPAIR ;

                                   SWAP ;

                                   DIG 6 ;

                                   DUP ;

                                   DUP ;

                                   DUG 8 ;

                                   ADD ;

                                   DIG 9 ;

                                   GET 3 ;

                                   CAR ;

                                   GET 3 ;

                                   ADD ;

                                   ADD ;

                                   SWAP ;

                                   PAIR ;

                                   SWAP ;

                                   PAIR ;

                                   SWAP ;

                                   PAIR ;

                                   PAIR ;

                                   PAIR ;

                                   DUP ;

                                   DUG 3 ;

                                   UNPAIR ;

                                   SWAP ;

                                   UNPAIR ;

                                   SWAP ;

                                   UNPAIR ;

                                   UNPAIR ;

                                   DIG 5 ;

                                   DUP ;

                                   DUP ;

                                   DUG 7 ;

                                   ADD ;

                                   DIG 8 ;

                                   GET 3 ;

                                   CAR ;

                                   GET 3 ;

                                   ADD ;

                                   ADD ;

                                   PAIR ;

                                   PAIR ;

                                   SWAP ;

                                   PAIR ;

                                   SWAP ;

                                   PAIR ;

                                   DUP ;

                                   DUG 3 ;

                                   UNPAIR ;

                                   SWAP ;

                                   UNPAIR ;

                                   UNPAIR ;

                                   SWAP ;

                                   UNPAIR ;

                                   DUP 8 ;

                                   GET 5 ;

                                   GET 4 ;

                                   PUSH nat 1000000000000000 ;

                                   DIG 7 ;

                                   DUP ;

                                   ADD ;

                                   DIG 9 ;

                                   GET 3 ;

                                   CAR ;

                                   GET 3 ;

                                   ADD ;

                                   MUL ;

                                   EDIV ;

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

                                   ADD ;

                                   PAIR ;

                                   SWAP ;

                                   UNPAIR ;

                                   SWAP ;

                                   CDR ;

                                   PUSH nat 0 ;

                                   PAIR ;

                                   SWAP ;

                                   PAIR ;

                                   PAIR ;

                                   PAIR ;

                                   SWAP ;

                                   PAIR ;

                                   SWAP } ;

                               NOW ;

                               PUSH int 3600 ;

                               ADD ;

                               DUP 3 ;

                               CAR ;

                               GET 3 ;

                               CAR ;

                               COMPARE ;

                               LE ;

                               IF

                                 { PUSH nat 25000000 ;

                                   DUP 3 ;

                                   GET 5 ;

                                   GET 3 ;

                                   COMPARE ;

                                   GT ;

                                   IF

                                     { PUSH nat 100000000 ; DUP 3 ; GET 5 ; GET 3 ; COMPARE ; LE }

                                     { PUSH bool False } ;

                                   IF

                                     { SWAP ;

                                       UNPAIR ;

                                       UNPAIR ;

                                       SWAP ;

                                       UNPAIR ;

                                       CDR ;

                                       NOW ;

                                       PUSH int 3600 ;

                                       ADD ;

                                       PAIR ;

                                       PAIR ;

                                       SWAP ;

                                       PAIR ;

                                       PAIR ;

                                       SWAP }

                                     {} }

                                 {} ;

                               NOW ;

                               PUSH int 2700 ;

                               ADD ;

                               DUP 3 ;

                               CAR ;

                               GET 3 ;

                               CAR ;

                               COMPARE ;

                               LE ;

                               IF

                                 { PUSH nat 100000000 ;

                                   DUP 3 ;

                                   GET 5 ;

                                   GET 3 ;

                                   COMPARE ;

                                   GT ;

                                   IF