Better Call Dev

FA2Ledger
​x
 
{ parameter (or
              (or
                (or
                  (or
                    (or
                      (pair %balance_of
                        (list %requests (pair (address %owner) (nat %token_id)))
                        (contract %callback (list (pair
                                                  (pair %request (address %owner)
                                                                 (nat %token_id))
                                                  (nat %balance)))))
                      (address %declare_ownership))
                    (or (unit %claim_ownership)
                        (pair %update_marketplace_fee (address %mpf_address)
                                                      (nat %mpf_bps))))
                  (or (or (unit %pause) (unit %unpause))
                      (or (pair %set_metadata (string %k) (option %d bytes))
                          (pair %set_token_metadata (nat %tid) (map %tdata string bytes)))))
                (or
                  (or
                    (or
                      (pair %mint (address %m_tokenOwner)
                                  (pair (nat %m_quantity)
                                        (pair (nat %m_maxSupply)
                                              (pair (map %m_tokenMetadata string bytes)
                                                    (list %m_royalties (pair
                                                                        (address %part_account)
                                                                        (nat %part_value)))))))
                      (pair %createToken (nat %ct_maxSupply)
                                         (pair (map %ct_tokenMetadata string bytes)
                                               (list %ct_royalties (pair
                                                                    (address %part_account)
                                                                    (nat %part_value))))))
                    (or
                      (pair %addClaimCondition (nat %acc_tokenId)
                                               (pair (nat %acc_maxPerTx)
                                                     (pair (nat %acc_claimCap)
                                                           (mutez %acc_price))))
                      (nat %removeClaimCondition)))
                  (or
                    (or (pair %claim (nat %c_tokenId) (nat %c_quantity))
                        (list %do_transfer (pair (address %from_)
                                                (list %txs (pair (address %to_)
                                                                (pair (nat %token_id)
                                                                      (nat %amount)))))))
                    (or
                      (list %transfer (pair (address %from_)
                                           (list %txs (pair (address %to_)
                                                           (pair (nat %token_id)
                                                                 (nat %amount))))))
                      (pair %burn (nat %b_tid) (nat %b_quantity))))))
              (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)))))) ;
  storage (pair (address %owner)
                (pair %defRoyalty (address %part_account) (nat %part_value))
                (pair %mpFee (address %mpf_address) (nat %mpf_bps))
                (option %owner_candidate address)
                (pair %mp_fee (address %mpf_address) (nat %mpf_bps))
                (bool %paused)
                (big_map %token_metadata nat
                                         (pair (nat %token_id)
                                               (map %token_info string bytes)))
                (nat %tokenIdCounter)
                (nat %totalSupply)
                (nat %totalActiveSupply)
                (big_map %claim_conditions nat
                                           (pair (nat %cc_maxPerTx) (nat %cc_claimCap)
                                                 (mutez %cc_price)
                                                 (nat %cc_claimed)))
                (big_map %ledger (pair address nat) nat)
                (big_map %supply nat (pair (nat %s_supply) (nat %s_maxSupply)))
                (big_map %royalties nat
                                    (list (pair (address %part_account) (nat %part_value))))
                (big_map %operator (pair address nat address) unit)
                (big_map %metadata string bytes)) ;
  code { LAMBDA
           (pair mutez nat)
           mutez
           { UNPAIR ;
             PUSH unit Unit ;
             DUP 2 ;
             PUSH nat 1 ;
             DUP 5 ;
             INT ;
             DIP 2
                  { PUSH mutez 1 ;
                    SWAP ;
                    EDIV ;
                    IF_NONE { PUSH string "DIV_BY_ZERO" ; FAILWITH } {} ;
                    CAR } ;
             ABS ;
             DIG 2 ;
             MUL ;
             EDIV ;
             IF_NONE { PUSH string "DIV_BY_ZERO" ; FAILWITH } {} ;
             CAR ;
             PUSH mutez 1 ;
             MUL ;
             PUSH mutez 1 ;
             PUSH nat 1 ;
             PUSH int 10000 ;
             DIP 2
                  { PUSH mutez 1 ;
                    SWAP ;
                    EDIV ;
                    IF_NONE { PUSH string "DIV_BY_ZERO" ; FAILWITH } {} ;
                    CAR } ;
             ABS ;
             DIG 2 ;
             MUL ;
             EDIV ;
             IF_NONE { PUSH string "DIV_BY_ZERO" ; FAILWITH } {} ;
             CAR ;
             PUSH mutez 1 ;
             MUL ;
             DUP ;
             PUSH mutez 1 ;
             SWAP ;
             EDIV ;
             IF_NONE { PUSH string "DIV_BY_ZERO" ; FAILWITH } {} ;
             CAR ;
             DUP 3 ;
             PUSH mutez 1 ;
             SWAP ;
             EDIV ;
             IF_NONE { PUSH string "DIV_BY_ZERO" ; FAILWITH } {} ;
             CAR ;
             INT ;
             PAIR ;
             PUSH mutez 1 ;
             DUP 2 ;
             UNPAIR ;
             DIP 2
                  { PUSH mutez 1 ;
                    SWAP ;
                    EDIV ;
                    IF_NONE { PUSH string "DIV_BY_ZERO" ; FAILWITH } {} ;
                    CAR } ;
             ABS ;
             DIG 2 ;
             MUL ;
             EDIV ;
             IF_NONE { PUSH string "DIV_BY_ZERO" ; FAILWITH } {} ;
             CAR ;
             PUSH mutez 1 ;
             MUL ;
             DUP ;
             DIP 1 { DIG 4 ; DROP 1 } ;
             DUG 4 ;
             DROP 4 ;
             DUG 2 ;
             DROP 2 } ;
         LAMBDA
           bool
           bool
           { PUSH unit Unit ;
             DUP 2 ;
             IF { PUSH string "CONTRACT_PAUSED" ; FAILWITH } {} ;
             PUSH bool True ;
             SWAP ;
             DROP 1 ;
             SWAP ;
             DROP 1 } ;
         LAMBDA
           (pair (big_map (pair address nat) nat)
                 (pair (address %owner) (nat %token_id)))
           nat
           { UNPAIR ;
             PUSH unit Unit ;
             DUP 2 ;
             DUP 4 ;
             GET 2 ;
             DUP 5 ;
             GET 1 ;
             PAIR ;
             GET ;
             IF_NONE { PUSH string "FA2_TOKEN_UNDEFINED" ; FAILWITH } {} ;
             DUP ;
             DIP 1 { SWAP ; DROP 1 } ;
             SWAP ;
             DROP 1 ;
             DUG 2 ;
             DROP 2 } ;
         LAMBDA
           (pair (big_map (pair address nat address) unit)
                 (list (pair (address %from_)
                            (list %txs (pair (address %to_)
                                            (pair (nat %token_id) (nat %amount)))))))
           bool
           { UNPAIR ;
             PUSH unit Unit ;
             PUSH bool True ;
             DUP 4 ;
             ITER { DUP ;
                    GET 1 ;
                    DUP 2 ;
                    GET 2 ;
                    DUP ;
                    ITER { DUP 5 ;
                           IF
                             { DUP 3 ;
                               SENDER ;
                               COMPARE ;
                               NEQ ;
                               IF
                                 { DUP 7 ; DUP 4 ; DUP 3 ; GET 2 ; GET 1 ; PAIR ; SENDER ; PAIR ; MEM }
                                 { PUSH bool True } ;
                               IF { PUSH bool True } { PUSH bool False } }
                             { PUSH bool False } ;
                           DIP 1 { DIG 4 ; DROP 1 } ;
                           DUG 4 ;
                           DROP 1 } ;
                    DROP 3 } ;
             DUP ;
             DIP 1 { SWAP ; DROP 1 } ;
             SWAP ;
             DROP 1 ;
             DUG 2 ;
             DROP 2 } ;
         NIL operation ;
         DIG 5 ;
         UNPAIR ;
         DIP 1 { UNPAIR 16 } ;
         IF_LEFT
           { IF_LEFT
               { IF_LEFT
                   { IF_LEFT
                       { IF_LEFT
                           { UNPAIR ;
                             NIL operation ;
                             NIL operation ;
                             DUP 21 ;
                             ITER { CONS } ;
                             DUP 4 ;
                             AMOUNT ;
                             DUP 5 ;
                             MAP { DUP 26 ; DUP 2 ; DUP 21 ; PAIR ; EXEC ; DUP 2 ; PAIR ; SWAP ; DROP 1 } ;
                             TRANSFER_TOKENS ;
                             CONS ;
                             ITER { CONS } ;
                             DIP 1 { DIG 18 ; DROP 1 } ;
                             DUG 18 ;
                             DROP 2 ;
                             PAIR 16 ;
                             SWAP ;
                             PAIR }
                           { DUP 2 ;
                             SENDER ;
                             COMPARE ;
                             EQ ;
                             NOT ;
                             IF { PUSH string "INVALID_CALLER" ; FAILWITH } {} ;
                             PUSH mutez 0 ;
                             AMOUNT ;
                             COMPARE ;
                             EQ ;
                             NOT ;
                             IF { PUSH string "NO_TRANSFER" ; FAILWITH } {} ;
                             DUP ;
                             SOME ;
                             DIP 1 { DIG 4 ; DROP 1 } ;
                             DUG 4 ;
                             DROP 1 ;
                             PAIR 16 ;
                             SWAP ;
                             PAIR } }
                       { IF_LEFT
                           { DROP 1 ;
                             PUSH mutez 0 ;
                             AMOUNT ;
                             COMPARE ;
                             EQ ;
                             NOT ;
                             IF { PUSH string "NO_TRANSFER" ; FAILWITH } {} ;
                             DUP 4 ;
                             IF_NONE
                               { PUSH bool False }
                               { SENDER ; DUP 2 ; COMPARE ; EQ ; SWAP ; DROP 1 } ;
                             NOT ;
                             IF { PUSH string "INVALID_CALLER" ; FAILWITH } {} ;
                             SENDER ;
                             SWAP ;
                             DROP 1 ;
                             NONE address ;
                             DIP 1 { DIG 3 ; DROP 1 } ;
                             DUG 3 ;
                             PAIR 16 ;
                             SWAP ;
                             PAIR }
                           { DUP 6 ;
                             GET 1 ;
                             SENDER ;
                             COMPARE ;
                             EQ ;
                             NOT ;
                             IF { PUSH string "INVALID_CALLER" ; FAILWITH } {} ;
                             PUSH mutez 0 ;
                             AMOUNT ;
                             COMPARE ;
                             EQ ;
                             NOT ;
                             IF { PUSH string "NO_TRANSFER" ; FAILWITH } {} ;
                             DUP ;
                             DIP 1 { DIG 5 ; DROP 1 } ;
                             DUG 5 ;
                             NIL operation ;
                             NIL operation ;
                             DUP 20 ;
                             ITER { CONS } ;
                             DUP 3 ;
                             GET 2 ;
                             DUP 4 ;
                             GET 1 ;
                             PAIR ;
                             EMIT %MP_FEE_UPDATED (pair (address %mpfu_address)
                                                        (nat %mpfu_bps)) ;
                             CONS ;
                             ITER { CONS } ;
                             DIP 1 { DIG 17 ; DROP 1 } ;
                             DUG 17 ;
                             DROP 1 ;
                             PAIR 16 ;
                             SWAP ;
                             PAIR } } }
                   { IF_LEFT
                       { IF_LEFT
                           { DROP 1 ;
                             DUP ;
                             SENDER ;
                             COMPARE ;
                             EQ ;
                             NOT ;
                             IF { PUSH string "INVALID_CALLER" ; FAILWITH } {} ;
                             PUSH mutez 0 ;
                             AMOUNT ;
                             COMPARE ;
                             EQ ;
                             NOT ;
                             IF { PUSH string "NO_TRANSFER" ; FAILWITH } {} ;
                             DUP 20 ;
                             DUP 7 ;
                             EXEC ;
                             NOT ;
                             IF
                               { PUSH string "pausable_r1" ;
                                 PUSH string "INVALID_CONDITION" ;
                                 PAIR ;
                                 FAILWITH }
                               {} ;
                             PUSH bool True ;
                             DIP 1 { DIG 5 ; DROP 1 } ;
                             DUG 5 ;
                             PAIR 16 ;
                             SWAP ;
                             PAIR }
                           { DROP 1 ;
                             DUP ;
                             SENDER ;
                             COMPARE ;
                             EQ ;
                             NOT ;
                             IF { PUSH string "INVALID_CALLER" ; FAILWITH } {} ;
                             PUSH mutez 0 ;
                             AMOUNT ;
                             COMPARE ;
                             EQ ;
                             NOT ;
                             IF { PUSH string "NO_TRANSFER" ; FAILWITH } {} ;
                             DUP 6 ;
                             NOT ;
                             IF { PUSH string "CONTRACT_NOT_PAUSED" ; FAILWITH } {} ;
                             PUSH bool False ;
                             DIP 1 { DIG 5 ; DROP 1 } ;
                             DUG 5 ;
                             PAIR 16 ;
                             SWAP ;
                             PAIR } }
                       { IF_LEFT
                           { UNPAIR ;
                             SWAP ;
                             DUP 3 ;
                             SENDER ;
                             COMPARE ;
                             EQ ;
                             NOT ;
                             IF { PUSH string "INVALID_CALLER" ; FAILWITH } {} ;
                             PUSH mutez 0 ;
                             AMOUNT ;
                             COMPARE ;
                             EQ ;
                             NOT ;
                             IF { PUSH string "NO_TRANSFER" ; FAILWITH } {} ;
                             DUP 22 ;
                             DUP 9 ;
                             EXEC ;
                             NOT ;
                             IF
                               { PUSH string "md_r1" ;
                                 PUSH string "INVALID_CONDITION" ;
                                 PAIR ;
                                 FAILWITH }
                               {} ;
                             DUP 18 ;
                             DUP 2 ;
                             DUP 4 ;
                             UPDATE ;
                             DIP 1 { DIG 17 ; DROP 1 } ;
                             DUG 17 ;
                             DROP 2 ;
                             PAIR 16 ;
                             SWAP ;
                             PAIR }
                           { UNPAIR ;
                             SWAP ;
                             DUP 3 ;
                             SENDER ;
                             COMPARE ;
                             EQ ;
                             NOT ;
                             IF { PUSH string "INVALID_CALLER" ; FAILWITH } {} ;
                             PUSH mutez 0 ;
                             AMOUNT ;
                             COMPARE ;
                             EQ ;
                             NOT ;
                             IF { PUSH string "NO_TRANSFER" ; FAILWITH } {} ;
                             DUP 22 ;
                             DUP 9 ;
                             EXEC ;
                             NOT ;
                             IF
                               { PUSH string "tmd_r1" ;
                                 PUSH string "INVALID_CONDITION" ;
                                 PAIR ;
                                 FAILWITH }
                               {} ;
                             DUP 9 ;
                             DUP 2 ;
                             DUP 4 ;
                             PAIR ;
                             SOME ;
                             DUP 4 ;
                             UPDATE ;
                             DIP 1 { DIG 8 ; DROP 1 } ;
                             DUG 8 ;
                             NIL operation ;
                             NIL operation ;
                             DUP 21 ;
                             ITER { CONS } ;
                             DUP 3 ;
                             SOME ;
                             DUP 5 ;
                             PAIR ;
                             EMIT %token_metadata_update (pair (nat %tmu_token_id)
                                                               (option %tmu_new_metadata (map
                                                                                          string
                                                                                          bytes))) ;
                             CONS ;
                             ITER { CONS } ;
                             DIP 1 { DIG 18 ; DROP 1 } ;
                             DUG 18 ;
                             DROP 2 ;
                             PAIR 16 ;
                             SWAP ;
                             PAIR } } } }
               { IF_LEFT
                   { IF_LEFT
                       { IF_LEFT
                           { UNPAIR ;
                             SWAP ;
                             UNPAIR ;
                             SWAP ;
                             UNPAIR ;
                             SWAP ;
                             UNPAIR ;
                             SWAP ;
                             DUP 6 ;
                             SENDER ;
                             COMPARE ;
                             EQ ;
                             NOT ;
                             IF { PUSH string "INVALID_CALLER" ; FAILWITH } {} ;
                             PUSH mutez 0 ;
                             AMOUNT ;
                             COMPARE ;
                             EQ ;
                             NOT ;
                             IF { PUSH string "NO_TRANSFER" ; FAILWITH } {} ;
                             DUP 25 ;
                             DUP 12 ;
                             EXEC ;
                             NOT ;
                             IF
                               { PUSH string "m_r1" ;
                                 PUSH string "INVALID_CONDITION" ;
                                 PAIR ;
                                 FAILWITH }
                               {} ;
                             PUSH nat 0 ;
                             DUP 5 ;
                             COMPARE ;
                             GT ;
                             NOT ;
                             IF { PUSH string "INVALID_QUANTITY" ; FAILWITH } {} ;
                             DUP 4 ;
                             DUP 4 ;
                             COMPARE ;
                             GE ;
                             NOT ;
                             IF { PUSH string "INVALID_MAX_SUPPLY" ; FAILWITH } {} ;
                             DUP 13 ;
                             DUP 5 ;
                             DUP 16 ;
                             ADD ;
                             DIP 1 { DIG 14 ; DROP 1 } ;
                             DUG 14 ;
                             DUP 5 ;
                             DUP 17 ;
                             ADD ;
                             DIP 1 { DIG 15 ; DROP 1 } ;
                             DUG 15 ;
                             PUSH nat 1 ;
                             DUP 15 ;
                             ADD ;
                             DIP 1 { DIG 13 ; DROP 1 } ;
                             DUG 13 ;
                             DUP 18 ;
                             DUP 2 ;
                             DUP 8 ;
                             PAIR ;
                             MEM ;
                             IF
                               { PUSH string "ledger" ;
                                 PUSH string "KEY_EXISTS" ;
                                 PAIR ;
                                 FAILWITH }
                               { DUP 18 ;
                                 DUP 6 ;
                                 SOME ;
                                 DUP 3 ;
                                 DUP 9 ;
                                 PAIR ;
                                 UPDATE ;
                                 DIP 1 { DIG 17 ; DROP 1 } ;
                                 DUG 17 } ;
                             DUP 19 ;
                             DUP 5 ;
                             DUP 7 ;
                             PAIR ;
                             SOME ;
                             DUP 3 ;
                             UPDATE ;
                             DIP 1 { DIG 18 ; DROP 1 } ;
                             DUG 18 ;
                             DUP 13 ;
                             DUP 4 ;
                             DUP 3 ;
                             PAIR ;
                             SOME ;
                             DUP 3 ;
                             UPDATE ;
                             DIP 1 { DIG 12 ; DROP 1 } ;
                             DUG 12 ;
                             PUSH nat 0 ;
                             DUP 3 ;
                             SIZE ;
                             COMPARE ;
                             GT ;
                             IF
                               { DUP 20 ;
                                 DUP 3 ;
                                 SOME ;
                                 DUP 3 ;
                                 UPDATE ;
                                 DIP 1 { DIG 19 ; DROP 1 } ;
                                 DUG 19 }
                               { DUP 20 ;
                                 NIL (pair (address %part_account) (nat %part_value)) ;
                                 DUP 10 ;
                                 CONS ;
                                 SOME ;
                                 DUP 3 ;
                                 UPDATE ;
                                 DIP 1 { DIG 19 ; DROP 1 } ;
                                 DUG 19 } ;
                             NIL operation ;
                             NIL operation ;
                             DUP 25 ;
                             ITER { CONS } ;
                             DUP 4 ;
                             DUP 6 ;
                             PAIR ;
                             DUP 7 ;
                             PAIR ;
                             DUP 8 ;
                             PAIR ;
                             DUP 9 ;
                             PAIR ;
                             DUP 4 ;
                             PAIR ;
                             EMIT %mint_event (pair (nat %me_token_id)
                                                    (address %me_owner)
                                                    (nat %me_quantity)
                                                    (nat %me_max_supply)
                                                    (map %me_tokenMetadata string bytes)
                                                    (list %me_royalties (pair
                                                                         (address %part_account)
                                                                         (nat %part_value)))) ;
                             CONS ;
                             ITER { CONS } ;
                             DIP 1 { DIG 22 ; DROP 1 } ;
                             DUG 22 ;
                             DROP 6 ;
                             PAIR 16 ;
                             SWAP ;
                             PAIR }
                           { UNPAIR ;
                             SWAP ;
                             UNPAIR ;
                             SWAP ;
                             DUP 4 ;
                             SENDER ;
                             COMPARE ;
                             EQ ;
                             NOT ;
                             IF { PUSH string "INVALID_CALLER" ; FAILWITH } {} ;
                             PUSH mutez 0 ;
                             AMOUNT ;
                             COMPARE ;
                             EQ ;
                             NOT ;
                             IF { PUSH string "NO_TRANSFER" ; FAILWITH } {} ;
                             DUP 23 ;
                             DUP 10 ;
                             EXEC ;
                             NOT ;
                             IF
                               { PUSH string "ct_r1" ;
                                 PUSH string "INVALID_CONDITION" ;
                                 PAIR ;
                                 FAILWITH }
                               {} ;
                             PUSH nat 0 ;
                             DUP 4 ;
                             COMPARE ;
                             GT ;
                             NOT ;
                             IF { PUSH string "INVALID_MAX_SUPPLY" ; FAILWITH } {} ;
                             DUP 11 ;
                             PUSH nat 1 ;
                             DUP 13 ;
                             ADD ;
                             DIP 1 { DIG 11 ; DROP 1 } ;
                             DUG 11 ;
                             DUP 17 ;
                             DUP 5 ;
                             PUSH nat 0 ;
                             PAIR ;
                             SOME ;
                             DUP 3 ;
                             UPDATE ;
                             DIP 1 { DIG 16 ; DROP 1 } ;
                             DUG 16 ;
                             DUP 11 ;
                             DUP 4 ;
                             DUP 3 ;
                             PAIR ;
                             SOME ;
                             DUP 3 ;
                             UPDATE ;
                             DIP 1 { DIG 10 ; DROP 1 } ;
                             DUG 10 ;
                             PUSH nat 0 ;
                             DUP 3 ;
                             SIZE ;
                             COMPARE ;
                             GT ;
                             IF
                               { DUP 18 ;
                                 DUP 3 ;
                                 SOME ;
                                 DUP 3 ;
                                 UPDATE ;
                                 DIP 1 { DIG 17 ; DROP 1 } ;
                                 DUG 17 }
                               { DUP 18 ;
                                 NIL (pair (address %part_account) (nat %part_value)) ;
                                 DUP 8 ;
                                 CONS ;
                                 SOME ;
                                 DUP 3 ;
                                 UPDATE ;
                                 DIP 1 { DIG 17 ; DROP 1 } ;
                                 DUG 17 } ;
                             NIL operation ;
                             NIL operation ;
                             DUP 23 ;
                             ITER { CONS } ;
                             DUP 4 ;
                             DUP 6 ;
                             PAIR ;
                             DUP 7 ;
                             PAIR ;
                             DUP 4 ;
                             PAIR ;
                             EMIT %new_token_event (pair (nat %nte_token_id)
                                                         (nat %nte_maxSupply)
                                                         (map %nte_tokenMetadata string
                                                                                 bytes)
                                                         (list %nte_royalties (pair
                                                                               (address %part_account)
                                                                               (nat %part_value)))) ;
                             CONS ;
                             ITER { CONS } ;
                             DIP 1 { DIG 20 ; DROP 1 } ;
                             DUG 20 ;
                             DROP 4 ;
                             PAIR 16 ;
                             SWAP ;
                             PAIR } }
                       { IF_LEFT
                           { UNPAIR ;
                             SWAP ;
                             UNPAIR ;
                             SWAP ;
                             UNPAIR ;
                             SWAP ;
                             DUP 5 ;
                             SENDER ;
                             COMPARE ;
                             EQ ;
                             NOT ;
                             IF { PUSH string "INVALID_CALLER" ; FAILWITH } {} ;
                             PUSH mutez 0 ;
                             AMOUNT ;
                             COMPARE ;
                             EQ ;
                             NOT ;
                             IF { PUSH string "NO_TRANSFER" ; FAILWITH } {} ;
                             DUP 24 ;
                             DUP 11 ;
                             EXEC ;
                             NOT ;
                             IF
                               { PUSH string "acc_r1" ;
                                 PUSH string "INVALID_CONDITION" ;
                                 PAIR ;
                                 FAILWITH }
                               {} ;
                             DUP 17 ;
                             DUP 5 ;
                             MEM ;
                             NOT ;
                             IF { PUSH string "FA2_TOKEN_UNDEFINED" ; FAILWITH } {} ;
                             DUP 15 ;
                             DUP 5 ;
                             MEM ;
                             IF
                               { PUSH string "CLAIM_CONDITION_ALREADY_EXIST" ; FAILWITH }
                               {} ;
                             PUSH nat 0 ;
                             DUP 4 ;
                             COMPARE ;
                             GT ;
                             NOT ;
                             IF { PUSH string "INVALID_MAX_PER_TX" ; FAILWITH } {} ;
                             DUP 17 ;
                             DUP 5 ;
                             GET ;
                             IF_NONE
                               { PUSH string "FA2_TOKEN_UNDEFINED" ; FAILWITH }
                               { DUP ;
                                 GET 1 ;
                                 INT ;
                                 DUP 2 ;
                                 GET 2 ;
                                 INT ;
                                 SUB ;
                                 PUSH int 0 ;
                                 DUP 2 ;
                                 COMPARE ;
                                 LE ;
                                 IF
                                   { PUSH bool True }
                                   { DUP ;
                                     DUP 5 ;
                                     INT ;
                                     COMPARE ;
                                     GT ;
                                     IF { PUSH bool True } { PUSH bool False } } ;
                                 IF
                                   { PUSH string "INSUFFICIENT_SUPPLY" ; FAILWITH }
                                   {} ;
                                 DROP 2 } ;
                             DUP 15 ;
                             PUSH nat 0 ;
                             DUP 3 ;
                             PAIR ;
                             DUP 4 ;
                             PAIR ;
                             DUP 5 ;
                             PAIR ;
                             SOME ;
                             DUP 6 ;
                             UPDATE ;
                             DIP 1 { DIG 14 ; DROP 1 } ;
                             DUG 14 ;
                             NIL operation ;
                             NIL operation ;
                             DUP 23 ;
                             ITER { CONS } ;
                             PUSH nat 0 ;
                             DUP 4 ;
                             PAIR ;
                             DUP 5 ;
                             PAIR ;
                             DUP 6 ;
                             PAIR ;
                             DUP 7 ;
                             PAIR ;
                             EMIT %new_claim_condition (pair (nat %ccu_token_id)
                                                             (nat %ccu_max_per_tx)
                                                             (nat %ccu_claim_cap)
                                                             (mutez %ccu_price)
                                                             (nat %ccu_claimed)) ;
                             CONS ;
                             ITER { CONS } ;
                             DIP 1 { DIG 20 ; DROP 1 } ;
                             DUG 20 ;
                             DROP 4 ;
                             PAIR 16 ;
                             SWAP ;
                             PAIR }
                           { DUP 2 ;
                             SENDER ;
                             COMPARE ;
                             EQ ;
                             NOT ;
                             IF { PUSH string "INVALID_CALLER" ; FAILWITH } {} ;
                             PUSH mutez 0 ;
                             AMOUNT ;
                             COMPARE ;
                             EQ ;
                             NOT ;
                             IF { PUSH string "NO_TRANSFER" ; FAILWITH } {} ;
                             DUP 21 ;
                             DUP 8 ;
                             EXEC ;
                             NOT ;
                             IF
                               { PUSH string "rcc_r1" ;
                                 PUSH string "INVALID_CONDITION" ;
                                 PAIR ;
                                 FAILWITH }
                               {} ;
                             DUP 12 ;
                             DUP 2 ;
                             GET ;
                             IF_NONE
                               { PUSH string "CLAIM_CONDITION_UNDEFINED" ; FAILWITH }
                               { PUSH nat 0 ;
                                 DUP 2 ;
                                 GET 6 ;
                                 COMPARE ;
                                 GT ;
                                 IF
                                   { PUSH string "CLAIM_CONDITION_IS_ACTIVE" ; FAILWITH }
                                   {} ;
                                 DROP 1 } ;
                             DUP 12 ;
                             NONE (pair nat nat mutez nat) ;
                             DUP 3 ;
                             UPDATE ;
                             DIP 1 { DIG 11 ; DROP 1 } ;
                             DUG 11 ;
                             NIL operation ;
                             NIL operation ;
                             DUP 20 ;
                             ITER { CONS } ;
                             DUP 3 ;
                             EMIT %claim_condition_removed nat ;
                             CONS ;
                             ITER { CONS } ;
                             DIP 1 { DIG 17 ; DROP 1 } ;
                             DUG 17 ;
                             DROP 1 ;
                             PAIR 16 ;
                             SWAP ;
                             PAIR } } }
                   { IF_LEFT
                       { IF_LEFT
                           { UNPAIR ;
                             SWAP ;
                             DUP 22 ;
                             DUP 9 ;
                             EXEC ;
                             NOT ;
                             IF
                               { PUSH string "c_r1" ;
                                 PUSH string "INVALID_CONDITION" ;
                                 PAIR ;
                                 FAILWITH }
                               {} ;
                             PUSH nat 0 ;
                             DUP 2 ;
                             COMPARE ;
                             GT ;
                             NOT ;
                             IF { PUSH string "INVALID_QUANTITY" ; FAILWITH } {} ;
                             DUP 15 ;
                             DUP 3 ;
                             GET ;
                             IF_NONE
                               { PUSH string "FA2_TOKEN_UNDEFINED" ; FAILWITH }
                               { DUP ;
                                 GET 2 ;
                                 DUP 2 ;
                                 GET 1 ;
                                 DUP ;
                                 INT ;
                                 DUP 3 ;
                                 INT ;
                                 SUB ;
                                 DUP 17 ;
                                 DUP 7 ;
                                 GET ;
                                 IF_NONE
                                   { PUSH string "CANT_CLAIM" ; FAILWITH }
                                   { DUP 6 ;
                                     DUP 2 ;
                                     GET 5 ;
                                     MUL ;
                                     AMOUNT ;
                                     COMPARE ;
                                     NEQ ;
                                     IF
                                       { PUSH string "INVALID_AMOUNT_TRANSFERRED" ;
                                         FAILWITH }
                                       {} ;
                                     DUP ;
                                     GET 3 ;
                                     DUP 7 ;
                                     DUP 3 ;
                                     GET 6 ;
                                     ADD ;
                                     COMPARE ;
                                     GT ;
                                     IF
                                       { PUSH string "CLAIM_CAP_REACHED" ; FAILWITH }
                                       {} ;
                                     PUSH int 0 ;
                                     DUP 3 ;
                                     COMPARE ;
                                     LE ;
                                     IF
                                       { PUSH bool True }
                                       { DUP 2 ;
                                         DUP 7 ;
                                         INT ;
                                         COMPARE ;
                                         GT ;
                                         IF { PUSH bool True } { PUSH bool False } } ;
                                     IF
                                       { PUSH string "INSUFFICIENT_SUPPLY" ; FAILWITH }
                                       {} ;
                                     DUP ;
                                     GET 1 ;
                                     DUP 7 ;
                                     COMPARE ;
                                     GT ;
                                     IF
                                       { PUSH string "MAX_QUANTITY_PER_TRANSACTION" ;
                                         FAILWITH }
                                       {} ;
                                     DUP 19 ;
                                     DUP 8 ;
                                     SENDER ;
                                     PAIR ;
                                     MEM ;
                                     IF
                                       { DUP 19 ;
                                         DUP 8 ;
                                         SENDER ;
                                         PAIR ;
                                         GET ;
                                         IF_NONE
                                           { PUSH string "ledger" ;
                                             PUSH string "ASSET_NOT_FOUND" ;
                                             PAIR ;
                                             FAILWITH }
                                           {} ;
                                         DUP 20 ;
                                         DUP 8 ;
                                         DUP 3 ;
                                         ADD ;
                                         SOME ;
                                         DUP 10 ;
                                         SENDER ;
                                         PAIR ;
                                         UPDATE ;
                                         DIP 1 { DIG 19 ; DROP 1 } ;
                                         DUG 19 ;
                                         DROP 1 }
                                       { DUP 19 ;
                                         DUP 7 ;
                                         PUSH nat 0 ;
                                         ADD ;
                                         SOME ;
                                         DUP 9 ;
                                         SENDER ;
                                         PAIR ;
                                         UPDATE ;
                                         DIP 1 { DIG 18 ; DROP 1 } ;
                                         DUG 18 } ;
                                     DUP 20 ;
                                     DUP 8 ;
                                     GET ;
                                     IF_NONE
                                       { PUSH string "supply" ;
                                         PUSH string "ASSET_NOT_FOUND" ;
                                         PAIR ;
                                         FAILWITH }
                                       {} ;
                                     DUP 21 ;
                                     DUP 22 ;
                                     DUP 10 ;
                                     GET ;
                                     IF_NONE
                                       { PUSH string "supply" ;
                                         PUSH string "ASSET_NOT_FOUND" ;
                                         PAIR ;
                                         FAILWITH }
                                       {} ;
                                     CDR ;
                                     DUP 9 ;
                                     DUP 4 ;
                                     GET 1 ;
                                     ADD ;
                                     PAIR ;
                                     SOME ;
                                     DUP 10 ;
                                     UPDATE ;
                                     DIP 1 { DIG 20 ; DROP 1 } ;
                                     DUG 20 ;
                                     DROP 1 ;
                                     DUP 6 ;
                                     DUP 18 ;
                                     ADD ;
                                     DIP 1 { DIG 16 ; DROP 1 } ;
                                     DUG 16 ;
                                     DUP 6 ;
                                     DUP 17 ;
                                     ADD ;
                                     DIP 1 { DIG 15 ; DROP 1 } ;
                                     DUG 15 ;
                                     AMOUNT ;
                                     AMOUNT ;
                                     DUP 30 ;
                                     DUP 15 ;
                                     GET 2 ;
                                     DUP 4 ;
                                     PAIR ;
                                     EXEC ;
                                     PUSH mutez 0 ;
                                     DUP 2 ;
                                     COMPARE ;
                                     GT ;
                                     IF
                                       { DUP ;
                                         DUP 4 ;
                                         SUB_MUTEZ ;
                                         IF_NONE
                                           { PUSH string "NAT_NEG_ASSIGN" ; FAILWITH }
                                           {} ;
                                         DIP 1 { SWAP ; DROP 1 } ;
                                         SWAP ;
                                         NIL operation ;
                                         NIL operation ;
                                         DUP 29 ;
                                         ITER { CONS } ;
                                         DUP 17 ;
                                         GET 1 ;
                                         CONTRACT unit ;
                                         IF_NONE
                                           { PUSH string "ENTRY_NOT_FOUND" ; FAILWITH }
                                           {} ;
                                         DUP 4 ;
                                         UNIT ;
                                         TRANSFER_TOKENS ;
                                         CONS ;
                                         ITER { CONS } ;
                                         DIP 1 { DIG 26 ; DROP 1 } ;
                                         DUG 26 }
                                       {} ;
                                     PUSH mutez 0 ;
                                     DUP 3 ;
                                     COMPARE ;
                                     GT ;
                                     IF
                                       { NIL operation ;
                                         NIL operation ;
                                         DUP 29 ;
                                         ITER { CONS } ;
                                         DUP 13 ;
                                         CONTRACT unit ;
                                         IF_NONE
                                           { PUSH string "ENTRY_NOT_FOUND" ; FAILWITH }
                                           {} ;
                                         DUP 5 ;
                                         UNIT ;
                                         TRANSFER_TOKENS ;
                                         CONS ;
                                         ITER { CONS } ;
                                         DIP 1 { DIG 26 ; DROP 1 } ;
                                         DUG 26 }
                                       {} ;
                                     NIL operation ;
                                     NIL operation ;
                                     DUP 29 ;
                                     ITER { CONS } ;
                                     AMOUNT ;
                                     DUP 12 ;
                                     PAIR ;
                                     DUP 13 ;
                                     PAIR ;
                                     SENDER ;
                                     PAIR ;
                                     EMIT %claimed_event (pair (address %ce_owner)
                                                               (nat %ce_token_id)
                                                               (nat %ce_amount)
                                                               (mutez %ce_price)) ;
                                     CONS ;
                                     ITER { CONS } ;
                                     DIP 1 { DIG 26 ; DROP 1 } ;
                                     DUG 26 ;
                                     DUP 4 ;
                                     GET 3 ;
                                     DUP 10 ;
                                     DUP 6 ;
                                     GET 6 ;
                                     ADD ;
                                     COMPARE ;
                                     EQ ;
                                     IF
                                       { DUP 21 ;
                                         NONE (pair nat nat mutez nat) ;
                                         DUP 12 ;
                                         UPDATE ;
                                         DIP 1 { DIG 20 ; DROP 1 } ;
                                         DUG 20 ;
                                         NIL operation ;
                                         NIL operation ;
                                         DUP 29 ;
                                         ITER { CONS } ;
                                         DUP 12 ;
                                         EMIT %claim_condition_removed nat ;
                                         CONS ;
                                         ITER { CONS } ;
                                         DIP 1 { DIG 26 ; DROP 1 } ;
                                         DUG 26 }
                                       { DUP 21 ;
                                         DUP 11 ;
                                         GET ;
                                         IF_NONE
                                           { PUSH string "claim_conditions" ;
                                             PUSH string "ASSET_NOT_FOUND" ;
                                             PAIR ;
                                             FAILWITH }
                                           {} ;
                                         DUP 22 ;
                                         DUP 23 ;
                                         DUP 13 ;
                                         GET ;
                                         IF_NONE
                                           { PUSH string "claim_conditions" ;
                                             PUSH string "ASSET_NOT_FOUND" ;
                                             PAIR ;
                                             FAILWITH }
                                           {} ;
                                         UNPAIR ;
                                         SWAP ;
                                         UNPAIR ;
                                         SWAP ;
                                         UNPAIR ;
                                         SWAP ;
                                         DROP 1 ;
                                         DUP 14 ;
                                         DUP 6 ;
                                         GET 6 ;
                                         ADD ;
                                         SWAP ;
                                         PAIR ;
                                         SWAP ;
                                         PAIR ;
                                         SWAP ;
                                         PAIR ;
                                         SOME ;
                                         DUP 13 ;
                                         UPDATE ;
                                         DIP 1 { DIG 21 ; DROP 1 } ;
                                         DUG 21 ;
                                         DROP 1 } ;
                                     DROP 4 } ;
                                 DROP 4 } ;
                             DROP 2 ;
                             PAIR 16 ;
                             SWAP ;
                             PAIR }
                           { SELF_ADDRESS ;
                             SENDER ;
                             COMPARE ;
                             EQ ;
                             NOT ;
                             IF { PUSH string "INVALID_CALLER" ; FAILWITH } {} ;
                             PUSH mutez 0 ;
                             AMOUNT ;
                             COMPARE ;
                             EQ ;
                             NOT ;
                             IF { PUSH string "NO_TRANSFER" ; FAILWITH } {} ;
                             DUP ;
                             ITER { DUP ;
                                    GET 1 ;
                                    DUP 2 ;
                                    GET 2 ;
                                    DUP ;
                                    ITER { DUP ;
                                           GET 2 ;
                                           GET 1 ;
                                           DUP 2 ;
                                           GET 2 ;
                                           GET 2 ;
                                           DUP 3 ;
                                           GET 1 ;
                                           GET 0 ;
                                           DUP 20 ;
                                           DUP 4 ;
                                           DUP 8 ;
                                           PAIR ;
                                           GET ;
                                           IF_NONE
                                             { PUSH string "FA2_TOKEN_UNDEFINED" ;
                                               FAILWITH }
                                             { DUP ;
                                               PUSH nat 0 ;
                                               DUP 5 ;
                                               COMPARE ;
                                               GT ;
                                               IF
                                                 { DUP ;
                                                   DUP 5 ;
                                                   COMPARE ;
                                                   GT ;
                                                   IF
                                                     { PUSH string "FA2_INSUFFICIENT_BALANCE" ;
                                                       FAILWITH }
                                                     {} ;
                                                   DUP 22 ;
                                                   DUP 6 ;
                                                   DUP 10 ;
                                                   PAIR ;
                                                   GET ;
                                                   IF_NONE
                                                     { PUSH string "ledger" ;
                                                       PUSH string "ASSET_NOT_FOUND" ;
                                                       PAIR ;
                                                       FAILWITH }
                                                     {} ;
                                                   DUP 23 ;
                                                   PUSH int 0 ;
                                                   DUP 7 ;
                                                   INT ;
                                                   DUP 4 ;
                                                   SUB ;
                                                   COMPARE ;
                                                   GE ;
                                                   IF
                                                     { DUP 6 ; INT ; DUP 3 ; SUB ; ABS }
                                                     { PUSH string "NAT_NEG_ASSIGN" ;
                                                       FAILWITH } ;
                                                   SOME ;
                                                   DUP 8 ;
                                                   DUP 12 ;
                                                   PAIR ;
                                                   UPDATE ;
                                                   DIP 1 { DIG 22 ; DROP 1 } ;
                                                   DUG 22 ;
                                                   DROP 1 ;
                                                   DUP 22 ;
                                                   DUP 6 ;
                                                   DUP 5 ;
                                                   PAIR ;
                                                   GET ;
                                                   IF_NONE
                                                     { DUP 22 ;
                                                       DUP 6 ;
                                                       DUP 5 ;
                                                       PAIR ;
                                                       MEM ;
                                                       IF
                                                         { PUSH string "ledger" ;
                                                           PUSH string "KEY_EXISTS" ;
                                                           PAIR ;
                                                           FAILWITH }
                                                         { DUP 22 ;
                                                           DUP 5 ;
                                                           SOME ;
                                                           DUP 7 ;
                                                           DUP 6 ;
                                                           PAIR ;
                                                           UPDATE ;
                                                           DIP 1 { DIG 21 ; DROP 1 } ;
                                                           DUG 21 } }
                                                     { DUP 23 ;
                                                       DUP 7 ;
                                                       DUP 6 ;
                                                       PAIR ;
                                                       GET ;
                                                       IF_NONE
                                                         { PUSH string "ledger" ;
                                                           PUSH string "ASSET_NOT_FOUND" ;
                                                           PAIR ;
                                                           FAILWITH }
                                                         {} ;
                                                       DUP 24 ;
                                                       DUP 7 ;
                                                       DUP 3 ;
                                                       ADD ;
                                                       SOME ;
                                                       DUP 9 ;
                                                       DUP 8 ;
                                                       PAIR ;
                                                       UPDATE ;
                                                       DIP 1 { DIG 23 ; DROP 1 } ;
                                                       DUG 23 ;
                                                       DROP 2 } ;
                                                   NIL operation ;
                                                   NIL operation ;
                                                   DUP 29 ;
                                                   ITER { CONS } ;
                                                   DUP 6 ;
                                                   DUP 8 ;
                                                   PAIR ;
                                                   DUP 6 ;
                                                   PAIR ;
                                                   DUP 11 ;
                                                   PAIR ;
                                                   EMIT %transfer_event (pair
                                                                          (address %te_from)
                                                                          (address %te_to)
                                                                          (nat %te_token_id)
                                                                          (nat %te_amount)) ;
                                                   CONS ;
                                                   ITER { CONS } ;
                                                   DIP 1 { DIG 26 ; DROP 1 } ;
                                                   DUG 26 }
                                                 {} ;
                                               DROP 2 } ;
                                           DROP 4 } ;
                                    DROP 3 } ;
                             DROP 1 ;
                             PAIR 16 ;
                             SWAP ;
                             PAIR } }
                       { IF_LEFT
                           { PUSH mutez 0 ;
                             AMOUNT ;
                             COMPARE ;
                             EQ ;
                             NOT ;
                             IF { PUSH string "NO_TRANSFER" ; FAILWITH } {} ;
                             DUP 21 ;
                             DUP 8 ;
                             EXEC ;
                             NOT ;
                             IF
                               { PUSH string "fa2_r4" ;
                                 PUSH string "INVALID_CONDITION" ;
                                 PAIR ;
                                 FAILWITH }
                               {} ;
                             DUP 19 ;
                             DUP 2 ;
                             DUP 18 ;
                             PAIR ;
                             EXEC ;
                             NOT ;
                             IF { PUSH string "FA2_NOT_OPERATOR" ; FAILWITH } {} ;
                             NIL operation ;
                             NIL operation ;
                             DUP 20 ;
                             ITER { CONS } ;
                             SELF_ADDRESS ;
                             CONTRACT %do_transfer (list (pair address
                                                              (list (pair address
                                                                         (pair nat nat))))) ;
                             IF_NONE
                               { PUSH string "do_transfer" ;
                                 PUSH string "ENTRY_NOT_FOUND" ;
                                 PAIR ;
                                 FAILWITH }
                               {} ;
                             PUSH mutez 0 ;
                             DUP 5 ;
                             TRANSFER_TOKENS ;
                             CONS ;
                             ITER { CONS } ;
                             DIP 1 { DIG 17 ; DROP 1 } ;
                             DUG 17 ;
                             DROP 1 ;
                             PAIR 16 ;
                             SWAP ;
                             PAIR }
                           { UNPAIR ;
                             SWAP ;
                             PUSH mutez 0 ;
                             AMOUNT ;
                             COMPARE ;
                             EQ ;
                             NOT ;
                             IF { PUSH string "NO_TRANSFER" ; FAILWITH } {} ;
                             DUP 14 ;
                             DUP 3 ;
                             SENDER ;
                             PAIR ;
                             MEM ;
                             NOT ;
                             IF { PUSH string "FA2_TOKEN_UNDEFINED" ; FAILWITH } {} ;
                             DUP 22 ;
                             DUP 9 ;
                             EXEC ;
                             NOT ;
                             IF { PUSH string "CONTRACT_PAUSED" ; FAILWITH } {} ;
                             DUP 14 ;
                             DUP 3 ;
                             SENDER ;
                             PAIR ;
                             GET ;
                             IF_NONE
                               { PUSH string "ledger" ;
                                 PUSH string "ASSET_NOT_FOUND" ;
                                 PAIR ;
                                 FAILWITH }
                               {} ;
                             DUP 2 ;
                             DUP 2 ;
                             COMPARE ;
                             LT ;
                             IF
                               { PUSH string "FA2_INSUFFICIENT_BALANCE" ; FAILWITH }
                               {} ;
                             DUP 2 ;
                             INT ;
                             DUP 2 ;
                             INT ;
                             SUB ;
                             ISNAT ;
                             IF_NONE
                               { PUSH string "FA2_INSUFFICIENT_BALANCE" ; FAILWITH }
                               { PUSH nat 0 ;
                                 DUP 2 ;
                                 COMPARE ;
                                 EQ ;
                                 IF
                                   { DUP 16 ;
                                     NONE nat ;
                                     DUP 6 ;
                                     SENDER ;
                                     PAIR ;
                                     UPDATE ;
                                     DIP 1 { DIG 15 ; DROP 1 } ;
                                     DUG 15 }
                                   { DUP 16 ;
                                     DUP 2 ;
                                     SOME ;
                                     DUP 6 ;
                                     SENDER ;
                                     PAIR ;
                                     UPDATE ;
                                     DIP 1 { DIG 15 ; DROP 1 } ;
                                     DUG 15 } ;
                                 DROP 1 } ;
                             PUSH int 0 ;
                             DUP 3 ;
                             INT ;
                             DUP 15 ;
                             SUB ;
                             COMPARE ;
                             GE ;
                             IF
                               { DUP 2 ; INT ; DUP 14 ; SUB ; ABS }
                               { PUSH string "NAT_NEG_ASSIGN" ; FAILWITH } ;
                             DIP 1 { DIG 12 ; DROP 1 } ;
                             DUG 12 ;
                             NIL operation ;
                             NIL operation ;
                             DUP 22 ;
                             ITER { CONS } ;
                             SENDER ;
                             DUP 5 ;
                             PAIR ;
                             DUP 6 ;
                             PAIR ;
                             EMIT %burn_event (pair (nat %brn_token_id)
                                                    (nat %brn_quantity)
                                                    (address %brn_owner)) ;
                             CONS ;
                             ITER { CONS } ;
                             DIP 1 { DIG 19 ; DROP 1 } ;
                             DUG 19 ;
                             DROP 3 ;
                             PAIR 16 ;
                             SWAP ;
                             PAIR } } } } }
           { PUSH mutez 0 ;
             AMOUNT ;
             COMPARE ;
             EQ ;
             NOT ;
             IF { PUSH string "NO_TRANSFER" ; FAILWITH } {} ;
             DUP 21 ;
             DUP 8 ;
             EXEC ;
             NOT ;
             IF
               { PUSH string "fa2_r1" ; PUSH string "INVALID_CONDITION" ; PAIR ; FAILWITH }
               {} ;
             DUP ;
             ITER { DUP ;
                    IF_LEFT
                      { SENDER ;
                        DUP 2 ;
                        GET 1 ;
                        GET 0 ;
                        COMPARE ;
                        EQ ;
                        NOT ;
                        IF { PUSH string "FA2_NOT_OWNER" ; FAILWITH } {} ;
                        DUP 18 ;
                        PUSH unit Unit ;
                        SOME ;
                        DUP 3 ;
                        GET 1 ;
                        GET 0 ;
                        DUP 4 ;
                        GET 2 ;
                        GET 2 ;
                        PAIR ;
                        DUP 4 ;
                        GET 2 ;
                        GET 1 ;
                        PAIR ;
                        UPDATE ;
                        DIP 1 { DIG 17 ; DROP 1 } ;
                        DUG 17 ;
                        NIL operation ;
                        NIL operation ;
                        DUP 22 ;
                        ITER { CONS } ;
                        PUSH bool True ;
                        DUP 4 ;
                        GET 2 ;
                        GET 2 ;
                        PAIR ;
                        DUP 4 ;
                        GET 2 ;
                        GET 1 ;
                        PAIR ;
                        DUP 4 ;
                        GET 1 ;
                        GET 0 ;
                        PAIR ;
                        EMIT %operator_update (pair (address %ou_owner)
                                                    (address %ou_operator)
                                                    (nat %ou_token_id)
                                                    (bool %ou_is_operator)) ;
                        CONS ;
                        ITER { CONS } ;
                        DIP 1 { DIG 19 ; DROP 1 } ;
                        DUG 19 ;
                        DROP 1 }
                      { SENDER ;
                        DUP 2 ;
                        GET 1 ;
                        GET 0 ;
                        COMPARE ;
                        EQ ;
                        NOT ;
                        IF { PUSH string "FA2_NOT_OWNER" ; FAILWITH } {} ;
                        DUP 18 ;
                        NONE unit ;
                        DUP 3 ;
                        GET 1 ;
                        GET 0 ;
                        DUP 4 ;
                        GET 2 ;
                        GET 2 ;
                        PAIR ;
                        DUP 4 ;
                        GET 2 ;
                        GET 1 ;
                        PAIR ;
                        UPDATE ;
                        DIP 1 { DIG 17 ; DROP 1 } ;
                        DUG 17 ;
                        NIL operation ;
                        NIL operation ;
                        DUP 22 ;
                        ITER { CONS } ;
                        PUSH bool False ;
                        DUP 4 ;
                        GET 2 ;
                        GET 2 ;
                        PAIR ;
                        DUP 4 ;
                        GET 2 ;
                        GET 1 ;
                        PAIR ;
                        DUP 4 ;
                        GET 1 ;
                        GET 0 ;
                        PAIR ;
                        EMIT %operator_update (pair (address %ou_owner)
                                                    (address %ou_operator)
                                                    (nat %ou_token_id)
                                                    (bool %ou_is_operator)) ;
                        CONS ;
                        ITER { CONS } ;
                        DIP 1 { DIG 19 ; DROP 1 } ;
                        DUG 19 ;
                        DROP 1 } ;
                    DROP 1 } ;
             DROP 1 ;
             PAIR 16 ;
             SWAP ;
             PAIR } ;
         DIP 1 { DROP 4 } } ;
  view "get_royalties" nat (list (pair (address %part_account) (nat %part_value)))
        { UNPAIR ;
          DIP 1
               { CDR ; CDR ; CDR ; CDR ; CDR ; CDR ; CDR ; CDR ; CDR ; CDR ; CDR ; CDR ; CDR ; UNPAIR ; SWAP ; DROP 1 } ;
          UNIT ;
          DUP 3 ;
          DUP 3 ;
          GET ;
          IF_NONE { NIL (pair (address %part_account) (nat %part_value)) } {} ;
          SWAP ;
          DROP 1 ;
          DIP 1 { DROP 2 } } ;
  view "get_balance" (pair nat address) nat
        { UNPAIR ;
          DIP 1
               { CDR ; CDR ; CDR ; CDR ; CDR ; CDR ; CDR ; CDR ; CDR ; CDR ; CDR ; UNPAIR ; SWAP ; DROP 1 } ;
          UNPAIR ;
          UNIT ;
          PUSH nat 0 ;
          DUP 5 ;
          DUP 4 ;
          DUP 6 ;
          PAIR ;
          GET ;
          IF_NONE {} { DUP ; DIP 1 { SWAP ; DROP 1 } ; SWAP ; DROP 1 } ;
          DUP ;
          DIP 1 { SWAP ; DROP 1 } ;
          SWAP ;
          DROP 1 ;
          DIP 1 { DROP 3 } } ;
  view "is_operator" (pair address address nat) bool
        { UNPAIR ;
          DIP 1
               { CDR ; CDR ; CDR ; CDR ; CDR ; CDR ; CDR ; CDR ; CDR ; CDR ; CDR ; CDR ; CDR ; CDR ; UNPAIR ; SWAP ; DROP 1 } ;
          UNPAIR 3 ;
          UNIT ;
          DUP 5 ;
          DUP 3 ;
          DUP 6 ;
          PAIR ;
          DUP 5 ;
          PAIR ;
          MEM ;
          SWAP ;
          DROP 1 ;
          DIP 1 { DROP 4 } } }