parameter (or

            (or

              (or (or %admin (unit %confirm_admin) (address %set_admin))

                  (or %assets

                    (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 %transfer (pair (address %from_)

                                           (list %txs (pair (address %to_)

                                                           (nat %token_id)

                                                           (nat %amount))))))

                    (list %update_operators (or

                                             (pair %add_operator (address %owner)

                                                                 (address %operator)

                                                                 (nat %token_id))

                                             (pair %remove_operator (address %owner)

                                                                    (address %operator)

                                                                    (nat %token_id))))))

              (or

                (list %authorized_transfer (pair (address %from_) (key %pk)

                                                (timestamp %expiry)

                                                (list %txs (pair (address %to_)

                                                                (nat %token_id)

                                                                (nat %amount)

                                                                (signature %sig)))))

                (list %burn_editions nat)))

            (or

              (or %minter

                (or

                  (list %mint_editions (pair (address %owner)

                                            (list %tokens (pair

                                                           (map %token_info string bytes)

                                                           (bytes %artwork_id)

                                                           (nat %edition)))))

                  (list %register_artworks (pair (string %title) (string %artist_name)

                                                (bytes %fingerprint)

                                                (nat %max_edition))))

                (list %update_edition_metadata (pair (nat %token_id)

                                                    (map %token_info string bytes))))

              (or %trustee (address %add_trustee) (address %remove_trustee))));

storage (pair

          (pair

            (pair (pair %admin (address %admin) (option %pending_admin address))

                  (map %artworks bytes

                                 (pair

                                   (pair

                                     (pair (string %artist_name) (bytes %fingerprint))

                                     (pair (nat %max_edition) (string %title)))

                                   (nat %token_start_id))))

            (pair

              (pair %assets

                (pair (big_map %ledger nat address)

                      (big_map %operators (pair address (pair address nat)) unit))

                (big_map %token_metadata nat

                                         (pair (nat %token_id)

                                               (map %token_info string bytes))))

              (bool %burnable)))

          (pair

            (pair (big_map %metadata string bytes)

                  (big_map %token_attribute nat

                                            (pair

                                              (pair (bytes %artwork_id) (bool %burned))

                                              (nat %edition_number))))

            (pair %trustee (nat %max_trustee) (set %trustees address))));

code { LAMBDA

         (pair address (option address))

         unit

         { CAR ; SENDER ; COMPARE ; NEQ ; IF { PUSH string "NOT_AN_ADMIN" ; FAILWITH } { UNIT } } ;

       PUSH string "FA2_TOKEN_UNDEFINED" ;

       PUSH string "FA2_INSUFFICIENT_BALANCE" ;

       PUSH string "FA2_NOT_OWNER" ;

       LAMBDA

         (pair nat (big_map nat (pair nat (map string bytes))))

         unit

         { UNPAIR ;

           MEM ;

           NOT ;

           IF { PUSH string "TOKEN_METADATA_NOT_FOUND" ; FAILWITH } { UNIT } } ;

       DIG 5 ;

       UNPAIR ;

       IF_LEFT

         { IF_LEFT

             { DIG 2 ;

               DROP ;

               IF_LEFT

                 { DIG 2 ;

                   DIG 3 ;

                   DIG 4 ;

                   DROP 3 ;

                   SWAP ;

                   DUP ;

                   DUG 2 ;

                   CAR ;

                   CAR ;

                   CAR ;

                   SWAP ;

                   IF_LEFT

                     { DIG 3 ;

                       DROP 2 ;

                       CDR ;

                       IF_NONE

                         { PUSH string "NO_PENDING_ADMIN" ; FAILWITH }

                         { SENDER ;

                           COMPARE ;

                           EQ ;

                           IF

                             { NONE address ; SENDER ; PAIR }

                             { PUSH string "NOT_A_PENDING_ADMIN" ; FAILWITH } } ;

                       NIL operation ;

                       PAIR }

                     { SWAP ; DUP ; DUG 2 ; DIG 4 ; SWAP ; EXEC ; DROP ; SOME ; SWAP ; CAR ; PAIR ; NIL operation ; PAIR } ;

                   UNPAIR ;

                   DUP 3 ;

                   CDR ;

                   DUP 4 ;

                   CAR ;

                   CDR ;

                   DIG 4 ;

                   CAR ;

                   CAR ;

                   CDR ;

                   DIG 4 ;

                   PAIR ;

                   PAIR ;

                   PAIR ;

                   SWAP ;

                   PAIR }

                 { DIG 5 ;

                   DROP ;

                   SWAP ;

                   DUP ;

                   DUG 2 ;

                   CAR ;

                   CDR ;

                   CAR ;

                   SWAP ;

                   IF_LEFT

                     { DIG 3 ;

                       DROP ;

                       IF_LEFT

                         { DIG 3 ;

                           DROP ;

                           DUP ;

                           CAR ;

                           MAP { DUP 3 ;

                                 CAR ;

                                 CAR ;

                                 SWAP ;

                                 DUP ;

                                 DUG 2 ;

                                 CDR ;

                                 GET ;

                                 IF_NONE

                                   { DROP ; DUP 4 ; FAILWITH }

                                   { SWAP ;

                                     DUP ;

                                     DUG 2 ;

                                     CAR ;

                                     SWAP ;

                                     COMPARE ;

                                     EQ ;

                                     IF { PUSH nat 1 } { PUSH nat 0 } ;

                                     SWAP ;

                                     PAIR } } ;

                           DIG 4 ;

                           DROP ;

                           SWAP ;

                           CDR ;

                           PUSH mutez 0 ;

                           DIG 2 ;

                           TRANSFER_TOKENS ;

                           SWAP ;

                           NIL operation ;

                           DIG 2 ;

                           CONS ;

                           PAIR }

                         { SWAP ;

                           DUP ;

                           DUG 2 ;

                           CAR ;

                           CAR ;

                           SWAP ;

                           ITER { DUP ;

                                  DUG 2 ;

                                  CDR ;

                                  ITER { SWAP ;

                                         PUSH nat 0 ;

                                         DUP 3 ;

                                         GET 4 ;

                                         COMPARE ;

                                         EQ ;

                                         IF

                                           { SWAP ; DROP }

                                           { PUSH nat 1 ;

                                             DUP 3 ;

                                             GET 4 ;

                                             COMPARE ;

                                             NEQ ;

                                             IF

                                               { DROP 2 ; DUP 4 ; FAILWITH }

                                               { DUP ;

                                                 DUP 3 ;

                                                 GET 3 ;

                                                 GET ;

                                                 IF_NONE

                                                   { DROP 2 ; DUP 5 ; FAILWITH }

                                                   { DUP 4 ;

                                                     CAR ;

                                                     SWAP ;

                                                     DUP ;

                                                     DUG 2 ;

                                                     COMPARE ;

                                                     NEQ ;

                                                     IF

                                                       { DROP 3 ; DUP 4 ; FAILWITH }

                                                       { DUP 5 ;

                                                         CAR ;

                                                         CDR ;

                                                         DUP 4 ;

                                                         GET 3 ;

                                                         PAIR ;

                                                         SENDER ;

                                                         DUG 2 ;

                                                         UNPAIR ;

                                                         DUP 4 ;

                                                         DUP 4 ;

                                                         COMPARE ;

                                                         EQ ;

                                                         IF

                                                           { DROP 4 ; UNIT }

                                                           { DIG 3 ;

                                                             PAIR ;

                                                             DIG 2 ;

                                                             PAIR ;

                                                             MEM ;

                                                             IF

                                                               { UNIT }

                                                               { PUSH string "FA2_NOT_OPERATOR" ;

                                                                 FAILWITH } } ;

                                                         DROP ;

                                                         SWAP ;

                                                         DUP ;

                                                         DUG 2 ;

                                                         CAR ;

                                                         SOME ;

                                                         DIG 2 ;

                                                         GET 3 ;

                                                         UPDATE } } } } } ;

                                  SWAP ;

                                  DROP } ;

                           DIG 3 ;

                           DIG 4 ;

                           DROP 2 ;

                           SWAP ;

                           DUP ;

                           DUG 2 ;

                           CDR ;

                           DIG 2 ;

                           CAR ;

                           CDR ;

                           DIG 2 ;

                           PAIR ;

                           PAIR ;

                           NIL operation ;

                           PAIR } }

                     { DIG 4 ;

                       DIG 5 ;

                       DROP 2 ;

                       SWAP ;

                       DUP ;

                       DUG 2 ;

                       CAR ;

                       CDR ;

                       SWAP ;

                       ITER { SWAP ;

                              SENDER ;

                              DUP 3 ;

                              IF_LEFT {} {} ;

                              CAR ;

                              COMPARE ;

                              EQ ;

                              IF {} { DUP 5 ; FAILWITH } ;

                              SWAP ;

                              IF_LEFT

                                { SWAP ;

                                  UNIT ;

                                  SOME ;

                                  DUP 3 ;

                                  GET 4 ;

                                  DUP 4 ;

                                  GET 3 ;

                                  PAIR ;

                                  DIG 3 ;

                                  CAR ;

                                  PAIR ;

                                  UPDATE }

                                { DUP ;

                                  DUG 2 ;

                                  GET 4 ;

                                  DUP 3 ;

                                  GET 3 ;

                                  PAIR ;

                                  DIG 2 ;

                                  CAR ;

                                  PAIR ;

                                  NONE unit ;

                                  SWAP ;

                                  UPDATE } } ;

                       DIG 3 ;

                       DROP ;

                       SWAP ;

                       DUP ;

                       DUG 2 ;

                       CDR ;

                       SWAP ;

                       DIG 2 ;

                       CAR ;

                       CAR ;

                       PAIR ;

                       PAIR ;

                       NIL operation ;

                       PAIR } ;

                   UNPAIR ;

                   DUP 3 ;

                   CDR ;

                   DUP 4 ;

                   CAR ;

                   CDR ;

                   CDR ;

                   DIG 3 ;

                   PAIR ;

                   DIG 3 ;

                   CAR ;

                   CAR ;

                   PAIR ;

                   PAIR ;

                   SWAP ;

                   PAIR } }

             { IF_LEFT

                 { DIG 2 ;

                   DIG 3 ;

                   DROP 2 ;

                   SWAP ;

                   DUP ;

                   DUG 2 ;

                   CDR ;

                   CDR ;

                   CDR ;

                   SENDER ;

                   MEM ;

                   NOT ;

                   IF

                     { SWAP ; DUP ; DUG 2 ; CAR ; CAR ; CAR ; DIG 5 ; SWAP ; EXEC ; DROP ; UNIT }

                     { DIG 4 ; DROP ; UNIT } ;

                   DROP ;

                   SWAP ;

                   DUP ;

                   DUG 2 ;

                   CAR ;

                   CDR ;

                   CAR ;

                   DUP ;

                   CAR ;

                   CAR ;

                   DIG 2 ;

                   ITER { DUP ;

                          DUG 2 ;

                          GET 3 ;

                          HASH_KEY ;

                          IMPLICIT_ACCOUNT ;

                          DUP 3 ;

                          CAR ;

                          SWAP ;

                          ADDRESS ;

                          COMPARE ;

                          NEQ ;

                          IF

                            { PUSH string "FA2_PUBLICKEY_ADDRESS_MISMATCH" ; FAILWITH }

                            {} ;

                          SWAP ;

                          DUP ;

                          DUG 2 ;

                          GET 5 ;

                          NOW ;

                          COMPARE ;

                          GT ;

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

                          SWAP ;

                          DUP ;

                          DUG 2 ;

                          GET 5 ;

                          PACK ;

                          SWAP ;

                          DUP 3 ;

                          GET 6 ;

                          ITER { SWAP ;

                                 PUSH nat 0 ;

                                 DUP 3 ;

                                 GET 5 ;

                                 COMPARE ;

                                 EQ ;

                                 IF

                                   { SWAP ; DROP }

                                   { PUSH nat 1 ;

                                     DUP 3 ;

                                     GET 5 ;

                                     COMPARE ;

                                     NEQ ;

                                     IF

                                       { DROP 2 ; DUP 5 ; FAILWITH }

                                       { DUP ;

                                         DUP 3 ;

                                         GET 3 ;

                                         GET ;

                                         IF_NONE

                                           { DROP 2 ; DUP 6 ; FAILWITH }

                                           { DUP 5 ;

                                             CAR ;

                                             SWAP ;

                                             COMPARE ;

                                             NEQ ;

                                             IF

                                               { DROP 2 ; DUP 5 ; FAILWITH }

                                               { SWAP ;

                                                 DUP ;

                                                 DUG 2 ;

                                                 CAR ;

                                                 PACK ;

                                                 DUP 3 ;

                                                 GET 3 ;

                                                 PACK ;

                                                 SWAP ;

                                                 CONCAT ;

                                                 DUP 4 ;

                                                 CONCAT ;

                                                 PUSH bytes 0x54657a6f73205369676e6564204d6573736167653a ;

                                                 CONCAT ;

                                                 PACK ;

                                                 PUSH bool False ;

                                                 SWAP ;

                                                 DUP 4 ;

                                                 GET 6 ;

                                                 DUP 7 ;

                                                 GET 3 ;

                                                 CHECK_SIGNATURE ;

                                                 COMPARE ;

                                                 EQ ;

                                                 IF

                                                   { PUSH string "FA2_INVALID_SIGNATURE" ;

                                                     FAILWITH }

                                                   {} ;

                                                 SWAP ;

                                                 DUP ;

                                                 DUG 2 ;

                                                 CAR ;

                                                 SOME ;

                                                 DIG 2 ;

                                                 GET 3 ;

                                                 UPDATE } } } } } ;

                          SWAP ;

                          DIG 2 ;

                          DROP 2 } ;

                   DIG 3 ;

                   DIG 4 ;

                   DROP 2 ;

                   DUP 3 ;

                   CDR ;

                   DUP 4 ;

                   CAR ;

                   CDR ;

                   CDR ;

                   DUP 4 ;

                   CDR ;

                   DIG 4 ;

                   CAR ;

                   CDR ;

                   DIG 4 ;

                   PAIR ;

                   PAIR ;

                   PAIR ;

                   DIG 2 ;

                   CAR ;

                   CAR ;

                   PAIR ;

                   PAIR ;

                   NIL operation ;

                   PAIR }

                 { DIG 4 ;

                   DIG 6 ;

                   DROP 2 ;

                   SWAP ;

                   DUP ;

                   DUG 2 ;

                   CAR ;

                   CDR ;

                   CDR ;

                   NOT ;

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

                   SWAP ;

                   DUP ;

                   DUG 2 ;

                   CAR ;

                   CDR ;

                   CAR ;

                   DUP ;

                   CDR ;

                   DUP 4 ;

                   CDR ;

                   CAR ;

                   CDR ;

                   DUP 3 ;

                   CAR ;

                   CAR ;

                   PAIR ;

                   PAIR ;

                   DIG 2 ;

                   ITER { SWAP ;

                          DUP ;

                          CDR ;

                          DUP 3 ;

                          PAIR ;

                          DUP 6 ;

                          SWAP ;

                          EXEC ;

                          DROP ;

                          DUP ;

                          CAR ;

                          CAR ;

                          DUP 3 ;

                          GET ;

                          IF_NONE

                            { DROP 2 ; DUP 5 ; FAILWITH }

                            { SENDER ;

                              SWAP ;

                              COMPARE ;

                              NEQ ;

                              IF { DUP 6 ; FAILWITH } {} ;

                              DUP ;

                              CAR ;

                              CDR ;

                              DUP 3 ;

                              GET ;

                              IF_NONE

                                { DROP 2 ;

                                  PUSH string "TOKEN_ATTRIBUTE_NOT_FOUND" ;

                                  FAILWITH }

                                { SWAP ;

                                  DUP ;

                                  DUG 2 ;

                                  CDR ;

                                  DUP 4 ;

                                  NONE (pair nat (map string bytes)) ;

                                  SWAP ;

                                  UPDATE ;

                                  DUP 3 ;

                                  CAR ;

                                  CDR ;

                                  DUP 3 ;

                                  CDR ;

                                  PUSH bool True ;

                                  DIG 4 ;

                                  CAR ;

                                  CAR ;

                                  PAIR ;

                                  PAIR ;

                                  SOME ;

                                  DUP 5 ;

                                  UPDATE ;

                                  DIG 2 ;

                                  CAR ;

                                  CAR ;

                                  DIG 3 ;

                                  NONE address ;

                                  SWAP ;

                                  UPDATE ;

                                  PAIR ;

                                  PAIR } } } ;

                   DIG 3 ;

                   DIG 4 ;

                   DIG 5 ;

                   DROP 3 ;

                   DUP 3 ;

                   CDR ;

                   DUP 4 ;

                   CAR ;

                   CDR ;

                   CDR ;

                   DUP 3 ;

                   CDR ;

                   DIG 4 ;

                   CAR ;

                   CDR ;

                   DUP 5 ;

                   CAR ;

                   CAR ;

                   PAIR ;

                   PAIR ;

                   PAIR ;

                   DIG 3 ;

                   CAR ;

                   CAR ;

                   PAIR ;

                   PAIR ;

                   DUP ;

                   CDR ;

                   CDR ;

                   DIG 2 ;

                   CAR ;

                   CDR ;

                   DUP 3 ;

                   CDR ;

                   CAR ;

                   CAR ;

                   PAIR ;

                   PAIR ;

                   SWAP ;

                   CAR ;

                   PAIR ;

                   NIL operation ;

                   PAIR } } }

         { DIG 3 ;

           DIG 4 ;

           DIG 5 ;

           DROP 3 ;

           IF_LEFT

             { SWAP ;

               DUP ;

               DUG 2 ;

               CDR ;

               CDR ;

               CDR ;

               SENDER ;

               MEM ;

               NOT ;

               IF

                 { SWAP ; DUP ; DUG 2 ; CAR ; CAR ; CAR ; DIG 4 ; SWAP ; EXEC ; DROP ; UNIT }

                 { DIG 3 ; DROP ; UNIT } ;

               DROP ;

               SWAP ;

               DUP ;

               DUG 2 ;

               CAR ;

               CDR ;

               CAR ;

               DUP 3 ;

               CDR ;

               CAR ;

               CDR ;

               DUP 4 ;

               CAR ;

               CAR ;

               CDR ;

               DIG 3 ;

               IF_LEFT

                 { DIG 5 ;

                   DROP ;

                   IF_LEFT

                     { DUP 4 ;

                       CDR ;

                       DIG 3 ;

                       DUP 5 ;

                       CAR ;

                       CAR ;

                       PAIR ;

                       PAIR ;

                       SWAP ;

                       ITER { DUP ;

                              DUG 2 ;

                              CDR ;

                              ITER { SWAP ;

                                     DUP 4 ;

                                     DUP 3 ;

                                     GET 3 ;

                                     GET ;

                                     IF_NONE

                                       { DROP 2 ;

                                         PUSH string "ARTWORK_NOT_FOUND" ;

                                         FAILWITH }

                                       { DUP ;

                                         CAR ;

                                         CDR ;

                                         CAR ;

                                         DUP 4 ;

                                         GET 4 ;

                                         COMPARE ;

                                         GT ;

                                         IF

                                           { PUSH string "EDITION_NUMBER_EXCEEDS_MAX_EDITION_LIMITS" ;

                                             FAILWITH }

                                           {} ;

                                         DUP 3 ;

                                         GET 4 ;

                                         SWAP ;

                                         CDR ;

                                         ADD ;

                                         SWAP ;

                                         DUP ;

                                         DUG 2 ;

                                         CAR ;

                                         CAR ;

                                         SWAP ;

                                         DUP ;

                                         DUG 2 ;

                                         MEM ;

                                         IF

                                           { PUSH string "TOKEN_HAS_ALREADY_ISSUED" ;

                                             FAILWITH }

                                           {} ;

                                         SWAP ;

                                         DUP ;

                                         DUG 2 ;

                                         CDR ;

                                         SWAP ;

                                         DUP ;

                                         DUG 2 ;

                                         MEM ;

                                         IF

                                           { PUSH string "TOKEN_METADATA_HAS_ALREADY_REGISTERED" ;

                                             FAILWITH }

                                           {} ;

                                         SWAP ;

                                         DUP ;

                                         DUG 2 ;

                                         CAR ;

                                         CDR ;

                                         SWAP ;

                                         DUP ;

                                         DUG 2 ;

                                         MEM ;

                                         IF

                                           { PUSH string "TOKEN_ATTRIBUTE_HAS_ALREADY_REGISTERED" ;

                                             FAILWITH }

                                           {} ;

                                         SWAP ;

                                         DUP ;

                                         DUG 2 ;

                                         CDR ;

                                         DUP 4 ;

                                         CAR ;

                                         DUP 3 ;

                                         PAIR ;

                                         DUP 3 ;

                                         SWAP ;

                                         SOME ;

                                         SWAP ;

                                         UPDATE ;

                                         DUP 3 ;

                                         CAR ;

                                         CDR ;

                                         DUP 5 ;

                                         GET 4 ;

                                         PUSH bool False ;

                                         DIG 6 ;

                                         GET 3 ;

                                         PAIR ;

                                         PAIR ;

                                         DUP 4 ;

                                         SWAP ;

                                         SOME ;

                                         SWAP ;

                                         UPDATE ;

                                         DIG 3 ;

                                         CAR ;

                                         CAR ;

                                         DUP 5 ;

                                         CAR ;

                                         DIG 4 ;

                                         SWAP ;

                                         SOME ;

                                         SWAP ;

                                         UPDATE ;

                                         PAIR ;

                                         PAIR } } ;

                              SWAP ;

                              DROP } ;

                       DUP ;

                       CAR ;

                       CDR ;

                       DUG 2 ;

                       DUP ;

                       DUG 3 ;

                       CDR ;

                       DIG 4 ;

                       CAR ;

                       CDR ;

                       DIG 4 ;

                       CAR ;

                       CAR ;

                       PAIR ;

                       PAIR ;

                       PAIR ;

                       PAIR }

                     { ITER { DUP ;

                              DUG 2 ;

                              GET 5 ;

                              KECCAK ;

                              SWAP ;

                              DUP ;

                              DUG 2 ;

                              SWAP ;

                              DUP ;

                              DUG 2 ;

                              MEM ;

                              IF

                                { DROP 3 ; PUSH string "USED_ARTWORK_ID" ; FAILWITH }

                                { PUSH nat 0 ;

                                  PUSH nat 0 ;

                                  DUP 3 ;

                                  PAIR ;

                                  PAIR ;

                                  { LEFT nat ;

                                    LOOP_LEFT { UNPAIR ;

                                                UNPAIR ;

                                                PUSH nat 0 ;

                                                SWAP ;

                                                DUP ;

                                                DUG 2 ;

                                                SIZE ;

                                                COMPARE ;

                                                EQ ;

                                                IF

                                                  { DROP 3 ;

                                                    PUSH string "BYTES_LENGTH_ZERO" ;

                                                    FAILWITH }

                                                  { DUP ;

                                                    SIZE ;

                                                    DUP 3 ;

                                                    COMPARE ;

                                                    LT ;

                                                    IF

                                                      { DUP ;

                                                        PUSH nat 1 ;

                                                        DUP 4 ;

                                                        SLICE ;

                                                        IF_NONE

                                                          { PUSH string "SLICE" ;

                                                            FAILWITH }

                                                          {} ;

                                                        EMPTY_MAP bytes nat ;

                                                        PUSH nat 255 ;