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 %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

          (pair (big_map %administrators (pair (address %owner) (nat %token_id)) unit)

                (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 { CAST (pair

              (or

                (or

                  (or

                    (pair (list (pair address nat))

                          (contract (list (pair (pair address nat) nat))))

                    (pair address (pair nat nat)))

                  (or (lambda unit (list operation)) (pair address (pair nat nat))))

                (or (or (pair address nat) (pair address nat))

                    (or (pair nat (map string bytes))

                        (or (list (pair address (list (pair address (pair nat nat)))))

                            (list (or (pair address (pair address nat))

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

              (pair

                (pair (big_map (pair address nat) unit) (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))))) ;

       LAMBDA

         (pair nat

               (pair

                 (pair (big_map (pair address nat) unit)

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

               (pair unit

                     (pair

                       (pair (big_map (pair address nat) unit)

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

         { NIL operation ;

           SWAP ;

           DUP ;

           DUG 2 ;

           CDR ;

           DUP ;

           CAR ;

           CAR ;

           DIG 3 ;

           CAR ;

           SENDER ;

           PAIR ;

           MEM ;

           IF {} { PUSH int 401 ; FAILWITH } ;

           UNIT ;

           DIG 2 ;

           PAIR 3 } ;

       SWAP ;

       UNPAIR ;

       IF_LEFT

         { IF_LEFT

             { IF_LEFT

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

                   SWAP ;

                   DUP ;

                   DUG 2 ;

                   CAR ;

                   ITER { DUP 4 ;

                          GET 5 ;

                          SWAP ;

                          DUP ;

                          DUG 2 ;

                          CDR ;

                          MEM ;

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

                          SWAP ;

                          DUP 4 ;

                          CAR ;

                          CDR ;

                          DUP 3 ;

                          GET ;

                          IF_NONE { PUSH nat 0 } {} ;

                          DIG 2 ;

                          PAIR ;

                          CONS } ;

                   DIG 3 ;

                   DROP ;

                   NIL operation ;

                   DIG 2 ;

                   CDR ;

                   PUSH mutez 0 ;

                   DIG 3 ;

                   TRANSFER_TOKENS ;

                   CONS }

                 { DUP 3 ;

                   DUG 2 ;

                   DUP ;

                   DUG 3 ;

                   GET 3 ;

                   PAIR ;

                   EXEC ;

                   DUP ;

                   GET 4 ;

                   DUG 2 ;

                   CAR ;

                   DUP 3 ;

                   UNPAIR ;

                   UNPAIR ;

                   SWAP ;

                   DUP 5 ;

                   GET 4 ;

                   DIG 6 ;

                   CAR ;

                   CDR ;

                   DIG 6 ;

                   DUP ;

                   GET 3 ;

                   SWAP ;

                   DUP ;

                   DUG 8 ;

                   CAR ;

                   PAIR ;

                   GET ;

                   IF_NONE { PUSH nat 0 } {} ;

                   SUB ;

                   ISNAT ;

                   IF_NONE { PUSH int 457 ; FAILWITH } {} ;

                   SOME ;

                   DIG 5 ;

                   DUP ;

                   GET 3 ;

                   SWAP ;

                   DUP ;

                   DUG 7 ;

                   CAR ;

                   PAIR ;

                   UPDATE ;

                   SWAP ;

                   PAIR ;

                   PAIR ;

                   DUP ;

                   DUG 3 ;

                   DUP ;

                   GET 6 ;

                   DUP 4 ;

                   GET 4 ;

                   DIG 5 ;

                   GET 6 ;

                   DUP 6 ;

                   GET 3 ;

                   GET ;

                   IF_NONE { PUSH int 458 ; FAILWITH } {} ;

                   SUB ;

                   ISNAT ;

                   IF_NONE { PUSH int 458 ; FAILWITH } {} ;

                   SOME ;

                   DUP 5 ;

                   GET 3 ;

                   UPDATE ;

                   UPDATE 6 ;

                   DUG 2 ;

                   PUSH nat 0 ;

                   DUP 4 ;

                   CAR ;

                   CDR ;

                   DIG 3 ;

                   DUP ;

                   GET 3 ;

                   SWAP ;

                   DUP ;

                   DUG 5 ;

                   CAR ;

                   PAIR ;

                   GET ;

                   IF_NONE { PUSH nat 0 } {} ;

                   COMPARE ;

                   EQ ;

                   IF

                     { DIG 3 ;

                       DROP ;

                       DIG 2 ;

                       UNPAIR ;

                       UNPAIR ;

                       SWAP ;

                       NONE nat ;

                       DIG 5 ;

                       DUP ;

                       GET 3 ;

                       SWAP ;

                       CAR ;

                       PAIR ;

                       UPDATE ;

                       SWAP ;

                       PAIR ;

                       PAIR ;

                       SWAP }

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

             { IF_LEFT

                 { DUG 2 ;

                   PUSH nat 0 ;

                   PAIR ;

                   EXEC ;

                   DUP ;

                   GET 4 ;

                   DUG 2 ;

                   CAR ;

                   SWAP ;

                   UNIT ;

                   EXEC ;

                   NIL operation ;

                   SWAP ;

                   ITER { CONS } ;

                   ITER { CONS } }

                 { DUP ;

                   DUG 3 ;

                   GET 3 ;

                   PAIR ;

                   EXEC ;

                   DUP ;

                   GET 4 ;

                   DUG 2 ;

                   CAR ;

                   DUP 3 ;

                   UNPAIR ;

                   UNPAIR ;

                   SWAP ;

                   DUP 5 ;

                   GET 4 ;

                   DIG 6 ;

                   CAR ;

                   CDR ;

                   DIG 6 ;

                   DUP ;

                   GET 3 ;

                   SWAP ;

                   DUP ;

                   DUG 8 ;

                   CAR ;

                   PAIR ;

                   GET ;

                   IF_NONE { PUSH nat 0 } {} ;

                   ADD ;

                   SOME ;

                   DIG 5 ;

                   DUP ;

                   GET 3 ;

                   SWAP ;

                   DUP ;

                   DUG 7 ;

                   CAR ;

                   PAIR ;

                   UPDATE ;

                   SWAP ;

                   PAIR ;

                   PAIR ;

                   DUP ;

                   GET 6 ;

                   DUP ;

                   DUP 5 ;

                   GET 3 ;

                   DUP ;

                   DUG 2 ;

                   GET ;

                   IF_NONE { PUSH int 440 ; FAILWITH } {} ;

                   DIG 5 ;

                   GET 4 ;

                   ADD ;

                   SOME ;

                   SWAP ;

                   UPDATE ;

                   UPDATE 6 ;

                   SWAP } } }

         { IF_LEFT

             { IF_LEFT

                 { DUP ;

                   DUG 3 ;

                   CDR ;

                   PAIR ;

                   EXEC ;

                   DUP ;

                   GET 4 ;

                   DUG 2 ;

                   CAR ;

                   DIG 2 ;

                   UNPAIR ;

                   UNPAIR ;

                   NONE unit ;

                   DIG 5 ;

                   UPDATE ;

                   PAIR ;

                   PAIR ;

                   SWAP }

                 { DUP ;

                   DUG 3 ;

                   CDR ;

                   PAIR ;

                   EXEC ;

                   DUP ;

                   GET 4 ;

                   DUG 2 ;

                   CAR ;

                   DIG 2 ;

                   UNPAIR ;

                   UNPAIR ;

                   PUSH (option unit) (Some Unit) ;

                   DIG 5 ;

                   UPDATE ;

                   PAIR ;

                   PAIR ;

                   SWAP } }

             { IF_LEFT

                 { DUP 3 ;

                   DIG 2 ;

                   PUSH nat 0 ;

                   PAIR ;

                   EXEC ;

                   DUP ;

                   GET 4 ;

                   DUG 2 ;

                   CAR ;

                   DUP 3 ;

                   GET 5 ;

                   DUP 3 ;

                   CAR ;

                   MEM ;

                   IF

                     { SWAP ; DROP ; DIG 2 ; DROP }

                     { DIG 3 ;

                       DROP ;

                       DIG 2 ;

                       DUP ;

                       GET 5 ;

                       DIG 3 ;

                       DUP ;

                       SOME ;

                       SWAP ;

                       DUP ;

                       DUG 5 ;

                       CAR ;

                       UPDATE ;

                       UPDATE 5 ;

                       UNPAIR ;

                       UNPAIR ;

                       PUSH (option unit) (Some Unit) ;

                       DUP 6 ;

                       CAR ;

                       SENDER ;

                       PAIR ;

                       UPDATE ;

                       PAIR ;

                       PAIR ;

                       DUP ;

                       GET 6 ;

                       PUSH (option nat) (Some 0) ;

                       DIG 4 ;

                       CAR ;

                       UPDATE ;

                       UPDATE 6 ;

                       SWAP } }

                 { DIG 2 ;

                   DROP ;

                   IF_LEFT

                     { DUP ;

                       ITER { DUP ;

                              CDR ;

                              ITER { DUP ;

                                     GET 3 ;

                                     DUP 3 ;

                                     CAR ;

                                     PAIR ;

                                     SWAP ;

                                     DUP ;

                                     GET 3 ;

                                     SWAP ;

                                     DUP ;

                                     DUG 3 ;

                                     CAR ;

                                     PAIR ;

                                     DUP 3 ;

                                     GET 4 ;

                                     DUP 7 ;

                                     CAR ;

                                     CDR ;

                                     DUP 4 ;

                                     GET ;

                                     IF_NONE { PUSH nat 0 } {} ;

                                     COMPARE ;

                                     GE ;

                                     IF

                                       {}

                                       { PUSH string "FA2_INSUFFICIENT_BALANCE" ;

                                         FAILWITH } ;

                                     DUP 4 ;

                                     CAR ;

                                     SENDER ;

                                     COMPARE ;

                                     EQ ;

                                     IF

                                       { PUSH bool True }

                                       { DUP 6 ; GET 3 ; DUP 4 ; GET 3 ; SENDER ; DUP 7 ; CAR ; PAIR 3 ; MEM } ;

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

                                     PUSH nat 0 ;

                                     DUP 4 ;

                                     GET 4 ;

                                     COMPARE ;

                                     GT ;

                                     IF

                                       { DUP 6 ;

                                         UNPAIR ;

                                         UNPAIR ;

                                         SWAP ;

                                         DUP 6 ;

                                         GET 4 ;

                                         DIG 9 ;

                                         CAR ;

                                         CDR ;

                                         DUP 7 ;

                                         GET ;

                                         IF_NONE { PUSH int 265 ; FAILWITH } {} ;

                                         SUB ;

                                         ISNAT ;

                                         IF_NONE { PUSH int 265 ; FAILWITH } {} ;

                                         SOME ;

                                         DUP 6 ;

                                         UPDATE ;

                                         SWAP ;

                                         PAIR ;

                                         PAIR ;

                                         DUP ;

                                         DUG 6 ;

                                         UNPAIR ;

                                         UNPAIR ;

                                         SWAP ;

                                         DUP 6 ;

                                         GET 4 ;

                                         DIG 9 ;

                                         CAR ;

                                         CDR ;

                                         DUP 6 ;

                                         GET ;

                                         IF_NONE { PUSH nat 0 } {} ;

                                         ADD ;

                                         SOME ;

                                         DIG 4 ;

                                         UPDATE ;

                                         SWAP ;

                                         PAIR ;

                                         PAIR ;

                                         DUG 4 ;

                                         PUSH nat 0 ;

                                         DUP 6 ;

                                         CAR ;

                                         CDR ;

                                         DUP 3 ;

                                         GET ;

                                         IF_NONE { PUSH int 269 ; FAILWITH } {} ;

                                         COMPARE ;

                                         EQ ;

                                         IF

                                           { SWAP ;

                                             DROP ;

                                             DIG 3 ;

                                             UNPAIR ;

                                             UNPAIR ;

                                             SWAP ;

                                             NONE nat ;

                                             DIG 4 ;

                                             UPDATE ;

                                             SWAP ;

                                             PAIR ;

                                             PAIR ;

                                             DUG 2 }

                                           { DROP 2 } }

                                       { DROP 3 } } ;

                              DROP } ;

                       DROP }

                     { DUP ;

                       ITER { IF_LEFT

                                { DUP ;

                                  CAR ;

                                  SENDER ;

                                  COMPARE ;

                                  EQ ;

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

                                  DIG 2 ;

                                  DUP ;

                                  GET 3 ;

                                  PUSH (option unit) (Some Unit) ;

                                  DIG 3 ;

                                  DUP ;

                                  GET 4 ;

                                  SWAP ;

                                  DUP ;

                                  GET 3 ;

                                  SWAP ;

                                  CAR ;

                                  PAIR 3 ;

                                  UPDATE ;

                                  UPDATE 3 ;

                                  SWAP }

                                { DUP ;

                                  CAR ;

                                  SENDER ;

                                  COMPARE ;

                                  EQ ;

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

                                  DIG 2 ;

                                  DUP ;

                                  GET 3 ;

                                  NONE unit ;

                                  DIG 3 ;

                                  DUP ;

                                  GET 4 ;

                                  SWAP ;

                                  DUP ;

                                  GET 3 ;

                                  SWAP ;

                                  CAR ;

                                  PAIR 3 ;

                                  UPDATE ;

                                  UPDATE 3 ;

                                  SWAP } } ;

                       DROP } ;

                   NIL operation } } } ;

       NIL operation ;

       SWAP ;

       ITER { CONS } ;

       PAIR }