parameter (or

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

                    (address %declare_ownership))

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

                (or

                  (or (unit %unpause)

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

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

                      (nat %set_default_expiry))))

              (or

                (or

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

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

                  (or

                    (list %transfer_gasless (pair

                                             (list (pair (address %from_)

                                                        (list %txs (pair (address %to_)

                                                                        (pair

                                                                          (nat %token_id)

                                                                          (nat %amount))))))

                                             (pair key signature)))

                    (list %transfer (pair (address %from_)

                                         (list %txs (pair (address %to_)

                                                         (pair (nat %token_id)

                                                               (nat %amount))))))))

                (or

                  (or (unit %collect)

                      (pair %collect_token (address %token_contract) (nat %token_amount)))

                  (or

                    (pair %collect_FA2token (nat %amount)

                                            (pair (address %contr) (nat %token_number)))

                    (pair %mint (nat %itokenid) (pair (address %iowner) (nat %iamount)))))))

            (or

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

                  (pair %set_metadata (string %ikey) (bytes %idata)))

              (pair %set_token_metadata (nat %itokenid)

                                        (map %itokenMetadata string bytes))));

storage (pair (address %owner)

              (pair (option %owner_candidate address)

                    (pair (bool %paused)

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

                                      (list %txs (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 %from_)

                          (list %txs (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 10 } ;

       IF_LEFT

         { IF_LEFT

             { IF_LEFT

                 { IF_LEFT

                     { IF_LEFT

                         { UNPAIR ;

                           DUP 13 ;

                           DUP 3 ;

                           AMOUNT ;

                           DUP 4 ;

                           MAP { DUP 10 ;

                                 DUP 2 ;

                                 CAR ;

                                 DUP 3 ;

                                 CDR ;

                                 PAIR ;

                                 MEM ;

                                 IF

                                   { DUP 10 ;

                                     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 12 ; DROP } ;

                           DUG 12 ;

                           DROP 2 ;

                           PAIR 10 ;

                           DIG 1 ;

                           PAIR }

                         { DUP 2 ;

                           SENDER ;

                           COMPARE ;

                           EQ ;

                           NOT ;

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

                           DUP ;

                           SOME ;

                           DIP { DIG 2 ; DROP } ;

                           DUG 2 ;

                           DROP ;

                           PAIR 10 ;

                           DIG 1 ;

                           PAIR } }

                     { IF_LEFT

                         { DROP ;

                           DUP 2 ;

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

                           SENDER ;

                           COMPARE ;

                           EQ ;

                           NOT ;

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

                           SENDER ;

                           SWAP ;

                           DROP ;

                           NONE address ;

                           DIP { DIG 1 ; DROP } ;

                           DUG 1 ;

                           PAIR 10 ;

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

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

                           DIG 1 ;

                           PAIR }

                         { DUP 18 ;

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

                                      DUP 2 ;

                                      CAR ;

                                      DUP 3 ;

                                      CDR ;

                                      CDR ;

                                      PAIR ;

                                      DUP 3 ;

                                      CDR ;

                                      CAR ;

                                      PAIR ;

                                      MEM ;

                                      IF

                                        { PUSH string "operator" ;

                                          PUSH string "KeyExists" ;

                                          PAIR ;

                                          FAILWITH }

                                        { DUP 8 ;

                                          PUSH unit Unit ;

                                          SOME ;

                                          DUP 3 ;

                                          CAR ;

                                          DUP 4 ;

                                          CDR ;

                                          CDR ;

                                          PAIR ;

                                          DUP 4 ;

                                          CDR ;

                                          CAR ;

                                          PAIR ;

                                          UPDATE ;

                                          DIP { DIG 7 ; DROP } ;

                                          DUG 7 } ;

                                      DROP }

                                    { SENDER ;

                                      DUP 2 ;

                                      CAR ;

                                      COMPARE ;

                                      EQ ;

                                      NOT ;

                                      IF

                                        { PUSH string "CALLER_NOT_OWNER" ; FAILWITH }

                                        {} ;

                                      DUP 8 ;

                                      NONE unit ;

                                      DUP 3 ;

                                      CAR ;

                                      DUP 4 ;

                                      CDR ;

                                      CDR ;

                                      PAIR ;

                                      DUP 4 ;

                                      CDR ;

                                      CAR ;

                                      PAIR ;

                                      UPDATE ;

                                      DIP { DIG 7 ; DROP } ;

                                      DUG 7 ;

                                      DROP } ;

                                  DROP } ;

                           DROP ;

                           PAIR 10 ;

                           DIG 1 ;

                           PAIR } }

                     { IF_LEFT

                         { DUP 18 ;

                           DUP 5 ;

                           PUSH string "CONTRACT_PAUSED" ;

                           PAIR ;

                           EXEC ;

                           NOT ;

                           IF

                             { PUSH string "r1" ;

                               PUSH string "InvalidCondition" ;

                               PAIR ;

                               FAILWITH }

                             {} ;

                           DUP ;

                           ITER { DUP ;

                                  IF_LEFT

                                    { DUP 11 ;

                                      SENDER ;

                                      DUP 3 ;

                                      PAIR ;

                                      MEM ;

                                      IF

                                        { PUSH string "operator_for_all" ;

                                          PUSH string "KeyExists" ;

                                          PAIR ;

                                          FAILWITH }

                                        { DUP 11 ;

                                          PUSH unit Unit ;

                                          SOME ;

                                          SENDER ;

                                          DUP 4 ;

                                          PAIR ;

                                          UPDATE ;

                                          DIP { DIG 10 ; DROP } ;

                                          DUG 10 } ;

                                      DROP }

                                    { DUP 11 ;

                                      NONE unit ;

                                      SENDER ;

                                      DUP 4 ;

                                      PAIR ;

                                      UPDATE ;

                                      DIP { DIG 10 ; DROP } ;

                                      DUG 10 ;

                                      DROP } ;

                                  DROP } ;

                           DROP ;

                           PAIR 10 ;

                           DIG 1 ;

                           PAIR }

                         { DUP 2 ;

                           SENDER ;

                           COMPARE ;

                           EQ ;

                           NOT ;

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

                           DUP 18 ;

                           DUP 5 ;

                           PUSH string "CONTRACT_PAUSED" ;

                           PAIR ;

                           EXEC ;

                           NOT ;

                           IF

                             { PUSH string "r6" ;

                               PUSH string "InvalidCondition" ;

                               PAIR ;

                               FAILWITH }

                             {} ;

                           DUP ;

                           DIP { DIG 9 ; DROP } ;

                           DUG 9 ;

                           DROP ;

                           PAIR 10 ;

                           DIG 1 ;

                           PAIR } } } }

             { IF_LEFT

                 { IF_LEFT

                     { IF_LEFT

                         { UNPAIR ;

                           SWAP ;

                           DUP 19 ;

                           DUP 6 ;

                           PUSH string "CONTRACT_PAUSED" ;

                           PAIR ;

                           EXEC ;

                           NOT ;

                           IF

                             { PUSH string "r7" ;

                               PUSH string "InvalidCondition" ;

                               PAIR ;

                               FAILWITH }

                             {} ;

                           DUP 2 ;

                           IF_NONE

                             {}

                             { DUP 12 ;

                               DUP 2 ;

                               COMPARE ;

                               GE ;

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

                               DROP } ;

                           DUP 9 ;

                           SENDER ;

                           MEM ;

                           IF

                             { DUP ;

                               IF_NONE

                                 { DUP 9 ;

                                   DUP 10 ;

                                   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 8 ; DROP } ;

                                   DUG 8 }

                                 { DUP 10 ;

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

                                               DUP 13 ;

                                               SENDER ;

                                               GET ;

                                               IF_NONE

                                                 { PUSH string "permits" ;

                                                   PUSH string "AssetNotFound" ;

                                                   PAIR ;

                                                   FAILWITH }

                                                 {} ;

                                               UNPAIR ;

                                               SWAP ;

                                               UNPAIR ;

                                               SWAP ;

                                               DROP ;

                                               DUP 15 ;

                                               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 11 ; DROP } ;

                                               DUG 11 }

                                             {} ;

                                           DROP } ;

                                       DUP ;

                                       IF

                                         { DUP 11 ;

                                           SENDER ;

                                           GET ;

                                           IF_NONE

                                             { PUSH string "permits" ;

                                               PUSH string "AssetNotFound" ;

                                               PAIR ;

                                               FAILWITH }

                                             {} ;

                                           CDR ;

                                           CDR ;

                                           DUP 3 ;

                                           GET ;

                                           IF_NONE

                                             { PUSH string "NotFound" ; FAILWITH }

                                             {} ;

                                           DUP 12 ;

                                           DUP 13 ;

                                           SENDER ;

                                           GET ;

                                           IF_NONE

                                             { PUSH string "permits" ;

                                               PUSH string "AssetNotFound" ;

                                               PAIR ;

                                               FAILWITH }

                                             {} ;

                                           UNPAIR ;

                                           SWAP ;

                                           UNPAIR ;

                                           SWAP ;

                                           DROP ;

                                           DUP 15 ;

                                           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 11 ; DROP } ;

                                           DUG 11 ;

                                           DROP }

                                         {} ;

                                       DROP }

                                     { DUP ;

                                       SENDER ;

                                       PAIR ;

                                       PUSH string "PERMIT_NOT_FOUND" ;

                                       PAIR ;

                                       FAILWITH } ;

                                   DROP } }

                             { SENDER ; PUSH string "PERMIT_USER_NOT_FOUND" ; PAIR ; FAILWITH } ;

                           DROP 2 ;

                           PAIR 10 ;

                           DIG 1 ;

                           PAIR }

                         { UNPAIR ;

                           SWAP ;

                           UNPAIR ;

                           SWAP ;

                           DUP 20 ;

                           DUP 7 ;

                           PUSH string "CONTRACT_PAUSED" ;

                           PAIR ;

                           EXEC ;

                           NOT ;

                           IF

                             { PUSH string "r5" ;

                               PUSH string "InvalidCondition" ;