parameter (or

            (or

              (or

                (or

                  (pair %borrow address

                                (pair address

                                      (pair nat

                                            (pair nat

                                                  (pair bool (pair int (pair int nat)))))))

                  (nat %borrow_callback))

                (or (unit %default)

                    (pair %deposit address

                                   (pair address

                                         (pair nat (pair nat (pair bool (pair int int))))))))

              (or

                (or

                  (pair %liquidate address

                                   (pair address

                                         (pair nat

                                               (pair nat

                                                     (pair bool

                                                           (pair int (pair int address)))))))

                  (nat %liquidate_callback))

                (or (unit %pause)

                    (pair %repay address

                                 (pair address

                                       (pair nat

                                             (pair nat

                                                   (pair bool (pair int (pair int nat))))))))))

            (or

              (or (or (address %setGovernorContract) (address %setMinterContract))

                  (or (address %setOracleContract) (address %setOvenRegistryContract)))

              (or (or (address %setPauseGuardianContract) (unit %unpause))

                  (or (pair %updateState address (pair nat (pair int (pair int bool))))

                      (or

                        (pair %withdraw address

                                        (pair address

                                              (pair nat

                                                    (pair nat

                                                          (pair bool

                                                                (pair int

                                                                      (pair int mutez)))))))

                        (nat %withdraw_callback))))));

storage (pair

          (pair

            (pair

              (option %borrowParams (pair address

                                         (pair address

                                               (pair nat

                                                     (pair nat

                                                           (pair bool

                                                                 (pair int

                                                                       (pair int nat))))))))

              (address %governorContractAddress))

            (pair

              (option %liquidateParams (pair address

                                            (pair address

                                                  (pair nat

                                                        (pair nat

                                                              (pair bool

                                                                    (pair int

                                                                          (pair int

                                                                                address))))))))

              (pair (address %minterContractAddress) (address %oracleContractAddress))))

          (pair

            (pair (address %ovenRegistryContractAddress)

                  (address %pauseGuardianContractAddress))

            (pair (bool %paused)

                  (pair (int %state)

                        (option %withdrawParams (pair address

                                                     (pair address

                                                           (pair nat

                                                                 (pair nat

                                                                       (pair bool

                                                                             (pair int

                                                                                   (pair

                                                                                     int

                                                                                     mutez))))))))))));

code { DUP ;

       CDR ;

       SWAP ;

       CAR ;

       IF_LEFT

         { IF_LEFT

             { IF_LEFT

                 { IF_LEFT

                     { NIL operation ;

                       DIG 2 ;

                       DUP ;

                       DUG 3 ;

                       CDR ;

                       CAR ;

                       CAR ;

                       CONTRACT %isOven address ;

                       { IF_NONE { UNIT ; FAILWITH } {} } ;

                       PUSH mutez 0 ;

                       SENDER ;

                       TRANSFER_TOKENS ;

                       CONS ;

                       PUSH bool False ;

                       DIG 3 ;

                       DUP ;

                       DUG 4 ;

                       CDR ;

                       CDR ;

                       CAR ;

                       COMPARE ;

                       EQ ;

                       IF {} { PUSH int 18 ; FAILWITH } ;

                       PUSH int 0 ;

                       DIG 3 ;

                       DUP ;

                       DUG 4 ;

                       CDR ;

                       CDR ;

                       CDR ;

                       CAR ;

                       COMPARE ;

                       EQ ;

                       IF {} { PUSH int 12 ; FAILWITH } ;

                       DIG 2 ;

                       DUP ;

                       CAR ;

                       SWAP ;

                       CDR ;

                       DUP ;

                       CAR ;

                       SWAP ;

                       CDR ;

                       DUP ;

                       CAR ;

                       SWAP ;

                       CDR ;

                       CDR ;

                       PUSH int 1 ;

                       PAIR ;

                       SWAP ;

                       PAIR ;

                       SWAP ;

                       PAIR ;

                       SWAP ;

                       PAIR ;

                       DUP ;

                       CDR ;

                       SWAP ;

                       CAR ;

                       DUP ;

                       CDR ;

                       SWAP ;

                       CAR ;

                       CDR ;

                       DIG 4 ;

                       SOME ;

                       PAIR ;

                       PAIR ;

                       PAIR ;

                       DUP ;

                       DUG 2 ;

                       CAR ;

                       CDR ;

                       CDR ;

                       CDR ;

                       CONTRACT %getXtzUsdRate (contract nat) ;

                       { IF_NONE { UNIT ; FAILWITH } {} } ;

                       PUSH mutez 0 ;

                       SELF %borrow_callback ;

                       TRANSFER_TOKENS ;

                       CONS }

                     { SWAP ;

                       DUP ;

                       DUG 2 ;

                       CAR ;

                       CDR ;

                       CDR ;

                       CDR ;

                       SENDER ;

                       COMPARE ;

                       EQ ;

                       IF {} { PUSH int 3 ; FAILWITH } ;

                       PUSH int 1 ;

                       DIG 2 ;

                       DUP ;

                       DUG 3 ;

                       CDR ;

                       CDR ;

                       CDR ;

                       CAR ;

                       COMPARE ;

                       EQ ;

                       IF {} { PUSH int 12 ; FAILWITH } ;

                       NIL operation ;

                       DIG 2 ;

                       DUP ;

                       DUG 3 ;

                       CAR ;

                       CDR ;

                       CDR ;

                       CAR ;

                       CONTRACT %borrow (pair nat

                                              (pair address

                                                    (pair address

                                                          (pair nat

                                                                (pair nat

                                                                      (pair bool

                                                                            (pair int

                                                                                  (pair

                                                                                    int

                                                                                    nat)))))))) ;

                       { IF_NONE { UNIT ; FAILWITH } {} } ;

                       BALANCE ;

                       DIG 4 ;

                       DUP ;

                       DUG 5 ;

                       CAR ;

                       CAR ;

                       CAR ;

                       { IF_NONE { UNIT ; FAILWITH } {} } ;

                       DIG 4 ;

                       PAIR ;

                       TRANSFER_TOKENS ;

                       CONS ;

                       SWAP ;

                       DUP ;

                       CAR ;

                       SWAP ;

                       CDR ;

                       DUP ;

                       CAR ;

                       SWAP ;

                       CDR ;

                       DUP ;

                       CAR ;

                       SWAP ;

                       CDR ;

                       CDR ;

                       PUSH int 0 ;

                       PAIR ;

                       SWAP ;

                       PAIR ;

                       SWAP ;

                       PAIR ;

                       SWAP ;

                       PAIR ;

                       DUP ;

                       CDR ;

                       SWAP ;

                       CAR ;

                       DUP ;

                       CDR ;

                       SWAP ;

                       CAR ;

                       CDR ;

                       NONE (pair address

                                  (pair address

                                        (pair nat

                                              (pair nat

                                                    (pair bool (pair int (pair int nat))))))) ;

                       PAIR ;

                       PAIR ;

                       PAIR ;

                       SWAP } }

                 { IF_LEFT

                     { PUSH int 19 ; FAILWITH }

                     { NIL operation ;

                       DIG 2 ;

                       DUP ;

                       DUG 3 ;

                       CDR ;

                       CAR ;

                       CAR ;

                       CONTRACT %isOven address ;

                       { IF_NONE { UNIT ; FAILWITH } {} } ;

                       PUSH mutez 0 ;

                       SENDER ;

                       TRANSFER_TOKENS ;

                       CONS ;

                       PUSH bool False ;

                       DIG 3 ;

                       DUP ;

                       DUG 4 ;

                       CDR ;

                       CDR ;

                       CAR ;

                       COMPARE ;

                       EQ ;

                       IF {} { PUSH int 18 ; FAILWITH } ;

                       PUSH int 0 ;

                       DIG 3 ;

                       DUP ;

                       DUG 4 ;

                       CDR ;

                       CDR ;

                       CDR ;

                       CAR ;

                       COMPARE ;

                       EQ ;

                       IF {} { PUSH int 12 ; FAILWITH } ;

                       DIG 2 ;

                       DUP ;

                       DUG 3 ;

                       CAR ;

                       CDR ;

                       CDR ;

                       CAR ;

                       CONTRACT %deposit (pair address

                                               (pair address

                                                     (pair nat

                                                           (pair nat

                                                                 (pair bool

                                                                       (pair int int)))))) ;

                       { IF_NONE { UNIT ; FAILWITH } {} } ;

                       AMOUNT ;

                       DIG 3 ;

                       TRANSFER_TOKENS ;

                       CONS } } }

             { IF_LEFT

                 { IF_LEFT

                     { NIL operation ;

                       DIG 2 ;

                       DUP ;

                       DUG 3 ;

                       CDR ;

                       CAR ;

                       CAR ;

                       CONTRACT %isOven address ;

                       { IF_NONE { UNIT ; FAILWITH } {} } ;

                       PUSH mutez 0 ;

                       SENDER ;

                       TRANSFER_TOKENS ;

                       CONS ;

                       PUSH bool False ;

                       DIG 3 ;

                       DUP ;

                       DUG 4 ;

                       CDR ;

                       CDR ;

                       CAR ;

                       COMPARE ;

                       EQ ;

                       IF {} { PUSH int 18 ; FAILWITH } ;

                       PUSH int 0 ;

                       DIG 3 ;

                       DUP ;

                       DUG 4 ;

                       CDR ;

                       CDR ;

                       CDR ;

                       CAR ;

                       COMPARE ;

                       EQ ;

                       IF {} { PUSH int 12 ; FAILWITH } ;

                       DIG 2 ;

                       DUP ;

                       CAR ;

                       SWAP ;

                       CDR ;

                       DUP ;

                       CAR ;

                       SWAP ;

                       CDR ;

                       DUP ;

                       CAR ;

                       SWAP ;

                       CDR ;

                       CDR ;

                       PUSH int 3 ;

                       PAIR ;

                       SWAP ;

                       PAIR ;

                       SWAP ;

                       PAIR ;

                       SWAP ;

                       PAIR ;

                       DUP ;

                       CDR ;

                       SWAP ;

                       CAR ;

                       DUP ;

                       CAR ;

                       SWAP ;

                       CDR ;

                       CDR ;

                       DIG 4 ;

                       SOME ;

                       PAIR ;

                       SWAP ;

                       PAIR ;

                       PAIR ;

                       DUP ;

                       DUG 2 ;

                       CAR ;

                       CDR ;

                       CDR ;

                       CDR ;

                       CONTRACT %getXtzUsdRate (contract nat) ;

                       { IF_NONE { UNIT ; FAILWITH } {} } ;

                       PUSH mutez 0 ;

                       SELF %liquidate_callback ;

                       TRANSFER_TOKENS ;

                       CONS }

                     { SWAP ;

                       DUP ;

                       DUG 2 ;

                       CAR ;

                       CDR ;

                       CDR ;

                       CDR ;

                       SENDER ;

                       COMPARE ;

                       EQ ;

                       IF {} { PUSH int 3 ; FAILWITH } ;

                       PUSH int 3 ;

                       DIG 2 ;

                       DUP ;

                       DUG 3 ;

                       CDR ;

                       CDR ;

                       CDR ;

                       CAR ;

                       COMPARE ;

                       EQ ;

                       IF {} { PUSH int 12 ; FAILWITH } ;

                       NIL operation ;

                       DIG 2 ;

                       DUP ;

                       DUG 3 ;

                       CAR ;

                       CDR ;

                       CDR ;

                       CAR ;

                       CONTRACT %liquidate (pair nat

                                                 (pair address

                                                       (pair address

                                                             (pair nat

                                                                   (pair nat

                                                                         (pair bool

                                                                               (pair int

                                                                                     (pair

                                                                                       int

                                                                                       address)))))))) ;

                       { IF_NONE { UNIT ; FAILWITH } {} } ;

                       BALANCE ;

                       DIG 4 ;

                       DUP ;

                       DUG 5 ;

                       CAR ;

                       CDR ;

                       CAR ;

                       { IF_NONE { UNIT ; FAILWITH } {} } ;

                       DIG 4 ;

                       PAIR ;

                       TRANSFER_TOKENS ;

                       CONS ;

                       SWAP ;

                       DUP ;

                       CAR ;

                       SWAP ;

                       CDR ;

                       DUP ;

                       CAR ;

                       SWAP ;

                       CDR ;

                       DUP ;

                       CAR ;

                       SWAP ;

                       CDR ;

                       CDR ;

                       PUSH int 0 ;

                       PAIR ;

                       SWAP ;

                       PAIR ;

                       SWAP ;

                       PAIR ;

                       SWAP ;

                       PAIR ;

                       DUP ;

                       CDR ;

                       SWAP ;

                       CAR ;

                       DUP ;

                       CAR ;

                       SWAP ;

                       CDR ;

                       CDR ;

                       NONE (pair address

                                  (pair address

                                        (pair nat

                                              (pair nat

                                                    (pair bool

                                                          (pair int (pair int address))))))) ;

                       PAIR ;

                       SWAP ;

                       PAIR ;

                       PAIR ;

                       SWAP } }

                 { IF_LEFT

                     { DROP ;

                       DUP ;

                       CDR ;

                       CAR ;

                       CDR ;

                       SENDER ;

                       COMPARE ;

                       EQ ;

                       IF {} { PUSH int 9 ; FAILWITH } ;

                       DUP ;

                       CAR ;

                       SWAP ;

                       CDR ;

                       DUP ;

                       CAR ;

                       SWAP ;

                       CDR ;

                       CDR ;

                       PUSH bool True ;

                       PAIR ;

                       SWAP ;

                       PAIR ;

                       SWAP ;

                       PAIR ;

                       NIL operation }

                     { NIL operation ;

                       DIG 2 ;

                       DUP ;

                       DUG 3 ;

                       CDR ;

                       CAR ;

                       CAR ;

                       CONTRACT %isOven address ;

                       { IF_NONE { UNIT ; FAILWITH } {} } ;

                       PUSH mutez 0 ;

                       SENDER ;

                       TRANSFER_TOKENS ;

                       CONS ;

                       PUSH bool False ;

                       DIG 3 ;

                       DUP ;

                       DUG 4 ;

                       CDR ;

                       CDR ;

                       CAR ;

                       COMPARE ;

                       EQ ;

                       IF {} { PUSH int 18 ; FAILWITH } ;

                       PUSH int 0 ;

                       DIG 3 ;

                       DUP ;

                       DUG 4 ;

                       CDR ;

                       CDR ;

                       CDR ;

                       CAR ;

                       COMPARE ;

                       EQ ;

                       IF {} { PUSH int 12 ; FAILWITH } ;

                       DIG 2 ;

                       DUP ;

                       DUG 3 ;

                       CAR ;

                       CDR ;

                       CDR ;

                       CAR ;

                       CONTRACT %repay (pair address

                                             (pair address

                                                   (pair nat

                                                         (pair nat

                                                               (pair bool

                                                                     (pair int

                                                                           (pair int nat))))))) ;

                       { IF_NONE { UNIT ; FAILWITH } {} } ;

                       AMOUNT ;

                       DIG 3 ;

                       TRANSFER_TOKENS ;

                       CONS } } } }

         { IF_LEFT

             { IF_LEFT

                 { IF_LEFT

                     { SWAP ;

                       DUP ;

                       DUG 2 ;

                       CAR ;

                       CAR ;

                       CDR ;

                       SENDER ;

                       COMPARE ;

                       EQ ;

                       IF {} { PUSH int 4 ; FAILWITH } ;

                       SWAP ;

                       DUP ;

                       CDR ;

                       SWAP ;

                       CAR ;

                       DUP ;

                       CDR ;

                       SWAP ;

                       CAR ;

                       CAR ;

                       DIG 3 ;

                       SWAP ;

                       PAIR ;

                       PAIR ;

                       PAIR }

                     { SWAP ;

                       DUP ;

                       DUG 2 ;

                       CAR ;

                       CAR ;

                       CDR ;

                       SENDER ;

                       COMPARE ;

                       EQ ;

                       IF {} { PUSH int 4 ; FAILWITH } ;

                       SWAP ;

                       DUP ;

                       CDR ;

                       SWAP ;

                       CAR ;

                       DUP ;

                       CAR ;

                       SWAP ;

                       CDR ;

                       DUP ;

                       CAR ;

                       SWAP ;

                       CDR ;

                       CDR ;

                       DIG 4 ;

                       PAIR ;

                       SWAP ;

                       PAIR ;

                       SWAP ;

                       PAIR ;

                       PAIR } }

                 { IF_LEFT

                     { SWAP ;

                       DUP ;

                       DUG 2 ;

                       CAR ;

                       CAR ;

                       CDR ;

                       SENDER ;

                       COMPARE ;

                       EQ ;

                       IF {} { PUSH int 4 ; FAILWITH } ;

                       SWAP ;

                       DUP ;

                       CDR ;

                       SWAP ;

                       CAR ;

                       DUP ;

                       CAR ;

                       SWAP ;

                       CDR ;

                       DUP ;

                       CAR ;

                       SWAP ;

                       CDR ;

                       CAR ;

                       DIG 4 ;

                       SWAP ;

                       PAIR ;

                       SWAP ;

                       PAIR ;

                       SWAP ;

                       PAIR ;

                       PAIR }

                     { SWAP ;

                       DUP ;

                       DUG 2 ;

                       CAR ;

                       CAR ;

                       CDR ;

                       SENDER ;

                       COMPARE ;

                       EQ ;

                       IF {} { PUSH int 4 ; FAILWITH } ;

                       SWAP ;

                       DUP ;

                       CAR ;

                       SWAP ;

                       CDR ;

                       DUP ;

                       CDR ;

                       SWAP ;

                       CAR ;

                       CDR ;

                       DIG 3 ;

                       PAIR ;

                       PAIR ;

                       SWAP ;

                       PAIR } } ;

               NIL operation }

             { IF_LEFT

                 { IF_LEFT

                     { SWAP ;

                       DUP ;

                       DUG 2 ;

                       CAR ;

                       CAR ;

                       CDR ;

                       SENDER ;

                       COMPARE ;

                       EQ ;

                       IF {} { PUSH int 4 ; FAILWITH } ;

                       SWAP ;

                       DUP ;

                       CAR ;

                       SWAP ;

                       CDR ;

                       DUP ;

                       CDR ;

                       SWAP ;

                       CAR ;

                       CAR ;

                       DIG 3 ;

                       SWAP ;

                       PAIR ;

                       PAIR ;

                       SWAP ;

                       PAIR }

                     { DROP ;

                       DUP ;

                       CAR ;

                       CAR ;

                       CDR ;

                       SENDER ;

                       COMPARE ;

                       EQ ;

                       IF {} { PUSH int 4 ; FAILWITH } ;

                       DUP ;

                       CAR ;

                       SWAP ;

                       CDR ;

                       DUP ;

                       CAR ;

                       SWAP ;

                       CDR ;

                       CDR ;

                       PUSH bool False ;

                       PAIR ;

                       SWAP ;

                       PAIR ;

                       SWAP ;

                       PAIR } ;

                   NIL operation }

                 { IF_LEFT

                     { SWAP ;

                       DUP ;

                       DUG 2 ;

                       CAR ;

                       CDR ;

                       CDR ;

                       CAR ;

                       SENDER ;

                       COMPARE ;

                       EQ ;

                       IF {} { PUSH int 5 ; FAILWITH } ;

                       DUP ;

                       CAR ;

                       CONTRACT %updateState (pair address

                                                   (pair nat (pair int (pair int bool)))) ;

                       { IF_NONE { UNIT ; FAILWITH } {} } ;

                       NIL operation ;

                       SWAP ;

                       AMOUNT ;

                       DIG 3 ;

                       TRANSFER_TOKENS ;

                       CONS }

                     { IF_LEFT

                         { NIL operation ;

                           DIG 2 ;

                           DUP ;

                           DUG 3 ;

                           CDR ;

                           CAR ;

                           CAR ;

                           CONTRACT %isOven address ;

                           { IF_NONE { UNIT ; FAILWITH } {} } ;

                           PUSH mutez 0 ;

                           SENDER ;

                           TRANSFER_TOKENS ;

                           CONS ;

                           PUSH int 0 ;

                           DIG 3 ;

                           DUP ;

                           DUG 4 ;

                           CDR ;

                           CDR ;

                           CDR ;

                           CAR ;

                           COMPARE ;

                           EQ ;

                           IF {} { PUSH int 12 ; FAILWITH } ;

                           PUSH bool False ;

                           DIG 3 ;

                           DUP ;

                           DUG 4 ;

                           CDR ;

                           CDR ;

                           CAR ;

                           COMPARE ;

                           EQ ;

                           IF {} { PUSH int 18 ; FAILWITH } ;

                           DIG 2 ;

                           DUP ;

                           CAR ;

                           SWAP ;

                           CDR ;

                           DUP ;

                           CAR ;

                           SWAP ;

                           CDR ;

                           DUP ;

                           CAR ;

                           SWAP ;

                           CDR ;

                           CDR ;

                           PUSH int 2 ;

                           PAIR ;

                           SWAP ;

                           PAIR ;

                           SWAP ;

                           PAIR ;

                           SWAP ;

                           PAIR ;

                           DUP ;

                           CAR ;

                           SWAP ;

                           CDR ;

                           DUP ;

                           CAR ;

                           SWAP ;

                           CDR ;

                           DUP ;

                           CAR ;

                           SWAP ;

                           CDR ;

                           CAR ;

                           DIG 5 ;

                           SOME ;

                           SWAP ;

                           PAIR ;

                           SWAP ;

                           PAIR ;

                           SWAP ;

                           PAIR ;

                           SWAP ;

                           PAIR ;

                           DUP ;

                           DUG 2 ;

                           CAR ;

                           CDR ;

                           CDR ;

                           CDR ;

                           CONTRACT %getXtzUsdRate (contract nat) ;

                           { IF_NONE { UNIT ; FAILWITH } {} } ;

                           PUSH mutez 0 ;

                           SELF %withdraw_callback ;

                           TRANSFER_TOKENS ;

                           CONS }

                         { SWAP ;

                           DUP ;

                           DUG 2 ;

                           CAR ;

                           CDR ;

                           CDR ;

                           CDR ;

                           SENDER ;

                           COMPARE ;

                           EQ ;

                           IF {} { PUSH int 3 ; FAILWITH } ;

                           PUSH int 2 ;

                           DIG 2 ;