{ parameter (or

              (or

                (or

                  (or

                    (pair %balance_of

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

                      (contract (list (pair

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

                                      (nat %balance)))))

                    (address %declare_ownership))

                  (or (unit %claim_ownership) (unit %pause)))

                (or

                  (or (unit %unpause) (pair %set_metadata (string %ikey) (bytes %idata)))

                  (or

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

                    (list %update_operators_for_all (or address address)))))

              (or

                (or

                  (or (nat %set_default_expiry)

                      (pair %set_expiry (option %v nat) (option %p bytes)))

                  (or (pair %permit (key %pk) (pair (signature %sig) (bytes %data)))

                      (list %transfer_gasless (pair

                                               (list (pair address

                                                          (list (pair (address %to)

                                                                     (pair

                                                                       (nat %token_id)

                                                                       (nat %amount))))))

                                               (pair key signature)))))

                (or

                  (or

                    (list %transfer (pair address

                                         (list (pair (address %to)

                                                    (pair (nat %token_id) (nat %amount))))))

                    (pair %mint (nat %itokenid)

                                (pair (address %iowner)

                                      (pair (nat %iamount)

                                            (pair (map %itokenMetadata string bytes)

                                                  (list %iroyalties (pair

                                                                     (address %partAccount)

                                                                     (nat %partValue))))))))

                  (pair %burn (nat %itokenid) (nat %iamount))))) ;

  storage (pair (address %owner)

                (pair (option %owner_candidate address)

                      (pair (bool %paused)

                            (pair

                              (big_map %royalties nat

                                                  (list (pair (address %partAccount)

                                                             (nat %partValue))))

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

                                    (pair

                                      (big_map %operator

                                        (pair address (pair nat address))

                                        unit)

                                      (pair

                                        (big_map %token_metadata nat

                                                                 (pair (nat %token_id)

                                                                       (map %token_info

                                                                         string

                                                                         bytes)))

                                        (pair

                                          (big_map %permits address

                                                            (pair (nat %counter)

                                                                  (pair

                                                                    (option %user_expiry nat)

                                                                    (map %user_permits

                                                                      bytes

                                                                      (pair

                                                                        (option %expiry nat)

                                                                        (timestamp %created_at))))))

                                          (pair

                                            (big_map %operator_for_all

                                              (pair address address)

                                              unit)

                                            (pair (nat %default_expiry)

                                                  (big_map %metadata string bytes))))))))))) ;

  code { LAMBDA

           (pair string bool)

           bool

           { UNPAIR 2 ;

             PUSH unit Unit ;

             DUP 3 ;

             NOT ;

             IF

               { PUSH bool True ; SWAP ; DROP }

               { PUSH string "CONTRACT_PAUSED" ; FAILWITH } ;

             DUG 2 ;

             DROP 2 } ;

         LAMBDA

           (pair (big_map (pair nat address) nat)

                 (pair (big_map (pair address address) unit)

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

                             (list (pair address

                                        (list (pair (address %to)

                                                   (pair (nat %token_id) (nat %amount)))))))))

           bool

           { UNPAIR 4 ;

             PUSH unit Unit ;

             PUSH bool True ;

             DUP 6 ;

             ITER { DUP ;

                    CAR ;

                    DUP 2 ;

                    CDR ;

                    DUP ;

                    ITER { DUP 3 ;

                           SENDER ;

                           COMPARE ;

                           NEQ ;

                           IF

                             { DUP 8 ;

                               DUP 4 ;

                               SENDER ;

                               PAIR ;

                               MEM ;

                               DUP 10 ;

                               DUP 5 ;

                               DUP 4 ;

                               CDR ;

                               CAR ;

                               PAIR ;

                               SENDER ;

                               PAIR ;

                               MEM ;

                               OR }

                             { DUP 7 ; SENDER ; DUP 3 ; CDR ; CAR ; PAIR ; MEM } ;

                           DUP 6 ;

                           AND ;

                           DIP { DIG 4 ; DROP } ;

                           DUG 4 ;

                           DROP } ;

                    DROP 3 } ;

             DUP ;

             DIP { DIG 1 ; DROP } ;

             DUG 1 ;

             DROP ;

             DUG 4 ;

             DROP 4 } ;

         LAMBDA

           (pair

             (big_map address

                      (pair (nat %counter)

                            (pair (option %user_expiry nat)

                                  (map %user_permits bytes

                                                     (pair (option %expiry nat)

                                                           (timestamp %created_at))))))

             (pair nat address))

           nat

           { UNPAIR 3 ;

             PUSH unit Unit ;

             DUP 3 ;

             DUP 3 ;

             DUP 6 ;

             MEM ;

             IF

               { DUP 3 ;

                 DUP 6 ;

                 GET ;

                 IF_NONE

                   { PUSH string "permits" ; PUSH string "AssetNotFound" ; PAIR ; FAILWITH }

                   {} ;

                 CDR ;

                 CAR ;

                 IF_NONE

                   { DUP 4 ; SWAP ; DROP }

                   { DUP ; DIP { DIG 1 ; DROP } ; DUG 1 ; DROP } }

               {} ;

             DUP ;

             DIP { DIG 1 ; DROP } ;

             DUG 1 ;

             DROP ;

             DUG 3 ;

             DROP 3 } ;

         LAMBDA

           (pair

             (big_map address

                      (pair (nat %counter)

                            (pair (option %user_expiry nat)

                                  (map %user_permits bytes

                                                     (pair (option %expiry nat)

                                                           (timestamp %created_at))))))

             (pair nat

                   (pair address

                         (pair bytes

                               (lambda

                                 (pair

                                   (big_map address

                                            (pair (nat %counter)

                                                  (pair (option %user_expiry nat)

                                                        (map %user_permits bytes

                                                                           (pair

                                                                             (option %expiry nat)

                                                                             (timestamp %created_at))))))

                                   (pair nat address))

                                 nat)))))

           nat

           { UNPAIR 5 ;

             PUSH unit Unit ;

             DUP 6 ;

             DUP 5 ;

             DUP 5 ;

             PAIR ;

             DUP 4 ;

             PAIR ;

             EXEC ;

             DUP 3 ;

             DUP 6 ;

             MEM ;

             IF

               { DUP 3 ;

                 DUP 6 ;

                 GET ;

                 IF_NONE

                   { PUSH string "permits" ; PUSH string "AssetNotFound" ; PAIR ; FAILWITH }

                   {} ;

                 CDR ;

                 CDR ;

                 DUP 7 ;

                 MEM ;

                 IF

                   { DUP 3 ;

                     DUP 6 ;

                     GET ;

                     IF_NONE

                       { PUSH string "permits" ; PUSH string "AssetNotFound" ; PAIR ; FAILWITH }

                       {} ;

                     CDR ;

                     CDR ;

                     DUP 7 ;

                     GET ;

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

                     CAR ;

                     IF_NONE {} { DUP ; DIP { DIG 1 ; DROP } ; DUG 1 ; DROP } }

                   {} }

               {} ;

             DUP ;

             DIP { DIG 1 ; DROP } ;

             DUG 1 ;

             DROP ;

             DUG 5 ;

             DROP 5 } ;

         LAMBDA

           (pair (pair (option %expiry nat) (timestamp %created_at)) nat)

           bool

           { UNPAIR 2 ;

             PUSH unit Unit ;

             DUP 2 ;

             CAR ;

             IF_NONE

               { NOW ;

                 PUSH int 1 ;

                 PUSH nat 1 ;

                 DUP 6 ;

                 INT ;

                 PAIR ;

                 PAIR ;

                 UNPAIR ;

                 UNPAIR ;

                 DIG 2 ;

                 MUL ;

                 EDIV ;

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

                 CAR ;

                 DUP 4 ;

                 CDR ;

                 ADD ;

                 COMPARE ;

                 LT ;

                 SWAP ;

                 DROP }

               { NOW ;

                 PUSH int 1 ;

                 PUSH nat 1 ;

                 DUP 4 ;

                 INT ;

                 PAIR ;

                 PAIR ;

                 UNPAIR ;

                 UNPAIR ;

                 DIG 2 ;

                 MUL ;

                 EDIV ;

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

                 CAR ;

                 DUP 5 ;

                 CDR ;

                 ADD ;

                 COMPARE ;

                 LT ;

                 DIP { DIG 1 ; DROP } ;

                 DUG 1 ;

                 DROP } ;

             DUG 2 ;

             DROP 2 } ;

         LAMBDA

           (pair string

                 (list (pair address

                            (list (pair (address %to)

                                       (pair (nat %token_id) (nat %amount)))))))

           (option address)

           { UNPAIR 2 ;

             PUSH unit Unit ;

             DUP 3 ;

             IF_CONS

               { DUP ;

                 CAR ;

                 DUP 3 ;

                 ITER { DUP ;

                        CAR ;

                        DUP 3 ;

                        COMPARE ;

                        EQ ;

                        NOT ;

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

                        DROP } ;

                 DUP ;

                 SOME ;

                 DIP { DIG 3 ; DROP } ;

                 DUG 3 ;

                 DROP 3 }

               { NONE address ; SWAP ; DROP } ;

             DUG 2 ;

             DROP 2 } ;

         NIL operation ;

         DIG 7 ;

         UNPAIR ;

         DIP { UNPAIR 11 } ;

         IF_LEFT

           { IF_LEFT

               { IF_LEFT

                   { IF_LEFT

                       { UNPAIR ;

                         DUP 14 ;

                         DUP 3 ;

                         AMOUNT ;

                         DUP 4 ;

                         MAP { DUP 11 ;

                               DUP 2 ;

                               CAR ;

                               DUP 3 ;

                               CDR ;

                               PAIR ;

                               MEM ;

                               IF

                                 { DUP 11 ;

                                   DUP 2 ;

                                   CAR ;

                                   DUP 3 ;

                                   CDR ;

                                   PAIR ;

                                   GET ;

                                   IF_NONE

                                     { PUSH string "ledger" ;

                                       PUSH string "AssetNotFound" ;

                                       PAIR ;

                                       FAILWITH }

                                     {} }

                                 { PUSH nat 0 } ;

                               DUP 2 ;

                               PAIR ;

                               SWAP ;

                               DROP } ;

                         TRANSFER_TOKENS ;

                         CONS ;

                         DIP { DIG 13 ; DROP } ;

                         DUG 13 ;

                         DROP 2 ;

                         PAIR 11 ;

                         DIG 1 ;

                         PAIR }

                       { DUP 2 ;

                         SENDER ;

                         COMPARE ;

                         EQ ;

                         NOT ;

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

                         DUP ;

                         SOME ;

                         DIP { DIG 2 ; DROP } ;

                         DUG 2 ;

                         DROP ;

                         PAIR 11 ;

                         DIG 1 ;

                         PAIR } }

                   { IF_LEFT

                       { DROP ;

                         DUP 2 ;

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

                         SENDER ;

                         COMPARE ;

                         EQ ;

                         NOT ;

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

                         DUP 2 ;

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

                         SWAP ;

                         DROP ;

                         NONE address ;

                         DIP { DIG 1 ; DROP } ;

                         DUG 1 ;

                         PAIR 11 ;

                         DIG 1 ;

                         PAIR }

                       { DROP ;

                         DUP ;

                         SENDER ;

                         COMPARE ;

                         EQ ;

                         NOT ;

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

                         DUP 3 ;

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

                         PUSH bool True ;

                         DIP { DIG 2 ; DROP } ;

                         DUG 2 ;

                         PAIR 11 ;

                         DIG 1 ;

                         PAIR } } }

               { IF_LEFT

                   { IF_LEFT

                       { DROP ;

                         DUP ;

                         SENDER ;

                         COMPARE ;

                         EQ ;

                         NOT ;

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

                         DUP 3 ;

                         NOT ;

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

                         PUSH bool False ;

                         DIP { DIG 2 ; DROP } ;

                         DUG 2 ;

                         PAIR 11 ;

                         DIG 1 ;

                         PAIR }

                       { UNPAIR ;

                         SWAP ;

                         DUP 3 ;

                         SENDER ;

                         COMPARE ;

                         EQ ;

                         NOT ;

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

                         DUP 20 ;

                         DUP 6 ;

                         PUSH string "CONTRACT_PAUSED" ;

                         PAIR ;

                         EXEC ;

                         NOT ;

                         IF

                           { PUSH string "r3" ;

                             PUSH string "InvalidCondition" ;

                             PAIR ;

                             FAILWITH }

                           {} ;

                         DIG 12 ;

                         DUP 2 ;

                         SOME ;

                         DUP 4 ;

                         UPDATE ;

                         DUG 12 ;

                         DROP 2 ;

                         PAIR 11 ;

                         DIG 1 ;

                         PAIR } }

                   { IF_LEFT

                       { DUP 19 ;

                         DUP 5 ;

                         PUSH string "CONTRACT_PAUSED" ;

                         PAIR ;

                         EXEC ;

                         NOT ;

                         IF

                           { PUSH string "r0" ;

                             PUSH string "InvalidCondition" ;

                             PAIR ;

                             FAILWITH }

                           {} ;

                         DUP ;

                         ITER { DUP ;

                                IF_LEFT

                                  { SENDER ;

                                    DUP 2 ;

                                    CAR ;

                                    COMPARE ;

                                    EQ ;

                                    NOT ;

                                    IF

                                      { PUSH string "CALLER_NOT_OWNER" ; FAILWITH }

                                      {} ;

                                    DUP 9 ;

                                    DUP 2 ;

                                    CAR ;

                                    DUP 3 ;

                                    CDR ;

                                    CDR ;

                                    PAIR ;

                                    DUP 3 ;

                                    CDR ;

                                    CAR ;

                                    PAIR ;

                                    MEM ;

                                    IF

                                      { PUSH string "operator" ;

                                        PUSH string "KeyExists" ;

                                        PAIR ;

                                        FAILWITH }

                                      { DUP 9 ;

                                        PUSH unit Unit ;

                                        SOME ;

                                        DUP 3 ;

                                        CAR ;

                                        DUP 4 ;

                                        CDR ;

                                        CDR ;

                                        PAIR ;

                                        DUP 4 ;

                                        CDR ;

                                        CAR ;

                                        PAIR ;

                                        UPDATE ;

                                        DIP { DIG 8 ; DROP } ;

                                        DUG 8 } ;

                                    DROP }

                                  { SENDER ;

                                    DUP 2 ;

                                    CAR ;

                                    COMPARE ;

                                    EQ ;

                                    NOT ;

                                    IF

                                      { PUSH string "CALLER_NOT_OWNER" ; FAILWITH }

                                      {} ;

                                    DUP 9 ;

                                    NONE unit ;

                                    DUP 3 ;

                                    CAR ;

                                    DUP 4 ;

                                    CDR ;

                                    CDR ;

                                    PAIR ;

                                    DUP 4 ;

                                    CDR ;

                                    CAR ;

                                    PAIR ;

                                    UPDATE ;

                                    DIP { DIG 8 ; DROP } ;

                                    DUG 8 ;

                                    DROP } ;

                                DROP } ;

                         DROP ;

                         PAIR 11 ;

                         DIG 1 ;

                         PAIR }

                       { DUP 19 ;

                         DUP 5 ;

                         PUSH string "CONTRACT_PAUSED" ;

                         PAIR ;

                         EXEC ;

                         NOT ;

                         IF

                           { PUSH string "r1" ;

                             PUSH string "InvalidCondition" ;

                             PAIR ;

                             FAILWITH }

                           {} ;

                         DUP ;

                         ITER { DUP ;

                                IF_LEFT

                                  { DUP 12 ;

                                    SENDER ;

                                    DUP 3 ;

                                    PAIR ;

                                    MEM ;

                                    IF

                                      { PUSH string "operator_for_all" ;

                                        PUSH string "KeyExists" ;

                                        PAIR ;

                                        FAILWITH }

                                      { DUP 12 ;

                                        PUSH unit Unit ;

                                        SOME ;

                                        SENDER ;

                                        DUP 4 ;

                                        PAIR ;

                                        UPDATE ;

                                        DIP { DIG 11 ; DROP } ;

                                        DUG 11 } ;

                                    DROP }

                                  { DUP 12 ;

                                    NONE unit ;

                                    SENDER ;

                                    DUP 4 ;

                                    PAIR ;

                                    UPDATE ;

                                    DIP { DIG 11 ; DROP } ;

                                    DUG 11 ;

                                    DROP } ;

                                DROP } ;

                         DROP ;

                         PAIR 11 ;

                         DIG 1 ;

                         PAIR } } } }

           { IF_LEFT

               { IF_LEFT

                   { IF_LEFT

                       { DUP 2 ;

                         SENDER ;

                         COMPARE ;

                         EQ ;

                         NOT ;

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

                         DUP 19 ;

                         DUP 5 ;

                         PUSH string "CONTRACT_PAUSED" ;

                         PAIR ;

                         EXEC ;

                         NOT ;

                         IF

                           { PUSH string "r6" ;

                             PUSH string "InvalidCondition" ;

                             PAIR ;

                             FAILWITH }

                           {} ;

                         DUP ;

                         DIP { DIG 10 ; DROP } ;

                         DUG 10 ;

                         DROP ;

                         PAIR 11 ;

                         DIG 1 ;

                         PAIR }

                       { UNPAIR ;

                         SWAP ;

                         DUP 20 ;

                         DUP 6 ;

                         PUSH string "CONTRACT_PAUSED" ;

                         PAIR ;

                         EXEC ;

                         NOT ;

                         IF

                           { PUSH string "r7" ;

                             PUSH string "InvalidCondition" ;

                             PAIR ;

                             FAILWITH }

                           {} ;

                         DUP 2 ;

                         IF_NONE

                           {}

                           { DUP 13 ;

                             DUP 2 ;

                             COMPARE ;

                             GE ;

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

                             DROP } ;

                         DUP 10 ;

                         SENDER ;

                         MEM ;

                         IF

                           { DUP ;

                             IF_NONE

                               { DUP 10 ;

                                 DUP 11 ;

                                 SENDER ;

                                 GET ;

                                 IF_NONE

                                   { PUSH string "permits" ;

                                     PUSH string "AssetNotFound" ;

                                     PAIR ;

                                     FAILWITH }

                                   {} ;

                                 UNPAIR ;

                                 SWAP ;

                                 UNPAIR ;

                                 DROP ;

                                 DUP 5 ;

                                 PAIR ;

                                 SWAP ;

                                 PAIR ;

                                 SOME ;

                                 SENDER ;

                                 UPDATE ;

                                 DIP { DIG 9 ; DROP } ;

                                 DUG 9 }

                               { DUP 11 ;

                                 SENDER ;

                                 GET ;

                                 IF_NONE

                                   { PUSH string "permits" ;

                                     PUSH string "AssetNotFound" ;

                                     PAIR ;

                                     FAILWITH }

                                   {} ;

                                 CDR ;

                                 CDR ;

                                 DUP 2 ;

                                 MEM ;

                                 IF

                                   { PUSH bool True ;

                                     DUP 4 ;

                                     IF_NONE

                                       {}

                                       { PUSH nat 0 ;

                                         DUP 2 ;

                                         COMPARE ;

                                         EQ ;

                                         IF

                                           { PUSH bool False ;

                                             DIP { DIG 1 ; DROP } ;

                                             DUG 1 ;

                                             DUP 13 ;

                                             DUP 14 ;

                                             SENDER ;

                                             GET ;

                                             IF_NONE

                                               { PUSH string "permits" ;

                                                 PUSH string "AssetNotFound" ;

                                                 PAIR ;

                                                 FAILWITH }

                                               {} ;

                                             UNPAIR ;

                                             SWAP ;

                                             UNPAIR ;

                                             SWAP ;

                                             DROP ;

                                             DUP 16 ;

                                             SENDER ;

                                             GET ;

                                             IF_NONE

                                               { PUSH string "permits" ;

                                                 PUSH string "AssetNotFound" ;

                                                 PAIR ;

                                                 FAILWITH }

                                               {} ;

                                             CDR ;

                                             CDR ;

                                             NONE (pair (option nat) timestamp) ;

                                             DUP 8 ;

                                             UPDATE ;

                                             SWAP ;

                                             PAIR ;

                                             SWAP ;

                                             PAIR ;

                                             SOME ;

                                             SENDER ;

                                             UPDATE ;

                                             DIP { DIG 12 ; DROP } ;

                                             DUG 12 }

                                           {} ;

                                         DROP } ;

                                     DUP ;

                                     IF

                                       { DUP 12 ;

                                         SENDER ;

                                         GET ;

                                         IF_NONE

                                           { PUSH string "permits" ;

                                             PUSH string "AssetNotFound" ;

                                             PAIR ;

                                             FAILWITH }

                                           {} ;

                                         CDR ;

                                         CDR ;

                                         DUP 3 ;

                                         GET ;

                                         IF_NONE

                                           { PUSH string "NotFound" ; FAILWITH }

                                           {} ;

                                         DUP 13 ;

                                         DUP 14 ;

                                         SENDER ;

                                         GET ;

                                         IF_NONE

                                           { PUSH string "permits" ;

                                             PUSH string "AssetNotFound" ;

                                             PAIR ;

                                             FAILWITH }

                                           {} ;

                                         UNPAIR ;

                                         SWAP ;

                                         UNPAIR ;

                                         SWAP ;

                                         DROP ;

                                         DUP 16 ;

                                         SENDER ;

                                         GET ;

                                         IF_NONE

                                           { PUSH string "permits" ;

                                             PUSH string "AssetNotFound" ;

                                             PAIR ;

                                             FAILWITH }

                                           {} ;

                                         CDR ;

                                         CDR ;

                                         DUP 5 ;

                                         UNPAIR ;

                                         DROP ;

                                         DUP 10 ;

                                         PAIR ;

                                         SOME ;

                                         DUP 8 ;

                                         UPDATE ;

                                         SWAP ;

                                         PAIR ;

                                         SWAP ;

                                         PAIR ;

                                         SOME ;

                                         SENDER ;

                                         UPDATE ;

                                         DIP { DIG 12 ; DROP } ;

                                         DUG 12 ;