parameter (or

            (or %adminAction

              (or

                (pair %mint (address %address)

                            (pair (nat %amount)

                                  (pair (nat %token_id) (map %metadata string bytes))))

                (pair %reveal (pair bytes nat) nat))

              (address %updateAdmin))

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

storage (pair (big_map %metadata string bytes)

              (pair

                (pair %assets

                  (pair

                    (pair (big_map %ledger (pair address nat) nat) (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 %token_total_supply nat nat))

                (address %admin)));

code { LAMBDA

         (pair nat

               (pair

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

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

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

                 (big_map nat nat)))

         nat

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

       LAMBDA

         (pair (pair address nat)

               (pair

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

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

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

                 (big_map nat nat)))

         nat

         { UNPAIR ; UNPAIR ; DIG 2 ; CAR ; CAR ; CAR ; DUG 2 ; PAIR ; GET ; IF_NONE { PUSH nat 0 } {} } ;

       LAMBDA

         address

         unit

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

       LAMBDA

         (pair nat

               (pair

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

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

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

                 (big_map nat nat)))

         unit

         { UNPAIR ;

           SWAP ;

           CAR ;

           CAR ;

           CDR ;

           SWAP ;

           COMPARE ;

           GE ;

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

       NIL operation ;

       DIG 5 ;

       UNPAIR ;

       IF_LEFT

         { DIG 4 ;

           DROP ;

           PUSH bool False ;

           DUP 3 ;

           GET 4 ;

           SENDER ;

           COMPARE ;

           EQ ;

           COMPARE ;

           EQ ;

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

           IF_LEFT

             { IF_LEFT

                 { PUSH nat 0 ;

                   DUP 3 ;

                   GET 3 ;

                   DUP 3 ;

                   GET 5 ;

                   PAIR ;

                   DUP 8 ;

                   SWAP ;

                   EXEC ;

                   COMPARE ;

                   GT ;

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

                   SWAP ;

                   DUP ;

                   DUP ;

                   DUG 3 ;

                   GET 3 ;

                   DUP ;

                   CDR ;

                   DIG 4 ;

                   GET 3 ;

                   CAR ;

                   CDR ;

                   CDR ;

                   DUP 5 ;

                   GET 6 ;

                   DUP 6 ;

                   GET 5 ;

                   PAIR ;

                   DUP 6 ;

                   GET 5 ;

                   SWAP ;

                   SOME ;

                   SWAP ;

                   UPDATE ;

                   DUP 3 ;

                   CAR ;

                   CDR ;

                   CAR ;

                   PAIR ;

                   DIG 2 ;

                   CAR ;

                   CAR ;

                   PAIR ;

                   PAIR ;

                   UPDATE 3 ;

                   DUP ;

                   GET 3 ;

                   DUP 3 ;

                   GET 3 ;

                   PAIR ;

                   DUP 3 ;

                   GET 5 ;

                   DIG 3 ;

                   CAR ;

                   DIG 2 ;

                   UNPAIR ;

                   SWAP ;

                   DUP ;

                   DUG 2 ;

                   DUP 5 ;

                   PAIR ;

                   DIG 7 ;

                   SWAP ;

                   EXEC ;

                   DROP ;

                   SWAP ;

                   DUP ;

                   DUG 2 ;

                   CDR ;

                   DUP 3 ;

                   CAR ;

                   CDR ;

                   DUP 4 ;

                   CAR ;

                   CAR ;

                   CDR ;

                   DUP 5 ;

                   CAR ;

                   CAR ;

                   CAR ;

                   DUP 5 ;

                   DIG 6 ;

                   DUP 9 ;

                   DUP 9 ;

                   PAIR ;

                   PAIR ;

                   DIG 11 ;

                   SWAP ;

                   EXEC ;

                   ADD ;

                   DUP 8 ;

                   DIG 7 ;

                   PAIR ;

                   SWAP ;

                   SOME ;

                   SWAP ;

                   UPDATE ;

                   PAIR ;

                   PAIR ;

                   PAIR ;

                   DUP ;

                   CDR ;

                   DUG 2 ;

                   DUP ;

                   DUG 3 ;

                   DUP 5 ;

                   PAIR ;

                   DIG 7 ;

                   SWAP ;

                   EXEC ;

                   ADD ;

                   DIG 3 ;

                   SWAP ;

                   SOME ;

                   SWAP ;

                   UPDATE ;

                   SWAP ;

                   CAR ;

                   PAIR ;

                   UPDATE 3 ;

                   SWAP ;

                   PAIR }

                 { DIG 3 ;

                   DIG 4 ;

                   DIG 5 ;

                   DROP 3 ;

                   DUP ;

                   DUG 2 ;

                   CDR ;

                   PAIR ;

                   SWAP ;

                   DUP ;

                   DUG 2 ;

                   CAR ;

                   CDR ;

                   DIG 2 ;

                   CAR ;

                   CAR ;

                   DIG 2 ;

                   UNPAIR ;

                   DIG 3 ;

                   INT ;

                   DIG 2 ;

                   PAIR ;

                   DUG 2 ;

                   PAIR ;

                   LAMBDA

                     (pair (pair nat bytes)

                           (pair

                             (pair (big_map string bytes)

                                   (pair

                                     (pair

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

                                             (pair

                                               (big_map

                                                 (pair address (pair address nat))

                                                 unit)

                                               (big_map nat

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

                                       (big_map nat nat))

                                     address))

                             int))

                     (pair bool

                           (pair

                             (pair (big_map string bytes)

                                   (pair

                                     (pair

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

                                             (pair

                                               (big_map

                                                 (pair address (pair address nat))

                                                 unit)

                                               (big_map nat

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

                                       (big_map nat nat))

                                     address))

                             int))

                     { UNPAIR ;

                       UNPAIR ;

                       DIG 2 ;

                       DUP ;

                       CDR ;

                       DIG 2 ;

                       INT ;

                       SWAP ;

                       DUP ;

                       DUG 2 ;

                       COMPARE ;

                       LE ;

                       IF

                         { SWAP ;

                           CAR ;

                           SWAP ;

                           DUP ;

                           DUG 2 ;

                           ABS ;

                           PUSH string ".json" ;

                           PUSH string "" ;

                           DUP 3 ;

                           PAIR ;

                           LAMBDA

                             (pair nat string)

                             (pair bool (pair nat string))

                             { DUP ;

                               CAR ;

                               PUSH nat 0 ;

                               SWAP ;

                               DUP ;

                               DUG 2 ;

                               COMPARE ;

                               GT ;

                               IF

                                 { SWAP ;

                                   CDR ;

                                   PUSH nat 10 ;

                                   DUP 3 ;

                                   EDIV ;

                                   IF_NONE { PUSH string "MOD by 0" ; FAILWITH } {} ;

                                   CDR ;

                                   EMPTY_MAP nat string ;

                                   PUSH string "9" ;

                                   SOME ;

                                   PUSH nat 9 ;

                                   UPDATE ;

                                   PUSH string "8" ;

                                   SOME ;

                                   PUSH nat 8 ;

                                   UPDATE ;

                                   PUSH string "7" ;

                                   SOME ;

                                   PUSH nat 7 ;

                                   UPDATE ;

                                   PUSH string "6" ;

                                   SOME ;

                                   PUSH nat 6 ;

                                   UPDATE ;

                                   PUSH string "5" ;

                                   SOME ;

                                   PUSH nat 5 ;

                                   UPDATE ;

                                   PUSH string "4" ;

                                   SOME ;

                                   PUSH nat 4 ;

                                   UPDATE ;

                                   PUSH string "3" ;

                                   SOME ;

                                   PUSH nat 3 ;

                                   UPDATE ;

                                   PUSH string "2" ;

                                   SOME ;

                                   PUSH nat 2 ;

                                   UPDATE ;

                                   PUSH string "1" ;

                                   SOME ;

                                   PUSH nat 1 ;

                                   UPDATE ;

                                   PUSH string "0" ;

                                   SOME ;

                                   PUSH nat 0 ;

                                   UPDATE ;

                                   SWAP ;

                                   GET ;

                                   IF_NONE { PUSH string "INVALID_NAT" ; FAILWITH } {} ;

                                   CONCAT ;

                                   PUSH nat 10 ;

                                   DIG 2 ;

                                   EDIV ;

                                   IF_NONE { PUSH string "DIV by 0" ; FAILWITH } {} ;

                                   CAR ;

                                   PAIR ;

                                   PUSH bool True ;

                                   PAIR }

                                 { DROP ; PUSH bool False ; PAIR } } ;

                           SWAP ;

                           PUSH bool True ;

                           LOOP { DIP { DUP } ; EXEC ; UNPAIR } ;

                           SWAP ;

                           DROP ;

                           CDR ;

                           PUSH string "" ;

                           SWAP ;

                           DUP ;

                           DUG 2 ;

                           COMPARE ;

                           EQ ;

                           IF { DROP ; PUSH string "0" } {} ;

                           CONCAT ;

                           PACK ;

                           DIG 2 ;

                           DUP ;

                           DUP ;

                           DUG 4 ;

                           GET 3 ;

                           DUP ;

                           CDR ;

                           DIG 5 ;

                           GET 3 ;

                           CAR ;

                           CDR ;

                           CDR ;

                           EMPTY_MAP string bytes ;

                           DUP 6 ;

                           PUSH nat 6 ;

                           DIG 7 ;

                           SIZE ;

                           SUB ;

                           ABS ;

                           PUSH nat 6 ;

                           SLICE ;

                           IF_NONE { PUSH string "SLICE" ; FAILWITH } {} ;

                           DIG 8 ;

                           CONCAT ;

                           SOME ;

                           PUSH string "" ;

                           UPDATE ;

                           DUP 6 ;

                           PAIR ;

                           DIG 5 ;

                           SWAP ;

                           SOME ;

                           SWAP ;

                           UPDATE ;

                           DUP 3 ;

                           CAR ;

                           CDR ;

                           CAR ;

                           PAIR ;

                           DIG 2 ;

                           CAR ;

                           CAR ;

                           PAIR ;

                           PAIR ;

                           UPDATE 3 ;

                           PUSH int 1 ;

                           DIG 2 ;

                           ADD ;

                           SWAP ;

                           PAIR ;

                           PUSH bool True ;

                           PAIR }

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

                   SWAP ;

                   APPLY ;

                   SWAP ;

                   PUSH bool True ;

                   LOOP { DIP { DUP } ; EXEC ; UNPAIR } ;

                   SWAP ;

                   DROP ;

                   CAR ;

                   SWAP ;

                   PAIR } }

             { DIG 3 ; DIG 4 ; DIG 5 ; DROP 3 ; UPDATE 4 ; SWAP ; PAIR } }

         { DIG 2 ;

           DIG 6 ;

           DROP 2 ;

           SWAP ;

           DUP ;

           DUG 2 ;

           GET 3 ;

           SWAP ;

           IF_LEFT

             { DIG 4 ;

               DROP ;

               IF_LEFT

                 { SWAP ;

                   DUP ;

                   DIG 2 ;

                   NIL (pair (pair address nat) nat) ;

                   SWAP ;

                   DUP ;

                   DUG 2 ;

                   CAR ;

                   ITER { SWAP ;

                          DUP 4 ;

                          DUP 3 ;

                          CDR ;

                          PAIR ;

                          DUP 8 ;

                          SWAP ;

                          EXEC ;

                          DROP ;

                          SWAP ;

                          DUP ;

                          DUG 2 ;

                          DUP 5 ;

                          DUP 4 ;

                          CDR ;

                          DIG 4 ;

                          CAR ;

                          PAIR ;

                          PAIR ;

                          DUP 9 ;

                          SWAP ;

                          EXEC ;

                          SWAP ;

                          PAIR ;

                          CONS } ;

                   DIG 2 ;

                   DIG 5 ;

                   DIG 6 ;

                   DROP 3 ;

                   NIL operation ;

                   DIG 2 ;

                   CDR ;

                   PUSH mutez 0 ;

                   DIG 3 ;

                   TRANSFER_TOKENS ;

                   CONS ;

                   PAIR }

                 { ITER { DUP ;

                          DUG 2 ;

                          CDR ;

                          ITER { SWAP ;

                                 DUP ;

                                 DUP 3 ;

                                 GET 3 ;

                                 PAIR ;

                                 SENDER ;

                                 DUP 5 ;

                                 CAR ;

                                 DIG 2 ;

                                 UNPAIR ;

                                 PUSH bool False ;

                                 DIG 2 ;

                                 CAR ;

                                 CDR ;

                                 CAR ;

                                 DIG 2 ;

                                 DUP 5 ;

                                 PAIR ;

                                 DUP 4 ;

                                 PAIR ;

                                 MEM ;

                                 COMPARE ;

                                 EQ ;

                                 DUG 2 ;

                                 COMPARE ;

                                 NEQ ;

                                 AND ;

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

                                 DUP ;

                                 DUP 3 ;

                                 GET 3 ;

                                 PAIR ;

                                 DUP 6 ;

                                 SWAP ;

                                 EXEC ;

                                 DROP ;

                                 DUP ;

                                 DUP 3 ;

                                 GET 3 ;

                                 DUP 5 ;

                                 CAR ;

                                 PAIR ;

                                 PAIR ;

                                 DUP 7 ;

                                 SWAP ;

                                 EXEC ;

                                 DUP 3 ;

                                 GET 4 ;

                                 SWAP ;

                                 DUP ;

                                 DUG 2 ;

                                 COMPARE ;

                                 LT ;

                                 IF

                                   { PUSH string "FA2_INSUFFICIENT_BALANCE" ; FAILWITH }

                                   {} ;

                                 SWAP ;

                                 DUP ;

                                 DUG 2 ;

                                 CDR ;

                                 DUP 3 ;

                                 CAR ;

                                 CDR ;

                                 DUP 4 ;

                                 CAR ;

                                 CAR ;

                                 CDR ;

                                 DIG 4 ;

                                 CAR ;

                                 CAR ;

                                 CAR ;

                                 DUP 6 ;

                                 GET 4 ;

                                 DIG 5 ;

                                 SUB ;

                                 ABS ;

                                 DUP 6 ;

                                 GET 3 ;

                                 DUP 8 ;

                                 CAR ;

                                 PAIR ;

                                 SWAP ;

                                 SOME ;

                                 SWAP ;

                                 UPDATE ;

                                 PAIR ;

                                 PAIR ;

                                 PAIR ;

                                 DUP ;

                                 DUP 3 ;

                                 GET 3 ;

                                 DUP 4 ;

                                 CAR ;

                                 PAIR ;

                                 PAIR ;

                                 DUP 7 ;

                                 SWAP ;

                                 EXEC ;

                                 SWAP ;

                                 DUP ;

                                 DUG 2 ;

                                 CDR ;

                                 DUP 3 ;

                                 CAR ;

                                 CDR ;

                                 DUP 4 ;

                                 CAR ;

                                 CAR ;

                                 CDR ;

                                 DIG 4 ;

                                 CAR ;

                                 CAR ;

                                 CAR ;

                                 DUP 6 ;

                                 GET 4 ;

                                 DIG 5 ;

                                 ADD ;

                                 DUP 6 ;

                                 GET 3 ;

                                 DIG 6 ;

                                 CAR ;

                                 PAIR ;

                                 SWAP ;

                                 SOME ;

                                 SWAP ;

                                 UPDATE ;

                                 PAIR ;

                                 PAIR ;

                                 PAIR } ;

                          SWAP ;

                          DROP } ;

                   DIG 2 ;

                   DIG 3 ;

                   DROP 2 ;

                   NIL operation ;

                   PAIR } }

             { DIG 5 ;

               DROP ;

               ITER { IF_LEFT

                        { SWAP ;

                          DUP ;

                          DUG 2 ;

                          SWAP ;

                          DUP ;

                          DUG 2 ;

                          GET 4 ;

                          PAIR ;

                          DUP 5 ;

                          SWAP ;

                          EXEC ;

                          DROP ;

                          DUP ;

                          CAR ;

                          DUP 6 ;

                          SWAP ;

                          EXEC ;

                          DROP ;

                          SWAP ;

                          DUP ;

                          DUG 2 ;

                          CDR ;

                          DUP 3 ;

                          CAR ;

                          CDR ;

                          CDR ;

                          DUP 4 ;

                          CAR ;

                          CDR ;

                          CAR ;

                          UNIT ;

                          SOME ;

                          DUP 5 ;

                          GET 4 ;

                          DUP 6 ;

                          GET 3 ;

                          PAIR ;

                          DIG 5 ;

                          CAR ;

                          PAIR ;

                          UPDATE ;

                          PAIR ;

                          DIG 2 ;

                          CAR ;

                          CAR ;

                          PAIR ;

                          PAIR }

                        { SWAP ;

                          DUP ;

                          DUG 2 ;

                          SWAP ;

                          DUP ;

                          DUG 2 ;

                          GET 4 ;

                          PAIR ;

                          DUP 5 ;

                          SWAP ;

                          EXEC ;

                          DROP ;

                          DUP ;

                          CAR ;

                          DUP 6 ;

                          SWAP ;

                          EXEC ;

                          DROP ;

                          SWAP ;

                          DUP ;

                          DUG 2 ;

                          CDR ;

                          DUP 3 ;

                          CAR ;

                          CDR ;

                          CDR ;

                          DUP 4 ;

                          CAR ;

                          CDR ;

                          CAR ;

                          DUP 4 ;

                          GET 4 ;

                          DUP 5 ;

                          GET 3 ;

                          PAIR ;

                          DIG 4 ;

                          CAR ;

                          PAIR ;

                          NONE unit ;

                          SWAP ;

                          UPDATE ;

                          PAIR ;

                          DIG 2 ;

                          CAR ;

                          CAR ;

                          PAIR ;

                          PAIR } } ;

               DIG 2 ;

               DIG 3 ;

               DROP 2 ;

               NIL operation ;

               PAIR } ;

           DUP ;

           DUG 2 ;

           CDR ;

           UPDATE 3 ;

           SWAP ;

           CAR ;

           PAIR } }