parameter (or

            (or

              (or

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

                    (pair %burn (address %address) (nat %value)))

                (or (unit %default) (nat %deposit)))

              (or

                (or (nat %deposit_callback)

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

                                        (contract nat)))

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

                    (or (pair %getTotalSupply unit (contract nat)) (address %liquidate)))))

            (or

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

                  (or (nat %redeem_callback)

                      (or

                        (pair %transfer (address %from)

                                        (pair (address %to) (nat %value)))

                        (pair %updateContractMetadata string bytes))))

              (or

                (or (address %updateGovernorAddress)

                    (address %updateOvenRegistryAddress))

                (or (address %updateQuipuswapAddress)

                    (or (nat %updateRewardPercent)

                        (pair %updateTokenMetadata nat (map string bytes)))))));

storage (pair

          (pair

            (pair

              (big_map %balances address

                                 (pair (map %approvals address nat) (nat %balance)))

              (pair (address %governorAddress) (big_map %metadata string bytes)))

            (pair (pair (address %ovenRegistryAddress) (address %quipuswapAddress))

                  (pair (nat %rewardChangeAllowedLevel) (nat %rewardPercent))))

          (pair

            (pair

              (pair (option %savedState_depositor address)

                    (option %savedState_redeemer address))

              (pair (option %savedState_tokensToDeposit nat)

                    (option %savedState_tokensToRedeem nat)))

            (pair (pair (int %state) (address %tokenAddress))

                  (pair (big_map %token_metadata nat (pair nat (map string bytes)))

                        (nat %totalSupply)))));

code { UNPAIR ;

       IF_LEFT

         { IF_LEFT

             { IF_LEFT

                 { IF_LEFT

                     { SWAP ;

                       DUP ;

                       DUG 2 ;

                       CAR ;

                       CAR ;

                       CAR ;

                       SENDER ;

                       MEM ;

                       IF

                         {}

                         { SWAP ;

                           UNPAIR ;

                           UNPAIR ;

                           UNPAIR ;

                           PUSH (option (pair (map %approvals address nat) (nat %balance))) (Some (Pair {} 0)) ;

                           SENDER ;

                           UPDATE ;

                           PAIR ;

                           PAIR ;

                           PAIR ;

                           SWAP } ;

                       PUSH nat 0 ;

                       DUP 3 ;

                       CAR ;

                       CAR ;

                       CAR ;

                       SENDER ;

                       GET ;

                       { IF_NONE

                           { PUSH (pair string int) (Pair "GetItem" 52) ; FAILWITH }

                           {} } ;

                       CAR ;

                       DUP 3 ;

                       CAR ;

                       GET ;

                       { IF_NONE { PUSH nat 0 } {} } ;

                       COMPARE ;

                       EQ ;

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

                       IF {} { PUSH (pair string int) (Pair "verify" 53) ; FAILWITH } ;

                       SWAP ;

                       UNPAIR ;

                       UNPAIR ;

                       UNPAIR ;

                       DUP ;

                       SENDER ;

                       DUP ;

                       DUG 2 ;

                       GET ;

                       { IF_NONE

                           { PUSH (pair string int) (Pair "unzip_option" 54) ; FAILWITH }

                           {} } ;

                       UNPAIR ;

                       DUP 8 ;

                       CDR ;

                       SOME ;

                       DIG 8 ;

                       CAR ;

                       UPDATE ;

                       PAIR ;

                       SOME ;

                       SWAP ;

                       UPDATE ;

                       PAIR ;

                       PAIR ;

                       PAIR }

                     { SELF_ADDRESS ;

                       SENDER ;

                       COMPARE ;

                       EQ ;

                       IF {} { PUSH (pair string int) (Pair "verify" 98) ; FAILWITH } ;

                       DUP ;

                       CDR ;

                       DUP 3 ;

                       CAR ;

                       CAR ;

                       CAR ;

                       DUP 3 ;

                       CAR ;

                       GET ;

                       { IF_NONE

                           { PUSH (pair string int) (Pair "GetItem" 100) ; FAILWITH }

                           {} } ;

                       CDR ;

                       COMPARE ;

                       GE ;

                       IF {} { PUSH (pair string int) (Pair "verify" 100) ; FAILWITH } ;

                       SWAP ;

                       DUP ;

                       DUG 2 ;

                       UNPAIR ;

                       UNPAIR ;

                       UNPAIR ;

                       DUP ;

                       DUP 6 ;

                       CAR ;

                       DUP ;

                       DUG 2 ;

                       GET ;

                       { IF_NONE

                           { PUSH (pair string int) (Pair "unzip_option" 101) ; FAILWITH }

                           {} } ;

                       CAR ;

                       DUP 7 ;

                       CDR ;

                       DIG 8 ;

                       CAR ;

                       CAR ;

                       CAR ;

                       DUP 9 ;

                       CAR ;

                       GET ;

                       { IF_NONE

                           { PUSH (pair string int) (Pair "GetItem" 101) ; FAILWITH }

                           {} } ;

                       CDR ;

                       SUB ;

                       ISNAT ;

                       { IF_NONE

                           { PUSH (pair string int) (Pair "OpenVariant" 101) ; FAILWITH }

                           {} } ;

                       SWAP ;

                       PAIR ;

                       SOME ;

                       SWAP ;

                       UPDATE ;

                       PAIR ;

                       PAIR ;

                       PAIR ;

                       DUP ;

                       DUG 2 ;

                       UNPAIR ;

                       SWAP ;

                       UNPAIR ;

                       SWAP ;

                       UNPAIR ;

                       SWAP ;

                       CAR ;

                       DIG 4 ;

                       CDR ;

                       DIG 5 ;

                       GET 8 ;

                       SUB ;

                       ISNAT ;

                       { IF_NONE

                           { PUSH (pair string int) (Pair "OpenVariant" 102) ; FAILWITH }

                           {} } ;

                       SWAP ;

                       PAIR ;

                       SWAP ;

                       PAIR ;

                       SWAP ;

                       PAIR ;

                       SWAP ;

                       PAIR } ;

                   NIL operation }

                 { IF_LEFT

                     { DROP ;

                       NIL operation ;

                       SOURCE ;

                       CONTRACT unit ;

                       { IF_NONE

                           { PUSH (pair string int) (Pair "OpenVariant" 141) ; FAILWITH }

                           {} } ;

                       PUSH nat 100 ;

                       AMOUNT ;

                       DUP 5 ;

                       CAR ;

                       GET 6 ;

                       MUL ;

                       EDIV ;

                       { IF_NONE

                           { PUSH (pair string int) (Pair "OfSome" 140) ; FAILWITH }

                           {} } ;

                       CAR ;

                       UNIT ;

                       TRANSFER_TOKENS ;

                       CONS ;

                       SWAP ;

                       DUP ;

                       DUG 2 ;

                       CAR ;

                       GET 3 ;

                       CDR ;

                       CONTRACT %tezToTokenPayment (pair nat address) ;

                       { IF_NONE

                           { PUSH (pair string int) (Pair "OpenVariant" 149) ; FAILWITH }

                           {} } ;

                       PUSH nat 100 ;

                       AMOUNT ;

                       DUP 5 ;

                       CAR ;

                       GET 6 ;

                       MUL ;

                       EDIV ;

                       { IF_NONE

                           { PUSH (pair string int) (Pair "OfSome" 140) ; FAILWITH }

                           {} } ;

                       CAR ;

                       BALANCE ;

                       SUB ;

                       SELF_ADDRESS ;

                       PUSH nat 1 ;

                       PAIR ;

                       TRANSFER_TOKENS ;

                       CONS }

                     { PUSH int 0 ;

                       DUP 3 ;

                       GET 5 ;

                       CAR ;

                       COMPARE ;

                       EQ ;

                       IF {} { PUSH (pair string int) (Pair "verify" 187) ; FAILWITH } ;

                       SWAP ;

                       UNPAIR ;

                       SWAP ;

                       UNPAIR ;

                       SWAP ;

                       UNPAIR ;

                       CDR ;

                       PUSH int 3 ;

                       PAIR ;

                       PAIR ;

                       SWAP ;

                       UNPAIR ;

                       SWAP ;

                       CDR ;

                       DIG 4 ;

                       SOME ;

                       PAIR ;

                       SWAP ;

                       CDR ;

                       SENDER ;

                       SOME ;

                       PAIR ;

                       PAIR ;

                       PAIR ;

                       SWAP ;

                       PAIR ;

                       DUP ;

                       GET 5 ;

                       CDR ;

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

                       { IF_NONE

                           { PUSH (pair string int) (Pair "OpenVariant" 196) ; FAILWITH }

                           {} } ;

                       NIL operation ;

                       SWAP ;

                       PUSH mutez 0 ;

                       SELF %deposit_callback ;

                       SELF_ADDRESS ;

                       PAIR ;

                       TRANSFER_TOKENS ;

                       CONS } } }

             { IF_LEFT

                 { IF_LEFT

                     { SWAP ;

                       DUP ;

                       DUG 2 ;

                       GET 5 ;

                       CDR ;

                       SENDER ;

                       COMPARE ;

                       EQ ;

                       IF {} { PUSH (pair string int) (Pair "verify" 209) ; FAILWITH } ;

                       PUSH int 3 ;

                       DUP 3 ;

                       GET 5 ;

                       CAR ;

                       COMPARE ;

                       EQ ;

                       IF {} { PUSH (pair string int) (Pair "verify" 212) ; FAILWITH } ;

                       SWAP ;

                       DUP ;

                       DUG 2 ;

                       GET 3 ;

                       GET 3 ;

                       { IF_NONE

                           { PUSH (pair string int) (Pair "OpenVariant" 215) ; FAILWITH }

                           {} } ;

                       DUP ;

                       PUSH nat 1000000000000000000 ;

                       MUL ;

                       PUSH nat 0 ;

                       DUP 5 ;

                       GET 8 ;

                       COMPARE ;

                       NEQ ;

                       IF

                         { DROP ;

                           DUP ;

                           DIG 2 ;

                           ADD ;

                           PUSH nat 1000000000000000000 ;

                           DUP 3 ;

                           MUL ;

                           EDIV ;

                           { IF_NONE

                               { PUSH (pair string int) (Pair "DivisionByZero" 219) ;

                                 FAILWITH }

                               { CAR } } ;

                           DUP ;

                           PUSH nat 1000000000000000000 ;

                           SUB ;

                           ISNAT ;

                           { IF_NONE

                               { PUSH (pair string int) (Pair "OpenVariant" 220) ;

                                 FAILWITH }

                               {} } ;

                           DUP 4 ;

                           GET 8 ;

                           DIG 2 ;

                           MUL ;

                           EDIV ;

                           { IF_NONE

                               { PUSH (pair string int) (Pair "DivisionByZero" 220) ;

                                 FAILWITH }

                               { CAR } } }

                         { DIG 2 ; DROP } ;

                       DUP 3 ;

                       GET 3 ;

                       CAR ;

                       CAR ;

                       { IF_NONE

                           { PUSH (pair string int) (Pair "OpenVariant" 223) ; FAILWITH }

                           {} } ;

                       NIL operation ;

                       DUP 5 ;

                       GET 5 ;

                       CDR ;

                       CONTRACT %transfer (pair (address %from)

                                                (pair (address %to) (nat %value))) ;

                       { IF_NONE

                           { PUSH (pair string int) (Pair "OpenVariant" 229) ; FAILWITH }

                           {} } ;

                       PUSH mutez 0 ;

                       DIG 5 ;

                       SELF_ADDRESS ;

                       PAIR %to %value ;

                       DUP 5 ;

                       PAIR %from ;

                       TRANSFER_TOKENS ;

                       CONS ;

                       SELF_ADDRESS ;

                       CONTRACT %mint (pair (address %address) (nat %value)) ;

                       { IF_NONE

                           { PUSH (pair string int) (Pair "OpenVariant" 241) ; FAILWITH }

                           {} } ;

                       PUSH mutez 0 ;

                       DIG 4 ;

                       DIG 4 ;

                       PAIR %address %value ;

                       TRANSFER_TOKENS ;

                       CONS ;

                       SWAP ;

                       UNPAIR ;

                       SWAP ;

                       UNPAIR ;

                       SWAP ;

                       UNPAIR ;

                       CDR ;

                       PUSH int 0 ;

                       PAIR ;

                       PAIR ;

                       SWAP ;

                       UNPAIR ;

                       SWAP ;

                       CDR ;

                       NONE nat ;

                       PAIR ;

                       SWAP ;

                       CDR ;

                       NONE address ;

                       PAIR ;

                       PAIR ;

                       PAIR ;

                       SWAP ;

                       PAIR ;

                       SWAP }

                     { SWAP ;

                       DUP ;

                       DUG 2 ;

                       CAR ;

                       CAR ;

                       CAR ;

                       SENDER ;

                       MEM ;

                       IF

                         {}

                         { SWAP ;

                           UNPAIR ;

                           UNPAIR ;

                           UNPAIR ;

                           PUSH (option (pair (map %approvals address nat) (nat %balance))) (Some (Pair {} 0)) ;

                           SENDER ;

                           UPDATE ;

                           PAIR ;

                           PAIR ;

                           PAIR ;

                           SWAP } ;

                       SWAP ;

                       DUP ;

                       DUG 2 ;

                       CAR ;

                       CAR ;

                       CAR ;

                       SWAP ;

                       DUP ;

                       DUG 2 ;

                       CAR ;

                       CAR ;

                       GET ;

                       { IF_NONE

                           { PUSH (pair string int) (Pair "GetItem" 75) ; FAILWITH }

                           {} } ;

                       CAR ;

                       SWAP ;

                       DUP ;

                       DUG 2 ;

                       CAR ;

                       CDR ;

                       GET ;

                       { IF_NONE { PUSH nat 0 } {} } ;

                       NIL operation ;

                       DIG 2 ;

                       CDR ;

                       PUSH mutez 0 ;

                       DIG 3 ;

                       TRANSFER_TOKENS ;

                       CONS } }

                 { IF_LEFT

                     { SWAP ;

                       DUP ;

                       DUG 2 ;

                       CAR ;

                       CAR ;

                       CAR ;

                       SWAP ;

                       DUP ;

                       DUG 2 ;

                       CAR ;

                       MEM ;

                       IF

                         {}

                         { SWAP ;

                           UNPAIR ;

                           UNPAIR ;

                           UNPAIR ;

                           PUSH (option (pair (map %approvals address nat) (nat %balance))) (Some (Pair {} 0)) ;

                           DUP 6 ;

                           CAR ;

                           UPDATE ;

                           PAIR ;

                           PAIR ;

                           PAIR ;

                           SWAP } ;

                       SWAP ;

                       DUP ;

                       DUG 2 ;

                       CAR ;

                       CAR ;

                       CAR ;

                       SWAP ;

                       DUP ;

                       DUG 2 ;

                       CAR ;

                       GET ;

                       { IF_NONE

                           { PUSH (pair string int) (Pair "GetItem" 66) ; FAILWITH }

                           {} } ;

                       CDR ;

                       NIL operation ;

                       DIG 2 ;

                       CDR ;

                       PUSH mutez 0 ;

                       DIG 3 ;

                       TRANSFER_TOKENS ;

                       CONS }

                     { IF_LEFT

                         { SWAP ;

                           DUP ;

                           DUG 2 ;

                           GET 8 ;

                           NIL operation ;

                           DIG 2 ;

                           CDR ;

                           PUSH mutez 0 ;

                           DIG 3 ;

                           TRANSFER_TOKENS ;

                           CONS }

                         { NIL operation ;

                           DUP 3 ;

                           CAR ;

                           GET 3 ;

                           CAR ;

                           CONTRACT %isOven address ;

                           { IF_NONE

                               { PUSH (pair string int) (Pair "OpenVariant" 162) ;

                                 FAILWITH }

                               {} } ;

                           PUSH mutez 0 ;

                           DUP 4 ;

                           TRANSFER_TOKENS ;

                           CONS ;

                           SWAP ;

                           CONTRACT %liquidate unit ;

                           { IF_NONE

                               { PUSH (pair string int) (Pair "OpenVariant" 170) ;

                                 FAILWITH }

                               {} } ;

                           PUSH mutez 0 ;

                           UNIT ;

                           TRANSFER_TOKENS ;

                           CONS } } } } }

         { IF_LEFT

             { IF_LEFT

                 { IF_LEFT

                     { SELF_ADDRESS ;

                       SENDER ;

                       COMPARE ;

                       EQ ;

                       IF {} { PUSH (pair string int) (Pair "verify" 87) ; FAILWITH } ;

                       SWAP ;

                       DUP ;

                       DUG 2 ;

                       CAR ;

                       CAR ;

                       CAR ;

                       SWAP ;

                       DUP ;

                       DUG 2 ;

                       CAR ;

                       MEM ;

                       IF

                         {}

                         { SWAP ;

                           UNPAIR ;

                           UNPAIR ;

                           UNPAIR ;

                           PUSH (option (pair (map %approvals address nat) (nat %balance))) (Some (Pair {} 0)) ;

                           DUP 6 ;

                           CAR ;

                           UPDATE ;

                           PAIR ;

                           PAIR ;

                           PAIR ;

                           SWAP } ;

                       SWAP ;

                       UNPAIR ;

                       UNPAIR ;

                       UNPAIR ;

                       DUP ;

                       DUP 6 ;

                       CAR ;

                       DUP ;

                       DUG 2 ;

                       GET ;

                       { IF_NONE

                           { PUSH (pair string int) (Pair "unzip_option" 90) ; FAILWITH }

                           {} } ;

                       UNPAIR ;

                       SWAP ;

                       DUP 8 ;

                       CDR ;

                       ADD ;

                       SWAP ;

                       PAIR ;

                       SOME ;

                       SWAP ;

                       UPDATE ;

                       PAIR ;

                       PAIR ;

                       SWAP ;

                       UNPAIR ;

                       SWAP ;

                       UNPAIR ;

                       SWAP ;

                       UNPAIR ;

                       SWAP ;

                       DIG 5 ;

                       CDR ;

                       ADD ;

                       SWAP ;

                       PAIR ;

                       SWAP ;

                       PAIR ;

                       SWAP ;

                       PAIR ;

                       SWAP ;

                       PAIR ;

                       NIL operation }

                     { PUSH int 0 ;

                       DUP 3 ;

                       GET 5 ;

                       CAR ;

                       COMPARE ;

                       EQ ;

                       IF {} { PUSH (pair string int) (Pair "verify" 259) ; FAILWITH } ;

                       SWAP ;

                       UNPAIR ;

                       SWAP ;

                       UNPAIR ;

                       SWAP ;

                       UNPAIR ;

                       CDR ;

                       PUSH int 2 ;

                       PAIR ;

                       PAIR ;

                       SWAP ;

                       UNPAIR ;

                       SWAP ;

                       CAR ;

                       DIG 4 ;

                       SOME ;

                       SWAP ;

                       PAIR ;

                       SWAP ;

                       CAR ;

                       SENDER ;

                       SOME ;

                       SWAP ;

                       PAIR ;

                       PAIR ;

                       PAIR ;

                       SWAP ;

                       PAIR ;

                       DUP ;

                       GET 5 ;

                       CDR ;

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

                       { IF_NONE

                           { PUSH (pair string int) (Pair "OpenVariant" 268) ; FAILWITH }

                           {} } ;

                       NIL operation ;

                       SWAP ;

                       PUSH mutez 0 ;

                       SELF %redeem_callback ;

                       SELF_ADDRESS ;

                       PAIR ;

                       TRANSFER_TOKENS ;

                       CONS } }

                 { IF_LEFT

                     { SWAP ;

                       DUP ;

                       DUG 2 ;

                       GET 5 ;

                       CDR ;

                       SENDER ;

                       COMPARE ;

                       EQ ;

                       IF {} { PUSH (pair string int) (Pair "verify" 281) ; FAILWITH } ;

                       PUSH int 2 ;

                       DUP 3 ;

                       GET 5 ;

                       CAR ;

                       COMPARE ;

                       EQ ;

                       IF {} { PUSH (pair string int) (Pair "verify" 284) ; FAILWITH } ;

                       SWAP ;

                       DUP ;

                       DUG 2 ;

                       GET 3 ;

                       GET 4 ;

                       { IF_NONE

                           { PUSH (pair string int) (Pair "OpenVariant" 287) ; FAILWITH }

                           {} } ;

                       DUP 3 ;

                       GET 8 ;

                       PUSH nat 1000000000000000000 ;

                       DUP 3 ;

                       MUL ;

                       EDIV ;

                       { IF_NONE

                           { PUSH (pair string int) (Pair "DivisionByZero" 288) ;

                             FAILWITH }

                           { CAR } } ;

                       PUSH nat 1000000000000000000 ;

                       DIG 3 ;

                       DIG 2 ;

                       MUL ;

                       EDIV ;

                       { IF_NONE

                           { PUSH (pair string int) (Pair "DivisionByZero" 289) ;

                             FAILWITH }

                           { CAR } } ;

                       DUP 3 ;

                       GET 3 ;

                       CAR ;

                       CDR ;

                       { IF_NONE

                           { PUSH (pair string int) (Pair "OpenVariant" 292) ; FAILWITH }

                           {} } ;

                       NIL operation ;

                       SELF_ADDRESS ;

                       CONTRACT %burn (pair (address %address) (nat %value)) ;

                       { IF_NONE

                           { PUSH (pair string int) (Pair "OpenVariant" 297) ; FAILWITH }

                           {} } ;

                       PUSH mutez 0 ;

                       DIG 5 ;

                       DUP 5 ;

                       PAIR %address %value ;

                       TRANSFER_TOKENS ;

                       CONS ;

                       DUP 4 ;

                       GET 5 ;

                       CDR ;

                       CONTRACT %transfer (pair (address %from)

                                                (pair (address %to) (nat %value))) ;

                       { IF_NONE

                           { PUSH (pair string int) (Pair "OpenVariant" 310) ; FAILWITH }

                           {} } ;

                       PUSH mutez 0 ;

                       DIG 4 ;

                       DIG 4 ;

                       PAIR %to %value ;

                       SELF_ADDRESS ;

                       PAIR %from ;

                       TRANSFER_TOKENS ;

                       CONS ;

                       SWAP ;

                       UNPAIR ;

                       SWAP ;

                       UNPAIR ;

                       SWAP ;

                       UNPAIR ;

                       CDR ;

                       PUSH int 0 ;

                       PAIR ;

                       PAIR ;

                       SWAP ;

                       UNPAIR ;

                       SWAP ;

                       CAR ;

                       NONE nat ;

                       SWAP ;

                       PAIR ;

                       SWAP ;

                       CAR ;

                       NONE address ;

                       SWAP ;

                       PAIR ;

                       PAIR ;

                       PAIR ;

                       SWAP ;

                       PAIR ;

                       SWAP }

                     { IF_LEFT

                         { DUP ;

                           CAR ;

                           SENDER ;

                           COMPARE ;

                           EQ ;

                           IF

                             { PUSH bool True }

                             { DUP ;

                               GET 4 ;

                               DUP 3 ;

                               CAR ;

                               CAR ;

                               CAR ;

                               DUP 3 ;

                               CAR ;

                               GET ;

                               { IF_NONE

                                   { PUSH (pair string int) (Pair "GetItem" 31) ;

                                     FAILWITH }

                                   {} } ;