parameter (or

            (or

              (or %admin (or (unit %confirm_admin) (bool %pause)) (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_)

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

            (list %mint (pair

                         (pair %token_metadata (nat %token_id)

                                               (map %token_info string bytes))

                         (address %owner))));

storage (pair

          (pair

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

                         (option %pending_admin address))

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

                          (pair

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

                            (big_map %token_metadata nat

                                                     (pair (nat %token_id)

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

          (big_map %metadata string bytes));

code { LAMBDA

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

         unit

         { CAR ;

           CAR ;

           SENDER ;

           COMPARE ;

           NEQ ;

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

       PUSH string "FA2_TOKEN_UNDEFINED" ;

       PUSH string "FA2_INSUFFICIENT_BALANCE" ;

       SWAP ;

       DUP ;

       DUG 2 ;

       SWAP ;

       PAIR ;

       LAMBDA

         (pair (pair string string)

               (pair

                 (pair

                   (list (pair (option address)

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

                   (lambda

                     (pair (pair address address)

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

                     unit))

                 (pair (pair (big_map nat address) nat)

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

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

         (pair (list operation)

               (pair (pair (big_map nat address) nat)

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

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

         { { { DUP ; CAR ; DIP { CDR } } } ;

           { { DUP ; CAR ; DIP { CDR } } } ;

           DIG 2 ;

           { { DUP ; CAR ; DIP { CDR } } } ;

           { { DUP ; CAR ; DIP { CDR } } } ;

           { DIP 2 { DUP } ; DIG 3 } ;

           CAR ;

           CAR ;

           { DIP 3 { DUP } ; DIG 4 } ;

           CDR ;

           CAR ;

           PAIR ;

           DUG 2 ;

           DUP ;

           DUG 3 ;

           DIG 2 ;

           { { DUP ; CAR ; DIP { CDR } } } ;

           SWAP ;

           DIG 2 ;

           ITER { DUP ;

                  DUG 2 ;

                  CDR ;

                  ITER { SWAP ;

                         { DIP 2 { DUP } ; DIG 3 } ;

                         CAR ;

                         IF_NONE

                           { UNIT }

                           { { DIP 4 { DUP } ; DIG 5 } ;

                             { DIP 3 { DUP } ; DIG 4 } ;

                             CDR ;

                             CAR ;

                             PAIR ;

                             SENDER ;

                             DIG 2 ;

                             PAIR ;

                             PAIR ;

                             { DIP 5 { DUP } ; DIG 6 } ;

                             SWAP ;

                             EXEC } ;

                         DROP ;

                         PUSH nat 1 ;

                         { DIP 2 { DUP } ; DIG 3 } ;

                         CDR ;

                         CDR ;

                         COMPARE ;

                         GT ;

                         IF

                           { DROP 2 ; { DIP 5 { DUP } ; DIG 6 } ; FAILWITH }

                           { PUSH nat 0 ;

                             { DIP 2 { DUP } ; DIG 3 } ;

                             CDR ;

                             CDR ;

                             COMPARE ;

                             EQ ;

                             IF

                               { DUP ;

                                 DIG 2 ;

                                 CDR ;

                                 CAR ;

                                 GET ;

                                 IF_NONE

                                   { DROP ; { DIP 6 { DUP } ; DIG 7 } ; FAILWITH }

                                   { DROP } }

                               { SWAP ;

                                 DUP ;

                                 DUG 2 ;

                                 CDR ;

                                 CAR ;

                                 { DIP 3 { DUP } ; DIG 4 } ;

                                 CAR ;

                                 IF_NONE

                                   { DROP }

                                   { { DIP 2 { DUP } ; DIG 3 } ;

                                     { DIP 2 { DUP } ; DIG 3 } ;

                                     GET ;

                                     IF_NONE

                                       { DROP 3 ; { DIP 7 { DUP } ; DIG 8 } ; FAILWITH }

                                       { COMPARE ;

                                         EQ ;

                                         IF

                                           { NONE address ; SWAP ; UPDATE }

                                           { DROP 2 ; { DIP 6 { DUP } ; DIG 7 } ; FAILWITH } } } ;

                                 SWAP ;

                                 DUP ;

                                 DUG 2 ;

                                 CDR ;

                                 CAR ;

                                 DIG 2 ;

                                 CAR ;

                                 IF_NONE

                                   { DROP }

                                   { DIG 2 ; SWAP ; DIG 2 ; SWAP ; SOME ; SWAP ; UPDATE } } } } ;

                  SWAP ;

                  DROP } ;

           SWAP ;

           DROP ;

           SWAP ;

           DROP ;

           DIG 3 ;

           DROP ;

           DIG 3 ;

           DROP ;

           { DIP 2 { DUP } ; DIG 3 } ;

           CDR ;

           { DIP 3 { DUP } ; DIG 4 } ;

           CAR ;

           CDR ;

           DIG 2 ;

           PAIR ;

           PAIR ;

           DUG 2 ;

           DROP 2 ;

           NIL operation ;

           PAIR } ;

       SWAP ;

       APPLY ;

       DIG 3 ;

       { { DUP ; CAR ; DIP { CDR } } } ;

       IF_LEFT

         { IF_LEFT

             { DIG 2 ;

               DROP ;

               DIG 2 ;

               DROP ;

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

               { { DUP ; CAR ; DIP { CDR } } } ;

               { DIP 2 { DUP } ; DIG 3 } ;

               CDR ;

               DIG 3 ;

               CAR ;

               CDR ;

               DIG 3 ;

               PAIR ;

               PAIR ;

               SWAP ;

               PAIR }

             { DIG 4 ;

               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 ;

                       SWAP ;

                       DUP ;

                       DUG 2 ;

                       CAR ;

                       CAR ;

                       SWAP ;

                       DUP ;

                       CAR ;

                       MAP { { DIP 2 { DUP } ; DIG 3 } ;

                             SWAP ;

                             DUP ;

                             DUG 2 ;

                             CDR ;

                             GET ;

                             IF_NONE

                               { DROP ; { DIP 4 { DUP } ; DIG 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 }

                     { DIG 4 ;

                       DROP ;

                       MAP { DUP ;

                             CDR ;

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

                             SWAP ;

                             CAR ;

                             SOME ;

                             PAIR } ;

                       SWAP ;

                       LAMBDA

                         (pair (pair address address)

                               (pair nat

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

                         unit

                         { { { DUP ; CAR ; DIP { CDR } } } ;

                           { { DUP ; CAR ; DIP { CDR } } } ;

                           DIG 2 ;

                           { { DUP ; CAR ; DIP { CDR } } } ;

                           { DIP 3 { DUP } ; DIG 4 } ;

                           { DIP 3 { DUP } ; DIG 4 } ;

                           COMPARE ;

                           EQ ;

                           IF

                             { DROP 4 ; UNIT }

                             { DIG 3 ;

                               PAIR ;

                               DIG 2 ;

                               PAIR ;

                               MEM ;

                               IF

                                 { UNIT }

                                 { PUSH string "FA2_NOT_OPERATOR" ; FAILWITH } } } ;

                       DIG 2 ;

                       PAIR ;

                       PAIR ;

                       DIG 2 ;

                       SWAP ;

                       EXEC } }

                 { DIG 3 ;

                   DROP ;

                   DIG 3 ;

                   DROP ;

                   SWAP ;

                   DUP ;

                   DUG 2 ;

                   CDR ;

                   CAR ;

                   SWAP ;

                   SENDER ;

                   DUG 2 ;

                   ITER { SWAP ;

                          { DIP 2 { DUP } ; DIG 3 } ;

                          { DIP 2 { DUP } ; DIG 3 } ;

                          IF_LEFT {} {} ;

                          CAR ;

                          COMPARE ;

                          EQ ;

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

                          SWAP ;

                          IF_LEFT

                            { SWAP ;

                              UNIT ;

                              SOME ;

                              { DIP 2 { DUP } ; DIG 3 } ;

                              CDR ;

                              CDR ;

                              { DIP 3 { DUP } ; DIG 4 } ;

                              CDR ;

                              CAR ;

                              PAIR ;

                              DIG 3 ;

                              CAR ;

                              PAIR ;

                              UPDATE }

                            { DUP ;

                              DUG 2 ;

                              CDR ;

                              CDR ;

                              { DIP 2 { DUP } ; DIG 3 } ;

                              CDR ;

                              CAR ;

                              PAIR ;

                              DIG 2 ;

                              CAR ;

                              PAIR ;

                              NONE unit ;

                              SWAP ;

                              UPDATE } } ;

                   SWAP ;

                   DROP ;

                   SWAP ;

                   DUP ;

                   DUG 2 ;

                   CDR ;

                   CDR ;

                   SWAP ;

                   PAIR ;

                   SWAP ;

                   CAR ;

                   PAIR ;

                   NIL operation ;

                   PAIR } ;

               { { DUP ; CAR ; DIP { CDR } } } ;

               { DIP 2 { DUP } ; DIG 3 } ;

               CDR ;

               DIG 2 ;

               DIG 3 ;

               CAR ;

               CAR ;

               PAIR ;

               PAIR ;

               SWAP ;

               PAIR } }

         { DIG 3 ;

           DROP ;

           SWAP ;

           DUP ;

           DUG 2 ;

           CAR ;

           CAR ;

           DIG 4 ;

           SWAP ;

           EXEC ;

           DROP ;

           SWAP ;

           DUP ;

           DUG 2 ;

           CAR ;

           CDR ;

           NIL (pair (option address) (pair nat nat)) ;

           PAIR ;

           SWAP ;

           ITER { DUP ;

                  DUG 2 ;

                  CAR ;

                  CAR ;

                  SWAP ;

                  DUP ;

                  DUG 2 ;

                  CDR ;

                  CAR ;

                  CAR ;

                  SWAP ;

                  DUP ;

                  DUG 2 ;

                  MEM ;

                  IF

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

                    { PUSH nat 1 ;

                      SWAP ;

                      DUP ;

                      DUG 2 ;

                      ADD ;

                      { DIP 2 { DUP } ; DIG 3 } ;

                      CDR ;

                      { DIP 3 { DUP } ; DIG 4 } ;

                      CDR ;

                      CDR ;

                      CDR ;

                      { DIP 5 { DUP } ; DIG 6 } ;

                      CAR ;

                      { DIP 4 { DUP } ; DIG 5 } ;

                      SWAP ;

                      SOME ;

                      SWAP ;

                      UPDATE ;

                      SWAP ;

                      DUP ;

                      DUG 2 ;

                      CDR ;

                      CAR ;

                      PAIR ;

                      SWAP ;

                      CAR ;

                      PAIR ;

                      DUP ;

                      CDR ;

                      DUG 2 ;

                      CAR ;

                      CAR ;

                      PAIR ;

                      PAIR ;

                      DIG 2 ;

                      CAR ;

                      PUSH nat 1 ;

                      DIG 3 ;

                      PAIR ;

                      DIG 3 ;

                      CDR ;

                      SOME ;

                      PAIR ;

                      CONS ;

                      PAIR } } ;

           DUP ;

           CDR ;

           LAMBDA

             (pair (pair address address)

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

             unit

             { DROP ; UNIT } ;

           NIL (pair (option address) (list (pair (option address) (pair nat nat)))) ;

           DIG 3 ;

           CAR ;

           NONE address ;

           PAIR ;

           CONS ;

           PAIR ;

           PAIR ;

           DIG 2 ;

           SWAP ;

           EXEC ;

           { { DUP ; CAR ; DIP { CDR } } } ;

           { DIP 2 { DUP } ; DIG 3 } ;

           CDR ;

           DIG 2 ;

           DIG 3 ;

           CAR ;

           CAR ;

           PAIR ;

           PAIR ;

           SWAP ;

           PAIR } }