parameter (or

            (or

              (or (or (nat %bailout) (nat %burn))

                  (or (bool %create_vault)

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

              (or

                (or (nat %internal_bailout)

                    (or (nat %internal_burn)

                        (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)))

                      (list %internal_touch address)))))

            (or

              (or

                (or (nat %internal_withdraw)

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

                        (nat %mint)))

                (or

                  (pair %remove_administrator (address %administrator_to_remove)

                                              (nat %token_id))

                  (or

                    (pair %set_administrator (address %administrator_to_set)

                                             (nat %token_id))

                    (pair %set_contracts

                      (pair (address %governance_token_contract)

                            (address %options_contract))

                      (pair (address %reward_pool_contract)

                            (pair (address %savings_pool_contract)

                                  (address %target_price_oracle)))))))

              (or

                (or (nat %set_reference_interest_rate)

                    (or (nat %set_target_price)

                        (pair %settle_with_vault (address %vault_owner)

                                                 (pair (nat %token_amount)

                                                       (address %recipient)))))

                (or (list %touch address) (or (unit %update) (nat %withdraw))))));

storage (pair

          (pair

            (pair

              (pair (timestamp %accrual_update_timestamp)

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

                                             unit))

              (pair (address %collateral_token_contract) (int %collateral_token_id)))

            (pair

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

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

          (pair

            (pair

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

              (pair (address %sender) (nat %target_price)))

            (pair (pair (address %target_price_oracle) (address %token_contract))

                  (pair (nat %token_id)

                        (pair (nat %total_supply)

                              (big_map %vault_contexts address

                                                       (pair

                                                         (pair (bool %allows_settlement)

                                                               (nat %balance))

                                                         (pair

                                                           (bool %is_being_liquidated)

                                                           (nat %minted)))))))));

code { LAMBDA

         (pair unit

               (pair (list operation)

                     (pair

                       (pair

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

                               (pair address int))

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

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

                             (pair (pair address address)

                                   (pair nat

                                         (pair nat

                                               (big_map address

                                                        (pair (pair bool nat)

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

         (pair unit

               (pair (list operation)

                     (pair

                       (pair

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

                               (pair address int))

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

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

                             (pair (pair address address)

                                   (pair nat

                                         (pair nat

                                               (big_map address

                                                        (pair (pair bool nat)

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

         { CDR ;

           UNPAIR ;

           SWAP ;

           DUP ;

           DUG 2 ;

           GET 5 ;

           CAR ;

           CONTRACT %get_price (contract nat) ;

           IF_NONE { PUSH int 69 ; FAILWITH } {} ;

           PUSH mutez 0 ;

           SELF_ADDRESS ;

           CONTRACT %set_target_price nat ;

           IF_NONE { PUSH int 71 ; FAILWITH } {} ;

           TRANSFER_TOKENS ;

           CONS ;

           UNIT ;

           PAIR 3 } ;

       SWAP ;

       LAMBDA

         (pair unit

               (pair (list operation)

                     (pair

                       (pair

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

                               (pair address int))

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

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

                             (pair (pair address address)

                                   (pair nat

                                         (pair nat

                                               (big_map address

                                                        (pair (pair bool nat)

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

         (pair unit

               (pair (list operation)

                     (pair

                       (pair

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

                               (pair address int))

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

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

                             (pair (pair address address)

                                   (pair nat

                                         (pair nat

                                               (big_map address

                                                        (pair (pair bool nat)

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

         { UNPAIR 3 ;

           SWAP ;

           DUP 3 ;

           CAR ;

           CAR ;

           CAR ;

           CAR ;

           NOW ;

           SUB ;

           ISNAT ;

           IF_NONE { PUSH int 139 ; FAILWITH } {} ;

           DUP ;

           PUSH nat 0 ;

           COMPARE ;

           LT ;

           IF

             { DIG 2 ;

               DROP ;

               PUSH nat 1000000000000 ;

               DUP 4 ;

               GET 9 ;

               DUP 3 ;

               DUP 6 ;

               CAR ;

               GET 6 ;

               MUL ;

               MUL ;

               EDIV ;

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

               PUSH nat 1000000000000 ;

               DUP 5 ;

               GET 9 ;

               DUP 4 ;

               PUSH nat 316 ;

               MUL ;

               MUL ;

               EDIV ;

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

               DUP 5 ;

               UNPAIR ;

               UNPAIR ;

               SWAP ;

               UNPAIR ;

               CDR ;

               PUSH nat 1000000000000 ;

               DIG 7 ;

               PUSH nat 316 ;

               DUP 11 ;

               CAR ;

               GET 6 ;

               ADD ;

               MUL ;

               PUSH nat 1000000000000 ;

               ADD ;

               DIG 9 ;

               CAR ;

               GET 3 ;

               CAR ;

               MUL ;

               EDIV ;

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

               PAIR ;

               PAIR ;

               SWAP ;

               PAIR ;

               PAIR ;

               DUG 3 ;

               DIG 2 ;

               DUP 4 ;

               GET 5 ;

               CDR ;

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

               IF_NONE { PUSH int 120 ; FAILWITH } {} ;

               PUSH mutez 0 ;

               DUP 5 ;

               DIG 6 ;

               DUP ;

               GET 7 ;

               SWAP ;

               DUP ;

               DUG 8 ;

               GET 3 ;

               CAR ;

               CDR ;

               PAIR 3 ;

               TRANSFER_TOKENS ;

               CONS ;

               DUP 4 ;

               GET 5 ;

               CDR ;

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

               IF_NONE { PUSH int 120 ; FAILWITH } {} ;

               PUSH mutez 0 ;

               DUP 4 ;

               DIG 6 ;

               DUP ;

               GET 7 ;

               SWAP ;

               DUP ;

               DUG 8 ;

               GET 3 ;

               CAR ;

               CAR ;

               PAIR 3 ;

               TRANSFER_TOKENS ;

               CONS ;

               DUG 2 ;

               DIG 3 ;

               DUP ;

               GET 9 ;

               DIG 2 ;

               DIG 3 ;

               ADD ;

               ADD ;

               UPDATE 9 ;

               UNPAIR ;

               UNPAIR ;

               UNPAIR ;

               CDR ;

               NOW ;

               PAIR ;

               PAIR ;

               PAIR ;

               PAIR ;

               SWAP }

             { DROP ; SWAP ; DROP } ;

           UNIT ;

           PAIR 3 } ;

       SWAP ;

       LAMBDA

         (pair (pair address nat)

               (pair (list operation)

                     (pair

                       (pair

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

                               (pair address int))

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

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

                             (pair (pair address address)

                                   (pair nat

                                         (pair nat

                                               (big_map address

                                                        (pair (pair bool nat)

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

         (pair unit

               (pair (list operation)

                     (pair

                       (pair

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

                               (pair address int))

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

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

                             (pair (pair address address)

                                   (pair nat

                                         (pair nat

                                               (big_map address

                                                        (pair (pair bool nat)

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

         { UNPAIR 3 ;

           SWAP ;

           DUP 3 ;

           CAR ;

           GET 3 ;

           CDR ;

           CONTRACT %update_stake (pair address nat) ;

           IF_NONE { PUSH int 167 ; FAILWITH } {} ;

           PUSH mutez 0 ;

           DIG 3 ;

           TRANSFER_TOKENS ;

           CONS ;

           UNIT ;

           PAIR 3 } ;

       SWAP ;

       LAMBDA

         (pair unit

               (pair (list operation)

                     (pair

                       (pair

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

                               (pair address int))

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

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

                             (pair (pair address address)

                                   (pair nat

                                         (pair nat

                                               (big_map address

                                                        (pair (pair bool nat)

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

         (pair unit

               (pair (list operation)

                     (pair

                       (pair

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

                               (pair address int))

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

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

                             (pair (pair address address)

                                   (pair nat

                                         (pair nat

                                               (big_map address

                                                        (pair (pair bool nat)

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

         { CDR ;

           UNPAIR ;

           SELF_ADDRESS ;

           SENDER ;

           COMPARE ;

           EQ ;

           IF {} { PUSH int 400 ; FAILWITH } ;

           UNIT ;

           PAIR 3 } ;

       SWAP ;

       LAMBDA

         (pair nat

               (pair (list operation)

                     (pair

                       (pair

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

                               (pair address int))

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

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

                             (pair (pair address address)

                                   (pair nat

                                         (pair nat

                                               (big_map address

                                                        (pair (pair bool nat)

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

         (pair unit

               (pair (list operation)

                     (pair

                       (pair

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

                               (pair address int))

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

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

                             (pair (pair address address)

                                   (pair nat

                                         (pair nat

                                               (big_map address

                                                        (pair (pair bool nat)

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

         { UNPAIR 3 ;

           SWAP ;

           DUP 3 ;

           CAR ;

           CAR ;

           CAR ;

           CDR ;

           DIG 2 ;

           SENDER ;

           PAIR ;

           MEM ;

           IF {} { PUSH int 401 ; FAILWITH } ;

           UNIT ;

           PAIR 3 } ;

       SWAP ;

       UNPAIR ;

       IF_LEFT

         { IF_LEFT

             { IF_LEFT

                 { IF_LEFT

                     { DIG 2 ;

                       DROP ;

                       DIG 2 ;

                       DROP ;

                       DIG 2 ;

                       DROP ;

                       NIL operation ;

                       DIG 4 ;

                       UNIT ;

                       SWAP ;

                       DIG 4 ;

                       DIG 3 ;

                       DIG 3 ;

                       PAIR 3 ;

                       EXEC ;

                       CDR ;

                       UNPAIR ;

                       DIG 3 ;

                       DIG 2 ;

                       DIG 3 ;

                       DIG 3 ;

                       DIG 3 ;

                       UNIT ;

                       SWAP ;

                       DIG 4 ;

                       DIG 3 ;

                       DIG 3 ;

                       PAIR 3 ;

                       EXEC ;

                       CDR ;

                       UNPAIR ;

                       SWAP ;

                       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 586 ; FAILWITH } {} ;

                       PUSH mutez 0 ;

                       DUP 4 ;

                       TRANSFER_TOKENS ;

                       CONS ;

                       SELF %internal_bailout ;

                       PUSH mutez 0 ;

                       DIG 3 ;

                       TRANSFER_TOKENS ;

                       CONS }

                     { DIG 2 ;

                       DROP ;

                       DIG 2 ;

                       DROP ;

                       DIG 2 ;

                       DROP ;

                       NIL operation ;

                       DIG 4 ;

                       UNIT ;

                       SWAP ;

                       DIG 4 ;

                       DIG 3 ;

                       DIG 3 ;

                       PAIR 3 ;

                       EXEC ;

                       CDR ;

                       UNPAIR ;

                       DIG 3 ;

                       DIG 2 ;

                       DIG 3 ;

                       DIG 3 ;

                       DIG 3 ;

                       UNIT ;

                       SWAP ;

                       DIG 4 ;

                       DIG 3 ;

                       DIG 3 ;

                       PAIR 3 ;

                       EXEC ;

                       CDR ;

                       UNPAIR ;

                       SWAP ;

                       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 } }

                 { IF_LEFT

                     { DIG 2 ;

                       DROP ;

                       DIG 2 ;

                       DROP ;

                       DIG 2 ;

                       DROP ;

                       DIG 2 ;

                       DROP ;

                       DIG 2 ;

                       DROP ;

                       SWAP ;

                       DUP ;

                       DUG 2 ;

                       GET 10 ;

                       SENDER ;

                       MEM ;

                       IF

                         { DROP }

                         { SWAP ;

                           DUP ;

                           GET 10 ;

                           PUSH (pair bool nat) (Pair False 0) ;

                           PUSH nat 0 ;

                           DIG 4 ;

                           PAIR ;

                           PAIR ;

                           SOME ;

                           SENDER ;

                           UPDATE ;

                           UPDATE 10 } ;

                       NIL operation }

                     { IF_LEFT

                         { DIG 2 ;

                           DROP ;

                           DIG 2 ;

                           DROP ;

                           DIG 2 ;

                           DROP ;

                           DIG 2 ;

                           DROP ;

                           DIG 2 ;

                           DROP ;

                           NIL operation ;

                           DUP 3 ;

                           CAR ;

                           CAR ;

                           GET 3 ;

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

                           IF_NONE { PUSH int 36 ; FAILWITH } {} ;

                           PUSH mutez 0 ;

                           DUP 4 ;

                           SELF_ADDRESS ;

                           SENDER ;

                           PAIR 3 ;

                           TRANSFER_TOKENS ;

                           CONS ;

                           DIG 2 ;

                           DUP ;

                           GET 10 ;

                           DUP ;

                           SENDER ;

                           DUP ;

                           DUG 2 ;

                           GET ;

                           IF_NONE { PUSH int 439 ; FAILWITH } {} ;

                           UNPAIR ;

                           UNPAIR ;

                           SWAP ;

                           DIG 7 ;

                           ADD ;

                           SWAP ;

                           PAIR ;

                           PAIR ;

                           SOME ;

                           SWAP ;

                           UPDATE ;

                           UPDATE 10 ;

                           SWAP }

                         { NIL operation ;

                           DUP 4 ;

                           PUSH nat 0 ;

                           SWAP ;

                           DIG 4 ;

                           DIG 3 ;

                           DIG 3 ;

                           PAIR 3 ;

                           EXEC ;

                           UNPAIR 3 ;

                           DUG 8 ;

                           DUG 8 ;

                           DUG 8 ;

                           DUG 8 ;

                           DIG 7 ;

                           DIG 8 ;

                           DIG 8 ;

                           DIG 8 ;

                           DUP 3 ;

                           UNIT ;

                           EXEC ;

                           NIL operation ;

                           SWAP ;

                           ITER { CONS } ;

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

                           DROP ;

                           SWAP ;

                           DROP ;

                           DIG 2 ;

                           DROP ;

                           DIG 2 ;

                           DROP ;

                           DIG 2 ;

                           DROP ;

                           DIG 2 ;

                           DROP ;

                           DIG 2 ;

                           DROP } } } }

             { IF_LEFT

                 { IF_LEFT

                     { NIL operation ;

                       DUP 5 ;

                       UNIT ;

                       SWAP ;

                       DIG 4 ;

                       DIG 3 ;

                       DIG 3 ;

                       PAIR 3 ;

                       EXEC ;

                       UNPAIR 3 ;

                       DUG 8 ;

                       DUG 8 ;

                       DUG 8 ;

                       DUG 8 ;

                       DIG 7 ;

                       DIG 8 ;

                       DIG 8 ;

                       DIG 8 ;

                       DIG 3 ;

                       DUP ;

                       GET 10 ;

                       SWAP ;

                       DUP ;

                       DUG 5 ;

                       GET 3 ;

                       GET 3 ;

                       GET ;

                       IF_NONE { PUSH int 611 ; FAILWITH } {} ;

                       DUP 5 ;

                       GET 3 ;

                       GET 4 ;

                       DUP 5 ;

                       MUL ;

                       PUSH nat 1000000000000000000 ;

                       PUSH nat 1 ;

                       PUSH nat 2 ;

                       DUP 4 ;

                       LSR ;

                       DUP 4 ;

                       ADD ;

                       MUL ;

                       EDIV ;

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

                       DUP ;

                       PUSH nat 1 ;

                       SWAP ;

                       COMPARE ;

                       GE ;

                       IF {} { PUSH int 602 ; FAILWITH } ;

                       PUSH nat 1000000000000 ;

                       DUP 8 ;

                       CAR ;

                       GET 3 ;

                       CAR ;

                       DUP 5 ;

                       GET 4 ;

                       MUL ;

                       EDIV ;

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

                       DIG 3 ;

                       DUP 8 ;

                       CAR ;

                       GET 3 ;

                       CAR ;

                       PUSH nat 1000000000000 ;

                       DUP 9 ;

                       DUP 5 ;

                       SUB ;

                       ISNAT ;

                       IF_NONE { PUSH int 620 ; FAILWITH } {} ;

                       MUL ;

                       EDIV ;

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

                       UPDATE 4 ;

                       DUP ;

                       DUG 4 ;

                       UNPAIR ;

                       CAR ;

                       DUP 4 ;

                       DIG 6 ;

                       CAR ;

                       CDR ;

                       SUB ;

                       ISNAT ;

                       IF_NONE { PUSH int 621 ; FAILWITH } {} ;

                       SWAP ;

                       PAIR ;

                       PAIR ;

                       DUG 3 ;

                       DUP 8 ;

                       DUP ;

                       GET 10 ;

                       DUP 6 ;

                       SOME ;

                       DIG 10 ;

                       GET 3 ;

                       GET 3 ;

                       UPDATE ;

                       UPDATE 10 ;

                       DUG 7 ;

                       DUP 4 ;

                       CAR ;

                       CAR ;

                       IF

                         { DIG 2 ;

                           DROP ;

                           DIG 2 ;

                           DROP ;

                           DIG 2 ;

                           DROP ;

                           DIG 5 ;

                           DROP ;

                           DIG 5 ;

                           DROP ;

                           DIG 6 ;

                           DROP ;

                           DIG 6 ;

                           DROP ;

                           DIG 5 ;

                           DUP 6 ;

                           GET 3 ;

                           GET 4 ;

                           DUP 6 ;

                           DIG 3 ;

                           SUB ;

                           ISNAT ;

                           IF_NONE { PUSH int 626 ; FAILWITH } {} ;

                           MUL ;

                           DUP 6 ;

                           GET 3 ;

                           GET 3 ;

                           PAIR ;

                           SWAP ;

                           DIG 5 ;

                           DIG 4 ;

                           DIG 3 ;

                           PAIR 3 ;

                           EXEC ;