parameter (pair %deploy_contract (option %admin address) (bytes %metadata));

storage (pair (big_map %metadata string bytes)

              (big_map %minted_collections address unit));

code { UNPAIR ;

       SENDER ;

       SWAP ;

       DUP ;

       DUG 2 ;

       CAR ;

       IF_NONE {} { DROP 2 ; DUP ; CAR ; IF_NONE { PUSH int 523 ; FAILWITH } {} } ;

       NIL operation ;

       EMPTY_BIG_MAP nat (pair nat (map string bytes)) ;

       EMPTY_BIG_MAP nat nat ;

       PAIR ;

       EMPTY_BIG_MAP (pair address (pair address nat)) unit ;

       PAIR ;

       EMPTY_BIG_MAP string bytes ;

       DIG 4 ;

       CDR ;

       SOME ;

       PUSH string "" ;

       UPDATE ;

       EMPTY_BIG_MAP address unit ;

       PAIR ;

       EMPTY_BIG_MAP nat (pair bool bool) ;

       PAIR ;

       PAIR ;

       EMPTY_BIG_MAP (pair address nat) nat ;

       PUSH nat 0 ;

       PAIR ;

       EMPTY_BIG_MAP nat

                      (pair

                        (pair (pair nat (list (map address (map (option nat) nat))))

                              (pair (option (pair address bytes)) timestamp))

                        (pair (pair nat mutez)

                              (pair (pair (map address nat) nat) timestamp))) ;

       PAIR ;

       EMPTY_BIG_MAP (pair address nat) nat ;

       DIG 4 ;

       PAIR ;

       PAIR ;

       PAIR ;

       PUSH mutez 0 ;

       NONE key_hash ;

       CREATE_CONTRACT { parameter (or

                                     (or

                                       (or (address %add_manager)

                                           (or

                                             (map %airdrop nat

                                                           (list (pair (nat %amount)

                                                                      (address %recipient))))

                                             (pair %balance_of

                                               (list %requests (pair (address %owner)

                                                                    (nat %token_id)))

                                               (contract %callback (list (pair

                                                                         (pair %request

                                                                           (address %owner)

                                                                           (nat %token_id))

                                                                         (nat %balance)))))))

                                       (or

                                         (or

                                           (list %burn (pair (address %from_)

                                                            (pair (nat %token_id)

                                                                  (nat %amount))))

                                           (pair %claim

                                             (pair (nat %amount)

                                                   (list %burn_tokens (pair

                                                                       (address %address)

                                                                       (nat %token_id))))

                                             (pair (option %condition_extra bytes)

                                                   (pair (option %proxy_for address)

                                                         (nat %token_id)))))

                                         (or

                                           (pair %create_claim (nat %token_id)

                                                               (pair

                                                                 (timestamp %start_time)

                                                                 (pair

                                                                   (timestamp %end_time)

                                                                   (pair (mutez %price)

                                                                         (pair

                                                                           (list %burn_recipe (map

                                                                                               address

                                                                                               (map

                                                                                                 (option nat)

                                                                                                 nat)))

                                                                           (pair

                                                                             (nat %max_per_wallet)

                                                                             (pair

                                                                               (nat %airdrop_capacity)

                                                                               (pair

                                                                                 (pair %split

                                                                                   (map %shares

                                                                                     address

                                                                                     nat)

                                                                                   (nat %total))

                                                                                 (option %condition (pair

                                                                                                     (address %address)

                                                                                                     (bytes %id)))))))))))

                                           (map %create_token string bytes))))

                                     (or

                                       (or

                                         (or

                                           (pair %lock (bool %metadata)

                                                       (pair (bool %mint)

                                                             (nat %token_id)))

                                           (pair %mint

                                             (list %mint_items (pair (nat %amount)

                                                                    (address %to_)))

                                             (nat %token_id)))

                                         (or (address %remove_manager)

                                             (address %set_administrator)))

                                       (or

                                         (or (big_map %set_metadata string bytes)

                                             (list %transfer (pair (address %from_)

                                                                  (list %txs (pair

                                                                              (address %to_)

                                                                              (pair

                                                                                (nat %token_id)

                                                                                (nat %amount)))))))

                                         (or

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

                                           (list %update_token_metadata (pair

                                                                         (nat %token_id)

                                                                         (map %token_info

                                                                           string

                                                                           bytes))))))) ;

                         storage (pair

                                   (pair

                                     (pair (address %administrator)

                                           (big_map %claimed (pair address nat) nat))

                                     (pair

                                       (big_map %claims nat

                                                        (pair

                                                          (pair

                                                            (pair

                                                              (nat %airdrop_capacity)

                                                              (list %burn_recipe (map

                                                                                  address

                                                                                  (map

                                                                                    (option nat)

                                                                                    nat))))

                                                            (pair

                                                              (option %condition (pair

                                                                                  (address %address)

                                                                                  (bytes %id)))

                                                              (timestamp %end_time)))

                                                          (pair

                                                            (pair (nat %max_per_wallet)

                                                                  (mutez %price))

                                                            (pair

                                                              (pair %split

                                                                (map %shares address nat)

                                                                (nat %total))

                                                              (timestamp %start_time)))))

                                       (pair (nat %last_token_id)

                                             (big_map %ledger (pair address nat) nat))))

                                   (pair

                                     (pair

                                       (big_map %locked nat

                                                        (pair (bool %metadata)

                                                              (bool %mint)))

                                       (pair (big_map %managers address unit)

                                             (big_map %metadata string bytes)))

                                     (pair

                                       (big_map %operators

                                         (pair (address %owner)

                                               (pair (address %operator) (nat %token_id)))

                                         unit)

                                       (pair (big_map %supply nat nat)

                                             (big_map %token_metadata nat

                                                                      (pair

                                                                        (nat %token_id)

                                                                        (map %token_info

                                                                          string

                                                                          bytes))))))) ;

                         code { UNPAIR ;

                                IF_LEFT

                                  { IF_LEFT

                                      { IF_LEFT

                                          { SWAP ;

                                            DUP ;

                                            DUG 2 ;

                                            CAR ;

                                            CAR ;

                                            CAR ;

                                            SENDER ;

                                            COMPARE ;

                                            EQ ;

                                            IF

                                              {}

                                              { PUSH string "FA2_NOT_ADMIN" ; FAILWITH } ;

                                            SWAP ;

                                            UNPAIR ;

                                            SWAP ;

                                            UNPAIR ;

                                            UNPAIR ;

                                            SWAP ;

                                            UNPAIR ;

                                            PUSH (option unit) (Some Unit) ;

                                            DIG 6 ;

                                            UPDATE ;

                                            PAIR ;

                                            SWAP ;

                                            PAIR ;

                                            PAIR ;

                                            SWAP ;

                                            PAIR ;

                                            NIL operation }

                                          { IF_LEFT

                                              { SWAP ;

                                                DUP ;

                                                DUG 2 ;

                                                CAR ;

                                                CAR ;

                                                CAR ;

                                                SENDER ;

                                                COMPARE ;

                                                EQ ;

                                                IF

                                                  { PUSH bool True }

                                                  { SWAP ; DUP ; DUG 2 ; GET 3 ; GET 3 ; SENDER ; MEM } ;

                                                IF

                                                  {}

                                                  { PUSH string "FA2_NOT_MANAGER" ;

                                                    FAILWITH } ;

                                                DUP ;

                                                ITER { DUP 3 ;

                                                       CAR ;

                                                       GET 3 ;

                                                       SWAP ;

                                                       DUP ;

                                                       DUG 2 ;

                                                       CAR ;

                                                       MEM ;

                                                       IF

                                                         {}

                                                         { PUSH string "OE_NO_SALE" ;

                                                           FAILWITH } ;

                                                       DUP ;

                                                       CDR ;

                                                       ITER { DUP 4 ;

                                                              CAR ;

                                                              GET 3 ;

                                                              DUP 3 ;

                                                              CAR ;

                                                              GET ;

                                                              IF_NONE

                                                                { PUSH int 420 ;

                                                                  FAILWITH }

                                                                {} ;

                                                              CAR ;

                                                              CAR ;

                                                              CAR ;

                                                              DUP 3 ;

                                                              CAR ;

                                                              DUP 3 ;

                                                              CDR ;

                                                              PAIR ;

                                                              DUP 6 ;

                                                              UNPAIR ;

                                                              UNPAIR ;

                                                              SWAP ;

                                                              UNPAIR ;

                                                              SWAP ;

                                                              UNPAIR ;

                                                              SWAP ;

                                                              DUP 8 ;

                                                              CAR ;

                                                              DIG 11 ;

                                                              CAR ;

                                                              GET 6 ;

                                                              DUP 8 ;

                                                              GET ;

                                                              IF_NONE

                                                                { PUSH nat 0 }

                                                                {} ;

                                                              ADD ;

                                                              SOME ;

                                                              DIG 6 ;

                                                              UPDATE ;

                                                              SWAP ;

                                                              PAIR ;

                                                              SWAP ;

                                                              PAIR ;

                                                              SWAP ;

                                                              PAIR ;

                                                              PAIR ;

                                                              DUP ;

                                                              GET 7 ;

                                                              DUP ;

                                                              DUP 6 ;

                                                              CAR ;

                                                              DUP ;

                                                              DUG 2 ;

                                                              GET ;

                                                              IF_NONE

                                                                { PUSH int 426 ;

                                                                  FAILWITH }

                                                                {} ;

                                                              DUP 6 ;

                                                              CAR ;

                                                              ADD ;

                                                              SOME ;

                                                              SWAP ;

                                                              UPDATE ;

                                                              UPDATE 7 ;

                                                              UNPAIR ;

                                                              UNPAIR ;

                                                              SWAP ;

                                                              UNPAIR ;

                                                              DUP ;

                                                              DUP 8 ;

                                                              CAR ;

                                                              DUP ;

                                                              DUG 2 ;

                                                              GET ;

                                                              IF_NONE

                                                                { PUSH int 427 ;

                                                                  FAILWITH }

                                                                {} ;

                                                              UNPAIR ;

                                                              UNPAIR ;

                                                              CDR ;

                                                              DIG 9 ;

                                                              CAR ;

                                                              DIG 9 ;

                                                              SUB ;

                                                              ISNAT ;

                                                              IF_NONE

                                                                { PUSH string "OE_AIRDROP_CAP_REACHED" ;

                                                                  FAILWITH }

                                                                {} ;

                                                              PAIR ;

                                                              PAIR ;

                                                              PAIR ;

                                                              SOME ;

                                                              SWAP ;

                                                              UPDATE ;

                                                              PAIR ;

                                                              SWAP ;

                                                              PAIR ;

                                                              PAIR ;

                                                              DUG 2 } ;

                                                       DROP } ;

                                                DROP ;

                                                NIL operation }

                                              { NIL operation ;

                                                DUP ;

                                                DUP 3 ;

                                                CDR ;

                                                PUSH mutez 0 ;

                                                DUP 5 ;

                                                CAR ;

                                                MAP { DUP 7 ;

                                                      GET 8 ;

                                                      SWAP ;

                                                      DUP ;

                                                      DUG 2 ;

                                                      CDR ;

                                                      MEM ;

                                                      IF

                                                        {}

                                                        { PUSH string "FA2_TOKEN_UNDEFINED" ;

                                                          FAILWITH } ;

                                                      DUP 7 ;

                                                      CAR ;

                                                      GET 6 ;

                                                      SWAP ;

                                                      DUP ;

                                                      CDR ;

                                                      SWAP ;

                                                      DUP ;

                                                      DUG 3 ;

                                                      CAR ;

                                                      PAIR ;

                                                      GET ;

                                                      IF_NONE { PUSH nat 0 } {} ;

                                                      SWAP ;

                                                      PAIR } ;

                                                DIG 4 ;

                                                DROP ;

                                                DIG 4 ;

                                                DROP ;

                                                TRANSFER_TOKENS ;

                                                CONS } } }

                                      { IF_LEFT

                                          { IF_LEFT

                                              { DUP ;

                                                ITER { DUP 3 ;

                                                       GET 8 ;

                                                       SWAP ;

                                                       DUP ;

                                                       DUG 2 ;

                                                       GET 3 ;

                                                       MEM ;

                                                       IF

                                                         {}

                                                         { PUSH string "FA2_TOKEN_UNDEFINED" ;

                                                           FAILWITH } ;

                                                       DUP ;

                                                       CAR ;

                                                       SENDER ;

                                                       COMPARE ;

                                                       EQ ;

                                                       IF

                                                         { PUSH bool True }

                                                         { DUP 3 ;

                                                           GET 5 ;

                                                           SWAP ;

                                                           DUP ;

                                                           DUG 2 ;

                                                           GET 3 ;

                                                           SENDER ;

                                                           DUP 4 ;

                                                           CAR ;

                                                           PAIR 3 ;

                                                           MEM } ;

                                                       IF

                                                         {}

                                                         { PUSH string "FA2_NOT_OPERATOR" ;

                                                           FAILWITH } ;

                                                       DUP 3 ;

                                                       UNPAIR ;

                                                       UNPAIR ;

                                                       SWAP ;

                                                       UNPAIR ;

                                                       SWAP ;

                                                       UNPAIR ;

                                                       SWAP ;

                                                       DUP 6 ;

                                                       GET 4 ;

                                                       DIG 8 ;

                                                       CAR ;

                                                       GET 6 ;

                                                       DIG 7 ;

                                                       DUP ;

                                                       GET 3 ;

                                                       SWAP ;

                                                       DUP ;

                                                       DUG 9 ;

                                                       CAR ;

                                                       PAIR ;

                                                       GET ;

                                                       IF_NONE { PUSH nat 0 } {} ;

                                                       SUB ;

                                                       ISNAT ;

                                                       IF_NONE

                                                         { PUSH string "FA2_INSUFFICIENT_BALANCE" ;

                                                           FAILWITH }

                                                         {} ;

                                                       SOME ;

                                                       DIG 6 ;

                                                       DUP ;

                                                       GET 3 ;

                                                       SWAP ;

                                                       DUP ;

                                                       DUG 8 ;

                                                       CAR ;

                                                       PAIR ;

                                                       UPDATE ;

                                                       SWAP ;

                                                       PAIR ;

                                                       SWAP ;

                                                       PAIR ;

                                                       SWAP ;

                                                       PAIR ;

                                                       PAIR ;

                                                       DUG 2 ;

                                                       DUP ;

                                                       GET 4 ;

                                                       DUP 4 ;

                                                       GET 7 ;

                                                       DUP 3 ;

                                                       GET 3 ;

                                                       GET ;

                                                       IF_NONE { PUSH nat 0 } {} ;

                                                       SUB ;

                                                       ISNAT ;

                                                       IF_NONE

                                                         { DIG 2 ;

                                                           DUP ;

                                                           GET 7 ;

                                                           PUSH (option nat) (Some 0) ;

                                                           DIG 3 ;

                                                           GET 3 ;

                                                           UPDATE ;

                                                           UPDATE 7 ;

                                                           SWAP }

                                                         { DIG 3 ;

                                                           DUP ;

                                                           GET 7 ;

                                                           DIG 2 ;

                                                           SOME ;

                                                           DIG 3 ;

                                                           GET 3 ;

                                                           UPDATE ;

                                                           UPDATE 7 ;

                                                           SWAP } } ;

                                                DROP ;

                                                NIL operation }

                                              { SWAP ;

                                                DUP ;

                                                DUG 2 ;

                                                CAR ;

                                                GET 3 ;

                                                SWAP ;

                                                DUP ;

                                                DUG 2 ;

                                                GET 6 ;

                                                MEM ;

                                                IF

                                                  {}

                                                  { PUSH string "OE_NO_SALE_ACTIVE" ;

                                                    FAILWITH } ;

                                                SWAP ;

                                                DUP ;

                                                DUG 2 ;

                                                CAR ;

                                                GET 3 ;

                                                SWAP ;

                                                DUP ;

                                                DUG 2 ;

                                                GET 6 ;

                                                GET ;

                                                IF_NONE { PUSH int 236 ; FAILWITH } {} ;

                                                DUP ;

                                                GET 6 ;

                                                NOW ;

                                                COMPARE ;

                                                GE ;

                                                IF

                                                  { DUP ; CAR ; GET 4 ; NOW ; COMPARE ; LE }

                                                  { PUSH bool False } ;

                                                IF

                                                  {}

                                                  { PUSH string "OE_NOT_IN_SALE_TIME" ;

                                                    FAILWITH } ;

                                                SENDER ;

                                                DUP 3 ;

                                                GET 5 ;

                                                IF_NONE {} { SWAP ; DROP } ;

                                                DUP 3 ;

                                                GET 6 ;

                                                SWAP ;

                                                DUP ;

                                                DUG 2 ;

                                                PAIR ;

                                                PUSH nat 0 ;

                                                DUP 5 ;

                                                CAR ;

                                                CAR ;

                                                COMPARE ;

                                                GT ;

                                                IF

                                                  {}

                                                  { PUSH string "OE_WRONG_AMOUNT" ;

                                                    FAILWITH } ;

                                                PUSH nat 0 ;

                                                DUP 4 ;

                                                GET 3 ;

                                                CAR ;

                                                COMPARE ;

                                                GT ;

                                                IF

                                                  { DUP 5 ;

                                                    CAR ;

                                                    CAR ;

                                                    CDR ;

                                                    SWAP ;

                                                    DUP ;

                                                    DUG 2 ;

                                                    GET ;

                                                    IF_NONE { PUSH nat 0 } {} ;

                                                    DUP 4 ;

                                                    GET 3 ;

                                                    CAR ;

                                                    SUB ;

                                                    ISNAT ;

                                                    IF_NONE

                                                      { PUSH int 261 ; FAILWITH }

                                                      {} ;

                                                    DUP 5 ;

                                                    CAR ;

                                                    CAR ;

                                                    COMPARE ;

                                                    LE ;

                                                    IF

                                                      {}

                                                      { PUSH string "OE_MAX_REACHED" ;

                                                        FAILWITH } }

                                                  {} ;

                                                DUP 5 ;

                                                UNPAIR ;

                                                UNPAIR ;

                                                UNPAIR ;

                                                SWAP ;

                                                DUP 8 ;

                                                CAR ;

                                                CAR ;

                                                DIG 9 ;

                                                CAR ;

                                                CAR ;

                                                CDR ;

                                                DUP 7 ;

                                                GET ;

                                                IF_NONE { PUSH nat 0 } {} ;

                                                ADD ;

                                                SOME ;

                                                DUP 6 ;

                                                UPDATE ;

                                                SWAP ;

                                                PAIR ;

                                                PAIR ;

                                                PAIR ;

                                                DUG 4 ;

                                                PUSH nat 0 ;

                                                DUP 4 ;

                                                CAR ;

                                                CAR ;

                                                CDR ;

                                                SIZE ;

                                                COMPARE ;

                                                GT ;

                                                IF

                                                  { DUP 4 ;

                                                    CAR ;

                                                    CDR ;

                                                    NIL operation ;

                                                    DUP 6 ;

                                                    CAR ;

                                                    CAR ;

                                                    PUSH nat 0 ;

                                                    DUP ;

                                                    DUP 3 ;

                                                    COMPARE ;

                                                    GT ;

                                                    LOOP { DUP 7 ;

                                                           CAR ;

                                                           CAR ;

                                                           CDR ;

                                                           ITER { DIG 4 ;

                                                                  IF_CONS

                                                                    { SWAP ;

                                                                      DUP ;

                                                                      DUG 2 ;

                                                                      DUG 6 ;

                                                                      DUP 3 ;

                                                                      SWAP ;

                                                                      DUP ;

                                                                      DUG 2 ;

                                                                      CAR ;

                                                                      MEM ;

                                                                      IF

                                                                        {}

                                                                        { PUSH string "OE_REDEEM_MISTMACH_FA2" ;

                                                                          FAILWITH } ;

                                                                      DUP 3 ;

                                                                      SWAP ;

                                                                      DUP ;

                                                                      DUG 2 ;

                                                                      CAR ;

                                                                      GET ;

                                                                      IF_NONE

                                                                        { PUSH int 279 ;

                                                                          FAILWITH }

                                                                        {} ;

                                                                      NONE nat ;

                                                                      SWAP ;

                                                                      DUP ;

                                                                      DUG 2 ;

                                                                      NONE nat ;

                                                                      MEM ;

                                                                      IF

                                                                        { DIG 3 ;

                                                                          DROP ;

                                                                          DIG 3 ;

                                                                          DROP }

                                                                        { DROP ;

                                                                          DIG 2 ;

                                                                          DROP ;

                                                                          DIG 2 ;

                                                                          DROP ;

                                                                          SWAP ;

                                                                          DUP ;

                                                                          DUG 2 ;

                                                                          CDR ;

                                                                          SOME ;

                                                                          SWAP ;

                                                                          DUP ;

                                                                          DUG 2 ;

                                                                          SWAP ;

                                                                          DUP ;

                                                                          DUG 2 ;

                                                                          MEM ;

                                                                          IF

                                                                            {}

                                                                            { PUSH string "OE_REDEEM_MISTMATCH_ID" ;

                                                                              FAILWITH } } ;

                                                                      DIG 5 ;

                                                                      DUP 4 ;

                                                                      CAR ;

                                                                      CONTRACT %transfer (list (pair

                                                                                                (address %from_)

                                                                                                (list %txs (pair

                                                                                                            (address %to_)

                                                                                                            (pair

                                                                                                              (nat %token_id)

                                                                                                              (nat %amount)))))) ;

                                                                      IF_NONE

                                                                        { PUSH int 490 ;

                                                                          FAILWITH }

                                                                        {} ;

                                                                      PUSH mutez 0 ;

                                                                      NIL (pair address

                                                                                (list (pair

                                                                                       address

                                                                                       (pair

                                                                                         nat

                                                                                         nat)))) ;

                                                                      NIL (pair address

                                                                                (pair

                                                                                  nat

                                                                                  nat)) ;

                                                                      DIG 6 ;

                                                                      DIG 6 ;

                                                                      GET ;

                                                                      IF_NONE

                                                                        { PUSH int 294 ;

                                                                          FAILWITH }

                                                                        {} ;

                                                                      DIG 6 ;

                                                                      CDR ;

                                                                      PUSH address "tz1burnburnburnburnburnburnburjAYjjX" ;

                                                                      PAIR 3 ;

                                                                      CONS ;

                                                                      SENDER ;

                                                                      PAIR ;

                                                                      CONS ;

                                                                      TRANSFER_TOKENS ;

                                                                      CONS ;

                                                                      DUG 2 }

                                                                    { PUSH string "OE_MISSING_BURN" ;

                                                                      FAILWITH } } ;

                                                           PUSH nat 1 ;

                                                           ADD ;

                                                           DUP ;

                                                           DUP 3 ;

                                                           COMPARE ;

                                                           GT } ;

                                                    DROP 2 ;

                                                    SWAP ;

                                                    DROP }

                                                  { NIL operation } ;

                                                PUSH mutez 0 ;

                                                DUP 5 ;

                                                GET 3 ;

                                                CDR ;

                                                COMPARE ;

                                                GT ;

                                                IF

                                                  { DUP 4 ;

                                                    GET 3 ;

                                                    CDR ;

                                                    DUP 6 ;

                                                    CAR ;

                                                    CAR ;

                                                    MUL ;

                                                    AMOUNT ;

                                                    COMPARE ;

                                                    EQ ;

                                                    IF

                                                      {}

                                                      { PUSH string "OE_WRONG_AMOUNT" ;

                                                        FAILWITH } ;

                                                    DUP 4 ;

                                                    GET 5 ;

                                                    CAR ;

                                                    ITER { DUP 5 ;

                                                           GET 5 ;

                                                           CDR ;

                                                           SWAP ;

                                                           DUP ;

                                                           DUG 2 ;

                                                           CDR ;

                                                           AMOUNT ;

                                                           MUL ;

                                                           EDIV ;

                                                           IF_NONE

                                                             { PUSH int 306 ; FAILWITH }

                                                             {} ;

                                                           CAR ;

                                                           DUP ;

                                                           PUSH mutez 0 ;

                                                           COMPARE ;

                                                           LT ;

                                                           IF

                                                             { DUG 2 ;

                                                               CAR ;

                                                               CONTRACT unit ;

                                                               IF_NONE

                                                                 { PUSH int 310 ;

                                                                   FAILWITH }

                                                                 {} ;

                                                               DIG 2 ;

                                                               UNIT ;

                                                               TRANSFER_TOKENS ;

                                                               CONS }

                                                             { DROP 2 } } }

                                                  {} ;

                                                DUP 4 ;

                                                CAR ;

                                                GET 3 ;

                                                IF_NONE

                                                  { DIG 2 ; DROP ; DIG 2 ; DROP }

                                                  { DIG 4 ;

                                                    DROP ;

                                                    DUP ;

                                                    DUG 2 ;

                                                    CAR ;

                                                    CONTRACT %enforce_conditions (list (pair

                                                                                        (pair

                                                                                          (nat %amount)

                                                                                          (address %claimer))

                                                                                        (pair

                                                                                          (bytes %condition_id)

                                                                                          (pair

                                                                                            (option %extra bytes)

                                                                                            (pair %token

                                                                                              (address %address)

                                                                                              (nat %token_id)))))) ;

                                                    IF_NONE

                                                      { PUSH int 27 ; FAILWITH }

                                                      {} ;

                                                    PUSH mutez 0 ;

                                                    NIL (pair (pair nat address)

                                                              (pair bytes

                                                                    (pair (option bytes)

                                                                          (pair address

                                                                                nat)))) ;

                                                    DUP 8 ;

                                                    GET 6 ;

                                                    SELF_ADDRESS ;