parameter (or

            (or

              (or

                (or (pair %add_manager (address %manager) (nat %token_id))

                    (map %airdrop nat (list (pair (nat %amount) (address %recipient)))))

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

                  (list %burn (pair (address %from_) (pair (nat %token_id) (nat %amount))))))

              (or

                (or

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

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

                (or

                  (pair %create_token (map %metadata string bytes)

                                      (pair (list %collaborators address)

                                            (pair (nat %editions)

                                                  (pair (bool %lock_metadata)

                                                        (bool %lock_mint)))))

                  (pair %lock (bool %metadata) (pair (bool %mint) (nat %token_id))))))

            (or

              (or

                (or

                  (pair %mint (list %mint_items (pair (nat %amount) (address %to_)))

                              (nat %token_id))

                  (nat %reject_authorship))

                (or (nat %remove_claim)

                    (pair %remove_manager (address %manager) (nat %token_id))))

              (or

                (or (nat %sign_authorship)

                    (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 (big_map %authors nat (map address bool))

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

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

                                               (address %creator)))

                                           (pair

                                             (pair (timestamp %end_time)

                                                   (nat %max_per_wallet))

                                             (pair (mutez %price)

                                                   (pair

                                                     (pair %split

                                                       (map %shares address nat)

                                                       (nat %total))

                                                     (timestamp %start_time))))))))

            (pair (nat %last_token_id)

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

                        (big_map %locked nat (pair (bool %metadata) (bool %mint))))))

          (pair

            (pair (big_map %managers nat (set address))

                  (pair (big_map %metadata string bytes)

                        (big_map %operators

                          (pair (address %owner)

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

                          unit)))

            (pair (big_map %pending_collabs nat (set address))

                  (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

                 { IF_LEFT

                     { SWAP ;

                       DUP ;

                       DUG 2 ;

                       CAR ;

                       CAR ;

                       CAR ;

                       SWAP ;

                       DUP ;

                       DUG 2 ;

                       CDR ;

                       GET ;

                       IF_NONE { PUSH int 135 ; FAILWITH } {} ;

                       SENDER ;

                       GET ;

                       IF_NONE { PUSH int 135 ; FAILWITH } {} ;

                       IF {} { PUSH string "NOT_VERIFIED_AUTHOR" ; FAILWITH } ;

                       SWAP ;

                       UNPAIR ;

                       SWAP ;

                       UNPAIR ;

                       UNPAIR ;

                       DUP ;

                       DUP 6 ;

                       CDR ;

                       DUP ;

                       DUG 2 ;

                       GET ;

                       IF_NONE { PUSH int 136 ; FAILWITH } {} ;

                       PUSH bool True ;

                       DIG 7 ;

                       CAR ;

                       UPDATE ;

                       SOME ;

                       SWAP ;

                       UPDATE ;

                       PAIR ;

                       PAIR ;

                       SWAP ;

                       PAIR }

                     { DUP ;

                       ITER { DUP 3 ;

                              CAR ;

                              CAR ;

                              GET 4 ;

                              SWAP ;

                              DUP ;

                              DUG 2 ;

                              CAR ;

                              MEM ;

                              IF {} { PUSH string "OE_NO_SALE" ; FAILWITH } ;

                              DUP 3 ;

                              GET 3 ;

                              CAR ;

                              SWAP ;

                              DUP ;

                              DUG 2 ;

                              CAR ;

                              MEM ;

                              IF

                                { DUP 3 ;

                                  GET 3 ;

                                  CAR ;

                                  SWAP ;

                                  DUP ;

                                  DUG 2 ;

                                  CAR ;

                                  GET ;

                                  IF_NONE { PUSH int 504 ; FAILWITH } {} ;

                                  SENDER ;

                                  MEM }

                                { PUSH bool False } ;

                              IF

                                { PUSH bool True }

                                { DUP 3 ;

                                  CAR ;

                                  CAR ;

                                  CAR ;

                                  SWAP ;

                                  DUP ;

                                  DUG 2 ;

                                  CAR ;

                                  GET ;

                                  IF_NONE { PUSH int 504 ; FAILWITH } {} ;

                                  SENDER ;

                                  GET ;

                                  IF_NONE { PUSH int 504 ; FAILWITH } {} } ;

                              IF {} { PUSH string "NOT_AUTHOR_MANAGER" ; FAILWITH } ;

                              DUP ;

                              CDR ;

                              ITER { DUP 4 ;

                                     CAR ;

                                     CAR ;

                                     GET 4 ;

                                     DUP 3 ;

                                     CAR ;

                                     GET ;

                                     IF_NONE { PUSH int 415 ; FAILWITH } {} ;

                                     CAR ;

                                     CAR ;

                                     CAR ;

                                     DUP 3 ;

                                     CAR ;

                                     DUP 3 ;

                                     CDR ;

                                     PAIR ;

                                     DUP 6 ;

                                     UNPAIR ;

                                     UNPAIR ;

                                     SWAP ;

                                     UNPAIR ;

                                     SWAP ;

                                     UNPAIR ;

                                     DUP 8 ;

                                     CAR ;

                                     DIG 11 ;

                                     CAR ;

                                     GET 5 ;

                                     DUP 8 ;

                                     GET ;

                                     IF_NONE { PUSH nat 0 } {} ;

                                     ADD ;

                                     SOME ;

                                     DIG 6 ;

                                     UPDATE ;

                                     PAIR ;

                                     SWAP ;

                                     PAIR ;

                                     SWAP ;

                                     PAIR ;

                                     PAIR ;

                                     DUP ;

                                     GET 7 ;

                                     DUP ;

                                     DUP 6 ;

                                     CAR ;

                                     DUP ;

                                     DUG 2 ;

                                     GET ;

                                     IF_NONE { PUSH int 424 ; FAILWITH } {} ;

                                     DUP 6 ;

                                     CAR ;

                                     ADD ;

                                     SOME ;

                                     SWAP ;

                                     UPDATE ;

                                     UPDATE 7 ;

                                     UNPAIR ;

                                     UNPAIR ;

                                     UNPAIR ;

                                     SWAP ;

                                     UNPAIR ;

                                     SWAP ;

                                     DUP ;

                                     DUP 9 ;

                                     CAR ;

                                     DUP ;

                                     DUG 2 ;

                                     GET ;

                                     IF_NONE { PUSH int 425 ; FAILWITH } {} ;

                                     UNPAIR ;

                                     UNPAIR ;

                                     CDR ;

                                     DIG 10 ;

                                     CAR ;

                                     DIG 10 ;

                                     SUB ;

                                     ISNAT ;

                                     IF_NONE

                                       { PUSH string "OE_AIRDROP_CAP_REACHED" ; FAILWITH }

                                       {} ;

                                     PAIR ;

                                     PAIR ;

                                     PAIR ;

                                     SOME ;

                                     SWAP ;

                                     UPDATE ;

                                     SWAP ;

                                     PAIR ;

                                     SWAP ;

                                     PAIR ;

                                     PAIR ;

                                     PAIR ;

                                     DUG 2 } ;

                              DROP } ;

                       DROP } ;

                   NIL operation }

                 { IF_LEFT

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

                             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 }

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

                                  GET 4 ;

                                  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 ;

                              DUP 6 ;

                              GET 4 ;

                              DIG 8 ;

                              CAR ;

                              GET 5 ;

                              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 ;

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

             { IF_LEFT

                 { IF_LEFT

                     { SWAP ;

                       DUP ;

                       DUG 2 ;

                       CAR ;

                       CAR ;

                       GET 4 ;

                       SWAP ;

                       DUP ;

                       DUG 2 ;

                       GET 6 ;

                       MEM ;

                       IF {} { PUSH string "OE_NO_SALE_ACTIVE" ; FAILWITH } ;

                       SWAP ;

                       DUP ;

                       DUG 2 ;

                       CAR ;

                       CAR ;

                       GET 4 ;

                       SWAP ;

                       DUP ;

                       DUG 2 ;

                       GET 6 ;

                       GET ;

                       IF_NONE { PUSH int 245 ; FAILWITH } {} ;

                       DUP ;

                       GET 8 ;

                       NOW ;

                       COMPARE ;

                       GE ;

                       IF

                         { DUP ; GET 3 ; CAR ; 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 ;

                       CDR ;

                       COMPARE ;

                       GT ;

                       IF

                         { DUP 5 ;

                           CAR ;

                           CAR ;

                           GET 3 ;

                           SWAP ;

                           DUP ;

                           DUG 2 ;

                           GET ;

                           IF_NONE { PUSH nat 0 } {} ;

                           DUP 4 ;

                           GET 3 ;

                           CDR ;

                           SUB ;

                           ISNAT ;

                           IF_NONE { PUSH int 270 ; FAILWITH } {} ;

                           DUP 5 ;

                           CAR ;

                           CAR ;

                           COMPARE ;

                           LE ;

                           IF {} { PUSH string "OE_MAX_REACHED" ; FAILWITH } }

                         {} ;

                       DUP 5 ;

                       UNPAIR ;

                       UNPAIR ;

                       UNPAIR ;

                       SWAP ;

                       UNPAIR ;

                       DUP 9 ;

                       CAR ;

                       CAR ;

                       DIG 10 ;

                       CAR ;

                       CAR ;

                       GET 3 ;

                       DUP 8 ;

                       GET ;

                       IF_NONE { PUSH nat 0 } {} ;

                       ADD ;

                       SOME ;

                       DUP 7 ;

                       UPDATE ;

                       PAIR ;

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

                                             DUP ;

                                             NONE nat ;

                                             SWAP ;

                                             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 482 ; 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 303 ; 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 5 ;

                       COMPARE ;

                       GT ;

                       IF

                         { DUP 4 ;

                           GET 5 ;

                           DUP 6 ;

                           CAR ;

                           CAR ;

                           MUL ;

                           AMOUNT ;

                           COMPARE ;

                           EQ ;

                           IF {} { PUSH string "OE_WRONG_AMOUNT" ; FAILWITH } ;

                           DUP 4 ;

                           GET 7 ;

                           CAR ;

                           ITER { DUP 5 ;

                                  GET 7 ;

                                  CDR ;

                                  SWAP ;

                                  DUP ;

                                  DUG 2 ;

                                  CDR ;

                                  AMOUNT ;

                                  MUL ;

                                  EDIV ;

                                  IF_NONE { PUSH int 315 ; FAILWITH } {} ;

                                  CAR ;

                                  DUP ;

                                  PUSH mutez 0 ;

                                  COMPARE ;

                                  LT ;

                                  IF

                                    { DUG 2 ;

                                      CAR ;

                                      CONTRACT unit ;

                                      IF_NONE { PUSH int 319 ; FAILWITH } {} ;

                                      DIG 2 ;

                                      UNIT ;

                                      TRANSFER_TOKENS ;

                                      CONS }

                                    { DROP 2 } } }

                         {} ;

                       DUP 4 ;

                       CAR ;

                       GET 3 ;

                       IF_NONE

                         { DIG 2 ; DROP ; DIG 2 ; DROP }

                         { DUP ;

                           DUG 2 ;

                           CAR ;

                           CONTRACT %enforce_conditions (list (pair

                                                               (pair (nat %amount)

                                                                     (pair

                                                                       (address %claimer)

                                                                       (bytes %condition_id)))

                                                               (pair (address %creator)

                                                                     (pair

                                                                       (option %extra bytes)

                                                                       (pair %token

                                                                         (address %address)

                                                                         (nat %token_id)))))) ;

                           IF_NONE { PUSH int 18 ; FAILWITH } {} ;

                           PUSH mutez 0 ;

                           NIL (pair (pair nat (pair address bytes))

                                     (pair address

                                           (pair (option bytes) (pair address nat)))) ;

                           DUP 9 ;

                           GET 6 ;

                           SELF_ADDRESS ;

                           PAIR ;

                           DUP 10 ;

                           GET 3 ;

                           PAIR ;

                           DIG 8 ;

                           CAR ;

                           GET 4 ;

                           PAIR ;

                           DIG 5 ;

                           CDR ;

                           DIG 7 ;

                           PAIR ;

                           DUP 8 ;

                           CAR ;

                           CAR ;

                           PAIR ;

                           PAIR ;

                           CONS ;

                           TRANSFER_TOKENS ;

                           CONS } ;

                       DUP 4 ;

                       UNPAIR ;

                       UNPAIR ;

                       SWAP ;

                       UNPAIR ;

                       SWAP ;

                       UNPAIR ;

                       DUP 8 ;

                       CAR ;

                       CAR ;

                       DIG 9 ;

                       CAR ;

                       GET 5 ;

                       DUP 9 ;

                       GET ;

                       IF_NONE { PUSH nat 0 } {} ;

                       ADD ;

                       SOME ;

                       DIG 7 ;

                       UPDATE ;

                       PAIR ;

                       SWAP ;

                       PAIR ;

                       SWAP ;

                       PAIR ;

                       PAIR ;

                       DUP ;

                       GET 7 ;

                       DUP ;

                       DUP 5 ;

                       GET 6 ;

                       DUP ;

                       DUG 2 ;

                       GET ;

                       IF_NONE { PUSH int 342 ; FAILWITH } {} ;

                       DUP 6 ;

                       CAR ;

                       CAR ;

                       ADD ;

                       SOME ;

                       SWAP ;

                       UPDATE ;

                       UPDATE 7 ;

                       DUP ;

                       DUG 3 ;

                       CAR ;

                       GET 6 ;

                       DUP 3 ;

                       GET 6 ;

                       MEM ;

                       IF

                         { DIG 2 ;

                           UNPAIR ;

                           UNPAIR ;

                           SWAP ;

                           UNPAIR ;

                           SWAP ;

                           UNPAIR ;

                           SWAP ;

                           DUP ;