{ parameter (or

              (or

                (or

                  (list %assert_balances (pair (address %owner)

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

                    (unit %confirm_ownership)))

              (or

                (or

                  (or %owner_action

                    (or

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

                      (unit %renounce_ownership))

                    (address %transfer_ownership))

                  (list %transfer (pair (address %from_)

                                       (list %txs (pair (address %to_)

                                                       (pair (nat %token_id)

                                                             (nat %amount)))))))

                (list %update_operators (or

                                         (pair %add_operator (address %owner)

                                                             (pair (address %operator)

                                                                   (nat %token_id)))

                                         (pair %remove_operator (address %owner)

                                                                (pair

                                                                  (address %operator)

                                                                  (nat %token_id))))))) ;

  storage (pair (big_map %metadata string bytes)

                (pair (pair %roles (address %owner) (option %pending_owner address))

                      (pair (big_map %token_total_supply nat nat)

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

                                  (pair

                                    (big_map %operators

                                      (pair address (pair address nat))

                                      unit)

                                    (big_map %token_metadata nat

                                                             (pair (nat %token_id)

                                                                   (map %token_info

                                                                     string

                                                                     bytes)))))))) ;

  code { NIL operation ;

         LAMBDA

           (pair nat

                 (pair (big_map string bytes)

                       (pair (pair address (option address))

                             (pair (big_map nat nat)

                                   (pair (big_map (pair address nat) nat)

                                         (pair

                                           (big_map (pair address (pair address nat))

                                                    unit)

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

           nat

           { UNPAIR ;

             SWAP ;

             GET 5 ;

             SWAP ;

             GET ;

             IF_NONE { NONE nat } { SOME } ;

             IF_NONE { PUSH nat 0 } {} } ;

         LAMBDA

           (pair address

                 (pair nat

                       (pair (big_map string bytes)

                             (pair (pair address (option address))

                                   (pair (big_map nat nat)

                                         (pair (big_map (pair address nat) nat)

                                               (pair

                                                 (big_map

                                                   (pair address (pair address nat))

                                                   unit)

                                                 (big_map nat

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

           nat

           { UNPAIR 3 ;

             DIG 2 ;

             GET 7 ;

             DUG 2 ;

             PAIR ;

             GET ;

             IF_NONE { NONE nat } { SOME } ;

             IF_NONE { PUSH nat 0 } {} } ;

         LAMBDA

           (pair address

                 (pair address

                       (pair nat

                             (pair (big_map string bytes)

                                   (pair (pair address (option address))

                                         (pair (big_map nat nat)

                                               (pair (big_map (pair address nat) nat)

                                                     (pair

                                                       (big_map

                                                         (pair address

                                                               (pair address nat))

                                                         unit)

                                                       (big_map nat

                                                                (pair nat

                                                                      (map string bytes)))))))))))

           unit

           { UNPAIR 4 ;

             PUSH bool True ;

             DIG 4 ;

             GET 9 ;

             DIG 4 ;

             DUP 5 ;

             PAIR ;

             DUP 4 ;

             PAIR ;

             MEM ;

             DIG 3 ;

             DIG 3 ;

             COMPARE ;

             EQ ;

             OR ;

             COMPARE ;

             EQ ;

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

             UNIT } ;

         LAMBDA

           address

           unit

           { PUSH string "FA2_NOT_OWNER" ;

             SWAP ;

             SENDER ;

             COMPARE ;

             EQ ;

             IF { DROP } { FAILWITH } ;

             UNIT } ;

         LAMBDA

           (pair nat

                 (pair (big_map string bytes)

                       (pair (pair address (option address))

                             (pair (big_map nat nat)

                                   (pair (big_map (pair address nat) nat)

                                         (pair

                                           (big_map (pair address (pair address nat))

                                                    unit)

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

           unit

           { CAR ;

             PUSH nat 0 ;

             COMPARE ;

             EQ ;

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

             UNIT } ;

         DIG 6 ;

         UNPAIR ;

         PUSH string "FA2_DONT_SEND_TEZ" ;

         PUSH mutez 0 ;

         AMOUNT ;

         COMPARE ;

         EQ ;

         IF { DROP } { FAILWITH } ;

         IF_LEFT

           { DIG 3 ;

             DROP ;

             IF_LEFT

               { DIG 3 ;

                 DROP ;

                 DIG 4 ;

                 DROP ;

                 IF_LEFT

                   { DIG 2 ;

                     DROP ;

                     ITER { PUSH string "FA2_INSUFFICIENT_BALANCE" ;

                            DUP 2 ;

                            GET 4 ;

                            DUP 4 ;

                            DUP 4 ;

                            GET 3 ;

                            DIG 4 ;

                            CAR ;

                            PAIR 3 ;

                            DUP 5 ;

                            SWAP ;

                            EXEC ;

                            COMPARE ;

                            GE ;

                            IF { DROP } { FAILWITH } } ;

                     SWAP ;

                     DROP }

                   { DIG 4 ;

                     DROP ;

                     NIL (pair (pair address nat) nat) ;

                     DUP 2 ;

                     CAR ;

                     ITER { DUP 4 ;

                            DUP 2 ;

                            CDR ;

                            PAIR ;

                            DUP 6 ;

                            SWAP ;

                            EXEC ;

                            DROP ;

                            DUP 4 ;

                            DUP 2 ;

                            CDR ;

                            DUP 3 ;

                            CAR ;

                            PAIR 3 ;

                            DUP 7 ;

                            SWAP ;

                            EXEC ;

                            SWAP ;

                            PAIR ;

                            CONS } ;

                     DIG 3 ;

                     DROP ;

                     DIG 3 ;

                     DROP ;

                     NIL operation ;

                     DIG 2 ;

                     CDR ;

                     PUSH mutez 0 ;

                     DIG 3 ;

                     TRANSFER_TOKENS ;

                     CONS ;

                     SWAP } }

               { IF_LEFT

                   { DIG 6 ;

                     DROP ;

                     SWAP ;

                     DUP ;

                     DUP 3 ;

                     GET 3 ;

                     SENDER ;

                     DUP 5 ;

                     CAR ;

                     PAIR 4 ;

                     DIG 4 ;

                     SWAP ;

                     EXEC ;

                     DROP ;

                     DUP ;

                     DUP 3 ;

                     GET 3 ;

                     PAIR ;

                     DIG 3 ;

                     SWAP ;

                     EXEC ;

                     DROP ;

                     DUP ;

                     DUP 3 ;

                     GET 3 ;

                     DUP 4 ;

                     CAR ;

                     PAIR 3 ;

                     DIG 3 ;

                     SWAP ;

                     EXEC ;

                     DUP 3 ;

                     GET 4 ;

                     DUP 2 ;

                     COMPARE ;

                     GE ;

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

                     DUP 3 ;

                     GET 4 ;

                     SWAP ;

                     SUB ;

                     ISNAT ;

                     IF_NONE { PUSH string "option is None" ; FAILWITH } {} ;

                     SWAP ;

                     DUP ;

                     GET 7 ;

                     DUP 3 ;

                     DUP 5 ;

                     GET 3 ;

                     DUP 6 ;

                     CAR ;

                     PAIR ;

                     SWAP ;

                     SOME ;

                     SWAP ;

                     UPDATE ;

                     UPDATE 7 ;

                     SWAP ;

                     DUP 3 ;

                     GET 4 ;

                     DUP 3 ;

                     DUP 5 ;

                     GET 3 ;

                     PAIR ;

                     DIG 5 ;

                     SWAP ;

                     EXEC ;

                     SUB ;

                     ISNAT ;

                     IF_NONE { PUSH string "option is None" ; FAILWITH } {} ;

                     DIG 2 ;

                     DUP ;

                     GET 5 ;

                     DUP 3 ;

                     DUP 6 ;

                     SWAP ;

                     SOME ;

                     SWAP ;

                     GET 3 ;

                     UPDATE ;

                     UPDATE 5 ;

                     DUG 2 ;

                     NIL operation ;

                     PUSH int -1 ;

                     DUP 6 ;

                     GET 4 ;

                     INT ;

                     MUL ;

                     DIG 2 ;

                     DUP 6 ;

                     GET 3 ;

                     NIL (pair address int) ;

                     PUSH int -1 ;

                     DUP 9 ;

                     GET 4 ;

                     INT ;

                     MUL ;

                     DUP 9 ;

                     CAR ;

                     PAIR ;

                     CONS ;

                     PAIR 4 ;

                     EMIT %total_supply_update (pair

                                                 (list (pair (address %owner)

                                                            (int %owner_diff)))

                                                 (pair (nat %token_id)

                                                       (pair (nat %new_total_supply)

                                                             (int %diff)))) ;

                     CONS ;

                     PUSH int -1 ;

                     DUP 5 ;

                     GET 4 ;

                     INT ;

                     MUL ;

                     DIG 2 ;

                     DUP 5 ;

                     GET 3 ;

                     DIG 5 ;

                     CAR ;

                     PAIR 4 ;

                     EMIT %balance_update (pair (address %owner)

                                                (pair (nat %token_id)

                                                      (pair (nat %new_balance)

                                                            (int %diff)))) ;

                     CONS ;

                     SWAP }

                   { DIG 2 ;

                     DROP ;

                     DIG 2 ;

                     DROP ;

                     DIG 2 ;

                     DROP ;

                     DIG 2 ;

                     DROP 2 ;

                     PUSH string "NO_PENDING_OWNER" ;

                     DUP 2 ;

                     GET 3 ;

                     CDR ;

                     IF_NONE { FAILWITH } { SWAP ; DROP } ;

                     PUSH string "INVALID_PENDING_OWNER_ACCESS" ;

                     DUP 2 ;

                     SENDER ;

                     COMPARE ;

                     EQ ;

                     IF { DROP } { FAILWITH } ;

                     SWAP ;

                     DUP ;

                     GET 3 ;

                     DIG 2 ;

                     UPDATE 1 ;

                     UPDATE 3 ;

                     DUP ;

                     GET 3 ;

                     NONE address ;

                     UPDATE 2 ;

                     UPDATE 3 } } }

           { IF_LEFT

               { DIG 3 ;

                 DROP ;

                 IF_LEFT

                   { DIG 3 ;

                     DROP ;

                     PUSH string "FA2_INVALID_ACCESS" ;

                     DUP 3 ;

                     GET 3 ;

                     CAR ;

                     SENDER ;

                     COMPARE ;

                     EQ ;

                     IF { DROP } { FAILWITH } ;

                     IF_LEFT

                       { IF_LEFT

                           { DIG 5 ;

                             DROP ;

                             SWAP ;

                             DUP ;

                             DUP 3 ;

                             GET 3 ;

                             PAIR ;

                             DIG 3 ;

                             SWAP ;

                             EXEC ;

                             DROP ;

                             DUP 2 ;

                             GET 4 ;

                             DUP 2 ;

                             DUP 4 ;

                             GET 3 ;

                             DUP 5 ;

                             CAR ;

                             PAIR 3 ;

                             DIG 4 ;

                             SWAP ;

                             EXEC ;

                             ADD ;

                             SWAP ;

                             DUP ;

                             GET 7 ;

                             DUP 3 ;

                             DUP 5 ;

                             GET 3 ;

                             DUP 6 ;

                             CAR ;

                             PAIR ;

                             SWAP ;

                             SOME ;

                             SWAP ;

                             UPDATE ;

                             UPDATE 7 ;

                             SWAP ;

                             DUP 3 ;

                             GET 4 ;

                             DUP 3 ;

                             DUP 5 ;

                             GET 3 ;

                             PAIR ;

                             DIG 5 ;

                             SWAP ;

                             EXEC ;

                             ADD ;

                             DIG 2 ;

                             DUP ;

                             GET 5 ;

                             DUP 3 ;

                             DUP 6 ;

                             SWAP ;

                             SOME ;

                             SWAP ;

                             GET 3 ;

                             UPDATE ;

                             UPDATE 5 ;

                             DUG 2 ;

                             NIL operation ;

                             DUP 5 ;

                             GET 4 ;

                             INT ;

                             DIG 2 ;

                             DUP 6 ;

                             GET 3 ;

                             NIL (pair address int) ;

                             DUP 8 ;

                             GET 4 ;

                             INT ;

                             DUP 9 ;

                             CAR ;

                             PAIR ;

                             CONS ;

                             PAIR 4 ;

                             EMIT %total_supply_update (pair

                                                         (list (pair (address %owner)

                                                                    (int %owner_diff)))

                                                         (pair (nat %token_id)

                                                               (pair

                                                                 (nat %new_total_supply)

                                                                 (int %diff)))) ;

                             CONS ;

                             DUP 4 ;

                             GET 4 ;

                             INT ;

                             DIG 2 ;

                             DUP 5 ;

                             GET 3 ;

                             DIG 5 ;

                             CAR ;

                             PAIR 4 ;

                             EMIT %balance_update (pair (address %owner)

                                                        (pair (nat %token_id)

                                                              (pair (nat %new_balance)

                                                                    (int %diff)))) ;

                             CONS ;

                             SWAP }

                           { DIG 2 ;

                             DROP ;

                             DIG 2 ;

                             DROP ;

                             DIG 2 ;

                             DROP 2 ;

                             DUP ;

                             GET 3 ;

                             PUSH address "tz1Ke2h7sDdakHJQh8WX4Z372du1KChsksyU" ;

                             UPDATE 1 ;

                             UPDATE 3 } }

                       { DIG 2 ;

                         DROP ;

                         DIG 2 ;

                         DROP ;

                         DIG 2 ;

                         DROP ;

                         SWAP ;

                         DUP ;

                         GET 3 ;

                         DIG 2 ;

                         SOME ;

                         UPDATE 2 ;

                         UPDATE 3 } }

                   { DIG 5 ;

                     DROP ;

                     DIG 5 ;

                     DROP ;

                     SWAP ;

                     EMPTY_MAP (pair address nat) nat ;

                     NIL operation ;

                     DIG 3 ;

                     ITER { DUP ;

                            CDR ;

                            ITER { DUP 5 ;

                                   DUP 2 ;

                                   GET 3 ;

                                   SENDER ;

                                   DUP 5 ;

                                   CAR ;

                                   PAIR 4 ;

                                   DUP 8 ;

                                   SWAP ;

                                   EXEC ;

                                   DROP ;

                                   DUP 5 ;

                                   DUP 2 ;

                                   GET 3 ;

                                   PAIR ;

                                   DUP 7 ;

                                   SWAP ;

                                   EXEC ;

                                   DROP ;

                                   DUP 5 ;

                                   DUP 2 ;

                                   GET 3 ;

                                   DUP 4 ;

                                   CAR ;

                                   PAIR 3 ;

                                   DUP 9 ;

                                   SWAP ;

                                   EXEC ;

                                   DUP 2 ;

                                   GET 4 ;

                                   DUP 2 ;

                                   COMPARE ;

                                   LT ;

                                   IF

                                     { PUSH string "FA2_INSUFFICIENT_BALANCE" ; FAILWITH }

                                     {} ;

                                   PUSH bool False ;

                                   DUP 6 ;

                                   DUP 4 ;

                                   GET 3 ;

                                   DUP 6 ;

                                   CAR ;

                                   PAIR ;

                                   MEM ;

                                   COMPARE ;

                                   EQ ;

                                   IF

                                     { DIG 4 ;

                                       DUP 2 ;

                                       DUP 4 ;

                                       GET 3 ;

                                       DUP 6 ;

                                       CAR ;

                                       PAIR ;

                                       SWAP ;

                                       SOME ;

                                       SWAP ;

                                       UPDATE ;

                                       DUG 4 }

                                     {} ;

                                   DIG 5 ;

                                   DUP ;

                                   GET 7 ;

                                   DUP 4 ;

                                   GET 4 ;

                                   DIG 3 ;

                                   SUB ;

                                   ABS ;

                                   DUP 4 ;

                                   GET 3 ;

                                   DUP 6 ;

                                   CAR ;

                                   PAIR ;

                                   SWAP ;

                                   SOME ;

                                   SWAP ;

                                   UPDATE ;

                                   UPDATE 7 ;

                                   DUG 4 ;

                                   DUP 5 ;

                                   DUP 2 ;

                                   GET 3 ;

                                   DUP 3 ;

                                   CAR ;

                                   PAIR 3 ;

                                   DUP 9 ;

                                   SWAP ;

                                   EXEC ;

                                   PUSH bool False ;

                                   DUP 6 ;

                                   DUP 4 ;

                                   GET 3 ;

                                   DUP 5 ;

                                   CAR ;

                                   PAIR ;

                                   MEM ;

                                   COMPARE ;

                                   EQ ;

                                   IF

                                     { DIG 4 ;

                                       DUP 2 ;

                                       DUP 4 ;

                                       GET 3 ;

                                       DUP 5 ;

                                       CAR ;

                                       PAIR ;

                                       SWAP ;

                                       SOME ;

                                       SWAP ;

                                       UPDATE ;

                                       DUG 4 }

                                     {} ;

                                   DIG 5 ;

                                   DUP ;

                                   GET 7 ;

                                   DUP 4 ;

                                   GET 4 ;

                                   DIG 3 ;

                                   ADD ;

                                   DUP 4 ;

                                   GET 3 ;

                                   DUP 5 ;

                                   CAR ;

                                   PAIR ;

                                   SWAP ;

                                   SOME ;

                                   SWAP ;

                                   UPDATE ;

                                   UPDATE 7 ;

                                   DUG 4 ;

                                   DIG 2 ;

                                   DUP 2 ;

                                   GET 4 ;

                                   DUP 3 ;

                                   GET 3 ;

                                   DIG 3 ;

                                   CAR ;

                                   DUP 5 ;

                                   CAR ;

                                   PAIR 4 ;

                                   EMIT %transfer_event (pair (address %from_)

                                                              (pair (address %to_)

                                                                    (pair

                                                                      (nat %token_id)

                                                                      (nat %amount)))) ;

                                   CONS ;

                                   SWAP } ;

                            DROP } ;

                     DIG 3 ;

                     DROP ;

                     DIG 3 ;

                     DROP ;

                     SWAP ;

                     ITER { UNPAIR ;

                            DUP 4 ;

                            DUP 2 ;

                            CDR ;

                            DUP 3 ;

                            CAR ;

                            PAIR 3 ;

                            DUP 6 ;

                            SWAP ;

                            EXEC ;

                            DIG 2 ;

                            DUP 2 ;

                            SUB ;

                            SWAP ;

                            DUP 3 ;

                            CDR ;

                            DIG 3 ;

                            CAR ;

                            PAIR 4 ;

                            EMIT %balance_update (pair (address %owner)

                                                       (pair (nat %token_id)

                                                             (pair (nat %new_balance)

                                                                   (int %diff)))) ;

                            CONS } ;

                     DIG 2 ;

                     DROP ;

                     SWAP } }

               { DIG 4 ;

                 DROP ;

                 DIG 4 ;

                 DROP ;

                 DIG 4 ;

                 DROP ;

                 DIG 4 ;

                 DROP ;

                 SWAP ;

                 NIL operation ;

                 DIG 2 ;

                 ITER { IF_LEFT

                          { DUP 3 ;

                            DUP 2 ;

                            GET 4 ;

                            PAIR ;

                            DUP 5 ;

                            SWAP ;

                            EXEC ;

                            DROP ;

                            DUP ;

                            CAR ;

                            DUP 6 ;

                            SWAP ;

                            EXEC ;

                            DROP ;

                            DIG 2 ;

                            DUP ;

                            GET 9 ;

                            PUSH (option unit) (Some Unit) ;

                            DUP 4 ;

                            GET 4 ;

                            DUP 5 ;

                            GET 3 ;

                            PAIR ;

                            DUP 5 ;

                            CAR ;

                            PAIR ;

                            UPDATE ;

                            UPDATE 9 ;

                            DUG 2 ;

                            SWAP ;

                            PUSH bool True ;

                            DUP 3 ;

                            GET 4 ;

                            DUP 4 ;

                            GET 3 ;

                            DIG 4 ;

                            CAR ;

                            PAIR 4 ;

                            EMIT %operator_update (pair (address %owner)

                                                        (pair (address %operator)

                                                              (pair (nat %token_id)

                                                                    (bool %is_operator)))) }

                          { DUP 3 ;

                            DUP 2 ;

                            GET 4 ;

                            PAIR ;

                            DUP 5 ;

                            SWAP ;

                            EXEC ;

                            DROP ;

                            DUP ;

                            CAR ;

                            DUP 6 ;

                            SWAP ;

                            EXEC ;

                            DROP ;

                            DIG 2 ;

                            DUP ;

                            GET 9 ;

                            DUP 3 ;

                            GET 4 ;

                            DUP 4 ;

                            GET 3 ;

                            PAIR ;

                            DUP 4 ;

                            CAR ;

                            PAIR ;

                            NONE unit ;

                            SWAP ;

                            UPDATE ;

                            UPDATE 9 ;

                            DUG 2 ;

                            SWAP ;

                            PUSH bool False ;

                            DUP 3 ;

                            GET 4 ;

                            DUP 4 ;

                            GET 3 ;

                            DIG 4 ;

                            CAR ;

                            PAIR 4 ;

                            EMIT %operator_update (pair (address %owner)

                                                        (pair (address %operator)

                                                              (pair (nat %token_id)

                                                                    (bool %is_operator)))) } ;

                        CONS } ;

                 DIG 2 ;

                 DROP ;

                 DIG 2 ;

                 DROP ;

                 SWAP } } ;