parameter (or

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

              (pair %mint

                (pair %mint_tx (address %owner) (pair (nat %token_id) (nat %amount)))

                (pair (pair %token_meta (nat %token_id) (map %token_info string bytes))

                      (pair %rgb (nat %token_id)

                                 (pair (address %creater)

                                       (pair (bytes %creater_name)

                                             (pair (bytes %token_name)

                                                   (pair (bytes %token_description)

                                                         (string %rgb)))))))))

            (or

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

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

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

                    (pair (nat %token_index)

                          (pair (big_map %token_total_supply nat nat)

                                (pair

                                  (big_map %token_metadata nat

                                                           (pair (nat %token_id)

                                                                 (map %token_info string

                                                                                  bytes)))

                                  (pair (big_map %metadata string bytes)

                                        (big_map %rgb nat

                                                      (pair (nat %token_id)

                                                            (pair (address %creater)

                                                                  (pair

                                                                    (bytes %creater_name)

                                                                    (pair

                                                                      (bytes %token_name)

                                                                      (pair

                                                                        (bytes %token_description)

                                                                        (string %rgb)))))))))))));

code { PUSH string "FA2_TOKEN_UNDEFINED" ;

       LAMBDA

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

         nat

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

       DUP ;

       LAMBDA

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

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

         (big_map (pair address nat) nat)

         { UNPAIR ;

           SWAP ;

           UNPAIR ;

           UNPAIR ;

           DIG 2 ;

           UNPAIR ;

           DIG 3 ;

           DIG 3 ;

           PAIR ;

           DUP 3 ;

           SWAP ;

           DUP ;

           DUG 2 ;

           PAIR ;

           DIG 4 ;

           SWAP ;

           EXEC ;

           DIG 2 ;

           ADD ;

           PUSH nat 0 ;

           SWAP ;

           DUP ;

           DUG 2 ;

           COMPARE ;

           EQ ;

           IF

             { DROP ; NONE nat ; SWAP ; UPDATE }

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

       SWAP ;

       APPLY ;

       DIG 3 ;

       UNPAIR ;

       IF_LEFT

         { IF_LEFT

             { DIG 2 ;

               DROP ;

               SWAP ;

               DUP ;

               DUG 2 ;

               GET 9 ;

               DUP 3 ;

               CAR ;

               DIG 2 ;

               DUP ;

               CAR ;

               MAP { DUP 4 ;

                     SWAP ;

                     DUP ;

                     DUG 2 ;

                     CDR ;

                     MEM ;

                     NOT ;

                     IF

                       { DROP ; DUP 6 ; FAILWITH }

                       { DUP 3 ; SWAP ; DUP ; DUG 2 ; CDR ; DUP 3 ; CAR ; PAIR ; PAIR ; DUP 7 ; SWAP ; EXEC ; SWAP ; PAIR } } ;

               DIG 2 ;

               DIG 3 ;

               DIG 5 ;

               DIG 6 ;

               DROP 4 ;

               SWAP ;

               CDR ;

               PUSH mutez 0 ;

               DIG 2 ;

               TRANSFER_TOKENS ;

               SWAP ;

               NIL operation ;

               DIG 2 ;

               CONS ;

               PAIR }

             { DIG 3 ;

               DIG 4 ;

               DROP 2 ;

               PUSH nat 1 ;

               DUP 3 ;

               GET 5 ;

               ADD ;

               DUP 3 ;

               GET 9 ;

               SWAP ;

               DUP ;

               DUG 2 ;

               GET ;

               IF_NONE

                 { PUSH nat 384 ;

                   DUP 3 ;

                   GET 4 ;

                   GET 10 ;

                   SIZE ;

                   COMPARE ;

                   NEQ ;

                   IF { PUSH string "Pixel size must be 8 x 8" ; FAILWITH } {} ;

                   SWAP ;

                   DUP ;

                   DUP ;

                   DUG 3 ;

                   GET 4 ;

                   DUP 3 ;

                   UPDATE 1 ;

                   UPDATE 4 ;

                   DUP ;

                   GET 3 ;

                   DUP 3 ;

                   UPDATE 1 ;

                   UPDATE 3 ;

                   DUP 4 ;

                   CAR ;

                   DUP 4 ;

                   CAR ;

                   GET 4 ;

                   PAIR ;

                   DUP 3 ;

                   DUP 5 ;

                   CAR ;

                   CAR ;

                   PAIR ;

                   PAIR ;

                   DIG 5 ;

                   SWAP ;

                   EXEC ;

                   DUP 5 ;

                   DUP 4 ;

                   UPDATE 5 ;

                   SWAP ;

                   UPDATE 1 ;

                   DUP 5 ;

                   GET 9 ;

                   DUP 3 ;

                   GET 3 ;

                   DUP 5 ;

                   SWAP ;

                   SOME ;

                   SWAP ;

                   UPDATE ;

                   UPDATE 9 ;

                   DUP 5 ;

                   GET 7 ;

                   DIG 4 ;

                   CAR ;

                   GET 4 ;

                   DUP 5 ;

                   SWAP ;

                   SOME ;

                   SWAP ;

                   UPDATE ;

                   UPDATE 7 ;

                   DIG 3 ;

                   GET 12 ;

                   DIG 2 ;

                   GET 4 ;

                   DIG 3 ;

                   SWAP ;

                   SOME ;

                   SWAP ;

                   UPDATE ;

                   UPDATE 12 }

                 { DROP 5 ; PUSH string "FA2_DUP_TOKEN_ID" ; FAILWITH } ;

               NIL operation ;

               PAIR } }

         { IF_LEFT

             { SWAP ;

               DUP ;

               DUG 2 ;

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

               DIG 2 ;

               DUP 3 ;

               CAR ;

               SWAP ;

               ITER { DUP ;

                      DUG 2 ;

                      CDR ;

                      ITER { SWAP ;

                             DUP 5 ;

                             GET 9 ;

                             DUP 3 ;

                             GET 3 ;

                             MEM ;

                             NOT ;

                             IF

                               { DROP 2 ; DUP 7 ; FAILWITH }

                               { DUP 5 ;

                                 GET 3 ;

                                 DUP 3 ;

                                 GET 3 ;

                                 PAIR ;

                                 SENDER ;

                                 DUP 5 ;

                                 CAR ;

                                 PAIR ;

                                 PAIR ;

                                 DUP 5 ;

                                 SWAP ;

                                 EXEC ;

                                 DROP ;

                                 SWAP ;

                                 DUP ;

                                 DUG 2 ;

                                 GET 4 ;

                                 PAIR ;

                                 SWAP ;

                                 DUP ;

                                 DUG 2 ;

                                 GET 3 ;

                                 DUP 4 ;

                                 CAR ;

                                 DIG 2 ;

                                 UNPAIR ;

                                 DIG 3 ;

                                 DIG 3 ;

                                 PAIR ;

                                 DUP 3 ;

                                 SWAP ;

                                 DUP ;

                                 DUG 2 ;

                                 PAIR ;

                                 DUP 11 ;

                                 SWAP ;

                                 EXEC ;

                                 DIG 2 ;

                                 SWAP ;

                                 SUB ;

                                 ISNAT ;

                                 IF_NONE

                                   { DROP 2 ;

                                     PUSH string "FA2_INSUFFICIENT_BALANCE" ;

                                     FAILWITH }

                                   { PUSH nat 0 ;

                                     SWAP ;

                                     DUP ;

                                     DUG 2 ;

                                     COMPARE ;

                                     EQ ;

                                     IF

                                       { DROP ; NONE nat ; SWAP ; UPDATE }

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

                                 SWAP ;

                                 DUP ;

                                 DUG 2 ;

                                 GET 4 ;

                                 PAIR ;

                                 SWAP ;

                                 DUP ;

                                 DUG 2 ;

                                 GET 3 ;

                                 DIG 2 ;

                                 CAR ;

                                 PAIR ;

                                 PAIR ;

                                 DUP 6 ;

                                 SWAP ;

                                 EXEC } } ;

                      SWAP ;

                      DROP } ;

               SWAP ;

               DIG 2 ;

               DIG 4 ;

               DIG 5 ;

               DIG 6 ;

               DROP 5 ;

               UPDATE 1 ;

               NIL operation ;

               PAIR }

             { DIG 2 ;

               DIG 3 ;

               DIG 4 ;

               DROP 3 ;

               SWAP ;

               DUP ;

               DUG 2 ;

               GET 3 ;

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

               SWAP ;

               DROP ;

               UPDATE 3 ;

               NIL operation ;

               PAIR } } }