parameter (or

            (or (pair %abyss (nat %asset_id) (bytes %payload))

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

            (or

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

                                                       (pair (nat %token_id)

                                                             (nat %amount)))))))

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

              (unit %close)));

storage (pair

          (pair

            (pair %admin (pair (address %admin) (bool %paused))

                         (option %pending_admin address))

            (pair %assets

              (pair (big_map %ledger nat address)

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

              (pair

                (pair %permissions

                  (or %operator (unit %no_transfer)

                                (or (unit %owner_transfer)

                                    (unit %owner_or_operator_transfer)))

                  (pair

                    (or %receiver (unit %owner_no_hook)

                                  (or (unit %optional_owner_hook)

                                      (unit %required_owner_hook)))

                    (pair

                      (or %sender (unit %owner_no_hook)

                                  (or (unit %optional_owner_hook)

                                      (unit %required_owner_hook)))

                      (option %custom (pair (string %tag) (option %config_api address))))))

                (big_map %token_metadata nat

                                         (pair (nat %token_id)

                                               (map %token_info string bytes))))))

          (pair (big_map %metadata string bytes) (bool %minting_closed)));

code { PUSH string "FA2_TOKEN_UNDEFINED" ;

       PUSH string "FA2_INSUFFICIENT_BALANCE" ;

       LAMBDA

         (pair

           (pair

             (pair

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

               address)

             (lambda

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

               (list (option address))))

           (pair

             (lambda address

                     (or

                       (contract (pair

                                  (list (pair (option address)

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

                                  address))

                       string))

             bool))

         (list (contract (pair

                         (list (pair (option address)

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

                         address)))

         { UNPAIR ;

           UNPAIR ;

           DIG 2 ;

           UNPAIR ;

           DIG 3 ;

           DIG 3 ;

           CAR ;

           EMPTY_SET address ;

           SWAP ;

           ITER { DUP 3 ; SWAP ; EXEC ; ITER { IF_NONE {} { PUSH bool True ; SWAP ; UPDATE } } } ;

           SWAP ;

           DROP ;

           NIL (contract (pair

                          (list (pair (option address)

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

                          address)) ;

           SWAP ;

           ITER { DUP 3 ;

                  SWAP ;

                  EXEC ;

                  IF_LEFT { CONS } { DUP 4 ; IF { SWAP ; DROP ; FAILWITH } { DROP } } } ;

           SWAP ;

           DROP ;

           SWAP ;

           DROP } ;

       LAMBDA

         (pair

           (lambda

             (pair

               (pair

                 (pair

                   (list (pair (option address)

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

                   address)

                 (lambda

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

                   (list (option address))))

               (pair

                 (lambda address

                         (or

                           (contract (pair

                                      (list (pair (option address)

                                                 (list (pair (option address)

                                                            (pair nat nat)))))

                                      address))

                           string))

                 bool))

             (list (contract (pair

                             (list (pair (option address)

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

                             address))))

           (pair

             (pair

               (pair

                 (list (pair (option address)

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

                 address)

               (or unit (or unit unit)))

             (pair

               (lambda

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

                 (list (option address)))

               (lambda address

                       (or

                         (contract (pair

                                    (list (pair (option address)

                                               (list (pair (option address)

                                                          (pair nat nat)))))

                                    address))

                         string)))))

         (list (contract (pair

                         (list (pair (option address)

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

                         address)))

         { UNPAIR ;

           SWAP ;

           UNPAIR ;

           UNPAIR ;

           DIG 2 ;

           UNPAIR ;

           DIG 3 ;

           IF_LEFT

             { DROP 5 ;

               NIL (contract (pair

                              (list (pair (option address)

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

                              address)) }

             { IF_LEFT

                 { DROP ; PUSH bool False ; DIG 2 ; PAIR ; SWAP ; DIG 2 ; PAIR ; PAIR ; EXEC }

                 { DROP ; PUSH bool True ; DIG 2 ; PAIR ; SWAP ; DIG 2 ; PAIR ; PAIR ; EXEC } } } ;

       SWAP ;

       APPLY ;

       LAMBDA

         (pair (pair address bool) (option address))

         unit

         { CAR ;

           CAR ;

           SENDER ;

           COMPARE ;

           NEQ ;

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

       DIG 4 ;

       UNPAIR ;

       IF_LEFT

         { DIG 3 ;

           DROP ;

           DIG 3 ;

           DROP ;

           DIG 3 ;

           DROP ;

           IF_LEFT

             { DROP ;

               SWAP ;

               DROP ;

               PUSH bool True ;

               SWAP ;

               DUP ;

               DUG 2 ;

               CDR ;

               CDR ;

               COMPARE ;

               EQ ;

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

               NIL operation ;

               PAIR }

             { SWAP ;

               DUP ;

               DUG 2 ;

               CAR ;

               CAR ;

               SWAP ;

               IF_LEFT

                 { IF_LEFT

                     { DROP ;

                       DIG 2 ;

                       DROP ;

                       DUP ;

                       CDR ;

                       IF_NONE

                         { DROP ; PUSH string "NO_PENDING_ADMIN" ; FAILWITH }

                         { SENDER ;

                           COMPARE ;

                           EQ ;

                           IF

                             { NONE address ; SWAP ; CAR ; CDR ; SENDER ; PAIR ; PAIR }

                             { DROP ; PUSH string "NOT_A_PENDING_ADMIN" ; FAILWITH } } ;

                       NIL operation ;

                       PAIR }

                     { SWAP ;

                       DUP ;

                       DUG 2 ;

                       DIG 4 ;

                       SWAP ;

                       EXEC ;

                       DROP ;

                       SWAP ;

                       DUP ;

                       DUG 2 ;

                       CDR ;

                       SWAP ;

                       DIG 2 ;

                       CAR ;

                       CAR ;

                       PAIR ;

                       PAIR ;

                       NIL operation ;

                       PAIR } }

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

               UNPAIR ;

               DUP 3 ;

               CDR ;

               DIG 3 ;

               CAR ;

               CDR ;

               DIG 3 ;

               PAIR ;

               PAIR ;

               SWAP ;

               PAIR } }

         { IF_LEFT

             { DIG 2 ;

               DROP ;

               SWAP ;

               DUP ;

               DUG 2 ;

               CAR ;

               CAR ;

               CAR ;

               CDR ;

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

               SWAP ;

               DUP ;

               DUG 2 ;

               CAR ;

               CDR ;

               SWAP ;

               IF_LEFT

                 { IF_LEFT

                     { DIG 3 ;

                       DROP ;

                       DIG 3 ;

                       DROP ;

                       SWAP ;

                       DUP ;

                       DUG 2 ;

                       CAR ;

                       CAR ;

                       SWAP ;

                       DUP ;

                       CAR ;

                       MAP { DUP 3 ;

                             SWAP ;

                             DUP ;

                             DUG 2 ;

                             CDR ;

                             GET ;

                             IF_NONE

                               { DROP ; DUP 5 ; FAILWITH }

                               { SWAP ;

                                 DUP ;

                                 DUG 2 ;

                                 CAR ;

                                 SWAP ;

                                 COMPARE ;

                                 EQ ;

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

                                 SWAP ;

                                 PAIR } } ;

                       DIG 2 ;

                       DROP ;

                       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 ;

                       DUP 3 ;

                       CAR ;

                       CDR ;

                       PAIR ;

                       LAMBDA

                         (pair (pair address address)

                               (pair nat

                                     (big_map (pair address (pair address nat)) unit)))

                         unit

                         { UNPAIR ;

                           UNPAIR ;

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

                       DUP 3 ;

                       DIG 2 ;

                       UNPAIR ;

                       SWAP ;

                       DIG 2 ;

                       ITER { DUP ;

                              DUG 2 ;

                              CDR ;

                              ITER { SWAP ;

                                     PUSH nat 0 ;

                                     DUP 3 ;

                                     CDR ;

                                     CDR ;

                                     COMPARE ;

                                     EQ ;

                                     IF

                                       { SWAP ; DROP }

                                       { PUSH nat 1 ;

                                         DUP 3 ;

                                         CDR ;

                                         CDR ;

                                         COMPARE ;

                                         NEQ ;

                                         IF

                                           { DROP 2 ; DUP 8 ; FAILWITH }

                                           { DUP ;

                                             DUP 3 ;

                                             CDR ;

                                             CAR ;

                                             GET ;

                                             IF_NONE

                                               { DROP 2 ; DUP 9 ; FAILWITH }

                                               { DUP 4 ;

                                                 CAR ;

                                                 SWAP ;

                                                 COMPARE ;

                                                 NEQ ;

                                                 IF

                                                   { DROP 2 ; DUP 8 ; FAILWITH }

                                                   { DUP 4 ;

                                                     DUP 3 ;

                                                     CDR ;

                                                     CAR ;

                                                     PAIR ;

                                                     SENDER ;

                                                     DUP 5 ;

                                                     CAR ;

                                                     PAIR ;

                                                     PAIR ;

                                                     DUP 6 ;

                                                     SWAP ;

                                                     EXEC ;

                                                     DROP ;

                                                     SWAP ;

                                                     DUP ;

                                                     DUG 2 ;

                                                     CAR ;

                                                     SOME ;

                                                     DIG 2 ;

                                                     CDR ;

                                                     CAR ;

                                                     UPDATE } } } } } ;

                              SWAP ;

                              DROP } ;

                       SWAP ;

                       DROP ;

                       SWAP ;

                       DROP ;

                       DIG 5 ;

                       DROP ;

                       DIG 5 ;

                       DROP ;

                       DUP 3 ;

                       CDR ;

                       CAR ;

                       DIG 2 ;

                       SENDER ;

                       SWAP ;

                       MAP { DUP ;

                             CDR ;

                             MAP { DUP ; CDR ; CDR ; SWAP ; DUP ; DUG 2 ; CDR ; CAR ; PAIR ; SWAP ; CAR ; SOME ; PAIR } ;

                             SWAP ;

                             CAR ;

                             SOME ;

                             PAIR } ;

                       PAIR ;

                       DUP ;

                       DUG 2 ;

                       SWAP ;

                       DUP ;

                       DUG 2 ;

                       CDR ;

                       CDR ;

                       CAR ;

                       SWAP ;

                       DUP ;

                       DUG 2 ;

                       LAMBDA

                         address

                         (or

                           (contract (pair

                                      (list (pair (option address)

                                                 (list (pair (option address)

                                                            (pair nat nat)))))

                                      address))

                           string)

                         { CONTRACT %tokens_sent (pair

                                                   (list %batch (pair

                                                                 (option %from_ address)

                                                                 (list %txs (pair

                                                                             (option %to_ address)

                                                                             (pair

                                                                               (nat %token_id)

                                                                               (nat %amount))))))

                                                   (address %operator)) ;

                           IF_NONE

                             { PUSH string "FA2_SENDER_HOOK_UNDEFINED" ;

                               RIGHT (contract (pair

                                                (list (pair (option address)

                                                           (list (pair (option address)

                                                                      (pair nat nat)))))

                                                address)) }

                             { LEFT string } } ;

                       LAMBDA

                         (pair (option address)

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

                         (list (option address))

                         { NIL (option address) ; SWAP ; CAR ; CONS } ;

                       PAIR ;

                       DUG 2 ;

                       PAIR ;

                       PAIR ;

                       DUP 8 ;

                       SWAP ;

                       EXEC ;

                       DIG 2 ;

                       CDR ;

                       CAR ;

                       DIG 2 ;

                       LAMBDA

                         address

                         (or

                           (contract (pair

                                      (list (pair (option address)

                                                 (list (pair (option address)

                                                            (pair nat nat)))))

                                      address))

                           string)

                         { CONTRACT %tokens_received (pair

                                                       (list %batch (pair

                                                                     (option %from_ address)

                                                                     (list %txs (pair

                                                                                 (option %to_ address)

                                                                                 (pair

                                                                                   (nat %token_id)

                                                                                   (nat %amount))))))

                                                       (address %operator)) ;

                           IF_NONE

                             { PUSH string "FA2_RECEIVER_HOOK_UNDEFINED" ;

                               RIGHT (contract (pair

                                                (list (pair (option address)

                                                           (list (pair (option address)

                                                                      (pair nat nat)))))

                                                address)) }

                             { LEFT string } } ;

                       LAMBDA

                         (pair (option address)

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

                         (list (option address))

                         { CDR ; MAP { CAR } } ;

                       PAIR ;

                       DUG 2 ;

                       PAIR ;

                       PAIR ;

                       DIG 6 ;

                       SWAP ;

                       EXEC ;

                       ITER { CONS } ;

                       DUP ;

                       IF_CONS

                         { DROP 2 ;

                           MAP { PUSH mutez 0 ; DUP 3 ; TRANSFER_TOKENS } ;

                           SWAP ;

                           DROP }

                         { DROP 2 ; NIL operation } ;

                       DUP 3 ;

                       CDR ;

                       DIG 3 ;

                       CAR ;

                       CDR ;

                       DIG 3 ;

                       PAIR ;

                       PAIR ;

                       SWAP ;

                       PAIR } }

                 { DIG 3 ;

                   DROP ;

                   DIG 3 ;

                   DROP ;

                   DIG 3 ;

                   DROP ;

                   SWAP ;

                   DUP ;

                   DUG 2 ;

                   CAR ;

                   CDR ;

                   SWAP ;

                   SENDER ;

                   DUG 2 ;

                   ITER { SWAP ;

                          DUP 3 ;

                          DUP 3 ;

                          IF_LEFT {} {} ;

                          CAR ;

                          COMPARE ;

                          EQ ;

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

                          SWAP ;

                          IF_LEFT

                            { SWAP ;

                              UNIT ;

                              SOME ;

                              DUP 3 ;

                              CDR ;

                              CDR ;

                              DUP 4 ;

                              CDR ;

                              CAR ;

                              PAIR ;

                              DIG 3 ;

                              CAR ;

                              PAIR ;

                              UPDATE }

                            { DUP ;

                              DUG 2 ;

                              CDR ;

                              CDR ;

                              DUP 3 ;

                              CDR ;

                              CAR ;

                              PAIR ;

                              DIG 2 ;

                              CAR ;

                              PAIR ;

                              NONE unit ;

                              SWAP ;

                              UPDATE } } ;

                   SWAP ;

                   DROP ;

                   SWAP ;

                   DUP ;

                   DUG 2 ;

                   CDR ;

                   SWAP ;

                   DIG 2 ;

                   CAR ;

                   CAR ;

                   PAIR ;

                   PAIR ;

                   NIL operation ;

                   PAIR } ;

               UNPAIR ;

               DUP 3 ;

               CDR ;

               DIG 2 ;

               DIG 3 ;

               CAR ;

               CAR ;

               PAIR ;

               PAIR ;

               SWAP ;

               PAIR }

             { DROP ;

               DIG 2 ;

               DROP ;

               DIG 2 ;

               DROP ;

               DIG 2 ;

               DROP ;

               DUP ;

               CAR ;

               CAR ;

               DIG 2 ;

               SWAP ;

               EXEC ;

               DROP ;

               PUSH bool True ;

               SWAP ;

               DUP ;

               DUG 2 ;

               CDR ;

               CAR ;

               PAIR ;

               SWAP ;

               CAR ;

               PAIR ;

               NIL operation ;

               PAIR } } }