parameter (or

            (or

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

                  (or

                    (pair %create_vault (bool %allows_settlement)

                                        (pair (option %baker key_hash)

                                              (contract %contract_address_callback address)))

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

              (or

                (or (nat %internal_burn)

                    (or

                      (pair %internal_liquidate (address %vault_owner)

                                                (nat %token_amount))

                      (nat %internal_mint)))

                (or

                  (pair %internal_settle_with_vault (address %vault_owner)

                                                    (pair (nat %token_amount)

                                                          (address %recipient)))

                  (or (mutez %internal_withdraw)

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

            (or

              (or

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

                            (address %options_contract))

                      (pair (address %reward_pool_contract)

                            (pair (address %savings_pool_contract)

                                  (address %target_price_oracle))))

                    (nat %set_reference_interest_rate))))

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

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

          (pair

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

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

            (pair (pair (nat %token_id) (nat %total_supply))

                  (pair

                    (big_map %vault_contexts address

                                             (pair

                                               (pair (address %address)

                                                     (bool %allows_settlement))

                                               (pair (mutez %balance)

                                                     (pair (bool %is_being_liquidated)

                                                           (nat %minted)))))

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

code { LAMBDA

         (pair unit

               (pair (list operation)

                     (pair

                       (pair

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

                               (pair nat address))

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

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

                             (pair (pair nat nat)

                                   (pair

                                     (big_map address

                                              (pair (pair address bool)

                                                    (pair mutez (pair bool nat))))

                                     (big_map address address)))))))

         (pair unit

               (pair (list operation)

                     (pair

                       (pair

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

                               (pair nat address))

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

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

                             (pair (pair nat nat)

                                   (pair

                                     (big_map address

                                              (pair (pair address bool)

                                                    (pair mutez (pair bool nat))))

                                     (big_map address address)))))))

         { CDR ;

           UNPAIR ;

           SWAP ;

           DUP ;

           DUG 2 ;

           GET 3 ;

           GET 3 ;

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

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

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

                             (pair (pair nat nat)

                                   (pair

                                     (big_map address

                                              (pair (pair address bool)

                                                    (pair mutez (pair bool nat))))

                                     (big_map address address)))))))

         (pair unit

               (pair (list operation)

                     (pair

                       (pair

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

                               (pair nat address))

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

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

                             (pair (pair nat nat)

                                   (pair

                                     (big_map address

                                              (pair (pair address bool)

                                                    (pair mutez (pair bool nat))))

                                     (big_map address address)))))))

         { UNPAIR 3 ;

           SWAP ;

           DUP 3 ;

           CAR ;

           CAR ;

           CAR ;

           CAR ;

           NOW ;

           SUB ;

           ISNAT ;

           IF_NONE { PUSH int 133 ; FAILWITH } {} ;

           DUP ;

           PUSH nat 0 ;

           COMPARE ;

           LT ;

           IF

             { DIG 2 ;

               DROP ;

               PUSH nat 1000000000000 ;

               DUP 4 ;

               GET 5 ;

               CDR ;

               DUP 3 ;

               DUP 6 ;

               CAR ;

               GET 3 ;

               CDR ;

               MUL ;

               MUL ;

               EDIV ;

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

               PUSH nat 1000000000000 ;

               DUP 5 ;

               GET 5 ;

               CDR ;

               DUP 4 ;

               PUSH nat 316 ;

               MUL ;

               MUL ;

               EDIV ;

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

               DUP 5 ;

               UNPAIR ;

               UNPAIR ;

               UNPAIR ;

               SWAP ;

               CDR ;

               PUSH nat 1000000000000 ;

               DIG 7 ;

               PUSH nat 316 ;

               DUP 11 ;

               CAR ;

               GET 3 ;

               CDR ;

               ADD ;

               MUL ;

               PUSH nat 1000000000000 ;

               ADD ;

               DIG 9 ;

               CAR ;

               CAR ;

               GET 3 ;

               MUL ;

               EDIV ;

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

               PAIR ;

               SWAP ;

               PAIR ;

               PAIR ;

               PAIR ;

               DUG 3 ;

               DIG 2 ;

               DUP 4 ;

               GET 3 ;

               GET 4 ;

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

               IF_NONE { PUSH int 120 ; FAILWITH } {} ;

               PUSH mutez 0 ;

               DUP 5 ;

               DIG 6 ;

               DUP ;

               GET 5 ;

               CAR ;

               SWAP ;

               DUP ;

               DUG 8 ;

               CAR ;

               GET 6 ;

               PAIR 3 ;

               TRANSFER_TOKENS ;

               CONS ;

               DUP 4 ;

               GET 3 ;

               GET 4 ;

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

               IF_NONE { PUSH int 120 ; FAILWITH } {} ;

               PUSH mutez 0 ;

               DUP 4 ;

               DIG 6 ;

               DUP ;

               GET 5 ;

               CAR ;

               SWAP ;

               DUP ;

               DUG 8 ;

               CAR ;

               GET 5 ;

               PAIR 3 ;

               TRANSFER_TOKENS ;

               CONS ;

               DUG 2 ;

               DIG 3 ;

               UNPAIR ;

               SWAP ;

               UNPAIR ;

               SWAP ;

               UNPAIR ;

               UNPAIR ;

               SWAP ;

               DIG 5 ;

               DIG 6 ;

               ADD ;

               ADD ;

               SWAP ;

               PAIR ;

               PAIR ;

               SWAP ;

               PAIR ;

               SWAP ;

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

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

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

                             (pair (pair nat nat)

                                   (pair

                                     (big_map address

                                              (pair (pair address bool)

                                                    (pair mutez (pair bool nat))))

                                     (big_map address address)))))))

         (pair unit

               (pair (list operation)

                     (pair

                       (pair

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

                               (pair nat address))

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

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

                             (pair (pair nat nat)

                                   (pair

                                     (big_map address

                                              (pair (pair address bool)

                                                    (pair mutez (pair bool nat))))

                                     (big_map address address)))))))

         { UNPAIR 3 ;

           SWAP ;

           DUP 3 ;

           CAR ;

           CAR ;

           GET 4 ;

           CONTRACT %update_stake (pair address nat) ;

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

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

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

                             (pair (pair nat nat)

                                   (pair

                                     (big_map address

                                              (pair (pair address bool)

                                                    (pair mutez (pair bool nat))))

                                     (big_map address address)))))))

         (pair unit

               (pair (list operation)

                     (pair

                       (pair

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

                               (pair nat address))

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

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

                             (pair (pair nat nat)

                                   (pair

                                     (big_map address

                                              (pair (pair address bool)

                                                    (pair mutez (pair bool nat))))

                                     (big_map address address)))))))

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

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

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

                             (pair (pair nat nat)

                                   (pair

                                     (big_map address

                                              (pair (pair address bool)

                                                    (pair mutez (pair bool nat))))

                                     (big_map address address)))))))

         (pair unit

               (pair (list operation)

                     (pair

                       (pair

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

                               (pair nat address))

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

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

                             (pair (pair nat nat)

                                   (pair

                                     (big_map address

                                              (pair (pair address bool)

                                                    (pair mutez (pair bool nat))))

                                     (big_map address address)))))))

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

                       CDR ;

                       SENDER ;

                       PAIR ;

                       PAIR ;

                       PAIR ;

                       SWAP ;

                       PAIR ;

                       DUP ;

                       DUG 3 ;

                       CAR ;

                       GET 6 ;

                       CONTRACT %bailout nat ;

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

                       CDR ;

                       SENDER ;

                       PAIR ;

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

                       SENDER ;

                       MEM ;

                       IF

                         { NIL operation ;

                           DUP 3 ;

                           GET 7 ;

                           SENDER ;

                           GET ;

                           IF_NONE { PUSH int 227 ; FAILWITH } {} ;

                           CAR ;

                           CAR ;

                           CONTRACT unit ;

                           IF_NONE { PUSH int 227 ; FAILWITH } {} ;

                           AMOUNT ;

                           UNIT ;

                           TRANSFER_TOKENS ;

                           CONS }

                         { NIL operation ;

                           SELF_ADDRESS ;

                           AMOUNT ;

                           DUP 4 ;

                           GET 3 ;

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

                                                            DUP ;

                                                            CAR ;

                                                            CONTRACT unit ;

                                                            IF_NONE

                                                              { PUSH int 79 ; FAILWITH }

                                                              {} ;

                                                            NIL operation ;

                                                            SWAP ;

                                                            DIG 2 ;

                                                            CDR ;

                                                            UNIT ;

                                                            TRANSFER_TOKENS ;

                                                            CONS } } ;

                                                    NIL operation ;

                                                    SWAP ;

                                                    ITER { CONS } ;

                                                    PAIR } } ;

                           PAIR ;

                           DUP ;

                           DUG 2 ;

                           CAR ;

                           CONS ;

                           SWAP ;

                           DIG 3 ;

                           DUP ;

                           GET 7 ;

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

                           AMOUNT ;

                           PAIR ;

                           DUP 6 ;

                           CAR ;

                           DUP 5 ;

                           CDR ;

                           PAIR ;

                           PAIR ;

                           SOME ;

                           SENDER ;

                           UPDATE ;

                           UPDATE 7 ;

                           DUP ;

                           GET 8 ;

                           SENDER ;

                           SOME ;

                           DIG 3 ;

                           CDR ;

                           UPDATE ;

                           UPDATE 8 ;

                           DUG 2 } ;

                       SWAP ;

                       GET 4 ;

                       PUSH mutez 0 ;

                       DUP 4 ;

                       GET 7 ;

                       SENDER ;

                       GET ;

                       IF_NONE { PUSH int 229 ; FAILWITH } {} ;

                       CAR ;

                       CAR ;

                       TRANSFER_TOKENS ;

                       CONS }

                     { IF_LEFT

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

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

                           SWAP ;

                           DUP ;

                           DUG 5 ;

                           GET 3 ;

                           CAR ;

                           CAR ;

                           GET ;

                           IF_NONE { PUSH int 606 ; FAILWITH } {} ;

                           DUP 5 ;

                           GET 3 ;

                           CAR ;

                           CDR ;

                           DUP 5 ;

                           MUL ;

                           PUSH mutez 1 ;

                           PUSH nat 1000000000000 ;

                           PUSH nat 2 ;

                           DUP 4 ;

                           LSR ;

                           DUP 4 ;

                           ADD ;

                           EDIV ;

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

                           MUL ;

                           DUP ;

                           PUSH mutez 1000 ;

                           SWAP ;

                           COMPARE ;

                           GE ;

                           IF {} { PUSH int 602 ; FAILWITH } ;

                           PUSH nat 1000000000000 ;

                           DUP 8 ;