{ parameter (or

              (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 %mint (bytes %message) (signature %signature)))

                  (or (mutez %payout) (address %set_administrator)))

                (or

                  (or (bool %set_paused)

                      (list %transfer (pair (address %from_)

                                           (list %txs (pair (address %to_)

                                                           (nat %token_id)

                                                           (nat %amount))))))

                  (or (pair %update (bytes %message) (signature %signature))

                      (list %update_operators (or

                                               (pair %add_operator (address %owner)

                                                                   (address %operator)

                                                                   (nat %token_id))

                                               (pair %remove_operator (address %owner)

                                                                      (address %operator)

                                                                      (nat %token_id)))))))

              (pair %update_pricing_model (pair nat mutez) bool)) ;

  storage (pair

            (pair

              (pair

                (pair %admin (pair (address %address) (bool %paused)) (key %verifier))

                (big_map %assets (pair address nat) nat))

              (big_map %ledger nat address)

              (nat %ledger_counter))

            (pair (big_map %metadata string bytes)

                  (big_map %operators (pair address address) (set nat)))

            (big_map %pricing nat (pair mutez bool))

            (big_map %token_metadata nat

                                     (pair (nat %token_id)

                                           (map %token_info string bytes)))) ;

  code { LAMBDA

           (pair (big_map nat address) nat address)

           bool

           { UNPAIR 3 ;

             SWAP ;

             GET ;

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

             COMPARE ;

             EQ } ;

         LAMBDA

           address

           unit

           { PUSH string "The sender can only manage operators for his own token" ;

             SENDER ;

             DIG 2 ;

             COMPARE ;

             EQ ;

             IF { DROP ; UNIT } { FAILWITH } } ;

         PUSH string "Invalid message" ;

         PUSH string "Invalid contract" ;

         LAMBDA

           (pair

             (pair

               (pair

                 (pair (pair (pair address bool) key) (big_map (pair address nat) nat))

                 (big_map nat address)

                 nat)

               (pair (big_map string bytes) (big_map (pair address address) (set nat)))

               (big_map nat (pair mutez bool))

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

             nat)

           unit

           { UNPAIR ;

             CDR ;

             CDR ;

             CDR ;

             SWAP ;

             GET ;

             IF_NONE { PUSH string "FA2_TOKEN_UNDEFINED" ; FAILWITH } { DROP } ;

             UNIT } ;

         LAMBDA

           bool

           unit

           { NOT ; IF { UNIT } { PUSH string "Contract paused" ; FAILWITH } } ;

         LAMBDA

           timestamp

           unit

           { NOW ;

             SUB ;

             PUSH int 180 ;

             DUP 2 ;

             COMPARE ;

             LE ;

             PUSH int 0 ;

             DIG 2 ;

             COMPARE ;

             GE ;

             AND ;

             IF { UNIT } { PUSH string "Request expired" ; FAILWITH } } ;

         LAMBDA

           (pair mutez mutez)

           unit

           { UNPAIR ;

             COMPARE ;

             EQ ;

             IF { UNIT } { PUSH string "The value is incorrect" ; FAILWITH } } ;

         LAMBDA

           address

           unit

           { PUSH string "Incorrect sender" ;

             SWAP ;

             SENDER ;

             COMPARE ;

             EQ ;

             IF { DROP ; UNIT } { FAILWITH } } ;

         LAMBDA

           (pair key signature bytes)

           unit

           { UNPAIR 3 ;

             PUSH string "Invalid signature" ;

             DUG 3 ;

             CHECK_SIGNATURE ;

             IF { DROP ; UNIT } { FAILWITH } } ;

         LAMBDA

           (pair string bytes)

           unit

           { UNPAIR ;

             PUSH nat 192 ;

             BYTES ;

             DIG 2 ;

             PUSH nat 1 ;

             PUSH nat 0 ;

             SLICE ;

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

             COMPARE ;

             EQ ;

             IF { DROP ; UNIT } { FAILWITH } } ;

         DUP 9 ;

         APPLY ;

         LAMBDA

           bool

           unit

           { IF { UNIT } { PUSH string "Pricing not active" ; FAILWITH } } ;

         LAMBDA

           address

           unit

           { PUSH string "Incorrect contract" ;

             SWAP ;

             SELF_ADDRESS ;

             COMPARE ;

             EQ ;

             IF { DROP ; UNIT } { FAILWITH } } ;

         LAMBDA

           (pair

             (pair

               (pair (pair (pair address bool) key) (big_map (pair address nat) nat))

               (big_map nat address)

               nat)

             (pair (big_map string bytes) (big_map (pair address address) (set nat)))

             (big_map nat (pair mutez bool))

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

           address

           { CAR ; CAR ; CAR ; CAR ; CAR } ;

         LAMBDA

           (pair

             (pair

               (pair

                 (pair (pair (pair address bool) key) (big_map (pair address nat) nat))

                 (big_map nat address)

                 nat)

               (pair (big_map string bytes) (big_map (pair address address) (set nat)))

               (big_map nat (pair mutez bool))

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

             nat)

           (pair mutez bool)

           { UNPAIR ;

             CDR ;

             CDR ;

             CAR ;

             SWAP ;

             GET ;

             IF_NONE { PUSH string "Pricing not found" ; FAILWITH } {} } ;

         DIG 15 ;

         UNPAIR ;

         IF_LEFT

           { IF_LEFT

               { DIG 15 ;

                 DROP ;

                 IF_LEFT

                   { DIG 3 ;

                     DIG 8 ;

                     DIG 13 ;

                     DROP 3 ;

                     IF_LEFT

                       { DIG 2 ;

                         DIG 3 ;

                         DIG 4 ;

                         DIG 5 ;

                         DIG 6 ;

                         DIG 7 ;

                         DIG 8 ;

                         DIG 9 ;

                         DIG 11 ;

                         DROP 9 ;

                         UNPAIR ;

                         MAP { DUP ;

                               UNPAIR ;

                               DUP 2 ;

                               DUP 6 ;

                               PAIR ;

                               DUP 7 ;

                               SWAP ;

                               EXEC ;

                               DROP ;

                               PUSH nat 0 ;

                               SWAP ;

                               DIG 2 ;

                               DUP 6 ;

                               CAR ;

                               CDR ;

                               CAR ;

                               PAIR 3 ;

                               DUP 7 ;

                               SWAP ;

                               EXEC ;

                               IF { DROP ; PUSH nat 1 } {} ;

                               SWAP ;

                               PAIR } ;

                         DIG 3 ;

                         DIG 4 ;

                         DROP 2 ;

                         SWAP ;

                         PUSH mutez 0 ;

                         DIG 2 ;

                         TRANSFER_TOKENS ;

                         SWAP ;

                         NIL operation ;

                         DIG 2 ;

                         CONS }

                       { DIG 10 ;

                         DIG 12 ;

                         DROP 2 ;

                         DUP 2 ;

                         CAR ;

                         CAR ;

                         CAR ;

                         CAR ;

                         CDR ;

                         DIG 10 ;

                         SWAP ;

                         EXEC ;

                         DROP ;

                         DUP ;

                         CAR ;

                         DUP 2 ;

                         CDR ;

                         DUP 4 ;

                         CAR ;

                         CAR ;

                         CAR ;

                         CDR ;

                         PAIR 3 ;

                         DIG 7 ;

                         SWAP ;

                         EXEC ;

                         DROP ;

                         DUP ;

                         CAR ;

                         DIG 6 ;

                         SWAP ;

                         EXEC ;

                         DROP ;

                         DUP ;

                         CAR ;

                         DUP ;

                         PUSH int 1 ;

                         DIG 2 ;

                         SIZE ;

                         SUB ;

                         ABS ;

                         PUSH nat 1 ;

                         SLICE ;

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

                         UNPACK (pair

                                  (pair

                                    (pair (address %asset_contract_address)

                                          (nat %asset_token_id))

                                    (bytes %policy)

                                    (address %policy_contract_address))

                                  (nat %pricing_id)

                                  (timestamp %timestamp)) ;

                         IF_NONE { DIG 7 ; FAILWITH } { DIG 8 ; DROP } ;

                         DUP ;

                         CAR ;

                         CDR ;

                         CDR ;

                         DIG 5 ;

                         SWAP ;

                         EXEC ;

                         DROP ;

                         DUP ;

                         CDR ;

                         CAR ;

                         DUP 4 ;

                         PAIR ;

                         DIG 4 ;

                         SWAP ;

                         EXEC ;

                         UNPAIR ;

                         SWAP ;

                         DIG 5 ;

                         SWAP ;

                         EXEC ;

                         DROP ;

                         AMOUNT ;

                         PAIR ;

                         DIG 4 ;

                         SWAP ;

                         EXEC ;

                         DROP ;

                         DUP ;

                         CDR ;

                         CDR ;

                         DIG 4 ;

                         SWAP ;

                         EXEC ;

                         DROP ;

                         DUP 3 ;

                         CAR ;

                         CAR ;

                         CDR ;

                         DUP 2 ;

                         CAR ;

                         CAR ;

                         CDR ;

                         DUP 3 ;

                         CAR ;

                         CAR ;

                         CAR ;

                         PAIR ;

                         MEM ;

                         NOT ;

                         IF {} { PUSH string "Asset already exists" ; FAILWITH } ;

                         SWAP ;

                         CDR ;

                         PUSH bytes 0x20 ;

                         PAIR ;

                         DUP 2 ;

                         CAR ;

                         CAR ;

                         CDR ;

                         DIG 2 ;

                         CAR ;

                         CAR ;

                         CAR ;

                         PAIR ;

                         PAIR ;

                         PUSH nat 1 ;

                         DUP 3 ;

                         CAR ;

                         CDR ;

                         CDR ;

                         ADD ;

                         EMPTY_MAP string bytes ;

                         DUP 3 ;

                         CDR ;

                         CDR ;

                         PACK ;

                         SOME ;

                         PUSH string "signature" ;

                         UPDATE ;

                         DUP 3 ;

                         CDR ;

                         CAR ;

                         SOME ;

                         PUSH string "policy" ;

                         UPDATE ;

                         DUP 2 ;

                         PAIR ;

                         DUP 4 ;

                         DUP 5 ;

                         CAR ;

                         DUP ;

                         CDR ;

                         DUP 7 ;

                         CAR ;

                         CDR ;

                         CAR ;

                         DUP 8 ;

                         CAR ;

                         CAR ;

                         CAR ;

                         CAR ;

                         CAR ;

                         DUP 7 ;

                         SWAP ;

                         SOME ;

                         SWAP ;

                         UPDATE ;

                         UPDATE 1 ;

                         UPDATE 2 ;

                         UPDATE 1 ;

                         DUP ;

                         CAR ;

                         DUP ;

                         CDR ;

                         DUP 5 ;

                         UPDATE 2 ;

                         UPDATE 2 ;

                         UPDATE 1 ;

                         DUP ;

                         CAR ;

                         DUP ;

                         CAR ;

                         DUP 7 ;

                         CAR ;

                         CAR ;

                         CDR ;

                         DUP 6 ;

                         DUP 8 ;

                         CAR ;

                         CDR ;

                         DIG 8 ;

                         CAR ;

                         CAR ;

                         PAIR ;

                         SWAP ;

                         SOME ;

                         SWAP ;

                         UPDATE ;

                         UPDATE 2 ;

                         UPDATE 1 ;

                         UPDATE 1 ;

                         DUP ;

                         CDR ;

                         DUP ;

                         CDR ;

                         DIG 5 ;

                         CDR ;

                         CDR ;

                         CDR ;

                         DIG 4 ;

                         DIG 5 ;

                         SWAP ;

                         SOME ;

                         SWAP ;

                         UPDATE ;

                         UPDATE 2 ;

                         UPDATE 2 ;

                         UPDATE 2 ;

                         NIL operation } }

                   { DIG 2 ;

                     DIG 4 ;

                     DIG 5 ;

                     DIG 6 ;

                     DIG 7 ;

                     DIG 9 ;

                     DIG 10 ;

                     DIG 11 ;

                     DIG 12 ;

                     DIG 14 ;

                     DIG 15 ;

                     DROP 11 ;

                     IF_LEFT

                       { DUP 2 ;

                         DIG 3 ;

                         SWAP ;

                         EXEC ;

                         DUP ;

                         DIG 4 ;

                         SWAP ;

                         EXEC ;

                         DROP ;

                         PUSH string "Low balance" ;

                         DUP 3 ;

                         BALANCE ;

                         COMPARE ;

                         GE ;

                         IF { DROP } { FAILWITH } ;

                         CONTRACT unit ;

                         IF_NONE { DIG 2 ; FAILWITH } { DIG 3 ; DROP } ;

                         SWAP ;

                         UNIT ;

                         TRANSFER_TOKENS ;

                         SWAP ;

                         NIL operation ;

                         DIG 2 ;

                         CONS }

                       { DUP 2 ;

                         DIG 3 ;

                         SWAP ;

                         EXEC ;

                         DIG 3 ;

                         SWAP ;

                         EXEC ;

                         DROP ;

                         CONTRACT unit ;

                         IF_NONE { SWAP ; FAILWITH } { DIG 2 ; DROP } ;

                         DUP 2 ;

                         DUP 3 ;

                         CAR ;

                         DUP ;

                         CAR ;

                         DIG 4 ;

                         CAR ;

                         CAR ;

                         CAR ;

                         DUP ;

                         CAR ;

                         DIG 5 ;

                         ADDRESS ;

                         UPDATE 1 ;

                         UPDATE 1 ;

                         UPDATE 1 ;

                         UPDATE 1 ;

                         UPDATE 1 ;

                         NIL operation } } }

               { DIG 13 ;

                 DROP ;

                 IF_LEFT

                   { DIG 2 ;

                     DIG 4 ;

                     DIG 5 ;

                     DIG 6 ;

                     DIG 7 ;

                     DIG 9 ;

                     DIG 10 ;

                     DIG 11 ;

                     DIG 13 ;

                     DIG 14 ;

                     DROP 10 ;

                     IF_LEFT

                       { DIG 4 ;

                         DIG 5 ;

                         DROP 2 ;

                         DUP 2 ;

                         DIG 3 ;

                         SWAP ;

                         EXEC ;

                         DIG 3 ;

                         SWAP ;

                         EXEC ;

                         DROP ;

                         DUP 2 ;

                         DUP 3 ;

                         CAR ;

                         DUP ;

                         CAR ;

                         DIG 4 ;

                         CAR ;

                         CAR ;

                         CAR ;

                         DUP ;

                         CAR ;

                         DIG 5 ;

                         UPDATE 2 ;

                         UPDATE 1 ;

                         UPDATE 1 ;

                         UPDATE 1 ;

                         UPDATE 1 }

                       { DIG 2 ;

                         DIG 3 ;

                         DROP 2 ;

                         DUP 2 ;

                         CAR ;

                         CDR ;

                         CAR ;

                         SWAP ;

                         ITER { UNPAIR ;

                                DUG 2 ;

                                ITER { UNPAIR 3 ;

                                       PUSH nat 1 ;

                                       DIG 3 ;

                                       COMPARE ;

                                       NEQ ;

                                       IF

                                         { DROP 3 ;

                                           PUSH string "FA2_WRONG_AMOUNT" ;

                                           FAILWITH }

                                         { DUP 2 ;

                                           DUP 6 ;

                                           PAIR ;

                                           DUP 7 ;

                                           SWAP ;

                                           EXEC ;

                                           DROP ;

                                           SENDER ;

                                           DUP 5 ;

                                           DUP 2 ;

                                           COMPARE ;

                                           NEQ ;

                                           IF

                                             { DUP 6 ;

                                               CDR ;

                                               CAR ;

                                               CDR ;

                                               SWAP ;

                                               DUP 6 ;

                                               PAIR ;

                                               GET ;

                                               IF_NONE { EMPTY_SET nat } {} ;

                                               DUP 3 ;

                                               MEM ;

                                               NOT ;

                                               IF

                                                 { PUSH string "FA2_NOT_OPERATOR" ;

                                                   FAILWITH }

                                                 {} }

                                             { DROP } ;

                                           PUSH string "FA2_INSUFFICIENT_BALANCE" ;

                                           DUP 5 ;

                                           DUP 4 ;

                                           DUP 6 ;

                                           PAIR 3 ;

                                           DUP 9 ;

                                           SWAP ;

                                           EXEC ;

                                           IF { DROP } { FAILWITH } ;

                                           DIG 2 ;

                                           SWAP ;

                                           SOME ;

                                           DIG 2 ;

                                           UPDATE } } ;

                                SWAP ;

                                DROP } ;

                         DIG 2 ;

                         DIG 3 ;

                         DROP 2 ;

                         DUP 2 ;

                         DIG 2 ;

                         CAR ;

                         DUP ;

                         CDR ;

                         DIG 3 ;

                         UPDATE 1 ;

                         UPDATE 2 ;

                         UPDATE 1 } }

                   { DIG 3 ;

                     DIG 8 ;

                     DIG 12 ;

                     DIG 15 ;

                     DROP 4 ;

                     IF_LEFT

                       { DIG 11 ;

                         DROP ;

                         DUP 2 ;

                         CAR ;

                         CAR ;

                         CAR ;

                         CAR ;

                         CDR ;

                         DIG 10 ;

                         SWAP ;

                         EXEC ;

                         DROP ;

                         DUP ;

                         CAR ;

                         DUP 2 ;

                         CDR ;

                         DUP 4 ;

                         CAR ;

                         CAR ;

                         CAR ;

                         CDR ;

                         PAIR 3 ;

                         DIG 7 ;

                         SWAP ;

                         EXEC ;

                         DROP ;

                         DUP ;

                         CAR ;

                         DUP ;

                         PUSH int 1 ;

                         DIG 2 ;

                         SIZE ;

                         SUB ;

                         ABS ;

                         PUSH nat 1 ;

                         SLICE ;

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

                         UNPACK (pair

                                  (pair

                                    (pair (address %asset_contract_address)

                                          (nat %asset_token_id))

                                    (bytes %policy)

                                    (address %policy_contract_address))

                                  (nat %pricing_id)

                                  (timestamp %timestamp)) ;

                         IF_NONE { DIG 8 ; FAILWITH } { DIG 9 ; DROP } ;

                         DUP 2 ;

                         CAR ;

                         DIG 7 ;

                         SWAP ;

                         EXEC ;

                         DROP ;

                         DUP ;

                         CAR ;

                         CDR ;

                         CDR ;

                         DIG 5 ;

                         SWAP ;

                         EXEC ;

                         DROP ;

                         DUP ;

                         CDR ;

                         CAR ;

                         DUP 4 ;

                         PAIR ;

                         DIG 4 ;

                         SWAP ;

                         EXEC ;

                         UNPAIR ;

                         SWAP ;

                         DIG 5 ;

                         SWAP ;

                         EXEC ;

                         DROP ;

                         AMOUNT ;

                         PAIR ;

                         DIG 4 ;

                         SWAP ;

                         EXEC ;

                         DROP ;

                         DUP ;

                         CDR ;

                         CDR ;

                         DIG 4 ;

                         SWAP ;

                         EXEC ;

                         DROP ;

                         DUP 3 ;

                         CAR ;

                         CAR ;

                         CDR ;

                         DUP 2 ;

                         CAR ;

                         CAR ;

                         CDR ;

                         DUP 3 ;

                         CAR ;

                         CAR ;

                         CAR ;

                         PAIR ;

                         GET ;

                         IF_NONE { PUSH string "Policy not found" ; FAILWITH } {} ;

                         DUP 4 ;

                         CAR ;

                         CDR ;

                         CAR ;

                         DUP 2 ;

                         MEM ;

                         IF {} { PUSH string "Token not found" ; FAILWITH } ;

                         DIG 2 ;

                         CDR ;

                         SWAP ;

                         DIG 2 ;

                         CAR ;

                         CDR ;

                         CAR ;

                         PAIR ;

                         PAIR ;

                         DUP 2 ;

                         DUP 3 ;

                         CDR ;

                         DUP ;

                         CDR ;

                         DIG 4 ;

                         CDR ;

                         CDR ;

                         CDR ;

                         EMPTY_MAP string bytes ;

                         DUP 6 ;

                         CDR ;

                         PACK ;

                         SOME ;

                         PUSH string "signature" ;

                         UPDATE ;

                         DUP 6 ;

                         CAR ;

                         CAR ;

                         SOME ;

                         PUSH string "policy" ;

                         UPDATE ;

                         DUP 6 ;

                         CAR ;

                         CDR ;

                         PAIR ;

                         SOME ;

                         DIG 5 ;

                         CAR ;

                         CDR ;

                         UPDATE ;

                         UPDATE 2 ;

                         UPDATE 2 ;

                         UPDATE 2 }

                       { DIG 2 ;

                         DIG 3 ;

                         DIG 4 ;

                         DIG 5 ;

                         DIG 6 ;

                         DIG 7 ;

                         DIG 8 ;

                         DIG 9 ;

                         DIG 10 ;

                         DROP 9 ;

                         DUP 2 ;

                         CDR ;

                         CAR ;

                         CDR ;

                         LAMBDA

                           (pair (lambda address unit)

                                 (pair (big_map (pair address address) (set nat))

                                       (or (pair address address nat)

                                           (pair address address nat))))

                           (big_map (pair address address) (set nat))

                           { UNPAIR ;

                             SWAP ;

                             UNPAIR ;

                             SWAP ;

                             IF_LEFT

                               { DUP ;

                                 GET 3 ;

                                 DUP 2 ;

                                 CAR ;