parameter (or

            (or

              (or

                (or (pair %add_token (nat %token_id) (map %token_info string bytes))

                    (list %burn (pair (address %owner)

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

                (or (list %freeze (pair (address %address) (nat %token_id)))

                    (list %mint (pair (address %owner)

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

              (or

                (or

                  (list %revoke (pair (address %owner)

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

                  (list %transfer (pair (address %from_)

                                       (list %txs (pair (address %to_)

                                                       (pair (nat %token_id)

                                                             (nat %amount)))))))

                (or

                  (list %transfer_frozen_assets (pair (address %from_)

                                                     (list %txs (pair (address %to_)

                                                                     (pair

                                                                       (nat %token_id)

                                                                       (nat %amount))))))

                  (list %unfreeze (pair (address %address) (nat %token_id))))))

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

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

                    (address %propose_administrator)))

              (or (or (address %remove_administrator) (unit %set_administrator))

                  (or

                    (pair %update_entrypoints

                      (or %entrypoint

                        (or (or (unit %add_token) (unit %burn))

                            (or (unit %freeze) (unit %mint)))

                        (or (or (unit %revoke) (unit %transfer))

                            (or (unit %transfer_frozen_assets) (unit %unfreeze))))

                      (lambda %new_lambda

                        (pair

                          (or

                            (or

                              (or

                                (pair %add_token (nat %token_id)

                                                 (map %token_info string bytes))

                                (list %burn (pair (address %owner)

                                                 (pair (nat %token_id)

                                                       (nat %token_amount)))))

                              (or

                                (list %freeze (pair (address %address) (nat %token_id)))

                                (list %mint (pair (address %owner)

                                                 (pair (nat %token_id)

                                                       (nat %token_amount))))))

                            (or

                              (or

                                (list %revoke (pair (address %owner)

                                                   (pair (nat %token_id)

                                                         (nat %token_amount))))

                                (list %transfer (pair (address %from_)

                                                     (list %txs (pair (address %to_)

                                                                     (pair

                                                                       (nat %token_id)

                                                                       (nat %amount)))))))

                              (or

                                (list %transfer_frozen_assets (pair (address %from_)

                                                                   (list %txs (pair

                                                                               (address %to_)

                                                                               (pair

                                                                                 (nat %token_id)

                                                                                 (nat %amount))))))

                                (list %unfreeze (pair (address %address) (nat %token_id))))))

                          (pair

                            (pair (big_map %administrators address nat)

                                  (pair

                                    (big_map %frozen_accounts

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

                                      unit)

                                    (big_map %ledger

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

                                      nat)))

                            (pair

                              (pair (big_map %metadata string bytes)

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

                        (pair (list operation)

                              (pair

                                (pair (big_map %administrators address nat)

                                      (pair

                                        (big_map %frozen_accounts

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

                                          unit)

                                        (big_map %ledger

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

                                          nat)))

                                (pair

                                  (pair (big_map %metadata string bytes)

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

                    (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

            (pair (big_map %administrators address nat)

                  (pair

                    (big_map %frozen_accounts (pair (address %address) (nat %token_id))

                                              unit)

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

            (pair

              (pair (big_map %metadata string bytes)

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

          (big_map nat

                   (lambda

                     (pair

                       (or

                         (or

                           (or (pair nat (map string bytes))

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

                           (or (list (pair address nat))

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

                         (or

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

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

                           (or

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

                             (list (pair address nat)))))

                       (pair

                         (pair (big_map address nat)

                               (pair (big_map (pair address nat) unit)

                                     (big_map (pair address nat) nat)))

                         (pair

                           (pair (big_map string bytes)

                                 (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

                             (pair (big_map address nat)

                                   (pair (big_map (pair address nat) unit)

                                         (big_map (pair address nat) nat)))

                             (pair

                               (pair (big_map string bytes)

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

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

                                     (big_map nat nat))))))));

code { CAST (pair

              (or

                (or

                  (or

                    (or (pair nat (map string bytes))

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

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

                  (or

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

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

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

                        (list (pair address nat)))))

                (or

                  (or

                    (pair (list (pair address nat))

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

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

                  (or (or address unit)

                      (or

                        (pair

                          (or (or (or unit unit) (or unit unit))

                              (or (or unit unit) (or unit unit)))

                          (lambda

                            (pair

                              (or

                                (or

                                  (or (pair nat (map string bytes))

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

                                  (or (list (pair address nat))

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

                                (or

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

                                      (list (pair address

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

                                  (or

                                    (list (pair address

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

                                    (list (pair address nat)))))

                              (pair

                                (pair (big_map address nat)

                                      (pair (big_map (pair address nat) unit)

                                            (big_map (pair address nat) nat)))

                                (pair

                                  (pair (big_map string bytes)

                                        (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

                                    (pair (big_map address nat)

                                          (pair (big_map (pair address nat) unit)

                                                (big_map (pair address nat) nat)))

                                    (pair

                                      (pair (big_map string bytes)

                                            (big_map (pair address (pair address nat))

                                                     unit))

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

                                            (big_map nat nat)))))))

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

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

              (pair

                (pair

                  (pair (big_map address nat)

                        (pair (big_map (pair address nat) unit)

                              (big_map (pair address nat) nat)))

                  (pair

                    (pair (big_map string bytes)

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

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

                (big_map nat

                         (lambda

                           (pair

                             (or

                               (or

                                 (or (pair nat (map string bytes))

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

                                 (or (list (pair address nat))

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

                               (or

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

                                     (list (pair address

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

                                 (or

                                   (list (pair address

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

                                   (list (pair address nat)))))

                             (pair

                               (pair (big_map address nat)

                                     (pair (big_map (pair address nat) unit)

                                           (big_map (pair address nat) nat)))

                               (pair

                                 (pair (big_map string bytes)

                                       (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

                                   (pair (big_map address nat)

                                         (pair (big_map (pair address nat) unit)

                                               (big_map (pair address nat) nat)))

                                   (pair

                                     (pair (big_map string bytes)

                                           (big_map (pair address (pair address nat))

                                                    unit))

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

                                           (big_map nat nat))))))))) ;

       UNPAIR 3 ;

       IF_LEFT

         { DUP ;

           IF_LEFT

             { IF_LEFT

                 { IF_LEFT { DROP ; PUSH nat 0 } { DROP ; PUSH nat 1 } }

                 { IF_LEFT { DROP ; PUSH nat 2 } { DROP ; PUSH nat 3 } } }

             { IF_LEFT

                 { IF_LEFT { DROP ; PUSH nat 4 } { DROP ; PUSH nat 5 } }

                 { IF_LEFT { DROP ; PUSH nat 6 } { DROP ; PUSH nat 7 } } } ;

           DUP 4 ;

           SWAP ;

           GET ;

           IF_NONE { PUSH int -1 ; FAILWITH } {} ;

           DUG 2 ;

           PAIR ;

           EXEC ;

           UNPAIR }

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

                          GET 4 ;

                          DUP 3 ;

                          GET ;

                          IF_NONE { PUSH nat 0 } {} ;

                          DIG 2 ;

                          PAIR ;

                          CONS } ;

                   NIL operation ;

                   DIG 2 ;

                   CDR ;

                   PUSH mutez 0 ;

                   DIG 3 ;

                   TRANSFER_TOKENS ;

                   CONS }

                 { IF_LEFT

                     { PUSH nat 1 ;

                       DUP 3 ;

                       CAR ;

                       CAR ;

                       SENDER ;

                       GET ;

                       IF_NONE { PUSH int 29 ; FAILWITH } {} ;

                       COMPARE ;

                       EQ ;

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

                       NIL operation ;

                       SWAP ;

                       UNIT ;

                       EXEC ;

                       NIL operation ;

                       SWAP ;

                       ITER { CONS } ;

                       ITER { CONS } }

                     { PUSH nat 1 ;

                       DUP 3 ;

                       CAR ;

                       CAR ;

                       SENDER ;

                       GET ;

                       IF_NONE { PUSH int 29 ; FAILWITH } {} ;

                       COMPARE ;

                       EQ ;

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

                       SWAP ;

                       UNPAIR ;

                       UNPAIR ;

                       PUSH (option nat) (Some 0) ;

                       DIG 4 ;

                       UPDATE ;

                       PAIR ;

                       PAIR ;

                       NIL operation } } }

             { IF_LEFT

                 { IF_LEFT

                     { PUSH nat 1 ;

                       DUP 3 ;

                       CAR ;

                       CAR ;

                       SENDER ;

                       GET ;

                       IF_NONE { PUSH int 29 ; FAILWITH } {} ;

                       COMPARE ;

                       EQ ;

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

                       SWAP ;

                       UNPAIR ;

                       UNPAIR ;

                       NONE nat ;

                       DIG 4 ;

                       UPDATE ;

                       PAIR ;

                       PAIR }

                     { DROP ;

                       DUP ;

                       CAR ;

                       CAR ;

                       PUSH nat 0 ;

                       SWAP ;

                       SENDER ;

                       GET ;

                       IF_NONE { PUSH int 51 ; FAILWITH } {} ;

                       COMPARE ;

                       EQ ;

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

                       UNPAIR ;

                       UNPAIR ;

                       PUSH (option nat) (Some 1) ;

                       SENDER ;

                       UPDATE ;

                       PAIR ;

                       PAIR } }

                 { IF_LEFT

                     { PUSH nat 1 ;

                       DUP 3 ;

                       CAR ;

                       CAR ;

                       SENDER ;

                       GET ;

                       IF_NONE { PUSH int 29 ; FAILWITH } {} ;

                       COMPARE ;

                       EQ ;

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

                       DUP ;

                       CAR ;

                       IF_LEFT

                         { IF_LEFT

                             { IF_LEFT

                                 { DROP ; DIG 2 ; SWAP ; CDR ; SOME ; PUSH nat 0 ; UPDATE ; SWAP }

                                 { DROP ; DIG 2 ; SWAP ; CDR ; SOME ; PUSH nat 1 ; UPDATE ; SWAP } }

                             { IF_LEFT

                                 { DROP ; DIG 2 ; SWAP ; CDR ; SOME ; PUSH nat 2 ; UPDATE ; SWAP }

                                 { DROP ; DIG 2 ; SWAP ; CDR ; SOME ; PUSH nat 3 ; UPDATE ; SWAP } } }

                         { IF_LEFT

                             { IF_LEFT

                                 { DROP ; DIG 2 ; SWAP ; CDR ; SOME ; PUSH nat 4 ; UPDATE ; SWAP }

                                 { DROP ; DIG 2 ; SWAP ; CDR ; SOME ; PUSH nat 5 ; UPDATE ; SWAP } }

                             { IF_LEFT

                                 { DROP ; DIG 2 ; SWAP ; CDR ; SOME ; PUSH nat 6 ; UPDATE ; SWAP }

                                 { DROP ; DIG 2 ; SWAP ; CDR ; SOME ; PUSH nat 7 ; UPDATE ; SWAP } } } }

                     { DUP ;

                       ITER { IF_LEFT

                                { DUP 3 ;

                                  GET 5 ;

                                  SWAP ;

                                  DUP ;

                                  DUG 2 ;

                                  GET 4 ;

                                  MEM ;

                                  IF

                                    {}

                                    { PUSH string "FA2_TOKEN_UNDEFINED" ; FAILWITH } ;

                                  DUP ;

                                  CAR ;

                                  SENDER ;

                                  COMPARE ;

                                  EQ ;

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

                                  DIG 2 ;

                                  UNPAIR ;

                                  SWAP ;

                                  UNPAIR ;

                                  UNPAIR ;

                                  SWAP ;

                                  PUSH (option unit) (Some Unit) ;

                                  DIG 5 ;

                                  DUP ;

                                  GET 4 ;

                                  SWAP ;

                                  DUP ;

                                  GET 3 ;

                                  SWAP ;

                                  CAR ;

                                  PAIR 3 ;

                                  UPDATE ;

                                  SWAP ;

                                  PAIR ;

                                  PAIR ;

                                  SWAP ;

                                  PAIR ;

                                  SWAP }

                                { DUP 3 ;

                                  GET 5 ;

                                  SWAP ;

                                  DUP ;

                                  DUG 2 ;

                                  GET 4 ;

                                  MEM ;

                                  IF

                                    {}

                                    { PUSH string "FA2_TOKEN_UNDEFINED" ; FAILWITH } ;

                                  DUP ;

                                  CAR ;

                                  SENDER ;

                                  COMPARE ;

                                  EQ ;

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

                                  DIG 2 ;

                                  UNPAIR ;

                                  SWAP ;

                                  UNPAIR ;

                                  UNPAIR ;

                                  SWAP ;

                                  NONE unit ;

                                  DIG 5 ;

                                  DUP ;

                                  GET 4 ;

                                  SWAP ;

                                  DUP ;

                                  GET 3 ;

                                  SWAP ;

                                  CAR ;

                                  PAIR 3 ;

                                  UPDATE ;

                                  SWAP ;

                                  PAIR ;

                                  PAIR ;

                                  SWAP ;

                                  PAIR ;

                                  SWAP } } ;

                       DROP } } ;

               NIL operation } } ;

       NIL operation ;

       SWAP ;

       ITER { CONS } ;

       DUG 2 ;

       PAIR ;

       SWAP ;

       PAIR }