parameter (or

            (or (or %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_) (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 %tokens (list %burn_tokens (pair (address %owner) (nat %amount)))

                        (list %mint_tokens (pair (address %owner) (nat %amount)))));

storage (pair

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

                (pair %assets

                  (pair (big_map %ledger address nat)

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

                  (big_map %token_metadata nat

                                           (pair (nat %token_id)

                                                 (map %token_info string bytes)))

                  (nat %total_supply)))

          (big_map %metadata string bytes));

code { PUSH string "FA2_TOKEN_UNDEFINED" ;

       PUSH string "FA2_INSUFFICIENT_BALANCE" ;

       LAMBDA

         (pair address (big_map address nat))

         nat

         { UNPAIR ; GET ; IF_NONE { PUSH nat 0 } {} } ;

       LAMBDA

         (pair (pair (lambda (pair address (big_map address nat)) nat) string)

               (pair (pair address int) (big_map address nat)))

         (big_map address nat)

         { UNPAIR ;

           UNPAIR ;

           DIG 2 ;

           UNPAIR ;

           UNPAIR ;

           DUP 3 ;

           DUP 2 ;

           PAIR ;

           DIG 4 ;

           SWAP ;

           EXEC ;

           DIG 2 ;

           ADD ;

           ISNAT ;

           IF_NONE

             { DROP 2 ; FAILWITH }

             { DIG 3 ;

               DROP ;

               PUSH nat 0 ;

               DUP 2 ;

               COMPARE ;

               EQ ;

               IF

                 { DROP ; NONE nat ; SWAP ; UPDATE }

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

       DUP 3 ;

       DUP 3 ;

       PAIR ;

       APPLY ;

       LAMBDA

         (pair

           (pair

             (lambda (pair (pair address int) (big_map address nat))

                     (big_map address nat))

             string)

           (pair

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

                   (lambda

                     (pair (pair address address) nat

                           (big_map (pair address address nat) unit))

                     unit))

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

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

             nat))

         (pair (list operation)

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

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

               nat)

         { UNPAIR ;

           UNPAIR ;

           DIG 2 ;

           UNPAIR ;

           UNPAIR ;

           DUP 3 ;

           CAR ;

           CAR ;

           SWAP ;

           ITER { SWAP ;

                  SENDER ;

                  SWAP ;

                  DUP 3 ;

                  CDR ;

                  ITER { SWAP ;

                         PUSH nat 0 ;

                         DUP 3 ;

                         GET 3 ;

                         COMPARE ;

                         NEQ ;

                         IF

                           { DROP 2 ; DUP 6 ; FAILWITH }

                           { DUP 4 ;

                             CAR ;

                             IF_NONE

                               {}

                               { DUP 7 ;

                                 CAR ;

                                 CDR ;

                                 DUP 4 ;

                                 GET 3 ;

                                 PAIR ;

                                 DUP 5 ;

                                 DUP 3 ;

                                 PAIR ;

                                 PAIR ;

                                 DUP 7 ;

                                 SWAP ;

                                 EXEC ;

                                 DROP ;

                                 SWAP ;

                                 DUP 3 ;

                                 GET 4 ;

                                 NEG ;

                                 DIG 2 ;

                                 PAIR ;

                                 PAIR ;

                                 DUP 7 ;

                                 SWAP ;

                                 EXEC } ;

                             DUP 2 ;

                             CAR ;

                             IF_NONE

                               { SWAP ; DROP }

                               { SWAP ; DIG 2 ; GET 4 ; INT ; DIG 2 ; PAIR ; PAIR ; DUP 6 ; SWAP ; EXEC } } } ;

                  SWAP ;

                  DIG 2 ;

                  DROP 2 } ;

           SWAP ;

           DIG 3 ;

           DIG 4 ;

           DROP 3 ;

           DUP 2 ;

           CDR ;

           DIG 2 ;

           CAR ;

           CDR ;

           DIG 2 ;

           PAIR ;

           PAIR ;

           NIL operation ;

           PAIR } ;

       DUP 5 ;

       DUP 3 ;

       PAIR ;

       APPLY ;

       SWAP ;

       DROP ;

       LAMBDA (list (pair address nat)) nat { PUSH nat 0 ; SWAP ; ITER { CDR ; ADD } } ;

       LAMBDA

         (pair address bool)

         unit

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

       DIG 6 ;

       UNPAIR ;

       PUSH mutez 0 ;

       AMOUNT ;

       COMPARE ;

       GT ;

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

       IF_LEFT

         { DIG 3 ;

           DIG 6 ;

           DROP 2 ;

           IF_LEFT

             { DIG 3 ;

               DIG 4 ;

               DIG 5 ;

               DROP 3 ;

               DUP 2 ;

               CAR ;

               CAR ;

               DIG 3 ;

               SWAP ;

               EXEC ;

               DROP ;

               DUP 2 ;

               CAR ;

               CAR ;

               SWAP ;

               IF_LEFT { SWAP ; CAR } { SWAP ; CDR ; SWAP } ;

               PAIR ;

               NIL operation ;

               DUP 3 ;

               CDR ;

               DIG 3 ;

               CAR ;

               CDR ;

               DIG 3 }

             { DIG 2 ;

               DROP ;

               DUP 2 ;

               CAR ;

               CAR ;

               CDR ;

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

               DUP 2 ;

               CAR ;

               CDR ;

               SWAP ;

               IF_LEFT

                 { IF_LEFT

                     { DIG 3 ;

                       DROP ;

                       DUP ;

                       CAR ;

                       MAP { PUSH nat 0 ;

                             DUP 2 ;

                             CDR ;

                             COMPARE ;

                             NEQ ;

                             IF

                               { DROP ; DUP 5 ; FAILWITH }

                               { DUP 3 ; CAR ; CAR ; DUP 2 ; CAR ; PAIR ; DUP 6 ; SWAP ; EXEC ; SWAP ; PAIR } } ;

                       DIG 4 ;

                       DIG 5 ;

                       DROP 2 ;

                       SWAP ;

                       CDR ;

                       PUSH mutez 0 ;

                       DIG 2 ;

                       TRANSFER_TOKENS ;

                       SWAP ;

                       NIL operation ;

                       DIG 2 ;

                       CONS ;

                       PAIR }

                     { DIG 4 ;

                       DIG 5 ;

                       DROP 2 ;

                       MAP { DUP ;

                             CDR ;

                             MAP { DUP ; GET 4 ; DUP 2 ; GET 3 ; DIG 2 ; CAR ; SOME ; PAIR 3 } ;

                             SWAP ;

                             CAR ;

                             SOME ;

                             PAIR } ;

                       SWAP ;

                       LAMBDA

                         (pair (pair address address) nat

                               (big_map (pair address 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 } } } ;

                       DIG 2 ;

                       PAIR ;

                       PAIR ;

                       DIG 2 ;

                       SWAP ;

                       EXEC } }

                 { DIG 3 ;

                   DIG 4 ;

                   DIG 5 ;

                   DROP 3 ;

                   SENDER ;

                   DUP 3 ;

                   CAR ;

                   CDR ;

                   DIG 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 ; GET 4 ; DUP 4 ; GET 3 ; PAIR ; DIG 3 ; CAR ; PAIR ; UPDATE }

                            { SWAP ;

                              DUP 2 ;

                              GET 4 ;

                              DUP 3 ;

                              GET 3 ;

                              PAIR ;

                              DIG 2 ;

                              CAR ;

                              PAIR ;

                              NONE unit ;

                              SWAP ;

                              UPDATE } } ;

                   SWAP ;

                   DROP ;

                   DUP 2 ;

                   CDR ;

                   SWAP ;

                   DIG 2 ;

                   CAR ;

                   CAR ;

                   PAIR ;

                   PAIR ;

                   NIL operation ;

                   PAIR } ;

               UNPAIR ;

               DUP 3 ;

               CDR ;

               DIG 2 ;

               DIG 3 ;

               CAR ;

               CAR } }

         { DIG 5 ;

           DIG 7 ;

           DROP 2 ;

           DUP 2 ;

           CAR ;

           CAR ;

           DIG 3 ;

           SWAP ;

           EXEC ;

           DROP ;

           DUP 2 ;

           CAR ;

           CDR ;

           SWAP ;

           IF_LEFT

             { DUP ;

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

                     DUP 2 ;

                     CDR ;

                     PUSH nat 0 ;

                     NONE address ;

                     PAIR 3 ;

                     CONS ;

                     SWAP ;

                     CAR ;

                     SOME ;

                     PAIR } ;

               DUP 3 ;

               LAMBDA

                 (pair (pair address address) nat

                       (big_map (pair address address nat) unit))

                 unit

                 { DROP ; UNIT } ;

               DIG 2 ;

               PAIR ;

               PAIR ;

               DIG 5 ;

               SWAP ;

               EXEC ;

               UNPAIR ;

               DIG 2 ;

               DIG 5 ;

               SWAP ;

               EXEC ;

               DIG 3 ;

               CDR ;

               CDR ;

               SUB ;

               ISNAT ;

               IF_NONE { DIG 3 ; FAILWITH } { DIG 4 ; DROP } ;

               DUP 3 ;

               CDR ;

               CAR ;

               PAIR ;

               DIG 2 ;

               CAR }

             { DIG 5 ;

               DROP ;

               DUP ;

               MAP { DUP ; CDR ; PUSH nat 0 ; DIG 2 ; CAR ; SOME ; PAIR 3 } ;

               DUP 3 ;

               LAMBDA

                 (pair (pair address address) nat

                       (big_map (pair address address nat) unit))

                 unit

                 { DROP ; UNIT } ;

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

               DIG 3 ;

               NONE address ;

               PAIR ;

               CONS ;

               PAIR ;

               PAIR ;

               DIG 5 ;

               SWAP ;

               EXEC ;

               UNPAIR ;

               DIG 2 ;

               DIG 5 ;

               SWAP ;

               EXEC ;

               DIG 3 ;

               CDR ;

               CDR ;

               ADD ;

               DUP 3 ;

               CDR ;

               CAR ;

               PAIR ;

               DIG 2 ;

               CAR } ;

           PAIR ;

           SWAP ;

           DUP 3 ;

           CDR ;

           DIG 2 ;

           DIG 3 ;

           CAR ;

           CAR } ;

       PAIR ;

       PAIR ;

       SWAP ;

       PAIR }