		Search-engine friendly clone of the ACL2 documentation.

*all-smtp-grammar-rules*

all-smtp-grammar-rules-tree-operations

Tree operations specialized to *all-smtp-grammar-rules*.

Definitions and Theorems

Function: smtp-cst-matchp$

(defun smtp-cst-matchp$ (tree elem)
 (declare (xargs :guard (and (treep tree) (elementp elem))))
 (let ((__function__ 'smtp-cst-matchp$))
   (declare (ignorable __function__))
   (and (tree-terminatedp tree)
        (tree-match-element-p tree elem *all-smtp-grammar-rules*))))

Theorem: booleanp-of-smtp-cst-matchp$

(defthm booleanp-of-smtp-cst-matchp$
  (b* ((yes/no (smtp-cst-matchp$ tree elem)))
    (booleanp yes/no))
  :rule-classes :rewrite)

Theorem: smtp-cst-matchp$-of-tree-fix-tree

(defthm smtp-cst-matchp$-of-tree-fix-tree
  (equal (smtp-cst-matchp$ (tree-fix tree) elem)
         (smtp-cst-matchp$ tree elem)))

Theorem: smtp-cst-matchp$-tree-equiv-congruence-on-tree

(defthm smtp-cst-matchp$-tree-equiv-congruence-on-tree
  (implies (tree-equiv tree tree-equiv)
           (equal (smtp-cst-matchp$ tree elem)
                  (smtp-cst-matchp$ tree-equiv elem)))
  :rule-classes :congruence)

Theorem: smtp-cst-matchp$-of-element-fix-elem

(defthm smtp-cst-matchp$-of-element-fix-elem
  (equal (smtp-cst-matchp$ tree (element-fix elem))
         (smtp-cst-matchp$ tree elem)))

Theorem: smtp-cst-matchp$-element-equiv-congruence-on-elem

(defthm smtp-cst-matchp$-element-equiv-congruence-on-elem
  (implies (element-equiv elem elem-equiv)
           (equal (smtp-cst-matchp$ tree elem)
                  (smtp-cst-matchp$ tree elem-equiv)))
  :rule-classes :congruence)

Function: smtp-cst-list-elem-matchp$

(defun smtp-cst-list-elem-matchp$ (trees elem)
  (declare (xargs :guard (and (tree-listp trees)
                              (elementp elem))))
  (let ((__function__ 'smtp-cst-list-elem-matchp$))
    (declare (ignorable __function__))
    (and (tree-list-terminatedp trees)
         (tree-list-match-element-p
              trees elem *all-smtp-grammar-rules*))))

Theorem: booleanp-of-smtp-cst-list-elem-matchp$

(defthm booleanp-of-smtp-cst-list-elem-matchp$
  (b* ((yes/no (smtp-cst-list-elem-matchp$ trees elem)))
    (booleanp yes/no))
  :rule-classes :rewrite)

Theorem: smtp-cst-list-elem-matchp$-of-tree-list-fix-trees

(defthm smtp-cst-list-elem-matchp$-of-tree-list-fix-trees
  (equal (smtp-cst-list-elem-matchp$ (tree-list-fix trees)
                                     elem)
         (smtp-cst-list-elem-matchp$ trees elem)))

Theorem: smtp-cst-list-elem-matchp$-tree-list-equiv-congruence-on-trees

(defthm
     smtp-cst-list-elem-matchp$-tree-list-equiv-congruence-on-trees
  (implies (tree-list-equiv trees trees-equiv)
           (equal (smtp-cst-list-elem-matchp$ trees elem)
                  (smtp-cst-list-elem-matchp$ trees-equiv elem)))
  :rule-classes :congruence)

Theorem: smtp-cst-list-elem-matchp$-of-element-fix-elem

(defthm smtp-cst-list-elem-matchp$-of-element-fix-elem
  (equal (smtp-cst-list-elem-matchp$ trees (element-fix elem))
         (smtp-cst-list-elem-matchp$ trees elem)))

Theorem: smtp-cst-list-elem-matchp$-element-equiv-congruence-on-elem

(defthm smtp-cst-list-elem-matchp$-element-equiv-congruence-on-elem
  (implies (element-equiv elem elem-equiv)
           (equal (smtp-cst-list-elem-matchp$ trees elem)
                  (smtp-cst-list-elem-matchp$ trees elem-equiv)))
  :rule-classes :congruence)

Function: smtp-cst-list-rep-matchp$

(defun smtp-cst-list-rep-matchp$ (trees rep)
  (declare (xargs :guard (and (tree-listp trees)
                              (repetitionp rep))))
  (let ((__function__ 'smtp-cst-list-rep-matchp$))
    (declare (ignorable __function__))
    (and (tree-list-terminatedp trees)
         (tree-list-match-repetition-p
              trees rep *all-smtp-grammar-rules*))))

Theorem: booleanp-of-smtp-cst-list-rep-matchp$

(defthm booleanp-of-smtp-cst-list-rep-matchp$
  (b* ((yes/no (smtp-cst-list-rep-matchp$ trees rep)))
    (booleanp yes/no))
  :rule-classes :rewrite)

Theorem: smtp-cst-list-rep-matchp$-of-tree-list-fix-trees

(defthm smtp-cst-list-rep-matchp$-of-tree-list-fix-trees
  (equal (smtp-cst-list-rep-matchp$ (tree-list-fix trees)
                                    rep)
         (smtp-cst-list-rep-matchp$ trees rep)))

Theorem: smtp-cst-list-rep-matchp$-tree-list-equiv-congruence-on-trees

(defthm
      smtp-cst-list-rep-matchp$-tree-list-equiv-congruence-on-trees
  (implies (tree-list-equiv trees trees-equiv)
           (equal (smtp-cst-list-rep-matchp$ trees rep)
                  (smtp-cst-list-rep-matchp$ trees-equiv rep)))
  :rule-classes :congruence)

Theorem: smtp-cst-list-rep-matchp$-of-repetition-fix-rep

(defthm smtp-cst-list-rep-matchp$-of-repetition-fix-rep
  (equal (smtp-cst-list-rep-matchp$ trees (repetition-fix rep))
         (smtp-cst-list-rep-matchp$ trees rep)))

Theorem: smtp-cst-list-rep-matchp$-repetition-equiv-congruence-on-rep

(defthm smtp-cst-list-rep-matchp$-repetition-equiv-congruence-on-rep
  (implies (repetition-equiv rep rep-equiv)
           (equal (smtp-cst-list-rep-matchp$ trees rep)
                  (smtp-cst-list-rep-matchp$ trees rep-equiv)))
  :rule-classes :congruence)

Function: smtp-cst-list-list-conc-matchp$

(defun smtp-cst-list-list-conc-matchp$ (treess conc)
  (declare (xargs :guard (and (tree-list-listp treess)
                              (concatenationp conc))))
  (let ((__function__ 'smtp-cst-list-list-conc-matchp$))
    (declare (ignorable __function__))
    (and (tree-list-list-terminatedp treess)
         (tree-list-list-match-concatenation-p
              treess conc *all-smtp-grammar-rules*))))

Theorem: booleanp-of-smtp-cst-list-list-conc-matchp$

(defthm booleanp-of-smtp-cst-list-list-conc-matchp$
  (b* ((yes/no (smtp-cst-list-list-conc-matchp$ treess conc)))
    (booleanp yes/no))
  :rule-classes :rewrite)

Theorem: smtp-cst-list-list-conc-matchp$-of-tree-list-list-fix-treess

(defthm smtp-cst-list-list-conc-matchp$-of-tree-list-list-fix-treess
 (equal (smtp-cst-list-list-conc-matchp$ (tree-list-list-fix treess)
                                         conc)
        (smtp-cst-list-list-conc-matchp$ treess conc)))

Theorem: smtp-cst-list-list-conc-matchp$-tree-list-list-equiv-congruence-on-treess

(defthm
 smtp-cst-list-list-conc-matchp$-tree-list-list-equiv-congruence-on-treess
 (implies
      (tree-list-list-equiv treess treess-equiv)
      (equal (smtp-cst-list-list-conc-matchp$ treess conc)
             (smtp-cst-list-list-conc-matchp$ treess-equiv conc)))
 :rule-classes :congruence)

Theorem: smtp-cst-list-list-conc-matchp$-of-concatenation-fix-conc

(defthm smtp-cst-list-list-conc-matchp$-of-concatenation-fix-conc
 (equal
   (smtp-cst-list-list-conc-matchp$ treess (concatenation-fix conc))
   (smtp-cst-list-list-conc-matchp$ treess conc)))

Theorem: smtp-cst-list-list-conc-matchp$-concatenation-equiv-congruence-on-conc

(defthm
 smtp-cst-list-list-conc-matchp$-concatenation-equiv-congruence-on-conc
 (implies
      (concatenation-equiv conc conc-equiv)
      (equal (smtp-cst-list-list-conc-matchp$ treess conc)
             (smtp-cst-list-list-conc-matchp$ treess conc-equiv)))
 :rule-classes :congruence)

Function: smtp-cst-list-list-alt-matchp$

(defun smtp-cst-list-list-alt-matchp$ (treess alt)
  (declare (xargs :guard (and (tree-list-listp treess)
                              (alternationp alt))))
  (let ((__function__ 'smtp-cst-list-list-alt-matchp$))
    (declare (ignorable __function__))
    (and (tree-list-list-terminatedp treess)
         (tree-list-list-match-alternation-p
              treess alt *all-smtp-grammar-rules*))))

Theorem: booleanp-of-smtp-cst-list-list-alt-matchp$

(defthm booleanp-of-smtp-cst-list-list-alt-matchp$
  (b* ((yes/no (smtp-cst-list-list-alt-matchp$ treess alt)))
    (booleanp yes/no))
  :rule-classes :rewrite)

Theorem: smtp-cst-list-list-alt-matchp$-of-tree-list-list-fix-treess

(defthm smtp-cst-list-list-alt-matchp$-of-tree-list-list-fix-treess
  (equal (smtp-cst-list-list-alt-matchp$ (tree-list-list-fix treess)
                                         alt)
         (smtp-cst-list-list-alt-matchp$ treess alt)))

Theorem: smtp-cst-list-list-alt-matchp$-tree-list-list-equiv-congruence-on-treess

(defthm
 smtp-cst-list-list-alt-matchp$-tree-list-list-equiv-congruence-on-treess
 (implies (tree-list-list-equiv treess treess-equiv)
          (equal (smtp-cst-list-list-alt-matchp$ treess alt)
                 (smtp-cst-list-list-alt-matchp$ treess-equiv alt)))
 :rule-classes :congruence)

Theorem: smtp-cst-list-list-alt-matchp$-of-alternation-fix-alt

(defthm smtp-cst-list-list-alt-matchp$-of-alternation-fix-alt
  (equal
       (smtp-cst-list-list-alt-matchp$ treess (alternation-fix alt))
       (smtp-cst-list-list-alt-matchp$ treess alt)))

Theorem: smtp-cst-list-list-alt-matchp$-alternation-equiv-congruence-on-alt

(defthm
 smtp-cst-list-list-alt-matchp$-alternation-equiv-congruence-on-alt
 (implies (alternation-equiv alt alt-equiv)
          (equal (smtp-cst-list-list-alt-matchp$ treess alt)
                 (smtp-cst-list-list-alt-matchp$ treess alt-equiv)))
 :rule-classes :congruence)

Function: smtp-cst-%d0-9-nat

(defun smtp-cst-%d0-9-nat (cst)
  (declare (xargs :guard (treep cst)))
  (declare (xargs :guard (smtp-cst-matchp cst "%d0-9")))
  (let ((__function__ 'smtp-cst-%d0-9-nat))
    (declare (ignorable __function__))
    (lnfix (nth 0 (tree-leafterm->get cst)))))

Theorem: natp-of-smtp-cst-%d0-9-nat

(defthm natp-of-smtp-cst-%d0-9-nat
  (b* ((nat (smtp-cst-%d0-9-nat cst)))
    (natp nat))
  :rule-classes :rewrite)

Theorem: smtp-cst-%d0-9-nat-of-tree-fix-cst

(defthm smtp-cst-%d0-9-nat-of-tree-fix-cst
  (equal (smtp-cst-%d0-9-nat (tree-fix cst))
         (smtp-cst-%d0-9-nat cst)))

Theorem: smtp-cst-%d0-9-nat-tree-equiv-congruence-on-cst

(defthm smtp-cst-%d0-9-nat-tree-equiv-congruence-on-cst
  (implies (tree-equiv cst cst-equiv)
           (equal (smtp-cst-%d0-9-nat cst)
                  (smtp-cst-%d0-9-nat cst-equiv)))
  :rule-classes :congruence)

Function: smtp-cst-%d1-8-nat

(defun smtp-cst-%d1-8-nat (cst)
  (declare (xargs :guard (treep cst)))
  (declare (xargs :guard (smtp-cst-matchp cst "%d1-8")))
  (let ((__function__ 'smtp-cst-%d1-8-nat))
    (declare (ignorable __function__))
    (lnfix (nth 0 (tree-leafterm->get cst)))))

Theorem: natp-of-smtp-cst-%d1-8-nat

(defthm natp-of-smtp-cst-%d1-8-nat
  (b* ((nat (smtp-cst-%d1-8-nat cst)))
    (natp nat))
  :rule-classes :rewrite)

Theorem: smtp-cst-%d1-8-nat-of-tree-fix-cst

(defthm smtp-cst-%d1-8-nat-of-tree-fix-cst
  (equal (smtp-cst-%d1-8-nat (tree-fix cst))
         (smtp-cst-%d1-8-nat cst)))

Theorem: smtp-cst-%d1-8-nat-tree-equiv-congruence-on-cst

(defthm smtp-cst-%d1-8-nat-tree-equiv-congruence-on-cst
  (implies (tree-equiv cst cst-equiv)
           (equal (smtp-cst-%d1-8-nat cst)
                  (smtp-cst-%d1-8-nat cst-equiv)))
  :rule-classes :congruence)

Function: smtp-cst-%d11-12-nat

(defun smtp-cst-%d11-12-nat (cst)
  (declare (xargs :guard (treep cst)))
  (declare (xargs :guard (smtp-cst-matchp cst "%d11-12")))
  (let ((__function__ 'smtp-cst-%d11-12-nat))
    (declare (ignorable __function__))
    (lnfix (nth 0 (tree-leafterm->get cst)))))

Theorem: natp-of-smtp-cst-%d11-12-nat

(defthm natp-of-smtp-cst-%d11-12-nat
  (b* ((nat (smtp-cst-%d11-12-nat cst)))
    (natp nat))
  :rule-classes :rewrite)

Theorem: smtp-cst-%d11-12-nat-of-tree-fix-cst

(defthm smtp-cst-%d11-12-nat-of-tree-fix-cst
  (equal (smtp-cst-%d11-12-nat (tree-fix cst))
         (smtp-cst-%d11-12-nat cst)))

Theorem: smtp-cst-%d11-12-nat-tree-equiv-congruence-on-cst

(defthm smtp-cst-%d11-12-nat-tree-equiv-congruence-on-cst
  (implies (tree-equiv cst cst-equiv)
           (equal (smtp-cst-%d11-12-nat cst)
                  (smtp-cst-%d11-12-nat cst-equiv)))
  :rule-classes :congruence)

Function: smtp-cst-%d14-31-nat

(defun smtp-cst-%d14-31-nat (cst)
  (declare (xargs :guard (treep cst)))
  (declare (xargs :guard (smtp-cst-matchp cst "%d14-31")))
  (let ((__function__ 'smtp-cst-%d14-31-nat))
    (declare (ignorable __function__))
    (lnfix (nth 0 (tree-leafterm->get cst)))))

Theorem: natp-of-smtp-cst-%d14-31-nat

(defthm natp-of-smtp-cst-%d14-31-nat
  (b* ((nat (smtp-cst-%d14-31-nat cst)))
    (natp nat))
  :rule-classes :rewrite)

Theorem: smtp-cst-%d14-31-nat-of-tree-fix-cst

(defthm smtp-cst-%d14-31-nat-of-tree-fix-cst
  (equal (smtp-cst-%d14-31-nat (tree-fix cst))
         (smtp-cst-%d14-31-nat cst)))

Theorem: smtp-cst-%d14-31-nat-tree-equiv-congruence-on-cst

(defthm smtp-cst-%d14-31-nat-tree-equiv-congruence-on-cst
  (implies (tree-equiv cst cst-equiv)
           (equal (smtp-cst-%d14-31-nat cst)
                  (smtp-cst-%d14-31-nat cst-equiv)))
  :rule-classes :congruence)

Function: smtp-cst-%d14-127-nat

(defun smtp-cst-%d14-127-nat (cst)
  (declare (xargs :guard (treep cst)))
  (declare (xargs :guard (smtp-cst-matchp cst "%d14-127")))
  (let ((__function__ 'smtp-cst-%d14-127-nat))
    (declare (ignorable __function__))
    (lnfix (nth 0 (tree-leafterm->get cst)))))

Theorem: natp-of-smtp-cst-%d14-127-nat

(defthm natp-of-smtp-cst-%d14-127-nat
  (b* ((nat (smtp-cst-%d14-127-nat cst)))
    (natp nat))
  :rule-classes :rewrite)

Theorem: smtp-cst-%d14-127-nat-of-tree-fix-cst

(defthm smtp-cst-%d14-127-nat-of-tree-fix-cst
  (equal (smtp-cst-%d14-127-nat (tree-fix cst))
         (smtp-cst-%d14-127-nat cst)))

Theorem: smtp-cst-%d14-127-nat-tree-equiv-congruence-on-cst

(defthm smtp-cst-%d14-127-nat-tree-equiv-congruence-on-cst
  (implies (tree-equiv cst cst-equiv)
           (equal (smtp-cst-%d14-127-nat cst)
                  (smtp-cst-%d14-127-nat cst-equiv)))
  :rule-classes :congruence)

Function: smtp-cst-%d32-33-nat

(defun smtp-cst-%d32-33-nat (cst)
  (declare (xargs :guard (treep cst)))
  (declare (xargs :guard (smtp-cst-matchp cst "%d32-33")))
  (let ((__function__ 'smtp-cst-%d32-33-nat))
    (declare (ignorable __function__))
    (lnfix (nth 0 (tree-leafterm->get cst)))))

Theorem: natp-of-smtp-cst-%d32-33-nat

(defthm natp-of-smtp-cst-%d32-33-nat
  (b* ((nat (smtp-cst-%d32-33-nat cst)))
    (natp nat))
  :rule-classes :rewrite)

Theorem: smtp-cst-%d32-33-nat-of-tree-fix-cst

(defthm smtp-cst-%d32-33-nat-of-tree-fix-cst
  (equal (smtp-cst-%d32-33-nat (tree-fix cst))
         (smtp-cst-%d32-33-nat cst)))

Theorem: smtp-cst-%d32-33-nat-tree-equiv-congruence-on-cst

(defthm smtp-cst-%d32-33-nat-tree-equiv-congruence-on-cst
  (implies (tree-equiv cst cst-equiv)
           (equal (smtp-cst-%d32-33-nat cst)
                  (smtp-cst-%d32-33-nat cst-equiv)))
  :rule-classes :congruence)

Function: smtp-cst-%d32-126-nat

(defun smtp-cst-%d32-126-nat (cst)
  (declare (xargs :guard (treep cst)))
  (declare (xargs :guard (smtp-cst-matchp cst "%d32-126")))
  (let ((__function__ 'smtp-cst-%d32-126-nat))
    (declare (ignorable __function__))
    (lnfix (nth 0 (tree-leafterm->get cst)))))

Theorem: natp-of-smtp-cst-%d32-126-nat

(defthm natp-of-smtp-cst-%d32-126-nat
  (b* ((nat (smtp-cst-%d32-126-nat cst)))
    (natp nat))
  :rule-classes :rewrite)

Theorem: smtp-cst-%d32-126-nat-of-tree-fix-cst

(defthm smtp-cst-%d32-126-nat-of-tree-fix-cst
  (equal (smtp-cst-%d32-126-nat (tree-fix cst))
         (smtp-cst-%d32-126-nat cst)))

Theorem: smtp-cst-%d32-126-nat-tree-equiv-congruence-on-cst

(defthm smtp-cst-%d32-126-nat-tree-equiv-congruence-on-cst
  (implies (tree-equiv cst cst-equiv)
           (equal (smtp-cst-%d32-126-nat cst)
                  (smtp-cst-%d32-126-nat cst-equiv)))
  :rule-classes :congruence)

Function: smtp-cst-%d33-39-nat

(defun smtp-cst-%d33-39-nat (cst)
  (declare (xargs :guard (treep cst)))
  (declare (xargs :guard (smtp-cst-matchp cst "%d33-39")))
  (let ((__function__ 'smtp-cst-%d33-39-nat))
    (declare (ignorable __function__))
    (lnfix (nth 0 (tree-leafterm->get cst)))))

Theorem: natp-of-smtp-cst-%d33-39-nat

(defthm natp-of-smtp-cst-%d33-39-nat
  (b* ((nat (smtp-cst-%d33-39-nat cst)))
    (natp nat))
  :rule-classes :rewrite)

Theorem: smtp-cst-%d33-39-nat-of-tree-fix-cst

(defthm smtp-cst-%d33-39-nat-of-tree-fix-cst
  (equal (smtp-cst-%d33-39-nat (tree-fix cst))
         (smtp-cst-%d33-39-nat cst)))

Theorem: smtp-cst-%d33-39-nat-tree-equiv-congruence-on-cst

(defthm smtp-cst-%d33-39-nat-tree-equiv-congruence-on-cst
  (implies (tree-equiv cst cst-equiv)
           (equal (smtp-cst-%d33-39-nat cst)
                  (smtp-cst-%d33-39-nat cst-equiv)))
  :rule-classes :congruence)

Function: smtp-cst-%d33-60-nat

(defun smtp-cst-%d33-60-nat (cst)
  (declare (xargs :guard (treep cst)))
  (declare (xargs :guard (smtp-cst-matchp cst "%d33-60")))
  (let ((__function__ 'smtp-cst-%d33-60-nat))
    (declare (ignorable __function__))
    (lnfix (nth 0 (tree-leafterm->get cst)))))

Theorem: natp-of-smtp-cst-%d33-60-nat

(defthm natp-of-smtp-cst-%d33-60-nat
  (b* ((nat (smtp-cst-%d33-60-nat cst)))
    (natp nat))
  :rule-classes :rewrite)

Theorem: smtp-cst-%d33-60-nat-of-tree-fix-cst

(defthm smtp-cst-%d33-60-nat-of-tree-fix-cst
  (equal (smtp-cst-%d33-60-nat (tree-fix cst))
         (smtp-cst-%d33-60-nat cst)))

Theorem: smtp-cst-%d33-60-nat-tree-equiv-congruence-on-cst

(defthm smtp-cst-%d33-60-nat-tree-equiv-congruence-on-cst
  (implies (tree-equiv cst cst-equiv)
           (equal (smtp-cst-%d33-60-nat cst)
                  (smtp-cst-%d33-60-nat cst-equiv)))
  :rule-classes :congruence)

Function: smtp-cst-%d33-90-nat

(defun smtp-cst-%d33-90-nat (cst)
  (declare (xargs :guard (treep cst)))
  (declare (xargs :guard (smtp-cst-matchp cst "%d33-90")))
  (let ((__function__ 'smtp-cst-%d33-90-nat))
    (declare (ignorable __function__))
    (lnfix (nth 0 (tree-leafterm->get cst)))))

Theorem: natp-of-smtp-cst-%d33-90-nat

(defthm natp-of-smtp-cst-%d33-90-nat
  (b* ((nat (smtp-cst-%d33-90-nat cst)))
    (natp nat))
  :rule-classes :rewrite)

Theorem: smtp-cst-%d33-90-nat-of-tree-fix-cst

(defthm smtp-cst-%d33-90-nat-of-tree-fix-cst
  (equal (smtp-cst-%d33-90-nat (tree-fix cst))
         (smtp-cst-%d33-90-nat cst)))

Theorem: smtp-cst-%d33-90-nat-tree-equiv-congruence-on-cst

(defthm smtp-cst-%d33-90-nat-tree-equiv-congruence-on-cst
  (implies (tree-equiv cst cst-equiv)
           (equal (smtp-cst-%d33-90-nat cst)
                  (smtp-cst-%d33-90-nat cst-equiv)))
  :rule-classes :congruence)

Function: smtp-cst-%d33-126-nat

(defun smtp-cst-%d33-126-nat (cst)
  (declare (xargs :guard (treep cst)))
  (declare (xargs :guard (smtp-cst-matchp cst "%d33-126")))
  (let ((__function__ 'smtp-cst-%d33-126-nat))
    (declare (ignorable __function__))
    (lnfix (nth 0 (tree-leafterm->get cst)))))

Theorem: natp-of-smtp-cst-%d33-126-nat

(defthm natp-of-smtp-cst-%d33-126-nat
  (b* ((nat (smtp-cst-%d33-126-nat cst)))
    (natp nat))
  :rule-classes :rewrite)

Theorem: smtp-cst-%d33-126-nat-of-tree-fix-cst

(defthm smtp-cst-%d33-126-nat-of-tree-fix-cst
  (equal (smtp-cst-%d33-126-nat (tree-fix cst))
         (smtp-cst-%d33-126-nat cst)))

Theorem: smtp-cst-%d33-126-nat-tree-equiv-congruence-on-cst

(defthm smtp-cst-%d33-126-nat-tree-equiv-congruence-on-cst
  (implies (tree-equiv cst cst-equiv)
           (equal (smtp-cst-%d33-126-nat cst)
                  (smtp-cst-%d33-126-nat cst-equiv)))
  :rule-classes :congruence)

Function: smtp-cst-%d35-91-nat

(defun smtp-cst-%d35-91-nat (cst)
  (declare (xargs :guard (treep cst)))
  (declare (xargs :guard (smtp-cst-matchp cst "%d35-91")))
  (let ((__function__ 'smtp-cst-%d35-91-nat))
    (declare (ignorable __function__))
    (lnfix (nth 0 (tree-leafterm->get cst)))))

Theorem: natp-of-smtp-cst-%d35-91-nat

(defthm natp-of-smtp-cst-%d35-91-nat
  (b* ((nat (smtp-cst-%d35-91-nat cst)))
    (natp nat))
  :rule-classes :rewrite)

Theorem: smtp-cst-%d35-91-nat-of-tree-fix-cst

(defthm smtp-cst-%d35-91-nat-of-tree-fix-cst
  (equal (smtp-cst-%d35-91-nat (tree-fix cst))
         (smtp-cst-%d35-91-nat cst)))

Theorem: smtp-cst-%d35-91-nat-tree-equiv-congruence-on-cst

(defthm smtp-cst-%d35-91-nat-tree-equiv-congruence-on-cst
  (implies (tree-equiv cst cst-equiv)
           (equal (smtp-cst-%d35-91-nat cst)
                  (smtp-cst-%d35-91-nat cst-equiv)))
  :rule-classes :congruence)

Function: smtp-cst-%d42-91-nat

(defun smtp-cst-%d42-91-nat (cst)
  (declare (xargs :guard (treep cst)))
  (declare (xargs :guard (smtp-cst-matchp cst "%d42-91")))
  (let ((__function__ 'smtp-cst-%d42-91-nat))
    (declare (ignorable __function__))
    (lnfix (nth 0 (tree-leafterm->get cst)))))

Theorem: natp-of-smtp-cst-%d42-91-nat

(defthm natp-of-smtp-cst-%d42-91-nat
  (b* ((nat (smtp-cst-%d42-91-nat cst)))
    (natp nat))
  :rule-classes :rewrite)

Theorem: smtp-cst-%d42-91-nat-of-tree-fix-cst

(defthm smtp-cst-%d42-91-nat-of-tree-fix-cst
  (equal (smtp-cst-%d42-91-nat (tree-fix cst))
         (smtp-cst-%d42-91-nat cst)))

Theorem: smtp-cst-%d42-91-nat-tree-equiv-congruence-on-cst

(defthm smtp-cst-%d42-91-nat-tree-equiv-congruence-on-cst
  (implies (tree-equiv cst cst-equiv)
           (equal (smtp-cst-%d42-91-nat cst)
                  (smtp-cst-%d42-91-nat cst-equiv)))
  :rule-classes :congruence)

Function: smtp-cst-%d62-126-nat

(defun smtp-cst-%d62-126-nat (cst)
  (declare (xargs :guard (treep cst)))
  (declare (xargs :guard (smtp-cst-matchp cst "%d62-126")))
  (let ((__function__ 'smtp-cst-%d62-126-nat))
    (declare (ignorable __function__))
    (lnfix (nth 0 (tree-leafterm->get cst)))))

Theorem: natp-of-smtp-cst-%d62-126-nat

(defthm natp-of-smtp-cst-%d62-126-nat
  (b* ((nat (smtp-cst-%d62-126-nat cst)))
    (natp nat))
  :rule-classes :rewrite)

Theorem: smtp-cst-%d62-126-nat-of-tree-fix-cst

(defthm smtp-cst-%d62-126-nat-of-tree-fix-cst
  (equal (smtp-cst-%d62-126-nat (tree-fix cst))
         (smtp-cst-%d62-126-nat cst)))

Theorem: smtp-cst-%d62-126-nat-tree-equiv-congruence-on-cst

(defthm smtp-cst-%d62-126-nat-tree-equiv-congruence-on-cst
  (implies (tree-equiv cst cst-equiv)
           (equal (smtp-cst-%d62-126-nat cst)
                  (smtp-cst-%d62-126-nat cst-equiv)))
  :rule-classes :congruence)

Function: smtp-cst-%d65-73-nat

(defun smtp-cst-%d65-73-nat (cst)
  (declare (xargs :guard (treep cst)))
  (declare (xargs :guard (smtp-cst-matchp cst "%d65-73")))
  (let ((__function__ 'smtp-cst-%d65-73-nat))
    (declare (ignorable __function__))
    (lnfix (nth 0 (tree-leafterm->get cst)))))

Theorem: natp-of-smtp-cst-%d65-73-nat

(defthm natp-of-smtp-cst-%d65-73-nat
  (b* ((nat (smtp-cst-%d65-73-nat cst)))
    (natp nat))
  :rule-classes :rewrite)

Theorem: smtp-cst-%d65-73-nat-of-tree-fix-cst

(defthm smtp-cst-%d65-73-nat-of-tree-fix-cst
  (equal (smtp-cst-%d65-73-nat (tree-fix cst))
         (smtp-cst-%d65-73-nat cst)))

Theorem: smtp-cst-%d65-73-nat-tree-equiv-congruence-on-cst

(defthm smtp-cst-%d65-73-nat-tree-equiv-congruence-on-cst
  (implies (tree-equiv cst cst-equiv)
           (equal (smtp-cst-%d65-73-nat cst)
                  (smtp-cst-%d65-73-nat cst-equiv)))
  :rule-classes :congruence)

Function: smtp-cst-%d75-90-nat

(defun smtp-cst-%d75-90-nat (cst)
  (declare (xargs :guard (treep cst)))
  (declare (xargs :guard (smtp-cst-matchp cst "%d75-90")))
  (let ((__function__ 'smtp-cst-%d75-90-nat))
    (declare (ignorable __function__))
    (lnfix (nth 0 (tree-leafterm->get cst)))))

Theorem: natp-of-smtp-cst-%d75-90-nat

(defthm natp-of-smtp-cst-%d75-90-nat
  (b* ((nat (smtp-cst-%d75-90-nat cst)))
    (natp nat))
  :rule-classes :rewrite)

Theorem: smtp-cst-%d75-90-nat-of-tree-fix-cst

(defthm smtp-cst-%d75-90-nat-of-tree-fix-cst
  (equal (smtp-cst-%d75-90-nat (tree-fix cst))
         (smtp-cst-%d75-90-nat cst)))

Theorem: smtp-cst-%d75-90-nat-tree-equiv-congruence-on-cst

(defthm smtp-cst-%d75-90-nat-tree-equiv-congruence-on-cst
  (implies (tree-equiv cst cst-equiv)
           (equal (smtp-cst-%d75-90-nat cst)
                  (smtp-cst-%d75-90-nat cst-equiv)))
  :rule-classes :congruence)

Function: smtp-cst-%d93-126-nat

(defun smtp-cst-%d93-126-nat (cst)
  (declare (xargs :guard (treep cst)))
  (declare (xargs :guard (smtp-cst-matchp cst "%d93-126")))
  (let ((__function__ 'smtp-cst-%d93-126-nat))
    (declare (ignorable __function__))
    (lnfix (nth 0 (tree-leafterm->get cst)))))

Theorem: natp-of-smtp-cst-%d93-126-nat

(defthm natp-of-smtp-cst-%d93-126-nat
  (b* ((nat (smtp-cst-%d93-126-nat cst)))
    (natp nat))
  :rule-classes :rewrite)

Theorem: smtp-cst-%d93-126-nat-of-tree-fix-cst

(defthm smtp-cst-%d93-126-nat-of-tree-fix-cst
  (equal (smtp-cst-%d93-126-nat (tree-fix cst))
         (smtp-cst-%d93-126-nat cst)))

Theorem: smtp-cst-%d93-126-nat-tree-equiv-congruence-on-cst

(defthm smtp-cst-%d93-126-nat-tree-equiv-congruence-on-cst
  (implies (tree-equiv cst cst-equiv)
           (equal (smtp-cst-%d93-126-nat cst)
                  (smtp-cst-%d93-126-nat cst-equiv)))
  :rule-classes :congruence)

Function: smtp-cst-%d94-126-nat

(defun smtp-cst-%d94-126-nat (cst)
  (declare (xargs :guard (treep cst)))
  (declare (xargs :guard (smtp-cst-matchp cst "%d94-126")))
  (let ((__function__ 'smtp-cst-%d94-126-nat))
    (declare (ignorable __function__))
    (lnfix (nth 0 (tree-leafterm->get cst)))))

Theorem: natp-of-smtp-cst-%d94-126-nat

(defthm natp-of-smtp-cst-%d94-126-nat
  (b* ((nat (smtp-cst-%d94-126-nat cst)))
    (natp nat))
  :rule-classes :rewrite)

Theorem: smtp-cst-%d94-126-nat-of-tree-fix-cst

(defthm smtp-cst-%d94-126-nat-of-tree-fix-cst
  (equal (smtp-cst-%d94-126-nat (tree-fix cst))
         (smtp-cst-%d94-126-nat cst)))

Theorem: smtp-cst-%d94-126-nat-tree-equiv-congruence-on-cst

(defthm smtp-cst-%d94-126-nat-tree-equiv-congruence-on-cst
  (implies (tree-equiv cst cst-equiv)
           (equal (smtp-cst-%d94-126-nat cst)
                  (smtp-cst-%d94-126-nat cst-equiv)))
  :rule-classes :congruence)

Function: smtp-cst-%d97-105-nat

(defun smtp-cst-%d97-105-nat (cst)
  (declare (xargs :guard (treep cst)))
  (declare (xargs :guard (smtp-cst-matchp cst "%d97-105")))
  (let ((__function__ 'smtp-cst-%d97-105-nat))
    (declare (ignorable __function__))
    (lnfix (nth 0 (tree-leafterm->get cst)))))

Theorem: natp-of-smtp-cst-%d97-105-nat

(defthm natp-of-smtp-cst-%d97-105-nat
  (b* ((nat (smtp-cst-%d97-105-nat cst)))
    (natp nat))
  :rule-classes :rewrite)

Theorem: smtp-cst-%d97-105-nat-of-tree-fix-cst

(defthm smtp-cst-%d97-105-nat-of-tree-fix-cst
  (equal (smtp-cst-%d97-105-nat (tree-fix cst))
         (smtp-cst-%d97-105-nat cst)))

Theorem: smtp-cst-%d97-105-nat-tree-equiv-congruence-on-cst

(defthm smtp-cst-%d97-105-nat-tree-equiv-congruence-on-cst
  (implies (tree-equiv cst cst-equiv)
           (equal (smtp-cst-%d97-105-nat cst)
                  (smtp-cst-%d97-105-nat cst-equiv)))
  :rule-classes :congruence)

Function: smtp-cst-%d107-122-nat

(defun smtp-cst-%d107-122-nat (cst)
  (declare (xargs :guard (treep cst)))
  (declare (xargs :guard (smtp-cst-matchp cst "%d107-122")))
  (let ((__function__ 'smtp-cst-%d107-122-nat))
    (declare (ignorable __function__))
    (lnfix (nth 0 (tree-leafterm->get cst)))))

Theorem: natp-of-smtp-cst-%d107-122-nat

(defthm natp-of-smtp-cst-%d107-122-nat
  (b* ((nat (smtp-cst-%d107-122-nat cst)))
    (natp nat))
  :rule-classes :rewrite)

Theorem: smtp-cst-%d107-122-nat-of-tree-fix-cst

(defthm smtp-cst-%d107-122-nat-of-tree-fix-cst
  (equal (smtp-cst-%d107-122-nat (tree-fix cst))
         (smtp-cst-%d107-122-nat cst)))

Theorem: smtp-cst-%d107-122-nat-tree-equiv-congruence-on-cst

(defthm smtp-cst-%d107-122-nat-tree-equiv-congruence-on-cst
  (implies (tree-equiv cst cst-equiv)
           (equal (smtp-cst-%d107-122-nat cst)
                  (smtp-cst-%d107-122-nat cst-equiv)))
  :rule-classes :congruence)

Function: smtp-cst-%x21-7e-nat

(defun smtp-cst-%x21-7e-nat (cst)
  (declare (xargs :guard (treep cst)))
  (declare (xargs :guard (smtp-cst-matchp cst "%x21-7E")))
  (let ((__function__ 'smtp-cst-%x21-7e-nat))
    (declare (ignorable __function__))
    (lnfix (nth 0 (tree-leafterm->get cst)))))

Theorem: natp-of-smtp-cst-%x21-7e-nat

(defthm natp-of-smtp-cst-%x21-7e-nat
  (b* ((nat (smtp-cst-%x21-7e-nat cst)))
    (natp nat))
  :rule-classes :rewrite)

Theorem: smtp-cst-%x21-7e-nat-of-tree-fix-cst

(defthm smtp-cst-%x21-7e-nat-of-tree-fix-cst
  (equal (smtp-cst-%x21-7e-nat (tree-fix cst))
         (smtp-cst-%x21-7e-nat cst)))

Theorem: smtp-cst-%x21-7e-nat-tree-equiv-congruence-on-cst

(defthm smtp-cst-%x21-7e-nat-tree-equiv-congruence-on-cst
  (implies (tree-equiv cst cst-equiv)
           (equal (smtp-cst-%x21-7e-nat cst)
                  (smtp-cst-%x21-7e-nat cst-equiv)))
  :rule-classes :congruence)

Function: smtp-cst-%x30-35-nat

(defun smtp-cst-%x30-35-nat (cst)
  (declare (xargs :guard (treep cst)))
  (declare (xargs :guard (smtp-cst-matchp cst "%x30-35")))
  (let ((__function__ 'smtp-cst-%x30-35-nat))
    (declare (ignorable __function__))
    (lnfix (nth 0 (tree-leafterm->get cst)))))

Theorem: natp-of-smtp-cst-%x30-35-nat

(defthm natp-of-smtp-cst-%x30-35-nat
  (b* ((nat (smtp-cst-%x30-35-nat cst)))
    (natp nat))
  :rule-classes :rewrite)

Theorem: smtp-cst-%x30-35-nat-of-tree-fix-cst

(defthm smtp-cst-%x30-35-nat-of-tree-fix-cst
  (equal (smtp-cst-%x30-35-nat (tree-fix cst))
         (smtp-cst-%x30-35-nat cst)))

Theorem: smtp-cst-%x30-35-nat-tree-equiv-congruence-on-cst

(defthm smtp-cst-%x30-35-nat-tree-equiv-congruence-on-cst
  (implies (tree-equiv cst cst-equiv)
           (equal (smtp-cst-%x30-35-nat cst)
                  (smtp-cst-%x30-35-nat cst-equiv)))
  :rule-classes :congruence)

Function: smtp-cst-%x30-39-nat

(defun smtp-cst-%x30-39-nat (cst)
  (declare (xargs :guard (treep cst)))
  (declare (xargs :guard (smtp-cst-matchp cst "%x30-39")))
  (let ((__function__ 'smtp-cst-%x30-39-nat))
    (declare (ignorable __function__))
    (lnfix (nth 0 (tree-leafterm->get cst)))))

Theorem: natp-of-smtp-cst-%x30-39-nat

(defthm natp-of-smtp-cst-%x30-39-nat
  (b* ((nat (smtp-cst-%x30-39-nat cst)))
    (natp nat))
  :rule-classes :rewrite)

Theorem: smtp-cst-%x30-39-nat-of-tree-fix-cst

(defthm smtp-cst-%x30-39-nat-of-tree-fix-cst
  (equal (smtp-cst-%x30-39-nat (tree-fix cst))
         (smtp-cst-%x30-39-nat cst)))

Theorem: smtp-cst-%x30-39-nat-tree-equiv-congruence-on-cst

(defthm smtp-cst-%x30-39-nat-tree-equiv-congruence-on-cst
  (implies (tree-equiv cst cst-equiv)
           (equal (smtp-cst-%x30-39-nat cst)
                  (smtp-cst-%x30-39-nat cst-equiv)))
  :rule-classes :congruence)

Function: smtp-cst-%x32-35-nat

(defun smtp-cst-%x32-35-nat (cst)
  (declare (xargs :guard (treep cst)))
  (declare (xargs :guard (smtp-cst-matchp cst "%x32-35")))
  (let ((__function__ 'smtp-cst-%x32-35-nat))
    (declare (ignorable __function__))
    (lnfix (nth 0 (tree-leafterm->get cst)))))

Theorem: natp-of-smtp-cst-%x32-35-nat

(defthm natp-of-smtp-cst-%x32-35-nat
  (b* ((nat (smtp-cst-%x32-35-nat cst)))
    (natp nat))
  :rule-classes :rewrite)

Theorem: smtp-cst-%x32-35-nat-of-tree-fix-cst

(defthm smtp-cst-%x32-35-nat-of-tree-fix-cst
  (equal (smtp-cst-%x32-35-nat (tree-fix cst))
         (smtp-cst-%x32-35-nat cst)))

Theorem: smtp-cst-%x32-35-nat-tree-equiv-congruence-on-cst

(defthm smtp-cst-%x32-35-nat-tree-equiv-congruence-on-cst
  (implies (tree-equiv cst cst-equiv)
           (equal (smtp-cst-%x32-35-nat cst)
                  (smtp-cst-%x32-35-nat cst-equiv)))
  :rule-classes :congruence)

Function: smtp-cst-%x41-5a-nat

(defun smtp-cst-%x41-5a-nat (cst)
  (declare (xargs :guard (treep cst)))
  (declare (xargs :guard (smtp-cst-matchp cst "%x41-5A")))
  (let ((__function__ 'smtp-cst-%x41-5a-nat))
    (declare (ignorable __function__))
    (lnfix (nth 0 (tree-leafterm->get cst)))))

Theorem: natp-of-smtp-cst-%x41-5a-nat

(defthm natp-of-smtp-cst-%x41-5a-nat
  (b* ((nat (smtp-cst-%x41-5a-nat cst)))
    (natp nat))
  :rule-classes :rewrite)

Theorem: smtp-cst-%x41-5a-nat-of-tree-fix-cst

(defthm smtp-cst-%x41-5a-nat-of-tree-fix-cst
  (equal (smtp-cst-%x41-5a-nat (tree-fix cst))
         (smtp-cst-%x41-5a-nat cst)))

Theorem: smtp-cst-%x41-5a-nat-tree-equiv-congruence-on-cst

(defthm smtp-cst-%x41-5a-nat-tree-equiv-congruence-on-cst
  (implies (tree-equiv cst cst-equiv)
           (equal (smtp-cst-%x41-5a-nat cst)
                  (smtp-cst-%x41-5a-nat cst-equiv)))
  :rule-classes :congruence)

Function: smtp-cst-%x61-7a-nat

(defun smtp-cst-%x61-7a-nat (cst)
  (declare (xargs :guard (treep cst)))
  (declare (xargs :guard (smtp-cst-matchp cst "%x61-7A")))
  (let ((__function__ 'smtp-cst-%x61-7a-nat))
    (declare (ignorable __function__))
    (lnfix (nth 0 (tree-leafterm->get cst)))))

Theorem: natp-of-smtp-cst-%x61-7a-nat

(defthm natp-of-smtp-cst-%x61-7a-nat
  (b* ((nat (smtp-cst-%x61-7a-nat cst)))
    (natp nat))
  :rule-classes :rewrite)

Theorem: smtp-cst-%x61-7a-nat-of-tree-fix-cst

(defthm smtp-cst-%x61-7a-nat-of-tree-fix-cst
  (equal (smtp-cst-%x61-7a-nat (tree-fix cst))
         (smtp-cst-%x61-7a-nat cst)))

Theorem: smtp-cst-%x61-7a-nat-tree-equiv-congruence-on-cst

(defthm smtp-cst-%x61-7a-nat-tree-equiv-congruence-on-cst
  (implies (tree-equiv cst cst-equiv)
           (equal (smtp-cst-%x61-7a-nat cst)
                  (smtp-cst-%x61-7a-nat cst-equiv)))
  :rule-classes :congruence)

Theorem: smtp-cst-%d0-9-nat-bounds

(defthm smtp-cst-%d0-9-nat-bounds
  (implies (smtp-cst-matchp cst "%d0-9")
           (and (<= 0 (smtp-cst-%d0-9-nat cst))
                (<= (smtp-cst-%d0-9-nat cst) 9)))
  :rule-classes :linear)

Theorem: smtp-cst-%d1-8-nat-bounds

(defthm smtp-cst-%d1-8-nat-bounds
  (implies (smtp-cst-matchp cst "%d1-8")
           (and (<= 1 (smtp-cst-%d1-8-nat cst))
                (<= (smtp-cst-%d1-8-nat cst) 8)))
  :rule-classes :linear)

Theorem: smtp-cst-%d11-12-nat-bounds

(defthm smtp-cst-%d11-12-nat-bounds
  (implies (smtp-cst-matchp cst "%d11-12")
           (and (<= 11 (smtp-cst-%d11-12-nat cst))
                (<= (smtp-cst-%d11-12-nat cst) 12)))
  :rule-classes :linear)

Theorem: smtp-cst-%d14-31-nat-bounds

(defthm smtp-cst-%d14-31-nat-bounds
  (implies (smtp-cst-matchp cst "%d14-31")
           (and (<= 14 (smtp-cst-%d14-31-nat cst))
                (<= (smtp-cst-%d14-31-nat cst) 31)))
  :rule-classes :linear)

Theorem: smtp-cst-%d14-127-nat-bounds

(defthm smtp-cst-%d14-127-nat-bounds
  (implies (smtp-cst-matchp cst "%d14-127")
           (and (<= 14 (smtp-cst-%d14-127-nat cst))
                (<= (smtp-cst-%d14-127-nat cst) 127)))
  :rule-classes :linear)

Theorem: smtp-cst-%d32-33-nat-bounds

(defthm smtp-cst-%d32-33-nat-bounds
  (implies (smtp-cst-matchp cst "%d32-33")
           (and (<= 32 (smtp-cst-%d32-33-nat cst))
                (<= (smtp-cst-%d32-33-nat cst) 33)))
  :rule-classes :linear)

Theorem: smtp-cst-%d32-126-nat-bounds

(defthm smtp-cst-%d32-126-nat-bounds
  (implies (smtp-cst-matchp cst "%d32-126")
           (and (<= 32 (smtp-cst-%d32-126-nat cst))
                (<= (smtp-cst-%d32-126-nat cst) 126)))
  :rule-classes :linear)

Theorem: smtp-cst-%d33-39-nat-bounds

(defthm smtp-cst-%d33-39-nat-bounds
  (implies (smtp-cst-matchp cst "%d33-39")
           (and (<= 33 (smtp-cst-%d33-39-nat cst))
                (<= (smtp-cst-%d33-39-nat cst) 39)))
  :rule-classes :linear)

Theorem: smtp-cst-%d33-60-nat-bounds

(defthm smtp-cst-%d33-60-nat-bounds
  (implies (smtp-cst-matchp cst "%d33-60")
           (and (<= 33 (smtp-cst-%d33-60-nat cst))
                (<= (smtp-cst-%d33-60-nat cst) 60)))
  :rule-classes :linear)

Theorem: smtp-cst-%d33-90-nat-bounds

(defthm smtp-cst-%d33-90-nat-bounds
  (implies (smtp-cst-matchp cst "%d33-90")
           (and (<= 33 (smtp-cst-%d33-90-nat cst))
                (<= (smtp-cst-%d33-90-nat cst) 90)))
  :rule-classes :linear)

Theorem: smtp-cst-%d33-126-nat-bounds

(defthm smtp-cst-%d33-126-nat-bounds
  (implies (smtp-cst-matchp cst "%d33-126")
           (and (<= 33 (smtp-cst-%d33-126-nat cst))
                (<= (smtp-cst-%d33-126-nat cst) 126)))
  :rule-classes :linear)

Theorem: smtp-cst-%d35-91-nat-bounds

(defthm smtp-cst-%d35-91-nat-bounds
  (implies (smtp-cst-matchp cst "%d35-91")
           (and (<= 35 (smtp-cst-%d35-91-nat cst))
                (<= (smtp-cst-%d35-91-nat cst) 91)))
  :rule-classes :linear)

Theorem: smtp-cst-%d42-91-nat-bounds

(defthm smtp-cst-%d42-91-nat-bounds
  (implies (smtp-cst-matchp cst "%d42-91")
           (and (<= 42 (smtp-cst-%d42-91-nat cst))
                (<= (smtp-cst-%d42-91-nat cst) 91)))
  :rule-classes :linear)

Theorem: smtp-cst-%d62-126-nat-bounds

(defthm smtp-cst-%d62-126-nat-bounds
  (implies (smtp-cst-matchp cst "%d62-126")
           (and (<= 62 (smtp-cst-%d62-126-nat cst))
                (<= (smtp-cst-%d62-126-nat cst) 126)))
  :rule-classes :linear)

Theorem: smtp-cst-%d65-73-nat-bounds

(defthm smtp-cst-%d65-73-nat-bounds
  (implies (smtp-cst-matchp cst "%d65-73")
           (and (<= 65 (smtp-cst-%d65-73-nat cst))
                (<= (smtp-cst-%d65-73-nat cst) 73)))
  :rule-classes :linear)

Theorem: smtp-cst-%d75-90-nat-bounds

(defthm smtp-cst-%d75-90-nat-bounds
  (implies (smtp-cst-matchp cst "%d75-90")
           (and (<= 75 (smtp-cst-%d75-90-nat cst))
                (<= (smtp-cst-%d75-90-nat cst) 90)))
  :rule-classes :linear)

Theorem: smtp-cst-%d93-126-nat-bounds

(defthm smtp-cst-%d93-126-nat-bounds
  (implies (smtp-cst-matchp cst "%d93-126")
           (and (<= 93 (smtp-cst-%d93-126-nat cst))
                (<= (smtp-cst-%d93-126-nat cst) 126)))
  :rule-classes :linear)

Theorem: smtp-cst-%d94-126-nat-bounds

(defthm smtp-cst-%d94-126-nat-bounds
  (implies (smtp-cst-matchp cst "%d94-126")
           (and (<= 94 (smtp-cst-%d94-126-nat cst))
                (<= (smtp-cst-%d94-126-nat cst) 126)))
  :rule-classes :linear)

Theorem: smtp-cst-%d97-105-nat-bounds

(defthm smtp-cst-%d97-105-nat-bounds
  (implies (smtp-cst-matchp cst "%d97-105")
           (and (<= 97 (smtp-cst-%d97-105-nat cst))
                (<= (smtp-cst-%d97-105-nat cst) 105)))
  :rule-classes :linear)

Theorem: smtp-cst-%d107-122-nat-bounds

(defthm smtp-cst-%d107-122-nat-bounds
  (implies (smtp-cst-matchp cst "%d107-122")
           (and (<= 107 (smtp-cst-%d107-122-nat cst))
                (<= (smtp-cst-%d107-122-nat cst) 122)))
  :rule-classes :linear)

Theorem: smtp-cst-%x21-7e-nat-bounds

(defthm smtp-cst-%x21-7e-nat-bounds
  (implies (smtp-cst-matchp cst "%x21-7E")
           (and (<= 33 (smtp-cst-%x21-7e-nat cst))
                (<= (smtp-cst-%x21-7e-nat cst) 126)))
  :rule-classes :linear)

Theorem: smtp-cst-%x30-35-nat-bounds

(defthm smtp-cst-%x30-35-nat-bounds
  (implies (smtp-cst-matchp cst "%x30-35")
           (and (<= 48 (smtp-cst-%x30-35-nat cst))
                (<= (smtp-cst-%x30-35-nat cst) 53)))
  :rule-classes :linear)

Theorem: smtp-cst-%x30-39-nat-bounds

(defthm smtp-cst-%x30-39-nat-bounds
  (implies (smtp-cst-matchp cst "%x30-39")
           (and (<= 48 (smtp-cst-%x30-39-nat cst))
                (<= (smtp-cst-%x30-39-nat cst) 57)))
  :rule-classes :linear)

Theorem: smtp-cst-%x32-35-nat-bounds

(defthm smtp-cst-%x32-35-nat-bounds
  (implies (smtp-cst-matchp cst "%x32-35")
           (and (<= 50 (smtp-cst-%x32-35-nat cst))
                (<= (smtp-cst-%x32-35-nat cst) 53)))
  :rule-classes :linear)

Theorem: smtp-cst-%x41-5a-nat-bounds

(defthm smtp-cst-%x41-5a-nat-bounds
  (implies (smtp-cst-matchp cst "%x41-5A")
           (and (<= 65 (smtp-cst-%x41-5a-nat cst))
                (<= (smtp-cst-%x41-5a-nat cst) 90)))
  :rule-classes :linear)

Theorem: smtp-cst-%x61-7a-nat-bounds

(defthm smtp-cst-%x61-7a-nat-bounds
  (implies (smtp-cst-matchp cst "%x61-7A")
           (and (<= 97 (smtp-cst-%x61-7a-nat cst))
                (<= (smtp-cst-%x61-7a-nat cst) 122)))
  :rule-classes :linear)

Theorem: smtp-cst-"!"-leafterm

(defthm |SMTP-CST-"!"-LEAFTERM|
  (implies (smtp-cst-matchp cst "\"!\"")
           (equal (tree-kind cst) :leafterm)))

Theorem: smtp-cst-"#"-leafterm

(defthm |SMTP-CST-"#"-LEAFTERM|
  (implies (smtp-cst-matchp cst "\"#\"")
           (equal (tree-kind cst) :leafterm)))

Theorem: smtp-cst-"$"-leafterm

(defthm |SMTP-CST-"$"-LEAFTERM|
  (implies (smtp-cst-matchp cst "\"$\"")
           (equal (tree-kind cst) :leafterm)))

Theorem: smtp-cst-"%"-leafterm

(defthm |SMTP-CST-"%"-LEAFTERM|
  (implies (smtp-cst-matchp cst "\"%\"")
           (equal (tree-kind cst) :leafterm)))

Theorem: smtp-cst-"&"-leafterm

(defthm |SMTP-CST-"&"-LEAFTERM|
  (implies (smtp-cst-matchp cst "\"&\"")
           (equal (tree-kind cst) :leafterm)))

Theorem: smtp-cst-"'"-leafterm

(defthm |SMTP-CST-"'"-LEAFTERM|
  (implies (smtp-cst-matchp cst "\"'\"")
           (equal (tree-kind cst) :leafterm)))

Theorem: smtp-cst-"("-leafterm

(defthm |SMTP-CST-"("-LEAFTERM|
  (implies (smtp-cst-matchp cst "\"(\"")
           (equal (tree-kind cst) :leafterm)))

Theorem: smtp-cst-")"-leafterm

(defthm |SMTP-CST-")"-LEAFTERM|
  (implies (smtp-cst-matchp cst "\")\"")
           (equal (tree-kind cst) :leafterm)))

Theorem: smtp-cst-"*"-leafterm

(defthm |SMTP-CST-"*"-LEAFTERM|
  (implies (smtp-cst-matchp cst "\"*\"")
           (equal (tree-kind cst) :leafterm)))

Theorem: smtp-cst-"+"-leafterm

(defthm |SMTP-CST-"+"-LEAFTERM|
  (implies (smtp-cst-matchp cst "\"+\"")
           (equal (tree-kind cst) :leafterm)))

Theorem: smtp-cst-","-leafterm

(defthm |SMTP-CST-","-LEAFTERM|
  (implies (smtp-cst-matchp cst "\",\"")
           (equal (tree-kind cst) :leafterm)))

Theorem: smtp-cst-"-"-leafterm

(defthm |SMTP-CST-"-"-LEAFTERM|
  (implies (smtp-cst-matchp cst "\"-\"")
           (equal (tree-kind cst) :leafterm)))

Theorem: smtp-cst-"."-leafterm

(defthm |SMTP-CST-"."-LEAFTERM|
  (implies (smtp-cst-matchp cst "\".\"")
           (equal (tree-kind cst) :leafterm)))

Theorem: smtp-cst-"/"-leafterm

(defthm |SMTP-CST-"/"-LEAFTERM|
  (implies (smtp-cst-matchp cst "\"/\"")
           (equal (tree-kind cst) :leafterm)))

Theorem: smtp-cst-"220"-leafterm

(defthm |SMTP-CST-"220"-LEAFTERM|
  (implies (smtp-cst-matchp cst "\"220\"")
           (equal (tree-kind cst) :leafterm)))

Theorem: smtp-cst-"220 "-leafterm

(defthm |SMTP-CST-"220 "-LEAFTERM|
  (implies (smtp-cst-matchp cst "\"220 \"")
           (equal (tree-kind cst) :leafterm)))

Theorem: smtp-cst-"220-"-leafterm

(defthm |SMTP-CST-"220-"-LEAFTERM|
  (implies (smtp-cst-matchp cst "\"220-\"")
           (equal (tree-kind cst) :leafterm)))

Theorem: smtp-cst-"250"-leafterm

(defthm |SMTP-CST-"250"-LEAFTERM|
  (implies (smtp-cst-matchp cst "\"250\"")
           (equal (tree-kind cst) :leafterm)))

Theorem: smtp-cst-"250-"-leafterm

(defthm |SMTP-CST-"250-"-LEAFTERM|
  (implies (smtp-cst-matchp cst "\"250-\"")
           (equal (tree-kind cst) :leafterm)))

Theorem: smtp-cst-":"-leafterm

(defthm |SMTP-CST-":"-LEAFTERM|
  (implies (smtp-cst-matchp cst "\":\"")
           (equal (tree-kind cst) :leafterm)))

Theorem: smtp-cst-"::"-leafterm

(defthm |SMTP-CST-"::"-LEAFTERM|
  (implies (smtp-cst-matchp cst "\"::\"")
           (equal (tree-kind cst) :leafterm)))

Theorem: smtp-cst-";"-leafterm

(defthm |SMTP-CST-";"-LEAFTERM|
  (implies (smtp-cst-matchp cst "\";\"")
           (equal (tree-kind cst) :leafterm)))

Theorem: smtp-cst-"<"-leafterm

(defthm |SMTP-CST-"<"-LEAFTERM|
  (implies (smtp-cst-matchp cst "\"<\"")
           (equal (tree-kind cst) :leafterm)))

Theorem: smtp-cst-"<>"-leafterm

(defthm |SMTP-CST-"<>"-LEAFTERM|
  (implies (smtp-cst-matchp cst "\"<>\"")
           (equal (tree-kind cst) :leafterm)))

Theorem: smtp-cst-"<postmaster>"-leafterm

(defthm |SMTP-CST-"<Postmaster>"-LEAFTERM|
  (implies (smtp-cst-matchp cst "\"<Postmaster>\"")
           (equal (tree-kind cst) :leafterm)))

Theorem: smtp-cst-"<postmaster@"-leafterm

(defthm |SMTP-CST-"<Postmaster@"-LEAFTERM|
  (implies (smtp-cst-matchp cst "\"<Postmaster@\"")
           (equal (tree-kind cst) :leafterm)))

Theorem: smtp-cst-"="-leafterm

(defthm |SMTP-CST-"="-LEAFTERM|
  (implies (smtp-cst-matchp cst "\"=\"")
           (equal (tree-kind cst) :leafterm)))

Theorem: smtp-cst-">"-leafterm

(defthm |SMTP-CST-">"-LEAFTERM|
  (implies (smtp-cst-matchp cst "\">\"")
           (equal (tree-kind cst) :leafterm)))

Theorem: smtp-cst-"?"-leafterm

(defthm |SMTP-CST-"?"-LEAFTERM|
  (implies (smtp-cst-matchp cst "\"?\"")
           (equal (tree-kind cst) :leafterm)))

Theorem: smtp-cst-"@"-leafterm

(defthm |SMTP-CST-"@"-LEAFTERM|
  (implies (smtp-cst-matchp cst "\"@\"")
           (equal (tree-kind cst) :leafterm)))

Theorem: smtp-cst-"a"-leafterm

(defthm |SMTP-CST-"A"-LEAFTERM|
  (implies (smtp-cst-matchp cst "\"A\"")
           (equal (tree-kind cst) :leafterm)))

Theorem: smtp-cst-"apr"-leafterm

(defthm |SMTP-CST-"Apr"-LEAFTERM|
  (implies (smtp-cst-matchp cst "\"Apr\"")
           (equal (tree-kind cst) :leafterm)))

Theorem: smtp-cst-"aug"-leafterm

(defthm |SMTP-CST-"Aug"-LEAFTERM|
  (implies (smtp-cst-matchp cst "\"Aug\"")
           (equal (tree-kind cst) :leafterm)))

Theorem: smtp-cst-"b"-leafterm

(defthm |SMTP-CST-"B"-LEAFTERM|
  (implies (smtp-cst-matchp cst "\"B\"")
           (equal (tree-kind cst) :leafterm)))

Theorem: smtp-cst-"by"-leafterm

(defthm |SMTP-CST-"BY"-LEAFTERM|
  (implies (smtp-cst-matchp cst "\"BY\"")
           (equal (tree-kind cst) :leafterm)))

Theorem: smtp-cst-"c"-leafterm

(defthm |SMTP-CST-"C"-LEAFTERM|
  (implies (smtp-cst-matchp cst "\"C\"")
           (equal (tree-kind cst) :leafterm)))

Theorem: smtp-cst-"cdt"-leafterm

(defthm |SMTP-CST-"CDT"-LEAFTERM|
  (implies (smtp-cst-matchp cst "\"CDT\"")
           (equal (tree-kind cst) :leafterm)))

Theorem: smtp-cst-"cst"-leafterm

(defthm |SMTP-CST-"CST"-LEAFTERM|
  (implies (smtp-cst-matchp cst "\"CST\"")
           (equal (tree-kind cst) :leafterm)))

Theorem: smtp-cst-"d"-leafterm

(defthm |SMTP-CST-"D"-LEAFTERM|
  (implies (smtp-cst-matchp cst "\"D\"")
           (equal (tree-kind cst) :leafterm)))

Theorem: smtp-cst-"data"-leafterm

(defthm |SMTP-CST-"DATA"-LEAFTERM|
  (implies (smtp-cst-matchp cst "\"DATA\"")
           (equal (tree-kind cst) :leafterm)))

Theorem: smtp-cst-"dec"-leafterm

(defthm |SMTP-CST-"Dec"-LEAFTERM|
  (implies (smtp-cst-matchp cst "\"Dec\"")
           (equal (tree-kind cst) :leafterm)))

Theorem: smtp-cst-"e"-leafterm

(defthm |SMTP-CST-"E"-LEAFTERM|
  (implies (smtp-cst-matchp cst "\"E\"")
           (equal (tree-kind cst) :leafterm)))

Theorem: smtp-cst-"edt"-leafterm

(defthm |SMTP-CST-"EDT"-LEAFTERM|
  (implies (smtp-cst-matchp cst "\"EDT\"")
           (equal (tree-kind cst) :leafterm)))

Theorem: smtp-cst-"ehlo"-leafterm

(defthm |SMTP-CST-"EHLO"-LEAFTERM|
  (implies (smtp-cst-matchp cst "\"EHLO\"")
           (equal (tree-kind cst) :leafterm)))

Theorem: smtp-cst-"esmtp"-leafterm

(defthm |SMTP-CST-"ESMTP"-LEAFTERM|
  (implies (smtp-cst-matchp cst "\"ESMTP\"")
           (equal (tree-kind cst) :leafterm)))

Theorem: smtp-cst-"est"-leafterm

(defthm |SMTP-CST-"EST"-LEAFTERM|
  (implies (smtp-cst-matchp cst "\"EST\"")
           (equal (tree-kind cst) :leafterm)))

Theorem: smtp-cst-"expn"-leafterm

(defthm |SMTP-CST-"EXPN"-LEAFTERM|
  (implies (smtp-cst-matchp cst "\"EXPN\"")
           (equal (tree-kind cst) :leafterm)))

Theorem: smtp-cst-"f"-leafterm

(defthm |SMTP-CST-"F"-LEAFTERM|
  (implies (smtp-cst-matchp cst "\"F\"")
           (equal (tree-kind cst) :leafterm)))

Theorem: smtp-cst-"for"-leafterm

(defthm |SMTP-CST-"FOR"-LEAFTERM|
  (implies (smtp-cst-matchp cst "\"FOR\"")
           (equal (tree-kind cst) :leafterm)))

Theorem: smtp-cst-"from"-leafterm

(defthm |SMTP-CST-"FROM"-LEAFTERM|
  (implies (smtp-cst-matchp cst "\"FROM\"")
           (equal (tree-kind cst) :leafterm)))

Theorem: smtp-cst-"feb"-leafterm

(defthm |SMTP-CST-"Feb"-LEAFTERM|
  (implies (smtp-cst-matchp cst "\"Feb\"")
           (equal (tree-kind cst) :leafterm)))

Theorem: smtp-cst-"fri"-leafterm

(defthm |SMTP-CST-"Fri"-LEAFTERM|
  (implies (smtp-cst-matchp cst "\"Fri\"")
           (equal (tree-kind cst) :leafterm)))

Theorem: smtp-cst-"gmt"-leafterm

(defthm |SMTP-CST-"GMT"-LEAFTERM|
  (implies (smtp-cst-matchp cst "\"GMT\"")
           (equal (tree-kind cst) :leafterm)))

Theorem: smtp-cst-"helo"-leafterm

(defthm |SMTP-CST-"HELO"-LEAFTERM|
  (implies (smtp-cst-matchp cst "\"HELO\"")
           (equal (tree-kind cst) :leafterm)))

Theorem: smtp-cst-"help"-leafterm

(defthm |SMTP-CST-"HELP"-LEAFTERM|
  (implies (smtp-cst-matchp cst "\"HELP\"")
           (equal (tree-kind cst) :leafterm)))

Theorem: smtp-cst-"id"-leafterm

(defthm |SMTP-CST-"ID"-LEAFTERM|
  (implies (smtp-cst-matchp cst "\"ID\"")
           (equal (tree-kind cst) :leafterm)))

Theorem: smtp-cst-"ipv6:"-leafterm

(defthm |SMTP-CST-"IPv6:"-LEAFTERM|
  (implies (smtp-cst-matchp cst "\"IPv6:\"")
           (equal (tree-kind cst) :leafterm)))

Theorem: smtp-cst-"jan"-leafterm

(defthm |SMTP-CST-"Jan"-LEAFTERM|
  (implies (smtp-cst-matchp cst "\"Jan\"")
           (equal (tree-kind cst) :leafterm)))

Theorem: smtp-cst-"jul"-leafterm

(defthm |SMTP-CST-"Jul"-LEAFTERM|
  (implies (smtp-cst-matchp cst "\"Jul\"")
           (equal (tree-kind cst) :leafterm)))

Theorem: smtp-cst-"jun"-leafterm

(defthm |SMTP-CST-"Jun"-LEAFTERM|
  (implies (smtp-cst-matchp cst "\"Jun\"")
           (equal (tree-kind cst) :leafterm)))

Theorem: smtp-cst-"mail from:"-leafterm

(defthm |SMTP-CST-"MAIL FROM:"-LEAFTERM|
  (implies (smtp-cst-matchp cst "\"MAIL FROM:\"")
           (equal (tree-kind cst) :leafterm)))

Theorem: smtp-cst-"mdt"-leafterm

(defthm |SMTP-CST-"MDT"-LEAFTERM|
  (implies (smtp-cst-matchp cst "\"MDT\"")
           (equal (tree-kind cst) :leafterm)))

Theorem: smtp-cst-"mst"-leafterm

(defthm |SMTP-CST-"MST"-LEAFTERM|
  (implies (smtp-cst-matchp cst "\"MST\"")
           (equal (tree-kind cst) :leafterm)))

Theorem: smtp-cst-"mar"-leafterm

(defthm |SMTP-CST-"Mar"-LEAFTERM|
  (implies (smtp-cst-matchp cst "\"Mar\"")
           (equal (tree-kind cst) :leafterm)))

Theorem: smtp-cst-"may"-leafterm

(defthm |SMTP-CST-"May"-LEAFTERM|
  (implies (smtp-cst-matchp cst "\"May\"")
           (equal (tree-kind cst) :leafterm)))

Theorem: smtp-cst-"mon"-leafterm

(defthm |SMTP-CST-"Mon"-LEAFTERM|
  (implies (smtp-cst-matchp cst "\"Mon\"")
           (equal (tree-kind cst) :leafterm)))

Theorem: smtp-cst-"noop"-leafterm

(defthm |SMTP-CST-"NOOP"-LEAFTERM|
  (implies (smtp-cst-matchp cst "\"NOOP\"")
           (equal (tree-kind cst) :leafterm)))

Theorem: smtp-cst-"nov"-leafterm

(defthm |SMTP-CST-"Nov"-LEAFTERM|
  (implies (smtp-cst-matchp cst "\"Nov\"")
           (equal (tree-kind cst) :leafterm)))

Theorem: smtp-cst-"oct"-leafterm

(defthm |SMTP-CST-"Oct"-LEAFTERM|
  (implies (smtp-cst-matchp cst "\"Oct\"")
           (equal (tree-kind cst) :leafterm)))

Theorem: smtp-cst-"pdt"-leafterm

(defthm |SMTP-CST-"PDT"-LEAFTERM|
  (implies (smtp-cst-matchp cst "\"PDT\"")
           (equal (tree-kind cst) :leafterm)))

Theorem: smtp-cst-"pst"-leafterm

(defthm |SMTP-CST-"PST"-LEAFTERM|
  (implies (smtp-cst-matchp cst "\"PST\"")
           (equal (tree-kind cst) :leafterm)))

Theorem: smtp-cst-"quit"-leafterm

(defthm |SMTP-CST-"QUIT"-LEAFTERM|
  (implies (smtp-cst-matchp cst "\"QUIT\"")
           (equal (tree-kind cst) :leafterm)))

Theorem: smtp-cst-"rcpt to:"-leafterm

(defthm |SMTP-CST-"RCPT TO:"-LEAFTERM|
  (implies (smtp-cst-matchp cst "\"RCPT TO:\"")
           (equal (tree-kind cst) :leafterm)))

Theorem: smtp-cst-"rset"-leafterm

(defthm |SMTP-CST-"RSET"-LEAFTERM|
  (implies (smtp-cst-matchp cst "\"RSET\"")
           (equal (tree-kind cst) :leafterm)))

Theorem: smtp-cst-"received:"-leafterm

(defthm |SMTP-CST-"Received:"-LEAFTERM|
  (implies (smtp-cst-matchp cst "\"Received:\"")
           (equal (tree-kind cst) :leafterm)))

Theorem: smtp-cst-"return-path:"-leafterm

(defthm |SMTP-CST-"Return-Path:"-LEAFTERM|
  (implies (smtp-cst-matchp cst "\"Return-Path:\"")
           (equal (tree-kind cst) :leafterm)))

Theorem: smtp-cst-"smtp"-leafterm

(defthm |SMTP-CST-"SMTP"-LEAFTERM|
  (implies (smtp-cst-matchp cst "\"SMTP\"")
           (equal (tree-kind cst) :leafterm)))

Theorem: smtp-cst-"sat"-leafterm

(defthm |SMTP-CST-"Sat"-LEAFTERM|
  (implies (smtp-cst-matchp cst "\"Sat\"")
           (equal (tree-kind cst) :leafterm)))

Theorem: smtp-cst-"sep"-leafterm

(defthm |SMTP-CST-"Sep"-LEAFTERM|
  (implies (smtp-cst-matchp cst "\"Sep\"")
           (equal (tree-kind cst) :leafterm)))

Theorem: smtp-cst-"sun"-leafterm

(defthm |SMTP-CST-"Sun"-LEAFTERM|
  (implies (smtp-cst-matchp cst "\"Sun\"")
           (equal (tree-kind cst) :leafterm)))

Theorem: smtp-cst-"tcp"-leafterm

(defthm |SMTP-CST-"TCP"-LEAFTERM|
  (implies (smtp-cst-matchp cst "\"TCP\"")
           (equal (tree-kind cst) :leafterm)))

Theorem: smtp-cst-"thu"-leafterm

(defthm |SMTP-CST-"Thu"-LEAFTERM|
  (implies (smtp-cst-matchp cst "\"Thu\"")
           (equal (tree-kind cst) :leafterm)))

Theorem: smtp-cst-"tue"-leafterm

(defthm |SMTP-CST-"Tue"-LEAFTERM|
  (implies (smtp-cst-matchp cst "\"Tue\"")
           (equal (tree-kind cst) :leafterm)))

Theorem: smtp-cst-"ut"-leafterm

(defthm |SMTP-CST-"UT"-LEAFTERM|
  (implies (smtp-cst-matchp cst "\"UT\"")
           (equal (tree-kind cst) :leafterm)))

Theorem: smtp-cst-"via"-leafterm

(defthm |SMTP-CST-"VIA"-LEAFTERM|
  (implies (smtp-cst-matchp cst "\"VIA\"")
           (equal (tree-kind cst) :leafterm)))

Theorem: smtp-cst-"vrfy"-leafterm

(defthm |SMTP-CST-"VRFY"-LEAFTERM|
  (implies (smtp-cst-matchp cst "\"VRFY\"")
           (equal (tree-kind cst) :leafterm)))

Theorem: smtp-cst-"with"-leafterm

(defthm |SMTP-CST-"WITH"-LEAFTERM|
  (implies (smtp-cst-matchp cst "\"WITH\"")
           (equal (tree-kind cst) :leafterm)))

Theorem: smtp-cst-"wed"-leafterm

(defthm |SMTP-CST-"Wed"-LEAFTERM|
  (implies (smtp-cst-matchp cst "\"Wed\"")
           (equal (tree-kind cst) :leafterm)))

Theorem: smtp-cst-"["-leafterm

(defthm |SMTP-CST-"["-LEAFTERM|
  (implies (smtp-cst-matchp cst "\"[\"")
           (equal (tree-kind cst) :leafterm)))

Theorem: smtp-cst-"\"-leafterm

(defthm |SMTP-CST-"\\"-LEAFTERM|
  (implies (smtp-cst-matchp cst "\"\\\"")
           (equal (tree-kind cst) :leafterm)))

Theorem: smtp-cst-"]"-leafterm

(defthm |SMTP-CST-"]"-LEAFTERM|
  (implies (smtp-cst-matchp cst "\"]\"")
           (equal (tree-kind cst) :leafterm)))

Theorem: smtp-cst-"^"-leafterm

(defthm |SMTP-CST-"^"-LEAFTERM|
  (implies (smtp-cst-matchp cst "\"^\"")
           (equal (tree-kind cst) :leafterm)))

Theorem: smtp-cst-"_"-leafterm

(defthm |SMTP-CST-"_"-LEAFTERM|
  (implies (smtp-cst-matchp cst "\"_\"")
           (equal (tree-kind cst) :leafterm)))

Theorem: smtp-cst-"`"-leafterm

(defthm |SMTP-CST-"`"-LEAFTERM|
  (implies (smtp-cst-matchp cst "\"`\"")
           (equal (tree-kind cst) :leafterm)))

Theorem: smtp-cst-"{"-leafterm

(defthm |SMTP-CST-"{"-LEAFTERM|
  (implies (smtp-cst-matchp cst "\"{\"")
           (equal (tree-kind cst) :leafterm)))

Theorem: smtp-cst-"|"-leafterm

(defthm |SMTP-CST-"\|"-LEAFTERM|
  (implies (smtp-cst-matchp cst "\"|\"")
           (equal (tree-kind cst) :leafterm)))

Theorem: smtp-cst-"}"-leafterm

(defthm |SMTP-CST-"}"-LEAFTERM|
  (implies (smtp-cst-matchp cst "\"}\"")
           (equal (tree-kind cst) :leafterm)))

Theorem: smtp-cst-"~"-leafterm

(defthm |SMTP-CST-"~"-LEAFTERM|
  (implies (smtp-cst-matchp cst "\"~\"")
           (equal (tree-kind cst) :leafterm)))

Theorem: smtp-cst-ehlo-nonleaf

(defthm smtp-cst-ehlo-nonleaf
  (implies (smtp-cst-matchp cst "ehlo")
           (equal (tree-kind cst) :nonleaf)))

Theorem: smtp-cst-helo-nonleaf

(defthm smtp-cst-helo-nonleaf
  (implies (smtp-cst-matchp cst "helo")
           (equal (tree-kind cst) :nonleaf)))

Theorem: smtp-cst-ehlo-ok-rsp-nonleaf

(defthm smtp-cst-ehlo-ok-rsp-nonleaf
  (implies (smtp-cst-matchp cst "ehlo-ok-rsp")
           (equal (tree-kind cst) :nonleaf)))

Theorem: smtp-cst-ehlo-greet-nonleaf

(defthm smtp-cst-ehlo-greet-nonleaf
  (implies (smtp-cst-matchp cst "ehlo-greet")
           (equal (tree-kind cst) :nonleaf)))

Theorem: smtp-cst-ehlo-line-nonleaf

(defthm smtp-cst-ehlo-line-nonleaf
  (implies (smtp-cst-matchp cst "ehlo-line")
           (equal (tree-kind cst) :nonleaf)))

Theorem: smtp-cst-ehlo-keyword-nonleaf

(defthm smtp-cst-ehlo-keyword-nonleaf
  (implies (smtp-cst-matchp cst "ehlo-keyword")
           (equal (tree-kind cst) :nonleaf)))

Theorem: smtp-cst-ehlo-param-nonleaf

(defthm smtp-cst-ehlo-param-nonleaf
  (implies (smtp-cst-matchp cst "ehlo-param")
           (equal (tree-kind cst) :nonleaf)))

Theorem: smtp-cst-mail-nonleaf

(defthm smtp-cst-mail-nonleaf
  (implies (smtp-cst-matchp cst "mail")
           (equal (tree-kind cst) :nonleaf)))

Theorem: smtp-cst-rcpt-nonleaf

(defthm smtp-cst-rcpt-nonleaf
  (implies (smtp-cst-matchp cst "rcpt")
           (equal (tree-kind cst) :nonleaf)))

Theorem: smtp-cst-data-nonleaf

(defthm smtp-cst-data-nonleaf
  (implies (smtp-cst-matchp cst "data")
           (equal (tree-kind cst) :nonleaf)))

Theorem: smtp-cst-rset-nonleaf

(defthm smtp-cst-rset-nonleaf
  (implies (smtp-cst-matchp cst "rset")
           (equal (tree-kind cst) :nonleaf)))

Theorem: smtp-cst-vrfy-nonleaf

(defthm smtp-cst-vrfy-nonleaf
  (implies (smtp-cst-matchp cst "vrfy")
           (equal (tree-kind cst) :nonleaf)))

Theorem: smtp-cst-expn-nonleaf

(defthm smtp-cst-expn-nonleaf
  (implies (smtp-cst-matchp cst "expn")
           (equal (tree-kind cst) :nonleaf)))

Theorem: smtp-cst-help-nonleaf

(defthm smtp-cst-help-nonleaf
  (implies (smtp-cst-matchp cst "help")
           (equal (tree-kind cst) :nonleaf)))

Theorem: smtp-cst-noop-nonleaf

(defthm smtp-cst-noop-nonleaf
  (implies (smtp-cst-matchp cst "noop")
           (equal (tree-kind cst) :nonleaf)))

Theorem: smtp-cst-quit-nonleaf

(defthm smtp-cst-quit-nonleaf
  (implies (smtp-cst-matchp cst "quit")
           (equal (tree-kind cst) :nonleaf)))

Theorem: smtp-cst-reverse-path-nonleaf

(defthm smtp-cst-reverse-path-nonleaf
  (implies (smtp-cst-matchp cst "reverse-path")
           (equal (tree-kind cst) :nonleaf)))

Theorem: smtp-cst-forward-path-nonleaf

(defthm smtp-cst-forward-path-nonleaf
  (implies (smtp-cst-matchp cst "forward-path")
           (equal (tree-kind cst) :nonleaf)))

Theorem: smtp-cst-path-nonleaf

(defthm smtp-cst-path-nonleaf
  (implies (smtp-cst-matchp cst "path")
           (equal (tree-kind cst) :nonleaf)))

Theorem: smtp-cst-a-d-l-nonleaf

(defthm smtp-cst-a-d-l-nonleaf
  (implies (smtp-cst-matchp cst "a-d-l")
           (equal (tree-kind cst) :nonleaf)))

Theorem: smtp-cst-at-domain-nonleaf

(defthm smtp-cst-at-domain-nonleaf
  (implies (smtp-cst-matchp cst "at-domain")
           (equal (tree-kind cst) :nonleaf)))

Theorem: smtp-cst-mail-parameters-nonleaf

(defthm smtp-cst-mail-parameters-nonleaf
  (implies (smtp-cst-matchp cst "mail-parameters")
           (equal (tree-kind cst) :nonleaf)))

Theorem: smtp-cst-rcpt-parameters-nonleaf

(defthm smtp-cst-rcpt-parameters-nonleaf
  (implies (smtp-cst-matchp cst "rcpt-parameters")
           (equal (tree-kind cst) :nonleaf)))

Theorem: smtp-cst-esmtp-param-nonleaf

(defthm smtp-cst-esmtp-param-nonleaf
  (implies (smtp-cst-matchp cst "esmtp-param")
           (equal (tree-kind cst) :nonleaf)))

Theorem: smtp-cst-esmtp-keyword-nonleaf

(defthm smtp-cst-esmtp-keyword-nonleaf
  (implies (smtp-cst-matchp cst "esmtp-keyword")
           (equal (tree-kind cst) :nonleaf)))

Theorem: smtp-cst-esmtp-value-nonleaf

(defthm smtp-cst-esmtp-value-nonleaf
  (implies (smtp-cst-matchp cst "esmtp-value")
           (equal (tree-kind cst) :nonleaf)))

Theorem: smtp-cst-keyword-nonleaf

(defthm smtp-cst-keyword-nonleaf
  (implies (smtp-cst-matchp cst "keyword")
           (equal (tree-kind cst) :nonleaf)))

Theorem: smtp-cst-argument-nonleaf

(defthm smtp-cst-argument-nonleaf
  (implies (smtp-cst-matchp cst "argument")
           (equal (tree-kind cst) :nonleaf)))

Theorem: smtp-cst-domain-nonleaf

(defthm smtp-cst-domain-nonleaf
  (implies (smtp-cst-matchp cst "domain")
           (equal (tree-kind cst) :nonleaf)))

Theorem: smtp-cst-sub-domain-nonleaf

(defthm smtp-cst-sub-domain-nonleaf
  (implies (smtp-cst-matchp cst "sub-domain")
           (equal (tree-kind cst) :nonleaf)))

Theorem: smtp-cst-let-dig-nonleaf

(defthm smtp-cst-let-dig-nonleaf
  (implies (smtp-cst-matchp cst "let-dig")
           (equal (tree-kind cst) :nonleaf)))

Theorem: smtp-cst-ldh-str-nonleaf

(defthm smtp-cst-ldh-str-nonleaf
  (implies (smtp-cst-matchp cst "ldh-str")
           (equal (tree-kind cst) :nonleaf)))

Theorem: smtp-cst-address-literal-nonleaf

(defthm smtp-cst-address-literal-nonleaf
  (implies (smtp-cst-matchp cst "address-literal")
           (equal (tree-kind cst) :nonleaf)))

Theorem: smtp-cst-mailbox-nonleaf

(defthm smtp-cst-mailbox-nonleaf
  (implies (smtp-cst-matchp cst "mailbox")
           (equal (tree-kind cst) :nonleaf)))

Theorem: smtp-cst-local-part-nonleaf

(defthm smtp-cst-local-part-nonleaf
  (implies (smtp-cst-matchp cst "local-part")
           (equal (tree-kind cst) :nonleaf)))

Theorem: smtp-cst-dot-string-nonleaf

(defthm smtp-cst-dot-string-nonleaf
  (implies (smtp-cst-matchp cst "dot-string")
           (equal (tree-kind cst) :nonleaf)))

Theorem: smtp-cst-atom-nonleaf

(defthm smtp-cst-atom-nonleaf
  (implies (smtp-cst-matchp cst "atom")
           (equal (tree-kind cst) :nonleaf)))

Theorem: smtp-cst-quoted-string-nonleaf

(defthm smtp-cst-quoted-string-nonleaf
  (implies (smtp-cst-matchp cst "quoted-string")
           (equal (tree-kind cst) :nonleaf)))

Theorem: smtp-cst-qcontentsmtp-nonleaf

(defthm smtp-cst-qcontentsmtp-nonleaf
  (implies (smtp-cst-matchp cst "qcontentsmtp")
           (equal (tree-kind cst) :nonleaf)))

Theorem: smtp-cst-quoted-pairsmtp-nonleaf

(defthm smtp-cst-quoted-pairsmtp-nonleaf
  (implies (smtp-cst-matchp cst "quoted-pairsmtp")
           (equal (tree-kind cst) :nonleaf)))

Theorem: smtp-cst-qtextsmtp-nonleaf

(defthm smtp-cst-qtextsmtp-nonleaf
  (implies (smtp-cst-matchp cst "qtextsmtp")
           (equal (tree-kind cst) :nonleaf)))

Theorem: smtp-cst-string-nonleaf

(defthm smtp-cst-string-nonleaf
  (implies (smtp-cst-matchp cst "string")
           (equal (tree-kind cst) :nonleaf)))

Theorem: smtp-cst-ipv4-address-literal-nonleaf

(defthm smtp-cst-ipv4-address-literal-nonleaf
  (implies (smtp-cst-matchp cst "ipv4-address-literal")
           (equal (tree-kind cst) :nonleaf)))

Theorem: smtp-cst-ipv6-address-literal-nonleaf

(defthm smtp-cst-ipv6-address-literal-nonleaf
  (implies (smtp-cst-matchp cst "ipv6-address-literal")
           (equal (tree-kind cst) :nonleaf)))

Theorem: smtp-cst-general-address-literal-nonleaf

(defthm smtp-cst-general-address-literal-nonleaf
  (implies (smtp-cst-matchp cst "general-address-literal")
           (equal (tree-kind cst) :nonleaf)))

Theorem: smtp-cst-standardized-tag-nonleaf

(defthm smtp-cst-standardized-tag-nonleaf
  (implies (smtp-cst-matchp cst "standardized-tag")
           (equal (tree-kind cst) :nonleaf)))

Theorem: smtp-cst-dcontent-nonleaf

(defthm smtp-cst-dcontent-nonleaf
  (implies (smtp-cst-matchp cst "dcontent")
           (equal (tree-kind cst) :nonleaf)))

Theorem: smtp-cst-snum-nonleaf

(defthm smtp-cst-snum-nonleaf
  (implies (smtp-cst-matchp cst "snum")
           (equal (tree-kind cst) :nonleaf)))

Theorem: smtp-cst-ipv6-addr-nonleaf

(defthm smtp-cst-ipv6-addr-nonleaf
  (implies (smtp-cst-matchp cst "ipv6-addr")
           (equal (tree-kind cst) :nonleaf)))

Theorem: smtp-cst-ipv6-hex-nonleaf

(defthm smtp-cst-ipv6-hex-nonleaf
  (implies (smtp-cst-matchp cst "ipv6-hex")
           (equal (tree-kind cst) :nonleaf)))

Theorem: smtp-cst-ipv6-full-nonleaf

(defthm smtp-cst-ipv6-full-nonleaf
  (implies (smtp-cst-matchp cst "ipv6-full")
           (equal (tree-kind cst) :nonleaf)))

Theorem: smtp-cst-ipv6-comp-nonleaf

(defthm smtp-cst-ipv6-comp-nonleaf
  (implies (smtp-cst-matchp cst "ipv6-comp")
           (equal (tree-kind cst) :nonleaf)))

Theorem: smtp-cst-ipv6v4-full-nonleaf

(defthm smtp-cst-ipv6v4-full-nonleaf
  (implies (smtp-cst-matchp cst "ipv6v4-full")
           (equal (tree-kind cst) :nonleaf)))

Theorem: smtp-cst-ipv6v4-comp-nonleaf

(defthm smtp-cst-ipv6v4-comp-nonleaf
  (implies (smtp-cst-matchp cst "ipv6v4-comp")
           (equal (tree-kind cst) :nonleaf)))

Theorem: smtp-cst-greeting-nonleaf

(defthm smtp-cst-greeting-nonleaf
  (implies (smtp-cst-matchp cst "greeting")
           (equal (tree-kind cst) :nonleaf)))

Theorem: smtp-cst-textstring-nonleaf

(defthm smtp-cst-textstring-nonleaf
  (implies (smtp-cst-matchp cst "textstring")
           (equal (tree-kind cst) :nonleaf)))

Theorem: smtp-cst-reply-line-nonleaf

(defthm smtp-cst-reply-line-nonleaf
  (implies (smtp-cst-matchp cst "reply-line")
           (equal (tree-kind cst) :nonleaf)))

Theorem: smtp-cst-reply-code-nonleaf

(defthm smtp-cst-reply-code-nonleaf
  (implies (smtp-cst-matchp cst "reply-code")
           (equal (tree-kind cst) :nonleaf)))

Theorem: smtp-cst-return-path-line-nonleaf

(defthm smtp-cst-return-path-line-nonleaf
  (implies (smtp-cst-matchp cst "return-path-line")
           (equal (tree-kind cst) :nonleaf)))

Theorem: smtp-cst-time-stamp-line-nonleaf

(defthm smtp-cst-time-stamp-line-nonleaf
  (implies (smtp-cst-matchp cst "time-stamp-line")
           (equal (tree-kind cst) :nonleaf)))

Theorem: smtp-cst-stamp-nonleaf

(defthm smtp-cst-stamp-nonleaf
  (implies (smtp-cst-matchp cst "stamp")
           (equal (tree-kind cst) :nonleaf)))

Theorem: smtp-cst-from-domain-nonleaf

(defthm smtp-cst-from-domain-nonleaf
  (implies (smtp-cst-matchp cst "from-domain")
           (equal (tree-kind cst) :nonleaf)))

Theorem: smtp-cst-by-domain-nonleaf

(defthm smtp-cst-by-domain-nonleaf
  (implies (smtp-cst-matchp cst "by-domain")
           (equal (tree-kind cst) :nonleaf)))

Theorem: smtp-cst-extended-domain-nonleaf

(defthm smtp-cst-extended-domain-nonleaf
  (implies (smtp-cst-matchp cst "extended-domain")
           (equal (tree-kind cst) :nonleaf)))

Theorem: smtp-cst-tcp-info-nonleaf

(defthm smtp-cst-tcp-info-nonleaf
  (implies (smtp-cst-matchp cst "tcp-info")
           (equal (tree-kind cst) :nonleaf)))

Theorem: smtp-cst-opt-info-nonleaf

(defthm smtp-cst-opt-info-nonleaf
  (implies (smtp-cst-matchp cst "opt-info")
           (equal (tree-kind cst) :nonleaf)))

Theorem: smtp-cst-via-nonleaf

(defthm smtp-cst-via-nonleaf
  (implies (smtp-cst-matchp cst "via")
           (equal (tree-kind cst) :nonleaf)))

Theorem: smtp-cst-with-nonleaf

(defthm smtp-cst-with-nonleaf
  (implies (smtp-cst-matchp cst "with")
           (equal (tree-kind cst) :nonleaf)))

Theorem: smtp-cst-id-nonleaf

(defthm smtp-cst-id-nonleaf
  (implies (smtp-cst-matchp cst "id")
           (equal (tree-kind cst) :nonleaf)))

Theorem: smtp-cst-for-nonleaf

(defthm smtp-cst-for-nonleaf
  (implies (smtp-cst-matchp cst "for")
           (equal (tree-kind cst) :nonleaf)))

Theorem: smtp-cst-additional-registered-clauses-nonleaf

(defthm smtp-cst-additional-registered-clauses-nonleaf
  (implies (smtp-cst-matchp cst "additional-registered-clauses")
           (equal (tree-kind cst) :nonleaf)))

Theorem: smtp-cst-link-nonleaf

(defthm smtp-cst-link-nonleaf
  (implies (smtp-cst-matchp cst "link")
           (equal (tree-kind cst) :nonleaf)))

Theorem: smtp-cst-addtl-link-nonleaf

(defthm smtp-cst-addtl-link-nonleaf
  (implies (smtp-cst-matchp cst "addtl-link")
           (equal (tree-kind cst) :nonleaf)))

Theorem: smtp-cst-protocol-nonleaf

(defthm smtp-cst-protocol-nonleaf
  (implies (smtp-cst-matchp cst "protocol")
           (equal (tree-kind cst) :nonleaf)))

Theorem: smtp-cst-attdl-protocol-nonleaf

(defthm smtp-cst-attdl-protocol-nonleaf
  (implies (smtp-cst-matchp cst "attdl-protocol")
           (equal (tree-kind cst) :nonleaf)))

Theorem: smtp-cst-atext-nonleaf

(defthm smtp-cst-atext-nonleaf
  (implies (smtp-cst-matchp cst "atext")
           (equal (tree-kind cst) :nonleaf)))

Theorem: smtp-cst-cfws-nonleaf

(defthm smtp-cst-cfws-nonleaf
  (implies (smtp-cst-matchp cst "cfws")
           (equal (tree-kind cst) :nonleaf)))

Theorem: smtp-cst-comment-nonleaf

(defthm smtp-cst-comment-nonleaf
  (implies (smtp-cst-matchp cst "comment")
           (equal (tree-kind cst) :nonleaf)))

Theorem: smtp-cst-ccontent-nonleaf

(defthm smtp-cst-ccontent-nonleaf
  (implies (smtp-cst-matchp cst "ccontent")
           (equal (tree-kind cst) :nonleaf)))

Theorem: smtp-cst-ctext-nonleaf

(defthm smtp-cst-ctext-nonleaf
  (implies (smtp-cst-matchp cst "ctext")
           (equal (tree-kind cst) :nonleaf)))

Theorem: smtp-cst-date-time-nonleaf

(defthm smtp-cst-date-time-nonleaf
  (implies (smtp-cst-matchp cst "date-time")
           (equal (tree-kind cst) :nonleaf)))

Theorem: smtp-cst-date-nonleaf

(defthm smtp-cst-date-nonleaf
  (implies (smtp-cst-matchp cst "date")
           (equal (tree-kind cst) :nonleaf)))

Theorem: smtp-cst-day-nonleaf

(defthm smtp-cst-day-nonleaf
  (implies (smtp-cst-matchp cst "day")
           (equal (tree-kind cst) :nonleaf)))

Theorem: smtp-cst-day-of-week-nonleaf

(defthm smtp-cst-day-of-week-nonleaf
  (implies (smtp-cst-matchp cst "day-of-week")
           (equal (tree-kind cst) :nonleaf)))

Theorem: smtp-cst-day-name-nonleaf

(defthm smtp-cst-day-name-nonleaf
  (implies (smtp-cst-matchp cst "day-name")
           (equal (tree-kind cst) :nonleaf)))

Theorem: smtp-cst-fws-nonleaf

(defthm smtp-cst-fws-nonleaf
  (implies (smtp-cst-matchp cst "fws")
           (equal (tree-kind cst) :nonleaf)))

Theorem: smtp-cst-month-nonleaf

(defthm smtp-cst-month-nonleaf
  (implies (smtp-cst-matchp cst "month")
           (equal (tree-kind cst) :nonleaf)))

Theorem: smtp-cst-msg-id-nonleaf

(defthm smtp-cst-msg-id-nonleaf
  (implies (smtp-cst-matchp cst "msg-id")
           (equal (tree-kind cst) :nonleaf)))

Theorem: smtp-cst-id-left-nonleaf

(defthm smtp-cst-id-left-nonleaf
  (implies (smtp-cst-matchp cst "id-left")
           (equal (tree-kind cst) :nonleaf)))

Theorem: smtp-cst-dot-atom-text-nonleaf

(defthm smtp-cst-dot-atom-text-nonleaf
  (implies (smtp-cst-matchp cst "dot-atom-text")
           (equal (tree-kind cst) :nonleaf)))

Theorem: smtp-cst-id-right-nonleaf

(defthm smtp-cst-id-right-nonleaf
  (implies (smtp-cst-matchp cst "id-right")
           (equal (tree-kind cst) :nonleaf)))

Theorem: smtp-cst-no-fold-literal-nonleaf

(defthm smtp-cst-no-fold-literal-nonleaf
  (implies (smtp-cst-matchp cst "no-fold-literal")
           (equal (tree-kind cst) :nonleaf)))

Theorem: smtp-cst-dtext-nonleaf

(defthm smtp-cst-dtext-nonleaf
  (implies (smtp-cst-matchp cst "dtext")
           (equal (tree-kind cst) :nonleaf)))

Theorem: smtp-cst-obs-ctext-nonleaf

(defthm smtp-cst-obs-ctext-nonleaf
  (implies (smtp-cst-matchp cst "obs-ctext")
           (equal (tree-kind cst) :nonleaf)))

Theorem: smtp-cst-obs-day-nonleaf

(defthm smtp-cst-obs-day-nonleaf
  (implies (smtp-cst-matchp cst "obs-day")
           (equal (tree-kind cst) :nonleaf)))

Theorem: smtp-cst-obs-day-of-week-nonleaf

(defthm smtp-cst-obs-day-of-week-nonleaf
  (implies (smtp-cst-matchp cst "obs-day-of-week")
           (equal (tree-kind cst) :nonleaf)))

Theorem: smtp-cst-obs-dtext-nonleaf

(defthm smtp-cst-obs-dtext-nonleaf
  (implies (smtp-cst-matchp cst "obs-dtext")
           (equal (tree-kind cst) :nonleaf)))

Theorem: smtp-cst-obs-fws-nonleaf

(defthm smtp-cst-obs-fws-nonleaf
  (implies (smtp-cst-matchp cst "obs-fws")
           (equal (tree-kind cst) :nonleaf)))

Theorem: smtp-cst-obs-id-left-nonleaf

(defthm smtp-cst-obs-id-left-nonleaf
  (implies (smtp-cst-matchp cst "obs-id-left")
           (equal (tree-kind cst) :nonleaf)))

Theorem: smtp-cst-imf-local-part-nonleaf

(defthm smtp-cst-imf-local-part-nonleaf
  (implies (smtp-cst-matchp cst "imf-local-part")
           (equal (tree-kind cst) :nonleaf)))

Theorem: smtp-cst-dot-atom-nonleaf

(defthm smtp-cst-dot-atom-nonleaf
  (implies (smtp-cst-matchp cst "dot-atom")
           (equal (tree-kind cst) :nonleaf)))

Theorem: smtp-cst-imf-quoted-string-nonleaf

(defthm smtp-cst-imf-quoted-string-nonleaf
  (implies (smtp-cst-matchp cst "imf-quoted-string")
           (equal (tree-kind cst) :nonleaf)))

Theorem: smtp-cst-obs-id-right-nonleaf

(defthm smtp-cst-obs-id-right-nonleaf
  (implies (smtp-cst-matchp cst "obs-id-right")
           (equal (tree-kind cst) :nonleaf)))

Theorem: smtp-cst-imf-domain-nonleaf

(defthm smtp-cst-imf-domain-nonleaf
  (implies (smtp-cst-matchp cst "imf-domain")
           (equal (tree-kind cst) :nonleaf)))

Theorem: smtp-cst-domain-literal-nonleaf

(defthm smtp-cst-domain-literal-nonleaf
  (implies (smtp-cst-matchp cst "domain-literal")
           (equal (tree-kind cst) :nonleaf)))

Theorem: smtp-cst-obs-domain-nonleaf

(defthm smtp-cst-obs-domain-nonleaf
  (implies (smtp-cst-matchp cst "obs-domain")
           (equal (tree-kind cst) :nonleaf)))

Theorem: smtp-cst-imf-atom-nonleaf

(defthm smtp-cst-imf-atom-nonleaf
  (implies (smtp-cst-matchp cst "imf-atom")
           (equal (tree-kind cst) :nonleaf)))

Theorem: smtp-cst-obs-local-part-nonleaf

(defthm smtp-cst-obs-local-part-nonleaf
  (implies (smtp-cst-matchp cst "obs-local-part")
           (equal (tree-kind cst) :nonleaf)))

Theorem: smtp-cst-obs-no-ws-ctl-nonleaf

(defthm smtp-cst-obs-no-ws-ctl-nonleaf
  (implies (smtp-cst-matchp cst "obs-no-ws-ctl")
           (equal (tree-kind cst) :nonleaf)))

Theorem: smtp-cst-qcontent-nonleaf

(defthm smtp-cst-qcontent-nonleaf
  (implies (smtp-cst-matchp cst "qcontent")
           (equal (tree-kind cst) :nonleaf)))

Theorem: smtp-cst-qtext-nonleaf

(defthm smtp-cst-qtext-nonleaf
  (implies (smtp-cst-matchp cst "qtext")
           (equal (tree-kind cst) :nonleaf)))

Theorem: smtp-cst-obs-qtext-nonleaf

(defthm smtp-cst-obs-qtext-nonleaf
  (implies (smtp-cst-matchp cst "obs-qtext")
           (equal (tree-kind cst) :nonleaf)))

Theorem: smtp-cst-quoted-pair-nonleaf

(defthm smtp-cst-quoted-pair-nonleaf
  (implies (smtp-cst-matchp cst "quoted-pair")
           (equal (tree-kind cst) :nonleaf)))

Theorem: smtp-cst-obs-qp-nonleaf

(defthm smtp-cst-obs-qp-nonleaf
  (implies (smtp-cst-matchp cst "obs-qp")
           (equal (tree-kind cst) :nonleaf)))

Theorem: smtp-cst-time-nonleaf

(defthm smtp-cst-time-nonleaf
  (implies (smtp-cst-matchp cst "time")
           (equal (tree-kind cst) :nonleaf)))

Theorem: smtp-cst-time-of-day-nonleaf

(defthm smtp-cst-time-of-day-nonleaf
  (implies (smtp-cst-matchp cst "time-of-day")
           (equal (tree-kind cst) :nonleaf)))

Theorem: smtp-cst-hour-nonleaf

(defthm smtp-cst-hour-nonleaf
  (implies (smtp-cst-matchp cst "hour")
           (equal (tree-kind cst) :nonleaf)))

Theorem: smtp-cst-minute-nonleaf

(defthm smtp-cst-minute-nonleaf
  (implies (smtp-cst-matchp cst "minute")
           (equal (tree-kind cst) :nonleaf)))

Theorem: smtp-cst-obs-hour-nonleaf

(defthm smtp-cst-obs-hour-nonleaf
  (implies (smtp-cst-matchp cst "obs-hour")
           (equal (tree-kind cst) :nonleaf)))

Theorem: smtp-cst-obs-minute-nonleaf

(defthm smtp-cst-obs-minute-nonleaf
  (implies (smtp-cst-matchp cst "obs-minute")
           (equal (tree-kind cst) :nonleaf)))

Theorem: smtp-cst-second-nonleaf

(defthm smtp-cst-second-nonleaf
  (implies (smtp-cst-matchp cst "second")
           (equal (tree-kind cst) :nonleaf)))

Theorem: smtp-cst-obs-second-nonleaf

(defthm smtp-cst-obs-second-nonleaf
  (implies (smtp-cst-matchp cst "obs-second")
           (equal (tree-kind cst) :nonleaf)))

Theorem: smtp-cst-word-nonleaf

(defthm smtp-cst-word-nonleaf
  (implies (smtp-cst-matchp cst "word")
           (equal (tree-kind cst) :nonleaf)))

Theorem: smtp-cst-year-nonleaf

(defthm smtp-cst-year-nonleaf
  (implies (smtp-cst-matchp cst "year")
           (equal (tree-kind cst) :nonleaf)))

Theorem: smtp-cst-obs-year-nonleaf

(defthm smtp-cst-obs-year-nonleaf
  (implies (smtp-cst-matchp cst "obs-year")
           (equal (tree-kind cst) :nonleaf)))

Theorem: smtp-cst-zone-nonleaf

(defthm smtp-cst-zone-nonleaf
  (implies (smtp-cst-matchp cst "zone")
           (equal (tree-kind cst) :nonleaf)))

Theorem: smtp-cst-obs-zone-nonleaf

(defthm smtp-cst-obs-zone-nonleaf
  (implies (smtp-cst-matchp cst "obs-zone")
           (equal (tree-kind cst) :nonleaf)))

Theorem: smtp-cst-alpha-nonleaf

(defthm smtp-cst-alpha-nonleaf
  (implies (smtp-cst-matchp cst "alpha")
           (equal (tree-kind cst) :nonleaf)))

Theorem: smtp-cst-cr-nonleaf

(defthm smtp-cst-cr-nonleaf
  (implies (smtp-cst-matchp cst "cr")
           (equal (tree-kind cst) :nonleaf)))

Theorem: smtp-cst-crlf-nonleaf

(defthm smtp-cst-crlf-nonleaf
  (implies (smtp-cst-matchp cst "crlf")
           (equal (tree-kind cst) :nonleaf)))

Theorem: smtp-cst-digit-nonleaf

(defthm smtp-cst-digit-nonleaf
  (implies (smtp-cst-matchp cst "digit")
           (equal (tree-kind cst) :nonleaf)))

Theorem: smtp-cst-dquote-nonleaf

(defthm smtp-cst-dquote-nonleaf
  (implies (smtp-cst-matchp cst "dquote")
           (equal (tree-kind cst) :nonleaf)))

Theorem: smtp-cst-hexdig-nonleaf

(defthm smtp-cst-hexdig-nonleaf
  (implies (smtp-cst-matchp cst "hexdig")
           (equal (tree-kind cst) :nonleaf)))

Theorem: smtp-cst-lf-nonleaf

(defthm smtp-cst-lf-nonleaf
  (implies (smtp-cst-matchp cst "lf")
           (equal (tree-kind cst) :nonleaf)))

Theorem: smtp-cst-sp-nonleaf

(defthm smtp-cst-sp-nonleaf
  (implies (smtp-cst-matchp cst "sp")
           (equal (tree-kind cst) :nonleaf)))

Theorem: smtp-cst-vchar-nonleaf

(defthm smtp-cst-vchar-nonleaf
  (implies (smtp-cst-matchp cst "vchar")
           (equal (tree-kind cst) :nonleaf)))

Theorem: smtp-cst-wsp-nonleaf

(defthm smtp-cst-wsp-nonleaf
  (implies (smtp-cst-matchp cst "wsp")
           (equal (tree-kind cst) :nonleaf)))

Theorem: smtp-cst-htab-nonleaf

(defthm smtp-cst-htab-nonleaf
  (implies (smtp-cst-matchp cst "htab")
           (equal (tree-kind cst) :nonleaf)))

Theorem: smtp-cst-ehlo-rulename

(defthm smtp-cst-ehlo-rulename
  (implies (smtp-cst-matchp cst "ehlo")
           (equal (tree-nonleaf->rulename? cst)
                  (rulename "ehlo"))))

Theorem: smtp-cst-helo-rulename

(defthm smtp-cst-helo-rulename
  (implies (smtp-cst-matchp cst "helo")
           (equal (tree-nonleaf->rulename? cst)
                  (rulename "helo"))))

Theorem: smtp-cst-ehlo-ok-rsp-rulename

(defthm smtp-cst-ehlo-ok-rsp-rulename
  (implies (smtp-cst-matchp cst "ehlo-ok-rsp")
           (equal (tree-nonleaf->rulename? cst)
                  (rulename "ehlo-ok-rsp"))))

Theorem: smtp-cst-ehlo-greet-rulename

(defthm smtp-cst-ehlo-greet-rulename
  (implies (smtp-cst-matchp cst "ehlo-greet")
           (equal (tree-nonleaf->rulename? cst)
                  (rulename "ehlo-greet"))))

Theorem: smtp-cst-ehlo-line-rulename

(defthm smtp-cst-ehlo-line-rulename
  (implies (smtp-cst-matchp cst "ehlo-line")
           (equal (tree-nonleaf->rulename? cst)
                  (rulename "ehlo-line"))))

Theorem: smtp-cst-ehlo-keyword-rulename

(defthm smtp-cst-ehlo-keyword-rulename
  (implies (smtp-cst-matchp cst "ehlo-keyword")
           (equal (tree-nonleaf->rulename? cst)
                  (rulename "ehlo-keyword"))))

Theorem: smtp-cst-ehlo-param-rulename

(defthm smtp-cst-ehlo-param-rulename
  (implies (smtp-cst-matchp cst "ehlo-param")
           (equal (tree-nonleaf->rulename? cst)
                  (rulename "ehlo-param"))))

Theorem: smtp-cst-mail-rulename

(defthm smtp-cst-mail-rulename
  (implies (smtp-cst-matchp cst "mail")
           (equal (tree-nonleaf->rulename? cst)
                  (rulename "mail"))))

Theorem: smtp-cst-rcpt-rulename

(defthm smtp-cst-rcpt-rulename
  (implies (smtp-cst-matchp cst "rcpt")
           (equal (tree-nonleaf->rulename? cst)
                  (rulename "rcpt"))))

Theorem: smtp-cst-data-rulename

(defthm smtp-cst-data-rulename
  (implies (smtp-cst-matchp cst "data")
           (equal (tree-nonleaf->rulename? cst)
                  (rulename "data"))))

Theorem: smtp-cst-rset-rulename

(defthm smtp-cst-rset-rulename
  (implies (smtp-cst-matchp cst "rset")
           (equal (tree-nonleaf->rulename? cst)
                  (rulename "rset"))))

Theorem: smtp-cst-vrfy-rulename

(defthm smtp-cst-vrfy-rulename
  (implies (smtp-cst-matchp cst "vrfy")
           (equal (tree-nonleaf->rulename? cst)
                  (rulename "vrfy"))))

Theorem: smtp-cst-expn-rulename

(defthm smtp-cst-expn-rulename
  (implies (smtp-cst-matchp cst "expn")
           (equal (tree-nonleaf->rulename? cst)
                  (rulename "expn"))))

Theorem: smtp-cst-help-rulename

(defthm smtp-cst-help-rulename
  (implies (smtp-cst-matchp cst "help")
           (equal (tree-nonleaf->rulename? cst)
                  (rulename "help"))))

Theorem: smtp-cst-noop-rulename

(defthm smtp-cst-noop-rulename
  (implies (smtp-cst-matchp cst "noop")
           (equal (tree-nonleaf->rulename? cst)
                  (rulename "noop"))))

Theorem: smtp-cst-quit-rulename

(defthm smtp-cst-quit-rulename
  (implies (smtp-cst-matchp cst "quit")
           (equal (tree-nonleaf->rulename? cst)
                  (rulename "quit"))))

Theorem: smtp-cst-reverse-path-rulename

(defthm smtp-cst-reverse-path-rulename
  (implies (smtp-cst-matchp cst "reverse-path")
           (equal (tree-nonleaf->rulename? cst)
                  (rulename "reverse-path"))))

Theorem: smtp-cst-forward-path-rulename

(defthm smtp-cst-forward-path-rulename
  (implies (smtp-cst-matchp cst "forward-path")
           (equal (tree-nonleaf->rulename? cst)
                  (rulename "forward-path"))))

Theorem: smtp-cst-path-rulename

(defthm smtp-cst-path-rulename
  (implies (smtp-cst-matchp cst "path")
           (equal (tree-nonleaf->rulename? cst)
                  (rulename "path"))))

Theorem: smtp-cst-a-d-l-rulename

(defthm smtp-cst-a-d-l-rulename
  (implies (smtp-cst-matchp cst "a-d-l")
           (equal (tree-nonleaf->rulename? cst)
                  (rulename "a-d-l"))))

Theorem: smtp-cst-at-domain-rulename

(defthm smtp-cst-at-domain-rulename
  (implies (smtp-cst-matchp cst "at-domain")
           (equal (tree-nonleaf->rulename? cst)
                  (rulename "at-domain"))))

Theorem: smtp-cst-mail-parameters-rulename

(defthm smtp-cst-mail-parameters-rulename
  (implies (smtp-cst-matchp cst "mail-parameters")
           (equal (tree-nonleaf->rulename? cst)
                  (rulename "mail-parameters"))))

Theorem: smtp-cst-rcpt-parameters-rulename

(defthm smtp-cst-rcpt-parameters-rulename
  (implies (smtp-cst-matchp cst "rcpt-parameters")
           (equal (tree-nonleaf->rulename? cst)
                  (rulename "rcpt-parameters"))))

Theorem: smtp-cst-esmtp-param-rulename

(defthm smtp-cst-esmtp-param-rulename
  (implies (smtp-cst-matchp cst "esmtp-param")
           (equal (tree-nonleaf->rulename? cst)
                  (rulename "esmtp-param"))))

Theorem: smtp-cst-esmtp-keyword-rulename

(defthm smtp-cst-esmtp-keyword-rulename
  (implies (smtp-cst-matchp cst "esmtp-keyword")
           (equal (tree-nonleaf->rulename? cst)
                  (rulename "esmtp-keyword"))))

Theorem: smtp-cst-esmtp-value-rulename

(defthm smtp-cst-esmtp-value-rulename
  (implies (smtp-cst-matchp cst "esmtp-value")
           (equal (tree-nonleaf->rulename? cst)
                  (rulename "esmtp-value"))))

Theorem: smtp-cst-keyword-rulename

(defthm smtp-cst-keyword-rulename
  (implies (smtp-cst-matchp cst "keyword")
           (equal (tree-nonleaf->rulename? cst)
                  (rulename "keyword"))))

Theorem: smtp-cst-argument-rulename

(defthm smtp-cst-argument-rulename
  (implies (smtp-cst-matchp cst "argument")
           (equal (tree-nonleaf->rulename? cst)
                  (rulename "argument"))))

Theorem: smtp-cst-domain-rulename

(defthm smtp-cst-domain-rulename
  (implies (smtp-cst-matchp cst "domain")
           (equal (tree-nonleaf->rulename? cst)
                  (rulename "domain"))))

Theorem: smtp-cst-sub-domain-rulename

(defthm smtp-cst-sub-domain-rulename
  (implies (smtp-cst-matchp cst "sub-domain")
           (equal (tree-nonleaf->rulename? cst)
                  (rulename "sub-domain"))))

Theorem: smtp-cst-let-dig-rulename

(defthm smtp-cst-let-dig-rulename
  (implies (smtp-cst-matchp cst "let-dig")
           (equal (tree-nonleaf->rulename? cst)
                  (rulename "let-dig"))))

Theorem: smtp-cst-ldh-str-rulename

(defthm smtp-cst-ldh-str-rulename
  (implies (smtp-cst-matchp cst "ldh-str")
           (equal (tree-nonleaf->rulename? cst)
                  (rulename "ldh-str"))))

Theorem: smtp-cst-address-literal-rulename

(defthm smtp-cst-address-literal-rulename
  (implies (smtp-cst-matchp cst "address-literal")
           (equal (tree-nonleaf->rulename? cst)
                  (rulename "address-literal"))))

Theorem: smtp-cst-mailbox-rulename

(defthm smtp-cst-mailbox-rulename
  (implies (smtp-cst-matchp cst "mailbox")
           (equal (tree-nonleaf->rulename? cst)
                  (rulename "mailbox"))))

Theorem: smtp-cst-local-part-rulename

(defthm smtp-cst-local-part-rulename
  (implies (smtp-cst-matchp cst "local-part")
           (equal (tree-nonleaf->rulename? cst)
                  (rulename "local-part"))))

Theorem: smtp-cst-dot-string-rulename

(defthm smtp-cst-dot-string-rulename
  (implies (smtp-cst-matchp cst "dot-string")
           (equal (tree-nonleaf->rulename? cst)
                  (rulename "dot-string"))))

Theorem: smtp-cst-atom-rulename

(defthm smtp-cst-atom-rulename
  (implies (smtp-cst-matchp cst "atom")
           (equal (tree-nonleaf->rulename? cst)
                  (rulename "atom"))))

Theorem: smtp-cst-quoted-string-rulename

(defthm smtp-cst-quoted-string-rulename
  (implies (smtp-cst-matchp cst "quoted-string")
           (equal (tree-nonleaf->rulename? cst)
                  (rulename "quoted-string"))))

Theorem: smtp-cst-qcontentsmtp-rulename

(defthm smtp-cst-qcontentsmtp-rulename
  (implies (smtp-cst-matchp cst "qcontentsmtp")
           (equal (tree-nonleaf->rulename? cst)
                  (rulename "qcontentsmtp"))))

Theorem: smtp-cst-quoted-pairsmtp-rulename

(defthm smtp-cst-quoted-pairsmtp-rulename
  (implies (smtp-cst-matchp cst "quoted-pairsmtp")
           (equal (tree-nonleaf->rulename? cst)
                  (rulename "quoted-pairsmtp"))))

Theorem: smtp-cst-qtextsmtp-rulename

(defthm smtp-cst-qtextsmtp-rulename
  (implies (smtp-cst-matchp cst "qtextsmtp")
           (equal (tree-nonleaf->rulename? cst)
                  (rulename "qtextsmtp"))))

Theorem: smtp-cst-string-rulename

(defthm smtp-cst-string-rulename
  (implies (smtp-cst-matchp cst "string")
           (equal (tree-nonleaf->rulename? cst)
                  (rulename "string"))))

Theorem: smtp-cst-ipv4-address-literal-rulename

(defthm smtp-cst-ipv4-address-literal-rulename
  (implies (smtp-cst-matchp cst "ipv4-address-literal")
           (equal (tree-nonleaf->rulename? cst)
                  (rulename "ipv4-address-literal"))))

Theorem: smtp-cst-ipv6-address-literal-rulename

(defthm smtp-cst-ipv6-address-literal-rulename
  (implies (smtp-cst-matchp cst "ipv6-address-literal")
           (equal (tree-nonleaf->rulename? cst)
                  (rulename "ipv6-address-literal"))))

Theorem: smtp-cst-general-address-literal-rulename

(defthm smtp-cst-general-address-literal-rulename
  (implies (smtp-cst-matchp cst "general-address-literal")
           (equal (tree-nonleaf->rulename? cst)
                  (rulename "general-address-literal"))))

Theorem: smtp-cst-standardized-tag-rulename

(defthm smtp-cst-standardized-tag-rulename
  (implies (smtp-cst-matchp cst "standardized-tag")
           (equal (tree-nonleaf->rulename? cst)
                  (rulename "standardized-tag"))))

Theorem: smtp-cst-dcontent-rulename

(defthm smtp-cst-dcontent-rulename
  (implies (smtp-cst-matchp cst "dcontent")
           (equal (tree-nonleaf->rulename? cst)
                  (rulename "dcontent"))))

Theorem: smtp-cst-snum-rulename

(defthm smtp-cst-snum-rulename
  (implies (smtp-cst-matchp cst "snum")
           (equal (tree-nonleaf->rulename? cst)
                  (rulename "snum"))))

Theorem: smtp-cst-ipv6-addr-rulename

(defthm smtp-cst-ipv6-addr-rulename
  (implies (smtp-cst-matchp cst "ipv6-addr")
           (equal (tree-nonleaf->rulename? cst)
                  (rulename "ipv6-addr"))))

Theorem: smtp-cst-ipv6-hex-rulename

(defthm smtp-cst-ipv6-hex-rulename
  (implies (smtp-cst-matchp cst "ipv6-hex")
           (equal (tree-nonleaf->rulename? cst)
                  (rulename "ipv6-hex"))))

Theorem: smtp-cst-ipv6-full-rulename

(defthm smtp-cst-ipv6-full-rulename
  (implies (smtp-cst-matchp cst "ipv6-full")
           (equal (tree-nonleaf->rulename? cst)
                  (rulename "ipv6-full"))))

Theorem: smtp-cst-ipv6-comp-rulename

(defthm smtp-cst-ipv6-comp-rulename
  (implies (smtp-cst-matchp cst "ipv6-comp")
           (equal (tree-nonleaf->rulename? cst)
                  (rulename "ipv6-comp"))))

Theorem: smtp-cst-ipv6v4-full-rulename

(defthm smtp-cst-ipv6v4-full-rulename
  (implies (smtp-cst-matchp cst "ipv6v4-full")
           (equal (tree-nonleaf->rulename? cst)
                  (rulename "ipv6v4-full"))))

Theorem: smtp-cst-ipv6v4-comp-rulename

(defthm smtp-cst-ipv6v4-comp-rulename
  (implies (smtp-cst-matchp cst "ipv6v4-comp")
           (equal (tree-nonleaf->rulename? cst)
                  (rulename "ipv6v4-comp"))))

Theorem: smtp-cst-greeting-rulename

(defthm smtp-cst-greeting-rulename
  (implies (smtp-cst-matchp cst "greeting")
           (equal (tree-nonleaf->rulename? cst)
                  (rulename "greeting"))))

Theorem: smtp-cst-textstring-rulename

(defthm smtp-cst-textstring-rulename
  (implies (smtp-cst-matchp cst "textstring")
           (equal (tree-nonleaf->rulename? cst)
                  (rulename "textstring"))))

Theorem: smtp-cst-reply-line-rulename

(defthm smtp-cst-reply-line-rulename
  (implies (smtp-cst-matchp cst "reply-line")
           (equal (tree-nonleaf->rulename? cst)
                  (rulename "reply-line"))))

Theorem: smtp-cst-reply-code-rulename

(defthm smtp-cst-reply-code-rulename
  (implies (smtp-cst-matchp cst "reply-code")
           (equal (tree-nonleaf->rulename? cst)
                  (rulename "reply-code"))))

Theorem: smtp-cst-return-path-line-rulename

(defthm smtp-cst-return-path-line-rulename
  (implies (smtp-cst-matchp cst "return-path-line")
           (equal (tree-nonleaf->rulename? cst)
                  (rulename "return-path-line"))))

Theorem: smtp-cst-time-stamp-line-rulename

(defthm smtp-cst-time-stamp-line-rulename
  (implies (smtp-cst-matchp cst "time-stamp-line")
           (equal (tree-nonleaf->rulename? cst)
                  (rulename "time-stamp-line"))))

Theorem: smtp-cst-stamp-rulename

(defthm smtp-cst-stamp-rulename
  (implies (smtp-cst-matchp cst "stamp")
           (equal (tree-nonleaf->rulename? cst)
                  (rulename "stamp"))))

Theorem: smtp-cst-from-domain-rulename

(defthm smtp-cst-from-domain-rulename
  (implies (smtp-cst-matchp cst "from-domain")
           (equal (tree-nonleaf->rulename? cst)
                  (rulename "from-domain"))))

Theorem: smtp-cst-by-domain-rulename

(defthm smtp-cst-by-domain-rulename
  (implies (smtp-cst-matchp cst "by-domain")
           (equal (tree-nonleaf->rulename? cst)
                  (rulename "by-domain"))))

Theorem: smtp-cst-extended-domain-rulename

(defthm smtp-cst-extended-domain-rulename
  (implies (smtp-cst-matchp cst "extended-domain")
           (equal (tree-nonleaf->rulename? cst)
                  (rulename "extended-domain"))))

Theorem: smtp-cst-tcp-info-rulename

(defthm smtp-cst-tcp-info-rulename
  (implies (smtp-cst-matchp cst "tcp-info")
           (equal (tree-nonleaf->rulename? cst)
                  (rulename "tcp-info"))))

Theorem: smtp-cst-opt-info-rulename

(defthm smtp-cst-opt-info-rulename
  (implies (smtp-cst-matchp cst "opt-info")
           (equal (tree-nonleaf->rulename? cst)
                  (rulename "opt-info"))))

Theorem: smtp-cst-via-rulename

(defthm smtp-cst-via-rulename
  (implies (smtp-cst-matchp cst "via")
           (equal (tree-nonleaf->rulename? cst)
                  (rulename "via"))))

Theorem: smtp-cst-with-rulename

(defthm smtp-cst-with-rulename
  (implies (smtp-cst-matchp cst "with")
           (equal (tree-nonleaf->rulename? cst)
                  (rulename "with"))))

Theorem: smtp-cst-id-rulename

(defthm smtp-cst-id-rulename
  (implies (smtp-cst-matchp cst "id")
           (equal (tree-nonleaf->rulename? cst)
                  (rulename "id"))))

Theorem: smtp-cst-for-rulename

(defthm smtp-cst-for-rulename
  (implies (smtp-cst-matchp cst "for")
           (equal (tree-nonleaf->rulename? cst)
                  (rulename "for"))))

Theorem: smtp-cst-additional-registered-clauses-rulename

(defthm smtp-cst-additional-registered-clauses-rulename
  (implies (smtp-cst-matchp cst "additional-registered-clauses")
           (equal (tree-nonleaf->rulename? cst)
                  (rulename "additional-registered-clauses"))))

Theorem: smtp-cst-link-rulename

(defthm smtp-cst-link-rulename
  (implies (smtp-cst-matchp cst "link")
           (equal (tree-nonleaf->rulename? cst)
                  (rulename "link"))))

Theorem: smtp-cst-addtl-link-rulename

(defthm smtp-cst-addtl-link-rulename
  (implies (smtp-cst-matchp cst "addtl-link")
           (equal (tree-nonleaf->rulename? cst)
                  (rulename "addtl-link"))))

Theorem: smtp-cst-protocol-rulename

(defthm smtp-cst-protocol-rulename
  (implies (smtp-cst-matchp cst "protocol")
           (equal (tree-nonleaf->rulename? cst)
                  (rulename "protocol"))))

Theorem: smtp-cst-attdl-protocol-rulename

(defthm smtp-cst-attdl-protocol-rulename
  (implies (smtp-cst-matchp cst "attdl-protocol")
           (equal (tree-nonleaf->rulename? cst)
                  (rulename "attdl-protocol"))))

Theorem: smtp-cst-atext-rulename

(defthm smtp-cst-atext-rulename
  (implies (smtp-cst-matchp cst "atext")
           (equal (tree-nonleaf->rulename? cst)
                  (rulename "atext"))))

Theorem: smtp-cst-cfws-rulename

(defthm smtp-cst-cfws-rulename
  (implies (smtp-cst-matchp cst "cfws")
           (equal (tree-nonleaf->rulename? cst)
                  (rulename "cfws"))))

Theorem: smtp-cst-comment-rulename

(defthm smtp-cst-comment-rulename
  (implies (smtp-cst-matchp cst "comment")
           (equal (tree-nonleaf->rulename? cst)
                  (rulename "comment"))))

Theorem: smtp-cst-ccontent-rulename

(defthm smtp-cst-ccontent-rulename
  (implies (smtp-cst-matchp cst "ccontent")
           (equal (tree-nonleaf->rulename? cst)
                  (rulename "ccontent"))))

Theorem: smtp-cst-ctext-rulename

(defthm smtp-cst-ctext-rulename
  (implies (smtp-cst-matchp cst "ctext")
           (equal (tree-nonleaf->rulename? cst)
                  (rulename "ctext"))))

Theorem: smtp-cst-date-time-rulename

(defthm smtp-cst-date-time-rulename
  (implies (smtp-cst-matchp cst "date-time")
           (equal (tree-nonleaf->rulename? cst)
                  (rulename "date-time"))))

Theorem: smtp-cst-date-rulename

(defthm smtp-cst-date-rulename
  (implies (smtp-cst-matchp cst "date")
           (equal (tree-nonleaf->rulename? cst)
                  (rulename "date"))))

Theorem: smtp-cst-day-rulename

(defthm smtp-cst-day-rulename
  (implies (smtp-cst-matchp cst "day")
           (equal (tree-nonleaf->rulename? cst)
                  (rulename "day"))))

Theorem: smtp-cst-day-of-week-rulename

(defthm smtp-cst-day-of-week-rulename
  (implies (smtp-cst-matchp cst "day-of-week")
           (equal (tree-nonleaf->rulename? cst)
                  (rulename "day-of-week"))))

Theorem: smtp-cst-day-name-rulename

(defthm smtp-cst-day-name-rulename
  (implies (smtp-cst-matchp cst "day-name")
           (equal (tree-nonleaf->rulename? cst)
                  (rulename "day-name"))))

Theorem: smtp-cst-fws-rulename

(defthm smtp-cst-fws-rulename
  (implies (smtp-cst-matchp cst "fws")
           (equal (tree-nonleaf->rulename? cst)
                  (rulename "fws"))))

Theorem: smtp-cst-month-rulename

(defthm smtp-cst-month-rulename
  (implies (smtp-cst-matchp cst "month")
           (equal (tree-nonleaf->rulename? cst)
                  (rulename "month"))))

Theorem: smtp-cst-msg-id-rulename

(defthm smtp-cst-msg-id-rulename
  (implies (smtp-cst-matchp cst "msg-id")
           (equal (tree-nonleaf->rulename? cst)
                  (rulename "msg-id"))))

Theorem: smtp-cst-id-left-rulename

(defthm smtp-cst-id-left-rulename
  (implies (smtp-cst-matchp cst "id-left")
           (equal (tree-nonleaf->rulename? cst)
                  (rulename "id-left"))))

Theorem: smtp-cst-dot-atom-text-rulename

(defthm smtp-cst-dot-atom-text-rulename
  (implies (smtp-cst-matchp cst "dot-atom-text")
           (equal (tree-nonleaf->rulename? cst)
                  (rulename "dot-atom-text"))))

Theorem: smtp-cst-id-right-rulename

(defthm smtp-cst-id-right-rulename
  (implies (smtp-cst-matchp cst "id-right")
           (equal (tree-nonleaf->rulename? cst)
                  (rulename "id-right"))))

Theorem: smtp-cst-no-fold-literal-rulename

(defthm smtp-cst-no-fold-literal-rulename
  (implies (smtp-cst-matchp cst "no-fold-literal")
           (equal (tree-nonleaf->rulename? cst)
                  (rulename "no-fold-literal"))))

Theorem: smtp-cst-dtext-rulename

(defthm smtp-cst-dtext-rulename
  (implies (smtp-cst-matchp cst "dtext")
           (equal (tree-nonleaf->rulename? cst)
                  (rulename "dtext"))))

Theorem: smtp-cst-obs-ctext-rulename

(defthm smtp-cst-obs-ctext-rulename
  (implies (smtp-cst-matchp cst "obs-ctext")
           (equal (tree-nonleaf->rulename? cst)
                  (rulename "obs-ctext"))))

Theorem: smtp-cst-obs-day-rulename

(defthm smtp-cst-obs-day-rulename
  (implies (smtp-cst-matchp cst "obs-day")
           (equal (tree-nonleaf->rulename? cst)
                  (rulename "obs-day"))))

Theorem: smtp-cst-obs-day-of-week-rulename

(defthm smtp-cst-obs-day-of-week-rulename
  (implies (smtp-cst-matchp cst "obs-day-of-week")
           (equal (tree-nonleaf->rulename? cst)
                  (rulename "obs-day-of-week"))))

Theorem: smtp-cst-obs-dtext-rulename

(defthm smtp-cst-obs-dtext-rulename
  (implies (smtp-cst-matchp cst "obs-dtext")
           (equal (tree-nonleaf->rulename? cst)
                  (rulename "obs-dtext"))))

Theorem: smtp-cst-obs-fws-rulename

(defthm smtp-cst-obs-fws-rulename
  (implies (smtp-cst-matchp cst "obs-fws")
           (equal (tree-nonleaf->rulename? cst)
                  (rulename "obs-fws"))))

Theorem: smtp-cst-obs-id-left-rulename

(defthm smtp-cst-obs-id-left-rulename
  (implies (smtp-cst-matchp cst "obs-id-left")
           (equal (tree-nonleaf->rulename? cst)
                  (rulename "obs-id-left"))))

Theorem: smtp-cst-imf-local-part-rulename

(defthm smtp-cst-imf-local-part-rulename
  (implies (smtp-cst-matchp cst "imf-local-part")
           (equal (tree-nonleaf->rulename? cst)
                  (rulename "imf-local-part"))))

Theorem: smtp-cst-dot-atom-rulename

(defthm smtp-cst-dot-atom-rulename
  (implies (smtp-cst-matchp cst "dot-atom")
           (equal (tree-nonleaf->rulename? cst)
                  (rulename "dot-atom"))))

Theorem: smtp-cst-imf-quoted-string-rulename

(defthm smtp-cst-imf-quoted-string-rulename
  (implies (smtp-cst-matchp cst "imf-quoted-string")
           (equal (tree-nonleaf->rulename? cst)
                  (rulename "imf-quoted-string"))))

Theorem: smtp-cst-obs-id-right-rulename

(defthm smtp-cst-obs-id-right-rulename
  (implies (smtp-cst-matchp cst "obs-id-right")
           (equal (tree-nonleaf->rulename? cst)
                  (rulename "obs-id-right"))))

Theorem: smtp-cst-imf-domain-rulename

(defthm smtp-cst-imf-domain-rulename
  (implies (smtp-cst-matchp cst "imf-domain")
           (equal (tree-nonleaf->rulename? cst)
                  (rulename "imf-domain"))))

Theorem: smtp-cst-domain-literal-rulename

(defthm smtp-cst-domain-literal-rulename
  (implies (smtp-cst-matchp cst "domain-literal")
           (equal (tree-nonleaf->rulename? cst)
                  (rulename "domain-literal"))))

Theorem: smtp-cst-obs-domain-rulename

(defthm smtp-cst-obs-domain-rulename
  (implies (smtp-cst-matchp cst "obs-domain")
           (equal (tree-nonleaf->rulename? cst)
                  (rulename "obs-domain"))))

Theorem: smtp-cst-imf-atom-rulename

(defthm smtp-cst-imf-atom-rulename
  (implies (smtp-cst-matchp cst "imf-atom")
           (equal (tree-nonleaf->rulename? cst)
                  (rulename "imf-atom"))))

Theorem: smtp-cst-obs-local-part-rulename

(defthm smtp-cst-obs-local-part-rulename
  (implies (smtp-cst-matchp cst "obs-local-part")
           (equal (tree-nonleaf->rulename? cst)
                  (rulename "obs-local-part"))))

Theorem: smtp-cst-obs-no-ws-ctl-rulename

(defthm smtp-cst-obs-no-ws-ctl-rulename
  (implies (smtp-cst-matchp cst "obs-no-ws-ctl")
           (equal (tree-nonleaf->rulename? cst)
                  (rulename "obs-no-ws-ctl"))))

Theorem: smtp-cst-qcontent-rulename

(defthm smtp-cst-qcontent-rulename
  (implies (smtp-cst-matchp cst "qcontent")
           (equal (tree-nonleaf->rulename? cst)
                  (rulename "qcontent"))))

Theorem: smtp-cst-qtext-rulename

(defthm smtp-cst-qtext-rulename
  (implies (smtp-cst-matchp cst "qtext")
           (equal (tree-nonleaf->rulename? cst)
                  (rulename "qtext"))))

Theorem: smtp-cst-obs-qtext-rulename

(defthm smtp-cst-obs-qtext-rulename
  (implies (smtp-cst-matchp cst "obs-qtext")
           (equal (tree-nonleaf->rulename? cst)
                  (rulename "obs-qtext"))))

Theorem: smtp-cst-quoted-pair-rulename

(defthm smtp-cst-quoted-pair-rulename
  (implies (smtp-cst-matchp cst "quoted-pair")
           (equal (tree-nonleaf->rulename? cst)
                  (rulename "quoted-pair"))))

Theorem: smtp-cst-obs-qp-rulename

(defthm smtp-cst-obs-qp-rulename
  (implies (smtp-cst-matchp cst "obs-qp")
           (equal (tree-nonleaf->rulename? cst)
                  (rulename "obs-qp"))))

Theorem: smtp-cst-time-rulename

(defthm smtp-cst-time-rulename
  (implies (smtp-cst-matchp cst "time")
           (equal (tree-nonleaf->rulename? cst)
                  (rulename "time"))))

Theorem: smtp-cst-time-of-day-rulename

(defthm smtp-cst-time-of-day-rulename
  (implies (smtp-cst-matchp cst "time-of-day")
           (equal (tree-nonleaf->rulename? cst)
                  (rulename "time-of-day"))))

Theorem: smtp-cst-hour-rulename

(defthm smtp-cst-hour-rulename
  (implies (smtp-cst-matchp cst "hour")
           (equal (tree-nonleaf->rulename? cst)
                  (rulename "hour"))))

Theorem: smtp-cst-minute-rulename

(defthm smtp-cst-minute-rulename
  (implies (smtp-cst-matchp cst "minute")
           (equal (tree-nonleaf->rulename? cst)
                  (rulename "minute"))))

Theorem: smtp-cst-obs-hour-rulename

(defthm smtp-cst-obs-hour-rulename
  (implies (smtp-cst-matchp cst "obs-hour")
           (equal (tree-nonleaf->rulename? cst)
                  (rulename "obs-hour"))))

Theorem: smtp-cst-obs-minute-rulename

(defthm smtp-cst-obs-minute-rulename
  (implies (smtp-cst-matchp cst "obs-minute")
           (equal (tree-nonleaf->rulename? cst)
                  (rulename "obs-minute"))))

Theorem: smtp-cst-second-rulename

(defthm smtp-cst-second-rulename
  (implies (smtp-cst-matchp cst "second")
           (equal (tree-nonleaf->rulename? cst)
                  (rulename "second"))))

Theorem: smtp-cst-obs-second-rulename

(defthm smtp-cst-obs-second-rulename
  (implies (smtp-cst-matchp cst "obs-second")
           (equal (tree-nonleaf->rulename? cst)
                  (rulename "obs-second"))))

Theorem: smtp-cst-word-rulename

(defthm smtp-cst-word-rulename
  (implies (smtp-cst-matchp cst "word")
           (equal (tree-nonleaf->rulename? cst)
                  (rulename "word"))))

Theorem: smtp-cst-year-rulename

(defthm smtp-cst-year-rulename
  (implies (smtp-cst-matchp cst "year")
           (equal (tree-nonleaf->rulename? cst)
                  (rulename "year"))))

Theorem: smtp-cst-obs-year-rulename

(defthm smtp-cst-obs-year-rulename
  (implies (smtp-cst-matchp cst "obs-year")
           (equal (tree-nonleaf->rulename? cst)
                  (rulename "obs-year"))))

Theorem: smtp-cst-zone-rulename

(defthm smtp-cst-zone-rulename
  (implies (smtp-cst-matchp cst "zone")
           (equal (tree-nonleaf->rulename? cst)
                  (rulename "zone"))))

Theorem: smtp-cst-obs-zone-rulename

(defthm smtp-cst-obs-zone-rulename
  (implies (smtp-cst-matchp cst "obs-zone")
           (equal (tree-nonleaf->rulename? cst)
                  (rulename "obs-zone"))))

Theorem: smtp-cst-alpha-rulename

(defthm smtp-cst-alpha-rulename
  (implies (smtp-cst-matchp cst "alpha")
           (equal (tree-nonleaf->rulename? cst)
                  (rulename "alpha"))))

Theorem: smtp-cst-cr-rulename

(defthm smtp-cst-cr-rulename
  (implies (smtp-cst-matchp cst "cr")
           (equal (tree-nonleaf->rulename? cst)
                  (rulename "cr"))))

Theorem: smtp-cst-crlf-rulename

(defthm smtp-cst-crlf-rulename
  (implies (smtp-cst-matchp cst "crlf")
           (equal (tree-nonleaf->rulename? cst)
                  (rulename "crlf"))))

Theorem: smtp-cst-digit-rulename

(defthm smtp-cst-digit-rulename
  (implies (smtp-cst-matchp cst "digit")
           (equal (tree-nonleaf->rulename? cst)
                  (rulename "digit"))))

Theorem: smtp-cst-dquote-rulename

(defthm smtp-cst-dquote-rulename
  (implies (smtp-cst-matchp cst "dquote")
           (equal (tree-nonleaf->rulename? cst)
                  (rulename "dquote"))))

Theorem: smtp-cst-hexdig-rulename

(defthm smtp-cst-hexdig-rulename
  (implies (smtp-cst-matchp cst "hexdig")
           (equal (tree-nonleaf->rulename? cst)
                  (rulename "hexdig"))))

Theorem: smtp-cst-lf-rulename

(defthm smtp-cst-lf-rulename
  (implies (smtp-cst-matchp cst "lf")
           (equal (tree-nonleaf->rulename? cst)
                  (rulename "lf"))))

Theorem: smtp-cst-sp-rulename

(defthm smtp-cst-sp-rulename
  (implies (smtp-cst-matchp cst "sp")
           (equal (tree-nonleaf->rulename? cst)
                  (rulename "sp"))))

Theorem: smtp-cst-vchar-rulename

(defthm smtp-cst-vchar-rulename
  (implies (smtp-cst-matchp cst "vchar")
           (equal (tree-nonleaf->rulename? cst)
                  (rulename "vchar"))))

Theorem: smtp-cst-wsp-rulename

(defthm smtp-cst-wsp-rulename
  (implies (smtp-cst-matchp cst "wsp")
           (equal (tree-nonleaf->rulename? cst)
                  (rulename "wsp"))))

Theorem: smtp-cst-htab-rulename

(defthm smtp-cst-htab-rulename
  (implies (smtp-cst-matchp cst "htab")
           (equal (tree-nonleaf->rulename? cst)
                  (rulename "htab"))))

Theorem: smtp-cst-ehlo-branches-match-alt

(defthm smtp-cst-ehlo-branches-match-alt
  (implies (smtp-cst-matchp cst "ehlo")
           (smtp-cst-list-list-alt-matchp
                (tree-nonleaf->branches cst)
                "\"EHLO\" sp ( domain / address-literal ) crlf")))

Theorem: smtp-cst-helo-branches-match-alt

(defthm smtp-cst-helo-branches-match-alt
  (implies
       (smtp-cst-matchp cst "helo")
       (smtp-cst-list-list-alt-matchp (tree-nonleaf->branches cst)
                                      "\"HELO\" sp domain crlf")))

Theorem: smtp-cst-ehlo-ok-rsp-branches-match-alt

(defthm smtp-cst-ehlo-ok-rsp-branches-match-alt
 (implies
  (smtp-cst-matchp cst "ehlo-ok-rsp")
  (smtp-cst-list-list-alt-matchp
   (tree-nonleaf->branches cst)
   "( \"250\" sp domain [ sp ehlo-greet ] crlf ) / ( \"250-\" domain [ sp ehlo-greet ] crlf *( \"250-\" ehlo-line crlf ) \"250\" sp ehlo-line crlf )")))

Theorem: smtp-cst-ehlo-greet-branches-match-alt

(defthm smtp-cst-ehlo-greet-branches-match-alt
  (implies (smtp-cst-matchp cst "ehlo-greet")
           (smtp-cst-list-list-alt-matchp
                (tree-nonleaf->branches cst)
                "1*( %d0-9 / %d11-12 / %d14-127 )")))

Theorem: smtp-cst-ehlo-line-branches-match-alt

(defthm smtp-cst-ehlo-line-branches-match-alt
  (implies (smtp-cst-matchp cst "ehlo-line")
           (smtp-cst-list-list-alt-matchp
                (tree-nonleaf->branches cst)
                "ehlo-keyword *( sp ehlo-param )")))

Theorem: smtp-cst-ehlo-keyword-branches-match-alt

(defthm smtp-cst-ehlo-keyword-branches-match-alt
  (implies (smtp-cst-matchp cst "ehlo-keyword")
           (smtp-cst-list-list-alt-matchp
                (tree-nonleaf->branches cst)
                "( alpha / digit ) *( alpha / digit / \"-\" )")))

Theorem: smtp-cst-ehlo-param-branches-match-alt

(defthm smtp-cst-ehlo-param-branches-match-alt
  (implies
       (smtp-cst-matchp cst "ehlo-param")
       (smtp-cst-list-list-alt-matchp (tree-nonleaf->branches cst)
                                      "1*( %d33-126 )")))

Theorem: smtp-cst-mail-branches-match-alt

(defthm smtp-cst-mail-branches-match-alt
 (implies
     (smtp-cst-matchp cst "mail")
     (smtp-cst-list-list-alt-matchp
          (tree-nonleaf->branches cst)
          "\"MAIL FROM:\" reverse-path [ sp mail-parameters ] crlf")))

Theorem: smtp-cst-rcpt-branches-match-alt

(defthm smtp-cst-rcpt-branches-match-alt
 (implies
  (smtp-cst-matchp cst "rcpt")
  (smtp-cst-list-list-alt-matchp
   (tree-nonleaf->branches cst)
   "\"RCPT TO:\" ( \"<Postmaster@\" domain \">\" / \"<Postmaster>\" / forward-path ) [ sp rcpt-parameters ] crlf")))

Theorem: smtp-cst-data-branches-match-alt

(defthm smtp-cst-data-branches-match-alt
  (implies
       (smtp-cst-matchp cst "data")
       (smtp-cst-list-list-alt-matchp (tree-nonleaf->branches cst)
                                      "\"DATA\" crlf")))

Theorem: smtp-cst-rset-branches-match-alt

(defthm smtp-cst-rset-branches-match-alt
  (implies
       (smtp-cst-matchp cst "rset")
       (smtp-cst-list-list-alt-matchp (tree-nonleaf->branches cst)
                                      "\"RSET\" crlf")))

Theorem: smtp-cst-vrfy-branches-match-alt

(defthm smtp-cst-vrfy-branches-match-alt
  (implies
       (smtp-cst-matchp cst "vrfy")
       (smtp-cst-list-list-alt-matchp (tree-nonleaf->branches cst)
                                      "\"VRFY\" sp string crlf")))

Theorem: smtp-cst-expn-branches-match-alt

(defthm smtp-cst-expn-branches-match-alt
  (implies
       (smtp-cst-matchp cst "expn")
       (smtp-cst-list-list-alt-matchp (tree-nonleaf->branches cst)
                                      "\"EXPN\" sp string crlf")))

Theorem: smtp-cst-help-branches-match-alt

(defthm smtp-cst-help-branches-match-alt
  (implies
       (smtp-cst-matchp cst "help")
       (smtp-cst-list-list-alt-matchp (tree-nonleaf->branches cst)
                                      "\"HELP\" [ sp string ] crlf")))

Theorem: smtp-cst-noop-branches-match-alt

(defthm smtp-cst-noop-branches-match-alt
  (implies
       (smtp-cst-matchp cst "noop")
       (smtp-cst-list-list-alt-matchp (tree-nonleaf->branches cst)
                                      "\"NOOP\" [ sp string ] crlf")))

Theorem: smtp-cst-quit-branches-match-alt

(defthm smtp-cst-quit-branches-match-alt
  (implies
       (smtp-cst-matchp cst "quit")
       (smtp-cst-list-list-alt-matchp (tree-nonleaf->branches cst)
                                      "\"QUIT\" crlf")))

Theorem: smtp-cst-reverse-path-branches-match-alt

(defthm smtp-cst-reverse-path-branches-match-alt
  (implies
       (smtp-cst-matchp cst "reverse-path")
       (smtp-cst-list-list-alt-matchp (tree-nonleaf->branches cst)
                                      "path / \"<>\"")))

Theorem: smtp-cst-forward-path-branches-match-alt

(defthm smtp-cst-forward-path-branches-match-alt
  (implies
       (smtp-cst-matchp cst "forward-path")
       (smtp-cst-list-list-alt-matchp (tree-nonleaf->branches cst)
                                      "path")))

Theorem: smtp-cst-path-branches-match-alt

(defthm smtp-cst-path-branches-match-alt
 (implies
   (smtp-cst-matchp cst "path")
   (smtp-cst-list-list-alt-matchp (tree-nonleaf->branches cst)
                                  "\"<\" [ a-d-l \":\" ] mailbox \">\"")))

Theorem: smtp-cst-a-d-l-branches-match-alt

(defthm smtp-cst-a-d-l-branches-match-alt
 (implies
    (smtp-cst-matchp cst "a-d-l")
    (smtp-cst-list-list-alt-matchp (tree-nonleaf->branches cst)
                                   "at-domain *( \",\" at-domain )")))

Theorem: smtp-cst-at-domain-branches-match-alt

(defthm smtp-cst-at-domain-branches-match-alt
  (implies
       (smtp-cst-matchp cst "at-domain")
       (smtp-cst-list-list-alt-matchp (tree-nonleaf->branches cst)
                                      "\"@\" domain")))

Theorem: smtp-cst-mail-parameters-branches-match-alt

(defthm smtp-cst-mail-parameters-branches-match-alt
  (implies (smtp-cst-matchp cst "mail-parameters")
           (smtp-cst-list-list-alt-matchp
                (tree-nonleaf->branches cst)
                "esmtp-param *( sp esmtp-param )")))

Theorem: smtp-cst-rcpt-parameters-branches-match-alt

(defthm smtp-cst-rcpt-parameters-branches-match-alt
  (implies (smtp-cst-matchp cst "rcpt-parameters")
           (smtp-cst-list-list-alt-matchp
                (tree-nonleaf->branches cst)
                "esmtp-param *( sp esmtp-param )")))

Theorem: smtp-cst-esmtp-param-branches-match-alt

(defthm smtp-cst-esmtp-param-branches-match-alt
  (implies (smtp-cst-matchp cst "esmtp-param")
           (smtp-cst-list-list-alt-matchp
                (tree-nonleaf->branches cst)
                "esmtp-keyword [ \"=\" esmtp-value ]")))

Theorem: smtp-cst-esmtp-keyword-branches-match-alt

(defthm smtp-cst-esmtp-keyword-branches-match-alt
  (implies (smtp-cst-matchp cst "esmtp-keyword")
           (smtp-cst-list-list-alt-matchp
                (tree-nonleaf->branches cst)
                "( alpha / digit ) *( alpha / digit / \"-\" )")))

Theorem: smtp-cst-esmtp-value-branches-match-alt

(defthm smtp-cst-esmtp-value-branches-match-alt
  (implies
       (smtp-cst-matchp cst "esmtp-value")
       (smtp-cst-list-list-alt-matchp (tree-nonleaf->branches cst)
                                      "1*( %d33-60 / %d62-126 )")))

Theorem: smtp-cst-keyword-branches-match-alt

(defthm smtp-cst-keyword-branches-match-alt
  (implies
       (smtp-cst-matchp cst "keyword")
       (smtp-cst-list-list-alt-matchp (tree-nonleaf->branches cst)
                                      "ldh-str")))

Theorem: smtp-cst-argument-branches-match-alt

(defthm smtp-cst-argument-branches-match-alt
  (implies
       (smtp-cst-matchp cst "argument")
       (smtp-cst-list-list-alt-matchp (tree-nonleaf->branches cst)
                                      "atom")))

Theorem: smtp-cst-domain-branches-match-alt

(defthm smtp-cst-domain-branches-match-alt
 (implies
  (smtp-cst-matchp cst "domain")
  (smtp-cst-list-list-alt-matchp (tree-nonleaf->branches cst)
                                 "sub-domain *( \".\" sub-domain )")))

Theorem: smtp-cst-sub-domain-branches-match-alt

(defthm smtp-cst-sub-domain-branches-match-alt
  (implies
       (smtp-cst-matchp cst "sub-domain")
       (smtp-cst-list-list-alt-matchp (tree-nonleaf->branches cst)
                                      "let-dig [ ldh-str ]")))

Theorem: smtp-cst-let-dig-branches-match-alt

(defthm smtp-cst-let-dig-branches-match-alt
  (implies
       (smtp-cst-matchp cst "let-dig")
       (smtp-cst-list-list-alt-matchp (tree-nonleaf->branches cst)
                                      "alpha / digit")))

Theorem: smtp-cst-ldh-str-branches-match-alt

(defthm smtp-cst-ldh-str-branches-match-alt
  (implies (smtp-cst-matchp cst "ldh-str")
           (smtp-cst-list-list-alt-matchp
                (tree-nonleaf->branches cst)
                "*( alpha / digit / \"-\" ) let-dig")))

Theorem: smtp-cst-address-literal-branches-match-alt

(defthm smtp-cst-address-literal-branches-match-alt
 (implies
  (smtp-cst-matchp cst "address-literal")
  (smtp-cst-list-list-alt-matchp
   (tree-nonleaf->branches cst)
   "\"[\" ( ipv4-address-literal / ipv6-address-literal / general-address-literal ) \"]\"")))

Theorem: smtp-cst-mailbox-branches-match-alt

(defthm smtp-cst-mailbox-branches-match-alt
  (implies (smtp-cst-matchp cst "mailbox")
           (smtp-cst-list-list-alt-matchp
                (tree-nonleaf->branches cst)
                "local-part \"@\" ( domain / address-literal )")))

Theorem: smtp-cst-local-part-branches-match-alt

(defthm smtp-cst-local-part-branches-match-alt
 (implies
      (smtp-cst-matchp cst "local-part")
      (smtp-cst-list-list-alt-matchp (tree-nonleaf->branches cst)
                                     "dot-string / quoted-string")))

Theorem: smtp-cst-dot-string-branches-match-alt

(defthm smtp-cst-dot-string-branches-match-alt
  (implies
       (smtp-cst-matchp cst "dot-string")
       (smtp-cst-list-list-alt-matchp (tree-nonleaf->branches cst)
                                      "atom *( \".\" atom )")))

Theorem: smtp-cst-atom-branches-match-alt

(defthm smtp-cst-atom-branches-match-alt
  (implies
       (smtp-cst-matchp cst "atom")
       (smtp-cst-list-list-alt-matchp (tree-nonleaf->branches cst)
                                      "1*atext")))

Theorem: smtp-cst-quoted-string-branches-match-alt

(defthm smtp-cst-quoted-string-branches-match-alt
 (implies
     (smtp-cst-matchp cst "quoted-string")
     (smtp-cst-list-list-alt-matchp (tree-nonleaf->branches cst)
                                    "dquote *qcontentsmtp dquote")))

Theorem: smtp-cst-qcontentsmtp-branches-match-alt

(defthm smtp-cst-qcontentsmtp-branches-match-alt
 (implies
     (smtp-cst-matchp cst "qcontentsmtp")
     (smtp-cst-list-list-alt-matchp (tree-nonleaf->branches cst)
                                    "qtextsmtp / quoted-pairsmtp")))

Theorem: smtp-cst-quoted-pairsmtp-branches-match-alt

(defthm smtp-cst-quoted-pairsmtp-branches-match-alt
  (implies
       (smtp-cst-matchp cst "quoted-pairsmtp")
       (smtp-cst-list-list-alt-matchp (tree-nonleaf->branches cst)
                                      "%d92 %d32-126")))

Theorem: smtp-cst-qtextsmtp-branches-match-alt

(defthm smtp-cst-qtextsmtp-branches-match-alt
 (implies
    (smtp-cst-matchp cst "qtextsmtp")
    (smtp-cst-list-list-alt-matchp (tree-nonleaf->branches cst)
                                   "%d32-33 / %d35-91 / %d93-126")))

Theorem: smtp-cst-string-branches-match-alt

(defthm smtp-cst-string-branches-match-alt
  (implies
       (smtp-cst-matchp cst "string")
       (smtp-cst-list-list-alt-matchp (tree-nonleaf->branches cst)
                                      "atom / quoted-string")))

Theorem: smtp-cst-ipv4-address-literal-branches-match-alt

(defthm smtp-cst-ipv4-address-literal-branches-match-alt
  (implies
       (smtp-cst-matchp cst "ipv4-address-literal")
       (smtp-cst-list-list-alt-matchp (tree-nonleaf->branches cst)
                                      "snum 3( \".\" snum )")))

Theorem: smtp-cst-ipv6-address-literal-branches-match-alt

(defthm smtp-cst-ipv6-address-literal-branches-match-alt
  (implies
       (smtp-cst-matchp cst "ipv6-address-literal")
       (smtp-cst-list-list-alt-matchp (tree-nonleaf->branches cst)
                                      "\"IPv6:\" ipv6-addr")))

Theorem: smtp-cst-general-address-literal-branches-match-alt

(defthm smtp-cst-general-address-literal-branches-match-alt
  (implies (smtp-cst-matchp cst "general-address-literal")
           (smtp-cst-list-list-alt-matchp
                (tree-nonleaf->branches cst)
                "standardized-tag \":\" 1*dcontent")))

Theorem: smtp-cst-standardized-tag-branches-match-alt

(defthm smtp-cst-standardized-tag-branches-match-alt
  (implies
       (smtp-cst-matchp cst "standardized-tag")
       (smtp-cst-list-list-alt-matchp (tree-nonleaf->branches cst)
                                      "ldh-str")))

Theorem: smtp-cst-dcontent-branches-match-alt

(defthm smtp-cst-dcontent-branches-match-alt
  (implies
       (smtp-cst-matchp cst "dcontent")
       (smtp-cst-list-list-alt-matchp (tree-nonleaf->branches cst)
                                      "%d33-90 / %d94-126")))

Theorem: smtp-cst-snum-branches-match-alt

(defthm smtp-cst-snum-branches-match-alt
  (implies
       (smtp-cst-matchp cst "snum")
       (smtp-cst-list-list-alt-matchp (tree-nonleaf->branches cst)
                                      "1*3digit")))

Theorem: smtp-cst-ipv6-addr-branches-match-alt

(defthm smtp-cst-ipv6-addr-branches-match-alt
  (implies
       (smtp-cst-matchp cst "ipv6-addr")
       (smtp-cst-list-list-alt-matchp
            (tree-nonleaf->branches cst)
            "ipv6-full / ipv6-comp / ipv6v4-full / ipv6v4-comp")))

Theorem: smtp-cst-ipv6-hex-branches-match-alt

(defthm smtp-cst-ipv6-hex-branches-match-alt
  (implies
       (smtp-cst-matchp cst "ipv6-hex")
       (smtp-cst-list-list-alt-matchp (tree-nonleaf->branches cst)
                                      "1*4hexdig")))

Theorem: smtp-cst-ipv6-full-branches-match-alt

(defthm smtp-cst-ipv6-full-branches-match-alt
 (implies
      (smtp-cst-matchp cst "ipv6-full")
      (smtp-cst-list-list-alt-matchp (tree-nonleaf->branches cst)
                                     "ipv6-hex 7( \":\" ipv6-hex )")))

Theorem: smtp-cst-ipv6-comp-branches-match-alt

(defthm smtp-cst-ipv6-comp-branches-match-alt
 (implies
  (smtp-cst-matchp cst "ipv6-comp")
  (smtp-cst-list-list-alt-matchp
   (tree-nonleaf->branches cst)
   "[ ipv6-hex *5( \":\" ipv6-hex ) ] \"::\" [ ipv6-hex *5( \":\" ipv6-hex ) ]")))

Theorem: smtp-cst-ipv6v4-full-branches-match-alt

(defthm smtp-cst-ipv6v4-full-branches-match-alt
  (implies
       (smtp-cst-matchp cst "ipv6v4-full")
       (smtp-cst-list-list-alt-matchp
            (tree-nonleaf->branches cst)
            "ipv6-hex 5( \":\" ipv6-hex ) \":\" ipv4-address-literal")))

Theorem: smtp-cst-ipv6v4-comp-branches-match-alt

(defthm smtp-cst-ipv6v4-comp-branches-match-alt
 (implies
  (smtp-cst-matchp cst "ipv6v4-comp")
  (smtp-cst-list-list-alt-matchp
   (tree-nonleaf->branches cst)
   "[ ipv6-hex *3( \":\" ipv6-hex ) ] \"::\" [ ipv6-hex *3( \":\" ipv6-hex ) \":\" ] ipv4-address-literal")))

Theorem: smtp-cst-greeting-branches-match-alt

(defthm smtp-cst-greeting-branches-match-alt
 (implies
  (smtp-cst-matchp cst "greeting")
  (smtp-cst-list-list-alt-matchp
   (tree-nonleaf->branches cst)
   "( \"220 \" ( domain / address-literal ) [ sp textstring ] crlf ) / ( \"220-\" ( domain / address-literal ) [ sp textstring ] crlf *( \"220-\" [ textstring ] crlf ) \"220\" [ sp textstring ] crlf )")))

Theorem: smtp-cst-textstring-branches-match-alt

(defthm smtp-cst-textstring-branches-match-alt
  (implies
       (smtp-cst-matchp cst "textstring")
       (smtp-cst-list-list-alt-matchp (tree-nonleaf->branches cst)
                                      "1*( %d9 / %d32-126 )")))

Theorem: smtp-cst-reply-line-branches-match-alt

(defthm smtp-cst-reply-line-branches-match-alt
 (implies
  (smtp-cst-matchp cst "reply-line")
  (smtp-cst-list-list-alt-matchp
   (tree-nonleaf->branches cst)
   "*( reply-code \"-\" [ textstring ] crlf ) reply-code [ sp textstring ] crlf")))

Theorem: smtp-cst-reply-code-branches-match-alt

(defthm smtp-cst-reply-code-branches-match-alt
  (implies
       (smtp-cst-matchp cst "reply-code")
       (smtp-cst-list-list-alt-matchp (tree-nonleaf->branches cst)
                                      "%x32-35 %x30-35 %x30-39")))

Theorem: smtp-cst-return-path-line-branches-match-alt

(defthm smtp-cst-return-path-line-branches-match-alt
  (implies (smtp-cst-matchp cst "return-path-line")
           (smtp-cst-list-list-alt-matchp
                (tree-nonleaf->branches cst)
                "\"Return-Path:\" fws reverse-path crlf")))

Theorem: smtp-cst-time-stamp-line-branches-match-alt

(defthm smtp-cst-time-stamp-line-branches-match-alt
 (implies
      (smtp-cst-matchp cst "time-stamp-line")
      (smtp-cst-list-list-alt-matchp (tree-nonleaf->branches cst)
                                     "\"Received:\" fws stamp crlf")))

Theorem: smtp-cst-stamp-branches-match-alt

(defthm smtp-cst-stamp-branches-match-alt
 (implies
  (smtp-cst-matchp cst "stamp")
  (smtp-cst-list-list-alt-matchp
      (tree-nonleaf->branches cst)
      "from-domain by-domain opt-info [ cfws ] \";\" fws date-time")))

Theorem: smtp-cst-from-domain-branches-match-alt

(defthm smtp-cst-from-domain-branches-match-alt
 (implies
      (smtp-cst-matchp cst "from-domain")
      (smtp-cst-list-list-alt-matchp (tree-nonleaf->branches cst)
                                     "\"FROM\" fws extended-domain")))

Theorem: smtp-cst-by-domain-branches-match-alt

(defthm smtp-cst-by-domain-branches-match-alt
 (implies
   (smtp-cst-matchp cst "by-domain")
   (smtp-cst-list-list-alt-matchp (tree-nonleaf->branches cst)
                                  "cfws \"BY\" fws extended-domain")))

Theorem: smtp-cst-extended-domain-branches-match-alt

(defthm smtp-cst-extended-domain-branches-match-alt
 (implies
  (smtp-cst-matchp cst "extended-domain")
  (smtp-cst-list-list-alt-matchp
   (tree-nonleaf->branches cst)
   "domain / ( domain fws \"(\" tcp-info \")\" ) / ( address-literal fws \"(\" tcp-info \")\" )")))

Theorem: smtp-cst-tcp-info-branches-match-alt

(defthm smtp-cst-tcp-info-branches-match-alt
 (implies (smtp-cst-matchp cst "tcp-info")
          (smtp-cst-list-list-alt-matchp
               (tree-nonleaf->branches cst)
               "address-literal / ( domain fws address-literal )")))

Theorem: smtp-cst-opt-info-branches-match-alt

(defthm smtp-cst-opt-info-branches-match-alt
 (implies
  (smtp-cst-matchp cst "opt-info")
  (smtp-cst-list-list-alt-matchp
   (tree-nonleaf->branches cst)
   "[ via ] [ with ] [ id ] [ for ] [ additional-registered-clauses ]")))

Theorem: smtp-cst-via-branches-match-alt

(defthm smtp-cst-via-branches-match-alt
  (implies
       (smtp-cst-matchp cst "via")
       (smtp-cst-list-list-alt-matchp (tree-nonleaf->branches cst)
                                      "cfws \"VIA\" fws link")))

Theorem: smtp-cst-with-branches-match-alt

(defthm smtp-cst-with-branches-match-alt
  (implies
       (smtp-cst-matchp cst "with")
       (smtp-cst-list-list-alt-matchp (tree-nonleaf->branches cst)
                                      "cfws \"WITH\" fws protocol")))

Theorem: smtp-cst-id-branches-match-alt

(defthm smtp-cst-id-branches-match-alt
  (implies (smtp-cst-matchp cst "id")
           (smtp-cst-list-list-alt-matchp
                (tree-nonleaf->branches cst)
                "cfws \"ID\" fws ( atom / msg-id )")))

Theorem: smtp-cst-for-branches-match-alt

(defthm smtp-cst-for-branches-match-alt
  (implies (smtp-cst-matchp cst "for")
           (smtp-cst-list-list-alt-matchp
                (tree-nonleaf->branches cst)
                "cfws \"FOR\" fws ( path / mailbox )")))

Theorem: smtp-cst-additional-registered-clauses-branches-match-alt

(defthm smtp-cst-additional-registered-clauses-branches-match-alt
  (implies
       (smtp-cst-matchp cst "additional-registered-clauses")
       (smtp-cst-list-list-alt-matchp (tree-nonleaf->branches cst)
                                      "cfws atom fws string")))

Theorem: smtp-cst-link-branches-match-alt

(defthm smtp-cst-link-branches-match-alt
  (implies
       (smtp-cst-matchp cst "link")
       (smtp-cst-list-list-alt-matchp (tree-nonleaf->branches cst)
                                      "\"TCP\" / addtl-link")))

Theorem: smtp-cst-addtl-link-branches-match-alt

(defthm smtp-cst-addtl-link-branches-match-alt
  (implies
       (smtp-cst-matchp cst "addtl-link")
       (smtp-cst-list-list-alt-matchp (tree-nonleaf->branches cst)
                                      "atom")))

Theorem: smtp-cst-protocol-branches-match-alt

(defthm smtp-cst-protocol-branches-match-alt
  (implies (smtp-cst-matchp cst "protocol")
           (smtp-cst-list-list-alt-matchp
                (tree-nonleaf->branches cst)
                "\"ESMTP\" / \"SMTP\" / attdl-protocol")))

Theorem: smtp-cst-attdl-protocol-branches-match-alt

(defthm smtp-cst-attdl-protocol-branches-match-alt
  (implies
       (smtp-cst-matchp cst "attdl-protocol")
       (smtp-cst-list-list-alt-matchp (tree-nonleaf->branches cst)
                                      "atom")))

Theorem: smtp-cst-atext-branches-match-alt

(defthm smtp-cst-atext-branches-match-alt
 (implies
  (smtp-cst-matchp cst "atext")
  (smtp-cst-list-list-alt-matchp
   (tree-nonleaf->branches cst)
   "alpha / digit / \"!\" / \"#\" / \"$\" / \"%\" / \"&\" / \"'\" / \"*\" / \"+\" / \"-\" / \"/\" / \"=\" / \"?\" / \"^\" / \"_\" / \"`\" / \"{\" / \"|\" / \"}\" / \"~\"")))

Theorem: smtp-cst-cfws-branches-match-alt

(defthm smtp-cst-cfws-branches-match-alt
  (implies (smtp-cst-matchp cst "cfws")
           (smtp-cst-list-list-alt-matchp
                (tree-nonleaf->branches cst)
                "( 1*( [ fws ] comment ) [ fws ] ) / fws")))

Theorem: smtp-cst-comment-branches-match-alt

(defthm smtp-cst-comment-branches-match-alt
  (implies (smtp-cst-matchp cst "comment")
           (smtp-cst-list-list-alt-matchp
                (tree-nonleaf->branches cst)
                "\"(\" *( [ fws ] ccontent ) [ fws ] \")\"")))

Theorem: smtp-cst-ccontent-branches-match-alt

(defthm smtp-cst-ccontent-branches-match-alt
 (implies
   (smtp-cst-matchp cst "ccontent")
   (smtp-cst-list-list-alt-matchp (tree-nonleaf->branches cst)
                                  "ctext / quoted-pair / comment")))

Theorem: smtp-cst-ctext-branches-match-alt

(defthm smtp-cst-ctext-branches-match-alt
  (implies (smtp-cst-matchp cst "ctext")
           (smtp-cst-list-list-alt-matchp
                (tree-nonleaf->branches cst)
                "%d33-39 / %d42-91 / %d93-126 / obs-ctext")))

Theorem: smtp-cst-date-time-branches-match-alt

(defthm smtp-cst-date-time-branches-match-alt
  (implies (smtp-cst-matchp cst "date-time")
           (smtp-cst-list-list-alt-matchp
                (tree-nonleaf->branches cst)
                "[ day-of-week \",\" ] date time [ cfws ]")))

Theorem: smtp-cst-date-branches-match-alt

(defthm smtp-cst-date-branches-match-alt
  (implies
       (smtp-cst-matchp cst "date")
       (smtp-cst-list-list-alt-matchp (tree-nonleaf->branches cst)
                                      "day month year")))

Theorem: smtp-cst-day-branches-match-alt

(defthm smtp-cst-day-branches-match-alt
  (implies (smtp-cst-matchp cst "day")
           (smtp-cst-list-list-alt-matchp
                (tree-nonleaf->branches cst)
                "( [ fws ] 1*2digit fws ) / obs-day")))

Theorem: smtp-cst-day-of-week-branches-match-alt

(defthm smtp-cst-day-of-week-branches-match-alt
  (implies (smtp-cst-matchp cst "day-of-week")
           (smtp-cst-list-list-alt-matchp
                (tree-nonleaf->branches cst)
                "( [ fws ] day-name ) / obs-day-of-week")))

Theorem: smtp-cst-day-name-branches-match-alt

(defthm smtp-cst-day-name-branches-match-alt
 (implies
     (smtp-cst-matchp cst "day-name")
     (smtp-cst-list-list-alt-matchp
          (tree-nonleaf->branches cst)
          "\"Mon\" / \"Tue\" / \"Wed\" / \"Thu\" / \"Fri\" / \"Sat\" / \"Sun\"")))

Theorem: smtp-cst-fws-branches-match-alt

(defthm smtp-cst-fws-branches-match-alt
  (implies (smtp-cst-matchp cst "fws")
           (smtp-cst-list-list-alt-matchp
                (tree-nonleaf->branches cst)
                "( [ *wsp crlf ] 1*wsp ) / obs-fws")))

Theorem: smtp-cst-month-branches-match-alt

(defthm smtp-cst-month-branches-match-alt
 (implies
  (smtp-cst-matchp cst "month")
  (smtp-cst-list-list-alt-matchp
   (tree-nonleaf->branches cst)
   "\"Jan\" / \"Feb\" / \"Mar\" / \"Apr\" / \"May\" / \"Jun\" / \"Jul\" / \"Aug\" / \"Sep\" / \"Oct\" / \"Nov\" / \"Dec\"")))

Theorem: smtp-cst-msg-id-branches-match-alt

(defthm smtp-cst-msg-id-branches-match-alt
  (implies (smtp-cst-matchp cst "msg-id")
           (smtp-cst-list-list-alt-matchp
                (tree-nonleaf->branches cst)
                "[ cfws ] \"<\" id-left \"@\" id-right \">\" [ cfws ]")))

Theorem: smtp-cst-id-left-branches-match-alt

(defthm smtp-cst-id-left-branches-match-alt
 (implies
     (smtp-cst-matchp cst "id-left")
     (smtp-cst-list-list-alt-matchp (tree-nonleaf->branches cst)
                                    "dot-atom-text / obs-id-left")))

Theorem: smtp-cst-dot-atom-text-branches-match-alt

(defthm smtp-cst-dot-atom-text-branches-match-alt
  (implies
       (smtp-cst-matchp cst "dot-atom-text")
       (smtp-cst-list-list-alt-matchp (tree-nonleaf->branches cst)
                                      "1*atext *( \".\" 1*atext )")))

Theorem: smtp-cst-id-right-branches-match-alt

(defthm smtp-cst-id-right-branches-match-alt
  (implies (smtp-cst-matchp cst "id-right")
           (smtp-cst-list-list-alt-matchp
                (tree-nonleaf->branches cst)
                "dot-atom-text / no-fold-literal / obs-id-right")))

Theorem: smtp-cst-no-fold-literal-branches-match-alt

(defthm smtp-cst-no-fold-literal-branches-match-alt
  (implies
       (smtp-cst-matchp cst "no-fold-literal")
       (smtp-cst-list-list-alt-matchp (tree-nonleaf->branches cst)
                                      "\"[\" *dtext \"]\"")))

Theorem: smtp-cst-dtext-branches-match-alt

(defthm smtp-cst-dtext-branches-match-alt
 (implies
  (smtp-cst-matchp cst "dtext")
  (smtp-cst-list-list-alt-matchp (tree-nonleaf->branches cst)
                                 "%d33-90 / %d94-126 / obs-dtext")))

Theorem: smtp-cst-obs-ctext-branches-match-alt

(defthm smtp-cst-obs-ctext-branches-match-alt
  (implies
       (smtp-cst-matchp cst "obs-ctext")
       (smtp-cst-list-list-alt-matchp (tree-nonleaf->branches cst)
                                      "obs-no-ws-ctl")))

Theorem: smtp-cst-obs-day-branches-match-alt

(defthm smtp-cst-obs-day-branches-match-alt
 (implies
      (smtp-cst-matchp cst "obs-day")
      (smtp-cst-list-list-alt-matchp (tree-nonleaf->branches cst)
                                     "[ cfws ] 1*2digit [ cfws ]")))

Theorem: smtp-cst-obs-day-of-week-branches-match-alt

(defthm smtp-cst-obs-day-of-week-branches-match-alt
 (implies
      (smtp-cst-matchp cst "obs-day-of-week")
      (smtp-cst-list-list-alt-matchp (tree-nonleaf->branches cst)
                                     "[ cfws ] day-name [ cfws ]")))

Theorem: smtp-cst-obs-dtext-branches-match-alt

(defthm smtp-cst-obs-dtext-branches-match-alt
 (implies
     (smtp-cst-matchp cst "obs-dtext")
     (smtp-cst-list-list-alt-matchp (tree-nonleaf->branches cst)
                                    "obs-no-ws-ctl / quoted-pair")))

Theorem: smtp-cst-obs-fws-branches-match-alt

(defthm smtp-cst-obs-fws-branches-match-alt
  (implies
       (smtp-cst-matchp cst "obs-fws")
       (smtp-cst-list-list-alt-matchp (tree-nonleaf->branches cst)
                                      "1*wsp *( crlf 1*wsp )")))

Theorem: smtp-cst-obs-id-left-branches-match-alt

(defthm smtp-cst-obs-id-left-branches-match-alt
  (implies
       (smtp-cst-matchp cst "obs-id-left")
       (smtp-cst-list-list-alt-matchp (tree-nonleaf->branches cst)
                                      "imf-local-part")))

Theorem: smtp-cst-imf-local-part-branches-match-alt

(defthm smtp-cst-imf-local-part-branches-match-alt
  (implies (smtp-cst-matchp cst "imf-local-part")
           (smtp-cst-list-list-alt-matchp
                (tree-nonleaf->branches cst)
                "dot-atom / imf-quoted-string / obs-local-part")))

Theorem: smtp-cst-dot-atom-branches-match-alt

(defthm smtp-cst-dot-atom-branches-match-alt
  (implies (smtp-cst-matchp cst "dot-atom")
           (smtp-cst-list-list-alt-matchp
                (tree-nonleaf->branches cst)
                "[ cfws ] dot-atom-text [ cfws ]")))

Theorem: smtp-cst-imf-quoted-string-branches-match-alt

(defthm smtp-cst-imf-quoted-string-branches-match-alt
 (implies
  (smtp-cst-matchp cst "imf-quoted-string")
  (smtp-cst-list-list-alt-matchp
   (tree-nonleaf->branches cst)
   "[ cfws ] dquote *( [ fws ] qcontent ) [ fws ] dquote [ cfws ]")))

Theorem: smtp-cst-obs-id-right-branches-match-alt

(defthm smtp-cst-obs-id-right-branches-match-alt
  (implies
       (smtp-cst-matchp cst "obs-id-right")
       (smtp-cst-list-list-alt-matchp (tree-nonleaf->branches cst)
                                      "imf-domain")))

Theorem: smtp-cst-imf-domain-branches-match-alt

(defthm smtp-cst-imf-domain-branches-match-alt
  (implies (smtp-cst-matchp cst "imf-domain")
           (smtp-cst-list-list-alt-matchp
                (tree-nonleaf->branches cst)
                "dot-atom / domain-literal / obs-domain")))

Theorem: smtp-cst-domain-literal-branches-match-alt

(defthm smtp-cst-domain-literal-branches-match-alt
 (implies
      (smtp-cst-matchp cst "domain-literal")
      (smtp-cst-list-list-alt-matchp
           (tree-nonleaf->branches cst)
           "[ cfws ] \"[\" *( [ fws ] dtext ) [ fws ] \"]\" [ cfws ]")))

Theorem: smtp-cst-obs-domain-branches-match-alt

(defthm smtp-cst-obs-domain-branches-match-alt
 (implies
      (smtp-cst-matchp cst "obs-domain")
      (smtp-cst-list-list-alt-matchp (tree-nonleaf->branches cst)
                                     "imf-atom *( \".\" imf-atom )")))

Theorem: smtp-cst-imf-atom-branches-match-alt

(defthm smtp-cst-imf-atom-branches-match-alt
  (implies
       (smtp-cst-matchp cst "imf-atom")
       (smtp-cst-list-list-alt-matchp (tree-nonleaf->branches cst)
                                      "[ cfws ] 1*atext [ cfws ]")))

Theorem: smtp-cst-obs-local-part-branches-match-alt

(defthm smtp-cst-obs-local-part-branches-match-alt
  (implies
       (smtp-cst-matchp cst "obs-local-part")
       (smtp-cst-list-list-alt-matchp (tree-nonleaf->branches cst)
                                      "word *( \".\" word )")))

Theorem: smtp-cst-obs-no-ws-ctl-branches-match-alt

(defthm smtp-cst-obs-no-ws-ctl-branches-match-alt
  (implies (smtp-cst-matchp cst "obs-no-ws-ctl")
           (smtp-cst-list-list-alt-matchp
                (tree-nonleaf->branches cst)
                "%d1-8 / %d11 / %d12 / %d14-31 / %d127")))

Theorem: smtp-cst-qcontent-branches-match-alt

(defthm smtp-cst-qcontent-branches-match-alt
  (implies
       (smtp-cst-matchp cst "qcontent")
       (smtp-cst-list-list-alt-matchp (tree-nonleaf->branches cst)
                                      "qtext / quoted-pair")))

Theorem: smtp-cst-qtext-branches-match-alt

(defthm smtp-cst-qtext-branches-match-alt
  (implies (smtp-cst-matchp cst "qtext")
           (smtp-cst-list-list-alt-matchp
                (tree-nonleaf->branches cst)
                "%d33 / %d35-91 / %d93-126 / obs-qtext")))

Theorem: smtp-cst-obs-qtext-branches-match-alt

(defthm smtp-cst-obs-qtext-branches-match-alt
  (implies
       (smtp-cst-matchp cst "obs-qtext")
       (smtp-cst-list-list-alt-matchp (tree-nonleaf->branches cst)
                                      "obs-no-ws-ctl")))

Theorem: smtp-cst-quoted-pair-branches-match-alt

(defthm smtp-cst-quoted-pair-branches-match-alt
  (implies (smtp-cst-matchp cst "quoted-pair")
           (smtp-cst-list-list-alt-matchp
                (tree-nonleaf->branches cst)
                "( \"\\\" ( vchar / wsp ) ) / obs-qp")))

Theorem: smtp-cst-obs-qp-branches-match-alt

(defthm smtp-cst-obs-qp-branches-match-alt
  (implies (smtp-cst-matchp cst "obs-qp")
           (smtp-cst-list-list-alt-matchp
                (tree-nonleaf->branches cst)
                "\"\\\" ( %d0 / obs-no-ws-ctl / lf / cr )")))

Theorem: smtp-cst-time-branches-match-alt

(defthm smtp-cst-time-branches-match-alt
  (implies
       (smtp-cst-matchp cst "time")
       (smtp-cst-list-list-alt-matchp (tree-nonleaf->branches cst)
                                      "time-of-day zone")))

Theorem: smtp-cst-time-of-day-branches-match-alt

(defthm smtp-cst-time-of-day-branches-match-alt
 (implies
  (smtp-cst-matchp cst "time-of-day")
  (smtp-cst-list-list-alt-matchp (tree-nonleaf->branches cst)
                                 "hour \":\" minute [ \":\" second ]")))

Theorem: smtp-cst-hour-branches-match-alt

(defthm smtp-cst-hour-branches-match-alt
  (implies
       (smtp-cst-matchp cst "hour")
       (smtp-cst-list-list-alt-matchp (tree-nonleaf->branches cst)
                                      "2digit / obs-hour")))

Theorem: smtp-cst-minute-branches-match-alt

(defthm smtp-cst-minute-branches-match-alt
  (implies
       (smtp-cst-matchp cst "minute")
       (smtp-cst-list-list-alt-matchp (tree-nonleaf->branches cst)
                                      "2digit / obs-minute")))

Theorem: smtp-cst-obs-hour-branches-match-alt

(defthm smtp-cst-obs-hour-branches-match-alt
  (implies
       (smtp-cst-matchp cst "obs-hour")
       (smtp-cst-list-list-alt-matchp (tree-nonleaf->branches cst)
                                      "[ cfws ] 2digit [ cfws ]")))

Theorem: smtp-cst-obs-minute-branches-match-alt

(defthm smtp-cst-obs-minute-branches-match-alt
  (implies
       (smtp-cst-matchp cst "obs-minute")
       (smtp-cst-list-list-alt-matchp (tree-nonleaf->branches cst)
                                      "[ cfws ] 2digit [ cfws ]")))

Theorem: smtp-cst-second-branches-match-alt

(defthm smtp-cst-second-branches-match-alt
  (implies
       (smtp-cst-matchp cst "second")
       (smtp-cst-list-list-alt-matchp (tree-nonleaf->branches cst)
                                      "2digit / obs-second")))

Theorem: smtp-cst-obs-second-branches-match-alt

(defthm smtp-cst-obs-second-branches-match-alt
  (implies
       (smtp-cst-matchp cst "obs-second")
       (smtp-cst-list-list-alt-matchp (tree-nonleaf->branches cst)
                                      "[ cfws ] 2digit [ cfws ]")))

Theorem: smtp-cst-word-branches-match-alt

(defthm smtp-cst-word-branches-match-alt
 (implies
    (smtp-cst-matchp cst "word")
    (smtp-cst-list-list-alt-matchp (tree-nonleaf->branches cst)
                                   "imf-atom / imf-quoted-string")))

Theorem: smtp-cst-year-branches-match-alt

(defthm smtp-cst-year-branches-match-alt
 (implies
  (smtp-cst-matchp cst "year")
  (smtp-cst-list-list-alt-matchp (tree-nonleaf->branches cst)
                                 "( fws 4*digit fws ) / obs-year")))

Theorem: smtp-cst-obs-year-branches-match-alt

(defthm smtp-cst-obs-year-branches-match-alt
  (implies
       (smtp-cst-matchp cst "obs-year")
       (smtp-cst-list-list-alt-matchp (tree-nonleaf->branches cst)
                                      "[ cfws ] 2*digit [ cfws ]")))

Theorem: smtp-cst-zone-branches-match-alt

(defthm smtp-cst-zone-branches-match-alt
  (implies (smtp-cst-matchp cst "zone")
           (smtp-cst-list-list-alt-matchp
                (tree-nonleaf->branches cst)
                "( fws ( \"+\" / \"-\" ) 4digit ) / obs-zone")))

Theorem: smtp-cst-obs-zone-branches-match-alt

(defthm smtp-cst-obs-zone-branches-match-alt
 (implies
  (smtp-cst-matchp cst "obs-zone")
  (smtp-cst-list-list-alt-matchp
   (tree-nonleaf->branches cst)
   "\"UT\" / \"GMT\" / \"EST\" / \"EDT\" / \"CST\" / \"CDT\" / \"MST\" / \"MDT\" / \"PST\" / \"PDT\" / %d65-73 / %d75-90 / %d97-105 / %d107-122")))

Theorem: smtp-cst-alpha-branches-match-alt

(defthm smtp-cst-alpha-branches-match-alt
  (implies
       (smtp-cst-matchp cst "alpha")
       (smtp-cst-list-list-alt-matchp (tree-nonleaf->branches cst)
                                      "%x41-5A / %x61-7A")))

Theorem: smtp-cst-cr-branches-match-alt

(defthm smtp-cst-cr-branches-match-alt
  (implies
       (smtp-cst-matchp cst "cr")
       (smtp-cst-list-list-alt-matchp (tree-nonleaf->branches cst)
                                      "%xD")))

Theorem: smtp-cst-crlf-branches-match-alt

(defthm smtp-cst-crlf-branches-match-alt
  (implies
       (smtp-cst-matchp cst "crlf")
       (smtp-cst-list-list-alt-matchp (tree-nonleaf->branches cst)
                                      "cr lf")))

Theorem: smtp-cst-digit-branches-match-alt

(defthm smtp-cst-digit-branches-match-alt
  (implies
       (smtp-cst-matchp cst "digit")
       (smtp-cst-list-list-alt-matchp (tree-nonleaf->branches cst)
                                      "%x30-39")))

Theorem: smtp-cst-dquote-branches-match-alt

(defthm smtp-cst-dquote-branches-match-alt
  (implies
       (smtp-cst-matchp cst "dquote")
       (smtp-cst-list-list-alt-matchp (tree-nonleaf->branches cst)
                                      "%x22")))

Theorem: smtp-cst-hexdig-branches-match-alt

(defthm smtp-cst-hexdig-branches-match-alt
  (implies (smtp-cst-matchp cst "hexdig")
           (smtp-cst-list-list-alt-matchp
                (tree-nonleaf->branches cst)
                "digit / \"A\" / \"B\" / \"C\" / \"D\" / \"E\" / \"F\"")))

Theorem: smtp-cst-lf-branches-match-alt

(defthm smtp-cst-lf-branches-match-alt
  (implies
       (smtp-cst-matchp cst "lf")
       (smtp-cst-list-list-alt-matchp (tree-nonleaf->branches cst)
                                      "%xA")))

Theorem: smtp-cst-sp-branches-match-alt

(defthm smtp-cst-sp-branches-match-alt
  (implies
       (smtp-cst-matchp cst "sp")
       (smtp-cst-list-list-alt-matchp (tree-nonleaf->branches cst)
                                      "%x20")))

Theorem: smtp-cst-vchar-branches-match-alt

(defthm smtp-cst-vchar-branches-match-alt
  (implies
       (smtp-cst-matchp cst "vchar")
       (smtp-cst-list-list-alt-matchp (tree-nonleaf->branches cst)
                                      "%x21-7E")))

Theorem: smtp-cst-wsp-branches-match-alt

(defthm smtp-cst-wsp-branches-match-alt
  (implies
       (smtp-cst-matchp cst "wsp")
       (smtp-cst-list-list-alt-matchp (tree-nonleaf->branches cst)
                                      "sp / htab")))

Theorem: smtp-cst-htab-branches-match-alt

(defthm smtp-cst-htab-branches-match-alt
  (implies
       (smtp-cst-matchp cst "htab")
       (smtp-cst-list-list-alt-matchp (tree-nonleaf->branches cst)
                                      "%x9")))

Theorem: smtp-cst-ehlo-concs

(defthm smtp-cst-ehlo-concs
 (implies (smtp-cst-list-list-alt-matchp
               cstss
               "\"EHLO\" sp ( domain / address-literal ) crlf")
          (or (smtp-cst-list-list-conc-matchp
                   cstss
                   "\"EHLO\" sp ( domain / address-literal ) crlf"))))

Theorem: smtp-cst-helo-concs

(defthm smtp-cst-helo-concs
 (implies
  (smtp-cst-list-list-alt-matchp cstss "\"HELO\" sp domain crlf")
  (or
   (smtp-cst-list-list-conc-matchp cstss "\"HELO\" sp domain crlf"))))

Theorem: smtp-cst-ehlo-ok-rsp-concs

(defthm smtp-cst-ehlo-ok-rsp-concs
 (implies
  (smtp-cst-list-list-alt-matchp
   cstss
   "( \"250\" sp domain [ sp ehlo-greet ] crlf ) / ( \"250-\" domain [ sp ehlo-greet ] crlf *( \"250-\" ehlo-line crlf ) \"250\" sp ehlo-line crlf )")
  (or
   (smtp-cst-list-list-conc-matchp
        cstss
        "( \"250\" sp domain [ sp ehlo-greet ] crlf )")
   (smtp-cst-list-list-conc-matchp
    cstss
    "( \"250-\" domain [ sp ehlo-greet ] crlf *( \"250-\" ehlo-line crlf ) \"250\" sp ehlo-line crlf )"))))

Theorem: smtp-cst-ehlo-greet-concs

(defthm smtp-cst-ehlo-greet-concs
 (implies
  (smtp-cst-list-list-alt-matchp cstss
                                 "1*( %d0-9 / %d11-12 / %d14-127 )")
  (or (smtp-cst-list-list-conc-matchp
           cstss
           "1*( %d0-9 / %d11-12 / %d14-127 )"))))

Theorem: smtp-cst-ehlo-line-concs

(defthm smtp-cst-ehlo-line-concs
  (implies (smtp-cst-list-list-alt-matchp
                cstss "ehlo-keyword *( sp ehlo-param )")
           (or (smtp-cst-list-list-conc-matchp
                    cstss
                    "ehlo-keyword *( sp ehlo-param )"))))

Theorem: smtp-cst-ehlo-keyword-concs

(defthm smtp-cst-ehlo-keyword-concs
  (implies (smtp-cst-list-list-alt-matchp
                cstss
                "( alpha / digit ) *( alpha / digit / \"-\" )")
           (or (smtp-cst-list-list-conc-matchp
                    cstss
                    "( alpha / digit ) *( alpha / digit / \"-\" )"))))

Theorem: smtp-cst-ehlo-param-concs

(defthm smtp-cst-ehlo-param-concs
 (implies
      (smtp-cst-list-list-alt-matchp cstss "1*( %d33-126 )")
      (or (smtp-cst-list-list-conc-matchp cstss "1*( %d33-126 )"))))

Theorem: smtp-cst-mail-concs

(defthm smtp-cst-mail-concs
 (implies
  (smtp-cst-list-list-alt-matchp
       cstss
       "\"MAIL FROM:\" reverse-path [ sp mail-parameters ] crlf")
  (or
    (smtp-cst-list-list-conc-matchp
         cstss
         "\"MAIL FROM:\" reverse-path [ sp mail-parameters ] crlf"))))

Theorem: smtp-cst-rcpt-concs

(defthm smtp-cst-rcpt-concs
 (implies
  (smtp-cst-list-list-alt-matchp
   cstss
   "\"RCPT TO:\" ( \"<Postmaster@\" domain \">\" / \"<Postmaster>\" / forward-path ) [ sp rcpt-parameters ] crlf")
  (or
   (smtp-cst-list-list-conc-matchp
    cstss
    "\"RCPT TO:\" ( \"<Postmaster@\" domain \">\" / \"<Postmaster>\" / forward-path ) [ sp rcpt-parameters ] crlf"))))

Theorem: smtp-cst-data-concs

(defthm smtp-cst-data-concs
  (implies
       (smtp-cst-list-list-alt-matchp cstss "\"DATA\" crlf")
       (or (smtp-cst-list-list-conc-matchp cstss "\"DATA\" crlf"))))

Theorem: smtp-cst-rset-concs

(defthm smtp-cst-rset-concs
  (implies
       (smtp-cst-list-list-alt-matchp cstss "\"RSET\" crlf")
       (or (smtp-cst-list-list-conc-matchp cstss "\"RSET\" crlf"))))

Theorem: smtp-cst-vrfy-concs

(defthm smtp-cst-vrfy-concs
 (implies
  (smtp-cst-list-list-alt-matchp cstss "\"VRFY\" sp string crlf")
  (or
   (smtp-cst-list-list-conc-matchp cstss "\"VRFY\" sp string crlf"))))

Theorem: smtp-cst-expn-concs

(defthm smtp-cst-expn-concs
 (implies
  (smtp-cst-list-list-alt-matchp cstss "\"EXPN\" sp string crlf")
  (or
   (smtp-cst-list-list-conc-matchp cstss "\"EXPN\" sp string crlf"))))

Theorem: smtp-cst-help-concs

(defthm smtp-cst-help-concs
 (implies
   (smtp-cst-list-list-alt-matchp cstss "\"HELP\" [ sp string ] crlf")
   (or (smtp-cst-list-list-conc-matchp
            cstss "\"HELP\" [ sp string ] crlf"))))

Theorem: smtp-cst-noop-concs

(defthm smtp-cst-noop-concs
 (implies
   (smtp-cst-list-list-alt-matchp cstss "\"NOOP\" [ sp string ] crlf")
   (or (smtp-cst-list-list-conc-matchp
            cstss "\"NOOP\" [ sp string ] crlf"))))

Theorem: smtp-cst-quit-concs

(defthm smtp-cst-quit-concs
  (implies
       (smtp-cst-list-list-alt-matchp cstss "\"QUIT\" crlf")
       (or (smtp-cst-list-list-conc-matchp cstss "\"QUIT\" crlf"))))

Theorem: smtp-cst-reverse-path-concs

(defthm smtp-cst-reverse-path-concs
  (implies (smtp-cst-list-list-alt-matchp cstss "path / \"<>\"")
           (or (smtp-cst-list-list-conc-matchp cstss "path")
               (smtp-cst-list-list-conc-matchp cstss "\"<>\""))))

Theorem: smtp-cst-forward-path-concs

(defthm smtp-cst-forward-path-concs
  (implies (smtp-cst-list-list-alt-matchp cstss "path")
           (or (smtp-cst-list-list-conc-matchp cstss "path"))))

Theorem: smtp-cst-path-concs

(defthm smtp-cst-path-concs
  (implies (smtp-cst-list-list-alt-matchp
                cstss "\"<\" [ a-d-l \":\" ] mailbox \">\"")
           (or (smtp-cst-list-list-conc-matchp
                    cstss
                    "\"<\" [ a-d-l \":\" ] mailbox \">\""))))

Theorem: smtp-cst-a-d-l-concs

(defthm smtp-cst-a-d-l-concs
  (implies (smtp-cst-list-list-alt-matchp
                cstss "at-domain *( \",\" at-domain )")
           (or (smtp-cst-list-list-conc-matchp
                    cstss "at-domain *( \",\" at-domain )"))))

Theorem: smtp-cst-at-domain-concs

(defthm smtp-cst-at-domain-concs
 (implies (smtp-cst-list-list-alt-matchp cstss "\"@\" domain")
          (or (smtp-cst-list-list-conc-matchp cstss "\"@\" domain"))))

Theorem: smtp-cst-mail-parameters-concs

(defthm smtp-cst-mail-parameters-concs
  (implies (smtp-cst-list-list-alt-matchp
                cstss "esmtp-param *( sp esmtp-param )")
           (or (smtp-cst-list-list-conc-matchp
                    cstss
                    "esmtp-param *( sp esmtp-param )"))))

Theorem: smtp-cst-rcpt-parameters-concs

(defthm smtp-cst-rcpt-parameters-concs
  (implies (smtp-cst-list-list-alt-matchp
                cstss "esmtp-param *( sp esmtp-param )")
           (or (smtp-cst-list-list-conc-matchp
                    cstss
                    "esmtp-param *( sp esmtp-param )"))))

Theorem: smtp-cst-esmtp-param-concs

(defthm smtp-cst-esmtp-param-concs
  (implies (smtp-cst-list-list-alt-matchp
                cstss
                "esmtp-keyword [ \"=\" esmtp-value ]")
           (or (smtp-cst-list-list-conc-matchp
                    cstss
                    "esmtp-keyword [ \"=\" esmtp-value ]"))))

Theorem: smtp-cst-esmtp-keyword-concs

(defthm smtp-cst-esmtp-keyword-concs
  (implies (smtp-cst-list-list-alt-matchp
                cstss
                "( alpha / digit ) *( alpha / digit / \"-\" )")
           (or (smtp-cst-list-list-conc-matchp
                    cstss
                    "( alpha / digit ) *( alpha / digit / \"-\" )"))))

Theorem: smtp-cst-esmtp-value-concs

(defthm smtp-cst-esmtp-value-concs
 (implies
    (smtp-cst-list-list-alt-matchp cstss "1*( %d33-60 / %d62-126 )")
    (or (smtp-cst-list-list-conc-matchp
             cstss "1*( %d33-60 / %d62-126 )"))))

Theorem: smtp-cst-keyword-concs

(defthm smtp-cst-keyword-concs
  (implies (smtp-cst-list-list-alt-matchp cstss "ldh-str")
           (or (smtp-cst-list-list-conc-matchp cstss "ldh-str"))))

Theorem: smtp-cst-argument-concs

(defthm smtp-cst-argument-concs
  (implies (smtp-cst-list-list-alt-matchp cstss "atom")
           (or (smtp-cst-list-list-conc-matchp cstss "atom"))))

Theorem: smtp-cst-domain-concs

(defthm smtp-cst-domain-concs
  (implies (smtp-cst-list-list-alt-matchp
                cstss "sub-domain *( \".\" sub-domain )")
           (or (smtp-cst-list-list-conc-matchp
                    cstss
                    "sub-domain *( \".\" sub-domain )"))))

Theorem: smtp-cst-sub-domain-concs

(defthm smtp-cst-sub-domain-concs
 (implies
  (smtp-cst-list-list-alt-matchp cstss "let-dig [ ldh-str ]")
  (or
     (smtp-cst-list-list-conc-matchp cstss "let-dig [ ldh-str ]"))))

Theorem: smtp-cst-let-dig-concs

(defthm smtp-cst-let-dig-concs
  (implies (smtp-cst-list-list-alt-matchp cstss "alpha / digit")
           (or (smtp-cst-list-list-conc-matchp cstss "alpha")
               (smtp-cst-list-list-conc-matchp cstss "digit"))))

Theorem: smtp-cst-ldh-str-concs

(defthm smtp-cst-ldh-str-concs
 (implies
  (smtp-cst-list-list-alt-matchp cstss
                                 "*( alpha / digit / \"-\" ) let-dig")
  (or (smtp-cst-list-list-conc-matchp
           cstss
           "*( alpha / digit / \"-\" ) let-dig"))))

Theorem: smtp-cst-address-literal-concs

(defthm smtp-cst-address-literal-concs
 (implies
  (smtp-cst-list-list-alt-matchp
   cstss
   "\"[\" ( ipv4-address-literal / ipv6-address-literal / general-address-literal ) \"]\"")
  (or
   (smtp-cst-list-list-conc-matchp
    cstss
    "\"[\" ( ipv4-address-literal / ipv6-address-literal / general-address-literal ) \"]\""))))

Theorem: smtp-cst-mailbox-concs

(defthm smtp-cst-mailbox-concs
 (implies (smtp-cst-list-list-alt-matchp
               cstss
               "local-part \"@\" ( domain / address-literal )")
          (or (smtp-cst-list-list-conc-matchp
                   cstss
                   "local-part \"@\" ( domain / address-literal )"))))

Theorem: smtp-cst-local-part-concs

(defthm smtp-cst-local-part-concs
 (implies
  (smtp-cst-list-list-alt-matchp cstss "dot-string / quoted-string")
  (or (smtp-cst-list-list-conc-matchp cstss "dot-string")
      (smtp-cst-list-list-conc-matchp cstss "quoted-string"))))

Theorem: smtp-cst-dot-string-concs

(defthm smtp-cst-dot-string-concs
 (implies
  (smtp-cst-list-list-alt-matchp cstss "atom *( \".\" atom )")
  (or (smtp-cst-list-list-conc-matchp cstss "atom *( \".\" atom )"))))

Theorem: smtp-cst-atom-concs

(defthm smtp-cst-atom-concs
  (implies (smtp-cst-list-list-alt-matchp cstss "1*atext")
           (or (smtp-cst-list-list-conc-matchp cstss "1*atext"))))

Theorem: smtp-cst-quoted-string-concs

(defthm smtp-cst-quoted-string-concs
  (implies (smtp-cst-list-list-alt-matchp
                cstss "dquote *qcontentsmtp dquote")
           (or (smtp-cst-list-list-conc-matchp
                    cstss "dquote *qcontentsmtp dquote"))))

Theorem: smtp-cst-qcontentsmtp-concs

(defthm smtp-cst-qcontentsmtp-concs
 (implies
     (smtp-cst-list-list-alt-matchp
          cstss "qtextsmtp / quoted-pairsmtp")
     (or (smtp-cst-list-list-conc-matchp cstss "qtextsmtp")
         (smtp-cst-list-list-conc-matchp cstss "quoted-pairsmtp"))))

Theorem: smtp-cst-quoted-pairsmtp-concs

(defthm smtp-cst-quoted-pairsmtp-concs
  (implies
       (smtp-cst-list-list-alt-matchp cstss "%d92 %d32-126")
       (or (smtp-cst-list-list-conc-matchp cstss "%d92 %d32-126"))))

Theorem: smtp-cst-qtextsmtp-concs

(defthm smtp-cst-qtextsmtp-concs
  (implies (smtp-cst-list-list-alt-matchp
                cstss "%d32-33 / %d35-91 / %d93-126")
           (or (smtp-cst-list-list-conc-matchp cstss "%d32-33")
               (smtp-cst-list-list-conc-matchp cstss "%d35-91")
               (smtp-cst-list-list-conc-matchp cstss "%d93-126"))))

Theorem: smtp-cst-string-concs

(defthm smtp-cst-string-concs
  (implies
       (smtp-cst-list-list-alt-matchp cstss "atom / quoted-string")
       (or (smtp-cst-list-list-conc-matchp cstss "atom")
           (smtp-cst-list-list-conc-matchp cstss "quoted-string"))))

Theorem: smtp-cst-ipv4-address-literal-concs

(defthm smtp-cst-ipv4-address-literal-concs
 (implies
  (smtp-cst-list-list-alt-matchp cstss "snum 3( \".\" snum )")
  (or (smtp-cst-list-list-conc-matchp cstss "snum 3( \".\" snum )"))))

Theorem: smtp-cst-ipv6-address-literal-concs

(defthm smtp-cst-ipv6-address-literal-concs
 (implies
   (smtp-cst-list-list-alt-matchp cstss "\"IPv6:\" ipv6-addr")
   (or (smtp-cst-list-list-conc-matchp cstss "\"IPv6:\" ipv6-addr"))))

Theorem: smtp-cst-general-address-literal-concs

(defthm smtp-cst-general-address-literal-concs
  (implies (smtp-cst-list-list-alt-matchp
                cstss "standardized-tag \":\" 1*dcontent")
           (or (smtp-cst-list-list-conc-matchp
                    cstss
                    "standardized-tag \":\" 1*dcontent"))))

Theorem: smtp-cst-standardized-tag-concs

(defthm smtp-cst-standardized-tag-concs
  (implies (smtp-cst-list-list-alt-matchp cstss "ldh-str")
           (or (smtp-cst-list-list-conc-matchp cstss "ldh-str"))))

Theorem: smtp-cst-dcontent-concs

(defthm smtp-cst-dcontent-concs
 (implies (smtp-cst-list-list-alt-matchp cstss "%d33-90 / %d94-126")
          (or (smtp-cst-list-list-conc-matchp cstss "%d33-90")
              (smtp-cst-list-list-conc-matchp cstss "%d94-126"))))

Theorem: smtp-cst-snum-concs

(defthm smtp-cst-snum-concs
  (implies (smtp-cst-list-list-alt-matchp cstss "1*3digit")
           (or (smtp-cst-list-list-conc-matchp cstss "1*3digit"))))

Theorem: smtp-cst-ipv6-addr-concs

(defthm smtp-cst-ipv6-addr-concs
  (implies
       (smtp-cst-list-list-alt-matchp
            cstss
            "ipv6-full / ipv6-comp / ipv6v4-full / ipv6v4-comp")
       (or (smtp-cst-list-list-conc-matchp cstss "ipv6-full")
           (smtp-cst-list-list-conc-matchp cstss "ipv6-comp")
           (smtp-cst-list-list-conc-matchp cstss "ipv6v4-full")
           (smtp-cst-list-list-conc-matchp cstss "ipv6v4-comp"))))

Theorem: smtp-cst-ipv6-hex-concs

(defthm smtp-cst-ipv6-hex-concs
  (implies (smtp-cst-list-list-alt-matchp cstss "1*4hexdig")
           (or (smtp-cst-list-list-conc-matchp cstss "1*4hexdig"))))

Theorem: smtp-cst-ipv6-full-concs

(defthm smtp-cst-ipv6-full-concs
 (implies
  (smtp-cst-list-list-alt-matchp cstss "ipv6-hex 7( \":\" ipv6-hex )")
  (or (smtp-cst-list-list-conc-matchp
           cstss "ipv6-hex 7( \":\" ipv6-hex )"))))

Theorem: smtp-cst-ipv6-comp-concs

(defthm smtp-cst-ipv6-comp-concs
 (implies
  (smtp-cst-list-list-alt-matchp
   cstss
   "[ ipv6-hex *5( \":\" ipv6-hex ) ] \"::\" [ ipv6-hex *5( \":\" ipv6-hex ) ]")
  (or
   (smtp-cst-list-list-conc-matchp
    cstss
    "[ ipv6-hex *5( \":\" ipv6-hex ) ] \"::\" [ ipv6-hex *5( \":\" ipv6-hex ) ]"))))

Theorem: smtp-cst-ipv6v4-full-concs

(defthm smtp-cst-ipv6v4-full-concs
 (implies
  (smtp-cst-list-list-alt-matchp
       cstss
       "ipv6-hex 5( \":\" ipv6-hex ) \":\" ipv4-address-literal")
  (or (smtp-cst-list-list-conc-matchp
           cstss
           "ipv6-hex 5( \":\" ipv6-hex ) \":\" ipv4-address-literal"))))

Theorem: smtp-cst-ipv6v4-comp-concs

(defthm smtp-cst-ipv6v4-comp-concs
 (implies
  (smtp-cst-list-list-alt-matchp
   cstss
   "[ ipv6-hex *3( \":\" ipv6-hex ) ] \"::\" [ ipv6-hex *3( \":\" ipv6-hex ) \":\" ] ipv4-address-literal")
  (or
   (smtp-cst-list-list-conc-matchp
    cstss
    "[ ipv6-hex *3( \":\" ipv6-hex ) ] \"::\" [ ipv6-hex *3( \":\" ipv6-hex ) \":\" ] ipv4-address-literal"))))

Theorem: smtp-cst-greeting-concs

(defthm smtp-cst-greeting-concs
 (implies
  (smtp-cst-list-list-alt-matchp
   cstss
   "( \"220 \" ( domain / address-literal ) [ sp textstring ] crlf ) / ( \"220-\" ( domain / address-literal ) [ sp textstring ] crlf *( \"220-\" [ textstring ] crlf ) \"220\" [ sp textstring ] crlf )")
  (or
   (smtp-cst-list-list-conc-matchp
    cstss
    "( \"220 \" ( domain / address-literal ) [ sp textstring ] crlf )")
   (smtp-cst-list-list-conc-matchp
    cstss
    "( \"220-\" ( domain / address-literal ) [ sp textstring ] crlf *( \"220-\" [ textstring ] crlf ) \"220\" [ sp textstring ] crlf )"))))

Theorem: smtp-cst-textstring-concs

(defthm smtp-cst-textstring-concs
 (implies
  (smtp-cst-list-list-alt-matchp cstss "1*( %d9 / %d32-126 )")
  (or
    (smtp-cst-list-list-conc-matchp cstss "1*( %d9 / %d32-126 )"))))

Theorem: smtp-cst-reply-line-concs

(defthm smtp-cst-reply-line-concs
 (implies
  (smtp-cst-list-list-alt-matchp
   cstss
   "*( reply-code \"-\" [ textstring ] crlf ) reply-code [ sp textstring ] crlf")
  (or
   (smtp-cst-list-list-conc-matchp
    cstss
    "*( reply-code \"-\" [ textstring ] crlf ) reply-code [ sp textstring ] crlf"))))

Theorem: smtp-cst-reply-code-concs

(defthm smtp-cst-reply-code-concs
 (implies
     (smtp-cst-list-list-alt-matchp cstss "%x32-35 %x30-35 %x30-39")
     (or (smtp-cst-list-list-conc-matchp
              cstss "%x32-35 %x30-35 %x30-39"))))

Theorem: smtp-cst-return-path-line-concs

(defthm smtp-cst-return-path-line-concs
  (implies (smtp-cst-list-list-alt-matchp
                cstss
                "\"Return-Path:\" fws reverse-path crlf")
           (or (smtp-cst-list-list-conc-matchp
                    cstss
                    "\"Return-Path:\" fws reverse-path crlf"))))

Theorem: smtp-cst-time-stamp-line-concs

(defthm smtp-cst-time-stamp-line-concs
 (implies
  (smtp-cst-list-list-alt-matchp cstss "\"Received:\" fws stamp crlf")
  (or (smtp-cst-list-list-conc-matchp
           cstss "\"Received:\" fws stamp crlf"))))

Theorem: smtp-cst-stamp-concs

(defthm smtp-cst-stamp-concs
 (implies
  (smtp-cst-list-list-alt-matchp
       cstss
       "from-domain by-domain opt-info [ cfws ] \";\" fws date-time")
  (or
   (smtp-cst-list-list-conc-matchp
     cstss
     "from-domain by-domain opt-info [ cfws ] \";\" fws date-time"))))

Theorem: smtp-cst-from-domain-concs

(defthm smtp-cst-from-domain-concs
 (implies
  (smtp-cst-list-list-alt-matchp cstss "\"FROM\" fws extended-domain")
  (or (smtp-cst-list-list-conc-matchp
           cstss "\"FROM\" fws extended-domain"))))

Theorem: smtp-cst-by-domain-concs

(defthm smtp-cst-by-domain-concs
  (implies (smtp-cst-list-list-alt-matchp
                cstss "cfws \"BY\" fws extended-domain")
           (or (smtp-cst-list-list-conc-matchp
                    cstss
                    "cfws \"BY\" fws extended-domain"))))

Theorem: smtp-cst-extended-domain-concs

(defthm smtp-cst-extended-domain-concs
 (implies
  (smtp-cst-list-list-alt-matchp
   cstss
   "domain / ( domain fws \"(\" tcp-info \")\" ) / ( address-literal fws \"(\" tcp-info \")\" )")
  (or (smtp-cst-list-list-conc-matchp cstss "domain")
      (smtp-cst-list-list-conc-matchp
           cstss "( domain fws \"(\" tcp-info \")\" )")
      (smtp-cst-list-list-conc-matchp
           cstss
           "( address-literal fws \"(\" tcp-info \")\" )"))))

Theorem: smtp-cst-tcp-info-concs

(defthm smtp-cst-tcp-info-concs
  (implies
       (smtp-cst-list-list-alt-matchp
            cstss
            "address-literal / ( domain fws address-literal )")
       (or (smtp-cst-list-list-conc-matchp cstss "address-literal")
           (smtp-cst-list-list-conc-matchp
                cstss
                "( domain fws address-literal )"))))

Theorem: smtp-cst-opt-info-concs

(defthm smtp-cst-opt-info-concs
 (implies
  (smtp-cst-list-list-alt-matchp
   cstss
   "[ via ] [ with ] [ id ] [ for ] [ additional-registered-clauses ]")
  (or
   (smtp-cst-list-list-conc-matchp
    cstss
    "[ via ] [ with ] [ id ] [ for ] [ additional-registered-clauses ]"))))

Theorem: smtp-cst-via-concs

(defthm smtp-cst-via-concs
 (implies
  (smtp-cst-list-list-alt-matchp cstss "cfws \"VIA\" fws link")
  (or
     (smtp-cst-list-list-conc-matchp cstss "cfws \"VIA\" fws link"))))

Theorem: smtp-cst-with-concs

(defthm smtp-cst-with-concs
 (implies
    (smtp-cst-list-list-alt-matchp cstss "cfws \"WITH\" fws protocol")
    (or (smtp-cst-list-list-conc-matchp
             cstss "cfws \"WITH\" fws protocol"))))

Theorem: smtp-cst-id-concs

(defthm smtp-cst-id-concs
  (implies (smtp-cst-list-list-alt-matchp
                cstss "cfws \"ID\" fws ( atom / msg-id )")
           (or (smtp-cst-list-list-conc-matchp
                    cstss
                    "cfws \"ID\" fws ( atom / msg-id )"))))

Theorem: smtp-cst-for-concs

(defthm smtp-cst-for-concs
  (implies (smtp-cst-list-list-alt-matchp
                cstss
                "cfws \"FOR\" fws ( path / mailbox )")
           (or (smtp-cst-list-list-conc-matchp
                    cstss
                    "cfws \"FOR\" fws ( path / mailbox )"))))

Theorem: smtp-cst-additional-registered-clauses-concs

(defthm smtp-cst-additional-registered-clauses-concs
 (implies
  (smtp-cst-list-list-alt-matchp cstss "cfws atom fws string")
  (or
    (smtp-cst-list-list-conc-matchp cstss "cfws atom fws string"))))

Theorem: smtp-cst-link-concs

(defthm smtp-cst-link-concs
 (implies (smtp-cst-list-list-alt-matchp cstss "\"TCP\" / addtl-link")
          (or (smtp-cst-list-list-conc-matchp cstss "\"TCP\"")
              (smtp-cst-list-list-conc-matchp cstss "addtl-link"))))

Theorem: smtp-cst-addtl-link-concs

(defthm smtp-cst-addtl-link-concs
  (implies (smtp-cst-list-list-alt-matchp cstss "atom")
           (or (smtp-cst-list-list-conc-matchp cstss "atom"))))

Theorem: smtp-cst-protocol-concs

(defthm smtp-cst-protocol-concs
 (implies
      (smtp-cst-list-list-alt-matchp
           cstss
           "\"ESMTP\" / \"SMTP\" / attdl-protocol")
      (or (smtp-cst-list-list-conc-matchp cstss "\"ESMTP\"")
          (smtp-cst-list-list-conc-matchp cstss "\"SMTP\"")
          (smtp-cst-list-list-conc-matchp cstss "attdl-protocol"))))

Theorem: smtp-cst-attdl-protocol-concs

(defthm smtp-cst-attdl-protocol-concs
  (implies (smtp-cst-list-list-alt-matchp cstss "atom")
           (or (smtp-cst-list-list-conc-matchp cstss "atom"))))

Theorem: smtp-cst-atext-concs

(defthm smtp-cst-atext-concs
 (implies
  (smtp-cst-list-list-alt-matchp
   cstss
   "alpha / digit / \"!\" / \"#\" / \"$\" / \"%\" / \"&\" / \"'\" / \"*\" / \"+\" / \"-\" / \"/\" / \"=\" / \"?\" / \"^\" / \"_\" / \"`\" / \"{\" / \"|\" / \"}\" / \"~\"")
  (or (smtp-cst-list-list-conc-matchp cstss "alpha")
      (smtp-cst-list-list-conc-matchp cstss "digit")
      (smtp-cst-list-list-conc-matchp cstss "\"!\"")
      (smtp-cst-list-list-conc-matchp cstss "\"#\"")
      (smtp-cst-list-list-conc-matchp cstss "\"$\"")
      (smtp-cst-list-list-conc-matchp cstss "\"%\"")
      (smtp-cst-list-list-conc-matchp cstss "\"&\"")
      (smtp-cst-list-list-conc-matchp cstss "\"'\"")
      (smtp-cst-list-list-conc-matchp cstss "\"*\"")
      (smtp-cst-list-list-conc-matchp cstss "\"+\"")
      (smtp-cst-list-list-conc-matchp cstss "\"-\"")
      (smtp-cst-list-list-conc-matchp cstss "\"/\"")
      (smtp-cst-list-list-conc-matchp cstss "\"=\"")
      (smtp-cst-list-list-conc-matchp cstss "\"?\"")
      (smtp-cst-list-list-conc-matchp cstss "\"^\"")
      (smtp-cst-list-list-conc-matchp cstss "\"_\"")
      (smtp-cst-list-list-conc-matchp cstss "\"`\"")
      (smtp-cst-list-list-conc-matchp cstss "\"{\"")
      (smtp-cst-list-list-conc-matchp cstss "\"|\"")
      (smtp-cst-list-list-conc-matchp cstss "\"}\"")
      (smtp-cst-list-list-conc-matchp cstss "\"~\""))))

Theorem: smtp-cst-cfws-concs

(defthm smtp-cst-cfws-concs
  (implies (smtp-cst-list-list-alt-matchp
                cstss
                "( 1*( [ fws ] comment ) [ fws ] ) / fws")
           (or (smtp-cst-list-list-conc-matchp
                    cstss
                    "( 1*( [ fws ] comment ) [ fws ] )")
               (smtp-cst-list-list-conc-matchp cstss "fws"))))

Theorem: smtp-cst-comment-concs

(defthm smtp-cst-comment-concs
  (implies (smtp-cst-list-list-alt-matchp
                cstss
                "\"(\" *( [ fws ] ccontent ) [ fws ] \")\"")
           (or (smtp-cst-list-list-conc-matchp
                    cstss
                    "\"(\" *( [ fws ] ccontent ) [ fws ] \")\""))))

Theorem: smtp-cst-ccontent-concs

(defthm smtp-cst-ccontent-concs
  (implies (smtp-cst-list-list-alt-matchp
                cstss "ctext / quoted-pair / comment")
           (or (smtp-cst-list-list-conc-matchp cstss "ctext")
               (smtp-cst-list-list-conc-matchp cstss "quoted-pair")
               (smtp-cst-list-list-conc-matchp cstss "comment"))))

Theorem: smtp-cst-ctext-concs

(defthm smtp-cst-ctext-concs
  (implies (smtp-cst-list-list-alt-matchp
                cstss
                "%d33-39 / %d42-91 / %d93-126 / obs-ctext")
           (or (smtp-cst-list-list-conc-matchp cstss "%d33-39")
               (smtp-cst-list-list-conc-matchp cstss "%d42-91")
               (smtp-cst-list-list-conc-matchp cstss "%d93-126")
               (smtp-cst-list-list-conc-matchp cstss "obs-ctext"))))

Theorem: smtp-cst-date-time-concs

(defthm smtp-cst-date-time-concs
  (implies (smtp-cst-list-list-alt-matchp
                cstss
                "[ day-of-week \",\" ] date time [ cfws ]")
           (or (smtp-cst-list-list-conc-matchp
                    cstss
                    "[ day-of-week \",\" ] date time [ cfws ]"))))

Theorem: smtp-cst-date-concs

(defthm smtp-cst-date-concs
 (implies
      (smtp-cst-list-list-alt-matchp cstss "day month year")
      (or (smtp-cst-list-list-conc-matchp cstss "day month year"))))

Theorem: smtp-cst-day-concs

(defthm smtp-cst-day-concs
 (implies
  (smtp-cst-list-list-alt-matchp
       cstss
       "( [ fws ] 1*2digit fws ) / obs-day")
  (or
   (smtp-cst-list-list-conc-matchp cstss "( [ fws ] 1*2digit fws )")
   (smtp-cst-list-list-conc-matchp cstss "obs-day"))))

Theorem: smtp-cst-day-of-week-concs

(defthm smtp-cst-day-of-week-concs
 (implies
   (smtp-cst-list-list-alt-matchp
        cstss
        "( [ fws ] day-name ) / obs-day-of-week")
   (or (smtp-cst-list-list-conc-matchp cstss "( [ fws ] day-name )")
       (smtp-cst-list-list-conc-matchp cstss "obs-day-of-week"))))

Theorem: smtp-cst-day-name-concs

(defthm smtp-cst-day-name-concs
  (implies
       (smtp-cst-list-list-alt-matchp
            cstss
            "\"Mon\" / \"Tue\" / \"Wed\" / \"Thu\" / \"Fri\" / \"Sat\" / \"Sun\"")
       (or (smtp-cst-list-list-conc-matchp cstss "\"Mon\"")
           (smtp-cst-list-list-conc-matchp cstss "\"Tue\"")
           (smtp-cst-list-list-conc-matchp cstss "\"Wed\"")
           (smtp-cst-list-list-conc-matchp cstss "\"Thu\"")
           (smtp-cst-list-list-conc-matchp cstss "\"Fri\"")
           (smtp-cst-list-list-conc-matchp cstss "\"Sat\"")
           (smtp-cst-list-list-conc-matchp cstss "\"Sun\""))))

Theorem: smtp-cst-fws-concs

(defthm smtp-cst-fws-concs
 (implies
  (smtp-cst-list-list-alt-matchp
       cstss
       "( [ *wsp crlf ] 1*wsp ) / obs-fws")
  (or
    (smtp-cst-list-list-conc-matchp cstss "( [ *wsp crlf ] 1*wsp )")
    (smtp-cst-list-list-conc-matchp cstss "obs-fws"))))

Theorem: smtp-cst-month-concs

(defthm smtp-cst-month-concs
 (implies
  (smtp-cst-list-list-alt-matchp
   cstss
   "\"Jan\" / \"Feb\" / \"Mar\" / \"Apr\" / \"May\" / \"Jun\" / \"Jul\" / \"Aug\" / \"Sep\" / \"Oct\" / \"Nov\" / \"Dec\"")
  (or (smtp-cst-list-list-conc-matchp cstss "\"Jan\"")
      (smtp-cst-list-list-conc-matchp cstss "\"Feb\"")
      (smtp-cst-list-list-conc-matchp cstss "\"Mar\"")
      (smtp-cst-list-list-conc-matchp cstss "\"Apr\"")
      (smtp-cst-list-list-conc-matchp cstss "\"May\"")
      (smtp-cst-list-list-conc-matchp cstss "\"Jun\"")
      (smtp-cst-list-list-conc-matchp cstss "\"Jul\"")
      (smtp-cst-list-list-conc-matchp cstss "\"Aug\"")
      (smtp-cst-list-list-conc-matchp cstss "\"Sep\"")
      (smtp-cst-list-list-conc-matchp cstss "\"Oct\"")
      (smtp-cst-list-list-conc-matchp cstss "\"Nov\"")
      (smtp-cst-list-list-conc-matchp cstss "\"Dec\""))))

Theorem: smtp-cst-msg-id-concs

(defthm smtp-cst-msg-id-concs
  (implies
       (smtp-cst-list-list-alt-matchp
            cstss
            "[ cfws ] \"<\" id-left \"@\" id-right \">\" [ cfws ]")
       (or (smtp-cst-list-list-conc-matchp
                cstss
                "[ cfws ] \"<\" id-left \"@\" id-right \">\" [ cfws ]"))))

Theorem: smtp-cst-id-left-concs

(defthm smtp-cst-id-left-concs
  (implies
       (smtp-cst-list-list-alt-matchp
            cstss "dot-atom-text / obs-id-left")
       (or (smtp-cst-list-list-conc-matchp cstss "dot-atom-text")
           (smtp-cst-list-list-conc-matchp cstss "obs-id-left"))))

Theorem: smtp-cst-dot-atom-text-concs

(defthm smtp-cst-dot-atom-text-concs
 (implies
    (smtp-cst-list-list-alt-matchp cstss "1*atext *( \".\" 1*atext )")
    (or (smtp-cst-list-list-conc-matchp
             cstss "1*atext *( \".\" 1*atext )"))))

Theorem: smtp-cst-id-right-concs

(defthm smtp-cst-id-right-concs
  (implies
       (smtp-cst-list-list-alt-matchp
            cstss
            "dot-atom-text / no-fold-literal / obs-id-right")
       (or (smtp-cst-list-list-conc-matchp cstss "dot-atom-text")
           (smtp-cst-list-list-conc-matchp cstss "no-fold-literal")
           (smtp-cst-list-list-conc-matchp cstss "obs-id-right"))))

Theorem: smtp-cst-no-fold-literal-concs

(defthm smtp-cst-no-fold-literal-concs
 (implies
      (smtp-cst-list-list-alt-matchp cstss "\"[\" *dtext \"]\"")
      (or (smtp-cst-list-list-conc-matchp cstss "\"[\" *dtext \"]\""))))

Theorem: smtp-cst-dtext-concs

(defthm smtp-cst-dtext-concs
  (implies (smtp-cst-list-list-alt-matchp
                cstss "%d33-90 / %d94-126 / obs-dtext")
           (or (smtp-cst-list-list-conc-matchp cstss "%d33-90")
               (smtp-cst-list-list-conc-matchp cstss "%d94-126")
               (smtp-cst-list-list-conc-matchp cstss "obs-dtext"))))

Theorem: smtp-cst-obs-ctext-concs

(defthm smtp-cst-obs-ctext-concs
  (implies
       (smtp-cst-list-list-alt-matchp cstss "obs-no-ws-ctl")
       (or (smtp-cst-list-list-conc-matchp cstss "obs-no-ws-ctl"))))

Theorem: smtp-cst-obs-day-concs

(defthm smtp-cst-obs-day-concs
 (implies
  (smtp-cst-list-list-alt-matchp cstss "[ cfws ] 1*2digit [ cfws ]")
  (or (smtp-cst-list-list-conc-matchp
           cstss "[ cfws ] 1*2digit [ cfws ]"))))

Theorem: smtp-cst-obs-day-of-week-concs

(defthm smtp-cst-obs-day-of-week-concs
 (implies
  (smtp-cst-list-list-alt-matchp cstss "[ cfws ] day-name [ cfws ]")
  (or (smtp-cst-list-list-conc-matchp
           cstss "[ cfws ] day-name [ cfws ]"))))

Theorem: smtp-cst-obs-dtext-concs

(defthm smtp-cst-obs-dtext-concs
  (implies
       (smtp-cst-list-list-alt-matchp
            cstss "obs-no-ws-ctl / quoted-pair")
       (or (smtp-cst-list-list-conc-matchp cstss "obs-no-ws-ctl")
           (smtp-cst-list-list-conc-matchp cstss "quoted-pair"))))

Theorem: smtp-cst-obs-fws-concs

(defthm smtp-cst-obs-fws-concs
 (implies
  (smtp-cst-list-list-alt-matchp cstss "1*wsp *( crlf 1*wsp )")
  (or
   (smtp-cst-list-list-conc-matchp cstss "1*wsp *( crlf 1*wsp )"))))

Theorem: smtp-cst-obs-id-left-concs

(defthm smtp-cst-obs-id-left-concs
 (implies
      (smtp-cst-list-list-alt-matchp cstss "imf-local-part")
      (or (smtp-cst-list-list-conc-matchp cstss "imf-local-part"))))

Theorem: smtp-cst-imf-local-part-concs

(defthm smtp-cst-imf-local-part-concs
 (implies
      (smtp-cst-list-list-alt-matchp
           cstss
           "dot-atom / imf-quoted-string / obs-local-part")
      (or (smtp-cst-list-list-conc-matchp cstss "dot-atom")
          (smtp-cst-list-list-conc-matchp cstss "imf-quoted-string")
          (smtp-cst-list-list-conc-matchp cstss "obs-local-part"))))

Theorem: smtp-cst-dot-atom-concs

(defthm smtp-cst-dot-atom-concs
  (implies (smtp-cst-list-list-alt-matchp
                cstss "[ cfws ] dot-atom-text [ cfws ]")
           (or (smtp-cst-list-list-conc-matchp
                    cstss
                    "[ cfws ] dot-atom-text [ cfws ]"))))

Theorem: smtp-cst-imf-quoted-string-concs

(defthm smtp-cst-imf-quoted-string-concs
 (implies
  (smtp-cst-list-list-alt-matchp
    cstss
    "[ cfws ] dquote *( [ fws ] qcontent ) [ fws ] dquote [ cfws ]")
  (or
   (smtp-cst-list-list-conc-matchp
    cstss
    "[ cfws ] dquote *( [ fws ] qcontent ) [ fws ] dquote [ cfws ]"))))

Theorem: smtp-cst-obs-id-right-concs

(defthm smtp-cst-obs-id-right-concs
 (implies (smtp-cst-list-list-alt-matchp cstss "imf-domain")
          (or (smtp-cst-list-list-conc-matchp cstss "imf-domain"))))

Theorem: smtp-cst-imf-domain-concs

(defthm smtp-cst-imf-domain-concs
  (implies
       (smtp-cst-list-list-alt-matchp
            cstss
            "dot-atom / domain-literal / obs-domain")
       (or (smtp-cst-list-list-conc-matchp cstss "dot-atom")
           (smtp-cst-list-list-conc-matchp cstss "domain-literal")
           (smtp-cst-list-list-conc-matchp cstss "obs-domain"))))

Theorem: smtp-cst-domain-literal-concs

(defthm smtp-cst-domain-literal-concs
 (implies
  (smtp-cst-list-list-alt-matchp
       cstss
       "[ cfws ] \"[\" *( [ fws ] dtext ) [ fws ] \"]\" [ cfws ]")
  (or
     (smtp-cst-list-list-conc-matchp
          cstss
          "[ cfws ] \"[\" *( [ fws ] dtext ) [ fws ] \"]\" [ cfws ]"))))

Theorem: smtp-cst-obs-domain-concs

(defthm smtp-cst-obs-domain-concs
 (implies
  (smtp-cst-list-list-alt-matchp cstss "imf-atom *( \".\" imf-atom )")
  (or (smtp-cst-list-list-conc-matchp
           cstss "imf-atom *( \".\" imf-atom )"))))

Theorem: smtp-cst-imf-atom-concs

(defthm smtp-cst-imf-atom-concs
 (implies
   (smtp-cst-list-list-alt-matchp cstss "[ cfws ] 1*atext [ cfws ]")
   (or (smtp-cst-list-list-conc-matchp
            cstss "[ cfws ] 1*atext [ cfws ]"))))

Theorem: smtp-cst-obs-local-part-concs

(defthm smtp-cst-obs-local-part-concs
 (implies
  (smtp-cst-list-list-alt-matchp cstss "word *( \".\" word )")
  (or (smtp-cst-list-list-conc-matchp cstss "word *( \".\" word )"))))

Theorem: smtp-cst-obs-no-ws-ctl-concs

(defthm smtp-cst-obs-no-ws-ctl-concs
  (implies (smtp-cst-list-list-alt-matchp
                cstss
                "%d1-8 / %d11 / %d12 / %d14-31 / %d127")
           (or (smtp-cst-list-list-conc-matchp cstss "%d1-8")
               (smtp-cst-list-list-conc-matchp cstss "%d11")
               (smtp-cst-list-list-conc-matchp cstss "%d12")
               (smtp-cst-list-list-conc-matchp cstss "%d14-31")
               (smtp-cst-list-list-conc-matchp cstss "%d127"))))

Theorem: smtp-cst-qcontent-concs

(defthm smtp-cst-qcontent-concs
  (implies
       (smtp-cst-list-list-alt-matchp cstss "qtext / quoted-pair")
       (or (smtp-cst-list-list-conc-matchp cstss "qtext")
           (smtp-cst-list-list-conc-matchp cstss "quoted-pair"))))

Theorem: smtp-cst-qtext-concs

(defthm smtp-cst-qtext-concs
  (implies (smtp-cst-list-list-alt-matchp
                cstss
                "%d33 / %d35-91 / %d93-126 / obs-qtext")
           (or (smtp-cst-list-list-conc-matchp cstss "%d33")
               (smtp-cst-list-list-conc-matchp cstss "%d35-91")
               (smtp-cst-list-list-conc-matchp cstss "%d93-126")
               (smtp-cst-list-list-conc-matchp cstss "obs-qtext"))))

Theorem: smtp-cst-obs-qtext-concs

(defthm smtp-cst-obs-qtext-concs
  (implies
       (smtp-cst-list-list-alt-matchp cstss "obs-no-ws-ctl")
       (or (smtp-cst-list-list-conc-matchp cstss "obs-no-ws-ctl"))))

Theorem: smtp-cst-quoted-pair-concs

(defthm smtp-cst-quoted-pair-concs
 (implies
  (smtp-cst-list-list-alt-matchp cstss
                                 "( \"\\\" ( vchar / wsp ) ) / obs-qp")
  (or
    (smtp-cst-list-list-conc-matchp cstss "( \"\\\" ( vchar / wsp ) )")
    (smtp-cst-list-list-conc-matchp cstss "obs-qp"))))

Theorem: smtp-cst-obs-qp-concs

(defthm smtp-cst-obs-qp-concs
  (implies (smtp-cst-list-list-alt-matchp
                cstss
                "\"\\\" ( %d0 / obs-no-ws-ctl / lf / cr )")
           (or (smtp-cst-list-list-conc-matchp
                    cstss
                    "\"\\\" ( %d0 / obs-no-ws-ctl / lf / cr )"))))

Theorem: smtp-cst-time-concs

(defthm smtp-cst-time-concs
 (implies
    (smtp-cst-list-list-alt-matchp cstss "time-of-day zone")
    (or (smtp-cst-list-list-conc-matchp cstss "time-of-day zone"))))

Theorem: smtp-cst-time-of-day-concs

(defthm smtp-cst-time-of-day-concs
  (implies (smtp-cst-list-list-alt-matchp
                cstss "hour \":\" minute [ \":\" second ]")
           (or (smtp-cst-list-list-conc-matchp
                    cstss
                    "hour \":\" minute [ \":\" second ]"))))

Theorem: smtp-cst-hour-concs

(defthm smtp-cst-hour-concs
  (implies (smtp-cst-list-list-alt-matchp cstss "2digit / obs-hour")
           (or (smtp-cst-list-list-conc-matchp cstss "2digit")
               (smtp-cst-list-list-conc-matchp cstss "obs-hour"))))

Theorem: smtp-cst-minute-concs

(defthm smtp-cst-minute-concs
  (implies
       (smtp-cst-list-list-alt-matchp cstss "2digit / obs-minute")
       (or (smtp-cst-list-list-conc-matchp cstss "2digit")
           (smtp-cst-list-list-conc-matchp cstss "obs-minute"))))

Theorem: smtp-cst-obs-hour-concs

(defthm smtp-cst-obs-hour-concs
 (implies
    (smtp-cst-list-list-alt-matchp cstss "[ cfws ] 2digit [ cfws ]")
    (or (smtp-cst-list-list-conc-matchp
             cstss "[ cfws ] 2digit [ cfws ]"))))

Theorem: smtp-cst-obs-minute-concs

(defthm smtp-cst-obs-minute-concs
 (implies
    (smtp-cst-list-list-alt-matchp cstss "[ cfws ] 2digit [ cfws ]")
    (or (smtp-cst-list-list-conc-matchp
             cstss "[ cfws ] 2digit [ cfws ]"))))

Theorem: smtp-cst-second-concs

(defthm smtp-cst-second-concs
  (implies
       (smtp-cst-list-list-alt-matchp cstss "2digit / obs-second")
       (or (smtp-cst-list-list-conc-matchp cstss "2digit")
           (smtp-cst-list-list-conc-matchp cstss "obs-second"))))

Theorem: smtp-cst-obs-second-concs

(defthm smtp-cst-obs-second-concs
 (implies
    (smtp-cst-list-list-alt-matchp cstss "[ cfws ] 2digit [ cfws ]")
    (or (smtp-cst-list-list-conc-matchp
             cstss "[ cfws ] 2digit [ cfws ]"))))

Theorem: smtp-cst-word-concs

(defthm smtp-cst-word-concs
 (implies
   (smtp-cst-list-list-alt-matchp
        cstss "imf-atom / imf-quoted-string")
   (or (smtp-cst-list-list-conc-matchp cstss "imf-atom")
       (smtp-cst-list-list-conc-matchp cstss "imf-quoted-string"))))

Theorem: smtp-cst-year-concs

(defthm smtp-cst-year-concs
 (implies
    (smtp-cst-list-list-alt-matchp
         cstss "( fws 4*digit fws ) / obs-year")
    (or (smtp-cst-list-list-conc-matchp cstss "( fws 4*digit fws )")
        (smtp-cst-list-list-conc-matchp cstss "obs-year"))))

Theorem: smtp-cst-obs-year-concs

(defthm smtp-cst-obs-year-concs
 (implies
   (smtp-cst-list-list-alt-matchp cstss "[ cfws ] 2*digit [ cfws ]")
   (or (smtp-cst-list-list-conc-matchp
            cstss "[ cfws ] 2*digit [ cfws ]"))))

Theorem: smtp-cst-zone-concs

(defthm smtp-cst-zone-concs
  (implies (smtp-cst-list-list-alt-matchp
                cstss
                "( fws ( \"+\" / \"-\" ) 4digit ) / obs-zone")
           (or (smtp-cst-list-list-conc-matchp
                    cstss "( fws ( \"+\" / \"-\" ) 4digit )")
               (smtp-cst-list-list-conc-matchp cstss "obs-zone"))))

Theorem: smtp-cst-obs-zone-concs

(defthm smtp-cst-obs-zone-concs
 (implies
  (smtp-cst-list-list-alt-matchp
   cstss
   "\"UT\" / \"GMT\" / \"EST\" / \"EDT\" / \"CST\" / \"CDT\" / \"MST\" / \"MDT\" / \"PST\" / \"PDT\" / %d65-73 / %d75-90 / %d97-105 / %d107-122")
  (or (smtp-cst-list-list-conc-matchp cstss "\"UT\"")
      (smtp-cst-list-list-conc-matchp cstss "\"GMT\"")
      (smtp-cst-list-list-conc-matchp cstss "\"EST\"")
      (smtp-cst-list-list-conc-matchp cstss "\"EDT\"")
      (smtp-cst-list-list-conc-matchp cstss "\"CST\"")
      (smtp-cst-list-list-conc-matchp cstss "\"CDT\"")
      (smtp-cst-list-list-conc-matchp cstss "\"MST\"")
      (smtp-cst-list-list-conc-matchp cstss "\"MDT\"")
      (smtp-cst-list-list-conc-matchp cstss "\"PST\"")
      (smtp-cst-list-list-conc-matchp cstss "\"PDT\"")
      (smtp-cst-list-list-conc-matchp cstss "%d65-73")
      (smtp-cst-list-list-conc-matchp cstss "%d75-90")
      (smtp-cst-list-list-conc-matchp cstss "%d97-105")
      (smtp-cst-list-list-conc-matchp cstss "%d107-122"))))

Theorem: smtp-cst-alpha-concs

(defthm smtp-cst-alpha-concs
  (implies (smtp-cst-list-list-alt-matchp cstss "%x41-5A / %x61-7A")
           (or (smtp-cst-list-list-conc-matchp cstss "%x41-5A")
               (smtp-cst-list-list-conc-matchp cstss "%x61-7A"))))

Theorem: smtp-cst-cr-concs

(defthm smtp-cst-cr-concs
  (implies (smtp-cst-list-list-alt-matchp cstss "%xD")
           (or (smtp-cst-list-list-conc-matchp cstss "%xD"))))

Theorem: smtp-cst-crlf-concs

(defthm smtp-cst-crlf-concs
  (implies (smtp-cst-list-list-alt-matchp cstss "cr lf")
           (or (smtp-cst-list-list-conc-matchp cstss "cr lf"))))

Theorem: smtp-cst-digit-concs

(defthm smtp-cst-digit-concs
  (implies (smtp-cst-list-list-alt-matchp cstss "%x30-39")
           (or (smtp-cst-list-list-conc-matchp cstss "%x30-39"))))

Theorem: smtp-cst-dquote-concs

(defthm smtp-cst-dquote-concs
  (implies (smtp-cst-list-list-alt-matchp cstss "%x22")
           (or (smtp-cst-list-list-conc-matchp cstss "%x22"))))

Theorem: smtp-cst-hexdig-concs

(defthm smtp-cst-hexdig-concs
  (implies (smtp-cst-list-list-alt-matchp
                cstss
                "digit / \"A\" / \"B\" / \"C\" / \"D\" / \"E\" / \"F\"")
           (or (smtp-cst-list-list-conc-matchp cstss "digit")
               (smtp-cst-list-list-conc-matchp cstss "\"A\"")
               (smtp-cst-list-list-conc-matchp cstss "\"B\"")
               (smtp-cst-list-list-conc-matchp cstss "\"C\"")
               (smtp-cst-list-list-conc-matchp cstss "\"D\"")
               (smtp-cst-list-list-conc-matchp cstss "\"E\"")
               (smtp-cst-list-list-conc-matchp cstss "\"F\""))))

Theorem: smtp-cst-lf-concs

(defthm smtp-cst-lf-concs
  (implies (smtp-cst-list-list-alt-matchp cstss "%xA")
           (or (smtp-cst-list-list-conc-matchp cstss "%xA"))))

Theorem: smtp-cst-sp-concs

(defthm smtp-cst-sp-concs
  (implies (smtp-cst-list-list-alt-matchp cstss "%x20")
           (or (smtp-cst-list-list-conc-matchp cstss "%x20"))))

Theorem: smtp-cst-vchar-concs

(defthm smtp-cst-vchar-concs
  (implies (smtp-cst-list-list-alt-matchp cstss "%x21-7E")
           (or (smtp-cst-list-list-conc-matchp cstss "%x21-7E"))))

Theorem: smtp-cst-wsp-concs

(defthm smtp-cst-wsp-concs
  (implies (smtp-cst-list-list-alt-matchp cstss "sp / htab")
           (or (smtp-cst-list-list-conc-matchp cstss "sp")
               (smtp-cst-list-list-conc-matchp cstss "htab"))))

Theorem: smtp-cst-htab-concs

(defthm smtp-cst-htab-concs
  (implies (smtp-cst-list-list-alt-matchp cstss "%x9")
           (or (smtp-cst-list-list-conc-matchp cstss "%x9"))))

Theorem: smtp-cst-ehlo-ok-rsp-conc1-matching

(defthm smtp-cst-ehlo-ok-rsp-conc1-matching
 (implies (smtp-cst-list-list-conc-matchp
               cstss
               "( \"250\" sp domain [ sp ehlo-greet ] crlf )")
          (and (equal (len cstss) 1)
               (smtp-cst-list-rep-matchp
                    (nth 0 cstss)
                    "( \"250\" sp domain [ sp ehlo-greet ] crlf )"))))

Theorem: smtp-cst-ehlo-ok-rsp-conc2-matching

(defthm smtp-cst-ehlo-ok-rsp-conc2-matching
 (implies
  (smtp-cst-list-list-conc-matchp
   cstss
   "( \"250-\" domain [ sp ehlo-greet ] crlf *( \"250-\" ehlo-line crlf ) \"250\" sp ehlo-line crlf )")
  (and
   (equal (len cstss) 1)
   (smtp-cst-list-rep-matchp
    (nth 0 cstss)
    "( \"250-\" domain [ sp ehlo-greet ] crlf *( \"250-\" ehlo-line crlf ) \"250\" sp ehlo-line crlf )"))))

Theorem: smtp-cst-ehlo-greet-conc-matching

(defthm smtp-cst-ehlo-greet-conc-matching
 (implies
  (smtp-cst-list-list-conc-matchp
       cstss
       "1*( %d0-9 / %d11-12 / %d14-127 )")
  (and
    (equal (len cstss) 1)
    (smtp-cst-list-rep-matchp (nth 0 cstss)
                              "1*( %d0-9 / %d11-12 / %d14-127 )"))))

Theorem: smtp-cst-ehlo-param-conc-matching

(defthm smtp-cst-ehlo-param-conc-matching
  (implies (smtp-cst-list-list-conc-matchp cstss "1*( %d33-126 )")
           (and (equal (len cstss) 1)
                (smtp-cst-list-rep-matchp (nth 0 cstss)
                                          "1*( %d33-126 )"))))

Theorem: smtp-cst-reverse-path-conc1-matching

(defthm smtp-cst-reverse-path-conc1-matching
  (implies (smtp-cst-list-list-conc-matchp cstss "path")
           (and (equal (len cstss) 1)
                (smtp-cst-list-rep-matchp (nth 0 cstss)
                                          "path"))))

Theorem: smtp-cst-reverse-path-conc2-matching

(defthm smtp-cst-reverse-path-conc2-matching
  (implies (smtp-cst-list-list-conc-matchp cstss "\"<>\"")
           (and (equal (len cstss) 1)
                (smtp-cst-list-rep-matchp (nth 0 cstss)
                                          "\"<>\""))))

Theorem: smtp-cst-forward-path-conc-matching

(defthm smtp-cst-forward-path-conc-matching
  (implies (smtp-cst-list-list-conc-matchp cstss "path")
           (and (equal (len cstss) 1)
                (smtp-cst-list-rep-matchp (nth 0 cstss)
                                          "path"))))

Theorem: smtp-cst-esmtp-value-conc-matching

(defthm smtp-cst-esmtp-value-conc-matching
 (implies
   (smtp-cst-list-list-conc-matchp cstss "1*( %d33-60 / %d62-126 )")
   (and (equal (len cstss) 1)
        (smtp-cst-list-rep-matchp (nth 0 cstss)
                                  "1*( %d33-60 / %d62-126 )"))))

Theorem: smtp-cst-keyword-conc-matching

(defthm smtp-cst-keyword-conc-matching
  (implies (smtp-cst-list-list-conc-matchp cstss "ldh-str")
           (and (equal (len cstss) 1)
                (smtp-cst-list-rep-matchp (nth 0 cstss)
                                          "ldh-str"))))

Theorem: smtp-cst-argument-conc-matching

(defthm smtp-cst-argument-conc-matching
  (implies (smtp-cst-list-list-conc-matchp cstss "atom")
           (and (equal (len cstss) 1)
                (smtp-cst-list-rep-matchp (nth 0 cstss)
                                          "atom"))))

Theorem: smtp-cst-let-dig-conc1-matching

(defthm smtp-cst-let-dig-conc1-matching
  (implies (smtp-cst-list-list-conc-matchp cstss "alpha")
           (and (equal (len cstss) 1)
                (smtp-cst-list-rep-matchp (nth 0 cstss)
                                          "alpha"))))

Theorem: smtp-cst-let-dig-conc2-matching

(defthm smtp-cst-let-dig-conc2-matching
  (implies (smtp-cst-list-list-conc-matchp cstss "digit")
           (and (equal (len cstss) 1)
                (smtp-cst-list-rep-matchp (nth 0 cstss)
                                          "digit"))))

Theorem: smtp-cst-local-part-conc1-matching

(defthm smtp-cst-local-part-conc1-matching
  (implies (smtp-cst-list-list-conc-matchp cstss "dot-string")
           (and (equal (len cstss) 1)
                (smtp-cst-list-rep-matchp (nth 0 cstss)
                                          "dot-string"))))

Theorem: smtp-cst-local-part-conc2-matching

(defthm smtp-cst-local-part-conc2-matching
  (implies (smtp-cst-list-list-conc-matchp cstss "quoted-string")
           (and (equal (len cstss) 1)
                (smtp-cst-list-rep-matchp (nth 0 cstss)
                                          "quoted-string"))))

Theorem: smtp-cst-atom-conc-matching

(defthm smtp-cst-atom-conc-matching
  (implies (smtp-cst-list-list-conc-matchp cstss "1*atext")
           (and (equal (len cstss) 1)
                (smtp-cst-list-rep-matchp (nth 0 cstss)
                                          "1*atext"))))

Theorem: smtp-cst-qcontentsmtp-conc1-matching

(defthm smtp-cst-qcontentsmtp-conc1-matching
  (implies (smtp-cst-list-list-conc-matchp cstss "qtextsmtp")
           (and (equal (len cstss) 1)
                (smtp-cst-list-rep-matchp (nth 0 cstss)
                                          "qtextsmtp"))))

Theorem: smtp-cst-qcontentsmtp-conc2-matching

(defthm smtp-cst-qcontentsmtp-conc2-matching
  (implies (smtp-cst-list-list-conc-matchp cstss "quoted-pairsmtp")
           (and (equal (len cstss) 1)
                (smtp-cst-list-rep-matchp (nth 0 cstss)
                                          "quoted-pairsmtp"))))

Theorem: smtp-cst-qtextsmtp-conc1-matching

(defthm smtp-cst-qtextsmtp-conc1-matching
  (implies (smtp-cst-list-list-conc-matchp cstss "%d32-33")
           (and (equal (len cstss) 1)
                (smtp-cst-list-rep-matchp (nth 0 cstss)
                                          "%d32-33"))))

Theorem: smtp-cst-qtextsmtp-conc2-matching

(defthm smtp-cst-qtextsmtp-conc2-matching
  (implies (smtp-cst-list-list-conc-matchp cstss "%d35-91")
           (and (equal (len cstss) 1)
                (smtp-cst-list-rep-matchp (nth 0 cstss)
                                          "%d35-91"))))

Theorem: smtp-cst-qtextsmtp-conc3-matching

(defthm smtp-cst-qtextsmtp-conc3-matching
  (implies (smtp-cst-list-list-conc-matchp cstss "%d93-126")
           (and (equal (len cstss) 1)
                (smtp-cst-list-rep-matchp (nth 0 cstss)
                                          "%d93-126"))))

Theorem: smtp-cst-string-conc1-matching

(defthm smtp-cst-string-conc1-matching
  (implies (smtp-cst-list-list-conc-matchp cstss "atom")
           (and (equal (len cstss) 1)
                (smtp-cst-list-rep-matchp (nth 0 cstss)
                                          "atom"))))

Theorem: smtp-cst-string-conc2-matching

(defthm smtp-cst-string-conc2-matching
  (implies (smtp-cst-list-list-conc-matchp cstss "quoted-string")
           (and (equal (len cstss) 1)
                (smtp-cst-list-rep-matchp (nth 0 cstss)
                                          "quoted-string"))))

Theorem: smtp-cst-standardized-tag-conc-matching

(defthm smtp-cst-standardized-tag-conc-matching
  (implies (smtp-cst-list-list-conc-matchp cstss "ldh-str")
           (and (equal (len cstss) 1)
                (smtp-cst-list-rep-matchp (nth 0 cstss)
                                          "ldh-str"))))

Theorem: smtp-cst-dcontent-conc1-matching

(defthm smtp-cst-dcontent-conc1-matching
  (implies (smtp-cst-list-list-conc-matchp cstss "%d33-90")
           (and (equal (len cstss) 1)
                (smtp-cst-list-rep-matchp (nth 0 cstss)
                                          "%d33-90"))))

Theorem: smtp-cst-dcontent-conc2-matching

(defthm smtp-cst-dcontent-conc2-matching
  (implies (smtp-cst-list-list-conc-matchp cstss "%d94-126")
           (and (equal (len cstss) 1)
                (smtp-cst-list-rep-matchp (nth 0 cstss)
                                          "%d94-126"))))

Theorem: smtp-cst-snum-conc-matching

(defthm smtp-cst-snum-conc-matching
  (implies (smtp-cst-list-list-conc-matchp cstss "1*3digit")
           (and (equal (len cstss) 1)
                (smtp-cst-list-rep-matchp (nth 0 cstss)
                                          "1*3digit"))))

Theorem: smtp-cst-ipv6-addr-conc1-matching

(defthm smtp-cst-ipv6-addr-conc1-matching
  (implies (smtp-cst-list-list-conc-matchp cstss "ipv6-full")
           (and (equal (len cstss) 1)
                (smtp-cst-list-rep-matchp (nth 0 cstss)
                                          "ipv6-full"))))

Theorem: smtp-cst-ipv6-addr-conc2-matching

(defthm smtp-cst-ipv6-addr-conc2-matching
  (implies (smtp-cst-list-list-conc-matchp cstss "ipv6-comp")
           (and (equal (len cstss) 1)
                (smtp-cst-list-rep-matchp (nth 0 cstss)
                                          "ipv6-comp"))))

Theorem: smtp-cst-ipv6-addr-conc3-matching

(defthm smtp-cst-ipv6-addr-conc3-matching
  (implies (smtp-cst-list-list-conc-matchp cstss "ipv6v4-full")
           (and (equal (len cstss) 1)
                (smtp-cst-list-rep-matchp (nth 0 cstss)
                                          "ipv6v4-full"))))

Theorem: smtp-cst-ipv6-addr-conc4-matching

(defthm smtp-cst-ipv6-addr-conc4-matching
  (implies (smtp-cst-list-list-conc-matchp cstss "ipv6v4-comp")
           (and (equal (len cstss) 1)
                (smtp-cst-list-rep-matchp (nth 0 cstss)
                                          "ipv6v4-comp"))))

Theorem: smtp-cst-ipv6-hex-conc-matching

(defthm smtp-cst-ipv6-hex-conc-matching
  (implies (smtp-cst-list-list-conc-matchp cstss "1*4hexdig")
           (and (equal (len cstss) 1)
                (smtp-cst-list-rep-matchp (nth 0 cstss)
                                          "1*4hexdig"))))

Theorem: smtp-cst-greeting-conc1-matching

(defthm smtp-cst-greeting-conc1-matching
 (implies
  (smtp-cst-list-list-conc-matchp
   cstss
   "( \"220 \" ( domain / address-literal ) [ sp textstring ] crlf )")
  (and
   (equal (len cstss) 1)
   (smtp-cst-list-rep-matchp
    (nth 0 cstss)
    "( \"220 \" ( domain / address-literal ) [ sp textstring ] crlf )"))))

Theorem: smtp-cst-greeting-conc2-matching

(defthm smtp-cst-greeting-conc2-matching
 (implies
  (smtp-cst-list-list-conc-matchp
   cstss
   "( \"220-\" ( domain / address-literal ) [ sp textstring ] crlf *( \"220-\" [ textstring ] crlf ) \"220\" [ sp textstring ] crlf )")
  (and
   (equal (len cstss) 1)
   (smtp-cst-list-rep-matchp
    (nth 0 cstss)
    "( \"220-\" ( domain / address-literal ) [ sp textstring ] crlf *( \"220-\" [ textstring ] crlf ) \"220\" [ sp textstring ] crlf )"))))

Theorem: smtp-cst-textstring-conc-matching

(defthm smtp-cst-textstring-conc-matching
  (implies
       (smtp-cst-list-list-conc-matchp cstss "1*( %d9 / %d32-126 )")
       (and (equal (len cstss) 1)
            (smtp-cst-list-rep-matchp (nth 0 cstss)
                                      "1*( %d9 / %d32-126 )"))))

Theorem: smtp-cst-extended-domain-conc1-matching

(defthm smtp-cst-extended-domain-conc1-matching
  (implies (smtp-cst-list-list-conc-matchp cstss "domain")
           (and (equal (len cstss) 1)
                (smtp-cst-list-rep-matchp (nth 0 cstss)
                                          "domain"))))

Theorem: smtp-cst-extended-domain-conc2-matching

(defthm smtp-cst-extended-domain-conc2-matching
 (implies
  (smtp-cst-list-list-conc-matchp
       cstss "( domain fws \"(\" tcp-info \")\" )")
  (and
     (equal (len cstss) 1)
     (smtp-cst-list-rep-matchp (nth 0 cstss)
                               "( domain fws \"(\" tcp-info \")\" )"))))

Theorem: smtp-cst-extended-domain-conc3-matching

(defthm smtp-cst-extended-domain-conc3-matching
  (implies (smtp-cst-list-list-conc-matchp
                cstss
                "( address-literal fws \"(\" tcp-info \")\" )")
           (and (equal (len cstss) 1)
                (smtp-cst-list-rep-matchp
                     (nth 0 cstss)
                     "( address-literal fws \"(\" tcp-info \")\" )"))))

Theorem: smtp-cst-tcp-info-conc1-matching

(defthm smtp-cst-tcp-info-conc1-matching
  (implies (smtp-cst-list-list-conc-matchp cstss "address-literal")
           (and (equal (len cstss) 1)
                (smtp-cst-list-rep-matchp (nth 0 cstss)
                                          "address-literal"))))

Theorem: smtp-cst-tcp-info-conc2-matching

(defthm smtp-cst-tcp-info-conc2-matching
 (implies
  (smtp-cst-list-list-conc-matchp
       cstss "( domain fws address-literal )")
  (and
      (equal (len cstss) 1)
      (smtp-cst-list-rep-matchp (nth 0 cstss)
                                "( domain fws address-literal )"))))

Theorem: smtp-cst-link-conc1-matching

(defthm smtp-cst-link-conc1-matching
  (implies (smtp-cst-list-list-conc-matchp cstss "\"TCP\"")
           (and (equal (len cstss) 1)
                (smtp-cst-list-rep-matchp (nth 0 cstss)
                                          "\"TCP\""))))

Theorem: smtp-cst-link-conc2-matching

(defthm smtp-cst-link-conc2-matching
  (implies (smtp-cst-list-list-conc-matchp cstss "addtl-link")
           (and (equal (len cstss) 1)
                (smtp-cst-list-rep-matchp (nth 0 cstss)
                                          "addtl-link"))))

Theorem: smtp-cst-addtl-link-conc-matching

(defthm smtp-cst-addtl-link-conc-matching
  (implies (smtp-cst-list-list-conc-matchp cstss "atom")
           (and (equal (len cstss) 1)
                (smtp-cst-list-rep-matchp (nth 0 cstss)
                                          "atom"))))

Theorem: smtp-cst-protocol-conc1-matching

(defthm smtp-cst-protocol-conc1-matching
  (implies (smtp-cst-list-list-conc-matchp cstss "\"ESMTP\"")
           (and (equal (len cstss) 1)
                (smtp-cst-list-rep-matchp (nth 0 cstss)
                                          "\"ESMTP\""))))

Theorem: smtp-cst-protocol-conc2-matching

(defthm smtp-cst-protocol-conc2-matching
  (implies (smtp-cst-list-list-conc-matchp cstss "\"SMTP\"")
           (and (equal (len cstss) 1)
                (smtp-cst-list-rep-matchp (nth 0 cstss)
                                          "\"SMTP\""))))

Theorem: smtp-cst-protocol-conc3-matching

(defthm smtp-cst-protocol-conc3-matching
  (implies (smtp-cst-list-list-conc-matchp cstss "attdl-protocol")
           (and (equal (len cstss) 1)
                (smtp-cst-list-rep-matchp (nth 0 cstss)
                                          "attdl-protocol"))))

Theorem: smtp-cst-attdl-protocol-conc-matching

(defthm smtp-cst-attdl-protocol-conc-matching
  (implies (smtp-cst-list-list-conc-matchp cstss "atom")
           (and (equal (len cstss) 1)
                (smtp-cst-list-rep-matchp (nth 0 cstss)
                                          "atom"))))

Theorem: smtp-cst-atext-conc1-matching

(defthm smtp-cst-atext-conc1-matching
  (implies (smtp-cst-list-list-conc-matchp cstss "alpha")
           (and (equal (len cstss) 1)
                (smtp-cst-list-rep-matchp (nth 0 cstss)
                                          "alpha"))))

Theorem: smtp-cst-atext-conc2-matching

(defthm smtp-cst-atext-conc2-matching
  (implies (smtp-cst-list-list-conc-matchp cstss "digit")
           (and (equal (len cstss) 1)
                (smtp-cst-list-rep-matchp (nth 0 cstss)
                                          "digit"))))

Theorem: smtp-cst-atext-conc3-matching

(defthm smtp-cst-atext-conc3-matching
  (implies (smtp-cst-list-list-conc-matchp cstss "\"!\"")
           (and (equal (len cstss) 1)
                (smtp-cst-list-rep-matchp (nth 0 cstss)
                                          "\"!\""))))

Theorem: smtp-cst-atext-conc4-matching

(defthm smtp-cst-atext-conc4-matching
  (implies (smtp-cst-list-list-conc-matchp cstss "\"#\"")
           (and (equal (len cstss) 1)
                (smtp-cst-list-rep-matchp (nth 0 cstss)
                                          "\"#\""))))

Theorem: smtp-cst-atext-conc5-matching

(defthm smtp-cst-atext-conc5-matching
  (implies (smtp-cst-list-list-conc-matchp cstss "\"$\"")
           (and (equal (len cstss) 1)
                (smtp-cst-list-rep-matchp (nth 0 cstss)
                                          "\"$\""))))

Theorem: smtp-cst-atext-conc6-matching

(defthm smtp-cst-atext-conc6-matching
  (implies (smtp-cst-list-list-conc-matchp cstss "\"%\"")
           (and (equal (len cstss) 1)
                (smtp-cst-list-rep-matchp (nth 0 cstss)
                                          "\"%\""))))

Theorem: smtp-cst-atext-conc7-matching

(defthm smtp-cst-atext-conc7-matching
  (implies (smtp-cst-list-list-conc-matchp cstss "\"&\"")
           (and (equal (len cstss) 1)
                (smtp-cst-list-rep-matchp (nth 0 cstss)
                                          "\"&\""))))

Theorem: smtp-cst-atext-conc8-matching

(defthm smtp-cst-atext-conc8-matching
  (implies (smtp-cst-list-list-conc-matchp cstss "\"'\"")
           (and (equal (len cstss) 1)
                (smtp-cst-list-rep-matchp (nth 0 cstss)
                                          "\"'\""))))

Theorem: smtp-cst-atext-conc9-matching

(defthm smtp-cst-atext-conc9-matching
  (implies (smtp-cst-list-list-conc-matchp cstss "\"*\"")
           (and (equal (len cstss) 1)
                (smtp-cst-list-rep-matchp (nth 0 cstss)
                                          "\"*\""))))

Theorem: smtp-cst-atext-conc10-matching

(defthm smtp-cst-atext-conc10-matching
  (implies (smtp-cst-list-list-conc-matchp cstss "\"+\"")
           (and (equal (len cstss) 1)
                (smtp-cst-list-rep-matchp (nth 0 cstss)
                                          "\"+\""))))

Theorem: smtp-cst-atext-conc11-matching

(defthm smtp-cst-atext-conc11-matching
  (implies (smtp-cst-list-list-conc-matchp cstss "\"-\"")
           (and (equal (len cstss) 1)
                (smtp-cst-list-rep-matchp (nth 0 cstss)
                                          "\"-\""))))

Theorem: smtp-cst-atext-conc12-matching

(defthm smtp-cst-atext-conc12-matching
  (implies (smtp-cst-list-list-conc-matchp cstss "\"/\"")
           (and (equal (len cstss) 1)
                (smtp-cst-list-rep-matchp (nth 0 cstss)
                                          "\"/\""))))

Theorem: smtp-cst-atext-conc13-matching

(defthm smtp-cst-atext-conc13-matching
  (implies (smtp-cst-list-list-conc-matchp cstss "\"=\"")
           (and (equal (len cstss) 1)
                (smtp-cst-list-rep-matchp (nth 0 cstss)
                                          "\"=\""))))

Theorem: smtp-cst-atext-conc14-matching

(defthm smtp-cst-atext-conc14-matching
  (implies (smtp-cst-list-list-conc-matchp cstss "\"?\"")
           (and (equal (len cstss) 1)
                (smtp-cst-list-rep-matchp (nth 0 cstss)
                                          "\"?\""))))

Theorem: smtp-cst-atext-conc15-matching

(defthm smtp-cst-atext-conc15-matching
  (implies (smtp-cst-list-list-conc-matchp cstss "\"^\"")
           (and (equal (len cstss) 1)
                (smtp-cst-list-rep-matchp (nth 0 cstss)
                                          "\"^\""))))

Theorem: smtp-cst-atext-conc16-matching

(defthm smtp-cst-atext-conc16-matching
  (implies (smtp-cst-list-list-conc-matchp cstss "\"_\"")
           (and (equal (len cstss) 1)
                (smtp-cst-list-rep-matchp (nth 0 cstss)
                                          "\"_\""))))

Theorem: smtp-cst-atext-conc17-matching

(defthm smtp-cst-atext-conc17-matching
  (implies (smtp-cst-list-list-conc-matchp cstss "\"`\"")
           (and (equal (len cstss) 1)
                (smtp-cst-list-rep-matchp (nth 0 cstss)
                                          "\"`\""))))

Theorem: smtp-cst-atext-conc18-matching

(defthm smtp-cst-atext-conc18-matching
  (implies (smtp-cst-list-list-conc-matchp cstss "\"{\"")
           (and (equal (len cstss) 1)
                (smtp-cst-list-rep-matchp (nth 0 cstss)
                                          "\"{\""))))

Theorem: smtp-cst-atext-conc19-matching

(defthm smtp-cst-atext-conc19-matching
  (implies (smtp-cst-list-list-conc-matchp cstss "\"|\"")
           (and (equal (len cstss) 1)
                (smtp-cst-list-rep-matchp (nth 0 cstss)
                                          "\"|\""))))

Theorem: smtp-cst-atext-conc20-matching

(defthm smtp-cst-atext-conc20-matching
  (implies (smtp-cst-list-list-conc-matchp cstss "\"}\"")
           (and (equal (len cstss) 1)
                (smtp-cst-list-rep-matchp (nth 0 cstss)
                                          "\"}\""))))

Theorem: smtp-cst-atext-conc21-matching

(defthm smtp-cst-atext-conc21-matching
  (implies (smtp-cst-list-list-conc-matchp cstss "\"~\"")
           (and (equal (len cstss) 1)
                (smtp-cst-list-rep-matchp (nth 0 cstss)
                                          "\"~\""))))

Theorem: smtp-cst-cfws-conc1-matching

(defthm smtp-cst-cfws-conc1-matching
 (implies
  (smtp-cst-list-list-conc-matchp
       cstss
       "( 1*( [ fws ] comment ) [ fws ] )")
  (and
   (equal (len cstss) 1)
   (smtp-cst-list-rep-matchp (nth 0 cstss)
                             "( 1*( [ fws ] comment ) [ fws ] )"))))

Theorem: smtp-cst-cfws-conc2-matching

(defthm smtp-cst-cfws-conc2-matching
  (implies (smtp-cst-list-list-conc-matchp cstss "fws")
           (and (equal (len cstss) 1)
                (smtp-cst-list-rep-matchp (nth 0 cstss)
                                          "fws"))))

Theorem: smtp-cst-ccontent-conc1-matching

(defthm smtp-cst-ccontent-conc1-matching
  (implies (smtp-cst-list-list-conc-matchp cstss "ctext")
           (and (equal (len cstss) 1)
                (smtp-cst-list-rep-matchp (nth 0 cstss)
                                          "ctext"))))

Theorem: smtp-cst-ccontent-conc2-matching

(defthm smtp-cst-ccontent-conc2-matching
  (implies (smtp-cst-list-list-conc-matchp cstss "quoted-pair")
           (and (equal (len cstss) 1)
                (smtp-cst-list-rep-matchp (nth 0 cstss)
                                          "quoted-pair"))))

Theorem: smtp-cst-ccontent-conc3-matching

(defthm smtp-cst-ccontent-conc3-matching
  (implies (smtp-cst-list-list-conc-matchp cstss "comment")
           (and (equal (len cstss) 1)
                (smtp-cst-list-rep-matchp (nth 0 cstss)
                                          "comment"))))

Theorem: smtp-cst-ctext-conc1-matching

(defthm smtp-cst-ctext-conc1-matching
  (implies (smtp-cst-list-list-conc-matchp cstss "%d33-39")
           (and (equal (len cstss) 1)
                (smtp-cst-list-rep-matchp (nth 0 cstss)
                                          "%d33-39"))))

Theorem: smtp-cst-ctext-conc2-matching

(defthm smtp-cst-ctext-conc2-matching
  (implies (smtp-cst-list-list-conc-matchp cstss "%d42-91")
           (and (equal (len cstss) 1)
                (smtp-cst-list-rep-matchp (nth 0 cstss)
                                          "%d42-91"))))

Theorem: smtp-cst-ctext-conc3-matching

(defthm smtp-cst-ctext-conc3-matching
  (implies (smtp-cst-list-list-conc-matchp cstss "%d93-126")
           (and (equal (len cstss) 1)
                (smtp-cst-list-rep-matchp (nth 0 cstss)
                                          "%d93-126"))))

Theorem: smtp-cst-ctext-conc4-matching

(defthm smtp-cst-ctext-conc4-matching
  (implies (smtp-cst-list-list-conc-matchp cstss "obs-ctext")
           (and (equal (len cstss) 1)
                (smtp-cst-list-rep-matchp (nth 0 cstss)
                                          "obs-ctext"))))

Theorem: smtp-cst-day-conc1-matching

(defthm smtp-cst-day-conc1-matching
 (implies
   (smtp-cst-list-list-conc-matchp cstss "( [ fws ] 1*2digit fws )")
   (and (equal (len cstss) 1)
        (smtp-cst-list-rep-matchp (nth 0 cstss)
                                  "( [ fws ] 1*2digit fws )"))))

Theorem: smtp-cst-day-conc2-matching

(defthm smtp-cst-day-conc2-matching
  (implies (smtp-cst-list-list-conc-matchp cstss "obs-day")
           (and (equal (len cstss) 1)
                (smtp-cst-list-rep-matchp (nth 0 cstss)
                                          "obs-day"))))

Theorem: smtp-cst-day-of-week-conc1-matching

(defthm smtp-cst-day-of-week-conc1-matching
  (implies
       (smtp-cst-list-list-conc-matchp cstss "( [ fws ] day-name )")
       (and (equal (len cstss) 1)
            (smtp-cst-list-rep-matchp (nth 0 cstss)
                                      "( [ fws ] day-name )"))))

Theorem: smtp-cst-day-of-week-conc2-matching

(defthm smtp-cst-day-of-week-conc2-matching
  (implies (smtp-cst-list-list-conc-matchp cstss "obs-day-of-week")
           (and (equal (len cstss) 1)
                (smtp-cst-list-rep-matchp (nth 0 cstss)
                                          "obs-day-of-week"))))

Theorem: smtp-cst-day-name-conc1-matching

(defthm smtp-cst-day-name-conc1-matching
  (implies (smtp-cst-list-list-conc-matchp cstss "\"Mon\"")
           (and (equal (len cstss) 1)
                (smtp-cst-list-rep-matchp (nth 0 cstss)
                                          "\"Mon\""))))

Theorem: smtp-cst-day-name-conc2-matching

(defthm smtp-cst-day-name-conc2-matching
  (implies (smtp-cst-list-list-conc-matchp cstss "\"Tue\"")
           (and (equal (len cstss) 1)
                (smtp-cst-list-rep-matchp (nth 0 cstss)
                                          "\"Tue\""))))

Theorem: smtp-cst-day-name-conc3-matching

(defthm smtp-cst-day-name-conc3-matching
  (implies (smtp-cst-list-list-conc-matchp cstss "\"Wed\"")
           (and (equal (len cstss) 1)
                (smtp-cst-list-rep-matchp (nth 0 cstss)
                                          "\"Wed\""))))

Theorem: smtp-cst-day-name-conc4-matching

(defthm smtp-cst-day-name-conc4-matching
  (implies (smtp-cst-list-list-conc-matchp cstss "\"Thu\"")
           (and (equal (len cstss) 1)
                (smtp-cst-list-rep-matchp (nth 0 cstss)
                                          "\"Thu\""))))

Theorem: smtp-cst-day-name-conc5-matching

(defthm smtp-cst-day-name-conc5-matching
  (implies (smtp-cst-list-list-conc-matchp cstss "\"Fri\"")
           (and (equal (len cstss) 1)
                (smtp-cst-list-rep-matchp (nth 0 cstss)
                                          "\"Fri\""))))

Theorem: smtp-cst-day-name-conc6-matching

(defthm smtp-cst-day-name-conc6-matching
  (implies (smtp-cst-list-list-conc-matchp cstss "\"Sat\"")
           (and (equal (len cstss) 1)
                (smtp-cst-list-rep-matchp (nth 0 cstss)
                                          "\"Sat\""))))

Theorem: smtp-cst-day-name-conc7-matching

(defthm smtp-cst-day-name-conc7-matching
  (implies (smtp-cst-list-list-conc-matchp cstss "\"Sun\"")
           (and (equal (len cstss) 1)
                (smtp-cst-list-rep-matchp (nth 0 cstss)
                                          "\"Sun\""))))

Theorem: smtp-cst-fws-conc1-matching

(defthm smtp-cst-fws-conc1-matching
 (implies
    (smtp-cst-list-list-conc-matchp cstss "( [ *wsp crlf ] 1*wsp )")
    (and (equal (len cstss) 1)
         (smtp-cst-list-rep-matchp (nth 0 cstss)
                                   "( [ *wsp crlf ] 1*wsp )"))))

Theorem: smtp-cst-fws-conc2-matching

(defthm smtp-cst-fws-conc2-matching
  (implies (smtp-cst-list-list-conc-matchp cstss "obs-fws")
           (and (equal (len cstss) 1)
                (smtp-cst-list-rep-matchp (nth 0 cstss)
                                          "obs-fws"))))

Theorem: smtp-cst-month-conc1-matching

(defthm smtp-cst-month-conc1-matching
  (implies (smtp-cst-list-list-conc-matchp cstss "\"Jan\"")
           (and (equal (len cstss) 1)
                (smtp-cst-list-rep-matchp (nth 0 cstss)
                                          "\"Jan\""))))

Theorem: smtp-cst-month-conc2-matching

(defthm smtp-cst-month-conc2-matching
  (implies (smtp-cst-list-list-conc-matchp cstss "\"Feb\"")
           (and (equal (len cstss) 1)
                (smtp-cst-list-rep-matchp (nth 0 cstss)
                                          "\"Feb\""))))

Theorem: smtp-cst-month-conc3-matching

(defthm smtp-cst-month-conc3-matching
  (implies (smtp-cst-list-list-conc-matchp cstss "\"Mar\"")
           (and (equal (len cstss) 1)
                (smtp-cst-list-rep-matchp (nth 0 cstss)
                                          "\"Mar\""))))

Theorem: smtp-cst-month-conc4-matching

(defthm smtp-cst-month-conc4-matching
  (implies (smtp-cst-list-list-conc-matchp cstss "\"Apr\"")
           (and (equal (len cstss) 1)
                (smtp-cst-list-rep-matchp (nth 0 cstss)
                                          "\"Apr\""))))

Theorem: smtp-cst-month-conc5-matching

(defthm smtp-cst-month-conc5-matching
  (implies (smtp-cst-list-list-conc-matchp cstss "\"May\"")
           (and (equal (len cstss) 1)
                (smtp-cst-list-rep-matchp (nth 0 cstss)
                                          "\"May\""))))

Theorem: smtp-cst-month-conc6-matching

(defthm smtp-cst-month-conc6-matching
  (implies (smtp-cst-list-list-conc-matchp cstss "\"Jun\"")
           (and (equal (len cstss) 1)
                (smtp-cst-list-rep-matchp (nth 0 cstss)
                                          "\"Jun\""))))

Theorem: smtp-cst-month-conc7-matching

(defthm smtp-cst-month-conc7-matching
  (implies (smtp-cst-list-list-conc-matchp cstss "\"Jul\"")
           (and (equal (len cstss) 1)
                (smtp-cst-list-rep-matchp (nth 0 cstss)
                                          "\"Jul\""))))

Theorem: smtp-cst-month-conc8-matching

(defthm smtp-cst-month-conc8-matching
  (implies (smtp-cst-list-list-conc-matchp cstss "\"Aug\"")
           (and (equal (len cstss) 1)
                (smtp-cst-list-rep-matchp (nth 0 cstss)
                                          "\"Aug\""))))

Theorem: smtp-cst-month-conc9-matching

(defthm smtp-cst-month-conc9-matching
  (implies (smtp-cst-list-list-conc-matchp cstss "\"Sep\"")
           (and (equal (len cstss) 1)
                (smtp-cst-list-rep-matchp (nth 0 cstss)
                                          "\"Sep\""))))

Theorem: smtp-cst-month-conc10-matching

(defthm smtp-cst-month-conc10-matching
  (implies (smtp-cst-list-list-conc-matchp cstss "\"Oct\"")
           (and (equal (len cstss) 1)
                (smtp-cst-list-rep-matchp (nth 0 cstss)
                                          "\"Oct\""))))

Theorem: smtp-cst-month-conc11-matching

(defthm smtp-cst-month-conc11-matching
  (implies (smtp-cst-list-list-conc-matchp cstss "\"Nov\"")
           (and (equal (len cstss) 1)
                (smtp-cst-list-rep-matchp (nth 0 cstss)
                                          "\"Nov\""))))

Theorem: smtp-cst-month-conc12-matching

(defthm smtp-cst-month-conc12-matching
  (implies (smtp-cst-list-list-conc-matchp cstss "\"Dec\"")
           (and (equal (len cstss) 1)
                (smtp-cst-list-rep-matchp (nth 0 cstss)
                                          "\"Dec\""))))

Theorem: smtp-cst-id-left-conc1-matching

(defthm smtp-cst-id-left-conc1-matching
  (implies (smtp-cst-list-list-conc-matchp cstss "dot-atom-text")
           (and (equal (len cstss) 1)
                (smtp-cst-list-rep-matchp (nth 0 cstss)
                                          "dot-atom-text"))))

Theorem: smtp-cst-id-left-conc2-matching

(defthm smtp-cst-id-left-conc2-matching
  (implies (smtp-cst-list-list-conc-matchp cstss "obs-id-left")
           (and (equal (len cstss) 1)
                (smtp-cst-list-rep-matchp (nth 0 cstss)
                                          "obs-id-left"))))

Theorem: smtp-cst-id-right-conc1-matching

(defthm smtp-cst-id-right-conc1-matching
  (implies (smtp-cst-list-list-conc-matchp cstss "dot-atom-text")
           (and (equal (len cstss) 1)
                (smtp-cst-list-rep-matchp (nth 0 cstss)
                                          "dot-atom-text"))))

Theorem: smtp-cst-id-right-conc2-matching

(defthm smtp-cst-id-right-conc2-matching
  (implies (smtp-cst-list-list-conc-matchp cstss "no-fold-literal")
           (and (equal (len cstss) 1)
                (smtp-cst-list-rep-matchp (nth 0 cstss)
                                          "no-fold-literal"))))

Theorem: smtp-cst-id-right-conc3-matching

(defthm smtp-cst-id-right-conc3-matching
  (implies (smtp-cst-list-list-conc-matchp cstss "obs-id-right")
           (and (equal (len cstss) 1)
                (smtp-cst-list-rep-matchp (nth 0 cstss)
                                          "obs-id-right"))))

Theorem: smtp-cst-dtext-conc1-matching

(defthm smtp-cst-dtext-conc1-matching
  (implies (smtp-cst-list-list-conc-matchp cstss "%d33-90")
           (and (equal (len cstss) 1)
                (smtp-cst-list-rep-matchp (nth 0 cstss)
                                          "%d33-90"))))

Theorem: smtp-cst-dtext-conc2-matching

(defthm smtp-cst-dtext-conc2-matching
  (implies (smtp-cst-list-list-conc-matchp cstss "%d94-126")
           (and (equal (len cstss) 1)
                (smtp-cst-list-rep-matchp (nth 0 cstss)
                                          "%d94-126"))))

Theorem: smtp-cst-dtext-conc3-matching

(defthm smtp-cst-dtext-conc3-matching
  (implies (smtp-cst-list-list-conc-matchp cstss "obs-dtext")
           (and (equal (len cstss) 1)
                (smtp-cst-list-rep-matchp (nth 0 cstss)
                                          "obs-dtext"))))

Theorem: smtp-cst-obs-ctext-conc-matching

(defthm smtp-cst-obs-ctext-conc-matching
  (implies (smtp-cst-list-list-conc-matchp cstss "obs-no-ws-ctl")
           (and (equal (len cstss) 1)
                (smtp-cst-list-rep-matchp (nth 0 cstss)
                                          "obs-no-ws-ctl"))))

Theorem: smtp-cst-obs-dtext-conc1-matching

(defthm smtp-cst-obs-dtext-conc1-matching
  (implies (smtp-cst-list-list-conc-matchp cstss "obs-no-ws-ctl")
           (and (equal (len cstss) 1)
                (smtp-cst-list-rep-matchp (nth 0 cstss)
                                          "obs-no-ws-ctl"))))

Theorem: smtp-cst-obs-dtext-conc2-matching

(defthm smtp-cst-obs-dtext-conc2-matching
  (implies (smtp-cst-list-list-conc-matchp cstss "quoted-pair")
           (and (equal (len cstss) 1)
                (smtp-cst-list-rep-matchp (nth 0 cstss)
                                          "quoted-pair"))))

Theorem: smtp-cst-obs-id-left-conc-matching

(defthm smtp-cst-obs-id-left-conc-matching
  (implies (smtp-cst-list-list-conc-matchp cstss "imf-local-part")
           (and (equal (len cstss) 1)
                (smtp-cst-list-rep-matchp (nth 0 cstss)
                                          "imf-local-part"))))

Theorem: smtp-cst-imf-local-part-conc1-matching

(defthm smtp-cst-imf-local-part-conc1-matching
  (implies (smtp-cst-list-list-conc-matchp cstss "dot-atom")
           (and (equal (len cstss) 1)
                (smtp-cst-list-rep-matchp (nth 0 cstss)
                                          "dot-atom"))))

Theorem: smtp-cst-imf-local-part-conc2-matching

(defthm smtp-cst-imf-local-part-conc2-matching
 (implies (smtp-cst-list-list-conc-matchp cstss "imf-quoted-string")
          (and (equal (len cstss) 1)
               (smtp-cst-list-rep-matchp (nth 0 cstss)
                                         "imf-quoted-string"))))

Theorem: smtp-cst-imf-local-part-conc3-matching

(defthm smtp-cst-imf-local-part-conc3-matching
  (implies (smtp-cst-list-list-conc-matchp cstss "obs-local-part")
           (and (equal (len cstss) 1)
                (smtp-cst-list-rep-matchp (nth 0 cstss)
                                          "obs-local-part"))))

Theorem: smtp-cst-obs-id-right-conc-matching

(defthm smtp-cst-obs-id-right-conc-matching
  (implies (smtp-cst-list-list-conc-matchp cstss "imf-domain")
           (and (equal (len cstss) 1)
                (smtp-cst-list-rep-matchp (nth 0 cstss)
                                          "imf-domain"))))

Theorem: smtp-cst-imf-domain-conc1-matching

(defthm smtp-cst-imf-domain-conc1-matching
  (implies (smtp-cst-list-list-conc-matchp cstss "dot-atom")
           (and (equal (len cstss) 1)
                (smtp-cst-list-rep-matchp (nth 0 cstss)
                                          "dot-atom"))))

Theorem: smtp-cst-imf-domain-conc2-matching

(defthm smtp-cst-imf-domain-conc2-matching
  (implies (smtp-cst-list-list-conc-matchp cstss "domain-literal")
           (and (equal (len cstss) 1)
                (smtp-cst-list-rep-matchp (nth 0 cstss)
                                          "domain-literal"))))

Theorem: smtp-cst-imf-domain-conc3-matching

(defthm smtp-cst-imf-domain-conc3-matching
  (implies (smtp-cst-list-list-conc-matchp cstss "obs-domain")
           (and (equal (len cstss) 1)
                (smtp-cst-list-rep-matchp (nth 0 cstss)
                                          "obs-domain"))))

Theorem: smtp-cst-obs-no-ws-ctl-conc1-matching

(defthm smtp-cst-obs-no-ws-ctl-conc1-matching
  (implies (smtp-cst-list-list-conc-matchp cstss "%d1-8")
           (and (equal (len cstss) 1)
                (smtp-cst-list-rep-matchp (nth 0 cstss)
                                          "%d1-8"))))

Theorem: smtp-cst-obs-no-ws-ctl-conc2-matching

(defthm smtp-cst-obs-no-ws-ctl-conc2-matching
  (implies (smtp-cst-list-list-conc-matchp cstss "%d11")
           (and (equal (len cstss) 1)
                (smtp-cst-list-rep-matchp (nth 0 cstss)
                                          "%d11"))))

Theorem: smtp-cst-obs-no-ws-ctl-conc3-matching

(defthm smtp-cst-obs-no-ws-ctl-conc3-matching
  (implies (smtp-cst-list-list-conc-matchp cstss "%d12")
           (and (equal (len cstss) 1)
                (smtp-cst-list-rep-matchp (nth 0 cstss)
                                          "%d12"))))

Theorem: smtp-cst-obs-no-ws-ctl-conc4-matching

(defthm smtp-cst-obs-no-ws-ctl-conc4-matching
  (implies (smtp-cst-list-list-conc-matchp cstss "%d14-31")
           (and (equal (len cstss) 1)
                (smtp-cst-list-rep-matchp (nth 0 cstss)
                                          "%d14-31"))))

Theorem: smtp-cst-obs-no-ws-ctl-conc5-matching

(defthm smtp-cst-obs-no-ws-ctl-conc5-matching
  (implies (smtp-cst-list-list-conc-matchp cstss "%d127")
           (and (equal (len cstss) 1)
                (smtp-cst-list-rep-matchp (nth 0 cstss)
                                          "%d127"))))

Theorem: smtp-cst-qcontent-conc1-matching

(defthm smtp-cst-qcontent-conc1-matching
  (implies (smtp-cst-list-list-conc-matchp cstss "qtext")
           (and (equal (len cstss) 1)
                (smtp-cst-list-rep-matchp (nth 0 cstss)
                                          "qtext"))))

Theorem: smtp-cst-qcontent-conc2-matching

(defthm smtp-cst-qcontent-conc2-matching
  (implies (smtp-cst-list-list-conc-matchp cstss "quoted-pair")
           (and (equal (len cstss) 1)
                (smtp-cst-list-rep-matchp (nth 0 cstss)
                                          "quoted-pair"))))

Theorem: smtp-cst-qtext-conc1-matching

(defthm smtp-cst-qtext-conc1-matching
  (implies (smtp-cst-list-list-conc-matchp cstss "%d33")
           (and (equal (len cstss) 1)
                (smtp-cst-list-rep-matchp (nth 0 cstss)
                                          "%d33"))))

Theorem: smtp-cst-qtext-conc2-matching

(defthm smtp-cst-qtext-conc2-matching
  (implies (smtp-cst-list-list-conc-matchp cstss "%d35-91")
           (and (equal (len cstss) 1)
                (smtp-cst-list-rep-matchp (nth 0 cstss)
                                          "%d35-91"))))

Theorem: smtp-cst-qtext-conc3-matching

(defthm smtp-cst-qtext-conc3-matching
  (implies (smtp-cst-list-list-conc-matchp cstss "%d93-126")
           (and (equal (len cstss) 1)
                (smtp-cst-list-rep-matchp (nth 0 cstss)
                                          "%d93-126"))))

Theorem: smtp-cst-qtext-conc4-matching

(defthm smtp-cst-qtext-conc4-matching
  (implies (smtp-cst-list-list-conc-matchp cstss "obs-qtext")
           (and (equal (len cstss) 1)
                (smtp-cst-list-rep-matchp (nth 0 cstss)
                                          "obs-qtext"))))

Theorem: smtp-cst-obs-qtext-conc-matching

(defthm smtp-cst-obs-qtext-conc-matching
  (implies (smtp-cst-list-list-conc-matchp cstss "obs-no-ws-ctl")
           (and (equal (len cstss) 1)
                (smtp-cst-list-rep-matchp (nth 0 cstss)
                                          "obs-no-ws-ctl"))))

Theorem: smtp-cst-quoted-pair-conc1-matching

(defthm smtp-cst-quoted-pair-conc1-matching
 (implies
    (smtp-cst-list-list-conc-matchp cstss "( \"\\\" ( vchar / wsp ) )")
    (and (equal (len cstss) 1)
         (smtp-cst-list-rep-matchp (nth 0 cstss)
                                   "( \"\\\" ( vchar / wsp ) )"))))

Theorem: smtp-cst-quoted-pair-conc2-matching

(defthm smtp-cst-quoted-pair-conc2-matching
  (implies (smtp-cst-list-list-conc-matchp cstss "obs-qp")
           (and (equal (len cstss) 1)
                (smtp-cst-list-rep-matchp (nth 0 cstss)
                                          "obs-qp"))))

Theorem: smtp-cst-hour-conc1-matching

(defthm smtp-cst-hour-conc1-matching
  (implies (smtp-cst-list-list-conc-matchp cstss "2digit")
           (and (equal (len cstss) 1)
                (smtp-cst-list-rep-matchp (nth 0 cstss)
                                          "2digit"))))

Theorem: smtp-cst-hour-conc2-matching

(defthm smtp-cst-hour-conc2-matching
  (implies (smtp-cst-list-list-conc-matchp cstss "obs-hour")
           (and (equal (len cstss) 1)
                (smtp-cst-list-rep-matchp (nth 0 cstss)
                                          "obs-hour"))))

Theorem: smtp-cst-minute-conc1-matching

(defthm smtp-cst-minute-conc1-matching
  (implies (smtp-cst-list-list-conc-matchp cstss "2digit")
           (and (equal (len cstss) 1)
                (smtp-cst-list-rep-matchp (nth 0 cstss)
                                          "2digit"))))

Theorem: smtp-cst-minute-conc2-matching

(defthm smtp-cst-minute-conc2-matching
  (implies (smtp-cst-list-list-conc-matchp cstss "obs-minute")
           (and (equal (len cstss) 1)
                (smtp-cst-list-rep-matchp (nth 0 cstss)
                                          "obs-minute"))))

Theorem: smtp-cst-second-conc1-matching

(defthm smtp-cst-second-conc1-matching
  (implies (smtp-cst-list-list-conc-matchp cstss "2digit")
           (and (equal (len cstss) 1)
                (smtp-cst-list-rep-matchp (nth 0 cstss)
                                          "2digit"))))

Theorem: smtp-cst-second-conc2-matching

(defthm smtp-cst-second-conc2-matching
  (implies (smtp-cst-list-list-conc-matchp cstss "obs-second")
           (and (equal (len cstss) 1)
                (smtp-cst-list-rep-matchp (nth 0 cstss)
                                          "obs-second"))))

Theorem: smtp-cst-word-conc1-matching

(defthm smtp-cst-word-conc1-matching
  (implies (smtp-cst-list-list-conc-matchp cstss "imf-atom")
           (and (equal (len cstss) 1)
                (smtp-cst-list-rep-matchp (nth 0 cstss)
                                          "imf-atom"))))

Theorem: smtp-cst-word-conc2-matching

(defthm smtp-cst-word-conc2-matching
 (implies (smtp-cst-list-list-conc-matchp cstss "imf-quoted-string")
          (and (equal (len cstss) 1)
               (smtp-cst-list-rep-matchp (nth 0 cstss)
                                         "imf-quoted-string"))))

Theorem: smtp-cst-year-conc1-matching

(defthm smtp-cst-year-conc1-matching
  (implies
       (smtp-cst-list-list-conc-matchp cstss "( fws 4*digit fws )")
       (and (equal (len cstss) 1)
            (smtp-cst-list-rep-matchp (nth 0 cstss)
                                      "( fws 4*digit fws )"))))

Theorem: smtp-cst-year-conc2-matching

(defthm smtp-cst-year-conc2-matching
  (implies (smtp-cst-list-list-conc-matchp cstss "obs-year")
           (and (equal (len cstss) 1)
                (smtp-cst-list-rep-matchp (nth 0 cstss)
                                          "obs-year"))))

Theorem: smtp-cst-zone-conc1-matching

(defthm smtp-cst-zone-conc1-matching
 (implies
   (smtp-cst-list-list-conc-matchp
        cstss "( fws ( \"+\" / \"-\" ) 4digit )")
   (and (equal (len cstss) 1)
        (smtp-cst-list-rep-matchp (nth 0 cstss)
                                  "( fws ( \"+\" / \"-\" ) 4digit )"))))

Theorem: smtp-cst-zone-conc2-matching

(defthm smtp-cst-zone-conc2-matching
  (implies (smtp-cst-list-list-conc-matchp cstss "obs-zone")
           (and (equal (len cstss) 1)
                (smtp-cst-list-rep-matchp (nth 0 cstss)
                                          "obs-zone"))))

Theorem: smtp-cst-obs-zone-conc1-matching

(defthm smtp-cst-obs-zone-conc1-matching
  (implies (smtp-cst-list-list-conc-matchp cstss "\"UT\"")
           (and (equal (len cstss) 1)
                (smtp-cst-list-rep-matchp (nth 0 cstss)
                                          "\"UT\""))))

Theorem: smtp-cst-obs-zone-conc2-matching

(defthm smtp-cst-obs-zone-conc2-matching
  (implies (smtp-cst-list-list-conc-matchp cstss "\"GMT\"")
           (and (equal (len cstss) 1)
                (smtp-cst-list-rep-matchp (nth 0 cstss)
                                          "\"GMT\""))))

Theorem: smtp-cst-obs-zone-conc3-matching

(defthm smtp-cst-obs-zone-conc3-matching
  (implies (smtp-cst-list-list-conc-matchp cstss "\"EST\"")
           (and (equal (len cstss) 1)
                (smtp-cst-list-rep-matchp (nth 0 cstss)
                                          "\"EST\""))))

Theorem: smtp-cst-obs-zone-conc4-matching

(defthm smtp-cst-obs-zone-conc4-matching
  (implies (smtp-cst-list-list-conc-matchp cstss "\"EDT\"")
           (and (equal (len cstss) 1)
                (smtp-cst-list-rep-matchp (nth 0 cstss)
                                          "\"EDT\""))))

Theorem: smtp-cst-obs-zone-conc5-matching

(defthm smtp-cst-obs-zone-conc5-matching
  (implies (smtp-cst-list-list-conc-matchp cstss "\"CST\"")
           (and (equal (len cstss) 1)
                (smtp-cst-list-rep-matchp (nth 0 cstss)
                                          "\"CST\""))))

Theorem: smtp-cst-obs-zone-conc6-matching

(defthm smtp-cst-obs-zone-conc6-matching
  (implies (smtp-cst-list-list-conc-matchp cstss "\"CDT\"")
           (and (equal (len cstss) 1)
                (smtp-cst-list-rep-matchp (nth 0 cstss)
                                          "\"CDT\""))))

Theorem: smtp-cst-obs-zone-conc7-matching

(defthm smtp-cst-obs-zone-conc7-matching
  (implies (smtp-cst-list-list-conc-matchp cstss "\"MST\"")
           (and (equal (len cstss) 1)
                (smtp-cst-list-rep-matchp (nth 0 cstss)
                                          "\"MST\""))))

Theorem: smtp-cst-obs-zone-conc8-matching

(defthm smtp-cst-obs-zone-conc8-matching
  (implies (smtp-cst-list-list-conc-matchp cstss "\"MDT\"")
           (and (equal (len cstss) 1)
                (smtp-cst-list-rep-matchp (nth 0 cstss)
                                          "\"MDT\""))))

Theorem: smtp-cst-obs-zone-conc9-matching

(defthm smtp-cst-obs-zone-conc9-matching
  (implies (smtp-cst-list-list-conc-matchp cstss "\"PST\"")
           (and (equal (len cstss) 1)
                (smtp-cst-list-rep-matchp (nth 0 cstss)
                                          "\"PST\""))))

Theorem: smtp-cst-obs-zone-conc10-matching

(defthm smtp-cst-obs-zone-conc10-matching
  (implies (smtp-cst-list-list-conc-matchp cstss "\"PDT\"")
           (and (equal (len cstss) 1)
                (smtp-cst-list-rep-matchp (nth 0 cstss)
                                          "\"PDT\""))))

Theorem: smtp-cst-obs-zone-conc11-matching

(defthm smtp-cst-obs-zone-conc11-matching
  (implies (smtp-cst-list-list-conc-matchp cstss "%d65-73")
           (and (equal (len cstss) 1)
                (smtp-cst-list-rep-matchp (nth 0 cstss)
                                          "%d65-73"))))

Theorem: smtp-cst-obs-zone-conc12-matching

(defthm smtp-cst-obs-zone-conc12-matching
  (implies (smtp-cst-list-list-conc-matchp cstss "%d75-90")
           (and (equal (len cstss) 1)
                (smtp-cst-list-rep-matchp (nth 0 cstss)
                                          "%d75-90"))))

Theorem: smtp-cst-obs-zone-conc13-matching

(defthm smtp-cst-obs-zone-conc13-matching
  (implies (smtp-cst-list-list-conc-matchp cstss "%d97-105")
           (and (equal (len cstss) 1)
                (smtp-cst-list-rep-matchp (nth 0 cstss)
                                          "%d97-105"))))

Theorem: smtp-cst-obs-zone-conc14-matching

(defthm smtp-cst-obs-zone-conc14-matching
  (implies (smtp-cst-list-list-conc-matchp cstss "%d107-122")
           (and (equal (len cstss) 1)
                (smtp-cst-list-rep-matchp (nth 0 cstss)
                                          "%d107-122"))))

Theorem: smtp-cst-alpha-conc1-matching

(defthm smtp-cst-alpha-conc1-matching
  (implies (smtp-cst-list-list-conc-matchp cstss "%x41-5A")
           (and (equal (len cstss) 1)
                (smtp-cst-list-rep-matchp (nth 0 cstss)
                                          "%x41-5A"))))

Theorem: smtp-cst-alpha-conc2-matching

(defthm smtp-cst-alpha-conc2-matching
  (implies (smtp-cst-list-list-conc-matchp cstss "%x61-7A")
           (and (equal (len cstss) 1)
                (smtp-cst-list-rep-matchp (nth 0 cstss)
                                          "%x61-7A"))))

Theorem: smtp-cst-cr-conc-matching

(defthm smtp-cst-cr-conc-matching
  (implies (smtp-cst-list-list-conc-matchp cstss "%xD")
           (and (equal (len cstss) 1)
                (smtp-cst-list-rep-matchp (nth 0 cstss)
                                          "%xD"))))

Theorem: smtp-cst-digit-conc-matching

(defthm smtp-cst-digit-conc-matching
  (implies (smtp-cst-list-list-conc-matchp cstss "%x30-39")
           (and (equal (len cstss) 1)
                (smtp-cst-list-rep-matchp (nth 0 cstss)
                                          "%x30-39"))))

Theorem: smtp-cst-dquote-conc-matching

(defthm smtp-cst-dquote-conc-matching
  (implies (smtp-cst-list-list-conc-matchp cstss "%x22")
           (and (equal (len cstss) 1)
                (smtp-cst-list-rep-matchp (nth 0 cstss)
                                          "%x22"))))

Theorem: smtp-cst-hexdig-conc1-matching

(defthm smtp-cst-hexdig-conc1-matching
  (implies (smtp-cst-list-list-conc-matchp cstss "digit")
           (and (equal (len cstss) 1)
                (smtp-cst-list-rep-matchp (nth 0 cstss)
                                          "digit"))))

Theorem: smtp-cst-hexdig-conc2-matching

(defthm smtp-cst-hexdig-conc2-matching
  (implies (smtp-cst-list-list-conc-matchp cstss "\"A\"")
           (and (equal (len cstss) 1)
                (smtp-cst-list-rep-matchp (nth 0 cstss)
                                          "\"A\""))))

Theorem: smtp-cst-hexdig-conc3-matching

(defthm smtp-cst-hexdig-conc3-matching
  (implies (smtp-cst-list-list-conc-matchp cstss "\"B\"")
           (and (equal (len cstss) 1)
                (smtp-cst-list-rep-matchp (nth 0 cstss)
                                          "\"B\""))))

Theorem: smtp-cst-hexdig-conc4-matching

(defthm smtp-cst-hexdig-conc4-matching
  (implies (smtp-cst-list-list-conc-matchp cstss "\"C\"")
           (and (equal (len cstss) 1)
                (smtp-cst-list-rep-matchp (nth 0 cstss)
                                          "\"C\""))))

Theorem: smtp-cst-hexdig-conc5-matching

(defthm smtp-cst-hexdig-conc5-matching
  (implies (smtp-cst-list-list-conc-matchp cstss "\"D\"")
           (and (equal (len cstss) 1)
                (smtp-cst-list-rep-matchp (nth 0 cstss)
                                          "\"D\""))))

Theorem: smtp-cst-hexdig-conc6-matching

(defthm smtp-cst-hexdig-conc6-matching
  (implies (smtp-cst-list-list-conc-matchp cstss "\"E\"")
           (and (equal (len cstss) 1)
                (smtp-cst-list-rep-matchp (nth 0 cstss)
                                          "\"E\""))))

Theorem: smtp-cst-hexdig-conc7-matching

(defthm smtp-cst-hexdig-conc7-matching
  (implies (smtp-cst-list-list-conc-matchp cstss "\"F\"")
           (and (equal (len cstss) 1)
                (smtp-cst-list-rep-matchp (nth 0 cstss)
                                          "\"F\""))))

Theorem: smtp-cst-lf-conc-matching

(defthm smtp-cst-lf-conc-matching
  (implies (smtp-cst-list-list-conc-matchp cstss "%xA")
           (and (equal (len cstss) 1)
                (smtp-cst-list-rep-matchp (nth 0 cstss)
                                          "%xA"))))

Theorem: smtp-cst-sp-conc-matching

(defthm smtp-cst-sp-conc-matching
  (implies (smtp-cst-list-list-conc-matchp cstss "%x20")
           (and (equal (len cstss) 1)
                (smtp-cst-list-rep-matchp (nth 0 cstss)
                                          "%x20"))))

Theorem: smtp-cst-vchar-conc-matching

(defthm smtp-cst-vchar-conc-matching
  (implies (smtp-cst-list-list-conc-matchp cstss "%x21-7E")
           (and (equal (len cstss) 1)
                (smtp-cst-list-rep-matchp (nth 0 cstss)
                                          "%x21-7E"))))

Theorem: smtp-cst-wsp-conc1-matching

(defthm smtp-cst-wsp-conc1-matching
  (implies (smtp-cst-list-list-conc-matchp cstss "sp")
           (and (equal (len cstss) 1)
                (smtp-cst-list-rep-matchp (nth 0 cstss)
                                          "sp"))))

Theorem: smtp-cst-wsp-conc2-matching

(defthm smtp-cst-wsp-conc2-matching
  (implies (smtp-cst-list-list-conc-matchp cstss "htab")
           (and (equal (len cstss) 1)
                (smtp-cst-list-rep-matchp (nth 0 cstss)
                                          "htab"))))

Theorem: smtp-cst-htab-conc-matching

(defthm smtp-cst-htab-conc-matching
  (implies (smtp-cst-list-list-conc-matchp cstss "%x9")
           (and (equal (len cstss) 1)
                (smtp-cst-list-rep-matchp (nth 0 cstss)
                                          "%x9"))))

Theorem: smtp-cst-ehlo-ok-rsp-conc1-rep-matching

(defthm smtp-cst-ehlo-ok-rsp-conc1-rep-matching
 (implies
  (smtp-cst-list-rep-matchp
       csts
       "( \"250\" sp domain [ sp ehlo-greet ] crlf )")
  (and
   (equal (len csts) 1)
   (smtp-cst-matchp (nth 0 csts)
                    "( \"250\" sp domain [ sp ehlo-greet ] crlf )"))))

Theorem: smtp-cst-ehlo-ok-rsp-conc2-rep-matching

(defthm smtp-cst-ehlo-ok-rsp-conc2-rep-matching
 (implies
  (smtp-cst-list-rep-matchp
   csts
   "( \"250-\" domain [ sp ehlo-greet ] crlf *( \"250-\" ehlo-line crlf ) \"250\" sp ehlo-line crlf )")
  (and
   (equal (len csts) 1)
   (smtp-cst-matchp
    (nth 0 csts)
    "( \"250-\" domain [ sp ehlo-greet ] crlf *( \"250-\" ehlo-line crlf ) \"250\" sp ehlo-line crlf )"))))

Theorem: smtp-cst-reverse-path-conc1-rep-matching

(defthm smtp-cst-reverse-path-conc1-rep-matching
  (implies (smtp-cst-list-rep-matchp csts "path")
           (and (equal (len csts) 1)
                (smtp-cst-matchp (nth 0 csts) "path"))))

Theorem: smtp-cst-reverse-path-conc2-rep-matching

(defthm smtp-cst-reverse-path-conc2-rep-matching
  (implies (smtp-cst-list-rep-matchp csts "\"<>\"")
           (and (equal (len csts) 1)
                (smtp-cst-matchp (nth 0 csts) "\"<>\""))))

Theorem: smtp-cst-forward-path-conc-rep-matching

(defthm smtp-cst-forward-path-conc-rep-matching
  (implies (smtp-cst-list-rep-matchp csts "path")
           (and (equal (len csts) 1)
                (smtp-cst-matchp (nth 0 csts) "path"))))

Theorem: smtp-cst-keyword-conc-rep-matching

(defthm smtp-cst-keyword-conc-rep-matching
  (implies (smtp-cst-list-rep-matchp csts "ldh-str")
           (and (equal (len csts) 1)
                (smtp-cst-matchp (nth 0 csts)
                                 "ldh-str"))))

Theorem: smtp-cst-argument-conc-rep-matching

(defthm smtp-cst-argument-conc-rep-matching
  (implies (smtp-cst-list-rep-matchp csts "atom")
           (and (equal (len csts) 1)
                (smtp-cst-matchp (nth 0 csts) "atom"))))

Theorem: smtp-cst-let-dig-conc1-rep-matching

(defthm smtp-cst-let-dig-conc1-rep-matching
  (implies (smtp-cst-list-rep-matchp csts "alpha")
           (and (equal (len csts) 1)
                (smtp-cst-matchp (nth 0 csts)
                                 "alpha"))))

Theorem: smtp-cst-let-dig-conc2-rep-matching

(defthm smtp-cst-let-dig-conc2-rep-matching
  (implies (smtp-cst-list-rep-matchp csts "digit")
           (and (equal (len csts) 1)
                (smtp-cst-matchp (nth 0 csts)
                                 "digit"))))

Theorem: smtp-cst-local-part-conc1-rep-matching

(defthm smtp-cst-local-part-conc1-rep-matching
  (implies (smtp-cst-list-rep-matchp csts "dot-string")
           (and (equal (len csts) 1)
                (smtp-cst-matchp (nth 0 csts)
                                 "dot-string"))))

Theorem: smtp-cst-local-part-conc2-rep-matching

(defthm smtp-cst-local-part-conc2-rep-matching
  (implies (smtp-cst-list-rep-matchp csts "quoted-string")
           (and (equal (len csts) 1)
                (smtp-cst-matchp (nth 0 csts)
                                 "quoted-string"))))

Theorem: smtp-cst-qcontentsmtp-conc1-rep-matching

(defthm smtp-cst-qcontentsmtp-conc1-rep-matching
  (implies (smtp-cst-list-rep-matchp csts "qtextsmtp")
           (and (equal (len csts) 1)
                (smtp-cst-matchp (nth 0 csts)
                                 "qtextsmtp"))))

Theorem: smtp-cst-qcontentsmtp-conc2-rep-matching

(defthm smtp-cst-qcontentsmtp-conc2-rep-matching
  (implies (smtp-cst-list-rep-matchp csts "quoted-pairsmtp")
           (and (equal (len csts) 1)
                (smtp-cst-matchp (nth 0 csts)
                                 "quoted-pairsmtp"))))

Theorem: smtp-cst-qtextsmtp-conc1-rep-matching

(defthm smtp-cst-qtextsmtp-conc1-rep-matching
  (implies (smtp-cst-list-rep-matchp csts "%d32-33")
           (and (equal (len csts) 1)
                (smtp-cst-matchp (nth 0 csts)
                                 "%d32-33"))))

Theorem: smtp-cst-qtextsmtp-conc2-rep-matching

(defthm smtp-cst-qtextsmtp-conc2-rep-matching
  (implies (smtp-cst-list-rep-matchp csts "%d35-91")
           (and (equal (len csts) 1)
                (smtp-cst-matchp (nth 0 csts)
                                 "%d35-91"))))

Theorem: smtp-cst-qtextsmtp-conc3-rep-matching

(defthm smtp-cst-qtextsmtp-conc3-rep-matching
  (implies (smtp-cst-list-rep-matchp csts "%d93-126")
           (and (equal (len csts) 1)
                (smtp-cst-matchp (nth 0 csts)
                                 "%d93-126"))))

Theorem: smtp-cst-string-conc1-rep-matching

(defthm smtp-cst-string-conc1-rep-matching
  (implies (smtp-cst-list-rep-matchp csts "atom")
           (and (equal (len csts) 1)
                (smtp-cst-matchp (nth 0 csts) "atom"))))

Theorem: smtp-cst-string-conc2-rep-matching

(defthm smtp-cst-string-conc2-rep-matching
  (implies (smtp-cst-list-rep-matchp csts "quoted-string")
           (and (equal (len csts) 1)
                (smtp-cst-matchp (nth 0 csts)
                                 "quoted-string"))))

Theorem: smtp-cst-standardized-tag-conc-rep-matching

(defthm smtp-cst-standardized-tag-conc-rep-matching
  (implies (smtp-cst-list-rep-matchp csts "ldh-str")
           (and (equal (len csts) 1)
                (smtp-cst-matchp (nth 0 csts)
                                 "ldh-str"))))

Theorem: smtp-cst-dcontent-conc1-rep-matching

(defthm smtp-cst-dcontent-conc1-rep-matching
  (implies (smtp-cst-list-rep-matchp csts "%d33-90")
           (and (equal (len csts) 1)
                (smtp-cst-matchp (nth 0 csts)
                                 "%d33-90"))))

Theorem: smtp-cst-dcontent-conc2-rep-matching

(defthm smtp-cst-dcontent-conc2-rep-matching
  (implies (smtp-cst-list-rep-matchp csts "%d94-126")
           (and (equal (len csts) 1)
                (smtp-cst-matchp (nth 0 csts)
                                 "%d94-126"))))

Theorem: smtp-cst-ipv6-addr-conc1-rep-matching

(defthm smtp-cst-ipv6-addr-conc1-rep-matching
  (implies (smtp-cst-list-rep-matchp csts "ipv6-full")
           (and (equal (len csts) 1)
                (smtp-cst-matchp (nth 0 csts)
                                 "ipv6-full"))))

Theorem: smtp-cst-ipv6-addr-conc2-rep-matching

(defthm smtp-cst-ipv6-addr-conc2-rep-matching
  (implies (smtp-cst-list-rep-matchp csts "ipv6-comp")
           (and (equal (len csts) 1)
                (smtp-cst-matchp (nth 0 csts)
                                 "ipv6-comp"))))

Theorem: smtp-cst-ipv6-addr-conc3-rep-matching

(defthm smtp-cst-ipv6-addr-conc3-rep-matching
  (implies (smtp-cst-list-rep-matchp csts "ipv6v4-full")
           (and (equal (len csts) 1)
                (smtp-cst-matchp (nth 0 csts)
                                 "ipv6v4-full"))))

Theorem: smtp-cst-ipv6-addr-conc4-rep-matching

(defthm smtp-cst-ipv6-addr-conc4-rep-matching
  (implies (smtp-cst-list-rep-matchp csts "ipv6v4-comp")
           (and (equal (len csts) 1)
                (smtp-cst-matchp (nth 0 csts)
                                 "ipv6v4-comp"))))

Theorem: smtp-cst-greeting-conc1-rep-matching

(defthm smtp-cst-greeting-conc1-rep-matching
 (implies
  (smtp-cst-list-rep-matchp
   csts
   "( \"220 \" ( domain / address-literal ) [ sp textstring ] crlf )")
  (and
   (equal (len csts) 1)
   (smtp-cst-matchp
    (nth 0 csts)
    "( \"220 \" ( domain / address-literal ) [ sp textstring ] crlf )"))))

Theorem: smtp-cst-greeting-conc2-rep-matching

(defthm smtp-cst-greeting-conc2-rep-matching
 (implies
  (smtp-cst-list-rep-matchp
   csts
   "( \"220-\" ( domain / address-literal ) [ sp textstring ] crlf *( \"220-\" [ textstring ] crlf ) \"220\" [ sp textstring ] crlf )")
  (and
   (equal (len csts) 1)
   (smtp-cst-matchp
    (nth 0 csts)
    "( \"220-\" ( domain / address-literal ) [ sp textstring ] crlf *( \"220-\" [ textstring ] crlf ) \"220\" [ sp textstring ] crlf )"))))

Theorem: smtp-cst-extended-domain-conc1-rep-matching

(defthm smtp-cst-extended-domain-conc1-rep-matching
  (implies (smtp-cst-list-rep-matchp csts "domain")
           (and (equal (len csts) 1)
                (smtp-cst-matchp (nth 0 csts)
                                 "domain"))))

Theorem: smtp-cst-extended-domain-conc2-rep-matching

(defthm smtp-cst-extended-domain-conc2-rep-matching
 (implies
   (smtp-cst-list-rep-matchp csts "( domain fws \"(\" tcp-info \")\" )")
   (and (equal (len csts) 1)
        (smtp-cst-matchp (nth 0 csts)
                         "( domain fws \"(\" tcp-info \")\" )"))))

Theorem: smtp-cst-extended-domain-conc3-rep-matching

(defthm smtp-cst-extended-domain-conc3-rep-matching
 (implies
  (smtp-cst-list-rep-matchp
       csts
       "( address-literal fws \"(\" tcp-info \")\" )")
  (and
     (equal (len csts) 1)
     (smtp-cst-matchp (nth 0 csts)
                      "( address-literal fws \"(\" tcp-info \")\" )"))))

Theorem: smtp-cst-tcp-info-conc1-rep-matching

(defthm smtp-cst-tcp-info-conc1-rep-matching
  (implies (smtp-cst-list-rep-matchp csts "address-literal")
           (and (equal (len csts) 1)
                (smtp-cst-matchp (nth 0 csts)
                                 "address-literal"))))

Theorem: smtp-cst-tcp-info-conc2-rep-matching

(defthm smtp-cst-tcp-info-conc2-rep-matching
 (implies
    (smtp-cst-list-rep-matchp csts "( domain fws address-literal )")
    (and (equal (len csts) 1)
         (smtp-cst-matchp (nth 0 csts)
                          "( domain fws address-literal )"))))

Theorem: smtp-cst-link-conc1-rep-matching

(defthm smtp-cst-link-conc1-rep-matching
  (implies (smtp-cst-list-rep-matchp csts "\"TCP\"")
           (and (equal (len csts) 1)
                (smtp-cst-matchp (nth 0 csts)
                                 "\"TCP\""))))

Theorem: smtp-cst-link-conc2-rep-matching

(defthm smtp-cst-link-conc2-rep-matching
  (implies (smtp-cst-list-rep-matchp csts "addtl-link")
           (and (equal (len csts) 1)
                (smtp-cst-matchp (nth 0 csts)
                                 "addtl-link"))))

Theorem: smtp-cst-addtl-link-conc-rep-matching

(defthm smtp-cst-addtl-link-conc-rep-matching
  (implies (smtp-cst-list-rep-matchp csts "atom")
           (and (equal (len csts) 1)
                (smtp-cst-matchp (nth 0 csts) "atom"))))

Theorem: smtp-cst-protocol-conc1-rep-matching

(defthm smtp-cst-protocol-conc1-rep-matching
  (implies (smtp-cst-list-rep-matchp csts "\"ESMTP\"")
           (and (equal (len csts) 1)
                (smtp-cst-matchp (nth 0 csts)
                                 "\"ESMTP\""))))

Theorem: smtp-cst-protocol-conc2-rep-matching

(defthm smtp-cst-protocol-conc2-rep-matching
  (implies (smtp-cst-list-rep-matchp csts "\"SMTP\"")
           (and (equal (len csts) 1)
                (smtp-cst-matchp (nth 0 csts)
                                 "\"SMTP\""))))

Theorem: smtp-cst-protocol-conc3-rep-matching

(defthm smtp-cst-protocol-conc3-rep-matching
  (implies (smtp-cst-list-rep-matchp csts "attdl-protocol")
           (and (equal (len csts) 1)
                (smtp-cst-matchp (nth 0 csts)
                                 "attdl-protocol"))))

Theorem: smtp-cst-attdl-protocol-conc-rep-matching

(defthm smtp-cst-attdl-protocol-conc-rep-matching
  (implies (smtp-cst-list-rep-matchp csts "atom")
           (and (equal (len csts) 1)
                (smtp-cst-matchp (nth 0 csts) "atom"))))

Theorem: smtp-cst-atext-conc1-rep-matching

(defthm smtp-cst-atext-conc1-rep-matching
  (implies (smtp-cst-list-rep-matchp csts "alpha")
           (and (equal (len csts) 1)
                (smtp-cst-matchp (nth 0 csts)
                                 "alpha"))))

Theorem: smtp-cst-atext-conc2-rep-matching

(defthm smtp-cst-atext-conc2-rep-matching
  (implies (smtp-cst-list-rep-matchp csts "digit")
           (and (equal (len csts) 1)
                (smtp-cst-matchp (nth 0 csts)
                                 "digit"))))

Theorem: smtp-cst-atext-conc3-rep-matching

(defthm smtp-cst-atext-conc3-rep-matching
  (implies (smtp-cst-list-rep-matchp csts "\"!\"")
           (and (equal (len csts) 1)
                (smtp-cst-matchp (nth 0 csts) "\"!\""))))

Theorem: smtp-cst-atext-conc4-rep-matching

(defthm smtp-cst-atext-conc4-rep-matching
  (implies (smtp-cst-list-rep-matchp csts "\"#\"")
           (and (equal (len csts) 1)
                (smtp-cst-matchp (nth 0 csts) "\"#\""))))

Theorem: smtp-cst-atext-conc5-rep-matching

(defthm smtp-cst-atext-conc5-rep-matching
  (implies (smtp-cst-list-rep-matchp csts "\"$\"")
           (and (equal (len csts) 1)
                (smtp-cst-matchp (nth 0 csts) "\"$\""))))

Theorem: smtp-cst-atext-conc6-rep-matching

(defthm smtp-cst-atext-conc6-rep-matching
  (implies (smtp-cst-list-rep-matchp csts "\"%\"")
           (and (equal (len csts) 1)
                (smtp-cst-matchp (nth 0 csts) "\"%\""))))

Theorem: smtp-cst-atext-conc7-rep-matching

(defthm smtp-cst-atext-conc7-rep-matching
  (implies (smtp-cst-list-rep-matchp csts "\"&\"")
           (and (equal (len csts) 1)
                (smtp-cst-matchp (nth 0 csts) "\"&\""))))

Theorem: smtp-cst-atext-conc8-rep-matching

(defthm smtp-cst-atext-conc8-rep-matching
  (implies (smtp-cst-list-rep-matchp csts "\"'\"")
           (and (equal (len csts) 1)
                (smtp-cst-matchp (nth 0 csts) "\"'\""))))

Theorem: smtp-cst-atext-conc9-rep-matching

(defthm smtp-cst-atext-conc9-rep-matching
  (implies (smtp-cst-list-rep-matchp csts "\"*\"")
           (and (equal (len csts) 1)
                (smtp-cst-matchp (nth 0 csts) "\"*\""))))

Theorem: smtp-cst-atext-conc10-rep-matching

(defthm smtp-cst-atext-conc10-rep-matching
  (implies (smtp-cst-list-rep-matchp csts "\"+\"")
           (and (equal (len csts) 1)
                (smtp-cst-matchp (nth 0 csts) "\"+\""))))

Theorem: smtp-cst-atext-conc11-rep-matching

(defthm smtp-cst-atext-conc11-rep-matching
  (implies (smtp-cst-list-rep-matchp csts "\"-\"")
           (and (equal (len csts) 1)
                (smtp-cst-matchp (nth 0 csts) "\"-\""))))

Theorem: smtp-cst-atext-conc12-rep-matching

(defthm smtp-cst-atext-conc12-rep-matching
  (implies (smtp-cst-list-rep-matchp csts "\"/\"")
           (and (equal (len csts) 1)
                (smtp-cst-matchp (nth 0 csts) "\"/\""))))

Theorem: smtp-cst-atext-conc13-rep-matching

(defthm smtp-cst-atext-conc13-rep-matching
  (implies (smtp-cst-list-rep-matchp csts "\"=\"")
           (and (equal (len csts) 1)
                (smtp-cst-matchp (nth 0 csts) "\"=\""))))

Theorem: smtp-cst-atext-conc14-rep-matching

(defthm smtp-cst-atext-conc14-rep-matching
  (implies (smtp-cst-list-rep-matchp csts "\"?\"")
           (and (equal (len csts) 1)
                (smtp-cst-matchp (nth 0 csts) "\"?\""))))

Theorem: smtp-cst-atext-conc15-rep-matching

(defthm smtp-cst-atext-conc15-rep-matching
  (implies (smtp-cst-list-rep-matchp csts "\"^\"")
           (and (equal (len csts) 1)
                (smtp-cst-matchp (nth 0 csts) "\"^\""))))

Theorem: smtp-cst-atext-conc16-rep-matching

(defthm smtp-cst-atext-conc16-rep-matching
  (implies (smtp-cst-list-rep-matchp csts "\"_\"")
           (and (equal (len csts) 1)
                (smtp-cst-matchp (nth 0 csts) "\"_\""))))

Theorem: smtp-cst-atext-conc17-rep-matching

(defthm smtp-cst-atext-conc17-rep-matching
  (implies (smtp-cst-list-rep-matchp csts "\"`\"")
           (and (equal (len csts) 1)
                (smtp-cst-matchp (nth 0 csts) "\"`\""))))

Theorem: smtp-cst-atext-conc18-rep-matching

(defthm smtp-cst-atext-conc18-rep-matching
  (implies (smtp-cst-list-rep-matchp csts "\"{\"")
           (and (equal (len csts) 1)
                (smtp-cst-matchp (nth 0 csts) "\"{\""))))

Theorem: smtp-cst-atext-conc19-rep-matching

(defthm smtp-cst-atext-conc19-rep-matching
  (implies (smtp-cst-list-rep-matchp csts "\"|\"")
           (and (equal (len csts) 1)
                (smtp-cst-matchp (nth 0 csts) "\"|\""))))

Theorem: smtp-cst-atext-conc20-rep-matching

(defthm smtp-cst-atext-conc20-rep-matching
  (implies (smtp-cst-list-rep-matchp csts "\"}\"")
           (and (equal (len csts) 1)
                (smtp-cst-matchp (nth 0 csts) "\"}\""))))

Theorem: smtp-cst-atext-conc21-rep-matching

(defthm smtp-cst-atext-conc21-rep-matching
  (implies (smtp-cst-list-rep-matchp csts "\"~\"")
           (and (equal (len csts) 1)
                (smtp-cst-matchp (nth 0 csts) "\"~\""))))

Theorem: smtp-cst-cfws-conc1-rep-matching

(defthm smtp-cst-cfws-conc1-rep-matching
 (implies
      (smtp-cst-list-rep-matchp csts
                                "( 1*( [ fws ] comment ) [ fws ] )")
      (and (equal (len csts) 1)
           (smtp-cst-matchp (nth 0 csts)
                            "( 1*( [ fws ] comment ) [ fws ] )"))))

Theorem: smtp-cst-cfws-conc2-rep-matching

(defthm smtp-cst-cfws-conc2-rep-matching
  (implies (smtp-cst-list-rep-matchp csts "fws")
           (and (equal (len csts) 1)
                (smtp-cst-matchp (nth 0 csts) "fws"))))

Theorem: smtp-cst-ccontent-conc1-rep-matching

(defthm smtp-cst-ccontent-conc1-rep-matching
  (implies (smtp-cst-list-rep-matchp csts "ctext")
           (and (equal (len csts) 1)
                (smtp-cst-matchp (nth 0 csts)
                                 "ctext"))))

Theorem: smtp-cst-ccontent-conc2-rep-matching

(defthm smtp-cst-ccontent-conc2-rep-matching
  (implies (smtp-cst-list-rep-matchp csts "quoted-pair")
           (and (equal (len csts) 1)
                (smtp-cst-matchp (nth 0 csts)
                                 "quoted-pair"))))

Theorem: smtp-cst-ccontent-conc3-rep-matching

(defthm smtp-cst-ccontent-conc3-rep-matching
  (implies (smtp-cst-list-rep-matchp csts "comment")
           (and (equal (len csts) 1)
                (smtp-cst-matchp (nth 0 csts)
                                 "comment"))))

Theorem: smtp-cst-ctext-conc1-rep-matching

(defthm smtp-cst-ctext-conc1-rep-matching
  (implies (smtp-cst-list-rep-matchp csts "%d33-39")
           (and (equal (len csts) 1)
                (smtp-cst-matchp (nth 0 csts)
                                 "%d33-39"))))

Theorem: smtp-cst-ctext-conc2-rep-matching

(defthm smtp-cst-ctext-conc2-rep-matching
  (implies (smtp-cst-list-rep-matchp csts "%d42-91")
           (and (equal (len csts) 1)
                (smtp-cst-matchp (nth 0 csts)
                                 "%d42-91"))))

Theorem: smtp-cst-ctext-conc3-rep-matching

(defthm smtp-cst-ctext-conc3-rep-matching
  (implies (smtp-cst-list-rep-matchp csts "%d93-126")
           (and (equal (len csts) 1)
                (smtp-cst-matchp (nth 0 csts)
                                 "%d93-126"))))

Theorem: smtp-cst-ctext-conc4-rep-matching

(defthm smtp-cst-ctext-conc4-rep-matching
  (implies (smtp-cst-list-rep-matchp csts "obs-ctext")
           (and (equal (len csts) 1)
                (smtp-cst-matchp (nth 0 csts)
                                 "obs-ctext"))))

Theorem: smtp-cst-day-conc1-rep-matching

(defthm smtp-cst-day-conc1-rep-matching
 (implies (smtp-cst-list-rep-matchp csts "( [ fws ] 1*2digit fws )")
          (and (equal (len csts) 1)
               (smtp-cst-matchp (nth 0 csts)
                                "( [ fws ] 1*2digit fws )"))))

Theorem: smtp-cst-day-conc2-rep-matching

(defthm smtp-cst-day-conc2-rep-matching
  (implies (smtp-cst-list-rep-matchp csts "obs-day")
           (and (equal (len csts) 1)
                (smtp-cst-matchp (nth 0 csts)
                                 "obs-day"))))

Theorem: smtp-cst-day-of-week-conc1-rep-matching

(defthm smtp-cst-day-of-week-conc1-rep-matching
  (implies (smtp-cst-list-rep-matchp csts "( [ fws ] day-name )")
           (and (equal (len csts) 1)
                (smtp-cst-matchp (nth 0 csts)
                                 "( [ fws ] day-name )"))))

Theorem: smtp-cst-day-of-week-conc2-rep-matching

(defthm smtp-cst-day-of-week-conc2-rep-matching
  (implies (smtp-cst-list-rep-matchp csts "obs-day-of-week")
           (and (equal (len csts) 1)
                (smtp-cst-matchp (nth 0 csts)
                                 "obs-day-of-week"))))

Theorem: smtp-cst-day-name-conc1-rep-matching

(defthm smtp-cst-day-name-conc1-rep-matching
  (implies (smtp-cst-list-rep-matchp csts "\"Mon\"")
           (and (equal (len csts) 1)
                (smtp-cst-matchp (nth 0 csts)
                                 "\"Mon\""))))

Theorem: smtp-cst-day-name-conc2-rep-matching

(defthm smtp-cst-day-name-conc2-rep-matching
  (implies (smtp-cst-list-rep-matchp csts "\"Tue\"")
           (and (equal (len csts) 1)
                (smtp-cst-matchp (nth 0 csts)
                                 "\"Tue\""))))

Theorem: smtp-cst-day-name-conc3-rep-matching

(defthm smtp-cst-day-name-conc3-rep-matching
  (implies (smtp-cst-list-rep-matchp csts "\"Wed\"")
           (and (equal (len csts) 1)
                (smtp-cst-matchp (nth 0 csts)
                                 "\"Wed\""))))

Theorem: smtp-cst-day-name-conc4-rep-matching

(defthm smtp-cst-day-name-conc4-rep-matching
  (implies (smtp-cst-list-rep-matchp csts "\"Thu\"")
           (and (equal (len csts) 1)
                (smtp-cst-matchp (nth 0 csts)
                                 "\"Thu\""))))

Theorem: smtp-cst-day-name-conc5-rep-matching

(defthm smtp-cst-day-name-conc5-rep-matching
  (implies (smtp-cst-list-rep-matchp csts "\"Fri\"")
           (and (equal (len csts) 1)
                (smtp-cst-matchp (nth 0 csts)
                                 "\"Fri\""))))

Theorem: smtp-cst-day-name-conc6-rep-matching

(defthm smtp-cst-day-name-conc6-rep-matching
  (implies (smtp-cst-list-rep-matchp csts "\"Sat\"")
           (and (equal (len csts) 1)
                (smtp-cst-matchp (nth 0 csts)
                                 "\"Sat\""))))

Theorem: smtp-cst-day-name-conc7-rep-matching

(defthm smtp-cst-day-name-conc7-rep-matching
  (implies (smtp-cst-list-rep-matchp csts "\"Sun\"")
           (and (equal (len csts) 1)
                (smtp-cst-matchp (nth 0 csts)
                                 "\"Sun\""))))

Theorem: smtp-cst-fws-conc1-rep-matching

(defthm smtp-cst-fws-conc1-rep-matching
  (implies (smtp-cst-list-rep-matchp csts "( [ *wsp crlf ] 1*wsp )")
           (and (equal (len csts) 1)
                (smtp-cst-matchp (nth 0 csts)
                                 "( [ *wsp crlf ] 1*wsp )"))))

Theorem: smtp-cst-fws-conc2-rep-matching

(defthm smtp-cst-fws-conc2-rep-matching
  (implies (smtp-cst-list-rep-matchp csts "obs-fws")
           (and (equal (len csts) 1)
                (smtp-cst-matchp (nth 0 csts)
                                 "obs-fws"))))

Theorem: smtp-cst-month-conc1-rep-matching

(defthm smtp-cst-month-conc1-rep-matching
  (implies (smtp-cst-list-rep-matchp csts "\"Jan\"")
           (and (equal (len csts) 1)
                (smtp-cst-matchp (nth 0 csts)
                                 "\"Jan\""))))

Theorem: smtp-cst-month-conc2-rep-matching

(defthm smtp-cst-month-conc2-rep-matching
  (implies (smtp-cst-list-rep-matchp csts "\"Feb\"")
           (and (equal (len csts) 1)
                (smtp-cst-matchp (nth 0 csts)
                                 "\"Feb\""))))

Theorem: smtp-cst-month-conc3-rep-matching

(defthm smtp-cst-month-conc3-rep-matching
  (implies (smtp-cst-list-rep-matchp csts "\"Mar\"")
           (and (equal (len csts) 1)
                (smtp-cst-matchp (nth 0 csts)
                                 "\"Mar\""))))

Theorem: smtp-cst-month-conc4-rep-matching

(defthm smtp-cst-month-conc4-rep-matching
  (implies (smtp-cst-list-rep-matchp csts "\"Apr\"")
           (and (equal (len csts) 1)
                (smtp-cst-matchp (nth 0 csts)
                                 "\"Apr\""))))

Theorem: smtp-cst-month-conc5-rep-matching

(defthm smtp-cst-month-conc5-rep-matching
  (implies (smtp-cst-list-rep-matchp csts "\"May\"")
           (and (equal (len csts) 1)
                (smtp-cst-matchp (nth 0 csts)
                                 "\"May\""))))

Theorem: smtp-cst-month-conc6-rep-matching

(defthm smtp-cst-month-conc6-rep-matching
  (implies (smtp-cst-list-rep-matchp csts "\"Jun\"")
           (and (equal (len csts) 1)
                (smtp-cst-matchp (nth 0 csts)
                                 "\"Jun\""))))

Theorem: smtp-cst-month-conc7-rep-matching

(defthm smtp-cst-month-conc7-rep-matching
  (implies (smtp-cst-list-rep-matchp csts "\"Jul\"")
           (and (equal (len csts) 1)
                (smtp-cst-matchp (nth 0 csts)
                                 "\"Jul\""))))

Theorem: smtp-cst-month-conc8-rep-matching

(defthm smtp-cst-month-conc8-rep-matching
  (implies (smtp-cst-list-rep-matchp csts "\"Aug\"")
           (and (equal (len csts) 1)
                (smtp-cst-matchp (nth 0 csts)
                                 "\"Aug\""))))

Theorem: smtp-cst-month-conc9-rep-matching

(defthm smtp-cst-month-conc9-rep-matching
  (implies (smtp-cst-list-rep-matchp csts "\"Sep\"")
           (and (equal (len csts) 1)
                (smtp-cst-matchp (nth 0 csts)
                                 "\"Sep\""))))

Theorem: smtp-cst-month-conc10-rep-matching

(defthm smtp-cst-month-conc10-rep-matching
  (implies (smtp-cst-list-rep-matchp csts "\"Oct\"")
           (and (equal (len csts) 1)
                (smtp-cst-matchp (nth 0 csts)
                                 "\"Oct\""))))

Theorem: smtp-cst-month-conc11-rep-matching

(defthm smtp-cst-month-conc11-rep-matching
  (implies (smtp-cst-list-rep-matchp csts "\"Nov\"")
           (and (equal (len csts) 1)
                (smtp-cst-matchp (nth 0 csts)
                                 "\"Nov\""))))

Theorem: smtp-cst-month-conc12-rep-matching

(defthm smtp-cst-month-conc12-rep-matching
  (implies (smtp-cst-list-rep-matchp csts "\"Dec\"")
           (and (equal (len csts) 1)
                (smtp-cst-matchp (nth 0 csts)
                                 "\"Dec\""))))

Theorem: smtp-cst-id-left-conc1-rep-matching

(defthm smtp-cst-id-left-conc1-rep-matching
  (implies (smtp-cst-list-rep-matchp csts "dot-atom-text")
           (and (equal (len csts) 1)
                (smtp-cst-matchp (nth 0 csts)
                                 "dot-atom-text"))))

Theorem: smtp-cst-id-left-conc2-rep-matching

(defthm smtp-cst-id-left-conc2-rep-matching
  (implies (smtp-cst-list-rep-matchp csts "obs-id-left")
           (and (equal (len csts) 1)
                (smtp-cst-matchp (nth 0 csts)
                                 "obs-id-left"))))

Theorem: smtp-cst-id-right-conc1-rep-matching

(defthm smtp-cst-id-right-conc1-rep-matching
  (implies (smtp-cst-list-rep-matchp csts "dot-atom-text")
           (and (equal (len csts) 1)
                (smtp-cst-matchp (nth 0 csts)
                                 "dot-atom-text"))))

Theorem: smtp-cst-id-right-conc2-rep-matching

(defthm smtp-cst-id-right-conc2-rep-matching
  (implies (smtp-cst-list-rep-matchp csts "no-fold-literal")
           (and (equal (len csts) 1)
                (smtp-cst-matchp (nth 0 csts)
                                 "no-fold-literal"))))

Theorem: smtp-cst-id-right-conc3-rep-matching

(defthm smtp-cst-id-right-conc3-rep-matching
  (implies (smtp-cst-list-rep-matchp csts "obs-id-right")
           (and (equal (len csts) 1)
                (smtp-cst-matchp (nth 0 csts)
                                 "obs-id-right"))))

Theorem: smtp-cst-dtext-conc1-rep-matching

(defthm smtp-cst-dtext-conc1-rep-matching
  (implies (smtp-cst-list-rep-matchp csts "%d33-90")
           (and (equal (len csts) 1)
                (smtp-cst-matchp (nth 0 csts)
                                 "%d33-90"))))

Theorem: smtp-cst-dtext-conc2-rep-matching

(defthm smtp-cst-dtext-conc2-rep-matching
  (implies (smtp-cst-list-rep-matchp csts "%d94-126")
           (and (equal (len csts) 1)
                (smtp-cst-matchp (nth 0 csts)
                                 "%d94-126"))))

Theorem: smtp-cst-dtext-conc3-rep-matching

(defthm smtp-cst-dtext-conc3-rep-matching
  (implies (smtp-cst-list-rep-matchp csts "obs-dtext")
           (and (equal (len csts) 1)
                (smtp-cst-matchp (nth 0 csts)
                                 "obs-dtext"))))

Theorem: smtp-cst-obs-ctext-conc-rep-matching

(defthm smtp-cst-obs-ctext-conc-rep-matching
  (implies (smtp-cst-list-rep-matchp csts "obs-no-ws-ctl")
           (and (equal (len csts) 1)
                (smtp-cst-matchp (nth 0 csts)
                                 "obs-no-ws-ctl"))))

Theorem: smtp-cst-obs-dtext-conc1-rep-matching

(defthm smtp-cst-obs-dtext-conc1-rep-matching
  (implies (smtp-cst-list-rep-matchp csts "obs-no-ws-ctl")
           (and (equal (len csts) 1)
                (smtp-cst-matchp (nth 0 csts)
                                 "obs-no-ws-ctl"))))

Theorem: smtp-cst-obs-dtext-conc2-rep-matching

(defthm smtp-cst-obs-dtext-conc2-rep-matching
  (implies (smtp-cst-list-rep-matchp csts "quoted-pair")
           (and (equal (len csts) 1)
                (smtp-cst-matchp (nth 0 csts)
                                 "quoted-pair"))))

Theorem: smtp-cst-obs-id-left-conc-rep-matching

(defthm smtp-cst-obs-id-left-conc-rep-matching
  (implies (smtp-cst-list-rep-matchp csts "imf-local-part")
           (and (equal (len csts) 1)
                (smtp-cst-matchp (nth 0 csts)
                                 "imf-local-part"))))

Theorem: smtp-cst-imf-local-part-conc1-rep-matching

(defthm smtp-cst-imf-local-part-conc1-rep-matching
  (implies (smtp-cst-list-rep-matchp csts "dot-atom")
           (and (equal (len csts) 1)
                (smtp-cst-matchp (nth 0 csts)
                                 "dot-atom"))))

Theorem: smtp-cst-imf-local-part-conc2-rep-matching

(defthm smtp-cst-imf-local-part-conc2-rep-matching
  (implies (smtp-cst-list-rep-matchp csts "imf-quoted-string")
           (and (equal (len csts) 1)
                (smtp-cst-matchp (nth 0 csts)
                                 "imf-quoted-string"))))

Theorem: smtp-cst-imf-local-part-conc3-rep-matching

(defthm smtp-cst-imf-local-part-conc3-rep-matching
  (implies (smtp-cst-list-rep-matchp csts "obs-local-part")
           (and (equal (len csts) 1)
                (smtp-cst-matchp (nth 0 csts)
                                 "obs-local-part"))))

Theorem: smtp-cst-obs-id-right-conc-rep-matching

(defthm smtp-cst-obs-id-right-conc-rep-matching
  (implies (smtp-cst-list-rep-matchp csts "imf-domain")
           (and (equal (len csts) 1)
                (smtp-cst-matchp (nth 0 csts)
                                 "imf-domain"))))

Theorem: smtp-cst-imf-domain-conc1-rep-matching

(defthm smtp-cst-imf-domain-conc1-rep-matching
  (implies (smtp-cst-list-rep-matchp csts "dot-atom")
           (and (equal (len csts) 1)
                (smtp-cst-matchp (nth 0 csts)
                                 "dot-atom"))))

Theorem: smtp-cst-imf-domain-conc2-rep-matching

(defthm smtp-cst-imf-domain-conc2-rep-matching
  (implies (smtp-cst-list-rep-matchp csts "domain-literal")
           (and (equal (len csts) 1)
                (smtp-cst-matchp (nth 0 csts)
                                 "domain-literal"))))

Theorem: smtp-cst-imf-domain-conc3-rep-matching

(defthm smtp-cst-imf-domain-conc3-rep-matching
  (implies (smtp-cst-list-rep-matchp csts "obs-domain")
           (and (equal (len csts) 1)
                (smtp-cst-matchp (nth 0 csts)
                                 "obs-domain"))))

Theorem: smtp-cst-obs-no-ws-ctl-conc1-rep-matching

(defthm smtp-cst-obs-no-ws-ctl-conc1-rep-matching
  (implies (smtp-cst-list-rep-matchp csts "%d1-8")
           (and (equal (len csts) 1)
                (smtp-cst-matchp (nth 0 csts)
                                 "%d1-8"))))

Theorem: smtp-cst-obs-no-ws-ctl-conc2-rep-matching

(defthm smtp-cst-obs-no-ws-ctl-conc2-rep-matching
  (implies (smtp-cst-list-rep-matchp csts "%d11")
           (and (equal (len csts) 1)
                (smtp-cst-matchp (nth 0 csts) "%d11"))))

Theorem: smtp-cst-obs-no-ws-ctl-conc3-rep-matching

(defthm smtp-cst-obs-no-ws-ctl-conc3-rep-matching
  (implies (smtp-cst-list-rep-matchp csts "%d12")
           (and (equal (len csts) 1)
                (smtp-cst-matchp (nth 0 csts) "%d12"))))

Theorem: smtp-cst-obs-no-ws-ctl-conc4-rep-matching

(defthm smtp-cst-obs-no-ws-ctl-conc4-rep-matching
  (implies (smtp-cst-list-rep-matchp csts "%d14-31")
           (and (equal (len csts) 1)
                (smtp-cst-matchp (nth 0 csts)
                                 "%d14-31"))))

Theorem: smtp-cst-obs-no-ws-ctl-conc5-rep-matching

(defthm smtp-cst-obs-no-ws-ctl-conc5-rep-matching
  (implies (smtp-cst-list-rep-matchp csts "%d127")
           (and (equal (len csts) 1)
                (smtp-cst-matchp (nth 0 csts)
                                 "%d127"))))

Theorem: smtp-cst-qcontent-conc1-rep-matching

(defthm smtp-cst-qcontent-conc1-rep-matching
  (implies (smtp-cst-list-rep-matchp csts "qtext")
           (and (equal (len csts) 1)
                (smtp-cst-matchp (nth 0 csts)
                                 "qtext"))))

Theorem: smtp-cst-qcontent-conc2-rep-matching

(defthm smtp-cst-qcontent-conc2-rep-matching
  (implies (smtp-cst-list-rep-matchp csts "quoted-pair")
           (and (equal (len csts) 1)
                (smtp-cst-matchp (nth 0 csts)
                                 "quoted-pair"))))

Theorem: smtp-cst-qtext-conc1-rep-matching

(defthm smtp-cst-qtext-conc1-rep-matching
  (implies (smtp-cst-list-rep-matchp csts "%d33")
           (and (equal (len csts) 1)
                (smtp-cst-matchp (nth 0 csts) "%d33"))))

Theorem: smtp-cst-qtext-conc2-rep-matching

(defthm smtp-cst-qtext-conc2-rep-matching
  (implies (smtp-cst-list-rep-matchp csts "%d35-91")
           (and (equal (len csts) 1)
                (smtp-cst-matchp (nth 0 csts)
                                 "%d35-91"))))

Theorem: smtp-cst-qtext-conc3-rep-matching

(defthm smtp-cst-qtext-conc3-rep-matching
  (implies (smtp-cst-list-rep-matchp csts "%d93-126")
           (and (equal (len csts) 1)
                (smtp-cst-matchp (nth 0 csts)
                                 "%d93-126"))))

Theorem: smtp-cst-qtext-conc4-rep-matching

(defthm smtp-cst-qtext-conc4-rep-matching
  (implies (smtp-cst-list-rep-matchp csts "obs-qtext")
           (and (equal (len csts) 1)
                (smtp-cst-matchp (nth 0 csts)
                                 "obs-qtext"))))

Theorem: smtp-cst-obs-qtext-conc-rep-matching

(defthm smtp-cst-obs-qtext-conc-rep-matching
  (implies (smtp-cst-list-rep-matchp csts "obs-no-ws-ctl")
           (and (equal (len csts) 1)
                (smtp-cst-matchp (nth 0 csts)
                                 "obs-no-ws-ctl"))))

Theorem: smtp-cst-quoted-pair-conc1-rep-matching

(defthm smtp-cst-quoted-pair-conc1-rep-matching
  (implies (smtp-cst-list-rep-matchp csts "( \"\\\" ( vchar / wsp ) )")
           (and (equal (len csts) 1)
                (smtp-cst-matchp (nth 0 csts)
                                 "( \"\\\" ( vchar / wsp ) )"))))

Theorem: smtp-cst-quoted-pair-conc2-rep-matching

(defthm smtp-cst-quoted-pair-conc2-rep-matching
  (implies (smtp-cst-list-rep-matchp csts "obs-qp")
           (and (equal (len csts) 1)
                (smtp-cst-matchp (nth 0 csts)
                                 "obs-qp"))))

Theorem: smtp-cst-hour-conc2-rep-matching

(defthm smtp-cst-hour-conc2-rep-matching
  (implies (smtp-cst-list-rep-matchp csts "obs-hour")
           (and (equal (len csts) 1)
                (smtp-cst-matchp (nth 0 csts)
                                 "obs-hour"))))

Theorem: smtp-cst-minute-conc2-rep-matching

(defthm smtp-cst-minute-conc2-rep-matching
  (implies (smtp-cst-list-rep-matchp csts "obs-minute")
           (and (equal (len csts) 1)
                (smtp-cst-matchp (nth 0 csts)
                                 "obs-minute"))))

Theorem: smtp-cst-second-conc2-rep-matching

(defthm smtp-cst-second-conc2-rep-matching
  (implies (smtp-cst-list-rep-matchp csts "obs-second")
           (and (equal (len csts) 1)
                (smtp-cst-matchp (nth 0 csts)
                                 "obs-second"))))

Theorem: smtp-cst-word-conc1-rep-matching

(defthm smtp-cst-word-conc1-rep-matching
  (implies (smtp-cst-list-rep-matchp csts "imf-atom")
           (and (equal (len csts) 1)
                (smtp-cst-matchp (nth 0 csts)
                                 "imf-atom"))))

Theorem: smtp-cst-word-conc2-rep-matching

(defthm smtp-cst-word-conc2-rep-matching
  (implies (smtp-cst-list-rep-matchp csts "imf-quoted-string")
           (and (equal (len csts) 1)
                (smtp-cst-matchp (nth 0 csts)
                                 "imf-quoted-string"))))

Theorem: smtp-cst-year-conc1-rep-matching

(defthm smtp-cst-year-conc1-rep-matching
  (implies (smtp-cst-list-rep-matchp csts "( fws 4*digit fws )")
           (and (equal (len csts) 1)
                (smtp-cst-matchp (nth 0 csts)
                                 "( fws 4*digit fws )"))))

Theorem: smtp-cst-year-conc2-rep-matching

(defthm smtp-cst-year-conc2-rep-matching
  (implies (smtp-cst-list-rep-matchp csts "obs-year")
           (and (equal (len csts) 1)
                (smtp-cst-matchp (nth 0 csts)
                                 "obs-year"))))

Theorem: smtp-cst-zone-conc1-rep-matching

(defthm smtp-cst-zone-conc1-rep-matching
 (implies
      (smtp-cst-list-rep-matchp csts "( fws ( \"+\" / \"-\" ) 4digit )")
      (and (equal (len csts) 1)
           (smtp-cst-matchp (nth 0 csts)
                            "( fws ( \"+\" / \"-\" ) 4digit )"))))

Theorem: smtp-cst-zone-conc2-rep-matching

(defthm smtp-cst-zone-conc2-rep-matching
  (implies (smtp-cst-list-rep-matchp csts "obs-zone")
           (and (equal (len csts) 1)
                (smtp-cst-matchp (nth 0 csts)
                                 "obs-zone"))))

Theorem: smtp-cst-obs-zone-conc1-rep-matching

(defthm smtp-cst-obs-zone-conc1-rep-matching
  (implies (smtp-cst-list-rep-matchp csts "\"UT\"")
           (and (equal (len csts) 1)
                (smtp-cst-matchp (nth 0 csts) "\"UT\""))))

Theorem: smtp-cst-obs-zone-conc2-rep-matching

(defthm smtp-cst-obs-zone-conc2-rep-matching
  (implies (smtp-cst-list-rep-matchp csts "\"GMT\"")
           (and (equal (len csts) 1)
                (smtp-cst-matchp (nth 0 csts)
                                 "\"GMT\""))))

Theorem: smtp-cst-obs-zone-conc3-rep-matching

(defthm smtp-cst-obs-zone-conc3-rep-matching
  (implies (smtp-cst-list-rep-matchp csts "\"EST\"")
           (and (equal (len csts) 1)
                (smtp-cst-matchp (nth 0 csts)
                                 "\"EST\""))))

Theorem: smtp-cst-obs-zone-conc4-rep-matching

(defthm smtp-cst-obs-zone-conc4-rep-matching
  (implies (smtp-cst-list-rep-matchp csts "\"EDT\"")
           (and (equal (len csts) 1)
                (smtp-cst-matchp (nth 0 csts)
                                 "\"EDT\""))))

Theorem: smtp-cst-obs-zone-conc5-rep-matching

(defthm smtp-cst-obs-zone-conc5-rep-matching
  (implies (smtp-cst-list-rep-matchp csts "\"CST\"")
           (and (equal (len csts) 1)
                (smtp-cst-matchp (nth 0 csts)
                                 "\"CST\""))))

Theorem: smtp-cst-obs-zone-conc6-rep-matching

(defthm smtp-cst-obs-zone-conc6-rep-matching
  (implies (smtp-cst-list-rep-matchp csts "\"CDT\"")
           (and (equal (len csts) 1)
                (smtp-cst-matchp (nth 0 csts)
                                 "\"CDT\""))))

Theorem: smtp-cst-obs-zone-conc7-rep-matching

(defthm smtp-cst-obs-zone-conc7-rep-matching
  (implies (smtp-cst-list-rep-matchp csts "\"MST\"")
           (and (equal (len csts) 1)
                (smtp-cst-matchp (nth 0 csts)
                                 "\"MST\""))))

Theorem: smtp-cst-obs-zone-conc8-rep-matching

(defthm smtp-cst-obs-zone-conc8-rep-matching
  (implies (smtp-cst-list-rep-matchp csts "\"MDT\"")
           (and (equal (len csts) 1)
                (smtp-cst-matchp (nth 0 csts)
                                 "\"MDT\""))))

Theorem: smtp-cst-obs-zone-conc9-rep-matching

(defthm smtp-cst-obs-zone-conc9-rep-matching
  (implies (smtp-cst-list-rep-matchp csts "\"PST\"")
           (and (equal (len csts) 1)
                (smtp-cst-matchp (nth 0 csts)
                                 "\"PST\""))))

Theorem: smtp-cst-obs-zone-conc10-rep-matching

(defthm smtp-cst-obs-zone-conc10-rep-matching
  (implies (smtp-cst-list-rep-matchp csts "\"PDT\"")
           (and (equal (len csts) 1)
                (smtp-cst-matchp (nth 0 csts)
                                 "\"PDT\""))))

Theorem: smtp-cst-obs-zone-conc11-rep-matching

(defthm smtp-cst-obs-zone-conc11-rep-matching
  (implies (smtp-cst-list-rep-matchp csts "%d65-73")
           (and (equal (len csts) 1)
                (smtp-cst-matchp (nth 0 csts)
                                 "%d65-73"))))

Theorem: smtp-cst-obs-zone-conc12-rep-matching

(defthm smtp-cst-obs-zone-conc12-rep-matching
  (implies (smtp-cst-list-rep-matchp csts "%d75-90")
           (and (equal (len csts) 1)
                (smtp-cst-matchp (nth 0 csts)
                                 "%d75-90"))))

Theorem: smtp-cst-obs-zone-conc13-rep-matching

(defthm smtp-cst-obs-zone-conc13-rep-matching
  (implies (smtp-cst-list-rep-matchp csts "%d97-105")
           (and (equal (len csts) 1)
                (smtp-cst-matchp (nth 0 csts)
                                 "%d97-105"))))

Theorem: smtp-cst-obs-zone-conc14-rep-matching

(defthm smtp-cst-obs-zone-conc14-rep-matching
  (implies (smtp-cst-list-rep-matchp csts "%d107-122")
           (and (equal (len csts) 1)
                (smtp-cst-matchp (nth 0 csts)
                                 "%d107-122"))))

Theorem: smtp-cst-alpha-conc1-rep-matching

(defthm smtp-cst-alpha-conc1-rep-matching
  (implies (smtp-cst-list-rep-matchp csts "%x41-5A")
           (and (equal (len csts) 1)
                (smtp-cst-matchp (nth 0 csts)
                                 "%x41-5A"))))

Theorem: smtp-cst-alpha-conc2-rep-matching

(defthm smtp-cst-alpha-conc2-rep-matching
  (implies (smtp-cst-list-rep-matchp csts "%x61-7A")
           (and (equal (len csts) 1)
                (smtp-cst-matchp (nth 0 csts)
                                 "%x61-7A"))))

Theorem: smtp-cst-cr-conc-rep-matching

(defthm smtp-cst-cr-conc-rep-matching
  (implies (smtp-cst-list-rep-matchp csts "%xD")
           (and (equal (len csts) 1)
                (smtp-cst-matchp (nth 0 csts) "%xD"))))

Theorem: smtp-cst-digit-conc-rep-matching

(defthm smtp-cst-digit-conc-rep-matching
  (implies (smtp-cst-list-rep-matchp csts "%x30-39")
           (and (equal (len csts) 1)
                (smtp-cst-matchp (nth 0 csts)
                                 "%x30-39"))))

Theorem: smtp-cst-dquote-conc-rep-matching

(defthm smtp-cst-dquote-conc-rep-matching
  (implies (smtp-cst-list-rep-matchp csts "%x22")
           (and (equal (len csts) 1)
                (smtp-cst-matchp (nth 0 csts) "%x22"))))

Theorem: smtp-cst-hexdig-conc1-rep-matching

(defthm smtp-cst-hexdig-conc1-rep-matching
  (implies (smtp-cst-list-rep-matchp csts "digit")
           (and (equal (len csts) 1)
                (smtp-cst-matchp (nth 0 csts)
                                 "digit"))))

Theorem: smtp-cst-hexdig-conc2-rep-matching

(defthm smtp-cst-hexdig-conc2-rep-matching
  (implies (smtp-cst-list-rep-matchp csts "\"A\"")
           (and (equal (len csts) 1)
                (smtp-cst-matchp (nth 0 csts) "\"A\""))))

Theorem: smtp-cst-hexdig-conc3-rep-matching

(defthm smtp-cst-hexdig-conc3-rep-matching
  (implies (smtp-cst-list-rep-matchp csts "\"B\"")
           (and (equal (len csts) 1)
                (smtp-cst-matchp (nth 0 csts) "\"B\""))))

Theorem: smtp-cst-hexdig-conc4-rep-matching

(defthm smtp-cst-hexdig-conc4-rep-matching
  (implies (smtp-cst-list-rep-matchp csts "\"C\"")
           (and (equal (len csts) 1)
                (smtp-cst-matchp (nth 0 csts) "\"C\""))))

Theorem: smtp-cst-hexdig-conc5-rep-matching

(defthm smtp-cst-hexdig-conc5-rep-matching
  (implies (smtp-cst-list-rep-matchp csts "\"D\"")
           (and (equal (len csts) 1)
                (smtp-cst-matchp (nth 0 csts) "\"D\""))))

Theorem: smtp-cst-hexdig-conc6-rep-matching

(defthm smtp-cst-hexdig-conc6-rep-matching
  (implies (smtp-cst-list-rep-matchp csts "\"E\"")
           (and (equal (len csts) 1)
                (smtp-cst-matchp (nth 0 csts) "\"E\""))))

Theorem: smtp-cst-hexdig-conc7-rep-matching

(defthm smtp-cst-hexdig-conc7-rep-matching
  (implies (smtp-cst-list-rep-matchp csts "\"F\"")
           (and (equal (len csts) 1)
                (smtp-cst-matchp (nth 0 csts) "\"F\""))))

Theorem: smtp-cst-lf-conc-rep-matching

(defthm smtp-cst-lf-conc-rep-matching
  (implies (smtp-cst-list-rep-matchp csts "%xA")
           (and (equal (len csts) 1)
                (smtp-cst-matchp (nth 0 csts) "%xA"))))

Theorem: smtp-cst-sp-conc-rep-matching

(defthm smtp-cst-sp-conc-rep-matching
  (implies (smtp-cst-list-rep-matchp csts "%x20")
           (and (equal (len csts) 1)
                (smtp-cst-matchp (nth 0 csts) "%x20"))))

Theorem: smtp-cst-vchar-conc-rep-matching

(defthm smtp-cst-vchar-conc-rep-matching
  (implies (smtp-cst-list-rep-matchp csts "%x21-7E")
           (and (equal (len csts) 1)
                (smtp-cst-matchp (nth 0 csts)
                                 "%x21-7E"))))

Theorem: smtp-cst-wsp-conc1-rep-matching

(defthm smtp-cst-wsp-conc1-rep-matching
  (implies (smtp-cst-list-rep-matchp csts "sp")
           (and (equal (len csts) 1)
                (smtp-cst-matchp (nth 0 csts) "sp"))))

Theorem: smtp-cst-wsp-conc2-rep-matching

(defthm smtp-cst-wsp-conc2-rep-matching
  (implies (smtp-cst-list-rep-matchp csts "htab")
           (and (equal (len csts) 1)
                (smtp-cst-matchp (nth 0 csts) "htab"))))

Theorem: smtp-cst-htab-conc-rep-matching

(defthm smtp-cst-htab-conc-rep-matching
  (implies (smtp-cst-list-rep-matchp csts "%x9")
           (and (equal (len csts) 1)
                (smtp-cst-matchp (nth 0 csts) "%x9"))))

Theorem: smtp-cst-reverse-path-conc-equivs

(defthm smtp-cst-reverse-path-conc-equivs
 (implies
  (smtp-cst-matchp cst "reverse-path")
  (and
   (iff (smtp-cst-list-list-conc-matchp (tree-nonleaf->branches cst)
                                        "path")
        (tree-case (nth 0 (nth 0 (tree-nonleaf->branches cst)))
                   :nonleaf))
   (iff (smtp-cst-list-list-conc-matchp (tree-nonleaf->branches cst)
                                        "\"<>\"")
        (tree-case (nth 0 (nth 0 (tree-nonleaf->branches cst)))
                   :leafterm)))))

Theorem: smtp-cst-let-dig-conc-equivs

(defthm smtp-cst-let-dig-conc-equivs
 (implies
  (smtp-cst-matchp cst "let-dig")
  (and
   (iff (smtp-cst-list-list-conc-matchp (tree-nonleaf->branches cst)
                                        "alpha")
        (equal (tree-nonleaf->rulename?
                    (nth 0 (nth 0 (tree-nonleaf->branches cst))))
               (rulename "alpha")))
   (iff (smtp-cst-list-list-conc-matchp (tree-nonleaf->branches cst)
                                        "digit")
        (equal (tree-nonleaf->rulename?
                    (nth 0 (nth 0 (tree-nonleaf->branches cst))))
               (rulename "digit"))))))

Theorem: smtp-cst-local-part-conc-equivs

(defthm smtp-cst-local-part-conc-equivs
 (implies
  (smtp-cst-matchp cst "local-part")
  (and
   (iff (smtp-cst-list-list-conc-matchp (tree-nonleaf->branches cst)
                                        "dot-string")
        (equal (tree-nonleaf->rulename?
                    (nth 0 (nth 0 (tree-nonleaf->branches cst))))
               (rulename "dot-string")))
   (iff (smtp-cst-list-list-conc-matchp (tree-nonleaf->branches cst)
                                        "quoted-string")
        (equal (tree-nonleaf->rulename?
                    (nth 0 (nth 0 (tree-nonleaf->branches cst))))
               (rulename "quoted-string"))))))

Theorem: smtp-cst-qcontentsmtp-conc-equivs

(defthm smtp-cst-qcontentsmtp-conc-equivs
 (implies
  (smtp-cst-matchp cst "qcontentsmtp")
  (and
   (iff (smtp-cst-list-list-conc-matchp (tree-nonleaf->branches cst)
                                        "qtextsmtp")
        (equal (tree-nonleaf->rulename?
                    (nth 0 (nth 0 (tree-nonleaf->branches cst))))
               (rulename "qtextsmtp")))
   (iff (smtp-cst-list-list-conc-matchp (tree-nonleaf->branches cst)
                                        "quoted-pairsmtp")
        (equal (tree-nonleaf->rulename?
                    (nth 0 (nth 0 (tree-nonleaf->branches cst))))
               (rulename "quoted-pairsmtp"))))))

Theorem: smtp-cst-string-conc-equivs

(defthm smtp-cst-string-conc-equivs
 (implies
  (smtp-cst-matchp cst "string")
  (and
   (iff (smtp-cst-list-list-conc-matchp (tree-nonleaf->branches cst)
                                        "atom")
        (equal (tree-nonleaf->rulename?
                    (nth 0 (nth 0 (tree-nonleaf->branches cst))))
               (rulename "atom")))
   (iff (smtp-cst-list-list-conc-matchp (tree-nonleaf->branches cst)
                                        "quoted-string")
        (equal (tree-nonleaf->rulename?
                    (nth 0 (nth 0 (tree-nonleaf->branches cst))))
               (rulename "quoted-string"))))))

Theorem: smtp-cst-ipv6-addr-conc-equivs

(defthm smtp-cst-ipv6-addr-conc-equivs
 (implies
  (smtp-cst-matchp cst "ipv6-addr")
  (and
   (iff (smtp-cst-list-list-conc-matchp (tree-nonleaf->branches cst)
                                        "ipv6-full")
        (equal (tree-nonleaf->rulename?
                    (nth 0 (nth 0 (tree-nonleaf->branches cst))))
               (rulename "ipv6-full")))
   (iff (smtp-cst-list-list-conc-matchp (tree-nonleaf->branches cst)
                                        "ipv6-comp")
        (equal (tree-nonleaf->rulename?
                    (nth 0 (nth 0 (tree-nonleaf->branches cst))))
               (rulename "ipv6-comp")))
   (iff (smtp-cst-list-list-conc-matchp (tree-nonleaf->branches cst)
                                        "ipv6v4-full")
        (equal (tree-nonleaf->rulename?
                    (nth 0 (nth 0 (tree-nonleaf->branches cst))))
               (rulename "ipv6v4-full")))
   (iff (smtp-cst-list-list-conc-matchp (tree-nonleaf->branches cst)
                                        "ipv6v4-comp")
        (equal (tree-nonleaf->rulename?
                    (nth 0 (nth 0 (tree-nonleaf->branches cst))))
               (rulename "ipv6v4-comp"))))))

Theorem: smtp-cst-link-conc-equivs

(defthm smtp-cst-link-conc-equivs
 (implies
  (smtp-cst-matchp cst "link")
  (and
   (iff (smtp-cst-list-list-conc-matchp (tree-nonleaf->branches cst)
                                        "\"TCP\"")
        (tree-case (nth 0 (nth 0 (tree-nonleaf->branches cst)))
                   :leafterm))
   (iff (smtp-cst-list-list-conc-matchp (tree-nonleaf->branches cst)
                                        "addtl-link")
        (tree-case (nth 0 (nth 0 (tree-nonleaf->branches cst)))
                   :nonleaf)))))

Theorem: smtp-cst-ccontent-conc-equivs

(defthm smtp-cst-ccontent-conc-equivs
 (implies
  (smtp-cst-matchp cst "ccontent")
  (and
   (iff (smtp-cst-list-list-conc-matchp (tree-nonleaf->branches cst)
                                        "ctext")
        (equal (tree-nonleaf->rulename?
                    (nth 0 (nth 0 (tree-nonleaf->branches cst))))
               (rulename "ctext")))
   (iff (smtp-cst-list-list-conc-matchp (tree-nonleaf->branches cst)
                                        "quoted-pair")
        (equal (tree-nonleaf->rulename?
                    (nth 0 (nth 0 (tree-nonleaf->branches cst))))
               (rulename "quoted-pair")))
   (iff (smtp-cst-list-list-conc-matchp (tree-nonleaf->branches cst)
                                        "comment")
        (equal (tree-nonleaf->rulename?
                    (nth 0 (nth 0 (tree-nonleaf->branches cst))))
               (rulename "comment"))))))

Theorem: smtp-cst-id-left-conc-equivs

(defthm smtp-cst-id-left-conc-equivs
 (implies
  (smtp-cst-matchp cst "id-left")
  (and
   (iff (smtp-cst-list-list-conc-matchp (tree-nonleaf->branches cst)
                                        "dot-atom-text")
        (equal (tree-nonleaf->rulename?
                    (nth 0 (nth 0 (tree-nonleaf->branches cst))))
               (rulename "dot-atom-text")))
   (iff (smtp-cst-list-list-conc-matchp (tree-nonleaf->branches cst)
                                        "obs-id-left")
        (equal (tree-nonleaf->rulename?
                    (nth 0 (nth 0 (tree-nonleaf->branches cst))))
               (rulename "obs-id-left"))))))

Theorem: smtp-cst-id-right-conc-equivs

(defthm smtp-cst-id-right-conc-equivs
 (implies
  (smtp-cst-matchp cst "id-right")
  (and
   (iff (smtp-cst-list-list-conc-matchp (tree-nonleaf->branches cst)
                                        "dot-atom-text")
        (equal (tree-nonleaf->rulename?
                    (nth 0 (nth 0 (tree-nonleaf->branches cst))))
               (rulename "dot-atom-text")))
   (iff (smtp-cst-list-list-conc-matchp (tree-nonleaf->branches cst)
                                        "no-fold-literal")
        (equal (tree-nonleaf->rulename?
                    (nth 0 (nth 0 (tree-nonleaf->branches cst))))
               (rulename "no-fold-literal")))
   (iff (smtp-cst-list-list-conc-matchp (tree-nonleaf->branches cst)
                                        "obs-id-right")
        (equal (tree-nonleaf->rulename?
                    (nth 0 (nth 0 (tree-nonleaf->branches cst))))
               (rulename "obs-id-right"))))))

Theorem: smtp-cst-obs-dtext-conc-equivs

(defthm smtp-cst-obs-dtext-conc-equivs
 (implies
  (smtp-cst-matchp cst "obs-dtext")
  (and
   (iff (smtp-cst-list-list-conc-matchp (tree-nonleaf->branches cst)
                                        "obs-no-ws-ctl")
        (equal (tree-nonleaf->rulename?
                    (nth 0 (nth 0 (tree-nonleaf->branches cst))))
               (rulename "obs-no-ws-ctl")))
   (iff (smtp-cst-list-list-conc-matchp (tree-nonleaf->branches cst)
                                        "quoted-pair")
        (equal (tree-nonleaf->rulename?
                    (nth 0 (nth 0 (tree-nonleaf->branches cst))))
               (rulename "quoted-pair"))))))

Theorem: smtp-cst-imf-local-part-conc-equivs

(defthm smtp-cst-imf-local-part-conc-equivs
 (implies
  (smtp-cst-matchp cst "imf-local-part")
  (and
   (iff (smtp-cst-list-list-conc-matchp (tree-nonleaf->branches cst)
                                        "dot-atom")
        (equal (tree-nonleaf->rulename?
                    (nth 0 (nth 0 (tree-nonleaf->branches cst))))
               (rulename "dot-atom")))
   (iff (smtp-cst-list-list-conc-matchp (tree-nonleaf->branches cst)
                                        "imf-quoted-string")
        (equal (tree-nonleaf->rulename?
                    (nth 0 (nth 0 (tree-nonleaf->branches cst))))
               (rulename "imf-quoted-string")))
   (iff (smtp-cst-list-list-conc-matchp (tree-nonleaf->branches cst)
                                        "obs-local-part")
        (equal (tree-nonleaf->rulename?
                    (nth 0 (nth 0 (tree-nonleaf->branches cst))))
               (rulename "obs-local-part"))))))

Theorem: smtp-cst-imf-domain-conc-equivs

(defthm smtp-cst-imf-domain-conc-equivs
 (implies
  (smtp-cst-matchp cst "imf-domain")
  (and
   (iff (smtp-cst-list-list-conc-matchp (tree-nonleaf->branches cst)
                                        "dot-atom")
        (equal (tree-nonleaf->rulename?
                    (nth 0 (nth 0 (tree-nonleaf->branches cst))))
               (rulename "dot-atom")))
   (iff (smtp-cst-list-list-conc-matchp (tree-nonleaf->branches cst)
                                        "domain-literal")
        (equal (tree-nonleaf->rulename?
                    (nth 0 (nth 0 (tree-nonleaf->branches cst))))
               (rulename "domain-literal")))
   (iff (smtp-cst-list-list-conc-matchp (tree-nonleaf->branches cst)
                                        "obs-domain")
        (equal (tree-nonleaf->rulename?
                    (nth 0 (nth 0 (tree-nonleaf->branches cst))))
               (rulename "obs-domain"))))))

Theorem: smtp-cst-qcontent-conc-equivs

(defthm smtp-cst-qcontent-conc-equivs
 (implies
  (smtp-cst-matchp cst "qcontent")
  (and
   (iff (smtp-cst-list-list-conc-matchp (tree-nonleaf->branches cst)
                                        "qtext")
        (equal (tree-nonleaf->rulename?
                    (nth 0 (nth 0 (tree-nonleaf->branches cst))))
               (rulename "qtext")))
   (iff (smtp-cst-list-list-conc-matchp (tree-nonleaf->branches cst)
                                        "quoted-pair")
        (equal (tree-nonleaf->rulename?
                    (nth 0 (nth 0 (tree-nonleaf->branches cst))))
               (rulename "quoted-pair"))))))

Theorem: smtp-cst-word-conc-equivs

(defthm smtp-cst-word-conc-equivs
 (implies
  (smtp-cst-matchp cst "word")
  (and
   (iff (smtp-cst-list-list-conc-matchp (tree-nonleaf->branches cst)
                                        "imf-atom")
        (equal (tree-nonleaf->rulename?
                    (nth 0 (nth 0 (tree-nonleaf->branches cst))))
               (rulename "imf-atom")))
   (iff (smtp-cst-list-list-conc-matchp (tree-nonleaf->branches cst)
                                        "imf-quoted-string")
        (equal (tree-nonleaf->rulename?
                    (nth 0 (nth 0 (tree-nonleaf->branches cst))))
               (rulename "imf-quoted-string"))))))

Theorem: smtp-cst-wsp-conc-equivs

(defthm smtp-cst-wsp-conc-equivs
 (implies
  (smtp-cst-matchp cst "wsp")
  (and
   (iff (smtp-cst-list-list-conc-matchp (tree-nonleaf->branches cst)
                                        "sp")
        (equal (tree-nonleaf->rulename?
                    (nth 0 (nth 0 (tree-nonleaf->branches cst))))
               (rulename "sp")))
   (iff (smtp-cst-list-list-conc-matchp (tree-nonleaf->branches cst)
                                        "htab")
        (equal (tree-nonleaf->rulename?
                    (nth 0 (nth 0 (tree-nonleaf->branches cst))))
               (rulename "htab"))))))

Function: smtp-cst-let-dig-conc?

(defun smtp-cst-let-dig-conc? (cst)
  (declare (xargs :guard (treep cst)))
  (declare (xargs :guard (smtp-cst-matchp cst "let-dig")))
  (let ((__function__ 'smtp-cst-let-dig-conc?))
    (declare (ignorable __function__))
    (cond ((equal (tree-nonleaf->rulename?
                       (nth 0 (nth 0 (tree-nonleaf->branches cst))))
                  (rulename "alpha"))
           1)
          ((equal (tree-nonleaf->rulename?
                       (nth 0 (nth 0 (tree-nonleaf->branches cst))))
                  (rulename "digit"))
           2)
          (t (prog2$ (acl2::impossible) 1)))))

Theorem: posp-of-smtp-cst-let-dig-conc?

(defthm posp-of-smtp-cst-let-dig-conc?
  (b* ((number (smtp-cst-let-dig-conc? cst)))
    (posp number))
  :rule-classes :rewrite)

Theorem: smtp-cst-let-dig-conc?-possibilities

(defthm smtp-cst-let-dig-conc?-possibilities
  (b* ((number (smtp-cst-let-dig-conc? cst)))
    (or (equal number 1) (equal number 2)))
  :rule-classes
  ((:forward-chaining
        :trigger-terms ((smtp-cst-let-dig-conc? cst)))))

Theorem: smtp-cst-let-dig-conc?-of-tree-fix-cst

(defthm smtp-cst-let-dig-conc?-of-tree-fix-cst
  (equal (smtp-cst-let-dig-conc? (tree-fix cst))
         (smtp-cst-let-dig-conc? cst)))

Theorem: smtp-cst-let-dig-conc?-tree-equiv-congruence-on-cst

(defthm smtp-cst-let-dig-conc?-tree-equiv-congruence-on-cst
  (implies (tree-equiv cst cst-equiv)
           (equal (smtp-cst-let-dig-conc? cst)
                  (smtp-cst-let-dig-conc? cst-equiv)))
  :rule-classes :congruence)

Theorem: smtp-cst-let-dig-conc?-1-iff-match-conc

(defthm smtp-cst-let-dig-conc?-1-iff-match-conc
 (implies
   (smtp-cst-matchp cst "let-dig")
   (iff (equal (smtp-cst-let-dig-conc? cst) 1)
        (smtp-cst-list-list-conc-matchp (tree-nonleaf->branches cst)
                                        "alpha"))))

Theorem: smtp-cst-let-dig-conc?-2-iff-match-conc

(defthm smtp-cst-let-dig-conc?-2-iff-match-conc
 (implies
   (smtp-cst-matchp cst "let-dig")
   (iff (equal (smtp-cst-let-dig-conc? cst) 2)
        (smtp-cst-list-list-conc-matchp (tree-nonleaf->branches cst)
                                        "digit"))))

Function: smtp-cst-local-part-conc?

(defun smtp-cst-local-part-conc? (cst)
  (declare (xargs :guard (treep cst)))
  (declare (xargs :guard (smtp-cst-matchp cst "local-part")))
  (let ((__function__ 'smtp-cst-local-part-conc?))
    (declare (ignorable __function__))
    (cond ((equal (tree-nonleaf->rulename?
                       (nth 0 (nth 0 (tree-nonleaf->branches cst))))
                  (rulename "dot-string"))
           1)
          ((equal (tree-nonleaf->rulename?
                       (nth 0 (nth 0 (tree-nonleaf->branches cst))))
                  (rulename "quoted-string"))
           2)
          (t (prog2$ (acl2::impossible) 1)))))

Theorem: posp-of-smtp-cst-local-part-conc?

(defthm posp-of-smtp-cst-local-part-conc?
  (b* ((number (smtp-cst-local-part-conc? cst)))
    (posp number))
  :rule-classes :rewrite)

Theorem: smtp-cst-local-part-conc?-possibilities

(defthm smtp-cst-local-part-conc?-possibilities
  (b* ((number (smtp-cst-local-part-conc? cst)))
    (or (equal number 1) (equal number 2)))
  :rule-classes
  ((:forward-chaining
        :trigger-terms ((smtp-cst-local-part-conc? cst)))))

Theorem: smtp-cst-local-part-conc?-of-tree-fix-cst

(defthm smtp-cst-local-part-conc?-of-tree-fix-cst
  (equal (smtp-cst-local-part-conc? (tree-fix cst))
         (smtp-cst-local-part-conc? cst)))

Theorem: smtp-cst-local-part-conc?-tree-equiv-congruence-on-cst

(defthm smtp-cst-local-part-conc?-tree-equiv-congruence-on-cst
  (implies (tree-equiv cst cst-equiv)
           (equal (smtp-cst-local-part-conc? cst)
                  (smtp-cst-local-part-conc? cst-equiv)))
  :rule-classes :congruence)

Theorem: smtp-cst-local-part-conc?-1-iff-match-conc

(defthm smtp-cst-local-part-conc?-1-iff-match-conc
 (implies
   (smtp-cst-matchp cst "local-part")
   (iff (equal (smtp-cst-local-part-conc? cst)
               1)
        (smtp-cst-list-list-conc-matchp (tree-nonleaf->branches cst)
                                        "dot-string"))))

Theorem: smtp-cst-local-part-conc?-2-iff-match-conc

(defthm smtp-cst-local-part-conc?-2-iff-match-conc
 (implies
   (smtp-cst-matchp cst "local-part")
   (iff (equal (smtp-cst-local-part-conc? cst)
               2)
        (smtp-cst-list-list-conc-matchp (tree-nonleaf->branches cst)
                                        "quoted-string"))))

Function: smtp-cst-qcontentsmtp-conc?

(defun smtp-cst-qcontentsmtp-conc? (cst)
  (declare (xargs :guard (treep cst)))
  (declare (xargs :guard (smtp-cst-matchp cst "qcontentsmtp")))
  (let ((__function__ 'smtp-cst-qcontentsmtp-conc?))
    (declare (ignorable __function__))
    (cond ((equal (tree-nonleaf->rulename?
                       (nth 0 (nth 0 (tree-nonleaf->branches cst))))
                  (rulename "qtextsmtp"))
           1)
          ((equal (tree-nonleaf->rulename?
                       (nth 0 (nth 0 (tree-nonleaf->branches cst))))
                  (rulename "quoted-pairsmtp"))
           2)
          (t (prog2$ (acl2::impossible) 1)))))

Theorem: posp-of-smtp-cst-qcontentsmtp-conc?

(defthm posp-of-smtp-cst-qcontentsmtp-conc?
  (b* ((number (smtp-cst-qcontentsmtp-conc? cst)))
    (posp number))
  :rule-classes :rewrite)

Theorem: smtp-cst-qcontentsmtp-conc?-possibilities

(defthm smtp-cst-qcontentsmtp-conc?-possibilities
  (b* ((number (smtp-cst-qcontentsmtp-conc? cst)))
    (or (equal number 1) (equal number 2)))
  :rule-classes
  ((:forward-chaining
        :trigger-terms ((smtp-cst-qcontentsmtp-conc? cst)))))

Theorem: smtp-cst-qcontentsmtp-conc?-of-tree-fix-cst

(defthm smtp-cst-qcontentsmtp-conc?-of-tree-fix-cst
  (equal (smtp-cst-qcontentsmtp-conc? (tree-fix cst))
         (smtp-cst-qcontentsmtp-conc? cst)))

Theorem: smtp-cst-qcontentsmtp-conc?-tree-equiv-congruence-on-cst

(defthm smtp-cst-qcontentsmtp-conc?-tree-equiv-congruence-on-cst
  (implies (tree-equiv cst cst-equiv)
           (equal (smtp-cst-qcontentsmtp-conc? cst)
                  (smtp-cst-qcontentsmtp-conc? cst-equiv)))
  :rule-classes :congruence)

Theorem: smtp-cst-qcontentsmtp-conc?-1-iff-match-conc

(defthm smtp-cst-qcontentsmtp-conc?-1-iff-match-conc
 (implies
   (smtp-cst-matchp cst "qcontentsmtp")
   (iff (equal (smtp-cst-qcontentsmtp-conc? cst)
               1)
        (smtp-cst-list-list-conc-matchp (tree-nonleaf->branches cst)
                                        "qtextsmtp"))))

Theorem: smtp-cst-qcontentsmtp-conc?-2-iff-match-conc

(defthm smtp-cst-qcontentsmtp-conc?-2-iff-match-conc
 (implies
   (smtp-cst-matchp cst "qcontentsmtp")
   (iff (equal (smtp-cst-qcontentsmtp-conc? cst)
               2)
        (smtp-cst-list-list-conc-matchp (tree-nonleaf->branches cst)
                                        "quoted-pairsmtp"))))

Function: smtp-cst-string-conc?

(defun smtp-cst-string-conc? (cst)
  (declare (xargs :guard (treep cst)))
  (declare (xargs :guard (smtp-cst-matchp cst "string")))
  (let ((__function__ 'smtp-cst-string-conc?))
    (declare (ignorable __function__))
    (cond ((equal (tree-nonleaf->rulename?
                       (nth 0 (nth 0 (tree-nonleaf->branches cst))))
                  (rulename "atom"))
           1)
          ((equal (tree-nonleaf->rulename?
                       (nth 0 (nth 0 (tree-nonleaf->branches cst))))
                  (rulename "quoted-string"))
           2)
          (t (prog2$ (acl2::impossible) 1)))))

Theorem: posp-of-smtp-cst-string-conc?

(defthm posp-of-smtp-cst-string-conc?
  (b* ((number (smtp-cst-string-conc? cst)))
    (posp number))
  :rule-classes :rewrite)

Theorem: smtp-cst-string-conc?-possibilities

(defthm smtp-cst-string-conc?-possibilities
 (b* ((number (smtp-cst-string-conc? cst)))
   (or (equal number 1) (equal number 2)))
 :rule-classes
 ((:forward-chaining :trigger-terms ((smtp-cst-string-conc? cst)))))

Theorem: smtp-cst-string-conc?-of-tree-fix-cst

(defthm smtp-cst-string-conc?-of-tree-fix-cst
  (equal (smtp-cst-string-conc? (tree-fix cst))
         (smtp-cst-string-conc? cst)))

Theorem: smtp-cst-string-conc?-tree-equiv-congruence-on-cst

(defthm smtp-cst-string-conc?-tree-equiv-congruence-on-cst
  (implies (tree-equiv cst cst-equiv)
           (equal (smtp-cst-string-conc? cst)
                  (smtp-cst-string-conc? cst-equiv)))
  :rule-classes :congruence)

Theorem: smtp-cst-string-conc?-1-iff-match-conc

(defthm smtp-cst-string-conc?-1-iff-match-conc
 (implies
   (smtp-cst-matchp cst "string")
   (iff (equal (smtp-cst-string-conc? cst) 1)
        (smtp-cst-list-list-conc-matchp (tree-nonleaf->branches cst)
                                        "atom"))))

Theorem: smtp-cst-string-conc?-2-iff-match-conc

(defthm smtp-cst-string-conc?-2-iff-match-conc
 (implies
   (smtp-cst-matchp cst "string")
   (iff (equal (smtp-cst-string-conc? cst) 2)
        (smtp-cst-list-list-conc-matchp (tree-nonleaf->branches cst)
                                        "quoted-string"))))

Function: smtp-cst-ipv6-addr-conc?

(defun smtp-cst-ipv6-addr-conc? (cst)
  (declare (xargs :guard (treep cst)))
  (declare (xargs :guard (smtp-cst-matchp cst "ipv6-addr")))
  (let ((__function__ 'smtp-cst-ipv6-addr-conc?))
    (declare (ignorable __function__))
    (cond ((equal (tree-nonleaf->rulename?
                       (nth 0 (nth 0 (tree-nonleaf->branches cst))))
                  (rulename "ipv6-full"))
           1)
          ((equal (tree-nonleaf->rulename?
                       (nth 0 (nth 0 (tree-nonleaf->branches cst))))
                  (rulename "ipv6-comp"))
           2)
          ((equal (tree-nonleaf->rulename?
                       (nth 0 (nth 0 (tree-nonleaf->branches cst))))
                  (rulename "ipv6v4-full"))
           3)
          ((equal (tree-nonleaf->rulename?
                       (nth 0 (nth 0 (tree-nonleaf->branches cst))))
                  (rulename "ipv6v4-comp"))
           4)
          (t (prog2$ (acl2::impossible) 1)))))

Theorem: posp-of-smtp-cst-ipv6-addr-conc?

(defthm posp-of-smtp-cst-ipv6-addr-conc?
  (b* ((number (smtp-cst-ipv6-addr-conc? cst)))
    (posp number))
  :rule-classes :rewrite)

Theorem: smtp-cst-ipv6-addr-conc?-possibilities

(defthm smtp-cst-ipv6-addr-conc?-possibilities
  (b* ((number (smtp-cst-ipv6-addr-conc? cst)))
    (or (equal number 1)
        (equal number 2)
        (equal number 3)
        (equal number 4)))
  :rule-classes
  ((:forward-chaining
        :trigger-terms ((smtp-cst-ipv6-addr-conc? cst)))))

Theorem: smtp-cst-ipv6-addr-conc?-of-tree-fix-cst

(defthm smtp-cst-ipv6-addr-conc?-of-tree-fix-cst
  (equal (smtp-cst-ipv6-addr-conc? (tree-fix cst))
         (smtp-cst-ipv6-addr-conc? cst)))

Theorem: smtp-cst-ipv6-addr-conc?-tree-equiv-congruence-on-cst

(defthm smtp-cst-ipv6-addr-conc?-tree-equiv-congruence-on-cst
  (implies (tree-equiv cst cst-equiv)
           (equal (smtp-cst-ipv6-addr-conc? cst)
                  (smtp-cst-ipv6-addr-conc? cst-equiv)))
  :rule-classes :congruence)

Theorem: smtp-cst-ipv6-addr-conc?-1-iff-match-conc

(defthm smtp-cst-ipv6-addr-conc?-1-iff-match-conc
 (implies
   (smtp-cst-matchp cst "ipv6-addr")
   (iff (equal (smtp-cst-ipv6-addr-conc? cst) 1)
        (smtp-cst-list-list-conc-matchp (tree-nonleaf->branches cst)
                                        "ipv6-full"))))

Theorem: smtp-cst-ipv6-addr-conc?-2-iff-match-conc

(defthm smtp-cst-ipv6-addr-conc?-2-iff-match-conc
 (implies
   (smtp-cst-matchp cst "ipv6-addr")
   (iff (equal (smtp-cst-ipv6-addr-conc? cst) 2)
        (smtp-cst-list-list-conc-matchp (tree-nonleaf->branches cst)
                                        "ipv6-comp"))))

Theorem: smtp-cst-ipv6-addr-conc?-3-iff-match-conc

(defthm smtp-cst-ipv6-addr-conc?-3-iff-match-conc
 (implies
   (smtp-cst-matchp cst "ipv6-addr")
   (iff (equal (smtp-cst-ipv6-addr-conc? cst) 3)
        (smtp-cst-list-list-conc-matchp (tree-nonleaf->branches cst)
                                        "ipv6v4-full"))))

Theorem: smtp-cst-ipv6-addr-conc?-4-iff-match-conc

(defthm smtp-cst-ipv6-addr-conc?-4-iff-match-conc
 (implies
   (smtp-cst-matchp cst "ipv6-addr")
   (iff (equal (smtp-cst-ipv6-addr-conc? cst) 4)
        (smtp-cst-list-list-conc-matchp (tree-nonleaf->branches cst)
                                        "ipv6v4-comp"))))

Function: smtp-cst-ccontent-conc?

(defun smtp-cst-ccontent-conc? (cst)
  (declare (xargs :guard (treep cst)))
  (declare (xargs :guard (smtp-cst-matchp cst "ccontent")))
  (let ((__function__ 'smtp-cst-ccontent-conc?))
    (declare (ignorable __function__))
    (cond ((equal (tree-nonleaf->rulename?
                       (nth 0 (nth 0 (tree-nonleaf->branches cst))))
                  (rulename "ctext"))
           1)
          ((equal (tree-nonleaf->rulename?
                       (nth 0 (nth 0 (tree-nonleaf->branches cst))))
                  (rulename "quoted-pair"))
           2)
          ((equal (tree-nonleaf->rulename?
                       (nth 0 (nth 0 (tree-nonleaf->branches cst))))
                  (rulename "comment"))
           3)
          (t (prog2$ (acl2::impossible) 1)))))

Theorem: posp-of-smtp-cst-ccontent-conc?

(defthm posp-of-smtp-cst-ccontent-conc?
  (b* ((number (smtp-cst-ccontent-conc? cst)))
    (posp number))
  :rule-classes :rewrite)

Theorem: smtp-cst-ccontent-conc?-possibilities

(defthm smtp-cst-ccontent-conc?-possibilities
  (b* ((number (smtp-cst-ccontent-conc? cst)))
    (or (equal number 1)
        (equal number 2)
        (equal number 3)))
  :rule-classes
  ((:forward-chaining
        :trigger-terms ((smtp-cst-ccontent-conc? cst)))))

Theorem: smtp-cst-ccontent-conc?-of-tree-fix-cst

(defthm smtp-cst-ccontent-conc?-of-tree-fix-cst
  (equal (smtp-cst-ccontent-conc? (tree-fix cst))
         (smtp-cst-ccontent-conc? cst)))

Theorem: smtp-cst-ccontent-conc?-tree-equiv-congruence-on-cst

(defthm smtp-cst-ccontent-conc?-tree-equiv-congruence-on-cst
  (implies (tree-equiv cst cst-equiv)
           (equal (smtp-cst-ccontent-conc? cst)
                  (smtp-cst-ccontent-conc? cst-equiv)))
  :rule-classes :congruence)

Theorem: smtp-cst-ccontent-conc?-1-iff-match-conc

(defthm smtp-cst-ccontent-conc?-1-iff-match-conc
 (implies
   (smtp-cst-matchp cst "ccontent")
   (iff (equal (smtp-cst-ccontent-conc? cst) 1)
        (smtp-cst-list-list-conc-matchp (tree-nonleaf->branches cst)
                                        "ctext"))))

Theorem: smtp-cst-ccontent-conc?-2-iff-match-conc

(defthm smtp-cst-ccontent-conc?-2-iff-match-conc
 (implies
   (smtp-cst-matchp cst "ccontent")
   (iff (equal (smtp-cst-ccontent-conc? cst) 2)
        (smtp-cst-list-list-conc-matchp (tree-nonleaf->branches cst)
                                        "quoted-pair"))))

Theorem: smtp-cst-ccontent-conc?-3-iff-match-conc

(defthm smtp-cst-ccontent-conc?-3-iff-match-conc
 (implies
   (smtp-cst-matchp cst "ccontent")
   (iff (equal (smtp-cst-ccontent-conc? cst) 3)
        (smtp-cst-list-list-conc-matchp (tree-nonleaf->branches cst)
                                        "comment"))))

Function: smtp-cst-id-left-conc?

(defun smtp-cst-id-left-conc? (cst)
  (declare (xargs :guard (treep cst)))
  (declare (xargs :guard (smtp-cst-matchp cst "id-left")))
  (let ((__function__ 'smtp-cst-id-left-conc?))
    (declare (ignorable __function__))
    (cond ((equal (tree-nonleaf->rulename?
                       (nth 0 (nth 0 (tree-nonleaf->branches cst))))
                  (rulename "dot-atom-text"))
           1)
          ((equal (tree-nonleaf->rulename?
                       (nth 0 (nth 0 (tree-nonleaf->branches cst))))
                  (rulename "obs-id-left"))
           2)
          (t (prog2$ (acl2::impossible) 1)))))

Theorem: posp-of-smtp-cst-id-left-conc?

(defthm posp-of-smtp-cst-id-left-conc?
  (b* ((number (smtp-cst-id-left-conc? cst)))
    (posp number))
  :rule-classes :rewrite)

Theorem: smtp-cst-id-left-conc?-possibilities

(defthm smtp-cst-id-left-conc?-possibilities
  (b* ((number (smtp-cst-id-left-conc? cst)))
    (or (equal number 1) (equal number 2)))
  :rule-classes
  ((:forward-chaining
        :trigger-terms ((smtp-cst-id-left-conc? cst)))))

Theorem: smtp-cst-id-left-conc?-of-tree-fix-cst

(defthm smtp-cst-id-left-conc?-of-tree-fix-cst
  (equal (smtp-cst-id-left-conc? (tree-fix cst))
         (smtp-cst-id-left-conc? cst)))

Theorem: smtp-cst-id-left-conc?-tree-equiv-congruence-on-cst

(defthm smtp-cst-id-left-conc?-tree-equiv-congruence-on-cst
  (implies (tree-equiv cst cst-equiv)
           (equal (smtp-cst-id-left-conc? cst)
                  (smtp-cst-id-left-conc? cst-equiv)))
  :rule-classes :congruence)

Theorem: smtp-cst-id-left-conc?-1-iff-match-conc

(defthm smtp-cst-id-left-conc?-1-iff-match-conc
 (implies
   (smtp-cst-matchp cst "id-left")
   (iff (equal (smtp-cst-id-left-conc? cst) 1)
        (smtp-cst-list-list-conc-matchp (tree-nonleaf->branches cst)
                                        "dot-atom-text"))))

Theorem: smtp-cst-id-left-conc?-2-iff-match-conc

(defthm smtp-cst-id-left-conc?-2-iff-match-conc
 (implies
   (smtp-cst-matchp cst "id-left")
   (iff (equal (smtp-cst-id-left-conc? cst) 2)
        (smtp-cst-list-list-conc-matchp (tree-nonleaf->branches cst)
                                        "obs-id-left"))))

Function: smtp-cst-id-right-conc?

(defun smtp-cst-id-right-conc? (cst)
  (declare (xargs :guard (treep cst)))
  (declare (xargs :guard (smtp-cst-matchp cst "id-right")))
  (let ((__function__ 'smtp-cst-id-right-conc?))
    (declare (ignorable __function__))
    (cond ((equal (tree-nonleaf->rulename?
                       (nth 0 (nth 0 (tree-nonleaf->branches cst))))
                  (rulename "dot-atom-text"))
           1)
          ((equal (tree-nonleaf->rulename?
                       (nth 0 (nth 0 (tree-nonleaf->branches cst))))
                  (rulename "no-fold-literal"))
           2)
          ((equal (tree-nonleaf->rulename?
                       (nth 0 (nth 0 (tree-nonleaf->branches cst))))
                  (rulename "obs-id-right"))
           3)
          (t (prog2$ (acl2::impossible) 1)))))

Theorem: posp-of-smtp-cst-id-right-conc?

(defthm posp-of-smtp-cst-id-right-conc?
  (b* ((number (smtp-cst-id-right-conc? cst)))
    (posp number))
  :rule-classes :rewrite)

Theorem: smtp-cst-id-right-conc?-possibilities

(defthm smtp-cst-id-right-conc?-possibilities
  (b* ((number (smtp-cst-id-right-conc? cst)))
    (or (equal number 1)
        (equal number 2)
        (equal number 3)))
  :rule-classes
  ((:forward-chaining
        :trigger-terms ((smtp-cst-id-right-conc? cst)))))

Theorem: smtp-cst-id-right-conc?-of-tree-fix-cst

(defthm smtp-cst-id-right-conc?-of-tree-fix-cst
  (equal (smtp-cst-id-right-conc? (tree-fix cst))
         (smtp-cst-id-right-conc? cst)))

Theorem: smtp-cst-id-right-conc?-tree-equiv-congruence-on-cst

(defthm smtp-cst-id-right-conc?-tree-equiv-congruence-on-cst
  (implies (tree-equiv cst cst-equiv)
           (equal (smtp-cst-id-right-conc? cst)
                  (smtp-cst-id-right-conc? cst-equiv)))
  :rule-classes :congruence)

Theorem: smtp-cst-id-right-conc?-1-iff-match-conc

(defthm smtp-cst-id-right-conc?-1-iff-match-conc
 (implies
   (smtp-cst-matchp cst "id-right")
   (iff (equal (smtp-cst-id-right-conc? cst) 1)
        (smtp-cst-list-list-conc-matchp (tree-nonleaf->branches cst)
                                        "dot-atom-text"))))

Theorem: smtp-cst-id-right-conc?-2-iff-match-conc

(defthm smtp-cst-id-right-conc?-2-iff-match-conc
 (implies
   (smtp-cst-matchp cst "id-right")
   (iff (equal (smtp-cst-id-right-conc? cst) 2)
        (smtp-cst-list-list-conc-matchp (tree-nonleaf->branches cst)
                                        "no-fold-literal"))))

Theorem: smtp-cst-id-right-conc?-3-iff-match-conc

(defthm smtp-cst-id-right-conc?-3-iff-match-conc
 (implies
   (smtp-cst-matchp cst "id-right")
   (iff (equal (smtp-cst-id-right-conc? cst) 3)
        (smtp-cst-list-list-conc-matchp (tree-nonleaf->branches cst)
                                        "obs-id-right"))))

Function: smtp-cst-obs-dtext-conc?

(defun smtp-cst-obs-dtext-conc? (cst)
  (declare (xargs :guard (treep cst)))
  (declare (xargs :guard (smtp-cst-matchp cst "obs-dtext")))
  (let ((__function__ 'smtp-cst-obs-dtext-conc?))
    (declare (ignorable __function__))
    (cond ((equal (tree-nonleaf->rulename?
                       (nth 0 (nth 0 (tree-nonleaf->branches cst))))
                  (rulename "obs-no-ws-ctl"))
           1)
          ((equal (tree-nonleaf->rulename?
                       (nth 0 (nth 0 (tree-nonleaf->branches cst))))
                  (rulename "quoted-pair"))
           2)
          (t (prog2$ (acl2::impossible) 1)))))

Theorem: posp-of-smtp-cst-obs-dtext-conc?

(defthm posp-of-smtp-cst-obs-dtext-conc?
  (b* ((number (smtp-cst-obs-dtext-conc? cst)))
    (posp number))
  :rule-classes :rewrite)

Theorem: smtp-cst-obs-dtext-conc?-possibilities

(defthm smtp-cst-obs-dtext-conc?-possibilities
  (b* ((number (smtp-cst-obs-dtext-conc? cst)))
    (or (equal number 1) (equal number 2)))
  :rule-classes
  ((:forward-chaining
        :trigger-terms ((smtp-cst-obs-dtext-conc? cst)))))

Theorem: smtp-cst-obs-dtext-conc?-of-tree-fix-cst

(defthm smtp-cst-obs-dtext-conc?-of-tree-fix-cst
  (equal (smtp-cst-obs-dtext-conc? (tree-fix cst))
         (smtp-cst-obs-dtext-conc? cst)))

Theorem: smtp-cst-obs-dtext-conc?-tree-equiv-congruence-on-cst

(defthm smtp-cst-obs-dtext-conc?-tree-equiv-congruence-on-cst
  (implies (tree-equiv cst cst-equiv)
           (equal (smtp-cst-obs-dtext-conc? cst)
                  (smtp-cst-obs-dtext-conc? cst-equiv)))
  :rule-classes :congruence)

Theorem: smtp-cst-obs-dtext-conc?-1-iff-match-conc

(defthm smtp-cst-obs-dtext-conc?-1-iff-match-conc
 (implies
   (smtp-cst-matchp cst "obs-dtext")
   (iff (equal (smtp-cst-obs-dtext-conc? cst) 1)
        (smtp-cst-list-list-conc-matchp (tree-nonleaf->branches cst)
                                        "obs-no-ws-ctl"))))

Theorem: smtp-cst-obs-dtext-conc?-2-iff-match-conc

(defthm smtp-cst-obs-dtext-conc?-2-iff-match-conc
 (implies
   (smtp-cst-matchp cst "obs-dtext")
   (iff (equal (smtp-cst-obs-dtext-conc? cst) 2)
        (smtp-cst-list-list-conc-matchp (tree-nonleaf->branches cst)
                                        "quoted-pair"))))

Function: smtp-cst-imf-local-part-conc?

(defun smtp-cst-imf-local-part-conc? (cst)
  (declare (xargs :guard (treep cst)))
  (declare (xargs :guard (smtp-cst-matchp cst "imf-local-part")))
  (let ((__function__ 'smtp-cst-imf-local-part-conc?))
    (declare (ignorable __function__))
    (cond ((equal (tree-nonleaf->rulename?
                       (nth 0 (nth 0 (tree-nonleaf->branches cst))))
                  (rulename "dot-atom"))
           1)
          ((equal (tree-nonleaf->rulename?
                       (nth 0 (nth 0 (tree-nonleaf->branches cst))))
                  (rulename "imf-quoted-string"))
           2)
          ((equal (tree-nonleaf->rulename?
                       (nth 0 (nth 0 (tree-nonleaf->branches cst))))
                  (rulename "obs-local-part"))
           3)
          (t (prog2$ (acl2::impossible) 1)))))

Theorem: posp-of-smtp-cst-imf-local-part-conc?

(defthm posp-of-smtp-cst-imf-local-part-conc?
  (b* ((number (smtp-cst-imf-local-part-conc? cst)))
    (posp number))
  :rule-classes :rewrite)

Theorem: smtp-cst-imf-local-part-conc?-possibilities

(defthm smtp-cst-imf-local-part-conc?-possibilities
  (b* ((number (smtp-cst-imf-local-part-conc? cst)))
    (or (equal number 1)
        (equal number 2)
        (equal number 3)))
  :rule-classes
  ((:forward-chaining
        :trigger-terms ((smtp-cst-imf-local-part-conc? cst)))))

Theorem: smtp-cst-imf-local-part-conc?-of-tree-fix-cst

(defthm smtp-cst-imf-local-part-conc?-of-tree-fix-cst
  (equal (smtp-cst-imf-local-part-conc? (tree-fix cst))
         (smtp-cst-imf-local-part-conc? cst)))

Theorem: smtp-cst-imf-local-part-conc?-tree-equiv-congruence-on-cst

(defthm smtp-cst-imf-local-part-conc?-tree-equiv-congruence-on-cst
  (implies (tree-equiv cst cst-equiv)
           (equal (smtp-cst-imf-local-part-conc? cst)
                  (smtp-cst-imf-local-part-conc? cst-equiv)))
  :rule-classes :congruence)

Theorem: smtp-cst-imf-local-part-conc?-1-iff-match-conc

(defthm smtp-cst-imf-local-part-conc?-1-iff-match-conc
 (implies
   (smtp-cst-matchp cst "imf-local-part")
   (iff (equal (smtp-cst-imf-local-part-conc? cst)
               1)
        (smtp-cst-list-list-conc-matchp (tree-nonleaf->branches cst)
                                        "dot-atom"))))

Theorem: smtp-cst-imf-local-part-conc?-2-iff-match-conc

(defthm smtp-cst-imf-local-part-conc?-2-iff-match-conc
 (implies
   (smtp-cst-matchp cst "imf-local-part")
   (iff (equal (smtp-cst-imf-local-part-conc? cst)
               2)
        (smtp-cst-list-list-conc-matchp (tree-nonleaf->branches cst)
                                        "imf-quoted-string"))))

Theorem: smtp-cst-imf-local-part-conc?-3-iff-match-conc

(defthm smtp-cst-imf-local-part-conc?-3-iff-match-conc
 (implies
   (smtp-cst-matchp cst "imf-local-part")
   (iff (equal (smtp-cst-imf-local-part-conc? cst)
               3)
        (smtp-cst-list-list-conc-matchp (tree-nonleaf->branches cst)
                                        "obs-local-part"))))

Function: smtp-cst-imf-domain-conc?

(defun smtp-cst-imf-domain-conc? (cst)
  (declare (xargs :guard (treep cst)))
  (declare (xargs :guard (smtp-cst-matchp cst "imf-domain")))
  (let ((__function__ 'smtp-cst-imf-domain-conc?))
    (declare (ignorable __function__))
    (cond ((equal (tree-nonleaf->rulename?
                       (nth 0 (nth 0 (tree-nonleaf->branches cst))))
                  (rulename "dot-atom"))
           1)
          ((equal (tree-nonleaf->rulename?
                       (nth 0 (nth 0 (tree-nonleaf->branches cst))))
                  (rulename "domain-literal"))
           2)
          ((equal (tree-nonleaf->rulename?
                       (nth 0 (nth 0 (tree-nonleaf->branches cst))))
                  (rulename "obs-domain"))
           3)
          (t (prog2$ (acl2::impossible) 1)))))

Theorem: posp-of-smtp-cst-imf-domain-conc?

(defthm posp-of-smtp-cst-imf-domain-conc?
  (b* ((number (smtp-cst-imf-domain-conc? cst)))
    (posp number))
  :rule-classes :rewrite)

Theorem: smtp-cst-imf-domain-conc?-possibilities

(defthm smtp-cst-imf-domain-conc?-possibilities
  (b* ((number (smtp-cst-imf-domain-conc? cst)))
    (or (equal number 1)
        (equal number 2)
        (equal number 3)))
  :rule-classes
  ((:forward-chaining
        :trigger-terms ((smtp-cst-imf-domain-conc? cst)))))

Theorem: smtp-cst-imf-domain-conc?-of-tree-fix-cst

(defthm smtp-cst-imf-domain-conc?-of-tree-fix-cst
  (equal (smtp-cst-imf-domain-conc? (tree-fix cst))
         (smtp-cst-imf-domain-conc? cst)))

Theorem: smtp-cst-imf-domain-conc?-tree-equiv-congruence-on-cst

(defthm smtp-cst-imf-domain-conc?-tree-equiv-congruence-on-cst
  (implies (tree-equiv cst cst-equiv)
           (equal (smtp-cst-imf-domain-conc? cst)
                  (smtp-cst-imf-domain-conc? cst-equiv)))
  :rule-classes :congruence)

Theorem: smtp-cst-imf-domain-conc?-1-iff-match-conc

(defthm smtp-cst-imf-domain-conc?-1-iff-match-conc
 (implies
   (smtp-cst-matchp cst "imf-domain")
   (iff (equal (smtp-cst-imf-domain-conc? cst)
               1)
        (smtp-cst-list-list-conc-matchp (tree-nonleaf->branches cst)
                                        "dot-atom"))))

Theorem: smtp-cst-imf-domain-conc?-2-iff-match-conc

(defthm smtp-cst-imf-domain-conc?-2-iff-match-conc
 (implies
   (smtp-cst-matchp cst "imf-domain")
   (iff (equal (smtp-cst-imf-domain-conc? cst)
               2)
        (smtp-cst-list-list-conc-matchp (tree-nonleaf->branches cst)
                                        "domain-literal"))))

Theorem: smtp-cst-imf-domain-conc?-3-iff-match-conc

(defthm smtp-cst-imf-domain-conc?-3-iff-match-conc
 (implies
   (smtp-cst-matchp cst "imf-domain")
   (iff (equal (smtp-cst-imf-domain-conc? cst)
               3)
        (smtp-cst-list-list-conc-matchp (tree-nonleaf->branches cst)
                                        "obs-domain"))))

Function: smtp-cst-qcontent-conc?

(defun smtp-cst-qcontent-conc? (cst)
  (declare (xargs :guard (treep cst)))
  (declare (xargs :guard (smtp-cst-matchp cst "qcontent")))
  (let ((__function__ 'smtp-cst-qcontent-conc?))
    (declare (ignorable __function__))
    (cond ((equal (tree-nonleaf->rulename?
                       (nth 0 (nth 0 (tree-nonleaf->branches cst))))
                  (rulename "qtext"))
           1)
          ((equal (tree-nonleaf->rulename?
                       (nth 0 (nth 0 (tree-nonleaf->branches cst))))
                  (rulename "quoted-pair"))
           2)
          (t (prog2$ (acl2::impossible) 1)))))

Theorem: posp-of-smtp-cst-qcontent-conc?

(defthm posp-of-smtp-cst-qcontent-conc?
  (b* ((number (smtp-cst-qcontent-conc? cst)))
    (posp number))
  :rule-classes :rewrite)

Theorem: smtp-cst-qcontent-conc?-possibilities

(defthm smtp-cst-qcontent-conc?-possibilities
  (b* ((number (smtp-cst-qcontent-conc? cst)))
    (or (equal number 1) (equal number 2)))
  :rule-classes
  ((:forward-chaining
        :trigger-terms ((smtp-cst-qcontent-conc? cst)))))

Theorem: smtp-cst-qcontent-conc?-of-tree-fix-cst

(defthm smtp-cst-qcontent-conc?-of-tree-fix-cst
  (equal (smtp-cst-qcontent-conc? (tree-fix cst))
         (smtp-cst-qcontent-conc? cst)))

Theorem: smtp-cst-qcontent-conc?-tree-equiv-congruence-on-cst

(defthm smtp-cst-qcontent-conc?-tree-equiv-congruence-on-cst
  (implies (tree-equiv cst cst-equiv)
           (equal (smtp-cst-qcontent-conc? cst)
                  (smtp-cst-qcontent-conc? cst-equiv)))
  :rule-classes :congruence)

Theorem: smtp-cst-qcontent-conc?-1-iff-match-conc

(defthm smtp-cst-qcontent-conc?-1-iff-match-conc
 (implies
   (smtp-cst-matchp cst "qcontent")
   (iff (equal (smtp-cst-qcontent-conc? cst) 1)
        (smtp-cst-list-list-conc-matchp (tree-nonleaf->branches cst)
                                        "qtext"))))

Theorem: smtp-cst-qcontent-conc?-2-iff-match-conc

(defthm smtp-cst-qcontent-conc?-2-iff-match-conc
 (implies
   (smtp-cst-matchp cst "qcontent")
   (iff (equal (smtp-cst-qcontent-conc? cst) 2)
        (smtp-cst-list-list-conc-matchp (tree-nonleaf->branches cst)
                                        "quoted-pair"))))

Function: smtp-cst-word-conc?

(defun smtp-cst-word-conc? (cst)
  (declare (xargs :guard (treep cst)))
  (declare (xargs :guard (smtp-cst-matchp cst "word")))
  (let ((__function__ 'smtp-cst-word-conc?))
    (declare (ignorable __function__))
    (cond ((equal (tree-nonleaf->rulename?
                       (nth 0 (nth 0 (tree-nonleaf->branches cst))))
                  (rulename "imf-atom"))
           1)
          ((equal (tree-nonleaf->rulename?
                       (nth 0 (nth 0 (tree-nonleaf->branches cst))))
                  (rulename "imf-quoted-string"))
           2)
          (t (prog2$ (acl2::impossible) 1)))))

Theorem: posp-of-smtp-cst-word-conc?

(defthm posp-of-smtp-cst-word-conc?
  (b* ((number (smtp-cst-word-conc? cst)))
    (posp number))
  :rule-classes :rewrite)

Theorem: smtp-cst-word-conc?-possibilities

(defthm smtp-cst-word-conc?-possibilities
  (b* ((number (smtp-cst-word-conc? cst)))
    (or (equal number 1) (equal number 2)))
  :rule-classes
  ((:forward-chaining :trigger-terms ((smtp-cst-word-conc? cst)))))

Theorem: smtp-cst-word-conc?-of-tree-fix-cst

(defthm smtp-cst-word-conc?-of-tree-fix-cst
  (equal (smtp-cst-word-conc? (tree-fix cst))
         (smtp-cst-word-conc? cst)))

Theorem: smtp-cst-word-conc?-tree-equiv-congruence-on-cst

(defthm smtp-cst-word-conc?-tree-equiv-congruence-on-cst
  (implies (tree-equiv cst cst-equiv)
           (equal (smtp-cst-word-conc? cst)
                  (smtp-cst-word-conc? cst-equiv)))
  :rule-classes :congruence)

Theorem: smtp-cst-word-conc?-1-iff-match-conc

(defthm smtp-cst-word-conc?-1-iff-match-conc
 (implies
   (smtp-cst-matchp cst "word")
   (iff (equal (smtp-cst-word-conc? cst) 1)
        (smtp-cst-list-list-conc-matchp (tree-nonleaf->branches cst)
                                        "imf-atom"))))

Theorem: smtp-cst-word-conc?-2-iff-match-conc

(defthm smtp-cst-word-conc?-2-iff-match-conc
 (implies
   (smtp-cst-matchp cst "word")
   (iff (equal (smtp-cst-word-conc? cst) 2)
        (smtp-cst-list-list-conc-matchp (tree-nonleaf->branches cst)
                                        "imf-quoted-string"))))

Function: smtp-cst-wsp-conc?

(defun smtp-cst-wsp-conc? (cst)
  (declare (xargs :guard (treep cst)))
  (declare (xargs :guard (smtp-cst-matchp cst "wsp")))
  (let ((__function__ 'smtp-cst-wsp-conc?))
    (declare (ignorable __function__))
    (cond ((equal (tree-nonleaf->rulename?
                       (nth 0 (nth 0 (tree-nonleaf->branches cst))))
                  (rulename "sp"))
           1)
          ((equal (tree-nonleaf->rulename?
                       (nth 0 (nth 0 (tree-nonleaf->branches cst))))
                  (rulename "htab"))
           2)
          (t (prog2$ (acl2::impossible) 1)))))

Theorem: posp-of-smtp-cst-wsp-conc?

(defthm posp-of-smtp-cst-wsp-conc?
  (b* ((number (smtp-cst-wsp-conc? cst)))
    (posp number))
  :rule-classes :rewrite)

Theorem: smtp-cst-wsp-conc?-possibilities

(defthm smtp-cst-wsp-conc?-possibilities
  (b* ((number (smtp-cst-wsp-conc? cst)))
    (or (equal number 1) (equal number 2)))
  :rule-classes
  ((:forward-chaining :trigger-terms ((smtp-cst-wsp-conc? cst)))))

Theorem: smtp-cst-wsp-conc?-of-tree-fix-cst

(defthm smtp-cst-wsp-conc?-of-tree-fix-cst
  (equal (smtp-cst-wsp-conc? (tree-fix cst))
         (smtp-cst-wsp-conc? cst)))

Theorem: smtp-cst-wsp-conc?-tree-equiv-congruence-on-cst

(defthm smtp-cst-wsp-conc?-tree-equiv-congruence-on-cst
  (implies (tree-equiv cst cst-equiv)
           (equal (smtp-cst-wsp-conc? cst)
                  (smtp-cst-wsp-conc? cst-equiv)))
  :rule-classes :congruence)

Theorem: smtp-cst-wsp-conc?-1-iff-match-conc

(defthm smtp-cst-wsp-conc?-1-iff-match-conc
 (implies
   (smtp-cst-matchp cst "wsp")
   (iff (equal (smtp-cst-wsp-conc? cst) 1)
        (smtp-cst-list-list-conc-matchp (tree-nonleaf->branches cst)
                                        "sp"))))

Theorem: smtp-cst-wsp-conc?-2-iff-match-conc

(defthm smtp-cst-wsp-conc?-2-iff-match-conc
 (implies
   (smtp-cst-matchp cst "wsp")
   (iff (equal (smtp-cst-wsp-conc? cst) 2)
        (smtp-cst-list-list-conc-matchp (tree-nonleaf->branches cst)
                                        "htab"))))

Function: smtp-cst-ehlo-conc

(defun smtp-cst-ehlo-conc (cst)
  (declare (xargs :guard (treep cst)))
  (declare (xargs :guard (smtp-cst-matchp cst "ehlo")))
  (let ((__function__ 'smtp-cst-ehlo-conc))
    (declare (ignorable __function__))
    (tree-nonleaf->branches cst)))

Theorem: tree-list-listp-of-smtp-cst-ehlo-conc

(defthm tree-list-listp-of-smtp-cst-ehlo-conc
  (b* ((cstss (smtp-cst-ehlo-conc cst)))
    (tree-list-listp cstss))
  :rule-classes :rewrite)

Theorem: smtp-cst-ehlo-conc-match

(defthm smtp-cst-ehlo-conc-match
  (implies (smtp-cst-matchp cst "ehlo")
           (b* ((cstss (smtp-cst-ehlo-conc cst)))
             (smtp-cst-list-list-conc-matchp
                  cstss
                  "\"EHLO\" sp ( domain / address-literal ) crlf")))
  :rule-classes :rewrite)

Theorem: smtp-cst-ehlo-conc-of-tree-fix-cst

(defthm smtp-cst-ehlo-conc-of-tree-fix-cst
  (equal (smtp-cst-ehlo-conc (tree-fix cst))
         (smtp-cst-ehlo-conc cst)))

Theorem: smtp-cst-ehlo-conc-tree-equiv-congruence-on-cst

(defthm smtp-cst-ehlo-conc-tree-equiv-congruence-on-cst
  (implies (tree-equiv cst cst-equiv)
           (equal (smtp-cst-ehlo-conc cst)
                  (smtp-cst-ehlo-conc cst-equiv)))
  :rule-classes :congruence)

Function: smtp-cst-helo-conc

(defun smtp-cst-helo-conc (cst)
  (declare (xargs :guard (treep cst)))
  (declare (xargs :guard (smtp-cst-matchp cst "helo")))
  (let ((__function__ 'smtp-cst-helo-conc))
    (declare (ignorable __function__))
    (tree-nonleaf->branches cst)))

Theorem: tree-list-listp-of-smtp-cst-helo-conc

(defthm tree-list-listp-of-smtp-cst-helo-conc
  (b* ((cstss (smtp-cst-helo-conc cst)))
    (tree-list-listp cstss))
  :rule-classes :rewrite)

Theorem: smtp-cst-helo-conc-match

(defthm smtp-cst-helo-conc-match
 (implies
  (smtp-cst-matchp cst "helo")
  (b* ((cstss (smtp-cst-helo-conc cst)))
    (smtp-cst-list-list-conc-matchp cstss "\"HELO\" sp domain crlf")))
 :rule-classes :rewrite)

Theorem: smtp-cst-helo-conc-of-tree-fix-cst

(defthm smtp-cst-helo-conc-of-tree-fix-cst
  (equal (smtp-cst-helo-conc (tree-fix cst))
         (smtp-cst-helo-conc cst)))

Theorem: smtp-cst-helo-conc-tree-equiv-congruence-on-cst

(defthm smtp-cst-helo-conc-tree-equiv-congruence-on-cst
  (implies (tree-equiv cst cst-equiv)
           (equal (smtp-cst-helo-conc cst)
                  (smtp-cst-helo-conc cst-equiv)))
  :rule-classes :congruence)

Function: smtp-cst-ehlo-greet-conc

(defun smtp-cst-ehlo-greet-conc (cst)
  (declare (xargs :guard (treep cst)))
  (declare (xargs :guard (smtp-cst-matchp cst "ehlo-greet")))
  (let ((__function__ 'smtp-cst-ehlo-greet-conc))
    (declare (ignorable __function__))
    (tree-nonleaf->branches cst)))

Theorem: tree-list-listp-of-smtp-cst-ehlo-greet-conc

(defthm tree-list-listp-of-smtp-cst-ehlo-greet-conc
  (b* ((cstss (smtp-cst-ehlo-greet-conc cst)))
    (tree-list-listp cstss))
  :rule-classes :rewrite)

Theorem: smtp-cst-ehlo-greet-conc-match

(defthm smtp-cst-ehlo-greet-conc-match
  (implies (smtp-cst-matchp cst "ehlo-greet")
           (b* ((cstss (smtp-cst-ehlo-greet-conc cst)))
             (smtp-cst-list-list-conc-matchp
                  cstss
                  "1*( %d0-9 / %d11-12 / %d14-127 )")))
  :rule-classes :rewrite)

Theorem: smtp-cst-ehlo-greet-conc-of-tree-fix-cst

(defthm smtp-cst-ehlo-greet-conc-of-tree-fix-cst
  (equal (smtp-cst-ehlo-greet-conc (tree-fix cst))
         (smtp-cst-ehlo-greet-conc cst)))

Theorem: smtp-cst-ehlo-greet-conc-tree-equiv-congruence-on-cst

(defthm smtp-cst-ehlo-greet-conc-tree-equiv-congruence-on-cst
  (implies (tree-equiv cst cst-equiv)
           (equal (smtp-cst-ehlo-greet-conc cst)
                  (smtp-cst-ehlo-greet-conc cst-equiv)))
  :rule-classes :congruence)

Function: smtp-cst-ehlo-line-conc

(defun smtp-cst-ehlo-line-conc (cst)
  (declare (xargs :guard (treep cst)))
  (declare (xargs :guard (smtp-cst-matchp cst "ehlo-line")))
  (let ((__function__ 'smtp-cst-ehlo-line-conc))
    (declare (ignorable __function__))
    (tree-nonleaf->branches cst)))

Theorem: tree-list-listp-of-smtp-cst-ehlo-line-conc

(defthm tree-list-listp-of-smtp-cst-ehlo-line-conc
  (b* ((cstss (smtp-cst-ehlo-line-conc cst)))
    (tree-list-listp cstss))
  :rule-classes :rewrite)

Theorem: smtp-cst-ehlo-line-conc-match

(defthm smtp-cst-ehlo-line-conc-match
  (implies (smtp-cst-matchp cst "ehlo-line")
           (b* ((cstss (smtp-cst-ehlo-line-conc cst)))
             (smtp-cst-list-list-conc-matchp
                  cstss
                  "ehlo-keyword *( sp ehlo-param )")))
  :rule-classes :rewrite)

Theorem: smtp-cst-ehlo-line-conc-of-tree-fix-cst

(defthm smtp-cst-ehlo-line-conc-of-tree-fix-cst
  (equal (smtp-cst-ehlo-line-conc (tree-fix cst))
         (smtp-cst-ehlo-line-conc cst)))

Theorem: smtp-cst-ehlo-line-conc-tree-equiv-congruence-on-cst

(defthm smtp-cst-ehlo-line-conc-tree-equiv-congruence-on-cst
  (implies (tree-equiv cst cst-equiv)
           (equal (smtp-cst-ehlo-line-conc cst)
                  (smtp-cst-ehlo-line-conc cst-equiv)))
  :rule-classes :congruence)

Function: smtp-cst-ehlo-keyword-conc

(defun smtp-cst-ehlo-keyword-conc (cst)
  (declare (xargs :guard (treep cst)))
  (declare (xargs :guard (smtp-cst-matchp cst "ehlo-keyword")))
  (let ((__function__ 'smtp-cst-ehlo-keyword-conc))
    (declare (ignorable __function__))
    (tree-nonleaf->branches cst)))

Theorem: tree-list-listp-of-smtp-cst-ehlo-keyword-conc

(defthm tree-list-listp-of-smtp-cst-ehlo-keyword-conc
  (b* ((cstss (smtp-cst-ehlo-keyword-conc cst)))
    (tree-list-listp cstss))
  :rule-classes :rewrite)

Theorem: smtp-cst-ehlo-keyword-conc-match

(defthm smtp-cst-ehlo-keyword-conc-match
  (implies (smtp-cst-matchp cst "ehlo-keyword")
           (b* ((cstss (smtp-cst-ehlo-keyword-conc cst)))
             (smtp-cst-list-list-conc-matchp
                  cstss
                  "( alpha / digit ) *( alpha / digit / \"-\" )")))
  :rule-classes :rewrite)

Theorem: smtp-cst-ehlo-keyword-conc-of-tree-fix-cst

(defthm smtp-cst-ehlo-keyword-conc-of-tree-fix-cst
  (equal (smtp-cst-ehlo-keyword-conc (tree-fix cst))
         (smtp-cst-ehlo-keyword-conc cst)))

Theorem: smtp-cst-ehlo-keyword-conc-tree-equiv-congruence-on-cst

(defthm smtp-cst-ehlo-keyword-conc-tree-equiv-congruence-on-cst
  (implies (tree-equiv cst cst-equiv)
           (equal (smtp-cst-ehlo-keyword-conc cst)
                  (smtp-cst-ehlo-keyword-conc cst-equiv)))
  :rule-classes :congruence)

Function: smtp-cst-ehlo-param-conc

(defun smtp-cst-ehlo-param-conc (cst)
  (declare (xargs :guard (treep cst)))
  (declare (xargs :guard (smtp-cst-matchp cst "ehlo-param")))
  (let ((__function__ 'smtp-cst-ehlo-param-conc))
    (declare (ignorable __function__))
    (tree-nonleaf->branches cst)))

Theorem: tree-list-listp-of-smtp-cst-ehlo-param-conc

(defthm tree-list-listp-of-smtp-cst-ehlo-param-conc
  (b* ((cstss (smtp-cst-ehlo-param-conc cst)))
    (tree-list-listp cstss))
  :rule-classes :rewrite)

Theorem: smtp-cst-ehlo-param-conc-match

(defthm smtp-cst-ehlo-param-conc-match
  (implies
       (smtp-cst-matchp cst "ehlo-param")
       (b* ((cstss (smtp-cst-ehlo-param-conc cst)))
         (smtp-cst-list-list-conc-matchp cstss "1*( %d33-126 )")))
  :rule-classes :rewrite)

Theorem: smtp-cst-ehlo-param-conc-of-tree-fix-cst

(defthm smtp-cst-ehlo-param-conc-of-tree-fix-cst
  (equal (smtp-cst-ehlo-param-conc (tree-fix cst))
         (smtp-cst-ehlo-param-conc cst)))

Theorem: smtp-cst-ehlo-param-conc-tree-equiv-congruence-on-cst

(defthm smtp-cst-ehlo-param-conc-tree-equiv-congruence-on-cst
  (implies (tree-equiv cst cst-equiv)
           (equal (smtp-cst-ehlo-param-conc cst)
                  (smtp-cst-ehlo-param-conc cst-equiv)))
  :rule-classes :congruence)

Function: smtp-cst-mail-conc

(defun smtp-cst-mail-conc (cst)
  (declare (xargs :guard (treep cst)))
  (declare (xargs :guard (smtp-cst-matchp cst "mail")))
  (let ((__function__ 'smtp-cst-mail-conc))
    (declare (ignorable __function__))
    (tree-nonleaf->branches cst)))

Theorem: tree-list-listp-of-smtp-cst-mail-conc

(defthm tree-list-listp-of-smtp-cst-mail-conc
  (b* ((cstss (smtp-cst-mail-conc cst)))
    (tree-list-listp cstss))
  :rule-classes :rewrite)

Theorem: smtp-cst-mail-conc-match

(defthm smtp-cst-mail-conc-match
 (implies
   (smtp-cst-matchp cst "mail")
   (b* ((cstss (smtp-cst-mail-conc cst)))
     (smtp-cst-list-list-conc-matchp
          cstss
          "\"MAIL FROM:\" reverse-path [ sp mail-parameters ] crlf")))
 :rule-classes :rewrite)

Theorem: smtp-cst-mail-conc-of-tree-fix-cst

(defthm smtp-cst-mail-conc-of-tree-fix-cst
  (equal (smtp-cst-mail-conc (tree-fix cst))
         (smtp-cst-mail-conc cst)))

Theorem: smtp-cst-mail-conc-tree-equiv-congruence-on-cst

(defthm smtp-cst-mail-conc-tree-equiv-congruence-on-cst
  (implies (tree-equiv cst cst-equiv)
           (equal (smtp-cst-mail-conc cst)
                  (smtp-cst-mail-conc cst-equiv)))
  :rule-classes :congruence)

Function: smtp-cst-rcpt-conc

(defun smtp-cst-rcpt-conc (cst)
  (declare (xargs :guard (treep cst)))
  (declare (xargs :guard (smtp-cst-matchp cst "rcpt")))
  (let ((__function__ 'smtp-cst-rcpt-conc))
    (declare (ignorable __function__))
    (tree-nonleaf->branches cst)))

Theorem: tree-list-listp-of-smtp-cst-rcpt-conc

(defthm tree-list-listp-of-smtp-cst-rcpt-conc
  (b* ((cstss (smtp-cst-rcpt-conc cst)))
    (tree-list-listp cstss))
  :rule-classes :rewrite)

Theorem: smtp-cst-rcpt-conc-match

(defthm smtp-cst-rcpt-conc-match
 (implies
  (smtp-cst-matchp cst "rcpt")
  (b* ((cstss (smtp-cst-rcpt-conc cst)))
   (smtp-cst-list-list-conc-matchp
    cstss
    "\"RCPT TO:\" ( \"<Postmaster@\" domain \">\" / \"<Postmaster>\" / forward-path ) [ sp rcpt-parameters ] crlf")))
 :rule-classes :rewrite)

Theorem: smtp-cst-rcpt-conc-of-tree-fix-cst

(defthm smtp-cst-rcpt-conc-of-tree-fix-cst
  (equal (smtp-cst-rcpt-conc (tree-fix cst))
         (smtp-cst-rcpt-conc cst)))

Theorem: smtp-cst-rcpt-conc-tree-equiv-congruence-on-cst

(defthm smtp-cst-rcpt-conc-tree-equiv-congruence-on-cst
  (implies (tree-equiv cst cst-equiv)
           (equal (smtp-cst-rcpt-conc cst)
                  (smtp-cst-rcpt-conc cst-equiv)))
  :rule-classes :congruence)

Function: smtp-cst-data-conc

(defun smtp-cst-data-conc (cst)
  (declare (xargs :guard (treep cst)))
  (declare (xargs :guard (smtp-cst-matchp cst "data")))
  (let ((__function__ 'smtp-cst-data-conc))
    (declare (ignorable __function__))
    (tree-nonleaf->branches cst)))

Theorem: tree-list-listp-of-smtp-cst-data-conc

(defthm tree-list-listp-of-smtp-cst-data-conc
  (b* ((cstss (smtp-cst-data-conc cst)))
    (tree-list-listp cstss))
  :rule-classes :rewrite)

Theorem: smtp-cst-data-conc-match

(defthm smtp-cst-data-conc-match
  (implies (smtp-cst-matchp cst "data")
           (b* ((cstss (smtp-cst-data-conc cst)))
             (smtp-cst-list-list-conc-matchp cstss "\"DATA\" crlf")))
  :rule-classes :rewrite)

Theorem: smtp-cst-data-conc-of-tree-fix-cst

(defthm smtp-cst-data-conc-of-tree-fix-cst
  (equal (smtp-cst-data-conc (tree-fix cst))
         (smtp-cst-data-conc cst)))

Theorem: smtp-cst-data-conc-tree-equiv-congruence-on-cst

(defthm smtp-cst-data-conc-tree-equiv-congruence-on-cst
  (implies (tree-equiv cst cst-equiv)
           (equal (smtp-cst-data-conc cst)
                  (smtp-cst-data-conc cst-equiv)))
  :rule-classes :congruence)

Function: smtp-cst-rset-conc

(defun smtp-cst-rset-conc (cst)
  (declare (xargs :guard (treep cst)))
  (declare (xargs :guard (smtp-cst-matchp cst "rset")))
  (let ((__function__ 'smtp-cst-rset-conc))
    (declare (ignorable __function__))
    (tree-nonleaf->branches cst)))

Theorem: tree-list-listp-of-smtp-cst-rset-conc

(defthm tree-list-listp-of-smtp-cst-rset-conc
  (b* ((cstss (smtp-cst-rset-conc cst)))
    (tree-list-listp cstss))
  :rule-classes :rewrite)

Theorem: smtp-cst-rset-conc-match

(defthm smtp-cst-rset-conc-match
  (implies (smtp-cst-matchp cst "rset")
           (b* ((cstss (smtp-cst-rset-conc cst)))
             (smtp-cst-list-list-conc-matchp cstss "\"RSET\" crlf")))
  :rule-classes :rewrite)

Theorem: smtp-cst-rset-conc-of-tree-fix-cst

(defthm smtp-cst-rset-conc-of-tree-fix-cst
  (equal (smtp-cst-rset-conc (tree-fix cst))
         (smtp-cst-rset-conc cst)))

Theorem: smtp-cst-rset-conc-tree-equiv-congruence-on-cst

(defthm smtp-cst-rset-conc-tree-equiv-congruence-on-cst
  (implies (tree-equiv cst cst-equiv)
           (equal (smtp-cst-rset-conc cst)
                  (smtp-cst-rset-conc cst-equiv)))
  :rule-classes :congruence)

Function: smtp-cst-vrfy-conc

(defun smtp-cst-vrfy-conc (cst)
  (declare (xargs :guard (treep cst)))
  (declare (xargs :guard (smtp-cst-matchp cst "vrfy")))
  (let ((__function__ 'smtp-cst-vrfy-conc))
    (declare (ignorable __function__))
    (tree-nonleaf->branches cst)))

Theorem: tree-list-listp-of-smtp-cst-vrfy-conc

(defthm tree-list-listp-of-smtp-cst-vrfy-conc
  (b* ((cstss (smtp-cst-vrfy-conc cst)))
    (tree-list-listp cstss))
  :rule-classes :rewrite)

Theorem: smtp-cst-vrfy-conc-match

(defthm smtp-cst-vrfy-conc-match
 (implies
  (smtp-cst-matchp cst "vrfy")
  (b* ((cstss (smtp-cst-vrfy-conc cst)))
    (smtp-cst-list-list-conc-matchp cstss "\"VRFY\" sp string crlf")))
 :rule-classes :rewrite)

Theorem: smtp-cst-vrfy-conc-of-tree-fix-cst

(defthm smtp-cst-vrfy-conc-of-tree-fix-cst
  (equal (smtp-cst-vrfy-conc (tree-fix cst))
         (smtp-cst-vrfy-conc cst)))

Theorem: smtp-cst-vrfy-conc-tree-equiv-congruence-on-cst

(defthm smtp-cst-vrfy-conc-tree-equiv-congruence-on-cst
  (implies (tree-equiv cst cst-equiv)
           (equal (smtp-cst-vrfy-conc cst)
                  (smtp-cst-vrfy-conc cst-equiv)))
  :rule-classes :congruence)

Function: smtp-cst-expn-conc

(defun smtp-cst-expn-conc (cst)
  (declare (xargs :guard (treep cst)))
  (declare (xargs :guard (smtp-cst-matchp cst "expn")))
  (let ((__function__ 'smtp-cst-expn-conc))
    (declare (ignorable __function__))
    (tree-nonleaf->branches cst)))

Theorem: tree-list-listp-of-smtp-cst-expn-conc

(defthm tree-list-listp-of-smtp-cst-expn-conc
  (b* ((cstss (smtp-cst-expn-conc cst)))
    (tree-list-listp cstss))
  :rule-classes :rewrite)

Theorem: smtp-cst-expn-conc-match

(defthm smtp-cst-expn-conc-match
 (implies
  (smtp-cst-matchp cst "expn")
  (b* ((cstss (smtp-cst-expn-conc cst)))
    (smtp-cst-list-list-conc-matchp cstss "\"EXPN\" sp string crlf")))
 :rule-classes :rewrite)

Theorem: smtp-cst-expn-conc-of-tree-fix-cst

(defthm smtp-cst-expn-conc-of-tree-fix-cst
  (equal (smtp-cst-expn-conc (tree-fix cst))
         (smtp-cst-expn-conc cst)))

Theorem: smtp-cst-expn-conc-tree-equiv-congruence-on-cst

(defthm smtp-cst-expn-conc-tree-equiv-congruence-on-cst
  (implies (tree-equiv cst cst-equiv)
           (equal (smtp-cst-expn-conc cst)
                  (smtp-cst-expn-conc cst-equiv)))
  :rule-classes :congruence)

Function: smtp-cst-help-conc

(defun smtp-cst-help-conc (cst)
  (declare (xargs :guard (treep cst)))
  (declare (xargs :guard (smtp-cst-matchp cst "help")))
  (let ((__function__ 'smtp-cst-help-conc))
    (declare (ignorable __function__))
    (tree-nonleaf->branches cst)))

Theorem: tree-list-listp-of-smtp-cst-help-conc

(defthm tree-list-listp-of-smtp-cst-help-conc
  (b* ((cstss (smtp-cst-help-conc cst)))
    (tree-list-listp cstss))
  :rule-classes :rewrite)

Theorem: smtp-cst-help-conc-match

(defthm smtp-cst-help-conc-match
  (implies (smtp-cst-matchp cst "help")
           (b* ((cstss (smtp-cst-help-conc cst)))
             (smtp-cst-list-list-conc-matchp
                  cstss "\"HELP\" [ sp string ] crlf")))
  :rule-classes :rewrite)

Theorem: smtp-cst-help-conc-of-tree-fix-cst

(defthm smtp-cst-help-conc-of-tree-fix-cst
  (equal (smtp-cst-help-conc (tree-fix cst))
         (smtp-cst-help-conc cst)))

Theorem: smtp-cst-help-conc-tree-equiv-congruence-on-cst

(defthm smtp-cst-help-conc-tree-equiv-congruence-on-cst
  (implies (tree-equiv cst cst-equiv)
           (equal (smtp-cst-help-conc cst)
                  (smtp-cst-help-conc cst-equiv)))
  :rule-classes :congruence)

Function: smtp-cst-noop-conc

(defun smtp-cst-noop-conc (cst)
  (declare (xargs :guard (treep cst)))
  (declare (xargs :guard (smtp-cst-matchp cst "noop")))
  (let ((__function__ 'smtp-cst-noop-conc))
    (declare (ignorable __function__))
    (tree-nonleaf->branches cst)))

Theorem: tree-list-listp-of-smtp-cst-noop-conc

(defthm tree-list-listp-of-smtp-cst-noop-conc
  (b* ((cstss (smtp-cst-noop-conc cst)))
    (tree-list-listp cstss))
  :rule-classes :rewrite)

Theorem: smtp-cst-noop-conc-match

(defthm smtp-cst-noop-conc-match
  (implies (smtp-cst-matchp cst "noop")
           (b* ((cstss (smtp-cst-noop-conc cst)))
             (smtp-cst-list-list-conc-matchp
                  cstss "\"NOOP\" [ sp string ] crlf")))
  :rule-classes :rewrite)

Theorem: smtp-cst-noop-conc-of-tree-fix-cst

(defthm smtp-cst-noop-conc-of-tree-fix-cst
  (equal (smtp-cst-noop-conc (tree-fix cst))
         (smtp-cst-noop-conc cst)))

Theorem: smtp-cst-noop-conc-tree-equiv-congruence-on-cst

(defthm smtp-cst-noop-conc-tree-equiv-congruence-on-cst
  (implies (tree-equiv cst cst-equiv)
           (equal (smtp-cst-noop-conc cst)
                  (smtp-cst-noop-conc cst-equiv)))
  :rule-classes :congruence)

Function: smtp-cst-quit-conc

(defun smtp-cst-quit-conc (cst)
  (declare (xargs :guard (treep cst)))
  (declare (xargs :guard (smtp-cst-matchp cst "quit")))
  (let ((__function__ 'smtp-cst-quit-conc))
    (declare (ignorable __function__))
    (tree-nonleaf->branches cst)))

Theorem: tree-list-listp-of-smtp-cst-quit-conc

(defthm tree-list-listp-of-smtp-cst-quit-conc
  (b* ((cstss (smtp-cst-quit-conc cst)))
    (tree-list-listp cstss))
  :rule-classes :rewrite)

Theorem: smtp-cst-quit-conc-match

(defthm smtp-cst-quit-conc-match
  (implies (smtp-cst-matchp cst "quit")
           (b* ((cstss (smtp-cst-quit-conc cst)))
             (smtp-cst-list-list-conc-matchp cstss "\"QUIT\" crlf")))
  :rule-classes :rewrite)

Theorem: smtp-cst-quit-conc-of-tree-fix-cst

(defthm smtp-cst-quit-conc-of-tree-fix-cst
  (equal (smtp-cst-quit-conc (tree-fix cst))
         (smtp-cst-quit-conc cst)))

Theorem: smtp-cst-quit-conc-tree-equiv-congruence-on-cst

(defthm smtp-cst-quit-conc-tree-equiv-congruence-on-cst
  (implies (tree-equiv cst cst-equiv)
           (equal (smtp-cst-quit-conc cst)
                  (smtp-cst-quit-conc cst-equiv)))
  :rule-classes :congruence)

Function: smtp-cst-forward-path-conc

(defun smtp-cst-forward-path-conc (cst)
  (declare (xargs :guard (treep cst)))
  (declare (xargs :guard (smtp-cst-matchp cst "forward-path")))
  (let ((__function__ 'smtp-cst-forward-path-conc))
    (declare (ignorable __function__))
    (tree-nonleaf->branches cst)))

Theorem: tree-list-listp-of-smtp-cst-forward-path-conc

(defthm tree-list-listp-of-smtp-cst-forward-path-conc
  (b* ((cstss (smtp-cst-forward-path-conc cst)))
    (tree-list-listp cstss))
  :rule-classes :rewrite)

Theorem: smtp-cst-forward-path-conc-match

(defthm smtp-cst-forward-path-conc-match
  (implies (smtp-cst-matchp cst "forward-path")
           (b* ((cstss (smtp-cst-forward-path-conc cst)))
             (smtp-cst-list-list-conc-matchp cstss "path")))
  :rule-classes :rewrite)

Theorem: smtp-cst-forward-path-conc-of-tree-fix-cst

(defthm smtp-cst-forward-path-conc-of-tree-fix-cst
  (equal (smtp-cst-forward-path-conc (tree-fix cst))
         (smtp-cst-forward-path-conc cst)))

Theorem: smtp-cst-forward-path-conc-tree-equiv-congruence-on-cst

(defthm smtp-cst-forward-path-conc-tree-equiv-congruence-on-cst
  (implies (tree-equiv cst cst-equiv)
           (equal (smtp-cst-forward-path-conc cst)
                  (smtp-cst-forward-path-conc cst-equiv)))
  :rule-classes :congruence)

Function: smtp-cst-path-conc

(defun smtp-cst-path-conc (cst)
  (declare (xargs :guard (treep cst)))
  (declare (xargs :guard (smtp-cst-matchp cst "path")))
  (let ((__function__ 'smtp-cst-path-conc))
    (declare (ignorable __function__))
    (tree-nonleaf->branches cst)))

Theorem: tree-list-listp-of-smtp-cst-path-conc

(defthm tree-list-listp-of-smtp-cst-path-conc
  (b* ((cstss (smtp-cst-path-conc cst)))
    (tree-list-listp cstss))
  :rule-classes :rewrite)

Theorem: smtp-cst-path-conc-match

(defthm smtp-cst-path-conc-match
  (implies (smtp-cst-matchp cst "path")
           (b* ((cstss (smtp-cst-path-conc cst)))
             (smtp-cst-list-list-conc-matchp
                  cstss "\"<\" [ a-d-l \":\" ] mailbox \">\"")))
  :rule-classes :rewrite)

Theorem: smtp-cst-path-conc-of-tree-fix-cst

(defthm smtp-cst-path-conc-of-tree-fix-cst
  (equal (smtp-cst-path-conc (tree-fix cst))
         (smtp-cst-path-conc cst)))

Theorem: smtp-cst-path-conc-tree-equiv-congruence-on-cst

(defthm smtp-cst-path-conc-tree-equiv-congruence-on-cst
  (implies (tree-equiv cst cst-equiv)
           (equal (smtp-cst-path-conc cst)
                  (smtp-cst-path-conc cst-equiv)))
  :rule-classes :congruence)

Function: smtp-cst-a-d-l-conc

(defun smtp-cst-a-d-l-conc (cst)
  (declare (xargs :guard (treep cst)))
  (declare (xargs :guard (smtp-cst-matchp cst "a-d-l")))
  (let ((__function__ 'smtp-cst-a-d-l-conc))
    (declare (ignorable __function__))
    (tree-nonleaf->branches cst)))

Theorem: tree-list-listp-of-smtp-cst-a-d-l-conc

(defthm tree-list-listp-of-smtp-cst-a-d-l-conc
  (b* ((cstss (smtp-cst-a-d-l-conc cst)))
    (tree-list-listp cstss))
  :rule-classes :rewrite)

Theorem: smtp-cst-a-d-l-conc-match

(defthm smtp-cst-a-d-l-conc-match
  (implies (smtp-cst-matchp cst "a-d-l")
           (b* ((cstss (smtp-cst-a-d-l-conc cst)))
             (smtp-cst-list-list-conc-matchp
                  cstss "at-domain *( \",\" at-domain )")))
  :rule-classes :rewrite)

Theorem: smtp-cst-a-d-l-conc-of-tree-fix-cst

(defthm smtp-cst-a-d-l-conc-of-tree-fix-cst
  (equal (smtp-cst-a-d-l-conc (tree-fix cst))
         (smtp-cst-a-d-l-conc cst)))

Theorem: smtp-cst-a-d-l-conc-tree-equiv-congruence-on-cst

(defthm smtp-cst-a-d-l-conc-tree-equiv-congruence-on-cst
  (implies (tree-equiv cst cst-equiv)
           (equal (smtp-cst-a-d-l-conc cst)
                  (smtp-cst-a-d-l-conc cst-equiv)))
  :rule-classes :congruence)

Function: smtp-cst-at-domain-conc

(defun smtp-cst-at-domain-conc (cst)
  (declare (xargs :guard (treep cst)))
  (declare (xargs :guard (smtp-cst-matchp cst "at-domain")))
  (let ((__function__ 'smtp-cst-at-domain-conc))
    (declare (ignorable __function__))
    (tree-nonleaf->branches cst)))

Theorem: tree-list-listp-of-smtp-cst-at-domain-conc

(defthm tree-list-listp-of-smtp-cst-at-domain-conc
  (b* ((cstss (smtp-cst-at-domain-conc cst)))
    (tree-list-listp cstss))
  :rule-classes :rewrite)

Theorem: smtp-cst-at-domain-conc-match

(defthm smtp-cst-at-domain-conc-match
  (implies (smtp-cst-matchp cst "at-domain")
           (b* ((cstss (smtp-cst-at-domain-conc cst)))
             (smtp-cst-list-list-conc-matchp cstss "\"@\" domain")))
  :rule-classes :rewrite)

Theorem: smtp-cst-at-domain-conc-of-tree-fix-cst

(defthm smtp-cst-at-domain-conc-of-tree-fix-cst
  (equal (smtp-cst-at-domain-conc (tree-fix cst))
         (smtp-cst-at-domain-conc cst)))

Theorem: smtp-cst-at-domain-conc-tree-equiv-congruence-on-cst

(defthm smtp-cst-at-domain-conc-tree-equiv-congruence-on-cst
  (implies (tree-equiv cst cst-equiv)
           (equal (smtp-cst-at-domain-conc cst)
                  (smtp-cst-at-domain-conc cst-equiv)))
  :rule-classes :congruence)

Function: smtp-cst-mail-parameters-conc

(defun smtp-cst-mail-parameters-conc (cst)
  (declare (xargs :guard (treep cst)))
  (declare (xargs :guard (smtp-cst-matchp cst "mail-parameters")))
  (let ((__function__ 'smtp-cst-mail-parameters-conc))
    (declare (ignorable __function__))
    (tree-nonleaf->branches cst)))

Theorem: tree-list-listp-of-smtp-cst-mail-parameters-conc

(defthm tree-list-listp-of-smtp-cst-mail-parameters-conc
  (b* ((cstss (smtp-cst-mail-parameters-conc cst)))
    (tree-list-listp cstss))
  :rule-classes :rewrite)

Theorem: smtp-cst-mail-parameters-conc-match

(defthm smtp-cst-mail-parameters-conc-match
  (implies (smtp-cst-matchp cst "mail-parameters")
           (b* ((cstss (smtp-cst-mail-parameters-conc cst)))
             (smtp-cst-list-list-conc-matchp
                  cstss
                  "esmtp-param *( sp esmtp-param )")))
  :rule-classes :rewrite)

Theorem: smtp-cst-mail-parameters-conc-of-tree-fix-cst

(defthm smtp-cst-mail-parameters-conc-of-tree-fix-cst
  (equal (smtp-cst-mail-parameters-conc (tree-fix cst))
         (smtp-cst-mail-parameters-conc cst)))

Theorem: smtp-cst-mail-parameters-conc-tree-equiv-congruence-on-cst

(defthm smtp-cst-mail-parameters-conc-tree-equiv-congruence-on-cst
  (implies (tree-equiv cst cst-equiv)
           (equal (smtp-cst-mail-parameters-conc cst)
                  (smtp-cst-mail-parameters-conc cst-equiv)))
  :rule-classes :congruence)

Function: smtp-cst-rcpt-parameters-conc

(defun smtp-cst-rcpt-parameters-conc (cst)
  (declare (xargs :guard (treep cst)))
  (declare (xargs :guard (smtp-cst-matchp cst "rcpt-parameters")))
  (let ((__function__ 'smtp-cst-rcpt-parameters-conc))
    (declare (ignorable __function__))
    (tree-nonleaf->branches cst)))

Theorem: tree-list-listp-of-smtp-cst-rcpt-parameters-conc

(defthm tree-list-listp-of-smtp-cst-rcpt-parameters-conc
  (b* ((cstss (smtp-cst-rcpt-parameters-conc cst)))
    (tree-list-listp cstss))
  :rule-classes :rewrite)

Theorem: smtp-cst-rcpt-parameters-conc-match

(defthm smtp-cst-rcpt-parameters-conc-match
  (implies (smtp-cst-matchp cst "rcpt-parameters")
           (b* ((cstss (smtp-cst-rcpt-parameters-conc cst)))
             (smtp-cst-list-list-conc-matchp
                  cstss
                  "esmtp-param *( sp esmtp-param )")))
  :rule-classes :rewrite)

Theorem: smtp-cst-rcpt-parameters-conc-of-tree-fix-cst

(defthm smtp-cst-rcpt-parameters-conc-of-tree-fix-cst
  (equal (smtp-cst-rcpt-parameters-conc (tree-fix cst))
         (smtp-cst-rcpt-parameters-conc cst)))

Theorem: smtp-cst-rcpt-parameters-conc-tree-equiv-congruence-on-cst

(defthm smtp-cst-rcpt-parameters-conc-tree-equiv-congruence-on-cst
  (implies (tree-equiv cst cst-equiv)
           (equal (smtp-cst-rcpt-parameters-conc cst)
                  (smtp-cst-rcpt-parameters-conc cst-equiv)))
  :rule-classes :congruence)

Function: smtp-cst-esmtp-param-conc

(defun smtp-cst-esmtp-param-conc (cst)
  (declare (xargs :guard (treep cst)))
  (declare (xargs :guard (smtp-cst-matchp cst "esmtp-param")))
  (let ((__function__ 'smtp-cst-esmtp-param-conc))
    (declare (ignorable __function__))
    (tree-nonleaf->branches cst)))

Theorem: tree-list-listp-of-smtp-cst-esmtp-param-conc

(defthm tree-list-listp-of-smtp-cst-esmtp-param-conc
  (b* ((cstss (smtp-cst-esmtp-param-conc cst)))
    (tree-list-listp cstss))
  :rule-classes :rewrite)

Theorem: smtp-cst-esmtp-param-conc-match

(defthm smtp-cst-esmtp-param-conc-match
  (implies (smtp-cst-matchp cst "esmtp-param")
           (b* ((cstss (smtp-cst-esmtp-param-conc cst)))
             (smtp-cst-list-list-conc-matchp
                  cstss
                  "esmtp-keyword [ \"=\" esmtp-value ]")))
  :rule-classes :rewrite)

Theorem: smtp-cst-esmtp-param-conc-of-tree-fix-cst

(defthm smtp-cst-esmtp-param-conc-of-tree-fix-cst
  (equal (smtp-cst-esmtp-param-conc (tree-fix cst))
         (smtp-cst-esmtp-param-conc cst)))

Theorem: smtp-cst-esmtp-param-conc-tree-equiv-congruence-on-cst

(defthm smtp-cst-esmtp-param-conc-tree-equiv-congruence-on-cst
  (implies (tree-equiv cst cst-equiv)
           (equal (smtp-cst-esmtp-param-conc cst)
                  (smtp-cst-esmtp-param-conc cst-equiv)))
  :rule-classes :congruence)

Function: smtp-cst-esmtp-keyword-conc

(defun smtp-cst-esmtp-keyword-conc (cst)
  (declare (xargs :guard (treep cst)))
  (declare (xargs :guard (smtp-cst-matchp cst "esmtp-keyword")))
  (let ((__function__ 'smtp-cst-esmtp-keyword-conc))
    (declare (ignorable __function__))
    (tree-nonleaf->branches cst)))

Theorem: tree-list-listp-of-smtp-cst-esmtp-keyword-conc

(defthm tree-list-listp-of-smtp-cst-esmtp-keyword-conc
  (b* ((cstss (smtp-cst-esmtp-keyword-conc cst)))
    (tree-list-listp cstss))
  :rule-classes :rewrite)

Theorem: smtp-cst-esmtp-keyword-conc-match

(defthm smtp-cst-esmtp-keyword-conc-match
  (implies (smtp-cst-matchp cst "esmtp-keyword")
           (b* ((cstss (smtp-cst-esmtp-keyword-conc cst)))
             (smtp-cst-list-list-conc-matchp
                  cstss
                  "( alpha / digit ) *( alpha / digit / \"-\" )")))
  :rule-classes :rewrite)

Theorem: smtp-cst-esmtp-keyword-conc-of-tree-fix-cst

(defthm smtp-cst-esmtp-keyword-conc-of-tree-fix-cst
  (equal (smtp-cst-esmtp-keyword-conc (tree-fix cst))
         (smtp-cst-esmtp-keyword-conc cst)))

Theorem: smtp-cst-esmtp-keyword-conc-tree-equiv-congruence-on-cst

(defthm smtp-cst-esmtp-keyword-conc-tree-equiv-congruence-on-cst
  (implies (tree-equiv cst cst-equiv)
           (equal (smtp-cst-esmtp-keyword-conc cst)
                  (smtp-cst-esmtp-keyword-conc cst-equiv)))
  :rule-classes :congruence)

Function: smtp-cst-esmtp-value-conc

(defun smtp-cst-esmtp-value-conc (cst)
  (declare (xargs :guard (treep cst)))
  (declare (xargs :guard (smtp-cst-matchp cst "esmtp-value")))
  (let ((__function__ 'smtp-cst-esmtp-value-conc))
    (declare (ignorable __function__))
    (tree-nonleaf->branches cst)))

Theorem: tree-list-listp-of-smtp-cst-esmtp-value-conc

(defthm tree-list-listp-of-smtp-cst-esmtp-value-conc
  (b* ((cstss (smtp-cst-esmtp-value-conc cst)))
    (tree-list-listp cstss))
  :rule-classes :rewrite)

Theorem: smtp-cst-esmtp-value-conc-match

(defthm smtp-cst-esmtp-value-conc-match
  (implies (smtp-cst-matchp cst "esmtp-value")
           (b* ((cstss (smtp-cst-esmtp-value-conc cst)))
             (smtp-cst-list-list-conc-matchp
                  cstss "1*( %d33-60 / %d62-126 )")))
  :rule-classes :rewrite)

Theorem: smtp-cst-esmtp-value-conc-of-tree-fix-cst

(defthm smtp-cst-esmtp-value-conc-of-tree-fix-cst
  (equal (smtp-cst-esmtp-value-conc (tree-fix cst))
         (smtp-cst-esmtp-value-conc cst)))

Theorem: smtp-cst-esmtp-value-conc-tree-equiv-congruence-on-cst

(defthm smtp-cst-esmtp-value-conc-tree-equiv-congruence-on-cst
  (implies (tree-equiv cst cst-equiv)
           (equal (smtp-cst-esmtp-value-conc cst)
                  (smtp-cst-esmtp-value-conc cst-equiv)))
  :rule-classes :congruence)

Function: smtp-cst-keyword-conc

(defun smtp-cst-keyword-conc (cst)
  (declare (xargs :guard (treep cst)))
  (declare (xargs :guard (smtp-cst-matchp cst "keyword")))
  (let ((__function__ 'smtp-cst-keyword-conc))
    (declare (ignorable __function__))
    (tree-nonleaf->branches cst)))

Theorem: tree-list-listp-of-smtp-cst-keyword-conc

(defthm tree-list-listp-of-smtp-cst-keyword-conc
  (b* ((cstss (smtp-cst-keyword-conc cst)))
    (tree-list-listp cstss))
  :rule-classes :rewrite)

Theorem: smtp-cst-keyword-conc-match

(defthm smtp-cst-keyword-conc-match
  (implies (smtp-cst-matchp cst "keyword")
           (b* ((cstss (smtp-cst-keyword-conc cst)))
             (smtp-cst-list-list-conc-matchp cstss "ldh-str")))
  :rule-classes :rewrite)

Theorem: smtp-cst-keyword-conc-of-tree-fix-cst

(defthm smtp-cst-keyword-conc-of-tree-fix-cst
  (equal (smtp-cst-keyword-conc (tree-fix cst))
         (smtp-cst-keyword-conc cst)))

Theorem: smtp-cst-keyword-conc-tree-equiv-congruence-on-cst

(defthm smtp-cst-keyword-conc-tree-equiv-congruence-on-cst
  (implies (tree-equiv cst cst-equiv)
           (equal (smtp-cst-keyword-conc cst)
                  (smtp-cst-keyword-conc cst-equiv)))
  :rule-classes :congruence)

Function: smtp-cst-argument-conc

(defun smtp-cst-argument-conc (cst)
  (declare (xargs :guard (treep cst)))
  (declare (xargs :guard (smtp-cst-matchp cst "argument")))
  (let ((__function__ 'smtp-cst-argument-conc))
    (declare (ignorable __function__))
    (tree-nonleaf->branches cst)))

Theorem: tree-list-listp-of-smtp-cst-argument-conc

(defthm tree-list-listp-of-smtp-cst-argument-conc
  (b* ((cstss (smtp-cst-argument-conc cst)))
    (tree-list-listp cstss))
  :rule-classes :rewrite)

Theorem: smtp-cst-argument-conc-match

(defthm smtp-cst-argument-conc-match
  (implies (smtp-cst-matchp cst "argument")
           (b* ((cstss (smtp-cst-argument-conc cst)))
             (smtp-cst-list-list-conc-matchp cstss "atom")))
  :rule-classes :rewrite)

Theorem: smtp-cst-argument-conc-of-tree-fix-cst

(defthm smtp-cst-argument-conc-of-tree-fix-cst
  (equal (smtp-cst-argument-conc (tree-fix cst))
         (smtp-cst-argument-conc cst)))

Theorem: smtp-cst-argument-conc-tree-equiv-congruence-on-cst

(defthm smtp-cst-argument-conc-tree-equiv-congruence-on-cst
  (implies (tree-equiv cst cst-equiv)
           (equal (smtp-cst-argument-conc cst)
                  (smtp-cst-argument-conc cst-equiv)))
  :rule-classes :congruence)

Function: smtp-cst-domain-conc

(defun smtp-cst-domain-conc (cst)
  (declare (xargs :guard (treep cst)))
  (declare (xargs :guard (smtp-cst-matchp cst "domain")))
  (let ((__function__ 'smtp-cst-domain-conc))
    (declare (ignorable __function__))
    (tree-nonleaf->branches cst)))

Theorem: tree-list-listp-of-smtp-cst-domain-conc

(defthm tree-list-listp-of-smtp-cst-domain-conc
  (b* ((cstss (smtp-cst-domain-conc cst)))
    (tree-list-listp cstss))
  :rule-classes :rewrite)

Theorem: smtp-cst-domain-conc-match

(defthm smtp-cst-domain-conc-match
  (implies (smtp-cst-matchp cst "domain")
           (b* ((cstss (smtp-cst-domain-conc cst)))
             (smtp-cst-list-list-conc-matchp
                  cstss
                  "sub-domain *( \".\" sub-domain )")))
  :rule-classes :rewrite)

Theorem: smtp-cst-domain-conc-of-tree-fix-cst

(defthm smtp-cst-domain-conc-of-tree-fix-cst
  (equal (smtp-cst-domain-conc (tree-fix cst))
         (smtp-cst-domain-conc cst)))

Theorem: smtp-cst-domain-conc-tree-equiv-congruence-on-cst

(defthm smtp-cst-domain-conc-tree-equiv-congruence-on-cst
  (implies (tree-equiv cst cst-equiv)
           (equal (smtp-cst-domain-conc cst)
                  (smtp-cst-domain-conc cst-equiv)))
  :rule-classes :congruence)

Function: smtp-cst-sub-domain-conc

(defun smtp-cst-sub-domain-conc (cst)
  (declare (xargs :guard (treep cst)))
  (declare (xargs :guard (smtp-cst-matchp cst "sub-domain")))
  (let ((__function__ 'smtp-cst-sub-domain-conc))
    (declare (ignorable __function__))
    (tree-nonleaf->branches cst)))

Theorem: tree-list-listp-of-smtp-cst-sub-domain-conc

(defthm tree-list-listp-of-smtp-cst-sub-domain-conc
  (b* ((cstss (smtp-cst-sub-domain-conc cst)))
    (tree-list-listp cstss))
  :rule-classes :rewrite)

Theorem: smtp-cst-sub-domain-conc-match

(defthm smtp-cst-sub-domain-conc-match
 (implies
    (smtp-cst-matchp cst "sub-domain")
    (b* ((cstss (smtp-cst-sub-domain-conc cst)))
      (smtp-cst-list-list-conc-matchp cstss "let-dig [ ldh-str ]")))
 :rule-classes :rewrite)

Theorem: smtp-cst-sub-domain-conc-of-tree-fix-cst

(defthm smtp-cst-sub-domain-conc-of-tree-fix-cst
  (equal (smtp-cst-sub-domain-conc (tree-fix cst))
         (smtp-cst-sub-domain-conc cst)))

Theorem: smtp-cst-sub-domain-conc-tree-equiv-congruence-on-cst

(defthm smtp-cst-sub-domain-conc-tree-equiv-congruence-on-cst
  (implies (tree-equiv cst cst-equiv)
           (equal (smtp-cst-sub-domain-conc cst)
                  (smtp-cst-sub-domain-conc cst-equiv)))
  :rule-classes :congruence)

Function: smtp-cst-let-dig-conc1

(defun smtp-cst-let-dig-conc1 (cst)
  (declare (xargs :guard (treep cst)))
  (declare (xargs :guard (and (smtp-cst-matchp cst "let-dig")
                              (equal (smtp-cst-let-dig-conc? cst)
                                     1))))
  (let ((__function__ 'smtp-cst-let-dig-conc1))
    (declare (ignorable __function__))
    (tree-nonleaf->branches cst)))

Theorem: tree-list-listp-of-smtp-cst-let-dig-conc1

(defthm tree-list-listp-of-smtp-cst-let-dig-conc1
  (b* ((cstss (smtp-cst-let-dig-conc1 cst)))
    (tree-list-listp cstss))
  :rule-classes :rewrite)

Theorem: smtp-cst-let-dig-conc1-match

(defthm smtp-cst-let-dig-conc1-match
  (implies (and (smtp-cst-matchp cst "let-dig")
                (equal (smtp-cst-let-dig-conc? cst) 1))
           (b* ((cstss (smtp-cst-let-dig-conc1 cst)))
             (smtp-cst-list-list-conc-matchp cstss "alpha")))
  :rule-classes :rewrite)

Theorem: smtp-cst-let-dig-conc1-of-tree-fix-cst

(defthm smtp-cst-let-dig-conc1-of-tree-fix-cst
  (equal (smtp-cst-let-dig-conc1 (tree-fix cst))
         (smtp-cst-let-dig-conc1 cst)))

Theorem: smtp-cst-let-dig-conc1-tree-equiv-congruence-on-cst

(defthm smtp-cst-let-dig-conc1-tree-equiv-congruence-on-cst
  (implies (tree-equiv cst cst-equiv)
           (equal (smtp-cst-let-dig-conc1 cst)
                  (smtp-cst-let-dig-conc1 cst-equiv)))
  :rule-classes :congruence)

Function: smtp-cst-let-dig-conc2

(defun smtp-cst-let-dig-conc2 (cst)
  (declare (xargs :guard (treep cst)))
  (declare (xargs :guard (and (smtp-cst-matchp cst "let-dig")
                              (equal (smtp-cst-let-dig-conc? cst)
                                     2))))
  (let ((__function__ 'smtp-cst-let-dig-conc2))
    (declare (ignorable __function__))
    (tree-nonleaf->branches cst)))

Theorem: tree-list-listp-of-smtp-cst-let-dig-conc2

(defthm tree-list-listp-of-smtp-cst-let-dig-conc2
  (b* ((cstss (smtp-cst-let-dig-conc2 cst)))
    (tree-list-listp cstss))
  :rule-classes :rewrite)

Theorem: smtp-cst-let-dig-conc2-match

(defthm smtp-cst-let-dig-conc2-match
  (implies (and (smtp-cst-matchp cst "let-dig")
                (equal (smtp-cst-let-dig-conc? cst) 2))
           (b* ((cstss (smtp-cst-let-dig-conc2 cst)))
             (smtp-cst-list-list-conc-matchp cstss "digit")))
  :rule-classes :rewrite)

Theorem: smtp-cst-let-dig-conc2-of-tree-fix-cst

(defthm smtp-cst-let-dig-conc2-of-tree-fix-cst
  (equal (smtp-cst-let-dig-conc2 (tree-fix cst))
         (smtp-cst-let-dig-conc2 cst)))

Theorem: smtp-cst-let-dig-conc2-tree-equiv-congruence-on-cst

(defthm smtp-cst-let-dig-conc2-tree-equiv-congruence-on-cst
  (implies (tree-equiv cst cst-equiv)
           (equal (smtp-cst-let-dig-conc2 cst)
                  (smtp-cst-let-dig-conc2 cst-equiv)))
  :rule-classes :congruence)

Function: smtp-cst-ldh-str-conc

(defun smtp-cst-ldh-str-conc (cst)
  (declare (xargs :guard (treep cst)))
  (declare (xargs :guard (smtp-cst-matchp cst "ldh-str")))
  (let ((__function__ 'smtp-cst-ldh-str-conc))
    (declare (ignorable __function__))
    (tree-nonleaf->branches cst)))

Theorem: tree-list-listp-of-smtp-cst-ldh-str-conc

(defthm tree-list-listp-of-smtp-cst-ldh-str-conc
  (b* ((cstss (smtp-cst-ldh-str-conc cst)))
    (tree-list-listp cstss))
  :rule-classes :rewrite)

Theorem: smtp-cst-ldh-str-conc-match

(defthm smtp-cst-ldh-str-conc-match
  (implies (smtp-cst-matchp cst "ldh-str")
           (b* ((cstss (smtp-cst-ldh-str-conc cst)))
             (smtp-cst-list-list-conc-matchp
                  cstss
                  "*( alpha / digit / \"-\" ) let-dig")))
  :rule-classes :rewrite)

Theorem: smtp-cst-ldh-str-conc-of-tree-fix-cst

(defthm smtp-cst-ldh-str-conc-of-tree-fix-cst
  (equal (smtp-cst-ldh-str-conc (tree-fix cst))
         (smtp-cst-ldh-str-conc cst)))

Theorem: smtp-cst-ldh-str-conc-tree-equiv-congruence-on-cst

(defthm smtp-cst-ldh-str-conc-tree-equiv-congruence-on-cst
  (implies (tree-equiv cst cst-equiv)
           (equal (smtp-cst-ldh-str-conc cst)
                  (smtp-cst-ldh-str-conc cst-equiv)))
  :rule-classes :congruence)

Function: smtp-cst-address-literal-conc

(defun smtp-cst-address-literal-conc (cst)
  (declare (xargs :guard (treep cst)))
  (declare (xargs :guard (smtp-cst-matchp cst "address-literal")))
  (let ((__function__ 'smtp-cst-address-literal-conc))
    (declare (ignorable __function__))
    (tree-nonleaf->branches cst)))

Theorem: tree-list-listp-of-smtp-cst-address-literal-conc

(defthm tree-list-listp-of-smtp-cst-address-literal-conc
  (b* ((cstss (smtp-cst-address-literal-conc cst)))
    (tree-list-listp cstss))
  :rule-classes :rewrite)

Theorem: smtp-cst-address-literal-conc-match

(defthm smtp-cst-address-literal-conc-match
 (implies
  (smtp-cst-matchp cst "address-literal")
  (b* ((cstss (smtp-cst-address-literal-conc cst)))
   (smtp-cst-list-list-conc-matchp
    cstss
    "\"[\" ( ipv4-address-literal / ipv6-address-literal / general-address-literal ) \"]\"")))
 :rule-classes :rewrite)

Theorem: smtp-cst-address-literal-conc-of-tree-fix-cst

(defthm smtp-cst-address-literal-conc-of-tree-fix-cst
  (equal (smtp-cst-address-literal-conc (tree-fix cst))
         (smtp-cst-address-literal-conc cst)))

Theorem: smtp-cst-address-literal-conc-tree-equiv-congruence-on-cst

(defthm smtp-cst-address-literal-conc-tree-equiv-congruence-on-cst
  (implies (tree-equiv cst cst-equiv)
           (equal (smtp-cst-address-literal-conc cst)
                  (smtp-cst-address-literal-conc cst-equiv)))
  :rule-classes :congruence)

Function: smtp-cst-mailbox-conc

(defun smtp-cst-mailbox-conc (cst)
  (declare (xargs :guard (treep cst)))
  (declare (xargs :guard (smtp-cst-matchp cst "mailbox")))
  (let ((__function__ 'smtp-cst-mailbox-conc))
    (declare (ignorable __function__))
    (tree-nonleaf->branches cst)))

Theorem: tree-list-listp-of-smtp-cst-mailbox-conc

(defthm tree-list-listp-of-smtp-cst-mailbox-conc
  (b* ((cstss (smtp-cst-mailbox-conc cst)))
    (tree-list-listp cstss))
  :rule-classes :rewrite)

Theorem: smtp-cst-mailbox-conc-match

(defthm smtp-cst-mailbox-conc-match
  (implies (smtp-cst-matchp cst "mailbox")
           (b* ((cstss (smtp-cst-mailbox-conc cst)))
             (smtp-cst-list-list-conc-matchp
                  cstss
                  "local-part \"@\" ( domain / address-literal )")))
  :rule-classes :rewrite)

Theorem: smtp-cst-mailbox-conc-of-tree-fix-cst

(defthm smtp-cst-mailbox-conc-of-tree-fix-cst
  (equal (smtp-cst-mailbox-conc (tree-fix cst))
         (smtp-cst-mailbox-conc cst)))

Theorem: smtp-cst-mailbox-conc-tree-equiv-congruence-on-cst

(defthm smtp-cst-mailbox-conc-tree-equiv-congruence-on-cst
  (implies (tree-equiv cst cst-equiv)
           (equal (smtp-cst-mailbox-conc cst)
                  (smtp-cst-mailbox-conc cst-equiv)))
  :rule-classes :congruence)

Function: smtp-cst-local-part-conc1

(defun smtp-cst-local-part-conc1 (cst)
  (declare (xargs :guard (treep cst)))
  (declare (xargs :guard (and (smtp-cst-matchp cst "local-part")
                              (equal (smtp-cst-local-part-conc? cst)
                                     1))))
  (let ((__function__ 'smtp-cst-local-part-conc1))
    (declare (ignorable __function__))
    (tree-nonleaf->branches cst)))

Theorem: tree-list-listp-of-smtp-cst-local-part-conc1

(defthm tree-list-listp-of-smtp-cst-local-part-conc1
  (b* ((cstss (smtp-cst-local-part-conc1 cst)))
    (tree-list-listp cstss))
  :rule-classes :rewrite)

Theorem: smtp-cst-local-part-conc1-match

(defthm smtp-cst-local-part-conc1-match
  (implies (and (smtp-cst-matchp cst "local-part")
                (equal (smtp-cst-local-part-conc? cst)
                       1))
           (b* ((cstss (smtp-cst-local-part-conc1 cst)))
             (smtp-cst-list-list-conc-matchp cstss "dot-string")))
  :rule-classes :rewrite)

Theorem: smtp-cst-local-part-conc1-of-tree-fix-cst

(defthm smtp-cst-local-part-conc1-of-tree-fix-cst
  (equal (smtp-cst-local-part-conc1 (tree-fix cst))
         (smtp-cst-local-part-conc1 cst)))

Theorem: smtp-cst-local-part-conc1-tree-equiv-congruence-on-cst

(defthm smtp-cst-local-part-conc1-tree-equiv-congruence-on-cst
  (implies (tree-equiv cst cst-equiv)
           (equal (smtp-cst-local-part-conc1 cst)
                  (smtp-cst-local-part-conc1 cst-equiv)))
  :rule-classes :congruence)

Function: smtp-cst-local-part-conc2

(defun smtp-cst-local-part-conc2 (cst)
  (declare (xargs :guard (treep cst)))
  (declare (xargs :guard (and (smtp-cst-matchp cst "local-part")
                              (equal (smtp-cst-local-part-conc? cst)
                                     2))))
  (let ((__function__ 'smtp-cst-local-part-conc2))
    (declare (ignorable __function__))
    (tree-nonleaf->branches cst)))

Theorem: tree-list-listp-of-smtp-cst-local-part-conc2

(defthm tree-list-listp-of-smtp-cst-local-part-conc2
  (b* ((cstss (smtp-cst-local-part-conc2 cst)))
    (tree-list-listp cstss))
  :rule-classes :rewrite)

Theorem: smtp-cst-local-part-conc2-match

(defthm smtp-cst-local-part-conc2-match
 (implies (and (smtp-cst-matchp cst "local-part")
               (equal (smtp-cst-local-part-conc? cst)
                      2))
          (b* ((cstss (smtp-cst-local-part-conc2 cst)))
            (smtp-cst-list-list-conc-matchp cstss "quoted-string")))
 :rule-classes :rewrite)

Theorem: smtp-cst-local-part-conc2-of-tree-fix-cst

(defthm smtp-cst-local-part-conc2-of-tree-fix-cst
  (equal (smtp-cst-local-part-conc2 (tree-fix cst))
         (smtp-cst-local-part-conc2 cst)))

Theorem: smtp-cst-local-part-conc2-tree-equiv-congruence-on-cst

(defthm smtp-cst-local-part-conc2-tree-equiv-congruence-on-cst
  (implies (tree-equiv cst cst-equiv)
           (equal (smtp-cst-local-part-conc2 cst)
                  (smtp-cst-local-part-conc2 cst-equiv)))
  :rule-classes :congruence)

Function: smtp-cst-dot-string-conc

(defun smtp-cst-dot-string-conc (cst)
  (declare (xargs :guard (treep cst)))
  (declare (xargs :guard (smtp-cst-matchp cst "dot-string")))
  (let ((__function__ 'smtp-cst-dot-string-conc))
    (declare (ignorable __function__))
    (tree-nonleaf->branches cst)))

Theorem: tree-list-listp-of-smtp-cst-dot-string-conc

(defthm tree-list-listp-of-smtp-cst-dot-string-conc
  (b* ((cstss (smtp-cst-dot-string-conc cst)))
    (tree-list-listp cstss))
  :rule-classes :rewrite)

Theorem: smtp-cst-dot-string-conc-match

(defthm smtp-cst-dot-string-conc-match
 (implies
     (smtp-cst-matchp cst "dot-string")
     (b* ((cstss (smtp-cst-dot-string-conc cst)))
       (smtp-cst-list-list-conc-matchp cstss "atom *( \".\" atom )")))
 :rule-classes :rewrite)

Theorem: smtp-cst-dot-string-conc-of-tree-fix-cst

(defthm smtp-cst-dot-string-conc-of-tree-fix-cst
  (equal (smtp-cst-dot-string-conc (tree-fix cst))
         (smtp-cst-dot-string-conc cst)))

Theorem: smtp-cst-dot-string-conc-tree-equiv-congruence-on-cst

(defthm smtp-cst-dot-string-conc-tree-equiv-congruence-on-cst
  (implies (tree-equiv cst cst-equiv)
           (equal (smtp-cst-dot-string-conc cst)
                  (smtp-cst-dot-string-conc cst-equiv)))
  :rule-classes :congruence)

Function: smtp-cst-atom-conc

(defun smtp-cst-atom-conc (cst)
  (declare (xargs :guard (treep cst)))
  (declare (xargs :guard (smtp-cst-matchp cst "atom")))
  (let ((__function__ 'smtp-cst-atom-conc))
    (declare (ignorable __function__))
    (tree-nonleaf->branches cst)))

Theorem: tree-list-listp-of-smtp-cst-atom-conc

(defthm tree-list-listp-of-smtp-cst-atom-conc
  (b* ((cstss (smtp-cst-atom-conc cst)))
    (tree-list-listp cstss))
  :rule-classes :rewrite)

Theorem: smtp-cst-atom-conc-match

(defthm smtp-cst-atom-conc-match
  (implies (smtp-cst-matchp cst "atom")
           (b* ((cstss (smtp-cst-atom-conc cst)))
             (smtp-cst-list-list-conc-matchp cstss "1*atext")))
  :rule-classes :rewrite)

Theorem: smtp-cst-atom-conc-of-tree-fix-cst

(defthm smtp-cst-atom-conc-of-tree-fix-cst
  (equal (smtp-cst-atom-conc (tree-fix cst))
         (smtp-cst-atom-conc cst)))

Theorem: smtp-cst-atom-conc-tree-equiv-congruence-on-cst

(defthm smtp-cst-atom-conc-tree-equiv-congruence-on-cst
  (implies (tree-equiv cst cst-equiv)
           (equal (smtp-cst-atom-conc cst)
                  (smtp-cst-atom-conc cst-equiv)))
  :rule-classes :congruence)

Function: smtp-cst-quoted-string-conc

(defun smtp-cst-quoted-string-conc (cst)
  (declare (xargs :guard (treep cst)))
  (declare (xargs :guard (smtp-cst-matchp cst "quoted-string")))
  (let ((__function__ 'smtp-cst-quoted-string-conc))
    (declare (ignorable __function__))
    (tree-nonleaf->branches cst)))

Theorem: tree-list-listp-of-smtp-cst-quoted-string-conc

(defthm tree-list-listp-of-smtp-cst-quoted-string-conc
  (b* ((cstss (smtp-cst-quoted-string-conc cst)))
    (tree-list-listp cstss))
  :rule-classes :rewrite)

Theorem: smtp-cst-quoted-string-conc-match

(defthm smtp-cst-quoted-string-conc-match
  (implies (smtp-cst-matchp cst "quoted-string")
           (b* ((cstss (smtp-cst-quoted-string-conc cst)))
             (smtp-cst-list-list-conc-matchp
                  cstss "dquote *qcontentsmtp dquote")))
  :rule-classes :rewrite)

Theorem: smtp-cst-quoted-string-conc-of-tree-fix-cst

(defthm smtp-cst-quoted-string-conc-of-tree-fix-cst
  (equal (smtp-cst-quoted-string-conc (tree-fix cst))
         (smtp-cst-quoted-string-conc cst)))

Theorem: smtp-cst-quoted-string-conc-tree-equiv-congruence-on-cst

(defthm smtp-cst-quoted-string-conc-tree-equiv-congruence-on-cst
  (implies (tree-equiv cst cst-equiv)
           (equal (smtp-cst-quoted-string-conc cst)
                  (smtp-cst-quoted-string-conc cst-equiv)))
  :rule-classes :congruence)

Function: smtp-cst-qcontentsmtp-conc1

(defun smtp-cst-qcontentsmtp-conc1 (cst)
  (declare (xargs :guard (treep cst)))
  (declare
       (xargs :guard (and (smtp-cst-matchp cst "qcontentsmtp")
                          (equal (smtp-cst-qcontentsmtp-conc? cst)
                                 1))))
  (let ((__function__ 'smtp-cst-qcontentsmtp-conc1))
    (declare (ignorable __function__))
    (tree-nonleaf->branches cst)))

Theorem: tree-list-listp-of-smtp-cst-qcontentsmtp-conc1

(defthm tree-list-listp-of-smtp-cst-qcontentsmtp-conc1
  (b* ((cstss (smtp-cst-qcontentsmtp-conc1 cst)))
    (tree-list-listp cstss))
  :rule-classes :rewrite)

Theorem: smtp-cst-qcontentsmtp-conc1-match

(defthm smtp-cst-qcontentsmtp-conc1-match
  (implies (and (smtp-cst-matchp cst "qcontentsmtp")
                (equal (smtp-cst-qcontentsmtp-conc? cst)
                       1))
           (b* ((cstss (smtp-cst-qcontentsmtp-conc1 cst)))
             (smtp-cst-list-list-conc-matchp cstss "qtextsmtp")))
  :rule-classes :rewrite)

Theorem: smtp-cst-qcontentsmtp-conc1-of-tree-fix-cst

(defthm smtp-cst-qcontentsmtp-conc1-of-tree-fix-cst
  (equal (smtp-cst-qcontentsmtp-conc1 (tree-fix cst))
         (smtp-cst-qcontentsmtp-conc1 cst)))

Theorem: smtp-cst-qcontentsmtp-conc1-tree-equiv-congruence-on-cst

(defthm smtp-cst-qcontentsmtp-conc1-tree-equiv-congruence-on-cst
  (implies (tree-equiv cst cst-equiv)
           (equal (smtp-cst-qcontentsmtp-conc1 cst)
                  (smtp-cst-qcontentsmtp-conc1 cst-equiv)))
  :rule-classes :congruence)

Function: smtp-cst-qcontentsmtp-conc2

(defun smtp-cst-qcontentsmtp-conc2 (cst)
  (declare (xargs :guard (treep cst)))
  (declare
       (xargs :guard (and (smtp-cst-matchp cst "qcontentsmtp")
                          (equal (smtp-cst-qcontentsmtp-conc? cst)
                                 2))))
  (let ((__function__ 'smtp-cst-qcontentsmtp-conc2))
    (declare (ignorable __function__))
    (tree-nonleaf->branches cst)))

Theorem: tree-list-listp-of-smtp-cst-qcontentsmtp-conc2

(defthm tree-list-listp-of-smtp-cst-qcontentsmtp-conc2
  (b* ((cstss (smtp-cst-qcontentsmtp-conc2 cst)))
    (tree-list-listp cstss))
  :rule-classes :rewrite)

Theorem: smtp-cst-qcontentsmtp-conc2-match

(defthm smtp-cst-qcontentsmtp-conc2-match
  (implies
       (and (smtp-cst-matchp cst "qcontentsmtp")
            (equal (smtp-cst-qcontentsmtp-conc? cst)
                   2))
       (b* ((cstss (smtp-cst-qcontentsmtp-conc2 cst)))
         (smtp-cst-list-list-conc-matchp cstss "quoted-pairsmtp")))
  :rule-classes :rewrite)

Theorem: smtp-cst-qcontentsmtp-conc2-of-tree-fix-cst

(defthm smtp-cst-qcontentsmtp-conc2-of-tree-fix-cst
  (equal (smtp-cst-qcontentsmtp-conc2 (tree-fix cst))
         (smtp-cst-qcontentsmtp-conc2 cst)))

Theorem: smtp-cst-qcontentsmtp-conc2-tree-equiv-congruence-on-cst

(defthm smtp-cst-qcontentsmtp-conc2-tree-equiv-congruence-on-cst
  (implies (tree-equiv cst cst-equiv)
           (equal (smtp-cst-qcontentsmtp-conc2 cst)
                  (smtp-cst-qcontentsmtp-conc2 cst-equiv)))
  :rule-classes :congruence)

Function: smtp-cst-quoted-pairsmtp-conc

(defun smtp-cst-quoted-pairsmtp-conc (cst)
  (declare (xargs :guard (treep cst)))
  (declare (xargs :guard (smtp-cst-matchp cst "quoted-pairsmtp")))
  (let ((__function__ 'smtp-cst-quoted-pairsmtp-conc))
    (declare (ignorable __function__))
    (tree-nonleaf->branches cst)))

Theorem: tree-list-listp-of-smtp-cst-quoted-pairsmtp-conc

(defthm tree-list-listp-of-smtp-cst-quoted-pairsmtp-conc
  (b* ((cstss (smtp-cst-quoted-pairsmtp-conc cst)))
    (tree-list-listp cstss))
  :rule-classes :rewrite)

Theorem: smtp-cst-quoted-pairsmtp-conc-match

(defthm smtp-cst-quoted-pairsmtp-conc-match
 (implies (smtp-cst-matchp cst "quoted-pairsmtp")
          (b* ((cstss (smtp-cst-quoted-pairsmtp-conc cst)))
            (smtp-cst-list-list-conc-matchp cstss "%d92 %d32-126")))
 :rule-classes :rewrite)

Theorem: smtp-cst-quoted-pairsmtp-conc-of-tree-fix-cst

(defthm smtp-cst-quoted-pairsmtp-conc-of-tree-fix-cst
  (equal (smtp-cst-quoted-pairsmtp-conc (tree-fix cst))
         (smtp-cst-quoted-pairsmtp-conc cst)))

Theorem: smtp-cst-quoted-pairsmtp-conc-tree-equiv-congruence-on-cst

(defthm smtp-cst-quoted-pairsmtp-conc-tree-equiv-congruence-on-cst
  (implies (tree-equiv cst cst-equiv)
           (equal (smtp-cst-quoted-pairsmtp-conc cst)
                  (smtp-cst-quoted-pairsmtp-conc cst-equiv)))
  :rule-classes :congruence)

Function: smtp-cst-string-conc1

(defun smtp-cst-string-conc1 (cst)
  (declare (xargs :guard (treep cst)))
  (declare
       (xargs :guard (and (smtp-cst-matchp cst "string")
                          (equal (smtp-cst-string-conc? cst) 1))))
  (let ((__function__ 'smtp-cst-string-conc1))
    (declare (ignorable __function__))
    (tree-nonleaf->branches cst)))

Theorem: tree-list-listp-of-smtp-cst-string-conc1

(defthm tree-list-listp-of-smtp-cst-string-conc1
  (b* ((cstss (smtp-cst-string-conc1 cst)))
    (tree-list-listp cstss))
  :rule-classes :rewrite)

Theorem: smtp-cst-string-conc1-match

(defthm smtp-cst-string-conc1-match
  (implies (and (smtp-cst-matchp cst "string")
                (equal (smtp-cst-string-conc? cst) 1))
           (b* ((cstss (smtp-cst-string-conc1 cst)))
             (smtp-cst-list-list-conc-matchp cstss "atom")))
  :rule-classes :rewrite)

Theorem: smtp-cst-string-conc1-of-tree-fix-cst

(defthm smtp-cst-string-conc1-of-tree-fix-cst
  (equal (smtp-cst-string-conc1 (tree-fix cst))
         (smtp-cst-string-conc1 cst)))

Theorem: smtp-cst-string-conc1-tree-equiv-congruence-on-cst

(defthm smtp-cst-string-conc1-tree-equiv-congruence-on-cst
  (implies (tree-equiv cst cst-equiv)
           (equal (smtp-cst-string-conc1 cst)
                  (smtp-cst-string-conc1 cst-equiv)))
  :rule-classes :congruence)

Function: smtp-cst-string-conc2

(defun smtp-cst-string-conc2 (cst)
  (declare (xargs :guard (treep cst)))
  (declare
       (xargs :guard (and (smtp-cst-matchp cst "string")
                          (equal (smtp-cst-string-conc? cst) 2))))
  (let ((__function__ 'smtp-cst-string-conc2))
    (declare (ignorable __function__))
    (tree-nonleaf->branches cst)))

Theorem: tree-list-listp-of-smtp-cst-string-conc2

(defthm tree-list-listp-of-smtp-cst-string-conc2
  (b* ((cstss (smtp-cst-string-conc2 cst)))
    (tree-list-listp cstss))
  :rule-classes :rewrite)

Theorem: smtp-cst-string-conc2-match

(defthm smtp-cst-string-conc2-match
 (implies (and (smtp-cst-matchp cst "string")
               (equal (smtp-cst-string-conc? cst) 2))
          (b* ((cstss (smtp-cst-string-conc2 cst)))
            (smtp-cst-list-list-conc-matchp cstss "quoted-string")))
 :rule-classes :rewrite)

Theorem: smtp-cst-string-conc2-of-tree-fix-cst

(defthm smtp-cst-string-conc2-of-tree-fix-cst
  (equal (smtp-cst-string-conc2 (tree-fix cst))
         (smtp-cst-string-conc2 cst)))

Theorem: smtp-cst-string-conc2-tree-equiv-congruence-on-cst

(defthm smtp-cst-string-conc2-tree-equiv-congruence-on-cst
  (implies (tree-equiv cst cst-equiv)
           (equal (smtp-cst-string-conc2 cst)
                  (smtp-cst-string-conc2 cst-equiv)))
  :rule-classes :congruence)

Function: smtp-cst-ipv4-address-literal-conc

(defun smtp-cst-ipv4-address-literal-conc (cst)
  (declare (xargs :guard (treep cst)))
  (declare
       (xargs :guard (smtp-cst-matchp cst "ipv4-address-literal")))
  (let ((__function__ 'smtp-cst-ipv4-address-literal-conc))
    (declare (ignorable __function__))
    (tree-nonleaf->branches cst)))

Theorem: tree-list-listp-of-smtp-cst-ipv4-address-literal-conc

(defthm tree-list-listp-of-smtp-cst-ipv4-address-literal-conc
  (b* ((cstss (smtp-cst-ipv4-address-literal-conc cst)))
    (tree-list-listp cstss))
  :rule-classes :rewrite)

Theorem: smtp-cst-ipv4-address-literal-conc-match

(defthm smtp-cst-ipv4-address-literal-conc-match
 (implies
     (smtp-cst-matchp cst "ipv4-address-literal")
     (b* ((cstss (smtp-cst-ipv4-address-literal-conc cst)))
       (smtp-cst-list-list-conc-matchp cstss "snum 3( \".\" snum )")))
 :rule-classes :rewrite)

Theorem: smtp-cst-ipv4-address-literal-conc-of-tree-fix-cst

(defthm smtp-cst-ipv4-address-literal-conc-of-tree-fix-cst
  (equal (smtp-cst-ipv4-address-literal-conc (tree-fix cst))
         (smtp-cst-ipv4-address-literal-conc cst)))

Theorem: smtp-cst-ipv4-address-literal-conc-tree-equiv-congruence-on-cst

(defthm
    smtp-cst-ipv4-address-literal-conc-tree-equiv-congruence-on-cst
  (implies (tree-equiv cst cst-equiv)
           (equal (smtp-cst-ipv4-address-literal-conc cst)
                  (smtp-cst-ipv4-address-literal-conc cst-equiv)))
  :rule-classes :congruence)

Function: smtp-cst-ipv6-address-literal-conc

(defun smtp-cst-ipv6-address-literal-conc (cst)
  (declare (xargs :guard (treep cst)))
  (declare
       (xargs :guard (smtp-cst-matchp cst "ipv6-address-literal")))
  (let ((__function__ 'smtp-cst-ipv6-address-literal-conc))
    (declare (ignorable __function__))
    (tree-nonleaf->branches cst)))

Theorem: tree-list-listp-of-smtp-cst-ipv6-address-literal-conc

(defthm tree-list-listp-of-smtp-cst-ipv6-address-literal-conc
  (b* ((cstss (smtp-cst-ipv6-address-literal-conc cst)))
    (tree-list-listp cstss))
  :rule-classes :rewrite)

Theorem: smtp-cst-ipv6-address-literal-conc-match

(defthm smtp-cst-ipv6-address-literal-conc-match
 (implies
      (smtp-cst-matchp cst "ipv6-address-literal")
      (b* ((cstss (smtp-cst-ipv6-address-literal-conc cst)))
        (smtp-cst-list-list-conc-matchp cstss "\"IPv6:\" ipv6-addr")))
 :rule-classes :rewrite)

Theorem: smtp-cst-ipv6-address-literal-conc-of-tree-fix-cst

(defthm smtp-cst-ipv6-address-literal-conc-of-tree-fix-cst
  (equal (smtp-cst-ipv6-address-literal-conc (tree-fix cst))
         (smtp-cst-ipv6-address-literal-conc cst)))

Theorem: smtp-cst-ipv6-address-literal-conc-tree-equiv-congruence-on-cst

(defthm
    smtp-cst-ipv6-address-literal-conc-tree-equiv-congruence-on-cst
  (implies (tree-equiv cst cst-equiv)
           (equal (smtp-cst-ipv6-address-literal-conc cst)
                  (smtp-cst-ipv6-address-literal-conc cst-equiv)))
  :rule-classes :congruence)

Function: smtp-cst-general-address-literal-conc

(defun smtp-cst-general-address-literal-conc (cst)
 (declare (xargs :guard (treep cst)))
 (declare
     (xargs :guard (smtp-cst-matchp cst "general-address-literal")))
 (let ((__function__ 'smtp-cst-general-address-literal-conc))
   (declare (ignorable __function__))
   (tree-nonleaf->branches cst)))

Theorem: tree-list-listp-of-smtp-cst-general-address-literal-conc

(defthm tree-list-listp-of-smtp-cst-general-address-literal-conc
  (b* ((cstss (smtp-cst-general-address-literal-conc cst)))
    (tree-list-listp cstss))
  :rule-classes :rewrite)

Theorem: smtp-cst-general-address-literal-conc-match

(defthm smtp-cst-general-address-literal-conc-match
  (implies (smtp-cst-matchp cst "general-address-literal")
           (b* ((cstss (smtp-cst-general-address-literal-conc cst)))
             (smtp-cst-list-list-conc-matchp
                  cstss
                  "standardized-tag \":\" 1*dcontent")))
  :rule-classes :rewrite)

Theorem: smtp-cst-general-address-literal-conc-of-tree-fix-cst

(defthm smtp-cst-general-address-literal-conc-of-tree-fix-cst
  (equal (smtp-cst-general-address-literal-conc (tree-fix cst))
         (smtp-cst-general-address-literal-conc cst)))

Theorem: smtp-cst-general-address-literal-conc-tree-equiv-congruence-on-cst

(defthm
 smtp-cst-general-address-literal-conc-tree-equiv-congruence-on-cst
 (implies (tree-equiv cst cst-equiv)
          (equal (smtp-cst-general-address-literal-conc cst)
                 (smtp-cst-general-address-literal-conc cst-equiv)))
 :rule-classes :congruence)

Function: smtp-cst-standardized-tag-conc

(defun smtp-cst-standardized-tag-conc (cst)
  (declare (xargs :guard (treep cst)))
  (declare (xargs :guard (smtp-cst-matchp cst "standardized-tag")))
  (let ((__function__ 'smtp-cst-standardized-tag-conc))
    (declare (ignorable __function__))
    (tree-nonleaf->branches cst)))

Theorem: tree-list-listp-of-smtp-cst-standardized-tag-conc

(defthm tree-list-listp-of-smtp-cst-standardized-tag-conc
  (b* ((cstss (smtp-cst-standardized-tag-conc cst)))
    (tree-list-listp cstss))
  :rule-classes :rewrite)

Theorem: smtp-cst-standardized-tag-conc-match

(defthm smtp-cst-standardized-tag-conc-match
  (implies (smtp-cst-matchp cst "standardized-tag")
           (b* ((cstss (smtp-cst-standardized-tag-conc cst)))
             (smtp-cst-list-list-conc-matchp cstss "ldh-str")))
  :rule-classes :rewrite)

Theorem: smtp-cst-standardized-tag-conc-of-tree-fix-cst

(defthm smtp-cst-standardized-tag-conc-of-tree-fix-cst
  (equal (smtp-cst-standardized-tag-conc (tree-fix cst))
         (smtp-cst-standardized-tag-conc cst)))

Theorem: smtp-cst-standardized-tag-conc-tree-equiv-congruence-on-cst

(defthm smtp-cst-standardized-tag-conc-tree-equiv-congruence-on-cst
  (implies (tree-equiv cst cst-equiv)
           (equal (smtp-cst-standardized-tag-conc cst)
                  (smtp-cst-standardized-tag-conc cst-equiv)))
  :rule-classes :congruence)

Function: smtp-cst-snum-conc

(defun smtp-cst-snum-conc (cst)
  (declare (xargs :guard (treep cst)))
  (declare (xargs :guard (smtp-cst-matchp cst "snum")))
  (let ((__function__ 'smtp-cst-snum-conc))
    (declare (ignorable __function__))
    (tree-nonleaf->branches cst)))

Theorem: tree-list-listp-of-smtp-cst-snum-conc

(defthm tree-list-listp-of-smtp-cst-snum-conc
  (b* ((cstss (smtp-cst-snum-conc cst)))
    (tree-list-listp cstss))
  :rule-classes :rewrite)

Theorem: smtp-cst-snum-conc-match

(defthm smtp-cst-snum-conc-match
  (implies (smtp-cst-matchp cst "snum")
           (b* ((cstss (smtp-cst-snum-conc cst)))
             (smtp-cst-list-list-conc-matchp cstss "1*3digit")))
  :rule-classes :rewrite)

Theorem: smtp-cst-snum-conc-of-tree-fix-cst

(defthm smtp-cst-snum-conc-of-tree-fix-cst
  (equal (smtp-cst-snum-conc (tree-fix cst))
         (smtp-cst-snum-conc cst)))

Theorem: smtp-cst-snum-conc-tree-equiv-congruence-on-cst

(defthm smtp-cst-snum-conc-tree-equiv-congruence-on-cst
  (implies (tree-equiv cst cst-equiv)
           (equal (smtp-cst-snum-conc cst)
                  (smtp-cst-snum-conc cst-equiv)))
  :rule-classes :congruence)

Function: smtp-cst-ipv6-addr-conc1

(defun smtp-cst-ipv6-addr-conc1 (cst)
  (declare (xargs :guard (treep cst)))
  (declare (xargs :guard (and (smtp-cst-matchp cst "ipv6-addr")
                              (equal (smtp-cst-ipv6-addr-conc? cst)
                                     1))))
  (let ((__function__ 'smtp-cst-ipv6-addr-conc1))
    (declare (ignorable __function__))
    (tree-nonleaf->branches cst)))

Theorem: tree-list-listp-of-smtp-cst-ipv6-addr-conc1

(defthm tree-list-listp-of-smtp-cst-ipv6-addr-conc1
  (b* ((cstss (smtp-cst-ipv6-addr-conc1 cst)))
    (tree-list-listp cstss))
  :rule-classes :rewrite)

Theorem: smtp-cst-ipv6-addr-conc1-match

(defthm smtp-cst-ipv6-addr-conc1-match
  (implies (and (smtp-cst-matchp cst "ipv6-addr")
                (equal (smtp-cst-ipv6-addr-conc? cst)
                       1))
           (b* ((cstss (smtp-cst-ipv6-addr-conc1 cst)))
             (smtp-cst-list-list-conc-matchp cstss "ipv6-full")))
  :rule-classes :rewrite)

Theorem: smtp-cst-ipv6-addr-conc1-of-tree-fix-cst

(defthm smtp-cst-ipv6-addr-conc1-of-tree-fix-cst
  (equal (smtp-cst-ipv6-addr-conc1 (tree-fix cst))
         (smtp-cst-ipv6-addr-conc1 cst)))

Theorem: smtp-cst-ipv6-addr-conc1-tree-equiv-congruence-on-cst

(defthm smtp-cst-ipv6-addr-conc1-tree-equiv-congruence-on-cst
  (implies (tree-equiv cst cst-equiv)
           (equal (smtp-cst-ipv6-addr-conc1 cst)
                  (smtp-cst-ipv6-addr-conc1 cst-equiv)))
  :rule-classes :congruence)

Function: smtp-cst-ipv6-addr-conc2

(defun smtp-cst-ipv6-addr-conc2 (cst)
  (declare (xargs :guard (treep cst)))
  (declare (xargs :guard (and (smtp-cst-matchp cst "ipv6-addr")
                              (equal (smtp-cst-ipv6-addr-conc? cst)
                                     2))))
  (let ((__function__ 'smtp-cst-ipv6-addr-conc2))
    (declare (ignorable __function__))
    (tree-nonleaf->branches cst)))

Theorem: tree-list-listp-of-smtp-cst-ipv6-addr-conc2

(defthm tree-list-listp-of-smtp-cst-ipv6-addr-conc2
  (b* ((cstss (smtp-cst-ipv6-addr-conc2 cst)))
    (tree-list-listp cstss))
  :rule-classes :rewrite)

Theorem: smtp-cst-ipv6-addr-conc2-match

(defthm smtp-cst-ipv6-addr-conc2-match
  (implies (and (smtp-cst-matchp cst "ipv6-addr")
                (equal (smtp-cst-ipv6-addr-conc? cst)
                       2))
           (b* ((cstss (smtp-cst-ipv6-addr-conc2 cst)))
             (smtp-cst-list-list-conc-matchp cstss "ipv6-comp")))
  :rule-classes :rewrite)

Theorem: smtp-cst-ipv6-addr-conc2-of-tree-fix-cst

(defthm smtp-cst-ipv6-addr-conc2-of-tree-fix-cst
  (equal (smtp-cst-ipv6-addr-conc2 (tree-fix cst))
         (smtp-cst-ipv6-addr-conc2 cst)))

Theorem: smtp-cst-ipv6-addr-conc2-tree-equiv-congruence-on-cst

(defthm smtp-cst-ipv6-addr-conc2-tree-equiv-congruence-on-cst
  (implies (tree-equiv cst cst-equiv)
           (equal (smtp-cst-ipv6-addr-conc2 cst)
                  (smtp-cst-ipv6-addr-conc2 cst-equiv)))
  :rule-classes :congruence)

Function: smtp-cst-ipv6-addr-conc3

(defun smtp-cst-ipv6-addr-conc3 (cst)
  (declare (xargs :guard (treep cst)))
  (declare (xargs :guard (and (smtp-cst-matchp cst "ipv6-addr")
                              (equal (smtp-cst-ipv6-addr-conc? cst)
                                     3))))
  (let ((__function__ 'smtp-cst-ipv6-addr-conc3))
    (declare (ignorable __function__))
    (tree-nonleaf->branches cst)))

Theorem: tree-list-listp-of-smtp-cst-ipv6-addr-conc3

(defthm tree-list-listp-of-smtp-cst-ipv6-addr-conc3
  (b* ((cstss (smtp-cst-ipv6-addr-conc3 cst)))
    (tree-list-listp cstss))
  :rule-classes :rewrite)

Theorem: smtp-cst-ipv6-addr-conc3-match

(defthm smtp-cst-ipv6-addr-conc3-match
  (implies (and (smtp-cst-matchp cst "ipv6-addr")
                (equal (smtp-cst-ipv6-addr-conc? cst)
                       3))
           (b* ((cstss (smtp-cst-ipv6-addr-conc3 cst)))
             (smtp-cst-list-list-conc-matchp cstss "ipv6v4-full")))
  :rule-classes :rewrite)

Theorem: smtp-cst-ipv6-addr-conc3-of-tree-fix-cst

(defthm smtp-cst-ipv6-addr-conc3-of-tree-fix-cst
  (equal (smtp-cst-ipv6-addr-conc3 (tree-fix cst))
         (smtp-cst-ipv6-addr-conc3 cst)))

Theorem: smtp-cst-ipv6-addr-conc3-tree-equiv-congruence-on-cst

(defthm smtp-cst-ipv6-addr-conc3-tree-equiv-congruence-on-cst
  (implies (tree-equiv cst cst-equiv)
           (equal (smtp-cst-ipv6-addr-conc3 cst)
                  (smtp-cst-ipv6-addr-conc3 cst-equiv)))
  :rule-classes :congruence)

Function: smtp-cst-ipv6-addr-conc4

(defun smtp-cst-ipv6-addr-conc4 (cst)
  (declare (xargs :guard (treep cst)))
  (declare (xargs :guard (and (smtp-cst-matchp cst "ipv6-addr")
                              (equal (smtp-cst-ipv6-addr-conc? cst)
                                     4))))
  (let ((__function__ 'smtp-cst-ipv6-addr-conc4))
    (declare (ignorable __function__))
    (tree-nonleaf->branches cst)))

Theorem: tree-list-listp-of-smtp-cst-ipv6-addr-conc4

(defthm tree-list-listp-of-smtp-cst-ipv6-addr-conc4
  (b* ((cstss (smtp-cst-ipv6-addr-conc4 cst)))
    (tree-list-listp cstss))
  :rule-classes :rewrite)

Theorem: smtp-cst-ipv6-addr-conc4-match

(defthm smtp-cst-ipv6-addr-conc4-match
  (implies (and (smtp-cst-matchp cst "ipv6-addr")
                (equal (smtp-cst-ipv6-addr-conc? cst)
                       4))
           (b* ((cstss (smtp-cst-ipv6-addr-conc4 cst)))
             (smtp-cst-list-list-conc-matchp cstss "ipv6v4-comp")))
  :rule-classes :rewrite)

Theorem: smtp-cst-ipv6-addr-conc4-of-tree-fix-cst

(defthm smtp-cst-ipv6-addr-conc4-of-tree-fix-cst
  (equal (smtp-cst-ipv6-addr-conc4 (tree-fix cst))
         (smtp-cst-ipv6-addr-conc4 cst)))

Theorem: smtp-cst-ipv6-addr-conc4-tree-equiv-congruence-on-cst

(defthm smtp-cst-ipv6-addr-conc4-tree-equiv-congruence-on-cst
  (implies (tree-equiv cst cst-equiv)
           (equal (smtp-cst-ipv6-addr-conc4 cst)
                  (smtp-cst-ipv6-addr-conc4 cst-equiv)))
  :rule-classes :congruence)

Function: smtp-cst-ipv6-hex-conc

(defun smtp-cst-ipv6-hex-conc (cst)
  (declare (xargs :guard (treep cst)))
  (declare (xargs :guard (smtp-cst-matchp cst "ipv6-hex")))
  (let ((__function__ 'smtp-cst-ipv6-hex-conc))
    (declare (ignorable __function__))
    (tree-nonleaf->branches cst)))

Theorem: tree-list-listp-of-smtp-cst-ipv6-hex-conc

(defthm tree-list-listp-of-smtp-cst-ipv6-hex-conc
  (b* ((cstss (smtp-cst-ipv6-hex-conc cst)))
    (tree-list-listp cstss))
  :rule-classes :rewrite)

Theorem: smtp-cst-ipv6-hex-conc-match

(defthm smtp-cst-ipv6-hex-conc-match
  (implies (smtp-cst-matchp cst "ipv6-hex")
           (b* ((cstss (smtp-cst-ipv6-hex-conc cst)))
             (smtp-cst-list-list-conc-matchp cstss "1*4hexdig")))
  :rule-classes :rewrite)

Theorem: smtp-cst-ipv6-hex-conc-of-tree-fix-cst

(defthm smtp-cst-ipv6-hex-conc-of-tree-fix-cst
  (equal (smtp-cst-ipv6-hex-conc (tree-fix cst))
         (smtp-cst-ipv6-hex-conc cst)))

Theorem: smtp-cst-ipv6-hex-conc-tree-equiv-congruence-on-cst

(defthm smtp-cst-ipv6-hex-conc-tree-equiv-congruence-on-cst
  (implies (tree-equiv cst cst-equiv)
           (equal (smtp-cst-ipv6-hex-conc cst)
                  (smtp-cst-ipv6-hex-conc cst-equiv)))
  :rule-classes :congruence)

Function: smtp-cst-ipv6-full-conc

(defun smtp-cst-ipv6-full-conc (cst)
  (declare (xargs :guard (treep cst)))
  (declare (xargs :guard (smtp-cst-matchp cst "ipv6-full")))
  (let ((__function__ 'smtp-cst-ipv6-full-conc))
    (declare (ignorable __function__))
    (tree-nonleaf->branches cst)))

Theorem: tree-list-listp-of-smtp-cst-ipv6-full-conc

(defthm tree-list-listp-of-smtp-cst-ipv6-full-conc
  (b* ((cstss (smtp-cst-ipv6-full-conc cst)))
    (tree-list-listp cstss))
  :rule-classes :rewrite)

Theorem: smtp-cst-ipv6-full-conc-match

(defthm smtp-cst-ipv6-full-conc-match
  (implies (smtp-cst-matchp cst "ipv6-full")
           (b* ((cstss (smtp-cst-ipv6-full-conc cst)))
             (smtp-cst-list-list-conc-matchp
                  cstss "ipv6-hex 7( \":\" ipv6-hex )")))
  :rule-classes :rewrite)

Theorem: smtp-cst-ipv6-full-conc-of-tree-fix-cst

(defthm smtp-cst-ipv6-full-conc-of-tree-fix-cst
  (equal (smtp-cst-ipv6-full-conc (tree-fix cst))
         (smtp-cst-ipv6-full-conc cst)))

Theorem: smtp-cst-ipv6-full-conc-tree-equiv-congruence-on-cst

(defthm smtp-cst-ipv6-full-conc-tree-equiv-congruence-on-cst
  (implies (tree-equiv cst cst-equiv)
           (equal (smtp-cst-ipv6-full-conc cst)
                  (smtp-cst-ipv6-full-conc cst-equiv)))
  :rule-classes :congruence)

Function: smtp-cst-ipv6-comp-conc

(defun smtp-cst-ipv6-comp-conc (cst)
  (declare (xargs :guard (treep cst)))
  (declare (xargs :guard (smtp-cst-matchp cst "ipv6-comp")))
  (let ((__function__ 'smtp-cst-ipv6-comp-conc))
    (declare (ignorable __function__))
    (tree-nonleaf->branches cst)))

Theorem: tree-list-listp-of-smtp-cst-ipv6-comp-conc

(defthm tree-list-listp-of-smtp-cst-ipv6-comp-conc
  (b* ((cstss (smtp-cst-ipv6-comp-conc cst)))
    (tree-list-listp cstss))
  :rule-classes :rewrite)

Theorem: smtp-cst-ipv6-comp-conc-match

(defthm smtp-cst-ipv6-comp-conc-match
 (implies
  (smtp-cst-matchp cst "ipv6-comp")
  (b* ((cstss (smtp-cst-ipv6-comp-conc cst)))
   (smtp-cst-list-list-conc-matchp
    cstss
    "[ ipv6-hex *5( \":\" ipv6-hex ) ] \"::\" [ ipv6-hex *5( \":\" ipv6-hex ) ]")))
 :rule-classes :rewrite)

Theorem: smtp-cst-ipv6-comp-conc-of-tree-fix-cst

(defthm smtp-cst-ipv6-comp-conc-of-tree-fix-cst
  (equal (smtp-cst-ipv6-comp-conc (tree-fix cst))
         (smtp-cst-ipv6-comp-conc cst)))

Theorem: smtp-cst-ipv6-comp-conc-tree-equiv-congruence-on-cst

(defthm smtp-cst-ipv6-comp-conc-tree-equiv-congruence-on-cst
  (implies (tree-equiv cst cst-equiv)
           (equal (smtp-cst-ipv6-comp-conc cst)
                  (smtp-cst-ipv6-comp-conc cst-equiv)))
  :rule-classes :congruence)

Function: smtp-cst-ipv6v4-full-conc

(defun smtp-cst-ipv6v4-full-conc (cst)
  (declare (xargs :guard (treep cst)))
  (declare (xargs :guard (smtp-cst-matchp cst "ipv6v4-full")))
  (let ((__function__ 'smtp-cst-ipv6v4-full-conc))
    (declare (ignorable __function__))
    (tree-nonleaf->branches cst)))

Theorem: tree-list-listp-of-smtp-cst-ipv6v4-full-conc

(defthm tree-list-listp-of-smtp-cst-ipv6v4-full-conc
  (b* ((cstss (smtp-cst-ipv6v4-full-conc cst)))
    (tree-list-listp cstss))
  :rule-classes :rewrite)

Theorem: smtp-cst-ipv6v4-full-conc-match

(defthm smtp-cst-ipv6v4-full-conc-match
 (implies
     (smtp-cst-matchp cst "ipv6v4-full")
     (b* ((cstss (smtp-cst-ipv6v4-full-conc cst)))
       (smtp-cst-list-list-conc-matchp
            cstss
            "ipv6-hex 5( \":\" ipv6-hex ) \":\" ipv4-address-literal")))
 :rule-classes :rewrite)

Theorem: smtp-cst-ipv6v4-full-conc-of-tree-fix-cst

(defthm smtp-cst-ipv6v4-full-conc-of-tree-fix-cst
  (equal (smtp-cst-ipv6v4-full-conc (tree-fix cst))
         (smtp-cst-ipv6v4-full-conc cst)))

Theorem: smtp-cst-ipv6v4-full-conc-tree-equiv-congruence-on-cst

(defthm smtp-cst-ipv6v4-full-conc-tree-equiv-congruence-on-cst
  (implies (tree-equiv cst cst-equiv)
           (equal (smtp-cst-ipv6v4-full-conc cst)
                  (smtp-cst-ipv6v4-full-conc cst-equiv)))
  :rule-classes :congruence)

Function: smtp-cst-ipv6v4-comp-conc

(defun smtp-cst-ipv6v4-comp-conc (cst)
  (declare (xargs :guard (treep cst)))
  (declare (xargs :guard (smtp-cst-matchp cst "ipv6v4-comp")))
  (let ((__function__ 'smtp-cst-ipv6v4-comp-conc))
    (declare (ignorable __function__))
    (tree-nonleaf->branches cst)))

Theorem: tree-list-listp-of-smtp-cst-ipv6v4-comp-conc

(defthm tree-list-listp-of-smtp-cst-ipv6v4-comp-conc
  (b* ((cstss (smtp-cst-ipv6v4-comp-conc cst)))
    (tree-list-listp cstss))
  :rule-classes :rewrite)

Theorem: smtp-cst-ipv6v4-comp-conc-match

(defthm smtp-cst-ipv6v4-comp-conc-match
 (implies
  (smtp-cst-matchp cst "ipv6v4-comp")
  (b* ((cstss (smtp-cst-ipv6v4-comp-conc cst)))
   (smtp-cst-list-list-conc-matchp
    cstss
    "[ ipv6-hex *3( \":\" ipv6-hex ) ] \"::\" [ ipv6-hex *3( \":\" ipv6-hex ) \":\" ] ipv4-address-literal")))
 :rule-classes :rewrite)

Theorem: smtp-cst-ipv6v4-comp-conc-of-tree-fix-cst

(defthm smtp-cst-ipv6v4-comp-conc-of-tree-fix-cst
  (equal (smtp-cst-ipv6v4-comp-conc (tree-fix cst))
         (smtp-cst-ipv6v4-comp-conc cst)))

Theorem: smtp-cst-ipv6v4-comp-conc-tree-equiv-congruence-on-cst

(defthm smtp-cst-ipv6v4-comp-conc-tree-equiv-congruence-on-cst
  (implies (tree-equiv cst cst-equiv)
           (equal (smtp-cst-ipv6v4-comp-conc cst)
                  (smtp-cst-ipv6v4-comp-conc cst-equiv)))
  :rule-classes :congruence)

Function: smtp-cst-textstring-conc

(defun smtp-cst-textstring-conc (cst)
  (declare (xargs :guard (treep cst)))
  (declare (xargs :guard (smtp-cst-matchp cst "textstring")))
  (let ((__function__ 'smtp-cst-textstring-conc))
    (declare (ignorable __function__))
    (tree-nonleaf->branches cst)))

Theorem: tree-list-listp-of-smtp-cst-textstring-conc

(defthm tree-list-listp-of-smtp-cst-textstring-conc
  (b* ((cstss (smtp-cst-textstring-conc cst)))
    (tree-list-listp cstss))
  :rule-classes :rewrite)

Theorem: smtp-cst-textstring-conc-match

(defthm smtp-cst-textstring-conc-match
 (implies
   (smtp-cst-matchp cst "textstring")
   (b* ((cstss (smtp-cst-textstring-conc cst)))
     (smtp-cst-list-list-conc-matchp cstss "1*( %d9 / %d32-126 )")))
 :rule-classes :rewrite)

Theorem: smtp-cst-textstring-conc-of-tree-fix-cst

(defthm smtp-cst-textstring-conc-of-tree-fix-cst
  (equal (smtp-cst-textstring-conc (tree-fix cst))
         (smtp-cst-textstring-conc cst)))

Theorem: smtp-cst-textstring-conc-tree-equiv-congruence-on-cst

(defthm smtp-cst-textstring-conc-tree-equiv-congruence-on-cst
  (implies (tree-equiv cst cst-equiv)
           (equal (smtp-cst-textstring-conc cst)
                  (smtp-cst-textstring-conc cst-equiv)))
  :rule-classes :congruence)

Function: smtp-cst-reply-line-conc

(defun smtp-cst-reply-line-conc (cst)
  (declare (xargs :guard (treep cst)))
  (declare (xargs :guard (smtp-cst-matchp cst "reply-line")))
  (let ((__function__ 'smtp-cst-reply-line-conc))
    (declare (ignorable __function__))
    (tree-nonleaf->branches cst)))

Theorem: tree-list-listp-of-smtp-cst-reply-line-conc

(defthm tree-list-listp-of-smtp-cst-reply-line-conc
  (b* ((cstss (smtp-cst-reply-line-conc cst)))
    (tree-list-listp cstss))
  :rule-classes :rewrite)

Theorem: smtp-cst-reply-line-conc-match

(defthm smtp-cst-reply-line-conc-match
 (implies
  (smtp-cst-matchp cst "reply-line")
  (b* ((cstss (smtp-cst-reply-line-conc cst)))
   (smtp-cst-list-list-conc-matchp
    cstss
    "*( reply-code \"-\" [ textstring ] crlf ) reply-code [ sp textstring ] crlf")))
 :rule-classes :rewrite)

Theorem: smtp-cst-reply-line-conc-of-tree-fix-cst

(defthm smtp-cst-reply-line-conc-of-tree-fix-cst
  (equal (smtp-cst-reply-line-conc (tree-fix cst))
         (smtp-cst-reply-line-conc cst)))

Theorem: smtp-cst-reply-line-conc-tree-equiv-congruence-on-cst

(defthm smtp-cst-reply-line-conc-tree-equiv-congruence-on-cst
  (implies (tree-equiv cst cst-equiv)
           (equal (smtp-cst-reply-line-conc cst)
                  (smtp-cst-reply-line-conc cst-equiv)))
  :rule-classes :congruence)

Function: smtp-cst-reply-code-conc

(defun smtp-cst-reply-code-conc (cst)
  (declare (xargs :guard (treep cst)))
  (declare (xargs :guard (smtp-cst-matchp cst "reply-code")))
  (let ((__function__ 'smtp-cst-reply-code-conc))
    (declare (ignorable __function__))
    (tree-nonleaf->branches cst)))

Theorem: tree-list-listp-of-smtp-cst-reply-code-conc

(defthm tree-list-listp-of-smtp-cst-reply-code-conc
  (b* ((cstss (smtp-cst-reply-code-conc cst)))
    (tree-list-listp cstss))
  :rule-classes :rewrite)

Theorem: smtp-cst-reply-code-conc-match

(defthm smtp-cst-reply-code-conc-match
  (implies (smtp-cst-matchp cst "reply-code")
           (b* ((cstss (smtp-cst-reply-code-conc cst)))
             (smtp-cst-list-list-conc-matchp
                  cstss "%x32-35 %x30-35 %x30-39")))
  :rule-classes :rewrite)

Theorem: smtp-cst-reply-code-conc-of-tree-fix-cst

(defthm smtp-cst-reply-code-conc-of-tree-fix-cst
  (equal (smtp-cst-reply-code-conc (tree-fix cst))
         (smtp-cst-reply-code-conc cst)))

Theorem: smtp-cst-reply-code-conc-tree-equiv-congruence-on-cst

(defthm smtp-cst-reply-code-conc-tree-equiv-congruence-on-cst
  (implies (tree-equiv cst cst-equiv)
           (equal (smtp-cst-reply-code-conc cst)
                  (smtp-cst-reply-code-conc cst-equiv)))
  :rule-classes :congruence)

Function: smtp-cst-return-path-line-conc

(defun smtp-cst-return-path-line-conc (cst)
  (declare (xargs :guard (treep cst)))
  (declare (xargs :guard (smtp-cst-matchp cst "return-path-line")))
  (let ((__function__ 'smtp-cst-return-path-line-conc))
    (declare (ignorable __function__))
    (tree-nonleaf->branches cst)))

Theorem: tree-list-listp-of-smtp-cst-return-path-line-conc

(defthm tree-list-listp-of-smtp-cst-return-path-line-conc
  (b* ((cstss (smtp-cst-return-path-line-conc cst)))
    (tree-list-listp cstss))
  :rule-classes :rewrite)

Theorem: smtp-cst-return-path-line-conc-match

(defthm smtp-cst-return-path-line-conc-match
  (implies (smtp-cst-matchp cst "return-path-line")
           (b* ((cstss (smtp-cst-return-path-line-conc cst)))
             (smtp-cst-list-list-conc-matchp
                  cstss
                  "\"Return-Path:\" fws reverse-path crlf")))
  :rule-classes :rewrite)

Theorem: smtp-cst-return-path-line-conc-of-tree-fix-cst

(defthm smtp-cst-return-path-line-conc-of-tree-fix-cst
  (equal (smtp-cst-return-path-line-conc (tree-fix cst))
         (smtp-cst-return-path-line-conc cst)))

Theorem: smtp-cst-return-path-line-conc-tree-equiv-congruence-on-cst

(defthm smtp-cst-return-path-line-conc-tree-equiv-congruence-on-cst
  (implies (tree-equiv cst cst-equiv)
           (equal (smtp-cst-return-path-line-conc cst)
                  (smtp-cst-return-path-line-conc cst-equiv)))
  :rule-classes :congruence)

Function: smtp-cst-time-stamp-line-conc

(defun smtp-cst-time-stamp-line-conc (cst)
  (declare (xargs :guard (treep cst)))
  (declare (xargs :guard (smtp-cst-matchp cst "time-stamp-line")))
  (let ((__function__ 'smtp-cst-time-stamp-line-conc))
    (declare (ignorable __function__))
    (tree-nonleaf->branches cst)))

Theorem: tree-list-listp-of-smtp-cst-time-stamp-line-conc

(defthm tree-list-listp-of-smtp-cst-time-stamp-line-conc
  (b* ((cstss (smtp-cst-time-stamp-line-conc cst)))
    (tree-list-listp cstss))
  :rule-classes :rewrite)

Theorem: smtp-cst-time-stamp-line-conc-match

(defthm smtp-cst-time-stamp-line-conc-match
  (implies (smtp-cst-matchp cst "time-stamp-line")
           (b* ((cstss (smtp-cst-time-stamp-line-conc cst)))
             (smtp-cst-list-list-conc-matchp
                  cstss "\"Received:\" fws stamp crlf")))
  :rule-classes :rewrite)

Theorem: smtp-cst-time-stamp-line-conc-of-tree-fix-cst

(defthm smtp-cst-time-stamp-line-conc-of-tree-fix-cst
  (equal (smtp-cst-time-stamp-line-conc (tree-fix cst))
         (smtp-cst-time-stamp-line-conc cst)))

Theorem: smtp-cst-time-stamp-line-conc-tree-equiv-congruence-on-cst

(defthm smtp-cst-time-stamp-line-conc-tree-equiv-congruence-on-cst
  (implies (tree-equiv cst cst-equiv)
           (equal (smtp-cst-time-stamp-line-conc cst)
                  (smtp-cst-time-stamp-line-conc cst-equiv)))
  :rule-classes :congruence)

Function: smtp-cst-stamp-conc

(defun smtp-cst-stamp-conc (cst)
  (declare (xargs :guard (treep cst)))
  (declare (xargs :guard (smtp-cst-matchp cst "stamp")))
  (let ((__function__ 'smtp-cst-stamp-conc))
    (declare (ignorable __function__))
    (tree-nonleaf->branches cst)))

Theorem: tree-list-listp-of-smtp-cst-stamp-conc

(defthm tree-list-listp-of-smtp-cst-stamp-conc
  (b* ((cstss (smtp-cst-stamp-conc cst)))
    (tree-list-listp cstss))
  :rule-classes :rewrite)

Theorem: smtp-cst-stamp-conc-match

(defthm smtp-cst-stamp-conc-match
 (implies
  (smtp-cst-matchp cst "stamp")
  (b* ((cstss (smtp-cst-stamp-conc cst)))
   (smtp-cst-list-list-conc-matchp
      cstss
      "from-domain by-domain opt-info [ cfws ] \";\" fws date-time")))
 :rule-classes :rewrite)

Theorem: smtp-cst-stamp-conc-of-tree-fix-cst

(defthm smtp-cst-stamp-conc-of-tree-fix-cst
  (equal (smtp-cst-stamp-conc (tree-fix cst))
         (smtp-cst-stamp-conc cst)))

Theorem: smtp-cst-stamp-conc-tree-equiv-congruence-on-cst

(defthm smtp-cst-stamp-conc-tree-equiv-congruence-on-cst
  (implies (tree-equiv cst cst-equiv)
           (equal (smtp-cst-stamp-conc cst)
                  (smtp-cst-stamp-conc cst-equiv)))
  :rule-classes :congruence)

Function: smtp-cst-from-domain-conc

(defun smtp-cst-from-domain-conc (cst)
  (declare (xargs :guard (treep cst)))
  (declare (xargs :guard (smtp-cst-matchp cst "from-domain")))
  (let ((__function__ 'smtp-cst-from-domain-conc))
    (declare (ignorable __function__))
    (tree-nonleaf->branches cst)))

Theorem: tree-list-listp-of-smtp-cst-from-domain-conc

(defthm tree-list-listp-of-smtp-cst-from-domain-conc
  (b* ((cstss (smtp-cst-from-domain-conc cst)))
    (tree-list-listp cstss))
  :rule-classes :rewrite)

Theorem: smtp-cst-from-domain-conc-match

(defthm smtp-cst-from-domain-conc-match
  (implies (smtp-cst-matchp cst "from-domain")
           (b* ((cstss (smtp-cst-from-domain-conc cst)))
             (smtp-cst-list-list-conc-matchp
                  cstss "\"FROM\" fws extended-domain")))
  :rule-classes :rewrite)

Theorem: smtp-cst-from-domain-conc-of-tree-fix-cst

(defthm smtp-cst-from-domain-conc-of-tree-fix-cst
  (equal (smtp-cst-from-domain-conc (tree-fix cst))
         (smtp-cst-from-domain-conc cst)))

Theorem: smtp-cst-from-domain-conc-tree-equiv-congruence-on-cst

(defthm smtp-cst-from-domain-conc-tree-equiv-congruence-on-cst
  (implies (tree-equiv cst cst-equiv)
           (equal (smtp-cst-from-domain-conc cst)
                  (smtp-cst-from-domain-conc cst-equiv)))
  :rule-classes :congruence)

Function: smtp-cst-by-domain-conc

(defun smtp-cst-by-domain-conc (cst)
  (declare (xargs :guard (treep cst)))
  (declare (xargs :guard (smtp-cst-matchp cst "by-domain")))
  (let ((__function__ 'smtp-cst-by-domain-conc))
    (declare (ignorable __function__))
    (tree-nonleaf->branches cst)))

Theorem: tree-list-listp-of-smtp-cst-by-domain-conc

(defthm tree-list-listp-of-smtp-cst-by-domain-conc
  (b* ((cstss (smtp-cst-by-domain-conc cst)))
    (tree-list-listp cstss))
  :rule-classes :rewrite)

Theorem: smtp-cst-by-domain-conc-match

(defthm smtp-cst-by-domain-conc-match
  (implies (smtp-cst-matchp cst "by-domain")
           (b* ((cstss (smtp-cst-by-domain-conc cst)))
             (smtp-cst-list-list-conc-matchp
                  cstss "cfws \"BY\" fws extended-domain")))
  :rule-classes :rewrite)

Theorem: smtp-cst-by-domain-conc-of-tree-fix-cst

(defthm smtp-cst-by-domain-conc-of-tree-fix-cst
  (equal (smtp-cst-by-domain-conc (tree-fix cst))
         (smtp-cst-by-domain-conc cst)))

Theorem: smtp-cst-by-domain-conc-tree-equiv-congruence-on-cst

(defthm smtp-cst-by-domain-conc-tree-equiv-congruence-on-cst
  (implies (tree-equiv cst cst-equiv)
           (equal (smtp-cst-by-domain-conc cst)
                  (smtp-cst-by-domain-conc cst-equiv)))
  :rule-classes :congruence)

Function: smtp-cst-opt-info-conc

(defun smtp-cst-opt-info-conc (cst)
  (declare (xargs :guard (treep cst)))
  (declare (xargs :guard (smtp-cst-matchp cst "opt-info")))
  (let ((__function__ 'smtp-cst-opt-info-conc))
    (declare (ignorable __function__))
    (tree-nonleaf->branches cst)))

Theorem: tree-list-listp-of-smtp-cst-opt-info-conc

(defthm tree-list-listp-of-smtp-cst-opt-info-conc
  (b* ((cstss (smtp-cst-opt-info-conc cst)))
    (tree-list-listp cstss))
  :rule-classes :rewrite)

Theorem: smtp-cst-opt-info-conc-match

(defthm smtp-cst-opt-info-conc-match
 (implies
  (smtp-cst-matchp cst "opt-info")
  (b* ((cstss (smtp-cst-opt-info-conc cst)))
   (smtp-cst-list-list-conc-matchp
    cstss
    "[ via ] [ with ] [ id ] [ for ] [ additional-registered-clauses ]")))
 :rule-classes :rewrite)

Theorem: smtp-cst-opt-info-conc-of-tree-fix-cst

(defthm smtp-cst-opt-info-conc-of-tree-fix-cst
  (equal (smtp-cst-opt-info-conc (tree-fix cst))
         (smtp-cst-opt-info-conc cst)))

Theorem: smtp-cst-opt-info-conc-tree-equiv-congruence-on-cst

(defthm smtp-cst-opt-info-conc-tree-equiv-congruence-on-cst
  (implies (tree-equiv cst cst-equiv)
           (equal (smtp-cst-opt-info-conc cst)
                  (smtp-cst-opt-info-conc cst-equiv)))
  :rule-classes :congruence)

Function: smtp-cst-via-conc

(defun smtp-cst-via-conc (cst)
  (declare (xargs :guard (treep cst)))
  (declare (xargs :guard (smtp-cst-matchp cst "via")))
  (let ((__function__ 'smtp-cst-via-conc))
    (declare (ignorable __function__))
    (tree-nonleaf->branches cst)))

Theorem: tree-list-listp-of-smtp-cst-via-conc

(defthm tree-list-listp-of-smtp-cst-via-conc
  (b* ((cstss (smtp-cst-via-conc cst)))
    (tree-list-listp cstss))
  :rule-classes :rewrite)

Theorem: smtp-cst-via-conc-match

(defthm smtp-cst-via-conc-match
 (implies
    (smtp-cst-matchp cst "via")
    (b* ((cstss (smtp-cst-via-conc cst)))
      (smtp-cst-list-list-conc-matchp cstss "cfws \"VIA\" fws link")))
 :rule-classes :rewrite)

Theorem: smtp-cst-via-conc-of-tree-fix-cst

(defthm smtp-cst-via-conc-of-tree-fix-cst
  (equal (smtp-cst-via-conc (tree-fix cst))
         (smtp-cst-via-conc cst)))

Theorem: smtp-cst-via-conc-tree-equiv-congruence-on-cst

(defthm smtp-cst-via-conc-tree-equiv-congruence-on-cst
  (implies (tree-equiv cst cst-equiv)
           (equal (smtp-cst-via-conc cst)
                  (smtp-cst-via-conc cst-equiv)))
  :rule-classes :congruence)

Function: smtp-cst-with-conc

(defun smtp-cst-with-conc (cst)
  (declare (xargs :guard (treep cst)))
  (declare (xargs :guard (smtp-cst-matchp cst "with")))
  (let ((__function__ 'smtp-cst-with-conc))
    (declare (ignorable __function__))
    (tree-nonleaf->branches cst)))

Theorem: tree-list-listp-of-smtp-cst-with-conc

(defthm tree-list-listp-of-smtp-cst-with-conc
  (b* ((cstss (smtp-cst-with-conc cst)))
    (tree-list-listp cstss))
  :rule-classes :rewrite)

Theorem: smtp-cst-with-conc-match

(defthm smtp-cst-with-conc-match
  (implies (smtp-cst-matchp cst "with")
           (b* ((cstss (smtp-cst-with-conc cst)))
             (smtp-cst-list-list-conc-matchp
                  cstss "cfws \"WITH\" fws protocol")))
  :rule-classes :rewrite)

Theorem: smtp-cst-with-conc-of-tree-fix-cst

(defthm smtp-cst-with-conc-of-tree-fix-cst
  (equal (smtp-cst-with-conc (tree-fix cst))
         (smtp-cst-with-conc cst)))

Theorem: smtp-cst-with-conc-tree-equiv-congruence-on-cst

(defthm smtp-cst-with-conc-tree-equiv-congruence-on-cst
  (implies (tree-equiv cst cst-equiv)
           (equal (smtp-cst-with-conc cst)
                  (smtp-cst-with-conc cst-equiv)))
  :rule-classes :congruence)

Function: smtp-cst-id-conc

(defun smtp-cst-id-conc (cst)
  (declare (xargs :guard (treep cst)))
  (declare (xargs :guard (smtp-cst-matchp cst "id")))
  (let ((__function__ 'smtp-cst-id-conc))
    (declare (ignorable __function__))
    (tree-nonleaf->branches cst)))

Theorem: tree-list-listp-of-smtp-cst-id-conc

(defthm tree-list-listp-of-smtp-cst-id-conc
  (b* ((cstss (smtp-cst-id-conc cst)))
    (tree-list-listp cstss))
  :rule-classes :rewrite)

Theorem: smtp-cst-id-conc-match

(defthm smtp-cst-id-conc-match
  (implies (smtp-cst-matchp cst "id")
           (b* ((cstss (smtp-cst-id-conc cst)))
             (smtp-cst-list-list-conc-matchp
                  cstss
                  "cfws \"ID\" fws ( atom / msg-id )")))
  :rule-classes :rewrite)

Theorem: smtp-cst-id-conc-of-tree-fix-cst

(defthm smtp-cst-id-conc-of-tree-fix-cst
  (equal (smtp-cst-id-conc (tree-fix cst))
         (smtp-cst-id-conc cst)))

Theorem: smtp-cst-id-conc-tree-equiv-congruence-on-cst

(defthm smtp-cst-id-conc-tree-equiv-congruence-on-cst
  (implies (tree-equiv cst cst-equiv)
           (equal (smtp-cst-id-conc cst)
                  (smtp-cst-id-conc cst-equiv)))
  :rule-classes :congruence)

Function: smtp-cst-for-conc

(defun smtp-cst-for-conc (cst)
  (declare (xargs :guard (treep cst)))
  (declare (xargs :guard (smtp-cst-matchp cst "for")))
  (let ((__function__ 'smtp-cst-for-conc))
    (declare (ignorable __function__))
    (tree-nonleaf->branches cst)))

Theorem: tree-list-listp-of-smtp-cst-for-conc

(defthm tree-list-listp-of-smtp-cst-for-conc
  (b* ((cstss (smtp-cst-for-conc cst)))
    (tree-list-listp cstss))
  :rule-classes :rewrite)

Theorem: smtp-cst-for-conc-match

(defthm smtp-cst-for-conc-match
  (implies (smtp-cst-matchp cst "for")
           (b* ((cstss (smtp-cst-for-conc cst)))
             (smtp-cst-list-list-conc-matchp
                  cstss
                  "cfws \"FOR\" fws ( path / mailbox )")))
  :rule-classes :rewrite)

Theorem: smtp-cst-for-conc-of-tree-fix-cst

(defthm smtp-cst-for-conc-of-tree-fix-cst
  (equal (smtp-cst-for-conc (tree-fix cst))
         (smtp-cst-for-conc cst)))

Theorem: smtp-cst-for-conc-tree-equiv-congruence-on-cst

(defthm smtp-cst-for-conc-tree-equiv-congruence-on-cst
  (implies (tree-equiv cst cst-equiv)
           (equal (smtp-cst-for-conc cst)
                  (smtp-cst-for-conc cst-equiv)))
  :rule-classes :congruence)

Function: smtp-cst-additional-registered-clauses-conc

(defun smtp-cst-additional-registered-clauses-conc (cst)
 (declare (xargs :guard (treep cst)))
 (declare
  (xargs
      :guard (smtp-cst-matchp cst "additional-registered-clauses")))
 (let ((__function__ 'smtp-cst-additional-registered-clauses-conc))
   (declare (ignorable __function__))
   (tree-nonleaf->branches cst)))

Theorem: tree-list-listp-of-smtp-cst-additional-registered-clauses-conc

(defthm
     tree-list-listp-of-smtp-cst-additional-registered-clauses-conc
  (b* ((cstss (smtp-cst-additional-registered-clauses-conc cst)))
    (tree-list-listp cstss))
  :rule-classes :rewrite)

Theorem: smtp-cst-additional-registered-clauses-conc-match

(defthm smtp-cst-additional-registered-clauses-conc-match
 (implies
   (smtp-cst-matchp cst "additional-registered-clauses")
   (b* ((cstss (smtp-cst-additional-registered-clauses-conc cst)))
     (smtp-cst-list-list-conc-matchp cstss "cfws atom fws string")))
 :rule-classes :rewrite)

Theorem: smtp-cst-additional-registered-clauses-conc-of-tree-fix-cst

(defthm smtp-cst-additional-registered-clauses-conc-of-tree-fix-cst
 (equal (smtp-cst-additional-registered-clauses-conc (tree-fix cst))
        (smtp-cst-additional-registered-clauses-conc cst)))

Theorem: smtp-cst-additional-registered-clauses-conc-tree-equiv-congruence-on-cst

(defthm
 smtp-cst-additional-registered-clauses-conc-tree-equiv-congruence-on-cst
 (implies
    (tree-equiv cst cst-equiv)
    (equal (smtp-cst-additional-registered-clauses-conc cst)
           (smtp-cst-additional-registered-clauses-conc cst-equiv)))
 :rule-classes :congruence)

Function: smtp-cst-addtl-link-conc

(defun smtp-cst-addtl-link-conc (cst)
  (declare (xargs :guard (treep cst)))
  (declare (xargs :guard (smtp-cst-matchp cst "addtl-link")))
  (let ((__function__ 'smtp-cst-addtl-link-conc))
    (declare (ignorable __function__))
    (tree-nonleaf->branches cst)))

Theorem: tree-list-listp-of-smtp-cst-addtl-link-conc

(defthm tree-list-listp-of-smtp-cst-addtl-link-conc
  (b* ((cstss (smtp-cst-addtl-link-conc cst)))
    (tree-list-listp cstss))
  :rule-classes :rewrite)

Theorem: smtp-cst-addtl-link-conc-match

(defthm smtp-cst-addtl-link-conc-match
  (implies (smtp-cst-matchp cst "addtl-link")
           (b* ((cstss (smtp-cst-addtl-link-conc cst)))
             (smtp-cst-list-list-conc-matchp cstss "atom")))
  :rule-classes :rewrite)

Theorem: smtp-cst-addtl-link-conc-of-tree-fix-cst

(defthm smtp-cst-addtl-link-conc-of-tree-fix-cst
  (equal (smtp-cst-addtl-link-conc (tree-fix cst))
         (smtp-cst-addtl-link-conc cst)))

Theorem: smtp-cst-addtl-link-conc-tree-equiv-congruence-on-cst

(defthm smtp-cst-addtl-link-conc-tree-equiv-congruence-on-cst
  (implies (tree-equiv cst cst-equiv)
           (equal (smtp-cst-addtl-link-conc cst)
                  (smtp-cst-addtl-link-conc cst-equiv)))
  :rule-classes :congruence)

Function: smtp-cst-attdl-protocol-conc

(defun smtp-cst-attdl-protocol-conc (cst)
  (declare (xargs :guard (treep cst)))
  (declare (xargs :guard (smtp-cst-matchp cst "attdl-protocol")))
  (let ((__function__ 'smtp-cst-attdl-protocol-conc))
    (declare (ignorable __function__))
    (tree-nonleaf->branches cst)))

Theorem: tree-list-listp-of-smtp-cst-attdl-protocol-conc

(defthm tree-list-listp-of-smtp-cst-attdl-protocol-conc
  (b* ((cstss (smtp-cst-attdl-protocol-conc cst)))
    (tree-list-listp cstss))
  :rule-classes :rewrite)

Theorem: smtp-cst-attdl-protocol-conc-match

(defthm smtp-cst-attdl-protocol-conc-match
  (implies (smtp-cst-matchp cst "attdl-protocol")
           (b* ((cstss (smtp-cst-attdl-protocol-conc cst)))
             (smtp-cst-list-list-conc-matchp cstss "atom")))
  :rule-classes :rewrite)

Theorem: smtp-cst-attdl-protocol-conc-of-tree-fix-cst

(defthm smtp-cst-attdl-protocol-conc-of-tree-fix-cst
  (equal (smtp-cst-attdl-protocol-conc (tree-fix cst))
         (smtp-cst-attdl-protocol-conc cst)))

Theorem: smtp-cst-attdl-protocol-conc-tree-equiv-congruence-on-cst

(defthm smtp-cst-attdl-protocol-conc-tree-equiv-congruence-on-cst
  (implies (tree-equiv cst cst-equiv)
           (equal (smtp-cst-attdl-protocol-conc cst)
                  (smtp-cst-attdl-protocol-conc cst-equiv)))
  :rule-classes :congruence)

Function: smtp-cst-comment-conc

(defun smtp-cst-comment-conc (cst)
  (declare (xargs :guard (treep cst)))
  (declare (xargs :guard (smtp-cst-matchp cst "comment")))
  (let ((__function__ 'smtp-cst-comment-conc))
    (declare (ignorable __function__))
    (tree-nonleaf->branches cst)))

Theorem: tree-list-listp-of-smtp-cst-comment-conc

(defthm tree-list-listp-of-smtp-cst-comment-conc
  (b* ((cstss (smtp-cst-comment-conc cst)))
    (tree-list-listp cstss))
  :rule-classes :rewrite)

Theorem: smtp-cst-comment-conc-match

(defthm smtp-cst-comment-conc-match
  (implies (smtp-cst-matchp cst "comment")
           (b* ((cstss (smtp-cst-comment-conc cst)))
             (smtp-cst-list-list-conc-matchp
                  cstss
                  "\"(\" *( [ fws ] ccontent ) [ fws ] \")\"")))
  :rule-classes :rewrite)

Theorem: smtp-cst-comment-conc-of-tree-fix-cst

(defthm smtp-cst-comment-conc-of-tree-fix-cst
  (equal (smtp-cst-comment-conc (tree-fix cst))
         (smtp-cst-comment-conc cst)))

Theorem: smtp-cst-comment-conc-tree-equiv-congruence-on-cst

(defthm smtp-cst-comment-conc-tree-equiv-congruence-on-cst
  (implies (tree-equiv cst cst-equiv)
           (equal (smtp-cst-comment-conc cst)
                  (smtp-cst-comment-conc cst-equiv)))
  :rule-classes :congruence)

Function: smtp-cst-ccontent-conc1

(defun smtp-cst-ccontent-conc1 (cst)
  (declare (xargs :guard (treep cst)))
  (declare (xargs :guard (and (smtp-cst-matchp cst "ccontent")
                              (equal (smtp-cst-ccontent-conc? cst)
                                     1))))
  (let ((__function__ 'smtp-cst-ccontent-conc1))
    (declare (ignorable __function__))
    (tree-nonleaf->branches cst)))

Theorem: tree-list-listp-of-smtp-cst-ccontent-conc1

(defthm tree-list-listp-of-smtp-cst-ccontent-conc1
  (b* ((cstss (smtp-cst-ccontent-conc1 cst)))
    (tree-list-listp cstss))
  :rule-classes :rewrite)

Theorem: smtp-cst-ccontent-conc1-match

(defthm smtp-cst-ccontent-conc1-match
  (implies (and (smtp-cst-matchp cst "ccontent")
                (equal (smtp-cst-ccontent-conc? cst) 1))
           (b* ((cstss (smtp-cst-ccontent-conc1 cst)))
             (smtp-cst-list-list-conc-matchp cstss "ctext")))
  :rule-classes :rewrite)

Theorem: smtp-cst-ccontent-conc1-of-tree-fix-cst

(defthm smtp-cst-ccontent-conc1-of-tree-fix-cst
  (equal (smtp-cst-ccontent-conc1 (tree-fix cst))
         (smtp-cst-ccontent-conc1 cst)))

Theorem: smtp-cst-ccontent-conc1-tree-equiv-congruence-on-cst

(defthm smtp-cst-ccontent-conc1-tree-equiv-congruence-on-cst
  (implies (tree-equiv cst cst-equiv)
           (equal (smtp-cst-ccontent-conc1 cst)
                  (smtp-cst-ccontent-conc1 cst-equiv)))
  :rule-classes :congruence)

Function: smtp-cst-ccontent-conc2

(defun smtp-cst-ccontent-conc2 (cst)
  (declare (xargs :guard (treep cst)))
  (declare (xargs :guard (and (smtp-cst-matchp cst "ccontent")
                              (equal (smtp-cst-ccontent-conc? cst)
                                     2))))
  (let ((__function__ 'smtp-cst-ccontent-conc2))
    (declare (ignorable __function__))
    (tree-nonleaf->branches cst)))

Theorem: tree-list-listp-of-smtp-cst-ccontent-conc2

(defthm tree-list-listp-of-smtp-cst-ccontent-conc2
  (b* ((cstss (smtp-cst-ccontent-conc2 cst)))
    (tree-list-listp cstss))
  :rule-classes :rewrite)

Theorem: smtp-cst-ccontent-conc2-match

(defthm smtp-cst-ccontent-conc2-match
  (implies (and (smtp-cst-matchp cst "ccontent")
                (equal (smtp-cst-ccontent-conc? cst) 2))
           (b* ((cstss (smtp-cst-ccontent-conc2 cst)))
             (smtp-cst-list-list-conc-matchp cstss "quoted-pair")))
  :rule-classes :rewrite)

Theorem: smtp-cst-ccontent-conc2-of-tree-fix-cst

(defthm smtp-cst-ccontent-conc2-of-tree-fix-cst
  (equal (smtp-cst-ccontent-conc2 (tree-fix cst))
         (smtp-cst-ccontent-conc2 cst)))

Theorem: smtp-cst-ccontent-conc2-tree-equiv-congruence-on-cst

(defthm smtp-cst-ccontent-conc2-tree-equiv-congruence-on-cst
  (implies (tree-equiv cst cst-equiv)
           (equal (smtp-cst-ccontent-conc2 cst)
                  (smtp-cst-ccontent-conc2 cst-equiv)))
  :rule-classes :congruence)

Function: smtp-cst-ccontent-conc3

(defun smtp-cst-ccontent-conc3 (cst)
  (declare (xargs :guard (treep cst)))
  (declare (xargs :guard (and (smtp-cst-matchp cst "ccontent")
                              (equal (smtp-cst-ccontent-conc? cst)
                                     3))))
  (let ((__function__ 'smtp-cst-ccontent-conc3))
    (declare (ignorable __function__))
    (tree-nonleaf->branches cst)))

Theorem: tree-list-listp-of-smtp-cst-ccontent-conc3

(defthm tree-list-listp-of-smtp-cst-ccontent-conc3
  (b* ((cstss (smtp-cst-ccontent-conc3 cst)))
    (tree-list-listp cstss))
  :rule-classes :rewrite)

Theorem: smtp-cst-ccontent-conc3-match

(defthm smtp-cst-ccontent-conc3-match
  (implies (and (smtp-cst-matchp cst "ccontent")
                (equal (smtp-cst-ccontent-conc? cst) 3))
           (b* ((cstss (smtp-cst-ccontent-conc3 cst)))
             (smtp-cst-list-list-conc-matchp cstss "comment")))
  :rule-classes :rewrite)

Theorem: smtp-cst-ccontent-conc3-of-tree-fix-cst

(defthm smtp-cst-ccontent-conc3-of-tree-fix-cst
  (equal (smtp-cst-ccontent-conc3 (tree-fix cst))
         (smtp-cst-ccontent-conc3 cst)))

Theorem: smtp-cst-ccontent-conc3-tree-equiv-congruence-on-cst

(defthm smtp-cst-ccontent-conc3-tree-equiv-congruence-on-cst
  (implies (tree-equiv cst cst-equiv)
           (equal (smtp-cst-ccontent-conc3 cst)
                  (smtp-cst-ccontent-conc3 cst-equiv)))
  :rule-classes :congruence)

Function: smtp-cst-date-time-conc

(defun smtp-cst-date-time-conc (cst)
  (declare (xargs :guard (treep cst)))
  (declare (xargs :guard (smtp-cst-matchp cst "date-time")))
  (let ((__function__ 'smtp-cst-date-time-conc))
    (declare (ignorable __function__))
    (tree-nonleaf->branches cst)))

Theorem: tree-list-listp-of-smtp-cst-date-time-conc

(defthm tree-list-listp-of-smtp-cst-date-time-conc
  (b* ((cstss (smtp-cst-date-time-conc cst)))
    (tree-list-listp cstss))
  :rule-classes :rewrite)

Theorem: smtp-cst-date-time-conc-match

(defthm smtp-cst-date-time-conc-match
  (implies (smtp-cst-matchp cst "date-time")
           (b* ((cstss (smtp-cst-date-time-conc cst)))
             (smtp-cst-list-list-conc-matchp
                  cstss
                  "[ day-of-week \",\" ] date time [ cfws ]")))
  :rule-classes :rewrite)

Theorem: smtp-cst-date-time-conc-of-tree-fix-cst

(defthm smtp-cst-date-time-conc-of-tree-fix-cst
  (equal (smtp-cst-date-time-conc (tree-fix cst))
         (smtp-cst-date-time-conc cst)))

Theorem: smtp-cst-date-time-conc-tree-equiv-congruence-on-cst

(defthm smtp-cst-date-time-conc-tree-equiv-congruence-on-cst
  (implies (tree-equiv cst cst-equiv)
           (equal (smtp-cst-date-time-conc cst)
                  (smtp-cst-date-time-conc cst-equiv)))
  :rule-classes :congruence)

Function: smtp-cst-date-conc

(defun smtp-cst-date-conc (cst)
  (declare (xargs :guard (treep cst)))
  (declare (xargs :guard (smtp-cst-matchp cst "date")))
  (let ((__function__ 'smtp-cst-date-conc))
    (declare (ignorable __function__))
    (tree-nonleaf->branches cst)))

Theorem: tree-list-listp-of-smtp-cst-date-conc

(defthm tree-list-listp-of-smtp-cst-date-conc
  (b* ((cstss (smtp-cst-date-conc cst)))
    (tree-list-listp cstss))
  :rule-classes :rewrite)

Theorem: smtp-cst-date-conc-match

(defthm smtp-cst-date-conc-match
  (implies
       (smtp-cst-matchp cst "date")
       (b* ((cstss (smtp-cst-date-conc cst)))
         (smtp-cst-list-list-conc-matchp cstss "day month year")))
  :rule-classes :rewrite)

Theorem: smtp-cst-date-conc-of-tree-fix-cst

(defthm smtp-cst-date-conc-of-tree-fix-cst
  (equal (smtp-cst-date-conc (tree-fix cst))
         (smtp-cst-date-conc cst)))

Theorem: smtp-cst-date-conc-tree-equiv-congruence-on-cst

(defthm smtp-cst-date-conc-tree-equiv-congruence-on-cst
  (implies (tree-equiv cst cst-equiv)
           (equal (smtp-cst-date-conc cst)
                  (smtp-cst-date-conc cst-equiv)))
  :rule-classes :congruence)

Function: smtp-cst-msg-id-conc

(defun smtp-cst-msg-id-conc (cst)
  (declare (xargs :guard (treep cst)))
  (declare (xargs :guard (smtp-cst-matchp cst "msg-id")))
  (let ((__function__ 'smtp-cst-msg-id-conc))
    (declare (ignorable __function__))
    (tree-nonleaf->branches cst)))

Theorem: tree-list-listp-of-smtp-cst-msg-id-conc

(defthm tree-list-listp-of-smtp-cst-msg-id-conc
  (b* ((cstss (smtp-cst-msg-id-conc cst)))
    (tree-list-listp cstss))
  :rule-classes :rewrite)

Theorem: smtp-cst-msg-id-conc-match

(defthm smtp-cst-msg-id-conc-match
 (implies (smtp-cst-matchp cst "msg-id")
          (b* ((cstss (smtp-cst-msg-id-conc cst)))
            (smtp-cst-list-list-conc-matchp
                 cstss
                 "[ cfws ] \"<\" id-left \"@\" id-right \">\" [ cfws ]")))
 :rule-classes :rewrite)

Theorem: smtp-cst-msg-id-conc-of-tree-fix-cst

(defthm smtp-cst-msg-id-conc-of-tree-fix-cst
  (equal (smtp-cst-msg-id-conc (tree-fix cst))
         (smtp-cst-msg-id-conc cst)))

Theorem: smtp-cst-msg-id-conc-tree-equiv-congruence-on-cst

(defthm smtp-cst-msg-id-conc-tree-equiv-congruence-on-cst
  (implies (tree-equiv cst cst-equiv)
           (equal (smtp-cst-msg-id-conc cst)
                  (smtp-cst-msg-id-conc cst-equiv)))
  :rule-classes :congruence)

Function: smtp-cst-id-left-conc1

(defun smtp-cst-id-left-conc1 (cst)
  (declare (xargs :guard (treep cst)))
  (declare (xargs :guard (and (smtp-cst-matchp cst "id-left")
                              (equal (smtp-cst-id-left-conc? cst)
                                     1))))
  (let ((__function__ 'smtp-cst-id-left-conc1))
    (declare (ignorable __function__))
    (tree-nonleaf->branches cst)))

Theorem: tree-list-listp-of-smtp-cst-id-left-conc1

(defthm tree-list-listp-of-smtp-cst-id-left-conc1
  (b* ((cstss (smtp-cst-id-left-conc1 cst)))
    (tree-list-listp cstss))
  :rule-classes :rewrite)

Theorem: smtp-cst-id-left-conc1-match

(defthm smtp-cst-id-left-conc1-match
 (implies (and (smtp-cst-matchp cst "id-left")
               (equal (smtp-cst-id-left-conc? cst) 1))
          (b* ((cstss (smtp-cst-id-left-conc1 cst)))
            (smtp-cst-list-list-conc-matchp cstss "dot-atom-text")))
 :rule-classes :rewrite)

Theorem: smtp-cst-id-left-conc1-of-tree-fix-cst

(defthm smtp-cst-id-left-conc1-of-tree-fix-cst
  (equal (smtp-cst-id-left-conc1 (tree-fix cst))
         (smtp-cst-id-left-conc1 cst)))

Theorem: smtp-cst-id-left-conc1-tree-equiv-congruence-on-cst

(defthm smtp-cst-id-left-conc1-tree-equiv-congruence-on-cst
  (implies (tree-equiv cst cst-equiv)
           (equal (smtp-cst-id-left-conc1 cst)
                  (smtp-cst-id-left-conc1 cst-equiv)))
  :rule-classes :congruence)

Function: smtp-cst-id-left-conc2

(defun smtp-cst-id-left-conc2 (cst)
  (declare (xargs :guard (treep cst)))
  (declare (xargs :guard (and (smtp-cst-matchp cst "id-left")
                              (equal (smtp-cst-id-left-conc? cst)
                                     2))))
  (let ((__function__ 'smtp-cst-id-left-conc2))
    (declare (ignorable __function__))
    (tree-nonleaf->branches cst)))

Theorem: tree-list-listp-of-smtp-cst-id-left-conc2

(defthm tree-list-listp-of-smtp-cst-id-left-conc2
  (b* ((cstss (smtp-cst-id-left-conc2 cst)))
    (tree-list-listp cstss))
  :rule-classes :rewrite)

Theorem: smtp-cst-id-left-conc2-match

(defthm smtp-cst-id-left-conc2-match
  (implies (and (smtp-cst-matchp cst "id-left")
                (equal (smtp-cst-id-left-conc? cst) 2))
           (b* ((cstss (smtp-cst-id-left-conc2 cst)))
             (smtp-cst-list-list-conc-matchp cstss "obs-id-left")))
  :rule-classes :rewrite)

Theorem: smtp-cst-id-left-conc2-of-tree-fix-cst

(defthm smtp-cst-id-left-conc2-of-tree-fix-cst
  (equal (smtp-cst-id-left-conc2 (tree-fix cst))
         (smtp-cst-id-left-conc2 cst)))

Theorem: smtp-cst-id-left-conc2-tree-equiv-congruence-on-cst

(defthm smtp-cst-id-left-conc2-tree-equiv-congruence-on-cst
  (implies (tree-equiv cst cst-equiv)
           (equal (smtp-cst-id-left-conc2 cst)
                  (smtp-cst-id-left-conc2 cst-equiv)))
  :rule-classes :congruence)

Function: smtp-cst-dot-atom-text-conc

(defun smtp-cst-dot-atom-text-conc (cst)
  (declare (xargs :guard (treep cst)))
  (declare (xargs :guard (smtp-cst-matchp cst "dot-atom-text")))
  (let ((__function__ 'smtp-cst-dot-atom-text-conc))
    (declare (ignorable __function__))
    (tree-nonleaf->branches cst)))

Theorem: tree-list-listp-of-smtp-cst-dot-atom-text-conc

(defthm tree-list-listp-of-smtp-cst-dot-atom-text-conc
  (b* ((cstss (smtp-cst-dot-atom-text-conc cst)))
    (tree-list-listp cstss))
  :rule-classes :rewrite)

Theorem: smtp-cst-dot-atom-text-conc-match

(defthm smtp-cst-dot-atom-text-conc-match
  (implies (smtp-cst-matchp cst "dot-atom-text")
           (b* ((cstss (smtp-cst-dot-atom-text-conc cst)))
             (smtp-cst-list-list-conc-matchp
                  cstss "1*atext *( \".\" 1*atext )")))
  :rule-classes :rewrite)

Theorem: smtp-cst-dot-atom-text-conc-of-tree-fix-cst

(defthm smtp-cst-dot-atom-text-conc-of-tree-fix-cst
  (equal (smtp-cst-dot-atom-text-conc (tree-fix cst))
         (smtp-cst-dot-atom-text-conc cst)))

Theorem: smtp-cst-dot-atom-text-conc-tree-equiv-congruence-on-cst

(defthm smtp-cst-dot-atom-text-conc-tree-equiv-congruence-on-cst
  (implies (tree-equiv cst cst-equiv)
           (equal (smtp-cst-dot-atom-text-conc cst)
                  (smtp-cst-dot-atom-text-conc cst-equiv)))
  :rule-classes :congruence)

Function: smtp-cst-id-right-conc1

(defun smtp-cst-id-right-conc1 (cst)
  (declare (xargs :guard (treep cst)))
  (declare (xargs :guard (and (smtp-cst-matchp cst "id-right")
                              (equal (smtp-cst-id-right-conc? cst)
                                     1))))
  (let ((__function__ 'smtp-cst-id-right-conc1))
    (declare (ignorable __function__))
    (tree-nonleaf->branches cst)))

Theorem: tree-list-listp-of-smtp-cst-id-right-conc1

(defthm tree-list-listp-of-smtp-cst-id-right-conc1
  (b* ((cstss (smtp-cst-id-right-conc1 cst)))
    (tree-list-listp cstss))
  :rule-classes :rewrite)

Theorem: smtp-cst-id-right-conc1-match

(defthm smtp-cst-id-right-conc1-match
 (implies (and (smtp-cst-matchp cst "id-right")
               (equal (smtp-cst-id-right-conc? cst) 1))
          (b* ((cstss (smtp-cst-id-right-conc1 cst)))
            (smtp-cst-list-list-conc-matchp cstss "dot-atom-text")))
 :rule-classes :rewrite)

Theorem: smtp-cst-id-right-conc1-of-tree-fix-cst

(defthm smtp-cst-id-right-conc1-of-tree-fix-cst
  (equal (smtp-cst-id-right-conc1 (tree-fix cst))
         (smtp-cst-id-right-conc1 cst)))

Theorem: smtp-cst-id-right-conc1-tree-equiv-congruence-on-cst

(defthm smtp-cst-id-right-conc1-tree-equiv-congruence-on-cst
  (implies (tree-equiv cst cst-equiv)
           (equal (smtp-cst-id-right-conc1 cst)
                  (smtp-cst-id-right-conc1 cst-equiv)))
  :rule-classes :congruence)

Function: smtp-cst-id-right-conc2

(defun smtp-cst-id-right-conc2 (cst)
  (declare (xargs :guard (treep cst)))
  (declare (xargs :guard (and (smtp-cst-matchp cst "id-right")
                              (equal (smtp-cst-id-right-conc? cst)
                                     2))))
  (let ((__function__ 'smtp-cst-id-right-conc2))
    (declare (ignorable __function__))
    (tree-nonleaf->branches cst)))

Theorem: tree-list-listp-of-smtp-cst-id-right-conc2

(defthm tree-list-listp-of-smtp-cst-id-right-conc2
  (b* ((cstss (smtp-cst-id-right-conc2 cst)))
    (tree-list-listp cstss))
  :rule-classes :rewrite)

Theorem: smtp-cst-id-right-conc2-match

(defthm smtp-cst-id-right-conc2-match
  (implies
       (and (smtp-cst-matchp cst "id-right")
            (equal (smtp-cst-id-right-conc? cst) 2))
       (b* ((cstss (smtp-cst-id-right-conc2 cst)))
         (smtp-cst-list-list-conc-matchp cstss "no-fold-literal")))
  :rule-classes :rewrite)

Theorem: smtp-cst-id-right-conc2-of-tree-fix-cst

(defthm smtp-cst-id-right-conc2-of-tree-fix-cst
  (equal (smtp-cst-id-right-conc2 (tree-fix cst))
         (smtp-cst-id-right-conc2 cst)))

Theorem: smtp-cst-id-right-conc2-tree-equiv-congruence-on-cst

(defthm smtp-cst-id-right-conc2-tree-equiv-congruence-on-cst
  (implies (tree-equiv cst cst-equiv)
           (equal (smtp-cst-id-right-conc2 cst)
                  (smtp-cst-id-right-conc2 cst-equiv)))
  :rule-classes :congruence)

Function: smtp-cst-id-right-conc3

(defun smtp-cst-id-right-conc3 (cst)
  (declare (xargs :guard (treep cst)))
  (declare (xargs :guard (and (smtp-cst-matchp cst "id-right")
                              (equal (smtp-cst-id-right-conc? cst)
                                     3))))
  (let ((__function__ 'smtp-cst-id-right-conc3))
    (declare (ignorable __function__))
    (tree-nonleaf->branches cst)))

Theorem: tree-list-listp-of-smtp-cst-id-right-conc3

(defthm tree-list-listp-of-smtp-cst-id-right-conc3
  (b* ((cstss (smtp-cst-id-right-conc3 cst)))
    (tree-list-listp cstss))
  :rule-classes :rewrite)

Theorem: smtp-cst-id-right-conc3-match

(defthm smtp-cst-id-right-conc3-match
  (implies (and (smtp-cst-matchp cst "id-right")
                (equal (smtp-cst-id-right-conc? cst) 3))
           (b* ((cstss (smtp-cst-id-right-conc3 cst)))
             (smtp-cst-list-list-conc-matchp cstss "obs-id-right")))
  :rule-classes :rewrite)

Theorem: smtp-cst-id-right-conc3-of-tree-fix-cst

(defthm smtp-cst-id-right-conc3-of-tree-fix-cst
  (equal (smtp-cst-id-right-conc3 (tree-fix cst))
         (smtp-cst-id-right-conc3 cst)))

Theorem: smtp-cst-id-right-conc3-tree-equiv-congruence-on-cst

(defthm smtp-cst-id-right-conc3-tree-equiv-congruence-on-cst
  (implies (tree-equiv cst cst-equiv)
           (equal (smtp-cst-id-right-conc3 cst)
                  (smtp-cst-id-right-conc3 cst-equiv)))
  :rule-classes :congruence)

Function: smtp-cst-no-fold-literal-conc

(defun smtp-cst-no-fold-literal-conc (cst)
  (declare (xargs :guard (treep cst)))
  (declare (xargs :guard (smtp-cst-matchp cst "no-fold-literal")))
  (let ((__function__ 'smtp-cst-no-fold-literal-conc))
    (declare (ignorable __function__))
    (tree-nonleaf->branches cst)))

Theorem: tree-list-listp-of-smtp-cst-no-fold-literal-conc

(defthm tree-list-listp-of-smtp-cst-no-fold-literal-conc
  (b* ((cstss (smtp-cst-no-fold-literal-conc cst)))
    (tree-list-listp cstss))
  :rule-classes :rewrite)

Theorem: smtp-cst-no-fold-literal-conc-match

(defthm smtp-cst-no-fold-literal-conc-match
  (implies
       (smtp-cst-matchp cst "no-fold-literal")
       (b* ((cstss (smtp-cst-no-fold-literal-conc cst)))
         (smtp-cst-list-list-conc-matchp cstss "\"[\" *dtext \"]\"")))
  :rule-classes :rewrite)

Theorem: smtp-cst-no-fold-literal-conc-of-tree-fix-cst

(defthm smtp-cst-no-fold-literal-conc-of-tree-fix-cst
  (equal (smtp-cst-no-fold-literal-conc (tree-fix cst))
         (smtp-cst-no-fold-literal-conc cst)))

Theorem: smtp-cst-no-fold-literal-conc-tree-equiv-congruence-on-cst

(defthm smtp-cst-no-fold-literal-conc-tree-equiv-congruence-on-cst
  (implies (tree-equiv cst cst-equiv)
           (equal (smtp-cst-no-fold-literal-conc cst)
                  (smtp-cst-no-fold-literal-conc cst-equiv)))
  :rule-classes :congruence)

Function: smtp-cst-obs-ctext-conc

(defun smtp-cst-obs-ctext-conc (cst)
  (declare (xargs :guard (treep cst)))
  (declare (xargs :guard (smtp-cst-matchp cst "obs-ctext")))
  (let ((__function__ 'smtp-cst-obs-ctext-conc))
    (declare (ignorable __function__))
    (tree-nonleaf->branches cst)))

Theorem: tree-list-listp-of-smtp-cst-obs-ctext-conc

(defthm tree-list-listp-of-smtp-cst-obs-ctext-conc
  (b* ((cstss (smtp-cst-obs-ctext-conc cst)))
    (tree-list-listp cstss))
  :rule-classes :rewrite)

Theorem: smtp-cst-obs-ctext-conc-match

(defthm smtp-cst-obs-ctext-conc-match
 (implies (smtp-cst-matchp cst "obs-ctext")
          (b* ((cstss (smtp-cst-obs-ctext-conc cst)))
            (smtp-cst-list-list-conc-matchp cstss "obs-no-ws-ctl")))
 :rule-classes :rewrite)

Theorem: smtp-cst-obs-ctext-conc-of-tree-fix-cst

(defthm smtp-cst-obs-ctext-conc-of-tree-fix-cst
  (equal (smtp-cst-obs-ctext-conc (tree-fix cst))
         (smtp-cst-obs-ctext-conc cst)))

Theorem: smtp-cst-obs-ctext-conc-tree-equiv-congruence-on-cst

(defthm smtp-cst-obs-ctext-conc-tree-equiv-congruence-on-cst
  (implies (tree-equiv cst cst-equiv)
           (equal (smtp-cst-obs-ctext-conc cst)
                  (smtp-cst-obs-ctext-conc cst-equiv)))
  :rule-classes :congruence)

Function: smtp-cst-obs-day-conc

(defun smtp-cst-obs-day-conc (cst)
  (declare (xargs :guard (treep cst)))
  (declare (xargs :guard (smtp-cst-matchp cst "obs-day")))
  (let ((__function__ 'smtp-cst-obs-day-conc))
    (declare (ignorable __function__))
    (tree-nonleaf->branches cst)))

Theorem: tree-list-listp-of-smtp-cst-obs-day-conc

(defthm tree-list-listp-of-smtp-cst-obs-day-conc
  (b* ((cstss (smtp-cst-obs-day-conc cst)))
    (tree-list-listp cstss))
  :rule-classes :rewrite)

Theorem: smtp-cst-obs-day-conc-match

(defthm smtp-cst-obs-day-conc-match
  (implies (smtp-cst-matchp cst "obs-day")
           (b* ((cstss (smtp-cst-obs-day-conc cst)))
             (smtp-cst-list-list-conc-matchp
                  cstss "[ cfws ] 1*2digit [ cfws ]")))
  :rule-classes :rewrite)

Theorem: smtp-cst-obs-day-conc-of-tree-fix-cst

(defthm smtp-cst-obs-day-conc-of-tree-fix-cst
  (equal (smtp-cst-obs-day-conc (tree-fix cst))
         (smtp-cst-obs-day-conc cst)))

Theorem: smtp-cst-obs-day-conc-tree-equiv-congruence-on-cst

(defthm smtp-cst-obs-day-conc-tree-equiv-congruence-on-cst
  (implies (tree-equiv cst cst-equiv)
           (equal (smtp-cst-obs-day-conc cst)
                  (smtp-cst-obs-day-conc cst-equiv)))
  :rule-classes :congruence)

Function: smtp-cst-obs-day-of-week-conc

(defun smtp-cst-obs-day-of-week-conc (cst)
  (declare (xargs :guard (treep cst)))
  (declare (xargs :guard (smtp-cst-matchp cst "obs-day-of-week")))
  (let ((__function__ 'smtp-cst-obs-day-of-week-conc))
    (declare (ignorable __function__))
    (tree-nonleaf->branches cst)))

Theorem: tree-list-listp-of-smtp-cst-obs-day-of-week-conc

(defthm tree-list-listp-of-smtp-cst-obs-day-of-week-conc
  (b* ((cstss (smtp-cst-obs-day-of-week-conc cst)))
    (tree-list-listp cstss))
  :rule-classes :rewrite)

Theorem: smtp-cst-obs-day-of-week-conc-match

(defthm smtp-cst-obs-day-of-week-conc-match
  (implies (smtp-cst-matchp cst "obs-day-of-week")
           (b* ((cstss (smtp-cst-obs-day-of-week-conc cst)))
             (smtp-cst-list-list-conc-matchp
                  cstss "[ cfws ] day-name [ cfws ]")))
  :rule-classes :rewrite)

Theorem: smtp-cst-obs-day-of-week-conc-of-tree-fix-cst

(defthm smtp-cst-obs-day-of-week-conc-of-tree-fix-cst
  (equal (smtp-cst-obs-day-of-week-conc (tree-fix cst))
         (smtp-cst-obs-day-of-week-conc cst)))

Theorem: smtp-cst-obs-day-of-week-conc-tree-equiv-congruence-on-cst

(defthm smtp-cst-obs-day-of-week-conc-tree-equiv-congruence-on-cst
  (implies (tree-equiv cst cst-equiv)
           (equal (smtp-cst-obs-day-of-week-conc cst)
                  (smtp-cst-obs-day-of-week-conc cst-equiv)))
  :rule-classes :congruence)

Function: smtp-cst-obs-dtext-conc1

(defun smtp-cst-obs-dtext-conc1 (cst)
  (declare (xargs :guard (treep cst)))
  (declare (xargs :guard (and (smtp-cst-matchp cst "obs-dtext")
                              (equal (smtp-cst-obs-dtext-conc? cst)
                                     1))))
  (let ((__function__ 'smtp-cst-obs-dtext-conc1))
    (declare (ignorable __function__))
    (tree-nonleaf->branches cst)))

Theorem: tree-list-listp-of-smtp-cst-obs-dtext-conc1

(defthm tree-list-listp-of-smtp-cst-obs-dtext-conc1
  (b* ((cstss (smtp-cst-obs-dtext-conc1 cst)))
    (tree-list-listp cstss))
  :rule-classes :rewrite)

Theorem: smtp-cst-obs-dtext-conc1-match

(defthm smtp-cst-obs-dtext-conc1-match
 (implies (and (smtp-cst-matchp cst "obs-dtext")
               (equal (smtp-cst-obs-dtext-conc? cst)
                      1))
          (b* ((cstss (smtp-cst-obs-dtext-conc1 cst)))
            (smtp-cst-list-list-conc-matchp cstss "obs-no-ws-ctl")))
 :rule-classes :rewrite)

Theorem: smtp-cst-obs-dtext-conc1-of-tree-fix-cst

(defthm smtp-cst-obs-dtext-conc1-of-tree-fix-cst
  (equal (smtp-cst-obs-dtext-conc1 (tree-fix cst))
         (smtp-cst-obs-dtext-conc1 cst)))

Theorem: smtp-cst-obs-dtext-conc1-tree-equiv-congruence-on-cst

(defthm smtp-cst-obs-dtext-conc1-tree-equiv-congruence-on-cst
  (implies (tree-equiv cst cst-equiv)
           (equal (smtp-cst-obs-dtext-conc1 cst)
                  (smtp-cst-obs-dtext-conc1 cst-equiv)))
  :rule-classes :congruence)

Function: smtp-cst-obs-dtext-conc2

(defun smtp-cst-obs-dtext-conc2 (cst)
  (declare (xargs :guard (treep cst)))
  (declare (xargs :guard (and (smtp-cst-matchp cst "obs-dtext")
                              (equal (smtp-cst-obs-dtext-conc? cst)
                                     2))))
  (let ((__function__ 'smtp-cst-obs-dtext-conc2))
    (declare (ignorable __function__))
    (tree-nonleaf->branches cst)))

Theorem: tree-list-listp-of-smtp-cst-obs-dtext-conc2

(defthm tree-list-listp-of-smtp-cst-obs-dtext-conc2
  (b* ((cstss (smtp-cst-obs-dtext-conc2 cst)))
    (tree-list-listp cstss))
  :rule-classes :rewrite)

Theorem: smtp-cst-obs-dtext-conc2-match

(defthm smtp-cst-obs-dtext-conc2-match
  (implies (and (smtp-cst-matchp cst "obs-dtext")
                (equal (smtp-cst-obs-dtext-conc? cst)
                       2))
           (b* ((cstss (smtp-cst-obs-dtext-conc2 cst)))
             (smtp-cst-list-list-conc-matchp cstss "quoted-pair")))
  :rule-classes :rewrite)

Theorem: smtp-cst-obs-dtext-conc2-of-tree-fix-cst

(defthm smtp-cst-obs-dtext-conc2-of-tree-fix-cst
  (equal (smtp-cst-obs-dtext-conc2 (tree-fix cst))
         (smtp-cst-obs-dtext-conc2 cst)))

Theorem: smtp-cst-obs-dtext-conc2-tree-equiv-congruence-on-cst

(defthm smtp-cst-obs-dtext-conc2-tree-equiv-congruence-on-cst
  (implies (tree-equiv cst cst-equiv)
           (equal (smtp-cst-obs-dtext-conc2 cst)
                  (smtp-cst-obs-dtext-conc2 cst-equiv)))
  :rule-classes :congruence)

Function: smtp-cst-obs-fws-conc

(defun smtp-cst-obs-fws-conc (cst)
  (declare (xargs :guard (treep cst)))
  (declare (xargs :guard (smtp-cst-matchp cst "obs-fws")))
  (let ((__function__ 'smtp-cst-obs-fws-conc))
    (declare (ignorable __function__))
    (tree-nonleaf->branches cst)))

Theorem: tree-list-listp-of-smtp-cst-obs-fws-conc

(defthm tree-list-listp-of-smtp-cst-obs-fws-conc
  (b* ((cstss (smtp-cst-obs-fws-conc cst)))
    (tree-list-listp cstss))
  :rule-classes :rewrite)

Theorem: smtp-cst-obs-fws-conc-match

(defthm smtp-cst-obs-fws-conc-match
 (implies
  (smtp-cst-matchp cst "obs-fws")
  (b* ((cstss (smtp-cst-obs-fws-conc cst)))
    (smtp-cst-list-list-conc-matchp cstss "1*wsp *( crlf 1*wsp )")))
 :rule-classes :rewrite)

Theorem: smtp-cst-obs-fws-conc-of-tree-fix-cst

(defthm smtp-cst-obs-fws-conc-of-tree-fix-cst
  (equal (smtp-cst-obs-fws-conc (tree-fix cst))
         (smtp-cst-obs-fws-conc cst)))

Theorem: smtp-cst-obs-fws-conc-tree-equiv-congruence-on-cst

(defthm smtp-cst-obs-fws-conc-tree-equiv-congruence-on-cst
  (implies (tree-equiv cst cst-equiv)
           (equal (smtp-cst-obs-fws-conc cst)
                  (smtp-cst-obs-fws-conc cst-equiv)))
  :rule-classes :congruence)

Function: smtp-cst-obs-id-left-conc

(defun smtp-cst-obs-id-left-conc (cst)
  (declare (xargs :guard (treep cst)))
  (declare (xargs :guard (smtp-cst-matchp cst "obs-id-left")))
  (let ((__function__ 'smtp-cst-obs-id-left-conc))
    (declare (ignorable __function__))
    (tree-nonleaf->branches cst)))

Theorem: tree-list-listp-of-smtp-cst-obs-id-left-conc

(defthm tree-list-listp-of-smtp-cst-obs-id-left-conc
  (b* ((cstss (smtp-cst-obs-id-left-conc cst)))
    (tree-list-listp cstss))
  :rule-classes :rewrite)

Theorem: smtp-cst-obs-id-left-conc-match

(defthm smtp-cst-obs-id-left-conc-match
  (implies
       (smtp-cst-matchp cst "obs-id-left")
       (b* ((cstss (smtp-cst-obs-id-left-conc cst)))
         (smtp-cst-list-list-conc-matchp cstss "imf-local-part")))
  :rule-classes :rewrite)

Theorem: smtp-cst-obs-id-left-conc-of-tree-fix-cst

(defthm smtp-cst-obs-id-left-conc-of-tree-fix-cst
  (equal (smtp-cst-obs-id-left-conc (tree-fix cst))
         (smtp-cst-obs-id-left-conc cst)))

Theorem: smtp-cst-obs-id-left-conc-tree-equiv-congruence-on-cst

(defthm smtp-cst-obs-id-left-conc-tree-equiv-congruence-on-cst
  (implies (tree-equiv cst cst-equiv)
           (equal (smtp-cst-obs-id-left-conc cst)
                  (smtp-cst-obs-id-left-conc cst-equiv)))
  :rule-classes :congruence)

Function: smtp-cst-imf-local-part-conc1

(defun smtp-cst-imf-local-part-conc1 (cst)
  (declare (xargs :guard (treep cst)))
  (declare
       (xargs :guard (and (smtp-cst-matchp cst "imf-local-part")
                          (equal (smtp-cst-imf-local-part-conc? cst)
                                 1))))
  (let ((__function__ 'smtp-cst-imf-local-part-conc1))
    (declare (ignorable __function__))
    (tree-nonleaf->branches cst)))

Theorem: tree-list-listp-of-smtp-cst-imf-local-part-conc1

(defthm tree-list-listp-of-smtp-cst-imf-local-part-conc1
  (b* ((cstss (smtp-cst-imf-local-part-conc1 cst)))
    (tree-list-listp cstss))
  :rule-classes :rewrite)

Theorem: smtp-cst-imf-local-part-conc1-match

(defthm smtp-cst-imf-local-part-conc1-match
  (implies (and (smtp-cst-matchp cst "imf-local-part")
                (equal (smtp-cst-imf-local-part-conc? cst)
                       1))
           (b* ((cstss (smtp-cst-imf-local-part-conc1 cst)))
             (smtp-cst-list-list-conc-matchp cstss "dot-atom")))
  :rule-classes :rewrite)

Theorem: smtp-cst-imf-local-part-conc1-of-tree-fix-cst

(defthm smtp-cst-imf-local-part-conc1-of-tree-fix-cst
  (equal (smtp-cst-imf-local-part-conc1 (tree-fix cst))
         (smtp-cst-imf-local-part-conc1 cst)))

Theorem: smtp-cst-imf-local-part-conc1-tree-equiv-congruence-on-cst

(defthm smtp-cst-imf-local-part-conc1-tree-equiv-congruence-on-cst
  (implies (tree-equiv cst cst-equiv)
           (equal (smtp-cst-imf-local-part-conc1 cst)
                  (smtp-cst-imf-local-part-conc1 cst-equiv)))
  :rule-classes :congruence)

Function: smtp-cst-imf-local-part-conc2

(defun smtp-cst-imf-local-part-conc2 (cst)
  (declare (xargs :guard (treep cst)))
  (declare
       (xargs :guard (and (smtp-cst-matchp cst "imf-local-part")
                          (equal (smtp-cst-imf-local-part-conc? cst)
                                 2))))
  (let ((__function__ 'smtp-cst-imf-local-part-conc2))
    (declare (ignorable __function__))
    (tree-nonleaf->branches cst)))

Theorem: tree-list-listp-of-smtp-cst-imf-local-part-conc2

(defthm tree-list-listp-of-smtp-cst-imf-local-part-conc2
  (b* ((cstss (smtp-cst-imf-local-part-conc2 cst)))
    (tree-list-listp cstss))
  :rule-classes :rewrite)

Theorem: smtp-cst-imf-local-part-conc2-match

(defthm smtp-cst-imf-local-part-conc2-match
 (implies
      (and (smtp-cst-matchp cst "imf-local-part")
           (equal (smtp-cst-imf-local-part-conc? cst)
                  2))
      (b* ((cstss (smtp-cst-imf-local-part-conc2 cst)))
        (smtp-cst-list-list-conc-matchp cstss "imf-quoted-string")))
 :rule-classes :rewrite)

Theorem: smtp-cst-imf-local-part-conc2-of-tree-fix-cst

(defthm smtp-cst-imf-local-part-conc2-of-tree-fix-cst
  (equal (smtp-cst-imf-local-part-conc2 (tree-fix cst))
         (smtp-cst-imf-local-part-conc2 cst)))

Theorem: smtp-cst-imf-local-part-conc2-tree-equiv-congruence-on-cst

(defthm smtp-cst-imf-local-part-conc2-tree-equiv-congruence-on-cst
  (implies (tree-equiv cst cst-equiv)
           (equal (smtp-cst-imf-local-part-conc2 cst)
                  (smtp-cst-imf-local-part-conc2 cst-equiv)))
  :rule-classes :congruence)

Function: smtp-cst-imf-local-part-conc3

(defun smtp-cst-imf-local-part-conc3 (cst)
  (declare (xargs :guard (treep cst)))
  (declare
       (xargs :guard (and (smtp-cst-matchp cst "imf-local-part")
                          (equal (smtp-cst-imf-local-part-conc? cst)
                                 3))))
  (let ((__function__ 'smtp-cst-imf-local-part-conc3))
    (declare (ignorable __function__))
    (tree-nonleaf->branches cst)))

Theorem: tree-list-listp-of-smtp-cst-imf-local-part-conc3

(defthm tree-list-listp-of-smtp-cst-imf-local-part-conc3
  (b* ((cstss (smtp-cst-imf-local-part-conc3 cst)))
    (tree-list-listp cstss))
  :rule-classes :rewrite)

Theorem: smtp-cst-imf-local-part-conc3-match

(defthm smtp-cst-imf-local-part-conc3-match
  (implies
       (and (smtp-cst-matchp cst "imf-local-part")
            (equal (smtp-cst-imf-local-part-conc? cst)
                   3))
       (b* ((cstss (smtp-cst-imf-local-part-conc3 cst)))
         (smtp-cst-list-list-conc-matchp cstss "obs-local-part")))
  :rule-classes :rewrite)

Theorem: smtp-cst-imf-local-part-conc3-of-tree-fix-cst

(defthm smtp-cst-imf-local-part-conc3-of-tree-fix-cst
  (equal (smtp-cst-imf-local-part-conc3 (tree-fix cst))
         (smtp-cst-imf-local-part-conc3 cst)))

Theorem: smtp-cst-imf-local-part-conc3-tree-equiv-congruence-on-cst

(defthm smtp-cst-imf-local-part-conc3-tree-equiv-congruence-on-cst
  (implies (tree-equiv cst cst-equiv)
           (equal (smtp-cst-imf-local-part-conc3 cst)
                  (smtp-cst-imf-local-part-conc3 cst-equiv)))
  :rule-classes :congruence)

Function: smtp-cst-dot-atom-conc

(defun smtp-cst-dot-atom-conc (cst)
  (declare (xargs :guard (treep cst)))
  (declare (xargs :guard (smtp-cst-matchp cst "dot-atom")))
  (let ((__function__ 'smtp-cst-dot-atom-conc))
    (declare (ignorable __function__))
    (tree-nonleaf->branches cst)))

Theorem: tree-list-listp-of-smtp-cst-dot-atom-conc

(defthm tree-list-listp-of-smtp-cst-dot-atom-conc
  (b* ((cstss (smtp-cst-dot-atom-conc cst)))
    (tree-list-listp cstss))
  :rule-classes :rewrite)

Theorem: smtp-cst-dot-atom-conc-match

(defthm smtp-cst-dot-atom-conc-match
  (implies (smtp-cst-matchp cst "dot-atom")
           (b* ((cstss (smtp-cst-dot-atom-conc cst)))
             (smtp-cst-list-list-conc-matchp
                  cstss
                  "[ cfws ] dot-atom-text [ cfws ]")))
  :rule-classes :rewrite)

Theorem: smtp-cst-dot-atom-conc-of-tree-fix-cst

(defthm smtp-cst-dot-atom-conc-of-tree-fix-cst
  (equal (smtp-cst-dot-atom-conc (tree-fix cst))
         (smtp-cst-dot-atom-conc cst)))

Theorem: smtp-cst-dot-atom-conc-tree-equiv-congruence-on-cst

(defthm smtp-cst-dot-atom-conc-tree-equiv-congruence-on-cst
  (implies (tree-equiv cst cst-equiv)
           (equal (smtp-cst-dot-atom-conc cst)
                  (smtp-cst-dot-atom-conc cst-equiv)))
  :rule-classes :congruence)

Function: smtp-cst-imf-quoted-string-conc

(defun smtp-cst-imf-quoted-string-conc (cst)
  (declare (xargs :guard (treep cst)))
  (declare (xargs :guard (smtp-cst-matchp cst "imf-quoted-string")))
  (let ((__function__ 'smtp-cst-imf-quoted-string-conc))
    (declare (ignorable __function__))
    (tree-nonleaf->branches cst)))

Theorem: tree-list-listp-of-smtp-cst-imf-quoted-string-conc

(defthm tree-list-listp-of-smtp-cst-imf-quoted-string-conc
  (b* ((cstss (smtp-cst-imf-quoted-string-conc cst)))
    (tree-list-listp cstss))
  :rule-classes :rewrite)

Theorem: smtp-cst-imf-quoted-string-conc-match

(defthm smtp-cst-imf-quoted-string-conc-match
 (implies
  (smtp-cst-matchp cst "imf-quoted-string")
  (b* ((cstss (smtp-cst-imf-quoted-string-conc cst)))
   (smtp-cst-list-list-conc-matchp
    cstss
    "[ cfws ] dquote *( [ fws ] qcontent ) [ fws ] dquote [ cfws ]")))
 :rule-classes :rewrite)

Theorem: smtp-cst-imf-quoted-string-conc-of-tree-fix-cst

(defthm smtp-cst-imf-quoted-string-conc-of-tree-fix-cst
  (equal (smtp-cst-imf-quoted-string-conc (tree-fix cst))
         (smtp-cst-imf-quoted-string-conc cst)))

Theorem: smtp-cst-imf-quoted-string-conc-tree-equiv-congruence-on-cst

(defthm smtp-cst-imf-quoted-string-conc-tree-equiv-congruence-on-cst
  (implies (tree-equiv cst cst-equiv)
           (equal (smtp-cst-imf-quoted-string-conc cst)
                  (smtp-cst-imf-quoted-string-conc cst-equiv)))
  :rule-classes :congruence)

Function: smtp-cst-obs-id-right-conc

(defun smtp-cst-obs-id-right-conc (cst)
  (declare (xargs :guard (treep cst)))
  (declare (xargs :guard (smtp-cst-matchp cst "obs-id-right")))
  (let ((__function__ 'smtp-cst-obs-id-right-conc))
    (declare (ignorable __function__))
    (tree-nonleaf->branches cst)))

Theorem: tree-list-listp-of-smtp-cst-obs-id-right-conc

(defthm tree-list-listp-of-smtp-cst-obs-id-right-conc
  (b* ((cstss (smtp-cst-obs-id-right-conc cst)))
    (tree-list-listp cstss))
  :rule-classes :rewrite)

Theorem: smtp-cst-obs-id-right-conc-match

(defthm smtp-cst-obs-id-right-conc-match
  (implies (smtp-cst-matchp cst "obs-id-right")
           (b* ((cstss (smtp-cst-obs-id-right-conc cst)))
             (smtp-cst-list-list-conc-matchp cstss "imf-domain")))
  :rule-classes :rewrite)

Theorem: smtp-cst-obs-id-right-conc-of-tree-fix-cst

(defthm smtp-cst-obs-id-right-conc-of-tree-fix-cst
  (equal (smtp-cst-obs-id-right-conc (tree-fix cst))
         (smtp-cst-obs-id-right-conc cst)))

Theorem: smtp-cst-obs-id-right-conc-tree-equiv-congruence-on-cst

(defthm smtp-cst-obs-id-right-conc-tree-equiv-congruence-on-cst
  (implies (tree-equiv cst cst-equiv)
           (equal (smtp-cst-obs-id-right-conc cst)
                  (smtp-cst-obs-id-right-conc cst-equiv)))
  :rule-classes :congruence)

Function: smtp-cst-imf-domain-conc1

(defun smtp-cst-imf-domain-conc1 (cst)
  (declare (xargs :guard (treep cst)))
  (declare (xargs :guard (and (smtp-cst-matchp cst "imf-domain")
                              (equal (smtp-cst-imf-domain-conc? cst)
                                     1))))
  (let ((__function__ 'smtp-cst-imf-domain-conc1))
    (declare (ignorable __function__))
    (tree-nonleaf->branches cst)))

Theorem: tree-list-listp-of-smtp-cst-imf-domain-conc1

(defthm tree-list-listp-of-smtp-cst-imf-domain-conc1
  (b* ((cstss (smtp-cst-imf-domain-conc1 cst)))
    (tree-list-listp cstss))
  :rule-classes :rewrite)

Theorem: smtp-cst-imf-domain-conc1-match

(defthm smtp-cst-imf-domain-conc1-match
  (implies (and (smtp-cst-matchp cst "imf-domain")
                (equal (smtp-cst-imf-domain-conc? cst)
                       1))
           (b* ((cstss (smtp-cst-imf-domain-conc1 cst)))
             (smtp-cst-list-list-conc-matchp cstss "dot-atom")))
  :rule-classes :rewrite)

Theorem: smtp-cst-imf-domain-conc1-of-tree-fix-cst

(defthm smtp-cst-imf-domain-conc1-of-tree-fix-cst
  (equal (smtp-cst-imf-domain-conc1 (tree-fix cst))
         (smtp-cst-imf-domain-conc1 cst)))

Theorem: smtp-cst-imf-domain-conc1-tree-equiv-congruence-on-cst

(defthm smtp-cst-imf-domain-conc1-tree-equiv-congruence-on-cst
  (implies (tree-equiv cst cst-equiv)
           (equal (smtp-cst-imf-domain-conc1 cst)
                  (smtp-cst-imf-domain-conc1 cst-equiv)))
  :rule-classes :congruence)

Function: smtp-cst-imf-domain-conc2

(defun smtp-cst-imf-domain-conc2 (cst)
  (declare (xargs :guard (treep cst)))
  (declare (xargs :guard (and (smtp-cst-matchp cst "imf-domain")
                              (equal (smtp-cst-imf-domain-conc? cst)
                                     2))))
  (let ((__function__ 'smtp-cst-imf-domain-conc2))
    (declare (ignorable __function__))
    (tree-nonleaf->branches cst)))

Theorem: tree-list-listp-of-smtp-cst-imf-domain-conc2

(defthm tree-list-listp-of-smtp-cst-imf-domain-conc2
  (b* ((cstss (smtp-cst-imf-domain-conc2 cst)))
    (tree-list-listp cstss))
  :rule-classes :rewrite)

Theorem: smtp-cst-imf-domain-conc2-match

(defthm smtp-cst-imf-domain-conc2-match
  (implies
       (and (smtp-cst-matchp cst "imf-domain")
            (equal (smtp-cst-imf-domain-conc? cst)
                   2))
       (b* ((cstss (smtp-cst-imf-domain-conc2 cst)))
         (smtp-cst-list-list-conc-matchp cstss "domain-literal")))
  :rule-classes :rewrite)

Theorem: smtp-cst-imf-domain-conc2-of-tree-fix-cst

(defthm smtp-cst-imf-domain-conc2-of-tree-fix-cst
  (equal (smtp-cst-imf-domain-conc2 (tree-fix cst))
         (smtp-cst-imf-domain-conc2 cst)))

Theorem: smtp-cst-imf-domain-conc2-tree-equiv-congruence-on-cst

(defthm smtp-cst-imf-domain-conc2-tree-equiv-congruence-on-cst
  (implies (tree-equiv cst cst-equiv)
           (equal (smtp-cst-imf-domain-conc2 cst)
                  (smtp-cst-imf-domain-conc2 cst-equiv)))
  :rule-classes :congruence)

Function: smtp-cst-imf-domain-conc3

(defun smtp-cst-imf-domain-conc3 (cst)
  (declare (xargs :guard (treep cst)))
  (declare (xargs :guard (and (smtp-cst-matchp cst "imf-domain")
                              (equal (smtp-cst-imf-domain-conc? cst)
                                     3))))
  (let ((__function__ 'smtp-cst-imf-domain-conc3))
    (declare (ignorable __function__))
    (tree-nonleaf->branches cst)))

Theorem: tree-list-listp-of-smtp-cst-imf-domain-conc3

(defthm tree-list-listp-of-smtp-cst-imf-domain-conc3
  (b* ((cstss (smtp-cst-imf-domain-conc3 cst)))
    (tree-list-listp cstss))
  :rule-classes :rewrite)

Theorem: smtp-cst-imf-domain-conc3-match

(defthm smtp-cst-imf-domain-conc3-match
  (implies (and (smtp-cst-matchp cst "imf-domain")
                (equal (smtp-cst-imf-domain-conc? cst)
                       3))
           (b* ((cstss (smtp-cst-imf-domain-conc3 cst)))
             (smtp-cst-list-list-conc-matchp cstss "obs-domain")))
  :rule-classes :rewrite)

Theorem: smtp-cst-imf-domain-conc3-of-tree-fix-cst

(defthm smtp-cst-imf-domain-conc3-of-tree-fix-cst
  (equal (smtp-cst-imf-domain-conc3 (tree-fix cst))
         (smtp-cst-imf-domain-conc3 cst)))

Theorem: smtp-cst-imf-domain-conc3-tree-equiv-congruence-on-cst

(defthm smtp-cst-imf-domain-conc3-tree-equiv-congruence-on-cst
  (implies (tree-equiv cst cst-equiv)
           (equal (smtp-cst-imf-domain-conc3 cst)
                  (smtp-cst-imf-domain-conc3 cst-equiv)))
  :rule-classes :congruence)

Function: smtp-cst-domain-literal-conc

(defun smtp-cst-domain-literal-conc (cst)
  (declare (xargs :guard (treep cst)))
  (declare (xargs :guard (smtp-cst-matchp cst "domain-literal")))
  (let ((__function__ 'smtp-cst-domain-literal-conc))
    (declare (ignorable __function__))
    (tree-nonleaf->branches cst)))

Theorem: tree-list-listp-of-smtp-cst-domain-literal-conc

(defthm tree-list-listp-of-smtp-cst-domain-literal-conc
  (b* ((cstss (smtp-cst-domain-literal-conc cst)))
    (tree-list-listp cstss))
  :rule-classes :rewrite)

Theorem: smtp-cst-domain-literal-conc-match

(defthm smtp-cst-domain-literal-conc-match
 (implies
    (smtp-cst-matchp cst "domain-literal")
    (b* ((cstss (smtp-cst-domain-literal-conc cst)))
      (smtp-cst-list-list-conc-matchp
           cstss
           "[ cfws ] \"[\" *( [ fws ] dtext ) [ fws ] \"]\" [ cfws ]")))
 :rule-classes :rewrite)

Theorem: smtp-cst-domain-literal-conc-of-tree-fix-cst

(defthm smtp-cst-domain-literal-conc-of-tree-fix-cst
  (equal (smtp-cst-domain-literal-conc (tree-fix cst))
         (smtp-cst-domain-literal-conc cst)))

Theorem: smtp-cst-domain-literal-conc-tree-equiv-congruence-on-cst

(defthm smtp-cst-domain-literal-conc-tree-equiv-congruence-on-cst
  (implies (tree-equiv cst cst-equiv)
           (equal (smtp-cst-domain-literal-conc cst)
                  (smtp-cst-domain-literal-conc cst-equiv)))
  :rule-classes :congruence)

Function: smtp-cst-obs-domain-conc

(defun smtp-cst-obs-domain-conc (cst)
  (declare (xargs :guard (treep cst)))
  (declare (xargs :guard (smtp-cst-matchp cst "obs-domain")))
  (let ((__function__ 'smtp-cst-obs-domain-conc))
    (declare (ignorable __function__))
    (tree-nonleaf->branches cst)))

Theorem: tree-list-listp-of-smtp-cst-obs-domain-conc

(defthm tree-list-listp-of-smtp-cst-obs-domain-conc
  (b* ((cstss (smtp-cst-obs-domain-conc cst)))
    (tree-list-listp cstss))
  :rule-classes :rewrite)

Theorem: smtp-cst-obs-domain-conc-match

(defthm smtp-cst-obs-domain-conc-match
  (implies (smtp-cst-matchp cst "obs-domain")
           (b* ((cstss (smtp-cst-obs-domain-conc cst)))
             (smtp-cst-list-list-conc-matchp
                  cstss "imf-atom *( \".\" imf-atom )")))
  :rule-classes :rewrite)

Theorem: smtp-cst-obs-domain-conc-of-tree-fix-cst

(defthm smtp-cst-obs-domain-conc-of-tree-fix-cst
  (equal (smtp-cst-obs-domain-conc (tree-fix cst))
         (smtp-cst-obs-domain-conc cst)))

Theorem: smtp-cst-obs-domain-conc-tree-equiv-congruence-on-cst

(defthm smtp-cst-obs-domain-conc-tree-equiv-congruence-on-cst
  (implies (tree-equiv cst cst-equiv)
           (equal (smtp-cst-obs-domain-conc cst)
                  (smtp-cst-obs-domain-conc cst-equiv)))
  :rule-classes :congruence)

Function: smtp-cst-imf-atom-conc

(defun smtp-cst-imf-atom-conc (cst)
  (declare (xargs :guard (treep cst)))
  (declare (xargs :guard (smtp-cst-matchp cst "imf-atom")))
  (let ((__function__ 'smtp-cst-imf-atom-conc))
    (declare (ignorable __function__))
    (tree-nonleaf->branches cst)))

Theorem: tree-list-listp-of-smtp-cst-imf-atom-conc

(defthm tree-list-listp-of-smtp-cst-imf-atom-conc
  (b* ((cstss (smtp-cst-imf-atom-conc cst)))
    (tree-list-listp cstss))
  :rule-classes :rewrite)

Theorem: smtp-cst-imf-atom-conc-match

(defthm smtp-cst-imf-atom-conc-match
  (implies (smtp-cst-matchp cst "imf-atom")
           (b* ((cstss (smtp-cst-imf-atom-conc cst)))
             (smtp-cst-list-list-conc-matchp
                  cstss "[ cfws ] 1*atext [ cfws ]")))
  :rule-classes :rewrite)

Theorem: smtp-cst-imf-atom-conc-of-tree-fix-cst

(defthm smtp-cst-imf-atom-conc-of-tree-fix-cst
  (equal (smtp-cst-imf-atom-conc (tree-fix cst))
         (smtp-cst-imf-atom-conc cst)))

Theorem: smtp-cst-imf-atom-conc-tree-equiv-congruence-on-cst

(defthm smtp-cst-imf-atom-conc-tree-equiv-congruence-on-cst
  (implies (tree-equiv cst cst-equiv)
           (equal (smtp-cst-imf-atom-conc cst)
                  (smtp-cst-imf-atom-conc cst-equiv)))
  :rule-classes :congruence)

Function: smtp-cst-obs-local-part-conc

(defun smtp-cst-obs-local-part-conc (cst)
  (declare (xargs :guard (treep cst)))
  (declare (xargs :guard (smtp-cst-matchp cst "obs-local-part")))
  (let ((__function__ 'smtp-cst-obs-local-part-conc))
    (declare (ignorable __function__))
    (tree-nonleaf->branches cst)))

Theorem: tree-list-listp-of-smtp-cst-obs-local-part-conc

(defthm tree-list-listp-of-smtp-cst-obs-local-part-conc
  (b* ((cstss (smtp-cst-obs-local-part-conc cst)))
    (tree-list-listp cstss))
  :rule-classes :rewrite)

Theorem: smtp-cst-obs-local-part-conc-match

(defthm smtp-cst-obs-local-part-conc-match
 (implies
     (smtp-cst-matchp cst "obs-local-part")
     (b* ((cstss (smtp-cst-obs-local-part-conc cst)))
       (smtp-cst-list-list-conc-matchp cstss "word *( \".\" word )")))
 :rule-classes :rewrite)

Theorem: smtp-cst-obs-local-part-conc-of-tree-fix-cst

(defthm smtp-cst-obs-local-part-conc-of-tree-fix-cst
  (equal (smtp-cst-obs-local-part-conc (tree-fix cst))
         (smtp-cst-obs-local-part-conc cst)))

Theorem: smtp-cst-obs-local-part-conc-tree-equiv-congruence-on-cst

(defthm smtp-cst-obs-local-part-conc-tree-equiv-congruence-on-cst
  (implies (tree-equiv cst cst-equiv)
           (equal (smtp-cst-obs-local-part-conc cst)
                  (smtp-cst-obs-local-part-conc cst-equiv)))
  :rule-classes :congruence)

Function: smtp-cst-qcontent-conc1

(defun smtp-cst-qcontent-conc1 (cst)
  (declare (xargs :guard (treep cst)))
  (declare (xargs :guard (and (smtp-cst-matchp cst "qcontent")
                              (equal (smtp-cst-qcontent-conc? cst)
                                     1))))
  (let ((__function__ 'smtp-cst-qcontent-conc1))
    (declare (ignorable __function__))
    (tree-nonleaf->branches cst)))

Theorem: tree-list-listp-of-smtp-cst-qcontent-conc1

(defthm tree-list-listp-of-smtp-cst-qcontent-conc1
  (b* ((cstss (smtp-cst-qcontent-conc1 cst)))
    (tree-list-listp cstss))
  :rule-classes :rewrite)

Theorem: smtp-cst-qcontent-conc1-match

(defthm smtp-cst-qcontent-conc1-match
  (implies (and (smtp-cst-matchp cst "qcontent")
                (equal (smtp-cst-qcontent-conc? cst) 1))
           (b* ((cstss (smtp-cst-qcontent-conc1 cst)))
             (smtp-cst-list-list-conc-matchp cstss "qtext")))
  :rule-classes :rewrite)

Theorem: smtp-cst-qcontent-conc1-of-tree-fix-cst

(defthm smtp-cst-qcontent-conc1-of-tree-fix-cst
  (equal (smtp-cst-qcontent-conc1 (tree-fix cst))
         (smtp-cst-qcontent-conc1 cst)))

Theorem: smtp-cst-qcontent-conc1-tree-equiv-congruence-on-cst

(defthm smtp-cst-qcontent-conc1-tree-equiv-congruence-on-cst
  (implies (tree-equiv cst cst-equiv)
           (equal (smtp-cst-qcontent-conc1 cst)
                  (smtp-cst-qcontent-conc1 cst-equiv)))
  :rule-classes :congruence)

Function: smtp-cst-qcontent-conc2

(defun smtp-cst-qcontent-conc2 (cst)
  (declare (xargs :guard (treep cst)))
  (declare (xargs :guard (and (smtp-cst-matchp cst "qcontent")
                              (equal (smtp-cst-qcontent-conc? cst)
                                     2))))
  (let ((__function__ 'smtp-cst-qcontent-conc2))
    (declare (ignorable __function__))
    (tree-nonleaf->branches cst)))

Theorem: tree-list-listp-of-smtp-cst-qcontent-conc2

(defthm tree-list-listp-of-smtp-cst-qcontent-conc2
  (b* ((cstss (smtp-cst-qcontent-conc2 cst)))
    (tree-list-listp cstss))
  :rule-classes :rewrite)

Theorem: smtp-cst-qcontent-conc2-match

(defthm smtp-cst-qcontent-conc2-match
  (implies (and (smtp-cst-matchp cst "qcontent")
                (equal (smtp-cst-qcontent-conc? cst) 2))
           (b* ((cstss (smtp-cst-qcontent-conc2 cst)))
             (smtp-cst-list-list-conc-matchp cstss "quoted-pair")))
  :rule-classes :rewrite)

Theorem: smtp-cst-qcontent-conc2-of-tree-fix-cst

(defthm smtp-cst-qcontent-conc2-of-tree-fix-cst
  (equal (smtp-cst-qcontent-conc2 (tree-fix cst))
         (smtp-cst-qcontent-conc2 cst)))

Theorem: smtp-cst-qcontent-conc2-tree-equiv-congruence-on-cst

(defthm smtp-cst-qcontent-conc2-tree-equiv-congruence-on-cst
  (implies (tree-equiv cst cst-equiv)
           (equal (smtp-cst-qcontent-conc2 cst)
                  (smtp-cst-qcontent-conc2 cst-equiv)))
  :rule-classes :congruence)

Function: smtp-cst-obs-qtext-conc

(defun smtp-cst-obs-qtext-conc (cst)
  (declare (xargs :guard (treep cst)))
  (declare (xargs :guard (smtp-cst-matchp cst "obs-qtext")))
  (let ((__function__ 'smtp-cst-obs-qtext-conc))
    (declare (ignorable __function__))
    (tree-nonleaf->branches cst)))

Theorem: tree-list-listp-of-smtp-cst-obs-qtext-conc

(defthm tree-list-listp-of-smtp-cst-obs-qtext-conc
  (b* ((cstss (smtp-cst-obs-qtext-conc cst)))
    (tree-list-listp cstss))
  :rule-classes :rewrite)

Theorem: smtp-cst-obs-qtext-conc-match

(defthm smtp-cst-obs-qtext-conc-match
 (implies (smtp-cst-matchp cst "obs-qtext")
          (b* ((cstss (smtp-cst-obs-qtext-conc cst)))
            (smtp-cst-list-list-conc-matchp cstss "obs-no-ws-ctl")))
 :rule-classes :rewrite)

Theorem: smtp-cst-obs-qtext-conc-of-tree-fix-cst

(defthm smtp-cst-obs-qtext-conc-of-tree-fix-cst
  (equal (smtp-cst-obs-qtext-conc (tree-fix cst))
         (smtp-cst-obs-qtext-conc cst)))

Theorem: smtp-cst-obs-qtext-conc-tree-equiv-congruence-on-cst

(defthm smtp-cst-obs-qtext-conc-tree-equiv-congruence-on-cst
  (implies (tree-equiv cst cst-equiv)
           (equal (smtp-cst-obs-qtext-conc cst)
                  (smtp-cst-obs-qtext-conc cst-equiv)))
  :rule-classes :congruence)

Function: smtp-cst-obs-qp-conc

(defun smtp-cst-obs-qp-conc (cst)
  (declare (xargs :guard (treep cst)))
  (declare (xargs :guard (smtp-cst-matchp cst "obs-qp")))
  (let ((__function__ 'smtp-cst-obs-qp-conc))
    (declare (ignorable __function__))
    (tree-nonleaf->branches cst)))

Theorem: tree-list-listp-of-smtp-cst-obs-qp-conc

(defthm tree-list-listp-of-smtp-cst-obs-qp-conc
  (b* ((cstss (smtp-cst-obs-qp-conc cst)))
    (tree-list-listp cstss))
  :rule-classes :rewrite)

Theorem: smtp-cst-obs-qp-conc-match

(defthm smtp-cst-obs-qp-conc-match
  (implies (smtp-cst-matchp cst "obs-qp")
           (b* ((cstss (smtp-cst-obs-qp-conc cst)))
             (smtp-cst-list-list-conc-matchp
                  cstss
                  "\"\\\" ( %d0 / obs-no-ws-ctl / lf / cr )")))
  :rule-classes :rewrite)

Theorem: smtp-cst-obs-qp-conc-of-tree-fix-cst

(defthm smtp-cst-obs-qp-conc-of-tree-fix-cst
  (equal (smtp-cst-obs-qp-conc (tree-fix cst))
         (smtp-cst-obs-qp-conc cst)))

Theorem: smtp-cst-obs-qp-conc-tree-equiv-congruence-on-cst

(defthm smtp-cst-obs-qp-conc-tree-equiv-congruence-on-cst
  (implies (tree-equiv cst cst-equiv)
           (equal (smtp-cst-obs-qp-conc cst)
                  (smtp-cst-obs-qp-conc cst-equiv)))
  :rule-classes :congruence)

Function: smtp-cst-time-conc

(defun smtp-cst-time-conc (cst)
  (declare (xargs :guard (treep cst)))
  (declare (xargs :guard (smtp-cst-matchp cst "time")))
  (let ((__function__ 'smtp-cst-time-conc))
    (declare (ignorable __function__))
    (tree-nonleaf->branches cst)))

Theorem: tree-list-listp-of-smtp-cst-time-conc

(defthm tree-list-listp-of-smtp-cst-time-conc
  (b* ((cstss (smtp-cst-time-conc cst)))
    (tree-list-listp cstss))
  :rule-classes :rewrite)

Theorem: smtp-cst-time-conc-match

(defthm smtp-cst-time-conc-match
  (implies
       (smtp-cst-matchp cst "time")
       (b* ((cstss (smtp-cst-time-conc cst)))
         (smtp-cst-list-list-conc-matchp cstss "time-of-day zone")))
  :rule-classes :rewrite)

Theorem: smtp-cst-time-conc-of-tree-fix-cst

(defthm smtp-cst-time-conc-of-tree-fix-cst
  (equal (smtp-cst-time-conc (tree-fix cst))
         (smtp-cst-time-conc cst)))

Theorem: smtp-cst-time-conc-tree-equiv-congruence-on-cst

(defthm smtp-cst-time-conc-tree-equiv-congruence-on-cst
  (implies (tree-equiv cst cst-equiv)
           (equal (smtp-cst-time-conc cst)
                  (smtp-cst-time-conc cst-equiv)))
  :rule-classes :congruence)

Function: smtp-cst-time-of-day-conc

(defun smtp-cst-time-of-day-conc (cst)
  (declare (xargs :guard (treep cst)))
  (declare (xargs :guard (smtp-cst-matchp cst "time-of-day")))
  (let ((__function__ 'smtp-cst-time-of-day-conc))
    (declare (ignorable __function__))
    (tree-nonleaf->branches cst)))

Theorem: tree-list-listp-of-smtp-cst-time-of-day-conc

(defthm tree-list-listp-of-smtp-cst-time-of-day-conc
  (b* ((cstss (smtp-cst-time-of-day-conc cst)))
    (tree-list-listp cstss))
  :rule-classes :rewrite)

Theorem: smtp-cst-time-of-day-conc-match

(defthm smtp-cst-time-of-day-conc-match
  (implies (smtp-cst-matchp cst "time-of-day")
           (b* ((cstss (smtp-cst-time-of-day-conc cst)))
             (smtp-cst-list-list-conc-matchp
                  cstss
                  "hour \":\" minute [ \":\" second ]")))
  :rule-classes :rewrite)

Theorem: smtp-cst-time-of-day-conc-of-tree-fix-cst

(defthm smtp-cst-time-of-day-conc-of-tree-fix-cst
  (equal (smtp-cst-time-of-day-conc (tree-fix cst))
         (smtp-cst-time-of-day-conc cst)))

Theorem: smtp-cst-time-of-day-conc-tree-equiv-congruence-on-cst

(defthm smtp-cst-time-of-day-conc-tree-equiv-congruence-on-cst
  (implies (tree-equiv cst cst-equiv)
           (equal (smtp-cst-time-of-day-conc cst)
                  (smtp-cst-time-of-day-conc cst-equiv)))
  :rule-classes :congruence)

Function: smtp-cst-obs-hour-conc

(defun smtp-cst-obs-hour-conc (cst)
  (declare (xargs :guard (treep cst)))
  (declare (xargs :guard (smtp-cst-matchp cst "obs-hour")))
  (let ((__function__ 'smtp-cst-obs-hour-conc))
    (declare (ignorable __function__))
    (tree-nonleaf->branches cst)))

Theorem: tree-list-listp-of-smtp-cst-obs-hour-conc

(defthm tree-list-listp-of-smtp-cst-obs-hour-conc
  (b* ((cstss (smtp-cst-obs-hour-conc cst)))
    (tree-list-listp cstss))
  :rule-classes :rewrite)

Theorem: smtp-cst-obs-hour-conc-match

(defthm smtp-cst-obs-hour-conc-match
  (implies (smtp-cst-matchp cst "obs-hour")
           (b* ((cstss (smtp-cst-obs-hour-conc cst)))
             (smtp-cst-list-list-conc-matchp
                  cstss "[ cfws ] 2digit [ cfws ]")))
  :rule-classes :rewrite)

Theorem: smtp-cst-obs-hour-conc-of-tree-fix-cst

(defthm smtp-cst-obs-hour-conc-of-tree-fix-cst
  (equal (smtp-cst-obs-hour-conc (tree-fix cst))
         (smtp-cst-obs-hour-conc cst)))

Theorem: smtp-cst-obs-hour-conc-tree-equiv-congruence-on-cst

(defthm smtp-cst-obs-hour-conc-tree-equiv-congruence-on-cst
  (implies (tree-equiv cst cst-equiv)
           (equal (smtp-cst-obs-hour-conc cst)
                  (smtp-cst-obs-hour-conc cst-equiv)))
  :rule-classes :congruence)

Function: smtp-cst-obs-minute-conc

(defun smtp-cst-obs-minute-conc (cst)
  (declare (xargs :guard (treep cst)))
  (declare (xargs :guard (smtp-cst-matchp cst "obs-minute")))
  (let ((__function__ 'smtp-cst-obs-minute-conc))
    (declare (ignorable __function__))
    (tree-nonleaf->branches cst)))

Theorem: tree-list-listp-of-smtp-cst-obs-minute-conc

(defthm tree-list-listp-of-smtp-cst-obs-minute-conc
  (b* ((cstss (smtp-cst-obs-minute-conc cst)))
    (tree-list-listp cstss))
  :rule-classes :rewrite)

Theorem: smtp-cst-obs-minute-conc-match

(defthm smtp-cst-obs-minute-conc-match
  (implies (smtp-cst-matchp cst "obs-minute")
           (b* ((cstss (smtp-cst-obs-minute-conc cst)))
             (smtp-cst-list-list-conc-matchp
                  cstss "[ cfws ] 2digit [ cfws ]")))
  :rule-classes :rewrite)

Theorem: smtp-cst-obs-minute-conc-of-tree-fix-cst

(defthm smtp-cst-obs-minute-conc-of-tree-fix-cst
  (equal (smtp-cst-obs-minute-conc (tree-fix cst))
         (smtp-cst-obs-minute-conc cst)))

Theorem: smtp-cst-obs-minute-conc-tree-equiv-congruence-on-cst

(defthm smtp-cst-obs-minute-conc-tree-equiv-congruence-on-cst
  (implies (tree-equiv cst cst-equiv)
           (equal (smtp-cst-obs-minute-conc cst)
                  (smtp-cst-obs-minute-conc cst-equiv)))
  :rule-classes :congruence)

Function: smtp-cst-obs-second-conc

(defun smtp-cst-obs-second-conc (cst)
  (declare (xargs :guard (treep cst)))
  (declare (xargs :guard (smtp-cst-matchp cst "obs-second")))
  (let ((__function__ 'smtp-cst-obs-second-conc))
    (declare (ignorable __function__))
    (tree-nonleaf->branches cst)))

Theorem: tree-list-listp-of-smtp-cst-obs-second-conc

(defthm tree-list-listp-of-smtp-cst-obs-second-conc
  (b* ((cstss (smtp-cst-obs-second-conc cst)))
    (tree-list-listp cstss))
  :rule-classes :rewrite)

Theorem: smtp-cst-obs-second-conc-match

(defthm smtp-cst-obs-second-conc-match
  (implies (smtp-cst-matchp cst "obs-second")
           (b* ((cstss (smtp-cst-obs-second-conc cst)))
             (smtp-cst-list-list-conc-matchp
                  cstss "[ cfws ] 2digit [ cfws ]")))
  :rule-classes :rewrite)

Theorem: smtp-cst-obs-second-conc-of-tree-fix-cst

(defthm smtp-cst-obs-second-conc-of-tree-fix-cst
  (equal (smtp-cst-obs-second-conc (tree-fix cst))
         (smtp-cst-obs-second-conc cst)))

Theorem: smtp-cst-obs-second-conc-tree-equiv-congruence-on-cst

(defthm smtp-cst-obs-second-conc-tree-equiv-congruence-on-cst
  (implies (tree-equiv cst cst-equiv)
           (equal (smtp-cst-obs-second-conc cst)
                  (smtp-cst-obs-second-conc cst-equiv)))
  :rule-classes :congruence)

Function: smtp-cst-word-conc1

(defun smtp-cst-word-conc1 (cst)
  (declare (xargs :guard (treep cst)))
  (declare (xargs :guard (and (smtp-cst-matchp cst "word")
                              (equal (smtp-cst-word-conc? cst) 1))))
  (let ((__function__ 'smtp-cst-word-conc1))
    (declare (ignorable __function__))
    (tree-nonleaf->branches cst)))

Theorem: tree-list-listp-of-smtp-cst-word-conc1

(defthm tree-list-listp-of-smtp-cst-word-conc1
  (b* ((cstss (smtp-cst-word-conc1 cst)))
    (tree-list-listp cstss))
  :rule-classes :rewrite)

Theorem: smtp-cst-word-conc1-match

(defthm smtp-cst-word-conc1-match
  (implies (and (smtp-cst-matchp cst "word")
                (equal (smtp-cst-word-conc? cst) 1))
           (b* ((cstss (smtp-cst-word-conc1 cst)))
             (smtp-cst-list-list-conc-matchp cstss "imf-atom")))
  :rule-classes :rewrite)

Theorem: smtp-cst-word-conc1-of-tree-fix-cst

(defthm smtp-cst-word-conc1-of-tree-fix-cst
  (equal (smtp-cst-word-conc1 (tree-fix cst))
         (smtp-cst-word-conc1 cst)))

Theorem: smtp-cst-word-conc1-tree-equiv-congruence-on-cst

(defthm smtp-cst-word-conc1-tree-equiv-congruence-on-cst
  (implies (tree-equiv cst cst-equiv)
           (equal (smtp-cst-word-conc1 cst)
                  (smtp-cst-word-conc1 cst-equiv)))
  :rule-classes :congruence)

Function: smtp-cst-word-conc2

(defun smtp-cst-word-conc2 (cst)
  (declare (xargs :guard (treep cst)))
  (declare (xargs :guard (and (smtp-cst-matchp cst "word")
                              (equal (smtp-cst-word-conc? cst) 2))))
  (let ((__function__ 'smtp-cst-word-conc2))
    (declare (ignorable __function__))
    (tree-nonleaf->branches cst)))

Theorem: tree-list-listp-of-smtp-cst-word-conc2

(defthm tree-list-listp-of-smtp-cst-word-conc2
  (b* ((cstss (smtp-cst-word-conc2 cst)))
    (tree-list-listp cstss))
  :rule-classes :rewrite)

Theorem: smtp-cst-word-conc2-match

(defthm smtp-cst-word-conc2-match
 (implies
      (and (smtp-cst-matchp cst "word")
           (equal (smtp-cst-word-conc? cst) 2))
      (b* ((cstss (smtp-cst-word-conc2 cst)))
        (smtp-cst-list-list-conc-matchp cstss "imf-quoted-string")))
 :rule-classes :rewrite)

Theorem: smtp-cst-word-conc2-of-tree-fix-cst

(defthm smtp-cst-word-conc2-of-tree-fix-cst
  (equal (smtp-cst-word-conc2 (tree-fix cst))
         (smtp-cst-word-conc2 cst)))

Theorem: smtp-cst-word-conc2-tree-equiv-congruence-on-cst

(defthm smtp-cst-word-conc2-tree-equiv-congruence-on-cst
  (implies (tree-equiv cst cst-equiv)
           (equal (smtp-cst-word-conc2 cst)
                  (smtp-cst-word-conc2 cst-equiv)))
  :rule-classes :congruence)

Function: smtp-cst-obs-year-conc

(defun smtp-cst-obs-year-conc (cst)
  (declare (xargs :guard (treep cst)))
  (declare (xargs :guard (smtp-cst-matchp cst "obs-year")))
  (let ((__function__ 'smtp-cst-obs-year-conc))
    (declare (ignorable __function__))
    (tree-nonleaf->branches cst)))

Theorem: tree-list-listp-of-smtp-cst-obs-year-conc

(defthm tree-list-listp-of-smtp-cst-obs-year-conc
  (b* ((cstss (smtp-cst-obs-year-conc cst)))
    (tree-list-listp cstss))
  :rule-classes :rewrite)

Theorem: smtp-cst-obs-year-conc-match

(defthm smtp-cst-obs-year-conc-match
  (implies (smtp-cst-matchp cst "obs-year")
           (b* ((cstss (smtp-cst-obs-year-conc cst)))
             (smtp-cst-list-list-conc-matchp
                  cstss "[ cfws ] 2*digit [ cfws ]")))
  :rule-classes :rewrite)

Theorem: smtp-cst-obs-year-conc-of-tree-fix-cst

(defthm smtp-cst-obs-year-conc-of-tree-fix-cst
  (equal (smtp-cst-obs-year-conc (tree-fix cst))
         (smtp-cst-obs-year-conc cst)))

Theorem: smtp-cst-obs-year-conc-tree-equiv-congruence-on-cst

(defthm smtp-cst-obs-year-conc-tree-equiv-congruence-on-cst
  (implies (tree-equiv cst cst-equiv)
           (equal (smtp-cst-obs-year-conc cst)
                  (smtp-cst-obs-year-conc cst-equiv)))
  :rule-classes :congruence)

Function: smtp-cst-cr-conc

(defun smtp-cst-cr-conc (cst)
  (declare (xargs :guard (treep cst)))
  (declare (xargs :guard (smtp-cst-matchp cst "cr")))
  (let ((__function__ 'smtp-cst-cr-conc))
    (declare (ignorable __function__))
    (tree-nonleaf->branches cst)))

Theorem: tree-list-listp-of-smtp-cst-cr-conc

(defthm tree-list-listp-of-smtp-cst-cr-conc
  (b* ((cstss (smtp-cst-cr-conc cst)))
    (tree-list-listp cstss))
  :rule-classes :rewrite)

Theorem: smtp-cst-cr-conc-match

(defthm smtp-cst-cr-conc-match
  (implies (smtp-cst-matchp cst "cr")
           (b* ((cstss (smtp-cst-cr-conc cst)))
             (smtp-cst-list-list-conc-matchp cstss "%xD")))
  :rule-classes :rewrite)

Theorem: smtp-cst-cr-conc-of-tree-fix-cst

(defthm smtp-cst-cr-conc-of-tree-fix-cst
  (equal (smtp-cst-cr-conc (tree-fix cst))
         (smtp-cst-cr-conc cst)))

Theorem: smtp-cst-cr-conc-tree-equiv-congruence-on-cst

(defthm smtp-cst-cr-conc-tree-equiv-congruence-on-cst
  (implies (tree-equiv cst cst-equiv)
           (equal (smtp-cst-cr-conc cst)
                  (smtp-cst-cr-conc cst-equiv)))
  :rule-classes :congruence)

Function: smtp-cst-crlf-conc

(defun smtp-cst-crlf-conc (cst)
  (declare (xargs :guard (treep cst)))
  (declare (xargs :guard (smtp-cst-matchp cst "crlf")))
  (let ((__function__ 'smtp-cst-crlf-conc))
    (declare (ignorable __function__))
    (tree-nonleaf->branches cst)))

Theorem: tree-list-listp-of-smtp-cst-crlf-conc

(defthm tree-list-listp-of-smtp-cst-crlf-conc
  (b* ((cstss (smtp-cst-crlf-conc cst)))
    (tree-list-listp cstss))
  :rule-classes :rewrite)

Theorem: smtp-cst-crlf-conc-match

(defthm smtp-cst-crlf-conc-match
  (implies (smtp-cst-matchp cst "crlf")
           (b* ((cstss (smtp-cst-crlf-conc cst)))
             (smtp-cst-list-list-conc-matchp cstss "cr lf")))
  :rule-classes :rewrite)

Theorem: smtp-cst-crlf-conc-of-tree-fix-cst

(defthm smtp-cst-crlf-conc-of-tree-fix-cst
  (equal (smtp-cst-crlf-conc (tree-fix cst))
         (smtp-cst-crlf-conc cst)))

Theorem: smtp-cst-crlf-conc-tree-equiv-congruence-on-cst

(defthm smtp-cst-crlf-conc-tree-equiv-congruence-on-cst
  (implies (tree-equiv cst cst-equiv)
           (equal (smtp-cst-crlf-conc cst)
                  (smtp-cst-crlf-conc cst-equiv)))
  :rule-classes :congruence)

Function: smtp-cst-digit-conc

(defun smtp-cst-digit-conc (cst)
  (declare (xargs :guard (treep cst)))
  (declare (xargs :guard (smtp-cst-matchp cst "digit")))
  (let ((__function__ 'smtp-cst-digit-conc))
    (declare (ignorable __function__))
    (tree-nonleaf->branches cst)))

Theorem: tree-list-listp-of-smtp-cst-digit-conc

(defthm tree-list-listp-of-smtp-cst-digit-conc
  (b* ((cstss (smtp-cst-digit-conc cst)))
    (tree-list-listp cstss))
  :rule-classes :rewrite)

Theorem: smtp-cst-digit-conc-match

(defthm smtp-cst-digit-conc-match
  (implies (smtp-cst-matchp cst "digit")
           (b* ((cstss (smtp-cst-digit-conc cst)))
             (smtp-cst-list-list-conc-matchp cstss "%x30-39")))
  :rule-classes :rewrite)

Theorem: smtp-cst-digit-conc-of-tree-fix-cst

(defthm smtp-cst-digit-conc-of-tree-fix-cst
  (equal (smtp-cst-digit-conc (tree-fix cst))
         (smtp-cst-digit-conc cst)))

Theorem: smtp-cst-digit-conc-tree-equiv-congruence-on-cst

(defthm smtp-cst-digit-conc-tree-equiv-congruence-on-cst
  (implies (tree-equiv cst cst-equiv)
           (equal (smtp-cst-digit-conc cst)
                  (smtp-cst-digit-conc cst-equiv)))
  :rule-classes :congruence)

Function: smtp-cst-dquote-conc

(defun smtp-cst-dquote-conc (cst)
  (declare (xargs :guard (treep cst)))
  (declare (xargs :guard (smtp-cst-matchp cst "dquote")))
  (let ((__function__ 'smtp-cst-dquote-conc))
    (declare (ignorable __function__))
    (tree-nonleaf->branches cst)))

Theorem: tree-list-listp-of-smtp-cst-dquote-conc

(defthm tree-list-listp-of-smtp-cst-dquote-conc
  (b* ((cstss (smtp-cst-dquote-conc cst)))
    (tree-list-listp cstss))
  :rule-classes :rewrite)

Theorem: smtp-cst-dquote-conc-match

(defthm smtp-cst-dquote-conc-match
  (implies (smtp-cst-matchp cst "dquote")
           (b* ((cstss (smtp-cst-dquote-conc cst)))
             (smtp-cst-list-list-conc-matchp cstss "%x22")))
  :rule-classes :rewrite)

Theorem: smtp-cst-dquote-conc-of-tree-fix-cst

(defthm smtp-cst-dquote-conc-of-tree-fix-cst
  (equal (smtp-cst-dquote-conc (tree-fix cst))
         (smtp-cst-dquote-conc cst)))

Theorem: smtp-cst-dquote-conc-tree-equiv-congruence-on-cst

(defthm smtp-cst-dquote-conc-tree-equiv-congruence-on-cst
  (implies (tree-equiv cst cst-equiv)
           (equal (smtp-cst-dquote-conc cst)
                  (smtp-cst-dquote-conc cst-equiv)))
  :rule-classes :congruence)

Function: smtp-cst-lf-conc

(defun smtp-cst-lf-conc (cst)
  (declare (xargs :guard (treep cst)))
  (declare (xargs :guard (smtp-cst-matchp cst "lf")))
  (let ((__function__ 'smtp-cst-lf-conc))
    (declare (ignorable __function__))
    (tree-nonleaf->branches cst)))

Theorem: tree-list-listp-of-smtp-cst-lf-conc

(defthm tree-list-listp-of-smtp-cst-lf-conc
  (b* ((cstss (smtp-cst-lf-conc cst)))
    (tree-list-listp cstss))
  :rule-classes :rewrite)

Theorem: smtp-cst-lf-conc-match

(defthm smtp-cst-lf-conc-match
  (implies (smtp-cst-matchp cst "lf")
           (b* ((cstss (smtp-cst-lf-conc cst)))
             (smtp-cst-list-list-conc-matchp cstss "%xA")))
  :rule-classes :rewrite)

Theorem: smtp-cst-lf-conc-of-tree-fix-cst

(defthm smtp-cst-lf-conc-of-tree-fix-cst
  (equal (smtp-cst-lf-conc (tree-fix cst))
         (smtp-cst-lf-conc cst)))

Theorem: smtp-cst-lf-conc-tree-equiv-congruence-on-cst

(defthm smtp-cst-lf-conc-tree-equiv-congruence-on-cst
  (implies (tree-equiv cst cst-equiv)
           (equal (smtp-cst-lf-conc cst)
                  (smtp-cst-lf-conc cst-equiv)))
  :rule-classes :congruence)

Function: smtp-cst-sp-conc

(defun smtp-cst-sp-conc (cst)
  (declare (xargs :guard (treep cst)))
  (declare (xargs :guard (smtp-cst-matchp cst "sp")))
  (let ((__function__ 'smtp-cst-sp-conc))
    (declare (ignorable __function__))
    (tree-nonleaf->branches cst)))

Theorem: tree-list-listp-of-smtp-cst-sp-conc

(defthm tree-list-listp-of-smtp-cst-sp-conc
  (b* ((cstss (smtp-cst-sp-conc cst)))
    (tree-list-listp cstss))
  :rule-classes :rewrite)

Theorem: smtp-cst-sp-conc-match

(defthm smtp-cst-sp-conc-match
  (implies (smtp-cst-matchp cst "sp")
           (b* ((cstss (smtp-cst-sp-conc cst)))
             (smtp-cst-list-list-conc-matchp cstss "%x20")))
  :rule-classes :rewrite)

Theorem: smtp-cst-sp-conc-of-tree-fix-cst

(defthm smtp-cst-sp-conc-of-tree-fix-cst
  (equal (smtp-cst-sp-conc (tree-fix cst))
         (smtp-cst-sp-conc cst)))

Theorem: smtp-cst-sp-conc-tree-equiv-congruence-on-cst

(defthm smtp-cst-sp-conc-tree-equiv-congruence-on-cst
  (implies (tree-equiv cst cst-equiv)
           (equal (smtp-cst-sp-conc cst)
                  (smtp-cst-sp-conc cst-equiv)))
  :rule-classes :congruence)

Function: smtp-cst-vchar-conc

(defun smtp-cst-vchar-conc (cst)
  (declare (xargs :guard (treep cst)))
  (declare (xargs :guard (smtp-cst-matchp cst "vchar")))
  (let ((__function__ 'smtp-cst-vchar-conc))
    (declare (ignorable __function__))
    (tree-nonleaf->branches cst)))

Theorem: tree-list-listp-of-smtp-cst-vchar-conc

(defthm tree-list-listp-of-smtp-cst-vchar-conc
  (b* ((cstss (smtp-cst-vchar-conc cst)))
    (tree-list-listp cstss))
  :rule-classes :rewrite)

Theorem: smtp-cst-vchar-conc-match

(defthm smtp-cst-vchar-conc-match
  (implies (smtp-cst-matchp cst "vchar")
           (b* ((cstss (smtp-cst-vchar-conc cst)))
             (smtp-cst-list-list-conc-matchp cstss "%x21-7E")))
  :rule-classes :rewrite)

Theorem: smtp-cst-vchar-conc-of-tree-fix-cst

(defthm smtp-cst-vchar-conc-of-tree-fix-cst
  (equal (smtp-cst-vchar-conc (tree-fix cst))
         (smtp-cst-vchar-conc cst)))

Theorem: smtp-cst-vchar-conc-tree-equiv-congruence-on-cst

(defthm smtp-cst-vchar-conc-tree-equiv-congruence-on-cst
  (implies (tree-equiv cst cst-equiv)
           (equal (smtp-cst-vchar-conc cst)
                  (smtp-cst-vchar-conc cst-equiv)))
  :rule-classes :congruence)

Function: smtp-cst-wsp-conc1

(defun smtp-cst-wsp-conc1 (cst)
  (declare (xargs :guard (treep cst)))
  (declare (xargs :guard (and (smtp-cst-matchp cst "wsp")
                              (equal (smtp-cst-wsp-conc? cst) 1))))
  (let ((__function__ 'smtp-cst-wsp-conc1))
    (declare (ignorable __function__))
    (tree-nonleaf->branches cst)))

Theorem: tree-list-listp-of-smtp-cst-wsp-conc1

(defthm tree-list-listp-of-smtp-cst-wsp-conc1
  (b* ((cstss (smtp-cst-wsp-conc1 cst)))
    (tree-list-listp cstss))
  :rule-classes :rewrite)

Theorem: smtp-cst-wsp-conc1-match

(defthm smtp-cst-wsp-conc1-match
  (implies (and (smtp-cst-matchp cst "wsp")
                (equal (smtp-cst-wsp-conc? cst) 1))
           (b* ((cstss (smtp-cst-wsp-conc1 cst)))
             (smtp-cst-list-list-conc-matchp cstss "sp")))
  :rule-classes :rewrite)

Theorem: smtp-cst-wsp-conc1-of-tree-fix-cst

(defthm smtp-cst-wsp-conc1-of-tree-fix-cst
  (equal (smtp-cst-wsp-conc1 (tree-fix cst))
         (smtp-cst-wsp-conc1 cst)))

Theorem: smtp-cst-wsp-conc1-tree-equiv-congruence-on-cst

(defthm smtp-cst-wsp-conc1-tree-equiv-congruence-on-cst
  (implies (tree-equiv cst cst-equiv)
           (equal (smtp-cst-wsp-conc1 cst)
                  (smtp-cst-wsp-conc1 cst-equiv)))
  :rule-classes :congruence)

Function: smtp-cst-wsp-conc2

(defun smtp-cst-wsp-conc2 (cst)
  (declare (xargs :guard (treep cst)))
  (declare (xargs :guard (and (smtp-cst-matchp cst "wsp")
                              (equal (smtp-cst-wsp-conc? cst) 2))))
  (let ((__function__ 'smtp-cst-wsp-conc2))
    (declare (ignorable __function__))
    (tree-nonleaf->branches cst)))

Theorem: tree-list-listp-of-smtp-cst-wsp-conc2

(defthm tree-list-listp-of-smtp-cst-wsp-conc2
  (b* ((cstss (smtp-cst-wsp-conc2 cst)))
    (tree-list-listp cstss))
  :rule-classes :rewrite)

Theorem: smtp-cst-wsp-conc2-match

(defthm smtp-cst-wsp-conc2-match
  (implies (and (smtp-cst-matchp cst "wsp")
                (equal (smtp-cst-wsp-conc? cst) 2))
           (b* ((cstss (smtp-cst-wsp-conc2 cst)))
             (smtp-cst-list-list-conc-matchp cstss "htab")))
  :rule-classes :rewrite)

Theorem: smtp-cst-wsp-conc2-of-tree-fix-cst

(defthm smtp-cst-wsp-conc2-of-tree-fix-cst
  (equal (smtp-cst-wsp-conc2 (tree-fix cst))
         (smtp-cst-wsp-conc2 cst)))

Theorem: smtp-cst-wsp-conc2-tree-equiv-congruence-on-cst

(defthm smtp-cst-wsp-conc2-tree-equiv-congruence-on-cst
  (implies (tree-equiv cst cst-equiv)
           (equal (smtp-cst-wsp-conc2 cst)
                  (smtp-cst-wsp-conc2 cst-equiv)))
  :rule-classes :congruence)

Function: smtp-cst-htab-conc

(defun smtp-cst-htab-conc (cst)
  (declare (xargs :guard (treep cst)))
  (declare (xargs :guard (smtp-cst-matchp cst "htab")))
  (let ((__function__ 'smtp-cst-htab-conc))
    (declare (ignorable __function__))
    (tree-nonleaf->branches cst)))

Theorem: tree-list-listp-of-smtp-cst-htab-conc

(defthm tree-list-listp-of-smtp-cst-htab-conc
  (b* ((cstss (smtp-cst-htab-conc cst)))
    (tree-list-listp cstss))
  :rule-classes :rewrite)

Theorem: smtp-cst-htab-conc-match

(defthm smtp-cst-htab-conc-match
  (implies (smtp-cst-matchp cst "htab")
           (b* ((cstss (smtp-cst-htab-conc cst)))
             (smtp-cst-list-list-conc-matchp cstss "%x9")))
  :rule-classes :rewrite)

Theorem: smtp-cst-htab-conc-of-tree-fix-cst

(defthm smtp-cst-htab-conc-of-tree-fix-cst
  (equal (smtp-cst-htab-conc (tree-fix cst))
         (smtp-cst-htab-conc cst)))

Theorem: smtp-cst-htab-conc-tree-equiv-congruence-on-cst

(defthm smtp-cst-htab-conc-tree-equiv-congruence-on-cst
  (implies (tree-equiv cst cst-equiv)
           (equal (smtp-cst-htab-conc cst)
                  (smtp-cst-htab-conc cst-equiv)))
  :rule-classes :congruence)

Function: smtp-cst-forward-path-conc-rep

(defun smtp-cst-forward-path-conc-rep (cst)
  (declare (xargs :guard (treep cst)))
  (declare (xargs :guard (smtp-cst-matchp cst "forward-path")))
  (let ((__function__ 'smtp-cst-forward-path-conc-rep))
    (declare (ignorable __function__))
    (tree-list-fix (nth 0 (smtp-cst-forward-path-conc cst)))))

Theorem: tree-listp-of-smtp-cst-forward-path-conc-rep

(defthm tree-listp-of-smtp-cst-forward-path-conc-rep
  (b* ((csts (smtp-cst-forward-path-conc-rep cst)))
    (tree-listp csts))
  :rule-classes :rewrite)

Theorem: smtp-cst-forward-path-conc-rep-match

(defthm smtp-cst-forward-path-conc-rep-match
  (implies (smtp-cst-matchp cst "forward-path")
           (b* ((csts (smtp-cst-forward-path-conc-rep cst)))
             (smtp-cst-list-rep-matchp csts "path")))
  :rule-classes :rewrite)

Theorem: smtp-cst-forward-path-conc-rep-of-tree-fix-cst

(defthm smtp-cst-forward-path-conc-rep-of-tree-fix-cst
  (equal (smtp-cst-forward-path-conc-rep (tree-fix cst))
         (smtp-cst-forward-path-conc-rep cst)))

Theorem: smtp-cst-forward-path-conc-rep-tree-equiv-congruence-on-cst

(defthm smtp-cst-forward-path-conc-rep-tree-equiv-congruence-on-cst
  (implies (tree-equiv cst cst-equiv)
           (equal (smtp-cst-forward-path-conc-rep cst)
                  (smtp-cst-forward-path-conc-rep cst-equiv)))
  :rule-classes :congruence)

Function: smtp-cst-keyword-conc-rep

(defun smtp-cst-keyword-conc-rep (cst)
  (declare (xargs :guard (treep cst)))
  (declare (xargs :guard (smtp-cst-matchp cst "keyword")))
  (let ((__function__ 'smtp-cst-keyword-conc-rep))
    (declare (ignorable __function__))
    (tree-list-fix (nth 0 (smtp-cst-keyword-conc cst)))))

Theorem: tree-listp-of-smtp-cst-keyword-conc-rep

(defthm tree-listp-of-smtp-cst-keyword-conc-rep
  (b* ((csts (smtp-cst-keyword-conc-rep cst)))
    (tree-listp csts))
  :rule-classes :rewrite)

Theorem: smtp-cst-keyword-conc-rep-match

(defthm smtp-cst-keyword-conc-rep-match
  (implies (smtp-cst-matchp cst "keyword")
           (b* ((csts (smtp-cst-keyword-conc-rep cst)))
             (smtp-cst-list-rep-matchp csts "ldh-str")))
  :rule-classes :rewrite)

Theorem: smtp-cst-keyword-conc-rep-of-tree-fix-cst

(defthm smtp-cst-keyword-conc-rep-of-tree-fix-cst
  (equal (smtp-cst-keyword-conc-rep (tree-fix cst))
         (smtp-cst-keyword-conc-rep cst)))

Theorem: smtp-cst-keyword-conc-rep-tree-equiv-congruence-on-cst

(defthm smtp-cst-keyword-conc-rep-tree-equiv-congruence-on-cst
  (implies (tree-equiv cst cst-equiv)
           (equal (smtp-cst-keyword-conc-rep cst)
                  (smtp-cst-keyword-conc-rep cst-equiv)))
  :rule-classes :congruence)

Function: smtp-cst-argument-conc-rep

(defun smtp-cst-argument-conc-rep (cst)
  (declare (xargs :guard (treep cst)))
  (declare (xargs :guard (smtp-cst-matchp cst "argument")))
  (let ((__function__ 'smtp-cst-argument-conc-rep))
    (declare (ignorable __function__))
    (tree-list-fix (nth 0 (smtp-cst-argument-conc cst)))))

Theorem: tree-listp-of-smtp-cst-argument-conc-rep

(defthm tree-listp-of-smtp-cst-argument-conc-rep
  (b* ((csts (smtp-cst-argument-conc-rep cst)))
    (tree-listp csts))
  :rule-classes :rewrite)

Theorem: smtp-cst-argument-conc-rep-match

(defthm smtp-cst-argument-conc-rep-match
  (implies (smtp-cst-matchp cst "argument")
           (b* ((csts (smtp-cst-argument-conc-rep cst)))
             (smtp-cst-list-rep-matchp csts "atom")))
  :rule-classes :rewrite)

Theorem: smtp-cst-argument-conc-rep-of-tree-fix-cst

(defthm smtp-cst-argument-conc-rep-of-tree-fix-cst
  (equal (smtp-cst-argument-conc-rep (tree-fix cst))
         (smtp-cst-argument-conc-rep cst)))

Theorem: smtp-cst-argument-conc-rep-tree-equiv-congruence-on-cst

(defthm smtp-cst-argument-conc-rep-tree-equiv-congruence-on-cst
  (implies (tree-equiv cst cst-equiv)
           (equal (smtp-cst-argument-conc-rep cst)
                  (smtp-cst-argument-conc-rep cst-equiv)))
  :rule-classes :congruence)

Function: smtp-cst-let-dig-conc1-rep

(defun smtp-cst-let-dig-conc1-rep (cst)
  (declare (xargs :guard (treep cst)))
  (declare (xargs :guard (and (smtp-cst-matchp cst "let-dig")
                              (equal (smtp-cst-let-dig-conc? cst)
                                     1))))
  (let ((__function__ 'smtp-cst-let-dig-conc1-rep))
    (declare (ignorable __function__))
    (tree-list-fix (nth 0 (smtp-cst-let-dig-conc1 cst)))))

Theorem: tree-listp-of-smtp-cst-let-dig-conc1-rep

(defthm tree-listp-of-smtp-cst-let-dig-conc1-rep
  (b* ((csts (smtp-cst-let-dig-conc1-rep cst)))
    (tree-listp csts))
  :rule-classes :rewrite)

Theorem: smtp-cst-let-dig-conc1-rep-match

(defthm smtp-cst-let-dig-conc1-rep-match
  (implies (and (smtp-cst-matchp cst "let-dig")
                (equal (smtp-cst-let-dig-conc? cst) 1))
           (b* ((csts (smtp-cst-let-dig-conc1-rep cst)))
             (smtp-cst-list-rep-matchp csts "alpha")))
  :rule-classes :rewrite)

Theorem: smtp-cst-let-dig-conc1-rep-of-tree-fix-cst

(defthm smtp-cst-let-dig-conc1-rep-of-tree-fix-cst
  (equal (smtp-cst-let-dig-conc1-rep (tree-fix cst))
         (smtp-cst-let-dig-conc1-rep cst)))

Theorem: smtp-cst-let-dig-conc1-rep-tree-equiv-congruence-on-cst

(defthm smtp-cst-let-dig-conc1-rep-tree-equiv-congruence-on-cst
  (implies (tree-equiv cst cst-equiv)
           (equal (smtp-cst-let-dig-conc1-rep cst)
                  (smtp-cst-let-dig-conc1-rep cst-equiv)))
  :rule-classes :congruence)

Function: smtp-cst-let-dig-conc2-rep

(defun smtp-cst-let-dig-conc2-rep (cst)
  (declare (xargs :guard (treep cst)))
  (declare (xargs :guard (and (smtp-cst-matchp cst "let-dig")
                              (equal (smtp-cst-let-dig-conc? cst)
                                     2))))
  (let ((__function__ 'smtp-cst-let-dig-conc2-rep))
    (declare (ignorable __function__))
    (tree-list-fix (nth 0 (smtp-cst-let-dig-conc2 cst)))))

Theorem: tree-listp-of-smtp-cst-let-dig-conc2-rep

(defthm tree-listp-of-smtp-cst-let-dig-conc2-rep
  (b* ((csts (smtp-cst-let-dig-conc2-rep cst)))
    (tree-listp csts))
  :rule-classes :rewrite)

Theorem: smtp-cst-let-dig-conc2-rep-match

(defthm smtp-cst-let-dig-conc2-rep-match
  (implies (and (smtp-cst-matchp cst "let-dig")
                (equal (smtp-cst-let-dig-conc? cst) 2))
           (b* ((csts (smtp-cst-let-dig-conc2-rep cst)))
             (smtp-cst-list-rep-matchp csts "digit")))
  :rule-classes :rewrite)

Theorem: smtp-cst-let-dig-conc2-rep-of-tree-fix-cst

(defthm smtp-cst-let-dig-conc2-rep-of-tree-fix-cst
  (equal (smtp-cst-let-dig-conc2-rep (tree-fix cst))
         (smtp-cst-let-dig-conc2-rep cst)))

Theorem: smtp-cst-let-dig-conc2-rep-tree-equiv-congruence-on-cst

(defthm smtp-cst-let-dig-conc2-rep-tree-equiv-congruence-on-cst
  (implies (tree-equiv cst cst-equiv)
           (equal (smtp-cst-let-dig-conc2-rep cst)
                  (smtp-cst-let-dig-conc2-rep cst-equiv)))
  :rule-classes :congruence)

Function: smtp-cst-local-part-conc1-rep

(defun smtp-cst-local-part-conc1-rep (cst)
  (declare (xargs :guard (treep cst)))
  (declare (xargs :guard (and (smtp-cst-matchp cst "local-part")
                              (equal (smtp-cst-local-part-conc? cst)
                                     1))))
  (let ((__function__ 'smtp-cst-local-part-conc1-rep))
    (declare (ignorable __function__))
    (tree-list-fix (nth 0 (smtp-cst-local-part-conc1 cst)))))

Theorem: tree-listp-of-smtp-cst-local-part-conc1-rep

(defthm tree-listp-of-smtp-cst-local-part-conc1-rep
  (b* ((csts (smtp-cst-local-part-conc1-rep cst)))
    (tree-listp csts))
  :rule-classes :rewrite)

Theorem: smtp-cst-local-part-conc1-rep-match

(defthm smtp-cst-local-part-conc1-rep-match
  (implies (and (smtp-cst-matchp cst "local-part")
                (equal (smtp-cst-local-part-conc? cst)
                       1))
           (b* ((csts (smtp-cst-local-part-conc1-rep cst)))
             (smtp-cst-list-rep-matchp csts "dot-string")))
  :rule-classes :rewrite)

Theorem: smtp-cst-local-part-conc1-rep-of-tree-fix-cst

(defthm smtp-cst-local-part-conc1-rep-of-tree-fix-cst
  (equal (smtp-cst-local-part-conc1-rep (tree-fix cst))
         (smtp-cst-local-part-conc1-rep cst)))

Theorem: smtp-cst-local-part-conc1-rep-tree-equiv-congruence-on-cst

(defthm smtp-cst-local-part-conc1-rep-tree-equiv-congruence-on-cst
  (implies (tree-equiv cst cst-equiv)
           (equal (smtp-cst-local-part-conc1-rep cst)
                  (smtp-cst-local-part-conc1-rep cst-equiv)))
  :rule-classes :congruence)

Function: smtp-cst-local-part-conc2-rep

(defun smtp-cst-local-part-conc2-rep (cst)
  (declare (xargs :guard (treep cst)))
  (declare (xargs :guard (and (smtp-cst-matchp cst "local-part")
                              (equal (smtp-cst-local-part-conc? cst)
                                     2))))
  (let ((__function__ 'smtp-cst-local-part-conc2-rep))
    (declare (ignorable __function__))
    (tree-list-fix (nth 0 (smtp-cst-local-part-conc2 cst)))))

Theorem: tree-listp-of-smtp-cst-local-part-conc2-rep

(defthm tree-listp-of-smtp-cst-local-part-conc2-rep
  (b* ((csts (smtp-cst-local-part-conc2-rep cst)))
    (tree-listp csts))
  :rule-classes :rewrite)

Theorem: smtp-cst-local-part-conc2-rep-match

(defthm smtp-cst-local-part-conc2-rep-match
  (implies (and (smtp-cst-matchp cst "local-part")
                (equal (smtp-cst-local-part-conc? cst)
                       2))
           (b* ((csts (smtp-cst-local-part-conc2-rep cst)))
             (smtp-cst-list-rep-matchp csts "quoted-string")))
  :rule-classes :rewrite)

Theorem: smtp-cst-local-part-conc2-rep-of-tree-fix-cst

(defthm smtp-cst-local-part-conc2-rep-of-tree-fix-cst
  (equal (smtp-cst-local-part-conc2-rep (tree-fix cst))
         (smtp-cst-local-part-conc2-rep cst)))

Theorem: smtp-cst-local-part-conc2-rep-tree-equiv-congruence-on-cst

(defthm smtp-cst-local-part-conc2-rep-tree-equiv-congruence-on-cst
  (implies (tree-equiv cst cst-equiv)
           (equal (smtp-cst-local-part-conc2-rep cst)
                  (smtp-cst-local-part-conc2-rep cst-equiv)))
  :rule-classes :congruence)

Function: smtp-cst-qcontentsmtp-conc1-rep

(defun smtp-cst-qcontentsmtp-conc1-rep (cst)
  (declare (xargs :guard (treep cst)))
  (declare
       (xargs :guard (and (smtp-cst-matchp cst "qcontentsmtp")
                          (equal (smtp-cst-qcontentsmtp-conc? cst)
                                 1))))
  (let ((__function__ 'smtp-cst-qcontentsmtp-conc1-rep))
    (declare (ignorable __function__))
    (tree-list-fix (nth 0 (smtp-cst-qcontentsmtp-conc1 cst)))))

Theorem: tree-listp-of-smtp-cst-qcontentsmtp-conc1-rep

(defthm tree-listp-of-smtp-cst-qcontentsmtp-conc1-rep
  (b* ((csts (smtp-cst-qcontentsmtp-conc1-rep cst)))
    (tree-listp csts))
  :rule-classes :rewrite)

Theorem: smtp-cst-qcontentsmtp-conc1-rep-match

(defthm smtp-cst-qcontentsmtp-conc1-rep-match
  (implies (and (smtp-cst-matchp cst "qcontentsmtp")
                (equal (smtp-cst-qcontentsmtp-conc? cst)
                       1))
           (b* ((csts (smtp-cst-qcontentsmtp-conc1-rep cst)))
             (smtp-cst-list-rep-matchp csts "qtextsmtp")))
  :rule-classes :rewrite)

Theorem: smtp-cst-qcontentsmtp-conc1-rep-of-tree-fix-cst

(defthm smtp-cst-qcontentsmtp-conc1-rep-of-tree-fix-cst
  (equal (smtp-cst-qcontentsmtp-conc1-rep (tree-fix cst))
         (smtp-cst-qcontentsmtp-conc1-rep cst)))

Theorem: smtp-cst-qcontentsmtp-conc1-rep-tree-equiv-congruence-on-cst

(defthm smtp-cst-qcontentsmtp-conc1-rep-tree-equiv-congruence-on-cst
  (implies (tree-equiv cst cst-equiv)
           (equal (smtp-cst-qcontentsmtp-conc1-rep cst)
                  (smtp-cst-qcontentsmtp-conc1-rep cst-equiv)))
  :rule-classes :congruence)

Function: smtp-cst-qcontentsmtp-conc2-rep

(defun smtp-cst-qcontentsmtp-conc2-rep (cst)
  (declare (xargs :guard (treep cst)))
  (declare
       (xargs :guard (and (smtp-cst-matchp cst "qcontentsmtp")
                          (equal (smtp-cst-qcontentsmtp-conc? cst)
                                 2))))
  (let ((__function__ 'smtp-cst-qcontentsmtp-conc2-rep))
    (declare (ignorable __function__))
    (tree-list-fix (nth 0 (smtp-cst-qcontentsmtp-conc2 cst)))))

Theorem: tree-listp-of-smtp-cst-qcontentsmtp-conc2-rep

(defthm tree-listp-of-smtp-cst-qcontentsmtp-conc2-rep
  (b* ((csts (smtp-cst-qcontentsmtp-conc2-rep cst)))
    (tree-listp csts))
  :rule-classes :rewrite)

Theorem: smtp-cst-qcontentsmtp-conc2-rep-match

(defthm smtp-cst-qcontentsmtp-conc2-rep-match
  (implies (and (smtp-cst-matchp cst "qcontentsmtp")
                (equal (smtp-cst-qcontentsmtp-conc? cst)
                       2))
           (b* ((csts (smtp-cst-qcontentsmtp-conc2-rep cst)))
             (smtp-cst-list-rep-matchp csts "quoted-pairsmtp")))
  :rule-classes :rewrite)

Theorem: smtp-cst-qcontentsmtp-conc2-rep-of-tree-fix-cst

(defthm smtp-cst-qcontentsmtp-conc2-rep-of-tree-fix-cst
  (equal (smtp-cst-qcontentsmtp-conc2-rep (tree-fix cst))
         (smtp-cst-qcontentsmtp-conc2-rep cst)))

Theorem: smtp-cst-qcontentsmtp-conc2-rep-tree-equiv-congruence-on-cst

(defthm smtp-cst-qcontentsmtp-conc2-rep-tree-equiv-congruence-on-cst
  (implies (tree-equiv cst cst-equiv)
           (equal (smtp-cst-qcontentsmtp-conc2-rep cst)
                  (smtp-cst-qcontentsmtp-conc2-rep cst-equiv)))
  :rule-classes :congruence)

Function: smtp-cst-string-conc1-rep

(defun smtp-cst-string-conc1-rep (cst)
  (declare (xargs :guard (treep cst)))
  (declare
       (xargs :guard (and (smtp-cst-matchp cst "string")
                          (equal (smtp-cst-string-conc? cst) 1))))
  (let ((__function__ 'smtp-cst-string-conc1-rep))
    (declare (ignorable __function__))
    (tree-list-fix (nth 0 (smtp-cst-string-conc1 cst)))))

Theorem: tree-listp-of-smtp-cst-string-conc1-rep

(defthm tree-listp-of-smtp-cst-string-conc1-rep
  (b* ((csts (smtp-cst-string-conc1-rep cst)))
    (tree-listp csts))
  :rule-classes :rewrite)

Theorem: smtp-cst-string-conc1-rep-match

(defthm smtp-cst-string-conc1-rep-match
  (implies (and (smtp-cst-matchp cst "string")
                (equal (smtp-cst-string-conc? cst) 1))
           (b* ((csts (smtp-cst-string-conc1-rep cst)))
             (smtp-cst-list-rep-matchp csts "atom")))
  :rule-classes :rewrite)

Theorem: smtp-cst-string-conc1-rep-of-tree-fix-cst

(defthm smtp-cst-string-conc1-rep-of-tree-fix-cst
  (equal (smtp-cst-string-conc1-rep (tree-fix cst))
         (smtp-cst-string-conc1-rep cst)))

Theorem: smtp-cst-string-conc1-rep-tree-equiv-congruence-on-cst

(defthm smtp-cst-string-conc1-rep-tree-equiv-congruence-on-cst
  (implies (tree-equiv cst cst-equiv)
           (equal (smtp-cst-string-conc1-rep cst)
                  (smtp-cst-string-conc1-rep cst-equiv)))
  :rule-classes :congruence)

Function: smtp-cst-string-conc2-rep

(defun smtp-cst-string-conc2-rep (cst)
  (declare (xargs :guard (treep cst)))
  (declare
       (xargs :guard (and (smtp-cst-matchp cst "string")
                          (equal (smtp-cst-string-conc? cst) 2))))
  (let ((__function__ 'smtp-cst-string-conc2-rep))
    (declare (ignorable __function__))
    (tree-list-fix (nth 0 (smtp-cst-string-conc2 cst)))))

Theorem: tree-listp-of-smtp-cst-string-conc2-rep

(defthm tree-listp-of-smtp-cst-string-conc2-rep
  (b* ((csts (smtp-cst-string-conc2-rep cst)))
    (tree-listp csts))
  :rule-classes :rewrite)

Theorem: smtp-cst-string-conc2-rep-match

(defthm smtp-cst-string-conc2-rep-match
  (implies (and (smtp-cst-matchp cst "string")
                (equal (smtp-cst-string-conc? cst) 2))
           (b* ((csts (smtp-cst-string-conc2-rep cst)))
             (smtp-cst-list-rep-matchp csts "quoted-string")))
  :rule-classes :rewrite)

Theorem: smtp-cst-string-conc2-rep-of-tree-fix-cst

(defthm smtp-cst-string-conc2-rep-of-tree-fix-cst
  (equal (smtp-cst-string-conc2-rep (tree-fix cst))
         (smtp-cst-string-conc2-rep cst)))

Theorem: smtp-cst-string-conc2-rep-tree-equiv-congruence-on-cst

(defthm smtp-cst-string-conc2-rep-tree-equiv-congruence-on-cst
  (implies (tree-equiv cst cst-equiv)
           (equal (smtp-cst-string-conc2-rep cst)
                  (smtp-cst-string-conc2-rep cst-equiv)))
  :rule-classes :congruence)

Function: smtp-cst-standardized-tag-conc-rep

(defun smtp-cst-standardized-tag-conc-rep (cst)
  (declare (xargs :guard (treep cst)))
  (declare (xargs :guard (smtp-cst-matchp cst "standardized-tag")))
  (let ((__function__ 'smtp-cst-standardized-tag-conc-rep))
    (declare (ignorable __function__))
    (tree-list-fix (nth 0
                        (smtp-cst-standardized-tag-conc cst)))))

Theorem: tree-listp-of-smtp-cst-standardized-tag-conc-rep

(defthm tree-listp-of-smtp-cst-standardized-tag-conc-rep
  (b* ((csts (smtp-cst-standardized-tag-conc-rep cst)))
    (tree-listp csts))
  :rule-classes :rewrite)

Theorem: smtp-cst-standardized-tag-conc-rep-match

(defthm smtp-cst-standardized-tag-conc-rep-match
  (implies (smtp-cst-matchp cst "standardized-tag")
           (b* ((csts (smtp-cst-standardized-tag-conc-rep cst)))
             (smtp-cst-list-rep-matchp csts "ldh-str")))
  :rule-classes :rewrite)

Theorem: smtp-cst-standardized-tag-conc-rep-of-tree-fix-cst

(defthm smtp-cst-standardized-tag-conc-rep-of-tree-fix-cst
  (equal (smtp-cst-standardized-tag-conc-rep (tree-fix cst))
         (smtp-cst-standardized-tag-conc-rep cst)))

Theorem: smtp-cst-standardized-tag-conc-rep-tree-equiv-congruence-on-cst

(defthm
    smtp-cst-standardized-tag-conc-rep-tree-equiv-congruence-on-cst
  (implies (tree-equiv cst cst-equiv)
           (equal (smtp-cst-standardized-tag-conc-rep cst)
                  (smtp-cst-standardized-tag-conc-rep cst-equiv)))
  :rule-classes :congruence)

Function: smtp-cst-ipv6-addr-conc1-rep

(defun smtp-cst-ipv6-addr-conc1-rep (cst)
  (declare (xargs :guard (treep cst)))
  (declare (xargs :guard (and (smtp-cst-matchp cst "ipv6-addr")
                              (equal (smtp-cst-ipv6-addr-conc? cst)
                                     1))))
  (let ((__function__ 'smtp-cst-ipv6-addr-conc1-rep))
    (declare (ignorable __function__))
    (tree-list-fix (nth 0 (smtp-cst-ipv6-addr-conc1 cst)))))

Theorem: tree-listp-of-smtp-cst-ipv6-addr-conc1-rep

(defthm tree-listp-of-smtp-cst-ipv6-addr-conc1-rep
  (b* ((csts (smtp-cst-ipv6-addr-conc1-rep cst)))
    (tree-listp csts))
  :rule-classes :rewrite)

Theorem: smtp-cst-ipv6-addr-conc1-rep-match

(defthm smtp-cst-ipv6-addr-conc1-rep-match
  (implies (and (smtp-cst-matchp cst "ipv6-addr")
                (equal (smtp-cst-ipv6-addr-conc? cst)
                       1))
           (b* ((csts (smtp-cst-ipv6-addr-conc1-rep cst)))
             (smtp-cst-list-rep-matchp csts "ipv6-full")))
  :rule-classes :rewrite)

Theorem: smtp-cst-ipv6-addr-conc1-rep-of-tree-fix-cst

(defthm smtp-cst-ipv6-addr-conc1-rep-of-tree-fix-cst
  (equal (smtp-cst-ipv6-addr-conc1-rep (tree-fix cst))
         (smtp-cst-ipv6-addr-conc1-rep cst)))

Theorem: smtp-cst-ipv6-addr-conc1-rep-tree-equiv-congruence-on-cst

(defthm smtp-cst-ipv6-addr-conc1-rep-tree-equiv-congruence-on-cst
  (implies (tree-equiv cst cst-equiv)
           (equal (smtp-cst-ipv6-addr-conc1-rep cst)
                  (smtp-cst-ipv6-addr-conc1-rep cst-equiv)))
  :rule-classes :congruence)

Function: smtp-cst-ipv6-addr-conc2-rep

(defun smtp-cst-ipv6-addr-conc2-rep (cst)
  (declare (xargs :guard (treep cst)))
  (declare (xargs :guard (and (smtp-cst-matchp cst "ipv6-addr")
                              (equal (smtp-cst-ipv6-addr-conc? cst)
                                     2))))
  (let ((__function__ 'smtp-cst-ipv6-addr-conc2-rep))
    (declare (ignorable __function__))
    (tree-list-fix (nth 0 (smtp-cst-ipv6-addr-conc2 cst)))))

Theorem: tree-listp-of-smtp-cst-ipv6-addr-conc2-rep

(defthm tree-listp-of-smtp-cst-ipv6-addr-conc2-rep
  (b* ((csts (smtp-cst-ipv6-addr-conc2-rep cst)))
    (tree-listp csts))
  :rule-classes :rewrite)

Theorem: smtp-cst-ipv6-addr-conc2-rep-match

(defthm smtp-cst-ipv6-addr-conc2-rep-match
  (implies (and (smtp-cst-matchp cst "ipv6-addr")
                (equal (smtp-cst-ipv6-addr-conc? cst)
                       2))
           (b* ((csts (smtp-cst-ipv6-addr-conc2-rep cst)))
             (smtp-cst-list-rep-matchp csts "ipv6-comp")))
  :rule-classes :rewrite)

Theorem: smtp-cst-ipv6-addr-conc2-rep-of-tree-fix-cst

(defthm smtp-cst-ipv6-addr-conc2-rep-of-tree-fix-cst
  (equal (smtp-cst-ipv6-addr-conc2-rep (tree-fix cst))
         (smtp-cst-ipv6-addr-conc2-rep cst)))

Theorem: smtp-cst-ipv6-addr-conc2-rep-tree-equiv-congruence-on-cst

(defthm smtp-cst-ipv6-addr-conc2-rep-tree-equiv-congruence-on-cst
  (implies (tree-equiv cst cst-equiv)
           (equal (smtp-cst-ipv6-addr-conc2-rep cst)
                  (smtp-cst-ipv6-addr-conc2-rep cst-equiv)))
  :rule-classes :congruence)

Function: smtp-cst-ipv6-addr-conc3-rep

(defun smtp-cst-ipv6-addr-conc3-rep (cst)
  (declare (xargs :guard (treep cst)))
  (declare (xargs :guard (and (smtp-cst-matchp cst "ipv6-addr")
                              (equal (smtp-cst-ipv6-addr-conc? cst)
                                     3))))
  (let ((__function__ 'smtp-cst-ipv6-addr-conc3-rep))
    (declare (ignorable __function__))
    (tree-list-fix (nth 0 (smtp-cst-ipv6-addr-conc3 cst)))))

Theorem: tree-listp-of-smtp-cst-ipv6-addr-conc3-rep

(defthm tree-listp-of-smtp-cst-ipv6-addr-conc3-rep
  (b* ((csts (smtp-cst-ipv6-addr-conc3-rep cst)))
    (tree-listp csts))
  :rule-classes :rewrite)

Theorem: smtp-cst-ipv6-addr-conc3-rep-match

(defthm smtp-cst-ipv6-addr-conc3-rep-match
  (implies (and (smtp-cst-matchp cst "ipv6-addr")
                (equal (smtp-cst-ipv6-addr-conc? cst)
                       3))
           (b* ((csts (smtp-cst-ipv6-addr-conc3-rep cst)))
             (smtp-cst-list-rep-matchp csts "ipv6v4-full")))
  :rule-classes :rewrite)

Theorem: smtp-cst-ipv6-addr-conc3-rep-of-tree-fix-cst

(defthm smtp-cst-ipv6-addr-conc3-rep-of-tree-fix-cst
  (equal (smtp-cst-ipv6-addr-conc3-rep (tree-fix cst))
         (smtp-cst-ipv6-addr-conc3-rep cst)))

Theorem: smtp-cst-ipv6-addr-conc3-rep-tree-equiv-congruence-on-cst

(defthm smtp-cst-ipv6-addr-conc3-rep-tree-equiv-congruence-on-cst
  (implies (tree-equiv cst cst-equiv)
           (equal (smtp-cst-ipv6-addr-conc3-rep cst)
                  (smtp-cst-ipv6-addr-conc3-rep cst-equiv)))
  :rule-classes :congruence)

Function: smtp-cst-ipv6-addr-conc4-rep

(defun smtp-cst-ipv6-addr-conc4-rep (cst)
  (declare (xargs :guard (treep cst)))
  (declare (xargs :guard (and (smtp-cst-matchp cst "ipv6-addr")
                              (equal (smtp-cst-ipv6-addr-conc? cst)
                                     4))))
  (let ((__function__ 'smtp-cst-ipv6-addr-conc4-rep))
    (declare (ignorable __function__))
    (tree-list-fix (nth 0 (smtp-cst-ipv6-addr-conc4 cst)))))

Theorem: tree-listp-of-smtp-cst-ipv6-addr-conc4-rep

(defthm tree-listp-of-smtp-cst-ipv6-addr-conc4-rep
  (b* ((csts (smtp-cst-ipv6-addr-conc4-rep cst)))
    (tree-listp csts))
  :rule-classes :rewrite)

Theorem: smtp-cst-ipv6-addr-conc4-rep-match

(defthm smtp-cst-ipv6-addr-conc4-rep-match
  (implies (and (smtp-cst-matchp cst "ipv6-addr")
                (equal (smtp-cst-ipv6-addr-conc? cst)
                       4))
           (b* ((csts (smtp-cst-ipv6-addr-conc4-rep cst)))
             (smtp-cst-list-rep-matchp csts "ipv6v4-comp")))
  :rule-classes :rewrite)

Theorem: smtp-cst-ipv6-addr-conc4-rep-of-tree-fix-cst

(defthm smtp-cst-ipv6-addr-conc4-rep-of-tree-fix-cst
  (equal (smtp-cst-ipv6-addr-conc4-rep (tree-fix cst))
         (smtp-cst-ipv6-addr-conc4-rep cst)))

Theorem: smtp-cst-ipv6-addr-conc4-rep-tree-equiv-congruence-on-cst

(defthm smtp-cst-ipv6-addr-conc4-rep-tree-equiv-congruence-on-cst
  (implies (tree-equiv cst cst-equiv)
           (equal (smtp-cst-ipv6-addr-conc4-rep cst)
                  (smtp-cst-ipv6-addr-conc4-rep cst-equiv)))
  :rule-classes :congruence)

Function: smtp-cst-addtl-link-conc-rep

(defun smtp-cst-addtl-link-conc-rep (cst)
  (declare (xargs :guard (treep cst)))
  (declare (xargs :guard (smtp-cst-matchp cst "addtl-link")))
  (let ((__function__ 'smtp-cst-addtl-link-conc-rep))
    (declare (ignorable __function__))
    (tree-list-fix (nth 0 (smtp-cst-addtl-link-conc cst)))))

Theorem: tree-listp-of-smtp-cst-addtl-link-conc-rep

(defthm tree-listp-of-smtp-cst-addtl-link-conc-rep
  (b* ((csts (smtp-cst-addtl-link-conc-rep cst)))
    (tree-listp csts))
  :rule-classes :rewrite)

Theorem: smtp-cst-addtl-link-conc-rep-match

(defthm smtp-cst-addtl-link-conc-rep-match
  (implies (smtp-cst-matchp cst "addtl-link")
           (b* ((csts (smtp-cst-addtl-link-conc-rep cst)))
             (smtp-cst-list-rep-matchp csts "atom")))
  :rule-classes :rewrite)

Theorem: smtp-cst-addtl-link-conc-rep-of-tree-fix-cst

(defthm smtp-cst-addtl-link-conc-rep-of-tree-fix-cst
  (equal (smtp-cst-addtl-link-conc-rep (tree-fix cst))
         (smtp-cst-addtl-link-conc-rep cst)))

Theorem: smtp-cst-addtl-link-conc-rep-tree-equiv-congruence-on-cst

(defthm smtp-cst-addtl-link-conc-rep-tree-equiv-congruence-on-cst
  (implies (tree-equiv cst cst-equiv)
           (equal (smtp-cst-addtl-link-conc-rep cst)
                  (smtp-cst-addtl-link-conc-rep cst-equiv)))
  :rule-classes :congruence)

Function: smtp-cst-attdl-protocol-conc-rep

(defun smtp-cst-attdl-protocol-conc-rep (cst)
  (declare (xargs :guard (treep cst)))
  (declare (xargs :guard (smtp-cst-matchp cst "attdl-protocol")))
  (let ((__function__ 'smtp-cst-attdl-protocol-conc-rep))
    (declare (ignorable __function__))
    (tree-list-fix (nth 0 (smtp-cst-attdl-protocol-conc cst)))))

Theorem: tree-listp-of-smtp-cst-attdl-protocol-conc-rep

(defthm tree-listp-of-smtp-cst-attdl-protocol-conc-rep
  (b* ((csts (smtp-cst-attdl-protocol-conc-rep cst)))
    (tree-listp csts))
  :rule-classes :rewrite)

Theorem: smtp-cst-attdl-protocol-conc-rep-match

(defthm smtp-cst-attdl-protocol-conc-rep-match
  (implies (smtp-cst-matchp cst "attdl-protocol")
           (b* ((csts (smtp-cst-attdl-protocol-conc-rep cst)))
             (smtp-cst-list-rep-matchp csts "atom")))
  :rule-classes :rewrite)

Theorem: smtp-cst-attdl-protocol-conc-rep-of-tree-fix-cst

(defthm smtp-cst-attdl-protocol-conc-rep-of-tree-fix-cst
  (equal (smtp-cst-attdl-protocol-conc-rep (tree-fix cst))
         (smtp-cst-attdl-protocol-conc-rep cst)))

Theorem: smtp-cst-attdl-protocol-conc-rep-tree-equiv-congruence-on-cst

(defthm
      smtp-cst-attdl-protocol-conc-rep-tree-equiv-congruence-on-cst
  (implies (tree-equiv cst cst-equiv)
           (equal (smtp-cst-attdl-protocol-conc-rep cst)
                  (smtp-cst-attdl-protocol-conc-rep cst-equiv)))
  :rule-classes :congruence)

Function: smtp-cst-ccontent-conc1-rep

(defun smtp-cst-ccontent-conc1-rep (cst)
  (declare (xargs :guard (treep cst)))
  (declare (xargs :guard (and (smtp-cst-matchp cst "ccontent")
                              (equal (smtp-cst-ccontent-conc? cst)
                                     1))))
  (let ((__function__ 'smtp-cst-ccontent-conc1-rep))
    (declare (ignorable __function__))
    (tree-list-fix (nth 0 (smtp-cst-ccontent-conc1 cst)))))

Theorem: tree-listp-of-smtp-cst-ccontent-conc1-rep

(defthm tree-listp-of-smtp-cst-ccontent-conc1-rep
  (b* ((csts (smtp-cst-ccontent-conc1-rep cst)))
    (tree-listp csts))
  :rule-classes :rewrite)

Theorem: smtp-cst-ccontent-conc1-rep-match

(defthm smtp-cst-ccontent-conc1-rep-match
  (implies (and (smtp-cst-matchp cst "ccontent")
                (equal (smtp-cst-ccontent-conc? cst) 1))
           (b* ((csts (smtp-cst-ccontent-conc1-rep cst)))
             (smtp-cst-list-rep-matchp csts "ctext")))
  :rule-classes :rewrite)

Theorem: smtp-cst-ccontent-conc1-rep-of-tree-fix-cst

(defthm smtp-cst-ccontent-conc1-rep-of-tree-fix-cst
  (equal (smtp-cst-ccontent-conc1-rep (tree-fix cst))
         (smtp-cst-ccontent-conc1-rep cst)))

Theorem: smtp-cst-ccontent-conc1-rep-tree-equiv-congruence-on-cst

(defthm smtp-cst-ccontent-conc1-rep-tree-equiv-congruence-on-cst
  (implies (tree-equiv cst cst-equiv)
           (equal (smtp-cst-ccontent-conc1-rep cst)
                  (smtp-cst-ccontent-conc1-rep cst-equiv)))
  :rule-classes :congruence)

Function: smtp-cst-ccontent-conc2-rep

(defun smtp-cst-ccontent-conc2-rep (cst)
  (declare (xargs :guard (treep cst)))
  (declare (xargs :guard (and (smtp-cst-matchp cst "ccontent")
                              (equal (smtp-cst-ccontent-conc? cst)
                                     2))))
  (let ((__function__ 'smtp-cst-ccontent-conc2-rep))
    (declare (ignorable __function__))
    (tree-list-fix (nth 0 (smtp-cst-ccontent-conc2 cst)))))

Theorem: tree-listp-of-smtp-cst-ccontent-conc2-rep

(defthm tree-listp-of-smtp-cst-ccontent-conc2-rep
  (b* ((csts (smtp-cst-ccontent-conc2-rep cst)))
    (tree-listp csts))
  :rule-classes :rewrite)

Theorem: smtp-cst-ccontent-conc2-rep-match

(defthm smtp-cst-ccontent-conc2-rep-match
  (implies (and (smtp-cst-matchp cst "ccontent")
                (equal (smtp-cst-ccontent-conc? cst) 2))
           (b* ((csts (smtp-cst-ccontent-conc2-rep cst)))
             (smtp-cst-list-rep-matchp csts "quoted-pair")))
  :rule-classes :rewrite)

Theorem: smtp-cst-ccontent-conc2-rep-of-tree-fix-cst

(defthm smtp-cst-ccontent-conc2-rep-of-tree-fix-cst
  (equal (smtp-cst-ccontent-conc2-rep (tree-fix cst))
         (smtp-cst-ccontent-conc2-rep cst)))

Theorem: smtp-cst-ccontent-conc2-rep-tree-equiv-congruence-on-cst

(defthm smtp-cst-ccontent-conc2-rep-tree-equiv-congruence-on-cst
  (implies (tree-equiv cst cst-equiv)
           (equal (smtp-cst-ccontent-conc2-rep cst)
                  (smtp-cst-ccontent-conc2-rep cst-equiv)))
  :rule-classes :congruence)

Function: smtp-cst-ccontent-conc3-rep

(defun smtp-cst-ccontent-conc3-rep (cst)
  (declare (xargs :guard (treep cst)))
  (declare (xargs :guard (and (smtp-cst-matchp cst "ccontent")
                              (equal (smtp-cst-ccontent-conc? cst)
                                     3))))
  (let ((__function__ 'smtp-cst-ccontent-conc3-rep))
    (declare (ignorable __function__))
    (tree-list-fix (nth 0 (smtp-cst-ccontent-conc3 cst)))))

Theorem: tree-listp-of-smtp-cst-ccontent-conc3-rep

(defthm tree-listp-of-smtp-cst-ccontent-conc3-rep
  (b* ((csts (smtp-cst-ccontent-conc3-rep cst)))
    (tree-listp csts))
  :rule-classes :rewrite)

Theorem: smtp-cst-ccontent-conc3-rep-match

(defthm smtp-cst-ccontent-conc3-rep-match
  (implies (and (smtp-cst-matchp cst "ccontent")
                (equal (smtp-cst-ccontent-conc? cst) 3))
           (b* ((csts (smtp-cst-ccontent-conc3-rep cst)))
             (smtp-cst-list-rep-matchp csts "comment")))
  :rule-classes :rewrite)

Theorem: smtp-cst-ccontent-conc3-rep-of-tree-fix-cst

(defthm smtp-cst-ccontent-conc3-rep-of-tree-fix-cst
  (equal (smtp-cst-ccontent-conc3-rep (tree-fix cst))
         (smtp-cst-ccontent-conc3-rep cst)))

Theorem: smtp-cst-ccontent-conc3-rep-tree-equiv-congruence-on-cst

(defthm smtp-cst-ccontent-conc3-rep-tree-equiv-congruence-on-cst
  (implies (tree-equiv cst cst-equiv)
           (equal (smtp-cst-ccontent-conc3-rep cst)
                  (smtp-cst-ccontent-conc3-rep cst-equiv)))
  :rule-classes :congruence)

Function: smtp-cst-id-left-conc1-rep

(defun smtp-cst-id-left-conc1-rep (cst)
  (declare (xargs :guard (treep cst)))
  (declare (xargs :guard (and (smtp-cst-matchp cst "id-left")
                              (equal (smtp-cst-id-left-conc? cst)
                                     1))))
  (let ((__function__ 'smtp-cst-id-left-conc1-rep))
    (declare (ignorable __function__))
    (tree-list-fix (nth 0 (smtp-cst-id-left-conc1 cst)))))

Theorem: tree-listp-of-smtp-cst-id-left-conc1-rep

(defthm tree-listp-of-smtp-cst-id-left-conc1-rep
  (b* ((csts (smtp-cst-id-left-conc1-rep cst)))
    (tree-listp csts))
  :rule-classes :rewrite)

Theorem: smtp-cst-id-left-conc1-rep-match

(defthm smtp-cst-id-left-conc1-rep-match
  (implies (and (smtp-cst-matchp cst "id-left")
                (equal (smtp-cst-id-left-conc? cst) 1))
           (b* ((csts (smtp-cst-id-left-conc1-rep cst)))
             (smtp-cst-list-rep-matchp csts "dot-atom-text")))
  :rule-classes :rewrite)

Theorem: smtp-cst-id-left-conc1-rep-of-tree-fix-cst

(defthm smtp-cst-id-left-conc1-rep-of-tree-fix-cst
  (equal (smtp-cst-id-left-conc1-rep (tree-fix cst))
         (smtp-cst-id-left-conc1-rep cst)))

Theorem: smtp-cst-id-left-conc1-rep-tree-equiv-congruence-on-cst

(defthm smtp-cst-id-left-conc1-rep-tree-equiv-congruence-on-cst
  (implies (tree-equiv cst cst-equiv)
           (equal (smtp-cst-id-left-conc1-rep cst)
                  (smtp-cst-id-left-conc1-rep cst-equiv)))
  :rule-classes :congruence)

Function: smtp-cst-id-left-conc2-rep

(defun smtp-cst-id-left-conc2-rep (cst)
  (declare (xargs :guard (treep cst)))
  (declare (xargs :guard (and (smtp-cst-matchp cst "id-left")
                              (equal (smtp-cst-id-left-conc? cst)
                                     2))))
  (let ((__function__ 'smtp-cst-id-left-conc2-rep))
    (declare (ignorable __function__))
    (tree-list-fix (nth 0 (smtp-cst-id-left-conc2 cst)))))

Theorem: tree-listp-of-smtp-cst-id-left-conc2-rep

(defthm tree-listp-of-smtp-cst-id-left-conc2-rep
  (b* ((csts (smtp-cst-id-left-conc2-rep cst)))
    (tree-listp csts))
  :rule-classes :rewrite)

Theorem: smtp-cst-id-left-conc2-rep-match

(defthm smtp-cst-id-left-conc2-rep-match
  (implies (and (smtp-cst-matchp cst "id-left")
                (equal (smtp-cst-id-left-conc? cst) 2))
           (b* ((csts (smtp-cst-id-left-conc2-rep cst)))
             (smtp-cst-list-rep-matchp csts "obs-id-left")))
  :rule-classes :rewrite)

Theorem: smtp-cst-id-left-conc2-rep-of-tree-fix-cst

(defthm smtp-cst-id-left-conc2-rep-of-tree-fix-cst
  (equal (smtp-cst-id-left-conc2-rep (tree-fix cst))
         (smtp-cst-id-left-conc2-rep cst)))

Theorem: smtp-cst-id-left-conc2-rep-tree-equiv-congruence-on-cst

(defthm smtp-cst-id-left-conc2-rep-tree-equiv-congruence-on-cst
  (implies (tree-equiv cst cst-equiv)
           (equal (smtp-cst-id-left-conc2-rep cst)
                  (smtp-cst-id-left-conc2-rep cst-equiv)))
  :rule-classes :congruence)

Function: smtp-cst-id-right-conc1-rep

(defun smtp-cst-id-right-conc1-rep (cst)
  (declare (xargs :guard (treep cst)))
  (declare (xargs :guard (and (smtp-cst-matchp cst "id-right")
                              (equal (smtp-cst-id-right-conc? cst)
                                     1))))
  (let ((__function__ 'smtp-cst-id-right-conc1-rep))
    (declare (ignorable __function__))
    (tree-list-fix (nth 0 (smtp-cst-id-right-conc1 cst)))))

Theorem: tree-listp-of-smtp-cst-id-right-conc1-rep

(defthm tree-listp-of-smtp-cst-id-right-conc1-rep
  (b* ((csts (smtp-cst-id-right-conc1-rep cst)))
    (tree-listp csts))
  :rule-classes :rewrite)

Theorem: smtp-cst-id-right-conc1-rep-match

(defthm smtp-cst-id-right-conc1-rep-match
  (implies (and (smtp-cst-matchp cst "id-right")
                (equal (smtp-cst-id-right-conc? cst) 1))
           (b* ((csts (smtp-cst-id-right-conc1-rep cst)))
             (smtp-cst-list-rep-matchp csts "dot-atom-text")))
  :rule-classes :rewrite)

Theorem: smtp-cst-id-right-conc1-rep-of-tree-fix-cst

(defthm smtp-cst-id-right-conc1-rep-of-tree-fix-cst
  (equal (smtp-cst-id-right-conc1-rep (tree-fix cst))
         (smtp-cst-id-right-conc1-rep cst)))

Theorem: smtp-cst-id-right-conc1-rep-tree-equiv-congruence-on-cst

(defthm smtp-cst-id-right-conc1-rep-tree-equiv-congruence-on-cst
  (implies (tree-equiv cst cst-equiv)
           (equal (smtp-cst-id-right-conc1-rep cst)
                  (smtp-cst-id-right-conc1-rep cst-equiv)))
  :rule-classes :congruence)

Function: smtp-cst-id-right-conc2-rep

(defun smtp-cst-id-right-conc2-rep (cst)
  (declare (xargs :guard (treep cst)))
  (declare (xargs :guard (and (smtp-cst-matchp cst "id-right")
                              (equal (smtp-cst-id-right-conc? cst)
                                     2))))
  (let ((__function__ 'smtp-cst-id-right-conc2-rep))
    (declare (ignorable __function__))
    (tree-list-fix (nth 0 (smtp-cst-id-right-conc2 cst)))))

Theorem: tree-listp-of-smtp-cst-id-right-conc2-rep

(defthm tree-listp-of-smtp-cst-id-right-conc2-rep
  (b* ((csts (smtp-cst-id-right-conc2-rep cst)))
    (tree-listp csts))
  :rule-classes :rewrite)

Theorem: smtp-cst-id-right-conc2-rep-match

(defthm smtp-cst-id-right-conc2-rep-match
  (implies (and (smtp-cst-matchp cst "id-right")
                (equal (smtp-cst-id-right-conc? cst) 2))
           (b* ((csts (smtp-cst-id-right-conc2-rep cst)))
             (smtp-cst-list-rep-matchp csts "no-fold-literal")))
  :rule-classes :rewrite)

Theorem: smtp-cst-id-right-conc2-rep-of-tree-fix-cst

(defthm smtp-cst-id-right-conc2-rep-of-tree-fix-cst
  (equal (smtp-cst-id-right-conc2-rep (tree-fix cst))
         (smtp-cst-id-right-conc2-rep cst)))

Theorem: smtp-cst-id-right-conc2-rep-tree-equiv-congruence-on-cst

(defthm smtp-cst-id-right-conc2-rep-tree-equiv-congruence-on-cst
  (implies (tree-equiv cst cst-equiv)
           (equal (smtp-cst-id-right-conc2-rep cst)
                  (smtp-cst-id-right-conc2-rep cst-equiv)))
  :rule-classes :congruence)

Function: smtp-cst-id-right-conc3-rep

(defun smtp-cst-id-right-conc3-rep (cst)
  (declare (xargs :guard (treep cst)))
  (declare (xargs :guard (and (smtp-cst-matchp cst "id-right")
                              (equal (smtp-cst-id-right-conc? cst)
                                     3))))
  (let ((__function__ 'smtp-cst-id-right-conc3-rep))
    (declare (ignorable __function__))
    (tree-list-fix (nth 0 (smtp-cst-id-right-conc3 cst)))))

Theorem: tree-listp-of-smtp-cst-id-right-conc3-rep

(defthm tree-listp-of-smtp-cst-id-right-conc3-rep
  (b* ((csts (smtp-cst-id-right-conc3-rep cst)))
    (tree-listp csts))
  :rule-classes :rewrite)

Theorem: smtp-cst-id-right-conc3-rep-match

(defthm smtp-cst-id-right-conc3-rep-match
  (implies (and (smtp-cst-matchp cst "id-right")
                (equal (smtp-cst-id-right-conc? cst) 3))
           (b* ((csts (smtp-cst-id-right-conc3-rep cst)))
             (smtp-cst-list-rep-matchp csts "obs-id-right")))
  :rule-classes :rewrite)

Theorem: smtp-cst-id-right-conc3-rep-of-tree-fix-cst

(defthm smtp-cst-id-right-conc3-rep-of-tree-fix-cst
  (equal (smtp-cst-id-right-conc3-rep (tree-fix cst))
         (smtp-cst-id-right-conc3-rep cst)))

Theorem: smtp-cst-id-right-conc3-rep-tree-equiv-congruence-on-cst

(defthm smtp-cst-id-right-conc3-rep-tree-equiv-congruence-on-cst
  (implies (tree-equiv cst cst-equiv)
           (equal (smtp-cst-id-right-conc3-rep cst)
                  (smtp-cst-id-right-conc3-rep cst-equiv)))
  :rule-classes :congruence)

Function: smtp-cst-obs-ctext-conc-rep

(defun smtp-cst-obs-ctext-conc-rep (cst)
  (declare (xargs :guard (treep cst)))
  (declare (xargs :guard (smtp-cst-matchp cst "obs-ctext")))
  (let ((__function__ 'smtp-cst-obs-ctext-conc-rep))
    (declare (ignorable __function__))
    (tree-list-fix (nth 0 (smtp-cst-obs-ctext-conc cst)))))

Theorem: tree-listp-of-smtp-cst-obs-ctext-conc-rep

(defthm tree-listp-of-smtp-cst-obs-ctext-conc-rep
  (b* ((csts (smtp-cst-obs-ctext-conc-rep cst)))
    (tree-listp csts))
  :rule-classes :rewrite)

Theorem: smtp-cst-obs-ctext-conc-rep-match

(defthm smtp-cst-obs-ctext-conc-rep-match
  (implies (smtp-cst-matchp cst "obs-ctext")
           (b* ((csts (smtp-cst-obs-ctext-conc-rep cst)))
             (smtp-cst-list-rep-matchp csts "obs-no-ws-ctl")))
  :rule-classes :rewrite)

Theorem: smtp-cst-obs-ctext-conc-rep-of-tree-fix-cst

(defthm smtp-cst-obs-ctext-conc-rep-of-tree-fix-cst
  (equal (smtp-cst-obs-ctext-conc-rep (tree-fix cst))
         (smtp-cst-obs-ctext-conc-rep cst)))

Theorem: smtp-cst-obs-ctext-conc-rep-tree-equiv-congruence-on-cst

(defthm smtp-cst-obs-ctext-conc-rep-tree-equiv-congruence-on-cst
  (implies (tree-equiv cst cst-equiv)
           (equal (smtp-cst-obs-ctext-conc-rep cst)
                  (smtp-cst-obs-ctext-conc-rep cst-equiv)))
  :rule-classes :congruence)

Function: smtp-cst-obs-dtext-conc1-rep

(defun smtp-cst-obs-dtext-conc1-rep (cst)
  (declare (xargs :guard (treep cst)))
  (declare (xargs :guard (and (smtp-cst-matchp cst "obs-dtext")
                              (equal (smtp-cst-obs-dtext-conc? cst)
                                     1))))
  (let ((__function__ 'smtp-cst-obs-dtext-conc1-rep))
    (declare (ignorable __function__))
    (tree-list-fix (nth 0 (smtp-cst-obs-dtext-conc1 cst)))))

Theorem: tree-listp-of-smtp-cst-obs-dtext-conc1-rep

(defthm tree-listp-of-smtp-cst-obs-dtext-conc1-rep
  (b* ((csts (smtp-cst-obs-dtext-conc1-rep cst)))
    (tree-listp csts))
  :rule-classes :rewrite)

Theorem: smtp-cst-obs-dtext-conc1-rep-match

(defthm smtp-cst-obs-dtext-conc1-rep-match
  (implies (and (smtp-cst-matchp cst "obs-dtext")
                (equal (smtp-cst-obs-dtext-conc? cst)
                       1))
           (b* ((csts (smtp-cst-obs-dtext-conc1-rep cst)))
             (smtp-cst-list-rep-matchp csts "obs-no-ws-ctl")))
  :rule-classes :rewrite)

Theorem: smtp-cst-obs-dtext-conc1-rep-of-tree-fix-cst

(defthm smtp-cst-obs-dtext-conc1-rep-of-tree-fix-cst
  (equal (smtp-cst-obs-dtext-conc1-rep (tree-fix cst))
         (smtp-cst-obs-dtext-conc1-rep cst)))

Theorem: smtp-cst-obs-dtext-conc1-rep-tree-equiv-congruence-on-cst

(defthm smtp-cst-obs-dtext-conc1-rep-tree-equiv-congruence-on-cst
  (implies (tree-equiv cst cst-equiv)
           (equal (smtp-cst-obs-dtext-conc1-rep cst)
                  (smtp-cst-obs-dtext-conc1-rep cst-equiv)))
  :rule-classes :congruence)

Function: smtp-cst-obs-dtext-conc2-rep

(defun smtp-cst-obs-dtext-conc2-rep (cst)
  (declare (xargs :guard (treep cst)))
  (declare (xargs :guard (and (smtp-cst-matchp cst "obs-dtext")
                              (equal (smtp-cst-obs-dtext-conc? cst)
                                     2))))
  (let ((__function__ 'smtp-cst-obs-dtext-conc2-rep))
    (declare (ignorable __function__))
    (tree-list-fix (nth 0 (smtp-cst-obs-dtext-conc2 cst)))))

Theorem: tree-listp-of-smtp-cst-obs-dtext-conc2-rep

(defthm tree-listp-of-smtp-cst-obs-dtext-conc2-rep
  (b* ((csts (smtp-cst-obs-dtext-conc2-rep cst)))
    (tree-listp csts))
  :rule-classes :rewrite)

Theorem: smtp-cst-obs-dtext-conc2-rep-match

(defthm smtp-cst-obs-dtext-conc2-rep-match
  (implies (and (smtp-cst-matchp cst "obs-dtext")
                (equal (smtp-cst-obs-dtext-conc? cst)
                       2))
           (b* ((csts (smtp-cst-obs-dtext-conc2-rep cst)))
             (smtp-cst-list-rep-matchp csts "quoted-pair")))
  :rule-classes :rewrite)

Theorem: smtp-cst-obs-dtext-conc2-rep-of-tree-fix-cst

(defthm smtp-cst-obs-dtext-conc2-rep-of-tree-fix-cst
  (equal (smtp-cst-obs-dtext-conc2-rep (tree-fix cst))
         (smtp-cst-obs-dtext-conc2-rep cst)))

Theorem: smtp-cst-obs-dtext-conc2-rep-tree-equiv-congruence-on-cst

(defthm smtp-cst-obs-dtext-conc2-rep-tree-equiv-congruence-on-cst
  (implies (tree-equiv cst cst-equiv)
           (equal (smtp-cst-obs-dtext-conc2-rep cst)
                  (smtp-cst-obs-dtext-conc2-rep cst-equiv)))
  :rule-classes :congruence)

Function: smtp-cst-obs-id-left-conc-rep

(defun smtp-cst-obs-id-left-conc-rep (cst)
  (declare (xargs :guard (treep cst)))
  (declare (xargs :guard (smtp-cst-matchp cst "obs-id-left")))
  (let ((__function__ 'smtp-cst-obs-id-left-conc-rep))
    (declare (ignorable __function__))
    (tree-list-fix (nth 0 (smtp-cst-obs-id-left-conc cst)))))

Theorem: tree-listp-of-smtp-cst-obs-id-left-conc-rep

(defthm tree-listp-of-smtp-cst-obs-id-left-conc-rep
  (b* ((csts (smtp-cst-obs-id-left-conc-rep cst)))
    (tree-listp csts))
  :rule-classes :rewrite)

Theorem: smtp-cst-obs-id-left-conc-rep-match

(defthm smtp-cst-obs-id-left-conc-rep-match
  (implies (smtp-cst-matchp cst "obs-id-left")
           (b* ((csts (smtp-cst-obs-id-left-conc-rep cst)))
             (smtp-cst-list-rep-matchp csts "imf-local-part")))
  :rule-classes :rewrite)

Theorem: smtp-cst-obs-id-left-conc-rep-of-tree-fix-cst

(defthm smtp-cst-obs-id-left-conc-rep-of-tree-fix-cst
  (equal (smtp-cst-obs-id-left-conc-rep (tree-fix cst))
         (smtp-cst-obs-id-left-conc-rep cst)))

Theorem: smtp-cst-obs-id-left-conc-rep-tree-equiv-congruence-on-cst

(defthm smtp-cst-obs-id-left-conc-rep-tree-equiv-congruence-on-cst
  (implies (tree-equiv cst cst-equiv)
           (equal (smtp-cst-obs-id-left-conc-rep cst)
                  (smtp-cst-obs-id-left-conc-rep cst-equiv)))
  :rule-classes :congruence)

Function: smtp-cst-imf-local-part-conc1-rep

(defun smtp-cst-imf-local-part-conc1-rep (cst)
  (declare (xargs :guard (treep cst)))
  (declare
       (xargs :guard (and (smtp-cst-matchp cst "imf-local-part")
                          (equal (smtp-cst-imf-local-part-conc? cst)
                                 1))))
  (let ((__function__ 'smtp-cst-imf-local-part-conc1-rep))
    (declare (ignorable __function__))
    (tree-list-fix (nth 0
                        (smtp-cst-imf-local-part-conc1 cst)))))

Theorem: tree-listp-of-smtp-cst-imf-local-part-conc1-rep

(defthm tree-listp-of-smtp-cst-imf-local-part-conc1-rep
  (b* ((csts (smtp-cst-imf-local-part-conc1-rep cst)))
    (tree-listp csts))
  :rule-classes :rewrite)

Theorem: smtp-cst-imf-local-part-conc1-rep-match

(defthm smtp-cst-imf-local-part-conc1-rep-match
  (implies (and (smtp-cst-matchp cst "imf-local-part")
                (equal (smtp-cst-imf-local-part-conc? cst)
                       1))
           (b* ((csts (smtp-cst-imf-local-part-conc1-rep cst)))
             (smtp-cst-list-rep-matchp csts "dot-atom")))
  :rule-classes :rewrite)

Theorem: smtp-cst-imf-local-part-conc1-rep-of-tree-fix-cst

(defthm smtp-cst-imf-local-part-conc1-rep-of-tree-fix-cst
  (equal (smtp-cst-imf-local-part-conc1-rep (tree-fix cst))
         (smtp-cst-imf-local-part-conc1-rep cst)))

Theorem: smtp-cst-imf-local-part-conc1-rep-tree-equiv-congruence-on-cst

(defthm
     smtp-cst-imf-local-part-conc1-rep-tree-equiv-congruence-on-cst
  (implies (tree-equiv cst cst-equiv)
           (equal (smtp-cst-imf-local-part-conc1-rep cst)
                  (smtp-cst-imf-local-part-conc1-rep cst-equiv)))
  :rule-classes :congruence)

Function: smtp-cst-imf-local-part-conc2-rep

(defun smtp-cst-imf-local-part-conc2-rep (cst)
  (declare (xargs :guard (treep cst)))
  (declare
       (xargs :guard (and (smtp-cst-matchp cst "imf-local-part")
                          (equal (smtp-cst-imf-local-part-conc? cst)
                                 2))))
  (let ((__function__ 'smtp-cst-imf-local-part-conc2-rep))
    (declare (ignorable __function__))
    (tree-list-fix (nth 0
                        (smtp-cst-imf-local-part-conc2 cst)))))

Theorem: tree-listp-of-smtp-cst-imf-local-part-conc2-rep

(defthm tree-listp-of-smtp-cst-imf-local-part-conc2-rep
  (b* ((csts (smtp-cst-imf-local-part-conc2-rep cst)))
    (tree-listp csts))
  :rule-classes :rewrite)

Theorem: smtp-cst-imf-local-part-conc2-rep-match

(defthm smtp-cst-imf-local-part-conc2-rep-match
  (implies (and (smtp-cst-matchp cst "imf-local-part")
                (equal (smtp-cst-imf-local-part-conc? cst)
                       2))
           (b* ((csts (smtp-cst-imf-local-part-conc2-rep cst)))
             (smtp-cst-list-rep-matchp csts "imf-quoted-string")))
  :rule-classes :rewrite)

Theorem: smtp-cst-imf-local-part-conc2-rep-of-tree-fix-cst

(defthm smtp-cst-imf-local-part-conc2-rep-of-tree-fix-cst
  (equal (smtp-cst-imf-local-part-conc2-rep (tree-fix cst))
         (smtp-cst-imf-local-part-conc2-rep cst)))

Theorem: smtp-cst-imf-local-part-conc2-rep-tree-equiv-congruence-on-cst

(defthm
     smtp-cst-imf-local-part-conc2-rep-tree-equiv-congruence-on-cst
  (implies (tree-equiv cst cst-equiv)
           (equal (smtp-cst-imf-local-part-conc2-rep cst)
                  (smtp-cst-imf-local-part-conc2-rep cst-equiv)))
  :rule-classes :congruence)

Function: smtp-cst-imf-local-part-conc3-rep

(defun smtp-cst-imf-local-part-conc3-rep (cst)
  (declare (xargs :guard (treep cst)))
  (declare
       (xargs :guard (and (smtp-cst-matchp cst "imf-local-part")
                          (equal (smtp-cst-imf-local-part-conc? cst)
                                 3))))
  (let ((__function__ 'smtp-cst-imf-local-part-conc3-rep))
    (declare (ignorable __function__))
    (tree-list-fix (nth 0
                        (smtp-cst-imf-local-part-conc3 cst)))))

Theorem: tree-listp-of-smtp-cst-imf-local-part-conc3-rep

(defthm tree-listp-of-smtp-cst-imf-local-part-conc3-rep
  (b* ((csts (smtp-cst-imf-local-part-conc3-rep cst)))
    (tree-listp csts))
  :rule-classes :rewrite)

Theorem: smtp-cst-imf-local-part-conc3-rep-match

(defthm smtp-cst-imf-local-part-conc3-rep-match
  (implies (and (smtp-cst-matchp cst "imf-local-part")
                (equal (smtp-cst-imf-local-part-conc? cst)
                       3))
           (b* ((csts (smtp-cst-imf-local-part-conc3-rep cst)))
             (smtp-cst-list-rep-matchp csts "obs-local-part")))
  :rule-classes :rewrite)

Theorem: smtp-cst-imf-local-part-conc3-rep-of-tree-fix-cst

(defthm smtp-cst-imf-local-part-conc3-rep-of-tree-fix-cst
  (equal (smtp-cst-imf-local-part-conc3-rep (tree-fix cst))
         (smtp-cst-imf-local-part-conc3-rep cst)))

Theorem: smtp-cst-imf-local-part-conc3-rep-tree-equiv-congruence-on-cst

(defthm
     smtp-cst-imf-local-part-conc3-rep-tree-equiv-congruence-on-cst
  (implies (tree-equiv cst cst-equiv)
           (equal (smtp-cst-imf-local-part-conc3-rep cst)
                  (smtp-cst-imf-local-part-conc3-rep cst-equiv)))
  :rule-classes :congruence)

Function: smtp-cst-obs-id-right-conc-rep

(defun smtp-cst-obs-id-right-conc-rep (cst)
  (declare (xargs :guard (treep cst)))
  (declare (xargs :guard (smtp-cst-matchp cst "obs-id-right")))
  (let ((__function__ 'smtp-cst-obs-id-right-conc-rep))
    (declare (ignorable __function__))
    (tree-list-fix (nth 0 (smtp-cst-obs-id-right-conc cst)))))

Theorem: tree-listp-of-smtp-cst-obs-id-right-conc-rep

(defthm tree-listp-of-smtp-cst-obs-id-right-conc-rep
  (b* ((csts (smtp-cst-obs-id-right-conc-rep cst)))
    (tree-listp csts))
  :rule-classes :rewrite)

Theorem: smtp-cst-obs-id-right-conc-rep-match

(defthm smtp-cst-obs-id-right-conc-rep-match
  (implies (smtp-cst-matchp cst "obs-id-right")
           (b* ((csts (smtp-cst-obs-id-right-conc-rep cst)))
             (smtp-cst-list-rep-matchp csts "imf-domain")))
  :rule-classes :rewrite)

Theorem: smtp-cst-obs-id-right-conc-rep-of-tree-fix-cst

(defthm smtp-cst-obs-id-right-conc-rep-of-tree-fix-cst
  (equal (smtp-cst-obs-id-right-conc-rep (tree-fix cst))
         (smtp-cst-obs-id-right-conc-rep cst)))

Theorem: smtp-cst-obs-id-right-conc-rep-tree-equiv-congruence-on-cst

(defthm smtp-cst-obs-id-right-conc-rep-tree-equiv-congruence-on-cst
  (implies (tree-equiv cst cst-equiv)
           (equal (smtp-cst-obs-id-right-conc-rep cst)
                  (smtp-cst-obs-id-right-conc-rep cst-equiv)))
  :rule-classes :congruence)

Function: smtp-cst-imf-domain-conc1-rep

(defun smtp-cst-imf-domain-conc1-rep (cst)
  (declare (xargs :guard (treep cst)))
  (declare (xargs :guard (and (smtp-cst-matchp cst "imf-domain")
                              (equal (smtp-cst-imf-domain-conc? cst)
                                     1))))
  (let ((__function__ 'smtp-cst-imf-domain-conc1-rep))
    (declare (ignorable __function__))
    (tree-list-fix (nth 0 (smtp-cst-imf-domain-conc1 cst)))))

Theorem: tree-listp-of-smtp-cst-imf-domain-conc1-rep

(defthm tree-listp-of-smtp-cst-imf-domain-conc1-rep
  (b* ((csts (smtp-cst-imf-domain-conc1-rep cst)))
    (tree-listp csts))
  :rule-classes :rewrite)

Theorem: smtp-cst-imf-domain-conc1-rep-match

(defthm smtp-cst-imf-domain-conc1-rep-match
  (implies (and (smtp-cst-matchp cst "imf-domain")
                (equal (smtp-cst-imf-domain-conc? cst)
                       1))
           (b* ((csts (smtp-cst-imf-domain-conc1-rep cst)))
             (smtp-cst-list-rep-matchp csts "dot-atom")))
  :rule-classes :rewrite)

Theorem: smtp-cst-imf-domain-conc1-rep-of-tree-fix-cst

(defthm smtp-cst-imf-domain-conc1-rep-of-tree-fix-cst
  (equal (smtp-cst-imf-domain-conc1-rep (tree-fix cst))
         (smtp-cst-imf-domain-conc1-rep cst)))

Theorem: smtp-cst-imf-domain-conc1-rep-tree-equiv-congruence-on-cst

(defthm smtp-cst-imf-domain-conc1-rep-tree-equiv-congruence-on-cst
  (implies (tree-equiv cst cst-equiv)
           (equal (smtp-cst-imf-domain-conc1-rep cst)
                  (smtp-cst-imf-domain-conc1-rep cst-equiv)))
  :rule-classes :congruence)

Function: smtp-cst-imf-domain-conc2-rep

(defun smtp-cst-imf-domain-conc2-rep (cst)
  (declare (xargs :guard (treep cst)))
  (declare (xargs :guard (and (smtp-cst-matchp cst "imf-domain")
                              (equal (smtp-cst-imf-domain-conc? cst)
                                     2))))
  (let ((__function__ 'smtp-cst-imf-domain-conc2-rep))
    (declare (ignorable __function__))
    (tree-list-fix (nth 0 (smtp-cst-imf-domain-conc2 cst)))))

Theorem: tree-listp-of-smtp-cst-imf-domain-conc2-rep

(defthm tree-listp-of-smtp-cst-imf-domain-conc2-rep
  (b* ((csts (smtp-cst-imf-domain-conc2-rep cst)))
    (tree-listp csts))
  :rule-classes :rewrite)

Theorem: smtp-cst-imf-domain-conc2-rep-match

(defthm smtp-cst-imf-domain-conc2-rep-match
  (implies (and (smtp-cst-matchp cst "imf-domain")
                (equal (smtp-cst-imf-domain-conc? cst)
                       2))
           (b* ((csts (smtp-cst-imf-domain-conc2-rep cst)))
             (smtp-cst-list-rep-matchp csts "domain-literal")))
  :rule-classes :rewrite)

Theorem: smtp-cst-imf-domain-conc2-rep-of-tree-fix-cst

(defthm smtp-cst-imf-domain-conc2-rep-of-tree-fix-cst
  (equal (smtp-cst-imf-domain-conc2-rep (tree-fix cst))
         (smtp-cst-imf-domain-conc2-rep cst)))

Theorem: smtp-cst-imf-domain-conc2-rep-tree-equiv-congruence-on-cst

(defthm smtp-cst-imf-domain-conc2-rep-tree-equiv-congruence-on-cst
  (implies (tree-equiv cst cst-equiv)
           (equal (smtp-cst-imf-domain-conc2-rep cst)
                  (smtp-cst-imf-domain-conc2-rep cst-equiv)))
  :rule-classes :congruence)

Function: smtp-cst-imf-domain-conc3-rep

(defun smtp-cst-imf-domain-conc3-rep (cst)
  (declare (xargs :guard (treep cst)))
  (declare (xargs :guard (and (smtp-cst-matchp cst "imf-domain")
                              (equal (smtp-cst-imf-domain-conc? cst)
                                     3))))
  (let ((__function__ 'smtp-cst-imf-domain-conc3-rep))
    (declare (ignorable __function__))
    (tree-list-fix (nth 0 (smtp-cst-imf-domain-conc3 cst)))))

Theorem: tree-listp-of-smtp-cst-imf-domain-conc3-rep

(defthm tree-listp-of-smtp-cst-imf-domain-conc3-rep
  (b* ((csts (smtp-cst-imf-domain-conc3-rep cst)))
    (tree-listp csts))
  :rule-classes :rewrite)

Theorem: smtp-cst-imf-domain-conc3-rep-match

(defthm smtp-cst-imf-domain-conc3-rep-match
  (implies (and (smtp-cst-matchp cst "imf-domain")
                (equal (smtp-cst-imf-domain-conc? cst)
                       3))
           (b* ((csts (smtp-cst-imf-domain-conc3-rep cst)))
             (smtp-cst-list-rep-matchp csts "obs-domain")))
  :rule-classes :rewrite)

Theorem: smtp-cst-imf-domain-conc3-rep-of-tree-fix-cst

(defthm smtp-cst-imf-domain-conc3-rep-of-tree-fix-cst
  (equal (smtp-cst-imf-domain-conc3-rep (tree-fix cst))
         (smtp-cst-imf-domain-conc3-rep cst)))

Theorem: smtp-cst-imf-domain-conc3-rep-tree-equiv-congruence-on-cst

(defthm smtp-cst-imf-domain-conc3-rep-tree-equiv-congruence-on-cst
  (implies (tree-equiv cst cst-equiv)
           (equal (smtp-cst-imf-domain-conc3-rep cst)
                  (smtp-cst-imf-domain-conc3-rep cst-equiv)))
  :rule-classes :congruence)

Function: smtp-cst-qcontent-conc1-rep

(defun smtp-cst-qcontent-conc1-rep (cst)
  (declare (xargs :guard (treep cst)))
  (declare (xargs :guard (and (smtp-cst-matchp cst "qcontent")
                              (equal (smtp-cst-qcontent-conc? cst)
                                     1))))
  (let ((__function__ 'smtp-cst-qcontent-conc1-rep))
    (declare (ignorable __function__))
    (tree-list-fix (nth 0 (smtp-cst-qcontent-conc1 cst)))))

Theorem: tree-listp-of-smtp-cst-qcontent-conc1-rep

(defthm tree-listp-of-smtp-cst-qcontent-conc1-rep
  (b* ((csts (smtp-cst-qcontent-conc1-rep cst)))
    (tree-listp csts))
  :rule-classes :rewrite)

Theorem: smtp-cst-qcontent-conc1-rep-match

(defthm smtp-cst-qcontent-conc1-rep-match
  (implies (and (smtp-cst-matchp cst "qcontent")
                (equal (smtp-cst-qcontent-conc? cst) 1))
           (b* ((csts (smtp-cst-qcontent-conc1-rep cst)))
             (smtp-cst-list-rep-matchp csts "qtext")))
  :rule-classes :rewrite)

Theorem: smtp-cst-qcontent-conc1-rep-of-tree-fix-cst

(defthm smtp-cst-qcontent-conc1-rep-of-tree-fix-cst
  (equal (smtp-cst-qcontent-conc1-rep (tree-fix cst))
         (smtp-cst-qcontent-conc1-rep cst)))

Theorem: smtp-cst-qcontent-conc1-rep-tree-equiv-congruence-on-cst

(defthm smtp-cst-qcontent-conc1-rep-tree-equiv-congruence-on-cst
  (implies (tree-equiv cst cst-equiv)
           (equal (smtp-cst-qcontent-conc1-rep cst)
                  (smtp-cst-qcontent-conc1-rep cst-equiv)))
  :rule-classes :congruence)

Function: smtp-cst-qcontent-conc2-rep

(defun smtp-cst-qcontent-conc2-rep (cst)
  (declare (xargs :guard (treep cst)))
  (declare (xargs :guard (and (smtp-cst-matchp cst "qcontent")
                              (equal (smtp-cst-qcontent-conc? cst)
                                     2))))
  (let ((__function__ 'smtp-cst-qcontent-conc2-rep))
    (declare (ignorable __function__))
    (tree-list-fix (nth 0 (smtp-cst-qcontent-conc2 cst)))))

Theorem: tree-listp-of-smtp-cst-qcontent-conc2-rep

(defthm tree-listp-of-smtp-cst-qcontent-conc2-rep
  (b* ((csts (smtp-cst-qcontent-conc2-rep cst)))
    (tree-listp csts))
  :rule-classes :rewrite)

Theorem: smtp-cst-qcontent-conc2-rep-match

(defthm smtp-cst-qcontent-conc2-rep-match
  (implies (and (smtp-cst-matchp cst "qcontent")
                (equal (smtp-cst-qcontent-conc? cst) 2))
           (b* ((csts (smtp-cst-qcontent-conc2-rep cst)))
             (smtp-cst-list-rep-matchp csts "quoted-pair")))
  :rule-classes :rewrite)

Theorem: smtp-cst-qcontent-conc2-rep-of-tree-fix-cst

(defthm smtp-cst-qcontent-conc2-rep-of-tree-fix-cst
  (equal (smtp-cst-qcontent-conc2-rep (tree-fix cst))
         (smtp-cst-qcontent-conc2-rep cst)))

Theorem: smtp-cst-qcontent-conc2-rep-tree-equiv-congruence-on-cst

(defthm smtp-cst-qcontent-conc2-rep-tree-equiv-congruence-on-cst
  (implies (tree-equiv cst cst-equiv)
           (equal (smtp-cst-qcontent-conc2-rep cst)
                  (smtp-cst-qcontent-conc2-rep cst-equiv)))
  :rule-classes :congruence)

Function: smtp-cst-obs-qtext-conc-rep

(defun smtp-cst-obs-qtext-conc-rep (cst)
  (declare (xargs :guard (treep cst)))
  (declare (xargs :guard (smtp-cst-matchp cst "obs-qtext")))
  (let ((__function__ 'smtp-cst-obs-qtext-conc-rep))
    (declare (ignorable __function__))
    (tree-list-fix (nth 0 (smtp-cst-obs-qtext-conc cst)))))

Theorem: tree-listp-of-smtp-cst-obs-qtext-conc-rep

(defthm tree-listp-of-smtp-cst-obs-qtext-conc-rep
  (b* ((csts (smtp-cst-obs-qtext-conc-rep cst)))
    (tree-listp csts))
  :rule-classes :rewrite)

Theorem: smtp-cst-obs-qtext-conc-rep-match

(defthm smtp-cst-obs-qtext-conc-rep-match
  (implies (smtp-cst-matchp cst "obs-qtext")
           (b* ((csts (smtp-cst-obs-qtext-conc-rep cst)))
             (smtp-cst-list-rep-matchp csts "obs-no-ws-ctl")))
  :rule-classes :rewrite)

Theorem: smtp-cst-obs-qtext-conc-rep-of-tree-fix-cst

(defthm smtp-cst-obs-qtext-conc-rep-of-tree-fix-cst
  (equal (smtp-cst-obs-qtext-conc-rep (tree-fix cst))
         (smtp-cst-obs-qtext-conc-rep cst)))

Theorem: smtp-cst-obs-qtext-conc-rep-tree-equiv-congruence-on-cst

(defthm smtp-cst-obs-qtext-conc-rep-tree-equiv-congruence-on-cst
  (implies (tree-equiv cst cst-equiv)
           (equal (smtp-cst-obs-qtext-conc-rep cst)
                  (smtp-cst-obs-qtext-conc-rep cst-equiv)))
  :rule-classes :congruence)

Function: smtp-cst-word-conc1-rep

(defun smtp-cst-word-conc1-rep (cst)
  (declare (xargs :guard (treep cst)))
  (declare (xargs :guard (and (smtp-cst-matchp cst "word")
                              (equal (smtp-cst-word-conc? cst) 1))))
  (let ((__function__ 'smtp-cst-word-conc1-rep))
    (declare (ignorable __function__))
    (tree-list-fix (nth 0 (smtp-cst-word-conc1 cst)))))

Theorem: tree-listp-of-smtp-cst-word-conc1-rep

(defthm tree-listp-of-smtp-cst-word-conc1-rep
  (b* ((csts (smtp-cst-word-conc1-rep cst)))
    (tree-listp csts))
  :rule-classes :rewrite)

Theorem: smtp-cst-word-conc1-rep-match

(defthm smtp-cst-word-conc1-rep-match
  (implies (and (smtp-cst-matchp cst "word")
                (equal (smtp-cst-word-conc? cst) 1))
           (b* ((csts (smtp-cst-word-conc1-rep cst)))
             (smtp-cst-list-rep-matchp csts "imf-atom")))
  :rule-classes :rewrite)

Theorem: smtp-cst-word-conc1-rep-of-tree-fix-cst

(defthm smtp-cst-word-conc1-rep-of-tree-fix-cst
  (equal (smtp-cst-word-conc1-rep (tree-fix cst))
         (smtp-cst-word-conc1-rep cst)))

Theorem: smtp-cst-word-conc1-rep-tree-equiv-congruence-on-cst

(defthm smtp-cst-word-conc1-rep-tree-equiv-congruence-on-cst
  (implies (tree-equiv cst cst-equiv)
           (equal (smtp-cst-word-conc1-rep cst)
                  (smtp-cst-word-conc1-rep cst-equiv)))
  :rule-classes :congruence)

Function: smtp-cst-word-conc2-rep

(defun smtp-cst-word-conc2-rep (cst)
  (declare (xargs :guard (treep cst)))
  (declare (xargs :guard (and (smtp-cst-matchp cst "word")
                              (equal (smtp-cst-word-conc? cst) 2))))
  (let ((__function__ 'smtp-cst-word-conc2-rep))
    (declare (ignorable __function__))
    (tree-list-fix (nth 0 (smtp-cst-word-conc2 cst)))))

Theorem: tree-listp-of-smtp-cst-word-conc2-rep

(defthm tree-listp-of-smtp-cst-word-conc2-rep
  (b* ((csts (smtp-cst-word-conc2-rep cst)))
    (tree-listp csts))
  :rule-classes :rewrite)

Theorem: smtp-cst-word-conc2-rep-match

(defthm smtp-cst-word-conc2-rep-match
  (implies (and (smtp-cst-matchp cst "word")
                (equal (smtp-cst-word-conc? cst) 2))
           (b* ((csts (smtp-cst-word-conc2-rep cst)))
             (smtp-cst-list-rep-matchp csts "imf-quoted-string")))
  :rule-classes :rewrite)

Theorem: smtp-cst-word-conc2-rep-of-tree-fix-cst

(defthm smtp-cst-word-conc2-rep-of-tree-fix-cst
  (equal (smtp-cst-word-conc2-rep (tree-fix cst))
         (smtp-cst-word-conc2-rep cst)))

Theorem: smtp-cst-word-conc2-rep-tree-equiv-congruence-on-cst

(defthm smtp-cst-word-conc2-rep-tree-equiv-congruence-on-cst
  (implies (tree-equiv cst cst-equiv)
           (equal (smtp-cst-word-conc2-rep cst)
                  (smtp-cst-word-conc2-rep cst-equiv)))
  :rule-classes :congruence)

Function: smtp-cst-cr-conc-rep

(defun smtp-cst-cr-conc-rep (cst)
  (declare (xargs :guard (treep cst)))
  (declare (xargs :guard (smtp-cst-matchp cst "cr")))
  (let ((__function__ 'smtp-cst-cr-conc-rep))
    (declare (ignorable __function__))
    (tree-list-fix (nth 0 (smtp-cst-cr-conc cst)))))

Theorem: tree-listp-of-smtp-cst-cr-conc-rep

(defthm tree-listp-of-smtp-cst-cr-conc-rep
  (b* ((csts (smtp-cst-cr-conc-rep cst)))
    (tree-listp csts))
  :rule-classes :rewrite)

Theorem: smtp-cst-cr-conc-rep-match

(defthm smtp-cst-cr-conc-rep-match
  (implies (smtp-cst-matchp cst "cr")
           (b* ((csts (smtp-cst-cr-conc-rep cst)))
             (smtp-cst-list-rep-matchp csts "%xD")))
  :rule-classes :rewrite)

Theorem: smtp-cst-cr-conc-rep-of-tree-fix-cst

(defthm smtp-cst-cr-conc-rep-of-tree-fix-cst
  (equal (smtp-cst-cr-conc-rep (tree-fix cst))
         (smtp-cst-cr-conc-rep cst)))

Theorem: smtp-cst-cr-conc-rep-tree-equiv-congruence-on-cst

(defthm smtp-cst-cr-conc-rep-tree-equiv-congruence-on-cst
  (implies (tree-equiv cst cst-equiv)
           (equal (smtp-cst-cr-conc-rep cst)
                  (smtp-cst-cr-conc-rep cst-equiv)))
  :rule-classes :congruence)

Function: smtp-cst-digit-conc-rep

(defun smtp-cst-digit-conc-rep (cst)
  (declare (xargs :guard (treep cst)))
  (declare (xargs :guard (smtp-cst-matchp cst "digit")))
  (let ((__function__ 'smtp-cst-digit-conc-rep))
    (declare (ignorable __function__))
    (tree-list-fix (nth 0 (smtp-cst-digit-conc cst)))))

Theorem: tree-listp-of-smtp-cst-digit-conc-rep

(defthm tree-listp-of-smtp-cst-digit-conc-rep
  (b* ((csts (smtp-cst-digit-conc-rep cst)))
    (tree-listp csts))
  :rule-classes :rewrite)

Theorem: smtp-cst-digit-conc-rep-match

(defthm smtp-cst-digit-conc-rep-match
  (implies (smtp-cst-matchp cst "digit")
           (b* ((csts (smtp-cst-digit-conc-rep cst)))
             (smtp-cst-list-rep-matchp csts "%x30-39")))
  :rule-classes :rewrite)

Theorem: smtp-cst-digit-conc-rep-of-tree-fix-cst

(defthm smtp-cst-digit-conc-rep-of-tree-fix-cst
  (equal (smtp-cst-digit-conc-rep (tree-fix cst))
         (smtp-cst-digit-conc-rep cst)))

Theorem: smtp-cst-digit-conc-rep-tree-equiv-congruence-on-cst

(defthm smtp-cst-digit-conc-rep-tree-equiv-congruence-on-cst
  (implies (tree-equiv cst cst-equiv)
           (equal (smtp-cst-digit-conc-rep cst)
                  (smtp-cst-digit-conc-rep cst-equiv)))
  :rule-classes :congruence)

Function: smtp-cst-dquote-conc-rep

(defun smtp-cst-dquote-conc-rep (cst)
  (declare (xargs :guard (treep cst)))
  (declare (xargs :guard (smtp-cst-matchp cst "dquote")))
  (let ((__function__ 'smtp-cst-dquote-conc-rep))
    (declare (ignorable __function__))
    (tree-list-fix (nth 0 (smtp-cst-dquote-conc cst)))))

Theorem: tree-listp-of-smtp-cst-dquote-conc-rep

(defthm tree-listp-of-smtp-cst-dquote-conc-rep
  (b* ((csts (smtp-cst-dquote-conc-rep cst)))
    (tree-listp csts))
  :rule-classes :rewrite)

Theorem: smtp-cst-dquote-conc-rep-match

(defthm smtp-cst-dquote-conc-rep-match
  (implies (smtp-cst-matchp cst "dquote")
           (b* ((csts (smtp-cst-dquote-conc-rep cst)))
             (smtp-cst-list-rep-matchp csts "%x22")))
  :rule-classes :rewrite)

Theorem: smtp-cst-dquote-conc-rep-of-tree-fix-cst

(defthm smtp-cst-dquote-conc-rep-of-tree-fix-cst
  (equal (smtp-cst-dquote-conc-rep (tree-fix cst))
         (smtp-cst-dquote-conc-rep cst)))

Theorem: smtp-cst-dquote-conc-rep-tree-equiv-congruence-on-cst

(defthm smtp-cst-dquote-conc-rep-tree-equiv-congruence-on-cst
  (implies (tree-equiv cst cst-equiv)
           (equal (smtp-cst-dquote-conc-rep cst)
                  (smtp-cst-dquote-conc-rep cst-equiv)))
  :rule-classes :congruence)

Function: smtp-cst-lf-conc-rep

(defun smtp-cst-lf-conc-rep (cst)
  (declare (xargs :guard (treep cst)))
  (declare (xargs :guard (smtp-cst-matchp cst "lf")))
  (let ((__function__ 'smtp-cst-lf-conc-rep))
    (declare (ignorable __function__))
    (tree-list-fix (nth 0 (smtp-cst-lf-conc cst)))))

Theorem: tree-listp-of-smtp-cst-lf-conc-rep

(defthm tree-listp-of-smtp-cst-lf-conc-rep
  (b* ((csts (smtp-cst-lf-conc-rep cst)))
    (tree-listp csts))
  :rule-classes :rewrite)

Theorem: smtp-cst-lf-conc-rep-match

(defthm smtp-cst-lf-conc-rep-match
  (implies (smtp-cst-matchp cst "lf")
           (b* ((csts (smtp-cst-lf-conc-rep cst)))
             (smtp-cst-list-rep-matchp csts "%xA")))
  :rule-classes :rewrite)

Theorem: smtp-cst-lf-conc-rep-of-tree-fix-cst

(defthm smtp-cst-lf-conc-rep-of-tree-fix-cst
  (equal (smtp-cst-lf-conc-rep (tree-fix cst))
         (smtp-cst-lf-conc-rep cst)))

Theorem: smtp-cst-lf-conc-rep-tree-equiv-congruence-on-cst

(defthm smtp-cst-lf-conc-rep-tree-equiv-congruence-on-cst
  (implies (tree-equiv cst cst-equiv)
           (equal (smtp-cst-lf-conc-rep cst)
                  (smtp-cst-lf-conc-rep cst-equiv)))
  :rule-classes :congruence)

Function: smtp-cst-sp-conc-rep

(defun smtp-cst-sp-conc-rep (cst)
  (declare (xargs :guard (treep cst)))
  (declare (xargs :guard (smtp-cst-matchp cst "sp")))
  (let ((__function__ 'smtp-cst-sp-conc-rep))
    (declare (ignorable __function__))
    (tree-list-fix (nth 0 (smtp-cst-sp-conc cst)))))

Theorem: tree-listp-of-smtp-cst-sp-conc-rep

(defthm tree-listp-of-smtp-cst-sp-conc-rep
  (b* ((csts (smtp-cst-sp-conc-rep cst)))
    (tree-listp csts))
  :rule-classes :rewrite)

Theorem: smtp-cst-sp-conc-rep-match

(defthm smtp-cst-sp-conc-rep-match
  (implies (smtp-cst-matchp cst "sp")
           (b* ((csts (smtp-cst-sp-conc-rep cst)))
             (smtp-cst-list-rep-matchp csts "%x20")))
  :rule-classes :rewrite)

Theorem: smtp-cst-sp-conc-rep-of-tree-fix-cst

(defthm smtp-cst-sp-conc-rep-of-tree-fix-cst
  (equal (smtp-cst-sp-conc-rep (tree-fix cst))
         (smtp-cst-sp-conc-rep cst)))

Theorem: smtp-cst-sp-conc-rep-tree-equiv-congruence-on-cst

(defthm smtp-cst-sp-conc-rep-tree-equiv-congruence-on-cst
  (implies (tree-equiv cst cst-equiv)
           (equal (smtp-cst-sp-conc-rep cst)
                  (smtp-cst-sp-conc-rep cst-equiv)))
  :rule-classes :congruence)

Function: smtp-cst-vchar-conc-rep

(defun smtp-cst-vchar-conc-rep (cst)
  (declare (xargs :guard (treep cst)))
  (declare (xargs :guard (smtp-cst-matchp cst "vchar")))
  (let ((__function__ 'smtp-cst-vchar-conc-rep))
    (declare (ignorable __function__))
    (tree-list-fix (nth 0 (smtp-cst-vchar-conc cst)))))

Theorem: tree-listp-of-smtp-cst-vchar-conc-rep

(defthm tree-listp-of-smtp-cst-vchar-conc-rep
  (b* ((csts (smtp-cst-vchar-conc-rep cst)))
    (tree-listp csts))
  :rule-classes :rewrite)

Theorem: smtp-cst-vchar-conc-rep-match

(defthm smtp-cst-vchar-conc-rep-match
  (implies (smtp-cst-matchp cst "vchar")
           (b* ((csts (smtp-cst-vchar-conc-rep cst)))
             (smtp-cst-list-rep-matchp csts "%x21-7E")))
  :rule-classes :rewrite)

Theorem: smtp-cst-vchar-conc-rep-of-tree-fix-cst

(defthm smtp-cst-vchar-conc-rep-of-tree-fix-cst
  (equal (smtp-cst-vchar-conc-rep (tree-fix cst))
         (smtp-cst-vchar-conc-rep cst)))

Theorem: smtp-cst-vchar-conc-rep-tree-equiv-congruence-on-cst

(defthm smtp-cst-vchar-conc-rep-tree-equiv-congruence-on-cst
  (implies (tree-equiv cst cst-equiv)
           (equal (smtp-cst-vchar-conc-rep cst)
                  (smtp-cst-vchar-conc-rep cst-equiv)))
  :rule-classes :congruence)

Function: smtp-cst-wsp-conc1-rep

(defun smtp-cst-wsp-conc1-rep (cst)
  (declare (xargs :guard (treep cst)))
  (declare (xargs :guard (and (smtp-cst-matchp cst "wsp")
                              (equal (smtp-cst-wsp-conc? cst) 1))))
  (let ((__function__ 'smtp-cst-wsp-conc1-rep))
    (declare (ignorable __function__))
    (tree-list-fix (nth 0 (smtp-cst-wsp-conc1 cst)))))

Theorem: tree-listp-of-smtp-cst-wsp-conc1-rep

(defthm tree-listp-of-smtp-cst-wsp-conc1-rep
  (b* ((csts (smtp-cst-wsp-conc1-rep cst)))
    (tree-listp csts))
  :rule-classes :rewrite)

Theorem: smtp-cst-wsp-conc1-rep-match

(defthm smtp-cst-wsp-conc1-rep-match
  (implies (and (smtp-cst-matchp cst "wsp")
                (equal (smtp-cst-wsp-conc? cst) 1))
           (b* ((csts (smtp-cst-wsp-conc1-rep cst)))
             (smtp-cst-list-rep-matchp csts "sp")))
  :rule-classes :rewrite)

Theorem: smtp-cst-wsp-conc1-rep-of-tree-fix-cst

(defthm smtp-cst-wsp-conc1-rep-of-tree-fix-cst
  (equal (smtp-cst-wsp-conc1-rep (tree-fix cst))
         (smtp-cst-wsp-conc1-rep cst)))

Theorem: smtp-cst-wsp-conc1-rep-tree-equiv-congruence-on-cst

(defthm smtp-cst-wsp-conc1-rep-tree-equiv-congruence-on-cst
  (implies (tree-equiv cst cst-equiv)
           (equal (smtp-cst-wsp-conc1-rep cst)
                  (smtp-cst-wsp-conc1-rep cst-equiv)))
  :rule-classes :congruence)

Function: smtp-cst-wsp-conc2-rep

(defun smtp-cst-wsp-conc2-rep (cst)
  (declare (xargs :guard (treep cst)))
  (declare (xargs :guard (and (smtp-cst-matchp cst "wsp")
                              (equal (smtp-cst-wsp-conc? cst) 2))))
  (let ((__function__ 'smtp-cst-wsp-conc2-rep))
    (declare (ignorable __function__))
    (tree-list-fix (nth 0 (smtp-cst-wsp-conc2 cst)))))

Theorem: tree-listp-of-smtp-cst-wsp-conc2-rep

(defthm tree-listp-of-smtp-cst-wsp-conc2-rep
  (b* ((csts (smtp-cst-wsp-conc2-rep cst)))
    (tree-listp csts))
  :rule-classes :rewrite)

Theorem: smtp-cst-wsp-conc2-rep-match

(defthm smtp-cst-wsp-conc2-rep-match
  (implies (and (smtp-cst-matchp cst "wsp")
                (equal (smtp-cst-wsp-conc? cst) 2))
           (b* ((csts (smtp-cst-wsp-conc2-rep cst)))
             (smtp-cst-list-rep-matchp csts "htab")))
  :rule-classes :rewrite)

Theorem: smtp-cst-wsp-conc2-rep-of-tree-fix-cst

(defthm smtp-cst-wsp-conc2-rep-of-tree-fix-cst
  (equal (smtp-cst-wsp-conc2-rep (tree-fix cst))
         (smtp-cst-wsp-conc2-rep cst)))

Theorem: smtp-cst-wsp-conc2-rep-tree-equiv-congruence-on-cst

(defthm smtp-cst-wsp-conc2-rep-tree-equiv-congruence-on-cst
  (implies (tree-equiv cst cst-equiv)
           (equal (smtp-cst-wsp-conc2-rep cst)
                  (smtp-cst-wsp-conc2-rep cst-equiv)))
  :rule-classes :congruence)

Function: smtp-cst-htab-conc-rep

(defun smtp-cst-htab-conc-rep (cst)
  (declare (xargs :guard (treep cst)))
  (declare (xargs :guard (smtp-cst-matchp cst "htab")))
  (let ((__function__ 'smtp-cst-htab-conc-rep))
    (declare (ignorable __function__))
    (tree-list-fix (nth 0 (smtp-cst-htab-conc cst)))))

Theorem: tree-listp-of-smtp-cst-htab-conc-rep

(defthm tree-listp-of-smtp-cst-htab-conc-rep
  (b* ((csts (smtp-cst-htab-conc-rep cst)))
    (tree-listp csts))
  :rule-classes :rewrite)

Theorem: smtp-cst-htab-conc-rep-match

(defthm smtp-cst-htab-conc-rep-match
  (implies (smtp-cst-matchp cst "htab")
           (b* ((csts (smtp-cst-htab-conc-rep cst)))
             (smtp-cst-list-rep-matchp csts "%x9")))
  :rule-classes :rewrite)

Theorem: smtp-cst-htab-conc-rep-of-tree-fix-cst

(defthm smtp-cst-htab-conc-rep-of-tree-fix-cst
  (equal (smtp-cst-htab-conc-rep (tree-fix cst))
         (smtp-cst-htab-conc-rep cst)))

Theorem: smtp-cst-htab-conc-rep-tree-equiv-congruence-on-cst

(defthm smtp-cst-htab-conc-rep-tree-equiv-congruence-on-cst
  (implies (tree-equiv cst cst-equiv)
           (equal (smtp-cst-htab-conc-rep cst)
                  (smtp-cst-htab-conc-rep cst-equiv)))
  :rule-classes :congruence)

Function: smtp-cst-forward-path-conc-rep-elem

(defun smtp-cst-forward-path-conc-rep-elem (cst)
  (declare (xargs :guard (treep cst)))
  (declare (xargs :guard (smtp-cst-matchp cst "forward-path")))
  (let ((__function__ 'smtp-cst-forward-path-conc-rep-elem))
    (declare (ignorable __function__))
    (tree-fix (nth 0
                   (smtp-cst-forward-path-conc-rep cst)))))

Theorem: treep-of-smtp-cst-forward-path-conc-rep-elem

(defthm treep-of-smtp-cst-forward-path-conc-rep-elem
  (b* ((cst1 (smtp-cst-forward-path-conc-rep-elem cst)))
    (treep cst1))
  :rule-classes :rewrite)

Theorem: smtp-cst-forward-path-conc-rep-elem-match

(defthm smtp-cst-forward-path-conc-rep-elem-match
  (implies (smtp-cst-matchp cst "forward-path")
           (b* ((cst1 (smtp-cst-forward-path-conc-rep-elem cst)))
             (smtp-cst-matchp cst1 "path")))
  :rule-classes :rewrite)

Theorem: smtp-cst-forward-path-conc-rep-elem-of-tree-fix-cst

(defthm smtp-cst-forward-path-conc-rep-elem-of-tree-fix-cst
  (equal (smtp-cst-forward-path-conc-rep-elem (tree-fix cst))
         (smtp-cst-forward-path-conc-rep-elem cst)))

Theorem: smtp-cst-forward-path-conc-rep-elem-tree-equiv-congruence-on-cst

(defthm
   smtp-cst-forward-path-conc-rep-elem-tree-equiv-congruence-on-cst
  (implies (tree-equiv cst cst-equiv)
           (equal (smtp-cst-forward-path-conc-rep-elem cst)
                  (smtp-cst-forward-path-conc-rep-elem cst-equiv)))
  :rule-classes :congruence)

Function: smtp-cst-keyword-conc-rep-elem

(defun smtp-cst-keyword-conc-rep-elem (cst)
  (declare (xargs :guard (treep cst)))
  (declare (xargs :guard (smtp-cst-matchp cst "keyword")))
  (let ((__function__ 'smtp-cst-keyword-conc-rep-elem))
    (declare (ignorable __function__))
    (tree-fix (nth 0 (smtp-cst-keyword-conc-rep cst)))))

Theorem: treep-of-smtp-cst-keyword-conc-rep-elem

(defthm treep-of-smtp-cst-keyword-conc-rep-elem
  (b* ((cst1 (smtp-cst-keyword-conc-rep-elem cst)))
    (treep cst1))
  :rule-classes :rewrite)

Theorem: smtp-cst-keyword-conc-rep-elem-match

(defthm smtp-cst-keyword-conc-rep-elem-match
  (implies (smtp-cst-matchp cst "keyword")
           (b* ((cst1 (smtp-cst-keyword-conc-rep-elem cst)))
             (smtp-cst-matchp cst1 "ldh-str")))
  :rule-classes :rewrite)

Theorem: smtp-cst-keyword-conc-rep-elem-of-tree-fix-cst

(defthm smtp-cst-keyword-conc-rep-elem-of-tree-fix-cst
  (equal (smtp-cst-keyword-conc-rep-elem (tree-fix cst))
         (smtp-cst-keyword-conc-rep-elem cst)))

Theorem: smtp-cst-keyword-conc-rep-elem-tree-equiv-congruence-on-cst

(defthm smtp-cst-keyword-conc-rep-elem-tree-equiv-congruence-on-cst
  (implies (tree-equiv cst cst-equiv)
           (equal (smtp-cst-keyword-conc-rep-elem cst)
                  (smtp-cst-keyword-conc-rep-elem cst-equiv)))
  :rule-classes :congruence)

Function: smtp-cst-argument-conc-rep-elem

(defun smtp-cst-argument-conc-rep-elem (cst)
  (declare (xargs :guard (treep cst)))
  (declare (xargs :guard (smtp-cst-matchp cst "argument")))
  (let ((__function__ 'smtp-cst-argument-conc-rep-elem))
    (declare (ignorable __function__))
    (tree-fix (nth 0 (smtp-cst-argument-conc-rep cst)))))

Theorem: treep-of-smtp-cst-argument-conc-rep-elem

(defthm treep-of-smtp-cst-argument-conc-rep-elem
  (b* ((cst1 (smtp-cst-argument-conc-rep-elem cst)))
    (treep cst1))
  :rule-classes :rewrite)

Theorem: smtp-cst-argument-conc-rep-elem-match

(defthm smtp-cst-argument-conc-rep-elem-match
  (implies (smtp-cst-matchp cst "argument")
           (b* ((cst1 (smtp-cst-argument-conc-rep-elem cst)))
             (smtp-cst-matchp cst1 "atom")))
  :rule-classes :rewrite)

Theorem: smtp-cst-argument-conc-rep-elem-of-tree-fix-cst

(defthm smtp-cst-argument-conc-rep-elem-of-tree-fix-cst
  (equal (smtp-cst-argument-conc-rep-elem (tree-fix cst))
         (smtp-cst-argument-conc-rep-elem cst)))

Theorem: smtp-cst-argument-conc-rep-elem-tree-equiv-congruence-on-cst

(defthm smtp-cst-argument-conc-rep-elem-tree-equiv-congruence-on-cst
  (implies (tree-equiv cst cst-equiv)
           (equal (smtp-cst-argument-conc-rep-elem cst)
                  (smtp-cst-argument-conc-rep-elem cst-equiv)))
  :rule-classes :congruence)

Function: smtp-cst-let-dig-conc1-rep-elem

(defun smtp-cst-let-dig-conc1-rep-elem (cst)
  (declare (xargs :guard (treep cst)))
  (declare (xargs :guard (and (smtp-cst-matchp cst "let-dig")
                              (equal (smtp-cst-let-dig-conc? cst)
                                     1))))
  (let ((__function__ 'smtp-cst-let-dig-conc1-rep-elem))
    (declare (ignorable __function__))
    (tree-fix (nth 0 (smtp-cst-let-dig-conc1-rep cst)))))

Theorem: treep-of-smtp-cst-let-dig-conc1-rep-elem

(defthm treep-of-smtp-cst-let-dig-conc1-rep-elem
  (b* ((cst1 (smtp-cst-let-dig-conc1-rep-elem cst)))
    (treep cst1))
  :rule-classes :rewrite)

Theorem: smtp-cst-let-dig-conc1-rep-elem-match

(defthm smtp-cst-let-dig-conc1-rep-elem-match
  (implies (and (smtp-cst-matchp cst "let-dig")
                (equal (smtp-cst-let-dig-conc? cst) 1))
           (b* ((cst1 (smtp-cst-let-dig-conc1-rep-elem cst)))
             (smtp-cst-matchp cst1 "alpha")))
  :rule-classes :rewrite)

Theorem: smtp-cst-let-dig-conc1-rep-elem-of-tree-fix-cst

(defthm smtp-cst-let-dig-conc1-rep-elem-of-tree-fix-cst
  (equal (smtp-cst-let-dig-conc1-rep-elem (tree-fix cst))
         (smtp-cst-let-dig-conc1-rep-elem cst)))

Theorem: smtp-cst-let-dig-conc1-rep-elem-tree-equiv-congruence-on-cst

(defthm smtp-cst-let-dig-conc1-rep-elem-tree-equiv-congruence-on-cst
  (implies (tree-equiv cst cst-equiv)
           (equal (smtp-cst-let-dig-conc1-rep-elem cst)
                  (smtp-cst-let-dig-conc1-rep-elem cst-equiv)))
  :rule-classes :congruence)

Function: smtp-cst-let-dig-conc2-rep-elem

(defun smtp-cst-let-dig-conc2-rep-elem (cst)
  (declare (xargs :guard (treep cst)))
  (declare (xargs :guard (and (smtp-cst-matchp cst "let-dig")
                              (equal (smtp-cst-let-dig-conc? cst)
                                     2))))
  (let ((__function__ 'smtp-cst-let-dig-conc2-rep-elem))
    (declare (ignorable __function__))
    (tree-fix (nth 0 (smtp-cst-let-dig-conc2-rep cst)))))

Theorem: treep-of-smtp-cst-let-dig-conc2-rep-elem

(defthm treep-of-smtp-cst-let-dig-conc2-rep-elem
  (b* ((cst1 (smtp-cst-let-dig-conc2-rep-elem cst)))
    (treep cst1))
  :rule-classes :rewrite)

Theorem: smtp-cst-let-dig-conc2-rep-elem-match

(defthm smtp-cst-let-dig-conc2-rep-elem-match
  (implies (and (smtp-cst-matchp cst "let-dig")
                (equal (smtp-cst-let-dig-conc? cst) 2))
           (b* ((cst1 (smtp-cst-let-dig-conc2-rep-elem cst)))
             (smtp-cst-matchp cst1 "digit")))
  :rule-classes :rewrite)

Theorem: smtp-cst-let-dig-conc2-rep-elem-of-tree-fix-cst

(defthm smtp-cst-let-dig-conc2-rep-elem-of-tree-fix-cst
  (equal (smtp-cst-let-dig-conc2-rep-elem (tree-fix cst))
         (smtp-cst-let-dig-conc2-rep-elem cst)))

Theorem: smtp-cst-let-dig-conc2-rep-elem-tree-equiv-congruence-on-cst

(defthm smtp-cst-let-dig-conc2-rep-elem-tree-equiv-congruence-on-cst
  (implies (tree-equiv cst cst-equiv)
           (equal (smtp-cst-let-dig-conc2-rep-elem cst)
                  (smtp-cst-let-dig-conc2-rep-elem cst-equiv)))
  :rule-classes :congruence)

Function: smtp-cst-local-part-conc1-rep-elem

(defun smtp-cst-local-part-conc1-rep-elem (cst)
  (declare (xargs :guard (treep cst)))
  (declare (xargs :guard (and (smtp-cst-matchp cst "local-part")
                              (equal (smtp-cst-local-part-conc? cst)
                                     1))))
  (let ((__function__ 'smtp-cst-local-part-conc1-rep-elem))
    (declare (ignorable __function__))
    (tree-fix (nth 0
                   (smtp-cst-local-part-conc1-rep cst)))))

Theorem: treep-of-smtp-cst-local-part-conc1-rep-elem

(defthm treep-of-smtp-cst-local-part-conc1-rep-elem
  (b* ((cst1 (smtp-cst-local-part-conc1-rep-elem cst)))
    (treep cst1))
  :rule-classes :rewrite)

Theorem: smtp-cst-local-part-conc1-rep-elem-match

(defthm smtp-cst-local-part-conc1-rep-elem-match
  (implies (and (smtp-cst-matchp cst "local-part")
                (equal (smtp-cst-local-part-conc? cst)
                       1))
           (b* ((cst1 (smtp-cst-local-part-conc1-rep-elem cst)))
             (smtp-cst-matchp cst1 "dot-string")))
  :rule-classes :rewrite)

Theorem: smtp-cst-local-part-conc1-rep-elem-of-tree-fix-cst

(defthm smtp-cst-local-part-conc1-rep-elem-of-tree-fix-cst
  (equal (smtp-cst-local-part-conc1-rep-elem (tree-fix cst))
         (smtp-cst-local-part-conc1-rep-elem cst)))

Theorem: smtp-cst-local-part-conc1-rep-elem-tree-equiv-congruence-on-cst

(defthm
    smtp-cst-local-part-conc1-rep-elem-tree-equiv-congruence-on-cst
  (implies (tree-equiv cst cst-equiv)
           (equal (smtp-cst-local-part-conc1-rep-elem cst)
                  (smtp-cst-local-part-conc1-rep-elem cst-equiv)))
  :rule-classes :congruence)

Function: smtp-cst-local-part-conc2-rep-elem

(defun smtp-cst-local-part-conc2-rep-elem (cst)
  (declare (xargs :guard (treep cst)))
  (declare (xargs :guard (and (smtp-cst-matchp cst "local-part")
                              (equal (smtp-cst-local-part-conc? cst)
                                     2))))
  (let ((__function__ 'smtp-cst-local-part-conc2-rep-elem))
    (declare (ignorable __function__))
    (tree-fix (nth 0
                   (smtp-cst-local-part-conc2-rep cst)))))

Theorem: treep-of-smtp-cst-local-part-conc2-rep-elem

(defthm treep-of-smtp-cst-local-part-conc2-rep-elem
  (b* ((cst1 (smtp-cst-local-part-conc2-rep-elem cst)))
    (treep cst1))
  :rule-classes :rewrite)

Theorem: smtp-cst-local-part-conc2-rep-elem-match

(defthm smtp-cst-local-part-conc2-rep-elem-match
  (implies (and (smtp-cst-matchp cst "local-part")
                (equal (smtp-cst-local-part-conc? cst)
                       2))
           (b* ((cst1 (smtp-cst-local-part-conc2-rep-elem cst)))
             (smtp-cst-matchp cst1 "quoted-string")))
  :rule-classes :rewrite)

Theorem: smtp-cst-local-part-conc2-rep-elem-of-tree-fix-cst

(defthm smtp-cst-local-part-conc2-rep-elem-of-tree-fix-cst
  (equal (smtp-cst-local-part-conc2-rep-elem (tree-fix cst))
         (smtp-cst-local-part-conc2-rep-elem cst)))

Theorem: smtp-cst-local-part-conc2-rep-elem-tree-equiv-congruence-on-cst

(defthm
    smtp-cst-local-part-conc2-rep-elem-tree-equiv-congruence-on-cst
  (implies (tree-equiv cst cst-equiv)
           (equal (smtp-cst-local-part-conc2-rep-elem cst)
                  (smtp-cst-local-part-conc2-rep-elem cst-equiv)))
  :rule-classes :congruence)

Function: smtp-cst-qcontentsmtp-conc1-rep-elem

(defun smtp-cst-qcontentsmtp-conc1-rep-elem (cst)
  (declare (xargs :guard (treep cst)))
  (declare
       (xargs :guard (and (smtp-cst-matchp cst "qcontentsmtp")
                          (equal (smtp-cst-qcontentsmtp-conc? cst)
                                 1))))
  (let ((__function__ 'smtp-cst-qcontentsmtp-conc1-rep-elem))
    (declare (ignorable __function__))
    (tree-fix (nth 0
                   (smtp-cst-qcontentsmtp-conc1-rep cst)))))

Theorem: treep-of-smtp-cst-qcontentsmtp-conc1-rep-elem

(defthm treep-of-smtp-cst-qcontentsmtp-conc1-rep-elem
  (b* ((cst1 (smtp-cst-qcontentsmtp-conc1-rep-elem cst)))
    (treep cst1))
  :rule-classes :rewrite)

Theorem: smtp-cst-qcontentsmtp-conc1-rep-elem-match

(defthm smtp-cst-qcontentsmtp-conc1-rep-elem-match
  (implies (and (smtp-cst-matchp cst "qcontentsmtp")
                (equal (smtp-cst-qcontentsmtp-conc? cst)
                       1))
           (b* ((cst1 (smtp-cst-qcontentsmtp-conc1-rep-elem cst)))
             (smtp-cst-matchp cst1 "qtextsmtp")))
  :rule-classes :rewrite)

Theorem: smtp-cst-qcontentsmtp-conc1-rep-elem-of-tree-fix-cst

(defthm smtp-cst-qcontentsmtp-conc1-rep-elem-of-tree-fix-cst
  (equal (smtp-cst-qcontentsmtp-conc1-rep-elem (tree-fix cst))
         (smtp-cst-qcontentsmtp-conc1-rep-elem cst)))

Theorem: smtp-cst-qcontentsmtp-conc1-rep-elem-tree-equiv-congruence-on-cst

(defthm
  smtp-cst-qcontentsmtp-conc1-rep-elem-tree-equiv-congruence-on-cst
  (implies (tree-equiv cst cst-equiv)
           (equal (smtp-cst-qcontentsmtp-conc1-rep-elem cst)
                  (smtp-cst-qcontentsmtp-conc1-rep-elem cst-equiv)))
  :rule-classes :congruence)

Function: smtp-cst-qcontentsmtp-conc2-rep-elem

(defun smtp-cst-qcontentsmtp-conc2-rep-elem (cst)
  (declare (xargs :guard (treep cst)))
  (declare
       (xargs :guard (and (smtp-cst-matchp cst "qcontentsmtp")
                          (equal (smtp-cst-qcontentsmtp-conc? cst)
                                 2))))
  (let ((__function__ 'smtp-cst-qcontentsmtp-conc2-rep-elem))
    (declare (ignorable __function__))
    (tree-fix (nth 0
                   (smtp-cst-qcontentsmtp-conc2-rep cst)))))

Theorem: treep-of-smtp-cst-qcontentsmtp-conc2-rep-elem

(defthm treep-of-smtp-cst-qcontentsmtp-conc2-rep-elem
  (b* ((cst1 (smtp-cst-qcontentsmtp-conc2-rep-elem cst)))
    (treep cst1))
  :rule-classes :rewrite)

Theorem: smtp-cst-qcontentsmtp-conc2-rep-elem-match

(defthm smtp-cst-qcontentsmtp-conc2-rep-elem-match
  (implies (and (smtp-cst-matchp cst "qcontentsmtp")
                (equal (smtp-cst-qcontentsmtp-conc? cst)
                       2))
           (b* ((cst1 (smtp-cst-qcontentsmtp-conc2-rep-elem cst)))
             (smtp-cst-matchp cst1 "quoted-pairsmtp")))
  :rule-classes :rewrite)

Theorem: smtp-cst-qcontentsmtp-conc2-rep-elem-of-tree-fix-cst

(defthm smtp-cst-qcontentsmtp-conc2-rep-elem-of-tree-fix-cst
  (equal (smtp-cst-qcontentsmtp-conc2-rep-elem (tree-fix cst))
         (smtp-cst-qcontentsmtp-conc2-rep-elem cst)))

Theorem: smtp-cst-qcontentsmtp-conc2-rep-elem-tree-equiv-congruence-on-cst

(defthm
  smtp-cst-qcontentsmtp-conc2-rep-elem-tree-equiv-congruence-on-cst
  (implies (tree-equiv cst cst-equiv)
           (equal (smtp-cst-qcontentsmtp-conc2-rep-elem cst)
                  (smtp-cst-qcontentsmtp-conc2-rep-elem cst-equiv)))
  :rule-classes :congruence)

Function: smtp-cst-string-conc1-rep-elem

(defun smtp-cst-string-conc1-rep-elem (cst)
  (declare (xargs :guard (treep cst)))
  (declare
       (xargs :guard (and (smtp-cst-matchp cst "string")
                          (equal (smtp-cst-string-conc? cst) 1))))
  (let ((__function__ 'smtp-cst-string-conc1-rep-elem))
    (declare (ignorable __function__))
    (tree-fix (nth 0 (smtp-cst-string-conc1-rep cst)))))

Theorem: treep-of-smtp-cst-string-conc1-rep-elem

(defthm treep-of-smtp-cst-string-conc1-rep-elem
  (b* ((cst1 (smtp-cst-string-conc1-rep-elem cst)))
    (treep cst1))
  :rule-classes :rewrite)

Theorem: smtp-cst-string-conc1-rep-elem-match

(defthm smtp-cst-string-conc1-rep-elem-match
  (implies (and (smtp-cst-matchp cst "string")
                (equal (smtp-cst-string-conc? cst) 1))
           (b* ((cst1 (smtp-cst-string-conc1-rep-elem cst)))
             (smtp-cst-matchp cst1 "atom")))
  :rule-classes :rewrite)

Theorem: smtp-cst-string-conc1-rep-elem-of-tree-fix-cst

(defthm smtp-cst-string-conc1-rep-elem-of-tree-fix-cst
  (equal (smtp-cst-string-conc1-rep-elem (tree-fix cst))
         (smtp-cst-string-conc1-rep-elem cst)))

Theorem: smtp-cst-string-conc1-rep-elem-tree-equiv-congruence-on-cst

(defthm smtp-cst-string-conc1-rep-elem-tree-equiv-congruence-on-cst
  (implies (tree-equiv cst cst-equiv)
           (equal (smtp-cst-string-conc1-rep-elem cst)
                  (smtp-cst-string-conc1-rep-elem cst-equiv)))
  :rule-classes :congruence)

Function: smtp-cst-string-conc2-rep-elem

(defun smtp-cst-string-conc2-rep-elem (cst)
  (declare (xargs :guard (treep cst)))
  (declare
       (xargs :guard (and (smtp-cst-matchp cst "string")
                          (equal (smtp-cst-string-conc? cst) 2))))
  (let ((__function__ 'smtp-cst-string-conc2-rep-elem))
    (declare (ignorable __function__))
    (tree-fix (nth 0 (smtp-cst-string-conc2-rep cst)))))

Theorem: treep-of-smtp-cst-string-conc2-rep-elem

(defthm treep-of-smtp-cst-string-conc2-rep-elem
  (b* ((cst1 (smtp-cst-string-conc2-rep-elem cst)))
    (treep cst1))
  :rule-classes :rewrite)

Theorem: smtp-cst-string-conc2-rep-elem-match

(defthm smtp-cst-string-conc2-rep-elem-match
  (implies (and (smtp-cst-matchp cst "string")
                (equal (smtp-cst-string-conc? cst) 2))
           (b* ((cst1 (smtp-cst-string-conc2-rep-elem cst)))
             (smtp-cst-matchp cst1 "quoted-string")))
  :rule-classes :rewrite)

Theorem: smtp-cst-string-conc2-rep-elem-of-tree-fix-cst

(defthm smtp-cst-string-conc2-rep-elem-of-tree-fix-cst
  (equal (smtp-cst-string-conc2-rep-elem (tree-fix cst))
         (smtp-cst-string-conc2-rep-elem cst)))

Theorem: smtp-cst-string-conc2-rep-elem-tree-equiv-congruence-on-cst

(defthm smtp-cst-string-conc2-rep-elem-tree-equiv-congruence-on-cst
  (implies (tree-equiv cst cst-equiv)
           (equal (smtp-cst-string-conc2-rep-elem cst)
                  (smtp-cst-string-conc2-rep-elem cst-equiv)))
  :rule-classes :congruence)

Function: smtp-cst-standardized-tag-conc-rep-elem

(defun smtp-cst-standardized-tag-conc-rep-elem (cst)
  (declare (xargs :guard (treep cst)))
  (declare (xargs :guard (smtp-cst-matchp cst "standardized-tag")))
  (let ((__function__ 'smtp-cst-standardized-tag-conc-rep-elem))
    (declare (ignorable __function__))
    (tree-fix (nth 0
                   (smtp-cst-standardized-tag-conc-rep cst)))))

Theorem: treep-of-smtp-cst-standardized-tag-conc-rep-elem

(defthm treep-of-smtp-cst-standardized-tag-conc-rep-elem
  (b* ((cst1 (smtp-cst-standardized-tag-conc-rep-elem cst)))
    (treep cst1))
  :rule-classes :rewrite)

Theorem: smtp-cst-standardized-tag-conc-rep-elem-match

(defthm smtp-cst-standardized-tag-conc-rep-elem-match
 (implies (smtp-cst-matchp cst "standardized-tag")
          (b* ((cst1 (smtp-cst-standardized-tag-conc-rep-elem cst)))
            (smtp-cst-matchp cst1 "ldh-str")))
 :rule-classes :rewrite)

Theorem: smtp-cst-standardized-tag-conc-rep-elem-of-tree-fix-cst

(defthm smtp-cst-standardized-tag-conc-rep-elem-of-tree-fix-cst
  (equal (smtp-cst-standardized-tag-conc-rep-elem (tree-fix cst))
         (smtp-cst-standardized-tag-conc-rep-elem cst)))

Theorem: smtp-cst-standardized-tag-conc-rep-elem-tree-equiv-congruence-on-cst

(defthm
 smtp-cst-standardized-tag-conc-rep-elem-tree-equiv-congruence-on-cst
 (implies
      (tree-equiv cst cst-equiv)
      (equal (smtp-cst-standardized-tag-conc-rep-elem cst)
             (smtp-cst-standardized-tag-conc-rep-elem cst-equiv)))
 :rule-classes :congruence)

Function: smtp-cst-ipv6-addr-conc1-rep-elem

(defun smtp-cst-ipv6-addr-conc1-rep-elem (cst)
  (declare (xargs :guard (treep cst)))
  (declare (xargs :guard (and (smtp-cst-matchp cst "ipv6-addr")
                              (equal (smtp-cst-ipv6-addr-conc? cst)
                                     1))))
  (let ((__function__ 'smtp-cst-ipv6-addr-conc1-rep-elem))
    (declare (ignorable __function__))
    (tree-fix (nth 0 (smtp-cst-ipv6-addr-conc1-rep cst)))))

Theorem: treep-of-smtp-cst-ipv6-addr-conc1-rep-elem

(defthm treep-of-smtp-cst-ipv6-addr-conc1-rep-elem
  (b* ((cst1 (smtp-cst-ipv6-addr-conc1-rep-elem cst)))
    (treep cst1))
  :rule-classes :rewrite)

Theorem: smtp-cst-ipv6-addr-conc1-rep-elem-match

(defthm smtp-cst-ipv6-addr-conc1-rep-elem-match
  (implies (and (smtp-cst-matchp cst "ipv6-addr")
                (equal (smtp-cst-ipv6-addr-conc? cst)
                       1))
           (b* ((cst1 (smtp-cst-ipv6-addr-conc1-rep-elem cst)))
             (smtp-cst-matchp cst1 "ipv6-full")))
  :rule-classes :rewrite)

Theorem: smtp-cst-ipv6-addr-conc1-rep-elem-of-tree-fix-cst

(defthm smtp-cst-ipv6-addr-conc1-rep-elem-of-tree-fix-cst
  (equal (smtp-cst-ipv6-addr-conc1-rep-elem (tree-fix cst))
         (smtp-cst-ipv6-addr-conc1-rep-elem cst)))

Theorem: smtp-cst-ipv6-addr-conc1-rep-elem-tree-equiv-congruence-on-cst

(defthm
     smtp-cst-ipv6-addr-conc1-rep-elem-tree-equiv-congruence-on-cst
  (implies (tree-equiv cst cst-equiv)
           (equal (smtp-cst-ipv6-addr-conc1-rep-elem cst)
                  (smtp-cst-ipv6-addr-conc1-rep-elem cst-equiv)))
  :rule-classes :congruence)

Function: smtp-cst-ipv6-addr-conc2-rep-elem

(defun smtp-cst-ipv6-addr-conc2-rep-elem (cst)
  (declare (xargs :guard (treep cst)))
  (declare (xargs :guard (and (smtp-cst-matchp cst "ipv6-addr")
                              (equal (smtp-cst-ipv6-addr-conc? cst)
                                     2))))
  (let ((__function__ 'smtp-cst-ipv6-addr-conc2-rep-elem))
    (declare (ignorable __function__))
    (tree-fix (nth 0 (smtp-cst-ipv6-addr-conc2-rep cst)))))

Theorem: treep-of-smtp-cst-ipv6-addr-conc2-rep-elem

(defthm treep-of-smtp-cst-ipv6-addr-conc2-rep-elem
  (b* ((cst1 (smtp-cst-ipv6-addr-conc2-rep-elem cst)))
    (treep cst1))
  :rule-classes :rewrite)

Theorem: smtp-cst-ipv6-addr-conc2-rep-elem-match

(defthm smtp-cst-ipv6-addr-conc2-rep-elem-match
  (implies (and (smtp-cst-matchp cst "ipv6-addr")
                (equal (smtp-cst-ipv6-addr-conc? cst)
                       2))
           (b* ((cst1 (smtp-cst-ipv6-addr-conc2-rep-elem cst)))
             (smtp-cst-matchp cst1 "ipv6-comp")))
  :rule-classes :rewrite)

Theorem: smtp-cst-ipv6-addr-conc2-rep-elem-of-tree-fix-cst

(defthm smtp-cst-ipv6-addr-conc2-rep-elem-of-tree-fix-cst
  (equal (smtp-cst-ipv6-addr-conc2-rep-elem (tree-fix cst))
         (smtp-cst-ipv6-addr-conc2-rep-elem cst)))

Theorem: smtp-cst-ipv6-addr-conc2-rep-elem-tree-equiv-congruence-on-cst

(defthm
     smtp-cst-ipv6-addr-conc2-rep-elem-tree-equiv-congruence-on-cst
  (implies (tree-equiv cst cst-equiv)
           (equal (smtp-cst-ipv6-addr-conc2-rep-elem cst)
                  (smtp-cst-ipv6-addr-conc2-rep-elem cst-equiv)))
  :rule-classes :congruence)

Function: smtp-cst-ipv6-addr-conc3-rep-elem

(defun smtp-cst-ipv6-addr-conc3-rep-elem (cst)
  (declare (xargs :guard (treep cst)))
  (declare (xargs :guard (and (smtp-cst-matchp cst "ipv6-addr")
                              (equal (smtp-cst-ipv6-addr-conc? cst)
                                     3))))
  (let ((__function__ 'smtp-cst-ipv6-addr-conc3-rep-elem))
    (declare (ignorable __function__))
    (tree-fix (nth 0 (smtp-cst-ipv6-addr-conc3-rep cst)))))

Theorem: treep-of-smtp-cst-ipv6-addr-conc3-rep-elem

(defthm treep-of-smtp-cst-ipv6-addr-conc3-rep-elem
  (b* ((cst1 (smtp-cst-ipv6-addr-conc3-rep-elem cst)))
    (treep cst1))
  :rule-classes :rewrite)

Theorem: smtp-cst-ipv6-addr-conc3-rep-elem-match

(defthm smtp-cst-ipv6-addr-conc3-rep-elem-match
  (implies (and (smtp-cst-matchp cst "ipv6-addr")
                (equal (smtp-cst-ipv6-addr-conc? cst)
                       3))
           (b* ((cst1 (smtp-cst-ipv6-addr-conc3-rep-elem cst)))
             (smtp-cst-matchp cst1 "ipv6v4-full")))
  :rule-classes :rewrite)

Theorem: smtp-cst-ipv6-addr-conc3-rep-elem-of-tree-fix-cst

(defthm smtp-cst-ipv6-addr-conc3-rep-elem-of-tree-fix-cst
  (equal (smtp-cst-ipv6-addr-conc3-rep-elem (tree-fix cst))
         (smtp-cst-ipv6-addr-conc3-rep-elem cst)))

Theorem: smtp-cst-ipv6-addr-conc3-rep-elem-tree-equiv-congruence-on-cst

(defthm
     smtp-cst-ipv6-addr-conc3-rep-elem-tree-equiv-congruence-on-cst
  (implies (tree-equiv cst cst-equiv)
           (equal (smtp-cst-ipv6-addr-conc3-rep-elem cst)
                  (smtp-cst-ipv6-addr-conc3-rep-elem cst-equiv)))
  :rule-classes :congruence)

Function: smtp-cst-ipv6-addr-conc4-rep-elem

(defun smtp-cst-ipv6-addr-conc4-rep-elem (cst)
  (declare (xargs :guard (treep cst)))
  (declare (xargs :guard (and (smtp-cst-matchp cst "ipv6-addr")
                              (equal (smtp-cst-ipv6-addr-conc? cst)
                                     4))))
  (let ((__function__ 'smtp-cst-ipv6-addr-conc4-rep-elem))
    (declare (ignorable __function__))
    (tree-fix (nth 0 (smtp-cst-ipv6-addr-conc4-rep cst)))))

Theorem: treep-of-smtp-cst-ipv6-addr-conc4-rep-elem

(defthm treep-of-smtp-cst-ipv6-addr-conc4-rep-elem
  (b* ((cst1 (smtp-cst-ipv6-addr-conc4-rep-elem cst)))
    (treep cst1))
  :rule-classes :rewrite)

Theorem: smtp-cst-ipv6-addr-conc4-rep-elem-match

(defthm smtp-cst-ipv6-addr-conc4-rep-elem-match
  (implies (and (smtp-cst-matchp cst "ipv6-addr")
                (equal (smtp-cst-ipv6-addr-conc? cst)
                       4))
           (b* ((cst1 (smtp-cst-ipv6-addr-conc4-rep-elem cst)))
             (smtp-cst-matchp cst1 "ipv6v4-comp")))
  :rule-classes :rewrite)

Theorem: smtp-cst-ipv6-addr-conc4-rep-elem-of-tree-fix-cst

(defthm smtp-cst-ipv6-addr-conc4-rep-elem-of-tree-fix-cst
  (equal (smtp-cst-ipv6-addr-conc4-rep-elem (tree-fix cst))
         (smtp-cst-ipv6-addr-conc4-rep-elem cst)))

Theorem: smtp-cst-ipv6-addr-conc4-rep-elem-tree-equiv-congruence-on-cst

(defthm
     smtp-cst-ipv6-addr-conc4-rep-elem-tree-equiv-congruence-on-cst
  (implies (tree-equiv cst cst-equiv)
           (equal (smtp-cst-ipv6-addr-conc4-rep-elem cst)
                  (smtp-cst-ipv6-addr-conc4-rep-elem cst-equiv)))
  :rule-classes :congruence)

Function: smtp-cst-addtl-link-conc-rep-elem

(defun smtp-cst-addtl-link-conc-rep-elem (cst)
  (declare (xargs :guard (treep cst)))
  (declare (xargs :guard (smtp-cst-matchp cst "addtl-link")))
  (let ((__function__ 'smtp-cst-addtl-link-conc-rep-elem))
    (declare (ignorable __function__))
    (tree-fix (nth 0 (smtp-cst-addtl-link-conc-rep cst)))))

Theorem: treep-of-smtp-cst-addtl-link-conc-rep-elem

(defthm treep-of-smtp-cst-addtl-link-conc-rep-elem
  (b* ((cst1 (smtp-cst-addtl-link-conc-rep-elem cst)))
    (treep cst1))
  :rule-classes :rewrite)

Theorem: smtp-cst-addtl-link-conc-rep-elem-match

(defthm smtp-cst-addtl-link-conc-rep-elem-match
  (implies (smtp-cst-matchp cst "addtl-link")
           (b* ((cst1 (smtp-cst-addtl-link-conc-rep-elem cst)))
             (smtp-cst-matchp cst1 "atom")))
  :rule-classes :rewrite)

Theorem: smtp-cst-addtl-link-conc-rep-elem-of-tree-fix-cst

(defthm smtp-cst-addtl-link-conc-rep-elem-of-tree-fix-cst
  (equal (smtp-cst-addtl-link-conc-rep-elem (tree-fix cst))
         (smtp-cst-addtl-link-conc-rep-elem cst)))

Theorem: smtp-cst-addtl-link-conc-rep-elem-tree-equiv-congruence-on-cst

(defthm
     smtp-cst-addtl-link-conc-rep-elem-tree-equiv-congruence-on-cst
  (implies (tree-equiv cst cst-equiv)
           (equal (smtp-cst-addtl-link-conc-rep-elem cst)
                  (smtp-cst-addtl-link-conc-rep-elem cst-equiv)))
  :rule-classes :congruence)

Function: smtp-cst-attdl-protocol-conc-rep-elem

(defun smtp-cst-attdl-protocol-conc-rep-elem (cst)
  (declare (xargs :guard (treep cst)))
  (declare (xargs :guard (smtp-cst-matchp cst "attdl-protocol")))
  (let ((__function__ 'smtp-cst-attdl-protocol-conc-rep-elem))
    (declare (ignorable __function__))
    (tree-fix (nth 0
                   (smtp-cst-attdl-protocol-conc-rep cst)))))

Theorem: treep-of-smtp-cst-attdl-protocol-conc-rep-elem

(defthm treep-of-smtp-cst-attdl-protocol-conc-rep-elem
  (b* ((cst1 (smtp-cst-attdl-protocol-conc-rep-elem cst)))
    (treep cst1))
  :rule-classes :rewrite)

Theorem: smtp-cst-attdl-protocol-conc-rep-elem-match

(defthm smtp-cst-attdl-protocol-conc-rep-elem-match
  (implies (smtp-cst-matchp cst "attdl-protocol")
           (b* ((cst1 (smtp-cst-attdl-protocol-conc-rep-elem cst)))
             (smtp-cst-matchp cst1 "atom")))
  :rule-classes :rewrite)

Theorem: smtp-cst-attdl-protocol-conc-rep-elem-of-tree-fix-cst

(defthm smtp-cst-attdl-protocol-conc-rep-elem-of-tree-fix-cst
  (equal (smtp-cst-attdl-protocol-conc-rep-elem (tree-fix cst))
         (smtp-cst-attdl-protocol-conc-rep-elem cst)))

Theorem: smtp-cst-attdl-protocol-conc-rep-elem-tree-equiv-congruence-on-cst

(defthm
 smtp-cst-attdl-protocol-conc-rep-elem-tree-equiv-congruence-on-cst
 (implies (tree-equiv cst cst-equiv)
          (equal (smtp-cst-attdl-protocol-conc-rep-elem cst)
                 (smtp-cst-attdl-protocol-conc-rep-elem cst-equiv)))
 :rule-classes :congruence)

Function: smtp-cst-ccontent-conc1-rep-elem

(defun smtp-cst-ccontent-conc1-rep-elem (cst)
  (declare (xargs :guard (treep cst)))
  (declare (xargs :guard (and (smtp-cst-matchp cst "ccontent")
                              (equal (smtp-cst-ccontent-conc? cst)
                                     1))))
  (let ((__function__ 'smtp-cst-ccontent-conc1-rep-elem))
    (declare (ignorable __function__))
    (tree-fix (nth 0 (smtp-cst-ccontent-conc1-rep cst)))))

Theorem: treep-of-smtp-cst-ccontent-conc1-rep-elem

(defthm treep-of-smtp-cst-ccontent-conc1-rep-elem
  (b* ((cst1 (smtp-cst-ccontent-conc1-rep-elem cst)))
    (treep cst1))
  :rule-classes :rewrite)

Theorem: smtp-cst-ccontent-conc1-rep-elem-match

(defthm smtp-cst-ccontent-conc1-rep-elem-match
  (implies (and (smtp-cst-matchp cst "ccontent")
                (equal (smtp-cst-ccontent-conc? cst) 1))
           (b* ((cst1 (smtp-cst-ccontent-conc1-rep-elem cst)))
             (smtp-cst-matchp cst1 "ctext")))
  :rule-classes :rewrite)

Theorem: smtp-cst-ccontent-conc1-rep-elem-of-tree-fix-cst

(defthm smtp-cst-ccontent-conc1-rep-elem-of-tree-fix-cst
  (equal (smtp-cst-ccontent-conc1-rep-elem (tree-fix cst))
         (smtp-cst-ccontent-conc1-rep-elem cst)))

Theorem: smtp-cst-ccontent-conc1-rep-elem-tree-equiv-congruence-on-cst

(defthm
      smtp-cst-ccontent-conc1-rep-elem-tree-equiv-congruence-on-cst
  (implies (tree-equiv cst cst-equiv)
           (equal (smtp-cst-ccontent-conc1-rep-elem cst)
                  (smtp-cst-ccontent-conc1-rep-elem cst-equiv)))
  :rule-classes :congruence)

Function: smtp-cst-ccontent-conc2-rep-elem

(defun smtp-cst-ccontent-conc2-rep-elem (cst)
  (declare (xargs :guard (treep cst)))
  (declare (xargs :guard (and (smtp-cst-matchp cst "ccontent")
                              (equal (smtp-cst-ccontent-conc? cst)
                                     2))))
  (let ((__function__ 'smtp-cst-ccontent-conc2-rep-elem))
    (declare (ignorable __function__))
    (tree-fix (nth 0 (smtp-cst-ccontent-conc2-rep cst)))))

Theorem: treep-of-smtp-cst-ccontent-conc2-rep-elem

(defthm treep-of-smtp-cst-ccontent-conc2-rep-elem
  (b* ((cst1 (smtp-cst-ccontent-conc2-rep-elem cst)))
    (treep cst1))
  :rule-classes :rewrite)

Theorem: smtp-cst-ccontent-conc2-rep-elem-match

(defthm smtp-cst-ccontent-conc2-rep-elem-match
  (implies (and (smtp-cst-matchp cst "ccontent")
                (equal (smtp-cst-ccontent-conc? cst) 2))
           (b* ((cst1 (smtp-cst-ccontent-conc2-rep-elem cst)))
             (smtp-cst-matchp cst1 "quoted-pair")))
  :rule-classes :rewrite)

Theorem: smtp-cst-ccontent-conc2-rep-elem-of-tree-fix-cst

(defthm smtp-cst-ccontent-conc2-rep-elem-of-tree-fix-cst
  (equal (smtp-cst-ccontent-conc2-rep-elem (tree-fix cst))
         (smtp-cst-ccontent-conc2-rep-elem cst)))

Theorem: smtp-cst-ccontent-conc2-rep-elem-tree-equiv-congruence-on-cst

(defthm
      smtp-cst-ccontent-conc2-rep-elem-tree-equiv-congruence-on-cst
  (implies (tree-equiv cst cst-equiv)
           (equal (smtp-cst-ccontent-conc2-rep-elem cst)
                  (smtp-cst-ccontent-conc2-rep-elem cst-equiv)))
  :rule-classes :congruence)

Function: smtp-cst-ccontent-conc3-rep-elem

(defun smtp-cst-ccontent-conc3-rep-elem (cst)
  (declare (xargs :guard (treep cst)))
  (declare (xargs :guard (and (smtp-cst-matchp cst "ccontent")
                              (equal (smtp-cst-ccontent-conc? cst)
                                     3))))
  (let ((__function__ 'smtp-cst-ccontent-conc3-rep-elem))
    (declare (ignorable __function__))
    (tree-fix (nth 0 (smtp-cst-ccontent-conc3-rep cst)))))

Theorem: treep-of-smtp-cst-ccontent-conc3-rep-elem

(defthm treep-of-smtp-cst-ccontent-conc3-rep-elem
  (b* ((cst1 (smtp-cst-ccontent-conc3-rep-elem cst)))
    (treep cst1))
  :rule-classes :rewrite)

Theorem: smtp-cst-ccontent-conc3-rep-elem-match

(defthm smtp-cst-ccontent-conc3-rep-elem-match
  (implies (and (smtp-cst-matchp cst "ccontent")
                (equal (smtp-cst-ccontent-conc? cst) 3))
           (b* ((cst1 (smtp-cst-ccontent-conc3-rep-elem cst)))
             (smtp-cst-matchp cst1 "comment")))
  :rule-classes :rewrite)

Theorem: smtp-cst-ccontent-conc3-rep-elem-of-tree-fix-cst

(defthm smtp-cst-ccontent-conc3-rep-elem-of-tree-fix-cst
  (equal (smtp-cst-ccontent-conc3-rep-elem (tree-fix cst))
         (smtp-cst-ccontent-conc3-rep-elem cst)))

Theorem: smtp-cst-ccontent-conc3-rep-elem-tree-equiv-congruence-on-cst

(defthm
      smtp-cst-ccontent-conc3-rep-elem-tree-equiv-congruence-on-cst
  (implies (tree-equiv cst cst-equiv)
           (equal (smtp-cst-ccontent-conc3-rep-elem cst)
                  (smtp-cst-ccontent-conc3-rep-elem cst-equiv)))
  :rule-classes :congruence)

Function: smtp-cst-id-left-conc1-rep-elem

(defun smtp-cst-id-left-conc1-rep-elem (cst)
  (declare (xargs :guard (treep cst)))
  (declare (xargs :guard (and (smtp-cst-matchp cst "id-left")
                              (equal (smtp-cst-id-left-conc? cst)
                                     1))))
  (let ((__function__ 'smtp-cst-id-left-conc1-rep-elem))
    (declare (ignorable __function__))
    (tree-fix (nth 0 (smtp-cst-id-left-conc1-rep cst)))))

Theorem: treep-of-smtp-cst-id-left-conc1-rep-elem

(defthm treep-of-smtp-cst-id-left-conc1-rep-elem
  (b* ((cst1 (smtp-cst-id-left-conc1-rep-elem cst)))
    (treep cst1))
  :rule-classes :rewrite)

Theorem: smtp-cst-id-left-conc1-rep-elem-match

(defthm smtp-cst-id-left-conc1-rep-elem-match
  (implies (and (smtp-cst-matchp cst "id-left")
                (equal (smtp-cst-id-left-conc? cst) 1))
           (b* ((cst1 (smtp-cst-id-left-conc1-rep-elem cst)))
             (smtp-cst-matchp cst1 "dot-atom-text")))
  :rule-classes :rewrite)

Theorem: smtp-cst-id-left-conc1-rep-elem-of-tree-fix-cst

(defthm smtp-cst-id-left-conc1-rep-elem-of-tree-fix-cst
  (equal (smtp-cst-id-left-conc1-rep-elem (tree-fix cst))
         (smtp-cst-id-left-conc1-rep-elem cst)))

Theorem: smtp-cst-id-left-conc1-rep-elem-tree-equiv-congruence-on-cst

(defthm smtp-cst-id-left-conc1-rep-elem-tree-equiv-congruence-on-cst
  (implies (tree-equiv cst cst-equiv)
           (equal (smtp-cst-id-left-conc1-rep-elem cst)
                  (smtp-cst-id-left-conc1-rep-elem cst-equiv)))
  :rule-classes :congruence)

Function: smtp-cst-id-left-conc2-rep-elem

(defun smtp-cst-id-left-conc2-rep-elem (cst)
  (declare (xargs :guard (treep cst)))
  (declare (xargs :guard (and (smtp-cst-matchp cst "id-left")
                              (equal (smtp-cst-id-left-conc? cst)
                                     2))))
  (let ((__function__ 'smtp-cst-id-left-conc2-rep-elem))
    (declare (ignorable __function__))
    (tree-fix (nth 0 (smtp-cst-id-left-conc2-rep cst)))))

Theorem: treep-of-smtp-cst-id-left-conc2-rep-elem

(defthm treep-of-smtp-cst-id-left-conc2-rep-elem
  (b* ((cst1 (smtp-cst-id-left-conc2-rep-elem cst)))
    (treep cst1))
  :rule-classes :rewrite)

Theorem: smtp-cst-id-left-conc2-rep-elem-match

(defthm smtp-cst-id-left-conc2-rep-elem-match
  (implies (and (smtp-cst-matchp cst "id-left")
                (equal (smtp-cst-id-left-conc? cst) 2))
           (b* ((cst1 (smtp-cst-id-left-conc2-rep-elem cst)))
             (smtp-cst-matchp cst1 "obs-id-left")))
  :rule-classes :rewrite)

Theorem: smtp-cst-id-left-conc2-rep-elem-of-tree-fix-cst

(defthm smtp-cst-id-left-conc2-rep-elem-of-tree-fix-cst
  (equal (smtp-cst-id-left-conc2-rep-elem (tree-fix cst))
         (smtp-cst-id-left-conc2-rep-elem cst)))

Theorem: smtp-cst-id-left-conc2-rep-elem-tree-equiv-congruence-on-cst

(defthm smtp-cst-id-left-conc2-rep-elem-tree-equiv-congruence-on-cst
  (implies (tree-equiv cst cst-equiv)
           (equal (smtp-cst-id-left-conc2-rep-elem cst)
                  (smtp-cst-id-left-conc2-rep-elem cst-equiv)))
  :rule-classes :congruence)

Function: smtp-cst-id-right-conc1-rep-elem

(defun smtp-cst-id-right-conc1-rep-elem (cst)
  (declare (xargs :guard (treep cst)))
  (declare (xargs :guard (and (smtp-cst-matchp cst "id-right")
                              (equal (smtp-cst-id-right-conc? cst)
                                     1))))
  (let ((__function__ 'smtp-cst-id-right-conc1-rep-elem))
    (declare (ignorable __function__))
    (tree-fix (nth 0 (smtp-cst-id-right-conc1-rep cst)))))

Theorem: treep-of-smtp-cst-id-right-conc1-rep-elem

(defthm treep-of-smtp-cst-id-right-conc1-rep-elem
  (b* ((cst1 (smtp-cst-id-right-conc1-rep-elem cst)))
    (treep cst1))
  :rule-classes :rewrite)

Theorem: smtp-cst-id-right-conc1-rep-elem-match

(defthm smtp-cst-id-right-conc1-rep-elem-match
  (implies (and (smtp-cst-matchp cst "id-right")
                (equal (smtp-cst-id-right-conc? cst) 1))
           (b* ((cst1 (smtp-cst-id-right-conc1-rep-elem cst)))
             (smtp-cst-matchp cst1 "dot-atom-text")))
  :rule-classes :rewrite)

Theorem: smtp-cst-id-right-conc1-rep-elem-of-tree-fix-cst

(defthm smtp-cst-id-right-conc1-rep-elem-of-tree-fix-cst
  (equal (smtp-cst-id-right-conc1-rep-elem (tree-fix cst))
         (smtp-cst-id-right-conc1-rep-elem cst)))

Theorem: smtp-cst-id-right-conc1-rep-elem-tree-equiv-congruence-on-cst

(defthm
      smtp-cst-id-right-conc1-rep-elem-tree-equiv-congruence-on-cst
  (implies (tree-equiv cst cst-equiv)
           (equal (smtp-cst-id-right-conc1-rep-elem cst)
                  (smtp-cst-id-right-conc1-rep-elem cst-equiv)))
  :rule-classes :congruence)

Function: smtp-cst-id-right-conc2-rep-elem

(defun smtp-cst-id-right-conc2-rep-elem (cst)
  (declare (xargs :guard (treep cst)))
  (declare (xargs :guard (and (smtp-cst-matchp cst "id-right")
                              (equal (smtp-cst-id-right-conc? cst)
                                     2))))
  (let ((__function__ 'smtp-cst-id-right-conc2-rep-elem))
    (declare (ignorable __function__))
    (tree-fix (nth 0 (smtp-cst-id-right-conc2-rep cst)))))

Theorem: treep-of-smtp-cst-id-right-conc2-rep-elem

(defthm treep-of-smtp-cst-id-right-conc2-rep-elem
  (b* ((cst1 (smtp-cst-id-right-conc2-rep-elem cst)))
    (treep cst1))
  :rule-classes :rewrite)

Theorem: smtp-cst-id-right-conc2-rep-elem-match

(defthm smtp-cst-id-right-conc2-rep-elem-match
  (implies (and (smtp-cst-matchp cst "id-right")
                (equal (smtp-cst-id-right-conc? cst) 2))
           (b* ((cst1 (smtp-cst-id-right-conc2-rep-elem cst)))
             (smtp-cst-matchp cst1 "no-fold-literal")))
  :rule-classes :rewrite)

Theorem: smtp-cst-id-right-conc2-rep-elem-of-tree-fix-cst

(defthm smtp-cst-id-right-conc2-rep-elem-of-tree-fix-cst
  (equal (smtp-cst-id-right-conc2-rep-elem (tree-fix cst))
         (smtp-cst-id-right-conc2-rep-elem cst)))

Theorem: smtp-cst-id-right-conc2-rep-elem-tree-equiv-congruence-on-cst

(defthm
      smtp-cst-id-right-conc2-rep-elem-tree-equiv-congruence-on-cst
  (implies (tree-equiv cst cst-equiv)
           (equal (smtp-cst-id-right-conc2-rep-elem cst)
                  (smtp-cst-id-right-conc2-rep-elem cst-equiv)))
  :rule-classes :congruence)

Function: smtp-cst-id-right-conc3-rep-elem

(defun smtp-cst-id-right-conc3-rep-elem (cst)
  (declare (xargs :guard (treep cst)))
  (declare (xargs :guard (and (smtp-cst-matchp cst "id-right")
                              (equal (smtp-cst-id-right-conc? cst)
                                     3))))
  (let ((__function__ 'smtp-cst-id-right-conc3-rep-elem))
    (declare (ignorable __function__))
    (tree-fix (nth 0 (smtp-cst-id-right-conc3-rep cst)))))

Theorem: treep-of-smtp-cst-id-right-conc3-rep-elem

(defthm treep-of-smtp-cst-id-right-conc3-rep-elem
  (b* ((cst1 (smtp-cst-id-right-conc3-rep-elem cst)))
    (treep cst1))
  :rule-classes :rewrite)

Theorem: smtp-cst-id-right-conc3-rep-elem-match

(defthm smtp-cst-id-right-conc3-rep-elem-match
  (implies (and (smtp-cst-matchp cst "id-right")
                (equal (smtp-cst-id-right-conc? cst) 3))
           (b* ((cst1 (smtp-cst-id-right-conc3-rep-elem cst)))
             (smtp-cst-matchp cst1 "obs-id-right")))
  :rule-classes :rewrite)

Theorem: smtp-cst-id-right-conc3-rep-elem-of-tree-fix-cst

(defthm smtp-cst-id-right-conc3-rep-elem-of-tree-fix-cst
  (equal (smtp-cst-id-right-conc3-rep-elem (tree-fix cst))
         (smtp-cst-id-right-conc3-rep-elem cst)))

Theorem: smtp-cst-id-right-conc3-rep-elem-tree-equiv-congruence-on-cst

(defthm
      smtp-cst-id-right-conc3-rep-elem-tree-equiv-congruence-on-cst
  (implies (tree-equiv cst cst-equiv)
           (equal (smtp-cst-id-right-conc3-rep-elem cst)
                  (smtp-cst-id-right-conc3-rep-elem cst-equiv)))
  :rule-classes :congruence)

Function: smtp-cst-obs-ctext-conc-rep-elem

(defun smtp-cst-obs-ctext-conc-rep-elem (cst)
  (declare (xargs :guard (treep cst)))
  (declare (xargs :guard (smtp-cst-matchp cst "obs-ctext")))
  (let ((__function__ 'smtp-cst-obs-ctext-conc-rep-elem))
    (declare (ignorable __function__))
    (tree-fix (nth 0 (smtp-cst-obs-ctext-conc-rep cst)))))

Theorem: treep-of-smtp-cst-obs-ctext-conc-rep-elem

(defthm treep-of-smtp-cst-obs-ctext-conc-rep-elem
  (b* ((cst1 (smtp-cst-obs-ctext-conc-rep-elem cst)))
    (treep cst1))
  :rule-classes :rewrite)

Theorem: smtp-cst-obs-ctext-conc-rep-elem-match

(defthm smtp-cst-obs-ctext-conc-rep-elem-match
  (implies (smtp-cst-matchp cst "obs-ctext")
           (b* ((cst1 (smtp-cst-obs-ctext-conc-rep-elem cst)))
             (smtp-cst-matchp cst1 "obs-no-ws-ctl")))
  :rule-classes :rewrite)

Theorem: smtp-cst-obs-ctext-conc-rep-elem-of-tree-fix-cst

(defthm smtp-cst-obs-ctext-conc-rep-elem-of-tree-fix-cst
  (equal (smtp-cst-obs-ctext-conc-rep-elem (tree-fix cst))
         (smtp-cst-obs-ctext-conc-rep-elem cst)))

Theorem: smtp-cst-obs-ctext-conc-rep-elem-tree-equiv-congruence-on-cst

(defthm
      smtp-cst-obs-ctext-conc-rep-elem-tree-equiv-congruence-on-cst
  (implies (tree-equiv cst cst-equiv)
           (equal (smtp-cst-obs-ctext-conc-rep-elem cst)
                  (smtp-cst-obs-ctext-conc-rep-elem cst-equiv)))
  :rule-classes :congruence)

Function: smtp-cst-obs-dtext-conc1-rep-elem

(defun smtp-cst-obs-dtext-conc1-rep-elem (cst)
  (declare (xargs :guard (treep cst)))
  (declare (xargs :guard (and (smtp-cst-matchp cst "obs-dtext")
                              (equal (smtp-cst-obs-dtext-conc? cst)
                                     1))))
  (let ((__function__ 'smtp-cst-obs-dtext-conc1-rep-elem))
    (declare (ignorable __function__))
    (tree-fix (nth 0 (smtp-cst-obs-dtext-conc1-rep cst)))))

Theorem: treep-of-smtp-cst-obs-dtext-conc1-rep-elem

(defthm treep-of-smtp-cst-obs-dtext-conc1-rep-elem
  (b* ((cst1 (smtp-cst-obs-dtext-conc1-rep-elem cst)))
    (treep cst1))
  :rule-classes :rewrite)

Theorem: smtp-cst-obs-dtext-conc1-rep-elem-match

(defthm smtp-cst-obs-dtext-conc1-rep-elem-match
  (implies (and (smtp-cst-matchp cst "obs-dtext")
                (equal (smtp-cst-obs-dtext-conc? cst)
                       1))
           (b* ((cst1 (smtp-cst-obs-dtext-conc1-rep-elem cst)))
             (smtp-cst-matchp cst1 "obs-no-ws-ctl")))
  :rule-classes :rewrite)

Theorem: smtp-cst-obs-dtext-conc1-rep-elem-of-tree-fix-cst

(defthm smtp-cst-obs-dtext-conc1-rep-elem-of-tree-fix-cst
  (equal (smtp-cst-obs-dtext-conc1-rep-elem (tree-fix cst))
         (smtp-cst-obs-dtext-conc1-rep-elem cst)))

Theorem: smtp-cst-obs-dtext-conc1-rep-elem-tree-equiv-congruence-on-cst

(defthm
     smtp-cst-obs-dtext-conc1-rep-elem-tree-equiv-congruence-on-cst
  (implies (tree-equiv cst cst-equiv)
           (equal (smtp-cst-obs-dtext-conc1-rep-elem cst)
                  (smtp-cst-obs-dtext-conc1-rep-elem cst-equiv)))
  :rule-classes :congruence)

Function: smtp-cst-obs-dtext-conc2-rep-elem

(defun smtp-cst-obs-dtext-conc2-rep-elem (cst)
  (declare (xargs :guard (treep cst)))
  (declare (xargs :guard (and (smtp-cst-matchp cst "obs-dtext")
                              (equal (smtp-cst-obs-dtext-conc? cst)
                                     2))))
  (let ((__function__ 'smtp-cst-obs-dtext-conc2-rep-elem))
    (declare (ignorable __function__))
    (tree-fix (nth 0 (smtp-cst-obs-dtext-conc2-rep cst)))))

Theorem: treep-of-smtp-cst-obs-dtext-conc2-rep-elem

(defthm treep-of-smtp-cst-obs-dtext-conc2-rep-elem
  (b* ((cst1 (smtp-cst-obs-dtext-conc2-rep-elem cst)))
    (treep cst1))
  :rule-classes :rewrite)

Theorem: smtp-cst-obs-dtext-conc2-rep-elem-match

(defthm smtp-cst-obs-dtext-conc2-rep-elem-match
  (implies (and (smtp-cst-matchp cst "obs-dtext")
                (equal (smtp-cst-obs-dtext-conc? cst)
                       2))
           (b* ((cst1 (smtp-cst-obs-dtext-conc2-rep-elem cst)))
             (smtp-cst-matchp cst1 "quoted-pair")))
  :rule-classes :rewrite)

Theorem: smtp-cst-obs-dtext-conc2-rep-elem-of-tree-fix-cst

(defthm smtp-cst-obs-dtext-conc2-rep-elem-of-tree-fix-cst
  (equal (smtp-cst-obs-dtext-conc2-rep-elem (tree-fix cst))
         (smtp-cst-obs-dtext-conc2-rep-elem cst)))

Theorem: smtp-cst-obs-dtext-conc2-rep-elem-tree-equiv-congruence-on-cst

(defthm
     smtp-cst-obs-dtext-conc2-rep-elem-tree-equiv-congruence-on-cst
  (implies (tree-equiv cst cst-equiv)
           (equal (smtp-cst-obs-dtext-conc2-rep-elem cst)
                  (smtp-cst-obs-dtext-conc2-rep-elem cst-equiv)))
  :rule-classes :congruence)

Function: smtp-cst-obs-id-left-conc-rep-elem

(defun smtp-cst-obs-id-left-conc-rep-elem (cst)
  (declare (xargs :guard (treep cst)))
  (declare (xargs :guard (smtp-cst-matchp cst "obs-id-left")))
  (let ((__function__ 'smtp-cst-obs-id-left-conc-rep-elem))
    (declare (ignorable __function__))
    (tree-fix (nth 0
                   (smtp-cst-obs-id-left-conc-rep cst)))))

Theorem: treep-of-smtp-cst-obs-id-left-conc-rep-elem

(defthm treep-of-smtp-cst-obs-id-left-conc-rep-elem
  (b* ((cst1 (smtp-cst-obs-id-left-conc-rep-elem cst)))
    (treep cst1))
  :rule-classes :rewrite)

Theorem: smtp-cst-obs-id-left-conc-rep-elem-match

(defthm smtp-cst-obs-id-left-conc-rep-elem-match
  (implies (smtp-cst-matchp cst "obs-id-left")
           (b* ((cst1 (smtp-cst-obs-id-left-conc-rep-elem cst)))
             (smtp-cst-matchp cst1 "imf-local-part")))
  :rule-classes :rewrite)

Theorem: smtp-cst-obs-id-left-conc-rep-elem-of-tree-fix-cst

(defthm smtp-cst-obs-id-left-conc-rep-elem-of-tree-fix-cst
  (equal (smtp-cst-obs-id-left-conc-rep-elem (tree-fix cst))
         (smtp-cst-obs-id-left-conc-rep-elem cst)))

Theorem: smtp-cst-obs-id-left-conc-rep-elem-tree-equiv-congruence-on-cst

(defthm
    smtp-cst-obs-id-left-conc-rep-elem-tree-equiv-congruence-on-cst
  (implies (tree-equiv cst cst-equiv)
           (equal (smtp-cst-obs-id-left-conc-rep-elem cst)
                  (smtp-cst-obs-id-left-conc-rep-elem cst-equiv)))
  :rule-classes :congruence)

Function: smtp-cst-imf-local-part-conc1-rep-elem

(defun smtp-cst-imf-local-part-conc1-rep-elem (cst)
  (declare (xargs :guard (treep cst)))
  (declare
       (xargs :guard (and (smtp-cst-matchp cst "imf-local-part")
                          (equal (smtp-cst-imf-local-part-conc? cst)
                                 1))))
  (let ((__function__ 'smtp-cst-imf-local-part-conc1-rep-elem))
    (declare (ignorable __function__))
    (tree-fix (nth 0
                   (smtp-cst-imf-local-part-conc1-rep cst)))))

Theorem: treep-of-smtp-cst-imf-local-part-conc1-rep-elem

(defthm treep-of-smtp-cst-imf-local-part-conc1-rep-elem
  (b* ((cst1 (smtp-cst-imf-local-part-conc1-rep-elem cst)))
    (treep cst1))
  :rule-classes :rewrite)

Theorem: smtp-cst-imf-local-part-conc1-rep-elem-match

(defthm smtp-cst-imf-local-part-conc1-rep-elem-match
  (implies (and (smtp-cst-matchp cst "imf-local-part")
                (equal (smtp-cst-imf-local-part-conc? cst)
                       1))
           (b* ((cst1 (smtp-cst-imf-local-part-conc1-rep-elem cst)))
             (smtp-cst-matchp cst1 "dot-atom")))
  :rule-classes :rewrite)

Theorem: smtp-cst-imf-local-part-conc1-rep-elem-of-tree-fix-cst

(defthm smtp-cst-imf-local-part-conc1-rep-elem-of-tree-fix-cst
  (equal (smtp-cst-imf-local-part-conc1-rep-elem (tree-fix cst))
         (smtp-cst-imf-local-part-conc1-rep-elem cst)))

Theorem: smtp-cst-imf-local-part-conc1-rep-elem-tree-equiv-congruence-on-cst

(defthm
 smtp-cst-imf-local-part-conc1-rep-elem-tree-equiv-congruence-on-cst
 (implies
      (tree-equiv cst cst-equiv)
      (equal (smtp-cst-imf-local-part-conc1-rep-elem cst)
             (smtp-cst-imf-local-part-conc1-rep-elem cst-equiv)))
 :rule-classes :congruence)

Function: smtp-cst-imf-local-part-conc2-rep-elem

(defun smtp-cst-imf-local-part-conc2-rep-elem (cst)
  (declare (xargs :guard (treep cst)))
  (declare
       (xargs :guard (and (smtp-cst-matchp cst "imf-local-part")
                          (equal (smtp-cst-imf-local-part-conc? cst)
                                 2))))
  (let ((__function__ 'smtp-cst-imf-local-part-conc2-rep-elem))
    (declare (ignorable __function__))
    (tree-fix (nth 0
                   (smtp-cst-imf-local-part-conc2-rep cst)))))

Theorem: treep-of-smtp-cst-imf-local-part-conc2-rep-elem

(defthm treep-of-smtp-cst-imf-local-part-conc2-rep-elem
  (b* ((cst1 (smtp-cst-imf-local-part-conc2-rep-elem cst)))
    (treep cst1))
  :rule-classes :rewrite)

Theorem: smtp-cst-imf-local-part-conc2-rep-elem-match

(defthm smtp-cst-imf-local-part-conc2-rep-elem-match
  (implies (and (smtp-cst-matchp cst "imf-local-part")
                (equal (smtp-cst-imf-local-part-conc? cst)
                       2))
           (b* ((cst1 (smtp-cst-imf-local-part-conc2-rep-elem cst)))
             (smtp-cst-matchp cst1 "imf-quoted-string")))
  :rule-classes :rewrite)

Theorem: smtp-cst-imf-local-part-conc2-rep-elem-of-tree-fix-cst

(defthm smtp-cst-imf-local-part-conc2-rep-elem-of-tree-fix-cst
  (equal (smtp-cst-imf-local-part-conc2-rep-elem (tree-fix cst))
         (smtp-cst-imf-local-part-conc2-rep-elem cst)))

Theorem: smtp-cst-imf-local-part-conc2-rep-elem-tree-equiv-congruence-on-cst

(defthm
 smtp-cst-imf-local-part-conc2-rep-elem-tree-equiv-congruence-on-cst
 (implies
      (tree-equiv cst cst-equiv)
      (equal (smtp-cst-imf-local-part-conc2-rep-elem cst)
             (smtp-cst-imf-local-part-conc2-rep-elem cst-equiv)))
 :rule-classes :congruence)

Function: smtp-cst-imf-local-part-conc3-rep-elem

(defun smtp-cst-imf-local-part-conc3-rep-elem (cst)
  (declare (xargs :guard (treep cst)))
  (declare
       (xargs :guard (and (smtp-cst-matchp cst "imf-local-part")
                          (equal (smtp-cst-imf-local-part-conc? cst)
                                 3))))
  (let ((__function__ 'smtp-cst-imf-local-part-conc3-rep-elem))
    (declare (ignorable __function__))
    (tree-fix (nth 0
                   (smtp-cst-imf-local-part-conc3-rep cst)))))

Theorem: treep-of-smtp-cst-imf-local-part-conc3-rep-elem

(defthm treep-of-smtp-cst-imf-local-part-conc3-rep-elem
  (b* ((cst1 (smtp-cst-imf-local-part-conc3-rep-elem cst)))
    (treep cst1))
  :rule-classes :rewrite)

Theorem: smtp-cst-imf-local-part-conc3-rep-elem-match

(defthm smtp-cst-imf-local-part-conc3-rep-elem-match
  (implies (and (smtp-cst-matchp cst "imf-local-part")
                (equal (smtp-cst-imf-local-part-conc? cst)
                       3))
           (b* ((cst1 (smtp-cst-imf-local-part-conc3-rep-elem cst)))
             (smtp-cst-matchp cst1 "obs-local-part")))
  :rule-classes :rewrite)

Theorem: smtp-cst-imf-local-part-conc3-rep-elem-of-tree-fix-cst

(defthm smtp-cst-imf-local-part-conc3-rep-elem-of-tree-fix-cst
  (equal (smtp-cst-imf-local-part-conc3-rep-elem (tree-fix cst))
         (smtp-cst-imf-local-part-conc3-rep-elem cst)))

Theorem: smtp-cst-imf-local-part-conc3-rep-elem-tree-equiv-congruence-on-cst

(defthm
 smtp-cst-imf-local-part-conc3-rep-elem-tree-equiv-congruence-on-cst
 (implies
      (tree-equiv cst cst-equiv)
      (equal (smtp-cst-imf-local-part-conc3-rep-elem cst)
             (smtp-cst-imf-local-part-conc3-rep-elem cst-equiv)))
 :rule-classes :congruence)

Function: smtp-cst-obs-id-right-conc-rep-elem

(defun smtp-cst-obs-id-right-conc-rep-elem (cst)
  (declare (xargs :guard (treep cst)))
  (declare (xargs :guard (smtp-cst-matchp cst "obs-id-right")))
  (let ((__function__ 'smtp-cst-obs-id-right-conc-rep-elem))
    (declare (ignorable __function__))
    (tree-fix (nth 0
                   (smtp-cst-obs-id-right-conc-rep cst)))))

Theorem: treep-of-smtp-cst-obs-id-right-conc-rep-elem

(defthm treep-of-smtp-cst-obs-id-right-conc-rep-elem
  (b* ((cst1 (smtp-cst-obs-id-right-conc-rep-elem cst)))
    (treep cst1))
  :rule-classes :rewrite)

Theorem: smtp-cst-obs-id-right-conc-rep-elem-match

(defthm smtp-cst-obs-id-right-conc-rep-elem-match
  (implies (smtp-cst-matchp cst "obs-id-right")
           (b* ((cst1 (smtp-cst-obs-id-right-conc-rep-elem cst)))
             (smtp-cst-matchp cst1 "imf-domain")))
  :rule-classes :rewrite)

Theorem: smtp-cst-obs-id-right-conc-rep-elem-of-tree-fix-cst

(defthm smtp-cst-obs-id-right-conc-rep-elem-of-tree-fix-cst
  (equal (smtp-cst-obs-id-right-conc-rep-elem (tree-fix cst))
         (smtp-cst-obs-id-right-conc-rep-elem cst)))

Theorem: smtp-cst-obs-id-right-conc-rep-elem-tree-equiv-congruence-on-cst

(defthm
   smtp-cst-obs-id-right-conc-rep-elem-tree-equiv-congruence-on-cst
  (implies (tree-equiv cst cst-equiv)
           (equal (smtp-cst-obs-id-right-conc-rep-elem cst)
                  (smtp-cst-obs-id-right-conc-rep-elem cst-equiv)))
  :rule-classes :congruence)

Function: smtp-cst-imf-domain-conc1-rep-elem

(defun smtp-cst-imf-domain-conc1-rep-elem (cst)
  (declare (xargs :guard (treep cst)))
  (declare (xargs :guard (and (smtp-cst-matchp cst "imf-domain")
                              (equal (smtp-cst-imf-domain-conc? cst)
                                     1))))
  (let ((__function__ 'smtp-cst-imf-domain-conc1-rep-elem))
    (declare (ignorable __function__))
    (tree-fix (nth 0
                   (smtp-cst-imf-domain-conc1-rep cst)))))

Theorem: treep-of-smtp-cst-imf-domain-conc1-rep-elem

(defthm treep-of-smtp-cst-imf-domain-conc1-rep-elem
  (b* ((cst1 (smtp-cst-imf-domain-conc1-rep-elem cst)))
    (treep cst1))
  :rule-classes :rewrite)

Theorem: smtp-cst-imf-domain-conc1-rep-elem-match

(defthm smtp-cst-imf-domain-conc1-rep-elem-match
  (implies (and (smtp-cst-matchp cst "imf-domain")
                (equal (smtp-cst-imf-domain-conc? cst)
                       1))
           (b* ((cst1 (smtp-cst-imf-domain-conc1-rep-elem cst)))
             (smtp-cst-matchp cst1 "dot-atom")))
  :rule-classes :rewrite)

Theorem: smtp-cst-imf-domain-conc1-rep-elem-of-tree-fix-cst

(defthm smtp-cst-imf-domain-conc1-rep-elem-of-tree-fix-cst
  (equal (smtp-cst-imf-domain-conc1-rep-elem (tree-fix cst))
         (smtp-cst-imf-domain-conc1-rep-elem cst)))

Theorem: smtp-cst-imf-domain-conc1-rep-elem-tree-equiv-congruence-on-cst

(defthm
    smtp-cst-imf-domain-conc1-rep-elem-tree-equiv-congruence-on-cst
  (implies (tree-equiv cst cst-equiv)
           (equal (smtp-cst-imf-domain-conc1-rep-elem cst)
                  (smtp-cst-imf-domain-conc1-rep-elem cst-equiv)))
  :rule-classes :congruence)

Function: smtp-cst-imf-domain-conc2-rep-elem

(defun smtp-cst-imf-domain-conc2-rep-elem (cst)
  (declare (xargs :guard (treep cst)))
  (declare (xargs :guard (and (smtp-cst-matchp cst "imf-domain")
                              (equal (smtp-cst-imf-domain-conc? cst)
                                     2))))
  (let ((__function__ 'smtp-cst-imf-domain-conc2-rep-elem))
    (declare (ignorable __function__))
    (tree-fix (nth 0
                   (smtp-cst-imf-domain-conc2-rep cst)))))

Theorem: treep-of-smtp-cst-imf-domain-conc2-rep-elem

(defthm treep-of-smtp-cst-imf-domain-conc2-rep-elem
  (b* ((cst1 (smtp-cst-imf-domain-conc2-rep-elem cst)))
    (treep cst1))
  :rule-classes :rewrite)

Theorem: smtp-cst-imf-domain-conc2-rep-elem-match

(defthm smtp-cst-imf-domain-conc2-rep-elem-match
  (implies (and (smtp-cst-matchp cst "imf-domain")
                (equal (smtp-cst-imf-domain-conc? cst)
                       2))
           (b* ((cst1 (smtp-cst-imf-domain-conc2-rep-elem cst)))
             (smtp-cst-matchp cst1 "domain-literal")))
  :rule-classes :rewrite)

Theorem: smtp-cst-imf-domain-conc2-rep-elem-of-tree-fix-cst

(defthm smtp-cst-imf-domain-conc2-rep-elem-of-tree-fix-cst
  (equal (smtp-cst-imf-domain-conc2-rep-elem (tree-fix cst))
         (smtp-cst-imf-domain-conc2-rep-elem cst)))

Theorem: smtp-cst-imf-domain-conc2-rep-elem-tree-equiv-congruence-on-cst

(defthm
    smtp-cst-imf-domain-conc2-rep-elem-tree-equiv-congruence-on-cst
  (implies (tree-equiv cst cst-equiv)
           (equal (smtp-cst-imf-domain-conc2-rep-elem cst)
                  (smtp-cst-imf-domain-conc2-rep-elem cst-equiv)))
  :rule-classes :congruence)

Function: smtp-cst-imf-domain-conc3-rep-elem

(defun smtp-cst-imf-domain-conc3-rep-elem (cst)
  (declare (xargs :guard (treep cst)))
  (declare (xargs :guard (and (smtp-cst-matchp cst "imf-domain")
                              (equal (smtp-cst-imf-domain-conc? cst)
                                     3))))
  (let ((__function__ 'smtp-cst-imf-domain-conc3-rep-elem))
    (declare (ignorable __function__))
    (tree-fix (nth 0
                   (smtp-cst-imf-domain-conc3-rep cst)))))

Theorem: treep-of-smtp-cst-imf-domain-conc3-rep-elem

(defthm treep-of-smtp-cst-imf-domain-conc3-rep-elem
  (b* ((cst1 (smtp-cst-imf-domain-conc3-rep-elem cst)))
    (treep cst1))
  :rule-classes :rewrite)

Theorem: smtp-cst-imf-domain-conc3-rep-elem-match

(defthm smtp-cst-imf-domain-conc3-rep-elem-match
  (implies (and (smtp-cst-matchp cst "imf-domain")
                (equal (smtp-cst-imf-domain-conc? cst)
                       3))
           (b* ((cst1 (smtp-cst-imf-domain-conc3-rep-elem cst)))
             (smtp-cst-matchp cst1 "obs-domain")))
  :rule-classes :rewrite)

Theorem: smtp-cst-imf-domain-conc3-rep-elem-of-tree-fix-cst

(defthm smtp-cst-imf-domain-conc3-rep-elem-of-tree-fix-cst
  (equal (smtp-cst-imf-domain-conc3-rep-elem (tree-fix cst))
         (smtp-cst-imf-domain-conc3-rep-elem cst)))

Theorem: smtp-cst-imf-domain-conc3-rep-elem-tree-equiv-congruence-on-cst

(defthm
    smtp-cst-imf-domain-conc3-rep-elem-tree-equiv-congruence-on-cst
  (implies (tree-equiv cst cst-equiv)
           (equal (smtp-cst-imf-domain-conc3-rep-elem cst)
                  (smtp-cst-imf-domain-conc3-rep-elem cst-equiv)))
  :rule-classes :congruence)

Function: smtp-cst-qcontent-conc1-rep-elem

(defun smtp-cst-qcontent-conc1-rep-elem (cst)
  (declare (xargs :guard (treep cst)))
  (declare (xargs :guard (and (smtp-cst-matchp cst "qcontent")
                              (equal (smtp-cst-qcontent-conc? cst)
                                     1))))
  (let ((__function__ 'smtp-cst-qcontent-conc1-rep-elem))
    (declare (ignorable __function__))
    (tree-fix (nth 0 (smtp-cst-qcontent-conc1-rep cst)))))

Theorem: treep-of-smtp-cst-qcontent-conc1-rep-elem

(defthm treep-of-smtp-cst-qcontent-conc1-rep-elem
  (b* ((cst1 (smtp-cst-qcontent-conc1-rep-elem cst)))
    (treep cst1))
  :rule-classes :rewrite)

Theorem: smtp-cst-qcontent-conc1-rep-elem-match

(defthm smtp-cst-qcontent-conc1-rep-elem-match
  (implies (and (smtp-cst-matchp cst "qcontent")
                (equal (smtp-cst-qcontent-conc? cst) 1))
           (b* ((cst1 (smtp-cst-qcontent-conc1-rep-elem cst)))
             (smtp-cst-matchp cst1 "qtext")))
  :rule-classes :rewrite)

Theorem: smtp-cst-qcontent-conc1-rep-elem-of-tree-fix-cst

(defthm smtp-cst-qcontent-conc1-rep-elem-of-tree-fix-cst
  (equal (smtp-cst-qcontent-conc1-rep-elem (tree-fix cst))
         (smtp-cst-qcontent-conc1-rep-elem cst)))

Theorem: smtp-cst-qcontent-conc1-rep-elem-tree-equiv-congruence-on-cst

(defthm
      smtp-cst-qcontent-conc1-rep-elem-tree-equiv-congruence-on-cst
  (implies (tree-equiv cst cst-equiv)
           (equal (smtp-cst-qcontent-conc1-rep-elem cst)
                  (smtp-cst-qcontent-conc1-rep-elem cst-equiv)))
  :rule-classes :congruence)

Function: smtp-cst-qcontent-conc2-rep-elem

(defun smtp-cst-qcontent-conc2-rep-elem (cst)
  (declare (xargs :guard (treep cst)))
  (declare (xargs :guard (and (smtp-cst-matchp cst "qcontent")
                              (equal (smtp-cst-qcontent-conc? cst)
                                     2))))
  (let ((__function__ 'smtp-cst-qcontent-conc2-rep-elem))
    (declare (ignorable __function__))
    (tree-fix (nth 0 (smtp-cst-qcontent-conc2-rep cst)))))

Theorem: treep-of-smtp-cst-qcontent-conc2-rep-elem

(defthm treep-of-smtp-cst-qcontent-conc2-rep-elem
  (b* ((cst1 (smtp-cst-qcontent-conc2-rep-elem cst)))
    (treep cst1))
  :rule-classes :rewrite)

Theorem: smtp-cst-qcontent-conc2-rep-elem-match

(defthm smtp-cst-qcontent-conc2-rep-elem-match
  (implies (and (smtp-cst-matchp cst "qcontent")
                (equal (smtp-cst-qcontent-conc? cst) 2))
           (b* ((cst1 (smtp-cst-qcontent-conc2-rep-elem cst)))
             (smtp-cst-matchp cst1 "quoted-pair")))
  :rule-classes :rewrite)

Theorem: smtp-cst-qcontent-conc2-rep-elem-of-tree-fix-cst

(defthm smtp-cst-qcontent-conc2-rep-elem-of-tree-fix-cst
  (equal (smtp-cst-qcontent-conc2-rep-elem (tree-fix cst))
         (smtp-cst-qcontent-conc2-rep-elem cst)))

Theorem: smtp-cst-qcontent-conc2-rep-elem-tree-equiv-congruence-on-cst

(defthm
      smtp-cst-qcontent-conc2-rep-elem-tree-equiv-congruence-on-cst
  (implies (tree-equiv cst cst-equiv)
           (equal (smtp-cst-qcontent-conc2-rep-elem cst)
                  (smtp-cst-qcontent-conc2-rep-elem cst-equiv)))
  :rule-classes :congruence)

Function: smtp-cst-obs-qtext-conc-rep-elem

(defun smtp-cst-obs-qtext-conc-rep-elem (cst)
  (declare (xargs :guard (treep cst)))
  (declare (xargs :guard (smtp-cst-matchp cst "obs-qtext")))
  (let ((__function__ 'smtp-cst-obs-qtext-conc-rep-elem))
    (declare (ignorable __function__))
    (tree-fix (nth 0 (smtp-cst-obs-qtext-conc-rep cst)))))

Theorem: treep-of-smtp-cst-obs-qtext-conc-rep-elem

(defthm treep-of-smtp-cst-obs-qtext-conc-rep-elem
  (b* ((cst1 (smtp-cst-obs-qtext-conc-rep-elem cst)))
    (treep cst1))
  :rule-classes :rewrite)

Theorem: smtp-cst-obs-qtext-conc-rep-elem-match

(defthm smtp-cst-obs-qtext-conc-rep-elem-match
  (implies (smtp-cst-matchp cst "obs-qtext")
           (b* ((cst1 (smtp-cst-obs-qtext-conc-rep-elem cst)))
             (smtp-cst-matchp cst1 "obs-no-ws-ctl")))
  :rule-classes :rewrite)

Theorem: smtp-cst-obs-qtext-conc-rep-elem-of-tree-fix-cst

(defthm smtp-cst-obs-qtext-conc-rep-elem-of-tree-fix-cst
  (equal (smtp-cst-obs-qtext-conc-rep-elem (tree-fix cst))
         (smtp-cst-obs-qtext-conc-rep-elem cst)))

Theorem: smtp-cst-obs-qtext-conc-rep-elem-tree-equiv-congruence-on-cst

(defthm
      smtp-cst-obs-qtext-conc-rep-elem-tree-equiv-congruence-on-cst
  (implies (tree-equiv cst cst-equiv)
           (equal (smtp-cst-obs-qtext-conc-rep-elem cst)
                  (smtp-cst-obs-qtext-conc-rep-elem cst-equiv)))
  :rule-classes :congruence)

Function: smtp-cst-word-conc1-rep-elem

(defun smtp-cst-word-conc1-rep-elem (cst)
  (declare (xargs :guard (treep cst)))
  (declare (xargs :guard (and (smtp-cst-matchp cst "word")
                              (equal (smtp-cst-word-conc? cst) 1))))
  (let ((__function__ 'smtp-cst-word-conc1-rep-elem))
    (declare (ignorable __function__))
    (tree-fix (nth 0 (smtp-cst-word-conc1-rep cst)))))

Theorem: treep-of-smtp-cst-word-conc1-rep-elem

(defthm treep-of-smtp-cst-word-conc1-rep-elem
  (b* ((cst1 (smtp-cst-word-conc1-rep-elem cst)))
    (treep cst1))
  :rule-classes :rewrite)

Theorem: smtp-cst-word-conc1-rep-elem-match

(defthm smtp-cst-word-conc1-rep-elem-match
  (implies (and (smtp-cst-matchp cst "word")
                (equal (smtp-cst-word-conc? cst) 1))
           (b* ((cst1 (smtp-cst-word-conc1-rep-elem cst)))
             (smtp-cst-matchp cst1 "imf-atom")))
  :rule-classes :rewrite)

Theorem: smtp-cst-word-conc1-rep-elem-of-tree-fix-cst

(defthm smtp-cst-word-conc1-rep-elem-of-tree-fix-cst
  (equal (smtp-cst-word-conc1-rep-elem (tree-fix cst))
         (smtp-cst-word-conc1-rep-elem cst)))

Theorem: smtp-cst-word-conc1-rep-elem-tree-equiv-congruence-on-cst

(defthm smtp-cst-word-conc1-rep-elem-tree-equiv-congruence-on-cst
  (implies (tree-equiv cst cst-equiv)
           (equal (smtp-cst-word-conc1-rep-elem cst)
                  (smtp-cst-word-conc1-rep-elem cst-equiv)))
  :rule-classes :congruence)

Function: smtp-cst-word-conc2-rep-elem

(defun smtp-cst-word-conc2-rep-elem (cst)
  (declare (xargs :guard (treep cst)))
  (declare (xargs :guard (and (smtp-cst-matchp cst "word")
                              (equal (smtp-cst-word-conc? cst) 2))))
  (let ((__function__ 'smtp-cst-word-conc2-rep-elem))
    (declare (ignorable __function__))
    (tree-fix (nth 0 (smtp-cst-word-conc2-rep cst)))))

Theorem: treep-of-smtp-cst-word-conc2-rep-elem

(defthm treep-of-smtp-cst-word-conc2-rep-elem
  (b* ((cst1 (smtp-cst-word-conc2-rep-elem cst)))
    (treep cst1))
  :rule-classes :rewrite)

Theorem: smtp-cst-word-conc2-rep-elem-match

(defthm smtp-cst-word-conc2-rep-elem-match
  (implies (and (smtp-cst-matchp cst "word")
                (equal (smtp-cst-word-conc? cst) 2))
           (b* ((cst1 (smtp-cst-word-conc2-rep-elem cst)))
             (smtp-cst-matchp cst1 "imf-quoted-string")))
  :rule-classes :rewrite)

Theorem: smtp-cst-word-conc2-rep-elem-of-tree-fix-cst

(defthm smtp-cst-word-conc2-rep-elem-of-tree-fix-cst
  (equal (smtp-cst-word-conc2-rep-elem (tree-fix cst))
         (smtp-cst-word-conc2-rep-elem cst)))

Theorem: smtp-cst-word-conc2-rep-elem-tree-equiv-congruence-on-cst

(defthm smtp-cst-word-conc2-rep-elem-tree-equiv-congruence-on-cst
  (implies (tree-equiv cst cst-equiv)
           (equal (smtp-cst-word-conc2-rep-elem cst)
                  (smtp-cst-word-conc2-rep-elem cst-equiv)))
  :rule-classes :congruence)

Function: smtp-cst-cr-conc-rep-elem

(defun smtp-cst-cr-conc-rep-elem (cst)
  (declare (xargs :guard (treep cst)))
  (declare (xargs :guard (smtp-cst-matchp cst "cr")))
  (let ((__function__ 'smtp-cst-cr-conc-rep-elem))
    (declare (ignorable __function__))
    (tree-fix (nth 0 (smtp-cst-cr-conc-rep cst)))))

Theorem: treep-of-smtp-cst-cr-conc-rep-elem

(defthm treep-of-smtp-cst-cr-conc-rep-elem
  (b* ((cst1 (smtp-cst-cr-conc-rep-elem cst)))
    (treep cst1))
  :rule-classes :rewrite)

Theorem: smtp-cst-cr-conc-rep-elem-match

(defthm smtp-cst-cr-conc-rep-elem-match
  (implies (smtp-cst-matchp cst "cr")
           (b* ((cst1 (smtp-cst-cr-conc-rep-elem cst)))
             (smtp-cst-matchp cst1 "%xD")))
  :rule-classes :rewrite)

Theorem: smtp-cst-cr-conc-rep-elem-of-tree-fix-cst

(defthm smtp-cst-cr-conc-rep-elem-of-tree-fix-cst
  (equal (smtp-cst-cr-conc-rep-elem (tree-fix cst))
         (smtp-cst-cr-conc-rep-elem cst)))

Theorem: smtp-cst-cr-conc-rep-elem-tree-equiv-congruence-on-cst

(defthm smtp-cst-cr-conc-rep-elem-tree-equiv-congruence-on-cst
  (implies (tree-equiv cst cst-equiv)
           (equal (smtp-cst-cr-conc-rep-elem cst)
                  (smtp-cst-cr-conc-rep-elem cst-equiv)))
  :rule-classes :congruence)

Function: smtp-cst-digit-conc-rep-elem

(defun smtp-cst-digit-conc-rep-elem (cst)
  (declare (xargs :guard (treep cst)))
  (declare (xargs :guard (smtp-cst-matchp cst "digit")))
  (let ((__function__ 'smtp-cst-digit-conc-rep-elem))
    (declare (ignorable __function__))
    (tree-fix (nth 0 (smtp-cst-digit-conc-rep cst)))))

Theorem: treep-of-smtp-cst-digit-conc-rep-elem

(defthm treep-of-smtp-cst-digit-conc-rep-elem
  (b* ((cst1 (smtp-cst-digit-conc-rep-elem cst)))
    (treep cst1))
  :rule-classes :rewrite)

Theorem: smtp-cst-digit-conc-rep-elem-match

(defthm smtp-cst-digit-conc-rep-elem-match
  (implies (smtp-cst-matchp cst "digit")
           (b* ((cst1 (smtp-cst-digit-conc-rep-elem cst)))
             (smtp-cst-matchp cst1 "%x30-39")))
  :rule-classes :rewrite)

Theorem: smtp-cst-digit-conc-rep-elem-of-tree-fix-cst

(defthm smtp-cst-digit-conc-rep-elem-of-tree-fix-cst
  (equal (smtp-cst-digit-conc-rep-elem (tree-fix cst))
         (smtp-cst-digit-conc-rep-elem cst)))

Theorem: smtp-cst-digit-conc-rep-elem-tree-equiv-congruence-on-cst

(defthm smtp-cst-digit-conc-rep-elem-tree-equiv-congruence-on-cst
  (implies (tree-equiv cst cst-equiv)
           (equal (smtp-cst-digit-conc-rep-elem cst)
                  (smtp-cst-digit-conc-rep-elem cst-equiv)))
  :rule-classes :congruence)

Function: smtp-cst-dquote-conc-rep-elem

(defun smtp-cst-dquote-conc-rep-elem (cst)
  (declare (xargs :guard (treep cst)))
  (declare (xargs :guard (smtp-cst-matchp cst "dquote")))
  (let ((__function__ 'smtp-cst-dquote-conc-rep-elem))
    (declare (ignorable __function__))
    (tree-fix (nth 0 (smtp-cst-dquote-conc-rep cst)))))

Theorem: treep-of-smtp-cst-dquote-conc-rep-elem

(defthm treep-of-smtp-cst-dquote-conc-rep-elem
  (b* ((cst1 (smtp-cst-dquote-conc-rep-elem cst)))
    (treep cst1))
  :rule-classes :rewrite)

Theorem: smtp-cst-dquote-conc-rep-elem-match

(defthm smtp-cst-dquote-conc-rep-elem-match
  (implies (smtp-cst-matchp cst "dquote")
           (b* ((cst1 (smtp-cst-dquote-conc-rep-elem cst)))
             (smtp-cst-matchp cst1 "%x22")))
  :rule-classes :rewrite)

Theorem: smtp-cst-dquote-conc-rep-elem-of-tree-fix-cst

(defthm smtp-cst-dquote-conc-rep-elem-of-tree-fix-cst
  (equal (smtp-cst-dquote-conc-rep-elem (tree-fix cst))
         (smtp-cst-dquote-conc-rep-elem cst)))

Theorem: smtp-cst-dquote-conc-rep-elem-tree-equiv-congruence-on-cst

(defthm smtp-cst-dquote-conc-rep-elem-tree-equiv-congruence-on-cst
  (implies (tree-equiv cst cst-equiv)
           (equal (smtp-cst-dquote-conc-rep-elem cst)
                  (smtp-cst-dquote-conc-rep-elem cst-equiv)))
  :rule-classes :congruence)

Function: smtp-cst-lf-conc-rep-elem

(defun smtp-cst-lf-conc-rep-elem (cst)
  (declare (xargs :guard (treep cst)))
  (declare (xargs :guard (smtp-cst-matchp cst "lf")))
  (let ((__function__ 'smtp-cst-lf-conc-rep-elem))
    (declare (ignorable __function__))
    (tree-fix (nth 0 (smtp-cst-lf-conc-rep cst)))))

Theorem: treep-of-smtp-cst-lf-conc-rep-elem

(defthm treep-of-smtp-cst-lf-conc-rep-elem
  (b* ((cst1 (smtp-cst-lf-conc-rep-elem cst)))
    (treep cst1))
  :rule-classes :rewrite)

Theorem: smtp-cst-lf-conc-rep-elem-match

(defthm smtp-cst-lf-conc-rep-elem-match
  (implies (smtp-cst-matchp cst "lf")
           (b* ((cst1 (smtp-cst-lf-conc-rep-elem cst)))
             (smtp-cst-matchp cst1 "%xA")))
  :rule-classes :rewrite)

Theorem: smtp-cst-lf-conc-rep-elem-of-tree-fix-cst

(defthm smtp-cst-lf-conc-rep-elem-of-tree-fix-cst
  (equal (smtp-cst-lf-conc-rep-elem (tree-fix cst))
         (smtp-cst-lf-conc-rep-elem cst)))

Theorem: smtp-cst-lf-conc-rep-elem-tree-equiv-congruence-on-cst

(defthm smtp-cst-lf-conc-rep-elem-tree-equiv-congruence-on-cst
  (implies (tree-equiv cst cst-equiv)
           (equal (smtp-cst-lf-conc-rep-elem cst)
                  (smtp-cst-lf-conc-rep-elem cst-equiv)))
  :rule-classes :congruence)

Function: smtp-cst-sp-conc-rep-elem

(defun smtp-cst-sp-conc-rep-elem (cst)
  (declare (xargs :guard (treep cst)))
  (declare (xargs :guard (smtp-cst-matchp cst "sp")))
  (let ((__function__ 'smtp-cst-sp-conc-rep-elem))
    (declare (ignorable __function__))
    (tree-fix (nth 0 (smtp-cst-sp-conc-rep cst)))))

Theorem: treep-of-smtp-cst-sp-conc-rep-elem

(defthm treep-of-smtp-cst-sp-conc-rep-elem
  (b* ((cst1 (smtp-cst-sp-conc-rep-elem cst)))
    (treep cst1))
  :rule-classes :rewrite)

Theorem: smtp-cst-sp-conc-rep-elem-match

(defthm smtp-cst-sp-conc-rep-elem-match
  (implies (smtp-cst-matchp cst "sp")
           (b* ((cst1 (smtp-cst-sp-conc-rep-elem cst)))
             (smtp-cst-matchp cst1 "%x20")))
  :rule-classes :rewrite)

Theorem: smtp-cst-sp-conc-rep-elem-of-tree-fix-cst

(defthm smtp-cst-sp-conc-rep-elem-of-tree-fix-cst
  (equal (smtp-cst-sp-conc-rep-elem (tree-fix cst))
         (smtp-cst-sp-conc-rep-elem cst)))

Theorem: smtp-cst-sp-conc-rep-elem-tree-equiv-congruence-on-cst

(defthm smtp-cst-sp-conc-rep-elem-tree-equiv-congruence-on-cst
  (implies (tree-equiv cst cst-equiv)
           (equal (smtp-cst-sp-conc-rep-elem cst)
                  (smtp-cst-sp-conc-rep-elem cst-equiv)))
  :rule-classes :congruence)

Function: smtp-cst-vchar-conc-rep-elem

(defun smtp-cst-vchar-conc-rep-elem (cst)
  (declare (xargs :guard (treep cst)))
  (declare (xargs :guard (smtp-cst-matchp cst "vchar")))
  (let ((__function__ 'smtp-cst-vchar-conc-rep-elem))
    (declare (ignorable __function__))
    (tree-fix (nth 0 (smtp-cst-vchar-conc-rep cst)))))

Theorem: treep-of-smtp-cst-vchar-conc-rep-elem

(defthm treep-of-smtp-cst-vchar-conc-rep-elem
  (b* ((cst1 (smtp-cst-vchar-conc-rep-elem cst)))
    (treep cst1))
  :rule-classes :rewrite)

Theorem: smtp-cst-vchar-conc-rep-elem-match

(defthm smtp-cst-vchar-conc-rep-elem-match
  (implies (smtp-cst-matchp cst "vchar")
           (b* ((cst1 (smtp-cst-vchar-conc-rep-elem cst)))
             (smtp-cst-matchp cst1 "%x21-7E")))
  :rule-classes :rewrite)

Theorem: smtp-cst-vchar-conc-rep-elem-of-tree-fix-cst

(defthm smtp-cst-vchar-conc-rep-elem-of-tree-fix-cst
  (equal (smtp-cst-vchar-conc-rep-elem (tree-fix cst))
         (smtp-cst-vchar-conc-rep-elem cst)))

Theorem: smtp-cst-vchar-conc-rep-elem-tree-equiv-congruence-on-cst

(defthm smtp-cst-vchar-conc-rep-elem-tree-equiv-congruence-on-cst
  (implies (tree-equiv cst cst-equiv)
           (equal (smtp-cst-vchar-conc-rep-elem cst)
                  (smtp-cst-vchar-conc-rep-elem cst-equiv)))
  :rule-classes :congruence)

Function: smtp-cst-wsp-conc1-rep-elem

(defun smtp-cst-wsp-conc1-rep-elem (cst)
  (declare (xargs :guard (treep cst)))
  (declare (xargs :guard (and (smtp-cst-matchp cst "wsp")
                              (equal (smtp-cst-wsp-conc? cst) 1))))
  (let ((__function__ 'smtp-cst-wsp-conc1-rep-elem))
    (declare (ignorable __function__))
    (tree-fix (nth 0 (smtp-cst-wsp-conc1-rep cst)))))

Theorem: treep-of-smtp-cst-wsp-conc1-rep-elem

(defthm treep-of-smtp-cst-wsp-conc1-rep-elem
  (b* ((cst1 (smtp-cst-wsp-conc1-rep-elem cst)))
    (treep cst1))
  :rule-classes :rewrite)

Theorem: smtp-cst-wsp-conc1-rep-elem-match

(defthm smtp-cst-wsp-conc1-rep-elem-match
  (implies (and (smtp-cst-matchp cst "wsp")
                (equal (smtp-cst-wsp-conc? cst) 1))
           (b* ((cst1 (smtp-cst-wsp-conc1-rep-elem cst)))
             (smtp-cst-matchp cst1 "sp")))
  :rule-classes :rewrite)

Theorem: smtp-cst-wsp-conc1-rep-elem-of-tree-fix-cst

(defthm smtp-cst-wsp-conc1-rep-elem-of-tree-fix-cst
  (equal (smtp-cst-wsp-conc1-rep-elem (tree-fix cst))
         (smtp-cst-wsp-conc1-rep-elem cst)))

Theorem: smtp-cst-wsp-conc1-rep-elem-tree-equiv-congruence-on-cst

(defthm smtp-cst-wsp-conc1-rep-elem-tree-equiv-congruence-on-cst
  (implies (tree-equiv cst cst-equiv)
           (equal (smtp-cst-wsp-conc1-rep-elem cst)
                  (smtp-cst-wsp-conc1-rep-elem cst-equiv)))
  :rule-classes :congruence)

Function: smtp-cst-wsp-conc2-rep-elem

(defun smtp-cst-wsp-conc2-rep-elem (cst)
  (declare (xargs :guard (treep cst)))
  (declare (xargs :guard (and (smtp-cst-matchp cst "wsp")
                              (equal (smtp-cst-wsp-conc? cst) 2))))
  (let ((__function__ 'smtp-cst-wsp-conc2-rep-elem))
    (declare (ignorable __function__))
    (tree-fix (nth 0 (smtp-cst-wsp-conc2-rep cst)))))

Theorem: treep-of-smtp-cst-wsp-conc2-rep-elem

(defthm treep-of-smtp-cst-wsp-conc2-rep-elem
  (b* ((cst1 (smtp-cst-wsp-conc2-rep-elem cst)))
    (treep cst1))
  :rule-classes :rewrite)

Theorem: smtp-cst-wsp-conc2-rep-elem-match

(defthm smtp-cst-wsp-conc2-rep-elem-match
  (implies (and (smtp-cst-matchp cst "wsp")
                (equal (smtp-cst-wsp-conc? cst) 2))
           (b* ((cst1 (smtp-cst-wsp-conc2-rep-elem cst)))
             (smtp-cst-matchp cst1 "htab")))
  :rule-classes :rewrite)

Theorem: smtp-cst-wsp-conc2-rep-elem-of-tree-fix-cst

(defthm smtp-cst-wsp-conc2-rep-elem-of-tree-fix-cst
  (equal (smtp-cst-wsp-conc2-rep-elem (tree-fix cst))
         (smtp-cst-wsp-conc2-rep-elem cst)))

Theorem: smtp-cst-wsp-conc2-rep-elem-tree-equiv-congruence-on-cst

(defthm smtp-cst-wsp-conc2-rep-elem-tree-equiv-congruence-on-cst
  (implies (tree-equiv cst cst-equiv)
           (equal (smtp-cst-wsp-conc2-rep-elem cst)
                  (smtp-cst-wsp-conc2-rep-elem cst-equiv)))
  :rule-classes :congruence)

Function: smtp-cst-htab-conc-rep-elem

(defun smtp-cst-htab-conc-rep-elem (cst)
  (declare (xargs :guard (treep cst)))
  (declare (xargs :guard (smtp-cst-matchp cst "htab")))
  (let ((__function__ 'smtp-cst-htab-conc-rep-elem))
    (declare (ignorable __function__))
    (tree-fix (nth 0 (smtp-cst-htab-conc-rep cst)))))

Theorem: treep-of-smtp-cst-htab-conc-rep-elem

(defthm treep-of-smtp-cst-htab-conc-rep-elem
  (b* ((cst1 (smtp-cst-htab-conc-rep-elem cst)))
    (treep cst1))
  :rule-classes :rewrite)

Theorem: smtp-cst-htab-conc-rep-elem-match

(defthm smtp-cst-htab-conc-rep-elem-match
  (implies (smtp-cst-matchp cst "htab")
           (b* ((cst1 (smtp-cst-htab-conc-rep-elem cst)))
             (smtp-cst-matchp cst1 "%x9")))
  :rule-classes :rewrite)

Theorem: smtp-cst-htab-conc-rep-elem-of-tree-fix-cst

(defthm smtp-cst-htab-conc-rep-elem-of-tree-fix-cst
  (equal (smtp-cst-htab-conc-rep-elem (tree-fix cst))
         (smtp-cst-htab-conc-rep-elem cst)))

Theorem: smtp-cst-htab-conc-rep-elem-tree-equiv-congruence-on-cst

(defthm smtp-cst-htab-conc-rep-elem-tree-equiv-congruence-on-cst
  (implies (tree-equiv cst cst-equiv)
           (equal (smtp-cst-htab-conc-rep-elem cst)
                  (smtp-cst-htab-conc-rep-elem cst-equiv)))
  :rule-classes :congruence)

*all-smtp-grammar-rules*-tree-operations

Definitions and Theorems

all-smtp-grammar-rules-tree-operations