{ parameter (or

              (or %adminAction

                (or

                  (pair %mint (address %address) (nat %amount) (nat %token_id)

                              (map %metadata string bytes))

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

                (address %updateAdmin))

              (or %assets

                (or

                  (list %assert_balances (pair (address %owner) (nat %token_id)

                                              (nat %balance)))

                  (pair %balance_of

                    (list %requests (pair (address %owner) (nat %token_id)))

                    (contract %callback (list (pair

                                              (pair %request (address %owner)

                                                             (nat %token_id))

                                              (nat %balance))))))

                (or

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

  storage (pair (big_map %metadata string bytes)

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

                     DUP ;

                     DUG 2 ;

                     GET 3 ;

                     DUP ;

                     CDR ;

                     SWAP ;

                     DUP ;

                     DUG 2 ;

                     CAR ;

                     CDR ;

                     PUSH nat 1 ;

                     DUP 7 ;

                     GET 5 ;

                     ADD ;

                     DIG 5 ;

                     GET 3 ;

                     CAR ;

                     CAR ;

                     CDR ;

                     SWAP ;

                     DUP ;

                     DUG 2 ;

                     SWAP ;

                     DUP ;

                     DUG 2 ;

                     COMPARE ;

                     GT ;

                     IF { SWAP ; DROP } { DROP } ;

                     DIG 3 ;

                     CAR ;

                     CAR ;

                     CAR ;

                     PAIR ;

                     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 ;

                     LEFT (pair

                            (pair (big_map string bytes)

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

                     LOOP_LEFT { DUP ;

                                 CDR ;

                                 DUP 3 ;

                                 INT ;

                                 SWAP ;

                                 DUP ;

                                 DUG 2 ;

                                 COMPARE ;

                                 LE ;

                                 IF

                                   { SWAP ;

                                     CAR ;

                                     SWAP ;

                                     DUP ;

                                     DUG 2 ;

                                     ABS ;

                                     SWAP ;

                                     DUP ;

                                     DUP ;

                                     DUG 3 ;

                                     GET 3 ;

                                     DUP ;

                                     CDR ;

                                     DIG 4 ;

                                     GET 3 ;

                                     CAR ;

                                     CDR ;

                                     CDR ;

                                     EMPTY_MAP string bytes ;

                                     PUSH string ".json" ;

                                     DUP 7 ;

                                     { PUSH string "" ;

                                       PAIR ;

                                       LEFT (pair string nat) ;

                                       LOOP_LEFT { DUP ;

                                                   CDR ;

                                                   PUSH nat 0 ;

                                                   SWAP ;

                                                   DUP ;

                                                   DUG 2 ;

                                                   COMPARE ;

                                                   GT ;

                                                   IF

                                                     { SWAP ;

                                                       CAR ;

                                                       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 ;

                                                       SWAP ;

                                                       PAIR ;

                                                       LEFT (pair string nat) }

                                                     { DROP ; RIGHT (pair string nat) } } ;

                                       CAR ;

                                       PUSH string "" ;

                                       SWAP ;

                                       DUP ;

                                       DUG 2 ;

                                       COMPARE ;

                                       EQ ;

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

                                     CONCAT ;

                                     PACK ;

                                     DUP ;

                                     PUSH nat 6 ;

                                     DIG 2 ;

                                     SIZE ;

                                     SUB ;

                                     ABS ;

                                     PUSH nat 6 ;

                                     SLICE ;

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

                                     DUP 10 ;

                                     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 ;

                                     LEFT (pair

                                            (pair (big_map string bytes)

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

                                   { DROP ;

                                     RIGHT (pair

                                             (pair (big_map string bytes)

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

                     SWAP ;

                     DIG 2 ;

                     DROP 2 ;

                     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

                   { DIG 3 ;

                     DROP ;

                     ITER { DUP ;

                            DUG 2 ;

                            GET 4 ;

                            SWAP ;

                            DUP ;

                            DUG 2 ;

                            DUP 4 ;

                            GET 3 ;

                            DIG 4 ;

                            CAR ;

                            PAIR ;

                            PAIR ;

                            DUP 5 ;

                            SWAP ;

                            EXEC ;

                            COMPARE ;

                            LT ;

                            IF

                              { PUSH string "FA2_INSUFFICIENT_BALANCE" ; FAILWITH }

                              {} } ;

                     DIG 2 ;

                     DROP ;

                     NIL operation ;

                     PAIR }

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

                            DUP 4 ;

                            DUP 3 ;

                            CDR ;

                            DUP 4 ;

                            CAR ;

                            PAIR ;

                            PAIR ;

                            DUP 9 ;

                            SWAP ;

                            EXEC ;

                            DIG 2 ;

                            PAIR ;

                            CONS } ;

                     DIG 2 ;

                     DIG 5 ;

                     DIG 6 ;

                     DROP 3 ;

                     NIL operation ;

                     DIG 2 ;

                     CDR ;

                     PUSH mutez 0 ;

                     DIG 3 ;

                     TRANSFER_TOKENS ;

                     CONS ;

                     PAIR } }

               { IF_LEFT

                   { DIG 4 ;

                     DROP ;

                     ITER { DUP ;

                            DUG 2 ;

                            CDR ;

                            ITER { SWAP ;

                                   DUP ;

                                   DUP 3 ;

                                   GET 3 ;

                                   PAIR ;

                                   SENDER ;

                                   DUP 5 ;

                                   CAR ;

                                   DIG 2 ;

                                   UNPAIR ;

                                   PUSH bool False ;

                                   DUG 2 ;

                                   PAIR ;

                                   DIG 3 ;

                                   DIG 3 ;

                                   DIG 2 ;

                                   UNPAIR ;

                                   SWAP ;

                                   CAR ;

                                   CDR ;

                                   CAR ;

                                   SWAP ;

                                   DUP 4 ;

                                   PAIR ;

                                   DUP 3 ;

                                   PAIR ;

                                   MEM ;

                                   DUG 2 ;

                                   COMPARE ;

                                   EQ ;

                                   OR ;

                                   COMPARE ;

                                   EQ ;

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

  view "is_operator" (pair (address %owner) (address %operator) (nat %token_id)) bool