{ parameter (or

              (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 %bulk_mint (nat %token_id) (map %operations address nat)))

                (or

                  (pair %burn (address %owner)

                              (pair (nat %token_id) (nat %token_amount)))

                  (or (lambda %execute unit (list operation))

                      (pair %mint (address %owner)

                                  (pair (nat %token_id) (nat %token_amount))))))

              (or

                (or

                  (pair %remove_administrator (address %administrator_to_remove)

                                              (nat %token_id))

                  (pair %set_administrator (address %administrator_to_set)

                                           (nat %token_id)))

                (or

                  (pair %set_token_metadata (nat %token_id)

                                            (map %token_info string bytes))

                  (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 %administrators (pair (address %owner) (nat %token_id)) unit)

                (pair (big_map %ledger (pair (address %owner) (nat %token_id)) nat)

                      (pair

                        (big_map %operators

                          (pair (address %owner)

                                (pair (address %operator) (nat %token_id)))

                          unit)

                        (pair

                          (big_map %token_metadata nat

                                                   (pair (nat %token_id)

                                                         (map %token_info string bytes)))

                          (big_map %total_supply nat nat))))) ;

  code { LAMBDA

           (pair (pair address (pair nat nat))

                 (pair (big_map (pair address nat) unit)

                       (pair (big_map (pair address nat) nat)

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

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

                                         (big_map nat nat))))))

           (pair unit

                 (pair (big_map (pair address nat) unit)

                       (pair (big_map (pair address nat) nat)

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

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

                                         (big_map nat nat))))))

           { UNPAIR ;

             PUSH mutez 0 ;

             AMOUNT ;

             COMPARE ;

             EQ ;

             IF {} { PUSH string "[token.mint]: No tez accepted" ; FAILWITH } ;

             DUP ;

             GET 3 ;

             DUP 2 ;

             CAR ;

             DIG 2 ;

             GET 4 ;

             DUP ;

             INT ;

             GT ;

             IF

               {}

               { PUSH string "[token.mint]: Invalid amount requested." ; FAILWITH } ;

             DUP 4 ;

             GET 8 ;

             DUP 4 ;

             MEM ;

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

             DUP 3 ;

             DIG 2 ;

             PAIR ;

             DUP 4 ;

             GET 3 ;

             DUP 2 ;

             MEM ;

             IF

               {}

               { DIG 3 ; DUP ; GET 3 ; PUSH (option nat) (Some 0) ; DUP 4 ; UPDATE ; UPDATE 3 ; DUG 3 } ;

             DIG 3 ;

             DUP ;

             GET 3 ;

             DUP ;

             DIG 3 ;

             DUP ;

             DUG 2 ;

             GET ;

             IF_NONE { PUSH int 334 ; FAILWITH } {} ;

             DUP 5 ;

             ADD ;

             SOME ;

             SWAP ;

             UPDATE ;

             UPDATE 3 ;

             DUP ;

             GET 8 ;

             DUP ;

             DIG 4 ;

             DUP ;

             DUG 2 ;

             GET ;

             IF_NONE { PUSH int 335 ; FAILWITH } {} ;

             DIG 4 ;

             ADD ;

             SOME ;

             SWAP ;

             UPDATE ;

             UPDATE 8 ;

             UNIT ;

             PAIR } ;

         SWAP ;

         LAMBDA

           (pair nat

                 (pair (list operation)

                       (pair (big_map (pair address nat) unit)

                             (pair (big_map (pair address nat) nat)

                                   (pair

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

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

                                           (big_map nat nat)))))))

           (pair unit

                 (pair (list operation)

                       (pair (big_map (pair address nat) unit)

                             (pair (big_map (pair address nat) nat)

                                   (pair

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

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

                                           (big_map nat nat)))))))

           { UNPAIR 3 ;

             SENDER ;

             PAIR ;

             DUP 3 ;

             CAR ;

             SWAP ;

             MEM ;

             IF {} { PUSH string "[token.verify_is_admin]: Unauthorized" ; FAILWITH } ;

             UNIT ;

             PAIR 3 } ;

         SWAP ;

         UNPAIR ;

         IF_LEFT

           { IF_LEFT

               { IF_LEFT

                   { PUSH mutez 0 ;

                     AMOUNT ;

                     COMPARE ;

                     EQ ;

                     IF {} { PUSH string "No tez accepted" ; FAILWITH } ;

                     DUP ;

                     NIL (pair (pair address nat) nat) ;

                     DUP 2 ;

                     CAR ;

                     ITER { DUP 5 ;

                            GET 7 ;

                            DUP 2 ;

                            CDR ;

                            MEM ;

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

                            PUSH nat 0 ;

                            DUP 6 ;

                            GET 3 ;

                            DUP 3 ;

                            MEM ;

                            IF

                              { DROP ;

                                DUP 5 ;

                                GET 3 ;

                                DUP 2 ;

                                GET ;

                                IF_NONE { PUSH int 251 ; FAILWITH } {} }

                              {} ;

                            DIG 2 ;

                            SWAP ;

                            DIG 2 ;

                            PAIR ;

                            CONS } ;

                     DIG 2 ;

                     DROP ;

                     DIG 3 ;

                     DROP ;

                     DIG 3 ;

                     DROP ;

                     NIL operation ;

                     DIG 2 ;

                     CDR ;

                     PUSH mutez 0 ;

                     DIG 3 ;

                     TRANSFER_TOKENS ;

                     CONS }

                   { DUP ;

                     DUP ;

                     CAR ;

                     DUP 2 ;

                     CDR ;

                     NIL operation ;

                     DUP 7 ;

                     DUP 4 ;

                     SWAP ;

                     DIG 7 ;

                     DIG 3 ;

                     DIG 3 ;

                     PAIR 3 ;

                     EXEC ;

                     CDR ;

                     UNPAIR ;

                     DIG 7 ;

                     DIG 7 ;

                     DIG 3 ;

                     DUG 7 ;

                     DUG 7 ;

                     DUG 7 ;

                     DUP 2 ;

                     ITER { DUP 9 ;

                            DUP 2 ;

                            CDR ;

                            DUP 6 ;

                            DIG 3 ;

                            CAR ;

                            PAIR 3 ;

                            SWAP ;

                            DIG 7 ;

                            DIG 2 ;

                            PAIR ;

                            EXEC ;

                            CDR ;

                            DIG 7 ;

                            DIG 7 ;

                            DIG 2 ;

                            DUG 7 ;

                            DUG 7 ;

                            DUG 7 } ;

                     SWAP ;

                     DROP ;

                     SWAP ;

                     DROP ;

                     SWAP ;

                     DROP ;

                     SWAP ;

                     DROP ;

                     DIG 2 ;

                     DROP ;

                     DIG 2 ;

                     DROP } }

               { IF_LEFT

                   { PUSH mutez 0 ;

                     AMOUNT ;

                     COMPARE ;

                     EQ ;

                     IF {} { PUSH string "[token.burn]: No tez accepted" ; FAILWITH } ;

                     DUP ;

                     DUP ;

                     GET 3 ;

                     DUP 2 ;

                     CAR ;

                     DUP 3 ;

                     GET 4 ;

                     NIL operation ;

                     DUP 8 ;

                     DUP 5 ;

                     SWAP ;

                     DIG 8 ;

                     DIG 3 ;

                     DIG 3 ;

                     PAIR 3 ;

                     EXEC ;

                     CDR ;

                     UNPAIR ;

                     DIG 8 ;

                     DIG 8 ;

                     DIG 3 ;

                     DUG 8 ;

                     DUG 8 ;

                     DUG 8 ;

                     DUP 7 ;

                     GET 8 ;

                     DUP 5 ;

                     MEM ;

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

                     DUP 4 ;

                     DUP 4 ;

                     PAIR ;

                     DUP 8 ;

                     GET 3 ;

                     DUP 2 ;

                     MEM ;

                     IF

                       {}

                       { PUSH string "[token.burn]: Sender not found." ; FAILWITH } ;

                     DUP 8 ;

                     GET 3 ;

                     DUP 2 ;

                     GET ;

                     IF_NONE { PUSH int 398 ; FAILWITH } {} ;

                     DUP 4 ;

                     SWAP ;

                     COMPARE ;

                     GE ;

                     IF

                       {}

                       { PUSH string "[token.burn]: Invalid amount requested." ;

                         FAILWITH } ;

                     DUP 8 ;

                     DUP ;

                     GET 3 ;

                     DUP 5 ;

                     DIG 10 ;

                     GET 3 ;

                     DUP 5 ;

                     GET ;

                     IF_NONE { PUSH int 403 ; FAILWITH } {} ;

                     SUB ;

                     ISNAT ;

                     IF_NONE { PUSH int 402 ; FAILWITH } {} ;

                     SOME ;

                     DUP 4 ;

                     UPDATE ;

                     UPDATE 3 ;

                     DUG 7 ;

                     DUP 8 ;

                     DUP ;

                     GET 8 ;

                     DUP 5 ;

                     DIG 10 ;

                     GET 8 ;

                     DUP 9 ;

                     GET ;

                     IF_NONE { PUSH int 406 ; FAILWITH } {} ;

                     SUB ;

                     ISNAT ;

                     IF_NONE { PUSH int 405 ; FAILWITH } {} ;

                     SOME ;

                     DUP 8 ;

                     UPDATE ;

                     UPDATE 8 ;

                     DUG 7 ;

                     PUSH nat 0 ;

                     DUP 9 ;

                     GET 3 ;

                     DUP 3 ;

                     GET ;

                     IF_NONE { PUSH int 409 ; FAILWITH } {} ;

                     COMPARE ;

                     EQ ;

                     IF

                       { DIG 2 ;

                         DROP ;

                         DIG 2 ;

                         DROP ;

                         DIG 2 ;

                         DROP ;

                         DIG 2 ;

                         DROP ;

                         DIG 2 ;

                         DROP ;

                         DIG 3 ;

                         DROP ;

                         DIG 3 ;

                         DROP ;

                         DIG 2 ;

                         DUP ;

                         GET 3 ;

                         NONE nat ;

                         DIG 3 ;

                         UPDATE ;

                         UPDATE 3 ;

                         SWAP }

                       { DROP ;

                         SWAP ;

                         DROP ;

                         SWAP ;

                         DROP ;

                         SWAP ;

                         DROP ;

                         SWAP ;

                         DROP ;

                         SWAP ;

                         DROP ;

                         DIG 2 ;

                         DROP ;

                         DIG 2 ;

                         DROP } }

                   { IF_LEFT

                       { DUP ;

                         NIL operation ;

                         DUP 5 ;

                         PUSH nat 0 ;

                         SWAP ;

                         DIG 5 ;

                         DIG 3 ;

                         DIG 3 ;

                         PAIR 3 ;

                         EXEC ;

                         CDR ;

                         UNPAIR ;

                         DIG 5 ;

                         DIG 5 ;

                         DIG 3 ;

                         DIG 5 ;

                         DIG 5 ;

                         DIG 5 ;

                         DUP 2 ;

                         UNIT ;

                         EXEC ;

                         NIL operation ;

                         SWAP ;

                         ITER { CONS } ;

                         DUP ;

                         ITER { DIG 2 ; SWAP ; CONS ; SWAP } ;

                         DROP ;

                         SWAP ;

                         DROP ;

                         SWAP ;

                         DROP ;

                         DIG 2 ;

                         DROP ;

                         DIG 2 ;

                         DROP }

                       { DUP ;

                         GET 3 ;

                         NIL operation ;

                         DIG 4 ;

                         DIG 2 ;

                         SWAP ;

                         DIG 4 ;

                         DIG 3 ;

                         DIG 3 ;

                         PAIR 3 ;

                         EXEC ;

                         CDR ;

                         UNPAIR ;

                         DIG 3 ;

                         DIG 2 ;

                         DIG 3 ;

                         DIG 3 ;

                         DIG 3 ;

                         DIG 2 ;

                         SWAP ;

                         DIG 3 ;

                         DIG 2 ;

                         PAIR ;

                         EXEC ;

                         CDR ;

                         SWAP } } } }

           { IF_LEFT

               { IF_LEFT

                   { DIG 3 ;

                     DROP ;

                     PUSH mutez 0 ;

                     AMOUNT ;

                     COMPARE ;

                     EQ ;

                     IF

                       {}

                       { PUSH string "[token.remove_administrator]: No tez accepted" ;

                         FAILWITH } ;

                     NIL operation ;

                     DIG 3 ;

                     DUP 3 ;

                     CDR ;

                     SWAP ;

                     DIG 4 ;

                     DIG 3 ;

                     DIG 3 ;

                     PAIR 3 ;

                     EXEC ;

                     CDR ;

                     UNPAIR ;

                     SWAP ;

                     DUG 2 ;

                     SWAP ;

                     DUP 3 ;

                     CAR ;

                     DUP 2 ;

                     MEM ;

                     IF

                       {}

                       { PUSH string "[token.remove_administrator]: The administrator does not exists" ;

                         FAILWITH } ;

                     DIG 2 ;

                     DUP ;

                     CAR ;

                     NONE unit ;

                     DIG 3 ;

                     UPDATE ;

                     UPDATE 1 ;

                     SWAP }

                   { DIG 3 ;

                     DROP ;

                     PUSH mutez 0 ;

                     AMOUNT ;

                     COMPARE ;

                     EQ ;

                     IF

                       {}

                       { PUSH string "[token.set_administrator]: No tez accepted" ;

                         FAILWITH } ;

                     NIL operation ;

                     DIG 3 ;

                     DUP 3 ;

                     CDR ;

                     SWAP ;

                     DIG 4 ;

                     DIG 3 ;

                     DIG 3 ;

                     PAIR 3 ;

                     EXEC ;

                     CDR ;

                     UNPAIR ;

                     SWAP ;

                     DUG 2 ;

                     SWAP ;

                     DIG 2 ;

                     DUP ;

                     CAR ;

                     PUSH (option unit) (Some Unit) ;

                     DIG 3 ;

                     UPDATE ;

                     UPDATE 1 ;

                     SWAP } }

               { IF_LEFT

                   { PUSH mutez 0 ;

                     AMOUNT ;

                     COMPARE ;

                     EQ ;

                     IF {} { PUSH string "No tez accepted" ; FAILWITH } ;

                     NIL operation ;

                     DUP 4 ;

                     PUSH nat 0 ;

                     SWAP ;

                     DIG 4 ;

                     DIG 3 ;

                     DIG 3 ;

                     PAIR 3 ;

                     EXEC ;

                     CDR ;

                     UNPAIR ;

                     DIG 4 ;

                     DIG 4 ;

                     DIG 3 ;

                     DIG 4 ;

                     DIG 4 ;

                     DUP 2 ;

                     DUP ;

                     CAR ;

                     DUP ;

                     SENDER ;

                     PAIR ;

                     DUP 6 ;

                     GET 7 ;

                     DUP 3 ;

                     MEM ;

                     IF

                       { DROP 3 ; SWAP ; DROP ; DIG 2 ; DROP ; DIG 2 ; DROP }

                       { DIG 4 ;

                         DROP ;

                         DIG 5 ;

                         DROP ;

                         DIG 5 ;

                         DROP ;

                         DIG 4 ;

                         DUP ;

                         GET 7 ;

                         DIG 4 ;

                         SOME ;

                         DUP 5 ;

                         UPDATE ;

                         UPDATE 7 ;

                         DUP ;

                         CAR ;

                         PUSH (option unit) (Some Unit) ;

                         DIG 3 ;

                         UPDATE ;

                         UPDATE 1 ;

                         DUP ;

                         GET 8 ;

                         PUSH (option nat) (Some 0) ;

                         DIG 3 ;

                         UPDATE ;

                         UPDATE 8 ;

                         SWAP } }

                   { DIG 2 ;

                     DROP ;

                     DIG 2 ;

                     DROP ;

                     IF_LEFT

                       { PUSH mutez 0 ;

                         AMOUNT ;

                         COMPARE ;

                         EQ ;

                         IF {} { PUSH string "No tez accepted" ; FAILWITH } ;

                         DUP ;

                         DUP ;

                         ITER { DUP ;

                                CDR ;

                                ITER { DUP 2 ;

                                       CAR ;

                                       DUP 2 ;

                                       CAR ;

                                       DUP 3 ;

                                       GET 3 ;

                                       DUP ;

                                       DUP 4 ;

                                       PAIR ;

                                       DUP 9 ;

                                       GET 3 ;

                                       DUP 2 ;

                                       MEM ;

                                       IF

                                         {}

                                         { PUSH string "FA2_INSUFFICIENT_BALANCE" ;

                                           FAILWITH } ;

                                       DUP 5 ;

                                       GET 4 ;

                                       DUP 10 ;

                                       GET 3 ;

                                       DUP 3 ;

                                       GET ;

                                       IF_NONE { PUSH int 163 ; FAILWITH } {} ;

                                       COMPARE ;

                                       GE ;

                                       IF

                                         {}

                                         { PUSH string "FA2_INSUFFICIENT_BALANCE" ;

                                           FAILWITH } ;

                                       DUP 2 ;

                                       SENDER ;

                                       DUP 6 ;

                                       PAIR 3 ;

                                       DUP 7 ;

                                       CAR ;

                                       SENDER ;

                                       COMPARE ;

                                       EQ ;

                                       IF

                                         { DROP ; PUSH bool True }

                                         { DUP 10 ; GET 5 ; SWAP ; MEM } ;

                                       IF

                                         {}

                                         { PUSH string "FA2_NOT_OPERATOR" ; FAILWITH } ;

                                       PUSH nat 0 ;

                                       DUP 6 ;

                                       GET 4 ;

                                       COMPARE ;

                                       GT ;

                                       IF

                                         { DUP 9 ;

                                           DUP ;

                                           GET 3 ;

                                           LAMBDA

                                             int

                                             nat

                                             { PUSH int 0 ;

                                               ISNAT ;

                                               IF_NONE { PUSH int 46 ; FAILWITH } {} ;

                                               DUP 2 ;

                                               GT ;

                                               IF

                                                 { DROP ;

                                                   ISNAT ;

                                                   IF_NONE

                                                     { PUSH int 49 ; FAILWITH }

                                                     {} }

                                                 { SWAP ; DROP } } ;

                                           DUP 8 ;

                                           GET 4 ;

                                           DIG 12 ;

                                           GET 3 ;

                                           DUP 6 ;

                                           GET ;

                                           IF_NONE { PUSH int 177 ; FAILWITH } {} ;

                                           SUB ;

                                           EXEC ;

                                           SOME ;

                                           DUP 4 ;

                                           UPDATE ;

                                           UPDATE 3 ;

                                           DUG 8 ;

                                           DUP 2 ;

                                           DUP 4 ;

                                           PAIR ;

                                           DUP 10 ;

                                           GET 3 ;

                                           DUP 2 ;

                                           MEM ;

                                           IF

                                             {}

                                             { DIG 9 ;

                                               DUP ;

                                               GET 3 ;

                                               PUSH (option nat) (Some 0) ;

                                               DUP 4 ;

                                               UPDATE ;

                                               UPDATE 3 ;

                                               DUG 9 } ;

                                           DIG 9 ;

                                           DUP ;

                                           GET 3 ;

                                           DUP ;

                                           DIG 3 ;

                                           DUP ;

                                           DUG 2 ;

                                           GET ;

                                           IF_NONE { PUSH int 187 ; FAILWITH } {} ;

                                           DUP 9 ;

                                           GET 4 ;

                                           ADD ;

                                           SOME ;

                                           SWAP ;

                                           UPDATE ;

                                           UPDATE 3 ;

                                           DUG 8 ;

                                           PUSH nat 0 ;

                                           DUP 10 ;

                                           GET 3 ;

                                           DUP 3 ;

                                           GET ;

                                           IF_NONE { PUSH int 189 ; FAILWITH } {} ;

                                           COMPARE ;

                                           EQ ;

                                           IF

                                             { SWAP ;

                                               DROP ;

                                               SWAP ;

                                               DROP ;

                                               SWAP ;

                                               DROP ;

                                               SWAP ;

                                               DROP ;

                                               DIG 4 ;

                                               DUP ;

                                               GET 3 ;

                                               NONE nat ;

                                               DIG 3 ;

                                               UPDATE ;

                                               UPDATE 3 ;

                                               DUG 3 }

                                             { DROP 5 } }

                                         { DROP 5 } } ;

                                DROP } ;

                         DROP 2 }

                       { PUSH mutez 0 ;

                         AMOUNT ;

                         COMPARE ;

                         EQ ;

                         IF {} { PUSH string "No tez accepted" ; FAILWITH } ;

                         DUP ;

                         DUP ;

                         ITER { IF_LEFT

                                  { SENDER ;

                                    DUP 2 ;

                                    CAR ;

                                    COMPARE ;

                                    EQ ;

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

                                    DUP ;

                                    GET 4 ;

                                    SWAP ;

                                    DUP ;

                                    GET 3 ;

                                    SWAP ;

                                    CAR ;

                                    PAIR 3 ;

                                    DIG 3 ;

                                    DUP ;

                                    GET 5 ;

                                    PUSH (option unit) (Some Unit) ;

                                    DIG 3 ;

                                    UPDATE ;

                                    UPDATE 5 ;

                                    DUG 2 }

                                  { SENDER ;

                                    DUP 2 ;

                                    CAR ;

                                    COMPARE ;

                                    EQ ;

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

                                    DUP ;

                                    GET 4 ;

                                    SWAP ;

                                    DUP ;

                                    GET 3 ;