parameter (or

            (or

              (or

                (or (nat %bailout)

                    (or (nat %burn)

                        (pair %create_vault (option %baker key_hash)

                                            (contract %contract_address_callback address))))

                (or (lambda %execute unit (list operation))

                    (or (unit %interest_rate_update) (nat %internal_bailout))))

              (or

                (or (nat %internal_burn)

                    (or (unit %internal_interest_rate_update)

                        (pair %internal_liquidate (address %vault_owner)

                                                  (nat %token_amount))))

                (or (nat %internal_mint)

                    (or

                      (pair %internal_settle_with_vault (address %vault_owner)

                                                        (pair (nat %token_amount)

                                                              (address %recipient)))

                      (mutez %internal_withdraw)))))

            (or

              (or

                (or (pair %liquidate (address %vault_owner) (nat %token_amount))

                    (or (nat %mint)

                        (pair %remove_administrator (address %administrator_to_remove)

                                                    (nat %token_id))))

                (or

                  (pair %set_administrator (address %administrator_to_set)

                                           (nat %token_id))

                  (or

                    (pair %set_contracts

                      (pair (address %governance_token_contract)

                            (pair (address %observed_price_oracle)

                                  (address %options_contract)))

                      (pair (address %reward_pool_contract)

                            (pair (address %savings_pool_contract)

                                  (address %target_price_oracle))))

                    (nat %set_observed_price))))

              (or

                (or (nat %set_target_price)

                    (or (mutez %set_vault_balance) (option %set_vault_delegate key_hash)))

                (or

                  (pair %settle_with_vault (address %vault_owner)

                                           (pair (nat %token_amount)

                                                 (address %recipient)))

                  (or (unit %update) (mutez %withdraw))))));

storage (pair

          (pair

            (pair

              (pair (timestamp %accrual_update_timestamp)

                    (big_map %administrators (pair (address %owner) (nat %token_id))

                                             unit))

              (pair (nat %compound_interest_rate) (address %governance_token_contract)))

            (pair (pair (timestamp %last_update_timestamp) (nat %observed_price))

                  (pair (address %observed_price_oracle)

                        (pair (address %options_contract) (nat %reference_interest_rate)))))

          (pair

            (pair

              (pair (address %reward_pool_contract) (address %savings_pool_contract))

              (pair (address %sender)

                    (pair (nat %target_price) (address %target_price_oracle))))

            (pair (pair (address %token_contract) (nat %token_id))

                  (pair (nat %total_supply)

                        (pair

                          (big_map %vault_contexts address

                                                   (pair

                                                     (pair (address %address)

                                                           (mutez %balance))

                                                     (pair (bool %is_being_liquidated)

                                                           (nat %minted))))

                          (big_map %vault_lookup address address))))));

code { CAST (pair

              (or

                (or

                  (or (or nat (or nat (pair (option key_hash) (contract address))))

                      (or (lambda unit (list operation)) (or unit nat)))

                  (or (or nat (or unit (pair address nat)))

                      (or nat (or (pair address (pair nat address)) mutez))))

                (or

                  (or (or (pair address nat) (or nat (pair address nat)))

                      (or (pair address nat)

                          (or

                            (pair (pair address (pair address address))

                                  (pair address (pair address address)))

                            nat)))

                  (or (or nat (or mutez (option key_hash)))

                      (or (pair address (pair nat address)) (or unit mutez)))))

              (pair

                (pair

                  (pair (pair timestamp (big_map (pair address nat) unit))

                        (pair nat address))

                  (pair (pair timestamp nat) (pair address (pair address nat))))

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

                      (pair (pair address nat)

                            (pair nat

                                  (pair

                                    (big_map address

                                             (pair (pair address mutez) (pair bool nat)))

                                    (big_map address address))))))) ;

       LAMBDA

         (pair unit

               (pair

                 (pair

                   (pair (pair timestamp (big_map (pair address nat) unit))

                         (pair nat address))

                   (pair (pair timestamp nat) (pair address (pair address nat))))

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

                       (pair (pair address nat)

                             (pair nat

                                   (pair

                                     (big_map address

                                              (pair (pair address mutez) (pair bool nat)))

                                     (big_map address address)))))))

         (pair (list operation)

               (pair unit

                     (pair

                       (pair

                         (pair (pair timestamp (big_map (pair address nat) unit))

                               (pair nat address))

                         (pair (pair timestamp nat) (pair address (pair address nat))))

                       (pair

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

                         (pair (pair address nat)

                               (pair nat

                                     (pair

                                       (big_map address

                                                (pair (pair address mutez)

                                                      (pair bool nat)))

                                       (big_map address address))))))))

         { NIL operation ;

           SWAP ;

           CDR ;

           DUP ;

           DUG 2 ;

           CAR ;

           GET 5 ;

           CONTRACT %get_price (contract nat) ;

           IF_NONE { PUSH int 50 ; FAILWITH } {} ;

           PUSH mutez 0 ;

           SELF_ADDRESS ;

           CONTRACT %set_observed_price nat ;

           IF_NONE { PUSH int 52 ; FAILWITH } {} ;

           TRANSFER_TOKENS ;

           CONS ;

           SWAP ;

           UNIT ;

           DIG 2 ;

           PAIR 3 } ;

       SWAP ;

       LAMBDA

         (pair unit

               (pair

                 (pair

                   (pair (pair timestamp (big_map (pair address nat) unit))

                         (pair nat address))

                   (pair (pair timestamp nat) (pair address (pair address nat))))

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

                       (pair (pair address nat)

                             (pair nat

                                   (pair

                                     (big_map address

                                              (pair (pair address mutez) (pair bool nat)))

                                     (big_map address address)))))))

         (pair (list operation)

               (pair unit

                     (pair

                       (pair

                         (pair (pair timestamp (big_map (pair address nat) unit))

                               (pair nat address))

                         (pair (pair timestamp nat) (pair address (pair address nat))))

                       (pair

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

                         (pair (pair address nat)

                               (pair nat

                                     (pair

                                       (big_map address

                                                (pair (pair address mutez)

                                                      (pair bool nat)))

                                       (big_map address address))))))))

         { NIL operation ;

           SWAP ;

           CDR ;

           DUP ;

           DUG 2 ;

           GET 3 ;

           GET 6 ;

           CONTRACT %get_price (contract nat) ;

           IF_NONE { PUSH int 50 ; FAILWITH } {} ;

           PUSH mutez 0 ;

           SELF_ADDRESS ;

           CONTRACT %set_target_price nat ;

           IF_NONE { PUSH int 52 ; FAILWITH } {} ;

           TRANSFER_TOKENS ;

           CONS ;

           SWAP ;

           UNIT ;

           DIG 2 ;

           PAIR 3 } ;

       SWAP ;

       LAMBDA

         (pair unit

               (pair

                 (pair

                   (pair (pair timestamp (big_map (pair address nat) unit))

                         (pair nat address))

                   (pair (pair timestamp nat) (pair address (pair address nat))))

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

                       (pair (pair address nat)

                             (pair nat

                                   (pair

                                     (big_map address

                                              (pair (pair address mutez) (pair bool nat)))

                                     (big_map address address)))))))

         (pair (list operation)

               (pair unit

                     (pair

                       (pair

                         (pair (pair timestamp (big_map (pair address nat) unit))

                               (pair nat address))

                         (pair (pair timestamp nat) (pair address (pair address nat))))

                       (pair

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

                         (pair (pair address nat)

                               (pair nat

                                     (pair

                                       (big_map address

                                                (pair (pair address mutez)

                                                      (pair bool nat)))

                                       (big_map address address))))))))

         { NIL operation ;

           SWAP ;

           DUP ;

           DUG 2 ;

           CDR ;

           DUP ;

           CAR ;

           CAR ;

           CAR ;

           CAR ;

           NOW ;

           SUB ;

           ISNAT ;

           IF_NONE { PUSH int 146 ; FAILWITH } {} ;

           DUP ;

           PUSH nat 0 ;

           COMPARE ;

           LT ;

           IF

             { DIG 3 ;

               DROP ;

               PUSH nat 1000000000000 ;

               DUP 3 ;

               GET 7 ;

               DUP 3 ;

               DUP 5 ;

               CAR ;

               GET 8 ;

               MUL ;

               MUL ;

               EDIV ;

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

               PUSH nat 1000000000000 ;

               DUP 4 ;

               GET 7 ;

               DUP 4 ;

               PUSH nat 316 ;

               MUL ;

               MUL ;

               EDIV ;

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

               DUP 4 ;

               UNPAIR ;

               UNPAIR ;

               UNPAIR ;

               SWAP ;

               CDR ;

               PUSH nat 1000000000000 ;

               DIG 7 ;

               PUSH nat 316 ;

               DUP 10 ;

               CAR ;

               GET 8 ;

               ADD ;

               MUL ;

               PUSH nat 1000000000000 ;

               ADD ;

               DIG 8 ;

               CAR ;

               CAR ;

               GET 3 ;

               MUL ;

               EDIV ;

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

               PAIR ;

               SWAP ;

               PAIR ;

               PAIR ;

               PAIR ;

               DUG 2 ;

               DIG 3 ;

               DUP 4 ;

               GET 5 ;

               CAR ;

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

               IF_NONE { PUSH int 101 ; FAILWITH } {} ;

               PUSH mutez 0 ;

               DUP 5 ;

               DIG 6 ;

               DUP ;

               GET 5 ;

               CDR ;

               SWAP ;

               DUP ;

               DUG 8 ;

               GET 3 ;

               CAR ;

               CDR ;

               PAIR 3 ;

               TRANSFER_TOKENS ;

               CONS ;

               DUP 4 ;

               GET 5 ;

               CAR ;

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

               IF_NONE { PUSH int 101 ; FAILWITH } {} ;

               PUSH mutez 0 ;

               DUP 4 ;

               DIG 6 ;

               DUP ;

               GET 5 ;

               CDR ;

               SWAP ;

               DUP ;

               DUG 8 ;

               GET 3 ;

               CAR ;

               CAR ;

               PAIR 3 ;

               TRANSFER_TOKENS ;

               CONS ;

               DUG 3 ;

               DIG 2 ;

               DUP ;

               GET 7 ;

               DIG 2 ;

               DIG 3 ;

               ADD ;

               ADD ;

               UPDATE 7 ;

               UNPAIR ;

               UNPAIR ;

               UNPAIR ;

               CDR ;

               NOW ;

               PAIR ;

               PAIR ;

               PAIR ;

               PAIR }

             { DROP ; DIG 2 ; DROP } ;

           UNIT ;

           DIG 2 ;

           PAIR 3 } ;

       SWAP ;

       LAMBDA

         (pair (pair address nat)

               (pair

                 (pair

                   (pair (pair timestamp (big_map (pair address nat) unit))

                         (pair nat address))

                   (pair (pair timestamp nat) (pair address (pair address nat))))

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

                       (pair (pair address nat)

                             (pair nat

                                   (pair

                                     (big_map address

                                              (pair (pair address mutez) (pair bool nat)))

                                     (big_map address address)))))))

         (pair (list operation)

               (pair unit

                     (pair

                       (pair

                         (pair (pair timestamp (big_map (pair address nat) unit))

                               (pair nat address))

                         (pair (pair timestamp nat) (pair address (pair address nat))))

                       (pair

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

                         (pair (pair address nat)

                               (pair nat

                                     (pair

                                       (big_map address

                                                (pair (pair address mutez)

                                                      (pair bool nat)))

                                       (big_map address address))))))))

         { NIL operation ;

           SWAP ;

           DUP ;

           DUG 2 ;

           CDR ;

           DUP ;

           DUG 2 ;

           CAR ;

           CAR ;

           GET 4 ;

           CONTRACT %update_stake (pair address nat) ;

           IF_NONE { PUSH int 174 ; FAILWITH } {} ;

           PUSH mutez 0 ;

           DIG 4 ;

           CAR ;

           TRANSFER_TOKENS ;

           CONS ;

           SWAP ;

           UNIT ;

           DIG 2 ;

           PAIR 3 } ;

       SWAP ;

       LAMBDA

         (pair unit

               (pair

                 (pair

                   (pair (pair timestamp (big_map (pair address nat) unit))

                         (pair nat address))

                   (pair (pair timestamp nat) (pair address (pair address nat))))

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

                       (pair (pair address nat)

                             (pair nat

                                   (pair

                                     (big_map address

                                              (pair (pair address mutez) (pair bool nat)))

                                     (big_map address address)))))))

         (pair (list operation)

               (pair unit

                     (pair

                       (pair

                         (pair (pair timestamp (big_map (pair address nat) unit))

                               (pair nat address))

                         (pair (pair timestamp nat) (pair address (pair address nat))))

                       (pair

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

                         (pair (pair address nat)

                               (pair nat

                                     (pair

                                       (big_map address

                                                (pair (pair address mutez)

                                                      (pair bool nat)))

                                       (big_map address address))))))))

         { NIL operation ;

           SWAP ;

           CDR ;

           SELF_ADDRESS ;

           SENDER ;

           COMPARE ;

           EQ ;

           IF {} { PUSH int 400 ; FAILWITH } ;

           UNIT ;

           DIG 2 ;

           PAIR 3 } ;

       SWAP ;

       LAMBDA

         (pair nat

               (pair

                 (pair

                   (pair (pair timestamp (big_map (pair address nat) unit))

                         (pair nat address))

                   (pair (pair timestamp nat) (pair address (pair address nat))))

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

                       (pair (pair address nat)

                             (pair nat

                                   (pair

                                     (big_map address

                                              (pair (pair address mutez) (pair bool nat)))

                                     (big_map address address)))))))

         (pair (list operation)

               (pair unit

                     (pair

                       (pair

                         (pair (pair timestamp (big_map (pair address nat) unit))

                               (pair nat address))

                         (pair (pair timestamp nat) (pair address (pair address nat))))

                       (pair

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

                         (pair (pair address nat)

                               (pair nat

                                     (pair

                                       (big_map address

                                                (pair (pair address mutez)

                                                      (pair bool nat)))

                                       (big_map address address))))))))

         { NIL operation ;

           SWAP ;

           DUP ;

           DUG 2 ;

           CDR ;

           DUP ;

           CAR ;

           CAR ;

           CAR ;

           CDR ;

           DIG 3 ;

           CAR ;

           SENDER ;

           PAIR ;

           MEM ;

           IF {} { PUSH int 401 ; FAILWITH } ;

           UNIT ;

           DIG 2 ;

           PAIR 3 } ;

       SWAP ;

       UNPAIR ;

       IF_LEFT

         { IF_LEFT

             { IF_LEFT

                 { IF_LEFT

                     { DUP 7 ;

                       DIG 2 ;

                       UNIT ;

                       PAIR ;

                       EXEC ;

                       DUP ;

                       GET 4 ;

                       DUG 2 ;

                       DUP ;

                       CAR ;

                       DUP 8 ;

                       DIG 4 ;

                       UNIT ;

                       PAIR ;

                       EXEC ;

                       DUP ;

                       GET 4 ;

                       DUG 4 ;

                       DUP ;

                       CAR ;

                       NIL operation ;

                       SWAP ;

                       ITER { CONS } ;

                       ITER { DIG 2 ; SWAP ; CONS ; SWAP } ;

                       DROP ;

                       SWAP ;

                       DROP ;

                       DIG 3 ;

                       DROP ;

                       DIG 3 ;

                       DROP ;

                       DIG 3 ;

                       DROP ;

                       DIG 3 ;

                       DROP ;

                       DIG 3 ;

                       DROP ;

                       DIG 3 ;

                       DROP ;

                       DIG 2 ;

                       UNPAIR ;

                       SWAP ;

                       UNPAIR ;

                       UNPAIR ;

                       SWAP ;

                       CDR ;

                       SENDER ;

                       PAIR ;

                       SWAP ;

                       PAIR ;

                       PAIR ;

                       SWAP ;

                       PAIR ;

                       DUP ;

                       DUG 3 ;

                       GET 3 ;

                       CAR ;

                       CDR ;

                       CONTRACT %bailout nat ;

                       IF_NONE { PUSH int 644 ; FAILWITH } {} ;

                       PUSH mutez 0 ;

                       DUP 4 ;

                       TRANSFER_TOKENS ;

                       CONS ;

                       SELF %internal_bailout ;

                       PUSH mutez 0 ;

                       DIG 3 ;

                       TRANSFER_TOKENS ;

                       CONS }

                     { IF_LEFT

                         { DUP 7 ;

                           DIG 2 ;

                           UNIT ;

                           PAIR ;

                           EXEC ;

                           DUP ;

                           GET 4 ;

                           DUG 2 ;

                           DUP ;

                           CAR ;

                           DUP 8 ;

                           DIG 4 ;

                           UNIT ;

                           PAIR ;

                           EXEC ;

                           DUP ;

                           GET 4 ;

                           DUG 4 ;

                           DUP ;

                           CAR ;

                           NIL operation ;

                           SWAP ;

                           ITER { CONS } ;

                           ITER { DIG 2 ; SWAP ; CONS ; SWAP } ;

                           DROP ;

                           SWAP ;

                           DROP ;

                           DIG 3 ;

                           DROP ;

                           DIG 3 ;

                           DROP ;

                           DIG 3 ;

                           DROP ;

                           DIG 3 ;

                           DROP ;

                           DIG 3 ;

                           DROP ;

                           DIG 3 ;

                           DROP ;

                           DIG 2 ;

                           UNPAIR ;

                           SWAP ;

                           UNPAIR ;

                           UNPAIR ;

                           SWAP ;

                           CDR ;

                           SENDER ;

                           PAIR ;

                           SWAP ;

                           PAIR ;

                           PAIR ;

                           SWAP ;

                           PAIR ;

                           DUG 2 ;

                           SELF %internal_burn ;

                           PUSH mutez 0 ;

                           DIG 3 ;

                           TRANSFER_TOKENS ;

                           CONS }

                         { DIG 2 ;

                           DROP ;

                           DIG 2 ;

                           DROP ;

                           DIG 2 ;

                           DROP ;

                           DIG 2 ;

                           DROP ;

                           DIG 2 ;

                           DROP ;

                           DIG 2 ;

                           DROP ;

                           SWAP ;

                           DUP ;

                           DUG 2 ;

                           GET 9 ;

                           SENDER ;

                           MEM ;

                           IF

                             { NIL operation ;

                               DUP 3 ;

                               GET 9 ;

                               SENDER ;

                               GET ;

                               IF_NONE { PUSH int 299 ; FAILWITH } {} ;

                               CAR ;

                               CAR ;

                               CONTRACT unit ;

                               IF_NONE { PUSH int 299 ; FAILWITH } {} ;

                               AMOUNT ;

                               UNIT ;

                               TRANSFER_TOKENS ;

                               CONS }

                             { SELF_ADDRESS ;

                               AMOUNT ;

                               DUP 3 ;

                               CAR ;

                               CREATE_CONTRACT { parameter (or (unit %default)

                                                               (or

                                                                 (option %set_delegate key_hash)

                                                                 (pair %withdraw

                                                                   (address %recipient)

                                                                   (mutez %amount)))) ;

                                                 storage address ;

                                                 code { CAST (pair

                                                               (or unit

                                                                   (or (option key_hash)

                                                                       (pair address

                                                                             mutez)))

                                                               address) ;

                                                        UNPAIR ;

                                                        IF_LEFT

                                                          { DROP ;

                                                            DUP ;

                                                            CONTRACT %set_vault_balance mutez ;

                                                            IF_NONE

                                                              { PUSH int 64 ; FAILWITH }

                                                              {} ;

                                                            NIL operation ;

                                                            SWAP ;

                                                            PUSH mutez 0 ;

                                                            BALANCE ;

                                                            TRANSFER_TOKENS ;

                                                            CONS }

                                                          { IF_LEFT

                                                              { SWAP ;

                                                                DUP ;

                                                                DUG 2 ;

                                                                SENDER ;

                                                                COMPARE ;

                                                                EQ ;

                                                                IF

                                                                  {}

                                                                  { PUSH int 401 ;

                                                                    FAILWITH } ;

                                                                SET_DELEGATE ;

                                                                NIL operation ;

                                                                SWAP ;

                                                                CONS ;

                                                                SELF_ADDRESS ;

                                                                CONTRACT unit ;

                                                                IF_NONE

                                                                  { PUSH int 57 ;

                                                                    FAILWITH }

                                                                  {} ;

                                                                PUSH mutez 0 ;

                                                                UNIT ;

                                                                TRANSFER_TOKENS ;

                                                                CONS }

                                                              { SWAP ;

                                                                DUP ;

                                                                DUG 2 ;

                                                                SENDER ;

                                                                COMPARE ;

                                                                EQ ;

                                                                IF

                                                                  {}

                                                                  { PUSH int 401 ;

                                                                    FAILWITH } ;