Better Call Dev

FA2Ledger
​x
 
{ parameter (or
              (or
                (or %checkerEntrypoint
                  (or %lazyParams
                    (or
                      (or
                        (or
                          (or (nat %activate_burrow)
                              (pair %add_liquidity (pair nat nat) (pair nat timestamp)))
                          (or (pair %burn_kit nat nat)
                              (pair %buy_kit (pair nat nat) timestamp)))
                        (or
                          (or (nat %cancel_liquidation_slice)
                              (pair %create_burrow nat (option key_hash)))
                          (or (pair %deactivate_burrow nat address)
                              (nat %deposit_collateral))))
                      (or
                        (or
                          (or (nat %liquidation_auction_claim_win)
                              (pair %liquidation_auction_place_bid nat nat))
                          (or (pair %mark_for_liquidation address nat)
                              (pair %mint_kit nat nat)))
                        (or
                          (or (pair %receive_ctez_marginal_price nat nat)
                              (nat %receive_price))
                          (or (pair %receive_slice_from_burrow address nat)
                              (pair %remove_liquidity (pair nat nat)
                                                      (pair nat timestamp))))))
                    (or
                      (or
                        (or
                          (or (pair %sell_kit (pair nat nat) timestamp)
                              (address %set_admin))
                          (or (pair %set_burrow_delegate nat (option key_hash))
                              (pair %set_contracts
                                (pair (pair (address %ctez) (address %ctez_cfmm))
                                      (pair (address %governance)
                                            (address %liquidation_tracker)))
                                (pair (address %oracle) (address %reward_pool)))))
                        (or (or (unit %touch) (pair %touch_burrow address nat))
                            (or (list %touch_liquidation_slices nat)
                                (list %update_operators (or
                                                         (pair %add_operator
                                                           (address %owner)
                                                           (pair (address %operator)
                                                                 (nat %token_id)))
                                                         (pair %remove_operator
                                                           (address %owner)
                                                           (pair (address %operator)
                                                                 (nat %token_id))))))))
                      (pair %withdraw_collateral nat mutez)))
                  (or %strictParams
                    (pair %balance_of
                      (list %requests (pair (address %owner) (nat %token_id)))
                      (contract %callback (list (pair
                                                (pair %request (address %owner)
                                                               (nat %token_id))
                                                (nat %balance)))))
                    (list %transfer (pair (address %from_)
                                         (list %txs (pair (address %to_)
                                                         (pair (nat %token_id)
                                                               (nat %amount))))))))
                (pair %deployFunction int bytes))
              (or (bytes %deployMetadata)
                  (pair %sealContract
                    (pair (pair address address) (pair address address))
                    (pair (pair address address) address)))) ;
  storage (pair (big_map %lazy_functions int bytes)
                (pair (big_map %metadata string bytes)
                      (or %deployment_state
                        (pair %sealed
                          (pair
                            (pair
                              (pair (address %admin)
                                    (big_map %burrows (pair address nat)
                                                      (pair
                                                        (pair
                                                          (pair (bool %active)
                                                                (address %address))
                                                          (pair (int %adjustment_index)
                                                                (nat %collateral)))
                                                        (pair
                                                          (pair
                                                            (nat %collateral_at_auction)
                                                            (timestamp %last_checker_timestamp))
                                                          (nat %outstanding_kit)))))
                              (pair
                                (pair %cfmm
                                  (pair (pair (nat %ctez) (nat %kit))
                                        (pair
                                          (pair %kit_in_ctez_in_prev_block (int %den)
                                                                           (int %num))
                                          (nat %last_level)))
                                  (nat %lqt))
                                (pair %external_contracts
                                  (pair (pair (address %ctez) (address %ctez_cfmm))
                                        (pair (address %governance)
                                              (address %liquidation_tracker)))
                                  (pair (address %oracle) (address %reward_pool)))))
                            (pair
                              (pair
                                (pair %fa2_state
                                  (big_map %ledger (pair address nat) nat)
                                  (big_map %operators (pair (pair address address) nat)
                                                      unit))
                                (option %last_ctez_in_tez (pair (int %den) (int %num))))
                              (pair (option %last_price nat)
                                    (pair %liquidation_auctions
                                      (pair
                                        (pair
                                          (pair %avl_storage (nat %last_ptr)
                                                             (big_map %mem nat
                                                                           (or
                                                                             (or
                                                                               (pair %branch
                                                                                 (pair
                                                                                   (pair
                                                                                     (nat %left)
                                                                                     (nat %left_height))
                                                                                   (pair
                                                                                     (nat %left_tok)
                                                                                     (nat %parent)))
                                                                                 (pair
                                                                                   (pair
                                                                                     (nat %right)
                                                                                     (nat %right_height))
                                                                                   (nat %right_tok)))
                                                                               (pair %leaf
                                                                                 (nat %parent)
                                                                                 (pair %value
                                                                                   (pair
                                                                                     (pair %contents
                                                                                       (pair
                                                                                         (pair %burrow
                                                                                           address
                                                                                           nat)
                                                                                         (option %min_kit_for_unwarranted nat))
                                                                                       (nat %tok))
                                                                                     (option %older nat))
                                                                                   (option %younger nat))))
                                                                             (pair %root
                                                                               (option nat)
                                                                               (option (pair
                                                                                        (pair
                                                                                          (option %older_auction nat)
                                                                                          (nat %sold_tok))
                                                                                        (pair
                                                                                          (pair %winning_bid
                                                                                            (address %address)
                                                                                            (nat %kit))
                                                                                          (option %younger_auction nat))))))))
                                          (big_map %burrow_slices (pair address nat)
                                                                  (pair
                                                                    (nat %oldest_slice)
                                                                    (nat %youngest_slice))))
                                        (pair
                                          (option %completed_auctions (pair (nat %oldest)
                                                                           (nat %youngest)))
                                          (option %current_auction (pair (nat %contents)
                                                                        (or %state
                                                                          (pair %ascending
                                                                            (pair
                                                                              (pair
                                                                                (address %address)
                                                                                (nat %kit))
                                                                              timestamp)
                                                                            nat)
                                                                          (pair %descending
                                                                            nat
                                                                            timestamp))))))
                                      (nat %queued_slices)))))
                          (pair %parameters
                            (pair
                              (pair
                                (pair (int %burrow_fee_index) (nat %circulating_kit))
                                (pair (int %drift) (int %drift_derivative)))
                              (pair (pair (int %imbalance_index) (nat %index))
                                    (pair (timestamp %last_touched)
                                          (nat %outstanding_kit))))
                            (pair (pair (nat %protected_index) (int %q)) (int %target))))
                        (address %unsealed)))) ;
  code { PUSH nat 1000000 ;
         LAMBDA
           nat
           unit
           { PUSH nat 1 ;
             SWAP ;
             DUP ;
             DUG 2 ;
             COMPARE ;
             EQ ;
             PUSH nat 0 ;
             DIG 2 ;
             COMPARE ;
             EQ ;
             OR ;
             IF { UNIT } { PUSH string "FA2_TOKEN_UNDEFINED" ; FAILWITH } } ;
         EMPTY_BIG_MAP (pair (pair address address) nat) unit ;
         EMPTY_BIG_MAP (pair address nat) nat ;
         PAIR ;
         LAMBDA
           (pair (big_map (pair address nat) nat) (pair (pair address nat) nat))
           (big_map (pair address nat) nat)
           { UNPAIR 3 ;
             PUSH nat 0 ;
             DUP 4 ;
             COMPARE ;
             EQ ;
             IF
               { DIG 2 ; DROP ; SWAP ; NONE nat ; SWAP ; UPDATE }
               { DUG 2 ; SWAP ; SOME ; SWAP ; UPDATE } } ;
         EMPTY_BIG_MAP nat
                        (or
                          (or
                            (pair (pair (pair nat nat) (pair nat nat))
                                  (pair (pair nat nat) nat))
                            (pair nat
                                  (pair
                                    (pair
                                      (pair (pair (pair address nat) (option nat)) nat)
                                      (option nat))
                                    (option nat))))
                          (pair (option nat)
                                (option (pair (pair (option nat) nat)
                                             (pair (pair address nat) (option nat)))))) ;
         PUSH nat 0 ;
         PUSH nat 1 ;
         ADD ;
         DUP ;
         DIG 2 ;
         NONE (pair (pair (option nat) nat) (pair (pair address nat) (option nat))) ;
         NONE nat ;
         PAIR ;
         RIGHT (or (pair (pair (pair nat nat) (pair nat nat)) (pair (pair nat nat) nat))
                   (pair nat
                         (pair
                           (pair (pair (pair (pair address nat) (option nat)) nat)
                                 (option nat))
                           (option nat)))) ;
         SOME ;
         DUP 4 ;
         UPDATE ;
         DIG 2 ;
         PAIR ;
         SWAP ;
         NONE (pair nat
                    (or (pair (pair (pair address nat) timestamp) nat)
                        (pair nat timestamp))) ;
         NONE (pair nat nat) ;
         PAIR ;
         EMPTY_BIG_MAP (pair address nat) (pair nat nat) ;
         DIG 3 ;
         PAIR ;
         PAIR ;
         PAIR ;
         PUSH int 18446744073709551616 ;
         PUSH int 18446744073709551616 ;
         DUP 7 ;
         PAIR ;
         PAIR ;
         PUSH nat 0 ;
         NOW ;
         PAIR ;
         DIG 6 ;
         PUSH int 18446744073709551616 ;
         PAIR ;
         PAIR ;
         PUSH int 0 ;
         PUSH int 0 ;
         PAIR ;
         PUSH nat 0 ;
         PUSH int 18446744073709551616 ;
         PAIR ;
         PAIR ;
         PAIR ;
         PAIR ;
         LAMBDA
           unit
           unit
           { DROP ; PUSH mutez 0 ; AMOUNT ; COMPARE ; NEQ ; IF { PUSH int 83 ; FAILWITH } { UNIT } } ;
         DIG 6 ;
         UNPAIR ;
         SWAP ;
         UNPAIR 3 ;
         DIG 2 ;
         IF_LEFT
           { DIG 5 ;
             DIG 6 ;
             DIG 8 ;
             DROP 3 ;
             DIG 3 ;
             IF_LEFT
               { IF_LEFT
                   { IF_LEFT
                       { DIG 4 ;
                         DIG 5 ;
                         DIG 6 ;
                         DROP 3 ;
                         IF_LEFT
                           { IF_LEFT
                               { IF_LEFT
                                   { IF_LEFT
                                       { IF_LEFT
                                           { PACK ; PUSH int 8 ; PAIR }
                                           { PACK ; PUSH int 17 ; PAIR } }
                                       { IF_LEFT
                                           { PACK ; PUSH int 7 ; PAIR }
                                           { PACK ; PUSH int 15 ; PAIR } } }
                                   { IF_LEFT
                                       { IF_LEFT
                                           { PACK ; PUSH int 12 ; PAIR }
                                           { PACK ; PUSH int 3 ; PAIR } }
                                       { IF_LEFT
                                           { PACK ; PUSH int 9 ; PAIR }
                                           { PACK ; PUSH int 4 ; PAIR } } } }
                               { IF_LEFT
                                   { IF_LEFT
                                       { IF_LEFT
                                           { PACK ; PUSH int 20 ; PAIR }
                                           { PACK ; PUSH int 19 ; PAIR } }
                                       { IF_LEFT
                                           { PACK ; PUSH int 10 ; PAIR }
                                           { PACK ; PUSH int 6 ; PAIR } } }
                                   { IF_LEFT
                                       { IF_LEFT
                                           { PACK ; PUSH int 23 ; PAIR }
                                           { PACK ; PUSH int 22 ; PAIR } }
                                       { IF_LEFT
                                           { PACK ; PUSH int 21 ; PAIR }
                                           { PACK ; PUSH int 18 ; PAIR } } } } }
                           { IF_LEFT
                               { IF_LEFT
                                   { IF_LEFT
                                       { IF_LEFT
                                           { PACK ; PUSH int 16 ; PAIR }
                                           { PACK ; PUSH int 2 ; PAIR } }
                                       { IF_LEFT
                                           { PACK ; PUSH int 14 ; PAIR }
                                           { PACK ; PUSH int 1 ; PAIR } } }
                                   { IF_LEFT
                                       { IF_LEFT
                                           { PACK ; PUSH int 0 ; PAIR }
                                           { PACK ; PUSH int 13 ; PAIR } }
                                       { IF_LEFT
                                           { PACK ; PUSH int 11 ; PAIR }
                                           { PACK ; PUSH int 24 ; PAIR } } } }
                               { PACK ; PUSH int 5 ; PAIR } } ;
                         UNPAIR ;
                         SWAP ;
                         DIG 2 ;
                         PAIR ;
                         DUP 3 ;
                         DIG 2 ;
                         GET ;
                         IF_NONE
                           { PUSH int 151 ; FAILWITH }
                           { UNPACK (lambda
                                      (pair
                                        (pair
                                          (pair
                                            (pair
                                              (pair (address %admin)
                                                    (big_map %burrows (pair address nat)
                                                                      (pair
                                                                        (pair
                                                                          (pair
                                                                            (bool %active)
                                                                            (address %address))
                                                                          (pair
                                                                            (int %adjustment_index)
                                                                            (nat %collateral)))
                                                                        (pair
                                                                          (pair
                                                                            (nat %collateral_at_auction)
                                                                            (timestamp %last_checker_timestamp))
                                                                          (nat %outstanding_kit)))))
                                              (pair
                                                (pair %cfmm
                                                  (pair (pair (nat %ctez) (nat %kit))
                                                        (pair
                                                          (pair %kit_in_ctez_in_prev_block
                                                            (int %den)
                                                            (int %num))
                                                          (nat %last_level)))
                                                  (nat %lqt))
                                                (pair %external_contracts
                                                  (pair
                                                    (pair (address %ctez)
                                                          (address %ctez_cfmm))
                                                    (pair (address %governance)
                                                          (address %liquidation_tracker)))
                                                  (pair (address %oracle)
                                                        (address %reward_pool)))))
                                            (pair
                                              (pair
                                                (pair %fa2_state
                                                  (big_map %ledger (pair address nat)
                                                                   nat)
                                                  (big_map %operators
                                                    (pair (pair address address) nat)
                                                    unit))
                                                (option %last_ctez_in_tez (pair
                                                                           (int %den)
                                                                           (int %num))))
                                              (pair (option %last_price nat)
                                                    (pair %liquidation_auctions
                                                      (pair
                                                        (pair
                                                          (pair %avl_storage
                                                            (nat %last_ptr)
                                                            (big_map %mem nat
                                                                          (or
                                                                            (or
                                                                              (pair %branch
                                                                                (pair
                                                                                  (pair
                                                                                    (nat %left)
                                                                                    (nat %left_height))
                                                                                  (pair
                                                                                    (nat %left_tok)
                                                                                    (nat %parent)))
                                                                                (pair
                                                                                  (pair
                                                                                    (nat %right)
                                                                                    (nat %right_height))
                                                                                  (nat %right_tok)))
                                                                              (pair %leaf
                                                                                (nat %parent)
                                                                                (pair %value
                                                                                  (pair
                                                                                    (pair %contents
                                                                                      (pair
                                                                                        (pair %burrow
                                                                                          address
                                                                                          nat)
                                                                                        (option %min_kit_for_unwarranted nat))
                                                                                      (nat %tok))
                                                                                    (option %older nat))
                                                                                  (option %younger nat))))
                                                                            (pair %root
                                                                              (option nat)
                                                                              (option (pair
                                                                                       (pair
                                                                                         (option %older_auction nat)
                                                                                         (nat %sold_tok))
                                                                                       (pair
                                                                                         (pair %winning_bid
                                                                                           (address %address)
                                                                                           (nat %kit))
                                                                                         (option %younger_auction nat))))))))
                                                          (big_map %burrow_slices
                                                            (pair address nat)
                                                            (pair (nat %oldest_slice)
                                                                  (nat %youngest_slice))))
                                                        (pair
                                                          (option %completed_auctions (pair
                                                                                       (nat %oldest)
                                                                                       (nat %youngest)))
                                                          (option %current_auction (pair
                                                                                    (nat %contents)
                                                                                    (or %state
                                                                                      (pair %ascending
                                                                                        (pair
                                                                                          (pair
                                                                                            (address %address)
                                                                                            (nat %kit))
                                                                                          timestamp)
                                                                                        nat)
                                                                                      (pair %descending
                                                                                        nat
                                                                                        timestamp))))))
                                                      (nat %queued_slices)))))
                                          (pair %parameters
                                            (pair
                                              (pair
                                                (pair (int %burrow_fee_index)
                                                      (nat %circulating_kit))
                                                (pair (int %drift)
                                                      (int %drift_derivative)))
                                              (pair
                                                (pair (int %imbalance_index)
                                                      (nat %index))
                                                (pair (timestamp %last_touched)
                                                      (nat %outstanding_kit))))
                                            (pair (pair (nat %protected_index) (int %q))
                                                  (int %target))))
                                        bytes)
                                      (pair (list operation)
                                            (pair
                                              (pair
                                                (pair
                                                  (pair (address %admin)
                                                        (big_map %burrows
                                                          (pair address nat)
                                                          (pair
                                                            (pair
                                                              (pair (bool %active)
                                                                    (address %address))
                                                              (pair
                                                                (int %adjustment_index)
                                                                (nat %collateral)))
                                                            (pair
                                                              (pair
                                                                (nat %collateral_at_auction)
                                                                (timestamp %last_checker_timestamp))
                                                              (nat %outstanding_kit)))))
                                                  (pair
                                                    (pair %cfmm
                                                      (pair
                                                        (pair (nat %ctez) (nat %kit))
                                                        (pair
                                                          (pair %kit_in_ctez_in_prev_block
                                                            (int %den)
                                                            (int %num))
                                                          (nat %last_level)))
                                                      (nat %lqt))
                                                    (pair %external_contracts
                                                      (pair
                                                        (pair (address %ctez)
                                                              (address %ctez_cfmm))
                                                        (pair (address %governance)
                                                              (address %liquidation_tracker)))
                                                      (pair (address %oracle)
                                                            (address %reward_pool)))))
                                                (pair
                                                  (pair
                                                    (pair %fa2_state
                                                      (big_map %ledger
                                                        (pair address nat)
                                                        nat)
                                                      (big_map %operators
                                                        (pair (pair address address) nat)
                                                        unit))
                                                    (option %last_ctez_in_tez (pair
                                                                               (int %den)
                                                                               (int %num))))
                                                  (pair (option %last_price nat)
                                                        (pair %liquidation_auctions
                                                          (pair
                                                            (pair
                                                              (pair %avl_storage
                                                                (nat %last_ptr)
                                                                (big_map %mem nat
                                                                              (or
                                                                                (or
                                                                                  (pair %branch
                                                                                    (pair
                                                                                      (pair
                                                                                        (nat %left)
                                                                                        (nat %left_height))
                                                                                      (pair
                                                                                        (nat %left_tok)
                                                                                        (nat %parent)))
                                                                                    (pair
                                                                                      (pair
                                                                                        (nat %right)
                                                                                        (nat %right_height))
                                                                                      (nat %right_tok)))
                                                                                  (pair %leaf
                                                                                    (nat %parent)
                                                                                    (pair %value
                                                                                      (pair
                                                                                        (pair %contents
                                                                                          (pair
                                                                                            (pair %burrow
                                                                                              address
                                                                                              nat)
                                                                                            (option %min_kit_for_unwarranted nat))
                                                                                          (nat %tok))
                                                                                        (option %older nat))
                                                                                      (option %younger nat))))
                                                                                (pair %root
                                                                                  (option nat)
                                                                                  (option (pair
                                                                                           (pair
                                                                                             (option %older_auction nat)
                                                                                             (nat %sold_tok))
                                                                                           (pair
                                                                                             (pair %winning_bid
                                                                                               (address %address)
                                                                                               (nat %kit))
                                                                                             (option %younger_auction nat))))))))
                                                              (big_map %burrow_slices
                                                                (pair address nat)
                                                                (pair
                                                                  (nat %oldest_slice)
                                                                  (nat %youngest_slice))))
                                                            (pair
                                                              (option %completed_auctions (pair
                                                                                           (nat %oldest)
                                                                                           (nat %youngest)))
                                                              (option %current_auction (pair
                                                                                        (nat %contents)
                                                                                        (or %state
                                                                                          (pair %ascending
                                                                                            (pair
                                                                                              (pair
                                                                                                (address %address)
                                                                                                (nat %kit))
                                                                                              timestamp)
                                                                                            nat)
                                                                                          (pair %descending
                                                                                            nat
                                                                                            timestamp))))))
                                                          (nat %queued_slices)))))
                                              (pair %parameters
                                                (pair
                                                  (pair
                                                    (pair (int %burrow_fee_index)
                                                          (nat %circulating_kit))
                                                    (pair (int %drift)
                                                          (int %drift_derivative)))
                                                  (pair
                                                    (pair (int %imbalance_index)
                                                          (nat %index))
                                                    (pair (timestamp %last_touched)
                                                          (nat %outstanding_kit))))
                                                (pair
                                                  (pair (nat %protected_index) (int %q))
                                                  (int %target)))))) ;
                             IF_NONE { PUSH int 150 ; FAILWITH } {} } ;
                         SWAP ;
                         EXEC }
                       { IF_LEFT
                           { DIG 5 ;
                             DROP ;
                             SWAP ;
                             UNIT ;
                             DIG 5 ;
                             SWAP ;
                             EXEC ;
                             DROP ;
                             SWAP ;
                             UNPAIR ;
                             DUP 3 ;
                             CAR ;
                             CDR ;
                             CAR ;
                             CAR ;
                             SWAP ;
                             MAP { DUP ;
                                   UNPAIR ;
                                   DUP 4 ;
                                   DUP 3 ;
                                   DUP 11 ;
                                   SWAP ;
                                   EXEC ;
                                   DROP ;
                                   CAR ;
                                   DUG 2 ;
                                   PAIR ;
                                   GET ;
                                   IF_NONE { PUSH nat 0 } {} ;
                                   SWAP ;
                                   PAIR } ;
                             SWAP ;
                             DIG 6 ;
                             DROP 2 ;
                             SWAP ;
                             PUSH mutez 0 ;
                             DIG 2 ;
                             TRANSFER_TOKENS ;
                             SWAP ;
                             NIL operation ;
                             DIG 2 ;
                             CONS ;
                             PAIR }
                           { SWAP ;
                             UNIT ;
                             DIG 5 ;
                             SWAP ;
                             EXEC ;
                             DROP ;
                             DUP ;
                             CDR ;
                             SWAP ;
                             DUP ;
                             DUG 2 ;
                             CAR ;
                             CDR ;
                             CDR ;
                             DUP 3 ;
                             CAR ;
                             CDR ;
                             CAR ;
                             CDR ;
                             DIG 4 ;
                             DUP 5 ;
                             CAR ;
                             CDR ;
                             CAR ;
                             CAR ;
                             SWAP ;
                             ITER { UNPAIR ;
                                    DUG 2 ;
                                    ITER { UNPAIR 3 ;
                                           SWAP ;
                                           DUP ;
                                           DUG 2 ;
                                           DUP 6 ;
                                           PAIR ;
                                           SENDER ;
                                           DUP 6 ;
                                           DIG 2 ;
                                           UNPAIR ;
                                           DIG 2 ;
                                           CDR ;
                                           DUG 2 ;
                                           DUP ;
                                           DUG 3 ;
                                           DUP 5 ;
                                           PAIR ;
                                           PAIR ;
                                           MEM ;
                                           DUG 2 ;
                                           COMPARE ;
                                           EQ ;
                                           OR ;
                                           IF
                                             { SWAP ;
                                               DUP ;
                                               DUG 2 ;
                                               DUP 14 ;
                                               SWAP ;
                                               EXEC ;
                                               DROP ;
                                               DUP 3 ;
                                               DUP 6 ;
                                               PAIR ;
                                               DUP 3 ;
                                               DIG 5 ;
                                               DIG 2 ;
                                               UNPAIR ;
                                               DUP 3 ;
                                               CAR ;
                                               DIG 4 ;
                                               DIG 2 ;
                                               PAIR ;
                                               DUG 2 ;
                                               DUP ;
                                               DUG 3 ;
                                               DUP 3 ;
                                               GET ;
                                               IF_NONE { PUSH nat 0 } {} ;
                                               SUB ;
                                               ISNAT ;
                                               IF_NONE
                                                 { PUSH string "FA2_INSUFFICIENT_BALANCE" ;
                                                   FAILWITH }
                                                 {} ;
                                               SWAP ;
                                               DIG 2 ;
                                               PAIR 3 ;
                                               DUP 13 ;
                                               SWAP ;
                                               EXEC ;
                                               SWAP ;
                                               CDR ;
                                               SWAP ;
                                               PAIR ;
                                               DIG 3 ;
                                               DIG 2 ;
                                               DUP 3 ;
                                               CAR ;
                                               DIG 4 ;
                                               DIG 2 ;
                                               PAIR ;
                                               DUG 2 ;
                                               DUP ;
                                               DUG 3 ;
                                               DUP 3 ;
                                               GET ;
                                               IF_NONE { PUSH nat 0 } {} ;
                                               ADD ;
                                               SWAP ;
                                               DIG 2 ;
                                               PAIR 3 ;
                                               DUP 10 ;
                                               SWAP ;
                                               EXEC ;
                                               SWAP ;
                                               CDR ;
                                               SWAP ;
                                               PAIR }
                                             { DROP 4 ;
                                               PUSH string "FA2_NOT_OPERATOR" ;
                                               FAILWITH } } ;
                                    SWAP ;
                                    DROP } ;
                             DIG 7 ;
                             DIG 8 ;
                             DROP 2 ;
                             PAIR ;
                             PAIR ;
                             DIG 2 ;
                             CAR ;
                             CAR ;
                             PAIR ;
                             PAIR ;
                             NIL operation ;
                             PAIR } } }
                   { SWAP ; DIG 4 ; DIG 5 ; DIG 6 ; DROP 5 ; PUSH int 135 ; FAILWITH } }
               { SWAP ;
                 DIG 4 ;
                 DIG 5 ;
                 DIG 6 ;
                 DROP 4 ;
                 IF_LEFT
                   { DROP ; PUSH int 135 ; FAILWITH }
                   { DROP ; PUSH int 135 ; FAILWITH } } ;
             UNPAIR ;
             SWAP ;
             LEFT address ;
             DIG 3 ;
             PAIR ;
             DUG 2 ;
             PAIR ;
             PAIR }
           { DIG 4 ;
             DIG 7 ;
             DIG 9 ;
             DROP 3 ;
             DUP ;
             SENDER ;
             COMPARE ;
             EQ ;
             IF
               { DIG 3 ;
                 IF_LEFT
                   { DIG 4 ;
                     DIG 5 ;
                     DIG 6 ;
                     DROP 3 ;
                     IF_LEFT
                       { DROP 4 ; PUSH int 134 ; FAILWITH }
                       { UNPAIR ;
                         DIG 2 ;
                         RIGHT (pair
                                 (pair
                                   (pair
                                     (pair address
                                           (big_map (pair address nat)
                                                    (pair
                                                      (pair (pair bool address)
                                                            (pair int nat))
                                                      (pair (pair nat timestamp) nat))))
                                     (pair
                                       (pair
                                         (pair (pair nat nat) (pair (pair int int) nat))
                                         nat)
                                       (pair
                                         (pair (pair address address)
                                               (pair address address))
                                         (pair address address))))
                                   (pair
                                     (pair
                                       (pair (big_map (pair address nat) nat)
                                             (big_map (pair (pair address address) nat)
                                                      unit))
                                       (option (pair int int)))
                                     (pair (option nat)
                                           (pair
                                             (pair
                                               (pair
                                                 (pair nat
                                                       (big_map nat
                                                                (or
                                                                  (or
                                                                    (pair
                                                                      (pair
                                                                        (pair nat nat)
                                                                        (pair nat nat))
                                                                      (pair
                                                                        (pair nat nat)
                                                                        nat))
                                                                    (pair nat
                                                                          (pair
                                                                            (pair
                                                                              (pair
                                                                                (pair
                                                                                  (pair
                                                                                    address
                                                                                    nat)
                                                                                  (option nat))
                                                                                nat)
                                                                              (option nat))
                                                                            (option nat))))
                                                                  (pair (option nat)
                                                                        (option (pair
                                                                                 (pair
                                                                                   (option nat)
                                                                                   nat)
                                                                                 (pair
                                                                                   (pair
                                                                                     address
                                                                                     nat)
                                                                                   (option nat))))))))
                                                 (big_map (pair address nat)
                                                          (pair nat nat)))
                                               (pair (option (pair nat nat))
                                                     (option (pair nat
                                                                  (or
                                                                    (pair
                                                                      (pair
                                                                        (pair address
                                                                              nat)
                                                                        timestamp)
                                                                      nat)
                                                                    (pair nat timestamp))))))
                                             nat))))
                                 (pair
                                   (pair (pair (pair int nat) (pair int int))
                                         (pair (pair int nat) (pair timestamp nat)))
                                   (pair (pair nat int) int))) ;
                         DIG 4 ;
                         PAIR ;
                         DUP 4 ;
                         DUP 3 ;
                         GET ;
                         IF_NONE
                           { DUG 3 ; SWAP ; SOME ; SWAP ; UPDATE }
                           { DIG 4 ; DIG 4 ; DIG 2 ; CONCAT ; DIG 3 ; SWAP ; SOME ; SWAP ; UPDATE } ;
                         NIL operation ;
                         PAIR ;
                         PAIR } }
                   { IF_LEFT
                       { DIG 4 ;
                         DIG 5 ;
                         DIG 6 ;
                         DROP 3 ;
                         SWAP ;
                         RIGHT (pair
                                 (pair
                                   (pair
                                     (pair address
                                           (big_map (pair address nat)
                                                    (pair
                                                      (pair (pair bool address)
                                                            (pair int nat))
                                                      (pair (pair nat timestamp) nat))))
                                     (pair
                                       (pair
                                         (pair (pair nat nat) (pair (pair int int) nat))
                                         nat)
                                       (pair
                                         (pair (pair address address)
                                               (pair address address))
                                         (pair address address))))
                                   (pair
                                     (pair
                                       (pair (big_map (pair address nat) nat)
                                             (big_map (pair (pair address address) nat)
                                                      unit))
                                       (option (pair int int)))
                                     (pair (option nat)
                                           (pair
                                             (pair
                                               (pair
                                                 (pair nat
                                                       (big_map nat
                                                                (or
                                                                  (or
                                                                    (pair
                                                                      (pair
                                                                        (pair nat nat)
                                                                        (pair nat nat))
                                                                      (pair
                                                                        (pair nat nat)
                                                                        nat))
                                                                    (pair nat
                                                                          (pair
                                                                            (pair
                                                                              (pair
                                                                                (pair
                                                                                  (pair
                                                                                    address
                                                                                    nat)
                                                                                  (option nat))
                                                                                nat)
                                                                              (option nat))
                                                                            (option nat))))
                                                                  (pair (option nat)
                                                                        (option (pair
                                                                                 (pair
                                                                                   (option nat)
                                                                                   nat)
                                                                                 (pair
                                                                                   (pair
                                                                                     address
                                                                                     nat)
                                                                                   (option nat))))))))
                                                 (big_map (pair address nat)
                                                          (pair nat nat)))
                                               (pair (option (pair nat nat))
                                                     (option (pair nat
                                                                  (or
                                                                    (pair
                                                                      (pair
                                                                        (pair address
                                                                              nat)
                                                                        timestamp)
                                                                      nat)
                                                                    (pair nat timestamp))))))
                                             nat))))
                                 (pair
                                   (pair (pair (pair int nat) (pair int int))
                                         (pair (pair int nat) (pair timestamp nat)))
                                   (pair (pair nat int) int))) ;
                         DUP 4 ;
                         PUSH string "m" ;
                         GET ;
                         IF_NONE
                           { DIG 3 ; DIG 2 ; SOME ; PUSH string "m" ; UPDATE }
                           { DIG 4 ; DIG 3 ; DIG 2 ; CONCAT ; SOME ; PUSH string "m" ; UPDATE } ;
                         PAIR ;
                         SWAP ;
                         NIL operation ;
                         PAIR ;
                         PAIR }
                       { SWAP ;
                         DROP ;
                         UNPAIR ;
                         UNPAIR ;
                         UNPAIR ;
                         DIG 2 ;
                         UNPAIR ;
                         DIG 4 ;
                         UNPAIR ;
                         UNPAIR ;
                         DIG 4 ;
                         DIG 5 ;
                         PAIR ;
                         SWAP ;
                         DIG 4 ;
                         PAIR ;
                         DIG 3 ;
                         DIG 4 ;
                         PAIR ;
                         PAIR ;
                         PAIR ;
                         DUP ;
                         CAR ;
                         CAR ;
                         CAR ;
                         CONTRACT %transfer (pair (address %from)
                                                  (pair (address %to) (nat %value))) ;
                         IF_NONE { PUSH int 114 ; FAILWITH } { DROP } ;
                         DUP ;
                         CDR ;
                         CAR ;
                         CONTRACT %getPrice (contract nat) ;
                         IF_NONE { PUSH int 113 ; FAILWITH } { DROP } ;
                         DUP ;
                         CAR ;
                         CAR ;
                         CDR ;
                         CONTRACT %getMarginalPrice (contract (pair nat nat)) ;
                         IF_NONE { PUSH int 116 ; FAILWITH } { DROP } ;
                         SELF_ADDRESS ;
                         CONTRACT %touch unit ;
                         IF_NONE
                           { PUSH int 4 ; NEG ; FAILWITH }
                           { PUSH mutez 0 ; UNIT ; TRANSFER_TOKENS } ;
                         DUG 2 ;
                         DIG 5 ;
                         DIG 6 ;
                         NONE nat ;
                         PAIR ;
                         NONE (pair int int) ;
                         DIG 8 ;
                         PAIR ;
                         PAIR ;
                         DIG 2 ;
                         PUSH nat 1 ;
                         LEVEL ;
                         PUSH int 1 ;
                         PUSH int 1 ;
                         PAIR ;
                         PAIR ;
                         PUSH nat 1 ;
                         PUSH nat 1 ;
                         PAIR ;
                         PAIR ;
                         PAIR ;
                         PAIR ;
                         EMPTY_BIG_MAP (pair address nat)
                                        (pair (pair (pair bool address) (pair int nat))
                                              (pair (pair nat timestamp) nat)) ;
                         DIG 4 ;
                         PAIR ;
                         PAIR ;
                         PAIR ;
                         PAIR ;
                         LEFT address ;
                         DIG 3 ;
                         PUSH bytes 0x74657a6f732d73746f726167653a6d ;
                         SOME ;
                         PUSH string "" ;
                         UPDATE ;
                         PAIR ;
                         DIG 2 ;
                         NIL operation ;
                         DIG 3 ;
                         CONS ;
                         PAIR ;
                         PAIR } } }
               { DROP 7 ; PUSH int 111 ; FAILWITH } } ;
         UNPAIR ;
         UNPAIR ;
         DIG 2 ;
         UNPAIR ;
         DIG 3 ;
         PAIR 3 ;
         SWAP ;
         PAIR } ;
  view "vault_context" address
        (option (pair (address %account_address)
                     (pair (nat %balance)
                           (pair (option %introducer address) (nat %minted)))))
        { PUSH nat 1000000 ;
          PUSH int 18446744073709551616 ;
          EMPTY_BIG_MAP nat
                         (or
                           (or
                             (pair (pair (pair nat nat) (pair nat nat))
                                   (pair (pair nat nat) nat))
                             (pair nat
                                   (pair
                                     (pair
                                       (pair (pair (pair address nat) (option nat)) nat)
                                       (option nat))
                                     (option nat))))
                           (pair (option nat)
                                 (option (pair (pair (option nat) nat)
                                              (pair (pair address nat) (option nat)))))) ;
          PUSH nat 0 ;
          PUSH nat 1 ;
          ADD ;
          DUP ;
          DIG 2 ;
          NONE (pair (pair (option nat) nat) (pair (pair address nat) (option nat))) ;
          NONE nat ;
          PAIR ;
          RIGHT (or
                  (pair (pair (pair nat nat) (pair nat nat)) (pair (pair nat nat) nat))
                  (pair nat
                        (pair
                          (pair (pair (pair (pair address nat) (option nat)) nat)
                                (option nat))
                          (option nat)))) ;
          SOME ;
          DUP 4 ;
          DROP 5 ;
          DUP ;
          DUP ;
          DUG 2 ;
          DUP 4 ;
          PAIR ;
          PAIR ;
          PUSH nat 0 ;
          NOW ;
          PAIR ;
          DIG 3 ;
          DUP 4 ;
          PAIR ;
          PAIR ;
          PUSH int 0 ;
          PUSH int 0 ;
          PAIR ;
          PUSH nat 0 ;
          DUP 5 ;
          DROP 5 ;
          SWAP ;
          UNPAIR ;
          SWAP ;
          GET 4 ;
          IF_LEFT
            { DUP ;
              CAR ;
              CAR ;
              CAR ;
              CDR ;
              PUSH nat 0 ;
              DIG 3 ;
              PAIR ;
              GET ;
              IF_NONE { PUSH int 81 ; FAILWITH } {} ;
              SWAP ;
              CDR ;
              SWAP ;
              DUP ;
              DUG 2 ;
              CDR ;
              CAR ;
              CDR ;
              SWAP ;
              DUP ;
              DUG 2 ;
              CAR ;
              CDR ;
              CDR ;
              CAR ;
              COMPARE ;
              EQ ;
              IF
                { DIG 2 ; DROP 2 }
                { DIG 2 ;
                  SWAP ;
                  DUP ;
                  DUG 2 ;
                  CAR ;
                  CDR ;
                  CAR ;
                  CAR ;
                  DUP 3 ;
                  CAR ;
                  CAR ;
                  CAR ;
                  CAR ;
                  MUL ;
                  SWAP ;
                  DUP ;
                  DUG 2 ;
                  SWAP ;
                  EDIV ;
                  IF_NONE
                    { DROP ; PUSH int 292 ; FAILWITH }
                    { UNPAIR ;
                      PUSH nat 0 ;
                      DIG 2 ;
                      COMPARE ;
                      EQ ;
                      IF
                        { SWAP ; DROP }
                        { PUSH int 0 ; DIG 2 ; COMPARE ; GT ; IF {} { PUSH int 1 ; SWAP ; SUB } } } ;
                  DUP 3 ;
                  CAR ;
                  CDR ;
                  CAR ;
                  PUSH int 1000000000000 ;
                  MUL ;
                  SWAP ;
                  DUP ;
                  DUG 2 ;
                  DUP 5 ;
                  CDR ;
                  CDR ;
                  MUL ;
                  PUSH int 0 ;
                  SWAP ;
                  DUP ;
                  DUG 2 ;
                  COMPARE ;
                  LT ;
                  IF
                    { DROP 2 ; PUSH int 271 ; FAILWITH }
                    { SWAP ;
                      PUSH int 1000000000000 ;
                      DIG 2 ;
                      MUL ;
                      SWAP ;
                      DUP ;
                      DUG 2 ;
                      SWAP ;
                      EDIV ;
                      IF_NONE
                        { DROP ; PUSH int 291 ; FAILWITH }
                        { UNPAIR ;
                          PUSH nat 0 ;
                          DIG 2 ;
                          COMPARE ;
                          EQ ;
                          IF
                            { SWAP ; DROP }
                            { PUSH int 0 ; DIG 2 ; COMPARE ; LT ; IF {} { PUSH int 1 ; ADD } } } ;
                      ABS } ;
                  DUP 4 ;
                  CDR ;
                  CAR ;
                  PAIR ;
                  DIG 3 ;
                  CAR ;
                  PAIR ;
                  DUP ;
                  CDR ;
                  SWAP ;
                  DUP ;
                  DUG 2 ;
                  CAR ;
                  CDR ;
                  CDR ;
                  DIG 3 ;
                  PAIR ;
                  DIG 2 ;
                  CAR ;
                  CAR ;
                  PAIR ;
                  PAIR ;
                  DUP ;
                  CDR ;
                  CDR ;
                  DIG 2 ;
                  CAR ;
                  CDR ;
                  CDR ;
                  CAR ;
                  DUP 3 ;
                  CDR ;
                  CAR ;
                  CAR ;
                  PAIR ;
                  PAIR ;
                  SWAP ;
                  CAR ;
                  PAIR } ;
              DUP ;
              CDR ;
              CDR ;
              NONE address ;
              DUP 3 ;
              CAR ;
              CDR ;
              CDR ;
              DIG 3 ;
              CAR ;
              CAR ;
              CDR ;
              PAIR 4 ;
              SOME }
            { DROP 3 ; NONE (pair address (pair nat (pair (option address) nat))) } } }