parameter (or

            (or (or (unit %default) (unit %makeOven))

                (or (nat %makeOven_minterCallback) (address %setGovernorContract)))

            (or (or (option %setInitialDelegate key_hash) (address %setMinterContract))

                (or (address %setOvenProxyContract) (address %setOvenRegistryContract))));

storage (pair

          (pair (address %governorContractAddress)

                (pair (option %initialDelegate key_hash) (option %makeOvenOwner address)))

          (pair

            (pair (address %minterContractAddress) (address %ovenProxyContractAddress))

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

code { DUP ;

       CDR ;

       SWAP ;

       CAR ;

       IF_LEFT

         { IF_LEFT

             { IF_LEFT

                 { PUSH int 19 ; FAILWITH }

                 { DROP ;

                   DUP ;

                   CDR ;

                   CDR ;

                   CDR ;

                   PUSH int 0 ;

                   COMPARE ;

                   EQ ;

                   IF {} { PUSH int 12 ; FAILWITH } ;

                   PUSH mutez 0 ;

                   AMOUNT ;

                   COMPARE ;

                   EQ ;

                   IF {} { PUSH int 15 ; FAILWITH } ;

                   DUP ;

                   CAR ;

                   SWAP ;

                   CDR ;

                   DUP ;

                   CAR ;

                   SWAP ;

                   CDR ;

                   CAR ;

                   PUSH int 1 ;

                   SWAP ;

                   PAIR ;

                   SWAP ;

                   PAIR ;

                   SWAP ;

                   PAIR ;

                   DUP ;

                   CDR ;

                   SWAP ;

                   CAR ;

                   DUP ;

                   CAR ;

                   SWAP ;

                   CDR ;

                   CAR ;

                   SENDER ;

                   SOME ;

                   SWAP ;

                   PAIR ;

                   SWAP ;

                   PAIR ;

                   PAIR ;

                   DUP ;

                   CDR ;

                   CAR ;

                   CAR ;

                   CONTRACT %getInterestIndex (contract nat) ;

                   { IF_NONE { UNIT ; FAILWITH } {} } ;

                   NIL operation ;

                   SWAP ;

                   PUSH mutez 0 ;

                   SELF %makeOven_minterCallback ;

                   TRANSFER_TOKENS ;

                   CONS } }

             { IF_LEFT

                 { SWAP ;

                   DUP ;

                   DUG 2 ;

                   CDR ;

                   CAR ;

                   CAR ;

                   SENDER ;

                   COMPARE ;

                   EQ ;

                   IF {} { PUSH int 5 ; FAILWITH } ;

                   PUSH int 1 ;

                   DIG 2 ;

                   DUP ;

                   DUG 3 ;

                   CDR ;

                   CDR ;

                   CDR ;

                   COMPARE ;

                   EQ ;

                   IF {} { PUSH int 12 ; FAILWITH } ;

                   PUSH int 0 ;

                   DIG 2 ;

                   DUP ;

                   DUG 3 ;

                   CAR ;

                   CDR ;

                   CDR ;

                   { IF_NONE { UNIT ; FAILWITH } {} } ;

                   PAIR %owner %stabilityFeeTokens ;

                   DIG 2 ;

                   DUP ;

                   DUG 3 ;

                   CDR ;

                   CAR ;

                   CDR ;

                   PAIR %ovenProxyContractAddress ;

                   PUSH bool False ;

                   DIG 2 ;

                   INT ;

                   PAIR %interestIndex %isLiquidated ;

                   PUSH nat 0 ;

                   PAIR %borrowedTokens ;

                   PAIR ;

                   PUSH mutez 0 ;

                   DIG 2 ;

                   DUP ;

                   DUG 3 ;

                   CAR ;

                   CDR ;

                   CAR ;

                   CREATE_CONTRACT { parameter (or

                                                 (or (nat %borrow)

                                                     (or (unit %default)

                                                         (unit %liquidate)))

                                                 (or

                                                   (or (nat %repay)

                                                       (option %setDelegate key_hash))

                                                   (or

                                                     (pair %updateState address

                                                                        (pair nat

                                                                              (pair int

                                                                                    (pair

                                                                                      int

                                                                                      bool))))

                                                     (mutez %withdraw)))) ;

                                     storage (pair

                                               (pair (nat %borrowedTokens)

                                                     (pair (int %interestIndex)

                                                           (bool %isLiquidated)))

                                               (pair (address %ovenProxyContractAddress)

                                                     (pair (address %owner)

                                                           (int %stabilityFeeTokens)))) ;

                                     code { DUP ;

                                            CDR ;

                                            SWAP ;

                                            CAR ;

                                            IF_LEFT

                                              { IF_LEFT

                                                  { SWAP ;

                                                    DUP ;

                                                    DUG 2 ;

                                                    CDR ;

                                                    CDR ;

                                                    CAR ;

                                                    SENDER ;

                                                    COMPARE ;

                                                    EQ ;

                                                    IF {} { PUSH int 6 ; FAILWITH } ;

                                                    PUSH mutez 0 ;

                                                    AMOUNT ;

                                                    COMPARE ;

                                                    EQ ;

                                                    IF {} { PUSH int 15 ; FAILWITH } ;

                                                    NIL operation ;

                                                    DIG 2 ;

                                                    DUP ;

                                                    DUG 3 ;

                                                    CDR ;

                                                    CAR ;

                                                    CONTRACT %borrow (pair address

                                                                           (pair address

                                                                                 (pair

                                                                                   nat

                                                                                   (pair

                                                                                     nat

                                                                                     (pair

                                                                                       bool

                                                                                       (pair

                                                                                         int

                                                                                         (pair

                                                                                           int

                                                                                           nat))))))) ;

                                                    { IF_NONE { UNIT ; FAILWITH } {} } ;

                                                    BALANCE ;

                                                    DIG 3 ;

                                                    DIG 4 ;

                                                    DUP ;

                                                    DUG 5 ;

                                                    CAR ;

                                                    CDR ;

                                                    CAR ;

                                                    PAIR ;

                                                    DIG 4 ;

                                                    DUP ;

                                                    DUG 5 ;

                                                    CDR ;

                                                    CDR ;

                                                    CDR ;

                                                    PAIR ;

                                                    DIG 4 ;

                                                    DUP ;

                                                    DUG 5 ;

                                                    CAR ;

                                                    CDR ;

                                                    CDR ;

                                                    PAIR ;

                                                    DIG 4 ;

                                                    DUP ;

                                                    DUG 5 ;

                                                    CAR ;

                                                    CAR ;

                                                    PAIR ;

                                                    PUSH nat 1000000000000 ;

                                                    PUSH mutez 1 ;

                                                    BALANCE ;

                                                    EDIV ;

                                                    { IF_NONE { UNIT ; FAILWITH } {} } ;

                                                    CAR ;

                                                    MUL ;

                                                    PAIR ;

                                                    DIG 4 ;

                                                    DUP ;

                                                    DUG 5 ;

                                                    CDR ;

                                                    CDR ;

                                                    CAR ;

                                                    PAIR ;

                                                    SELF ;

                                                    ADDRESS ;

                                                    PAIR ;

                                                    TRANSFER_TOKENS ;

                                                    CONS }

                                                  { IF_LEFT

                                                      { DROP ;

                                                        DUP ;

                                                        CDR ;

                                                        CAR ;

                                                        CONTRACT %deposit (pair address

                                                                                (pair

                                                                                  address

                                                                                  (pair

                                                                                    nat

                                                                                    (pair

                                                                                      nat

                                                                                      (pair

                                                                                        bool

                                                                                        (pair

                                                                                          int

                                                                                          int)))))) ;

                                                        { IF_NONE

                                                            { UNIT ; FAILWITH }

                                                            {} } ;

                                                        NIL operation ;

                                                        SWAP ;

                                                        BALANCE ;

                                                        DIG 3 ;

                                                        DUP ;

                                                        CAR ;

                                                        CDR ;

                                                        CAR ;

                                                        SWAP ;

                                                        DUP ;

                                                        DUG 5 ;

                                                        CDR ;

                                                        CDR ;

                                                        CDR ;

                                                        PAIR ;

                                                        DIG 4 ;

                                                        DUP ;

                                                        DUG 5 ;

                                                        CAR ;

                                                        CDR ;

                                                        CDR ;

                                                        PAIR ;

                                                        DIG 4 ;

                                                        DUP ;

                                                        DUG 5 ;

                                                        CAR ;

                                                        CAR ;

                                                        PAIR ;

                                                        PUSH nat 1000000000000 ;

                                                        PUSH mutez 1 ;

                                                        BALANCE ;

                                                        EDIV ;

                                                        { IF_NONE

                                                            { UNIT ; FAILWITH }

                                                            {} } ;

                                                        CAR ;

                                                        MUL ;

                                                        PAIR ;

                                                        DIG 4 ;

                                                        DUP ;

                                                        DUG 5 ;

                                                        CDR ;

                                                        CDR ;

                                                        CAR ;

                                                        PAIR ;

                                                        SELF ;

                                                        ADDRESS ;

                                                        PAIR ;

                                                        TRANSFER_TOKENS ;

                                                        CONS }

                                                      { DROP ;

                                                        PUSH mutez 0 ;

                                                        AMOUNT ;

                                                        COMPARE ;

                                                        EQ ;

                                                        IF

                                                          {}

                                                          { PUSH int 15 ; FAILWITH } ;

                                                        DUP ;

                                                        CDR ;

                                                        CAR ;

                                                        CONTRACT %liquidate (pair

                                                                              address

                                                                              (pair

                                                                                address

                                                                                (pair

                                                                                  nat

                                                                                  (pair

                                                                                    nat

                                                                                    (pair

                                                                                      bool

                                                                                      (pair

                                                                                        int

                                                                                        (pair

                                                                                          int

                                                                                          address))))))) ;

                                                        { IF_NONE

                                                            { UNIT ; FAILWITH }

                                                            {} } ;

                                                        NIL operation ;

                                                        SWAP ;

                                                        BALANCE ;

                                                        SENDER ;

                                                        DIG 4 ;

                                                        DUP ;

                                                        DUG 5 ;

                                                        CAR ;

                                                        CDR ;

                                                        CAR ;

                                                        PAIR ;

                                                        DIG 4 ;

                                                        DUP ;

                                                        DUG 5 ;

                                                        CDR ;

                                                        CDR ;

                                                        CDR ;

                                                        PAIR ;

                                                        DIG 4 ;

                                                        DUP ;

                                                        DUG 5 ;

                                                        CAR ;

                                                        CDR ;

                                                        CDR ;

                                                        PAIR ;

                                                        DIG 4 ;

                                                        DUP ;

                                                        DUG 5 ;

                                                        CAR ;

                                                        CAR ;

                                                        PAIR ;

                                                        PUSH nat 1000000000000 ;

                                                        PUSH mutez 1 ;

                                                        BALANCE ;

                                                        EDIV ;

                                                        { IF_NONE

                                                            { UNIT ; FAILWITH }

                                                            {} } ;

                                                        CAR ;

                                                        MUL ;

                                                        PAIR ;

                                                        DIG 4 ;

                                                        DUP ;

                                                        DUG 5 ;

                                                        CDR ;

                                                        CDR ;

                                                        CAR ;

                                                        PAIR ;

                                                        SELF ;

                                                        ADDRESS ;

                                                        PAIR ;

                                                        TRANSFER_TOKENS ;

                                                        CONS } } }

                                              { IF_LEFT

                                                  { IF_LEFT

                                                      { SWAP ;

                                                        DUP ;

                                                        DUG 2 ;

                                                        CDR ;

                                                        CDR ;

                                                        CAR ;

                                                        SENDER ;

                                                        COMPARE ;

                                                        EQ ;

                                                        IF

                                                          {}

                                                          { PUSH int 6 ; FAILWITH } ;

                                                        PUSH mutez 0 ;

                                                        AMOUNT ;

                                                        COMPARE ;

                                                        EQ ;

                                                        IF

                                                          {}

                                                          { PUSH int 15 ; FAILWITH } ;

                                                        NIL operation ;

                                                        DIG 2 ;

                                                        DUP ;

                                                        DUG 3 ;

                                                        CDR ;

                                                        CAR ;

                                                        CONTRACT %repay (pair address

                                                                              (pair

                                                                                address

                                                                                (pair

                                                                                  nat

                                                                                  (pair

                                                                                    nat

                                                                                    (pair

                                                                                      bool

                                                                                      (pair

                                                                                        int

                                                                                        (pair

                                                                                          int

                                                                                          nat))))))) ;

                                                        { IF_NONE

                                                            { UNIT ; FAILWITH }

                                                            {} } ;

                                                        BALANCE ;

                                                        DIG 3 ;

                                                        DIG 4 ;

                                                        DUP ;

                                                        DUG 5 ;

                                                        CAR ;

                                                        CDR ;

                                                        CAR ;

                                                        PAIR ;

                                                        DIG 4 ;

                                                        DUP ;

                                                        DUG 5 ;

                                                        CDR ;

                                                        CDR ;

                                                        CDR ;

                                                        PAIR ;

                                                        DIG 4 ;

                                                        DUP ;

                                                        DUG 5 ;

                                                        CAR ;

                                                        CDR ;

                                                        CDR ;

                                                        PAIR ;

                                                        DIG 4 ;

                                                        DUP ;

                                                        DUG 5 ;

                                                        CAR ;

                                                        CAR ;

                                                        PAIR ;

                                                        PUSH nat 1000000000000 ;

                                                        PUSH mutez 1 ;

                                                        BALANCE ;

                                                        EDIV ;

                                                        { IF_NONE

                                                            { UNIT ; FAILWITH }

                                                            {} } ;

                                                        CAR ;

                                                        MUL ;

                                                        PAIR ;

                                                        DIG 4 ;

                                                        DUP ;

                                                        DUG 5 ;

                                                        CDR ;

                                                        CDR ;

                                                        CAR ;

                                                        PAIR ;

                                                        SELF ;

                                                        ADDRESS ;

                                                        PAIR ;

                                                        TRANSFER_TOKENS ;

                                                        CONS }

                                                      { SWAP ;

                                                        DUP ;

                                                        DUG 2 ;

                                                        CDR ;

                                                        CDR ;

                                                        CAR ;

                                                        SENDER ;

                                                        COMPARE ;

                                                        EQ ;

                                                        IF

                                                          {}

                                                          { PUSH int 6 ; FAILWITH } ;

                                                        PUSH mutez 0 ;

                                                        AMOUNT ;

                                                        COMPARE ;

                                                        EQ ;

                                                        IF

                                                          {}

                                                          { PUSH int 15 ; FAILWITH } ;

                                                        SET_DELEGATE ;

                                                        NIL operation ;

                                                        SWAP ;

                                                        CONS } }

                                                  { IF_LEFT

                                                      { SWAP ;

                                                        DUP ;

                                                        DUG 2 ;

                                                        CDR ;

                                                        CAR ;

                                                        SENDER ;

                                                        COMPARE ;

                                                        EQ ;

                                                        IF

                                                          {}

                                                          { PUSH int 2 ; FAILWITH } ;

                                                        SELF ;

                                                        ADDRESS ;

                                                        SWAP ;

                                                        DUP ;

                                                        DUG 2 ;

                                                        CAR ;

                                                        COMPARE ;

                                                        EQ ;

                                                        IF

                                                          {}

                                                          { PUSH int 13 ; FAILWITH } ;

                                                        SWAP ;

                                                        DUP ;

                                                        CDR ;

                                                        SWAP ;

                                                        CAR ;

                                                        CDR ;

                                                        DIG 2 ;

                                                        DUP ;

                                                        DUG 3 ;

                                                        CDR ;

                                                        CAR ;

                                                        PAIR ;

                                                        PAIR ;

                                                        DUP ;

                                                        CAR ;

                                                        SWAP ;

                                                        CDR ;

                                                        DUP ;

                                                        CAR ;

                                                        SWAP ;

                                                        CDR ;

                                                        CAR ;

                                                        DIG 3 ;

                                                        DUP ;

                                                        DUG 4 ;

                                                        CDR ;

                                                        CDR ;

                                                        CAR ;

                                                        SWAP ;

                                                        PAIR ;

                                                        SWAP ;

                                                        PAIR ;

                                                        SWAP ;

                                                        PAIR ;

                                                        DUP ;

                                                        CDR ;

                                                        SWAP ;

                                                        CAR ;

                                                        DUP ;

                                                        CAR ;

                                                        SWAP ;

                                                        CDR ;

                                                        CDR ;

                                                        DIG 3 ;

                                                        DUP ;

                                                        DUG 4 ;

                                                        CDR ;

                                                        CDR ;

                                                        CDR ;

                                                        CAR ;

                                                        PAIR ;

                                                        SWAP ;

                                                        PAIR ;

                                                        PAIR ;

                                                        DUP ;

                                                        CDR ;

                                                        SWAP ;

                                                        CAR ;

                                                        DUP ;

                                                        CAR ;

                                                        SWAP ;

                                                        CDR ;

                                                        CAR ;

                                                        DIG 3 ;

                                                        CDR ;

                                                        CDR ;

                                                        CDR ;

                                                        CDR ;

                                                        SWAP ;

                                                        PAIR ;

                                                        SWAP ;

                                                        PAIR ;

                                                        PAIR ;

                                                        NIL operation }

                                                      { SWAP ;

                                                        DUP ;

                                                        DUG 2 ;

                                                        CDR ;

                                                        CDR ;

                                                        CAR ;

                                                        SENDER ;

                                                        COMPARE ;

                                                        EQ ;

                                                        IF

                                                          {}

                                                          { PUSH int 6 ; FAILWITH } ;

                                                        PUSH mutez 0 ;

                                                        AMOUNT ;

                                                        COMPARE ;

                                                        EQ ;

                                                        IF

                                                          {}

                                                          { PUSH int 15 ; FAILWITH } ;

                                                        NIL operation ;

                                                        DIG 2 ;

                                                        DUP ;

                                                        DUG 3 ;

                                                        CDR ;

                                                        CAR ;

                                                        CONTRACT %withdraw (pair address

                                                                                 (pair

                                                                                   address

                                                                                   (pair

                                                                                     nat

                                                                                     (pair

                                                                                       nat

                                                                                       (pair

                                                                                         bool

                                                                                         (pair

                                                                                           int

                                                                                           (pair

                                                                                             int

                                                                                             mutez))))))) ;

                                                        { IF_NONE

                                                            { UNIT ; FAILWITH }

                                                            {} } ;

                                                        BALANCE ;

                                                        DIG 3 ;

                                                        DIG 4 ;

                                                        DUP ;

                                                        DUG 5 ;

                                                        CAR ;

                                                        CDR ;

                                                        CAR ;

                                                        PAIR ;

                                                        DIG 4 ;

                                                        DUP ;

                                                        DUG 5 ;

                                                        CDR ;

                                                        CDR ;

                                                        CDR ;

                                                        PAIR ;

                                                        DIG 4 ;

                                                        DUP ;

                                                        DUG 5 ;

                                                        CAR ;

                                                        CDR ;

                                                        CDR ;

                                                        PAIR ;

                                                        DIG 4 ;

                                                        DUP ;

                                                        DUG 5 ;

                                                        CAR ;

                                                        CAR ;

                                                        PAIR ;

                                                        PUSH nat 1000000000000 ;

                                                        PUSH mutez 1 ;

                                                        BALANCE ;

                                                        EDIV ;

                                                        { IF_NONE

                                                            { UNIT ; FAILWITH }

                                                            {} } ;

                                                        CAR ;

                                                        MUL ;

                                                        PAIR ;

                                                        DIG 4 ;

                                                        DUP ;

                                                        DUG 5 ;

                                                        CDR ;

                                                        CDR ;

                                                        CAR ;

                                                        PAIR ;

                                                        SELF ;

                                                        ADDRESS ;

                                                        PAIR ;

                                                        TRANSFER_TOKENS ;

                                                        CONS } } } ;

                                            PAIR } } ;

                   PAIR ;

                   DUP ;

                   CAR ;

                   NIL operation ;

                   SWAP ;

                   CONS ;

                   DIG 2 ;

                   DUP ;

                   DUG 3 ;

                   CDR ;

                   CDR ;

                   CAR ;

                   CONTRACT %addOven (pair address address) ;

                   { IF_NONE { UNIT ; FAILWITH } {} } ;

                   PUSH mutez 0 ;

                   DIG 4 ;

                   DUP ;

                   DUG 5 ;

                   CAR ;

                   CDR ;

                   CDR ;

                   { IF_NONE { UNIT ; FAILWITH } {} } ;

                   DIG 4 ;

                   CDR ;

                   PAIR ;

                   TRANSFER_TOKENS ;

                   CONS ;

                   SWAP ;

                   DUP ;

                   CAR ;

                   SWAP ;

                   CDR ;

                   DUP ;

                   CAR ;

                   SWAP ;

                   CDR ;

                   CAR ;

                   PUSH int 0 ;

                   SWAP ;

                   PAIR ;

                   SWAP ;

                   PAIR ;

                   SWAP ;

                   PAIR ;

                   DUP ;

                   CDR ;

                   SWAP ;

                   CAR ;

                   DUP ;

                   CAR ;

                   SWAP ;

                   CDR ;

                   CAR ;

                   NONE address ;

                   SWAP ;

                   PAIR ;

                   SWAP ;

                   PAIR ;

                   PAIR ;

                   SWAP }

                 { SWAP ;

                   DUP ;

                   DUG 2 ;

                   CAR ;

                   CAR ;

                   SENDER ;

                   COMPARE ;

                   EQ ;

                   IF {} { PUSH int 4 ; FAILWITH } ;

                   SWAP ;

                   DUP ;

                   CDR ;

                   SWAP ;

                   CAR ;

                   CDR ;

                   DIG 2 ;

                   PAIR ;

                   PAIR ;

                   NIL operation } } }

         { IF_LEFT

             { IF_LEFT

                 { SWAP ;

                   DUP ;

                   DUG 2 ;

                   CAR ;

                   CAR ;

                   SENDER ;

                   COMPARE ;

                   EQ ;

                   IF {} { PUSH int 4 ; FAILWITH } ;

                   SWAP ;

                   DUP ;

                   CDR ;

                   SWAP ;

                   CAR ;

                   DUP ;

                   CAR ;

                   SWAP ;

                   CDR ;

                   CDR ;

                   DIG 3 ;

                   PAIR ;

                   SWAP ;

                   PAIR ;

                   PAIR }

                 { SWAP ;

                   DUP ;

                   DUG 2 ;

                   CAR ;

                   CAR ;

                   SENDER ;

                   COMPARE ;

                   EQ ;

                   IF {} { PUSH int 4 ; FAILWITH } ;

                   SWAP ;

                   DUP ;

                   CAR ;

                   SWAP ;

                   CDR ;

                   DUP ;

                   CDR ;

                   SWAP ;

                   CAR ;

                   CDR ;

                   DIG 3 ;

                   PAIR ;

                   PAIR ;

                   SWAP ;

                   PAIR } }

             { IF_LEFT

                 { SWAP ;

                   DUP ;

                   DUG 2 ;

                   CAR ;

                   CAR ;

                   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 }

                 { SWAP ;

                   DUP ;

                   DUG 2 ;

                   CAR ;

                   CAR ;

                   SENDER ;

                   COMPARE ;

                   EQ ;

                   IF {} { PUSH int 4 ; FAILWITH } ;

                   SWAP ;

                   DUP ;

                   CAR ;

                   SWAP ;

                   CDR ;

                   DUP ;

                   CAR ;

                   SWAP ;

                   CDR ;

                   CDR ;

                   DIG 3 ;

                   PAIR ;

                   SWAP ;

                   PAIR ;

                   SWAP ;

                   PAIR } } ;

           NIL operation } ;

       NIL operation ;

       SWAP ;

       ITER { CONS } ;

       PAIR }