{ parameter (or

              (or (or (address %change_admin) (nat %change_threshold))

                  (or (key %add_owner) (key %remove_owner)))

              (or

                (or

                  (pair %create

                    (pair %params_c (string %eh_token_addr) (bytes %contract_metadata)

                                    (pair %token_ma (bytes %na) (bytes %de) (bytes %sy)))

                    (bytes %signatures))

                  (pair %wrap

                    (pair %params_w (string %eth_id) (string %eth_token_addr)

                                    (address %user_addr)

                                    (nat %amount))

                    (bytes %signatures)))

                (pair %unwrap (address %tz_addr) (pair (nat %tz_at) (string %eth_addr))))) ;

  storage (pair (address %admin) (nat %threshold)

                (pair %owners (big_map %values key (pair (nat %index) (unit %value)))

                              (big_map %keys nat key)

                              (nat %size))

                (big_map %nonces address nat)

                (big_map %ids bytes timestamp)

                (big_map %eth_to_tez string address)

                (big_map %tez_to_eth address string)

                (big_map %processed_id string timestamp)) ;

  code { LAMBDA

           (pair (pair (big_map key (pair nat unit)) (big_map nat key) nat) nat bytes

                 bytes)

           bool

           { UNPAIR 4 ;

             PUSH unit Unit ;

             DUP 3 ;

             PUSH nat 65 ;

             MUL ;

             DUP 6 ;

             SIZE ;

             COMPARE ;

             EQ ;

             NOT ;

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

             EMPTY_MAP key bool ;

             PUSH nat 0 ;

             PUSH nat 0 ;

             DUP 6 ;

             DUP 2 ;

             COMPARE ;

             LT ;

             LOOP { DUP 8 ;

                    PUSH nat 65 ;

                    PUSH nat 65 ;

                    DUP 4 ;

                    MUL ;

                    SLICE ;

                    DUP ;

                    IF_NONE

                      { PUSH bool False ;

                        NOT ;

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

                      { DUP ;

                        UNPACK signature ;

                        DUP ;

                        IF_NONE

                          { PUSH bool False ;

                            NOT ;

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

                          { PUSH bool False ;

                            DUP 10 ;

                            DUP ;

                            GET 4 ;

                            PUSH nat 1 ;

                            DUP 2 ;

                            DUP 2 ;

                            COMPARE ;

                            LE ;

                            LOOP { DUP 3 ;

                                   GET 3 ;

                                   DUP 2 ;

                                   GET ;

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

                                   DUP 4 ;

                                   GET 1 ;

                                   DUP 2 ;

                                   GET ;

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

                                   CDR ;

                                   DUP 6 ;

                                   NOT ;

                                   IF

                                     { DUP 13 ;

                                       DUP 3 ;

                                       MEM ;

                                       NOT ;

                                       IF

                                         { DUP 17 ;

                                           DUP 8 ;

                                           DUP 4 ;

                                           CHECK_SIGNATURE ;

                                           IF

                                             { DIG 12 ;

                                               PUSH bool True ;

                                               SOME ;

                                               DUP 4 ;

                                               UPDATE ;

                                               DUG 12 }

                                             {} }

                                         {} }

                                     {} ;

                                   PUSH nat 1 ;

                                   DUP 13 ;

                                   ADD ;

                                   DIP 1 { DIG 11 ; DROP 1 } ;

                                   DUG 11 ;

                                   PUSH bool True ;

                                   DIP 1 { DIG 5 ; DROP 1 } ;

                                   DUG 5 ;

                                   DROP 2 ;

                                   PUSH nat 1 ;

                                   DUP 2 ;

                                   ADD ;

                                   SWAP ;

                                   DROP 1 ;

                                   DUP 2 ;

                                   DUP 2 ;

                                   COMPARE ;

                                   LE } ;

                            DROP 5 } ;

                        DROP 2 } ;

                    PUSH nat 1 ;

                    DUP 3 ;

                    ADD ;

                    DIP 1 { SWAP ; DROP 1 } ;

                    SWAP ;

                    DROP 1 ;

                    DUP 6 ;

                    DUP 2 ;

                    COMPARE ;

                    LT } ;

             DUP 6 ;

             DUP 3 ;

             COMPARE ;

             GE ;

             IF { PUSH bool True } { PUSH bool False } ;

             DIP 1 { DIG 3 ; DROP 1 } ;

             DUG 3 ;

             DROP 3 ;

             DUG 4 ;

             DROP 4 } ;

         NIL operation ;

         DIG 2 ;

         UNPAIR ;

         DIP 1 { UNPAIR 8 } ;

         IF_LEFT

           { IF_LEFT

               { IF_LEFT

                   { DUP 2 ;

                     SENDER ;

                     COMPARE ;

                     EQ ;

                     NOT ;

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

                     PUSH mutez 0 ;

                     AMOUNT ;

                     COMPARE ;

                     EQ ;

                     NOT ;

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

                     DUP ;

                     DIP 1 { SWAP ; DROP 1 } ;

                     SWAP ;

                     DROP 1 ;

                     PAIR 8 ;

                     SWAP ;

                     PAIR }

                   { DUP 2 ;

                     SENDER ;

                     COMPARE ;

                     EQ ;

                     NOT ;

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

                     PUSH mutez 0 ;

                     AMOUNT ;

                     COMPARE ;

                     EQ ;

                     NOT ;

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

                     PUSH nat 0 ;

                     DUP 2 ;

                     COMPARE ;

                     GT ;

                     NOT ;

                     IF

                       { PUSH string "THRESHOLD_MUST_BE_GREATER_THAN_ZERO" ; FAILWITH }

                       {} ;

                     DUP ;

                     DIP 1 { DIG 2 ; DROP 1 } ;

                     DUG 2 ;

                     DROP 1 ;

                     PAIR 8 ;

                     SWAP ;

                     PAIR } }

               { IF_LEFT

                   { DUP 2 ;

                     SENDER ;

                     COMPARE ;

                     EQ ;

                     NOT ;

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

                     PUSH mutez 0 ;

                     AMOUNT ;

                     COMPARE ;

                     EQ ;

                     NOT ;

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

                     DUP 4 ;

                     GET 1 ;

                     DUP 2 ;

                     MEM ;

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

                     DUP 4 ;

                     PUSH nat 1 ;

                     DUP 2 ;

                     GET 4 ;

                     ADD ;

                     DUP 2 ;

                     GET 1 ;

                     DUP 4 ;

                     GET ;

                     IF_NONE

                       { DUP 2 ;

                         DUP 2 ;

                         UPDATE 4 ;

                         DIP 1 { SWAP ; DROP 1 } ;

                         SWAP ;

                         DUP 2 ;

                         DUP 3 ;

                         GET 3 ;

                         DUP 5 ;

                         SOME ;

                         DUP 5 ;

                         GET 4 ;

                         UPDATE ;

                         UPDATE 3 ;

                         DIP 1 { SWAP ; DROP 1 } ;

                         SWAP }

                       { DUP ; GET 1 ; DIP 1 { SWAP ; DROP 1 } ; SWAP ; DROP 1 } ;

                     DUP 2 ;

                     DUP 3 ;

                     GET 1 ;

                     PUSH unit Unit ;

                     DUP 4 ;

                     PAIR ;

                     SOME ;

                     DUP 6 ;

                     UPDATE ;

                     UPDATE 1 ;

                     DIP 1 { SWAP ; DROP 1 } ;

                     SWAP ;

                     DUP 2 ;

                     DIP 1 { DIG 5 ; DROP 1 } ;

                     DUG 5 ;

                     DROP 3 ;

                     PAIR 8 ;

                     SWAP ;

                     PAIR }

                   { DUP 2 ;

                     SENDER ;

                     COMPARE ;

                     EQ ;

                     NOT ;

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

                     PUSH mutez 0 ;

                     AMOUNT ;

                     COMPARE ;

                     EQ ;

                     NOT ;

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

                     DUP 4 ;

                     GET 1 ;

                     DUP 2 ;

                     MEM ;

                     NOT ;

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

                     DUP 4 ;

                     DUP ;

                     GET 1 ;

                     DUP 3 ;

                     GET ;

                     IF_NONE

                       {}

                       { DUP ;

                         GET 1 ;

                         DUP 3 ;

                         GET 3 ;

                         DUP 4 ;

                         GET 4 ;

                         GET ;

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

                         DUP 4 ;

                         GET 1 ;

                         DUP 2 ;

                         GET ;

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

                         DUP 5 ;

                         DUP 6 ;

                         GET 3 ;

                         DUP 4 ;

                         SOME ;

                         DUP 6 ;

                         UPDATE ;

                         UPDATE 3 ;

                         DIP 1 { DIG 4 ; DROP 1 } ;

                         DUG 4 ;

                         DUP 5 ;

                         DUP 6 ;

                         GET 1 ;

                         DUP 3 ;

                         GET 2 ;

                         DUP 6 ;

                         PAIR ;

                         SOME ;

                         DUP 5 ;

                         UPDATE ;

                         UPDATE 1 ;

                         DIP 1 { DIG 4 ; DROP 1 } ;

                         DUG 4 ;

                         DUP 5 ;

                         DUP 6 ;

                         GET 3 ;

                         NONE key ;

                         DUP 8 ;

                         GET 4 ;

                         UPDATE ;

                         UPDATE 3 ;

                         DIP 1 { DIG 4 ; DROP 1 } ;

                         DUG 4 ;

                         DUP 5 ;

                         PUSH nat 1 ;

                         DUP 7 ;

                         GET 4 ;

                         SUB ;

                         ISNAT ;

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

                         UPDATE 4 ;

                         DIP 1 { DIG 4 ; DROP 1 } ;

                         DUG 4 ;

                         DUP 5 ;

                         DUP 6 ;

                         GET 1 ;

                         NONE (pair nat unit) ;

                         DUP 9 ;

                         UPDATE ;

                         UPDATE 1 ;

                         DIP 1 { DIG 4 ; DROP 1 } ;

                         DUG 4 ;

                         DUP 5 ;

                         DIP 1 { DIG 8 ; DROP 1 } ;

                         DUG 8 ;

                         DROP 4 } ;

                     DROP 2 ;

                     PAIR 8 ;

                     SWAP ;

                     PAIR } } }

           { IF_LEFT

               { IF_LEFT

                   { UNPAIR ;

                     SWAP ;

                     PUSH mutez 0 ;

                     AMOUNT ;

                     COMPARE ;

                     EQ ;

                     NOT ;

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

                     DUP 8 ;

                     DUP 3 ;

                     GET 1 ;

                     MEM ;

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

                     DUP 2 ;

                     GET 4 ;

                     DUP 3 ;

                     GET 3 ;

                     PAIR ;

                     DUP 3 ;

                     GET 1 ;

                     PAIR ;

                     PACK ;

                     KECCAK ;

                     DUP 13 ;

                     DUP 3 ;

                     DUP 3 ;

                     PAIR ;

                     DUP 7 ;

                     PAIR ;

                     DUP 8 ;

                     PAIR ;

                     EXEC ;

                     NOT ;

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

                     PUSH nat 31556952 ;

                     EMPTY_BIG_MAP address

                                    (pair nat (option nat)

                                          (map bytes (pair (option nat) timestamp))) ;

                     PAIR ;

                     EMPTY_SET address ;

                     PAIR ;

                     PUSH mutez 0 ;

                     NONE key_hash ;

                     CREATE_CONTRACT { storage (pair (set %consumer address)

                                                     (big_map %permits address

                                                                       (pair

                                                                         (nat %counter)

                                                                         (option %user_expiry nat)

                                                                         (map %user_permits

                                                                           bytes

                                                                           (pair

                                                                             (option %expiry nat)

                                                                             (timestamp %created_at)))))

                                                     (nat %default_expiry)) ;

                                       parameter (or

                                                   (or

                                                     (or

                                                       (pair %set_expiry

                                                         (option %iv nat)

                                                         (option %ip bytes))

                                                       (pair %setExpiry (address %u)

                                                                        (pair (nat %sec)

                                                                              (option %data bytes))))

                                                     (or

                                                       (pair %permit (key %signer)

                                                                     (pair

                                                                       (signature %sig)

                                                                       (bytes %permit_key)))

                                                       (pair %consume (address %user)

                                                                      (pair

                                                                        (bytes %permit_key)

                                                                        (string %err)))))

                                                   (pair %check (key %signer)

                                                                (pair (signature %sig)

                                                                      (bytes %data)))) ;

                                       code { LAMBDA

                                                (pair nat

                                                      (big_map address

                                                               (pair (nat %counter)

                                                                     (option %user_expiry nat)

                                                                     (map %user_permits

                                                                       bytes

                                                                       (pair

                                                                         (option %expiry nat)

                                                                         (timestamp %created_at)))))

                                                      address)

                                                nat

                                                { UNPAIR 3 ;

                                                  PUSH unit Unit ;

                                                  DUP 3 ;

                                                  DUP 5 ;

                                                  GET ;

                                                  IF_NONE

                                                    { DUP 2 }

                                                    { DUP ;

                                                      GET 3 ;

                                                      IF_NONE { DUP 3 } {} ;

                                                      SWAP ;

                                                      DROP 1 } ;

                                                  SWAP ;

                                                  DROP 1 ;

                                                  DUG 3 ;

                                                  DROP 3 } ;

                                              LAMBDA

                                                (pair nat

                                                      (big_map address

                                                               (pair (nat %counter)

                                                                     (option %user_expiry nat)

                                                                     (map %user_permits

                                                                       bytes

                                                                       (pair

                                                                         (option %expiry nat)

                                                                         (timestamp %created_at)))))

                                                      address

                                                      bytes)

                                                nat

                                                { UNPAIR 4 ;

                                                  PUSH unit Unit ;

                                                  DUP 3 ;

                                                  DUP 5 ;

                                                  GET ;

                                                  IF_NONE

                                                    { DUP 2 }

                                                    { DUP ;

                                                      GET 3 ;

                                                      IF_NONE { DUP 3 } {} ;

                                                      DUP 2 ;

                                                      GET 4 ;

                                                      DUP 8 ;

                                                      GET ;

                                                      IF_NONE

                                                        { DUP }

                                                        { DUP ;

                                                          GET 1 ;

                                                          IF_NONE { DUP 5 } {} ;

                                                          SWAP ;

                                                          DROP 1 } ;

                                                      SWAP ;

                                                      DROP 1 ;

                                                      SWAP ;

                                                      DROP 1 } ;

                                                  SWAP ;

                                                  DROP 1 ;

                                                  DUG 4 ;

                                                  DROP 4 } ;

                                              LAMBDA

                                                (pair

                                                  (pair (option %expiry nat)

                                                        (timestamp %created_at))

                                                  nat)

                                                bool

                                                { UNPAIR ;

                                                  PUSH unit Unit ;

                                                  NOW ;

                                                  PUSH int 1 ;

                                                  PUSH nat 1 ;

                                                  DUP 5 ;

                                                  GET 1 ;

                                                  IF_NONE { DUP 6 } {} ;

                                                  INT ;

                                                  DIG 2 ;

                                                  MUL ;

                                                  EDIV ;

                                                  IF_NONE

                                                    { PUSH string "DIV_BY_ZERO" ;

                                                      FAILWITH }

                                                    {} ;

                                                  CAR ;

                                                  DUP 4 ;

                                                  GET 2 ;

                                                  ADD ;

                                                  COMPARE ;

                                                  LT ;

                                                  SWAP ;

                                                  DROP 1 ;

                                                  DUG 2 ;

                                                  DROP 2 } ;

                                              DIG 3 ;

                                              UNPAIR ;

                                              DIP 1 { UNPAIR 3 } ;

                                              IF_LEFT

                                                { IF_LEFT

                                                    { IF_LEFT

                                                        { UNPAIR ;

                                                          SWAP ;

                                                          PUSH mutez 0 ;

                                                          AMOUNT ;

                                                          COMPARE ;

                                                          EQ ;

                                                          NOT ;

                                                          IF

                                                            { PUSH string "NO_TRANSFER" ;

                                                              FAILWITH }

                                                            {} ;

                                                          DUP 4 ;

                                                          SENDER ;

                                                          GET ;

                                                          IF_NONE

                                                            { SENDER ;

                                                              PUSH string "USER_PERMIT_NOT_FOUND" ;

                                                              PAIR ;

                                                              FAILWITH }

                                                            {} ;

                                                          DUP 3 ;

                                                          IF_NONE

                                                            { PUSH bool True }

                                                            { DUP 7 ;

                                                              DUP 2 ;

                                                              COMPARE ;

                                                              LT ;

                                                              SWAP ;

                                                              DROP 1 } ;

                                                          NOT ;

                                                          IF

                                                            { PUSH string "EXPIRY_TOO_BIG" ;

                                                              FAILWITH }

                                                            {} ;

                                                          DUP 2 ;

                                                          IF_NONE

                                                            { DUP 5 ;

                                                              DUP 6 ;

                                                              SENDER ;

                                                              GET ;

                                                              IF_NONE

                                                                { PUSH string "permits" ;

                                                                  PUSH string "ASSET_NOT_FOUND" ;

                                                                  PAIR ;

                                                                  FAILWITH }

                                                                {} ;

                                                              UNPAIR ;

                                                              SWAP ;

                                                              CDR ;

                                                              DUP 6 ;

                                                              PAIR ;

                                                              SWAP ;

                                                              PAIR ;

                                                              SOME ;

                                                              SENDER ;

                                                              UPDATE ;

                                                              DIP 1 { DIG 4 ; DROP 1 } ;

                                                              DUG 4 }

                                                            { DUP 4 ;

                                                              IF_NONE

                                                                { PUSH bool True }

                                                                { PUSH nat 0 ;

                                                                  DUP 2 ;

                                                                  COMPARE ;

                                                                  GT ;

                                                                  SWAP ;

                                                                  DROP 1 } ;

                                                              IF

                                                                { DUP 2 ;

                                                                  GET 4 ;

                                                                  DUP 2 ;

                                                                  GET ;

                                                                  IF_NONE

                                                                    { DUP ;

                                                                      SENDER ;

                                                                      PAIR ;

                                                                      PUSH string "PERMIT_NOT_FOUND" ;

                                                                      PAIR ;

                                                                      FAILWITH }

                                                                    {} ;

                                                                  DUP 7 ;

                                                                  DUP 8 ;

                                                                  SENDER ;

                                                                  GET ;

                                                                  IF_NONE

                                                                    { PUSH string "permits" ;

                                                                      PUSH string "ASSET_NOT_FOUND" ;

                                                                      PAIR ;

                                                                      FAILWITH }

                                                                    {} ;

                                                                  UNPAIR ;

                                                                  SWAP ;

                                                                  UNPAIR ;

                                                                  SWAP ;

                                                                  DROP 1 ;

                                                                  DUP 10 ;

                                                                  SENDER ;

                                                                  GET ;

                                                                  IF_NONE

                                                                    { PUSH string "permits" ;

                                                                      PUSH string "ASSET_NOT_FOUND" ;

                                                                      PAIR ;

                                                                      FAILWITH }

                                                                    {} ;

                                                                  CDR ;

                                                                  CDR ;

                                                                  DUP 5 ;

                                                                  CDR ;

                                                                  DUP 10 ;

                                                                  PAIR ;

                                                                  SOME ;

                                                                  DUP 7 ;

                                                                  UPDATE ;

                                                                  SWAP ;

                                                                  PAIR ;

                                                                  SWAP ;

                                                                  PAIR ;

                                                                  SOME ;

                                                                  SENDER ;

                                                                  UPDATE ;

                                                                  DIP 1

                                                                       { DIG 6 ; DROP 1 } ;

                                                                  DUG 6 ;

                                                                  DROP 1 }

                                                                { DUP 6 ;

                                                                  DUP 7 ;

                                                                  SENDER ;

                                                                  GET ;

                                                                  IF_NONE

                                                                    { PUSH string "permits" ;

                                                                      PUSH string "ASSET_NOT_FOUND" ;

                                                                      PAIR ;

                                                                      FAILWITH }

                                                                    {} ;

                                                                  UNPAIR ;

                                                                  SWAP ;

                                                                  UNPAIR ;

                                                                  SWAP ;

                                                                  DROP 1 ;

                                                                  DUP 9 ;

                                                                  SENDER ;

                                                                  GET ;

                                                                  IF_NONE

                                                                    { PUSH string "permits" ;

                                                                      PUSH string "ASSET_NOT_FOUND" ;

                                                                      PAIR ;

                                                                      FAILWITH }

                                                                    {} ;

                                                                  CDR ;

                                                                  CDR ;

                                                                  NONE (pair

                                                                         (option nat)

                                                                         timestamp) ;

                                                                  DUP 6 ;

                                                                  UPDATE ;

                                                                  SWAP ;

                                                                  PAIR ;

                                                                  SWAP ;

                                                                  PAIR ;

                                                                  SOME ;

                                                                  SENDER ;

                                                                  UPDATE ;

                                                                  DIP 1

                                                                       { DIG 5 ; DROP 1 } ;

                                                                  DUG 5 } ;

                                                              DROP 1 } ;

                                                          DROP 3 ;

                                                          PAIR 3 ;

                                                          NIL operation ;

                                                          PAIR }

                                                        { UNPAIR ;

                                                          SWAP ;

                                                          UNPAIR ;

                                                          SWAP ;

                                                          DUP 3 ;

                                                          SENDER ;

                                                          COMPARE ;

                                                          EQ ;

                                                          NOT ;

                                                          IF

                                                            { PUSH string "INVALID_CALLER" ;

                                                              FAILWITH }

                                                            {} ;

                                                          PUSH mutez 0 ;

                                                          AMOUNT ;

                                                          COMPARE ;

                                                          EQ ;

                                                          NOT ;

                                                          IF

                                                            { PUSH string "NO_TRANSFER" ;

                                                              FAILWITH }

                                                            {} ;

                                                          DUP 5 ;

                                                          DUP 4 ;

                                                          GET ;

                                                          IF_NONE

                                                            { DUP 3 ;

                                                              PUSH string "USER_PERMIT_NOT_FOUND" ;

                                                              PAIR ;

                                                              FAILWITH }

                                                            {} ;

                                                          DUP 2 ;

                                                          IF_NONE

                                                            { DUP 6 ;

                                                              DUP 7 ;

                                                              SENDER ;

                                                              GET ;

                                                              IF_NONE

                                                                { PUSH string "permits" ;

                                                                  PUSH string "ASSET_NOT_FOUND" ;

                                                                  PAIR ;

                                                                  FAILWITH }

                                                                {} ;

                                                              UNPAIR ;

                                                              SWAP ;

                                                              CDR ;

                                                              DUP 6 ;

                                                              SOME ;

                                                              PAIR ;

                                                              SWAP ;

                                                              PAIR ;

                                                              SOME ;

                                                              SENDER ;

                                                              UPDATE ;

                                                              DIP 1 { DIG 5 ; DROP 1 } ;

                                                              DUG 5 }

                                                            { PUSH nat 0 ;

                                                              DUP 5 ;

                                                              COMPARE ;

                                                              EQ ;

                                                              IF

                                                                { PUSH bool True }

                                                                { DUP 2 ;

                                                                  GET 4 ;

                                                                  DUP 2 ;

                                                                  GET ;

                                                                  IF_NONE

                                                                    { PUSH bool False }

                                                                    { DUP 5 ;

                                                                      INT ;

                                                                      DUP 2 ;

                                                                      GET 2 ;

                                                                      NOW ;

                                                                      SUB ;

                                                                      COMPARE ;

                                                                      GE ;

                                                                      SWAP ;

                                                                      DROP 1 } ;

                                                                  IF

                                                                    { PUSH bool True }

                                                                    { PUSH bool False } } ;

                                                              IF

                                                                { DUP 7 ;

                                                                  DUP 8 ;

                                                                  DUP 7 ;

                                                                  GET ;

                                                                  IF_NONE

                                                                    { PUSH string "permits" ;

                                                                      PUSH string "ASSET_NOT_FOUND" ;