parameter (or

            (or (or (nat %accrueInterest) (or (unit %default) (address %liquidate)))

                (or

                  (or

                    (pair %rescueFA12 (address %tokenContractAddress)

                                      (pair (nat %amount) (address %destination)))

                    (pair %rescueFA2 (address %tokenContractAddress)

                                     (pair (nat %tokenId)

                                           (pair (nat %amount) (address %destination)))))

                  (or (pair %send mutez address) (address %sendAll))))

            (or

              (or (or (address %sendAllTokens) (nat %sendAllTokens_callback))

                  (or (pair %sendTokens nat address) (address %setAdministratorContract)))

              (or (or (option %setDelegate key_hash) (address %setGovernorContract))

                  (or (address %setOvenRegistryContract)

                      (address %setSavingsPoolContract)))));

storage (pair

          (pair (address %administratorContractAddress)

                (pair (address %governorContractAddress)

                      (address %ovenRegistryContractAddress)))

          (pair

            (pair (address %savingsPoolContractAddress)

                  (option %sendAllTokens_destination address))

            (pair (int %state) (address %tokenContractAddress))));

code { { { DUP ; CAR ; DIP { CDR } } } ;

       IF_LEFT

         { IF_LEFT

             { IF_LEFT

                 { SWAP ;

                   DUP ;

                   DUG 2 ;

                   GET 3 ;

                   CAR ;

                   SENDER ;

                   COMPARE ;

                   EQ ;

                   IF {} { PUSH int 27 ; FAILWITH } ;

                   NIL operation ;

                   { DIP 2 { DUP } ; DIG 3 } ;

                   GET 6 ;

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

                   IF_NONE { UNIT ; FAILWITH } {} ;

                   PUSH mutez 0 ;

                   DIG 3 ;

                   { DIP 4 { DUP } ; DIG 5 } ;

                   GET 3 ;

                   CAR ;

                   SELF_ADDRESS ;

                   PAIR 3 ;

                   TRANSFER_TOKENS ;

                   CONS }

                 { IF_LEFT

                     { DROP ; NIL operation }

                     { SWAP ;

                       DUP ;

                       DUG 2 ;

                       CAR ;

                       CAR ;

                       SENDER ;

                       COMPARE ;

                       EQ ;

                       IF {} { PUSH int 8 ; FAILWITH } ;

                       NIL operation ;

                       { DIP 2 { DUP } ; DIG 3 } ;

                       CAR ;

                       GET 4 ;

                       CONTRACT %isOven address ;

                       IF_NONE { UNIT ; FAILWITH } {} ;

                       PUSH mutez 0 ;

                       { DIP 3 { DUP } ; DIG 4 } ;

                       TRANSFER_TOKENS ;

                       CONS ;

                       SWAP ;

                       CONTRACT %liquidate unit ;

                       IF_NONE { UNIT ; FAILWITH } {} ;

                       PUSH mutez 0 ;

                       UNIT ;

                       TRANSFER_TOKENS ;

                       CONS } } }

             { IF_LEFT

                 { IF_LEFT

                     { SWAP ;

                       DUP ;

                       DUG 2 ;

                       CAR ;

                       GET 3 ;

                       SENDER ;

                       COMPARE ;

                       EQ ;

                       IF {} { PUSH int 4 ; FAILWITH } ;

                       DUP ;

                       CAR ;

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

                       IF_NONE { UNIT ; FAILWITH } {} ;

                       NIL operation ;

                       SWAP ;

                       PUSH mutez 0 ;

                       DIG 3 ;

                       DUP ;

                       GET 3 ;

                       SWAP ;

                       GET 4 ;

                       SELF_ADDRESS ;

                       PAIR 3 ;

                       TRANSFER_TOKENS ;

                       CONS }

                     { SWAP ;

                       DUP ;

                       DUG 2 ;

                       CAR ;

                       GET 3 ;

                       SENDER ;

                       COMPARE ;

                       EQ ;

                       IF {} { PUSH int 4 ; FAILWITH } ;

                       DUP ;

                       CAR ;

                       CONTRACT %transfer (list (pair address

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

                       IF_NONE { UNIT ; FAILWITH } {} ;

                       NIL operation ;

                       SWAP ;

                       PUSH mutez 0 ;

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

                       NIL (pair address (pair nat nat)) ;

                       DIG 5 ;

                       DUP ;

                       GET 5 ;

                       SWAP ;

                       DUP ;

                       GET 3 ;

                       SWAP ;

                       GET 6 ;

                       PAIR 3 ;

                       CONS ;

                       SELF_ADDRESS ;

                       PAIR ;

                       CONS ;

                       TRANSFER_TOKENS ;

                       CONS } }

                 { IF_LEFT

                     { SWAP ;

                       DUP ;

                       DUG 2 ;

                       CAR ;

                       GET 3 ;

                       SENDER ;

                       COMPARE ;

                       EQ ;

                       IF {} { PUSH int 4 ; FAILWITH } ;

                       DUP ;

                       CDR ;

                       CONTRACT unit ;

                       IF_NONE { UNIT ; FAILWITH } {} ;

                       NIL operation ;

                       SWAP ;

                       DIG 2 ;

                       CAR ;

                       UNIT ;

                       TRANSFER_TOKENS ;

                       CONS }

                     { SWAP ;

                       DUP ;

                       DUG 2 ;

                       CAR ;

                       GET 3 ;

                       SENDER ;

                       COMPARE ;

                       EQ ;

                       IF {} { PUSH int 4 ; FAILWITH } ;

                       CONTRACT unit ;

                       IF_NONE { UNIT ; FAILWITH } {} ;

                       NIL operation ;

                       SWAP ;

                       BALANCE ;

                       UNIT ;

                       TRANSFER_TOKENS ;

                       CONS } } } }

         { IF_LEFT

             { IF_LEFT

                 { IF_LEFT

                     { SWAP ;

                       DUP ;

                       DUG 2 ;

                       CAR ;

                       GET 3 ;

                       SENDER ;

                       COMPARE ;

                       EQ ;

                       IF {} { PUSH int 4 ; FAILWITH } ;

                       PUSH int 0 ;

                       { DIP 2 { DUP } ; DIG 3 } ;

                       GET 5 ;

                       COMPARE ;

                       EQ ;

                       IF {} { PUSH int 12 ; FAILWITH } ;

                       NIL operation ;

                       { DIP 2 { DUP } ; DIG 3 } ;

                       GET 6 ;

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

                       IF_NONE { UNIT ; FAILWITH } {} ;

                       PUSH mutez 0 ;

                       SELF %sendAllTokens_callback ;

                       SELF_ADDRESS ;

                       PAIR ;

                       TRANSFER_TOKENS ;

                       CONS ;

                       DIG 2 ;

                       PUSH int 1 ;

                       UPDATE 5 ;

                       { { DUP ; CAR ; DIP { CDR } } } ;

                       SWAP ;

                       { { DUP ; CAR ; DIP { CDR } } } ;

                       CAR ;

                       DIG 4 ;

                       SOME ;

                       SWAP ;

                       PAIR ;

                       PAIR ;

                       SWAP ;

                       PAIR ;

                       SWAP }

                     { SWAP ;

                       DUP ;

                       DUG 2 ;

                       GET 6 ;

                       SENDER ;

                       COMPARE ;

                       EQ ;

                       IF {} { PUSH int 28 ; FAILWITH } ;

                       PUSH int 1 ;

                       { DIP 2 { DUP } ; DIG 3 } ;

                       GET 5 ;

                       COMPARE ;

                       EQ ;

                       IF {} { PUSH int 12 ; FAILWITH } ;

                       NIL operation ;

                       { DIP 2 { DUP } ; DIG 3 } ;

                       GET 6 ;

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

                       IF_NONE { UNIT ; FAILWITH } {} ;

                       PUSH mutez 0 ;

                       DIG 3 ;

                       { DIP 4 { DUP } ; DIG 5 } ;

                       GET 3 ;

                       CDR ;

                       IF_NONE { UNIT ; FAILWITH } {} ;

                       SELF_ADDRESS ;

                       PAIR 3 ;

                       TRANSFER_TOKENS ;

                       CONS ;

                       SWAP ;

                       PUSH int 0 ;

                       UPDATE 5 ;

                       { { DUP ; CAR ; DIP { CDR } } } ;

                       SWAP ;

                       { { DUP ; CAR ; DIP { CDR } } } ;

                       CAR ;

                       NONE address ;

                       SWAP ;

                       PAIR ;

                       PAIR ;

                       SWAP ;

                       PAIR ;

                       SWAP } }

                 { IF_LEFT

                     { SWAP ;

                       DUP ;

                       DUG 2 ;

                       CAR ;

                       GET 3 ;

                       SENDER ;

                       COMPARE ;

                       EQ ;

                       IF {} { PUSH int 4 ; FAILWITH } ;

                       NIL operation ;

                       { DIP 2 { DUP } ; DIG 3 } ;

                       GET 6 ;

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

                       IF_NONE { UNIT ; FAILWITH } {} ;

                       PUSH mutez 0 ;

                       DIG 3 ;

                       { { DUP ; CAR ; DIP { CDR } } } ;

                       SWAP ;

                       SELF_ADDRESS ;

                       PAIR 3 ;

                       TRANSFER_TOKENS ;

                       CONS }

                     { SWAP ;

                       DUP ;

                       DUG 2 ;

                       CAR ;

                       GET 3 ;

                       SENDER ;

                       COMPARE ;

                       EQ ;

                       IF {} { PUSH int 4 ; FAILWITH } ;

                       SWAP ;

                       { { DUP ; CAR ; DIP { CDR } } } ;

                       CDR ;

                       DIG 2 ;

                       PAIR ;

                       PAIR ;

                       NIL operation } } }

             { IF_LEFT

                 { IF_LEFT

                     { SWAP ;

                       DUP ;

                       DUG 2 ;

                       CAR ;

                       CAR ;

                       SENDER ;

                       COMPARE ;

                       EQ ;

                       IF {} { PUSH int 8 ; FAILWITH } ;

                       SET_DELEGATE ;

                       NIL operation ;

                       SWAP ;

                       CONS }

                     { SWAP ;

                       DUP ;

                       DUG 2 ;

                       CAR ;

                       GET 3 ;

                       SENDER ;

                       COMPARE ;

                       EQ ;

                       IF {} { PUSH int 4 ; FAILWITH } ;

                       SWAP ;

                       { { DUP ; CAR ; DIP { CDR } } } ;

                       { { DUP ; CAR ; DIP { CDR } } } ;

                       SWAP ;

                       CDR ;

                       DIG 3 ;

                       PAIR ;

                       SWAP ;

                       PAIR ;

                       PAIR ;

                       NIL operation } }

                 { IF_LEFT

                     { SWAP ;

                       DUP ;

                       DUG 2 ;

                       CAR ;

                       GET 3 ;

                       SENDER ;

                       COMPARE ;

                       EQ ;

                       IF {} { PUSH int 4 ; FAILWITH } ;

                       SWAP ;

                       { { DUP ; CAR ; DIP { CDR } } } ;

                       { { DUP ; CAR ; DIP { CDR } } } ;

                       SWAP ;

                       CAR ;

                       DIG 3 ;

                       SWAP ;

                       PAIR ;

                       SWAP ;

                       PAIR ;

                       PAIR }

                     { SWAP ;

                       DUP ;

                       DUG 2 ;

                       CAR ;

                       GET 3 ;

                       SENDER ;

                       COMPARE ;

                       EQ ;

                       IF {} { PUSH int 4 ; FAILWITH } ;

                       SWAP ;

                       { { DUP ; CAR ; DIP { CDR } } } ;

                       SWAP ;

                       { { DUP ; CAR ; DIP { CDR } } } ;

                       CDR ;

                       DIG 3 ;

                       PAIR ;

                       PAIR ;

                       SWAP ;

                       PAIR } ;

                   NIL operation } } } ;

       NIL operation ;

       SWAP ;

       ITER { CONS } ;

       PAIR }