{ parameter (or

              (or

                (or

                  (or

                    (pair %can_transfer

                      (pair (nat %tokenid) (pair (address %from_) (address %to_)))

                      (contract string))

                    (pair %balance_of

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

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

                                          (nat %balance))))))

                  (or (unit %pause) (unit %unpause)))

                (or (or (address %set_admin_candidate) (unit %accept_admin_candidate))

                    (or (address %set_archetype) (string %set_token_metadata_uri))))

              (or

                (or

                  (or (bytes %set_metadata_uri)

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

                  (or (nat %set_default_expiry)

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

                (or

                  (or (pair %consume_permit (address %expected_user) (bytes %permitkey))

                      (list %update_operators (or

                                               (pair (address %owner)

                                                     (pair (address %operator)

                                                           (nat %token_id)))

                                               (pair (address %owner)

                                                     (pair (address %operator)

                                                           (nat %token_id))))))

                  (or

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

                        (list %transfer (pair address

                                             (list (pair (address %to)

                                                        (pair (nat %token_id)

                                                              (nat %amount)))))))

                    (or

                      (list %transfer_gasless (pair

                                               (list (pair address

                                                          (list (pair (address %to)

                                                                     (pair

                                                                       (nat %token_id)

                                                                       (nat %amount))))))

                                               (pair key signature)))

                      (pair %mint (address %account) (nat %tokenid))))))) ;

  storage (pair (address %admin)

                (pair (option %archetype address)

                      (pair (bool %paused)

                            (pair (option %admin_candidate address)

                                  (pair (string %token_metadata_uri)

                                        (pair (nat %default_expiry)

                                              (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 %ledger nat address)

                                                      (pair

                                                        (big_map %operator

                                                          (pair address

                                                                (pair nat address))

                                                          unit)

                                                        (pair

                                                          (big_map %operator_for_all

                                                            (pair address address)

                                                            unit)

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

                      (pair (nat %counter)

                            (pair (option %user_expiry nat)

                                  (map %user_permits bytes

                                                     (pair (option %expiry nat)

                                                           (timestamp %created_at))))))

             (pair nat address))

           (option nat)

           { UNPAIR 3 ;

             PUSH unit Unit ;

             DUP 3 ;

             SOME ;

             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 ; SOME ; DIP { DIG 1 ; DROP } ; DUG 1 ; DROP } }

               {} ;

             DUP ;

             DIP { DIG 1 ; DROP } ;

             DUG 1 ;

             DROP ;

             DUG 3 ;

             DROP 3 } ;

         LAMBDA

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

           bool

           { PUSH unit Unit ;

             DUP 2 ;

             CAR ;

             IF_NONE

               { PUSH bool False ; 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 1 ;

             DROP } ;

         LAMBDA

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

                 (pair (big_map (pair address address) unit)

                       (list (pair address

                                  (list (pair (address %to)

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

           bool

           { UNPAIR 3 ;

             PUSH unit Unit ;

             PUSH bool True ;

             DUP 5 ;

             ITER { DUP ;

                    CAR ;

                    DUP 2 ;

                    CDR ;

                    DUP ;

                    ITER { DUP 7 ;

                           DUP 4 ;

                           DUP 3 ;

                           CDR ;

                           CAR ;

                           PAIR ;

                           SENDER ;

                           PAIR ;

                           MEM ;

                           DUP 9 ;

                           DUP 5 ;

                           SENDER ;

                           PAIR ;

                           MEM ;

                           DUP 5 ;

                           SENDER ;

                           COMPARE ;

                           EQ ;

                           OR ;

                           OR ;

                           DUP 6 ;

                           AND ;

                           DIP { DIG 4 ; DROP } ;

                           DUG 4 ;

                           DROP } ;

                    DROP 3 } ;

             DUP ;

             DIP { DIG 1 ; DROP } ;

             DUG 1 ;

             DROP ;

             DUG 3 ;

             DROP 3 } ;

         LAMBDA

           (pair string

                 (list (pair address

                            (list (pair (address %to)

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

           (pair (option address) string)

           { UNPAIR 2 ;

             PUSH unit Unit ;

             PUSH string "" ;

             NONE address ;

             PAIR ;

             DUP 4 ;

             IF_CONS

               { DUP ;

                 CAR ;

                 PUSH string "" ;

                 DUP 4 ;

                 ITER { DUP ;

                        CAR ;

                        DUP 4 ;

                        COMPARE ;

                        NEQ ;

                        IF

                          { PUSH string "FA2_NOT_OPERATOR" ; DIP { DIG 1 ; DROP } ; DUG 1 }

                          {} ;

                        DROP } ;

                 DUP ;

                 DUP 3 ;

                 SOME ;

                 PAIR ;

                 DIP { DIG 4 ; DROP } ;

                 DUG 4 ;

                 DROP 4 }

               {} ;

             DUP ;

             DIP { DIG 1 ; DROP } ;

             DUG 1 ;

             DROP ;

             DUG 2 ;

             DROP 2 } ;

         NIL operation ;

         DIG 6 ;

         UNPAIR ;

         DIP { UNPAIR 11 } ;

         IF_LEFT

           { IF_LEFT

               { IF_LEFT

                   { IF_LEFT

                       { UNPAIR ;

                         UNPAIR ;

                         SWAP ;

                         UNPAIR ;

                         SWAP ;

                         PUSH string "" ;

                         NIL (pair address

                                   (list (pair (address %to)

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

                         NIL (pair (address %to) (pair (nat %token_id) (nat %amount))) ;

                         PUSH nat 1 ;

                         DUP 7 ;

                         PAIR ;

                         DUP 5 ;

                         PAIR ;

                         CONS ;

                         DUP 5 ;

                         PAIR ;

                         CONS ;

                         DUP 20 ;

                         DUP 2 ;

                         DUP 18 ;

                         PAIR ;

                         DUP 17 ;

                         PAIR ;

                         EXEC ;

                         NOT ;

                         IF

                           { DUP 19 ;

                             DUP 2 ;

                             PUSH string "FA2_NOT_OPERATOR" ;

                             PAIR ;

                             EXEC ;

                             DUP ;

                             CDR ;

                             PUSH string "" ;

                             DUP 2 ;

                             COMPARE ;

                             NEQ ;

                             IF

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

                               { DUP 2 ;

                                 CAR ;

                                 IF_NONE

                                   {}

                                   { SELF_ADDRESS ;

                                     DUP 5 ;

                                     PACK ;

                                     BLAKE2B ;

                                     DUP 3 ;

                                     PAIR ;

                                     VIEW "check_permit" string ;

                                     IF_NONE

                                       { PUSH string "INTERNAL_ERROR" ;

                                         DIP { DIG 4 ; DROP } ;

                                         DUG 4 }

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

                                     DROP } } ;

                             DROP 2 }

                           {} ;

                         PUSH string "" ;

                         DUP 3 ;

                         COMPARE ;

                         EQ ;

                         IF

                           { DUP 8 ;

                             IF_NONE

                               { PUSH string "ARCHETYPE_NOT_SET" ;

                                 DIP { DIG 1 ; DROP } ;

                                 DUG 1 }

                               { DUP ;

                                 SENDER ;

                                 DUP 6 ;

                                 PAIR ;

                                 DUP 7 ;

                                 PAIR ;

                                 DUP 8 ;

                                 PAIR ;

                                 VIEW "validateTransfer" string ;

                                 IF_NONE

                                   { PUSH string "INTERNAL_ERROR" ;

                                     DIP { DIG 2 ; DROP } ;

                                     DUG 2 }

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

                                 DROP } }

                           {} ;

                         DUP 18 ;

                         DUP 7 ;

                         AMOUNT ;

                         DUP 5 ;

                         TRANSFER_TOKENS ;

                         CONS ;

                         DIP { DIG 17 ; DROP } ;

                         DUG 17 ;

                         DROP 6 ;

                         PAIR 11 ;

                         DIG 1 ;

                         PAIR }

                       { UNPAIR ;

                         DUP 14 ;

                         DUP 3 ;

                         AMOUNT ;

                         DUP 4 ;

                         MAP { DUP 14 ;

                               DUP 2 ;

                               CDR ;

                               MEM ;

                               IF

                                 { DUP ;

                                   CAR ;

                                   DUP 15 ;

                                   DUP 3 ;

                                   CDR ;

                                   GET ;

                                   IF_NONE

                                     { PUSH string "ledger" ;

                                       PUSH string "AssetNotFound" ;

                                       PAIR ;

                                       FAILWITH }

                                     {} ;

                                   COMPARE ;

                                   EQ ;

                                   IF { PUSH nat 1 } { PUSH nat 0 } }

                                 { PUSH nat 0 } ;

                               DUP 2 ;

                               PAIR ;

                               SWAP ;

                               DROP } ;

                         TRANSFER_TOKENS ;

                         CONS ;

                         DIP { DIG 13 ; DROP } ;

                         DUG 13 ;

                         DROP 2 ;

                         PAIR 11 ;

                         DIG 1 ;

                         PAIR } }

                   { IF_LEFT

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

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

               { IF_LEFT

                   { IF_LEFT

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

                             PUSH string "InvalidCondition" ;

                             PAIR ;

                             FAILWITH }

                           {} ;

                         DUP ;

                         SOME ;

                         DIP { DIG 4 ; DROP } ;

                         DUG 4 ;

                         DROP ;

                         PAIR 11 ;

                         DIG 1 ;

                         PAIR }

                       { DROP ;

                         DUP 17 ;

                         DUP 4 ;

                         PUSH string "CONTRACT_PAUSED" ;

                         PAIR ;

                         EXEC ;

                         NOT ;

                         IF

                           { PUSH string "r1" ;

                             PUSH string "InvalidCondition" ;

                             PAIR ;

                             FAILWITH }

                           {} ;

                         DUP 4 ;

                         IF_NONE

                           { PUSH string "ADMIN_CANDIDATE_NOT_SET" ; FAILWITH }

                           { DUP ;

                             SENDER ;

                             COMPARE ;

                             EQ ;

                             NOT ;

                             IF

                               { PUSH string "CALLER_NOT_ADMIN_CANDIDATE" ; FAILWITH }

                               {} ;

                             DUP ;

                             DIP { DIG 1 ; DROP } ;

                             DUG 1 ;

                             NONE address ;

                             DIP { DIG 4 ; DROP } ;

                             DUG 4 ;

                             DROP } ;

                         PAIR 11 ;

                         DIG 1 ;

                         PAIR } }

                   { IF_LEFT

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

                             PUSH string "InvalidCondition" ;

                             PAIR ;

                             FAILWITH }

                           {} ;

                         DUP ;

                         SOME ;

                         DIP { DIG 2 ; DROP } ;

                         DUG 2 ;

                         DROP ;

                         PAIR 11 ;

                         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 "r8" ;

                             PUSH string "InvalidCondition" ;

                             PAIR ;

                             FAILWITH }

                           {} ;

                         DUP ;

                         DIP { DIG 5 ; DROP } ;

                         DUG 5 ;

                         DROP ;

                         PAIR 11 ;

                         DIG 1 ;

                         PAIR } } } }

           { IF_LEFT

               { IF_LEFT

                   { IF_LEFT

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

                             PUSH string "InvalidCondition" ;

                             PAIR ;

                             FAILWITH }

                           {} ;

                         DIG 11 ;

                         DUP 2 ;

                         SOME ;

                         PUSH string "" ;

                         UPDATE ;

                         DUG 11 ;

                         DROP ;

                         PAIR 11 ;

                         DIG 1 ;

                         PAIR }

                       { UNPAIR ;

                         SWAP ;

                         UNPAIR ;

                         SWAP ;

                         DUP 20 ;

                         DUP 7 ;

                         PUSH string "CONTRACT_PAUSED" ;

                         PAIR ;

                         EXEC ;

                         NOT ;

                         IF

                           { PUSH string "p0" ;

                             PUSH string "InvalidCondition" ;

                             PAIR ;

                             FAILWITH }

                           {} ;

                         DUP 3 ;

                         HASH_KEY ;

                         IMPLICIT_ACCOUNT ;

                         ADDRESS ;

                         EMPTY_MAP bytes

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

                         DUP 12 ;

                         DUP 3 ;

                         MEM ;

                         IF

                           { DUP 12 ;

                             DUP 3 ;

                             GET ;

                             IF_NONE

                               { PUSH string "permits" ;

                                 PUSH string "AssetNotFound" ;

                                 PAIR ;

                                 FAILWITH }

                               {} ;

                             CDR ;

                             CDR ;

                             DUP 13 ;

                             DUP 4 ;

                             GET ;

                             IF_NONE

                               { PUSH string "permits" ;

                                 PUSH string "AssetNotFound" ;

                                 PAIR ;

                                 FAILWITH }

                               {} ;

                             CAR ;

                             PAIR }

                           { DUP ; PUSH nat 0 ; PAIR } ;

                         DUP ;

                         CAR ;

                         DUP 2 ;

                         CDR ;

                         DUP 6 ;

                         DUP 3 ;

                         PAIR ;

                         CHAIN_ID ;

                         SELF_ADDRESS ;

                         PAIR ;

                         PAIR ;

                         PACK ;

                         DUP ;

                         DUP 9 ;

                         DUP 11 ;

                         CHECK_SIGNATURE ;

                         NOT ;

                         IF { DUP ; PUSH string "MISSIGNED" ; PAIR ; FAILWITH } {} ;

                         DUP 25 ;

                         DUP 7 ;

                         DUP 17 ;

                         PAIR ;

                         DUP 18 ;

                         PAIR ;

                         EXEC ;

                         DUP 17 ;

                         DUP 8 ;

                         MEM ;

                         IF

                           { DUP 17 ;

                             DUP 8 ;

                             GET ;

                             IF_NONE

                               { PUSH string "permits" ;

                                 PUSH string "AssetNotFound" ;

                                 PAIR ;

                                 FAILWITH }

                               {} ;

                             DUP 18 ;

                             DUP 19 ;

                             DUP 10 ;

                             GET ;

                             IF_NONE

                               { PUSH string "permits" ;

                                 PUSH string "AssetNotFound" ;

                                 PAIR ;

                                 FAILWITH }

                               {} ;

                             UNPAIR ;

                             DROP ;

                             PUSH nat 1 ;

                             DUP 4 ;

                             CAR ;

                             ADD ;

                             SWAP ;

                             UNPAIR ;

                             SWAP ;

                             DROP ;

                             DUP 7 ;

                             NOW ;

                             DUP 7 ;

                             PAIR ;

                             SOME ;

                             DUP 14 ;

                             UPDATE ;

                             SWAP ;

                             PAIR ;

                             SWAP ;

                             PAIR ;

                             SOME ;

                             DUP 10 ;

                             UPDATE ;

                             DIP { DIG 17 ; DROP } ;

                             DUG 17 ;

                             DROP }

                           { DUP 17 ;

                             DUP 8 ;

                             MEM ;

                             IF

                               { PUSH string "permits" ;

                                 PUSH string "KeyExists" ;

                                 PAIR ;

                                 FAILWITH }

                               { DUP 17 ;

                                 DUP 4 ;

                                 NOW ;

                                 DUP 4 ;

                                 PAIR ;

                                 SOME ;

                                 DUP 11 ;

                                 UPDATE ;

                                 NONE nat ;

                                 PAIR ;

                                 PUSH nat 1 ;

                                 PUSH nat 0 ;

                                 ADD ;

                                 PAIR ;

                                 SOME ;

                                 DUP 9 ;

                                 UPDATE ;

                                 DIP { DIG 16 ; DROP } ;

                                 DUG 16 } } ;

                         DUP 17 ;

                         DUP 8 ;

                         GET ;

                         IF_NONE

                           { PUSH string "permits" ;

                             PUSH string "AssetNotFound" ;

                             PAIR ;

                             FAILWITH }

                           {} ;

                         CDR ;

                         CDR ;

                         ITER { UNPAIR ;

                                DUP 27 ;

                                DUP 3 ;

                                EXEC ;

                                IF

                                  { DUP 19 ;

                                    DUP 20 ;

                                    DUP 11 ;

                                    GET ;

                                    IF_NONE

                                      { PUSH string "permits" ;

                                        PUSH string "AssetNotFound" ;

                                        PAIR ;

                                        FAILWITH }

                                      {} ;

                                    UNPAIR ;

                                    SWAP ;

                                    UNPAIR ;

                                    SWAP ;

                                    DROP ;

                                    DUP 22 ;

                                    DUP 13 ;

                                    GET ;

                                    IF_NONE

                                      { PUSH string "permits" ;

                                        PUSH string "AssetNotFound" ;

                                        PAIR ;

                                        FAILWITH }

                                      {} ;

                                    CDR ;

                                    CDR ;

                                    NONE (pair (option nat) timestamp) ;

                                    DUP 6 ;

                                    UPDATE ;

                                    SWAP ;

                                    PAIR ;

                                    SWAP ;

                                    PAIR ;

                                    SOME ;

                                    DUP 11 ;

                                    UPDATE ;

                                    DIP { DIG 18 ; DROP } ;

                                    DUG 18 }

                                  {} ;

                                DROP 2 } ;

                         DROP 10 ;

                         PAIR 11 ;

                         DIG 1 ;

                         PAIR } }

                   { IF_LEFT

                       { DUP 2 ;

                         SENDER ;

                         COMPARE ;

                         EQ ;

                         NOT ;

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

                         DUP ;

                         DIP { DIG 6 ; DROP } ;

                         DUG 6 ;

                         DROP ;

                         PAIR 11 ;

                         DIG 1 ;

                         PAIR }

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

                             DUP 2 ;

                             COMPARE ;

                             GE ;

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

                             DROP } ;

                         DUP 9 ;