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

                 (pair

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

                         (pair address nat))

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

               (pair unit

                     (pair

                       (pair

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

                               (pair address nat))

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

         { NIL operation ;

           SWAP ;

           CDR ;

           DUP ;

           DUG 2 ;

           GET 5 ;

           CAR ;

           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 address nat))

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

               (pair unit

                     (pair

                       (pair

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

                               (pair address nat))

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

         { NIL operation ;

           SWAP ;

           DUP ;

           DUG 2 ;

           CDR ;

           DUP ;

           CAR ;

           CAR ;

           CAR ;

           CAR ;

           NOW ;

           SUB ;

           ISNAT ;

           IF_NONE { PUSH int 136 ; FAILWITH } {} ;

           DUP ;

           PUSH nat 0 ;

           COMPARE ;

           LT ;

           IF

             { DIG 3 ;

               DROP ;

               PUSH nat 1000000000000 ;

               DUP 3 ;

               GET 9 ;

               DUP 3 ;

               DUP 5 ;

               CAR ;

               GET 6 ;

               MUL ;

               MUL ;

               EDIV ;

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

               PUSH nat 1000000000000 ;

               DUP 4 ;

               GET 9 ;

               DUP 4 ;

               PUSH nat 316 ;

               MUL ;

               MUL ;

               EDIV ;

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

               DUP 4 ;

               UNPAIR ;

               UNPAIR ;

               SWAP ;

               UNPAIR ;

               CDR ;

               PUSH nat 1000000000000 ;

               DIG 7 ;

               PUSH nat 316 ;

               DUP 10 ;

               CAR ;

               GET 6 ;

               ADD ;

               MUL ;

               PUSH nat 1000000000000 ;

               ADD ;

               DIG 8 ;

               CAR ;

               GET 3 ;

               CAR ;

               MUL ;

               EDIV ;

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

               PAIR ;

               PAIR ;

               SWAP ;

               PAIR ;

               PAIR ;

               DUG 2 ;

               DIG 3 ;

               DUP 4 ;

               GET 5 ;

               CDR ;

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

               IF_NONE { PUSH int 101 ; 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 101 ; 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 3 ;

               DIG 2 ;

               DUP ;

               GET 9 ;

               DIG 2 ;

               DIG 3 ;

               ADD ;

               ADD ;

               UPDATE 9 ;

               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 address nat))

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

               (pair unit

                     (pair

                       (pair

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

                               (pair address nat))

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

         { NIL operation ;

           SWAP ;

           DUP ;

           DUG 2 ;

           CDR ;

           DUP ;

           DUG 2 ;

           CAR ;

           GET 3 ;

           CDR ;

           CONTRACT %update_stake (pair address nat) ;

           IF_NONE { PUSH int 164 ; 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 address nat))

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

               (pair unit

                     (pair

                       (pair

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

                               (pair address nat))

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

         { 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 address nat))

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

               (pair unit

                     (pair

                       (pair

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

                               (pair address nat))

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

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

                       PUSH mutez 0 ;

                       DUP 4 ;

                       TRANSFER_TOKENS ;

                       CONS ;

                       SELF %internal_bailout ;

                       PUSH mutez 0 ;

                       DIG 3 ;

                       TRANSFER_TOKENS ;

                       CONS }

                     { 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 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 3 ;

                   DROP ;

                   DIG 3 ;

                   DROP ;

                   DIG 3 ;

                   DROP ;

                   DIG 3 ;

                   DROP ;

                   IF_LEFT

                     { 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 ;

                           NIL operation ;

                           DUP 3 ;

                           CAR ;

                           CAR ;

                           GET 3 ;

                           CONTRACT %transfer (list (pair address

                                                         (list (pair address

                                                                    (pair nat nat))))) ;

                           IF_NONE { PUSH int 35 ; FAILWITH } {} ;

                           PUSH mutez 0 ;

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

                           NIL (pair address (pair nat nat)) ;

                           DUP 6 ;

                           DUP 8 ;

                           CAR ;

                           CAR ;

                           GET 4 ;

                           SELF_ADDRESS ;

                           PAIR 3 ;

                           CONS ;

                           SENDER ;

                           PAIR ;

                           CONS ;

                           TRANSFER_TOKENS ;

                           CONS ;

                           DIG 2 ;

                           DUP ;

                           GET 10 ;

                           DUP ;

                           SENDER ;

                           DUP ;

                           DUG 2 ;

                           GET ;

                           IF_NONE { PUSH int 430 ; FAILWITH } {} ;

                           UNPAIR ;

                           UNPAIR ;

                           SWAP ;

                           DIG 7 ;

                           ADD ;

                           SWAP ;

                           PAIR ;

                           PAIR ;

                           SOME ;

                           SWAP ;

                           UPDATE ;

                           UPDATE 10 ;

                           SWAP }

                         { DUG 2 ;

                           PUSH nat 0 ;

                           PAIR ;

                           EXEC ;

                           DUP ;

                           GET 4 ;

                           DUG 2 ;

                           CAR ;

                           SWAP ;

                           UNIT ;

                           EXEC ;

                           NIL operation ;

                           SWAP ;

                           ITER { CONS } ;

                           ITER { CONS } } } } }

             { IF_LEFT

                 { IF_LEFT

                     { DUP 4 ;

                       DIG 2 ;

                       UNIT ;

                       PAIR ;

                       EXEC ;

                       DUP ;

                       GET 4 ;

                       DUG 2 ;

                       DUP ;

                       CAR ;

                       DIG 3 ;

                       DUP ;

                       GET 10 ;

                       SWAP ;

                       DUP ;

                       DUG 5 ;

                       GET 3 ;

                       GET 3 ;

                       GET ;

                       IF_NONE { PUSH int 595 ; FAILWITH } {} ;

                       DUP 5 ;

                       GET 3 ;

                       GET 4 ;

                       DUP 5 ;

                       MUL ;

                       PUSH nat 1000000 ;

                       PUSH nat 2 ;

                       DUP 3 ;

                       LSR ;

                       DUP 3 ;

                       ADD ;

                       EDIV ;

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

                       DUP ;

                       PUSH nat 1000000000 ;

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

                       DIG 3 ;

                       DUP 8 ;

                       CAR ;

                       GET 3 ;

                       CAR ;

                       PUSH nat 1000000000000 ;

                       DUP 9 ;

                       DUP 5 ;

                       SUB ;

                       ISNAT ;

                       IF_NONE { PUSH int 604 ; FAILWITH } {} ;

                       MUL ;

                       EDIV ;

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

                       UPDATE 4 ;

                       DUP ;

                       DUG 4 ;

                       UNPAIR ;

                       CAR ;

                       DUP 4 ;

                       DIG 6 ;

                       CAR ;

                       CDR ;

                       SUB ;

                       ISNAT ;

                       IF_NONE { PUSH int 605 ; 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

                         { DUP 11 ;

                           DIG 8 ;

                           DUP ;

                           DUP ;

                           DUG 10 ;

                           GET 3 ;

                           GET 4 ;

                           DUP 10 ;

                           DUP 5 ;

                           SUB ;

                           ISNAT ;

                           IF_NONE { PUSH int 610 ; FAILWITH } {} ;

                           MUL ;

                           DIG 10 ;

                           GET 3 ;

                           GET 3 ;

                           PAIR ;

                           PAIR ;

                           EXEC ;

                           DUP ;

                           GET 4 ;

                           DUG 8 ;

                           DUP ;

                           CAR ;

                           NIL operation ;

                           SWAP ;

                           ITER { CONS } ;

                           ITER { DIG 6 ; SWAP ; CONS ; DUG 5 } ;

                           DROP 2 ;

                           SWAP ;

                           DROP ;

                           SWAP ;

                           DROP ;

                           DIG 2 ;

                           DROP ;

                           DIG 4 ;

                           DROP ;

                           DIG 4 ;

                           DROP ;

                           DIG 4 ;

                           DROP ;

                           DIG 4 ;

                           DROP ;

                           DIG 4 ;

                           DROP }