		Search-engine friendly clone of the ACL2 documentation.

*grammar*

grammar-tree-operations

Tree operations specialized to *grammar*.

Definitions and Theorems

Function: cst-matchp$

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

Theorem: booleanp-of-cst-matchp$

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

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

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

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

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

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

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

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

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

Function: cst-list-elem-matchp$

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

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

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

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

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

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

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

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

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

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

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

Function: cst-list-rep-matchp$

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

Function: cst-%x20-21-nat

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

Theorem: natp-of-cst-%x20-21-nat

(defthm natp-of-cst-%x20-21-nat
  (b* ((nat (cst-%x20-21-nat abnf::cst)))
    (natp nat))
  :rule-classes :rewrite)

Theorem: cst-%x20-21-nat-of-tree-fix-cst

(defthm cst-%x20-21-nat-of-tree-fix-cst
  (equal (cst-%x20-21-nat (abnf::tree-fix abnf::cst))
         (cst-%x20-21-nat abnf::cst)))

Theorem: cst-%x20-21-nat-tree-equiv-congruence-on-cst

(defthm cst-%x20-21-nat-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-%x20-21-nat abnf::cst)
                  (cst-%x20-21-nat cst-equiv)))
  :rule-classes :congruence)

Function: cst-%x20-29-nat

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

Theorem: natp-of-cst-%x20-29-nat

(defthm natp-of-cst-%x20-29-nat
  (b* ((nat (cst-%x20-29-nat abnf::cst)))
    (natp nat))
  :rule-classes :rewrite)

Theorem: cst-%x20-29-nat-of-tree-fix-cst

(defthm cst-%x20-29-nat-of-tree-fix-cst
  (equal (cst-%x20-29-nat (abnf::tree-fix abnf::cst))
         (cst-%x20-29-nat abnf::cst)))

Theorem: cst-%x20-29-nat-tree-equiv-congruence-on-cst

(defthm cst-%x20-29-nat-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-%x20-29-nat abnf::cst)
                  (cst-%x20-29-nat cst-equiv)))
  :rule-classes :congruence)

Function: cst-%x21-7e-nat

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

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

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

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

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

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

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

Function: cst-%x23-5b-nat

(defun cst-%x23-5b-nat (abnf::cst)
  (declare (xargs :guard (abnf::treep abnf::cst)))
  (declare (xargs :guard (cst-matchp abnf::cst "%x23-5B")))
  (let ((__function__ 'cst-%x23-5b-nat))
    (declare (ignorable __function__))
    (lnfix (nth 0
                (abnf::tree-leafterm->get abnf::cst)))))

Theorem: natp-of-cst-%x23-5b-nat

(defthm natp-of-cst-%x23-5b-nat
  (b* ((nat (cst-%x23-5b-nat abnf::cst)))
    (natp nat))
  :rule-classes :rewrite)

Theorem: cst-%x23-5b-nat-of-tree-fix-cst

(defthm cst-%x23-5b-nat-of-tree-fix-cst
  (equal (cst-%x23-5b-nat (abnf::tree-fix abnf::cst))
         (cst-%x23-5b-nat abnf::cst)))

Theorem: cst-%x23-5b-nat-tree-equiv-congruence-on-cst

(defthm cst-%x23-5b-nat-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-%x23-5b-nat abnf::cst)
                  (cst-%x23-5b-nat cst-equiv)))
  :rule-classes :congruence)

Function: cst-%x2b-2e-nat

(defun cst-%x2b-2e-nat (abnf::cst)
  (declare (xargs :guard (abnf::treep abnf::cst)))
  (declare (xargs :guard (cst-matchp abnf::cst "%x2B-2E")))
  (let ((__function__ 'cst-%x2b-2e-nat))
    (declare (ignorable __function__))
    (lnfix (nth 0
                (abnf::tree-leafterm->get abnf::cst)))))

Theorem: natp-of-cst-%x2b-2e-nat

(defthm natp-of-cst-%x2b-2e-nat
  (b* ((nat (cst-%x2b-2e-nat abnf::cst)))
    (natp nat))
  :rule-classes :rewrite)

Theorem: cst-%x2b-2e-nat-of-tree-fix-cst

(defthm cst-%x2b-2e-nat-of-tree-fix-cst
  (equal (cst-%x2b-2e-nat (abnf::tree-fix abnf::cst))
         (cst-%x2b-2e-nat abnf::cst)))

Theorem: cst-%x2b-2e-nat-tree-equiv-congruence-on-cst

(defthm cst-%x2b-2e-nat-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-%x2b-2e-nat abnf::cst)
                  (cst-%x2b-2e-nat cst-equiv)))
  :rule-classes :congruence)

Function: cst-%x2b-7e-nat

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

Theorem: natp-of-cst-%x2b-7e-nat

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

Theorem: cst-%x2b-7e-nat-of-tree-fix-cst

(defthm cst-%x2b-7e-nat-of-tree-fix-cst
  (equal (cst-%x2b-7e-nat (abnf::tree-fix abnf::cst))
         (cst-%x2b-7e-nat abnf::cst)))

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

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

Function: cst-%x30-39-nat

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

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

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

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

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

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

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

Function: cst-%x30-7e-nat

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

Theorem: natp-of-cst-%x30-7e-nat

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

Theorem: cst-%x30-7e-nat-of-tree-fix-cst

(defthm cst-%x30-7e-nat-of-tree-fix-cst
  (equal (cst-%x30-7e-nat (abnf::tree-fix abnf::cst))
         (cst-%x30-7e-nat abnf::cst)))

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

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

Function: cst-%x41-5a-nat

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

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

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

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

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

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

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

Function: cst-%x5d-7e-nat

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

Theorem: natp-of-cst-%x5d-7e-nat

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

Theorem: cst-%x5d-7e-nat-of-tree-fix-cst

(defthm cst-%x5d-7e-nat-of-tree-fix-cst
  (equal (cst-%x5d-7e-nat (abnf::tree-fix abnf::cst))
         (cst-%x5d-7e-nat abnf::cst)))

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

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

Function: cst-%x61-7a-nat

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

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

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

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

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

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

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

Function: cst-%x80-2029-nat

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

Theorem: natp-of-cst-%x80-2029-nat

(defthm natp-of-cst-%x80-2029-nat
  (b* ((nat (cst-%x80-2029-nat abnf::cst)))
    (natp nat))
  :rule-classes :rewrite)

Theorem: cst-%x80-2029-nat-of-tree-fix-cst

(defthm cst-%x80-2029-nat-of-tree-fix-cst
  (equal (cst-%x80-2029-nat (abnf::tree-fix abnf::cst))
         (cst-%x80-2029-nat abnf::cst)))

Theorem: cst-%x80-2029-nat-tree-equiv-congruence-on-cst

(defthm cst-%x80-2029-nat-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-%x80-2029-nat abnf::cst)
                  (cst-%x80-2029-nat cst-equiv)))
  :rule-classes :congruence)

Function: cst-%x202f-2065-nat

(defun cst-%x202f-2065-nat (abnf::cst)
  (declare (xargs :guard (abnf::treep abnf::cst)))
  (declare (xargs :guard (cst-matchp abnf::cst "%x202F-2065")))
  (let ((__function__ 'cst-%x202f-2065-nat))
    (declare (ignorable __function__))
    (lnfix (nth 0
                (abnf::tree-leafterm->get abnf::cst)))))

Theorem: natp-of-cst-%x202f-2065-nat

(defthm natp-of-cst-%x202f-2065-nat
  (b* ((nat (cst-%x202f-2065-nat abnf::cst)))
    (natp nat))
  :rule-classes :rewrite)

Theorem: cst-%x202f-2065-nat-of-tree-fix-cst

(defthm cst-%x202f-2065-nat-of-tree-fix-cst
  (equal (cst-%x202f-2065-nat (abnf::tree-fix abnf::cst))
         (cst-%x202f-2065-nat abnf::cst)))

Theorem: cst-%x202f-2065-nat-tree-equiv-congruence-on-cst

(defthm cst-%x202f-2065-nat-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-%x202f-2065-nat abnf::cst)
                  (cst-%x202f-2065-nat cst-equiv)))
  :rule-classes :congruence)

Function: cst-%x206a-d7ff-nat

(defun cst-%x206a-d7ff-nat (abnf::cst)
  (declare (xargs :guard (abnf::treep abnf::cst)))
  (declare (xargs :guard (cst-matchp abnf::cst "%x206A-D7FF")))
  (let ((__function__ 'cst-%x206a-d7ff-nat))
    (declare (ignorable __function__))
    (lnfix (nth 0
                (abnf::tree-leafterm->get abnf::cst)))))

Theorem: natp-of-cst-%x206a-d7ff-nat

(defthm natp-of-cst-%x206a-d7ff-nat
  (b* ((nat (cst-%x206a-d7ff-nat abnf::cst)))
    (natp nat))
  :rule-classes :rewrite)

Theorem: cst-%x206a-d7ff-nat-of-tree-fix-cst

(defthm cst-%x206a-d7ff-nat-of-tree-fix-cst
  (equal (cst-%x206a-d7ff-nat (abnf::tree-fix abnf::cst))
         (cst-%x206a-d7ff-nat abnf::cst)))

Theorem: cst-%x206a-d7ff-nat-tree-equiv-congruence-on-cst

(defthm cst-%x206a-d7ff-nat-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-%x206a-d7ff-nat abnf::cst)
                  (cst-%x206a-d7ff-nat cst-equiv)))
  :rule-classes :congruence)

Function: cst-%xe000-10ffff-nat

(defun cst-%xe000-10ffff-nat (abnf::cst)
  (declare (xargs :guard (abnf::treep abnf::cst)))
  (declare (xargs :guard (cst-matchp abnf::cst "%xE000-10FFFF")))
  (let ((__function__ 'cst-%xe000-10ffff-nat))
    (declare (ignorable __function__))
    (lnfix (nth 0
                (abnf::tree-leafterm->get abnf::cst)))))

Theorem: natp-of-cst-%xe000-10ffff-nat

(defthm natp-of-cst-%xe000-10ffff-nat
  (b* ((nat (cst-%xe000-10ffff-nat abnf::cst)))
    (natp nat))
  :rule-classes :rewrite)

Theorem: cst-%xe000-10ffff-nat-of-tree-fix-cst

(defthm cst-%xe000-10ffff-nat-of-tree-fix-cst
  (equal (cst-%xe000-10ffff-nat (abnf::tree-fix abnf::cst))
         (cst-%xe000-10ffff-nat abnf::cst)))

Theorem: cst-%xe000-10ffff-nat-tree-equiv-congruence-on-cst

(defthm cst-%xe000-10ffff-nat-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-%xe000-10ffff-nat abnf::cst)
                  (cst-%xe000-10ffff-nat cst-equiv)))
  :rule-classes :congruence)

Theorem: cst-%x20-21-nat-bounds

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

Theorem: cst-%x20-29-nat-bounds

(defthm cst-%x20-29-nat-bounds
  (implies (cst-matchp abnf::cst "%x20-29")
           (and (<= 32 (cst-%x20-29-nat abnf::cst))
                (<= (cst-%x20-29-nat abnf::cst) 41)))
  :rule-classes :linear)

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

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

Theorem: cst-%x23-5b-nat-bounds

(defthm cst-%x23-5b-nat-bounds
  (implies (cst-matchp abnf::cst "%x23-5B")
           (and (<= 35 (cst-%x23-5b-nat abnf::cst))
                (<= (cst-%x23-5b-nat abnf::cst) 91)))
  :rule-classes :linear)

Theorem: cst-%x2b-2e-nat-bounds

(defthm cst-%x2b-2e-nat-bounds
  (implies (cst-matchp abnf::cst "%x2B-2E")
           (and (<= 43 (cst-%x2b-2e-nat abnf::cst))
                (<= (cst-%x2b-2e-nat abnf::cst) 46)))
  :rule-classes :linear)

Theorem: cst-%x2b-7e-nat-bounds

(defthm cst-%x2b-7e-nat-bounds
  (implies (cst-matchp abnf::cst "%x2B-7E")
           (and (<= 43 (cst-%x2b-7e-nat abnf::cst))
                (<= (cst-%x2b-7e-nat abnf::cst) 126)))
  :rule-classes :linear)

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

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

Theorem: cst-%x30-7e-nat-bounds

(defthm cst-%x30-7e-nat-bounds
  (implies (cst-matchp abnf::cst "%x30-7E")
           (and (<= 48 (cst-%x30-7e-nat abnf::cst))
                (<= (cst-%x30-7e-nat abnf::cst) 126)))
  :rule-classes :linear)

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

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

Theorem: cst-%x5d-7e-nat-bounds

(defthm cst-%x5d-7e-nat-bounds
  (implies (cst-matchp abnf::cst "%x5D-7E")
           (and (<= 93 (cst-%x5d-7e-nat abnf::cst))
                (<= (cst-%x5d-7e-nat abnf::cst) 126)))
  :rule-classes :linear)

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

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

Theorem: cst-%x80-2029-nat-bounds

(defthm cst-%x80-2029-nat-bounds
  (implies (cst-matchp abnf::cst "%x80-2029")
           (and (<= 128 (cst-%x80-2029-nat abnf::cst))
                (<= (cst-%x80-2029-nat abnf::cst)
                    8233)))
  :rule-classes :linear)

Theorem: cst-%x202f-2065-nat-bounds

(defthm cst-%x202f-2065-nat-bounds
  (implies (cst-matchp abnf::cst "%x202F-2065")
           (and (<= 8239 (cst-%x202f-2065-nat abnf::cst))
                (<= (cst-%x202f-2065-nat abnf::cst)
                    8293)))
  :rule-classes :linear)

Theorem: cst-%x206a-d7ff-nat-bounds

(defthm cst-%x206a-d7ff-nat-bounds
  (implies (cst-matchp abnf::cst "%x206A-D7FF")
           (and (<= 8298 (cst-%x206a-d7ff-nat abnf::cst))
                (<= (cst-%x206a-d7ff-nat abnf::cst)
                    55295)))
  :rule-classes :linear)

Theorem: cst-%xe000-10ffff-nat-bounds

(defthm cst-%xe000-10ffff-nat-bounds
  (implies (cst-matchp abnf::cst "%xE000-10FFFF")
           (and (<= 57344 (cst-%xe000-10ffff-nat abnf::cst))
                (<= (cst-%xe000-10ffff-nat abnf::cst)
                    1114111)))
  :rule-classes :linear)

Theorem: cst-"*"-leafterm

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

Theorem: cst-"-"-leafterm

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

Theorem: cst-"."-leafterm

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

Theorem: cst-"/"-leafterm

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

Theorem: cst-"/*"-leafterm

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

Theorem: cst-"//"-leafterm

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

Theorem: cst-"0"-leafterm

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

Theorem: cst-"1024"-leafterm

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

Theorem: cst-"128"-leafterm

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

Theorem: cst-"2"-leafterm

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

Theorem: cst-"256"-leafterm

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

Theorem: cst-"3"-leafterm

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

Theorem: cst-"4"-leafterm

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

Theorem: cst-"5"-leafterm

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

Theorem: cst-"512"-leafterm

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

Theorem: cst-"6"-leafterm

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

Theorem: cst-"64"-leafterm

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

Theorem: cst-"7"-leafterm

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

Theorem: cst-"768"-leafterm

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

Theorem: cst-"8"-leafterm

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

Theorem: cst-"9"-leafterm

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

Theorem: cst-":"-leafterm

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

Theorem: cst-";"-leafterm

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

Theorem: cst-"["-leafterm

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

Theorem: cst-"\"-leafterm

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

Theorem: cst-"]"-leafterm

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

Theorem: cst-"_"-leafterm

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

Theorem: cst-"a"-leafterm

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

Theorem: cst-"b"-leafterm

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

Theorem: cst-"c"-leafterm

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

Theorem: cst-"d"-leafterm

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

Theorem: cst-"e"-leafterm

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

Theorem: cst-"f"-leafterm

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

Theorem: cst-"{"-leafterm

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

Theorem: cst-"}"-leafterm

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

Theorem: cst-%s".constant"-leafterm

(defthm |CST-%s".constant"-LEAFTERM|
  (implies (cst-matchp abnf::cst "%s\".constant\"")
           (equal (abnf::tree-kind abnf::cst)
                  :leafterm)))

Theorem: cst-%s".private"-leafterm

(defthm |CST-%s".private"-LEAFTERM|
  (implies (cst-matchp abnf::cst "%s\".private\"")
           (equal (abnf::tree-kind abnf::cst)
                  :leafterm)))

Theorem: cst-%s".public"-leafterm

(defthm |CST-%s".public"-LEAFTERM|
  (implies (cst-matchp abnf::cst "%s\".public\"")
           (equal (abnf::tree-kind abnf::cst)
                  :leafterm)))

Theorem: cst-%s".record"-leafterm

(defthm |CST-%s".record"-LEAFTERM|
  (implies (cst-matchp abnf::cst "%s\".record\"")
           (equal (abnf::tree-kind abnf::cst)
                  :leafterm)))

Theorem: cst-%s"a"-leafterm

(defthm |CST-%s"a"-LEAFTERM|
  (implies (cst-matchp abnf::cst "%s\"a\"")
           (equal (abnf::tree-kind abnf::cst)
                  :leafterm)))

Theorem: cst-%s"abs"-leafterm

(defthm |CST-%s"abs"-LEAFTERM|
  (implies (cst-matchp abnf::cst "%s\"abs\"")
           (equal (abnf::tree-kind abnf::cst)
                  :leafterm)))

Theorem: cst-%s"abs.w"-leafterm

(defthm |CST-%s"abs.w"-LEAFTERM|
  (implies (cst-matchp abnf::cst "%s\"abs.w\"")
           (equal (abnf::tree-kind abnf::cst)
                  :leafterm)))

Theorem: cst-%s"add"-leafterm

(defthm |CST-%s"add"-LEAFTERM|
  (implies (cst-matchp abnf::cst "%s\"add\"")
           (equal (abnf::tree-kind abnf::cst)
                  :leafterm)))

Theorem: cst-%s"add.w"-leafterm

(defthm |CST-%s"add.w"-LEAFTERM|
  (implies (cst-matchp abnf::cst "%s\"add.w\"")
           (equal (abnf::tree-kind abnf::cst)
                  :leafterm)))

Theorem: cst-%s"address"-leafterm

(defthm |CST-%s"address"-LEAFTERM|
  (implies (cst-matchp abnf::cst "%s\"address\"")
           (equal (abnf::tree-kind abnf::cst)
                  :leafterm)))

Theorem: cst-%s"address.private"-leafterm

(defthm |CST-%s"address.private"-LEAFTERM|
  (implies (cst-matchp abnf::cst "%s\"address.private\"")
           (equal (abnf::tree-kind abnf::cst)
                  :leafterm)))

Theorem: cst-%s"address.public"-leafterm

(defthm |CST-%s"address.public"-LEAFTERM|
  (implies (cst-matchp abnf::cst "%s\"address.public\"")
           (equal (abnf::tree-kind abnf::cst)
                  :leafterm)))

Theorem: cst-%s"aleo1"-leafterm

(defthm |CST-%s"aleo1"-LEAFTERM|
  (implies (cst-matchp abnf::cst "%s\"aleo1\"")
           (equal (abnf::tree-kind abnf::cst)
                  :leafterm)))

Theorem: cst-%s"and"-leafterm

(defthm |CST-%s"and"-LEAFTERM|
  (implies (cst-matchp abnf::cst "%s\"and\"")
           (equal (abnf::tree-kind abnf::cst)
                  :leafterm)))

Theorem: cst-%s"as"-leafterm

(defthm |CST-%s"as"-LEAFTERM|
  (implies (cst-matchp abnf::cst "%s\"as\"")
           (equal (abnf::tree-kind abnf::cst)
                  :leafterm)))

Theorem: cst-%s"assert.eq"-leafterm

(defthm |CST-%s"assert.eq"-LEAFTERM|
  (implies (cst-matchp abnf::cst "%s\"assert.eq\"")
           (equal (abnf::tree-kind abnf::cst)
                  :leafterm)))

Theorem: cst-%s"assert.neq"-leafterm

(defthm |CST-%s"assert.neq"-LEAFTERM|
  (implies (cst-matchp abnf::cst "%s\"assert.neq\"")
           (equal (abnf::tree-kind abnf::cst)
                  :leafterm)))

Theorem: cst-%s"b"-leafterm

(defthm |CST-%s"b"-LEAFTERM|
  (implies (cst-matchp abnf::cst "%s\"b\"")
           (equal (abnf::tree-kind abnf::cst)
                  :leafterm)))

Theorem: cst-%s"boolean"-leafterm

(defthm |CST-%s"boolean"-LEAFTERM|
  (implies (cst-matchp abnf::cst "%s\"boolean\"")
           (equal (abnf::tree-kind abnf::cst)
                  :leafterm)))

Theorem: cst-%s"by"-leafterm

(defthm |CST-%s"by"-LEAFTERM|
  (implies (cst-matchp abnf::cst "%s\"by\"")
           (equal (abnf::tree-kind abnf::cst)
                  :leafterm)))

Theorem: cst-%s"c"-leafterm

(defthm |CST-%s"c"-LEAFTERM|
  (implies (cst-matchp abnf::cst "%s\"c\"")
           (equal (abnf::tree-kind abnf::cst)
                  :leafterm)))

Theorem: cst-%s"call"-leafterm

(defthm |CST-%s"call"-LEAFTERM|
  (implies (cst-matchp abnf::cst "%s\"call\"")
           (equal (abnf::tree-kind abnf::cst)
                  :leafterm)))

Theorem: cst-%s"cast"-leafterm

(defthm |CST-%s"cast"-LEAFTERM|
  (implies (cst-matchp abnf::cst "%s\"cast\"")
           (equal (abnf::tree-kind abnf::cst)
                  :leafterm)))

Theorem: cst-%s"commit.bhp"-leafterm

(defthm |CST-%s"commit.bhp"-LEAFTERM|
  (implies (cst-matchp abnf::cst "%s\"commit.bhp\"")
           (equal (abnf::tree-kind abnf::cst)
                  :leafterm)))

Theorem: cst-%s"commit.ped"-leafterm

(defthm |CST-%s"commit.ped"-LEAFTERM|
  (implies (cst-matchp abnf::cst "%s\"commit.ped\"")
           (equal (abnf::tree-kind abnf::cst)
                  :leafterm)))

Theorem: cst-%s"d"-leafterm

(defthm |CST-%s"d"-LEAFTERM|
  (implies (cst-matchp abnf::cst "%s\"d\"")
           (equal (abnf::tree-kind abnf::cst)
                  :leafterm)))

Theorem: cst-%s"decrement"-leafterm

(defthm |CST-%s"decrement"-LEAFTERM|
  (implies (cst-matchp abnf::cst "%s\"decrement\"")
           (equal (abnf::tree-kind abnf::cst)
                  :leafterm)))

Theorem: cst-%s"div"-leafterm

(defthm |CST-%s"div"-LEAFTERM|
  (implies (cst-matchp abnf::cst "%s\"div\"")
           (equal (abnf::tree-kind abnf::cst)
                  :leafterm)))

Theorem: cst-%s"div.w"-leafterm

(defthm |CST-%s"div.w"-LEAFTERM|
  (implies (cst-matchp abnf::cst "%s\"div.w\"")
           (equal (abnf::tree-kind abnf::cst)
                  :leafterm)))

Theorem: cst-%s"double"-leafterm

(defthm |CST-%s"double"-LEAFTERM|
  (implies (cst-matchp abnf::cst "%s\"double\"")
           (equal (abnf::tree-kind abnf::cst)
                  :leafterm)))

Theorem: cst-%s"e"-leafterm

(defthm |CST-%s"e"-LEAFTERM|
  (implies (cst-matchp abnf::cst "%s\"e\"")
           (equal (abnf::tree-kind abnf::cst)
                  :leafterm)))

Theorem: cst-%s"f"-leafterm

(defthm |CST-%s"f"-LEAFTERM|
  (implies (cst-matchp abnf::cst "%s\"f\"")
           (equal (abnf::tree-kind abnf::cst)
                  :leafterm)))

Theorem: cst-%s"false"-leafterm

(defthm |CST-%s"false"-LEAFTERM|
  (implies (cst-matchp abnf::cst "%s\"false\"")
           (equal (abnf::tree-kind abnf::cst)
                  :leafterm)))

Theorem: cst-%s"field"-leafterm

(defthm |CST-%s"field"-LEAFTERM|
  (implies (cst-matchp abnf::cst "%s\"field\"")
           (equal (abnf::tree-kind abnf::cst)
                  :leafterm)))

Theorem: cst-%s"finalize"-leafterm

(defthm |CST-%s"finalize"-LEAFTERM|
  (implies (cst-matchp abnf::cst "%s\"finalize\"")
           (equal (abnf::tree-kind abnf::cst)
                  :leafterm)))

Theorem: cst-%s"function"-leafterm

(defthm |CST-%s"function"-LEAFTERM|
  (implies (cst-matchp abnf::cst "%s\"function\"")
           (equal (abnf::tree-kind abnf::cst)
                  :leafterm)))

Theorem: cst-%s"g"-leafterm

(defthm |CST-%s"g"-LEAFTERM|
  (implies (cst-matchp abnf::cst "%s\"g\"")
           (equal (abnf::tree-kind abnf::cst)
                  :leafterm)))

Theorem: cst-%s"gates"-leafterm

(defthm |CST-%s"gates"-LEAFTERM|
  (implies (cst-matchp abnf::cst "%s\"gates\"")
           (equal (abnf::tree-kind abnf::cst)
                  :leafterm)))

Theorem: cst-%s"group"-leafterm

(defthm |CST-%s"group"-LEAFTERM|
  (implies (cst-matchp abnf::cst "%s\"group\"")
           (equal (abnf::tree-kind abnf::cst)
                  :leafterm)))

Theorem: cst-%s"gt"-leafterm

(defthm |CST-%s"gt"-LEAFTERM|
  (implies (cst-matchp abnf::cst "%s\"gt\"")
           (equal (abnf::tree-kind abnf::cst)
                  :leafterm)))

Theorem: cst-%s"gte"-leafterm

(defthm |CST-%s"gte"-LEAFTERM|
  (implies (cst-matchp abnf::cst "%s\"gte\"")
           (equal (abnf::tree-kind abnf::cst)
                  :leafterm)))

Theorem: cst-%s"h"-leafterm

(defthm |CST-%s"h"-LEAFTERM|
  (implies (cst-matchp abnf::cst "%s\"h\"")
           (equal (abnf::tree-kind abnf::cst)
                  :leafterm)))

Theorem: cst-%s"hash.bhp"-leafterm

(defthm |CST-%s"hash.bhp"-LEAFTERM|
  (implies (cst-matchp abnf::cst "%s\"hash.bhp\"")
           (equal (abnf::tree-kind abnf::cst)
                  :leafterm)))

Theorem: cst-%s"hash.ped"-leafterm

(defthm |CST-%s"hash.ped"-LEAFTERM|
  (implies (cst-matchp abnf::cst "%s\"hash.ped\"")
           (equal (abnf::tree-kind abnf::cst)
                  :leafterm)))

Theorem: cst-%s"hash.psd"-leafterm

(defthm |CST-%s"hash.psd"-LEAFTERM|
  (implies (cst-matchp abnf::cst "%s\"hash.psd\"")
           (equal (abnf::tree-kind abnf::cst)
                  :leafterm)))

Theorem: cst-%s"i128"-leafterm

(defthm |CST-%s"i128"-LEAFTERM|
  (implies (cst-matchp abnf::cst "%s\"i128\"")
           (equal (abnf::tree-kind abnf::cst)
                  :leafterm)))

Theorem: cst-%s"i16"-leafterm

(defthm |CST-%s"i16"-LEAFTERM|
  (implies (cst-matchp abnf::cst "%s\"i16\"")
           (equal (abnf::tree-kind abnf::cst)
                  :leafterm)))

Theorem: cst-%s"i32"-leafterm

(defthm |CST-%s"i32"-LEAFTERM|
  (implies (cst-matchp abnf::cst "%s\"i32\"")
           (equal (abnf::tree-kind abnf::cst)
                  :leafterm)))

Theorem: cst-%s"i64"-leafterm

(defthm |CST-%s"i64"-LEAFTERM|
  (implies (cst-matchp abnf::cst "%s\"i64\"")
           (equal (abnf::tree-kind abnf::cst)
                  :leafterm)))

Theorem: cst-%s"i8"-leafterm

(defthm |CST-%s"i8"-LEAFTERM|
  (implies (cst-matchp abnf::cst "%s\"i8\"")
           (equal (abnf::tree-kind abnf::cst)
                  :leafterm)))

Theorem: cst-%s"import"-leafterm

(defthm |CST-%s"import"-LEAFTERM|
  (implies (cst-matchp abnf::cst "%s\"import\"")
           (equal (abnf::tree-kind abnf::cst)
                  :leafterm)))

Theorem: cst-%s"increment"-leafterm

(defthm |CST-%s"increment"-LEAFTERM|
  (implies (cst-matchp abnf::cst "%s\"increment\"")
           (equal (abnf::tree-kind abnf::cst)
                  :leafterm)))

Theorem: cst-%s"input"-leafterm

(defthm |CST-%s"input"-LEAFTERM|
  (implies (cst-matchp abnf::cst "%s\"input\"")
           (equal (abnf::tree-kind abnf::cst)
                  :leafterm)))

Theorem: cst-%s"into"-leafterm

(defthm |CST-%s"into"-LEAFTERM|
  (implies (cst-matchp abnf::cst "%s\"into\"")
           (equal (abnf::tree-kind abnf::cst)
                  :leafterm)))

Theorem: cst-%s"inv"-leafterm

(defthm |CST-%s"inv"-LEAFTERM|
  (implies (cst-matchp abnf::cst "%s\"inv\"")
           (equal (abnf::tree-kind abnf::cst)
                  :leafterm)))

Theorem: cst-%s"is.eq"-leafterm

(defthm |CST-%s"is.eq"-LEAFTERM|
  (implies (cst-matchp abnf::cst "%s\"is.eq\"")
           (equal (abnf::tree-kind abnf::cst)
                  :leafterm)))

Theorem: cst-%s"is.neq"-leafterm

(defthm |CST-%s"is.neq"-LEAFTERM|
  (implies (cst-matchp abnf::cst "%s\"is.neq\"")
           (equal (abnf::tree-kind abnf::cst)
                  :leafterm)))

Theorem: cst-%s"j"-leafterm

(defthm |CST-%s"j"-LEAFTERM|
  (implies (cst-matchp abnf::cst "%s\"j\"")
           (equal (abnf::tree-kind abnf::cst)
                  :leafterm)))

Theorem: cst-%s"k"-leafterm

(defthm |CST-%s"k"-LEAFTERM|
  (implies (cst-matchp abnf::cst "%s\"k\"")
           (equal (abnf::tree-kind abnf::cst)
                  :leafterm)))

Theorem: cst-%s"key"-leafterm

(defthm |CST-%s"key"-LEAFTERM|
  (implies (cst-matchp abnf::cst "%s\"key\"")
           (equal (abnf::tree-kind abnf::cst)
                  :leafterm)))

Theorem: cst-%s"l"-leafterm

(defthm |CST-%s"l"-LEAFTERM|
  (implies (cst-matchp abnf::cst "%s\"l\"")
           (equal (abnf::tree-kind abnf::cst)
                  :leafterm)))

Theorem: cst-%s"lt"-leafterm

(defthm |CST-%s"lt"-LEAFTERM|
  (implies (cst-matchp abnf::cst "%s\"lt\"")
           (equal (abnf::tree-kind abnf::cst)
                  :leafterm)))

Theorem: cst-%s"lte"-leafterm

(defthm |CST-%s"lte"-LEAFTERM|
  (implies (cst-matchp abnf::cst "%s\"lte\"")
           (equal (abnf::tree-kind abnf::cst)
                  :leafterm)))

Theorem: cst-%s"m"-leafterm

(defthm |CST-%s"m"-LEAFTERM|
  (implies (cst-matchp abnf::cst "%s\"m\"")
           (equal (abnf::tree-kind abnf::cst)
                  :leafterm)))

Theorem: cst-%s"mapping"-leafterm

(defthm |CST-%s"mapping"-LEAFTERM|
  (implies (cst-matchp abnf::cst "%s\"mapping\"")
           (equal (abnf::tree-kind abnf::cst)
                  :leafterm)))

Theorem: cst-%s"mod"-leafterm

(defthm |CST-%s"mod"-LEAFTERM|
  (implies (cst-matchp abnf::cst "%s\"mod\"")
           (equal (abnf::tree-kind abnf::cst)
                  :leafterm)))

Theorem: cst-%s"mul"-leafterm

(defthm |CST-%s"mul"-LEAFTERM|
  (implies (cst-matchp abnf::cst "%s\"mul\"")
           (equal (abnf::tree-kind abnf::cst)
                  :leafterm)))

Theorem: cst-%s"mul.w"-leafterm

(defthm |CST-%s"mul.w"-LEAFTERM|
  (implies (cst-matchp abnf::cst "%s\"mul.w\"")
           (equal (abnf::tree-kind abnf::cst)
                  :leafterm)))

Theorem: cst-%s"n"-leafterm

(defthm |CST-%s"n"-LEAFTERM|
  (implies (cst-matchp abnf::cst "%s\"n\"")
           (equal (abnf::tree-kind abnf::cst)
                  :leafterm)))

Theorem: cst-%s"nand"-leafterm

(defthm |CST-%s"nand"-LEAFTERM|
  (implies (cst-matchp abnf::cst "%s\"nand\"")
           (equal (abnf::tree-kind abnf::cst)
                  :leafterm)))

Theorem: cst-%s"neg"-leafterm

(defthm |CST-%s"neg"-LEAFTERM|
  (implies (cst-matchp abnf::cst "%s\"neg\"")
           (equal (abnf::tree-kind abnf::cst)
                  :leafterm)))

Theorem: cst-%s"nor"-leafterm

(defthm |CST-%s"nor"-LEAFTERM|
  (implies (cst-matchp abnf::cst "%s\"nor\"")
           (equal (abnf::tree-kind abnf::cst)
                  :leafterm)))

Theorem: cst-%s"not"-leafterm

(defthm |CST-%s"not"-LEAFTERM|
  (implies (cst-matchp abnf::cst "%s\"not\"")
           (equal (abnf::tree-kind abnf::cst)
                  :leafterm)))

Theorem: cst-%s"or"-leafterm

(defthm |CST-%s"or"-LEAFTERM|
  (implies (cst-matchp abnf::cst "%s\"or\"")
           (equal (abnf::tree-kind abnf::cst)
                  :leafterm)))

Theorem: cst-%s"output"-leafterm

(defthm |CST-%s"output"-LEAFTERM|
  (implies (cst-matchp abnf::cst "%s\"output\"")
           (equal (abnf::tree-kind abnf::cst)
                  :leafterm)))

Theorem: cst-%s"owner"-leafterm

(defthm |CST-%s"owner"-LEAFTERM|
  (implies (cst-matchp abnf::cst "%s\"owner\"")
           (equal (abnf::tree-kind abnf::cst)
                  :leafterm)))

Theorem: cst-%s"p"-leafterm

(defthm |CST-%s"p"-LEAFTERM|
  (implies (cst-matchp abnf::cst "%s\"p\"")
           (equal (abnf::tree-kind abnf::cst)
                  :leafterm)))

Theorem: cst-%s"pow"-leafterm

(defthm |CST-%s"pow"-LEAFTERM|
  (implies (cst-matchp abnf::cst "%s\"pow\"")
           (equal (abnf::tree-kind abnf::cst)
                  :leafterm)))

Theorem: cst-%s"pow.w"-leafterm

(defthm |CST-%s"pow.w"-LEAFTERM|
  (implies (cst-matchp abnf::cst "%s\"pow.w\"")
           (equal (abnf::tree-kind abnf::cst)
                  :leafterm)))

Theorem: cst-%s"program"-leafterm

(defthm |CST-%s"program"-LEAFTERM|
  (implies (cst-matchp abnf::cst "%s\"program\"")
           (equal (abnf::tree-kind abnf::cst)
                  :leafterm)))

Theorem: cst-%s"q"-leafterm

(defthm |CST-%s"q"-LEAFTERM|
  (implies (cst-matchp abnf::cst "%s\"q\"")
           (equal (abnf::tree-kind abnf::cst)
                  :leafterm)))

Theorem: cst-%s"r"-leafterm

(defthm |CST-%s"r"-LEAFTERM|
  (implies (cst-matchp abnf::cst "%s\"r\"")
           (equal (abnf::tree-kind abnf::cst)
                  :leafterm)))

Theorem: cst-%s"record"-leafterm

(defthm |CST-%s"record"-LEAFTERM|
  (implies (cst-matchp abnf::cst "%s\"record\"")
           (equal (abnf::tree-kind abnf::cst)
                  :leafterm)))

Theorem: cst-%s"rem"-leafterm

(defthm |CST-%s"rem"-LEAFTERM|
  (implies (cst-matchp abnf::cst "%s\"rem\"")
           (equal (abnf::tree-kind abnf::cst)
                  :leafterm)))

Theorem: cst-%s"rem.w"-leafterm

(defthm |CST-%s"rem.w"-LEAFTERM|
  (implies (cst-matchp abnf::cst "%s\"rem.w\"")
           (equal (abnf::tree-kind abnf::cst)
                  :leafterm)))

Theorem: cst-%s"s"-leafterm

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

Theorem: cst-%s"scalar"-leafterm

(defthm |CST-%s"scalar"-LEAFTERM|
  (implies (cst-matchp abnf::cst "%s\"scalar\"")
           (equal (abnf::tree-kind abnf::cst)
                  :leafterm)))

Theorem: cst-%s"self.caller"-leafterm

(defthm |CST-%s"self.caller"-LEAFTERM|
  (implies (cst-matchp abnf::cst "%s\"self.caller\"")
           (equal (abnf::tree-kind abnf::cst)
                  :leafterm)))

Theorem: cst-%s"shl"-leafterm

(defthm |CST-%s"shl"-LEAFTERM|
  (implies (cst-matchp abnf::cst "%s\"shl\"")
           (equal (abnf::tree-kind abnf::cst)
                  :leafterm)))

Theorem: cst-%s"shl.w"-leafterm

(defthm |CST-%s"shl.w"-LEAFTERM|
  (implies (cst-matchp abnf::cst "%s\"shl.w\"")
           (equal (abnf::tree-kind abnf::cst)
                  :leafterm)))

Theorem: cst-%s"shr"-leafterm

(defthm |CST-%s"shr"-LEAFTERM|
  (implies (cst-matchp abnf::cst "%s\"shr\"")
           (equal (abnf::tree-kind abnf::cst)
                  :leafterm)))

Theorem: cst-%s"shr.w"-leafterm

(defthm |CST-%s"shr.w"-LEAFTERM|
  (implies (cst-matchp abnf::cst "%s\"shr.w\"")
           (equal (abnf::tree-kind abnf::cst)
                  :leafterm)))

Theorem: cst-%s"sqrt"-leafterm

(defthm |CST-%s"sqrt"-LEAFTERM|
  (implies (cst-matchp abnf::cst "%s\"sqrt\"")
           (equal (abnf::tree-kind abnf::cst)
                  :leafterm)))

Theorem: cst-%s"square"-leafterm

(defthm |CST-%s"square"-LEAFTERM|
  (implies (cst-matchp abnf::cst "%s\"square\"")
           (equal (abnf::tree-kind abnf::cst)
                  :leafterm)))

Theorem: cst-%s"string"-leafterm

(defthm |CST-%s"string"-LEAFTERM|
  (implies (cst-matchp abnf::cst "%s\"string\"")
           (equal (abnf::tree-kind abnf::cst)
                  :leafterm)))

Theorem: cst-%s"struct"-leafterm

(defthm |CST-%s"struct"-LEAFTERM|
  (implies (cst-matchp abnf::cst "%s\"struct\"")
           (equal (abnf::tree-kind abnf::cst)
                  :leafterm)))

Theorem: cst-%s"sub"-leafterm

(defthm |CST-%s"sub"-LEAFTERM|
  (implies (cst-matchp abnf::cst "%s\"sub\"")
           (equal (abnf::tree-kind abnf::cst)
                  :leafterm)))

Theorem: cst-%s"sub.w"-leafterm

(defthm |CST-%s"sub.w"-LEAFTERM|
  (implies (cst-matchp abnf::cst "%s\"sub.w\"")
           (equal (abnf::tree-kind abnf::cst)
                  :leafterm)))

Theorem: cst-%s"t"-leafterm

(defthm |CST-%s"t"-LEAFTERM|
  (implies (cst-matchp abnf::cst "%s\"t\"")
           (equal (abnf::tree-kind abnf::cst)
                  :leafterm)))

Theorem: cst-%s"ternary"-leafterm

(defthm |CST-%s"ternary"-LEAFTERM|
  (implies (cst-matchp abnf::cst "%s\"ternary\"")
           (equal (abnf::tree-kind abnf::cst)
                  :leafterm)))

Theorem: cst-%s"transition"-leafterm

(defthm |CST-%s"transition"-LEAFTERM|
  (implies (cst-matchp abnf::cst "%s\"transition\"")
           (equal (abnf::tree-kind abnf::cst)
                  :leafterm)))

Theorem: cst-%s"true"-leafterm

(defthm |CST-%s"true"-LEAFTERM|
  (implies (cst-matchp abnf::cst "%s\"true\"")
           (equal (abnf::tree-kind abnf::cst)
                  :leafterm)))

Theorem: cst-%s"u"-leafterm

(defthm |CST-%s"u"-LEAFTERM|
  (implies (cst-matchp abnf::cst "%s\"u\"")
           (equal (abnf::tree-kind abnf::cst)
                  :leafterm)))

Theorem: cst-%s"u128"-leafterm

(defthm |CST-%s"u128"-LEAFTERM|
  (implies (cst-matchp abnf::cst "%s\"u128\"")
           (equal (abnf::tree-kind abnf::cst)
                  :leafterm)))

Theorem: cst-%s"u16"-leafterm

(defthm |CST-%s"u16"-LEAFTERM|
  (implies (cst-matchp abnf::cst "%s\"u16\"")
           (equal (abnf::tree-kind abnf::cst)
                  :leafterm)))

Theorem: cst-%s"u32"-leafterm

(defthm |CST-%s"u32"-LEAFTERM|
  (implies (cst-matchp abnf::cst "%s\"u32\"")
           (equal (abnf::tree-kind abnf::cst)
                  :leafterm)))

Theorem: cst-%s"u64"-leafterm

(defthm |CST-%s"u64"-LEAFTERM|
  (implies (cst-matchp abnf::cst "%s\"u64\"")
           (equal (abnf::tree-kind abnf::cst)
                  :leafterm)))

Theorem: cst-%s"u64.private"-leafterm

(defthm |CST-%s"u64.private"-LEAFTERM|
  (implies (cst-matchp abnf::cst "%s\"u64.private\"")
           (equal (abnf::tree-kind abnf::cst)
                  :leafterm)))

Theorem: cst-%s"u64.public"-leafterm

(defthm |CST-%s"u64.public"-LEAFTERM|
  (implies (cst-matchp abnf::cst "%s\"u64.public\"")
           (equal (abnf::tree-kind abnf::cst)
                  :leafterm)))

Theorem: cst-%s"u8"-leafterm

(defthm |CST-%s"u8"-LEAFTERM|
  (implies (cst-matchp abnf::cst "%s\"u8\"")
           (equal (abnf::tree-kind abnf::cst)
                  :leafterm)))

Theorem: cst-%s"v"-leafterm

(defthm |CST-%s"v"-LEAFTERM|
  (implies (cst-matchp abnf::cst "%s\"v\"")
           (equal (abnf::tree-kind abnf::cst)
                  :leafterm)))

Theorem: cst-%s"value"-leafterm

(defthm |CST-%s"value"-LEAFTERM|
  (implies (cst-matchp abnf::cst "%s\"value\"")
           (equal (abnf::tree-kind abnf::cst)
                  :leafterm)))

Theorem: cst-%s"w"-leafterm

(defthm |CST-%s"w"-LEAFTERM|
  (implies (cst-matchp abnf::cst "%s\"w\"")
           (equal (abnf::tree-kind abnf::cst)
                  :leafterm)))

Theorem: cst-%s"x"-leafterm

(defthm |CST-%s"x"-LEAFTERM|
  (implies (cst-matchp abnf::cst "%s\"x\"")
           (equal (abnf::tree-kind abnf::cst)
                  :leafterm)))

Theorem: cst-%s"xor"-leafterm

(defthm |CST-%s"xor"-LEAFTERM|
  (implies (cst-matchp abnf::cst "%s\"xor\"")
           (equal (abnf::tree-kind abnf::cst)
                  :leafterm)))

Theorem: cst-%s"y"-leafterm

(defthm |CST-%s"y"-LEAFTERM|
  (implies (cst-matchp abnf::cst "%s\"y\"")
           (equal (abnf::tree-kind abnf::cst)
                  :leafterm)))

Theorem: cst-%s"z"-leafterm

(defthm |CST-%s"z"-LEAFTERM|
  (implies (cst-matchp abnf::cst "%s\"z\"")
           (equal (abnf::tree-kind abnf::cst)
                  :leafterm)))

Theorem: cst-ht-nonleaf

(defthm cst-ht-nonleaf
  (implies (cst-matchp abnf::cst "ht")
           (equal (abnf::tree-kind abnf::cst)
                  :nonleaf)))

Theorem: cst-lf-nonleaf

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

Theorem: cst-cr-nonleaf

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

Theorem: cst-sp-nonleaf

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

Theorem: cst-dq-nonleaf

(defthm cst-dq-nonleaf
  (implies (cst-matchp abnf::cst "dq")
           (equal (abnf::tree-kind abnf::cst)
                  :nonleaf)))

Theorem: cst-visible-ascii-nonleaf

(defthm cst-visible-ascii-nonleaf
  (implies (cst-matchp abnf::cst "visible-ascii")
           (equal (abnf::tree-kind abnf::cst)
                  :nonleaf)))

Theorem: cst-safe-ascii-nonleaf

(defthm cst-safe-ascii-nonleaf
  (implies (cst-matchp abnf::cst "safe-ascii")
           (equal (abnf::tree-kind abnf::cst)
                  :nonleaf)))

Theorem: cst-safe-nonascii-nonleaf

(defthm cst-safe-nonascii-nonleaf
  (implies (cst-matchp abnf::cst "safe-nonascii")
           (equal (abnf::tree-kind abnf::cst)
                  :nonleaf)))

Theorem: cst-character-nonleaf

(defthm cst-character-nonleaf
  (implies (cst-matchp abnf::cst "character")
           (equal (abnf::tree-kind abnf::cst)
                  :nonleaf)))

Theorem: cst-escaped-lf-nonleaf

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

Theorem: cst-plain-ws-nonleaf

(defthm cst-plain-ws-nonleaf
  (implies (cst-matchp abnf::cst "plain-ws")
           (equal (abnf::tree-kind abnf::cst)
                  :nonleaf)))

Theorem: cst-ws-nonleaf

(defthm cst-ws-nonleaf
  (implies (cst-matchp abnf::cst "ws")
           (equal (abnf::tree-kind abnf::cst)
                  :nonleaf)))

Theorem: cst-comment-nonleaf

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

Theorem: cst-line-comment-nonleaf

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

Theorem: cst-not-lf-or-cr-nonleaf

(defthm cst-not-lf-or-cr-nonleaf
  (implies (cst-matchp abnf::cst "not-lf-or-cr")
           (equal (abnf::tree-kind abnf::cst)
                  :nonleaf)))

Theorem: cst-block-comment-nonleaf

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

Theorem: cst-rest-of-block-comment-nonleaf

(defthm cst-rest-of-block-comment-nonleaf
  (implies (cst-matchp abnf::cst "rest-of-block-comment")
           (equal (abnf::tree-kind abnf::cst)
                  :nonleaf)))

Theorem: cst-not-star-nonleaf

(defthm cst-not-star-nonleaf
  (implies (cst-matchp abnf::cst "not-star")
           (equal (abnf::tree-kind abnf::cst)
                  :nonleaf)))

Theorem: cst-rest-of-block-comment-after-star-nonleaf

(defthm cst-rest-of-block-comment-after-star-nonleaf
  (implies (cst-matchp abnf::cst
                       "rest-of-block-comment-after-star")
           (equal (abnf::tree-kind abnf::cst)
                  :nonleaf)))

Theorem: cst-not-star-or-slash-nonleaf

(defthm cst-not-star-or-slash-nonleaf
  (implies (cst-matchp abnf::cst "not-star-or-slash")
           (equal (abnf::tree-kind abnf::cst)
                  :nonleaf)))

Theorem: cst-cws-nonleaf

(defthm cst-cws-nonleaf
  (implies (cst-matchp abnf::cst "cws")
           (equal (abnf::tree-kind abnf::cst)
                  :nonleaf)))

Theorem: cst-uppercase-letter-nonleaf

(defthm cst-uppercase-letter-nonleaf
  (implies (cst-matchp abnf::cst "uppercase-letter")
           (equal (abnf::tree-kind abnf::cst)
                  :nonleaf)))

Theorem: cst-lowercase-letter-nonleaf

(defthm cst-lowercase-letter-nonleaf
  (implies (cst-matchp abnf::cst "lowercase-letter")
           (equal (abnf::tree-kind abnf::cst)
                  :nonleaf)))

Theorem: cst-letter-nonleaf

(defthm cst-letter-nonleaf
  (implies (cst-matchp abnf::cst "letter")
           (equal (abnf::tree-kind abnf::cst)
                  :nonleaf)))

Theorem: cst-digit-nonleaf

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

Theorem: cst-hex-digit-nonleaf

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

Theorem: cst-identifier-nonleaf

(defthm cst-identifier-nonleaf
  (implies (cst-matchp abnf::cst "identifier")
           (equal (abnf::tree-kind abnf::cst)
                  :nonleaf)))

Theorem: cst-program-id-nonleaf

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

Theorem: cst-locator-nonleaf

(defthm cst-locator-nonleaf
  (implies (cst-matchp abnf::cst "locator")
           (equal (abnf::tree-kind abnf::cst)
                  :nonleaf)))

Theorem: cst-register-nonleaf

(defthm cst-register-nonleaf
  (implies (cst-matchp abnf::cst "register")
           (equal (abnf::tree-kind abnf::cst)
                  :nonleaf)))

Theorem: cst-register-access-nonleaf

(defthm cst-register-access-nonleaf
  (implies (cst-matchp abnf::cst "register-access")
           (equal (abnf::tree-kind abnf::cst)
                  :nonleaf)))

Theorem: cst-signed-literal-nonleaf

(defthm cst-signed-literal-nonleaf
  (implies (cst-matchp abnf::cst "signed-literal")
           (equal (abnf::tree-kind abnf::cst)
                  :nonleaf)))

Theorem: cst-unsigned-literal-nonleaf

(defthm cst-unsigned-literal-nonleaf
  (implies (cst-matchp abnf::cst "unsigned-literal")
           (equal (abnf::tree-kind abnf::cst)
                  :nonleaf)))

Theorem: cst-integer-literal-nonleaf

(defthm cst-integer-literal-nonleaf
  (implies (cst-matchp abnf::cst "integer-literal")
           (equal (abnf::tree-kind abnf::cst)
                  :nonleaf)))

Theorem: cst-field-literal-nonleaf

(defthm cst-field-literal-nonleaf
  (implies (cst-matchp abnf::cst "field-literal")
           (equal (abnf::tree-kind abnf::cst)
                  :nonleaf)))

Theorem: cst-group-literal-nonleaf

(defthm cst-group-literal-nonleaf
  (implies (cst-matchp abnf::cst "group-literal")
           (equal (abnf::tree-kind abnf::cst)
                  :nonleaf)))

Theorem: cst-scalar-literal-nonleaf

(defthm cst-scalar-literal-nonleaf
  (implies (cst-matchp abnf::cst "scalar-literal")
           (equal (abnf::tree-kind abnf::cst)
                  :nonleaf)))

Theorem: cst-arithmetic-literal-nonleaf

(defthm cst-arithmetic-literal-nonleaf
  (implies (cst-matchp abnf::cst "arithmetic-literal")
           (equal (abnf::tree-kind abnf::cst)
                  :nonleaf)))

Theorem: cst-address-literal-nonleaf

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

Theorem: cst-address-char-nonleaf

(defthm cst-address-char-nonleaf
  (implies (cst-matchp abnf::cst "address-char")
           (equal (abnf::tree-kind abnf::cst)
                  :nonleaf)))

Theorem: cst-boolean-literal-nonleaf

(defthm cst-boolean-literal-nonleaf
  (implies (cst-matchp abnf::cst "boolean-literal")
           (equal (abnf::tree-kind abnf::cst)
                  :nonleaf)))

Theorem: cst-string-literal-nonleaf

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

Theorem: cst-string-element-nonleaf

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

Theorem: cst-not-dq-or-backslash-nonleaf

(defthm cst-not-dq-or-backslash-nonleaf
  (implies (cst-matchp abnf::cst "not-dq-or-backslash")
           (equal (abnf::tree-kind abnf::cst)
                  :nonleaf)))

Theorem: cst-escaped-char-nonleaf

(defthm cst-escaped-char-nonleaf
  (implies (cst-matchp abnf::cst "escaped-char")
           (equal (abnf::tree-kind abnf::cst)
                  :nonleaf)))

Theorem: cst-escaped-ws-nonleaf

(defthm cst-escaped-ws-nonleaf
  (implies (cst-matchp abnf::cst "escaped-ws")
           (equal (abnf::tree-kind abnf::cst)
                  :nonleaf)))

Theorem: cst-literal-nonleaf

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

Theorem: cst-operand-nonleaf

(defthm cst-operand-nonleaf
  (implies (cst-matchp abnf::cst "operand")
           (equal (abnf::tree-kind abnf::cst)
                  :nonleaf)))

Theorem: cst-unsigned-type-nonleaf

(defthm cst-unsigned-type-nonleaf
  (implies (cst-matchp abnf::cst "unsigned-type")
           (equal (abnf::tree-kind abnf::cst)
                  :nonleaf)))

Theorem: cst-signed-type-nonleaf

(defthm cst-signed-type-nonleaf
  (implies (cst-matchp abnf::cst "signed-type")
           (equal (abnf::tree-kind abnf::cst)
                  :nonleaf)))

Theorem: cst-integer-type-nonleaf

(defthm cst-integer-type-nonleaf
  (implies (cst-matchp abnf::cst "integer-type")
           (equal (abnf::tree-kind abnf::cst)
                  :nonleaf)))

Theorem: cst-field-type-nonleaf

(defthm cst-field-type-nonleaf
  (implies (cst-matchp abnf::cst "field-type")
           (equal (abnf::tree-kind abnf::cst)
                  :nonleaf)))

Theorem: cst-group-type-nonleaf

(defthm cst-group-type-nonleaf
  (implies (cst-matchp abnf::cst "group-type")
           (equal (abnf::tree-kind abnf::cst)
                  :nonleaf)))

Theorem: cst-scalar-type-nonleaf

(defthm cst-scalar-type-nonleaf
  (implies (cst-matchp abnf::cst "scalar-type")
           (equal (abnf::tree-kind abnf::cst)
                  :nonleaf)))

Theorem: cst-arithmetic-type-nonleaf

(defthm cst-arithmetic-type-nonleaf
  (implies (cst-matchp abnf::cst "arithmetic-type")
           (equal (abnf::tree-kind abnf::cst)
                  :nonleaf)))

Theorem: cst-address-type-nonleaf

(defthm cst-address-type-nonleaf
  (implies (cst-matchp abnf::cst "address-type")
           (equal (abnf::tree-kind abnf::cst)
                  :nonleaf)))

Theorem: cst-boolean-type-nonleaf

(defthm cst-boolean-type-nonleaf
  (implies (cst-matchp abnf::cst "boolean-type")
           (equal (abnf::tree-kind abnf::cst)
                  :nonleaf)))

Theorem: cst-string-type-nonleaf

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

Theorem: cst-literal-type-nonleaf

(defthm cst-literal-type-nonleaf
  (implies (cst-matchp abnf::cst "literal-type")
           (equal (abnf::tree-kind abnf::cst)
                  :nonleaf)))

Theorem: cst-plaintext-type-nonleaf

(defthm cst-plaintext-type-nonleaf
  (implies (cst-matchp abnf::cst "plaintext-type")
           (equal (abnf::tree-kind abnf::cst)
                  :nonleaf)))

Theorem: cst-value-type-nonleaf

(defthm cst-value-type-nonleaf
  (implies (cst-matchp abnf::cst "value-type")
           (equal (abnf::tree-kind abnf::cst)
                  :nonleaf)))

Theorem: cst-finalize-type-nonleaf

(defthm cst-finalize-type-nonleaf
  (implies (cst-matchp abnf::cst "finalize-type")
           (equal (abnf::tree-kind abnf::cst)
                  :nonleaf)))

Theorem: cst-entry-type-nonleaf

(defthm cst-entry-type-nonleaf
  (implies (cst-matchp abnf::cst "entry-type")
           (equal (abnf::tree-kind abnf::cst)
                  :nonleaf)))

Theorem: cst-register-type-nonleaf

(defthm cst-register-type-nonleaf
  (implies (cst-matchp abnf::cst "register-type")
           (equal (abnf::tree-kind abnf::cst)
                  :nonleaf)))

Theorem: cst-import-nonleaf

(defthm cst-import-nonleaf
  (implies (cst-matchp abnf::cst "import")
           (equal (abnf::tree-kind abnf::cst)
                  :nonleaf)))

Theorem: cst-mapping-nonleaf

(defthm cst-mapping-nonleaf
  (implies (cst-matchp abnf::cst "mapping")
           (equal (abnf::tree-kind abnf::cst)
                  :nonleaf)))

Theorem: cst-mapping-key-nonleaf

(defthm cst-mapping-key-nonleaf
  (implies (cst-matchp abnf::cst "mapping-key")
           (equal (abnf::tree-kind abnf::cst)
                  :nonleaf)))

Theorem: cst-mapping-value-nonleaf

(defthm cst-mapping-value-nonleaf
  (implies (cst-matchp abnf::cst "mapping-value")
           (equal (abnf::tree-kind abnf::cst)
                  :nonleaf)))

Theorem: cst-struct-nonleaf

(defthm cst-struct-nonleaf
  (implies (cst-matchp abnf::cst "struct")
           (equal (abnf::tree-kind abnf::cst)
                  :nonleaf)))

Theorem: cst-tuple-nonleaf

(defthm cst-tuple-nonleaf
  (implies (cst-matchp abnf::cst "tuple")
           (equal (abnf::tree-kind abnf::cst)
                  :nonleaf)))

Theorem: cst-record-nonleaf

(defthm cst-record-nonleaf
  (implies (cst-matchp abnf::cst "record")
           (equal (abnf::tree-kind abnf::cst)
                  :nonleaf)))

Theorem: cst-entry-nonleaf

(defthm cst-entry-nonleaf
  (implies (cst-matchp abnf::cst "entry")
           (equal (abnf::tree-kind abnf::cst)
                  :nonleaf)))

Theorem: cst-unary-op-nonleaf

(defthm cst-unary-op-nonleaf
  (implies (cst-matchp abnf::cst "unary-op")
           (equal (abnf::tree-kind abnf::cst)
                  :nonleaf)))

Theorem: cst-binary-op-nonleaf

(defthm cst-binary-op-nonleaf
  (implies (cst-matchp abnf::cst "binary-op")
           (equal (abnf::tree-kind abnf::cst)
                  :nonleaf)))

Theorem: cst-ternary-op-nonleaf

(defthm cst-ternary-op-nonleaf
  (implies (cst-matchp abnf::cst "ternary-op")
           (equal (abnf::tree-kind abnf::cst)
                  :nonleaf)))

Theorem: cst-is-op-nonleaf

(defthm cst-is-op-nonleaf
  (implies (cst-matchp abnf::cst "is-op")
           (equal (abnf::tree-kind abnf::cst)
                  :nonleaf)))

Theorem: cst-assert-op-nonleaf

(defthm cst-assert-op-nonleaf
  (implies (cst-matchp abnf::cst "assert-op")
           (equal (abnf::tree-kind abnf::cst)
                  :nonleaf)))

Theorem: cst-commit-op-nonleaf

(defthm cst-commit-op-nonleaf
  (implies (cst-matchp abnf::cst "commit-op")
           (equal (abnf::tree-kind abnf::cst)
                  :nonleaf)))

Theorem: cst-hash-op-nonleaf

(defthm cst-hash-op-nonleaf
  (implies (cst-matchp abnf::cst "hash-op")
           (equal (abnf::tree-kind abnf::cst)
                  :nonleaf)))

Theorem: cst-unary-nonleaf

(defthm cst-unary-nonleaf
  (implies (cst-matchp abnf::cst "unary")
           (equal (abnf::tree-kind abnf::cst)
                  :nonleaf)))

Theorem: cst-binary-nonleaf

(defthm cst-binary-nonleaf
  (implies (cst-matchp abnf::cst "binary")
           (equal (abnf::tree-kind abnf::cst)
                  :nonleaf)))

Theorem: cst-ternary-nonleaf

(defthm cst-ternary-nonleaf
  (implies (cst-matchp abnf::cst "ternary")
           (equal (abnf::tree-kind abnf::cst)
                  :nonleaf)))

Theorem: cst-is-nonleaf

(defthm cst-is-nonleaf
  (implies (cst-matchp abnf::cst "is")
           (equal (abnf::tree-kind abnf::cst)
                  :nonleaf)))

Theorem: cst-assert-nonleaf

(defthm cst-assert-nonleaf
  (implies (cst-matchp abnf::cst "assert")
           (equal (abnf::tree-kind abnf::cst)
                  :nonleaf)))

Theorem: cst-commit-nonleaf

(defthm cst-commit-nonleaf
  (implies (cst-matchp abnf::cst "commit")
           (equal (abnf::tree-kind abnf::cst)
                  :nonleaf)))

Theorem: cst-hash-nonleaf

(defthm cst-hash-nonleaf
  (implies (cst-matchp abnf::cst "hash")
           (equal (abnf::tree-kind abnf::cst)
                  :nonleaf)))

Theorem: cst-cast-nonleaf

(defthm cst-cast-nonleaf
  (implies (cst-matchp abnf::cst "cast")
           (equal (abnf::tree-kind abnf::cst)
                  :nonleaf)))

Theorem: cst-call-nonleaf

(defthm cst-call-nonleaf
  (implies (cst-matchp abnf::cst "call")
           (equal (abnf::tree-kind abnf::cst)
                  :nonleaf)))

Theorem: cst-instruction-nonleaf

(defthm cst-instruction-nonleaf
  (implies (cst-matchp abnf::cst "instruction")
           (equal (abnf::tree-kind abnf::cst)
                  :nonleaf)))

Theorem: cst-decrement-nonleaf

(defthm cst-decrement-nonleaf
  (implies (cst-matchp abnf::cst "decrement")
           (equal (abnf::tree-kind abnf::cst)
                  :nonleaf)))

Theorem: cst-increment-nonleaf

(defthm cst-increment-nonleaf
  (implies (cst-matchp abnf::cst "increment")
           (equal (abnf::tree-kind abnf::cst)
                  :nonleaf)))

Theorem: cst-command-nonleaf

(defthm cst-command-nonleaf
  (implies (cst-matchp abnf::cst "command")
           (equal (abnf::tree-kind abnf::cst)
                  :nonleaf)))

Theorem: cst-finalize-command-nonleaf

(defthm cst-finalize-command-nonleaf
  (implies (cst-matchp abnf::cst "finalize-command")
           (equal (abnf::tree-kind abnf::cst)
                  :nonleaf)))

Theorem: cst-function-nonleaf

(defthm cst-function-nonleaf
  (implies (cst-matchp abnf::cst "function")
           (equal (abnf::tree-kind abnf::cst)
                  :nonleaf)))

Theorem: cst-function-input-nonleaf

(defthm cst-function-input-nonleaf
  (implies (cst-matchp abnf::cst "function-input")
           (equal (abnf::tree-kind abnf::cst)
                  :nonleaf)))

Theorem: cst-function-output-nonleaf

(defthm cst-function-output-nonleaf
  (implies (cst-matchp abnf::cst "function-output")
           (equal (abnf::tree-kind abnf::cst)
                  :nonleaf)))

Theorem: cst-transition-nonleaf

(defthm cst-transition-nonleaf
  (implies (cst-matchp abnf::cst "transition")
           (equal (abnf::tree-kind abnf::cst)
                  :nonleaf)))

Theorem: cst-transition-input-nonleaf

(defthm cst-transition-input-nonleaf
  (implies (cst-matchp abnf::cst "transition-input")
           (equal (abnf::tree-kind abnf::cst)
                  :nonleaf)))

Theorem: cst-transition-output-nonleaf

(defthm cst-transition-output-nonleaf
  (implies (cst-matchp abnf::cst "transition-output")
           (equal (abnf::tree-kind abnf::cst)
                  :nonleaf)))

Theorem: cst-finalize-nonleaf

(defthm cst-finalize-nonleaf
  (implies (cst-matchp abnf::cst "finalize")
           (equal (abnf::tree-kind abnf::cst)
                  :nonleaf)))

Theorem: cst-finalize-input-nonleaf

(defthm cst-finalize-input-nonleaf
  (implies (cst-matchp abnf::cst "finalize-input")
           (equal (abnf::tree-kind abnf::cst)
                  :nonleaf)))

Theorem: cst-finalize-output-nonleaf

(defthm cst-finalize-output-nonleaf
  (implies (cst-matchp abnf::cst "finalize-output")
           (equal (abnf::tree-kind abnf::cst)
                  :nonleaf)))

Theorem: cst-program-nonleaf

(defthm cst-program-nonleaf
  (implies (cst-matchp abnf::cst "program")
           (equal (abnf::tree-kind abnf::cst)
                  :nonleaf)))

Theorem: cst-ht-rulename

(defthm cst-ht-rulename
  (implies (cst-matchp abnf::cst "ht")
           (equal (abnf::tree-nonleaf->rulename? abnf::cst)
                  (abnf::rulename "ht"))))

Theorem: cst-lf-rulename

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

Theorem: cst-cr-rulename

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

Theorem: cst-sp-rulename

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

Theorem: cst-dq-rulename

(defthm cst-dq-rulename
  (implies (cst-matchp abnf::cst "dq")
           (equal (abnf::tree-nonleaf->rulename? abnf::cst)
                  (abnf::rulename "dq"))))

Theorem: cst-visible-ascii-rulename

(defthm cst-visible-ascii-rulename
  (implies (cst-matchp abnf::cst "visible-ascii")
           (equal (abnf::tree-nonleaf->rulename? abnf::cst)
                  (abnf::rulename "visible-ascii"))))

Theorem: cst-safe-ascii-rulename

(defthm cst-safe-ascii-rulename
  (implies (cst-matchp abnf::cst "safe-ascii")
           (equal (abnf::tree-nonleaf->rulename? abnf::cst)
                  (abnf::rulename "safe-ascii"))))

Theorem: cst-safe-nonascii-rulename

(defthm cst-safe-nonascii-rulename
  (implies (cst-matchp abnf::cst "safe-nonascii")
           (equal (abnf::tree-nonleaf->rulename? abnf::cst)
                  (abnf::rulename "safe-nonascii"))))

Theorem: cst-character-rulename

(defthm cst-character-rulename
  (implies (cst-matchp abnf::cst "character")
           (equal (abnf::tree-nonleaf->rulename? abnf::cst)
                  (abnf::rulename "character"))))

Theorem: cst-escaped-lf-rulename

(defthm cst-escaped-lf-rulename
  (implies (cst-matchp abnf::cst "escaped-lf")
           (equal (abnf::tree-nonleaf->rulename? abnf::cst)
                  (abnf::rulename "escaped-lf"))))

Theorem: cst-plain-ws-rulename

(defthm cst-plain-ws-rulename
  (implies (cst-matchp abnf::cst "plain-ws")
           (equal (abnf::tree-nonleaf->rulename? abnf::cst)
                  (abnf::rulename "plain-ws"))))

Theorem: cst-ws-rulename

(defthm cst-ws-rulename
  (implies (cst-matchp abnf::cst "ws")
           (equal (abnf::tree-nonleaf->rulename? abnf::cst)
                  (abnf::rulename "ws"))))

Theorem: cst-comment-rulename

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

Theorem: cst-line-comment-rulename

(defthm cst-line-comment-rulename
  (implies (cst-matchp abnf::cst "line-comment")
           (equal (abnf::tree-nonleaf->rulename? abnf::cst)
                  (abnf::rulename "line-comment"))))

Theorem: cst-not-lf-or-cr-rulename

(defthm cst-not-lf-or-cr-rulename
  (implies (cst-matchp abnf::cst "not-lf-or-cr")
           (equal (abnf::tree-nonleaf->rulename? abnf::cst)
                  (abnf::rulename "not-lf-or-cr"))))

Theorem: cst-block-comment-rulename

(defthm cst-block-comment-rulename
  (implies (cst-matchp abnf::cst "block-comment")
           (equal (abnf::tree-nonleaf->rulename? abnf::cst)
                  (abnf::rulename "block-comment"))))

Theorem: cst-rest-of-block-comment-rulename

(defthm cst-rest-of-block-comment-rulename
  (implies (cst-matchp abnf::cst "rest-of-block-comment")
           (equal (abnf::tree-nonleaf->rulename? abnf::cst)
                  (abnf::rulename "rest-of-block-comment"))))

Theorem: cst-not-star-rulename

(defthm cst-not-star-rulename
  (implies (cst-matchp abnf::cst "not-star")
           (equal (abnf::tree-nonleaf->rulename? abnf::cst)
                  (abnf::rulename "not-star"))))

Theorem: cst-rest-of-block-comment-after-star-rulename

(defthm cst-rest-of-block-comment-after-star-rulename
  (implies
       (cst-matchp abnf::cst
                   "rest-of-block-comment-after-star")
       (equal (abnf::tree-nonleaf->rulename? abnf::cst)
              (abnf::rulename "rest-of-block-comment-after-star"))))

Theorem: cst-not-star-or-slash-rulename

(defthm cst-not-star-or-slash-rulename
  (implies (cst-matchp abnf::cst "not-star-or-slash")
           (equal (abnf::tree-nonleaf->rulename? abnf::cst)
                  (abnf::rulename "not-star-or-slash"))))

Theorem: cst-cws-rulename

(defthm cst-cws-rulename
  (implies (cst-matchp abnf::cst "cws")
           (equal (abnf::tree-nonleaf->rulename? abnf::cst)
                  (abnf::rulename "cws"))))

Theorem: cst-uppercase-letter-rulename

(defthm cst-uppercase-letter-rulename
  (implies (cst-matchp abnf::cst "uppercase-letter")
           (equal (abnf::tree-nonleaf->rulename? abnf::cst)
                  (abnf::rulename "uppercase-letter"))))

Theorem: cst-lowercase-letter-rulename

(defthm cst-lowercase-letter-rulename
  (implies (cst-matchp abnf::cst "lowercase-letter")
           (equal (abnf::tree-nonleaf->rulename? abnf::cst)
                  (abnf::rulename "lowercase-letter"))))

Theorem: cst-letter-rulename

(defthm cst-letter-rulename
  (implies (cst-matchp abnf::cst "letter")
           (equal (abnf::tree-nonleaf->rulename? abnf::cst)
                  (abnf::rulename "letter"))))

Theorem: cst-digit-rulename

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

Theorem: cst-hex-digit-rulename

(defthm cst-hex-digit-rulename
  (implies (cst-matchp abnf::cst "hex-digit")
           (equal (abnf::tree-nonleaf->rulename? abnf::cst)
                  (abnf::rulename "hex-digit"))))

Theorem: cst-identifier-rulename

(defthm cst-identifier-rulename
  (implies (cst-matchp abnf::cst "identifier")
           (equal (abnf::tree-nonleaf->rulename? abnf::cst)
                  (abnf::rulename "identifier"))))

Theorem: cst-program-id-rulename

(defthm cst-program-id-rulename
  (implies (cst-matchp abnf::cst "program-id")
           (equal (abnf::tree-nonleaf->rulename? abnf::cst)
                  (abnf::rulename "program-id"))))

Theorem: cst-locator-rulename

(defthm cst-locator-rulename
  (implies (cst-matchp abnf::cst "locator")
           (equal (abnf::tree-nonleaf->rulename? abnf::cst)
                  (abnf::rulename "locator"))))

Theorem: cst-register-rulename

(defthm cst-register-rulename
  (implies (cst-matchp abnf::cst "register")
           (equal (abnf::tree-nonleaf->rulename? abnf::cst)
                  (abnf::rulename "register"))))

Theorem: cst-register-access-rulename

(defthm cst-register-access-rulename
  (implies (cst-matchp abnf::cst "register-access")
           (equal (abnf::tree-nonleaf->rulename? abnf::cst)
                  (abnf::rulename "register-access"))))

Theorem: cst-signed-literal-rulename

(defthm cst-signed-literal-rulename
  (implies (cst-matchp abnf::cst "signed-literal")
           (equal (abnf::tree-nonleaf->rulename? abnf::cst)
                  (abnf::rulename "signed-literal"))))

Theorem: cst-unsigned-literal-rulename

(defthm cst-unsigned-literal-rulename
  (implies (cst-matchp abnf::cst "unsigned-literal")
           (equal (abnf::tree-nonleaf->rulename? abnf::cst)
                  (abnf::rulename "unsigned-literal"))))

Theorem: cst-integer-literal-rulename

(defthm cst-integer-literal-rulename
  (implies (cst-matchp abnf::cst "integer-literal")
           (equal (abnf::tree-nonleaf->rulename? abnf::cst)
                  (abnf::rulename "integer-literal"))))

Theorem: cst-field-literal-rulename

(defthm cst-field-literal-rulename
  (implies (cst-matchp abnf::cst "field-literal")
           (equal (abnf::tree-nonleaf->rulename? abnf::cst)
                  (abnf::rulename "field-literal"))))

Theorem: cst-group-literal-rulename

(defthm cst-group-literal-rulename
  (implies (cst-matchp abnf::cst "group-literal")
           (equal (abnf::tree-nonleaf->rulename? abnf::cst)
                  (abnf::rulename "group-literal"))))

Theorem: cst-scalar-literal-rulename

(defthm cst-scalar-literal-rulename
  (implies (cst-matchp abnf::cst "scalar-literal")
           (equal (abnf::tree-nonleaf->rulename? abnf::cst)
                  (abnf::rulename "scalar-literal"))))

Theorem: cst-arithmetic-literal-rulename

(defthm cst-arithmetic-literal-rulename
  (implies (cst-matchp abnf::cst "arithmetic-literal")
           (equal (abnf::tree-nonleaf->rulename? abnf::cst)
                  (abnf::rulename "arithmetic-literal"))))

Theorem: cst-address-literal-rulename

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

Theorem: cst-address-char-rulename

(defthm cst-address-char-rulename
  (implies (cst-matchp abnf::cst "address-char")
           (equal (abnf::tree-nonleaf->rulename? abnf::cst)
                  (abnf::rulename "address-char"))))

Theorem: cst-boolean-literal-rulename

(defthm cst-boolean-literal-rulename
  (implies (cst-matchp abnf::cst "boolean-literal")
           (equal (abnf::tree-nonleaf->rulename? abnf::cst)
                  (abnf::rulename "boolean-literal"))))

Theorem: cst-string-literal-rulename

(defthm cst-string-literal-rulename
  (implies (cst-matchp abnf::cst "string-literal")
           (equal (abnf::tree-nonleaf->rulename? abnf::cst)
                  (abnf::rulename "string-literal"))))

Theorem: cst-string-element-rulename

(defthm cst-string-element-rulename
  (implies (cst-matchp abnf::cst "string-element")
           (equal (abnf::tree-nonleaf->rulename? abnf::cst)
                  (abnf::rulename "string-element"))))

Theorem: cst-not-dq-or-backslash-rulename

(defthm cst-not-dq-or-backslash-rulename
  (implies (cst-matchp abnf::cst "not-dq-or-backslash")
           (equal (abnf::tree-nonleaf->rulename? abnf::cst)
                  (abnf::rulename "not-dq-or-backslash"))))

Theorem: cst-escaped-char-rulename

(defthm cst-escaped-char-rulename
  (implies (cst-matchp abnf::cst "escaped-char")
           (equal (abnf::tree-nonleaf->rulename? abnf::cst)
                  (abnf::rulename "escaped-char"))))

Theorem: cst-escaped-ws-rulename

(defthm cst-escaped-ws-rulename
  (implies (cst-matchp abnf::cst "escaped-ws")
           (equal (abnf::tree-nonleaf->rulename? abnf::cst)
                  (abnf::rulename "escaped-ws"))))

Theorem: cst-literal-rulename

(defthm cst-literal-rulename
  (implies (cst-matchp abnf::cst "literal")
           (equal (abnf::tree-nonleaf->rulename? abnf::cst)
                  (abnf::rulename "literal"))))

Theorem: cst-operand-rulename

(defthm cst-operand-rulename
  (implies (cst-matchp abnf::cst "operand")
           (equal (abnf::tree-nonleaf->rulename? abnf::cst)
                  (abnf::rulename "operand"))))

Theorem: cst-unsigned-type-rulename

(defthm cst-unsigned-type-rulename
  (implies (cst-matchp abnf::cst "unsigned-type")
           (equal (abnf::tree-nonleaf->rulename? abnf::cst)
                  (abnf::rulename "unsigned-type"))))

Theorem: cst-signed-type-rulename

(defthm cst-signed-type-rulename
  (implies (cst-matchp abnf::cst "signed-type")
           (equal (abnf::tree-nonleaf->rulename? abnf::cst)
                  (abnf::rulename "signed-type"))))

Theorem: cst-integer-type-rulename

(defthm cst-integer-type-rulename
  (implies (cst-matchp abnf::cst "integer-type")
           (equal (abnf::tree-nonleaf->rulename? abnf::cst)
                  (abnf::rulename "integer-type"))))

Theorem: cst-field-type-rulename

(defthm cst-field-type-rulename
  (implies (cst-matchp abnf::cst "field-type")
           (equal (abnf::tree-nonleaf->rulename? abnf::cst)
                  (abnf::rulename "field-type"))))

Theorem: cst-group-type-rulename

(defthm cst-group-type-rulename
  (implies (cst-matchp abnf::cst "group-type")
           (equal (abnf::tree-nonleaf->rulename? abnf::cst)
                  (abnf::rulename "group-type"))))

Theorem: cst-scalar-type-rulename

(defthm cst-scalar-type-rulename
  (implies (cst-matchp abnf::cst "scalar-type")
           (equal (abnf::tree-nonleaf->rulename? abnf::cst)
                  (abnf::rulename "scalar-type"))))

Theorem: cst-arithmetic-type-rulename

(defthm cst-arithmetic-type-rulename
  (implies (cst-matchp abnf::cst "arithmetic-type")
           (equal (abnf::tree-nonleaf->rulename? abnf::cst)
                  (abnf::rulename "arithmetic-type"))))

Theorem: cst-address-type-rulename

(defthm cst-address-type-rulename
  (implies (cst-matchp abnf::cst "address-type")
           (equal (abnf::tree-nonleaf->rulename? abnf::cst)
                  (abnf::rulename "address-type"))))

Theorem: cst-boolean-type-rulename

(defthm cst-boolean-type-rulename
  (implies (cst-matchp abnf::cst "boolean-type")
           (equal (abnf::tree-nonleaf->rulename? abnf::cst)
                  (abnf::rulename "boolean-type"))))

Theorem: cst-string-type-rulename

(defthm cst-string-type-rulename
  (implies (cst-matchp abnf::cst "string-type")
           (equal (abnf::tree-nonleaf->rulename? abnf::cst)
                  (abnf::rulename "string-type"))))

Theorem: cst-literal-type-rulename

(defthm cst-literal-type-rulename
  (implies (cst-matchp abnf::cst "literal-type")
           (equal (abnf::tree-nonleaf->rulename? abnf::cst)
                  (abnf::rulename "literal-type"))))

Theorem: cst-plaintext-type-rulename

(defthm cst-plaintext-type-rulename
  (implies (cst-matchp abnf::cst "plaintext-type")
           (equal (abnf::tree-nonleaf->rulename? abnf::cst)
                  (abnf::rulename "plaintext-type"))))

Theorem: cst-value-type-rulename

(defthm cst-value-type-rulename
  (implies (cst-matchp abnf::cst "value-type")
           (equal (abnf::tree-nonleaf->rulename? abnf::cst)
                  (abnf::rulename "value-type"))))

Theorem: cst-finalize-type-rulename

(defthm cst-finalize-type-rulename
  (implies (cst-matchp abnf::cst "finalize-type")
           (equal (abnf::tree-nonleaf->rulename? abnf::cst)
                  (abnf::rulename "finalize-type"))))

Theorem: cst-entry-type-rulename

(defthm cst-entry-type-rulename
  (implies (cst-matchp abnf::cst "entry-type")
           (equal (abnf::tree-nonleaf->rulename? abnf::cst)
                  (abnf::rulename "entry-type"))))

Theorem: cst-register-type-rulename

(defthm cst-register-type-rulename
  (implies (cst-matchp abnf::cst "register-type")
           (equal (abnf::tree-nonleaf->rulename? abnf::cst)
                  (abnf::rulename "register-type"))))

Theorem: cst-import-rulename

(defthm cst-import-rulename
  (implies (cst-matchp abnf::cst "import")
           (equal (abnf::tree-nonleaf->rulename? abnf::cst)
                  (abnf::rulename "import"))))

Theorem: cst-mapping-rulename

(defthm cst-mapping-rulename
  (implies (cst-matchp abnf::cst "mapping")
           (equal (abnf::tree-nonleaf->rulename? abnf::cst)
                  (abnf::rulename "mapping"))))

Theorem: cst-mapping-key-rulename

(defthm cst-mapping-key-rulename
  (implies (cst-matchp abnf::cst "mapping-key")
           (equal (abnf::tree-nonleaf->rulename? abnf::cst)
                  (abnf::rulename "mapping-key"))))

Theorem: cst-mapping-value-rulename

(defthm cst-mapping-value-rulename
  (implies (cst-matchp abnf::cst "mapping-value")
           (equal (abnf::tree-nonleaf->rulename? abnf::cst)
                  (abnf::rulename "mapping-value"))))

Theorem: cst-struct-rulename

(defthm cst-struct-rulename
  (implies (cst-matchp abnf::cst "struct")
           (equal (abnf::tree-nonleaf->rulename? abnf::cst)
                  (abnf::rulename "struct"))))

Theorem: cst-tuple-rulename

(defthm cst-tuple-rulename
  (implies (cst-matchp abnf::cst "tuple")
           (equal (abnf::tree-nonleaf->rulename? abnf::cst)
                  (abnf::rulename "tuple"))))

Theorem: cst-record-rulename

(defthm cst-record-rulename
  (implies (cst-matchp abnf::cst "record")
           (equal (abnf::tree-nonleaf->rulename? abnf::cst)
                  (abnf::rulename "record"))))

Theorem: cst-entry-rulename

(defthm cst-entry-rulename
  (implies (cst-matchp abnf::cst "entry")
           (equal (abnf::tree-nonleaf->rulename? abnf::cst)
                  (abnf::rulename "entry"))))

Theorem: cst-unary-op-rulename

(defthm cst-unary-op-rulename
  (implies (cst-matchp abnf::cst "unary-op")
           (equal (abnf::tree-nonleaf->rulename? abnf::cst)
                  (abnf::rulename "unary-op"))))

Theorem: cst-binary-op-rulename

(defthm cst-binary-op-rulename
  (implies (cst-matchp abnf::cst "binary-op")
           (equal (abnf::tree-nonleaf->rulename? abnf::cst)
                  (abnf::rulename "binary-op"))))

Theorem: cst-ternary-op-rulename

(defthm cst-ternary-op-rulename
  (implies (cst-matchp abnf::cst "ternary-op")
           (equal (abnf::tree-nonleaf->rulename? abnf::cst)
                  (abnf::rulename "ternary-op"))))

Theorem: cst-is-op-rulename

(defthm cst-is-op-rulename
  (implies (cst-matchp abnf::cst "is-op")
           (equal (abnf::tree-nonleaf->rulename? abnf::cst)
                  (abnf::rulename "is-op"))))

Theorem: cst-assert-op-rulename

(defthm cst-assert-op-rulename
  (implies (cst-matchp abnf::cst "assert-op")
           (equal (abnf::tree-nonleaf->rulename? abnf::cst)
                  (abnf::rulename "assert-op"))))

Theorem: cst-commit-op-rulename

(defthm cst-commit-op-rulename
  (implies (cst-matchp abnf::cst "commit-op")
           (equal (abnf::tree-nonleaf->rulename? abnf::cst)
                  (abnf::rulename "commit-op"))))

Theorem: cst-hash-op-rulename

(defthm cst-hash-op-rulename
  (implies (cst-matchp abnf::cst "hash-op")
           (equal (abnf::tree-nonleaf->rulename? abnf::cst)
                  (abnf::rulename "hash-op"))))

Theorem: cst-unary-rulename

(defthm cst-unary-rulename
  (implies (cst-matchp abnf::cst "unary")
           (equal (abnf::tree-nonleaf->rulename? abnf::cst)
                  (abnf::rulename "unary"))))

Theorem: cst-binary-rulename

(defthm cst-binary-rulename
  (implies (cst-matchp abnf::cst "binary")
           (equal (abnf::tree-nonleaf->rulename? abnf::cst)
                  (abnf::rulename "binary"))))

Theorem: cst-ternary-rulename

(defthm cst-ternary-rulename
  (implies (cst-matchp abnf::cst "ternary")
           (equal (abnf::tree-nonleaf->rulename? abnf::cst)
                  (abnf::rulename "ternary"))))

Theorem: cst-is-rulename

(defthm cst-is-rulename
  (implies (cst-matchp abnf::cst "is")
           (equal (abnf::tree-nonleaf->rulename? abnf::cst)
                  (abnf::rulename "is"))))

Theorem: cst-assert-rulename

(defthm cst-assert-rulename
  (implies (cst-matchp abnf::cst "assert")
           (equal (abnf::tree-nonleaf->rulename? abnf::cst)
                  (abnf::rulename "assert"))))

Theorem: cst-commit-rulename

(defthm cst-commit-rulename
  (implies (cst-matchp abnf::cst "commit")
           (equal (abnf::tree-nonleaf->rulename? abnf::cst)
                  (abnf::rulename "commit"))))

Theorem: cst-hash-rulename

(defthm cst-hash-rulename
  (implies (cst-matchp abnf::cst "hash")
           (equal (abnf::tree-nonleaf->rulename? abnf::cst)
                  (abnf::rulename "hash"))))

Theorem: cst-cast-rulename

(defthm cst-cast-rulename
  (implies (cst-matchp abnf::cst "cast")
           (equal (abnf::tree-nonleaf->rulename? abnf::cst)
                  (abnf::rulename "cast"))))

Theorem: cst-call-rulename

(defthm cst-call-rulename
  (implies (cst-matchp abnf::cst "call")
           (equal (abnf::tree-nonleaf->rulename? abnf::cst)
                  (abnf::rulename "call"))))

Theorem: cst-instruction-rulename

(defthm cst-instruction-rulename
  (implies (cst-matchp abnf::cst "instruction")
           (equal (abnf::tree-nonleaf->rulename? abnf::cst)
                  (abnf::rulename "instruction"))))

Theorem: cst-decrement-rulename

(defthm cst-decrement-rulename
  (implies (cst-matchp abnf::cst "decrement")
           (equal (abnf::tree-nonleaf->rulename? abnf::cst)
                  (abnf::rulename "decrement"))))

Theorem: cst-increment-rulename

(defthm cst-increment-rulename
  (implies (cst-matchp abnf::cst "increment")
           (equal (abnf::tree-nonleaf->rulename? abnf::cst)
                  (abnf::rulename "increment"))))

Theorem: cst-command-rulename

(defthm cst-command-rulename
  (implies (cst-matchp abnf::cst "command")
           (equal (abnf::tree-nonleaf->rulename? abnf::cst)
                  (abnf::rulename "command"))))

Theorem: cst-finalize-command-rulename

(defthm cst-finalize-command-rulename
  (implies (cst-matchp abnf::cst "finalize-command")
           (equal (abnf::tree-nonleaf->rulename? abnf::cst)
                  (abnf::rulename "finalize-command"))))

Theorem: cst-function-rulename

(defthm cst-function-rulename
  (implies (cst-matchp abnf::cst "function")
           (equal (abnf::tree-nonleaf->rulename? abnf::cst)
                  (abnf::rulename "function"))))

Theorem: cst-function-input-rulename

(defthm cst-function-input-rulename
  (implies (cst-matchp abnf::cst "function-input")
           (equal (abnf::tree-nonleaf->rulename? abnf::cst)
                  (abnf::rulename "function-input"))))

Theorem: cst-function-output-rulename

(defthm cst-function-output-rulename
  (implies (cst-matchp abnf::cst "function-output")
           (equal (abnf::tree-nonleaf->rulename? abnf::cst)
                  (abnf::rulename "function-output"))))

Theorem: cst-transition-rulename

(defthm cst-transition-rulename
  (implies (cst-matchp abnf::cst "transition")
           (equal (abnf::tree-nonleaf->rulename? abnf::cst)
                  (abnf::rulename "transition"))))

Theorem: cst-transition-input-rulename

(defthm cst-transition-input-rulename
  (implies (cst-matchp abnf::cst "transition-input")
           (equal (abnf::tree-nonleaf->rulename? abnf::cst)
                  (abnf::rulename "transition-input"))))

Theorem: cst-transition-output-rulename

(defthm cst-transition-output-rulename
  (implies (cst-matchp abnf::cst "transition-output")
           (equal (abnf::tree-nonleaf->rulename? abnf::cst)
                  (abnf::rulename "transition-output"))))

Theorem: cst-finalize-rulename

(defthm cst-finalize-rulename
  (implies (cst-matchp abnf::cst "finalize")
           (equal (abnf::tree-nonleaf->rulename? abnf::cst)
                  (abnf::rulename "finalize"))))

Theorem: cst-finalize-input-rulename

(defthm cst-finalize-input-rulename
  (implies (cst-matchp abnf::cst "finalize-input")
           (equal (abnf::tree-nonleaf->rulename? abnf::cst)
                  (abnf::rulename "finalize-input"))))

Theorem: cst-finalize-output-rulename

(defthm cst-finalize-output-rulename
  (implies (cst-matchp abnf::cst "finalize-output")
           (equal (abnf::tree-nonleaf->rulename? abnf::cst)
                  (abnf::rulename "finalize-output"))))

Theorem: cst-program-rulename

(defthm cst-program-rulename
  (implies (cst-matchp abnf::cst "program")
           (equal (abnf::tree-nonleaf->rulename? abnf::cst)
                  (abnf::rulename "program"))))

Theorem: cst-ht-branches-match-alt

(defthm cst-ht-branches-match-alt
 (implies
  (cst-matchp abnf::cst "ht")
  (cst-list-list-alt-matchp (abnf::tree-nonleaf->branches abnf::cst)
                            "%x9")))

Theorem: cst-lf-branches-match-alt

(defthm cst-lf-branches-match-alt
 (implies
  (cst-matchp abnf::cst "lf")
  (cst-list-list-alt-matchp (abnf::tree-nonleaf->branches abnf::cst)
                            "%xA")))

Theorem: cst-cr-branches-match-alt

(defthm cst-cr-branches-match-alt
 (implies
  (cst-matchp abnf::cst "cr")
  (cst-list-list-alt-matchp (abnf::tree-nonleaf->branches abnf::cst)
                            "%xD")))

Theorem: cst-sp-branches-match-alt

(defthm cst-sp-branches-match-alt
 (implies
  (cst-matchp abnf::cst "sp")
  (cst-list-list-alt-matchp (abnf::tree-nonleaf->branches abnf::cst)
                            "%x20")))

Theorem: cst-dq-branches-match-alt

(defthm cst-dq-branches-match-alt
 (implies
  (cst-matchp abnf::cst "dq")
  (cst-list-list-alt-matchp (abnf::tree-nonleaf->branches abnf::cst)
                            "%x22")))

Theorem: cst-visible-ascii-branches-match-alt

(defthm cst-visible-ascii-branches-match-alt
 (implies
  (cst-matchp abnf::cst "visible-ascii")
  (cst-list-list-alt-matchp (abnf::tree-nonleaf->branches abnf::cst)
                            "%x21-7E")))

Theorem: cst-safe-ascii-branches-match-alt

(defthm cst-safe-ascii-branches-match-alt
 (implies
  (cst-matchp abnf::cst "safe-ascii")
  (cst-list-list-alt-matchp (abnf::tree-nonleaf->branches abnf::cst)
                            "ht / lf / cr / sp / visible-ascii")))

Theorem: cst-safe-nonascii-branches-match-alt

(defthm cst-safe-nonascii-branches-match-alt
 (implies
     (cst-matchp abnf::cst "safe-nonascii")
     (cst-list-list-alt-matchp
          (abnf::tree-nonleaf->branches abnf::cst)
          "%x80-2029 / %x202F-2065 / %x206A-D7FF / %xE000-10FFFF")))

Theorem: cst-character-branches-match-alt

(defthm cst-character-branches-match-alt
 (implies
  (cst-matchp abnf::cst "character")
  (cst-list-list-alt-matchp (abnf::tree-nonleaf->branches abnf::cst)
                            "safe-ascii / safe-nonascii")))

Theorem: cst-escaped-lf-branches-match-alt

(defthm cst-escaped-lf-branches-match-alt
 (implies
  (cst-matchp abnf::cst "escaped-lf")
  (cst-list-list-alt-matchp (abnf::tree-nonleaf->branches abnf::cst)
                            "\"\\\" lf")))

Theorem: cst-plain-ws-branches-match-alt

(defthm cst-plain-ws-branches-match-alt
 (implies
  (cst-matchp abnf::cst "plain-ws")
  (cst-list-list-alt-matchp (abnf::tree-nonleaf->branches abnf::cst)
                            "ht / sp / lf / cr")))

Theorem: cst-ws-branches-match-alt

(defthm cst-ws-branches-match-alt
 (implies
  (cst-matchp abnf::cst "ws")
  (cst-list-list-alt-matchp (abnf::tree-nonleaf->branches abnf::cst)
                            "*( 1*plain-ws / escaped-lf )")))

Theorem: cst-comment-branches-match-alt

(defthm cst-comment-branches-match-alt
 (implies
  (cst-matchp abnf::cst "comment")
  (cst-list-list-alt-matchp (abnf::tree-nonleaf->branches abnf::cst)
                            "line-comment / block-comment")))

Theorem: cst-line-comment-branches-match-alt

(defthm cst-line-comment-branches-match-alt
 (implies
  (cst-matchp abnf::cst "line-comment")
  (cst-list-list-alt-matchp (abnf::tree-nonleaf->branches abnf::cst)
                            "\"//\" *( escaped-lf / not-lf-or-cr )")))

Theorem: cst-not-lf-or-cr-branches-match-alt

(defthm cst-not-lf-or-cr-branches-match-alt
  (implies (cst-matchp abnf::cst "not-lf-or-cr")
           (cst-list-list-alt-matchp
                (abnf::tree-nonleaf->branches abnf::cst)
                "ht / sp / visible-ascii / safe-nonascii")))

Theorem: cst-block-comment-branches-match-alt

(defthm cst-block-comment-branches-match-alt
 (implies
  (cst-matchp abnf::cst "block-comment")
  (cst-list-list-alt-matchp (abnf::tree-nonleaf->branches abnf::cst)
                            "\"/*\" rest-of-block-comment")))

Theorem: cst-rest-of-block-comment-branches-match-alt

(defthm cst-rest-of-block-comment-branches-match-alt
 (implies
  (cst-matchp abnf::cst "rest-of-block-comment")
  (cst-list-list-alt-matchp
   (abnf::tree-nonleaf->branches abnf::cst)
   "\"*\" rest-of-block-comment-after-star / not-star rest-of-block-comment")))

Theorem: cst-not-star-branches-match-alt

(defthm cst-not-star-branches-match-alt
 (implies (cst-matchp abnf::cst "not-star")
          (cst-list-list-alt-matchp
               (abnf::tree-nonleaf->branches abnf::cst)
               "ht / lf / cr / %x20-29 / %x2B-7E / safe-nonascii")))

Theorem: cst-rest-of-block-comment-after-star-branches-match-alt

(defthm cst-rest-of-block-comment-after-star-branches-match-alt
 (implies
  (cst-matchp abnf::cst
              "rest-of-block-comment-after-star")
  (cst-list-list-alt-matchp
   (abnf::tree-nonleaf->branches abnf::cst)
   "\"/\" / \"*\" rest-of-block-comment-after-star / not-star-or-slash rest-of-block-comment")))

Theorem: cst-not-star-or-slash-branches-match-alt

(defthm cst-not-star-or-slash-branches-match-alt
 (implies
  (cst-matchp abnf::cst "not-star-or-slash")
  (cst-list-list-alt-matchp
     (abnf::tree-nonleaf->branches abnf::cst)
     "ht / lf / cr / %x20-29 / %x2B-2E / %x30-7E / safe-nonascii")))

Theorem: cst-cws-branches-match-alt

(defthm cst-cws-branches-match-alt
 (implies
  (cst-matchp abnf::cst "cws")
  (cst-list-list-alt-matchp (abnf::tree-nonleaf->branches abnf::cst)
                            "ws *( comment / ws )")))

Theorem: cst-uppercase-letter-branches-match-alt

(defthm cst-uppercase-letter-branches-match-alt
 (implies
  (cst-matchp abnf::cst "uppercase-letter")
  (cst-list-list-alt-matchp (abnf::tree-nonleaf->branches abnf::cst)
                            "%x41-5A")))

Theorem: cst-lowercase-letter-branches-match-alt

(defthm cst-lowercase-letter-branches-match-alt
 (implies
  (cst-matchp abnf::cst "lowercase-letter")
  (cst-list-list-alt-matchp (abnf::tree-nonleaf->branches abnf::cst)
                            "%x61-7A")))

Theorem: cst-letter-branches-match-alt

(defthm cst-letter-branches-match-alt
 (implies
  (cst-matchp abnf::cst "letter")
  (cst-list-list-alt-matchp (abnf::tree-nonleaf->branches abnf::cst)
                            "uppercase-letter / lowercase-letter")))

Theorem: cst-digit-branches-match-alt

(defthm cst-digit-branches-match-alt
 (implies
  (cst-matchp abnf::cst "digit")
  (cst-list-list-alt-matchp (abnf::tree-nonleaf->branches abnf::cst)
                            "%x30-39")))

Theorem: cst-hex-digit-branches-match-alt

(defthm cst-hex-digit-branches-match-alt
  (implies (cst-matchp abnf::cst "hex-digit")
           (cst-list-list-alt-matchp
                (abnf::tree-nonleaf->branches abnf::cst)
                "digit / \"a\" / \"b\" / \"c\" / \"d\" / \"e\" / \"f\"")))

Theorem: cst-identifier-branches-match-alt

(defthm cst-identifier-branches-match-alt
 (implies
  (cst-matchp abnf::cst "identifier")
  (cst-list-list-alt-matchp (abnf::tree-nonleaf->branches abnf::cst)
                            "letter *( letter / digit / \"_\" )")))

Theorem: cst-program-id-branches-match-alt

(defthm cst-program-id-branches-match-alt
 (implies
  (cst-matchp abnf::cst "program-id")
  (cst-list-list-alt-matchp (abnf::tree-nonleaf->branches abnf::cst)
                            "identifier \".\" identifier")))

Theorem: cst-locator-branches-match-alt

(defthm cst-locator-branches-match-alt
 (implies
  (cst-matchp abnf::cst "locator")
  (cst-list-list-alt-matchp (abnf::tree-nonleaf->branches abnf::cst)
                            "program-id \"/\" identifier")))

Theorem: cst-register-branches-match-alt

(defthm cst-register-branches-match-alt
 (implies
  (cst-matchp abnf::cst "register")
  (cst-list-list-alt-matchp (abnf::tree-nonleaf->branches abnf::cst)
                            "%s\"r\" 1*digit")))

Theorem: cst-register-access-branches-match-alt

(defthm cst-register-access-branches-match-alt
 (implies
  (cst-matchp abnf::cst "register-access")
  (cst-list-list-alt-matchp (abnf::tree-nonleaf->branches abnf::cst)
                            "register *( \".\" identifier )")))

Theorem: cst-signed-literal-branches-match-alt

(defthm cst-signed-literal-branches-match-alt
  (implies (cst-matchp abnf::cst "signed-literal")
           (cst-list-list-alt-matchp
                (abnf::tree-nonleaf->branches abnf::cst)
                "[ \"-\" ] 1*( digit *\"_\" ) signed-type")))

Theorem: cst-unsigned-literal-branches-match-alt

(defthm cst-unsigned-literal-branches-match-alt
  (implies (cst-matchp abnf::cst "unsigned-literal")
           (cst-list-list-alt-matchp
                (abnf::tree-nonleaf->branches abnf::cst)
                "[ \"-\" ] 1*( digit *\"_\" ) unsigned-type")))

Theorem: cst-integer-literal-branches-match-alt

(defthm cst-integer-literal-branches-match-alt
 (implies
  (cst-matchp abnf::cst "integer-literal")
  (cst-list-list-alt-matchp (abnf::tree-nonleaf->branches abnf::cst)
                            "signed-literal / unsigned-literal")))

Theorem: cst-field-literal-branches-match-alt

(defthm cst-field-literal-branches-match-alt
 (implies
  (cst-matchp abnf::cst "field-literal")
  (cst-list-list-alt-matchp (abnf::tree-nonleaf->branches abnf::cst)
                            "[ \"-\" ] 1*( digit *\"_\" ) field-type")))

Theorem: cst-group-literal-branches-match-alt

(defthm cst-group-literal-branches-match-alt
 (implies
  (cst-matchp abnf::cst "group-literal")
  (cst-list-list-alt-matchp (abnf::tree-nonleaf->branches abnf::cst)
                            "[ \"-\" ] 1*( digit *\"_\" ) group-type")))

Theorem: cst-scalar-literal-branches-match-alt

(defthm cst-scalar-literal-branches-match-alt
  (implies (cst-matchp abnf::cst "scalar-literal")
           (cst-list-list-alt-matchp
                (abnf::tree-nonleaf->branches abnf::cst)
                "[ \"-\" ] 1*( digit *\"_\" ) scalar-type")))

Theorem: cst-arithmetic-literal-branches-match-alt

(defthm cst-arithmetic-literal-branches-match-alt
 (implies
  (cst-matchp abnf::cst "arithmetic-literal")
  (cst-list-list-alt-matchp
   (abnf::tree-nonleaf->branches abnf::cst)
   "integer-literal / field-literal / group-literal / scalar-literal")))

Theorem: cst-address-literal-branches-match-alt

(defthm cst-address-literal-branches-match-alt
 (implies
  (cst-matchp abnf::cst "address-literal")
  (cst-list-list-alt-matchp (abnf::tree-nonleaf->branches abnf::cst)
                            "%s\"aleo1\" 1*( address-char *\"_\" )")))

Theorem: cst-address-char-branches-match-alt

(defthm cst-address-char-branches-match-alt
 (implies
  (cst-matchp abnf::cst "address-char")
  (cst-list-list-alt-matchp
   (abnf::tree-nonleaf->branches abnf::cst)
   "\"0\" / \"2\" / \"3\" / \"4\" / \"5\" / \"6\" / \"7\" / \"8\" / \"9\" / %s\"a\" / %s\"c\" / %s\"d\" / %s\"e\" / %s\"f\" / %s\"g\" / %s\"h\" / %s\"j\" / %s\"k\" / %s\"l\" / %s\"m\" / %s\"n\" / %s\"p\" / %s\"q\" / %s\"r\" / %s\"s\" / %s\"t\" / %s\"u\" / %s\"v\" / %s\"w\" / %s\"x\" / %s\"y\" / %s\"z\"")))

Theorem: cst-boolean-literal-branches-match-alt

(defthm cst-boolean-literal-branches-match-alt
 (implies
  (cst-matchp abnf::cst "boolean-literal")
  (cst-list-list-alt-matchp (abnf::tree-nonleaf->branches abnf::cst)
                            "%s\"true\" / %s\"false\"")))

Theorem: cst-string-literal-branches-match-alt

(defthm cst-string-literal-branches-match-alt
 (implies
  (cst-matchp abnf::cst "string-literal")
  (cst-list-list-alt-matchp (abnf::tree-nonleaf->branches abnf::cst)
                            "dq *string-element dq")))

Theorem: cst-string-element-branches-match-alt

(defthm cst-string-element-branches-match-alt
  (implies (cst-matchp abnf::cst "string-element")
           (cst-list-list-alt-matchp
                (abnf::tree-nonleaf->branches abnf::cst)
                "not-dq-or-backslash / escaped-char / escaped-ws")))

Theorem: cst-not-dq-or-backslash-branches-match-alt

(defthm cst-not-dq-or-backslash-branches-match-alt
 (implies
  (cst-matchp abnf::cst "not-dq-or-backslash")
  (cst-list-list-alt-matchp
     (abnf::tree-nonleaf->branches abnf::cst)
     "ht / lf / cr / %x20-21 / %x23-5B / %x5D-7E / safe-nonascii")))

Theorem: cst-escaped-char-branches-match-alt

(defthm cst-escaped-char-branches-match-alt
 (implies
  (cst-matchp abnf::cst "escaped-char")
  (cst-list-list-alt-matchp
   (abnf::tree-nonleaf->branches abnf::cst)
   "\"\\\" ( dq / \"\\\" / \"/\" / %s\"n\" / %s\"r\" / %s\"t\" / %s\"b\" / %s\"f\" / %s\"u\" \"{\" 1*6hex-digit \"}\" )")))

Theorem: cst-escaped-ws-branches-match-alt

(defthm cst-escaped-ws-branches-match-alt
 (implies
  (cst-matchp abnf::cst "escaped-ws")
  (cst-list-list-alt-matchp (abnf::tree-nonleaf->branches abnf::cst)
                            "\"\\\" 1*plain-ws")))

Theorem: cst-literal-branches-match-alt

(defthm cst-literal-branches-match-alt
 (implies
  (cst-matchp abnf::cst "literal")
  (cst-list-list-alt-matchp
   (abnf::tree-nonleaf->branches abnf::cst)
   "arithmetic-literal / address-literal / boolean-literal / string-literal")))

Theorem: cst-operand-branches-match-alt

(defthm cst-operand-branches-match-alt
 (implies
  (cst-matchp abnf::cst "operand")
  (cst-list-list-alt-matchp
       (abnf::tree-nonleaf->branches abnf::cst)
       "literal / register-access / %s\"self.caller\" / program-id")))

Theorem: cst-unsigned-type-branches-match-alt

(defthm cst-unsigned-type-branches-match-alt
  (implies (cst-matchp abnf::cst "unsigned-type")
           (cst-list-list-alt-matchp
                (abnf::tree-nonleaf->branches abnf::cst)
                "%s\"u8\" / %s\"u16\" / %s\"u32\" / %s\"u64\" / %s\"u128\"")))

Theorem: cst-signed-type-branches-match-alt

(defthm cst-signed-type-branches-match-alt
  (implies (cst-matchp abnf::cst "signed-type")
           (cst-list-list-alt-matchp
                (abnf::tree-nonleaf->branches abnf::cst)
                "%s\"i8\" / %s\"i16\" / %s\"i32\" / %s\"i64\" / %s\"i128\"")))

Theorem: cst-integer-type-branches-match-alt

(defthm cst-integer-type-branches-match-alt
 (implies
  (cst-matchp abnf::cst "integer-type")
  (cst-list-list-alt-matchp (abnf::tree-nonleaf->branches abnf::cst)
                            "unsigned-type / signed-type")))

Theorem: cst-field-type-branches-match-alt

(defthm cst-field-type-branches-match-alt
 (implies
  (cst-matchp abnf::cst "field-type")
  (cst-list-list-alt-matchp (abnf::tree-nonleaf->branches abnf::cst)
                            "%s\"field\"")))

Theorem: cst-group-type-branches-match-alt

(defthm cst-group-type-branches-match-alt
 (implies
  (cst-matchp abnf::cst "group-type")
  (cst-list-list-alt-matchp (abnf::tree-nonleaf->branches abnf::cst)
                            "%s\"group\"")))

Theorem: cst-scalar-type-branches-match-alt

(defthm cst-scalar-type-branches-match-alt
 (implies
  (cst-matchp abnf::cst "scalar-type")
  (cst-list-list-alt-matchp (abnf::tree-nonleaf->branches abnf::cst)
                            "%s\"scalar\"")))

Theorem: cst-arithmetic-type-branches-match-alt

(defthm cst-arithmetic-type-branches-match-alt
 (implies
      (cst-matchp abnf::cst "arithmetic-type")
      (cst-list-list-alt-matchp
           (abnf::tree-nonleaf->branches abnf::cst)
           "integer-type / field-type / group-type / scalar-type")))

Theorem: cst-address-type-branches-match-alt

(defthm cst-address-type-branches-match-alt
 (implies
  (cst-matchp abnf::cst "address-type")
  (cst-list-list-alt-matchp (abnf::tree-nonleaf->branches abnf::cst)
                            "%s\"address\"")))

Theorem: cst-boolean-type-branches-match-alt

(defthm cst-boolean-type-branches-match-alt
 (implies
  (cst-matchp abnf::cst "boolean-type")
  (cst-list-list-alt-matchp (abnf::tree-nonleaf->branches abnf::cst)
                            "%s\"boolean\"")))

Theorem: cst-string-type-branches-match-alt

(defthm cst-string-type-branches-match-alt
 (implies
  (cst-matchp abnf::cst "string-type")
  (cst-list-list-alt-matchp (abnf::tree-nonleaf->branches abnf::cst)
                            "%s\"string\"")))

Theorem: cst-literal-type-branches-match-alt

(defthm cst-literal-type-branches-match-alt
 (implies
  (cst-matchp abnf::cst "literal-type")
  (cst-list-list-alt-matchp
    (abnf::tree-nonleaf->branches abnf::cst)
    "arithmetic-type / address-type / boolean-type / string-type")))

Theorem: cst-plaintext-type-branches-match-alt

(defthm cst-plaintext-type-branches-match-alt
 (implies
  (cst-matchp abnf::cst "plaintext-type")
  (cst-list-list-alt-matchp (abnf::tree-nonleaf->branches abnf::cst)
                            "literal-type / identifier")))

Theorem: cst-value-type-branches-match-alt

(defthm cst-value-type-branches-match-alt
 (implies
  (cst-matchp abnf::cst "value-type")
  (cst-list-list-alt-matchp
   (abnf::tree-nonleaf->branches abnf::cst)
   "plaintext-type %s\".constant\" / plaintext-type %s\".public\" / plaintext-type %s\".private\" / identifier %s\".record\" / locator %s\".record\"")))

Theorem: cst-finalize-type-branches-match-alt

(defthm cst-finalize-type-branches-match-alt
 (implies
  (cst-matchp abnf::cst "finalize-type")
  (cst-list-list-alt-matchp
   (abnf::tree-nonleaf->branches abnf::cst)
   "plaintext-type %s\".public\" / identifier %s\".record\" / locator %s\".record\"")))

Theorem: cst-entry-type-branches-match-alt

(defthm cst-entry-type-branches-match-alt
 (implies
  (cst-matchp abnf::cst "entry-type")
  (cst-list-list-alt-matchp
   (abnf::tree-nonleaf->branches abnf::cst)
   "plaintext-type ( %s\".constant\" / %s\".public\" / %s\".private\" )")))

Theorem: cst-register-type-branches-match-alt

(defthm cst-register-type-branches-match-alt
 (implies
  (cst-matchp abnf::cst "register-type")
  (cst-list-list-alt-matchp
   (abnf::tree-nonleaf->branches abnf::cst)
   "locator %s\".record\" / identifier %s\".record\" / plaintext-type")))

Theorem: cst-import-branches-match-alt

(defthm cst-import-branches-match-alt
 (implies
  (cst-matchp abnf::cst "import")
  (cst-list-list-alt-matchp (abnf::tree-nonleaf->branches abnf::cst)
                            "cws %s\"import\" ws program-id ws \";\"")))

Theorem: cst-mapping-branches-match-alt

(defthm cst-mapping-branches-match-alt
 (implies
  (cst-matchp abnf::cst "mapping")
  (cst-list-list-alt-matchp
   (abnf::tree-nonleaf->branches abnf::cst)
   "cws %s\"mapping\" ws identifier ws \":\" mapping-key mapping-value")))

Theorem: cst-mapping-key-branches-match-alt

(defthm cst-mapping-key-branches-match-alt
 (implies
  (cst-matchp abnf::cst "mapping-key")
  (cst-list-list-alt-matchp
    (abnf::tree-nonleaf->branches abnf::cst)
    "cws %s\"key\" ws identifier ws %s\"as\" ws finalize-type ws \";\"")))

Theorem: cst-mapping-value-branches-match-alt

(defthm cst-mapping-value-branches-match-alt
 (implies
  (cst-matchp abnf::cst "mapping-value")
  (cst-list-list-alt-matchp
   (abnf::tree-nonleaf->branches abnf::cst)
   "cws %s\"value\" ws identifier ws %s\"as\" ws finalize-type ws \";\"")))

Theorem: cst-struct-branches-match-alt

(defthm cst-struct-branches-match-alt
  (implies (cst-matchp abnf::cst "struct")
           (cst-list-list-alt-matchp
                (abnf::tree-nonleaf->branches abnf::cst)
                "cws %s\"struct\" ws identifier ws \":\" 1*tuple")))

Theorem: cst-tuple-branches-match-alt

(defthm cst-tuple-branches-match-alt
  (implies
       (cst-matchp abnf::cst "tuple")
       (cst-list-list-alt-matchp
            (abnf::tree-nonleaf->branches abnf::cst)
            "cws identifier ws %s\"as\" ws plaintext-type ws \";\"")))

Theorem: cst-record-branches-match-alt

(defthm cst-record-branches-match-alt
 (implies
  (cst-matchp abnf::cst "record")
  (cst-list-list-alt-matchp
   (abnf::tree-nonleaf->branches abnf::cst)
   "cws %s\"record\" ws identifier ws \":\" cws %s\"owner\" ws %s\"as\" ws cws ( %s\"address.public\" / %s\"address.private\" ) ws \";\" cws %s\"gates\" ws %s\"as\" ws cws ( %s\"u64.public\" / %s\"u64.private\" ) ws \";\" *entry")))

Theorem: cst-entry-branches-match-alt

(defthm cst-entry-branches-match-alt
  (implies (cst-matchp abnf::cst "entry")
           (cst-list-list-alt-matchp
                (abnf::tree-nonleaf->branches abnf::cst)
                "cws identifier ws %s\"as\" ws entry-type ws \";\"")))

Theorem: cst-unary-op-branches-match-alt

(defthm cst-unary-op-branches-match-alt
 (implies
  (cst-matchp abnf::cst "unary-op")
  (cst-list-list-alt-matchp
   (abnf::tree-nonleaf->branches abnf::cst)
   "%s\"abs\" / %s\"abs.w\" / %s\"double\" / %s\"inv\" / %s\"neg\" / %s\"not\" / %s\"square\" / %s\"sqrt\"")))

Theorem: cst-binary-op-branches-match-alt

(defthm cst-binary-op-branches-match-alt
 (implies
  (cst-matchp abnf::cst "binary-op")
  (cst-list-list-alt-matchp
   (abnf::tree-nonleaf->branches abnf::cst)
   "%s\"add\" / %s\"add.w\" / %s\"sub\" / %s\"sub.w\" / %s\"mul\" / %s\"mul.w\" / %s\"div\" / %s\"div.w\" / %s\"rem\" / %s\"rem.w\" / %s\"mod\" / %s\"pow\" / %s\"pow.w\" / %s\"shl\" / %s\"shl.w\" / %s\"shr\" / %s\"shr.w\" / %s\"and\" / %s\"or\" / %s\"xor\" / %s\"nand\" / %s\"nor\" / %s\"gt\" / %s\"gte\" / %s\"lt\" / %s\"lte\"")))

Theorem: cst-ternary-op-branches-match-alt

(defthm cst-ternary-op-branches-match-alt
 (implies
  (cst-matchp abnf::cst "ternary-op")
  (cst-list-list-alt-matchp (abnf::tree-nonleaf->branches abnf::cst)
                            "%s\"ternary\"")))

Theorem: cst-is-op-branches-match-alt

(defthm cst-is-op-branches-match-alt
 (implies
  (cst-matchp abnf::cst "is-op")
  (cst-list-list-alt-matchp (abnf::tree-nonleaf->branches abnf::cst)
                            "%s\"is.eq\" / %s\"is.neq\"")))

Theorem: cst-assert-op-branches-match-alt

(defthm cst-assert-op-branches-match-alt
 (implies
  (cst-matchp abnf::cst "assert-op")
  (cst-list-list-alt-matchp (abnf::tree-nonleaf->branches abnf::cst)
                            "%s\"assert.eq\" / %s\"assert.neq\"")))

Theorem: cst-commit-op-branches-match-alt

(defthm cst-commit-op-branches-match-alt
 (implies
  (cst-matchp abnf::cst "commit-op")
  (cst-list-list-alt-matchp
   (abnf::tree-nonleaf->branches abnf::cst)
   "%s\"commit.bhp\" ( \"256\" / \"512\" / \"768\" / \"1024\" ) / %s\"commit.ped\" ( \"64\" / \"128\" )")))

Theorem: cst-hash-op-branches-match-alt

(defthm cst-hash-op-branches-match-alt
 (implies
  (cst-matchp abnf::cst "hash-op")
  (cst-list-list-alt-matchp
   (abnf::tree-nonleaf->branches abnf::cst)
   "%s\"hash.bhp\" ( \"256\" / \"512\" / \"768\" / \"1024\" ) / %s\"hash.ped\" ( \"64\" / \"128\" ) / %s\"hash.psd\" ( \"2\" / \"4\" / \"8\" )")))

Theorem: cst-unary-branches-match-alt

(defthm cst-unary-branches-match-alt
  (implies (cst-matchp abnf::cst "unary")
           (cst-list-list-alt-matchp
                (abnf::tree-nonleaf->branches abnf::cst)
                "unary-op ws ( operand ws ) %s\"into\" ws register")))

Theorem: cst-binary-branches-match-alt

(defthm cst-binary-branches-match-alt
  (implies
       (cst-matchp abnf::cst "binary")
       (cst-list-list-alt-matchp
            (abnf::tree-nonleaf->branches abnf::cst)
            "binary-op ws 2( operand ws ) %s\"into\" ws register")))

Theorem: cst-ternary-branches-match-alt

(defthm cst-ternary-branches-match-alt
  (implies
       (cst-matchp abnf::cst "ternary")
       (cst-list-list-alt-matchp
            (abnf::tree-nonleaf->branches abnf::cst)
            "ternary-op ws 3( operand ws ) %s\"into\" ws register")))

Theorem: cst-is-branches-match-alt

(defthm cst-is-branches-match-alt
  (implies
       (cst-matchp abnf::cst "is")
       (cst-list-list-alt-matchp
            (abnf::tree-nonleaf->branches abnf::cst)
            "is-op ws operand ws operand ws %s\"into\" ws register")))

Theorem: cst-assert-branches-match-alt

(defthm cst-assert-branches-match-alt
 (implies
  (cst-matchp abnf::cst "assert")
  (cst-list-list-alt-matchp (abnf::tree-nonleaf->branches abnf::cst)
                            "assert-op ws operand ws operand")))

Theorem: cst-commit-branches-match-alt

(defthm cst-commit-branches-match-alt
 (implies
   (cst-matchp abnf::cst "commit")
   (cst-list-list-alt-matchp
        (abnf::tree-nonleaf->branches abnf::cst)
        "commit-op ws operand ws operand ws %s\"into\" ws register")))

Theorem: cst-hash-branches-match-alt

(defthm cst-hash-branches-match-alt
  (implies (cst-matchp abnf::cst "hash")
           (cst-list-list-alt-matchp
                (abnf::tree-nonleaf->branches abnf::cst)
                "hash-op ws operand ws %s\"into\" ws register")))

Theorem: cst-cast-branches-match-alt

(defthm cst-cast-branches-match-alt
 (implies
  (cst-matchp abnf::cst "cast")
  (cst-list-list-alt-matchp
   (abnf::tree-nonleaf->branches abnf::cst)
   "%s\"cast\" 1*( ws operand ) ws %s\"into\" ws register ws %s\"as\" ws register-type")))

Theorem: cst-call-branches-match-alt

(defthm cst-call-branches-match-alt
 (implies
  (cst-matchp abnf::cst "call")
  (cst-list-list-alt-matchp
   (abnf::tree-nonleaf->branches abnf::cst)
   "%s\"call\" ws ( locator / identifier ) ws 1*( ws operand ) ws %s\"into\" ws 1*( ws register )")))

Theorem: cst-instruction-branches-match-alt

(defthm cst-instruction-branches-match-alt
 (implies
  (cst-matchp abnf::cst "instruction")
  (cst-list-list-alt-matchp
   (abnf::tree-nonleaf->branches abnf::cst)
   "cws ( unary / binary / ternary / is / assert / commit / hash / cast / call ) ws \";\"")))

Theorem: cst-decrement-branches-match-alt

(defthm cst-decrement-branches-match-alt
 (implies
  (cst-matchp abnf::cst "decrement")
  (cst-list-list-alt-matchp
   (abnf::tree-nonleaf->branches abnf::cst)
   "cws %s\"decrement\" ws identifier \"[\" ws operand ws \"]\" ws %s\"by\" ws operand ws \";\"")))

Theorem: cst-increment-branches-match-alt

(defthm cst-increment-branches-match-alt
 (implies
  (cst-matchp abnf::cst "increment")
  (cst-list-list-alt-matchp
   (abnf::tree-nonleaf->branches abnf::cst)
   "cws %s\"increment\" ws identifier \"[\" ws operand ws \"]\" ws %s\"by\" ws operand ws \";\"")))

Theorem: cst-command-branches-match-alt

(defthm cst-command-branches-match-alt
 (implies
  (cst-matchp abnf::cst "command")
  (cst-list-list-alt-matchp (abnf::tree-nonleaf->branches abnf::cst)
                            "decrement / increment / instruction")))

Theorem: cst-finalize-command-branches-match-alt

(defthm cst-finalize-command-branches-match-alt
  (implies (cst-matchp abnf::cst "finalize-command")
           (cst-list-list-alt-matchp
                (abnf::tree-nonleaf->branches abnf::cst)
                "cws %s\"finalize\" *( ws operand ) ws \";\"")))

Theorem: cst-function-branches-match-alt

(defthm cst-function-branches-match-alt
 (implies
  (cst-matchp abnf::cst "function")
  (cst-list-list-alt-matchp
   (abnf::tree-nonleaf->branches abnf::cst)
   "cws %s\"function\" ws identifier ws \":\" *function-input 1*instruction *function-output")))

Theorem: cst-function-input-branches-match-alt

(defthm cst-function-input-branches-match-alt
 (implies
  (cst-matchp abnf::cst "function-input")
  (cst-list-list-alt-matchp
    (abnf::tree-nonleaf->branches abnf::cst)
    "cws %s\"input\" ws register ws %s\"as\" ws register-type ws \";\"")))

Theorem: cst-function-output-branches-match-alt

(defthm cst-function-output-branches-match-alt
 (implies
  (cst-matchp abnf::cst "function-output")
  (cst-list-list-alt-matchp
   (abnf::tree-nonleaf->branches abnf::cst)
   "cws %s\"output\" ws register-access ws %s\"as\" ws register-type ws \";\"")))

Theorem: cst-transition-branches-match-alt

(defthm cst-transition-branches-match-alt
 (implies
  (cst-matchp abnf::cst "transition")
  (cst-list-list-alt-matchp
   (abnf::tree-nonleaf->branches abnf::cst)
   "cws %s\"transition\" ws identifier ws \":\" *transition-input *instruction *transition-output [ finalize-command finalize ]")))

Theorem: cst-transition-input-branches-match-alt

(defthm cst-transition-input-branches-match-alt
 (implies
  (cst-matchp abnf::cst "transition-input")
  (cst-list-list-alt-matchp
       (abnf::tree-nonleaf->branches abnf::cst)
       "cws %s\"input\" ws register ws %s\"as\" ws value-type ws \";\"")))

Theorem: cst-transition-output-branches-match-alt

(defthm cst-transition-output-branches-match-alt
 (implies
  (cst-matchp abnf::cst "transition-output")
  (cst-list-list-alt-matchp
   (abnf::tree-nonleaf->branches abnf::cst)
   "cws %s\"output\" ws register-access ws %s\"as\" ws value-type ws \";\"")))

Theorem: cst-finalize-branches-match-alt

(defthm cst-finalize-branches-match-alt
 (implies
  (cst-matchp abnf::cst "finalize")
  (cst-list-list-alt-matchp
   (abnf::tree-nonleaf->branches abnf::cst)
   "cws %s\"finalize\" ws identifier ws \":\" *finalize-input 1*command *finalize-output")))

Theorem: cst-finalize-input-branches-match-alt

(defthm cst-finalize-input-branches-match-alt
 (implies
  (cst-matchp abnf::cst "finalize-input")
  (cst-list-list-alt-matchp
    (abnf::tree-nonleaf->branches abnf::cst)
    "cws %s\"input\" ws register ws %s\"as\" ws finalize-type ws \";\"")))

Theorem: cst-finalize-output-branches-match-alt

(defthm cst-finalize-output-branches-match-alt
 (implies
  (cst-matchp abnf::cst "finalize-output")
  (cst-list-list-alt-matchp
   (abnf::tree-nonleaf->branches abnf::cst)
   "cws %s\"output\" ws register-access ws %s\"as\" ws finalize-type ws \";\"")))

Theorem: cst-program-branches-match-alt

(defthm cst-program-branches-match-alt
 (implies
  (cst-matchp abnf::cst "program")
  (cst-list-list-alt-matchp
   (abnf::tree-nonleaf->branches abnf::cst)
   "*import cws %s\"program\" ws program-id ws \";\" 1*( mapping / struct / record / function / transition ) cws")))

Theorem: cst-ht-concs

(defthm cst-ht-concs
  (implies (cst-list-list-alt-matchp abnf::cstss "%x9")
           (or (cst-list-list-conc-matchp abnf::cstss "%x9"))))

Theorem: cst-lf-concs

(defthm cst-lf-concs
  (implies (cst-list-list-alt-matchp abnf::cstss "%xA")
           (or (cst-list-list-conc-matchp abnf::cstss "%xA"))))

Theorem: cst-cr-concs

(defthm cst-cr-concs
  (implies (cst-list-list-alt-matchp abnf::cstss "%xD")
           (or (cst-list-list-conc-matchp abnf::cstss "%xD"))))

Theorem: cst-sp-concs

(defthm cst-sp-concs
  (implies (cst-list-list-alt-matchp abnf::cstss "%x20")
           (or (cst-list-list-conc-matchp abnf::cstss "%x20"))))

Theorem: cst-dq-concs

(defthm cst-dq-concs
  (implies (cst-list-list-alt-matchp abnf::cstss "%x22")
           (or (cst-list-list-conc-matchp abnf::cstss "%x22"))))

Theorem: cst-visible-ascii-concs

(defthm cst-visible-ascii-concs
  (implies (cst-list-list-alt-matchp abnf::cstss "%x21-7E")
           (or (cst-list-list-conc-matchp abnf::cstss "%x21-7E"))))

Theorem: cst-safe-ascii-concs

(defthm cst-safe-ascii-concs
 (implies
      (cst-list-list-alt-matchp abnf::cstss
                                "ht / lf / cr / sp / visible-ascii")
      (or (cst-list-list-conc-matchp abnf::cstss "ht")
          (cst-list-list-conc-matchp abnf::cstss "lf")
          (cst-list-list-conc-matchp abnf::cstss "cr")
          (cst-list-list-conc-matchp abnf::cstss "sp")
          (cst-list-list-conc-matchp abnf::cstss "visible-ascii"))))

Theorem: cst-safe-nonascii-concs

(defthm cst-safe-nonascii-concs
 (implies
      (cst-list-list-alt-matchp
           abnf::cstss
           "%x80-2029 / %x202F-2065 / %x206A-D7FF / %xE000-10FFFF")
      (or (cst-list-list-conc-matchp abnf::cstss "%x80-2029")
          (cst-list-list-conc-matchp abnf::cstss "%x202F-2065")
          (cst-list-list-conc-matchp abnf::cstss "%x206A-D7FF")
          (cst-list-list-conc-matchp abnf::cstss "%xE000-10FFFF"))))

Theorem: cst-character-concs

(defthm cst-character-concs
 (implies
      (cst-list-list-alt-matchp abnf::cstss
                                "safe-ascii / safe-nonascii")
      (or (cst-list-list-conc-matchp abnf::cstss "safe-ascii")
          (cst-list-list-conc-matchp abnf::cstss "safe-nonascii"))))

Theorem: cst-escaped-lf-concs

(defthm cst-escaped-lf-concs
  (implies (cst-list-list-alt-matchp abnf::cstss "\"\\\" lf")
           (or (cst-list-list-conc-matchp abnf::cstss "\"\\\" lf"))))

Theorem: cst-plain-ws-concs

(defthm cst-plain-ws-concs
 (implies (cst-list-list-alt-matchp abnf::cstss "ht / sp / lf / cr")
          (or (cst-list-list-conc-matchp abnf::cstss "ht")
              (cst-list-list-conc-matchp abnf::cstss "sp")
              (cst-list-list-conc-matchp abnf::cstss "lf")
              (cst-list-list-conc-matchp abnf::cstss "cr"))))

Theorem: cst-ws-concs

(defthm cst-ws-concs
 (implies
   (cst-list-list-alt-matchp abnf::cstss
                             "*( 1*plain-ws / escaped-lf )")
   (or (cst-list-list-conc-matchp abnf::cstss
                                  "*( 1*plain-ws / escaped-lf )"))))

Theorem: cst-comment-concs

(defthm cst-comment-concs
 (implies
      (cst-list-list-alt-matchp abnf::cstss
                                "line-comment / block-comment")
      (or (cst-list-list-conc-matchp abnf::cstss "line-comment")
          (cst-list-list-conc-matchp abnf::cstss "block-comment"))))

Theorem: cst-line-comment-concs

(defthm cst-line-comment-concs
 (implies
    (cst-list-list-alt-matchp abnf::cstss
                              "\"//\" *( escaped-lf / not-lf-or-cr )")
    (or (cst-list-list-conc-matchp
             abnf::cstss
             "\"//\" *( escaped-lf / not-lf-or-cr )"))))

Theorem: cst-not-lf-or-cr-concs

(defthm cst-not-lf-or-cr-concs
 (implies
      (cst-list-list-alt-matchp
           abnf::cstss
           "ht / sp / visible-ascii / safe-nonascii")
      (or (cst-list-list-conc-matchp abnf::cstss "ht")
          (cst-list-list-conc-matchp abnf::cstss "sp")
          (cst-list-list-conc-matchp abnf::cstss "visible-ascii")
          (cst-list-list-conc-matchp abnf::cstss "safe-nonascii"))))

Theorem: cst-block-comment-concs

(defthm cst-block-comment-concs
 (implies
     (cst-list-list-alt-matchp abnf::cstss
                               "\"/*\" rest-of-block-comment")
     (or (cst-list-list-conc-matchp abnf::cstss
                                    "\"/*\" rest-of-block-comment"))))

Theorem: cst-rest-of-block-comment-concs

(defthm cst-rest-of-block-comment-concs
 (implies
  (cst-list-list-alt-matchp
   abnf::cstss
   "\"*\" rest-of-block-comment-after-star / not-star rest-of-block-comment")
  (or
     (cst-list-list-conc-matchp
          abnf::cstss
          "\"*\" rest-of-block-comment-after-star")
     (cst-list-list-conc-matchp abnf::cstss
                                "not-star rest-of-block-comment"))))

Theorem: cst-not-star-concs

(defthm cst-not-star-concs
 (implies
      (cst-list-list-alt-matchp
           abnf::cstss
           "ht / lf / cr / %x20-29 / %x2B-7E / safe-nonascii")
      (or (cst-list-list-conc-matchp abnf::cstss "ht")
          (cst-list-list-conc-matchp abnf::cstss "lf")
          (cst-list-list-conc-matchp abnf::cstss "cr")
          (cst-list-list-conc-matchp abnf::cstss "%x20-29")
          (cst-list-list-conc-matchp abnf::cstss "%x2B-7E")
          (cst-list-list-conc-matchp abnf::cstss "safe-nonascii"))))

Theorem: cst-rest-of-block-comment-after-star-concs

(defthm cst-rest-of-block-comment-after-star-concs
 (implies
  (cst-list-list-alt-matchp
   abnf::cstss
   "\"/\" / \"*\" rest-of-block-comment-after-star / not-star-or-slash rest-of-block-comment")
  (or (cst-list-list-conc-matchp abnf::cstss "\"/\"")
      (cst-list-list-conc-matchp
           abnf::cstss
           "\"*\" rest-of-block-comment-after-star")
      (cst-list-list-conc-matchp
           abnf::cstss
           "not-star-or-slash rest-of-block-comment"))))

Theorem: cst-not-star-or-slash-concs

(defthm cst-not-star-or-slash-concs
 (implies
  (cst-list-list-alt-matchp
       abnf::cstss
       "ht / lf / cr / %x20-29 / %x2B-2E / %x30-7E / safe-nonascii")
  (or (cst-list-list-conc-matchp abnf::cstss "ht")
      (cst-list-list-conc-matchp abnf::cstss "lf")
      (cst-list-list-conc-matchp abnf::cstss "cr")
      (cst-list-list-conc-matchp abnf::cstss "%x20-29")
      (cst-list-list-conc-matchp abnf::cstss "%x2B-2E")
      (cst-list-list-conc-matchp abnf::cstss "%x30-7E")
      (cst-list-list-conc-matchp abnf::cstss "safe-nonascii"))))

Theorem: cst-cws-concs

(defthm cst-cws-concs
 (implies
  (cst-list-list-alt-matchp abnf::cstss "ws *( comment / ws )")
  (or
   (cst-list-list-conc-matchp abnf::cstss "ws *( comment / ws )"))))

Theorem: cst-uppercase-letter-concs

(defthm cst-uppercase-letter-concs
  (implies (cst-list-list-alt-matchp abnf::cstss "%x41-5A")
           (or (cst-list-list-conc-matchp abnf::cstss "%x41-5A"))))

Theorem: cst-lowercase-letter-concs

(defthm cst-lowercase-letter-concs
  (implies (cst-list-list-alt-matchp abnf::cstss "%x61-7A")
           (or (cst-list-list-conc-matchp abnf::cstss "%x61-7A"))))

Theorem: cst-letter-concs

(defthm cst-letter-concs
 (implies
   (cst-list-list-alt-matchp abnf::cstss
                             "uppercase-letter / lowercase-letter")
   (or (cst-list-list-conc-matchp abnf::cstss "uppercase-letter")
       (cst-list-list-conc-matchp abnf::cstss "lowercase-letter"))))

Theorem: cst-digit-concs

(defthm cst-digit-concs
  (implies (cst-list-list-alt-matchp abnf::cstss "%x30-39")
           (or (cst-list-list-conc-matchp abnf::cstss "%x30-39"))))

Theorem: cst-hex-digit-concs

(defthm cst-hex-digit-concs
  (implies (cst-list-list-alt-matchp
                abnf::cstss
                "digit / \"a\" / \"b\" / \"c\" / \"d\" / \"e\" / \"f\"")
           (or (cst-list-list-conc-matchp abnf::cstss "digit")
               (cst-list-list-conc-matchp abnf::cstss "\"a\"")
               (cst-list-list-conc-matchp abnf::cstss "\"b\"")
               (cst-list-list-conc-matchp abnf::cstss "\"c\"")
               (cst-list-list-conc-matchp abnf::cstss "\"d\"")
               (cst-list-list-conc-matchp abnf::cstss "\"e\"")
               (cst-list-list-conc-matchp abnf::cstss "\"f\""))))

Theorem: cst-identifier-concs

(defthm cst-identifier-concs
 (implies
  (cst-list-list-alt-matchp abnf::cstss
                            "letter *( letter / digit / \"_\" )")
  (or
   (cst-list-list-conc-matchp abnf::cstss
                              "letter *( letter / digit / \"_\" )"))))

Theorem: cst-program-id-concs

(defthm cst-program-id-concs
 (implies
  (cst-list-list-alt-matchp abnf::cstss "identifier \".\" identifier")
  (or (cst-list-list-conc-matchp abnf::cstss
                                 "identifier \".\" identifier"))))

Theorem: cst-locator-concs

(defthm cst-locator-concs
 (implies
  (cst-list-list-alt-matchp abnf::cstss "program-id \"/\" identifier")
  (or (cst-list-list-conc-matchp abnf::cstss
                                 "program-id \"/\" identifier"))))

Theorem: cst-register-concs

(defthm cst-register-concs
 (implies
      (cst-list-list-alt-matchp abnf::cstss "%s\"r\" 1*digit")
      (or (cst-list-list-conc-matchp abnf::cstss "%s\"r\" 1*digit"))))

Theorem: cst-register-access-concs

(defthm cst-register-access-concs
 (implies
   (cst-list-list-alt-matchp abnf::cstss
                             "register *( \".\" identifier )")
   (or (cst-list-list-conc-matchp abnf::cstss
                                  "register *( \".\" identifier )"))))

Theorem: cst-signed-literal-concs

(defthm cst-signed-literal-concs
 (implies
   (cst-list-list-alt-matchp abnf::cstss
                             "[ \"-\" ] 1*( digit *\"_\" ) signed-type")
   (or (cst-list-list-conc-matchp
            abnf::cstss
            "[ \"-\" ] 1*( digit *\"_\" ) signed-type"))))

Theorem: cst-unsigned-literal-concs

(defthm cst-unsigned-literal-concs
  (implies (cst-list-list-alt-matchp
                abnf::cstss
                "[ \"-\" ] 1*( digit *\"_\" ) unsigned-type")
           (or (cst-list-list-conc-matchp
                    abnf::cstss
                    "[ \"-\" ] 1*( digit *\"_\" ) unsigned-type"))))

Theorem: cst-integer-literal-concs

(defthm cst-integer-literal-concs
 (implies
   (cst-list-list-alt-matchp abnf::cstss
                             "signed-literal / unsigned-literal")
   (or (cst-list-list-conc-matchp abnf::cstss "signed-literal")
       (cst-list-list-conc-matchp abnf::cstss "unsigned-literal"))))

Theorem: cst-field-literal-concs

(defthm cst-field-literal-concs
 (implies
    (cst-list-list-alt-matchp abnf::cstss
                              "[ \"-\" ] 1*( digit *\"_\" ) field-type")
    (or (cst-list-list-conc-matchp
             abnf::cstss
             "[ \"-\" ] 1*( digit *\"_\" ) field-type"))))

Theorem: cst-group-literal-concs

(defthm cst-group-literal-concs
 (implies
    (cst-list-list-alt-matchp abnf::cstss
                              "[ \"-\" ] 1*( digit *\"_\" ) group-type")
    (or (cst-list-list-conc-matchp
             abnf::cstss
             "[ \"-\" ] 1*( digit *\"_\" ) group-type"))))

Theorem: cst-scalar-literal-concs

(defthm cst-scalar-literal-concs
 (implies
   (cst-list-list-alt-matchp abnf::cstss
                             "[ \"-\" ] 1*( digit *\"_\" ) scalar-type")
   (or (cst-list-list-conc-matchp
            abnf::cstss
            "[ \"-\" ] 1*( digit *\"_\" ) scalar-type"))))

Theorem: cst-arithmetic-literal-concs

(defthm cst-arithmetic-literal-concs
 (implies
  (cst-list-list-alt-matchp
   abnf::cstss
   "integer-literal / field-literal / group-literal / scalar-literal")
  (or (cst-list-list-conc-matchp abnf::cstss "integer-literal")
      (cst-list-list-conc-matchp abnf::cstss "field-literal")
      (cst-list-list-conc-matchp abnf::cstss "group-literal")
      (cst-list-list-conc-matchp abnf::cstss "scalar-literal"))))

Theorem: cst-address-literal-concs

(defthm cst-address-literal-concs
 (implies
      (cst-list-list-alt-matchp abnf::cstss
                                "%s\"aleo1\" 1*( address-char *\"_\" )")
      (or (cst-list-list-conc-matchp
               abnf::cstss
               "%s\"aleo1\" 1*( address-char *\"_\" )"))))

Theorem: cst-address-char-concs

(defthm cst-address-char-concs
 (implies
  (cst-list-list-alt-matchp
   abnf::cstss
   "\"0\" / \"2\" / \"3\" / \"4\" / \"5\" / \"6\" / \"7\" / \"8\" / \"9\" / %s\"a\" / %s\"c\" / %s\"d\" / %s\"e\" / %s\"f\" / %s\"g\" / %s\"h\" / %s\"j\" / %s\"k\" / %s\"l\" / %s\"m\" / %s\"n\" / %s\"p\" / %s\"q\" / %s\"r\" / %s\"s\" / %s\"t\" / %s\"u\" / %s\"v\" / %s\"w\" / %s\"x\" / %s\"y\" / %s\"z\"")
  (or (cst-list-list-conc-matchp abnf::cstss "\"0\"")
      (cst-list-list-conc-matchp abnf::cstss "\"2\"")
      (cst-list-list-conc-matchp abnf::cstss "\"3\"")
      (cst-list-list-conc-matchp abnf::cstss "\"4\"")
      (cst-list-list-conc-matchp abnf::cstss "\"5\"")
      (cst-list-list-conc-matchp abnf::cstss "\"6\"")
      (cst-list-list-conc-matchp abnf::cstss "\"7\"")
      (cst-list-list-conc-matchp abnf::cstss "\"8\"")
      (cst-list-list-conc-matchp abnf::cstss "\"9\"")
      (cst-list-list-conc-matchp abnf::cstss "%s\"a\"")
      (cst-list-list-conc-matchp abnf::cstss "%s\"c\"")
      (cst-list-list-conc-matchp abnf::cstss "%s\"d\"")
      (cst-list-list-conc-matchp abnf::cstss "%s\"e\"")
      (cst-list-list-conc-matchp abnf::cstss "%s\"f\"")
      (cst-list-list-conc-matchp abnf::cstss "%s\"g\"")
      (cst-list-list-conc-matchp abnf::cstss "%s\"h\"")
      (cst-list-list-conc-matchp abnf::cstss "%s\"j\"")
      (cst-list-list-conc-matchp abnf::cstss "%s\"k\"")
      (cst-list-list-conc-matchp abnf::cstss "%s\"l\"")
      (cst-list-list-conc-matchp abnf::cstss "%s\"m\"")
      (cst-list-list-conc-matchp abnf::cstss "%s\"n\"")
      (cst-list-list-conc-matchp abnf::cstss "%s\"p\"")
      (cst-list-list-conc-matchp abnf::cstss "%s\"q\"")
      (cst-list-list-conc-matchp abnf::cstss "%s\"r\"")
      (cst-list-list-conc-matchp abnf::cstss "%s\"s\"")
      (cst-list-list-conc-matchp abnf::cstss "%s\"t\"")
      (cst-list-list-conc-matchp abnf::cstss "%s\"u\"")
      (cst-list-list-conc-matchp abnf::cstss "%s\"v\"")
      (cst-list-list-conc-matchp abnf::cstss "%s\"w\"")
      (cst-list-list-conc-matchp abnf::cstss "%s\"x\"")
      (cst-list-list-conc-matchp abnf::cstss "%s\"y\"")
      (cst-list-list-conc-matchp abnf::cstss "%s\"z\""))))

Theorem: cst-boolean-literal-concs

(defthm cst-boolean-literal-concs
  (implies
       (cst-list-list-alt-matchp abnf::cstss "%s\"true\" / %s\"false\"")
       (or (cst-list-list-conc-matchp abnf::cstss "%s\"true\"")
           (cst-list-list-conc-matchp abnf::cstss "%s\"false\""))))

Theorem: cst-string-literal-concs

(defthm cst-string-literal-concs
 (implies
      (cst-list-list-alt-matchp abnf::cstss "dq *string-element dq")
      (or (cst-list-list-conc-matchp
               abnf::cstss "dq *string-element dq"))))

Theorem: cst-string-element-concs

(defthm cst-string-element-concs
 (implies
   (cst-list-list-alt-matchp
        abnf::cstss
        "not-dq-or-backslash / escaped-char / escaped-ws")
   (or (cst-list-list-conc-matchp abnf::cstss "not-dq-or-backslash")
       (cst-list-list-conc-matchp abnf::cstss "escaped-char")
       (cst-list-list-conc-matchp abnf::cstss "escaped-ws"))))

Theorem: cst-not-dq-or-backslash-concs

(defthm cst-not-dq-or-backslash-concs
 (implies
  (cst-list-list-alt-matchp
       abnf::cstss
       "ht / lf / cr / %x20-21 / %x23-5B / %x5D-7E / safe-nonascii")
  (or (cst-list-list-conc-matchp abnf::cstss "ht")
      (cst-list-list-conc-matchp abnf::cstss "lf")
      (cst-list-list-conc-matchp abnf::cstss "cr")
      (cst-list-list-conc-matchp abnf::cstss "%x20-21")
      (cst-list-list-conc-matchp abnf::cstss "%x23-5B")
      (cst-list-list-conc-matchp abnf::cstss "%x5D-7E")
      (cst-list-list-conc-matchp abnf::cstss "safe-nonascii"))))

Theorem: cst-escaped-char-concs

(defthm cst-escaped-char-concs
 (implies
  (cst-list-list-alt-matchp
   abnf::cstss
   "\"\\\" ( dq / \"\\\" / \"/\" / %s\"n\" / %s\"r\" / %s\"t\" / %s\"b\" / %s\"f\" / %s\"u\" \"{\" 1*6hex-digit \"}\" )")
  (or
   (cst-list-list-conc-matchp
    abnf::cstss
    "\"\\\" ( dq / \"\\\" / \"/\" / %s\"n\" / %s\"r\" / %s\"t\" / %s\"b\" / %s\"f\" / %s\"u\" \"{\" 1*6hex-digit \"}\" )"))))

Theorem: cst-escaped-ws-concs

(defthm cst-escaped-ws-concs
 (implies
     (cst-list-list-alt-matchp abnf::cstss "\"\\\" 1*plain-ws")
     (or (cst-list-list-conc-matchp abnf::cstss "\"\\\" 1*plain-ws"))))

Theorem: cst-literal-concs

(defthm cst-literal-concs
 (implies
  (cst-list-list-alt-matchp
   abnf::cstss
   "arithmetic-literal / address-literal / boolean-literal / string-literal")
  (or (cst-list-list-conc-matchp abnf::cstss "arithmetic-literal")
      (cst-list-list-conc-matchp abnf::cstss "address-literal")
      (cst-list-list-conc-matchp abnf::cstss "boolean-literal")
      (cst-list-list-conc-matchp abnf::cstss "string-literal"))))

Theorem: cst-operand-concs

(defthm cst-operand-concs
 (implies
    (cst-list-list-alt-matchp
         abnf::cstss
         "literal / register-access / %s\"self.caller\" / program-id")
    (or (cst-list-list-conc-matchp abnf::cstss "literal")
        (cst-list-list-conc-matchp abnf::cstss "register-access")
        (cst-list-list-conc-matchp abnf::cstss "%s\"self.caller\"")
        (cst-list-list-conc-matchp abnf::cstss "program-id"))))

Theorem: cst-unsigned-type-concs

(defthm cst-unsigned-type-concs
  (implies (cst-list-list-alt-matchp
                abnf::cstss
                "%s\"u8\" / %s\"u16\" / %s\"u32\" / %s\"u64\" / %s\"u128\"")
           (or (cst-list-list-conc-matchp abnf::cstss "%s\"u8\"")
               (cst-list-list-conc-matchp abnf::cstss "%s\"u16\"")
               (cst-list-list-conc-matchp abnf::cstss "%s\"u32\"")
               (cst-list-list-conc-matchp abnf::cstss "%s\"u64\"")
               (cst-list-list-conc-matchp abnf::cstss "%s\"u128\""))))

Theorem: cst-signed-type-concs

(defthm cst-signed-type-concs
  (implies (cst-list-list-alt-matchp
                abnf::cstss
                "%s\"i8\" / %s\"i16\" / %s\"i32\" / %s\"i64\" / %s\"i128\"")
           (or (cst-list-list-conc-matchp abnf::cstss "%s\"i8\"")
               (cst-list-list-conc-matchp abnf::cstss "%s\"i16\"")
               (cst-list-list-conc-matchp abnf::cstss "%s\"i32\"")
               (cst-list-list-conc-matchp abnf::cstss "%s\"i64\"")
               (cst-list-list-conc-matchp abnf::cstss "%s\"i128\""))))

Theorem: cst-integer-type-concs

(defthm cst-integer-type-concs
  (implies
       (cst-list-list-alt-matchp abnf::cstss
                                 "unsigned-type / signed-type")
       (or (cst-list-list-conc-matchp abnf::cstss "unsigned-type")
           (cst-list-list-conc-matchp abnf::cstss "signed-type"))))

Theorem: cst-field-type-concs

(defthm cst-field-type-concs
 (implies (cst-list-list-alt-matchp abnf::cstss "%s\"field\"")
          (or (cst-list-list-conc-matchp abnf::cstss "%s\"field\""))))

Theorem: cst-group-type-concs

(defthm cst-group-type-concs
 (implies (cst-list-list-alt-matchp abnf::cstss "%s\"group\"")
          (or (cst-list-list-conc-matchp abnf::cstss "%s\"group\""))))

Theorem: cst-scalar-type-concs

(defthm cst-scalar-type-concs
  (implies
       (cst-list-list-alt-matchp abnf::cstss "%s\"scalar\"")
       (or (cst-list-list-conc-matchp abnf::cstss "%s\"scalar\""))))

Theorem: cst-arithmetic-type-concs

(defthm cst-arithmetic-type-concs
  (implies
       (cst-list-list-alt-matchp
            abnf::cstss
            "integer-type / field-type / group-type / scalar-type")
       (or (cst-list-list-conc-matchp abnf::cstss "integer-type")
           (cst-list-list-conc-matchp abnf::cstss "field-type")
           (cst-list-list-conc-matchp abnf::cstss "group-type")
           (cst-list-list-conc-matchp abnf::cstss "scalar-type"))))

Theorem: cst-address-type-concs

(defthm cst-address-type-concs
  (implies
       (cst-list-list-alt-matchp abnf::cstss "%s\"address\"")
       (or (cst-list-list-conc-matchp abnf::cstss "%s\"address\""))))

Theorem: cst-boolean-type-concs

(defthm cst-boolean-type-concs
  (implies
       (cst-list-list-alt-matchp abnf::cstss "%s\"boolean\"")
       (or (cst-list-list-conc-matchp abnf::cstss "%s\"boolean\""))))

Theorem: cst-string-type-concs

(defthm cst-string-type-concs
  (implies
       (cst-list-list-alt-matchp abnf::cstss "%s\"string\"")
       (or (cst-list-list-conc-matchp abnf::cstss "%s\"string\""))))

Theorem: cst-literal-type-concs

(defthm cst-literal-type-concs
 (implies
  (cst-list-list-alt-matchp
      abnf::cstss
      "arithmetic-type / address-type / boolean-type / string-type")
  (or (cst-list-list-conc-matchp abnf::cstss "arithmetic-type")
      (cst-list-list-conc-matchp abnf::cstss "address-type")
      (cst-list-list-conc-matchp abnf::cstss "boolean-type")
      (cst-list-list-conc-matchp abnf::cstss "string-type"))))

Theorem: cst-plaintext-type-concs

(defthm cst-plaintext-type-concs
 (implies
  (cst-list-list-alt-matchp abnf::cstss "literal-type / identifier")
  (or (cst-list-list-conc-matchp abnf::cstss "literal-type")
      (cst-list-list-conc-matchp abnf::cstss "identifier"))))

Theorem: cst-value-type-concs

(defthm cst-value-type-concs
 (implies
  (cst-list-list-alt-matchp
   abnf::cstss
   "plaintext-type %s\".constant\" / plaintext-type %s\".public\" / plaintext-type %s\".private\" / identifier %s\".record\" / locator %s\".record\"")
  (or
    (cst-list-list-conc-matchp abnf::cstss
                               "plaintext-type %s\".constant\"")
    (cst-list-list-conc-matchp abnf::cstss
                               "plaintext-type %s\".public\"")
    (cst-list-list-conc-matchp abnf::cstss
                               "plaintext-type %s\".private\"")
    (cst-list-list-conc-matchp abnf::cstss "identifier %s\".record\"")
    (cst-list-list-conc-matchp abnf::cstss "locator %s\".record\""))))

Theorem: cst-finalize-type-concs

(defthm cst-finalize-type-concs
 (implies
  (cst-list-list-alt-matchp
   abnf::cstss
   "plaintext-type %s\".public\" / identifier %s\".record\" / locator %s\".record\"")
  (or
    (cst-list-list-conc-matchp abnf::cstss
                               "plaintext-type %s\".public\"")
    (cst-list-list-conc-matchp abnf::cstss "identifier %s\".record\"")
    (cst-list-list-conc-matchp abnf::cstss "locator %s\".record\""))))

Theorem: cst-entry-type-concs

(defthm cst-entry-type-concs
 (implies
  (cst-list-list-alt-matchp
    abnf::cstss
    "plaintext-type ( %s\".constant\" / %s\".public\" / %s\".private\" )")
  (or
   (cst-list-list-conc-matchp
    abnf::cstss
    "plaintext-type ( %s\".constant\" / %s\".public\" / %s\".private\" )"))))

Theorem: cst-register-type-concs

(defthm cst-register-type-concs
 (implies
  (cst-list-list-alt-matchp
    abnf::cstss
    "locator %s\".record\" / identifier %s\".record\" / plaintext-type")
  (or
    (cst-list-list-conc-matchp abnf::cstss "locator %s\".record\"")
    (cst-list-list-conc-matchp abnf::cstss "identifier %s\".record\"")
    (cst-list-list-conc-matchp abnf::cstss "plaintext-type"))))

Theorem: cst-import-concs

(defthm cst-import-concs
 (implies
    (cst-list-list-alt-matchp abnf::cstss
                              "cws %s\"import\" ws program-id ws \";\"")
    (or (cst-list-list-conc-matchp
             abnf::cstss
             "cws %s\"import\" ws program-id ws \";\""))))

Theorem: cst-mapping-concs

(defthm cst-mapping-concs
 (implies
  (cst-list-list-alt-matchp
   abnf::cstss
   "cws %s\"mapping\" ws identifier ws \":\" mapping-key mapping-value")
  (or
   (cst-list-list-conc-matchp
    abnf::cstss
    "cws %s\"mapping\" ws identifier ws \":\" mapping-key mapping-value"))))

Theorem: cst-mapping-key-concs

(defthm cst-mapping-key-concs
 (implies
  (cst-list-list-alt-matchp
      abnf::cstss
      "cws %s\"key\" ws identifier ws %s\"as\" ws finalize-type ws \";\"")
  (or
   (cst-list-list-conc-matchp
    abnf::cstss
    "cws %s\"key\" ws identifier ws %s\"as\" ws finalize-type ws \";\""))))

Theorem: cst-mapping-value-concs

(defthm cst-mapping-value-concs
 (implies
  (cst-list-list-alt-matchp
    abnf::cstss
    "cws %s\"value\" ws identifier ws %s\"as\" ws finalize-type ws \";\"")
  (or
   (cst-list-list-conc-matchp
    abnf::cstss
    "cws %s\"value\" ws identifier ws %s\"as\" ws finalize-type ws \";\""))))

Theorem: cst-struct-concs

(defthm cst-struct-concs
 (implies (cst-list-list-alt-matchp
               abnf::cstss
               "cws %s\"struct\" ws identifier ws \":\" 1*tuple")
          (or (cst-list-list-conc-matchp
                   abnf::cstss
                   "cws %s\"struct\" ws identifier ws \":\" 1*tuple"))))

Theorem: cst-tuple-concs

(defthm cst-tuple-concs
 (implies
    (cst-list-list-alt-matchp
         abnf::cstss
         "cws identifier ws %s\"as\" ws plaintext-type ws \";\"")
    (or (cst-list-list-conc-matchp
             abnf::cstss
             "cws identifier ws %s\"as\" ws plaintext-type ws \";\""))))

Theorem: cst-record-concs

(defthm cst-record-concs
 (implies
  (cst-list-list-alt-matchp
   abnf::cstss
   "cws %s\"record\" ws identifier ws \":\" cws %s\"owner\" ws %s\"as\" ws cws ( %s\"address.public\" / %s\"address.private\" ) ws \";\" cws %s\"gates\" ws %s\"as\" ws cws ( %s\"u64.public\" / %s\"u64.private\" ) ws \";\" *entry")
  (or
   (cst-list-list-conc-matchp
    abnf::cstss
    "cws %s\"record\" ws identifier ws \":\" cws %s\"owner\" ws %s\"as\" ws cws ( %s\"address.public\" / %s\"address.private\" ) ws \";\" cws %s\"gates\" ws %s\"as\" ws cws ( %s\"u64.public\" / %s\"u64.private\" ) ws \";\" *entry"))))

Theorem: cst-entry-concs

(defthm cst-entry-concs
  (implies
       (cst-list-list-alt-matchp
            abnf::cstss
            "cws identifier ws %s\"as\" ws entry-type ws \";\"")
       (or (cst-list-list-conc-matchp
                abnf::cstss
                "cws identifier ws %s\"as\" ws entry-type ws \";\""))))

Theorem: cst-unary-op-concs

(defthm cst-unary-op-concs
 (implies
  (cst-list-list-alt-matchp
   abnf::cstss
   "%s\"abs\" / %s\"abs.w\" / %s\"double\" / %s\"inv\" / %s\"neg\" / %s\"not\" / %s\"square\" / %s\"sqrt\"")
  (or (cst-list-list-conc-matchp abnf::cstss "%s\"abs\"")
      (cst-list-list-conc-matchp abnf::cstss "%s\"abs.w\"")
      (cst-list-list-conc-matchp abnf::cstss "%s\"double\"")
      (cst-list-list-conc-matchp abnf::cstss "%s\"inv\"")
      (cst-list-list-conc-matchp abnf::cstss "%s\"neg\"")
      (cst-list-list-conc-matchp abnf::cstss "%s\"not\"")
      (cst-list-list-conc-matchp abnf::cstss "%s\"square\"")
      (cst-list-list-conc-matchp abnf::cstss "%s\"sqrt\""))))

Theorem: cst-binary-op-concs

(defthm cst-binary-op-concs
 (implies
  (cst-list-list-alt-matchp
   abnf::cstss
   "%s\"add\" / %s\"add.w\" / %s\"sub\" / %s\"sub.w\" / %s\"mul\" / %s\"mul.w\" / %s\"div\" / %s\"div.w\" / %s\"rem\" / %s\"rem.w\" / %s\"mod\" / %s\"pow\" / %s\"pow.w\" / %s\"shl\" / %s\"shl.w\" / %s\"shr\" / %s\"shr.w\" / %s\"and\" / %s\"or\" / %s\"xor\" / %s\"nand\" / %s\"nor\" / %s\"gt\" / %s\"gte\" / %s\"lt\" / %s\"lte\"")
  (or (cst-list-list-conc-matchp abnf::cstss "%s\"add\"")
      (cst-list-list-conc-matchp abnf::cstss "%s\"add.w\"")
      (cst-list-list-conc-matchp abnf::cstss "%s\"sub\"")
      (cst-list-list-conc-matchp abnf::cstss "%s\"sub.w\"")
      (cst-list-list-conc-matchp abnf::cstss "%s\"mul\"")
      (cst-list-list-conc-matchp abnf::cstss "%s\"mul.w\"")
      (cst-list-list-conc-matchp abnf::cstss "%s\"div\"")
      (cst-list-list-conc-matchp abnf::cstss "%s\"div.w\"")
      (cst-list-list-conc-matchp abnf::cstss "%s\"rem\"")
      (cst-list-list-conc-matchp abnf::cstss "%s\"rem.w\"")
      (cst-list-list-conc-matchp abnf::cstss "%s\"mod\"")
      (cst-list-list-conc-matchp abnf::cstss "%s\"pow\"")
      (cst-list-list-conc-matchp abnf::cstss "%s\"pow.w\"")
      (cst-list-list-conc-matchp abnf::cstss "%s\"shl\"")
      (cst-list-list-conc-matchp abnf::cstss "%s\"shl.w\"")
      (cst-list-list-conc-matchp abnf::cstss "%s\"shr\"")
      (cst-list-list-conc-matchp abnf::cstss "%s\"shr.w\"")
      (cst-list-list-conc-matchp abnf::cstss "%s\"and\"")
      (cst-list-list-conc-matchp abnf::cstss "%s\"or\"")
      (cst-list-list-conc-matchp abnf::cstss "%s\"xor\"")
      (cst-list-list-conc-matchp abnf::cstss "%s\"nand\"")
      (cst-list-list-conc-matchp abnf::cstss "%s\"nor\"")
      (cst-list-list-conc-matchp abnf::cstss "%s\"gt\"")
      (cst-list-list-conc-matchp abnf::cstss "%s\"gte\"")
      (cst-list-list-conc-matchp abnf::cstss "%s\"lt\"")
      (cst-list-list-conc-matchp abnf::cstss "%s\"lte\""))))

Theorem: cst-ternary-op-concs

(defthm cst-ternary-op-concs
  (implies
       (cst-list-list-alt-matchp abnf::cstss "%s\"ternary\"")
       (or (cst-list-list-conc-matchp abnf::cstss "%s\"ternary\""))))

Theorem: cst-is-op-concs

(defthm cst-is-op-concs
 (implies
     (cst-list-list-alt-matchp abnf::cstss "%s\"is.eq\" / %s\"is.neq\"")
     (or (cst-list-list-conc-matchp abnf::cstss "%s\"is.eq\"")
         (cst-list-list-conc-matchp abnf::cstss "%s\"is.neq\""))))

Theorem: cst-assert-op-concs

(defthm cst-assert-op-concs
 (implies
     (cst-list-list-alt-matchp abnf::cstss
                               "%s\"assert.eq\" / %s\"assert.neq\"")
     (or (cst-list-list-conc-matchp abnf::cstss "%s\"assert.eq\"")
         (cst-list-list-conc-matchp abnf::cstss "%s\"assert.neq\""))))

Theorem: cst-commit-op-concs

(defthm cst-commit-op-concs
 (implies
  (cst-list-list-alt-matchp
   abnf::cstss
   "%s\"commit.bhp\" ( \"256\" / \"512\" / \"768\" / \"1024\" ) / %s\"commit.ped\" ( \"64\" / \"128\" )")
  (or
    (cst-list-list-conc-matchp
         abnf::cstss
         "%s\"commit.bhp\" ( \"256\" / \"512\" / \"768\" / \"1024\" )")
    (cst-list-list-conc-matchp abnf::cstss
                               "%s\"commit.ped\" ( \"64\" / \"128\" )"))))

Theorem: cst-hash-op-concs

(defthm cst-hash-op-concs
 (implies
  (cst-list-list-alt-matchp
   abnf::cstss
   "%s\"hash.bhp\" ( \"256\" / \"512\" / \"768\" / \"1024\" ) / %s\"hash.ped\" ( \"64\" / \"128\" ) / %s\"hash.psd\" ( \"2\" / \"4\" / \"8\" )")
  (or
   (cst-list-list-conc-matchp
        abnf::cstss
        "%s\"hash.bhp\" ( \"256\" / \"512\" / \"768\" / \"1024\" )")
   (cst-list-list-conc-matchp abnf::cstss
                              "%s\"hash.ped\" ( \"64\" / \"128\" )")
   (cst-list-list-conc-matchp abnf::cstss
                              "%s\"hash.psd\" ( \"2\" / \"4\" / \"8\" )"))))

Theorem: cst-unary-concs

(defthm cst-unary-concs
 (implies
      (cst-list-list-alt-matchp
           abnf::cstss
           "unary-op ws ( operand ws ) %s\"into\" ws register")
      (or (cst-list-list-conc-matchp
               abnf::cstss
               "unary-op ws ( operand ws ) %s\"into\" ws register"))))

Theorem: cst-binary-concs

(defthm cst-binary-concs
 (implies
    (cst-list-list-alt-matchp
         abnf::cstss
         "binary-op ws 2( operand ws ) %s\"into\" ws register")
    (or (cst-list-list-conc-matchp
             abnf::cstss
             "binary-op ws 2( operand ws ) %s\"into\" ws register"))))

Theorem: cst-ternary-concs

(defthm cst-ternary-concs
 (implies
   (cst-list-list-alt-matchp
        abnf::cstss
        "ternary-op ws 3( operand ws ) %s\"into\" ws register")
   (or (cst-list-list-conc-matchp
            abnf::cstss
            "ternary-op ws 3( operand ws ) %s\"into\" ws register"))))

Theorem: cst-is-concs

(defthm cst-is-concs
 (implies
  (cst-list-list-alt-matchp
       abnf::cstss
       "is-op ws operand ws operand ws %s\"into\" ws register")
  (or (cst-list-list-conc-matchp
           abnf::cstss
           "is-op ws operand ws operand ws %s\"into\" ws register"))))

Theorem: cst-assert-concs

(defthm cst-assert-concs
 (implies
  (cst-list-list-alt-matchp abnf::cstss
                            "assert-op ws operand ws operand")
  (or
    (cst-list-list-conc-matchp abnf::cstss
                               "assert-op ws operand ws operand"))))

Theorem: cst-commit-concs

(defthm cst-commit-concs
 (implies
  (cst-list-list-alt-matchp
       abnf::cstss
       "commit-op ws operand ws operand ws %s\"into\" ws register")
  (or
   (cst-list-list-conc-matchp
       abnf::cstss
       "commit-op ws operand ws operand ws %s\"into\" ws register"))))

Theorem: cst-hash-concs

(defthm cst-hash-concs
  (implies (cst-list-list-alt-matchp
                abnf::cstss
                "hash-op ws operand ws %s\"into\" ws register")
           (or (cst-list-list-conc-matchp
                    abnf::cstss
                    "hash-op ws operand ws %s\"into\" ws register"))))

Theorem: cst-cast-concs

(defthm cst-cast-concs
 (implies
  (cst-list-list-alt-matchp
   abnf::cstss
   "%s\"cast\" 1*( ws operand ) ws %s\"into\" ws register ws %s\"as\" ws register-type")
  (or
   (cst-list-list-conc-matchp
    abnf::cstss
    "%s\"cast\" 1*( ws operand ) ws %s\"into\" ws register ws %s\"as\" ws register-type"))))

Theorem: cst-call-concs

(defthm cst-call-concs
 (implies
  (cst-list-list-alt-matchp
   abnf::cstss
   "%s\"call\" ws ( locator / identifier ) ws 1*( ws operand ) ws %s\"into\" ws 1*( ws register )")
  (or
   (cst-list-list-conc-matchp
    abnf::cstss
    "%s\"call\" ws ( locator / identifier ) ws 1*( ws operand ) ws %s\"into\" ws 1*( ws register )"))))

Theorem: cst-instruction-concs

(defthm cst-instruction-concs
 (implies
  (cst-list-list-alt-matchp
   abnf::cstss
   "cws ( unary / binary / ternary / is / assert / commit / hash / cast / call ) ws \";\"")
  (or
   (cst-list-list-conc-matchp
    abnf::cstss
    "cws ( unary / binary / ternary / is / assert / commit / hash / cast / call ) ws \";\""))))

Theorem: cst-decrement-concs

(defthm cst-decrement-concs
 (implies
  (cst-list-list-alt-matchp
   abnf::cstss
   "cws %s\"decrement\" ws identifier \"[\" ws operand ws \"]\" ws %s\"by\" ws operand ws \";\"")
  (or
   (cst-list-list-conc-matchp
    abnf::cstss
    "cws %s\"decrement\" ws identifier \"[\" ws operand ws \"]\" ws %s\"by\" ws operand ws \";\""))))

Theorem: cst-increment-concs

(defthm cst-increment-concs
 (implies
  (cst-list-list-alt-matchp
   abnf::cstss
   "cws %s\"increment\" ws identifier \"[\" ws operand ws \"]\" ws %s\"by\" ws operand ws \";\"")
  (or
   (cst-list-list-conc-matchp
    abnf::cstss
    "cws %s\"increment\" ws identifier \"[\" ws operand ws \"]\" ws %s\"by\" ws operand ws \";\""))))

Theorem: cst-command-concs

(defthm cst-command-concs
 (implies
    (cst-list-list-alt-matchp abnf::cstss
                              "decrement / increment / instruction")
    (or (cst-list-list-conc-matchp abnf::cstss "decrement")
        (cst-list-list-conc-matchp abnf::cstss "increment")
        (cst-list-list-conc-matchp abnf::cstss "instruction"))))

Theorem: cst-finalize-command-concs

(defthm cst-finalize-command-concs
  (implies (cst-list-list-alt-matchp
                abnf::cstss
                "cws %s\"finalize\" *( ws operand ) ws \";\"")
           (or (cst-list-list-conc-matchp
                    abnf::cstss
                    "cws %s\"finalize\" *( ws operand ) ws \";\""))))

Theorem: cst-function-concs

(defthm cst-function-concs
 (implies
  (cst-list-list-alt-matchp
   abnf::cstss
   "cws %s\"function\" ws identifier ws \":\" *function-input 1*instruction *function-output")
  (or
   (cst-list-list-conc-matchp
    abnf::cstss
    "cws %s\"function\" ws identifier ws \":\" *function-input 1*instruction *function-output"))))

Theorem: cst-function-input-concs

(defthm cst-function-input-concs
 (implies
  (cst-list-list-alt-matchp
      abnf::cstss
      "cws %s\"input\" ws register ws %s\"as\" ws register-type ws \";\"")
  (or
   (cst-list-list-conc-matchp
    abnf::cstss
    "cws %s\"input\" ws register ws %s\"as\" ws register-type ws \";\""))))

Theorem: cst-function-output-concs

(defthm cst-function-output-concs
 (implies
  (cst-list-list-alt-matchp
   abnf::cstss
   "cws %s\"output\" ws register-access ws %s\"as\" ws register-type ws \";\"")
  (or
   (cst-list-list-conc-matchp
    abnf::cstss
    "cws %s\"output\" ws register-access ws %s\"as\" ws register-type ws \";\""))))

Theorem: cst-transition-concs

(defthm cst-transition-concs
 (implies
  (cst-list-list-alt-matchp
   abnf::cstss
   "cws %s\"transition\" ws identifier ws \":\" *transition-input *instruction *transition-output [ finalize-command finalize ]")
  (or
   (cst-list-list-conc-matchp
    abnf::cstss
    "cws %s\"transition\" ws identifier ws \":\" *transition-input *instruction *transition-output [ finalize-command finalize ]"))))

Theorem: cst-transition-input-concs

(defthm cst-transition-input-concs
 (implies
  (cst-list-list-alt-matchp
       abnf::cstss
       "cws %s\"input\" ws register ws %s\"as\" ws value-type ws \";\"")
  (or
   (cst-list-list-conc-matchp
      abnf::cstss
      "cws %s\"input\" ws register ws %s\"as\" ws value-type ws \";\""))))

Theorem: cst-transition-output-concs

(defthm cst-transition-output-concs
 (implies
  (cst-list-list-alt-matchp
   abnf::cstss
   "cws %s\"output\" ws register-access ws %s\"as\" ws value-type ws \";\"")
  (or
   (cst-list-list-conc-matchp
    abnf::cstss
    "cws %s\"output\" ws register-access ws %s\"as\" ws value-type ws \";\""))))

Theorem: cst-finalize-concs

(defthm cst-finalize-concs
 (implies
  (cst-list-list-alt-matchp
   abnf::cstss
   "cws %s\"finalize\" ws identifier ws \":\" *finalize-input 1*command *finalize-output")
  (or
   (cst-list-list-conc-matchp
    abnf::cstss
    "cws %s\"finalize\" ws identifier ws \":\" *finalize-input 1*command *finalize-output"))))

Theorem: cst-finalize-input-concs

(defthm cst-finalize-input-concs
 (implies
  (cst-list-list-alt-matchp
      abnf::cstss
      "cws %s\"input\" ws register ws %s\"as\" ws finalize-type ws \";\"")
  (or
   (cst-list-list-conc-matchp
    abnf::cstss
    "cws %s\"input\" ws register ws %s\"as\" ws finalize-type ws \";\""))))

Theorem: cst-finalize-output-concs

(defthm cst-finalize-output-concs
 (implies
  (cst-list-list-alt-matchp
   abnf::cstss
   "cws %s\"output\" ws register-access ws %s\"as\" ws finalize-type ws \";\"")
  (or
   (cst-list-list-conc-matchp
    abnf::cstss
    "cws %s\"output\" ws register-access ws %s\"as\" ws finalize-type ws \";\""))))

Theorem: cst-program-concs

(defthm cst-program-concs
 (implies
  (cst-list-list-alt-matchp
   abnf::cstss
   "*import cws %s\"program\" ws program-id ws \";\" 1*( mapping / struct / record / function / transition ) cws")
  (or
   (cst-list-list-conc-matchp
    abnf::cstss
    "*import cws %s\"program\" ws program-id ws \";\" 1*( mapping / struct / record / function / transition ) cws"))))

Theorem: cst-ht-conc-matching

(defthm cst-ht-conc-matching
  (implies (cst-list-list-conc-matchp abnf::cstss "%x9")
           (and (equal (len abnf::cstss) 1)
                (cst-list-rep-matchp (nth 0 abnf::cstss)
                                     "%x9"))))

Theorem: cst-lf-conc-matching

(defthm cst-lf-conc-matching
  (implies (cst-list-list-conc-matchp abnf::cstss "%xA")
           (and (equal (len abnf::cstss) 1)
                (cst-list-rep-matchp (nth 0 abnf::cstss)
                                     "%xA"))))

Theorem: cst-cr-conc-matching

(defthm cst-cr-conc-matching
  (implies (cst-list-list-conc-matchp abnf::cstss "%xD")
           (and (equal (len abnf::cstss) 1)
                (cst-list-rep-matchp (nth 0 abnf::cstss)
                                     "%xD"))))

Theorem: cst-sp-conc-matching

(defthm cst-sp-conc-matching
  (implies (cst-list-list-conc-matchp abnf::cstss "%x20")
           (and (equal (len abnf::cstss) 1)
                (cst-list-rep-matchp (nth 0 abnf::cstss)
                                     "%x20"))))

Theorem: cst-dq-conc-matching

(defthm cst-dq-conc-matching
  (implies (cst-list-list-conc-matchp abnf::cstss "%x22")
           (and (equal (len abnf::cstss) 1)
                (cst-list-rep-matchp (nth 0 abnf::cstss)
                                     "%x22"))))

Theorem: cst-visible-ascii-conc-matching

(defthm cst-visible-ascii-conc-matching
  (implies (cst-list-list-conc-matchp abnf::cstss "%x21-7E")
           (and (equal (len abnf::cstss) 1)
                (cst-list-rep-matchp (nth 0 abnf::cstss)
                                     "%x21-7E"))))

Theorem: cst-safe-ascii-conc1-matching

(defthm cst-safe-ascii-conc1-matching
  (implies (cst-list-list-conc-matchp abnf::cstss "ht")
           (and (equal (len abnf::cstss) 1)
                (cst-list-rep-matchp (nth 0 abnf::cstss)
                                     "ht"))))

Theorem: cst-safe-ascii-conc2-matching

(defthm cst-safe-ascii-conc2-matching
  (implies (cst-list-list-conc-matchp abnf::cstss "lf")
           (and (equal (len abnf::cstss) 1)
                (cst-list-rep-matchp (nth 0 abnf::cstss)
                                     "lf"))))

Theorem: cst-safe-ascii-conc3-matching

(defthm cst-safe-ascii-conc3-matching
  (implies (cst-list-list-conc-matchp abnf::cstss "cr")
           (and (equal (len abnf::cstss) 1)
                (cst-list-rep-matchp (nth 0 abnf::cstss)
                                     "cr"))))

Theorem: cst-safe-ascii-conc4-matching

(defthm cst-safe-ascii-conc4-matching
  (implies (cst-list-list-conc-matchp abnf::cstss "sp")
           (and (equal (len abnf::cstss) 1)
                (cst-list-rep-matchp (nth 0 abnf::cstss)
                                     "sp"))))

Theorem: cst-safe-ascii-conc5-matching

(defthm cst-safe-ascii-conc5-matching
  (implies (cst-list-list-conc-matchp abnf::cstss "visible-ascii")
           (and (equal (len abnf::cstss) 1)
                (cst-list-rep-matchp (nth 0 abnf::cstss)
                                     "visible-ascii"))))

Theorem: cst-safe-nonascii-conc1-matching

(defthm cst-safe-nonascii-conc1-matching
  (implies (cst-list-list-conc-matchp abnf::cstss "%x80-2029")
           (and (equal (len abnf::cstss) 1)
                (cst-list-rep-matchp (nth 0 abnf::cstss)
                                     "%x80-2029"))))

Theorem: cst-safe-nonascii-conc2-matching

(defthm cst-safe-nonascii-conc2-matching
  (implies (cst-list-list-conc-matchp abnf::cstss "%x202F-2065")
           (and (equal (len abnf::cstss) 1)
                (cst-list-rep-matchp (nth 0 abnf::cstss)
                                     "%x202F-2065"))))

Theorem: cst-safe-nonascii-conc3-matching

(defthm cst-safe-nonascii-conc3-matching
  (implies (cst-list-list-conc-matchp abnf::cstss "%x206A-D7FF")
           (and (equal (len abnf::cstss) 1)
                (cst-list-rep-matchp (nth 0 abnf::cstss)
                                     "%x206A-D7FF"))))

Theorem: cst-safe-nonascii-conc4-matching

(defthm cst-safe-nonascii-conc4-matching
  (implies (cst-list-list-conc-matchp abnf::cstss "%xE000-10FFFF")
           (and (equal (len abnf::cstss) 1)
                (cst-list-rep-matchp (nth 0 abnf::cstss)
                                     "%xE000-10FFFF"))))

Theorem: cst-character-conc1-matching

(defthm cst-character-conc1-matching
  (implies (cst-list-list-conc-matchp abnf::cstss "safe-ascii")
           (and (equal (len abnf::cstss) 1)
                (cst-list-rep-matchp (nth 0 abnf::cstss)
                                     "safe-ascii"))))

Theorem: cst-character-conc2-matching

(defthm cst-character-conc2-matching
  (implies (cst-list-list-conc-matchp abnf::cstss "safe-nonascii")
           (and (equal (len abnf::cstss) 1)
                (cst-list-rep-matchp (nth 0 abnf::cstss)
                                     "safe-nonascii"))))

Theorem: cst-plain-ws-conc1-matching

(defthm cst-plain-ws-conc1-matching
  (implies (cst-list-list-conc-matchp abnf::cstss "ht")
           (and (equal (len abnf::cstss) 1)
                (cst-list-rep-matchp (nth 0 abnf::cstss)
                                     "ht"))))

Theorem: cst-plain-ws-conc2-matching

(defthm cst-plain-ws-conc2-matching
  (implies (cst-list-list-conc-matchp abnf::cstss "sp")
           (and (equal (len abnf::cstss) 1)
                (cst-list-rep-matchp (nth 0 abnf::cstss)
                                     "sp"))))

Theorem: cst-plain-ws-conc3-matching

(defthm cst-plain-ws-conc3-matching
  (implies (cst-list-list-conc-matchp abnf::cstss "lf")
           (and (equal (len abnf::cstss) 1)
                (cst-list-rep-matchp (nth 0 abnf::cstss)
                                     "lf"))))

Theorem: cst-plain-ws-conc4-matching

(defthm cst-plain-ws-conc4-matching
  (implies (cst-list-list-conc-matchp abnf::cstss "cr")
           (and (equal (len abnf::cstss) 1)
                (cst-list-rep-matchp (nth 0 abnf::cstss)
                                     "cr"))))

Theorem: cst-ws-conc-matching

(defthm cst-ws-conc-matching
  (implies
       (cst-list-list-conc-matchp abnf::cstss
                                  "*( 1*plain-ws / escaped-lf )")
       (and (equal (len abnf::cstss) 1)
            (cst-list-rep-matchp (nth 0 abnf::cstss)
                                 "*( 1*plain-ws / escaped-lf )"))))

Theorem: cst-comment-conc1-matching

(defthm cst-comment-conc1-matching
  (implies (cst-list-list-conc-matchp abnf::cstss "line-comment")
           (and (equal (len abnf::cstss) 1)
                (cst-list-rep-matchp (nth 0 abnf::cstss)
                                     "line-comment"))))

Theorem: cst-comment-conc2-matching

(defthm cst-comment-conc2-matching
  (implies (cst-list-list-conc-matchp abnf::cstss "block-comment")
           (and (equal (len abnf::cstss) 1)
                (cst-list-rep-matchp (nth 0 abnf::cstss)
                                     "block-comment"))))

Theorem: cst-not-lf-or-cr-conc1-matching

(defthm cst-not-lf-or-cr-conc1-matching
  (implies (cst-list-list-conc-matchp abnf::cstss "ht")
           (and (equal (len abnf::cstss) 1)
                (cst-list-rep-matchp (nth 0 abnf::cstss)
                                     "ht"))))

Theorem: cst-not-lf-or-cr-conc2-matching

(defthm cst-not-lf-or-cr-conc2-matching
  (implies (cst-list-list-conc-matchp abnf::cstss "sp")
           (and (equal (len abnf::cstss) 1)
                (cst-list-rep-matchp (nth 0 abnf::cstss)
                                     "sp"))))

Theorem: cst-not-lf-or-cr-conc3-matching

(defthm cst-not-lf-or-cr-conc3-matching
  (implies (cst-list-list-conc-matchp abnf::cstss "visible-ascii")
           (and (equal (len abnf::cstss) 1)
                (cst-list-rep-matchp (nth 0 abnf::cstss)
                                     "visible-ascii"))))

Theorem: cst-not-lf-or-cr-conc4-matching

(defthm cst-not-lf-or-cr-conc4-matching
  (implies (cst-list-list-conc-matchp abnf::cstss "safe-nonascii")
           (and (equal (len abnf::cstss) 1)
                (cst-list-rep-matchp (nth 0 abnf::cstss)
                                     "safe-nonascii"))))

Theorem: cst-not-star-conc1-matching

(defthm cst-not-star-conc1-matching
  (implies (cst-list-list-conc-matchp abnf::cstss "ht")
           (and (equal (len abnf::cstss) 1)
                (cst-list-rep-matchp (nth 0 abnf::cstss)
                                     "ht"))))

Theorem: cst-not-star-conc2-matching

(defthm cst-not-star-conc2-matching
  (implies (cst-list-list-conc-matchp abnf::cstss "lf")
           (and (equal (len abnf::cstss) 1)
                (cst-list-rep-matchp (nth 0 abnf::cstss)
                                     "lf"))))

Theorem: cst-not-star-conc3-matching

(defthm cst-not-star-conc3-matching
  (implies (cst-list-list-conc-matchp abnf::cstss "cr")
           (and (equal (len abnf::cstss) 1)
                (cst-list-rep-matchp (nth 0 abnf::cstss)
                                     "cr"))))

Theorem: cst-not-star-conc4-matching

(defthm cst-not-star-conc4-matching
  (implies (cst-list-list-conc-matchp abnf::cstss "%x20-29")
           (and (equal (len abnf::cstss) 1)
                (cst-list-rep-matchp (nth 0 abnf::cstss)
                                     "%x20-29"))))

Theorem: cst-not-star-conc5-matching

(defthm cst-not-star-conc5-matching
  (implies (cst-list-list-conc-matchp abnf::cstss "%x2B-7E")
           (and (equal (len abnf::cstss) 1)
                (cst-list-rep-matchp (nth 0 abnf::cstss)
                                     "%x2B-7E"))))

Theorem: cst-not-star-conc6-matching

(defthm cst-not-star-conc6-matching
  (implies (cst-list-list-conc-matchp abnf::cstss "safe-nonascii")
           (and (equal (len abnf::cstss) 1)
                (cst-list-rep-matchp (nth 0 abnf::cstss)
                                     "safe-nonascii"))))

Theorem: cst-rest-of-block-comment-after-star-conc1-matching

(defthm cst-rest-of-block-comment-after-star-conc1-matching
  (implies (cst-list-list-conc-matchp abnf::cstss "\"/\"")
           (and (equal (len abnf::cstss) 1)
                (cst-list-rep-matchp (nth 0 abnf::cstss)
                                     "\"/\""))))

Theorem: cst-not-star-or-slash-conc1-matching

(defthm cst-not-star-or-slash-conc1-matching
  (implies (cst-list-list-conc-matchp abnf::cstss "ht")
           (and (equal (len abnf::cstss) 1)
                (cst-list-rep-matchp (nth 0 abnf::cstss)
                                     "ht"))))

Theorem: cst-not-star-or-slash-conc2-matching

(defthm cst-not-star-or-slash-conc2-matching
  (implies (cst-list-list-conc-matchp abnf::cstss "lf")
           (and (equal (len abnf::cstss) 1)
                (cst-list-rep-matchp (nth 0 abnf::cstss)
                                     "lf"))))

Theorem: cst-not-star-or-slash-conc3-matching

(defthm cst-not-star-or-slash-conc3-matching
  (implies (cst-list-list-conc-matchp abnf::cstss "cr")
           (and (equal (len abnf::cstss) 1)
                (cst-list-rep-matchp (nth 0 abnf::cstss)
                                     "cr"))))

Theorem: cst-not-star-or-slash-conc4-matching

(defthm cst-not-star-or-slash-conc4-matching
  (implies (cst-list-list-conc-matchp abnf::cstss "%x20-29")
           (and (equal (len abnf::cstss) 1)
                (cst-list-rep-matchp (nth 0 abnf::cstss)
                                     "%x20-29"))))

Theorem: cst-not-star-or-slash-conc5-matching

(defthm cst-not-star-or-slash-conc5-matching
  (implies (cst-list-list-conc-matchp abnf::cstss "%x2B-2E")
           (and (equal (len abnf::cstss) 1)
                (cst-list-rep-matchp (nth 0 abnf::cstss)
                                     "%x2B-2E"))))

Theorem: cst-not-star-or-slash-conc6-matching

(defthm cst-not-star-or-slash-conc6-matching
  (implies (cst-list-list-conc-matchp abnf::cstss "%x30-7E")
           (and (equal (len abnf::cstss) 1)
                (cst-list-rep-matchp (nth 0 abnf::cstss)
                                     "%x30-7E"))))

Theorem: cst-not-star-or-slash-conc7-matching

(defthm cst-not-star-or-slash-conc7-matching
  (implies (cst-list-list-conc-matchp abnf::cstss "safe-nonascii")
           (and (equal (len abnf::cstss) 1)
                (cst-list-rep-matchp (nth 0 abnf::cstss)
                                     "safe-nonascii"))))

Theorem: cst-uppercase-letter-conc-matching

(defthm cst-uppercase-letter-conc-matching
  (implies (cst-list-list-conc-matchp abnf::cstss "%x41-5A")
           (and (equal (len abnf::cstss) 1)
                (cst-list-rep-matchp (nth 0 abnf::cstss)
                                     "%x41-5A"))))

Theorem: cst-lowercase-letter-conc-matching

(defthm cst-lowercase-letter-conc-matching
  (implies (cst-list-list-conc-matchp abnf::cstss "%x61-7A")
           (and (equal (len abnf::cstss) 1)
                (cst-list-rep-matchp (nth 0 abnf::cstss)
                                     "%x61-7A"))))

Theorem: cst-letter-conc1-matching

(defthm cst-letter-conc1-matching
 (implies (cst-list-list-conc-matchp abnf::cstss "uppercase-letter")
          (and (equal (len abnf::cstss) 1)
               (cst-list-rep-matchp (nth 0 abnf::cstss)
                                    "uppercase-letter"))))

Theorem: cst-letter-conc2-matching

(defthm cst-letter-conc2-matching
 (implies (cst-list-list-conc-matchp abnf::cstss "lowercase-letter")
          (and (equal (len abnf::cstss) 1)
               (cst-list-rep-matchp (nth 0 abnf::cstss)
                                    "lowercase-letter"))))

Theorem: cst-digit-conc-matching

(defthm cst-digit-conc-matching
  (implies (cst-list-list-conc-matchp abnf::cstss "%x30-39")
           (and (equal (len abnf::cstss) 1)
                (cst-list-rep-matchp (nth 0 abnf::cstss)
                                     "%x30-39"))))

Theorem: cst-hex-digit-conc1-matching

(defthm cst-hex-digit-conc1-matching
  (implies (cst-list-list-conc-matchp abnf::cstss "digit")
           (and (equal (len abnf::cstss) 1)
                (cst-list-rep-matchp (nth 0 abnf::cstss)
                                     "digit"))))

Theorem: cst-hex-digit-conc2-matching

(defthm cst-hex-digit-conc2-matching
  (implies (cst-list-list-conc-matchp abnf::cstss "\"a\"")
           (and (equal (len abnf::cstss) 1)
                (cst-list-rep-matchp (nth 0 abnf::cstss)
                                     "\"a\""))))

Theorem: cst-hex-digit-conc3-matching

(defthm cst-hex-digit-conc3-matching
  (implies (cst-list-list-conc-matchp abnf::cstss "\"b\"")
           (and (equal (len abnf::cstss) 1)
                (cst-list-rep-matchp (nth 0 abnf::cstss)
                                     "\"b\""))))

Theorem: cst-hex-digit-conc4-matching

(defthm cst-hex-digit-conc4-matching
  (implies (cst-list-list-conc-matchp abnf::cstss "\"c\"")
           (and (equal (len abnf::cstss) 1)
                (cst-list-rep-matchp (nth 0 abnf::cstss)
                                     "\"c\""))))

Theorem: cst-hex-digit-conc5-matching

(defthm cst-hex-digit-conc5-matching
  (implies (cst-list-list-conc-matchp abnf::cstss "\"d\"")
           (and (equal (len abnf::cstss) 1)
                (cst-list-rep-matchp (nth 0 abnf::cstss)
                                     "\"d\""))))

Theorem: cst-hex-digit-conc6-matching

(defthm cst-hex-digit-conc6-matching
  (implies (cst-list-list-conc-matchp abnf::cstss "\"e\"")
           (and (equal (len abnf::cstss) 1)
                (cst-list-rep-matchp (nth 0 abnf::cstss)
                                     "\"e\""))))

Theorem: cst-hex-digit-conc7-matching

(defthm cst-hex-digit-conc7-matching
  (implies (cst-list-list-conc-matchp abnf::cstss "\"f\"")
           (and (equal (len abnf::cstss) 1)
                (cst-list-rep-matchp (nth 0 abnf::cstss)
                                     "\"f\""))))

Theorem: cst-integer-literal-conc1-matching

(defthm cst-integer-literal-conc1-matching
  (implies (cst-list-list-conc-matchp abnf::cstss "signed-literal")
           (and (equal (len abnf::cstss) 1)
                (cst-list-rep-matchp (nth 0 abnf::cstss)
                                     "signed-literal"))))

Theorem: cst-integer-literal-conc2-matching

(defthm cst-integer-literal-conc2-matching
 (implies (cst-list-list-conc-matchp abnf::cstss "unsigned-literal")
          (and (equal (len abnf::cstss) 1)
               (cst-list-rep-matchp (nth 0 abnf::cstss)
                                    "unsigned-literal"))))

Theorem: cst-arithmetic-literal-conc1-matching

(defthm cst-arithmetic-literal-conc1-matching
  (implies (cst-list-list-conc-matchp abnf::cstss "integer-literal")
           (and (equal (len abnf::cstss) 1)
                (cst-list-rep-matchp (nth 0 abnf::cstss)
                                     "integer-literal"))))

Theorem: cst-arithmetic-literal-conc2-matching

(defthm cst-arithmetic-literal-conc2-matching
  (implies (cst-list-list-conc-matchp abnf::cstss "field-literal")
           (and (equal (len abnf::cstss) 1)
                (cst-list-rep-matchp (nth 0 abnf::cstss)
                                     "field-literal"))))

Theorem: cst-arithmetic-literal-conc3-matching

(defthm cst-arithmetic-literal-conc3-matching
  (implies (cst-list-list-conc-matchp abnf::cstss "group-literal")
           (and (equal (len abnf::cstss) 1)
                (cst-list-rep-matchp (nth 0 abnf::cstss)
                                     "group-literal"))))

Theorem: cst-arithmetic-literal-conc4-matching

(defthm cst-arithmetic-literal-conc4-matching
  (implies (cst-list-list-conc-matchp abnf::cstss "scalar-literal")
           (and (equal (len abnf::cstss) 1)
                (cst-list-rep-matchp (nth 0 abnf::cstss)
                                     "scalar-literal"))))

Theorem: cst-address-char-conc1-matching

(defthm cst-address-char-conc1-matching
  (implies (cst-list-list-conc-matchp abnf::cstss "\"0\"")
           (and (equal (len abnf::cstss) 1)
                (cst-list-rep-matchp (nth 0 abnf::cstss)
                                     "\"0\""))))

Theorem: cst-address-char-conc2-matching

(defthm cst-address-char-conc2-matching
  (implies (cst-list-list-conc-matchp abnf::cstss "\"2\"")
           (and (equal (len abnf::cstss) 1)
                (cst-list-rep-matchp (nth 0 abnf::cstss)
                                     "\"2\""))))

Theorem: cst-address-char-conc3-matching

(defthm cst-address-char-conc3-matching
  (implies (cst-list-list-conc-matchp abnf::cstss "\"3\"")
           (and (equal (len abnf::cstss) 1)
                (cst-list-rep-matchp (nth 0 abnf::cstss)
                                     "\"3\""))))

Theorem: cst-address-char-conc4-matching

(defthm cst-address-char-conc4-matching
  (implies (cst-list-list-conc-matchp abnf::cstss "\"4\"")
           (and (equal (len abnf::cstss) 1)
                (cst-list-rep-matchp (nth 0 abnf::cstss)
                                     "\"4\""))))

Theorem: cst-address-char-conc5-matching

(defthm cst-address-char-conc5-matching
  (implies (cst-list-list-conc-matchp abnf::cstss "\"5\"")
           (and (equal (len abnf::cstss) 1)
                (cst-list-rep-matchp (nth 0 abnf::cstss)
                                     "\"5\""))))

Theorem: cst-address-char-conc6-matching

(defthm cst-address-char-conc6-matching
  (implies (cst-list-list-conc-matchp abnf::cstss "\"6\"")
           (and (equal (len abnf::cstss) 1)
                (cst-list-rep-matchp (nth 0 abnf::cstss)
                                     "\"6\""))))

Theorem: cst-address-char-conc7-matching

(defthm cst-address-char-conc7-matching
  (implies (cst-list-list-conc-matchp abnf::cstss "\"7\"")
           (and (equal (len abnf::cstss) 1)
                (cst-list-rep-matchp (nth 0 abnf::cstss)
                                     "\"7\""))))

Theorem: cst-address-char-conc8-matching

(defthm cst-address-char-conc8-matching
  (implies (cst-list-list-conc-matchp abnf::cstss "\"8\"")
           (and (equal (len abnf::cstss) 1)
                (cst-list-rep-matchp (nth 0 abnf::cstss)
                                     "\"8\""))))

Theorem: cst-address-char-conc9-matching

(defthm cst-address-char-conc9-matching
  (implies (cst-list-list-conc-matchp abnf::cstss "\"9\"")
           (and (equal (len abnf::cstss) 1)
                (cst-list-rep-matchp (nth 0 abnf::cstss)
                                     "\"9\""))))

Theorem: cst-address-char-conc10-matching

(defthm cst-address-char-conc10-matching
  (implies (cst-list-list-conc-matchp abnf::cstss "%s\"a\"")
           (and (equal (len abnf::cstss) 1)
                (cst-list-rep-matchp (nth 0 abnf::cstss)
                                     "%s\"a\""))))

Theorem: cst-address-char-conc11-matching

(defthm cst-address-char-conc11-matching
  (implies (cst-list-list-conc-matchp abnf::cstss "%s\"c\"")
           (and (equal (len abnf::cstss) 1)
                (cst-list-rep-matchp (nth 0 abnf::cstss)
                                     "%s\"c\""))))

Theorem: cst-address-char-conc12-matching

(defthm cst-address-char-conc12-matching
  (implies (cst-list-list-conc-matchp abnf::cstss "%s\"d\"")
           (and (equal (len abnf::cstss) 1)
                (cst-list-rep-matchp (nth 0 abnf::cstss)
                                     "%s\"d\""))))

Theorem: cst-address-char-conc13-matching

(defthm cst-address-char-conc13-matching
  (implies (cst-list-list-conc-matchp abnf::cstss "%s\"e\"")
           (and (equal (len abnf::cstss) 1)
                (cst-list-rep-matchp (nth 0 abnf::cstss)
                                     "%s\"e\""))))

Theorem: cst-address-char-conc14-matching

(defthm cst-address-char-conc14-matching
  (implies (cst-list-list-conc-matchp abnf::cstss "%s\"f\"")
           (and (equal (len abnf::cstss) 1)
                (cst-list-rep-matchp (nth 0 abnf::cstss)
                                     "%s\"f\""))))

Theorem: cst-address-char-conc15-matching

(defthm cst-address-char-conc15-matching
  (implies (cst-list-list-conc-matchp abnf::cstss "%s\"g\"")
           (and (equal (len abnf::cstss) 1)
                (cst-list-rep-matchp (nth 0 abnf::cstss)
                                     "%s\"g\""))))

Theorem: cst-address-char-conc16-matching

(defthm cst-address-char-conc16-matching
  (implies (cst-list-list-conc-matchp abnf::cstss "%s\"h\"")
           (and (equal (len abnf::cstss) 1)
                (cst-list-rep-matchp (nth 0 abnf::cstss)
                                     "%s\"h\""))))

Theorem: cst-address-char-conc17-matching

(defthm cst-address-char-conc17-matching
  (implies (cst-list-list-conc-matchp abnf::cstss "%s\"j\"")
           (and (equal (len abnf::cstss) 1)
                (cst-list-rep-matchp (nth 0 abnf::cstss)
                                     "%s\"j\""))))

Theorem: cst-address-char-conc18-matching

(defthm cst-address-char-conc18-matching
  (implies (cst-list-list-conc-matchp abnf::cstss "%s\"k\"")
           (and (equal (len abnf::cstss) 1)
                (cst-list-rep-matchp (nth 0 abnf::cstss)
                                     "%s\"k\""))))

Theorem: cst-address-char-conc19-matching

(defthm cst-address-char-conc19-matching
  (implies (cst-list-list-conc-matchp abnf::cstss "%s\"l\"")
           (and (equal (len abnf::cstss) 1)
                (cst-list-rep-matchp (nth 0 abnf::cstss)
                                     "%s\"l\""))))

Theorem: cst-address-char-conc20-matching

(defthm cst-address-char-conc20-matching
  (implies (cst-list-list-conc-matchp abnf::cstss "%s\"m\"")
           (and (equal (len abnf::cstss) 1)
                (cst-list-rep-matchp (nth 0 abnf::cstss)
                                     "%s\"m\""))))

Theorem: cst-address-char-conc21-matching

(defthm cst-address-char-conc21-matching
  (implies (cst-list-list-conc-matchp abnf::cstss "%s\"n\"")
           (and (equal (len abnf::cstss) 1)
                (cst-list-rep-matchp (nth 0 abnf::cstss)
                                     "%s\"n\""))))

Theorem: cst-address-char-conc22-matching

(defthm cst-address-char-conc22-matching
  (implies (cst-list-list-conc-matchp abnf::cstss "%s\"p\"")
           (and (equal (len abnf::cstss) 1)
                (cst-list-rep-matchp (nth 0 abnf::cstss)
                                     "%s\"p\""))))

Theorem: cst-address-char-conc23-matching

(defthm cst-address-char-conc23-matching
  (implies (cst-list-list-conc-matchp abnf::cstss "%s\"q\"")
           (and (equal (len abnf::cstss) 1)
                (cst-list-rep-matchp (nth 0 abnf::cstss)
                                     "%s\"q\""))))

Theorem: cst-address-char-conc24-matching

(defthm cst-address-char-conc24-matching
  (implies (cst-list-list-conc-matchp abnf::cstss "%s\"r\"")
           (and (equal (len abnf::cstss) 1)
                (cst-list-rep-matchp (nth 0 abnf::cstss)
                                     "%s\"r\""))))

Theorem: cst-address-char-conc25-matching

(defthm cst-address-char-conc25-matching
  (implies (cst-list-list-conc-matchp abnf::cstss "%s\"s\"")
           (and (equal (len abnf::cstss) 1)
                (cst-list-rep-matchp (nth 0 abnf::cstss)
                                     "%s\"s\""))))

Theorem: cst-address-char-conc26-matching

(defthm cst-address-char-conc26-matching
  (implies (cst-list-list-conc-matchp abnf::cstss "%s\"t\"")
           (and (equal (len abnf::cstss) 1)
                (cst-list-rep-matchp (nth 0 abnf::cstss)
                                     "%s\"t\""))))

Theorem: cst-address-char-conc27-matching

(defthm cst-address-char-conc27-matching
  (implies (cst-list-list-conc-matchp abnf::cstss "%s\"u\"")
           (and (equal (len abnf::cstss) 1)
                (cst-list-rep-matchp (nth 0 abnf::cstss)
                                     "%s\"u\""))))

Theorem: cst-address-char-conc28-matching

(defthm cst-address-char-conc28-matching
  (implies (cst-list-list-conc-matchp abnf::cstss "%s\"v\"")
           (and (equal (len abnf::cstss) 1)
                (cst-list-rep-matchp (nth 0 abnf::cstss)
                                     "%s\"v\""))))

Theorem: cst-address-char-conc29-matching

(defthm cst-address-char-conc29-matching
  (implies (cst-list-list-conc-matchp abnf::cstss "%s\"w\"")
           (and (equal (len abnf::cstss) 1)
                (cst-list-rep-matchp (nth 0 abnf::cstss)
                                     "%s\"w\""))))

Theorem: cst-address-char-conc30-matching

(defthm cst-address-char-conc30-matching
  (implies (cst-list-list-conc-matchp abnf::cstss "%s\"x\"")
           (and (equal (len abnf::cstss) 1)
                (cst-list-rep-matchp (nth 0 abnf::cstss)
                                     "%s\"x\""))))

Theorem: cst-address-char-conc31-matching

(defthm cst-address-char-conc31-matching
  (implies (cst-list-list-conc-matchp abnf::cstss "%s\"y\"")
           (and (equal (len abnf::cstss) 1)
                (cst-list-rep-matchp (nth 0 abnf::cstss)
                                     "%s\"y\""))))

Theorem: cst-address-char-conc32-matching

(defthm cst-address-char-conc32-matching
  (implies (cst-list-list-conc-matchp abnf::cstss "%s\"z\"")
           (and (equal (len abnf::cstss) 1)
                (cst-list-rep-matchp (nth 0 abnf::cstss)
                                     "%s\"z\""))))

Theorem: cst-boolean-literal-conc1-matching

(defthm cst-boolean-literal-conc1-matching
  (implies (cst-list-list-conc-matchp abnf::cstss "%s\"true\"")
           (and (equal (len abnf::cstss) 1)
                (cst-list-rep-matchp (nth 0 abnf::cstss)
                                     "%s\"true\""))))

Theorem: cst-boolean-literal-conc2-matching

(defthm cst-boolean-literal-conc2-matching
  (implies (cst-list-list-conc-matchp abnf::cstss "%s\"false\"")
           (and (equal (len abnf::cstss) 1)
                (cst-list-rep-matchp (nth 0 abnf::cstss)
                                     "%s\"false\""))))

Theorem: cst-string-element-conc1-matching

(defthm cst-string-element-conc1-matching
  (implies
       (cst-list-list-conc-matchp abnf::cstss "not-dq-or-backslash")
       (and (equal (len abnf::cstss) 1)
            (cst-list-rep-matchp (nth 0 abnf::cstss)
                                 "not-dq-or-backslash"))))

Theorem: cst-string-element-conc2-matching

(defthm cst-string-element-conc2-matching
  (implies (cst-list-list-conc-matchp abnf::cstss "escaped-char")
           (and (equal (len abnf::cstss) 1)
                (cst-list-rep-matchp (nth 0 abnf::cstss)
                                     "escaped-char"))))

Theorem: cst-string-element-conc3-matching

(defthm cst-string-element-conc3-matching
  (implies (cst-list-list-conc-matchp abnf::cstss "escaped-ws")
           (and (equal (len abnf::cstss) 1)
                (cst-list-rep-matchp (nth 0 abnf::cstss)
                                     "escaped-ws"))))

Theorem: cst-not-dq-or-backslash-conc1-matching

(defthm cst-not-dq-or-backslash-conc1-matching
  (implies (cst-list-list-conc-matchp abnf::cstss "ht")
           (and (equal (len abnf::cstss) 1)
                (cst-list-rep-matchp (nth 0 abnf::cstss)
                                     "ht"))))

Theorem: cst-not-dq-or-backslash-conc2-matching

(defthm cst-not-dq-or-backslash-conc2-matching
  (implies (cst-list-list-conc-matchp abnf::cstss "lf")
           (and (equal (len abnf::cstss) 1)
                (cst-list-rep-matchp (nth 0 abnf::cstss)
                                     "lf"))))

Theorem: cst-not-dq-or-backslash-conc3-matching

(defthm cst-not-dq-or-backslash-conc3-matching
  (implies (cst-list-list-conc-matchp abnf::cstss "cr")
           (and (equal (len abnf::cstss) 1)
                (cst-list-rep-matchp (nth 0 abnf::cstss)
                                     "cr"))))

Theorem: cst-not-dq-or-backslash-conc4-matching

(defthm cst-not-dq-or-backslash-conc4-matching
  (implies (cst-list-list-conc-matchp abnf::cstss "%x20-21")
           (and (equal (len abnf::cstss) 1)
                (cst-list-rep-matchp (nth 0 abnf::cstss)
                                     "%x20-21"))))

Theorem: cst-not-dq-or-backslash-conc5-matching

(defthm cst-not-dq-or-backslash-conc5-matching
  (implies (cst-list-list-conc-matchp abnf::cstss "%x23-5B")
           (and (equal (len abnf::cstss) 1)
                (cst-list-rep-matchp (nth 0 abnf::cstss)
                                     "%x23-5B"))))

Theorem: cst-not-dq-or-backslash-conc6-matching

(defthm cst-not-dq-or-backslash-conc6-matching
  (implies (cst-list-list-conc-matchp abnf::cstss "%x5D-7E")
           (and (equal (len abnf::cstss) 1)
                (cst-list-rep-matchp (nth 0 abnf::cstss)
                                     "%x5D-7E"))))

Theorem: cst-not-dq-or-backslash-conc7-matching

(defthm cst-not-dq-or-backslash-conc7-matching
  (implies (cst-list-list-conc-matchp abnf::cstss "safe-nonascii")
           (and (equal (len abnf::cstss) 1)
                (cst-list-rep-matchp (nth 0 abnf::cstss)
                                     "safe-nonascii"))))

Theorem: cst-literal-conc1-matching

(defthm cst-literal-conc1-matching
  (implies
       (cst-list-list-conc-matchp abnf::cstss "arithmetic-literal")
       (and (equal (len abnf::cstss) 1)
            (cst-list-rep-matchp (nth 0 abnf::cstss)
                                 "arithmetic-literal"))))

Theorem: cst-literal-conc2-matching

(defthm cst-literal-conc2-matching
  (implies (cst-list-list-conc-matchp abnf::cstss "address-literal")
           (and (equal (len abnf::cstss) 1)
                (cst-list-rep-matchp (nth 0 abnf::cstss)
                                     "address-literal"))))

Theorem: cst-literal-conc3-matching

(defthm cst-literal-conc3-matching
  (implies (cst-list-list-conc-matchp abnf::cstss "boolean-literal")
           (and (equal (len abnf::cstss) 1)
                (cst-list-rep-matchp (nth 0 abnf::cstss)
                                     "boolean-literal"))))

Theorem: cst-literal-conc4-matching

(defthm cst-literal-conc4-matching
  (implies (cst-list-list-conc-matchp abnf::cstss "string-literal")
           (and (equal (len abnf::cstss) 1)
                (cst-list-rep-matchp (nth 0 abnf::cstss)
                                     "string-literal"))))

Theorem: cst-operand-conc1-matching

(defthm cst-operand-conc1-matching
  (implies (cst-list-list-conc-matchp abnf::cstss "literal")
           (and (equal (len abnf::cstss) 1)
                (cst-list-rep-matchp (nth 0 abnf::cstss)
                                     "literal"))))

Theorem: cst-operand-conc2-matching

(defthm cst-operand-conc2-matching
  (implies (cst-list-list-conc-matchp abnf::cstss "register-access")
           (and (equal (len abnf::cstss) 1)
                (cst-list-rep-matchp (nth 0 abnf::cstss)
                                     "register-access"))))

Theorem: cst-operand-conc3-matching

(defthm cst-operand-conc3-matching
  (implies (cst-list-list-conc-matchp abnf::cstss "%s\"self.caller\"")
           (and (equal (len abnf::cstss) 1)
                (cst-list-rep-matchp (nth 0 abnf::cstss)
                                     "%s\"self.caller\""))))

Theorem: cst-operand-conc4-matching

(defthm cst-operand-conc4-matching
  (implies (cst-list-list-conc-matchp abnf::cstss "program-id")
           (and (equal (len abnf::cstss) 1)
                (cst-list-rep-matchp (nth 0 abnf::cstss)
                                     "program-id"))))

Theorem: cst-unsigned-type-conc1-matching

(defthm cst-unsigned-type-conc1-matching
  (implies (cst-list-list-conc-matchp abnf::cstss "%s\"u8\"")
           (and (equal (len abnf::cstss) 1)
                (cst-list-rep-matchp (nth 0 abnf::cstss)
                                     "%s\"u8\""))))

Theorem: cst-unsigned-type-conc2-matching

(defthm cst-unsigned-type-conc2-matching
  (implies (cst-list-list-conc-matchp abnf::cstss "%s\"u16\"")
           (and (equal (len abnf::cstss) 1)
                (cst-list-rep-matchp (nth 0 abnf::cstss)
                                     "%s\"u16\""))))

Theorem: cst-unsigned-type-conc3-matching

(defthm cst-unsigned-type-conc3-matching
  (implies (cst-list-list-conc-matchp abnf::cstss "%s\"u32\"")
           (and (equal (len abnf::cstss) 1)
                (cst-list-rep-matchp (nth 0 abnf::cstss)
                                     "%s\"u32\""))))

Theorem: cst-unsigned-type-conc4-matching

(defthm cst-unsigned-type-conc4-matching
  (implies (cst-list-list-conc-matchp abnf::cstss "%s\"u64\"")
           (and (equal (len abnf::cstss) 1)
                (cst-list-rep-matchp (nth 0 abnf::cstss)
                                     "%s\"u64\""))))

Theorem: cst-unsigned-type-conc5-matching

(defthm cst-unsigned-type-conc5-matching
  (implies (cst-list-list-conc-matchp abnf::cstss "%s\"u128\"")
           (and (equal (len abnf::cstss) 1)
                (cst-list-rep-matchp (nth 0 abnf::cstss)
                                     "%s\"u128\""))))

Theorem: cst-signed-type-conc1-matching

(defthm cst-signed-type-conc1-matching
  (implies (cst-list-list-conc-matchp abnf::cstss "%s\"i8\"")
           (and (equal (len abnf::cstss) 1)
                (cst-list-rep-matchp (nth 0 abnf::cstss)
                                     "%s\"i8\""))))

Theorem: cst-signed-type-conc2-matching

(defthm cst-signed-type-conc2-matching
  (implies (cst-list-list-conc-matchp abnf::cstss "%s\"i16\"")
           (and (equal (len abnf::cstss) 1)
                (cst-list-rep-matchp (nth 0 abnf::cstss)
                                     "%s\"i16\""))))

Theorem: cst-signed-type-conc3-matching

(defthm cst-signed-type-conc3-matching
  (implies (cst-list-list-conc-matchp abnf::cstss "%s\"i32\"")
           (and (equal (len abnf::cstss) 1)
                (cst-list-rep-matchp (nth 0 abnf::cstss)
                                     "%s\"i32\""))))

Theorem: cst-signed-type-conc4-matching

(defthm cst-signed-type-conc4-matching
  (implies (cst-list-list-conc-matchp abnf::cstss "%s\"i64\"")
           (and (equal (len abnf::cstss) 1)
                (cst-list-rep-matchp (nth 0 abnf::cstss)
                                     "%s\"i64\""))))

Theorem: cst-signed-type-conc5-matching

(defthm cst-signed-type-conc5-matching
  (implies (cst-list-list-conc-matchp abnf::cstss "%s\"i128\"")
           (and (equal (len abnf::cstss) 1)
                (cst-list-rep-matchp (nth 0 abnf::cstss)
                                     "%s\"i128\""))))

Theorem: cst-integer-type-conc1-matching

(defthm cst-integer-type-conc1-matching
  (implies (cst-list-list-conc-matchp abnf::cstss "unsigned-type")
           (and (equal (len abnf::cstss) 1)
                (cst-list-rep-matchp (nth 0 abnf::cstss)
                                     "unsigned-type"))))

Theorem: cst-integer-type-conc2-matching

(defthm cst-integer-type-conc2-matching
  (implies (cst-list-list-conc-matchp abnf::cstss "signed-type")
           (and (equal (len abnf::cstss) 1)
                (cst-list-rep-matchp (nth 0 abnf::cstss)
                                     "signed-type"))))

Theorem: cst-field-type-conc-matching

(defthm cst-field-type-conc-matching
  (implies (cst-list-list-conc-matchp abnf::cstss "%s\"field\"")
           (and (equal (len abnf::cstss) 1)
                (cst-list-rep-matchp (nth 0 abnf::cstss)
                                     "%s\"field\""))))

Theorem: cst-group-type-conc-matching

(defthm cst-group-type-conc-matching
  (implies (cst-list-list-conc-matchp abnf::cstss "%s\"group\"")
           (and (equal (len abnf::cstss) 1)
                (cst-list-rep-matchp (nth 0 abnf::cstss)
                                     "%s\"group\""))))

Theorem: cst-scalar-type-conc-matching

(defthm cst-scalar-type-conc-matching
  (implies (cst-list-list-conc-matchp abnf::cstss "%s\"scalar\"")
           (and (equal (len abnf::cstss) 1)
                (cst-list-rep-matchp (nth 0 abnf::cstss)
                                     "%s\"scalar\""))))

Theorem: cst-arithmetic-type-conc1-matching

(defthm cst-arithmetic-type-conc1-matching
  (implies (cst-list-list-conc-matchp abnf::cstss "integer-type")
           (and (equal (len abnf::cstss) 1)
                (cst-list-rep-matchp (nth 0 abnf::cstss)
                                     "integer-type"))))

Theorem: cst-arithmetic-type-conc2-matching

(defthm cst-arithmetic-type-conc2-matching
  (implies (cst-list-list-conc-matchp abnf::cstss "field-type")
           (and (equal (len abnf::cstss) 1)
                (cst-list-rep-matchp (nth 0 abnf::cstss)
                                     "field-type"))))

Theorem: cst-arithmetic-type-conc3-matching

(defthm cst-arithmetic-type-conc3-matching
  (implies (cst-list-list-conc-matchp abnf::cstss "group-type")
           (and (equal (len abnf::cstss) 1)
                (cst-list-rep-matchp (nth 0 abnf::cstss)
                                     "group-type"))))

Theorem: cst-arithmetic-type-conc4-matching

(defthm cst-arithmetic-type-conc4-matching
  (implies (cst-list-list-conc-matchp abnf::cstss "scalar-type")
           (and (equal (len abnf::cstss) 1)
                (cst-list-rep-matchp (nth 0 abnf::cstss)
                                     "scalar-type"))))

Theorem: cst-address-type-conc-matching

(defthm cst-address-type-conc-matching
  (implies (cst-list-list-conc-matchp abnf::cstss "%s\"address\"")
           (and (equal (len abnf::cstss) 1)
                (cst-list-rep-matchp (nth 0 abnf::cstss)
                                     "%s\"address\""))))

Theorem: cst-boolean-type-conc-matching

(defthm cst-boolean-type-conc-matching
  (implies (cst-list-list-conc-matchp abnf::cstss "%s\"boolean\"")
           (and (equal (len abnf::cstss) 1)
                (cst-list-rep-matchp (nth 0 abnf::cstss)
                                     "%s\"boolean\""))))

Theorem: cst-string-type-conc-matching

(defthm cst-string-type-conc-matching
  (implies (cst-list-list-conc-matchp abnf::cstss "%s\"string\"")
           (and (equal (len abnf::cstss) 1)
                (cst-list-rep-matchp (nth 0 abnf::cstss)
                                     "%s\"string\""))))

Theorem: cst-literal-type-conc1-matching

(defthm cst-literal-type-conc1-matching
  (implies (cst-list-list-conc-matchp abnf::cstss "arithmetic-type")
           (and (equal (len abnf::cstss) 1)
                (cst-list-rep-matchp (nth 0 abnf::cstss)
                                     "arithmetic-type"))))

Theorem: cst-literal-type-conc2-matching

(defthm cst-literal-type-conc2-matching
  (implies (cst-list-list-conc-matchp abnf::cstss "address-type")
           (and (equal (len abnf::cstss) 1)
                (cst-list-rep-matchp (nth 0 abnf::cstss)
                                     "address-type"))))

Theorem: cst-literal-type-conc3-matching

(defthm cst-literal-type-conc3-matching
  (implies (cst-list-list-conc-matchp abnf::cstss "boolean-type")
           (and (equal (len abnf::cstss) 1)
                (cst-list-rep-matchp (nth 0 abnf::cstss)
                                     "boolean-type"))))

Theorem: cst-literal-type-conc4-matching

(defthm cst-literal-type-conc4-matching
  (implies (cst-list-list-conc-matchp abnf::cstss "string-type")
           (and (equal (len abnf::cstss) 1)
                (cst-list-rep-matchp (nth 0 abnf::cstss)
                                     "string-type"))))

Theorem: cst-plaintext-type-conc1-matching

(defthm cst-plaintext-type-conc1-matching
  (implies (cst-list-list-conc-matchp abnf::cstss "literal-type")
           (and (equal (len abnf::cstss) 1)
                (cst-list-rep-matchp (nth 0 abnf::cstss)
                                     "literal-type"))))

Theorem: cst-plaintext-type-conc2-matching

(defthm cst-plaintext-type-conc2-matching
  (implies (cst-list-list-conc-matchp abnf::cstss "identifier")
           (and (equal (len abnf::cstss) 1)
                (cst-list-rep-matchp (nth 0 abnf::cstss)
                                     "identifier"))))

Theorem: cst-register-type-conc3-matching

(defthm cst-register-type-conc3-matching
  (implies (cst-list-list-conc-matchp abnf::cstss "plaintext-type")
           (and (equal (len abnf::cstss) 1)
                (cst-list-rep-matchp (nth 0 abnf::cstss)
                                     "plaintext-type"))))

Theorem: cst-unary-op-conc1-matching

(defthm cst-unary-op-conc1-matching
  (implies (cst-list-list-conc-matchp abnf::cstss "%s\"abs\"")
           (and (equal (len abnf::cstss) 1)
                (cst-list-rep-matchp (nth 0 abnf::cstss)
                                     "%s\"abs\""))))

Theorem: cst-unary-op-conc2-matching

(defthm cst-unary-op-conc2-matching
  (implies (cst-list-list-conc-matchp abnf::cstss "%s\"abs.w\"")
           (and (equal (len abnf::cstss) 1)
                (cst-list-rep-matchp (nth 0 abnf::cstss)
                                     "%s\"abs.w\""))))

Theorem: cst-unary-op-conc3-matching

(defthm cst-unary-op-conc3-matching
  (implies (cst-list-list-conc-matchp abnf::cstss "%s\"double\"")
           (and (equal (len abnf::cstss) 1)
                (cst-list-rep-matchp (nth 0 abnf::cstss)
                                     "%s\"double\""))))

Theorem: cst-unary-op-conc4-matching

(defthm cst-unary-op-conc4-matching
  (implies (cst-list-list-conc-matchp abnf::cstss "%s\"inv\"")
           (and (equal (len abnf::cstss) 1)
                (cst-list-rep-matchp (nth 0 abnf::cstss)
                                     "%s\"inv\""))))

Theorem: cst-unary-op-conc5-matching

(defthm cst-unary-op-conc5-matching
  (implies (cst-list-list-conc-matchp abnf::cstss "%s\"neg\"")
           (and (equal (len abnf::cstss) 1)
                (cst-list-rep-matchp (nth 0 abnf::cstss)
                                     "%s\"neg\""))))

Theorem: cst-unary-op-conc6-matching

(defthm cst-unary-op-conc6-matching
  (implies (cst-list-list-conc-matchp abnf::cstss "%s\"not\"")
           (and (equal (len abnf::cstss) 1)
                (cst-list-rep-matchp (nth 0 abnf::cstss)
                                     "%s\"not\""))))

Theorem: cst-unary-op-conc7-matching

(defthm cst-unary-op-conc7-matching
  (implies (cst-list-list-conc-matchp abnf::cstss "%s\"square\"")
           (and (equal (len abnf::cstss) 1)
                (cst-list-rep-matchp (nth 0 abnf::cstss)
                                     "%s\"square\""))))

Theorem: cst-unary-op-conc8-matching

(defthm cst-unary-op-conc8-matching
  (implies (cst-list-list-conc-matchp abnf::cstss "%s\"sqrt\"")
           (and (equal (len abnf::cstss) 1)
                (cst-list-rep-matchp (nth 0 abnf::cstss)
                                     "%s\"sqrt\""))))

Theorem: cst-binary-op-conc1-matching

(defthm cst-binary-op-conc1-matching
  (implies (cst-list-list-conc-matchp abnf::cstss "%s\"add\"")
           (and (equal (len abnf::cstss) 1)
                (cst-list-rep-matchp (nth 0 abnf::cstss)
                                     "%s\"add\""))))

Theorem: cst-binary-op-conc2-matching

(defthm cst-binary-op-conc2-matching
  (implies (cst-list-list-conc-matchp abnf::cstss "%s\"add.w\"")
           (and (equal (len abnf::cstss) 1)
                (cst-list-rep-matchp (nth 0 abnf::cstss)
                                     "%s\"add.w\""))))

Theorem: cst-binary-op-conc3-matching

(defthm cst-binary-op-conc3-matching
  (implies (cst-list-list-conc-matchp abnf::cstss "%s\"sub\"")
           (and (equal (len abnf::cstss) 1)
                (cst-list-rep-matchp (nth 0 abnf::cstss)
                                     "%s\"sub\""))))

Theorem: cst-binary-op-conc4-matching

(defthm cst-binary-op-conc4-matching
  (implies (cst-list-list-conc-matchp abnf::cstss "%s\"sub.w\"")
           (and (equal (len abnf::cstss) 1)
                (cst-list-rep-matchp (nth 0 abnf::cstss)
                                     "%s\"sub.w\""))))

Theorem: cst-binary-op-conc5-matching

(defthm cst-binary-op-conc5-matching
  (implies (cst-list-list-conc-matchp abnf::cstss "%s\"mul\"")
           (and (equal (len abnf::cstss) 1)
                (cst-list-rep-matchp (nth 0 abnf::cstss)
                                     "%s\"mul\""))))

Theorem: cst-binary-op-conc6-matching

(defthm cst-binary-op-conc6-matching
  (implies (cst-list-list-conc-matchp abnf::cstss "%s\"mul.w\"")
           (and (equal (len abnf::cstss) 1)
                (cst-list-rep-matchp (nth 0 abnf::cstss)
                                     "%s\"mul.w\""))))

Theorem: cst-binary-op-conc7-matching

(defthm cst-binary-op-conc7-matching
  (implies (cst-list-list-conc-matchp abnf::cstss "%s\"div\"")
           (and (equal (len abnf::cstss) 1)
                (cst-list-rep-matchp (nth 0 abnf::cstss)
                                     "%s\"div\""))))

Theorem: cst-binary-op-conc8-matching

(defthm cst-binary-op-conc8-matching
  (implies (cst-list-list-conc-matchp abnf::cstss "%s\"div.w\"")
           (and (equal (len abnf::cstss) 1)
                (cst-list-rep-matchp (nth 0 abnf::cstss)
                                     "%s\"div.w\""))))

Theorem: cst-binary-op-conc9-matching

(defthm cst-binary-op-conc9-matching
  (implies (cst-list-list-conc-matchp abnf::cstss "%s\"rem\"")
           (and (equal (len abnf::cstss) 1)
                (cst-list-rep-matchp (nth 0 abnf::cstss)
                                     "%s\"rem\""))))

Theorem: cst-binary-op-conc10-matching

(defthm cst-binary-op-conc10-matching
  (implies (cst-list-list-conc-matchp abnf::cstss "%s\"rem.w\"")
           (and (equal (len abnf::cstss) 1)
                (cst-list-rep-matchp (nth 0 abnf::cstss)
                                     "%s\"rem.w\""))))

Theorem: cst-binary-op-conc11-matching

(defthm cst-binary-op-conc11-matching
  (implies (cst-list-list-conc-matchp abnf::cstss "%s\"mod\"")
           (and (equal (len abnf::cstss) 1)
                (cst-list-rep-matchp (nth 0 abnf::cstss)
                                     "%s\"mod\""))))

Theorem: cst-binary-op-conc12-matching

(defthm cst-binary-op-conc12-matching
  (implies (cst-list-list-conc-matchp abnf::cstss "%s\"pow\"")
           (and (equal (len abnf::cstss) 1)
                (cst-list-rep-matchp (nth 0 abnf::cstss)
                                     "%s\"pow\""))))

Theorem: cst-binary-op-conc13-matching

(defthm cst-binary-op-conc13-matching
  (implies (cst-list-list-conc-matchp abnf::cstss "%s\"pow.w\"")
           (and (equal (len abnf::cstss) 1)
                (cst-list-rep-matchp (nth 0 abnf::cstss)
                                     "%s\"pow.w\""))))

Theorem: cst-binary-op-conc14-matching

(defthm cst-binary-op-conc14-matching
  (implies (cst-list-list-conc-matchp abnf::cstss "%s\"shl\"")
           (and (equal (len abnf::cstss) 1)
                (cst-list-rep-matchp (nth 0 abnf::cstss)
                                     "%s\"shl\""))))

Theorem: cst-binary-op-conc15-matching

(defthm cst-binary-op-conc15-matching
  (implies (cst-list-list-conc-matchp abnf::cstss "%s\"shl.w\"")
           (and (equal (len abnf::cstss) 1)
                (cst-list-rep-matchp (nth 0 abnf::cstss)
                                     "%s\"shl.w\""))))

Theorem: cst-binary-op-conc16-matching

(defthm cst-binary-op-conc16-matching
  (implies (cst-list-list-conc-matchp abnf::cstss "%s\"shr\"")
           (and (equal (len abnf::cstss) 1)
                (cst-list-rep-matchp (nth 0 abnf::cstss)
                                     "%s\"shr\""))))

Theorem: cst-binary-op-conc17-matching

(defthm cst-binary-op-conc17-matching
  (implies (cst-list-list-conc-matchp abnf::cstss "%s\"shr.w\"")
           (and (equal (len abnf::cstss) 1)
                (cst-list-rep-matchp (nth 0 abnf::cstss)
                                     "%s\"shr.w\""))))

Theorem: cst-binary-op-conc18-matching

(defthm cst-binary-op-conc18-matching
  (implies (cst-list-list-conc-matchp abnf::cstss "%s\"and\"")
           (and (equal (len abnf::cstss) 1)
                (cst-list-rep-matchp (nth 0 abnf::cstss)
                                     "%s\"and\""))))

Theorem: cst-binary-op-conc19-matching

(defthm cst-binary-op-conc19-matching
  (implies (cst-list-list-conc-matchp abnf::cstss "%s\"or\"")
           (and (equal (len abnf::cstss) 1)
                (cst-list-rep-matchp (nth 0 abnf::cstss)
                                     "%s\"or\""))))

Theorem: cst-binary-op-conc20-matching

(defthm cst-binary-op-conc20-matching
  (implies (cst-list-list-conc-matchp abnf::cstss "%s\"xor\"")
           (and (equal (len abnf::cstss) 1)
                (cst-list-rep-matchp (nth 0 abnf::cstss)
                                     "%s\"xor\""))))

Theorem: cst-binary-op-conc21-matching

(defthm cst-binary-op-conc21-matching
  (implies (cst-list-list-conc-matchp abnf::cstss "%s\"nand\"")
           (and (equal (len abnf::cstss) 1)
                (cst-list-rep-matchp (nth 0 abnf::cstss)
                                     "%s\"nand\""))))

Theorem: cst-binary-op-conc22-matching

(defthm cst-binary-op-conc22-matching
  (implies (cst-list-list-conc-matchp abnf::cstss "%s\"nor\"")
           (and (equal (len abnf::cstss) 1)
                (cst-list-rep-matchp (nth 0 abnf::cstss)
                                     "%s\"nor\""))))

Theorem: cst-binary-op-conc23-matching

(defthm cst-binary-op-conc23-matching
  (implies (cst-list-list-conc-matchp abnf::cstss "%s\"gt\"")
           (and (equal (len abnf::cstss) 1)
                (cst-list-rep-matchp (nth 0 abnf::cstss)
                                     "%s\"gt\""))))

Theorem: cst-binary-op-conc24-matching

(defthm cst-binary-op-conc24-matching
  (implies (cst-list-list-conc-matchp abnf::cstss "%s\"gte\"")
           (and (equal (len abnf::cstss) 1)
                (cst-list-rep-matchp (nth 0 abnf::cstss)
                                     "%s\"gte\""))))

Theorem: cst-binary-op-conc25-matching

(defthm cst-binary-op-conc25-matching
  (implies (cst-list-list-conc-matchp abnf::cstss "%s\"lt\"")
           (and (equal (len abnf::cstss) 1)
                (cst-list-rep-matchp (nth 0 abnf::cstss)
                                     "%s\"lt\""))))

Theorem: cst-binary-op-conc26-matching

(defthm cst-binary-op-conc26-matching
  (implies (cst-list-list-conc-matchp abnf::cstss "%s\"lte\"")
           (and (equal (len abnf::cstss) 1)
                (cst-list-rep-matchp (nth 0 abnf::cstss)
                                     "%s\"lte\""))))

Theorem: cst-ternary-op-conc-matching

(defthm cst-ternary-op-conc-matching
  (implies (cst-list-list-conc-matchp abnf::cstss "%s\"ternary\"")
           (and (equal (len abnf::cstss) 1)
                (cst-list-rep-matchp (nth 0 abnf::cstss)
                                     "%s\"ternary\""))))

Theorem: cst-is-op-conc1-matching

(defthm cst-is-op-conc1-matching
  (implies (cst-list-list-conc-matchp abnf::cstss "%s\"is.eq\"")
           (and (equal (len abnf::cstss) 1)
                (cst-list-rep-matchp (nth 0 abnf::cstss)
                                     "%s\"is.eq\""))))

Theorem: cst-is-op-conc2-matching

(defthm cst-is-op-conc2-matching
  (implies (cst-list-list-conc-matchp abnf::cstss "%s\"is.neq\"")
           (and (equal (len abnf::cstss) 1)
                (cst-list-rep-matchp (nth 0 abnf::cstss)
                                     "%s\"is.neq\""))))

Theorem: cst-assert-op-conc1-matching

(defthm cst-assert-op-conc1-matching
  (implies (cst-list-list-conc-matchp abnf::cstss "%s\"assert.eq\"")
           (and (equal (len abnf::cstss) 1)
                (cst-list-rep-matchp (nth 0 abnf::cstss)
                                     "%s\"assert.eq\""))))

Theorem: cst-assert-op-conc2-matching

(defthm cst-assert-op-conc2-matching
  (implies (cst-list-list-conc-matchp abnf::cstss "%s\"assert.neq\"")
           (and (equal (len abnf::cstss) 1)
                (cst-list-rep-matchp (nth 0 abnf::cstss)
                                     "%s\"assert.neq\""))))

Theorem: cst-command-conc1-matching

(defthm cst-command-conc1-matching
  (implies (cst-list-list-conc-matchp abnf::cstss "decrement")
           (and (equal (len abnf::cstss) 1)
                (cst-list-rep-matchp (nth 0 abnf::cstss)
                                     "decrement"))))

Theorem: cst-command-conc2-matching

(defthm cst-command-conc2-matching
  (implies (cst-list-list-conc-matchp abnf::cstss "increment")
           (and (equal (len abnf::cstss) 1)
                (cst-list-rep-matchp (nth 0 abnf::cstss)
                                     "increment"))))

Theorem: cst-command-conc3-matching

(defthm cst-command-conc3-matching
  (implies (cst-list-list-conc-matchp abnf::cstss "instruction")
           (and (equal (len abnf::cstss) 1)
                (cst-list-rep-matchp (nth 0 abnf::cstss)
                                     "instruction"))))

Theorem: cst-ht-conc-rep-matching

(defthm cst-ht-conc-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "%x9")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts) "%x9"))))

Theorem: cst-lf-conc-rep-matching

(defthm cst-lf-conc-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "%xA")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts) "%xA"))))

Theorem: cst-cr-conc-rep-matching

(defthm cst-cr-conc-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "%xD")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts) "%xD"))))

Theorem: cst-sp-conc-rep-matching

(defthm cst-sp-conc-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "%x20")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "%x20"))))

Theorem: cst-dq-conc-rep-matching

(defthm cst-dq-conc-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "%x22")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "%x22"))))

Theorem: cst-visible-ascii-conc-rep-matching

(defthm cst-visible-ascii-conc-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "%x21-7E")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "%x21-7E"))))

Theorem: cst-safe-ascii-conc1-rep-matching

(defthm cst-safe-ascii-conc1-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "ht")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts) "ht"))))

Theorem: cst-safe-ascii-conc2-rep-matching

(defthm cst-safe-ascii-conc2-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "lf")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts) "lf"))))

Theorem: cst-safe-ascii-conc3-rep-matching

(defthm cst-safe-ascii-conc3-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "cr")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts) "cr"))))

Theorem: cst-safe-ascii-conc4-rep-matching

(defthm cst-safe-ascii-conc4-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "sp")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts) "sp"))))

Theorem: cst-safe-ascii-conc5-rep-matching

(defthm cst-safe-ascii-conc5-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "visible-ascii")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "visible-ascii"))))

Theorem: cst-safe-nonascii-conc1-rep-matching

(defthm cst-safe-nonascii-conc1-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "%x80-2029")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "%x80-2029"))))

Theorem: cst-safe-nonascii-conc2-rep-matching

(defthm cst-safe-nonascii-conc2-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "%x202F-2065")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "%x202F-2065"))))

Theorem: cst-safe-nonascii-conc3-rep-matching

(defthm cst-safe-nonascii-conc3-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "%x206A-D7FF")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "%x206A-D7FF"))))

Theorem: cst-safe-nonascii-conc4-rep-matching

(defthm cst-safe-nonascii-conc4-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "%xE000-10FFFF")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "%xE000-10FFFF"))))

Theorem: cst-character-conc1-rep-matching

(defthm cst-character-conc1-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "safe-ascii")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "safe-ascii"))))

Theorem: cst-character-conc2-rep-matching

(defthm cst-character-conc2-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "safe-nonascii")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "safe-nonascii"))))

Theorem: cst-plain-ws-conc1-rep-matching

(defthm cst-plain-ws-conc1-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "ht")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts) "ht"))))

Theorem: cst-plain-ws-conc2-rep-matching

(defthm cst-plain-ws-conc2-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "sp")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts) "sp"))))

Theorem: cst-plain-ws-conc3-rep-matching

(defthm cst-plain-ws-conc3-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "lf")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts) "lf"))))

Theorem: cst-plain-ws-conc4-rep-matching

(defthm cst-plain-ws-conc4-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "cr")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts) "cr"))))

Theorem: cst-comment-conc1-rep-matching

(defthm cst-comment-conc1-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "line-comment")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "line-comment"))))

Theorem: cst-comment-conc2-rep-matching

(defthm cst-comment-conc2-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "block-comment")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "block-comment"))))

Theorem: cst-not-lf-or-cr-conc1-rep-matching

(defthm cst-not-lf-or-cr-conc1-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "ht")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts) "ht"))))

Theorem: cst-not-lf-or-cr-conc2-rep-matching

(defthm cst-not-lf-or-cr-conc2-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "sp")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts) "sp"))))

Theorem: cst-not-lf-or-cr-conc3-rep-matching

(defthm cst-not-lf-or-cr-conc3-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "visible-ascii")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "visible-ascii"))))

Theorem: cst-not-lf-or-cr-conc4-rep-matching

(defthm cst-not-lf-or-cr-conc4-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "safe-nonascii")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "safe-nonascii"))))

Theorem: cst-not-star-conc1-rep-matching

(defthm cst-not-star-conc1-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "ht")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts) "ht"))))

Theorem: cst-not-star-conc2-rep-matching

(defthm cst-not-star-conc2-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "lf")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts) "lf"))))

Theorem: cst-not-star-conc3-rep-matching

(defthm cst-not-star-conc3-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "cr")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts) "cr"))))

Theorem: cst-not-star-conc4-rep-matching

(defthm cst-not-star-conc4-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "%x20-29")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "%x20-29"))))

Theorem: cst-not-star-conc5-rep-matching

(defthm cst-not-star-conc5-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "%x2B-7E")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "%x2B-7E"))))

Theorem: cst-not-star-conc6-rep-matching

(defthm cst-not-star-conc6-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "safe-nonascii")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "safe-nonascii"))))

Theorem: cst-rest-of-block-comment-after-star-conc1-rep-matching

(defthm cst-rest-of-block-comment-after-star-conc1-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "\"/\"")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts) "\"/\""))))

Theorem: cst-not-star-or-slash-conc1-rep-matching

(defthm cst-not-star-or-slash-conc1-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "ht")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts) "ht"))))

Theorem: cst-not-star-or-slash-conc2-rep-matching

(defthm cst-not-star-or-slash-conc2-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "lf")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts) "lf"))))

Theorem: cst-not-star-or-slash-conc3-rep-matching

(defthm cst-not-star-or-slash-conc3-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "cr")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts) "cr"))))

Theorem: cst-not-star-or-slash-conc4-rep-matching

(defthm cst-not-star-or-slash-conc4-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "%x20-29")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "%x20-29"))))

Theorem: cst-not-star-or-slash-conc5-rep-matching

(defthm cst-not-star-or-slash-conc5-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "%x2B-2E")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "%x2B-2E"))))

Theorem: cst-not-star-or-slash-conc6-rep-matching

(defthm cst-not-star-or-slash-conc6-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "%x30-7E")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "%x30-7E"))))

Theorem: cst-not-star-or-slash-conc7-rep-matching

(defthm cst-not-star-or-slash-conc7-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "safe-nonascii")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "safe-nonascii"))))

Theorem: cst-uppercase-letter-conc-rep-matching

(defthm cst-uppercase-letter-conc-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "%x41-5A")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "%x41-5A"))))

Theorem: cst-lowercase-letter-conc-rep-matching

(defthm cst-lowercase-letter-conc-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "%x61-7A")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "%x61-7A"))))

Theorem: cst-letter-conc1-rep-matching

(defthm cst-letter-conc1-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "uppercase-letter")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "uppercase-letter"))))

Theorem: cst-letter-conc2-rep-matching

(defthm cst-letter-conc2-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "lowercase-letter")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "lowercase-letter"))))

Theorem: cst-digit-conc-rep-matching

(defthm cst-digit-conc-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "%x30-39")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "%x30-39"))))

Theorem: cst-hex-digit-conc1-rep-matching

(defthm cst-hex-digit-conc1-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "digit")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "digit"))))

Theorem: cst-hex-digit-conc2-rep-matching

(defthm cst-hex-digit-conc2-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "\"a\"")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts) "\"a\""))))

Theorem: cst-hex-digit-conc3-rep-matching

(defthm cst-hex-digit-conc3-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "\"b\"")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts) "\"b\""))))

Theorem: cst-hex-digit-conc4-rep-matching

(defthm cst-hex-digit-conc4-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "\"c\"")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts) "\"c\""))))

Theorem: cst-hex-digit-conc5-rep-matching

(defthm cst-hex-digit-conc5-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "\"d\"")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts) "\"d\""))))

Theorem: cst-hex-digit-conc6-rep-matching

(defthm cst-hex-digit-conc6-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "\"e\"")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts) "\"e\""))))

Theorem: cst-hex-digit-conc7-rep-matching

(defthm cst-hex-digit-conc7-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "\"f\"")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts) "\"f\""))))

Theorem: cst-integer-literal-conc1-rep-matching

(defthm cst-integer-literal-conc1-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "signed-literal")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "signed-literal"))))

Theorem: cst-integer-literal-conc2-rep-matching

(defthm cst-integer-literal-conc2-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "unsigned-literal")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "unsigned-literal"))))

Theorem: cst-arithmetic-literal-conc1-rep-matching

(defthm cst-arithmetic-literal-conc1-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "integer-literal")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "integer-literal"))))

Theorem: cst-arithmetic-literal-conc2-rep-matching

(defthm cst-arithmetic-literal-conc2-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "field-literal")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "field-literal"))))

Theorem: cst-arithmetic-literal-conc3-rep-matching

(defthm cst-arithmetic-literal-conc3-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "group-literal")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "group-literal"))))

Theorem: cst-arithmetic-literal-conc4-rep-matching

(defthm cst-arithmetic-literal-conc4-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "scalar-literal")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "scalar-literal"))))

Theorem: cst-address-char-conc1-rep-matching

(defthm cst-address-char-conc1-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "\"0\"")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts) "\"0\""))))

Theorem: cst-address-char-conc2-rep-matching

(defthm cst-address-char-conc2-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "\"2\"")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts) "\"2\""))))

Theorem: cst-address-char-conc3-rep-matching

(defthm cst-address-char-conc3-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "\"3\"")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts) "\"3\""))))

Theorem: cst-address-char-conc4-rep-matching

(defthm cst-address-char-conc4-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "\"4\"")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts) "\"4\""))))

Theorem: cst-address-char-conc5-rep-matching

(defthm cst-address-char-conc5-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "\"5\"")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts) "\"5\""))))

Theorem: cst-address-char-conc6-rep-matching

(defthm cst-address-char-conc6-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "\"6\"")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts) "\"6\""))))

Theorem: cst-address-char-conc7-rep-matching

(defthm cst-address-char-conc7-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "\"7\"")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts) "\"7\""))))

Theorem: cst-address-char-conc8-rep-matching

(defthm cst-address-char-conc8-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "\"8\"")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts) "\"8\""))))

Theorem: cst-address-char-conc9-rep-matching

(defthm cst-address-char-conc9-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "\"9\"")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts) "\"9\""))))

Theorem: cst-address-char-conc10-rep-matching

(defthm cst-address-char-conc10-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "%s\"a\"")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "%s\"a\""))))

Theorem: cst-address-char-conc11-rep-matching

(defthm cst-address-char-conc11-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "%s\"c\"")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "%s\"c\""))))

Theorem: cst-address-char-conc12-rep-matching

(defthm cst-address-char-conc12-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "%s\"d\"")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "%s\"d\""))))

Theorem: cst-address-char-conc13-rep-matching

(defthm cst-address-char-conc13-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "%s\"e\"")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "%s\"e\""))))

Theorem: cst-address-char-conc14-rep-matching

(defthm cst-address-char-conc14-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "%s\"f\"")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "%s\"f\""))))

Theorem: cst-address-char-conc15-rep-matching

(defthm cst-address-char-conc15-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "%s\"g\"")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "%s\"g\""))))

Theorem: cst-address-char-conc16-rep-matching

(defthm cst-address-char-conc16-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "%s\"h\"")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "%s\"h\""))))

Theorem: cst-address-char-conc17-rep-matching

(defthm cst-address-char-conc17-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "%s\"j\"")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "%s\"j\""))))

Theorem: cst-address-char-conc18-rep-matching

(defthm cst-address-char-conc18-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "%s\"k\"")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "%s\"k\""))))

Theorem: cst-address-char-conc19-rep-matching

(defthm cst-address-char-conc19-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "%s\"l\"")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "%s\"l\""))))

Theorem: cst-address-char-conc20-rep-matching

(defthm cst-address-char-conc20-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "%s\"m\"")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "%s\"m\""))))

Theorem: cst-address-char-conc21-rep-matching

(defthm cst-address-char-conc21-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "%s\"n\"")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "%s\"n\""))))

Theorem: cst-address-char-conc22-rep-matching

(defthm cst-address-char-conc22-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "%s\"p\"")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "%s\"p\""))))

Theorem: cst-address-char-conc23-rep-matching

(defthm cst-address-char-conc23-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "%s\"q\"")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "%s\"q\""))))

Theorem: cst-address-char-conc24-rep-matching

(defthm cst-address-char-conc24-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "%s\"r\"")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "%s\"r\""))))

Theorem: cst-address-char-conc25-rep-matching

(defthm cst-address-char-conc25-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "%s\"s\"")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "%s\"s\""))))

Theorem: cst-address-char-conc26-rep-matching

(defthm cst-address-char-conc26-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "%s\"t\"")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "%s\"t\""))))

Theorem: cst-address-char-conc27-rep-matching

(defthm cst-address-char-conc27-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "%s\"u\"")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "%s\"u\""))))

Theorem: cst-address-char-conc28-rep-matching

(defthm cst-address-char-conc28-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "%s\"v\"")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "%s\"v\""))))

Theorem: cst-address-char-conc29-rep-matching

(defthm cst-address-char-conc29-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "%s\"w\"")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "%s\"w\""))))

Theorem: cst-address-char-conc30-rep-matching

(defthm cst-address-char-conc30-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "%s\"x\"")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "%s\"x\""))))

Theorem: cst-address-char-conc31-rep-matching

(defthm cst-address-char-conc31-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "%s\"y\"")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "%s\"y\""))))

Theorem: cst-address-char-conc32-rep-matching

(defthm cst-address-char-conc32-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "%s\"z\"")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "%s\"z\""))))

Theorem: cst-boolean-literal-conc1-rep-matching

(defthm cst-boolean-literal-conc1-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "%s\"true\"")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "%s\"true\""))))

Theorem: cst-boolean-literal-conc2-rep-matching

(defthm cst-boolean-literal-conc2-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "%s\"false\"")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "%s\"false\""))))

Theorem: cst-string-element-conc1-rep-matching

(defthm cst-string-element-conc1-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "not-dq-or-backslash")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "not-dq-or-backslash"))))

Theorem: cst-string-element-conc2-rep-matching

(defthm cst-string-element-conc2-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "escaped-char")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "escaped-char"))))

Theorem: cst-string-element-conc3-rep-matching

(defthm cst-string-element-conc3-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "escaped-ws")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "escaped-ws"))))

Theorem: cst-not-dq-or-backslash-conc1-rep-matching

(defthm cst-not-dq-or-backslash-conc1-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "ht")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts) "ht"))))

Theorem: cst-not-dq-or-backslash-conc2-rep-matching

(defthm cst-not-dq-or-backslash-conc2-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "lf")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts) "lf"))))

Theorem: cst-not-dq-or-backslash-conc3-rep-matching

(defthm cst-not-dq-or-backslash-conc3-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "cr")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts) "cr"))))

Theorem: cst-not-dq-or-backslash-conc4-rep-matching

(defthm cst-not-dq-or-backslash-conc4-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "%x20-21")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "%x20-21"))))

Theorem: cst-not-dq-or-backslash-conc5-rep-matching

(defthm cst-not-dq-or-backslash-conc5-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "%x23-5B")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "%x23-5B"))))

Theorem: cst-not-dq-or-backslash-conc6-rep-matching

(defthm cst-not-dq-or-backslash-conc6-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "%x5D-7E")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "%x5D-7E"))))

Theorem: cst-not-dq-or-backslash-conc7-rep-matching

(defthm cst-not-dq-or-backslash-conc7-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "safe-nonascii")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "safe-nonascii"))))

Theorem: cst-literal-conc1-rep-matching

(defthm cst-literal-conc1-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "arithmetic-literal")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "arithmetic-literal"))))

Theorem: cst-literal-conc2-rep-matching

(defthm cst-literal-conc2-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "address-literal")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "address-literal"))))

Theorem: cst-literal-conc3-rep-matching

(defthm cst-literal-conc3-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "boolean-literal")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "boolean-literal"))))

Theorem: cst-literal-conc4-rep-matching

(defthm cst-literal-conc4-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "string-literal")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "string-literal"))))

Theorem: cst-operand-conc1-rep-matching

(defthm cst-operand-conc1-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "literal")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "literal"))))

Theorem: cst-operand-conc2-rep-matching

(defthm cst-operand-conc2-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "register-access")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "register-access"))))

Theorem: cst-operand-conc3-rep-matching

(defthm cst-operand-conc3-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "%s\"self.caller\"")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "%s\"self.caller\""))))

Theorem: cst-operand-conc4-rep-matching

(defthm cst-operand-conc4-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "program-id")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "program-id"))))

Theorem: cst-unsigned-type-conc1-rep-matching

(defthm cst-unsigned-type-conc1-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "%s\"u8\"")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "%s\"u8\""))))

Theorem: cst-unsigned-type-conc2-rep-matching

(defthm cst-unsigned-type-conc2-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "%s\"u16\"")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "%s\"u16\""))))

Theorem: cst-unsigned-type-conc3-rep-matching

(defthm cst-unsigned-type-conc3-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "%s\"u32\"")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "%s\"u32\""))))

Theorem: cst-unsigned-type-conc4-rep-matching

(defthm cst-unsigned-type-conc4-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "%s\"u64\"")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "%s\"u64\""))))

Theorem: cst-unsigned-type-conc5-rep-matching

(defthm cst-unsigned-type-conc5-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "%s\"u128\"")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "%s\"u128\""))))

Theorem: cst-signed-type-conc1-rep-matching

(defthm cst-signed-type-conc1-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "%s\"i8\"")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "%s\"i8\""))))

Theorem: cst-signed-type-conc2-rep-matching

(defthm cst-signed-type-conc2-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "%s\"i16\"")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "%s\"i16\""))))

Theorem: cst-signed-type-conc3-rep-matching

(defthm cst-signed-type-conc3-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "%s\"i32\"")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "%s\"i32\""))))

Theorem: cst-signed-type-conc4-rep-matching

(defthm cst-signed-type-conc4-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "%s\"i64\"")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "%s\"i64\""))))

Theorem: cst-signed-type-conc5-rep-matching

(defthm cst-signed-type-conc5-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "%s\"i128\"")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "%s\"i128\""))))

Theorem: cst-integer-type-conc1-rep-matching

(defthm cst-integer-type-conc1-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "unsigned-type")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "unsigned-type"))))

Theorem: cst-integer-type-conc2-rep-matching

(defthm cst-integer-type-conc2-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "signed-type")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "signed-type"))))

Theorem: cst-field-type-conc-rep-matching

(defthm cst-field-type-conc-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "%s\"field\"")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "%s\"field\""))))

Theorem: cst-group-type-conc-rep-matching

(defthm cst-group-type-conc-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "%s\"group\"")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "%s\"group\""))))

Theorem: cst-scalar-type-conc-rep-matching

(defthm cst-scalar-type-conc-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "%s\"scalar\"")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "%s\"scalar\""))))

Theorem: cst-arithmetic-type-conc1-rep-matching

(defthm cst-arithmetic-type-conc1-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "integer-type")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "integer-type"))))

Theorem: cst-arithmetic-type-conc2-rep-matching

(defthm cst-arithmetic-type-conc2-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "field-type")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "field-type"))))

Theorem: cst-arithmetic-type-conc3-rep-matching

(defthm cst-arithmetic-type-conc3-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "group-type")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "group-type"))))

Theorem: cst-arithmetic-type-conc4-rep-matching

(defthm cst-arithmetic-type-conc4-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "scalar-type")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "scalar-type"))))

Theorem: cst-address-type-conc-rep-matching

(defthm cst-address-type-conc-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "%s\"address\"")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "%s\"address\""))))

Theorem: cst-boolean-type-conc-rep-matching

(defthm cst-boolean-type-conc-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "%s\"boolean\"")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "%s\"boolean\""))))

Theorem: cst-string-type-conc-rep-matching

(defthm cst-string-type-conc-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "%s\"string\"")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "%s\"string\""))))

Theorem: cst-literal-type-conc1-rep-matching

(defthm cst-literal-type-conc1-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "arithmetic-type")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "arithmetic-type"))))

Theorem: cst-literal-type-conc2-rep-matching

(defthm cst-literal-type-conc2-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "address-type")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "address-type"))))

Theorem: cst-literal-type-conc3-rep-matching

(defthm cst-literal-type-conc3-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "boolean-type")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "boolean-type"))))

Theorem: cst-literal-type-conc4-rep-matching

(defthm cst-literal-type-conc4-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "string-type")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "string-type"))))

Theorem: cst-plaintext-type-conc1-rep-matching

(defthm cst-plaintext-type-conc1-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "literal-type")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "literal-type"))))

Theorem: cst-plaintext-type-conc2-rep-matching

(defthm cst-plaintext-type-conc2-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "identifier")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "identifier"))))

Theorem: cst-register-type-conc3-rep-matching

(defthm cst-register-type-conc3-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "plaintext-type")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "plaintext-type"))))

Theorem: cst-unary-op-conc1-rep-matching

(defthm cst-unary-op-conc1-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "%s\"abs\"")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "%s\"abs\""))))

Theorem: cst-unary-op-conc2-rep-matching

(defthm cst-unary-op-conc2-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "%s\"abs.w\"")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "%s\"abs.w\""))))

Theorem: cst-unary-op-conc3-rep-matching

(defthm cst-unary-op-conc3-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "%s\"double\"")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "%s\"double\""))))

Theorem: cst-unary-op-conc4-rep-matching

(defthm cst-unary-op-conc4-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "%s\"inv\"")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "%s\"inv\""))))

Theorem: cst-unary-op-conc5-rep-matching

(defthm cst-unary-op-conc5-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "%s\"neg\"")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "%s\"neg\""))))

Theorem: cst-unary-op-conc6-rep-matching

(defthm cst-unary-op-conc6-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "%s\"not\"")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "%s\"not\""))))

Theorem: cst-unary-op-conc7-rep-matching

(defthm cst-unary-op-conc7-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "%s\"square\"")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "%s\"square\""))))

Theorem: cst-unary-op-conc8-rep-matching

(defthm cst-unary-op-conc8-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "%s\"sqrt\"")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "%s\"sqrt\""))))

Theorem: cst-binary-op-conc1-rep-matching

(defthm cst-binary-op-conc1-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "%s\"add\"")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "%s\"add\""))))

Theorem: cst-binary-op-conc2-rep-matching

(defthm cst-binary-op-conc2-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "%s\"add.w\"")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "%s\"add.w\""))))

Theorem: cst-binary-op-conc3-rep-matching

(defthm cst-binary-op-conc3-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "%s\"sub\"")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "%s\"sub\""))))

Theorem: cst-binary-op-conc4-rep-matching

(defthm cst-binary-op-conc4-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "%s\"sub.w\"")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "%s\"sub.w\""))))

Theorem: cst-binary-op-conc5-rep-matching

(defthm cst-binary-op-conc5-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "%s\"mul\"")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "%s\"mul\""))))

Theorem: cst-binary-op-conc6-rep-matching

(defthm cst-binary-op-conc6-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "%s\"mul.w\"")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "%s\"mul.w\""))))

Theorem: cst-binary-op-conc7-rep-matching

(defthm cst-binary-op-conc7-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "%s\"div\"")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "%s\"div\""))))

Theorem: cst-binary-op-conc8-rep-matching

(defthm cst-binary-op-conc8-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "%s\"div.w\"")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "%s\"div.w\""))))

Theorem: cst-binary-op-conc9-rep-matching

(defthm cst-binary-op-conc9-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "%s\"rem\"")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "%s\"rem\""))))

Theorem: cst-binary-op-conc10-rep-matching

(defthm cst-binary-op-conc10-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "%s\"rem.w\"")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "%s\"rem.w\""))))

Theorem: cst-binary-op-conc11-rep-matching

(defthm cst-binary-op-conc11-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "%s\"mod\"")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "%s\"mod\""))))

Theorem: cst-binary-op-conc12-rep-matching

(defthm cst-binary-op-conc12-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "%s\"pow\"")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "%s\"pow\""))))

Theorem: cst-binary-op-conc13-rep-matching

(defthm cst-binary-op-conc13-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "%s\"pow.w\"")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "%s\"pow.w\""))))

Theorem: cst-binary-op-conc14-rep-matching

(defthm cst-binary-op-conc14-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "%s\"shl\"")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "%s\"shl\""))))

Theorem: cst-binary-op-conc15-rep-matching

(defthm cst-binary-op-conc15-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "%s\"shl.w\"")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "%s\"shl.w\""))))

Theorem: cst-binary-op-conc16-rep-matching

(defthm cst-binary-op-conc16-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "%s\"shr\"")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "%s\"shr\""))))

Theorem: cst-binary-op-conc17-rep-matching

(defthm cst-binary-op-conc17-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "%s\"shr.w\"")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "%s\"shr.w\""))))

Theorem: cst-binary-op-conc18-rep-matching

(defthm cst-binary-op-conc18-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "%s\"and\"")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "%s\"and\""))))

Theorem: cst-binary-op-conc19-rep-matching

(defthm cst-binary-op-conc19-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "%s\"or\"")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "%s\"or\""))))

Theorem: cst-binary-op-conc20-rep-matching

(defthm cst-binary-op-conc20-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "%s\"xor\"")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "%s\"xor\""))))

Theorem: cst-binary-op-conc21-rep-matching

(defthm cst-binary-op-conc21-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "%s\"nand\"")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "%s\"nand\""))))

Theorem: cst-binary-op-conc22-rep-matching

(defthm cst-binary-op-conc22-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "%s\"nor\"")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "%s\"nor\""))))

Theorem: cst-binary-op-conc23-rep-matching

(defthm cst-binary-op-conc23-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "%s\"gt\"")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "%s\"gt\""))))

Theorem: cst-binary-op-conc24-rep-matching

(defthm cst-binary-op-conc24-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "%s\"gte\"")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "%s\"gte\""))))

Theorem: cst-binary-op-conc25-rep-matching

(defthm cst-binary-op-conc25-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "%s\"lt\"")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "%s\"lt\""))))

Theorem: cst-binary-op-conc26-rep-matching

(defthm cst-binary-op-conc26-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "%s\"lte\"")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "%s\"lte\""))))

Theorem: cst-ternary-op-conc-rep-matching

(defthm cst-ternary-op-conc-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "%s\"ternary\"")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "%s\"ternary\""))))

Theorem: cst-is-op-conc1-rep-matching

(defthm cst-is-op-conc1-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "%s\"is.eq\"")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "%s\"is.eq\""))))

Theorem: cst-is-op-conc2-rep-matching

(defthm cst-is-op-conc2-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "%s\"is.neq\"")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "%s\"is.neq\""))))

Theorem: cst-assert-op-conc1-rep-matching

(defthm cst-assert-op-conc1-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "%s\"assert.eq\"")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "%s\"assert.eq\""))))

Theorem: cst-assert-op-conc2-rep-matching

(defthm cst-assert-op-conc2-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "%s\"assert.neq\"")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "%s\"assert.neq\""))))

Theorem: cst-command-conc1-rep-matching

(defthm cst-command-conc1-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "decrement")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "decrement"))))

Theorem: cst-command-conc2-rep-matching

(defthm cst-command-conc2-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "increment")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "increment"))))

Theorem: cst-command-conc3-rep-matching

(defthm cst-command-conc3-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "instruction")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "instruction"))))

Theorem: cst-safe-ascii-conc-equivs

(defthm cst-safe-ascii-conc-equivs
 (implies
  (cst-matchp abnf::cst "safe-ascii")
  (and
   (iff
     (cst-list-list-conc-matchp
          (abnf::tree-nonleaf->branches abnf::cst)
          "ht")
     (equal
          (abnf::tree-nonleaf->rulename?
               (nth 0
                    (nth 0
                         (abnf::tree-nonleaf->branches abnf::cst))))
          (abnf::rulename "ht")))
   (iff
     (cst-list-list-conc-matchp
          (abnf::tree-nonleaf->branches abnf::cst)
          "lf")
     (equal
          (abnf::tree-nonleaf->rulename?
               (nth 0
                    (nth 0
                         (abnf::tree-nonleaf->branches abnf::cst))))
          (abnf::rulename "lf")))
   (iff
     (cst-list-list-conc-matchp
          (abnf::tree-nonleaf->branches abnf::cst)
          "cr")
     (equal
          (abnf::tree-nonleaf->rulename?
               (nth 0
                    (nth 0
                         (abnf::tree-nonleaf->branches abnf::cst))))
          (abnf::rulename "cr")))
   (iff
     (cst-list-list-conc-matchp
          (abnf::tree-nonleaf->branches abnf::cst)
          "sp")
     (equal
          (abnf::tree-nonleaf->rulename?
               (nth 0
                    (nth 0
                         (abnf::tree-nonleaf->branches abnf::cst))))
          (abnf::rulename "sp")))
   (iff
     (cst-list-list-conc-matchp
          (abnf::tree-nonleaf->branches abnf::cst)
          "visible-ascii")
     (equal
          (abnf::tree-nonleaf->rulename?
               (nth 0
                    (nth 0
                         (abnf::tree-nonleaf->branches abnf::cst))))
          (abnf::rulename "visible-ascii"))))))

Theorem: cst-character-conc-equivs

(defthm cst-character-conc-equivs
 (implies
  (cst-matchp abnf::cst "character")
  (and
   (iff
     (cst-list-list-conc-matchp
          (abnf::tree-nonleaf->branches abnf::cst)
          "safe-ascii")
     (equal
          (abnf::tree-nonleaf->rulename?
               (nth 0
                    (nth 0
                         (abnf::tree-nonleaf->branches abnf::cst))))
          (abnf::rulename "safe-ascii")))
   (iff
     (cst-list-list-conc-matchp
          (abnf::tree-nonleaf->branches abnf::cst)
          "safe-nonascii")
     (equal
          (abnf::tree-nonleaf->rulename?
               (nth 0
                    (nth 0
                         (abnf::tree-nonleaf->branches abnf::cst))))
          (abnf::rulename "safe-nonascii"))))))

Theorem: cst-plain-ws-conc-equivs

(defthm cst-plain-ws-conc-equivs
 (implies
  (cst-matchp abnf::cst "plain-ws")
  (and
   (iff
     (cst-list-list-conc-matchp
          (abnf::tree-nonleaf->branches abnf::cst)
          "ht")
     (equal
          (abnf::tree-nonleaf->rulename?
               (nth 0
                    (nth 0
                         (abnf::tree-nonleaf->branches abnf::cst))))
          (abnf::rulename "ht")))
   (iff
     (cst-list-list-conc-matchp
          (abnf::tree-nonleaf->branches abnf::cst)
          "sp")
     (equal
          (abnf::tree-nonleaf->rulename?
               (nth 0
                    (nth 0
                         (abnf::tree-nonleaf->branches abnf::cst))))
          (abnf::rulename "sp")))
   (iff
     (cst-list-list-conc-matchp
          (abnf::tree-nonleaf->branches abnf::cst)
          "lf")
     (equal
          (abnf::tree-nonleaf->rulename?
               (nth 0
                    (nth 0
                         (abnf::tree-nonleaf->branches abnf::cst))))
          (abnf::rulename "lf")))
   (iff
     (cst-list-list-conc-matchp
          (abnf::tree-nonleaf->branches abnf::cst)
          "cr")
     (equal
          (abnf::tree-nonleaf->rulename?
               (nth 0
                    (nth 0
                         (abnf::tree-nonleaf->branches abnf::cst))))
          (abnf::rulename "cr"))))))

Theorem: cst-comment-conc-equivs

(defthm cst-comment-conc-equivs
 (implies
  (cst-matchp abnf::cst "comment")
  (and
   (iff
     (cst-list-list-conc-matchp
          (abnf::tree-nonleaf->branches abnf::cst)
          "line-comment")
     (equal
          (abnf::tree-nonleaf->rulename?
               (nth 0
                    (nth 0
                         (abnf::tree-nonleaf->branches abnf::cst))))
          (abnf::rulename "line-comment")))
   (iff
     (cst-list-list-conc-matchp
          (abnf::tree-nonleaf->branches abnf::cst)
          "block-comment")
     (equal
          (abnf::tree-nonleaf->rulename?
               (nth 0
                    (nth 0
                         (abnf::tree-nonleaf->branches abnf::cst))))
          (abnf::rulename "block-comment"))))))

Theorem: cst-not-lf-or-cr-conc-equivs

(defthm cst-not-lf-or-cr-conc-equivs
 (implies
  (cst-matchp abnf::cst "not-lf-or-cr")
  (and
   (iff
     (cst-list-list-conc-matchp
          (abnf::tree-nonleaf->branches abnf::cst)
          "ht")
     (equal
          (abnf::tree-nonleaf->rulename?
               (nth 0
                    (nth 0
                         (abnf::tree-nonleaf->branches abnf::cst))))
          (abnf::rulename "ht")))
   (iff
     (cst-list-list-conc-matchp
          (abnf::tree-nonleaf->branches abnf::cst)
          "sp")
     (equal
          (abnf::tree-nonleaf->rulename?
               (nth 0
                    (nth 0
                         (abnf::tree-nonleaf->branches abnf::cst))))
          (abnf::rulename "sp")))
   (iff
     (cst-list-list-conc-matchp
          (abnf::tree-nonleaf->branches abnf::cst)
          "visible-ascii")
     (equal
          (abnf::tree-nonleaf->rulename?
               (nth 0
                    (nth 0
                         (abnf::tree-nonleaf->branches abnf::cst))))
          (abnf::rulename "visible-ascii")))
   (iff
     (cst-list-list-conc-matchp
          (abnf::tree-nonleaf->branches abnf::cst)
          "safe-nonascii")
     (equal
          (abnf::tree-nonleaf->rulename?
               (nth 0
                    (nth 0
                         (abnf::tree-nonleaf->branches abnf::cst))))
          (abnf::rulename "safe-nonascii"))))))

Theorem: cst-letter-conc-equivs

(defthm cst-letter-conc-equivs
 (implies
  (cst-matchp abnf::cst "letter")
  (and
   (iff
     (cst-list-list-conc-matchp
          (abnf::tree-nonleaf->branches abnf::cst)
          "uppercase-letter")
     (equal
          (abnf::tree-nonleaf->rulename?
               (nth 0
                    (nth 0
                         (abnf::tree-nonleaf->branches abnf::cst))))
          (abnf::rulename "uppercase-letter")))
   (iff
     (cst-list-list-conc-matchp
          (abnf::tree-nonleaf->branches abnf::cst)
          "lowercase-letter")
     (equal
          (abnf::tree-nonleaf->rulename?
               (nth 0
                    (nth 0
                         (abnf::tree-nonleaf->branches abnf::cst))))
          (abnf::rulename "lowercase-letter"))))))

Theorem: cst-integer-literal-conc-equivs

(defthm cst-integer-literal-conc-equivs
 (implies
  (cst-matchp abnf::cst "integer-literal")
  (and
   (iff
     (cst-list-list-conc-matchp
          (abnf::tree-nonleaf->branches abnf::cst)
          "signed-literal")
     (equal
          (abnf::tree-nonleaf->rulename?
               (nth 0
                    (nth 0
                         (abnf::tree-nonleaf->branches abnf::cst))))
          (abnf::rulename "signed-literal")))
   (iff
     (cst-list-list-conc-matchp
          (abnf::tree-nonleaf->branches abnf::cst)
          "unsigned-literal")
     (equal
          (abnf::tree-nonleaf->rulename?
               (nth 0
                    (nth 0
                         (abnf::tree-nonleaf->branches abnf::cst))))
          (abnf::rulename "unsigned-literal"))))))

Theorem: cst-arithmetic-literal-conc-equivs

(defthm cst-arithmetic-literal-conc-equivs
 (implies
  (cst-matchp abnf::cst "arithmetic-literal")
  (and
   (iff
     (cst-list-list-conc-matchp
          (abnf::tree-nonleaf->branches abnf::cst)
          "integer-literal")
     (equal
          (abnf::tree-nonleaf->rulename?
               (nth 0
                    (nth 0
                         (abnf::tree-nonleaf->branches abnf::cst))))
          (abnf::rulename "integer-literal")))
   (iff
     (cst-list-list-conc-matchp
          (abnf::tree-nonleaf->branches abnf::cst)
          "field-literal")
     (equal
          (abnf::tree-nonleaf->rulename?
               (nth 0
                    (nth 0
                         (abnf::tree-nonleaf->branches abnf::cst))))
          (abnf::rulename "field-literal")))
   (iff
     (cst-list-list-conc-matchp
          (abnf::tree-nonleaf->branches abnf::cst)
          "group-literal")
     (equal
          (abnf::tree-nonleaf->rulename?
               (nth 0
                    (nth 0
                         (abnf::tree-nonleaf->branches abnf::cst))))
          (abnf::rulename "group-literal")))
   (iff
     (cst-list-list-conc-matchp
          (abnf::tree-nonleaf->branches abnf::cst)
          "scalar-literal")
     (equal
          (abnf::tree-nonleaf->rulename?
               (nth 0
                    (nth 0
                         (abnf::tree-nonleaf->branches abnf::cst))))
          (abnf::rulename "scalar-literal"))))))

Theorem: cst-string-element-conc-equivs

(defthm cst-string-element-conc-equivs
 (implies
  (cst-matchp abnf::cst "string-element")
  (and
   (iff
     (cst-list-list-conc-matchp
          (abnf::tree-nonleaf->branches abnf::cst)
          "not-dq-or-backslash")
     (equal
          (abnf::tree-nonleaf->rulename?
               (nth 0
                    (nth 0
                         (abnf::tree-nonleaf->branches abnf::cst))))
          (abnf::rulename "not-dq-or-backslash")))
   (iff
     (cst-list-list-conc-matchp
          (abnf::tree-nonleaf->branches abnf::cst)
          "escaped-char")
     (equal
          (abnf::tree-nonleaf->rulename?
               (nth 0
                    (nth 0
                         (abnf::tree-nonleaf->branches abnf::cst))))
          (abnf::rulename "escaped-char")))
   (iff
     (cst-list-list-conc-matchp
          (abnf::tree-nonleaf->branches abnf::cst)
          "escaped-ws")
     (equal
          (abnf::tree-nonleaf->rulename?
               (nth 0
                    (nth 0
                         (abnf::tree-nonleaf->branches abnf::cst))))
          (abnf::rulename "escaped-ws"))))))

Theorem: cst-literal-conc-equivs

(defthm cst-literal-conc-equivs
 (implies
  (cst-matchp abnf::cst "literal")
  (and
   (iff
     (cst-list-list-conc-matchp
          (abnf::tree-nonleaf->branches abnf::cst)
          "arithmetic-literal")
     (equal
          (abnf::tree-nonleaf->rulename?
               (nth 0
                    (nth 0
                         (abnf::tree-nonleaf->branches abnf::cst))))
          (abnf::rulename "arithmetic-literal")))
   (iff
     (cst-list-list-conc-matchp
          (abnf::tree-nonleaf->branches abnf::cst)
          "address-literal")
     (equal
          (abnf::tree-nonleaf->rulename?
               (nth 0
                    (nth 0
                         (abnf::tree-nonleaf->branches abnf::cst))))
          (abnf::rulename "address-literal")))
   (iff
     (cst-list-list-conc-matchp
          (abnf::tree-nonleaf->branches abnf::cst)
          "boolean-literal")
     (equal
          (abnf::tree-nonleaf->rulename?
               (nth 0
                    (nth 0
                         (abnf::tree-nonleaf->branches abnf::cst))))
          (abnf::rulename "boolean-literal")))
   (iff
     (cst-list-list-conc-matchp
          (abnf::tree-nonleaf->branches abnf::cst)
          "string-literal")
     (equal
          (abnf::tree-nonleaf->rulename?
               (nth 0
                    (nth 0
                         (abnf::tree-nonleaf->branches abnf::cst))))
          (abnf::rulename "string-literal"))))))

Theorem: cst-integer-type-conc-equivs

(defthm cst-integer-type-conc-equivs
 (implies
  (cst-matchp abnf::cst "integer-type")
  (and
   (iff
     (cst-list-list-conc-matchp
          (abnf::tree-nonleaf->branches abnf::cst)
          "unsigned-type")
     (equal
          (abnf::tree-nonleaf->rulename?
               (nth 0
                    (nth 0
                         (abnf::tree-nonleaf->branches abnf::cst))))
          (abnf::rulename "unsigned-type")))
   (iff
     (cst-list-list-conc-matchp
          (abnf::tree-nonleaf->branches abnf::cst)
          "signed-type")
     (equal
          (abnf::tree-nonleaf->rulename?
               (nth 0
                    (nth 0
                         (abnf::tree-nonleaf->branches abnf::cst))))
          (abnf::rulename "signed-type"))))))

Theorem: cst-arithmetic-type-conc-equivs

(defthm cst-arithmetic-type-conc-equivs
 (implies
  (cst-matchp abnf::cst "arithmetic-type")
  (and
   (iff
     (cst-list-list-conc-matchp
          (abnf::tree-nonleaf->branches abnf::cst)
          "integer-type")
     (equal
          (abnf::tree-nonleaf->rulename?
               (nth 0
                    (nth 0
                         (abnf::tree-nonleaf->branches abnf::cst))))
          (abnf::rulename "integer-type")))
   (iff
     (cst-list-list-conc-matchp
          (abnf::tree-nonleaf->branches abnf::cst)
          "field-type")
     (equal
          (abnf::tree-nonleaf->rulename?
               (nth 0
                    (nth 0
                         (abnf::tree-nonleaf->branches abnf::cst))))
          (abnf::rulename "field-type")))
   (iff
     (cst-list-list-conc-matchp
          (abnf::tree-nonleaf->branches abnf::cst)
          "group-type")
     (equal
          (abnf::tree-nonleaf->rulename?
               (nth 0
                    (nth 0
                         (abnf::tree-nonleaf->branches abnf::cst))))
          (abnf::rulename "group-type")))
   (iff
     (cst-list-list-conc-matchp
          (abnf::tree-nonleaf->branches abnf::cst)
          "scalar-type")
     (equal
          (abnf::tree-nonleaf->rulename?
               (nth 0
                    (nth 0
                         (abnf::tree-nonleaf->branches abnf::cst))))
          (abnf::rulename "scalar-type"))))))

Theorem: cst-literal-type-conc-equivs

(defthm cst-literal-type-conc-equivs
 (implies
  (cst-matchp abnf::cst "literal-type")
  (and
   (iff
     (cst-list-list-conc-matchp
          (abnf::tree-nonleaf->branches abnf::cst)
          "arithmetic-type")
     (equal
          (abnf::tree-nonleaf->rulename?
               (nth 0
                    (nth 0
                         (abnf::tree-nonleaf->branches abnf::cst))))
          (abnf::rulename "arithmetic-type")))
   (iff
     (cst-list-list-conc-matchp
          (abnf::tree-nonleaf->branches abnf::cst)
          "address-type")
     (equal
          (abnf::tree-nonleaf->rulename?
               (nth 0
                    (nth 0
                         (abnf::tree-nonleaf->branches abnf::cst))))
          (abnf::rulename "address-type")))
   (iff
     (cst-list-list-conc-matchp
          (abnf::tree-nonleaf->branches abnf::cst)
          "boolean-type")
     (equal
          (abnf::tree-nonleaf->rulename?
               (nth 0
                    (nth 0
                         (abnf::tree-nonleaf->branches abnf::cst))))
          (abnf::rulename "boolean-type")))
   (iff
     (cst-list-list-conc-matchp
          (abnf::tree-nonleaf->branches abnf::cst)
          "string-type")
     (equal
          (abnf::tree-nonleaf->rulename?
               (nth 0
                    (nth 0
                         (abnf::tree-nonleaf->branches abnf::cst))))
          (abnf::rulename "string-type"))))))

Theorem: cst-plaintext-type-conc-equivs

(defthm cst-plaintext-type-conc-equivs
 (implies
  (cst-matchp abnf::cst "plaintext-type")
  (and
   (iff
     (cst-list-list-conc-matchp
          (abnf::tree-nonleaf->branches abnf::cst)
          "literal-type")
     (equal
          (abnf::tree-nonleaf->rulename?
               (nth 0
                    (nth 0
                         (abnf::tree-nonleaf->branches abnf::cst))))
          (abnf::rulename "literal-type")))
   (iff
     (cst-list-list-conc-matchp
          (abnf::tree-nonleaf->branches abnf::cst)
          "identifier")
     (equal
          (abnf::tree-nonleaf->rulename?
               (nth 0
                    (nth 0
                         (abnf::tree-nonleaf->branches abnf::cst))))
          (abnf::rulename "identifier"))))))

Theorem: cst-command-conc-equivs

(defthm cst-command-conc-equivs
 (implies
  (cst-matchp abnf::cst "command")
  (and
   (iff
     (cst-list-list-conc-matchp
          (abnf::tree-nonleaf->branches abnf::cst)
          "decrement")
     (equal
          (abnf::tree-nonleaf->rulename?
               (nth 0
                    (nth 0
                         (abnf::tree-nonleaf->branches abnf::cst))))
          (abnf::rulename "decrement")))
   (iff
     (cst-list-list-conc-matchp
          (abnf::tree-nonleaf->branches abnf::cst)
          "increment")
     (equal
          (abnf::tree-nonleaf->rulename?
               (nth 0
                    (nth 0
                         (abnf::tree-nonleaf->branches abnf::cst))))
          (abnf::rulename "increment")))
   (iff
     (cst-list-list-conc-matchp
          (abnf::tree-nonleaf->branches abnf::cst)
          "instruction")
     (equal
          (abnf::tree-nonleaf->rulename?
               (nth 0
                    (nth 0
                         (abnf::tree-nonleaf->branches abnf::cst))))
          (abnf::rulename "instruction"))))))

Function: cst-safe-ascii-conc?

(defun cst-safe-ascii-conc? (abnf::cst)
 (declare (xargs :guard (abnf::treep abnf::cst)))
 (declare (xargs :guard (cst-matchp abnf::cst "safe-ascii")))
 (let ((__function__ 'cst-safe-ascii-conc?))
  (declare (ignorable __function__))
  (cond
    ((equal
          (abnf::tree-nonleaf->rulename?
               (nth 0
                    (nth 0
                         (abnf::tree-nonleaf->branches abnf::cst))))
          (abnf::rulename "ht"))
     1)
    ((equal
          (abnf::tree-nonleaf->rulename?
               (nth 0
                    (nth 0
                         (abnf::tree-nonleaf->branches abnf::cst))))
          (abnf::rulename "lf"))
     2)
    ((equal
          (abnf::tree-nonleaf->rulename?
               (nth 0
                    (nth 0
                         (abnf::tree-nonleaf->branches abnf::cst))))
          (abnf::rulename "cr"))
     3)
    ((equal
          (abnf::tree-nonleaf->rulename?
               (nth 0
                    (nth 0
                         (abnf::tree-nonleaf->branches abnf::cst))))
          (abnf::rulename "sp"))
     4)
    ((equal
          (abnf::tree-nonleaf->rulename?
               (nth 0
                    (nth 0
                         (abnf::tree-nonleaf->branches abnf::cst))))
          (abnf::rulename "visible-ascii"))
     5)
    (t (prog2$ (impossible) 1)))))

Theorem: posp-of-cst-safe-ascii-conc?

(defthm posp-of-cst-safe-ascii-conc?
  (b* ((number (cst-safe-ascii-conc? abnf::cst)))
    (posp number))
  :rule-classes :rewrite)

Theorem: cst-safe-ascii-conc?-possibilities

(defthm cst-safe-ascii-conc?-possibilities
  (b* ((number (cst-safe-ascii-conc? abnf::cst)))
    (or (equal number 1)
        (equal number 2)
        (equal number 3)
        (equal number 4)
        (equal number 5)))
  :rule-classes
  ((:forward-chaining
        :trigger-terms ((cst-safe-ascii-conc? abnf::cst)))))

Theorem: cst-safe-ascii-conc?-of-tree-fix-cst

(defthm cst-safe-ascii-conc?-of-tree-fix-cst
  (equal (cst-safe-ascii-conc? (abnf::tree-fix abnf::cst))
         (cst-safe-ascii-conc? abnf::cst)))

Theorem: cst-safe-ascii-conc?-tree-equiv-congruence-on-cst

(defthm cst-safe-ascii-conc?-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-safe-ascii-conc? abnf::cst)
                  (cst-safe-ascii-conc? cst-equiv)))
  :rule-classes :congruence)

Theorem: cst-safe-ascii-conc?-1-iff-match-conc

(defthm cst-safe-ascii-conc?-1-iff-match-conc
  (implies (cst-matchp abnf::cst "safe-ascii")
           (iff (equal (cst-safe-ascii-conc? abnf::cst)
                       1)
                (cst-list-list-conc-matchp
                     (abnf::tree-nonleaf->branches abnf::cst)
                     "ht"))))

Theorem: cst-safe-ascii-conc?-2-iff-match-conc

(defthm cst-safe-ascii-conc?-2-iff-match-conc
  (implies (cst-matchp abnf::cst "safe-ascii")
           (iff (equal (cst-safe-ascii-conc? abnf::cst)
                       2)
                (cst-list-list-conc-matchp
                     (abnf::tree-nonleaf->branches abnf::cst)
                     "lf"))))

Theorem: cst-safe-ascii-conc?-3-iff-match-conc

(defthm cst-safe-ascii-conc?-3-iff-match-conc
  (implies (cst-matchp abnf::cst "safe-ascii")
           (iff (equal (cst-safe-ascii-conc? abnf::cst)
                       3)
                (cst-list-list-conc-matchp
                     (abnf::tree-nonleaf->branches abnf::cst)
                     "cr"))))

Theorem: cst-safe-ascii-conc?-4-iff-match-conc

(defthm cst-safe-ascii-conc?-4-iff-match-conc
  (implies (cst-matchp abnf::cst "safe-ascii")
           (iff (equal (cst-safe-ascii-conc? abnf::cst)
                       4)
                (cst-list-list-conc-matchp
                     (abnf::tree-nonleaf->branches abnf::cst)
                     "sp"))))

Theorem: cst-safe-ascii-conc?-5-iff-match-conc

(defthm cst-safe-ascii-conc?-5-iff-match-conc
  (implies (cst-matchp abnf::cst "safe-ascii")
           (iff (equal (cst-safe-ascii-conc? abnf::cst)
                       5)
                (cst-list-list-conc-matchp
                     (abnf::tree-nonleaf->branches abnf::cst)
                     "visible-ascii"))))

Function: cst-character-conc?

(defun cst-character-conc? (abnf::cst)
 (declare (xargs :guard (abnf::treep abnf::cst)))
 (declare (xargs :guard (cst-matchp abnf::cst "character")))
 (let ((__function__ 'cst-character-conc?))
  (declare (ignorable __function__))
  (cond
    ((equal
          (abnf::tree-nonleaf->rulename?
               (nth 0
                    (nth 0
                         (abnf::tree-nonleaf->branches abnf::cst))))
          (abnf::rulename "safe-ascii"))
     1)
    ((equal
          (abnf::tree-nonleaf->rulename?
               (nth 0
                    (nth 0
                         (abnf::tree-nonleaf->branches abnf::cst))))
          (abnf::rulename "safe-nonascii"))
     2)
    (t (prog2$ (impossible) 1)))))

Theorem: posp-of-cst-character-conc?

(defthm posp-of-cst-character-conc?
  (b* ((number (cst-character-conc? abnf::cst)))
    (posp number))
  :rule-classes :rewrite)

Theorem: cst-character-conc?-possibilities

(defthm cst-character-conc?-possibilities
  (b* ((number (cst-character-conc? abnf::cst)))
    (or (equal number 1) (equal number 2)))
  :rule-classes
  ((:forward-chaining
        :trigger-terms ((cst-character-conc? abnf::cst)))))

Theorem: cst-character-conc?-of-tree-fix-cst

(defthm cst-character-conc?-of-tree-fix-cst
  (equal (cst-character-conc? (abnf::tree-fix abnf::cst))
         (cst-character-conc? abnf::cst)))

Theorem: cst-character-conc?-tree-equiv-congruence-on-cst

(defthm cst-character-conc?-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-character-conc? abnf::cst)
                  (cst-character-conc? cst-equiv)))
  :rule-classes :congruence)

Theorem: cst-character-conc?-1-iff-match-conc

(defthm cst-character-conc?-1-iff-match-conc
  (implies (cst-matchp abnf::cst "character")
           (iff (equal (cst-character-conc? abnf::cst)
                       1)
                (cst-list-list-conc-matchp
                     (abnf::tree-nonleaf->branches abnf::cst)
                     "safe-ascii"))))

Theorem: cst-character-conc?-2-iff-match-conc

(defthm cst-character-conc?-2-iff-match-conc
  (implies (cst-matchp abnf::cst "character")
           (iff (equal (cst-character-conc? abnf::cst)
                       2)
                (cst-list-list-conc-matchp
                     (abnf::tree-nonleaf->branches abnf::cst)
                     "safe-nonascii"))))

Function: cst-plain-ws-conc?

(defun cst-plain-ws-conc? (abnf::cst)
 (declare (xargs :guard (abnf::treep abnf::cst)))
 (declare (xargs :guard (cst-matchp abnf::cst "plain-ws")))
 (let ((__function__ 'cst-plain-ws-conc?))
  (declare (ignorable __function__))
  (cond
    ((equal
          (abnf::tree-nonleaf->rulename?
               (nth 0
                    (nth 0
                         (abnf::tree-nonleaf->branches abnf::cst))))
          (abnf::rulename "ht"))
     1)
    ((equal
          (abnf::tree-nonleaf->rulename?
               (nth 0
                    (nth 0
                         (abnf::tree-nonleaf->branches abnf::cst))))
          (abnf::rulename "sp"))
     2)
    ((equal
          (abnf::tree-nonleaf->rulename?
               (nth 0
                    (nth 0
                         (abnf::tree-nonleaf->branches abnf::cst))))
          (abnf::rulename "lf"))
     3)
    ((equal
          (abnf::tree-nonleaf->rulename?
               (nth 0
                    (nth 0
                         (abnf::tree-nonleaf->branches abnf::cst))))
          (abnf::rulename "cr"))
     4)
    (t (prog2$ (impossible) 1)))))

Theorem: posp-of-cst-plain-ws-conc?

(defthm posp-of-cst-plain-ws-conc?
  (b* ((number (cst-plain-ws-conc? abnf::cst)))
    (posp number))
  :rule-classes :rewrite)

Theorem: cst-plain-ws-conc?-possibilities

(defthm cst-plain-ws-conc?-possibilities
  (b* ((number (cst-plain-ws-conc? abnf::cst)))
    (or (equal number 1)
        (equal number 2)
        (equal number 3)
        (equal number 4)))
  :rule-classes
  ((:forward-chaining
        :trigger-terms ((cst-plain-ws-conc? abnf::cst)))))

Theorem: cst-plain-ws-conc?-of-tree-fix-cst

(defthm cst-plain-ws-conc?-of-tree-fix-cst
  (equal (cst-plain-ws-conc? (abnf::tree-fix abnf::cst))
         (cst-plain-ws-conc? abnf::cst)))

Theorem: cst-plain-ws-conc?-tree-equiv-congruence-on-cst

(defthm cst-plain-ws-conc?-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-plain-ws-conc? abnf::cst)
                  (cst-plain-ws-conc? cst-equiv)))
  :rule-classes :congruence)

Theorem: cst-plain-ws-conc?-1-iff-match-conc

(defthm cst-plain-ws-conc?-1-iff-match-conc
  (implies (cst-matchp abnf::cst "plain-ws")
           (iff (equal (cst-plain-ws-conc? abnf::cst) 1)
                (cst-list-list-conc-matchp
                     (abnf::tree-nonleaf->branches abnf::cst)
                     "ht"))))

Theorem: cst-plain-ws-conc?-2-iff-match-conc

(defthm cst-plain-ws-conc?-2-iff-match-conc
  (implies (cst-matchp abnf::cst "plain-ws")
           (iff (equal (cst-plain-ws-conc? abnf::cst) 2)
                (cst-list-list-conc-matchp
                     (abnf::tree-nonleaf->branches abnf::cst)
                     "sp"))))

Theorem: cst-plain-ws-conc?-3-iff-match-conc

(defthm cst-plain-ws-conc?-3-iff-match-conc
  (implies (cst-matchp abnf::cst "plain-ws")
           (iff (equal (cst-plain-ws-conc? abnf::cst) 3)
                (cst-list-list-conc-matchp
                     (abnf::tree-nonleaf->branches abnf::cst)
                     "lf"))))

Theorem: cst-plain-ws-conc?-4-iff-match-conc

(defthm cst-plain-ws-conc?-4-iff-match-conc
  (implies (cst-matchp abnf::cst "plain-ws")
           (iff (equal (cst-plain-ws-conc? abnf::cst) 4)
                (cst-list-list-conc-matchp
                     (abnf::tree-nonleaf->branches abnf::cst)
                     "cr"))))

Function: cst-comment-conc?

(defun cst-comment-conc? (abnf::cst)
 (declare (xargs :guard (abnf::treep abnf::cst)))
 (declare (xargs :guard (cst-matchp abnf::cst "comment")))
 (let ((__function__ 'cst-comment-conc?))
  (declare (ignorable __function__))
  (cond
    ((equal
          (abnf::tree-nonleaf->rulename?
               (nth 0
                    (nth 0
                         (abnf::tree-nonleaf->branches abnf::cst))))
          (abnf::rulename "line-comment"))
     1)
    ((equal
          (abnf::tree-nonleaf->rulename?
               (nth 0
                    (nth 0
                         (abnf::tree-nonleaf->branches abnf::cst))))
          (abnf::rulename "block-comment"))
     2)
    (t (prog2$ (impossible) 1)))))

Theorem: posp-of-cst-comment-conc?

(defthm posp-of-cst-comment-conc?
  (b* ((number (cst-comment-conc? abnf::cst)))
    (posp number))
  :rule-classes :rewrite)

Theorem: cst-comment-conc?-possibilities

(defthm cst-comment-conc?-possibilities
  (b* ((number (cst-comment-conc? abnf::cst)))
    (or (equal number 1) (equal number 2)))
  :rule-classes
  ((:forward-chaining
        :trigger-terms ((cst-comment-conc? abnf::cst)))))

Theorem: cst-comment-conc?-of-tree-fix-cst

(defthm cst-comment-conc?-of-tree-fix-cst
  (equal (cst-comment-conc? (abnf::tree-fix abnf::cst))
         (cst-comment-conc? abnf::cst)))

Theorem: cst-comment-conc?-tree-equiv-congruence-on-cst

(defthm cst-comment-conc?-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-comment-conc? abnf::cst)
                  (cst-comment-conc? cst-equiv)))
  :rule-classes :congruence)

Theorem: cst-comment-conc?-1-iff-match-conc

(defthm cst-comment-conc?-1-iff-match-conc
  (implies (cst-matchp abnf::cst "comment")
           (iff (equal (cst-comment-conc? abnf::cst) 1)
                (cst-list-list-conc-matchp
                     (abnf::tree-nonleaf->branches abnf::cst)
                     "line-comment"))))

Theorem: cst-comment-conc?-2-iff-match-conc

(defthm cst-comment-conc?-2-iff-match-conc
  (implies (cst-matchp abnf::cst "comment")
           (iff (equal (cst-comment-conc? abnf::cst) 2)
                (cst-list-list-conc-matchp
                     (abnf::tree-nonleaf->branches abnf::cst)
                     "block-comment"))))

Function: cst-not-lf-or-cr-conc?

(defun cst-not-lf-or-cr-conc? (abnf::cst)
 (declare (xargs :guard (abnf::treep abnf::cst)))
 (declare (xargs :guard (cst-matchp abnf::cst "not-lf-or-cr")))
 (let ((__function__ 'cst-not-lf-or-cr-conc?))
  (declare (ignorable __function__))
  (cond
    ((equal
          (abnf::tree-nonleaf->rulename?
               (nth 0
                    (nth 0
                         (abnf::tree-nonleaf->branches abnf::cst))))
          (abnf::rulename "ht"))
     1)
    ((equal
          (abnf::tree-nonleaf->rulename?
               (nth 0
                    (nth 0
                         (abnf::tree-nonleaf->branches abnf::cst))))
          (abnf::rulename "sp"))
     2)
    ((equal
          (abnf::tree-nonleaf->rulename?
               (nth 0
                    (nth 0
                         (abnf::tree-nonleaf->branches abnf::cst))))
          (abnf::rulename "visible-ascii"))
     3)
    ((equal
          (abnf::tree-nonleaf->rulename?
               (nth 0
                    (nth 0
                         (abnf::tree-nonleaf->branches abnf::cst))))
          (abnf::rulename "safe-nonascii"))
     4)
    (t (prog2$ (impossible) 1)))))

Theorem: posp-of-cst-not-lf-or-cr-conc?

(defthm posp-of-cst-not-lf-or-cr-conc?
  (b* ((number (cst-not-lf-or-cr-conc? abnf::cst)))
    (posp number))
  :rule-classes :rewrite)

Theorem: cst-not-lf-or-cr-conc?-possibilities

(defthm cst-not-lf-or-cr-conc?-possibilities
  (b* ((number (cst-not-lf-or-cr-conc? abnf::cst)))
    (or (equal number 1)
        (equal number 2)
        (equal number 3)
        (equal number 4)))
  :rule-classes
  ((:forward-chaining
        :trigger-terms ((cst-not-lf-or-cr-conc? abnf::cst)))))

Theorem: cst-not-lf-or-cr-conc?-of-tree-fix-cst

(defthm cst-not-lf-or-cr-conc?-of-tree-fix-cst
  (equal (cst-not-lf-or-cr-conc? (abnf::tree-fix abnf::cst))
         (cst-not-lf-or-cr-conc? abnf::cst)))

Theorem: cst-not-lf-or-cr-conc?-tree-equiv-congruence-on-cst

(defthm cst-not-lf-or-cr-conc?-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-not-lf-or-cr-conc? abnf::cst)
                  (cst-not-lf-or-cr-conc? cst-equiv)))
  :rule-classes :congruence)

Theorem: cst-not-lf-or-cr-conc?-1-iff-match-conc

(defthm cst-not-lf-or-cr-conc?-1-iff-match-conc
  (implies (cst-matchp abnf::cst "not-lf-or-cr")
           (iff (equal (cst-not-lf-or-cr-conc? abnf::cst)
                       1)
                (cst-list-list-conc-matchp
                     (abnf::tree-nonleaf->branches abnf::cst)
                     "ht"))))

Theorem: cst-not-lf-or-cr-conc?-2-iff-match-conc

(defthm cst-not-lf-or-cr-conc?-2-iff-match-conc
  (implies (cst-matchp abnf::cst "not-lf-or-cr")
           (iff (equal (cst-not-lf-or-cr-conc? abnf::cst)
                       2)
                (cst-list-list-conc-matchp
                     (abnf::tree-nonleaf->branches abnf::cst)
                     "sp"))))

Theorem: cst-not-lf-or-cr-conc?-3-iff-match-conc

(defthm cst-not-lf-or-cr-conc?-3-iff-match-conc
  (implies (cst-matchp abnf::cst "not-lf-or-cr")
           (iff (equal (cst-not-lf-or-cr-conc? abnf::cst)
                       3)
                (cst-list-list-conc-matchp
                     (abnf::tree-nonleaf->branches abnf::cst)
                     "visible-ascii"))))

Theorem: cst-not-lf-or-cr-conc?-4-iff-match-conc

(defthm cst-not-lf-or-cr-conc?-4-iff-match-conc
  (implies (cst-matchp abnf::cst "not-lf-or-cr")
           (iff (equal (cst-not-lf-or-cr-conc? abnf::cst)
                       4)
                (cst-list-list-conc-matchp
                     (abnf::tree-nonleaf->branches abnf::cst)
                     "safe-nonascii"))))

Function: cst-letter-conc?

(defun cst-letter-conc? (abnf::cst)
 (declare (xargs :guard (abnf::treep abnf::cst)))
 (declare (xargs :guard (cst-matchp abnf::cst "letter")))
 (let ((__function__ 'cst-letter-conc?))
  (declare (ignorable __function__))
  (cond
    ((equal
          (abnf::tree-nonleaf->rulename?
               (nth 0
                    (nth 0
                         (abnf::tree-nonleaf->branches abnf::cst))))
          (abnf::rulename "uppercase-letter"))
     1)
    ((equal
          (abnf::tree-nonleaf->rulename?
               (nth 0
                    (nth 0
                         (abnf::tree-nonleaf->branches abnf::cst))))
          (abnf::rulename "lowercase-letter"))
     2)
    (t (prog2$ (impossible) 1)))))

Theorem: posp-of-cst-letter-conc?

(defthm posp-of-cst-letter-conc?
  (b* ((number (cst-letter-conc? abnf::cst)))
    (posp number))
  :rule-classes :rewrite)

Theorem: cst-letter-conc?-possibilities

(defthm cst-letter-conc?-possibilities
  (b* ((number (cst-letter-conc? abnf::cst)))
    (or (equal number 1) (equal number 2)))
  :rule-classes
  ((:forward-chaining
        :trigger-terms ((cst-letter-conc? abnf::cst)))))

Theorem: cst-letter-conc?-of-tree-fix-cst

(defthm cst-letter-conc?-of-tree-fix-cst
  (equal (cst-letter-conc? (abnf::tree-fix abnf::cst))
         (cst-letter-conc? abnf::cst)))

Theorem: cst-letter-conc?-tree-equiv-congruence-on-cst

(defthm cst-letter-conc?-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-letter-conc? abnf::cst)
                  (cst-letter-conc? cst-equiv)))
  :rule-classes :congruence)

Theorem: cst-letter-conc?-1-iff-match-conc

(defthm cst-letter-conc?-1-iff-match-conc
  (implies (cst-matchp abnf::cst "letter")
           (iff (equal (cst-letter-conc? abnf::cst) 1)
                (cst-list-list-conc-matchp
                     (abnf::tree-nonleaf->branches abnf::cst)
                     "uppercase-letter"))))

Theorem: cst-letter-conc?-2-iff-match-conc

(defthm cst-letter-conc?-2-iff-match-conc
  (implies (cst-matchp abnf::cst "letter")
           (iff (equal (cst-letter-conc? abnf::cst) 2)
                (cst-list-list-conc-matchp
                     (abnf::tree-nonleaf->branches abnf::cst)
                     "lowercase-letter"))))

Function: cst-integer-literal-conc?

(defun cst-integer-literal-conc? (abnf::cst)
 (declare (xargs :guard (abnf::treep abnf::cst)))
 (declare (xargs :guard (cst-matchp abnf::cst "integer-literal")))
 (let ((__function__ 'cst-integer-literal-conc?))
  (declare (ignorable __function__))
  (cond
    ((equal
          (abnf::tree-nonleaf->rulename?
               (nth 0
                    (nth 0
                         (abnf::tree-nonleaf->branches abnf::cst))))
          (abnf::rulename "signed-literal"))
     1)
    ((equal
          (abnf::tree-nonleaf->rulename?
               (nth 0
                    (nth 0
                         (abnf::tree-nonleaf->branches abnf::cst))))
          (abnf::rulename "unsigned-literal"))
     2)
    (t (prog2$ (impossible) 1)))))

Theorem: posp-of-cst-integer-literal-conc?

(defthm posp-of-cst-integer-literal-conc?
  (b* ((number (cst-integer-literal-conc? abnf::cst)))
    (posp number))
  :rule-classes :rewrite)

Theorem: cst-integer-literal-conc?-possibilities

(defthm cst-integer-literal-conc?-possibilities
  (b* ((number (cst-integer-literal-conc? abnf::cst)))
    (or (equal number 1) (equal number 2)))
  :rule-classes
  ((:forward-chaining
        :trigger-terms ((cst-integer-literal-conc? abnf::cst)))))

Theorem: cst-integer-literal-conc?-of-tree-fix-cst

(defthm cst-integer-literal-conc?-of-tree-fix-cst
  (equal (cst-integer-literal-conc? (abnf::tree-fix abnf::cst))
         (cst-integer-literal-conc? abnf::cst)))

Theorem: cst-integer-literal-conc?-tree-equiv-congruence-on-cst

(defthm cst-integer-literal-conc?-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-integer-literal-conc? abnf::cst)
                  (cst-integer-literal-conc? cst-equiv)))
  :rule-classes :congruence)

Theorem: cst-integer-literal-conc?-1-iff-match-conc

(defthm cst-integer-literal-conc?-1-iff-match-conc
  (implies (cst-matchp abnf::cst "integer-literal")
           (iff (equal (cst-integer-literal-conc? abnf::cst)
                       1)
                (cst-list-list-conc-matchp
                     (abnf::tree-nonleaf->branches abnf::cst)
                     "signed-literal"))))

Theorem: cst-integer-literal-conc?-2-iff-match-conc

(defthm cst-integer-literal-conc?-2-iff-match-conc
  (implies (cst-matchp abnf::cst "integer-literal")
           (iff (equal (cst-integer-literal-conc? abnf::cst)
                       2)
                (cst-list-list-conc-matchp
                     (abnf::tree-nonleaf->branches abnf::cst)
                     "unsigned-literal"))))

Function: cst-arithmetic-literal-conc?

(defun cst-arithmetic-literal-conc? (abnf::cst)
 (declare (xargs :guard (abnf::treep abnf::cst)))
 (declare
      (xargs :guard (cst-matchp abnf::cst "arithmetic-literal")))
 (let ((__function__ 'cst-arithmetic-literal-conc?))
  (declare (ignorable __function__))
  (cond
    ((equal
          (abnf::tree-nonleaf->rulename?
               (nth 0
                    (nth 0
                         (abnf::tree-nonleaf->branches abnf::cst))))
          (abnf::rulename "integer-literal"))
     1)
    ((equal
          (abnf::tree-nonleaf->rulename?
               (nth 0
                    (nth 0
                         (abnf::tree-nonleaf->branches abnf::cst))))
          (abnf::rulename "field-literal"))
     2)
    ((equal
          (abnf::tree-nonleaf->rulename?
               (nth 0
                    (nth 0
                         (abnf::tree-nonleaf->branches abnf::cst))))
          (abnf::rulename "group-literal"))
     3)
    ((equal
          (abnf::tree-nonleaf->rulename?
               (nth 0
                    (nth 0
                         (abnf::tree-nonleaf->branches abnf::cst))))
          (abnf::rulename "scalar-literal"))
     4)
    (t (prog2$ (impossible) 1)))))

Theorem: posp-of-cst-arithmetic-literal-conc?

(defthm posp-of-cst-arithmetic-literal-conc?
  (b* ((number (cst-arithmetic-literal-conc? abnf::cst)))
    (posp number))
  :rule-classes :rewrite)

Theorem: cst-arithmetic-literal-conc?-possibilities

(defthm cst-arithmetic-literal-conc?-possibilities
  (b* ((number (cst-arithmetic-literal-conc? abnf::cst)))
    (or (equal number 1)
        (equal number 2)
        (equal number 3)
        (equal number 4)))
  :rule-classes
  ((:forward-chaining
        :trigger-terms ((cst-arithmetic-literal-conc? abnf::cst)))))

Theorem: cst-arithmetic-literal-conc?-of-tree-fix-cst

(defthm cst-arithmetic-literal-conc?-of-tree-fix-cst
  (equal (cst-arithmetic-literal-conc? (abnf::tree-fix abnf::cst))
         (cst-arithmetic-literal-conc? abnf::cst)))

Theorem: cst-arithmetic-literal-conc?-tree-equiv-congruence-on-cst

(defthm cst-arithmetic-literal-conc?-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-arithmetic-literal-conc? abnf::cst)
                  (cst-arithmetic-literal-conc? cst-equiv)))
  :rule-classes :congruence)

Theorem: cst-arithmetic-literal-conc?-1-iff-match-conc

(defthm cst-arithmetic-literal-conc?-1-iff-match-conc
  (implies (cst-matchp abnf::cst "arithmetic-literal")
           (iff (equal (cst-arithmetic-literal-conc? abnf::cst)
                       1)
                (cst-list-list-conc-matchp
                     (abnf::tree-nonleaf->branches abnf::cst)
                     "integer-literal"))))

Theorem: cst-arithmetic-literal-conc?-2-iff-match-conc

(defthm cst-arithmetic-literal-conc?-2-iff-match-conc
  (implies (cst-matchp abnf::cst "arithmetic-literal")
           (iff (equal (cst-arithmetic-literal-conc? abnf::cst)
                       2)
                (cst-list-list-conc-matchp
                     (abnf::tree-nonleaf->branches abnf::cst)
                     "field-literal"))))

Theorem: cst-arithmetic-literal-conc?-3-iff-match-conc

(defthm cst-arithmetic-literal-conc?-3-iff-match-conc
  (implies (cst-matchp abnf::cst "arithmetic-literal")
           (iff (equal (cst-arithmetic-literal-conc? abnf::cst)
                       3)
                (cst-list-list-conc-matchp
                     (abnf::tree-nonleaf->branches abnf::cst)
                     "group-literal"))))

Theorem: cst-arithmetic-literal-conc?-4-iff-match-conc

(defthm cst-arithmetic-literal-conc?-4-iff-match-conc
  (implies (cst-matchp abnf::cst "arithmetic-literal")
           (iff (equal (cst-arithmetic-literal-conc? abnf::cst)
                       4)
                (cst-list-list-conc-matchp
                     (abnf::tree-nonleaf->branches abnf::cst)
                     "scalar-literal"))))

Function: cst-string-element-conc?

(defun cst-string-element-conc? (abnf::cst)
 (declare (xargs :guard (abnf::treep abnf::cst)))
 (declare (xargs :guard (cst-matchp abnf::cst "string-element")))
 (let ((__function__ 'cst-string-element-conc?))
  (declare (ignorable __function__))
  (cond
    ((equal
          (abnf::tree-nonleaf->rulename?
               (nth 0
                    (nth 0
                         (abnf::tree-nonleaf->branches abnf::cst))))
          (abnf::rulename "not-dq-or-backslash"))
     1)
    ((equal
          (abnf::tree-nonleaf->rulename?
               (nth 0
                    (nth 0
                         (abnf::tree-nonleaf->branches abnf::cst))))
          (abnf::rulename "escaped-char"))
     2)
    ((equal
          (abnf::tree-nonleaf->rulename?
               (nth 0
                    (nth 0
                         (abnf::tree-nonleaf->branches abnf::cst))))
          (abnf::rulename "escaped-ws"))
     3)
    (t (prog2$ (impossible) 1)))))

Theorem: posp-of-cst-string-element-conc?

(defthm posp-of-cst-string-element-conc?
  (b* ((number (cst-string-element-conc? abnf::cst)))
    (posp number))
  :rule-classes :rewrite)

Theorem: cst-string-element-conc?-possibilities

(defthm cst-string-element-conc?-possibilities
  (b* ((number (cst-string-element-conc? abnf::cst)))
    (or (equal number 1)
        (equal number 2)
        (equal number 3)))
  :rule-classes
  ((:forward-chaining
        :trigger-terms ((cst-string-element-conc? abnf::cst)))))

Theorem: cst-string-element-conc?-of-tree-fix-cst

(defthm cst-string-element-conc?-of-tree-fix-cst
  (equal (cst-string-element-conc? (abnf::tree-fix abnf::cst))
         (cst-string-element-conc? abnf::cst)))

Theorem: cst-string-element-conc?-tree-equiv-congruence-on-cst

(defthm cst-string-element-conc?-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-string-element-conc? abnf::cst)
                  (cst-string-element-conc? cst-equiv)))
  :rule-classes :congruence)

Theorem: cst-string-element-conc?-1-iff-match-conc

(defthm cst-string-element-conc?-1-iff-match-conc
  (implies (cst-matchp abnf::cst "string-element")
           (iff (equal (cst-string-element-conc? abnf::cst)
                       1)
                (cst-list-list-conc-matchp
                     (abnf::tree-nonleaf->branches abnf::cst)
                     "not-dq-or-backslash"))))

Theorem: cst-string-element-conc?-2-iff-match-conc

(defthm cst-string-element-conc?-2-iff-match-conc
  (implies (cst-matchp abnf::cst "string-element")
           (iff (equal (cst-string-element-conc? abnf::cst)
                       2)
                (cst-list-list-conc-matchp
                     (abnf::tree-nonleaf->branches abnf::cst)
                     "escaped-char"))))

Theorem: cst-string-element-conc?-3-iff-match-conc

(defthm cst-string-element-conc?-3-iff-match-conc
  (implies (cst-matchp abnf::cst "string-element")
           (iff (equal (cst-string-element-conc? abnf::cst)
                       3)
                (cst-list-list-conc-matchp
                     (abnf::tree-nonleaf->branches abnf::cst)
                     "escaped-ws"))))

Function: cst-literal-conc?

(defun cst-literal-conc? (abnf::cst)
 (declare (xargs :guard (abnf::treep abnf::cst)))
 (declare (xargs :guard (cst-matchp abnf::cst "literal")))
 (let ((__function__ 'cst-literal-conc?))
  (declare (ignorable __function__))
  (cond
    ((equal
          (abnf::tree-nonleaf->rulename?
               (nth 0
                    (nth 0
                         (abnf::tree-nonleaf->branches abnf::cst))))
          (abnf::rulename "arithmetic-literal"))
     1)
    ((equal
          (abnf::tree-nonleaf->rulename?
               (nth 0
                    (nth 0
                         (abnf::tree-nonleaf->branches abnf::cst))))
          (abnf::rulename "address-literal"))
     2)
    ((equal
          (abnf::tree-nonleaf->rulename?
               (nth 0
                    (nth 0
                         (abnf::tree-nonleaf->branches abnf::cst))))
          (abnf::rulename "boolean-literal"))
     3)
    ((equal
          (abnf::tree-nonleaf->rulename?
               (nth 0
                    (nth 0
                         (abnf::tree-nonleaf->branches abnf::cst))))
          (abnf::rulename "string-literal"))
     4)
    (t (prog2$ (impossible) 1)))))

Theorem: posp-of-cst-literal-conc?

(defthm posp-of-cst-literal-conc?
  (b* ((number (cst-literal-conc? abnf::cst)))
    (posp number))
  :rule-classes :rewrite)

Theorem: cst-literal-conc?-possibilities

(defthm cst-literal-conc?-possibilities
  (b* ((number (cst-literal-conc? abnf::cst)))
    (or (equal number 1)
        (equal number 2)
        (equal number 3)
        (equal number 4)))
  :rule-classes
  ((:forward-chaining
        :trigger-terms ((cst-literal-conc? abnf::cst)))))

Theorem: cst-literal-conc?-of-tree-fix-cst

(defthm cst-literal-conc?-of-tree-fix-cst
  (equal (cst-literal-conc? (abnf::tree-fix abnf::cst))
         (cst-literal-conc? abnf::cst)))

Theorem: cst-literal-conc?-tree-equiv-congruence-on-cst

(defthm cst-literal-conc?-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-literal-conc? abnf::cst)
                  (cst-literal-conc? cst-equiv)))
  :rule-classes :congruence)

Theorem: cst-literal-conc?-1-iff-match-conc

(defthm cst-literal-conc?-1-iff-match-conc
  (implies (cst-matchp abnf::cst "literal")
           (iff (equal (cst-literal-conc? abnf::cst) 1)
                (cst-list-list-conc-matchp
                     (abnf::tree-nonleaf->branches abnf::cst)
                     "arithmetic-literal"))))

Theorem: cst-literal-conc?-2-iff-match-conc

(defthm cst-literal-conc?-2-iff-match-conc
  (implies (cst-matchp abnf::cst "literal")
           (iff (equal (cst-literal-conc? abnf::cst) 2)
                (cst-list-list-conc-matchp
                     (abnf::tree-nonleaf->branches abnf::cst)
                     "address-literal"))))

Theorem: cst-literal-conc?-3-iff-match-conc

(defthm cst-literal-conc?-3-iff-match-conc
  (implies (cst-matchp abnf::cst "literal")
           (iff (equal (cst-literal-conc? abnf::cst) 3)
                (cst-list-list-conc-matchp
                     (abnf::tree-nonleaf->branches abnf::cst)
                     "boolean-literal"))))

Theorem: cst-literal-conc?-4-iff-match-conc

(defthm cst-literal-conc?-4-iff-match-conc
  (implies (cst-matchp abnf::cst "literal")
           (iff (equal (cst-literal-conc? abnf::cst) 4)
                (cst-list-list-conc-matchp
                     (abnf::tree-nonleaf->branches abnf::cst)
                     "string-literal"))))

Function: cst-integer-type-conc?

(defun cst-integer-type-conc? (abnf::cst)
 (declare (xargs :guard (abnf::treep abnf::cst)))
 (declare (xargs :guard (cst-matchp abnf::cst "integer-type")))
 (let ((__function__ 'cst-integer-type-conc?))
  (declare (ignorable __function__))
  (cond
    ((equal
          (abnf::tree-nonleaf->rulename?
               (nth 0
                    (nth 0
                         (abnf::tree-nonleaf->branches abnf::cst))))
          (abnf::rulename "unsigned-type"))
     1)
    ((equal
          (abnf::tree-nonleaf->rulename?
               (nth 0
                    (nth 0
                         (abnf::tree-nonleaf->branches abnf::cst))))
          (abnf::rulename "signed-type"))
     2)
    (t (prog2$ (impossible) 1)))))

Theorem: posp-of-cst-integer-type-conc?

(defthm posp-of-cst-integer-type-conc?
  (b* ((number (cst-integer-type-conc? abnf::cst)))
    (posp number))
  :rule-classes :rewrite)

Theorem: cst-integer-type-conc?-possibilities

(defthm cst-integer-type-conc?-possibilities
  (b* ((number (cst-integer-type-conc? abnf::cst)))
    (or (equal number 1) (equal number 2)))
  :rule-classes
  ((:forward-chaining
        :trigger-terms ((cst-integer-type-conc? abnf::cst)))))

Theorem: cst-integer-type-conc?-of-tree-fix-cst

(defthm cst-integer-type-conc?-of-tree-fix-cst
  (equal (cst-integer-type-conc? (abnf::tree-fix abnf::cst))
         (cst-integer-type-conc? abnf::cst)))

Theorem: cst-integer-type-conc?-tree-equiv-congruence-on-cst

(defthm cst-integer-type-conc?-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-integer-type-conc? abnf::cst)
                  (cst-integer-type-conc? cst-equiv)))
  :rule-classes :congruence)

Theorem: cst-integer-type-conc?-1-iff-match-conc

(defthm cst-integer-type-conc?-1-iff-match-conc
  (implies (cst-matchp abnf::cst "integer-type")
           (iff (equal (cst-integer-type-conc? abnf::cst)
                       1)
                (cst-list-list-conc-matchp
                     (abnf::tree-nonleaf->branches abnf::cst)
                     "unsigned-type"))))

Theorem: cst-integer-type-conc?-2-iff-match-conc

(defthm cst-integer-type-conc?-2-iff-match-conc
  (implies (cst-matchp abnf::cst "integer-type")
           (iff (equal (cst-integer-type-conc? abnf::cst)
                       2)
                (cst-list-list-conc-matchp
                     (abnf::tree-nonleaf->branches abnf::cst)
                     "signed-type"))))

Function: cst-arithmetic-type-conc?

(defun cst-arithmetic-type-conc? (abnf::cst)
 (declare (xargs :guard (abnf::treep abnf::cst)))
 (declare (xargs :guard (cst-matchp abnf::cst "arithmetic-type")))
 (let ((__function__ 'cst-arithmetic-type-conc?))
  (declare (ignorable __function__))
  (cond
    ((equal
          (abnf::tree-nonleaf->rulename?
               (nth 0
                    (nth 0
                         (abnf::tree-nonleaf->branches abnf::cst))))
          (abnf::rulename "integer-type"))
     1)
    ((equal
          (abnf::tree-nonleaf->rulename?
               (nth 0
                    (nth 0
                         (abnf::tree-nonleaf->branches abnf::cst))))
          (abnf::rulename "field-type"))
     2)
    ((equal
          (abnf::tree-nonleaf->rulename?
               (nth 0
                    (nth 0
                         (abnf::tree-nonleaf->branches abnf::cst))))
          (abnf::rulename "group-type"))
     3)
    ((equal
          (abnf::tree-nonleaf->rulename?
               (nth 0
                    (nth 0
                         (abnf::tree-nonleaf->branches abnf::cst))))
          (abnf::rulename "scalar-type"))
     4)
    (t (prog2$ (impossible) 1)))))

Theorem: posp-of-cst-arithmetic-type-conc?

(defthm posp-of-cst-arithmetic-type-conc?
  (b* ((number (cst-arithmetic-type-conc? abnf::cst)))
    (posp number))
  :rule-classes :rewrite)

Theorem: cst-arithmetic-type-conc?-possibilities

(defthm cst-arithmetic-type-conc?-possibilities
  (b* ((number (cst-arithmetic-type-conc? abnf::cst)))
    (or (equal number 1)
        (equal number 2)
        (equal number 3)
        (equal number 4)))
  :rule-classes
  ((:forward-chaining
        :trigger-terms ((cst-arithmetic-type-conc? abnf::cst)))))

Theorem: cst-arithmetic-type-conc?-of-tree-fix-cst

(defthm cst-arithmetic-type-conc?-of-tree-fix-cst
  (equal (cst-arithmetic-type-conc? (abnf::tree-fix abnf::cst))
         (cst-arithmetic-type-conc? abnf::cst)))

Theorem: cst-arithmetic-type-conc?-tree-equiv-congruence-on-cst

(defthm cst-arithmetic-type-conc?-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-arithmetic-type-conc? abnf::cst)
                  (cst-arithmetic-type-conc? cst-equiv)))
  :rule-classes :congruence)

Theorem: cst-arithmetic-type-conc?-1-iff-match-conc

(defthm cst-arithmetic-type-conc?-1-iff-match-conc
  (implies (cst-matchp abnf::cst "arithmetic-type")
           (iff (equal (cst-arithmetic-type-conc? abnf::cst)
                       1)
                (cst-list-list-conc-matchp
                     (abnf::tree-nonleaf->branches abnf::cst)
                     "integer-type"))))

Theorem: cst-arithmetic-type-conc?-2-iff-match-conc

(defthm cst-arithmetic-type-conc?-2-iff-match-conc
  (implies (cst-matchp abnf::cst "arithmetic-type")
           (iff (equal (cst-arithmetic-type-conc? abnf::cst)
                       2)
                (cst-list-list-conc-matchp
                     (abnf::tree-nonleaf->branches abnf::cst)
                     "field-type"))))

Theorem: cst-arithmetic-type-conc?-3-iff-match-conc

(defthm cst-arithmetic-type-conc?-3-iff-match-conc
  (implies (cst-matchp abnf::cst "arithmetic-type")
           (iff (equal (cst-arithmetic-type-conc? abnf::cst)
                       3)
                (cst-list-list-conc-matchp
                     (abnf::tree-nonleaf->branches abnf::cst)
                     "group-type"))))

Theorem: cst-arithmetic-type-conc?-4-iff-match-conc

(defthm cst-arithmetic-type-conc?-4-iff-match-conc
  (implies (cst-matchp abnf::cst "arithmetic-type")
           (iff (equal (cst-arithmetic-type-conc? abnf::cst)
                       4)
                (cst-list-list-conc-matchp
                     (abnf::tree-nonleaf->branches abnf::cst)
                     "scalar-type"))))

Function: cst-literal-type-conc?

(defun cst-literal-type-conc? (abnf::cst)
 (declare (xargs :guard (abnf::treep abnf::cst)))
 (declare (xargs :guard (cst-matchp abnf::cst "literal-type")))
 (let ((__function__ 'cst-literal-type-conc?))
  (declare (ignorable __function__))
  (cond
    ((equal
          (abnf::tree-nonleaf->rulename?
               (nth 0
                    (nth 0
                         (abnf::tree-nonleaf->branches abnf::cst))))
          (abnf::rulename "arithmetic-type"))
     1)
    ((equal
          (abnf::tree-nonleaf->rulename?
               (nth 0
                    (nth 0
                         (abnf::tree-nonleaf->branches abnf::cst))))
          (abnf::rulename "address-type"))
     2)
    ((equal
          (abnf::tree-nonleaf->rulename?
               (nth 0
                    (nth 0
                         (abnf::tree-nonleaf->branches abnf::cst))))
          (abnf::rulename "boolean-type"))
     3)
    ((equal
          (abnf::tree-nonleaf->rulename?
               (nth 0
                    (nth 0
                         (abnf::tree-nonleaf->branches abnf::cst))))
          (abnf::rulename "string-type"))
     4)
    (t (prog2$ (impossible) 1)))))

Theorem: posp-of-cst-literal-type-conc?

(defthm posp-of-cst-literal-type-conc?
  (b* ((number (cst-literal-type-conc? abnf::cst)))
    (posp number))
  :rule-classes :rewrite)

Theorem: cst-literal-type-conc?-possibilities

(defthm cst-literal-type-conc?-possibilities
  (b* ((number (cst-literal-type-conc? abnf::cst)))
    (or (equal number 1)
        (equal number 2)
        (equal number 3)
        (equal number 4)))
  :rule-classes
  ((:forward-chaining
        :trigger-terms ((cst-literal-type-conc? abnf::cst)))))

Theorem: cst-literal-type-conc?-of-tree-fix-cst

(defthm cst-literal-type-conc?-of-tree-fix-cst
  (equal (cst-literal-type-conc? (abnf::tree-fix abnf::cst))
         (cst-literal-type-conc? abnf::cst)))

Theorem: cst-literal-type-conc?-tree-equiv-congruence-on-cst

(defthm cst-literal-type-conc?-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-literal-type-conc? abnf::cst)
                  (cst-literal-type-conc? cst-equiv)))
  :rule-classes :congruence)

Theorem: cst-literal-type-conc?-1-iff-match-conc

(defthm cst-literal-type-conc?-1-iff-match-conc
  (implies (cst-matchp abnf::cst "literal-type")
           (iff (equal (cst-literal-type-conc? abnf::cst)
                       1)
                (cst-list-list-conc-matchp
                     (abnf::tree-nonleaf->branches abnf::cst)
                     "arithmetic-type"))))

Theorem: cst-literal-type-conc?-2-iff-match-conc

(defthm cst-literal-type-conc?-2-iff-match-conc
  (implies (cst-matchp abnf::cst "literal-type")
           (iff (equal (cst-literal-type-conc? abnf::cst)
                       2)
                (cst-list-list-conc-matchp
                     (abnf::tree-nonleaf->branches abnf::cst)
                     "address-type"))))

Theorem: cst-literal-type-conc?-3-iff-match-conc

(defthm cst-literal-type-conc?-3-iff-match-conc
  (implies (cst-matchp abnf::cst "literal-type")
           (iff (equal (cst-literal-type-conc? abnf::cst)
                       3)
                (cst-list-list-conc-matchp
                     (abnf::tree-nonleaf->branches abnf::cst)
                     "boolean-type"))))

Theorem: cst-literal-type-conc?-4-iff-match-conc

(defthm cst-literal-type-conc?-4-iff-match-conc
  (implies (cst-matchp abnf::cst "literal-type")
           (iff (equal (cst-literal-type-conc? abnf::cst)
                       4)
                (cst-list-list-conc-matchp
                     (abnf::tree-nonleaf->branches abnf::cst)
                     "string-type"))))

Function: cst-plaintext-type-conc?

(defun cst-plaintext-type-conc? (abnf::cst)
 (declare (xargs :guard (abnf::treep abnf::cst)))
 (declare (xargs :guard (cst-matchp abnf::cst "plaintext-type")))
 (let ((__function__ 'cst-plaintext-type-conc?))
  (declare (ignorable __function__))
  (cond
    ((equal
          (abnf::tree-nonleaf->rulename?
               (nth 0
                    (nth 0
                         (abnf::tree-nonleaf->branches abnf::cst))))
          (abnf::rulename "literal-type"))
     1)
    ((equal
          (abnf::tree-nonleaf->rulename?
               (nth 0
                    (nth 0
                         (abnf::tree-nonleaf->branches abnf::cst))))
          (abnf::rulename "identifier"))
     2)
    (t (prog2$ (impossible) 1)))))

Theorem: posp-of-cst-plaintext-type-conc?

(defthm posp-of-cst-plaintext-type-conc?
  (b* ((number (cst-plaintext-type-conc? abnf::cst)))
    (posp number))
  :rule-classes :rewrite)

Theorem: cst-plaintext-type-conc?-possibilities

(defthm cst-plaintext-type-conc?-possibilities
  (b* ((number (cst-plaintext-type-conc? abnf::cst)))
    (or (equal number 1) (equal number 2)))
  :rule-classes
  ((:forward-chaining
        :trigger-terms ((cst-plaintext-type-conc? abnf::cst)))))

Theorem: cst-plaintext-type-conc?-of-tree-fix-cst

(defthm cst-plaintext-type-conc?-of-tree-fix-cst
  (equal (cst-plaintext-type-conc? (abnf::tree-fix abnf::cst))
         (cst-plaintext-type-conc? abnf::cst)))

Theorem: cst-plaintext-type-conc?-tree-equiv-congruence-on-cst

(defthm cst-plaintext-type-conc?-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-plaintext-type-conc? abnf::cst)
                  (cst-plaintext-type-conc? cst-equiv)))
  :rule-classes :congruence)

Theorem: cst-plaintext-type-conc?-1-iff-match-conc

(defthm cst-plaintext-type-conc?-1-iff-match-conc
  (implies (cst-matchp abnf::cst "plaintext-type")
           (iff (equal (cst-plaintext-type-conc? abnf::cst)
                       1)
                (cst-list-list-conc-matchp
                     (abnf::tree-nonleaf->branches abnf::cst)
                     "literal-type"))))

Theorem: cst-plaintext-type-conc?-2-iff-match-conc

(defthm cst-plaintext-type-conc?-2-iff-match-conc
  (implies (cst-matchp abnf::cst "plaintext-type")
           (iff (equal (cst-plaintext-type-conc? abnf::cst)
                       2)
                (cst-list-list-conc-matchp
                     (abnf::tree-nonleaf->branches abnf::cst)
                     "identifier"))))

Function: cst-command-conc?

(defun cst-command-conc? (abnf::cst)
 (declare (xargs :guard (abnf::treep abnf::cst)))
 (declare (xargs :guard (cst-matchp abnf::cst "command")))
 (let ((__function__ 'cst-command-conc?))
  (declare (ignorable __function__))
  (cond
    ((equal
          (abnf::tree-nonleaf->rulename?
               (nth 0
                    (nth 0
                         (abnf::tree-nonleaf->branches abnf::cst))))
          (abnf::rulename "decrement"))
     1)
    ((equal
          (abnf::tree-nonleaf->rulename?
               (nth 0
                    (nth 0
                         (abnf::tree-nonleaf->branches abnf::cst))))
          (abnf::rulename "increment"))
     2)
    ((equal
          (abnf::tree-nonleaf->rulename?
               (nth 0
                    (nth 0
                         (abnf::tree-nonleaf->branches abnf::cst))))
          (abnf::rulename "instruction"))
     3)
    (t (prog2$ (impossible) 1)))))

Theorem: posp-of-cst-command-conc?

(defthm posp-of-cst-command-conc?
  (b* ((number (cst-command-conc? abnf::cst)))
    (posp number))
  :rule-classes :rewrite)

Theorem: cst-command-conc?-possibilities

(defthm cst-command-conc?-possibilities
  (b* ((number (cst-command-conc? abnf::cst)))
    (or (equal number 1)
        (equal number 2)
        (equal number 3)))
  :rule-classes
  ((:forward-chaining
        :trigger-terms ((cst-command-conc? abnf::cst)))))

Theorem: cst-command-conc?-of-tree-fix-cst

(defthm cst-command-conc?-of-tree-fix-cst
  (equal (cst-command-conc? (abnf::tree-fix abnf::cst))
         (cst-command-conc? abnf::cst)))

Theorem: cst-command-conc?-tree-equiv-congruence-on-cst

(defthm cst-command-conc?-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-command-conc? abnf::cst)
                  (cst-command-conc? cst-equiv)))
  :rule-classes :congruence)

Theorem: cst-command-conc?-1-iff-match-conc

(defthm cst-command-conc?-1-iff-match-conc
  (implies (cst-matchp abnf::cst "command")
           (iff (equal (cst-command-conc? abnf::cst) 1)
                (cst-list-list-conc-matchp
                     (abnf::tree-nonleaf->branches abnf::cst)
                     "decrement"))))

Theorem: cst-command-conc?-2-iff-match-conc

(defthm cst-command-conc?-2-iff-match-conc
  (implies (cst-matchp abnf::cst "command")
           (iff (equal (cst-command-conc? abnf::cst) 2)
                (cst-list-list-conc-matchp
                     (abnf::tree-nonleaf->branches abnf::cst)
                     "increment"))))

Theorem: cst-command-conc?-3-iff-match-conc

(defthm cst-command-conc?-3-iff-match-conc
  (implies (cst-matchp abnf::cst "command")
           (iff (equal (cst-command-conc? abnf::cst) 3)
                (cst-list-list-conc-matchp
                     (abnf::tree-nonleaf->branches abnf::cst)
                     "instruction"))))

Function: cst-ht-conc

(defun cst-ht-conc (abnf::cst)
  (declare (xargs :guard (abnf::treep abnf::cst)))
  (declare (xargs :guard (cst-matchp abnf::cst "ht")))
  (let ((__function__ 'cst-ht-conc))
    (declare (ignorable __function__))
    (abnf::tree-nonleaf->branches abnf::cst)))

Theorem: tree-list-listp-of-cst-ht-conc

(defthm tree-list-listp-of-cst-ht-conc
  (b* ((abnf::cstss (cst-ht-conc abnf::cst)))
    (abnf::tree-list-listp abnf::cstss))
  :rule-classes :rewrite)

Theorem: cst-ht-conc-match

(defthm cst-ht-conc-match
  (implies (cst-matchp abnf::cst "ht")
           (b* ((abnf::cstss (cst-ht-conc abnf::cst)))
             (cst-list-list-conc-matchp abnf::cstss "%x9")))
  :rule-classes :rewrite)

Theorem: cst-ht-conc-of-tree-fix-cst

(defthm cst-ht-conc-of-tree-fix-cst
  (equal (cst-ht-conc (abnf::tree-fix abnf::cst))
         (cst-ht-conc abnf::cst)))

Theorem: cst-ht-conc-tree-equiv-congruence-on-cst

(defthm cst-ht-conc-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-ht-conc abnf::cst)
                  (cst-ht-conc cst-equiv)))
  :rule-classes :congruence)

Function: cst-lf-conc

(defun cst-lf-conc (abnf::cst)
  (declare (xargs :guard (abnf::treep abnf::cst)))
  (declare (xargs :guard (cst-matchp abnf::cst "lf")))
  (let ((__function__ 'cst-lf-conc))
    (declare (ignorable __function__))
    (abnf::tree-nonleaf->branches abnf::cst)))

Theorem: tree-list-listp-of-cst-lf-conc

(defthm tree-list-listp-of-cst-lf-conc
  (b* ((abnf::cstss (cst-lf-conc abnf::cst)))
    (abnf::tree-list-listp abnf::cstss))
  :rule-classes :rewrite)

Theorem: cst-lf-conc-match

(defthm cst-lf-conc-match
  (implies (cst-matchp abnf::cst "lf")
           (b* ((abnf::cstss (cst-lf-conc abnf::cst)))
             (cst-list-list-conc-matchp abnf::cstss "%xA")))
  :rule-classes :rewrite)

Theorem: cst-lf-conc-of-tree-fix-cst

(defthm cst-lf-conc-of-tree-fix-cst
  (equal (cst-lf-conc (abnf::tree-fix abnf::cst))
         (cst-lf-conc abnf::cst)))

Theorem: cst-lf-conc-tree-equiv-congruence-on-cst

(defthm cst-lf-conc-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-lf-conc abnf::cst)
                  (cst-lf-conc cst-equiv)))
  :rule-classes :congruence)

Function: cst-cr-conc

(defun cst-cr-conc (abnf::cst)
  (declare (xargs :guard (abnf::treep abnf::cst)))
  (declare (xargs :guard (cst-matchp abnf::cst "cr")))
  (let ((__function__ 'cst-cr-conc))
    (declare (ignorable __function__))
    (abnf::tree-nonleaf->branches abnf::cst)))

Theorem: tree-list-listp-of-cst-cr-conc

(defthm tree-list-listp-of-cst-cr-conc
  (b* ((abnf::cstss (cst-cr-conc abnf::cst)))
    (abnf::tree-list-listp abnf::cstss))
  :rule-classes :rewrite)

Theorem: cst-cr-conc-match

(defthm cst-cr-conc-match
  (implies (cst-matchp abnf::cst "cr")
           (b* ((abnf::cstss (cst-cr-conc abnf::cst)))
             (cst-list-list-conc-matchp abnf::cstss "%xD")))
  :rule-classes :rewrite)

Theorem: cst-cr-conc-of-tree-fix-cst

(defthm cst-cr-conc-of-tree-fix-cst
  (equal (cst-cr-conc (abnf::tree-fix abnf::cst))
         (cst-cr-conc abnf::cst)))

Theorem: cst-cr-conc-tree-equiv-congruence-on-cst

(defthm cst-cr-conc-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-cr-conc abnf::cst)
                  (cst-cr-conc cst-equiv)))
  :rule-classes :congruence)

Function: cst-sp-conc

(defun cst-sp-conc (abnf::cst)
  (declare (xargs :guard (abnf::treep abnf::cst)))
  (declare (xargs :guard (cst-matchp abnf::cst "sp")))
  (let ((__function__ 'cst-sp-conc))
    (declare (ignorable __function__))
    (abnf::tree-nonleaf->branches abnf::cst)))

Theorem: tree-list-listp-of-cst-sp-conc

(defthm tree-list-listp-of-cst-sp-conc
  (b* ((abnf::cstss (cst-sp-conc abnf::cst)))
    (abnf::tree-list-listp abnf::cstss))
  :rule-classes :rewrite)

Theorem: cst-sp-conc-match

(defthm cst-sp-conc-match
  (implies (cst-matchp abnf::cst "sp")
           (b* ((abnf::cstss (cst-sp-conc abnf::cst)))
             (cst-list-list-conc-matchp abnf::cstss "%x20")))
  :rule-classes :rewrite)

Theorem: cst-sp-conc-of-tree-fix-cst

(defthm cst-sp-conc-of-tree-fix-cst
  (equal (cst-sp-conc (abnf::tree-fix abnf::cst))
         (cst-sp-conc abnf::cst)))

Theorem: cst-sp-conc-tree-equiv-congruence-on-cst

(defthm cst-sp-conc-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-sp-conc abnf::cst)
                  (cst-sp-conc cst-equiv)))
  :rule-classes :congruence)

Function: cst-dq-conc

(defun cst-dq-conc (abnf::cst)
  (declare (xargs :guard (abnf::treep abnf::cst)))
  (declare (xargs :guard (cst-matchp abnf::cst "dq")))
  (let ((__function__ 'cst-dq-conc))
    (declare (ignorable __function__))
    (abnf::tree-nonleaf->branches abnf::cst)))

Theorem: tree-list-listp-of-cst-dq-conc

(defthm tree-list-listp-of-cst-dq-conc
  (b* ((abnf::cstss (cst-dq-conc abnf::cst)))
    (abnf::tree-list-listp abnf::cstss))
  :rule-classes :rewrite)

Theorem: cst-dq-conc-match

(defthm cst-dq-conc-match
  (implies (cst-matchp abnf::cst "dq")
           (b* ((abnf::cstss (cst-dq-conc abnf::cst)))
             (cst-list-list-conc-matchp abnf::cstss "%x22")))
  :rule-classes :rewrite)

Theorem: cst-dq-conc-of-tree-fix-cst

(defthm cst-dq-conc-of-tree-fix-cst
  (equal (cst-dq-conc (abnf::tree-fix abnf::cst))
         (cst-dq-conc abnf::cst)))

Theorem: cst-dq-conc-tree-equiv-congruence-on-cst

(defthm cst-dq-conc-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-dq-conc abnf::cst)
                  (cst-dq-conc cst-equiv)))
  :rule-classes :congruence)

Function: cst-visible-ascii-conc

(defun cst-visible-ascii-conc (abnf::cst)
  (declare (xargs :guard (abnf::treep abnf::cst)))
  (declare (xargs :guard (cst-matchp abnf::cst "visible-ascii")))
  (let ((__function__ 'cst-visible-ascii-conc))
    (declare (ignorable __function__))
    (abnf::tree-nonleaf->branches abnf::cst)))

Theorem: tree-list-listp-of-cst-visible-ascii-conc

(defthm tree-list-listp-of-cst-visible-ascii-conc
  (b* ((abnf::cstss (cst-visible-ascii-conc abnf::cst)))
    (abnf::tree-list-listp abnf::cstss))
  :rule-classes :rewrite)

Theorem: cst-visible-ascii-conc-match

(defthm cst-visible-ascii-conc-match
  (implies (cst-matchp abnf::cst "visible-ascii")
           (b* ((abnf::cstss (cst-visible-ascii-conc abnf::cst)))
             (cst-list-list-conc-matchp abnf::cstss "%x21-7E")))
  :rule-classes :rewrite)

Theorem: cst-visible-ascii-conc-of-tree-fix-cst

(defthm cst-visible-ascii-conc-of-tree-fix-cst
  (equal (cst-visible-ascii-conc (abnf::tree-fix abnf::cst))
         (cst-visible-ascii-conc abnf::cst)))

Theorem: cst-visible-ascii-conc-tree-equiv-congruence-on-cst

(defthm cst-visible-ascii-conc-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-visible-ascii-conc abnf::cst)
                  (cst-visible-ascii-conc cst-equiv)))
  :rule-classes :congruence)

Function: cst-safe-ascii-conc1

(defun cst-safe-ascii-conc1 (abnf::cst)
 (declare (xargs :guard (abnf::treep abnf::cst)))
 (declare (xargs :guard (and (cst-matchp abnf::cst "safe-ascii")
                             (equal (cst-safe-ascii-conc? abnf::cst)
                                    1))))
 (let ((__function__ 'cst-safe-ascii-conc1))
   (declare (ignorable __function__))
   (abnf::tree-nonleaf->branches abnf::cst)))

Theorem: tree-list-listp-of-cst-safe-ascii-conc1

(defthm tree-list-listp-of-cst-safe-ascii-conc1
  (b* ((abnf::cstss (cst-safe-ascii-conc1 abnf::cst)))
    (abnf::tree-list-listp abnf::cstss))
  :rule-classes :rewrite)

Theorem: cst-safe-ascii-conc1-match

(defthm cst-safe-ascii-conc1-match
  (implies (and (cst-matchp abnf::cst "safe-ascii")
                (equal (cst-safe-ascii-conc? abnf::cst)
                       1))
           (b* ((abnf::cstss (cst-safe-ascii-conc1 abnf::cst)))
             (cst-list-list-conc-matchp abnf::cstss "ht")))
  :rule-classes :rewrite)

Theorem: cst-safe-ascii-conc1-of-tree-fix-cst

(defthm cst-safe-ascii-conc1-of-tree-fix-cst
  (equal (cst-safe-ascii-conc1 (abnf::tree-fix abnf::cst))
         (cst-safe-ascii-conc1 abnf::cst)))

Theorem: cst-safe-ascii-conc1-tree-equiv-congruence-on-cst

(defthm cst-safe-ascii-conc1-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-safe-ascii-conc1 abnf::cst)
                  (cst-safe-ascii-conc1 cst-equiv)))
  :rule-classes :congruence)

Function: cst-safe-ascii-conc2

(defun cst-safe-ascii-conc2 (abnf::cst)
 (declare (xargs :guard (abnf::treep abnf::cst)))
 (declare (xargs :guard (and (cst-matchp abnf::cst "safe-ascii")
                             (equal (cst-safe-ascii-conc? abnf::cst)
                                    2))))
 (let ((__function__ 'cst-safe-ascii-conc2))
   (declare (ignorable __function__))
   (abnf::tree-nonleaf->branches abnf::cst)))

Theorem: tree-list-listp-of-cst-safe-ascii-conc2

(defthm tree-list-listp-of-cst-safe-ascii-conc2
  (b* ((abnf::cstss (cst-safe-ascii-conc2 abnf::cst)))
    (abnf::tree-list-listp abnf::cstss))
  :rule-classes :rewrite)

Theorem: cst-safe-ascii-conc2-match

(defthm cst-safe-ascii-conc2-match
  (implies (and (cst-matchp abnf::cst "safe-ascii")
                (equal (cst-safe-ascii-conc? abnf::cst)
                       2))
           (b* ((abnf::cstss (cst-safe-ascii-conc2 abnf::cst)))
             (cst-list-list-conc-matchp abnf::cstss "lf")))
  :rule-classes :rewrite)

Theorem: cst-safe-ascii-conc2-of-tree-fix-cst

(defthm cst-safe-ascii-conc2-of-tree-fix-cst
  (equal (cst-safe-ascii-conc2 (abnf::tree-fix abnf::cst))
         (cst-safe-ascii-conc2 abnf::cst)))

Theorem: cst-safe-ascii-conc2-tree-equiv-congruence-on-cst

(defthm cst-safe-ascii-conc2-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-safe-ascii-conc2 abnf::cst)
                  (cst-safe-ascii-conc2 cst-equiv)))
  :rule-classes :congruence)

Function: cst-safe-ascii-conc3

(defun cst-safe-ascii-conc3 (abnf::cst)
 (declare (xargs :guard (abnf::treep abnf::cst)))
 (declare (xargs :guard (and (cst-matchp abnf::cst "safe-ascii")
                             (equal (cst-safe-ascii-conc? abnf::cst)
                                    3))))
 (let ((__function__ 'cst-safe-ascii-conc3))
   (declare (ignorable __function__))
   (abnf::tree-nonleaf->branches abnf::cst)))

Theorem: tree-list-listp-of-cst-safe-ascii-conc3

(defthm tree-list-listp-of-cst-safe-ascii-conc3
  (b* ((abnf::cstss (cst-safe-ascii-conc3 abnf::cst)))
    (abnf::tree-list-listp abnf::cstss))
  :rule-classes :rewrite)

Theorem: cst-safe-ascii-conc3-match

(defthm cst-safe-ascii-conc3-match
  (implies (and (cst-matchp abnf::cst "safe-ascii")
                (equal (cst-safe-ascii-conc? abnf::cst)
                       3))
           (b* ((abnf::cstss (cst-safe-ascii-conc3 abnf::cst)))
             (cst-list-list-conc-matchp abnf::cstss "cr")))
  :rule-classes :rewrite)

Theorem: cst-safe-ascii-conc3-of-tree-fix-cst

(defthm cst-safe-ascii-conc3-of-tree-fix-cst
  (equal (cst-safe-ascii-conc3 (abnf::tree-fix abnf::cst))
         (cst-safe-ascii-conc3 abnf::cst)))

Theorem: cst-safe-ascii-conc3-tree-equiv-congruence-on-cst

(defthm cst-safe-ascii-conc3-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-safe-ascii-conc3 abnf::cst)
                  (cst-safe-ascii-conc3 cst-equiv)))
  :rule-classes :congruence)

Function: cst-safe-ascii-conc4

(defun cst-safe-ascii-conc4 (abnf::cst)
 (declare (xargs :guard (abnf::treep abnf::cst)))
 (declare (xargs :guard (and (cst-matchp abnf::cst "safe-ascii")
                             (equal (cst-safe-ascii-conc? abnf::cst)
                                    4))))
 (let ((__function__ 'cst-safe-ascii-conc4))
   (declare (ignorable __function__))
   (abnf::tree-nonleaf->branches abnf::cst)))

Theorem: tree-list-listp-of-cst-safe-ascii-conc4

(defthm tree-list-listp-of-cst-safe-ascii-conc4
  (b* ((abnf::cstss (cst-safe-ascii-conc4 abnf::cst)))
    (abnf::tree-list-listp abnf::cstss))
  :rule-classes :rewrite)

Theorem: cst-safe-ascii-conc4-match

(defthm cst-safe-ascii-conc4-match
  (implies (and (cst-matchp abnf::cst "safe-ascii")
                (equal (cst-safe-ascii-conc? abnf::cst)
                       4))
           (b* ((abnf::cstss (cst-safe-ascii-conc4 abnf::cst)))
             (cst-list-list-conc-matchp abnf::cstss "sp")))
  :rule-classes :rewrite)

Theorem: cst-safe-ascii-conc4-of-tree-fix-cst

(defthm cst-safe-ascii-conc4-of-tree-fix-cst
  (equal (cst-safe-ascii-conc4 (abnf::tree-fix abnf::cst))
         (cst-safe-ascii-conc4 abnf::cst)))

Theorem: cst-safe-ascii-conc4-tree-equiv-congruence-on-cst

(defthm cst-safe-ascii-conc4-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-safe-ascii-conc4 abnf::cst)
                  (cst-safe-ascii-conc4 cst-equiv)))
  :rule-classes :congruence)

Function: cst-safe-ascii-conc5

(defun cst-safe-ascii-conc5 (abnf::cst)
 (declare (xargs :guard (abnf::treep abnf::cst)))
 (declare (xargs :guard (and (cst-matchp abnf::cst "safe-ascii")
                             (equal (cst-safe-ascii-conc? abnf::cst)
                                    5))))
 (let ((__function__ 'cst-safe-ascii-conc5))
   (declare (ignorable __function__))
   (abnf::tree-nonleaf->branches abnf::cst)))

Theorem: tree-list-listp-of-cst-safe-ascii-conc5

(defthm tree-list-listp-of-cst-safe-ascii-conc5
  (b* ((abnf::cstss (cst-safe-ascii-conc5 abnf::cst)))
    (abnf::tree-list-listp abnf::cstss))
  :rule-classes :rewrite)

Theorem: cst-safe-ascii-conc5-match

(defthm cst-safe-ascii-conc5-match
  (implies
       (and (cst-matchp abnf::cst "safe-ascii")
            (equal (cst-safe-ascii-conc? abnf::cst)
                   5))
       (b* ((abnf::cstss (cst-safe-ascii-conc5 abnf::cst)))
         (cst-list-list-conc-matchp abnf::cstss "visible-ascii")))
  :rule-classes :rewrite)

Theorem: cst-safe-ascii-conc5-of-tree-fix-cst

(defthm cst-safe-ascii-conc5-of-tree-fix-cst
  (equal (cst-safe-ascii-conc5 (abnf::tree-fix abnf::cst))
         (cst-safe-ascii-conc5 abnf::cst)))

Theorem: cst-safe-ascii-conc5-tree-equiv-congruence-on-cst

(defthm cst-safe-ascii-conc5-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-safe-ascii-conc5 abnf::cst)
                  (cst-safe-ascii-conc5 cst-equiv)))
  :rule-classes :congruence)

Function: cst-character-conc1

(defun cst-character-conc1 (abnf::cst)
  (declare (xargs :guard (abnf::treep abnf::cst)))
  (declare (xargs :guard (and (cst-matchp abnf::cst "character")
                              (equal (cst-character-conc? abnf::cst)
                                     1))))
  (let ((__function__ 'cst-character-conc1))
    (declare (ignorable __function__))
    (abnf::tree-nonleaf->branches abnf::cst)))

Theorem: tree-list-listp-of-cst-character-conc1

(defthm tree-list-listp-of-cst-character-conc1
  (b* ((abnf::cstss (cst-character-conc1 abnf::cst)))
    (abnf::tree-list-listp abnf::cstss))
  :rule-classes :rewrite)

Theorem: cst-character-conc1-match

(defthm cst-character-conc1-match
  (implies (and (cst-matchp abnf::cst "character")
                (equal (cst-character-conc? abnf::cst)
                       1))
           (b* ((abnf::cstss (cst-character-conc1 abnf::cst)))
             (cst-list-list-conc-matchp abnf::cstss "safe-ascii")))
  :rule-classes :rewrite)

Theorem: cst-character-conc1-of-tree-fix-cst

(defthm cst-character-conc1-of-tree-fix-cst
  (equal (cst-character-conc1 (abnf::tree-fix abnf::cst))
         (cst-character-conc1 abnf::cst)))

Theorem: cst-character-conc1-tree-equiv-congruence-on-cst

(defthm cst-character-conc1-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-character-conc1 abnf::cst)
                  (cst-character-conc1 cst-equiv)))
  :rule-classes :congruence)

Function: cst-character-conc2

(defun cst-character-conc2 (abnf::cst)
  (declare (xargs :guard (abnf::treep abnf::cst)))
  (declare (xargs :guard (and (cst-matchp abnf::cst "character")
                              (equal (cst-character-conc? abnf::cst)
                                     2))))
  (let ((__function__ 'cst-character-conc2))
    (declare (ignorable __function__))
    (abnf::tree-nonleaf->branches abnf::cst)))

Theorem: tree-list-listp-of-cst-character-conc2

(defthm tree-list-listp-of-cst-character-conc2
  (b* ((abnf::cstss (cst-character-conc2 abnf::cst)))
    (abnf::tree-list-listp abnf::cstss))
  :rule-classes :rewrite)

Theorem: cst-character-conc2-match

(defthm cst-character-conc2-match
  (implies
       (and (cst-matchp abnf::cst "character")
            (equal (cst-character-conc? abnf::cst)
                   2))
       (b* ((abnf::cstss (cst-character-conc2 abnf::cst)))
         (cst-list-list-conc-matchp abnf::cstss "safe-nonascii")))
  :rule-classes :rewrite)

Theorem: cst-character-conc2-of-tree-fix-cst

(defthm cst-character-conc2-of-tree-fix-cst
  (equal (cst-character-conc2 (abnf::tree-fix abnf::cst))
         (cst-character-conc2 abnf::cst)))

Theorem: cst-character-conc2-tree-equiv-congruence-on-cst

(defthm cst-character-conc2-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-character-conc2 abnf::cst)
                  (cst-character-conc2 cst-equiv)))
  :rule-classes :congruence)

Function: cst-escaped-lf-conc

(defun cst-escaped-lf-conc (abnf::cst)
  (declare (xargs :guard (abnf::treep abnf::cst)))
  (declare (xargs :guard (cst-matchp abnf::cst "escaped-lf")))
  (let ((__function__ 'cst-escaped-lf-conc))
    (declare (ignorable __function__))
    (abnf::tree-nonleaf->branches abnf::cst)))

Theorem: tree-list-listp-of-cst-escaped-lf-conc

(defthm tree-list-listp-of-cst-escaped-lf-conc
  (b* ((abnf::cstss (cst-escaped-lf-conc abnf::cst)))
    (abnf::tree-list-listp abnf::cstss))
  :rule-classes :rewrite)

Theorem: cst-escaped-lf-conc-match

(defthm cst-escaped-lf-conc-match
  (implies (cst-matchp abnf::cst "escaped-lf")
           (b* ((abnf::cstss (cst-escaped-lf-conc abnf::cst)))
             (cst-list-list-conc-matchp abnf::cstss "\"\\\" lf")))
  :rule-classes :rewrite)

Theorem: cst-escaped-lf-conc-of-tree-fix-cst

(defthm cst-escaped-lf-conc-of-tree-fix-cst
  (equal (cst-escaped-lf-conc (abnf::tree-fix abnf::cst))
         (cst-escaped-lf-conc abnf::cst)))

Theorem: cst-escaped-lf-conc-tree-equiv-congruence-on-cst

(defthm cst-escaped-lf-conc-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-escaped-lf-conc abnf::cst)
                  (cst-escaped-lf-conc cst-equiv)))
  :rule-classes :congruence)

Function: cst-plain-ws-conc1

(defun cst-plain-ws-conc1 (abnf::cst)
  (declare (xargs :guard (abnf::treep abnf::cst)))
  (declare (xargs :guard (and (cst-matchp abnf::cst "plain-ws")
                              (equal (cst-plain-ws-conc? abnf::cst)
                                     1))))
  (let ((__function__ 'cst-plain-ws-conc1))
    (declare (ignorable __function__))
    (abnf::tree-nonleaf->branches abnf::cst)))

Theorem: tree-list-listp-of-cst-plain-ws-conc1

(defthm tree-list-listp-of-cst-plain-ws-conc1
  (b* ((abnf::cstss (cst-plain-ws-conc1 abnf::cst)))
    (abnf::tree-list-listp abnf::cstss))
  :rule-classes :rewrite)

Theorem: cst-plain-ws-conc1-match

(defthm cst-plain-ws-conc1-match
  (implies (and (cst-matchp abnf::cst "plain-ws")
                (equal (cst-plain-ws-conc? abnf::cst)
                       1))
           (b* ((abnf::cstss (cst-plain-ws-conc1 abnf::cst)))
             (cst-list-list-conc-matchp abnf::cstss "ht")))
  :rule-classes :rewrite)

Theorem: cst-plain-ws-conc1-of-tree-fix-cst

(defthm cst-plain-ws-conc1-of-tree-fix-cst
  (equal (cst-plain-ws-conc1 (abnf::tree-fix abnf::cst))
         (cst-plain-ws-conc1 abnf::cst)))

Theorem: cst-plain-ws-conc1-tree-equiv-congruence-on-cst

(defthm cst-plain-ws-conc1-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-plain-ws-conc1 abnf::cst)
                  (cst-plain-ws-conc1 cst-equiv)))
  :rule-classes :congruence)

Function: cst-plain-ws-conc2

(defun cst-plain-ws-conc2 (abnf::cst)
  (declare (xargs :guard (abnf::treep abnf::cst)))
  (declare (xargs :guard (and (cst-matchp abnf::cst "plain-ws")
                              (equal (cst-plain-ws-conc? abnf::cst)
                                     2))))
  (let ((__function__ 'cst-plain-ws-conc2))
    (declare (ignorable __function__))
    (abnf::tree-nonleaf->branches abnf::cst)))

Theorem: tree-list-listp-of-cst-plain-ws-conc2

(defthm tree-list-listp-of-cst-plain-ws-conc2
  (b* ((abnf::cstss (cst-plain-ws-conc2 abnf::cst)))
    (abnf::tree-list-listp abnf::cstss))
  :rule-classes :rewrite)

Theorem: cst-plain-ws-conc2-match

(defthm cst-plain-ws-conc2-match
  (implies (and (cst-matchp abnf::cst "plain-ws")
                (equal (cst-plain-ws-conc? abnf::cst)
                       2))
           (b* ((abnf::cstss (cst-plain-ws-conc2 abnf::cst)))
             (cst-list-list-conc-matchp abnf::cstss "sp")))
  :rule-classes :rewrite)

Theorem: cst-plain-ws-conc2-of-tree-fix-cst

(defthm cst-plain-ws-conc2-of-tree-fix-cst
  (equal (cst-plain-ws-conc2 (abnf::tree-fix abnf::cst))
         (cst-plain-ws-conc2 abnf::cst)))

Theorem: cst-plain-ws-conc2-tree-equiv-congruence-on-cst

(defthm cst-plain-ws-conc2-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-plain-ws-conc2 abnf::cst)
                  (cst-plain-ws-conc2 cst-equiv)))
  :rule-classes :congruence)

Function: cst-plain-ws-conc3

(defun cst-plain-ws-conc3 (abnf::cst)
  (declare (xargs :guard (abnf::treep abnf::cst)))
  (declare (xargs :guard (and (cst-matchp abnf::cst "plain-ws")
                              (equal (cst-plain-ws-conc? abnf::cst)
                                     3))))
  (let ((__function__ 'cst-plain-ws-conc3))
    (declare (ignorable __function__))
    (abnf::tree-nonleaf->branches abnf::cst)))

Theorem: tree-list-listp-of-cst-plain-ws-conc3

(defthm tree-list-listp-of-cst-plain-ws-conc3
  (b* ((abnf::cstss (cst-plain-ws-conc3 abnf::cst)))
    (abnf::tree-list-listp abnf::cstss))
  :rule-classes :rewrite)

Theorem: cst-plain-ws-conc3-match

(defthm cst-plain-ws-conc3-match
  (implies (and (cst-matchp abnf::cst "plain-ws")
                (equal (cst-plain-ws-conc? abnf::cst)
                       3))
           (b* ((abnf::cstss (cst-plain-ws-conc3 abnf::cst)))
             (cst-list-list-conc-matchp abnf::cstss "lf")))
  :rule-classes :rewrite)

Theorem: cst-plain-ws-conc3-of-tree-fix-cst

(defthm cst-plain-ws-conc3-of-tree-fix-cst
  (equal (cst-plain-ws-conc3 (abnf::tree-fix abnf::cst))
         (cst-plain-ws-conc3 abnf::cst)))

Theorem: cst-plain-ws-conc3-tree-equiv-congruence-on-cst

(defthm cst-plain-ws-conc3-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-plain-ws-conc3 abnf::cst)
                  (cst-plain-ws-conc3 cst-equiv)))
  :rule-classes :congruence)

Function: cst-plain-ws-conc4

(defun cst-plain-ws-conc4 (abnf::cst)
  (declare (xargs :guard (abnf::treep abnf::cst)))
  (declare (xargs :guard (and (cst-matchp abnf::cst "plain-ws")
                              (equal (cst-plain-ws-conc? abnf::cst)
                                     4))))
  (let ((__function__ 'cst-plain-ws-conc4))
    (declare (ignorable __function__))
    (abnf::tree-nonleaf->branches abnf::cst)))

Theorem: tree-list-listp-of-cst-plain-ws-conc4

(defthm tree-list-listp-of-cst-plain-ws-conc4
  (b* ((abnf::cstss (cst-plain-ws-conc4 abnf::cst)))
    (abnf::tree-list-listp abnf::cstss))
  :rule-classes :rewrite)

Theorem: cst-plain-ws-conc4-match

(defthm cst-plain-ws-conc4-match
  (implies (and (cst-matchp abnf::cst "plain-ws")
                (equal (cst-plain-ws-conc? abnf::cst)
                       4))
           (b* ((abnf::cstss (cst-plain-ws-conc4 abnf::cst)))
             (cst-list-list-conc-matchp abnf::cstss "cr")))
  :rule-classes :rewrite)

Theorem: cst-plain-ws-conc4-of-tree-fix-cst

(defthm cst-plain-ws-conc4-of-tree-fix-cst
  (equal (cst-plain-ws-conc4 (abnf::tree-fix abnf::cst))
         (cst-plain-ws-conc4 abnf::cst)))

Theorem: cst-plain-ws-conc4-tree-equiv-congruence-on-cst

(defthm cst-plain-ws-conc4-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-plain-ws-conc4 abnf::cst)
                  (cst-plain-ws-conc4 cst-equiv)))
  :rule-classes :congruence)

Function: cst-ws-conc

(defun cst-ws-conc (abnf::cst)
  (declare (xargs :guard (abnf::treep abnf::cst)))
  (declare (xargs :guard (cst-matchp abnf::cst "ws")))
  (let ((__function__ 'cst-ws-conc))
    (declare (ignorable __function__))
    (abnf::tree-nonleaf->branches abnf::cst)))

Theorem: tree-list-listp-of-cst-ws-conc

(defthm tree-list-listp-of-cst-ws-conc
  (b* ((abnf::cstss (cst-ws-conc abnf::cst)))
    (abnf::tree-list-listp abnf::cstss))
  :rule-classes :rewrite)

Theorem: cst-ws-conc-match

(defthm cst-ws-conc-match
 (implies
      (cst-matchp abnf::cst "ws")
      (b* ((abnf::cstss (cst-ws-conc abnf::cst)))
        (cst-list-list-conc-matchp abnf::cstss
                                   "*( 1*plain-ws / escaped-lf )")))
 :rule-classes :rewrite)

Theorem: cst-ws-conc-of-tree-fix-cst

(defthm cst-ws-conc-of-tree-fix-cst
  (equal (cst-ws-conc (abnf::tree-fix abnf::cst))
         (cst-ws-conc abnf::cst)))

Theorem: cst-ws-conc-tree-equiv-congruence-on-cst

(defthm cst-ws-conc-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-ws-conc abnf::cst)
                  (cst-ws-conc cst-equiv)))
  :rule-classes :congruence)

Function: cst-comment-conc1

(defun cst-comment-conc1 (abnf::cst)
  (declare (xargs :guard (abnf::treep abnf::cst)))
  (declare (xargs :guard (and (cst-matchp abnf::cst "comment")
                              (equal (cst-comment-conc? abnf::cst)
                                     1))))
  (let ((__function__ 'cst-comment-conc1))
    (declare (ignorable __function__))
    (abnf::tree-nonleaf->branches abnf::cst)))

Theorem: tree-list-listp-of-cst-comment-conc1

(defthm tree-list-listp-of-cst-comment-conc1
  (b* ((abnf::cstss (cst-comment-conc1 abnf::cst)))
    (abnf::tree-list-listp abnf::cstss))
  :rule-classes :rewrite)

Theorem: cst-comment-conc1-match

(defthm cst-comment-conc1-match
 (implies (and (cst-matchp abnf::cst "comment")
               (equal (cst-comment-conc? abnf::cst) 1))
          (b* ((abnf::cstss (cst-comment-conc1 abnf::cst)))
            (cst-list-list-conc-matchp abnf::cstss "line-comment")))
 :rule-classes :rewrite)

Theorem: cst-comment-conc1-of-tree-fix-cst

(defthm cst-comment-conc1-of-tree-fix-cst
  (equal (cst-comment-conc1 (abnf::tree-fix abnf::cst))
         (cst-comment-conc1 abnf::cst)))

Theorem: cst-comment-conc1-tree-equiv-congruence-on-cst

(defthm cst-comment-conc1-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-comment-conc1 abnf::cst)
                  (cst-comment-conc1 cst-equiv)))
  :rule-classes :congruence)

Function: cst-comment-conc2

(defun cst-comment-conc2 (abnf::cst)
  (declare (xargs :guard (abnf::treep abnf::cst)))
  (declare (xargs :guard (and (cst-matchp abnf::cst "comment")
                              (equal (cst-comment-conc? abnf::cst)
                                     2))))
  (let ((__function__ 'cst-comment-conc2))
    (declare (ignorable __function__))
    (abnf::tree-nonleaf->branches abnf::cst)))

Theorem: tree-list-listp-of-cst-comment-conc2

(defthm tree-list-listp-of-cst-comment-conc2
  (b* ((abnf::cstss (cst-comment-conc2 abnf::cst)))
    (abnf::tree-list-listp abnf::cstss))
  :rule-classes :rewrite)

Theorem: cst-comment-conc2-match

(defthm cst-comment-conc2-match
  (implies
       (and (cst-matchp abnf::cst "comment")
            (equal (cst-comment-conc? abnf::cst) 2))
       (b* ((abnf::cstss (cst-comment-conc2 abnf::cst)))
         (cst-list-list-conc-matchp abnf::cstss "block-comment")))
  :rule-classes :rewrite)

Theorem: cst-comment-conc2-of-tree-fix-cst

(defthm cst-comment-conc2-of-tree-fix-cst
  (equal (cst-comment-conc2 (abnf::tree-fix abnf::cst))
         (cst-comment-conc2 abnf::cst)))

Theorem: cst-comment-conc2-tree-equiv-congruence-on-cst

(defthm cst-comment-conc2-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-comment-conc2 abnf::cst)
                  (cst-comment-conc2 cst-equiv)))
  :rule-classes :congruence)

Function: cst-line-comment-conc

(defun cst-line-comment-conc (abnf::cst)
  (declare (xargs :guard (abnf::treep abnf::cst)))
  (declare (xargs :guard (cst-matchp abnf::cst "line-comment")))
  (let ((__function__ 'cst-line-comment-conc))
    (declare (ignorable __function__))
    (abnf::tree-nonleaf->branches abnf::cst)))

Theorem: tree-list-listp-of-cst-line-comment-conc

(defthm tree-list-listp-of-cst-line-comment-conc
  (b* ((abnf::cstss (cst-line-comment-conc abnf::cst)))
    (abnf::tree-list-listp abnf::cstss))
  :rule-classes :rewrite)

Theorem: cst-line-comment-conc-match

(defthm cst-line-comment-conc-match
  (implies (cst-matchp abnf::cst "line-comment")
           (b* ((abnf::cstss (cst-line-comment-conc abnf::cst)))
             (cst-list-list-conc-matchp
                  abnf::cstss
                  "\"//\" *( escaped-lf / not-lf-or-cr )")))
  :rule-classes :rewrite)

Theorem: cst-line-comment-conc-of-tree-fix-cst

(defthm cst-line-comment-conc-of-tree-fix-cst
  (equal (cst-line-comment-conc (abnf::tree-fix abnf::cst))
         (cst-line-comment-conc abnf::cst)))

Theorem: cst-line-comment-conc-tree-equiv-congruence-on-cst

(defthm cst-line-comment-conc-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-line-comment-conc abnf::cst)
                  (cst-line-comment-conc cst-equiv)))
  :rule-classes :congruence)

Function: cst-not-lf-or-cr-conc1

(defun cst-not-lf-or-cr-conc1 (abnf::cst)
  (declare (xargs :guard (abnf::treep abnf::cst)))
  (declare
       (xargs :guard (and (cst-matchp abnf::cst "not-lf-or-cr")
                          (equal (cst-not-lf-or-cr-conc? abnf::cst)
                                 1))))
  (let ((__function__ 'cst-not-lf-or-cr-conc1))
    (declare (ignorable __function__))
    (abnf::tree-nonleaf->branches abnf::cst)))

Theorem: tree-list-listp-of-cst-not-lf-or-cr-conc1

(defthm tree-list-listp-of-cst-not-lf-or-cr-conc1
  (b* ((abnf::cstss (cst-not-lf-or-cr-conc1 abnf::cst)))
    (abnf::tree-list-listp abnf::cstss))
  :rule-classes :rewrite)

Theorem: cst-not-lf-or-cr-conc1-match

(defthm cst-not-lf-or-cr-conc1-match
  (implies (and (cst-matchp abnf::cst "not-lf-or-cr")
                (equal (cst-not-lf-or-cr-conc? abnf::cst)
                       1))
           (b* ((abnf::cstss (cst-not-lf-or-cr-conc1 abnf::cst)))
             (cst-list-list-conc-matchp abnf::cstss "ht")))
  :rule-classes :rewrite)

Theorem: cst-not-lf-or-cr-conc1-of-tree-fix-cst

(defthm cst-not-lf-or-cr-conc1-of-tree-fix-cst
  (equal (cst-not-lf-or-cr-conc1 (abnf::tree-fix abnf::cst))
         (cst-not-lf-or-cr-conc1 abnf::cst)))

Theorem: cst-not-lf-or-cr-conc1-tree-equiv-congruence-on-cst

(defthm cst-not-lf-or-cr-conc1-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-not-lf-or-cr-conc1 abnf::cst)
                  (cst-not-lf-or-cr-conc1 cst-equiv)))
  :rule-classes :congruence)

Function: cst-not-lf-or-cr-conc2

(defun cst-not-lf-or-cr-conc2 (abnf::cst)
  (declare (xargs :guard (abnf::treep abnf::cst)))
  (declare
       (xargs :guard (and (cst-matchp abnf::cst "not-lf-or-cr")
                          (equal (cst-not-lf-or-cr-conc? abnf::cst)
                                 2))))
  (let ((__function__ 'cst-not-lf-or-cr-conc2))
    (declare (ignorable __function__))
    (abnf::tree-nonleaf->branches abnf::cst)))

Theorem: tree-list-listp-of-cst-not-lf-or-cr-conc2

(defthm tree-list-listp-of-cst-not-lf-or-cr-conc2
  (b* ((abnf::cstss (cst-not-lf-or-cr-conc2 abnf::cst)))
    (abnf::tree-list-listp abnf::cstss))
  :rule-classes :rewrite)

Theorem: cst-not-lf-or-cr-conc2-match

(defthm cst-not-lf-or-cr-conc2-match
  (implies (and (cst-matchp abnf::cst "not-lf-or-cr")
                (equal (cst-not-lf-or-cr-conc? abnf::cst)
                       2))
           (b* ((abnf::cstss (cst-not-lf-or-cr-conc2 abnf::cst)))
             (cst-list-list-conc-matchp abnf::cstss "sp")))
  :rule-classes :rewrite)

Theorem: cst-not-lf-or-cr-conc2-of-tree-fix-cst

(defthm cst-not-lf-or-cr-conc2-of-tree-fix-cst
  (equal (cst-not-lf-or-cr-conc2 (abnf::tree-fix abnf::cst))
         (cst-not-lf-or-cr-conc2 abnf::cst)))

Theorem: cst-not-lf-or-cr-conc2-tree-equiv-congruence-on-cst

(defthm cst-not-lf-or-cr-conc2-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-not-lf-or-cr-conc2 abnf::cst)
                  (cst-not-lf-or-cr-conc2 cst-equiv)))
  :rule-classes :congruence)

Function: cst-not-lf-or-cr-conc3

(defun cst-not-lf-or-cr-conc3 (abnf::cst)
  (declare (xargs :guard (abnf::treep abnf::cst)))
  (declare
       (xargs :guard (and (cst-matchp abnf::cst "not-lf-or-cr")
                          (equal (cst-not-lf-or-cr-conc? abnf::cst)
                                 3))))
  (let ((__function__ 'cst-not-lf-or-cr-conc3))
    (declare (ignorable __function__))
    (abnf::tree-nonleaf->branches abnf::cst)))

Theorem: tree-list-listp-of-cst-not-lf-or-cr-conc3

(defthm tree-list-listp-of-cst-not-lf-or-cr-conc3
  (b* ((abnf::cstss (cst-not-lf-or-cr-conc3 abnf::cst)))
    (abnf::tree-list-listp abnf::cstss))
  :rule-classes :rewrite)

Theorem: cst-not-lf-or-cr-conc3-match

(defthm cst-not-lf-or-cr-conc3-match
  (implies
       (and (cst-matchp abnf::cst "not-lf-or-cr")
            (equal (cst-not-lf-or-cr-conc? abnf::cst)
                   3))
       (b* ((abnf::cstss (cst-not-lf-or-cr-conc3 abnf::cst)))
         (cst-list-list-conc-matchp abnf::cstss "visible-ascii")))
  :rule-classes :rewrite)

Theorem: cst-not-lf-or-cr-conc3-of-tree-fix-cst

(defthm cst-not-lf-or-cr-conc3-of-tree-fix-cst
  (equal (cst-not-lf-or-cr-conc3 (abnf::tree-fix abnf::cst))
         (cst-not-lf-or-cr-conc3 abnf::cst)))

Theorem: cst-not-lf-or-cr-conc3-tree-equiv-congruence-on-cst

(defthm cst-not-lf-or-cr-conc3-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-not-lf-or-cr-conc3 abnf::cst)
                  (cst-not-lf-or-cr-conc3 cst-equiv)))
  :rule-classes :congruence)

Function: cst-not-lf-or-cr-conc4

(defun cst-not-lf-or-cr-conc4 (abnf::cst)
  (declare (xargs :guard (abnf::treep abnf::cst)))
  (declare
       (xargs :guard (and (cst-matchp abnf::cst "not-lf-or-cr")
                          (equal (cst-not-lf-or-cr-conc? abnf::cst)
                                 4))))
  (let ((__function__ 'cst-not-lf-or-cr-conc4))
    (declare (ignorable __function__))
    (abnf::tree-nonleaf->branches abnf::cst)))

Theorem: tree-list-listp-of-cst-not-lf-or-cr-conc4

(defthm tree-list-listp-of-cst-not-lf-or-cr-conc4
  (b* ((abnf::cstss (cst-not-lf-or-cr-conc4 abnf::cst)))
    (abnf::tree-list-listp abnf::cstss))
  :rule-classes :rewrite)

Theorem: cst-not-lf-or-cr-conc4-match

(defthm cst-not-lf-or-cr-conc4-match
  (implies
       (and (cst-matchp abnf::cst "not-lf-or-cr")
            (equal (cst-not-lf-or-cr-conc? abnf::cst)
                   4))
       (b* ((abnf::cstss (cst-not-lf-or-cr-conc4 abnf::cst)))
         (cst-list-list-conc-matchp abnf::cstss "safe-nonascii")))
  :rule-classes :rewrite)

Theorem: cst-not-lf-or-cr-conc4-of-tree-fix-cst

(defthm cst-not-lf-or-cr-conc4-of-tree-fix-cst
  (equal (cst-not-lf-or-cr-conc4 (abnf::tree-fix abnf::cst))
         (cst-not-lf-or-cr-conc4 abnf::cst)))

Theorem: cst-not-lf-or-cr-conc4-tree-equiv-congruence-on-cst

(defthm cst-not-lf-or-cr-conc4-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-not-lf-or-cr-conc4 abnf::cst)
                  (cst-not-lf-or-cr-conc4 cst-equiv)))
  :rule-classes :congruence)

Function: cst-block-comment-conc

(defun cst-block-comment-conc (abnf::cst)
  (declare (xargs :guard (abnf::treep abnf::cst)))
  (declare (xargs :guard (cst-matchp abnf::cst "block-comment")))
  (let ((__function__ 'cst-block-comment-conc))
    (declare (ignorable __function__))
    (abnf::tree-nonleaf->branches abnf::cst)))

Theorem: tree-list-listp-of-cst-block-comment-conc

(defthm tree-list-listp-of-cst-block-comment-conc
  (b* ((abnf::cstss (cst-block-comment-conc abnf::cst)))
    (abnf::tree-list-listp abnf::cstss))
  :rule-classes :rewrite)

Theorem: cst-block-comment-conc-match

(defthm cst-block-comment-conc-match
  (implies
       (cst-matchp abnf::cst "block-comment")
       (b* ((abnf::cstss (cst-block-comment-conc abnf::cst)))
         (cst-list-list-conc-matchp abnf::cstss
                                    "\"/*\" rest-of-block-comment")))
  :rule-classes :rewrite)

Theorem: cst-block-comment-conc-of-tree-fix-cst

(defthm cst-block-comment-conc-of-tree-fix-cst
  (equal (cst-block-comment-conc (abnf::tree-fix abnf::cst))
         (cst-block-comment-conc abnf::cst)))

Theorem: cst-block-comment-conc-tree-equiv-congruence-on-cst

(defthm cst-block-comment-conc-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-block-comment-conc abnf::cst)
                  (cst-block-comment-conc cst-equiv)))
  :rule-classes :congruence)

Function: cst-cws-conc

(defun cst-cws-conc (abnf::cst)
  (declare (xargs :guard (abnf::treep abnf::cst)))
  (declare (xargs :guard (cst-matchp abnf::cst "cws")))
  (let ((__function__ 'cst-cws-conc))
    (declare (ignorable __function__))
    (abnf::tree-nonleaf->branches abnf::cst)))

Theorem: tree-list-listp-of-cst-cws-conc

(defthm tree-list-listp-of-cst-cws-conc
  (b* ((abnf::cstss (cst-cws-conc abnf::cst)))
    (abnf::tree-list-listp abnf::cstss))
  :rule-classes :rewrite)

Theorem: cst-cws-conc-match

(defthm cst-cws-conc-match
 (implies
  (cst-matchp abnf::cst "cws")
  (b* ((abnf::cstss (cst-cws-conc abnf::cst)))
    (cst-list-list-conc-matchp abnf::cstss "ws *( comment / ws )")))
 :rule-classes :rewrite)

Theorem: cst-cws-conc-of-tree-fix-cst

(defthm cst-cws-conc-of-tree-fix-cst
  (equal (cst-cws-conc (abnf::tree-fix abnf::cst))
         (cst-cws-conc abnf::cst)))

Theorem: cst-cws-conc-tree-equiv-congruence-on-cst

(defthm cst-cws-conc-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-cws-conc abnf::cst)
                  (cst-cws-conc cst-equiv)))
  :rule-classes :congruence)

Function: cst-uppercase-letter-conc

(defun cst-uppercase-letter-conc (abnf::cst)
  (declare (xargs :guard (abnf::treep abnf::cst)))
  (declare (xargs :guard (cst-matchp abnf::cst "uppercase-letter")))
  (let ((__function__ 'cst-uppercase-letter-conc))
    (declare (ignorable __function__))
    (abnf::tree-nonleaf->branches abnf::cst)))

Theorem: tree-list-listp-of-cst-uppercase-letter-conc

(defthm tree-list-listp-of-cst-uppercase-letter-conc
  (b* ((abnf::cstss (cst-uppercase-letter-conc abnf::cst)))
    (abnf::tree-list-listp abnf::cstss))
  :rule-classes :rewrite)

Theorem: cst-uppercase-letter-conc-match

(defthm cst-uppercase-letter-conc-match
  (implies (cst-matchp abnf::cst "uppercase-letter")
           (b* ((abnf::cstss (cst-uppercase-letter-conc abnf::cst)))
             (cst-list-list-conc-matchp abnf::cstss "%x41-5A")))
  :rule-classes :rewrite)

Theorem: cst-uppercase-letter-conc-of-tree-fix-cst

(defthm cst-uppercase-letter-conc-of-tree-fix-cst
  (equal (cst-uppercase-letter-conc (abnf::tree-fix abnf::cst))
         (cst-uppercase-letter-conc abnf::cst)))

Theorem: cst-uppercase-letter-conc-tree-equiv-congruence-on-cst

(defthm cst-uppercase-letter-conc-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-uppercase-letter-conc abnf::cst)
                  (cst-uppercase-letter-conc cst-equiv)))
  :rule-classes :congruence)

Function: cst-lowercase-letter-conc

(defun cst-lowercase-letter-conc (abnf::cst)
  (declare (xargs :guard (abnf::treep abnf::cst)))
  (declare (xargs :guard (cst-matchp abnf::cst "lowercase-letter")))
  (let ((__function__ 'cst-lowercase-letter-conc))
    (declare (ignorable __function__))
    (abnf::tree-nonleaf->branches abnf::cst)))

Theorem: tree-list-listp-of-cst-lowercase-letter-conc

(defthm tree-list-listp-of-cst-lowercase-letter-conc
  (b* ((abnf::cstss (cst-lowercase-letter-conc abnf::cst)))
    (abnf::tree-list-listp abnf::cstss))
  :rule-classes :rewrite)

Theorem: cst-lowercase-letter-conc-match

(defthm cst-lowercase-letter-conc-match
  (implies (cst-matchp abnf::cst "lowercase-letter")
           (b* ((abnf::cstss (cst-lowercase-letter-conc abnf::cst)))
             (cst-list-list-conc-matchp abnf::cstss "%x61-7A")))
  :rule-classes :rewrite)

Theorem: cst-lowercase-letter-conc-of-tree-fix-cst

(defthm cst-lowercase-letter-conc-of-tree-fix-cst
  (equal (cst-lowercase-letter-conc (abnf::tree-fix abnf::cst))
         (cst-lowercase-letter-conc abnf::cst)))

Theorem: cst-lowercase-letter-conc-tree-equiv-congruence-on-cst

(defthm cst-lowercase-letter-conc-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-lowercase-letter-conc abnf::cst)
                  (cst-lowercase-letter-conc cst-equiv)))
  :rule-classes :congruence)

Function: cst-letter-conc1

(defun cst-letter-conc1 (abnf::cst)
  (declare (xargs :guard (abnf::treep abnf::cst)))
  (declare (xargs :guard (and (cst-matchp abnf::cst "letter")
                              (equal (cst-letter-conc? abnf::cst)
                                     1))))
  (let ((__function__ 'cst-letter-conc1))
    (declare (ignorable __function__))
    (abnf::tree-nonleaf->branches abnf::cst)))

Theorem: tree-list-listp-of-cst-letter-conc1

(defthm tree-list-listp-of-cst-letter-conc1
  (b* ((abnf::cstss (cst-letter-conc1 abnf::cst)))
    (abnf::tree-list-listp abnf::cstss))
  :rule-classes :rewrite)

Theorem: cst-letter-conc1-match

(defthm cst-letter-conc1-match
 (implies
      (and (cst-matchp abnf::cst "letter")
           (equal (cst-letter-conc? abnf::cst) 1))
      (b* ((abnf::cstss (cst-letter-conc1 abnf::cst)))
        (cst-list-list-conc-matchp abnf::cstss "uppercase-letter")))
 :rule-classes :rewrite)

Theorem: cst-letter-conc1-of-tree-fix-cst

(defthm cst-letter-conc1-of-tree-fix-cst
  (equal (cst-letter-conc1 (abnf::tree-fix abnf::cst))
         (cst-letter-conc1 abnf::cst)))

Theorem: cst-letter-conc1-tree-equiv-congruence-on-cst

(defthm cst-letter-conc1-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-letter-conc1 abnf::cst)
                  (cst-letter-conc1 cst-equiv)))
  :rule-classes :congruence)

Function: cst-letter-conc2

(defun cst-letter-conc2 (abnf::cst)
  (declare (xargs :guard (abnf::treep abnf::cst)))
  (declare (xargs :guard (and (cst-matchp abnf::cst "letter")
                              (equal (cst-letter-conc? abnf::cst)
                                     2))))
  (let ((__function__ 'cst-letter-conc2))
    (declare (ignorable __function__))
    (abnf::tree-nonleaf->branches abnf::cst)))

Theorem: tree-list-listp-of-cst-letter-conc2

(defthm tree-list-listp-of-cst-letter-conc2
  (b* ((abnf::cstss (cst-letter-conc2 abnf::cst)))
    (abnf::tree-list-listp abnf::cstss))
  :rule-classes :rewrite)

Theorem: cst-letter-conc2-match

(defthm cst-letter-conc2-match
 (implies
      (and (cst-matchp abnf::cst "letter")
           (equal (cst-letter-conc? abnf::cst) 2))
      (b* ((abnf::cstss (cst-letter-conc2 abnf::cst)))
        (cst-list-list-conc-matchp abnf::cstss "lowercase-letter")))
 :rule-classes :rewrite)

Theorem: cst-letter-conc2-of-tree-fix-cst

(defthm cst-letter-conc2-of-tree-fix-cst
  (equal (cst-letter-conc2 (abnf::tree-fix abnf::cst))
         (cst-letter-conc2 abnf::cst)))

Theorem: cst-letter-conc2-tree-equiv-congruence-on-cst

(defthm cst-letter-conc2-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-letter-conc2 abnf::cst)
                  (cst-letter-conc2 cst-equiv)))
  :rule-classes :congruence)

Function: cst-digit-conc

(defun cst-digit-conc (abnf::cst)
  (declare (xargs :guard (abnf::treep abnf::cst)))
  (declare (xargs :guard (cst-matchp abnf::cst "digit")))
  (let ((__function__ 'cst-digit-conc))
    (declare (ignorable __function__))
    (abnf::tree-nonleaf->branches abnf::cst)))

Theorem: tree-list-listp-of-cst-digit-conc

(defthm tree-list-listp-of-cst-digit-conc
  (b* ((abnf::cstss (cst-digit-conc abnf::cst)))
    (abnf::tree-list-listp abnf::cstss))
  :rule-classes :rewrite)

Theorem: cst-digit-conc-match

(defthm cst-digit-conc-match
  (implies (cst-matchp abnf::cst "digit")
           (b* ((abnf::cstss (cst-digit-conc abnf::cst)))
             (cst-list-list-conc-matchp abnf::cstss "%x30-39")))
  :rule-classes :rewrite)

Theorem: cst-digit-conc-of-tree-fix-cst

(defthm cst-digit-conc-of-tree-fix-cst
  (equal (cst-digit-conc (abnf::tree-fix abnf::cst))
         (cst-digit-conc abnf::cst)))

Theorem: cst-digit-conc-tree-equiv-congruence-on-cst

(defthm cst-digit-conc-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-digit-conc abnf::cst)
                  (cst-digit-conc cst-equiv)))
  :rule-classes :congruence)

Function: cst-identifier-conc

(defun cst-identifier-conc (abnf::cst)
  (declare (xargs :guard (abnf::treep abnf::cst)))
  (declare (xargs :guard (cst-matchp abnf::cst "identifier")))
  (let ((__function__ 'cst-identifier-conc))
    (declare (ignorable __function__))
    (abnf::tree-nonleaf->branches abnf::cst)))

Theorem: tree-list-listp-of-cst-identifier-conc

(defthm tree-list-listp-of-cst-identifier-conc
  (b* ((abnf::cstss (cst-identifier-conc abnf::cst)))
    (abnf::tree-list-listp abnf::cstss))
  :rule-classes :rewrite)

Theorem: cst-identifier-conc-match

(defthm cst-identifier-conc-match
 (implies
  (cst-matchp abnf::cst "identifier")
  (b* ((abnf::cstss (cst-identifier-conc abnf::cst)))
    (cst-list-list-conc-matchp abnf::cstss
                               "letter *( letter / digit / \"_\" )")))
 :rule-classes :rewrite)

Theorem: cst-identifier-conc-of-tree-fix-cst

(defthm cst-identifier-conc-of-tree-fix-cst
  (equal (cst-identifier-conc (abnf::tree-fix abnf::cst))
         (cst-identifier-conc abnf::cst)))

Theorem: cst-identifier-conc-tree-equiv-congruence-on-cst

(defthm cst-identifier-conc-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-identifier-conc abnf::cst)
                  (cst-identifier-conc cst-equiv)))
  :rule-classes :congruence)

Function: cst-program-id-conc

(defun cst-program-id-conc (abnf::cst)
  (declare (xargs :guard (abnf::treep abnf::cst)))
  (declare (xargs :guard (cst-matchp abnf::cst "program-id")))
  (let ((__function__ 'cst-program-id-conc))
    (declare (ignorable __function__))
    (abnf::tree-nonleaf->branches abnf::cst)))

Theorem: tree-list-listp-of-cst-program-id-conc

(defthm tree-list-listp-of-cst-program-id-conc
  (b* ((abnf::cstss (cst-program-id-conc abnf::cst)))
    (abnf::tree-list-listp abnf::cstss))
  :rule-classes :rewrite)

Theorem: cst-program-id-conc-match

(defthm cst-program-id-conc-match
  (implies
       (cst-matchp abnf::cst "program-id")
       (b* ((abnf::cstss (cst-program-id-conc abnf::cst)))
         (cst-list-list-conc-matchp abnf::cstss
                                    "identifier \".\" identifier")))
  :rule-classes :rewrite)

Theorem: cst-program-id-conc-of-tree-fix-cst

(defthm cst-program-id-conc-of-tree-fix-cst
  (equal (cst-program-id-conc (abnf::tree-fix abnf::cst))
         (cst-program-id-conc abnf::cst)))

Theorem: cst-program-id-conc-tree-equiv-congruence-on-cst

(defthm cst-program-id-conc-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-program-id-conc abnf::cst)
                  (cst-program-id-conc cst-equiv)))
  :rule-classes :congruence)

Function: cst-locator-conc

(defun cst-locator-conc (abnf::cst)
  (declare (xargs :guard (abnf::treep abnf::cst)))
  (declare (xargs :guard (cst-matchp abnf::cst "locator")))
  (let ((__function__ 'cst-locator-conc))
    (declare (ignorable __function__))
    (abnf::tree-nonleaf->branches abnf::cst)))

Theorem: tree-list-listp-of-cst-locator-conc

(defthm tree-list-listp-of-cst-locator-conc
  (b* ((abnf::cstss (cst-locator-conc abnf::cst)))
    (abnf::tree-list-listp abnf::cstss))
  :rule-classes :rewrite)

Theorem: cst-locator-conc-match

(defthm cst-locator-conc-match
  (implies
       (cst-matchp abnf::cst "locator")
       (b* ((abnf::cstss (cst-locator-conc abnf::cst)))
         (cst-list-list-conc-matchp abnf::cstss
                                    "program-id \"/\" identifier")))
  :rule-classes :rewrite)

Theorem: cst-locator-conc-of-tree-fix-cst

(defthm cst-locator-conc-of-tree-fix-cst
  (equal (cst-locator-conc (abnf::tree-fix abnf::cst))
         (cst-locator-conc abnf::cst)))

Theorem: cst-locator-conc-tree-equiv-congruence-on-cst

(defthm cst-locator-conc-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-locator-conc abnf::cst)
                  (cst-locator-conc cst-equiv)))
  :rule-classes :congruence)

Function: cst-register-conc

(defun cst-register-conc (abnf::cst)
  (declare (xargs :guard (abnf::treep abnf::cst)))
  (declare (xargs :guard (cst-matchp abnf::cst "register")))
  (let ((__function__ 'cst-register-conc))
    (declare (ignorable __function__))
    (abnf::tree-nonleaf->branches abnf::cst)))

Theorem: tree-list-listp-of-cst-register-conc

(defthm tree-list-listp-of-cst-register-conc
  (b* ((abnf::cstss (cst-register-conc abnf::cst)))
    (abnf::tree-list-listp abnf::cstss))
  :rule-classes :rewrite)

Theorem: cst-register-conc-match

(defthm cst-register-conc-match
  (implies
       (cst-matchp abnf::cst "register")
       (b* ((abnf::cstss (cst-register-conc abnf::cst)))
         (cst-list-list-conc-matchp abnf::cstss "%s\"r\" 1*digit")))
  :rule-classes :rewrite)

Theorem: cst-register-conc-of-tree-fix-cst

(defthm cst-register-conc-of-tree-fix-cst
  (equal (cst-register-conc (abnf::tree-fix abnf::cst))
         (cst-register-conc abnf::cst)))

Theorem: cst-register-conc-tree-equiv-congruence-on-cst

(defthm cst-register-conc-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-register-conc abnf::cst)
                  (cst-register-conc cst-equiv)))
  :rule-classes :congruence)

Function: cst-register-access-conc

(defun cst-register-access-conc (abnf::cst)
  (declare (xargs :guard (abnf::treep abnf::cst)))
  (declare (xargs :guard (cst-matchp abnf::cst "register-access")))
  (let ((__function__ 'cst-register-access-conc))
    (declare (ignorable __function__))
    (abnf::tree-nonleaf->branches abnf::cst)))

Theorem: tree-list-listp-of-cst-register-access-conc

(defthm tree-list-listp-of-cst-register-access-conc
  (b* ((abnf::cstss (cst-register-access-conc abnf::cst)))
    (abnf::tree-list-listp abnf::cstss))
  :rule-classes :rewrite)

Theorem: cst-register-access-conc-match

(defthm cst-register-access-conc-match
 (implies
      (cst-matchp abnf::cst "register-access")
      (b* ((abnf::cstss (cst-register-access-conc abnf::cst)))
        (cst-list-list-conc-matchp abnf::cstss
                                   "register *( \".\" identifier )")))
 :rule-classes :rewrite)

Theorem: cst-register-access-conc-of-tree-fix-cst

(defthm cst-register-access-conc-of-tree-fix-cst
  (equal (cst-register-access-conc (abnf::tree-fix abnf::cst))
         (cst-register-access-conc abnf::cst)))

Theorem: cst-register-access-conc-tree-equiv-congruence-on-cst

(defthm cst-register-access-conc-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-register-access-conc abnf::cst)
                  (cst-register-access-conc cst-equiv)))
  :rule-classes :congruence)

Function: cst-signed-literal-conc

(defun cst-signed-literal-conc (abnf::cst)
  (declare (xargs :guard (abnf::treep abnf::cst)))
  (declare (xargs :guard (cst-matchp abnf::cst "signed-literal")))
  (let ((__function__ 'cst-signed-literal-conc))
    (declare (ignorable __function__))
    (abnf::tree-nonleaf->branches abnf::cst)))

Theorem: tree-list-listp-of-cst-signed-literal-conc

(defthm tree-list-listp-of-cst-signed-literal-conc
  (b* ((abnf::cstss (cst-signed-literal-conc abnf::cst)))
    (abnf::tree-list-listp abnf::cstss))
  :rule-classes :rewrite)

Theorem: cst-signed-literal-conc-match

(defthm cst-signed-literal-conc-match
  (implies (cst-matchp abnf::cst "signed-literal")
           (b* ((abnf::cstss (cst-signed-literal-conc abnf::cst)))
             (cst-list-list-conc-matchp
                  abnf::cstss
                  "[ \"-\" ] 1*( digit *\"_\" ) signed-type")))
  :rule-classes :rewrite)

Theorem: cst-signed-literal-conc-of-tree-fix-cst

(defthm cst-signed-literal-conc-of-tree-fix-cst
  (equal (cst-signed-literal-conc (abnf::tree-fix abnf::cst))
         (cst-signed-literal-conc abnf::cst)))

Theorem: cst-signed-literal-conc-tree-equiv-congruence-on-cst

(defthm cst-signed-literal-conc-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-signed-literal-conc abnf::cst)
                  (cst-signed-literal-conc cst-equiv)))
  :rule-classes :congruence)

Function: cst-unsigned-literal-conc

(defun cst-unsigned-literal-conc (abnf::cst)
  (declare (xargs :guard (abnf::treep abnf::cst)))
  (declare (xargs :guard (cst-matchp abnf::cst "unsigned-literal")))
  (let ((__function__ 'cst-unsigned-literal-conc))
    (declare (ignorable __function__))
    (abnf::tree-nonleaf->branches abnf::cst)))

Theorem: tree-list-listp-of-cst-unsigned-literal-conc

(defthm tree-list-listp-of-cst-unsigned-literal-conc
  (b* ((abnf::cstss (cst-unsigned-literal-conc abnf::cst)))
    (abnf::tree-list-listp abnf::cstss))
  :rule-classes :rewrite)

Theorem: cst-unsigned-literal-conc-match

(defthm cst-unsigned-literal-conc-match
  (implies (cst-matchp abnf::cst "unsigned-literal")
           (b* ((abnf::cstss (cst-unsigned-literal-conc abnf::cst)))
             (cst-list-list-conc-matchp
                  abnf::cstss
                  "[ \"-\" ] 1*( digit *\"_\" ) unsigned-type")))
  :rule-classes :rewrite)

Theorem: cst-unsigned-literal-conc-of-tree-fix-cst

(defthm cst-unsigned-literal-conc-of-tree-fix-cst
  (equal (cst-unsigned-literal-conc (abnf::tree-fix abnf::cst))
         (cst-unsigned-literal-conc abnf::cst)))

Theorem: cst-unsigned-literal-conc-tree-equiv-congruence-on-cst

(defthm cst-unsigned-literal-conc-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-unsigned-literal-conc abnf::cst)
                  (cst-unsigned-literal-conc cst-equiv)))
  :rule-classes :congruence)

Function: cst-integer-literal-conc1

(defun cst-integer-literal-conc1 (abnf::cst)
 (declare (xargs :guard (abnf::treep abnf::cst)))
 (declare
     (xargs :guard (and (cst-matchp abnf::cst "integer-literal")
                        (equal (cst-integer-literal-conc? abnf::cst)
                               1))))
 (let ((__function__ 'cst-integer-literal-conc1))
   (declare (ignorable __function__))
   (abnf::tree-nonleaf->branches abnf::cst)))

Theorem: tree-list-listp-of-cst-integer-literal-conc1

(defthm tree-list-listp-of-cst-integer-literal-conc1
  (b* ((abnf::cstss (cst-integer-literal-conc1 abnf::cst)))
    (abnf::tree-list-listp abnf::cstss))
  :rule-classes :rewrite)

Theorem: cst-integer-literal-conc1-match

(defthm cst-integer-literal-conc1-match
  (implies
       (and (cst-matchp abnf::cst "integer-literal")
            (equal (cst-integer-literal-conc? abnf::cst)
                   1))
       (b* ((abnf::cstss (cst-integer-literal-conc1 abnf::cst)))
         (cst-list-list-conc-matchp abnf::cstss "signed-literal")))
  :rule-classes :rewrite)

Theorem: cst-integer-literal-conc1-of-tree-fix-cst

(defthm cst-integer-literal-conc1-of-tree-fix-cst
  (equal (cst-integer-literal-conc1 (abnf::tree-fix abnf::cst))
         (cst-integer-literal-conc1 abnf::cst)))

Theorem: cst-integer-literal-conc1-tree-equiv-congruence-on-cst

(defthm cst-integer-literal-conc1-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-integer-literal-conc1 abnf::cst)
                  (cst-integer-literal-conc1 cst-equiv)))
  :rule-classes :congruence)

Function: cst-integer-literal-conc2

(defun cst-integer-literal-conc2 (abnf::cst)
 (declare (xargs :guard (abnf::treep abnf::cst)))
 (declare
     (xargs :guard (and (cst-matchp abnf::cst "integer-literal")
                        (equal (cst-integer-literal-conc? abnf::cst)
                               2))))
 (let ((__function__ 'cst-integer-literal-conc2))
   (declare (ignorable __function__))
   (abnf::tree-nonleaf->branches abnf::cst)))

Theorem: tree-list-listp-of-cst-integer-literal-conc2

(defthm tree-list-listp-of-cst-integer-literal-conc2
  (b* ((abnf::cstss (cst-integer-literal-conc2 abnf::cst)))
    (abnf::tree-list-listp abnf::cstss))
  :rule-classes :rewrite)

Theorem: cst-integer-literal-conc2-match

(defthm cst-integer-literal-conc2-match
 (implies
      (and (cst-matchp abnf::cst "integer-literal")
           (equal (cst-integer-literal-conc? abnf::cst)
                  2))
      (b* ((abnf::cstss (cst-integer-literal-conc2 abnf::cst)))
        (cst-list-list-conc-matchp abnf::cstss "unsigned-literal")))
 :rule-classes :rewrite)

Theorem: cst-integer-literal-conc2-of-tree-fix-cst

(defthm cst-integer-literal-conc2-of-tree-fix-cst
  (equal (cst-integer-literal-conc2 (abnf::tree-fix abnf::cst))
         (cst-integer-literal-conc2 abnf::cst)))

Theorem: cst-integer-literal-conc2-tree-equiv-congruence-on-cst

(defthm cst-integer-literal-conc2-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-integer-literal-conc2 abnf::cst)
                  (cst-integer-literal-conc2 cst-equiv)))
  :rule-classes :congruence)

Function: cst-field-literal-conc

(defun cst-field-literal-conc (abnf::cst)
  (declare (xargs :guard (abnf::treep abnf::cst)))
  (declare (xargs :guard (cst-matchp abnf::cst "field-literal")))
  (let ((__function__ 'cst-field-literal-conc))
    (declare (ignorable __function__))
    (abnf::tree-nonleaf->branches abnf::cst)))

Theorem: tree-list-listp-of-cst-field-literal-conc

(defthm tree-list-listp-of-cst-field-literal-conc
  (b* ((abnf::cstss (cst-field-literal-conc abnf::cst)))
    (abnf::tree-list-listp abnf::cstss))
  :rule-classes :rewrite)

Theorem: cst-field-literal-conc-match

(defthm cst-field-literal-conc-match
  (implies (cst-matchp abnf::cst "field-literal")
           (b* ((abnf::cstss (cst-field-literal-conc abnf::cst)))
             (cst-list-list-conc-matchp
                  abnf::cstss
                  "[ \"-\" ] 1*( digit *\"_\" ) field-type")))
  :rule-classes :rewrite)

Theorem: cst-field-literal-conc-of-tree-fix-cst

(defthm cst-field-literal-conc-of-tree-fix-cst
  (equal (cst-field-literal-conc (abnf::tree-fix abnf::cst))
         (cst-field-literal-conc abnf::cst)))

Theorem: cst-field-literal-conc-tree-equiv-congruence-on-cst

(defthm cst-field-literal-conc-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-field-literal-conc abnf::cst)
                  (cst-field-literal-conc cst-equiv)))
  :rule-classes :congruence)

Function: cst-group-literal-conc

(defun cst-group-literal-conc (abnf::cst)
  (declare (xargs :guard (abnf::treep abnf::cst)))
  (declare (xargs :guard (cst-matchp abnf::cst "group-literal")))
  (let ((__function__ 'cst-group-literal-conc))
    (declare (ignorable __function__))
    (abnf::tree-nonleaf->branches abnf::cst)))

Theorem: tree-list-listp-of-cst-group-literal-conc

(defthm tree-list-listp-of-cst-group-literal-conc
  (b* ((abnf::cstss (cst-group-literal-conc abnf::cst)))
    (abnf::tree-list-listp abnf::cstss))
  :rule-classes :rewrite)

Theorem: cst-group-literal-conc-match

(defthm cst-group-literal-conc-match
  (implies (cst-matchp abnf::cst "group-literal")
           (b* ((abnf::cstss (cst-group-literal-conc abnf::cst)))
             (cst-list-list-conc-matchp
                  abnf::cstss
                  "[ \"-\" ] 1*( digit *\"_\" ) group-type")))
  :rule-classes :rewrite)

Theorem: cst-group-literal-conc-of-tree-fix-cst

(defthm cst-group-literal-conc-of-tree-fix-cst
  (equal (cst-group-literal-conc (abnf::tree-fix abnf::cst))
         (cst-group-literal-conc abnf::cst)))

Theorem: cst-group-literal-conc-tree-equiv-congruence-on-cst

(defthm cst-group-literal-conc-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-group-literal-conc abnf::cst)
                  (cst-group-literal-conc cst-equiv)))
  :rule-classes :congruence)

Function: cst-scalar-literal-conc

(defun cst-scalar-literal-conc (abnf::cst)
  (declare (xargs :guard (abnf::treep abnf::cst)))
  (declare (xargs :guard (cst-matchp abnf::cst "scalar-literal")))
  (let ((__function__ 'cst-scalar-literal-conc))
    (declare (ignorable __function__))
    (abnf::tree-nonleaf->branches abnf::cst)))

Theorem: tree-list-listp-of-cst-scalar-literal-conc

(defthm tree-list-listp-of-cst-scalar-literal-conc
  (b* ((abnf::cstss (cst-scalar-literal-conc abnf::cst)))
    (abnf::tree-list-listp abnf::cstss))
  :rule-classes :rewrite)

Theorem: cst-scalar-literal-conc-match

(defthm cst-scalar-literal-conc-match
  (implies (cst-matchp abnf::cst "scalar-literal")
           (b* ((abnf::cstss (cst-scalar-literal-conc abnf::cst)))
             (cst-list-list-conc-matchp
                  abnf::cstss
                  "[ \"-\" ] 1*( digit *\"_\" ) scalar-type")))
  :rule-classes :rewrite)

Theorem: cst-scalar-literal-conc-of-tree-fix-cst

(defthm cst-scalar-literal-conc-of-tree-fix-cst
  (equal (cst-scalar-literal-conc (abnf::tree-fix abnf::cst))
         (cst-scalar-literal-conc abnf::cst)))

Theorem: cst-scalar-literal-conc-tree-equiv-congruence-on-cst

(defthm cst-scalar-literal-conc-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-scalar-literal-conc abnf::cst)
                  (cst-scalar-literal-conc cst-equiv)))
  :rule-classes :congruence)

Function: cst-arithmetic-literal-conc1

(defun cst-arithmetic-literal-conc1 (abnf::cst)
 (declare (xargs :guard (abnf::treep abnf::cst)))
 (declare
  (xargs :guard (and (cst-matchp abnf::cst "arithmetic-literal")
                     (equal (cst-arithmetic-literal-conc? abnf::cst)
                            1))))
 (let ((__function__ 'cst-arithmetic-literal-conc1))
   (declare (ignorable __function__))
   (abnf::tree-nonleaf->branches abnf::cst)))

Theorem: tree-list-listp-of-cst-arithmetic-literal-conc1

(defthm tree-list-listp-of-cst-arithmetic-literal-conc1
  (b* ((abnf::cstss (cst-arithmetic-literal-conc1 abnf::cst)))
    (abnf::tree-list-listp abnf::cstss))
  :rule-classes :rewrite)

Theorem: cst-arithmetic-literal-conc1-match

(defthm cst-arithmetic-literal-conc1-match
  (implies
       (and (cst-matchp abnf::cst "arithmetic-literal")
            (equal (cst-arithmetic-literal-conc? abnf::cst)
                   1))
       (b* ((abnf::cstss (cst-arithmetic-literal-conc1 abnf::cst)))
         (cst-list-list-conc-matchp abnf::cstss "integer-literal")))
  :rule-classes :rewrite)

Theorem: cst-arithmetic-literal-conc1-of-tree-fix-cst

(defthm cst-arithmetic-literal-conc1-of-tree-fix-cst
  (equal (cst-arithmetic-literal-conc1 (abnf::tree-fix abnf::cst))
         (cst-arithmetic-literal-conc1 abnf::cst)))

Theorem: cst-arithmetic-literal-conc1-tree-equiv-congruence-on-cst

(defthm cst-arithmetic-literal-conc1-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-arithmetic-literal-conc1 abnf::cst)
                  (cst-arithmetic-literal-conc1 cst-equiv)))
  :rule-classes :congruence)

Function: cst-arithmetic-literal-conc2

(defun cst-arithmetic-literal-conc2 (abnf::cst)
 (declare (xargs :guard (abnf::treep abnf::cst)))
 (declare
  (xargs :guard (and (cst-matchp abnf::cst "arithmetic-literal")
                     (equal (cst-arithmetic-literal-conc? abnf::cst)
                            2))))
 (let ((__function__ 'cst-arithmetic-literal-conc2))
   (declare (ignorable __function__))
   (abnf::tree-nonleaf->branches abnf::cst)))

Theorem: tree-list-listp-of-cst-arithmetic-literal-conc2

(defthm tree-list-listp-of-cst-arithmetic-literal-conc2
  (b* ((abnf::cstss (cst-arithmetic-literal-conc2 abnf::cst)))
    (abnf::tree-list-listp abnf::cstss))
  :rule-classes :rewrite)

Theorem: cst-arithmetic-literal-conc2-match

(defthm cst-arithmetic-literal-conc2-match
  (implies
       (and (cst-matchp abnf::cst "arithmetic-literal")
            (equal (cst-arithmetic-literal-conc? abnf::cst)
                   2))
       (b* ((abnf::cstss (cst-arithmetic-literal-conc2 abnf::cst)))
         (cst-list-list-conc-matchp abnf::cstss "field-literal")))
  :rule-classes :rewrite)

Theorem: cst-arithmetic-literal-conc2-of-tree-fix-cst

(defthm cst-arithmetic-literal-conc2-of-tree-fix-cst
  (equal (cst-arithmetic-literal-conc2 (abnf::tree-fix abnf::cst))
         (cst-arithmetic-literal-conc2 abnf::cst)))

Theorem: cst-arithmetic-literal-conc2-tree-equiv-congruence-on-cst

(defthm cst-arithmetic-literal-conc2-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-arithmetic-literal-conc2 abnf::cst)
                  (cst-arithmetic-literal-conc2 cst-equiv)))
  :rule-classes :congruence)

Function: cst-arithmetic-literal-conc3

(defun cst-arithmetic-literal-conc3 (abnf::cst)
 (declare (xargs :guard (abnf::treep abnf::cst)))
 (declare
  (xargs :guard (and (cst-matchp abnf::cst "arithmetic-literal")
                     (equal (cst-arithmetic-literal-conc? abnf::cst)
                            3))))
 (let ((__function__ 'cst-arithmetic-literal-conc3))
   (declare (ignorable __function__))
   (abnf::tree-nonleaf->branches abnf::cst)))

Theorem: tree-list-listp-of-cst-arithmetic-literal-conc3

(defthm tree-list-listp-of-cst-arithmetic-literal-conc3
  (b* ((abnf::cstss (cst-arithmetic-literal-conc3 abnf::cst)))
    (abnf::tree-list-listp abnf::cstss))
  :rule-classes :rewrite)

Theorem: cst-arithmetic-literal-conc3-match

(defthm cst-arithmetic-literal-conc3-match
  (implies
       (and (cst-matchp abnf::cst "arithmetic-literal")
            (equal (cst-arithmetic-literal-conc? abnf::cst)
                   3))
       (b* ((abnf::cstss (cst-arithmetic-literal-conc3 abnf::cst)))
         (cst-list-list-conc-matchp abnf::cstss "group-literal")))
  :rule-classes :rewrite)

Theorem: cst-arithmetic-literal-conc3-of-tree-fix-cst

(defthm cst-arithmetic-literal-conc3-of-tree-fix-cst
  (equal (cst-arithmetic-literal-conc3 (abnf::tree-fix abnf::cst))
         (cst-arithmetic-literal-conc3 abnf::cst)))

Theorem: cst-arithmetic-literal-conc3-tree-equiv-congruence-on-cst

(defthm cst-arithmetic-literal-conc3-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-arithmetic-literal-conc3 abnf::cst)
                  (cst-arithmetic-literal-conc3 cst-equiv)))
  :rule-classes :congruence)

Function: cst-arithmetic-literal-conc4

(defun cst-arithmetic-literal-conc4 (abnf::cst)
 (declare (xargs :guard (abnf::treep abnf::cst)))
 (declare
  (xargs :guard (and (cst-matchp abnf::cst "arithmetic-literal")
                     (equal (cst-arithmetic-literal-conc? abnf::cst)
                            4))))
 (let ((__function__ 'cst-arithmetic-literal-conc4))
   (declare (ignorable __function__))
   (abnf::tree-nonleaf->branches abnf::cst)))

Theorem: tree-list-listp-of-cst-arithmetic-literal-conc4

(defthm tree-list-listp-of-cst-arithmetic-literal-conc4
  (b* ((abnf::cstss (cst-arithmetic-literal-conc4 abnf::cst)))
    (abnf::tree-list-listp abnf::cstss))
  :rule-classes :rewrite)

Theorem: cst-arithmetic-literal-conc4-match

(defthm cst-arithmetic-literal-conc4-match
  (implies
       (and (cst-matchp abnf::cst "arithmetic-literal")
            (equal (cst-arithmetic-literal-conc? abnf::cst)
                   4))
       (b* ((abnf::cstss (cst-arithmetic-literal-conc4 abnf::cst)))
         (cst-list-list-conc-matchp abnf::cstss "scalar-literal")))
  :rule-classes :rewrite)

Theorem: cst-arithmetic-literal-conc4-of-tree-fix-cst

(defthm cst-arithmetic-literal-conc4-of-tree-fix-cst
  (equal (cst-arithmetic-literal-conc4 (abnf::tree-fix abnf::cst))
         (cst-arithmetic-literal-conc4 abnf::cst)))

Theorem: cst-arithmetic-literal-conc4-tree-equiv-congruence-on-cst

(defthm cst-arithmetic-literal-conc4-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-arithmetic-literal-conc4 abnf::cst)
                  (cst-arithmetic-literal-conc4 cst-equiv)))
  :rule-classes :congruence)

Function: cst-address-literal-conc

(defun cst-address-literal-conc (abnf::cst)
  (declare (xargs :guard (abnf::treep abnf::cst)))
  (declare (xargs :guard (cst-matchp abnf::cst "address-literal")))
  (let ((__function__ 'cst-address-literal-conc))
    (declare (ignorable __function__))
    (abnf::tree-nonleaf->branches abnf::cst)))

Theorem: tree-list-listp-of-cst-address-literal-conc

(defthm tree-list-listp-of-cst-address-literal-conc
  (b* ((abnf::cstss (cst-address-literal-conc abnf::cst)))
    (abnf::tree-list-listp abnf::cstss))
  :rule-classes :rewrite)

Theorem: cst-address-literal-conc-match

(defthm cst-address-literal-conc-match
 (implies
  (cst-matchp abnf::cst "address-literal")
  (b* ((abnf::cstss (cst-address-literal-conc abnf::cst)))
   (cst-list-list-conc-matchp abnf::cstss
                              "%s\"aleo1\" 1*( address-char *\"_\" )")))
 :rule-classes :rewrite)

Theorem: cst-address-literal-conc-of-tree-fix-cst

(defthm cst-address-literal-conc-of-tree-fix-cst
  (equal (cst-address-literal-conc (abnf::tree-fix abnf::cst))
         (cst-address-literal-conc abnf::cst)))

Theorem: cst-address-literal-conc-tree-equiv-congruence-on-cst

(defthm cst-address-literal-conc-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-address-literal-conc abnf::cst)
                  (cst-address-literal-conc cst-equiv)))
  :rule-classes :congruence)

Function: cst-string-literal-conc

(defun cst-string-literal-conc (abnf::cst)
  (declare (xargs :guard (abnf::treep abnf::cst)))
  (declare (xargs :guard (cst-matchp abnf::cst "string-literal")))
  (let ((__function__ 'cst-string-literal-conc))
    (declare (ignorable __function__))
    (abnf::tree-nonleaf->branches abnf::cst)))

Theorem: tree-list-listp-of-cst-string-literal-conc

(defthm tree-list-listp-of-cst-string-literal-conc
  (b* ((abnf::cstss (cst-string-literal-conc abnf::cst)))
    (abnf::tree-list-listp abnf::cstss))
  :rule-classes :rewrite)

Theorem: cst-string-literal-conc-match

(defthm cst-string-literal-conc-match
 (implies
  (cst-matchp abnf::cst "string-literal")
  (b* ((abnf::cstss (cst-string-literal-conc abnf::cst)))
   (cst-list-list-conc-matchp abnf::cstss "dq *string-element dq")))
 :rule-classes :rewrite)

Theorem: cst-string-literal-conc-of-tree-fix-cst

(defthm cst-string-literal-conc-of-tree-fix-cst
  (equal (cst-string-literal-conc (abnf::tree-fix abnf::cst))
         (cst-string-literal-conc abnf::cst)))

Theorem: cst-string-literal-conc-tree-equiv-congruence-on-cst

(defthm cst-string-literal-conc-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-string-literal-conc abnf::cst)
                  (cst-string-literal-conc cst-equiv)))
  :rule-classes :congruence)

Function: cst-string-element-conc1

(defun cst-string-element-conc1 (abnf::cst)
 (declare (xargs :guard (abnf::treep abnf::cst)))
 (declare
      (xargs :guard (and (cst-matchp abnf::cst "string-element")
                         (equal (cst-string-element-conc? abnf::cst)
                                1))))
 (let ((__function__ 'cst-string-element-conc1))
   (declare (ignorable __function__))
   (abnf::tree-nonleaf->branches abnf::cst)))

Theorem: tree-list-listp-of-cst-string-element-conc1

(defthm tree-list-listp-of-cst-string-element-conc1
  (b* ((abnf::cstss (cst-string-element-conc1 abnf::cst)))
    (abnf::tree-list-listp abnf::cstss))
  :rule-classes :rewrite)

Theorem: cst-string-element-conc1-match

(defthm cst-string-element-conc1-match
 (implies
   (and (cst-matchp abnf::cst "string-element")
        (equal (cst-string-element-conc? abnf::cst)
               1))
   (b* ((abnf::cstss (cst-string-element-conc1 abnf::cst)))
     (cst-list-list-conc-matchp abnf::cstss "not-dq-or-backslash")))
 :rule-classes :rewrite)

Theorem: cst-string-element-conc1-of-tree-fix-cst

(defthm cst-string-element-conc1-of-tree-fix-cst
  (equal (cst-string-element-conc1 (abnf::tree-fix abnf::cst))
         (cst-string-element-conc1 abnf::cst)))

Theorem: cst-string-element-conc1-tree-equiv-congruence-on-cst

(defthm cst-string-element-conc1-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-string-element-conc1 abnf::cst)
                  (cst-string-element-conc1 cst-equiv)))
  :rule-classes :congruence)

Function: cst-string-element-conc2

(defun cst-string-element-conc2 (abnf::cst)
 (declare (xargs :guard (abnf::treep abnf::cst)))
 (declare
      (xargs :guard (and (cst-matchp abnf::cst "string-element")
                         (equal (cst-string-element-conc? abnf::cst)
                                2))))
 (let ((__function__ 'cst-string-element-conc2))
   (declare (ignorable __function__))
   (abnf::tree-nonleaf->branches abnf::cst)))

Theorem: tree-list-listp-of-cst-string-element-conc2

(defthm tree-list-listp-of-cst-string-element-conc2
  (b* ((abnf::cstss (cst-string-element-conc2 abnf::cst)))
    (abnf::tree-list-listp abnf::cstss))
  :rule-classes :rewrite)

Theorem: cst-string-element-conc2-match

(defthm cst-string-element-conc2-match
 (implies (and (cst-matchp abnf::cst "string-element")
               (equal (cst-string-element-conc? abnf::cst)
                      2))
          (b* ((abnf::cstss (cst-string-element-conc2 abnf::cst)))
            (cst-list-list-conc-matchp abnf::cstss "escaped-char")))
 :rule-classes :rewrite)

Theorem: cst-string-element-conc2-of-tree-fix-cst

(defthm cst-string-element-conc2-of-tree-fix-cst
  (equal (cst-string-element-conc2 (abnf::tree-fix abnf::cst))
         (cst-string-element-conc2 abnf::cst)))

Theorem: cst-string-element-conc2-tree-equiv-congruence-on-cst

(defthm cst-string-element-conc2-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-string-element-conc2 abnf::cst)
                  (cst-string-element-conc2 cst-equiv)))
  :rule-classes :congruence)

Function: cst-string-element-conc3

(defun cst-string-element-conc3 (abnf::cst)
 (declare (xargs :guard (abnf::treep abnf::cst)))
 (declare
      (xargs :guard (and (cst-matchp abnf::cst "string-element")
                         (equal (cst-string-element-conc? abnf::cst)
                                3))))
 (let ((__function__ 'cst-string-element-conc3))
   (declare (ignorable __function__))
   (abnf::tree-nonleaf->branches abnf::cst)))

Theorem: tree-list-listp-of-cst-string-element-conc3

(defthm tree-list-listp-of-cst-string-element-conc3
  (b* ((abnf::cstss (cst-string-element-conc3 abnf::cst)))
    (abnf::tree-list-listp abnf::cstss))
  :rule-classes :rewrite)

Theorem: cst-string-element-conc3-match

(defthm cst-string-element-conc3-match
  (implies (and (cst-matchp abnf::cst "string-element")
                (equal (cst-string-element-conc? abnf::cst)
                       3))
           (b* ((abnf::cstss (cst-string-element-conc3 abnf::cst)))
             (cst-list-list-conc-matchp abnf::cstss "escaped-ws")))
  :rule-classes :rewrite)

Theorem: cst-string-element-conc3-of-tree-fix-cst

(defthm cst-string-element-conc3-of-tree-fix-cst
  (equal (cst-string-element-conc3 (abnf::tree-fix abnf::cst))
         (cst-string-element-conc3 abnf::cst)))

Theorem: cst-string-element-conc3-tree-equiv-congruence-on-cst

(defthm cst-string-element-conc3-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-string-element-conc3 abnf::cst)
                  (cst-string-element-conc3 cst-equiv)))
  :rule-classes :congruence)

Function: cst-escaped-char-conc

(defun cst-escaped-char-conc (abnf::cst)
  (declare (xargs :guard (abnf::treep abnf::cst)))
  (declare (xargs :guard (cst-matchp abnf::cst "escaped-char")))
  (let ((__function__ 'cst-escaped-char-conc))
    (declare (ignorable __function__))
    (abnf::tree-nonleaf->branches abnf::cst)))

Theorem: tree-list-listp-of-cst-escaped-char-conc

(defthm tree-list-listp-of-cst-escaped-char-conc
  (b* ((abnf::cstss (cst-escaped-char-conc abnf::cst)))
    (abnf::tree-list-listp abnf::cstss))
  :rule-classes :rewrite)

Theorem: cst-escaped-char-conc-match

(defthm cst-escaped-char-conc-match
 (implies
  (cst-matchp abnf::cst "escaped-char")
  (b* ((abnf::cstss (cst-escaped-char-conc abnf::cst)))
   (cst-list-list-conc-matchp
    abnf::cstss
    "\"\\\" ( dq / \"\\\" / \"/\" / %s\"n\" / %s\"r\" / %s\"t\" / %s\"b\" / %s\"f\" / %s\"u\" \"{\" 1*6hex-digit \"}\" )")))
 :rule-classes :rewrite)

Theorem: cst-escaped-char-conc-of-tree-fix-cst

(defthm cst-escaped-char-conc-of-tree-fix-cst
  (equal (cst-escaped-char-conc (abnf::tree-fix abnf::cst))
         (cst-escaped-char-conc abnf::cst)))

Theorem: cst-escaped-char-conc-tree-equiv-congruence-on-cst

(defthm cst-escaped-char-conc-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-escaped-char-conc abnf::cst)
                  (cst-escaped-char-conc cst-equiv)))
  :rule-classes :congruence)

Function: cst-escaped-ws-conc

(defun cst-escaped-ws-conc (abnf::cst)
  (declare (xargs :guard (abnf::treep abnf::cst)))
  (declare (xargs :guard (cst-matchp abnf::cst "escaped-ws")))
  (let ((__function__ 'cst-escaped-ws-conc))
    (declare (ignorable __function__))
    (abnf::tree-nonleaf->branches abnf::cst)))

Theorem: tree-list-listp-of-cst-escaped-ws-conc

(defthm tree-list-listp-of-cst-escaped-ws-conc
  (b* ((abnf::cstss (cst-escaped-ws-conc abnf::cst)))
    (abnf::tree-list-listp abnf::cstss))
  :rule-classes :rewrite)

Theorem: cst-escaped-ws-conc-match

(defthm cst-escaped-ws-conc-match
  (implies
       (cst-matchp abnf::cst "escaped-ws")
       (b* ((abnf::cstss (cst-escaped-ws-conc abnf::cst)))
         (cst-list-list-conc-matchp abnf::cstss "\"\\\" 1*plain-ws")))
  :rule-classes :rewrite)

Theorem: cst-escaped-ws-conc-of-tree-fix-cst

(defthm cst-escaped-ws-conc-of-tree-fix-cst
  (equal (cst-escaped-ws-conc (abnf::tree-fix abnf::cst))
         (cst-escaped-ws-conc abnf::cst)))

Theorem: cst-escaped-ws-conc-tree-equiv-congruence-on-cst

(defthm cst-escaped-ws-conc-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-escaped-ws-conc abnf::cst)
                  (cst-escaped-ws-conc cst-equiv)))
  :rule-classes :congruence)

Function: cst-literal-conc1

(defun cst-literal-conc1 (abnf::cst)
  (declare (xargs :guard (abnf::treep abnf::cst)))
  (declare (xargs :guard (and (cst-matchp abnf::cst "literal")
                              (equal (cst-literal-conc? abnf::cst)
                                     1))))
  (let ((__function__ 'cst-literal-conc1))
    (declare (ignorable __function__))
    (abnf::tree-nonleaf->branches abnf::cst)))

Theorem: tree-list-listp-of-cst-literal-conc1

(defthm tree-list-listp-of-cst-literal-conc1
  (b* ((abnf::cstss (cst-literal-conc1 abnf::cst)))
    (abnf::tree-list-listp abnf::cstss))
  :rule-classes :rewrite)

Theorem: cst-literal-conc1-match

(defthm cst-literal-conc1-match
 (implies
    (and (cst-matchp abnf::cst "literal")
         (equal (cst-literal-conc? abnf::cst) 1))
    (b* ((abnf::cstss (cst-literal-conc1 abnf::cst)))
      (cst-list-list-conc-matchp abnf::cstss "arithmetic-literal")))
 :rule-classes :rewrite)

Theorem: cst-literal-conc1-of-tree-fix-cst

(defthm cst-literal-conc1-of-tree-fix-cst
  (equal (cst-literal-conc1 (abnf::tree-fix abnf::cst))
         (cst-literal-conc1 abnf::cst)))

Theorem: cst-literal-conc1-tree-equiv-congruence-on-cst

(defthm cst-literal-conc1-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-literal-conc1 abnf::cst)
                  (cst-literal-conc1 cst-equiv)))
  :rule-classes :congruence)

Function: cst-literal-conc2

(defun cst-literal-conc2 (abnf::cst)
  (declare (xargs :guard (abnf::treep abnf::cst)))
  (declare (xargs :guard (and (cst-matchp abnf::cst "literal")
                              (equal (cst-literal-conc? abnf::cst)
                                     2))))
  (let ((__function__ 'cst-literal-conc2))
    (declare (ignorable __function__))
    (abnf::tree-nonleaf->branches abnf::cst)))

Theorem: tree-list-listp-of-cst-literal-conc2

(defthm tree-list-listp-of-cst-literal-conc2
  (b* ((abnf::cstss (cst-literal-conc2 abnf::cst)))
    (abnf::tree-list-listp abnf::cstss))
  :rule-classes :rewrite)

Theorem: cst-literal-conc2-match

(defthm cst-literal-conc2-match
  (implies
       (and (cst-matchp abnf::cst "literal")
            (equal (cst-literal-conc? abnf::cst) 2))
       (b* ((abnf::cstss (cst-literal-conc2 abnf::cst)))
         (cst-list-list-conc-matchp abnf::cstss "address-literal")))
  :rule-classes :rewrite)

Theorem: cst-literal-conc2-of-tree-fix-cst

(defthm cst-literal-conc2-of-tree-fix-cst
  (equal (cst-literal-conc2 (abnf::tree-fix abnf::cst))
         (cst-literal-conc2 abnf::cst)))

Theorem: cst-literal-conc2-tree-equiv-congruence-on-cst

(defthm cst-literal-conc2-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-literal-conc2 abnf::cst)
                  (cst-literal-conc2 cst-equiv)))
  :rule-classes :congruence)

Function: cst-literal-conc3

(defun cst-literal-conc3 (abnf::cst)
  (declare (xargs :guard (abnf::treep abnf::cst)))
  (declare (xargs :guard (and (cst-matchp abnf::cst "literal")
                              (equal (cst-literal-conc? abnf::cst)
                                     3))))
  (let ((__function__ 'cst-literal-conc3))
    (declare (ignorable __function__))
    (abnf::tree-nonleaf->branches abnf::cst)))

Theorem: tree-list-listp-of-cst-literal-conc3

(defthm tree-list-listp-of-cst-literal-conc3
  (b* ((abnf::cstss (cst-literal-conc3 abnf::cst)))
    (abnf::tree-list-listp abnf::cstss))
  :rule-classes :rewrite)

Theorem: cst-literal-conc3-match

(defthm cst-literal-conc3-match
  (implies
       (and (cst-matchp abnf::cst "literal")
            (equal (cst-literal-conc? abnf::cst) 3))
       (b* ((abnf::cstss (cst-literal-conc3 abnf::cst)))
         (cst-list-list-conc-matchp abnf::cstss "boolean-literal")))
  :rule-classes :rewrite)

Theorem: cst-literal-conc3-of-tree-fix-cst

(defthm cst-literal-conc3-of-tree-fix-cst
  (equal (cst-literal-conc3 (abnf::tree-fix abnf::cst))
         (cst-literal-conc3 abnf::cst)))

Theorem: cst-literal-conc3-tree-equiv-congruence-on-cst

(defthm cst-literal-conc3-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-literal-conc3 abnf::cst)
                  (cst-literal-conc3 cst-equiv)))
  :rule-classes :congruence)

Function: cst-literal-conc4

(defun cst-literal-conc4 (abnf::cst)
  (declare (xargs :guard (abnf::treep abnf::cst)))
  (declare (xargs :guard (and (cst-matchp abnf::cst "literal")
                              (equal (cst-literal-conc? abnf::cst)
                                     4))))
  (let ((__function__ 'cst-literal-conc4))
    (declare (ignorable __function__))
    (abnf::tree-nonleaf->branches abnf::cst)))

Theorem: tree-list-listp-of-cst-literal-conc4

(defthm tree-list-listp-of-cst-literal-conc4
  (b* ((abnf::cstss (cst-literal-conc4 abnf::cst)))
    (abnf::tree-list-listp abnf::cstss))
  :rule-classes :rewrite)

Theorem: cst-literal-conc4-match

(defthm cst-literal-conc4-match
  (implies
       (and (cst-matchp abnf::cst "literal")
            (equal (cst-literal-conc? abnf::cst) 4))
       (b* ((abnf::cstss (cst-literal-conc4 abnf::cst)))
         (cst-list-list-conc-matchp abnf::cstss "string-literal")))
  :rule-classes :rewrite)

Theorem: cst-literal-conc4-of-tree-fix-cst

(defthm cst-literal-conc4-of-tree-fix-cst
  (equal (cst-literal-conc4 (abnf::tree-fix abnf::cst))
         (cst-literal-conc4 abnf::cst)))

Theorem: cst-literal-conc4-tree-equiv-congruence-on-cst

(defthm cst-literal-conc4-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-literal-conc4 abnf::cst)
                  (cst-literal-conc4 cst-equiv)))
  :rule-classes :congruence)

Function: cst-integer-type-conc1

(defun cst-integer-type-conc1 (abnf::cst)
  (declare (xargs :guard (abnf::treep abnf::cst)))
  (declare
       (xargs :guard (and (cst-matchp abnf::cst "integer-type")
                          (equal (cst-integer-type-conc? abnf::cst)
                                 1))))
  (let ((__function__ 'cst-integer-type-conc1))
    (declare (ignorable __function__))
    (abnf::tree-nonleaf->branches abnf::cst)))

Theorem: tree-list-listp-of-cst-integer-type-conc1

(defthm tree-list-listp-of-cst-integer-type-conc1
  (b* ((abnf::cstss (cst-integer-type-conc1 abnf::cst)))
    (abnf::tree-list-listp abnf::cstss))
  :rule-classes :rewrite)

Theorem: cst-integer-type-conc1-match

(defthm cst-integer-type-conc1-match
  (implies
       (and (cst-matchp abnf::cst "integer-type")
            (equal (cst-integer-type-conc? abnf::cst)
                   1))
       (b* ((abnf::cstss (cst-integer-type-conc1 abnf::cst)))
         (cst-list-list-conc-matchp abnf::cstss "unsigned-type")))
  :rule-classes :rewrite)

Theorem: cst-integer-type-conc1-of-tree-fix-cst

(defthm cst-integer-type-conc1-of-tree-fix-cst
  (equal (cst-integer-type-conc1 (abnf::tree-fix abnf::cst))
         (cst-integer-type-conc1 abnf::cst)))

Theorem: cst-integer-type-conc1-tree-equiv-congruence-on-cst

(defthm cst-integer-type-conc1-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-integer-type-conc1 abnf::cst)
                  (cst-integer-type-conc1 cst-equiv)))
  :rule-classes :congruence)

Function: cst-integer-type-conc2

(defun cst-integer-type-conc2 (abnf::cst)
  (declare (xargs :guard (abnf::treep abnf::cst)))
  (declare
       (xargs :guard (and (cst-matchp abnf::cst "integer-type")
                          (equal (cst-integer-type-conc? abnf::cst)
                                 2))))
  (let ((__function__ 'cst-integer-type-conc2))
    (declare (ignorable __function__))
    (abnf::tree-nonleaf->branches abnf::cst)))

Theorem: tree-list-listp-of-cst-integer-type-conc2

(defthm tree-list-listp-of-cst-integer-type-conc2
  (b* ((abnf::cstss (cst-integer-type-conc2 abnf::cst)))
    (abnf::tree-list-listp abnf::cstss))
  :rule-classes :rewrite)

Theorem: cst-integer-type-conc2-match

(defthm cst-integer-type-conc2-match
  (implies (and (cst-matchp abnf::cst "integer-type")
                (equal (cst-integer-type-conc? abnf::cst)
                       2))
           (b* ((abnf::cstss (cst-integer-type-conc2 abnf::cst)))
             (cst-list-list-conc-matchp abnf::cstss "signed-type")))
  :rule-classes :rewrite)

Theorem: cst-integer-type-conc2-of-tree-fix-cst

(defthm cst-integer-type-conc2-of-tree-fix-cst
  (equal (cst-integer-type-conc2 (abnf::tree-fix abnf::cst))
         (cst-integer-type-conc2 abnf::cst)))

Theorem: cst-integer-type-conc2-tree-equiv-congruence-on-cst

(defthm cst-integer-type-conc2-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-integer-type-conc2 abnf::cst)
                  (cst-integer-type-conc2 cst-equiv)))
  :rule-classes :congruence)

Function: cst-field-type-conc

(defun cst-field-type-conc (abnf::cst)
  (declare (xargs :guard (abnf::treep abnf::cst)))
  (declare (xargs :guard (cst-matchp abnf::cst "field-type")))
  (let ((__function__ 'cst-field-type-conc))
    (declare (ignorable __function__))
    (abnf::tree-nonleaf->branches abnf::cst)))

Theorem: tree-list-listp-of-cst-field-type-conc

(defthm tree-list-listp-of-cst-field-type-conc
  (b* ((abnf::cstss (cst-field-type-conc abnf::cst)))
    (abnf::tree-list-listp abnf::cstss))
  :rule-classes :rewrite)

Theorem: cst-field-type-conc-match

(defthm cst-field-type-conc-match
  (implies (cst-matchp abnf::cst "field-type")
           (b* ((abnf::cstss (cst-field-type-conc abnf::cst)))
             (cst-list-list-conc-matchp abnf::cstss "%s\"field\"")))
  :rule-classes :rewrite)

Theorem: cst-field-type-conc-of-tree-fix-cst

(defthm cst-field-type-conc-of-tree-fix-cst
  (equal (cst-field-type-conc (abnf::tree-fix abnf::cst))
         (cst-field-type-conc abnf::cst)))

Theorem: cst-field-type-conc-tree-equiv-congruence-on-cst

(defthm cst-field-type-conc-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-field-type-conc abnf::cst)
                  (cst-field-type-conc cst-equiv)))
  :rule-classes :congruence)

Function: cst-group-type-conc

(defun cst-group-type-conc (abnf::cst)
  (declare (xargs :guard (abnf::treep abnf::cst)))
  (declare (xargs :guard (cst-matchp abnf::cst "group-type")))
  (let ((__function__ 'cst-group-type-conc))
    (declare (ignorable __function__))
    (abnf::tree-nonleaf->branches abnf::cst)))

Theorem: tree-list-listp-of-cst-group-type-conc

(defthm tree-list-listp-of-cst-group-type-conc
  (b* ((abnf::cstss (cst-group-type-conc abnf::cst)))
    (abnf::tree-list-listp abnf::cstss))
  :rule-classes :rewrite)

Theorem: cst-group-type-conc-match

(defthm cst-group-type-conc-match
  (implies (cst-matchp abnf::cst "group-type")
           (b* ((abnf::cstss (cst-group-type-conc abnf::cst)))
             (cst-list-list-conc-matchp abnf::cstss "%s\"group\"")))
  :rule-classes :rewrite)

Theorem: cst-group-type-conc-of-tree-fix-cst

(defthm cst-group-type-conc-of-tree-fix-cst
  (equal (cst-group-type-conc (abnf::tree-fix abnf::cst))
         (cst-group-type-conc abnf::cst)))

Theorem: cst-group-type-conc-tree-equiv-congruence-on-cst

(defthm cst-group-type-conc-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-group-type-conc abnf::cst)
                  (cst-group-type-conc cst-equiv)))
  :rule-classes :congruence)

Function: cst-scalar-type-conc

(defun cst-scalar-type-conc (abnf::cst)
  (declare (xargs :guard (abnf::treep abnf::cst)))
  (declare (xargs :guard (cst-matchp abnf::cst "scalar-type")))
  (let ((__function__ 'cst-scalar-type-conc))
    (declare (ignorable __function__))
    (abnf::tree-nonleaf->branches abnf::cst)))

Theorem: tree-list-listp-of-cst-scalar-type-conc

(defthm tree-list-listp-of-cst-scalar-type-conc
  (b* ((abnf::cstss (cst-scalar-type-conc abnf::cst)))
    (abnf::tree-list-listp abnf::cstss))
  :rule-classes :rewrite)

Theorem: cst-scalar-type-conc-match

(defthm cst-scalar-type-conc-match
  (implies (cst-matchp abnf::cst "scalar-type")
           (b* ((abnf::cstss (cst-scalar-type-conc abnf::cst)))
             (cst-list-list-conc-matchp abnf::cstss "%s\"scalar\"")))
  :rule-classes :rewrite)

Theorem: cst-scalar-type-conc-of-tree-fix-cst

(defthm cst-scalar-type-conc-of-tree-fix-cst
  (equal (cst-scalar-type-conc (abnf::tree-fix abnf::cst))
         (cst-scalar-type-conc abnf::cst)))

Theorem: cst-scalar-type-conc-tree-equiv-congruence-on-cst

(defthm cst-scalar-type-conc-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-scalar-type-conc abnf::cst)
                  (cst-scalar-type-conc cst-equiv)))
  :rule-classes :congruence)

Function: cst-arithmetic-type-conc1

(defun cst-arithmetic-type-conc1 (abnf::cst)
 (declare (xargs :guard (abnf::treep abnf::cst)))
 (declare
     (xargs :guard (and (cst-matchp abnf::cst "arithmetic-type")
                        (equal (cst-arithmetic-type-conc? abnf::cst)
                               1))))
 (let ((__function__ 'cst-arithmetic-type-conc1))
   (declare (ignorable __function__))
   (abnf::tree-nonleaf->branches abnf::cst)))

Theorem: tree-list-listp-of-cst-arithmetic-type-conc1

(defthm tree-list-listp-of-cst-arithmetic-type-conc1
  (b* ((abnf::cstss (cst-arithmetic-type-conc1 abnf::cst)))
    (abnf::tree-list-listp abnf::cstss))
  :rule-classes :rewrite)

Theorem: cst-arithmetic-type-conc1-match

(defthm cst-arithmetic-type-conc1-match
 (implies (and (cst-matchp abnf::cst "arithmetic-type")
               (equal (cst-arithmetic-type-conc? abnf::cst)
                      1))
          (b* ((abnf::cstss (cst-arithmetic-type-conc1 abnf::cst)))
            (cst-list-list-conc-matchp abnf::cstss "integer-type")))
 :rule-classes :rewrite)

Theorem: cst-arithmetic-type-conc1-of-tree-fix-cst

(defthm cst-arithmetic-type-conc1-of-tree-fix-cst
  (equal (cst-arithmetic-type-conc1 (abnf::tree-fix abnf::cst))
         (cst-arithmetic-type-conc1 abnf::cst)))

Theorem: cst-arithmetic-type-conc1-tree-equiv-congruence-on-cst

(defthm cst-arithmetic-type-conc1-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-arithmetic-type-conc1 abnf::cst)
                  (cst-arithmetic-type-conc1 cst-equiv)))
  :rule-classes :congruence)

Function: cst-arithmetic-type-conc2

(defun cst-arithmetic-type-conc2 (abnf::cst)
 (declare (xargs :guard (abnf::treep abnf::cst)))
 (declare
     (xargs :guard (and (cst-matchp abnf::cst "arithmetic-type")
                        (equal (cst-arithmetic-type-conc? abnf::cst)
                               2))))
 (let ((__function__ 'cst-arithmetic-type-conc2))
   (declare (ignorable __function__))
   (abnf::tree-nonleaf->branches abnf::cst)))

Theorem: tree-list-listp-of-cst-arithmetic-type-conc2

(defthm tree-list-listp-of-cst-arithmetic-type-conc2
  (b* ((abnf::cstss (cst-arithmetic-type-conc2 abnf::cst)))
    (abnf::tree-list-listp abnf::cstss))
  :rule-classes :rewrite)

Theorem: cst-arithmetic-type-conc2-match

(defthm cst-arithmetic-type-conc2-match
  (implies (and (cst-matchp abnf::cst "arithmetic-type")
                (equal (cst-arithmetic-type-conc? abnf::cst)
                       2))
           (b* ((abnf::cstss (cst-arithmetic-type-conc2 abnf::cst)))
             (cst-list-list-conc-matchp abnf::cstss "field-type")))
  :rule-classes :rewrite)

Theorem: cst-arithmetic-type-conc2-of-tree-fix-cst

(defthm cst-arithmetic-type-conc2-of-tree-fix-cst
  (equal (cst-arithmetic-type-conc2 (abnf::tree-fix abnf::cst))
         (cst-arithmetic-type-conc2 abnf::cst)))

Theorem: cst-arithmetic-type-conc2-tree-equiv-congruence-on-cst

(defthm cst-arithmetic-type-conc2-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-arithmetic-type-conc2 abnf::cst)
                  (cst-arithmetic-type-conc2 cst-equiv)))
  :rule-classes :congruence)

Function: cst-arithmetic-type-conc3

(defun cst-arithmetic-type-conc3 (abnf::cst)
 (declare (xargs :guard (abnf::treep abnf::cst)))
 (declare
     (xargs :guard (and (cst-matchp abnf::cst "arithmetic-type")
                        (equal (cst-arithmetic-type-conc? abnf::cst)
                               3))))
 (let ((__function__ 'cst-arithmetic-type-conc3))
   (declare (ignorable __function__))
   (abnf::tree-nonleaf->branches abnf::cst)))

Theorem: tree-list-listp-of-cst-arithmetic-type-conc3

(defthm tree-list-listp-of-cst-arithmetic-type-conc3
  (b* ((abnf::cstss (cst-arithmetic-type-conc3 abnf::cst)))
    (abnf::tree-list-listp abnf::cstss))
  :rule-classes :rewrite)

Theorem: cst-arithmetic-type-conc3-match

(defthm cst-arithmetic-type-conc3-match
  (implies (and (cst-matchp abnf::cst "arithmetic-type")
                (equal (cst-arithmetic-type-conc? abnf::cst)
                       3))
           (b* ((abnf::cstss (cst-arithmetic-type-conc3 abnf::cst)))
             (cst-list-list-conc-matchp abnf::cstss "group-type")))
  :rule-classes :rewrite)

Theorem: cst-arithmetic-type-conc3-of-tree-fix-cst

(defthm cst-arithmetic-type-conc3-of-tree-fix-cst
  (equal (cst-arithmetic-type-conc3 (abnf::tree-fix abnf::cst))
         (cst-arithmetic-type-conc3 abnf::cst)))

Theorem: cst-arithmetic-type-conc3-tree-equiv-congruence-on-cst

(defthm cst-arithmetic-type-conc3-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-arithmetic-type-conc3 abnf::cst)
                  (cst-arithmetic-type-conc3 cst-equiv)))
  :rule-classes :congruence)

Function: cst-arithmetic-type-conc4

(defun cst-arithmetic-type-conc4 (abnf::cst)
 (declare (xargs :guard (abnf::treep abnf::cst)))
 (declare
     (xargs :guard (and (cst-matchp abnf::cst "arithmetic-type")
                        (equal (cst-arithmetic-type-conc? abnf::cst)
                               4))))
 (let ((__function__ 'cst-arithmetic-type-conc4))
   (declare (ignorable __function__))
   (abnf::tree-nonleaf->branches abnf::cst)))

Theorem: tree-list-listp-of-cst-arithmetic-type-conc4

(defthm tree-list-listp-of-cst-arithmetic-type-conc4
  (b* ((abnf::cstss (cst-arithmetic-type-conc4 abnf::cst)))
    (abnf::tree-list-listp abnf::cstss))
  :rule-classes :rewrite)

Theorem: cst-arithmetic-type-conc4-match

(defthm cst-arithmetic-type-conc4-match
  (implies (and (cst-matchp abnf::cst "arithmetic-type")
                (equal (cst-arithmetic-type-conc? abnf::cst)
                       4))
           (b* ((abnf::cstss (cst-arithmetic-type-conc4 abnf::cst)))
             (cst-list-list-conc-matchp abnf::cstss "scalar-type")))
  :rule-classes :rewrite)

Theorem: cst-arithmetic-type-conc4-of-tree-fix-cst

(defthm cst-arithmetic-type-conc4-of-tree-fix-cst
  (equal (cst-arithmetic-type-conc4 (abnf::tree-fix abnf::cst))
         (cst-arithmetic-type-conc4 abnf::cst)))

Theorem: cst-arithmetic-type-conc4-tree-equiv-congruence-on-cst

(defthm cst-arithmetic-type-conc4-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-arithmetic-type-conc4 abnf::cst)
                  (cst-arithmetic-type-conc4 cst-equiv)))
  :rule-classes :congruence)

Function: cst-address-type-conc

(defun cst-address-type-conc (abnf::cst)
  (declare (xargs :guard (abnf::treep abnf::cst)))
  (declare (xargs :guard (cst-matchp abnf::cst "address-type")))
  (let ((__function__ 'cst-address-type-conc))
    (declare (ignorable __function__))
    (abnf::tree-nonleaf->branches abnf::cst)))

Theorem: tree-list-listp-of-cst-address-type-conc

(defthm tree-list-listp-of-cst-address-type-conc
  (b* ((abnf::cstss (cst-address-type-conc abnf::cst)))
    (abnf::tree-list-listp abnf::cstss))
  :rule-classes :rewrite)

Theorem: cst-address-type-conc-match

(defthm cst-address-type-conc-match
  (implies (cst-matchp abnf::cst "address-type")
           (b* ((abnf::cstss (cst-address-type-conc abnf::cst)))
             (cst-list-list-conc-matchp abnf::cstss "%s\"address\"")))
  :rule-classes :rewrite)

Theorem: cst-address-type-conc-of-tree-fix-cst

(defthm cst-address-type-conc-of-tree-fix-cst
  (equal (cst-address-type-conc (abnf::tree-fix abnf::cst))
         (cst-address-type-conc abnf::cst)))

Theorem: cst-address-type-conc-tree-equiv-congruence-on-cst

(defthm cst-address-type-conc-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-address-type-conc abnf::cst)
                  (cst-address-type-conc cst-equiv)))
  :rule-classes :congruence)

Function: cst-boolean-type-conc

(defun cst-boolean-type-conc (abnf::cst)
  (declare (xargs :guard (abnf::treep abnf::cst)))
  (declare (xargs :guard (cst-matchp abnf::cst "boolean-type")))
  (let ((__function__ 'cst-boolean-type-conc))
    (declare (ignorable __function__))
    (abnf::tree-nonleaf->branches abnf::cst)))

Theorem: tree-list-listp-of-cst-boolean-type-conc

(defthm tree-list-listp-of-cst-boolean-type-conc
  (b* ((abnf::cstss (cst-boolean-type-conc abnf::cst)))
    (abnf::tree-list-listp abnf::cstss))
  :rule-classes :rewrite)

Theorem: cst-boolean-type-conc-match

(defthm cst-boolean-type-conc-match
  (implies (cst-matchp abnf::cst "boolean-type")
           (b* ((abnf::cstss (cst-boolean-type-conc abnf::cst)))
             (cst-list-list-conc-matchp abnf::cstss "%s\"boolean\"")))
  :rule-classes :rewrite)

Theorem: cst-boolean-type-conc-of-tree-fix-cst

(defthm cst-boolean-type-conc-of-tree-fix-cst
  (equal (cst-boolean-type-conc (abnf::tree-fix abnf::cst))
         (cst-boolean-type-conc abnf::cst)))

Theorem: cst-boolean-type-conc-tree-equiv-congruence-on-cst

(defthm cst-boolean-type-conc-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-boolean-type-conc abnf::cst)
                  (cst-boolean-type-conc cst-equiv)))
  :rule-classes :congruence)

Function: cst-string-type-conc

(defun cst-string-type-conc (abnf::cst)
  (declare (xargs :guard (abnf::treep abnf::cst)))
  (declare (xargs :guard (cst-matchp abnf::cst "string-type")))
  (let ((__function__ 'cst-string-type-conc))
    (declare (ignorable __function__))
    (abnf::tree-nonleaf->branches abnf::cst)))

Theorem: tree-list-listp-of-cst-string-type-conc

(defthm tree-list-listp-of-cst-string-type-conc
  (b* ((abnf::cstss (cst-string-type-conc abnf::cst)))
    (abnf::tree-list-listp abnf::cstss))
  :rule-classes :rewrite)

Theorem: cst-string-type-conc-match

(defthm cst-string-type-conc-match
  (implies (cst-matchp abnf::cst "string-type")
           (b* ((abnf::cstss (cst-string-type-conc abnf::cst)))
             (cst-list-list-conc-matchp abnf::cstss "%s\"string\"")))
  :rule-classes :rewrite)

Theorem: cst-string-type-conc-of-tree-fix-cst

(defthm cst-string-type-conc-of-tree-fix-cst
  (equal (cst-string-type-conc (abnf::tree-fix abnf::cst))
         (cst-string-type-conc abnf::cst)))

Theorem: cst-string-type-conc-tree-equiv-congruence-on-cst

(defthm cst-string-type-conc-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-string-type-conc abnf::cst)
                  (cst-string-type-conc cst-equiv)))
  :rule-classes :congruence)

Function: cst-literal-type-conc1

(defun cst-literal-type-conc1 (abnf::cst)
  (declare (xargs :guard (abnf::treep abnf::cst)))
  (declare
       (xargs :guard (and (cst-matchp abnf::cst "literal-type")
                          (equal (cst-literal-type-conc? abnf::cst)
                                 1))))
  (let ((__function__ 'cst-literal-type-conc1))
    (declare (ignorable __function__))
    (abnf::tree-nonleaf->branches abnf::cst)))

Theorem: tree-list-listp-of-cst-literal-type-conc1

(defthm tree-list-listp-of-cst-literal-type-conc1
  (b* ((abnf::cstss (cst-literal-type-conc1 abnf::cst)))
    (abnf::tree-list-listp abnf::cstss))
  :rule-classes :rewrite)

Theorem: cst-literal-type-conc1-match

(defthm cst-literal-type-conc1-match
  (implies
       (and (cst-matchp abnf::cst "literal-type")
            (equal (cst-literal-type-conc? abnf::cst)
                   1))
       (b* ((abnf::cstss (cst-literal-type-conc1 abnf::cst)))
         (cst-list-list-conc-matchp abnf::cstss "arithmetic-type")))
  :rule-classes :rewrite)

Theorem: cst-literal-type-conc1-of-tree-fix-cst

(defthm cst-literal-type-conc1-of-tree-fix-cst
  (equal (cst-literal-type-conc1 (abnf::tree-fix abnf::cst))
         (cst-literal-type-conc1 abnf::cst)))

Theorem: cst-literal-type-conc1-tree-equiv-congruence-on-cst

(defthm cst-literal-type-conc1-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-literal-type-conc1 abnf::cst)
                  (cst-literal-type-conc1 cst-equiv)))
  :rule-classes :congruence)

Function: cst-literal-type-conc2

(defun cst-literal-type-conc2 (abnf::cst)
  (declare (xargs :guard (abnf::treep abnf::cst)))
  (declare
       (xargs :guard (and (cst-matchp abnf::cst "literal-type")
                          (equal (cst-literal-type-conc? abnf::cst)
                                 2))))
  (let ((__function__ 'cst-literal-type-conc2))
    (declare (ignorable __function__))
    (abnf::tree-nonleaf->branches abnf::cst)))

Theorem: tree-list-listp-of-cst-literal-type-conc2

(defthm tree-list-listp-of-cst-literal-type-conc2
  (b* ((abnf::cstss (cst-literal-type-conc2 abnf::cst)))
    (abnf::tree-list-listp abnf::cstss))
  :rule-classes :rewrite)

Theorem: cst-literal-type-conc2-match

(defthm cst-literal-type-conc2-match
 (implies (and (cst-matchp abnf::cst "literal-type")
               (equal (cst-literal-type-conc? abnf::cst)
                      2))
          (b* ((abnf::cstss (cst-literal-type-conc2 abnf::cst)))
            (cst-list-list-conc-matchp abnf::cstss "address-type")))
 :rule-classes :rewrite)

Theorem: cst-literal-type-conc2-of-tree-fix-cst

(defthm cst-literal-type-conc2-of-tree-fix-cst
  (equal (cst-literal-type-conc2 (abnf::tree-fix abnf::cst))
         (cst-literal-type-conc2 abnf::cst)))

Theorem: cst-literal-type-conc2-tree-equiv-congruence-on-cst

(defthm cst-literal-type-conc2-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-literal-type-conc2 abnf::cst)
                  (cst-literal-type-conc2 cst-equiv)))
  :rule-classes :congruence)

Function: cst-literal-type-conc3

(defun cst-literal-type-conc3 (abnf::cst)
  (declare (xargs :guard (abnf::treep abnf::cst)))
  (declare
       (xargs :guard (and (cst-matchp abnf::cst "literal-type")
                          (equal (cst-literal-type-conc? abnf::cst)
                                 3))))
  (let ((__function__ 'cst-literal-type-conc3))
    (declare (ignorable __function__))
    (abnf::tree-nonleaf->branches abnf::cst)))

Theorem: tree-list-listp-of-cst-literal-type-conc3

(defthm tree-list-listp-of-cst-literal-type-conc3
  (b* ((abnf::cstss (cst-literal-type-conc3 abnf::cst)))
    (abnf::tree-list-listp abnf::cstss))
  :rule-classes :rewrite)

Theorem: cst-literal-type-conc3-match

(defthm cst-literal-type-conc3-match
 (implies (and (cst-matchp abnf::cst "literal-type")
               (equal (cst-literal-type-conc? abnf::cst)
                      3))
          (b* ((abnf::cstss (cst-literal-type-conc3 abnf::cst)))
            (cst-list-list-conc-matchp abnf::cstss "boolean-type")))
 :rule-classes :rewrite)

Theorem: cst-literal-type-conc3-of-tree-fix-cst

(defthm cst-literal-type-conc3-of-tree-fix-cst
  (equal (cst-literal-type-conc3 (abnf::tree-fix abnf::cst))
         (cst-literal-type-conc3 abnf::cst)))

Theorem: cst-literal-type-conc3-tree-equiv-congruence-on-cst

(defthm cst-literal-type-conc3-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-literal-type-conc3 abnf::cst)
                  (cst-literal-type-conc3 cst-equiv)))
  :rule-classes :congruence)

Function: cst-literal-type-conc4

(defun cst-literal-type-conc4 (abnf::cst)
  (declare (xargs :guard (abnf::treep abnf::cst)))
  (declare
       (xargs :guard (and (cst-matchp abnf::cst "literal-type")
                          (equal (cst-literal-type-conc? abnf::cst)
                                 4))))
  (let ((__function__ 'cst-literal-type-conc4))
    (declare (ignorable __function__))
    (abnf::tree-nonleaf->branches abnf::cst)))

Theorem: tree-list-listp-of-cst-literal-type-conc4

(defthm tree-list-listp-of-cst-literal-type-conc4
  (b* ((abnf::cstss (cst-literal-type-conc4 abnf::cst)))
    (abnf::tree-list-listp abnf::cstss))
  :rule-classes :rewrite)

Theorem: cst-literal-type-conc4-match

(defthm cst-literal-type-conc4-match
  (implies (and (cst-matchp abnf::cst "literal-type")
                (equal (cst-literal-type-conc? abnf::cst)
                       4))
           (b* ((abnf::cstss (cst-literal-type-conc4 abnf::cst)))
             (cst-list-list-conc-matchp abnf::cstss "string-type")))
  :rule-classes :rewrite)

Theorem: cst-literal-type-conc4-of-tree-fix-cst

(defthm cst-literal-type-conc4-of-tree-fix-cst
  (equal (cst-literal-type-conc4 (abnf::tree-fix abnf::cst))
         (cst-literal-type-conc4 abnf::cst)))

Theorem: cst-literal-type-conc4-tree-equiv-congruence-on-cst

(defthm cst-literal-type-conc4-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-literal-type-conc4 abnf::cst)
                  (cst-literal-type-conc4 cst-equiv)))
  :rule-classes :congruence)

Function: cst-plaintext-type-conc1

(defun cst-plaintext-type-conc1 (abnf::cst)
 (declare (xargs :guard (abnf::treep abnf::cst)))
 (declare
      (xargs :guard (and (cst-matchp abnf::cst "plaintext-type")
                         (equal (cst-plaintext-type-conc? abnf::cst)
                                1))))
 (let ((__function__ 'cst-plaintext-type-conc1))
   (declare (ignorable __function__))
   (abnf::tree-nonleaf->branches abnf::cst)))

Theorem: tree-list-listp-of-cst-plaintext-type-conc1

(defthm tree-list-listp-of-cst-plaintext-type-conc1
  (b* ((abnf::cstss (cst-plaintext-type-conc1 abnf::cst)))
    (abnf::tree-list-listp abnf::cstss))
  :rule-classes :rewrite)

Theorem: cst-plaintext-type-conc1-match

(defthm cst-plaintext-type-conc1-match
 (implies (and (cst-matchp abnf::cst "plaintext-type")
               (equal (cst-plaintext-type-conc? abnf::cst)
                      1))
          (b* ((abnf::cstss (cst-plaintext-type-conc1 abnf::cst)))
            (cst-list-list-conc-matchp abnf::cstss "literal-type")))
 :rule-classes :rewrite)

Theorem: cst-plaintext-type-conc1-of-tree-fix-cst

(defthm cst-plaintext-type-conc1-of-tree-fix-cst
  (equal (cst-plaintext-type-conc1 (abnf::tree-fix abnf::cst))
         (cst-plaintext-type-conc1 abnf::cst)))

Theorem: cst-plaintext-type-conc1-tree-equiv-congruence-on-cst

(defthm cst-plaintext-type-conc1-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-plaintext-type-conc1 abnf::cst)
                  (cst-plaintext-type-conc1 cst-equiv)))
  :rule-classes :congruence)

Function: cst-plaintext-type-conc2

(defun cst-plaintext-type-conc2 (abnf::cst)
 (declare (xargs :guard (abnf::treep abnf::cst)))
 (declare
      (xargs :guard (and (cst-matchp abnf::cst "plaintext-type")
                         (equal (cst-plaintext-type-conc? abnf::cst)
                                2))))
 (let ((__function__ 'cst-plaintext-type-conc2))
   (declare (ignorable __function__))
   (abnf::tree-nonleaf->branches abnf::cst)))

Theorem: tree-list-listp-of-cst-plaintext-type-conc2

(defthm tree-list-listp-of-cst-plaintext-type-conc2
  (b* ((abnf::cstss (cst-plaintext-type-conc2 abnf::cst)))
    (abnf::tree-list-listp abnf::cstss))
  :rule-classes :rewrite)

Theorem: cst-plaintext-type-conc2-match

(defthm cst-plaintext-type-conc2-match
  (implies (and (cst-matchp abnf::cst "plaintext-type")
                (equal (cst-plaintext-type-conc? abnf::cst)
                       2))
           (b* ((abnf::cstss (cst-plaintext-type-conc2 abnf::cst)))
             (cst-list-list-conc-matchp abnf::cstss "identifier")))
  :rule-classes :rewrite)

Theorem: cst-plaintext-type-conc2-of-tree-fix-cst

(defthm cst-plaintext-type-conc2-of-tree-fix-cst
  (equal (cst-plaintext-type-conc2 (abnf::tree-fix abnf::cst))
         (cst-plaintext-type-conc2 abnf::cst)))

Theorem: cst-plaintext-type-conc2-tree-equiv-congruence-on-cst

(defthm cst-plaintext-type-conc2-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-plaintext-type-conc2 abnf::cst)
                  (cst-plaintext-type-conc2 cst-equiv)))
  :rule-classes :congruence)

Function: cst-entry-type-conc

(defun cst-entry-type-conc (abnf::cst)
  (declare (xargs :guard (abnf::treep abnf::cst)))
  (declare (xargs :guard (cst-matchp abnf::cst "entry-type")))
  (let ((__function__ 'cst-entry-type-conc))
    (declare (ignorable __function__))
    (abnf::tree-nonleaf->branches abnf::cst)))

Theorem: tree-list-listp-of-cst-entry-type-conc

(defthm tree-list-listp-of-cst-entry-type-conc
  (b* ((abnf::cstss (cst-entry-type-conc abnf::cst)))
    (abnf::tree-list-listp abnf::cstss))
  :rule-classes :rewrite)

Theorem: cst-entry-type-conc-match

(defthm cst-entry-type-conc-match
 (implies
  (cst-matchp abnf::cst "entry-type")
  (b* ((abnf::cstss (cst-entry-type-conc abnf::cst)))
   (cst-list-list-conc-matchp
    abnf::cstss
    "plaintext-type ( %s\".constant\" / %s\".public\" / %s\".private\" )")))
 :rule-classes :rewrite)

Theorem: cst-entry-type-conc-of-tree-fix-cst

(defthm cst-entry-type-conc-of-tree-fix-cst
  (equal (cst-entry-type-conc (abnf::tree-fix abnf::cst))
         (cst-entry-type-conc abnf::cst)))

Theorem: cst-entry-type-conc-tree-equiv-congruence-on-cst

(defthm cst-entry-type-conc-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-entry-type-conc abnf::cst)
                  (cst-entry-type-conc cst-equiv)))
  :rule-classes :congruence)

Function: cst-import-conc

(defun cst-import-conc (abnf::cst)
  (declare (xargs :guard (abnf::treep abnf::cst)))
  (declare (xargs :guard (cst-matchp abnf::cst "import")))
  (let ((__function__ 'cst-import-conc))
    (declare (ignorable __function__))
    (abnf::tree-nonleaf->branches abnf::cst)))

Theorem: tree-list-listp-of-cst-import-conc

(defthm tree-list-listp-of-cst-import-conc
  (b* ((abnf::cstss (cst-import-conc abnf::cst)))
    (abnf::tree-list-listp abnf::cstss))
  :rule-classes :rewrite)

Theorem: cst-import-conc-match

(defthm cst-import-conc-match
  (implies (cst-matchp abnf::cst "import")
           (b* ((abnf::cstss (cst-import-conc abnf::cst)))
             (cst-list-list-conc-matchp
                  abnf::cstss
                  "cws %s\"import\" ws program-id ws \";\"")))
  :rule-classes :rewrite)

Theorem: cst-import-conc-of-tree-fix-cst

(defthm cst-import-conc-of-tree-fix-cst
  (equal (cst-import-conc (abnf::tree-fix abnf::cst))
         (cst-import-conc abnf::cst)))

Theorem: cst-import-conc-tree-equiv-congruence-on-cst

(defthm cst-import-conc-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-import-conc abnf::cst)
                  (cst-import-conc cst-equiv)))
  :rule-classes :congruence)

Function: cst-mapping-conc

(defun cst-mapping-conc (abnf::cst)
  (declare (xargs :guard (abnf::treep abnf::cst)))
  (declare (xargs :guard (cst-matchp abnf::cst "mapping")))
  (let ((__function__ 'cst-mapping-conc))
    (declare (ignorable __function__))
    (abnf::tree-nonleaf->branches abnf::cst)))

Theorem: tree-list-listp-of-cst-mapping-conc

(defthm tree-list-listp-of-cst-mapping-conc
  (b* ((abnf::cstss (cst-mapping-conc abnf::cst)))
    (abnf::tree-list-listp abnf::cstss))
  :rule-classes :rewrite)

Theorem: cst-mapping-conc-match

(defthm cst-mapping-conc-match
 (implies
  (cst-matchp abnf::cst "mapping")
  (b* ((abnf::cstss (cst-mapping-conc abnf::cst)))
   (cst-list-list-conc-matchp
    abnf::cstss
    "cws %s\"mapping\" ws identifier ws \":\" mapping-key mapping-value")))
 :rule-classes :rewrite)

Theorem: cst-mapping-conc-of-tree-fix-cst

(defthm cst-mapping-conc-of-tree-fix-cst
  (equal (cst-mapping-conc (abnf::tree-fix abnf::cst))
         (cst-mapping-conc abnf::cst)))

Theorem: cst-mapping-conc-tree-equiv-congruence-on-cst

(defthm cst-mapping-conc-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-mapping-conc abnf::cst)
                  (cst-mapping-conc cst-equiv)))
  :rule-classes :congruence)

Function: cst-mapping-key-conc

(defun cst-mapping-key-conc (abnf::cst)
  (declare (xargs :guard (abnf::treep abnf::cst)))
  (declare (xargs :guard (cst-matchp abnf::cst "mapping-key")))
  (let ((__function__ 'cst-mapping-key-conc))
    (declare (ignorable __function__))
    (abnf::tree-nonleaf->branches abnf::cst)))

Theorem: tree-list-listp-of-cst-mapping-key-conc

(defthm tree-list-listp-of-cst-mapping-key-conc
  (b* ((abnf::cstss (cst-mapping-key-conc abnf::cst)))
    (abnf::tree-list-listp abnf::cstss))
  :rule-classes :rewrite)

Theorem: cst-mapping-key-conc-match

(defthm cst-mapping-key-conc-match
 (implies
  (cst-matchp abnf::cst "mapping-key")
  (b* ((abnf::cstss (cst-mapping-key-conc abnf::cst)))
   (cst-list-list-conc-matchp
    abnf::cstss
    "cws %s\"key\" ws identifier ws %s\"as\" ws finalize-type ws \";\"")))
 :rule-classes :rewrite)

Theorem: cst-mapping-key-conc-of-tree-fix-cst

(defthm cst-mapping-key-conc-of-tree-fix-cst
  (equal (cst-mapping-key-conc (abnf::tree-fix abnf::cst))
         (cst-mapping-key-conc abnf::cst)))

Theorem: cst-mapping-key-conc-tree-equiv-congruence-on-cst

(defthm cst-mapping-key-conc-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-mapping-key-conc abnf::cst)
                  (cst-mapping-key-conc cst-equiv)))
  :rule-classes :congruence)

Function: cst-mapping-value-conc

(defun cst-mapping-value-conc (abnf::cst)
  (declare (xargs :guard (abnf::treep abnf::cst)))
  (declare (xargs :guard (cst-matchp abnf::cst "mapping-value")))
  (let ((__function__ 'cst-mapping-value-conc))
    (declare (ignorable __function__))
    (abnf::tree-nonleaf->branches abnf::cst)))

Theorem: tree-list-listp-of-cst-mapping-value-conc

(defthm tree-list-listp-of-cst-mapping-value-conc
  (b* ((abnf::cstss (cst-mapping-value-conc abnf::cst)))
    (abnf::tree-list-listp abnf::cstss))
  :rule-classes :rewrite)

Theorem: cst-mapping-value-conc-match

(defthm cst-mapping-value-conc-match
 (implies
  (cst-matchp abnf::cst "mapping-value")
  (b* ((abnf::cstss (cst-mapping-value-conc abnf::cst)))
   (cst-list-list-conc-matchp
    abnf::cstss
    "cws %s\"value\" ws identifier ws %s\"as\" ws finalize-type ws \";\"")))
 :rule-classes :rewrite)

Theorem: cst-mapping-value-conc-of-tree-fix-cst

(defthm cst-mapping-value-conc-of-tree-fix-cst
  (equal (cst-mapping-value-conc (abnf::tree-fix abnf::cst))
         (cst-mapping-value-conc abnf::cst)))

Theorem: cst-mapping-value-conc-tree-equiv-congruence-on-cst

(defthm cst-mapping-value-conc-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-mapping-value-conc abnf::cst)
                  (cst-mapping-value-conc cst-equiv)))
  :rule-classes :congruence)

Function: cst-struct-conc

(defun cst-struct-conc (abnf::cst)
  (declare (xargs :guard (abnf::treep abnf::cst)))
  (declare (xargs :guard (cst-matchp abnf::cst "struct")))
  (let ((__function__ 'cst-struct-conc))
    (declare (ignorable __function__))
    (abnf::tree-nonleaf->branches abnf::cst)))

Theorem: tree-list-listp-of-cst-struct-conc

(defthm tree-list-listp-of-cst-struct-conc
  (b* ((abnf::cstss (cst-struct-conc abnf::cst)))
    (abnf::tree-list-listp abnf::cstss))
  :rule-classes :rewrite)

Theorem: cst-struct-conc-match

(defthm cst-struct-conc-match
  (implies (cst-matchp abnf::cst "struct")
           (b* ((abnf::cstss (cst-struct-conc abnf::cst)))
             (cst-list-list-conc-matchp
                  abnf::cstss
                  "cws %s\"struct\" ws identifier ws \":\" 1*tuple")))
  :rule-classes :rewrite)

Theorem: cst-struct-conc-of-tree-fix-cst

(defthm cst-struct-conc-of-tree-fix-cst
  (equal (cst-struct-conc (abnf::tree-fix abnf::cst))
         (cst-struct-conc abnf::cst)))

Theorem: cst-struct-conc-tree-equiv-congruence-on-cst

(defthm cst-struct-conc-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-struct-conc abnf::cst)
                  (cst-struct-conc cst-equiv)))
  :rule-classes :congruence)

Function: cst-tuple-conc

(defun cst-tuple-conc (abnf::cst)
  (declare (xargs :guard (abnf::treep abnf::cst)))
  (declare (xargs :guard (cst-matchp abnf::cst "tuple")))
  (let ((__function__ 'cst-tuple-conc))
    (declare (ignorable __function__))
    (abnf::tree-nonleaf->branches abnf::cst)))

Theorem: tree-list-listp-of-cst-tuple-conc

(defthm tree-list-listp-of-cst-tuple-conc
  (b* ((abnf::cstss (cst-tuple-conc abnf::cst)))
    (abnf::tree-list-listp abnf::cstss))
  :rule-classes :rewrite)

Theorem: cst-tuple-conc-match

(defthm cst-tuple-conc-match
  (implies
       (cst-matchp abnf::cst "tuple")
       (b* ((abnf::cstss (cst-tuple-conc abnf::cst)))
         (cst-list-list-conc-matchp
              abnf::cstss
              "cws identifier ws %s\"as\" ws plaintext-type ws \";\"")))
  :rule-classes :rewrite)

Theorem: cst-tuple-conc-of-tree-fix-cst

(defthm cst-tuple-conc-of-tree-fix-cst
  (equal (cst-tuple-conc (abnf::tree-fix abnf::cst))
         (cst-tuple-conc abnf::cst)))

Theorem: cst-tuple-conc-tree-equiv-congruence-on-cst

(defthm cst-tuple-conc-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-tuple-conc abnf::cst)
                  (cst-tuple-conc cst-equiv)))
  :rule-classes :congruence)

Function: cst-record-conc

(defun cst-record-conc (abnf::cst)
  (declare (xargs :guard (abnf::treep abnf::cst)))
  (declare (xargs :guard (cst-matchp abnf::cst "record")))
  (let ((__function__ 'cst-record-conc))
    (declare (ignorable __function__))
    (abnf::tree-nonleaf->branches abnf::cst)))

Theorem: tree-list-listp-of-cst-record-conc

(defthm tree-list-listp-of-cst-record-conc
  (b* ((abnf::cstss (cst-record-conc abnf::cst)))
    (abnf::tree-list-listp abnf::cstss))
  :rule-classes :rewrite)

Theorem: cst-record-conc-match

(defthm cst-record-conc-match
 (implies
  (cst-matchp abnf::cst "record")
  (b* ((abnf::cstss (cst-record-conc abnf::cst)))
   (cst-list-list-conc-matchp
    abnf::cstss
    "cws %s\"record\" ws identifier ws \":\" cws %s\"owner\" ws %s\"as\" ws cws ( %s\"address.public\" / %s\"address.private\" ) ws \";\" cws %s\"gates\" ws %s\"as\" ws cws ( %s\"u64.public\" / %s\"u64.private\" ) ws \";\" *entry")))
 :rule-classes :rewrite)

Theorem: cst-record-conc-of-tree-fix-cst

(defthm cst-record-conc-of-tree-fix-cst
  (equal (cst-record-conc (abnf::tree-fix abnf::cst))
         (cst-record-conc abnf::cst)))

Theorem: cst-record-conc-tree-equiv-congruence-on-cst

(defthm cst-record-conc-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-record-conc abnf::cst)
                  (cst-record-conc cst-equiv)))
  :rule-classes :congruence)

Function: cst-entry-conc

(defun cst-entry-conc (abnf::cst)
  (declare (xargs :guard (abnf::treep abnf::cst)))
  (declare (xargs :guard (cst-matchp abnf::cst "entry")))
  (let ((__function__ 'cst-entry-conc))
    (declare (ignorable __function__))
    (abnf::tree-nonleaf->branches abnf::cst)))

Theorem: tree-list-listp-of-cst-entry-conc

(defthm tree-list-listp-of-cst-entry-conc
  (b* ((abnf::cstss (cst-entry-conc abnf::cst)))
    (abnf::tree-list-listp abnf::cstss))
  :rule-classes :rewrite)

Theorem: cst-entry-conc-match

(defthm cst-entry-conc-match
  (implies (cst-matchp abnf::cst "entry")
           (b* ((abnf::cstss (cst-entry-conc abnf::cst)))
             (cst-list-list-conc-matchp
                  abnf::cstss
                  "cws identifier ws %s\"as\" ws entry-type ws \";\"")))
  :rule-classes :rewrite)

Theorem: cst-entry-conc-of-tree-fix-cst

(defthm cst-entry-conc-of-tree-fix-cst
  (equal (cst-entry-conc (abnf::tree-fix abnf::cst))
         (cst-entry-conc abnf::cst)))

Theorem: cst-entry-conc-tree-equiv-congruence-on-cst

(defthm cst-entry-conc-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-entry-conc abnf::cst)
                  (cst-entry-conc cst-equiv)))
  :rule-classes :congruence)

Function: cst-ternary-op-conc

(defun cst-ternary-op-conc (abnf::cst)
  (declare (xargs :guard (abnf::treep abnf::cst)))
  (declare (xargs :guard (cst-matchp abnf::cst "ternary-op")))
  (let ((__function__ 'cst-ternary-op-conc))
    (declare (ignorable __function__))
    (abnf::tree-nonleaf->branches abnf::cst)))

Theorem: tree-list-listp-of-cst-ternary-op-conc

(defthm tree-list-listp-of-cst-ternary-op-conc
  (b* ((abnf::cstss (cst-ternary-op-conc abnf::cst)))
    (abnf::tree-list-listp abnf::cstss))
  :rule-classes :rewrite)

Theorem: cst-ternary-op-conc-match

(defthm cst-ternary-op-conc-match
  (implies (cst-matchp abnf::cst "ternary-op")
           (b* ((abnf::cstss (cst-ternary-op-conc abnf::cst)))
             (cst-list-list-conc-matchp abnf::cstss "%s\"ternary\"")))
  :rule-classes :rewrite)

Theorem: cst-ternary-op-conc-of-tree-fix-cst

(defthm cst-ternary-op-conc-of-tree-fix-cst
  (equal (cst-ternary-op-conc (abnf::tree-fix abnf::cst))
         (cst-ternary-op-conc abnf::cst)))

Theorem: cst-ternary-op-conc-tree-equiv-congruence-on-cst

(defthm cst-ternary-op-conc-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-ternary-op-conc abnf::cst)
                  (cst-ternary-op-conc cst-equiv)))
  :rule-classes :congruence)

Function: cst-unary-conc

(defun cst-unary-conc (abnf::cst)
  (declare (xargs :guard (abnf::treep abnf::cst)))
  (declare (xargs :guard (cst-matchp abnf::cst "unary")))
  (let ((__function__ 'cst-unary-conc))
    (declare (ignorable __function__))
    (abnf::tree-nonleaf->branches abnf::cst)))

Theorem: tree-list-listp-of-cst-unary-conc

(defthm tree-list-listp-of-cst-unary-conc
  (b* ((abnf::cstss (cst-unary-conc abnf::cst)))
    (abnf::tree-list-listp abnf::cstss))
  :rule-classes :rewrite)

Theorem: cst-unary-conc-match

(defthm cst-unary-conc-match
  (implies
       (cst-matchp abnf::cst "unary")
       (b* ((abnf::cstss (cst-unary-conc abnf::cst)))
         (cst-list-list-conc-matchp
              abnf::cstss
              "unary-op ws ( operand ws ) %s\"into\" ws register")))
  :rule-classes :rewrite)

Theorem: cst-unary-conc-of-tree-fix-cst

(defthm cst-unary-conc-of-tree-fix-cst
  (equal (cst-unary-conc (abnf::tree-fix abnf::cst))
         (cst-unary-conc abnf::cst)))

Theorem: cst-unary-conc-tree-equiv-congruence-on-cst

(defthm cst-unary-conc-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-unary-conc abnf::cst)
                  (cst-unary-conc cst-equiv)))
  :rule-classes :congruence)

Function: cst-binary-conc

(defun cst-binary-conc (abnf::cst)
  (declare (xargs :guard (abnf::treep abnf::cst)))
  (declare (xargs :guard (cst-matchp abnf::cst "binary")))
  (let ((__function__ 'cst-binary-conc))
    (declare (ignorable __function__))
    (abnf::tree-nonleaf->branches abnf::cst)))

Theorem: tree-list-listp-of-cst-binary-conc

(defthm tree-list-listp-of-cst-binary-conc
  (b* ((abnf::cstss (cst-binary-conc abnf::cst)))
    (abnf::tree-list-listp abnf::cstss))
  :rule-classes :rewrite)

Theorem: cst-binary-conc-match

(defthm cst-binary-conc-match
  (implies
       (cst-matchp abnf::cst "binary")
       (b* ((abnf::cstss (cst-binary-conc abnf::cst)))
         (cst-list-list-conc-matchp
              abnf::cstss
              "binary-op ws 2( operand ws ) %s\"into\" ws register")))
  :rule-classes :rewrite)

Theorem: cst-binary-conc-of-tree-fix-cst

(defthm cst-binary-conc-of-tree-fix-cst
  (equal (cst-binary-conc (abnf::tree-fix abnf::cst))
         (cst-binary-conc abnf::cst)))

Theorem: cst-binary-conc-tree-equiv-congruence-on-cst

(defthm cst-binary-conc-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-binary-conc abnf::cst)
                  (cst-binary-conc cst-equiv)))
  :rule-classes :congruence)

Function: cst-ternary-conc

(defun cst-ternary-conc (abnf::cst)
  (declare (xargs :guard (abnf::treep abnf::cst)))
  (declare (xargs :guard (cst-matchp abnf::cst "ternary")))
  (let ((__function__ 'cst-ternary-conc))
    (declare (ignorable __function__))
    (abnf::tree-nonleaf->branches abnf::cst)))

Theorem: tree-list-listp-of-cst-ternary-conc

(defthm tree-list-listp-of-cst-ternary-conc
  (b* ((abnf::cstss (cst-ternary-conc abnf::cst)))
    (abnf::tree-list-listp abnf::cstss))
  :rule-classes :rewrite)

Theorem: cst-ternary-conc-match

(defthm cst-ternary-conc-match
 (implies
      (cst-matchp abnf::cst "ternary")
      (b* ((abnf::cstss (cst-ternary-conc abnf::cst)))
        (cst-list-list-conc-matchp
             abnf::cstss
             "ternary-op ws 3( operand ws ) %s\"into\" ws register")))
 :rule-classes :rewrite)

Theorem: cst-ternary-conc-of-tree-fix-cst

(defthm cst-ternary-conc-of-tree-fix-cst
  (equal (cst-ternary-conc (abnf::tree-fix abnf::cst))
         (cst-ternary-conc abnf::cst)))

Theorem: cst-ternary-conc-tree-equiv-congruence-on-cst

(defthm cst-ternary-conc-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-ternary-conc abnf::cst)
                  (cst-ternary-conc cst-equiv)))
  :rule-classes :congruence)

Function: cst-is-conc

(defun cst-is-conc (abnf::cst)
  (declare (xargs :guard (abnf::treep abnf::cst)))
  (declare (xargs :guard (cst-matchp abnf::cst "is")))
  (let ((__function__ 'cst-is-conc))
    (declare (ignorable __function__))
    (abnf::tree-nonleaf->branches abnf::cst)))

Theorem: tree-list-listp-of-cst-is-conc

(defthm tree-list-listp-of-cst-is-conc
  (b* ((abnf::cstss (cst-is-conc abnf::cst)))
    (abnf::tree-list-listp abnf::cstss))
  :rule-classes :rewrite)

Theorem: cst-is-conc-match

(defthm cst-is-conc-match
 (implies
     (cst-matchp abnf::cst "is")
     (b* ((abnf::cstss (cst-is-conc abnf::cst)))
       (cst-list-list-conc-matchp
            abnf::cstss
            "is-op ws operand ws operand ws %s\"into\" ws register")))
 :rule-classes :rewrite)

Theorem: cst-is-conc-of-tree-fix-cst

(defthm cst-is-conc-of-tree-fix-cst
  (equal (cst-is-conc (abnf::tree-fix abnf::cst))
         (cst-is-conc abnf::cst)))

Theorem: cst-is-conc-tree-equiv-congruence-on-cst

(defthm cst-is-conc-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-is-conc abnf::cst)
                  (cst-is-conc cst-equiv)))
  :rule-classes :congruence)

Function: cst-assert-conc

(defun cst-assert-conc (abnf::cst)
  (declare (xargs :guard (abnf::treep abnf::cst)))
  (declare (xargs :guard (cst-matchp abnf::cst "assert")))
  (let ((__function__ 'cst-assert-conc))
    (declare (ignorable __function__))
    (abnf::tree-nonleaf->branches abnf::cst)))

Theorem: tree-list-listp-of-cst-assert-conc

(defthm tree-list-listp-of-cst-assert-conc
  (b* ((abnf::cstss (cst-assert-conc abnf::cst)))
    (abnf::tree-list-listp abnf::cstss))
  :rule-classes :rewrite)

Theorem: cst-assert-conc-match

(defthm cst-assert-conc-match
 (implies
   (cst-matchp abnf::cst "assert")
   (b* ((abnf::cstss (cst-assert-conc abnf::cst)))
     (cst-list-list-conc-matchp abnf::cstss
                                "assert-op ws operand ws operand")))
 :rule-classes :rewrite)

Theorem: cst-assert-conc-of-tree-fix-cst

(defthm cst-assert-conc-of-tree-fix-cst
  (equal (cst-assert-conc (abnf::tree-fix abnf::cst))
         (cst-assert-conc abnf::cst)))

Theorem: cst-assert-conc-tree-equiv-congruence-on-cst

(defthm cst-assert-conc-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-assert-conc abnf::cst)
                  (cst-assert-conc cst-equiv)))
  :rule-classes :congruence)

Function: cst-commit-conc

(defun cst-commit-conc (abnf::cst)
  (declare (xargs :guard (abnf::treep abnf::cst)))
  (declare (xargs :guard (cst-matchp abnf::cst "commit")))
  (let ((__function__ 'cst-commit-conc))
    (declare (ignorable __function__))
    (abnf::tree-nonleaf->branches abnf::cst)))

Theorem: tree-list-listp-of-cst-commit-conc

(defthm tree-list-listp-of-cst-commit-conc
  (b* ((abnf::cstss (cst-commit-conc abnf::cst)))
    (abnf::tree-list-listp abnf::cstss))
  :rule-classes :rewrite)

Theorem: cst-commit-conc-match

(defthm cst-commit-conc-match
 (implies
  (cst-matchp abnf::cst "commit")
  (b* ((abnf::cstss (cst-commit-conc abnf::cst)))
   (cst-list-list-conc-matchp
        abnf::cstss
        "commit-op ws operand ws operand ws %s\"into\" ws register")))
 :rule-classes :rewrite)

Theorem: cst-commit-conc-of-tree-fix-cst

(defthm cst-commit-conc-of-tree-fix-cst
  (equal (cst-commit-conc (abnf::tree-fix abnf::cst))
         (cst-commit-conc abnf::cst)))

Theorem: cst-commit-conc-tree-equiv-congruence-on-cst

(defthm cst-commit-conc-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-commit-conc abnf::cst)
                  (cst-commit-conc cst-equiv)))
  :rule-classes :congruence)

Function: cst-hash-conc

(defun cst-hash-conc (abnf::cst)
  (declare (xargs :guard (abnf::treep abnf::cst)))
  (declare (xargs :guard (cst-matchp abnf::cst "hash")))
  (let ((__function__ 'cst-hash-conc))
    (declare (ignorable __function__))
    (abnf::tree-nonleaf->branches abnf::cst)))

Theorem: tree-list-listp-of-cst-hash-conc

(defthm tree-list-listp-of-cst-hash-conc
  (b* ((abnf::cstss (cst-hash-conc abnf::cst)))
    (abnf::tree-list-listp abnf::cstss))
  :rule-classes :rewrite)

Theorem: cst-hash-conc-match

(defthm cst-hash-conc-match
  (implies (cst-matchp abnf::cst "hash")
           (b* ((abnf::cstss (cst-hash-conc abnf::cst)))
             (cst-list-list-conc-matchp
                  abnf::cstss
                  "hash-op ws operand ws %s\"into\" ws register")))
  :rule-classes :rewrite)

Theorem: cst-hash-conc-of-tree-fix-cst

(defthm cst-hash-conc-of-tree-fix-cst
  (equal (cst-hash-conc (abnf::tree-fix abnf::cst))
         (cst-hash-conc abnf::cst)))

Theorem: cst-hash-conc-tree-equiv-congruence-on-cst

(defthm cst-hash-conc-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-hash-conc abnf::cst)
                  (cst-hash-conc cst-equiv)))
  :rule-classes :congruence)

Function: cst-cast-conc

(defun cst-cast-conc (abnf::cst)
  (declare (xargs :guard (abnf::treep abnf::cst)))
  (declare (xargs :guard (cst-matchp abnf::cst "cast")))
  (let ((__function__ 'cst-cast-conc))
    (declare (ignorable __function__))
    (abnf::tree-nonleaf->branches abnf::cst)))

Theorem: tree-list-listp-of-cst-cast-conc

(defthm tree-list-listp-of-cst-cast-conc
  (b* ((abnf::cstss (cst-cast-conc abnf::cst)))
    (abnf::tree-list-listp abnf::cstss))
  :rule-classes :rewrite)

Theorem: cst-cast-conc-match

(defthm cst-cast-conc-match
 (implies
  (cst-matchp abnf::cst "cast")
  (b* ((abnf::cstss (cst-cast-conc abnf::cst)))
   (cst-list-list-conc-matchp
    abnf::cstss
    "%s\"cast\" 1*( ws operand ) ws %s\"into\" ws register ws %s\"as\" ws register-type")))
 :rule-classes :rewrite)

Theorem: cst-cast-conc-of-tree-fix-cst

(defthm cst-cast-conc-of-tree-fix-cst
  (equal (cst-cast-conc (abnf::tree-fix abnf::cst))
         (cst-cast-conc abnf::cst)))

Theorem: cst-cast-conc-tree-equiv-congruence-on-cst

(defthm cst-cast-conc-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-cast-conc abnf::cst)
                  (cst-cast-conc cst-equiv)))
  :rule-classes :congruence)

Function: cst-call-conc

(defun cst-call-conc (abnf::cst)
  (declare (xargs :guard (abnf::treep abnf::cst)))
  (declare (xargs :guard (cst-matchp abnf::cst "call")))
  (let ((__function__ 'cst-call-conc))
    (declare (ignorable __function__))
    (abnf::tree-nonleaf->branches abnf::cst)))

Theorem: tree-list-listp-of-cst-call-conc

(defthm tree-list-listp-of-cst-call-conc
  (b* ((abnf::cstss (cst-call-conc abnf::cst)))
    (abnf::tree-list-listp abnf::cstss))
  :rule-classes :rewrite)

Theorem: cst-call-conc-match

(defthm cst-call-conc-match
 (implies
  (cst-matchp abnf::cst "call")
  (b* ((abnf::cstss (cst-call-conc abnf::cst)))
   (cst-list-list-conc-matchp
    abnf::cstss
    "%s\"call\" ws ( locator / identifier ) ws 1*( ws operand ) ws %s\"into\" ws 1*( ws register )")))
 :rule-classes :rewrite)

Theorem: cst-call-conc-of-tree-fix-cst

(defthm cst-call-conc-of-tree-fix-cst
  (equal (cst-call-conc (abnf::tree-fix abnf::cst))
         (cst-call-conc abnf::cst)))

Theorem: cst-call-conc-tree-equiv-congruence-on-cst

(defthm cst-call-conc-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-call-conc abnf::cst)
                  (cst-call-conc cst-equiv)))
  :rule-classes :congruence)

Function: cst-instruction-conc

(defun cst-instruction-conc (abnf::cst)
  (declare (xargs :guard (abnf::treep abnf::cst)))
  (declare (xargs :guard (cst-matchp abnf::cst "instruction")))
  (let ((__function__ 'cst-instruction-conc))
    (declare (ignorable __function__))
    (abnf::tree-nonleaf->branches abnf::cst)))

Theorem: tree-list-listp-of-cst-instruction-conc

(defthm tree-list-listp-of-cst-instruction-conc
  (b* ((abnf::cstss (cst-instruction-conc abnf::cst)))
    (abnf::tree-list-listp abnf::cstss))
  :rule-classes :rewrite)

Theorem: cst-instruction-conc-match

(defthm cst-instruction-conc-match
 (implies
  (cst-matchp abnf::cst "instruction")
  (b* ((abnf::cstss (cst-instruction-conc abnf::cst)))
   (cst-list-list-conc-matchp
    abnf::cstss
    "cws ( unary / binary / ternary / is / assert / commit / hash / cast / call ) ws \";\"")))
 :rule-classes :rewrite)

Theorem: cst-instruction-conc-of-tree-fix-cst

(defthm cst-instruction-conc-of-tree-fix-cst
  (equal (cst-instruction-conc (abnf::tree-fix abnf::cst))
         (cst-instruction-conc abnf::cst)))

Theorem: cst-instruction-conc-tree-equiv-congruence-on-cst

(defthm cst-instruction-conc-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-instruction-conc abnf::cst)
                  (cst-instruction-conc cst-equiv)))
  :rule-classes :congruence)

Function: cst-decrement-conc

(defun cst-decrement-conc (abnf::cst)
  (declare (xargs :guard (abnf::treep abnf::cst)))
  (declare (xargs :guard (cst-matchp abnf::cst "decrement")))
  (let ((__function__ 'cst-decrement-conc))
    (declare (ignorable __function__))
    (abnf::tree-nonleaf->branches abnf::cst)))

Theorem: tree-list-listp-of-cst-decrement-conc

(defthm tree-list-listp-of-cst-decrement-conc
  (b* ((abnf::cstss (cst-decrement-conc abnf::cst)))
    (abnf::tree-list-listp abnf::cstss))
  :rule-classes :rewrite)

Theorem: cst-decrement-conc-match

(defthm cst-decrement-conc-match
 (implies
  (cst-matchp abnf::cst "decrement")
  (b* ((abnf::cstss (cst-decrement-conc abnf::cst)))
   (cst-list-list-conc-matchp
    abnf::cstss
    "cws %s\"decrement\" ws identifier \"[\" ws operand ws \"]\" ws %s\"by\" ws operand ws \";\"")))
 :rule-classes :rewrite)

Theorem: cst-decrement-conc-of-tree-fix-cst

(defthm cst-decrement-conc-of-tree-fix-cst
  (equal (cst-decrement-conc (abnf::tree-fix abnf::cst))
         (cst-decrement-conc abnf::cst)))

Theorem: cst-decrement-conc-tree-equiv-congruence-on-cst

(defthm cst-decrement-conc-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-decrement-conc abnf::cst)
                  (cst-decrement-conc cst-equiv)))
  :rule-classes :congruence)

Function: cst-increment-conc

(defun cst-increment-conc (abnf::cst)
  (declare (xargs :guard (abnf::treep abnf::cst)))
  (declare (xargs :guard (cst-matchp abnf::cst "increment")))
  (let ((__function__ 'cst-increment-conc))
    (declare (ignorable __function__))
    (abnf::tree-nonleaf->branches abnf::cst)))

Theorem: tree-list-listp-of-cst-increment-conc

(defthm tree-list-listp-of-cst-increment-conc
  (b* ((abnf::cstss (cst-increment-conc abnf::cst)))
    (abnf::tree-list-listp abnf::cstss))
  :rule-classes :rewrite)

Theorem: cst-increment-conc-match

(defthm cst-increment-conc-match
 (implies
  (cst-matchp abnf::cst "increment")
  (b* ((abnf::cstss (cst-increment-conc abnf::cst)))
   (cst-list-list-conc-matchp
    abnf::cstss
    "cws %s\"increment\" ws identifier \"[\" ws operand ws \"]\" ws %s\"by\" ws operand ws \";\"")))
 :rule-classes :rewrite)

Theorem: cst-increment-conc-of-tree-fix-cst

(defthm cst-increment-conc-of-tree-fix-cst
  (equal (cst-increment-conc (abnf::tree-fix abnf::cst))
         (cst-increment-conc abnf::cst)))

Theorem: cst-increment-conc-tree-equiv-congruence-on-cst

(defthm cst-increment-conc-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-increment-conc abnf::cst)
                  (cst-increment-conc cst-equiv)))
  :rule-classes :congruence)

Function: cst-command-conc1

(defun cst-command-conc1 (abnf::cst)
  (declare (xargs :guard (abnf::treep abnf::cst)))
  (declare (xargs :guard (and (cst-matchp abnf::cst "command")
                              (equal (cst-command-conc? abnf::cst)
                                     1))))
  (let ((__function__ 'cst-command-conc1))
    (declare (ignorable __function__))
    (abnf::tree-nonleaf->branches abnf::cst)))

Theorem: tree-list-listp-of-cst-command-conc1

(defthm tree-list-listp-of-cst-command-conc1
  (b* ((abnf::cstss (cst-command-conc1 abnf::cst)))
    (abnf::tree-list-listp abnf::cstss))
  :rule-classes :rewrite)

Theorem: cst-command-conc1-match

(defthm cst-command-conc1-match
  (implies (and (cst-matchp abnf::cst "command")
                (equal (cst-command-conc? abnf::cst) 1))
           (b* ((abnf::cstss (cst-command-conc1 abnf::cst)))
             (cst-list-list-conc-matchp abnf::cstss "decrement")))
  :rule-classes :rewrite)

Theorem: cst-command-conc1-of-tree-fix-cst

(defthm cst-command-conc1-of-tree-fix-cst
  (equal (cst-command-conc1 (abnf::tree-fix abnf::cst))
         (cst-command-conc1 abnf::cst)))

Theorem: cst-command-conc1-tree-equiv-congruence-on-cst

(defthm cst-command-conc1-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-command-conc1 abnf::cst)
                  (cst-command-conc1 cst-equiv)))
  :rule-classes :congruence)

Function: cst-command-conc2

(defun cst-command-conc2 (abnf::cst)
  (declare (xargs :guard (abnf::treep abnf::cst)))
  (declare (xargs :guard (and (cst-matchp abnf::cst "command")
                              (equal (cst-command-conc? abnf::cst)
                                     2))))
  (let ((__function__ 'cst-command-conc2))
    (declare (ignorable __function__))
    (abnf::tree-nonleaf->branches abnf::cst)))

Theorem: tree-list-listp-of-cst-command-conc2

(defthm tree-list-listp-of-cst-command-conc2
  (b* ((abnf::cstss (cst-command-conc2 abnf::cst)))
    (abnf::tree-list-listp abnf::cstss))
  :rule-classes :rewrite)

Theorem: cst-command-conc2-match

(defthm cst-command-conc2-match
  (implies (and (cst-matchp abnf::cst "command")
                (equal (cst-command-conc? abnf::cst) 2))
           (b* ((abnf::cstss (cst-command-conc2 abnf::cst)))
             (cst-list-list-conc-matchp abnf::cstss "increment")))
  :rule-classes :rewrite)

Theorem: cst-command-conc2-of-tree-fix-cst

(defthm cst-command-conc2-of-tree-fix-cst
  (equal (cst-command-conc2 (abnf::tree-fix abnf::cst))
         (cst-command-conc2 abnf::cst)))

Theorem: cst-command-conc2-tree-equiv-congruence-on-cst

(defthm cst-command-conc2-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-command-conc2 abnf::cst)
                  (cst-command-conc2 cst-equiv)))
  :rule-classes :congruence)

Function: cst-command-conc3

(defun cst-command-conc3 (abnf::cst)
  (declare (xargs :guard (abnf::treep abnf::cst)))
  (declare (xargs :guard (and (cst-matchp abnf::cst "command")
                              (equal (cst-command-conc? abnf::cst)
                                     3))))
  (let ((__function__ 'cst-command-conc3))
    (declare (ignorable __function__))
    (abnf::tree-nonleaf->branches abnf::cst)))

Theorem: tree-list-listp-of-cst-command-conc3

(defthm tree-list-listp-of-cst-command-conc3
  (b* ((abnf::cstss (cst-command-conc3 abnf::cst)))
    (abnf::tree-list-listp abnf::cstss))
  :rule-classes :rewrite)

Theorem: cst-command-conc3-match

(defthm cst-command-conc3-match
  (implies (and (cst-matchp abnf::cst "command")
                (equal (cst-command-conc? abnf::cst) 3))
           (b* ((abnf::cstss (cst-command-conc3 abnf::cst)))
             (cst-list-list-conc-matchp abnf::cstss "instruction")))
  :rule-classes :rewrite)

Theorem: cst-command-conc3-of-tree-fix-cst

(defthm cst-command-conc3-of-tree-fix-cst
  (equal (cst-command-conc3 (abnf::tree-fix abnf::cst))
         (cst-command-conc3 abnf::cst)))

Theorem: cst-command-conc3-tree-equiv-congruence-on-cst

(defthm cst-command-conc3-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-command-conc3 abnf::cst)
                  (cst-command-conc3 cst-equiv)))
  :rule-classes :congruence)

Function: cst-finalize-command-conc

(defun cst-finalize-command-conc (abnf::cst)
  (declare (xargs :guard (abnf::treep abnf::cst)))
  (declare (xargs :guard (cst-matchp abnf::cst "finalize-command")))
  (let ((__function__ 'cst-finalize-command-conc))
    (declare (ignorable __function__))
    (abnf::tree-nonleaf->branches abnf::cst)))

Theorem: tree-list-listp-of-cst-finalize-command-conc

(defthm tree-list-listp-of-cst-finalize-command-conc
  (b* ((abnf::cstss (cst-finalize-command-conc abnf::cst)))
    (abnf::tree-list-listp abnf::cstss))
  :rule-classes :rewrite)

Theorem: cst-finalize-command-conc-match

(defthm cst-finalize-command-conc-match
  (implies (cst-matchp abnf::cst "finalize-command")
           (b* ((abnf::cstss (cst-finalize-command-conc abnf::cst)))
             (cst-list-list-conc-matchp
                  abnf::cstss
                  "cws %s\"finalize\" *( ws operand ) ws \";\"")))
  :rule-classes :rewrite)

Theorem: cst-finalize-command-conc-of-tree-fix-cst

(defthm cst-finalize-command-conc-of-tree-fix-cst
  (equal (cst-finalize-command-conc (abnf::tree-fix abnf::cst))
         (cst-finalize-command-conc abnf::cst)))

Theorem: cst-finalize-command-conc-tree-equiv-congruence-on-cst

(defthm cst-finalize-command-conc-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-finalize-command-conc abnf::cst)
                  (cst-finalize-command-conc cst-equiv)))
  :rule-classes :congruence)

Function: cst-function-conc

(defun cst-function-conc (abnf::cst)
  (declare (xargs :guard (abnf::treep abnf::cst)))
  (declare (xargs :guard (cst-matchp abnf::cst "function")))
  (let ((__function__ 'cst-function-conc))
    (declare (ignorable __function__))
    (abnf::tree-nonleaf->branches abnf::cst)))

Theorem: tree-list-listp-of-cst-function-conc

(defthm tree-list-listp-of-cst-function-conc
  (b* ((abnf::cstss (cst-function-conc abnf::cst)))
    (abnf::tree-list-listp abnf::cstss))
  :rule-classes :rewrite)

Theorem: cst-function-conc-match

(defthm cst-function-conc-match
 (implies
  (cst-matchp abnf::cst "function")
  (b* ((abnf::cstss (cst-function-conc abnf::cst)))
   (cst-list-list-conc-matchp
    abnf::cstss
    "cws %s\"function\" ws identifier ws \":\" *function-input 1*instruction *function-output")))
 :rule-classes :rewrite)

Theorem: cst-function-conc-of-tree-fix-cst

(defthm cst-function-conc-of-tree-fix-cst
  (equal (cst-function-conc (abnf::tree-fix abnf::cst))
         (cst-function-conc abnf::cst)))

Theorem: cst-function-conc-tree-equiv-congruence-on-cst

(defthm cst-function-conc-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-function-conc abnf::cst)
                  (cst-function-conc cst-equiv)))
  :rule-classes :congruence)

Function: cst-function-input-conc

(defun cst-function-input-conc (abnf::cst)
  (declare (xargs :guard (abnf::treep abnf::cst)))
  (declare (xargs :guard (cst-matchp abnf::cst "function-input")))
  (let ((__function__ 'cst-function-input-conc))
    (declare (ignorable __function__))
    (abnf::tree-nonleaf->branches abnf::cst)))

Theorem: tree-list-listp-of-cst-function-input-conc

(defthm tree-list-listp-of-cst-function-input-conc
  (b* ((abnf::cstss (cst-function-input-conc abnf::cst)))
    (abnf::tree-list-listp abnf::cstss))
  :rule-classes :rewrite)

Theorem: cst-function-input-conc-match

(defthm cst-function-input-conc-match
 (implies
  (cst-matchp abnf::cst "function-input")
  (b* ((abnf::cstss (cst-function-input-conc abnf::cst)))
   (cst-list-list-conc-matchp
    abnf::cstss
    "cws %s\"input\" ws register ws %s\"as\" ws register-type ws \";\"")))
 :rule-classes :rewrite)

Theorem: cst-function-input-conc-of-tree-fix-cst

(defthm cst-function-input-conc-of-tree-fix-cst
  (equal (cst-function-input-conc (abnf::tree-fix abnf::cst))
         (cst-function-input-conc abnf::cst)))

Theorem: cst-function-input-conc-tree-equiv-congruence-on-cst

(defthm cst-function-input-conc-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-function-input-conc abnf::cst)
                  (cst-function-input-conc cst-equiv)))
  :rule-classes :congruence)

Function: cst-function-output-conc

(defun cst-function-output-conc (abnf::cst)
  (declare (xargs :guard (abnf::treep abnf::cst)))
  (declare (xargs :guard (cst-matchp abnf::cst "function-output")))
  (let ((__function__ 'cst-function-output-conc))
    (declare (ignorable __function__))
    (abnf::tree-nonleaf->branches abnf::cst)))

Theorem: tree-list-listp-of-cst-function-output-conc

(defthm tree-list-listp-of-cst-function-output-conc
  (b* ((abnf::cstss (cst-function-output-conc abnf::cst)))
    (abnf::tree-list-listp abnf::cstss))
  :rule-classes :rewrite)

Theorem: cst-function-output-conc-match

(defthm cst-function-output-conc-match
 (implies
  (cst-matchp abnf::cst "function-output")
  (b* ((abnf::cstss (cst-function-output-conc abnf::cst)))
   (cst-list-list-conc-matchp
    abnf::cstss
    "cws %s\"output\" ws register-access ws %s\"as\" ws register-type ws \";\"")))
 :rule-classes :rewrite)

Theorem: cst-function-output-conc-of-tree-fix-cst

(defthm cst-function-output-conc-of-tree-fix-cst
  (equal (cst-function-output-conc (abnf::tree-fix abnf::cst))
         (cst-function-output-conc abnf::cst)))

Theorem: cst-function-output-conc-tree-equiv-congruence-on-cst

(defthm cst-function-output-conc-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-function-output-conc abnf::cst)
                  (cst-function-output-conc cst-equiv)))
  :rule-classes :congruence)

Function: cst-transition-conc

(defun cst-transition-conc (abnf::cst)
  (declare (xargs :guard (abnf::treep abnf::cst)))
  (declare (xargs :guard (cst-matchp abnf::cst "transition")))
  (let ((__function__ 'cst-transition-conc))
    (declare (ignorable __function__))
    (abnf::tree-nonleaf->branches abnf::cst)))

Theorem: tree-list-listp-of-cst-transition-conc

(defthm tree-list-listp-of-cst-transition-conc
  (b* ((abnf::cstss (cst-transition-conc abnf::cst)))
    (abnf::tree-list-listp abnf::cstss))
  :rule-classes :rewrite)

Theorem: cst-transition-conc-match

(defthm cst-transition-conc-match
 (implies
  (cst-matchp abnf::cst "transition")
  (b* ((abnf::cstss (cst-transition-conc abnf::cst)))
   (cst-list-list-conc-matchp
    abnf::cstss
    "cws %s\"transition\" ws identifier ws \":\" *transition-input *instruction *transition-output [ finalize-command finalize ]")))
 :rule-classes :rewrite)

Theorem: cst-transition-conc-of-tree-fix-cst

(defthm cst-transition-conc-of-tree-fix-cst
  (equal (cst-transition-conc (abnf::tree-fix abnf::cst))
         (cst-transition-conc abnf::cst)))

Theorem: cst-transition-conc-tree-equiv-congruence-on-cst

(defthm cst-transition-conc-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-transition-conc abnf::cst)
                  (cst-transition-conc cst-equiv)))
  :rule-classes :congruence)

Function: cst-transition-input-conc

(defun cst-transition-input-conc (abnf::cst)
  (declare (xargs :guard (abnf::treep abnf::cst)))
  (declare (xargs :guard (cst-matchp abnf::cst "transition-input")))
  (let ((__function__ 'cst-transition-input-conc))
    (declare (ignorable __function__))
    (abnf::tree-nonleaf->branches abnf::cst)))

Theorem: tree-list-listp-of-cst-transition-input-conc

(defthm tree-list-listp-of-cst-transition-input-conc
  (b* ((abnf::cstss (cst-transition-input-conc abnf::cst)))
    (abnf::tree-list-listp abnf::cstss))
  :rule-classes :rewrite)

Theorem: cst-transition-input-conc-match

(defthm cst-transition-input-conc-match
 (implies
  (cst-matchp abnf::cst "transition-input")
  (b* ((abnf::cstss (cst-transition-input-conc abnf::cst)))
   (cst-list-list-conc-matchp
       abnf::cstss
       "cws %s\"input\" ws register ws %s\"as\" ws value-type ws \";\"")))
 :rule-classes :rewrite)

Theorem: cst-transition-input-conc-of-tree-fix-cst

(defthm cst-transition-input-conc-of-tree-fix-cst
  (equal (cst-transition-input-conc (abnf::tree-fix abnf::cst))
         (cst-transition-input-conc abnf::cst)))

Theorem: cst-transition-input-conc-tree-equiv-congruence-on-cst

(defthm cst-transition-input-conc-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-transition-input-conc abnf::cst)
                  (cst-transition-input-conc cst-equiv)))
  :rule-classes :congruence)

Function: cst-transition-output-conc

(defun cst-transition-output-conc (abnf::cst)
 (declare (xargs :guard (abnf::treep abnf::cst)))
 (declare (xargs :guard (cst-matchp abnf::cst "transition-output")))
 (let ((__function__ 'cst-transition-output-conc))
   (declare (ignorable __function__))
   (abnf::tree-nonleaf->branches abnf::cst)))

Theorem: tree-list-listp-of-cst-transition-output-conc

(defthm tree-list-listp-of-cst-transition-output-conc
  (b* ((abnf::cstss (cst-transition-output-conc abnf::cst)))
    (abnf::tree-list-listp abnf::cstss))
  :rule-classes :rewrite)

Theorem: cst-transition-output-conc-match

(defthm cst-transition-output-conc-match
 (implies
  (cst-matchp abnf::cst "transition-output")
  (b* ((abnf::cstss (cst-transition-output-conc abnf::cst)))
   (cst-list-list-conc-matchp
    abnf::cstss
    "cws %s\"output\" ws register-access ws %s\"as\" ws value-type ws \";\"")))
 :rule-classes :rewrite)

Theorem: cst-transition-output-conc-of-tree-fix-cst

(defthm cst-transition-output-conc-of-tree-fix-cst
  (equal (cst-transition-output-conc (abnf::tree-fix abnf::cst))
         (cst-transition-output-conc abnf::cst)))

Theorem: cst-transition-output-conc-tree-equiv-congruence-on-cst

(defthm cst-transition-output-conc-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-transition-output-conc abnf::cst)
                  (cst-transition-output-conc cst-equiv)))
  :rule-classes :congruence)

Function: cst-finalize-conc

(defun cst-finalize-conc (abnf::cst)
  (declare (xargs :guard (abnf::treep abnf::cst)))
  (declare (xargs :guard (cst-matchp abnf::cst "finalize")))
  (let ((__function__ 'cst-finalize-conc))
    (declare (ignorable __function__))
    (abnf::tree-nonleaf->branches abnf::cst)))

Theorem: tree-list-listp-of-cst-finalize-conc

(defthm tree-list-listp-of-cst-finalize-conc
  (b* ((abnf::cstss (cst-finalize-conc abnf::cst)))
    (abnf::tree-list-listp abnf::cstss))
  :rule-classes :rewrite)

Theorem: cst-finalize-conc-match

(defthm cst-finalize-conc-match
 (implies
  (cst-matchp abnf::cst "finalize")
  (b* ((abnf::cstss (cst-finalize-conc abnf::cst)))
   (cst-list-list-conc-matchp
    abnf::cstss
    "cws %s\"finalize\" ws identifier ws \":\" *finalize-input 1*command *finalize-output")))
 :rule-classes :rewrite)

Theorem: cst-finalize-conc-of-tree-fix-cst

(defthm cst-finalize-conc-of-tree-fix-cst
  (equal (cst-finalize-conc (abnf::tree-fix abnf::cst))
         (cst-finalize-conc abnf::cst)))

Theorem: cst-finalize-conc-tree-equiv-congruence-on-cst

(defthm cst-finalize-conc-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-finalize-conc abnf::cst)
                  (cst-finalize-conc cst-equiv)))
  :rule-classes :congruence)

Function: cst-finalize-input-conc

(defun cst-finalize-input-conc (abnf::cst)
  (declare (xargs :guard (abnf::treep abnf::cst)))
  (declare (xargs :guard (cst-matchp abnf::cst "finalize-input")))
  (let ((__function__ 'cst-finalize-input-conc))
    (declare (ignorable __function__))
    (abnf::tree-nonleaf->branches abnf::cst)))

Theorem: tree-list-listp-of-cst-finalize-input-conc

(defthm tree-list-listp-of-cst-finalize-input-conc
  (b* ((abnf::cstss (cst-finalize-input-conc abnf::cst)))
    (abnf::tree-list-listp abnf::cstss))
  :rule-classes :rewrite)

Theorem: cst-finalize-input-conc-match

(defthm cst-finalize-input-conc-match
 (implies
  (cst-matchp abnf::cst "finalize-input")
  (b* ((abnf::cstss (cst-finalize-input-conc abnf::cst)))
   (cst-list-list-conc-matchp
    abnf::cstss
    "cws %s\"input\" ws register ws %s\"as\" ws finalize-type ws \";\"")))
 :rule-classes :rewrite)

Theorem: cst-finalize-input-conc-of-tree-fix-cst

(defthm cst-finalize-input-conc-of-tree-fix-cst
  (equal (cst-finalize-input-conc (abnf::tree-fix abnf::cst))
         (cst-finalize-input-conc abnf::cst)))

Theorem: cst-finalize-input-conc-tree-equiv-congruence-on-cst

(defthm cst-finalize-input-conc-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-finalize-input-conc abnf::cst)
                  (cst-finalize-input-conc cst-equiv)))
  :rule-classes :congruence)

Function: cst-finalize-output-conc

(defun cst-finalize-output-conc (abnf::cst)
  (declare (xargs :guard (abnf::treep abnf::cst)))
  (declare (xargs :guard (cst-matchp abnf::cst "finalize-output")))
  (let ((__function__ 'cst-finalize-output-conc))
    (declare (ignorable __function__))
    (abnf::tree-nonleaf->branches abnf::cst)))

Theorem: tree-list-listp-of-cst-finalize-output-conc

(defthm tree-list-listp-of-cst-finalize-output-conc
  (b* ((abnf::cstss (cst-finalize-output-conc abnf::cst)))
    (abnf::tree-list-listp abnf::cstss))
  :rule-classes :rewrite)

Theorem: cst-finalize-output-conc-match

(defthm cst-finalize-output-conc-match
 (implies
  (cst-matchp abnf::cst "finalize-output")
  (b* ((abnf::cstss (cst-finalize-output-conc abnf::cst)))
   (cst-list-list-conc-matchp
    abnf::cstss
    "cws %s\"output\" ws register-access ws %s\"as\" ws finalize-type ws \";\"")))
 :rule-classes :rewrite)

Theorem: cst-finalize-output-conc-of-tree-fix-cst

(defthm cst-finalize-output-conc-of-tree-fix-cst
  (equal (cst-finalize-output-conc (abnf::tree-fix abnf::cst))
         (cst-finalize-output-conc abnf::cst)))

Theorem: cst-finalize-output-conc-tree-equiv-congruence-on-cst

(defthm cst-finalize-output-conc-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-finalize-output-conc abnf::cst)
                  (cst-finalize-output-conc cst-equiv)))
  :rule-classes :congruence)

Function: cst-program-conc

(defun cst-program-conc (abnf::cst)
  (declare (xargs :guard (abnf::treep abnf::cst)))
  (declare (xargs :guard (cst-matchp abnf::cst "program")))
  (let ((__function__ 'cst-program-conc))
    (declare (ignorable __function__))
    (abnf::tree-nonleaf->branches abnf::cst)))

Theorem: tree-list-listp-of-cst-program-conc

(defthm tree-list-listp-of-cst-program-conc
  (b* ((abnf::cstss (cst-program-conc abnf::cst)))
    (abnf::tree-list-listp abnf::cstss))
  :rule-classes :rewrite)

Theorem: cst-program-conc-match

(defthm cst-program-conc-match
 (implies
  (cst-matchp abnf::cst "program")
  (b* ((abnf::cstss (cst-program-conc abnf::cst)))
   (cst-list-list-conc-matchp
    abnf::cstss
    "*import cws %s\"program\" ws program-id ws \";\" 1*( mapping / struct / record / function / transition ) cws")))
 :rule-classes :rewrite)

Theorem: cst-program-conc-of-tree-fix-cst

(defthm cst-program-conc-of-tree-fix-cst
  (equal (cst-program-conc (abnf::tree-fix abnf::cst))
         (cst-program-conc abnf::cst)))

Theorem: cst-program-conc-tree-equiv-congruence-on-cst

(defthm cst-program-conc-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-program-conc abnf::cst)
                  (cst-program-conc cst-equiv)))
  :rule-classes :congruence)

Function: cst-ht-conc-rep

(defun cst-ht-conc-rep (abnf::cst)
  (declare (xargs :guard (abnf::treep abnf::cst)))
  (declare (xargs :guard (cst-matchp abnf::cst "ht")))
  (let ((__function__ 'cst-ht-conc-rep))
    (declare (ignorable __function__))
    (abnf::tree-list-fix (nth 0 (cst-ht-conc abnf::cst)))))

Theorem: tree-listp-of-cst-ht-conc-rep

(defthm tree-listp-of-cst-ht-conc-rep
  (b* ((abnf::csts (cst-ht-conc-rep abnf::cst)))
    (abnf::tree-listp abnf::csts))
  :rule-classes :rewrite)

Theorem: cst-ht-conc-rep-match

(defthm cst-ht-conc-rep-match
  (implies (cst-matchp abnf::cst "ht")
           (b* ((abnf::csts (cst-ht-conc-rep abnf::cst)))
             (cst-list-rep-matchp abnf::csts "%x9")))
  :rule-classes :rewrite)

Theorem: cst-ht-conc-rep-of-tree-fix-cst

(defthm cst-ht-conc-rep-of-tree-fix-cst
  (equal (cst-ht-conc-rep (abnf::tree-fix abnf::cst))
         (cst-ht-conc-rep abnf::cst)))

Theorem: cst-ht-conc-rep-tree-equiv-congruence-on-cst

(defthm cst-ht-conc-rep-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-ht-conc-rep abnf::cst)
                  (cst-ht-conc-rep cst-equiv)))
  :rule-classes :congruence)

Function: cst-lf-conc-rep

(defun cst-lf-conc-rep (abnf::cst)
  (declare (xargs :guard (abnf::treep abnf::cst)))
  (declare (xargs :guard (cst-matchp abnf::cst "lf")))
  (let ((__function__ 'cst-lf-conc-rep))
    (declare (ignorable __function__))
    (abnf::tree-list-fix (nth 0 (cst-lf-conc abnf::cst)))))

Theorem: tree-listp-of-cst-lf-conc-rep

(defthm tree-listp-of-cst-lf-conc-rep
  (b* ((abnf::csts (cst-lf-conc-rep abnf::cst)))
    (abnf::tree-listp abnf::csts))
  :rule-classes :rewrite)

Theorem: cst-lf-conc-rep-match

(defthm cst-lf-conc-rep-match
  (implies (cst-matchp abnf::cst "lf")
           (b* ((abnf::csts (cst-lf-conc-rep abnf::cst)))
             (cst-list-rep-matchp abnf::csts "%xA")))
  :rule-classes :rewrite)

Theorem: cst-lf-conc-rep-of-tree-fix-cst

(defthm cst-lf-conc-rep-of-tree-fix-cst
  (equal (cst-lf-conc-rep (abnf::tree-fix abnf::cst))
         (cst-lf-conc-rep abnf::cst)))

Theorem: cst-lf-conc-rep-tree-equiv-congruence-on-cst

(defthm cst-lf-conc-rep-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-lf-conc-rep abnf::cst)
                  (cst-lf-conc-rep cst-equiv)))
  :rule-classes :congruence)

Function: cst-cr-conc-rep

(defun cst-cr-conc-rep (abnf::cst)
  (declare (xargs :guard (abnf::treep abnf::cst)))
  (declare (xargs :guard (cst-matchp abnf::cst "cr")))
  (let ((__function__ 'cst-cr-conc-rep))
    (declare (ignorable __function__))
    (abnf::tree-list-fix (nth 0 (cst-cr-conc abnf::cst)))))

Theorem: tree-listp-of-cst-cr-conc-rep

(defthm tree-listp-of-cst-cr-conc-rep
  (b* ((abnf::csts (cst-cr-conc-rep abnf::cst)))
    (abnf::tree-listp abnf::csts))
  :rule-classes :rewrite)

Theorem: cst-cr-conc-rep-match

(defthm cst-cr-conc-rep-match
  (implies (cst-matchp abnf::cst "cr")
           (b* ((abnf::csts (cst-cr-conc-rep abnf::cst)))
             (cst-list-rep-matchp abnf::csts "%xD")))
  :rule-classes :rewrite)

Theorem: cst-cr-conc-rep-of-tree-fix-cst

(defthm cst-cr-conc-rep-of-tree-fix-cst
  (equal (cst-cr-conc-rep (abnf::tree-fix abnf::cst))
         (cst-cr-conc-rep abnf::cst)))

Theorem: cst-cr-conc-rep-tree-equiv-congruence-on-cst

(defthm cst-cr-conc-rep-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-cr-conc-rep abnf::cst)
                  (cst-cr-conc-rep cst-equiv)))
  :rule-classes :congruence)

Function: cst-sp-conc-rep

(defun cst-sp-conc-rep (abnf::cst)
  (declare (xargs :guard (abnf::treep abnf::cst)))
  (declare (xargs :guard (cst-matchp abnf::cst "sp")))
  (let ((__function__ 'cst-sp-conc-rep))
    (declare (ignorable __function__))
    (abnf::tree-list-fix (nth 0 (cst-sp-conc abnf::cst)))))

Theorem: tree-listp-of-cst-sp-conc-rep

(defthm tree-listp-of-cst-sp-conc-rep
  (b* ((abnf::csts (cst-sp-conc-rep abnf::cst)))
    (abnf::tree-listp abnf::csts))
  :rule-classes :rewrite)

Theorem: cst-sp-conc-rep-match

(defthm cst-sp-conc-rep-match
  (implies (cst-matchp abnf::cst "sp")
           (b* ((abnf::csts (cst-sp-conc-rep abnf::cst)))
             (cst-list-rep-matchp abnf::csts "%x20")))
  :rule-classes :rewrite)

Theorem: cst-sp-conc-rep-of-tree-fix-cst

(defthm cst-sp-conc-rep-of-tree-fix-cst
  (equal (cst-sp-conc-rep (abnf::tree-fix abnf::cst))
         (cst-sp-conc-rep abnf::cst)))

Theorem: cst-sp-conc-rep-tree-equiv-congruence-on-cst

(defthm cst-sp-conc-rep-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-sp-conc-rep abnf::cst)
                  (cst-sp-conc-rep cst-equiv)))
  :rule-classes :congruence)

Function: cst-dq-conc-rep

(defun cst-dq-conc-rep (abnf::cst)
  (declare (xargs :guard (abnf::treep abnf::cst)))
  (declare (xargs :guard (cst-matchp abnf::cst "dq")))
  (let ((__function__ 'cst-dq-conc-rep))
    (declare (ignorable __function__))
    (abnf::tree-list-fix (nth 0 (cst-dq-conc abnf::cst)))))

Theorem: tree-listp-of-cst-dq-conc-rep

(defthm tree-listp-of-cst-dq-conc-rep
  (b* ((abnf::csts (cst-dq-conc-rep abnf::cst)))
    (abnf::tree-listp abnf::csts))
  :rule-classes :rewrite)

Theorem: cst-dq-conc-rep-match

(defthm cst-dq-conc-rep-match
  (implies (cst-matchp abnf::cst "dq")
           (b* ((abnf::csts (cst-dq-conc-rep abnf::cst)))
             (cst-list-rep-matchp abnf::csts "%x22")))
  :rule-classes :rewrite)

Theorem: cst-dq-conc-rep-of-tree-fix-cst

(defthm cst-dq-conc-rep-of-tree-fix-cst
  (equal (cst-dq-conc-rep (abnf::tree-fix abnf::cst))
         (cst-dq-conc-rep abnf::cst)))

Theorem: cst-dq-conc-rep-tree-equiv-congruence-on-cst

(defthm cst-dq-conc-rep-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-dq-conc-rep abnf::cst)
                  (cst-dq-conc-rep cst-equiv)))
  :rule-classes :congruence)

Function: cst-visible-ascii-conc-rep

(defun cst-visible-ascii-conc-rep (abnf::cst)
 (declare (xargs :guard (abnf::treep abnf::cst)))
 (declare (xargs :guard (cst-matchp abnf::cst "visible-ascii")))
 (let ((__function__ 'cst-visible-ascii-conc-rep))
  (declare (ignorable __function__))
  (abnf::tree-list-fix (nth 0 (cst-visible-ascii-conc abnf::cst)))))

Theorem: tree-listp-of-cst-visible-ascii-conc-rep

(defthm tree-listp-of-cst-visible-ascii-conc-rep
  (b* ((abnf::csts (cst-visible-ascii-conc-rep abnf::cst)))
    (abnf::tree-listp abnf::csts))
  :rule-classes :rewrite)

Theorem: cst-visible-ascii-conc-rep-match

(defthm cst-visible-ascii-conc-rep-match
  (implies (cst-matchp abnf::cst "visible-ascii")
           (b* ((abnf::csts (cst-visible-ascii-conc-rep abnf::cst)))
             (cst-list-rep-matchp abnf::csts "%x21-7E")))
  :rule-classes :rewrite)

Theorem: cst-visible-ascii-conc-rep-of-tree-fix-cst

(defthm cst-visible-ascii-conc-rep-of-tree-fix-cst
  (equal (cst-visible-ascii-conc-rep (abnf::tree-fix abnf::cst))
         (cst-visible-ascii-conc-rep abnf::cst)))

Theorem: cst-visible-ascii-conc-rep-tree-equiv-congruence-on-cst

(defthm cst-visible-ascii-conc-rep-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-visible-ascii-conc-rep abnf::cst)
                  (cst-visible-ascii-conc-rep cst-equiv)))
  :rule-classes :congruence)

Function: cst-safe-ascii-conc1-rep

(defun cst-safe-ascii-conc1-rep (abnf::cst)
 (declare (xargs :guard (abnf::treep abnf::cst)))
 (declare (xargs :guard (and (cst-matchp abnf::cst "safe-ascii")
                             (equal (cst-safe-ascii-conc? abnf::cst)
                                    1))))
 (let ((__function__ 'cst-safe-ascii-conc1-rep))
   (declare (ignorable __function__))
   (abnf::tree-list-fix (nth 0 (cst-safe-ascii-conc1 abnf::cst)))))

Theorem: tree-listp-of-cst-safe-ascii-conc1-rep

(defthm tree-listp-of-cst-safe-ascii-conc1-rep
  (b* ((abnf::csts (cst-safe-ascii-conc1-rep abnf::cst)))
    (abnf::tree-listp abnf::csts))
  :rule-classes :rewrite)

Theorem: cst-safe-ascii-conc1-rep-match

(defthm cst-safe-ascii-conc1-rep-match
  (implies (and (cst-matchp abnf::cst "safe-ascii")
                (equal (cst-safe-ascii-conc? abnf::cst)
                       1))
           (b* ((abnf::csts (cst-safe-ascii-conc1-rep abnf::cst)))
             (cst-list-rep-matchp abnf::csts "ht")))
  :rule-classes :rewrite)

Theorem: cst-safe-ascii-conc1-rep-of-tree-fix-cst

(defthm cst-safe-ascii-conc1-rep-of-tree-fix-cst
  (equal (cst-safe-ascii-conc1-rep (abnf::tree-fix abnf::cst))
         (cst-safe-ascii-conc1-rep abnf::cst)))

Theorem: cst-safe-ascii-conc1-rep-tree-equiv-congruence-on-cst

(defthm cst-safe-ascii-conc1-rep-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-safe-ascii-conc1-rep abnf::cst)
                  (cst-safe-ascii-conc1-rep cst-equiv)))
  :rule-classes :congruence)

Function: cst-safe-ascii-conc2-rep

(defun cst-safe-ascii-conc2-rep (abnf::cst)
 (declare (xargs :guard (abnf::treep abnf::cst)))
 (declare (xargs :guard (and (cst-matchp abnf::cst "safe-ascii")
                             (equal (cst-safe-ascii-conc? abnf::cst)
                                    2))))
 (let ((__function__ 'cst-safe-ascii-conc2-rep))
   (declare (ignorable __function__))
   (abnf::tree-list-fix (nth 0 (cst-safe-ascii-conc2 abnf::cst)))))

Theorem: tree-listp-of-cst-safe-ascii-conc2-rep

(defthm tree-listp-of-cst-safe-ascii-conc2-rep
  (b* ((abnf::csts (cst-safe-ascii-conc2-rep abnf::cst)))
    (abnf::tree-listp abnf::csts))
  :rule-classes :rewrite)

Theorem: cst-safe-ascii-conc2-rep-match

(defthm cst-safe-ascii-conc2-rep-match
  (implies (and (cst-matchp abnf::cst "safe-ascii")
                (equal (cst-safe-ascii-conc? abnf::cst)
                       2))
           (b* ((abnf::csts (cst-safe-ascii-conc2-rep abnf::cst)))
             (cst-list-rep-matchp abnf::csts "lf")))
  :rule-classes :rewrite)

Theorem: cst-safe-ascii-conc2-rep-of-tree-fix-cst

(defthm cst-safe-ascii-conc2-rep-of-tree-fix-cst
  (equal (cst-safe-ascii-conc2-rep (abnf::tree-fix abnf::cst))
         (cst-safe-ascii-conc2-rep abnf::cst)))

Theorem: cst-safe-ascii-conc2-rep-tree-equiv-congruence-on-cst

(defthm cst-safe-ascii-conc2-rep-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-safe-ascii-conc2-rep abnf::cst)
                  (cst-safe-ascii-conc2-rep cst-equiv)))
  :rule-classes :congruence)

Function: cst-safe-ascii-conc3-rep

(defun cst-safe-ascii-conc3-rep (abnf::cst)
 (declare (xargs :guard (abnf::treep abnf::cst)))
 (declare (xargs :guard (and (cst-matchp abnf::cst "safe-ascii")
                             (equal (cst-safe-ascii-conc? abnf::cst)
                                    3))))
 (let ((__function__ 'cst-safe-ascii-conc3-rep))
   (declare (ignorable __function__))
   (abnf::tree-list-fix (nth 0 (cst-safe-ascii-conc3 abnf::cst)))))

Theorem: tree-listp-of-cst-safe-ascii-conc3-rep

(defthm tree-listp-of-cst-safe-ascii-conc3-rep
  (b* ((abnf::csts (cst-safe-ascii-conc3-rep abnf::cst)))
    (abnf::tree-listp abnf::csts))
  :rule-classes :rewrite)

Theorem: cst-safe-ascii-conc3-rep-match

(defthm cst-safe-ascii-conc3-rep-match
  (implies (and (cst-matchp abnf::cst "safe-ascii")
                (equal (cst-safe-ascii-conc? abnf::cst)
                       3))
           (b* ((abnf::csts (cst-safe-ascii-conc3-rep abnf::cst)))
             (cst-list-rep-matchp abnf::csts "cr")))
  :rule-classes :rewrite)

Theorem: cst-safe-ascii-conc3-rep-of-tree-fix-cst

(defthm cst-safe-ascii-conc3-rep-of-tree-fix-cst
  (equal (cst-safe-ascii-conc3-rep (abnf::tree-fix abnf::cst))
         (cst-safe-ascii-conc3-rep abnf::cst)))

Theorem: cst-safe-ascii-conc3-rep-tree-equiv-congruence-on-cst

(defthm cst-safe-ascii-conc3-rep-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-safe-ascii-conc3-rep abnf::cst)
                  (cst-safe-ascii-conc3-rep cst-equiv)))
  :rule-classes :congruence)

Function: cst-safe-ascii-conc4-rep

(defun cst-safe-ascii-conc4-rep (abnf::cst)
 (declare (xargs :guard (abnf::treep abnf::cst)))
 (declare (xargs :guard (and (cst-matchp abnf::cst "safe-ascii")
                             (equal (cst-safe-ascii-conc? abnf::cst)
                                    4))))
 (let ((__function__ 'cst-safe-ascii-conc4-rep))
   (declare (ignorable __function__))
   (abnf::tree-list-fix (nth 0 (cst-safe-ascii-conc4 abnf::cst)))))

Theorem: tree-listp-of-cst-safe-ascii-conc4-rep

(defthm tree-listp-of-cst-safe-ascii-conc4-rep
  (b* ((abnf::csts (cst-safe-ascii-conc4-rep abnf::cst)))
    (abnf::tree-listp abnf::csts))
  :rule-classes :rewrite)

Theorem: cst-safe-ascii-conc4-rep-match

(defthm cst-safe-ascii-conc4-rep-match
  (implies (and (cst-matchp abnf::cst "safe-ascii")
                (equal (cst-safe-ascii-conc? abnf::cst)
                       4))
           (b* ((abnf::csts (cst-safe-ascii-conc4-rep abnf::cst)))
             (cst-list-rep-matchp abnf::csts "sp")))
  :rule-classes :rewrite)

Theorem: cst-safe-ascii-conc4-rep-of-tree-fix-cst

(defthm cst-safe-ascii-conc4-rep-of-tree-fix-cst
  (equal (cst-safe-ascii-conc4-rep (abnf::tree-fix abnf::cst))
         (cst-safe-ascii-conc4-rep abnf::cst)))

Theorem: cst-safe-ascii-conc4-rep-tree-equiv-congruence-on-cst

(defthm cst-safe-ascii-conc4-rep-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-safe-ascii-conc4-rep abnf::cst)
                  (cst-safe-ascii-conc4-rep cst-equiv)))
  :rule-classes :congruence)

Function: cst-safe-ascii-conc5-rep

(defun cst-safe-ascii-conc5-rep (abnf::cst)
 (declare (xargs :guard (abnf::treep abnf::cst)))
 (declare (xargs :guard (and (cst-matchp abnf::cst "safe-ascii")
                             (equal (cst-safe-ascii-conc? abnf::cst)
                                    5))))
 (let ((__function__ 'cst-safe-ascii-conc5-rep))
   (declare (ignorable __function__))
   (abnf::tree-list-fix (nth 0 (cst-safe-ascii-conc5 abnf::cst)))))

Theorem: tree-listp-of-cst-safe-ascii-conc5-rep

(defthm tree-listp-of-cst-safe-ascii-conc5-rep
  (b* ((abnf::csts (cst-safe-ascii-conc5-rep abnf::cst)))
    (abnf::tree-listp abnf::csts))
  :rule-classes :rewrite)

Theorem: cst-safe-ascii-conc5-rep-match

(defthm cst-safe-ascii-conc5-rep-match
  (implies (and (cst-matchp abnf::cst "safe-ascii")
                (equal (cst-safe-ascii-conc? abnf::cst)
                       5))
           (b* ((abnf::csts (cst-safe-ascii-conc5-rep abnf::cst)))
             (cst-list-rep-matchp abnf::csts "visible-ascii")))
  :rule-classes :rewrite)

Theorem: cst-safe-ascii-conc5-rep-of-tree-fix-cst

(defthm cst-safe-ascii-conc5-rep-of-tree-fix-cst
  (equal (cst-safe-ascii-conc5-rep (abnf::tree-fix abnf::cst))
         (cst-safe-ascii-conc5-rep abnf::cst)))

Theorem: cst-safe-ascii-conc5-rep-tree-equiv-congruence-on-cst

(defthm cst-safe-ascii-conc5-rep-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-safe-ascii-conc5-rep abnf::cst)
                  (cst-safe-ascii-conc5-rep cst-equiv)))
  :rule-classes :congruence)

Function: cst-character-conc1-rep

(defun cst-character-conc1-rep (abnf::cst)
  (declare (xargs :guard (abnf::treep abnf::cst)))
  (declare (xargs :guard (and (cst-matchp abnf::cst "character")
                              (equal (cst-character-conc? abnf::cst)
                                     1))))
  (let ((__function__ 'cst-character-conc1-rep))
    (declare (ignorable __function__))
    (abnf::tree-list-fix (nth 0 (cst-character-conc1 abnf::cst)))))

Theorem: tree-listp-of-cst-character-conc1-rep

(defthm tree-listp-of-cst-character-conc1-rep
  (b* ((abnf::csts (cst-character-conc1-rep abnf::cst)))
    (abnf::tree-listp abnf::csts))
  :rule-classes :rewrite)

Theorem: cst-character-conc1-rep-match

(defthm cst-character-conc1-rep-match
  (implies (and (cst-matchp abnf::cst "character")
                (equal (cst-character-conc? abnf::cst)
                       1))
           (b* ((abnf::csts (cst-character-conc1-rep abnf::cst)))
             (cst-list-rep-matchp abnf::csts "safe-ascii")))
  :rule-classes :rewrite)

Theorem: cst-character-conc1-rep-of-tree-fix-cst

(defthm cst-character-conc1-rep-of-tree-fix-cst
  (equal (cst-character-conc1-rep (abnf::tree-fix abnf::cst))
         (cst-character-conc1-rep abnf::cst)))

Theorem: cst-character-conc1-rep-tree-equiv-congruence-on-cst

(defthm cst-character-conc1-rep-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-character-conc1-rep abnf::cst)
                  (cst-character-conc1-rep cst-equiv)))
  :rule-classes :congruence)

Function: cst-character-conc2-rep

(defun cst-character-conc2-rep (abnf::cst)
  (declare (xargs :guard (abnf::treep abnf::cst)))
  (declare (xargs :guard (and (cst-matchp abnf::cst "character")
                              (equal (cst-character-conc? abnf::cst)
                                     2))))
  (let ((__function__ 'cst-character-conc2-rep))
    (declare (ignorable __function__))
    (abnf::tree-list-fix (nth 0 (cst-character-conc2 abnf::cst)))))

Theorem: tree-listp-of-cst-character-conc2-rep

(defthm tree-listp-of-cst-character-conc2-rep
  (b* ((abnf::csts (cst-character-conc2-rep abnf::cst)))
    (abnf::tree-listp abnf::csts))
  :rule-classes :rewrite)

Theorem: cst-character-conc2-rep-match

(defthm cst-character-conc2-rep-match
  (implies (and (cst-matchp abnf::cst "character")
                (equal (cst-character-conc? abnf::cst)
                       2))
           (b* ((abnf::csts (cst-character-conc2-rep abnf::cst)))
             (cst-list-rep-matchp abnf::csts "safe-nonascii")))
  :rule-classes :rewrite)

Theorem: cst-character-conc2-rep-of-tree-fix-cst

(defthm cst-character-conc2-rep-of-tree-fix-cst
  (equal (cst-character-conc2-rep (abnf::tree-fix abnf::cst))
         (cst-character-conc2-rep abnf::cst)))

Theorem: cst-character-conc2-rep-tree-equiv-congruence-on-cst

(defthm cst-character-conc2-rep-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-character-conc2-rep abnf::cst)
                  (cst-character-conc2-rep cst-equiv)))
  :rule-classes :congruence)

Function: cst-plain-ws-conc1-rep

(defun cst-plain-ws-conc1-rep (abnf::cst)
  (declare (xargs :guard (abnf::treep abnf::cst)))
  (declare (xargs :guard (and (cst-matchp abnf::cst "plain-ws")
                              (equal (cst-plain-ws-conc? abnf::cst)
                                     1))))
  (let ((__function__ 'cst-plain-ws-conc1-rep))
    (declare (ignorable __function__))
    (abnf::tree-list-fix (nth 0 (cst-plain-ws-conc1 abnf::cst)))))

Theorem: tree-listp-of-cst-plain-ws-conc1-rep

(defthm tree-listp-of-cst-plain-ws-conc1-rep
  (b* ((abnf::csts (cst-plain-ws-conc1-rep abnf::cst)))
    (abnf::tree-listp abnf::csts))
  :rule-classes :rewrite)

Theorem: cst-plain-ws-conc1-rep-match

(defthm cst-plain-ws-conc1-rep-match
  (implies (and (cst-matchp abnf::cst "plain-ws")
                (equal (cst-plain-ws-conc? abnf::cst)
                       1))
           (b* ((abnf::csts (cst-plain-ws-conc1-rep abnf::cst)))
             (cst-list-rep-matchp abnf::csts "ht")))
  :rule-classes :rewrite)

Theorem: cst-plain-ws-conc1-rep-of-tree-fix-cst

(defthm cst-plain-ws-conc1-rep-of-tree-fix-cst
  (equal (cst-plain-ws-conc1-rep (abnf::tree-fix abnf::cst))
         (cst-plain-ws-conc1-rep abnf::cst)))

Theorem: cst-plain-ws-conc1-rep-tree-equiv-congruence-on-cst

(defthm cst-plain-ws-conc1-rep-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-plain-ws-conc1-rep abnf::cst)
                  (cst-plain-ws-conc1-rep cst-equiv)))
  :rule-classes :congruence)

Function: cst-plain-ws-conc2-rep

(defun cst-plain-ws-conc2-rep (abnf::cst)
  (declare (xargs :guard (abnf::treep abnf::cst)))
  (declare (xargs :guard (and (cst-matchp abnf::cst "plain-ws")
                              (equal (cst-plain-ws-conc? abnf::cst)
                                     2))))
  (let ((__function__ 'cst-plain-ws-conc2-rep))
    (declare (ignorable __function__))
    (abnf::tree-list-fix (nth 0 (cst-plain-ws-conc2 abnf::cst)))))

Theorem: tree-listp-of-cst-plain-ws-conc2-rep

(defthm tree-listp-of-cst-plain-ws-conc2-rep
  (b* ((abnf::csts (cst-plain-ws-conc2-rep abnf::cst)))
    (abnf::tree-listp abnf::csts))
  :rule-classes :rewrite)

Theorem: cst-plain-ws-conc2-rep-match

(defthm cst-plain-ws-conc2-rep-match
  (implies (and (cst-matchp abnf::cst "plain-ws")
                (equal (cst-plain-ws-conc? abnf::cst)
                       2))
           (b* ((abnf::csts (cst-plain-ws-conc2-rep abnf::cst)))
             (cst-list-rep-matchp abnf::csts "sp")))
  :rule-classes :rewrite)

Theorem: cst-plain-ws-conc2-rep-of-tree-fix-cst

(defthm cst-plain-ws-conc2-rep-of-tree-fix-cst
  (equal (cst-plain-ws-conc2-rep (abnf::tree-fix abnf::cst))
         (cst-plain-ws-conc2-rep abnf::cst)))

Theorem: cst-plain-ws-conc2-rep-tree-equiv-congruence-on-cst

(defthm cst-plain-ws-conc2-rep-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-plain-ws-conc2-rep abnf::cst)
                  (cst-plain-ws-conc2-rep cst-equiv)))
  :rule-classes :congruence)

Function: cst-plain-ws-conc3-rep

(defun cst-plain-ws-conc3-rep (abnf::cst)
  (declare (xargs :guard (abnf::treep abnf::cst)))
  (declare (xargs :guard (and (cst-matchp abnf::cst "plain-ws")
                              (equal (cst-plain-ws-conc? abnf::cst)
                                     3))))
  (let ((__function__ 'cst-plain-ws-conc3-rep))
    (declare (ignorable __function__))
    (abnf::tree-list-fix (nth 0 (cst-plain-ws-conc3 abnf::cst)))))

Theorem: tree-listp-of-cst-plain-ws-conc3-rep

(defthm tree-listp-of-cst-plain-ws-conc3-rep
  (b* ((abnf::csts (cst-plain-ws-conc3-rep abnf::cst)))
    (abnf::tree-listp abnf::csts))
  :rule-classes :rewrite)

Theorem: cst-plain-ws-conc3-rep-match

(defthm cst-plain-ws-conc3-rep-match
  (implies (and (cst-matchp abnf::cst "plain-ws")
                (equal (cst-plain-ws-conc? abnf::cst)
                       3))
           (b* ((abnf::csts (cst-plain-ws-conc3-rep abnf::cst)))
             (cst-list-rep-matchp abnf::csts "lf")))
  :rule-classes :rewrite)

Theorem: cst-plain-ws-conc3-rep-of-tree-fix-cst

(defthm cst-plain-ws-conc3-rep-of-tree-fix-cst
  (equal (cst-plain-ws-conc3-rep (abnf::tree-fix abnf::cst))
         (cst-plain-ws-conc3-rep abnf::cst)))

Theorem: cst-plain-ws-conc3-rep-tree-equiv-congruence-on-cst

(defthm cst-plain-ws-conc3-rep-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-plain-ws-conc3-rep abnf::cst)
                  (cst-plain-ws-conc3-rep cst-equiv)))
  :rule-classes :congruence)

Function: cst-plain-ws-conc4-rep

(defun cst-plain-ws-conc4-rep (abnf::cst)
  (declare (xargs :guard (abnf::treep abnf::cst)))
  (declare (xargs :guard (and (cst-matchp abnf::cst "plain-ws")
                              (equal (cst-plain-ws-conc? abnf::cst)
                                     4))))
  (let ((__function__ 'cst-plain-ws-conc4-rep))
    (declare (ignorable __function__))
    (abnf::tree-list-fix (nth 0 (cst-plain-ws-conc4 abnf::cst)))))

Theorem: tree-listp-of-cst-plain-ws-conc4-rep

(defthm tree-listp-of-cst-plain-ws-conc4-rep
  (b* ((abnf::csts (cst-plain-ws-conc4-rep abnf::cst)))
    (abnf::tree-listp abnf::csts))
  :rule-classes :rewrite)

Theorem: cst-plain-ws-conc4-rep-match

(defthm cst-plain-ws-conc4-rep-match
  (implies (and (cst-matchp abnf::cst "plain-ws")
                (equal (cst-plain-ws-conc? abnf::cst)
                       4))
           (b* ((abnf::csts (cst-plain-ws-conc4-rep abnf::cst)))
             (cst-list-rep-matchp abnf::csts "cr")))
  :rule-classes :rewrite)

Theorem: cst-plain-ws-conc4-rep-of-tree-fix-cst

(defthm cst-plain-ws-conc4-rep-of-tree-fix-cst
  (equal (cst-plain-ws-conc4-rep (abnf::tree-fix abnf::cst))
         (cst-plain-ws-conc4-rep abnf::cst)))

Theorem: cst-plain-ws-conc4-rep-tree-equiv-congruence-on-cst

(defthm cst-plain-ws-conc4-rep-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-plain-ws-conc4-rep abnf::cst)
                  (cst-plain-ws-conc4-rep cst-equiv)))
  :rule-classes :congruence)

Function: cst-comment-conc1-rep

(defun cst-comment-conc1-rep (abnf::cst)
  (declare (xargs :guard (abnf::treep abnf::cst)))
  (declare (xargs :guard (and (cst-matchp abnf::cst "comment")
                              (equal (cst-comment-conc? abnf::cst)
                                     1))))
  (let ((__function__ 'cst-comment-conc1-rep))
    (declare (ignorable __function__))
    (abnf::tree-list-fix (nth 0 (cst-comment-conc1 abnf::cst)))))

Theorem: tree-listp-of-cst-comment-conc1-rep

(defthm tree-listp-of-cst-comment-conc1-rep
  (b* ((abnf::csts (cst-comment-conc1-rep abnf::cst)))
    (abnf::tree-listp abnf::csts))
  :rule-classes :rewrite)

Theorem: cst-comment-conc1-rep-match

(defthm cst-comment-conc1-rep-match
  (implies (and (cst-matchp abnf::cst "comment")
                (equal (cst-comment-conc? abnf::cst) 1))
           (b* ((abnf::csts (cst-comment-conc1-rep abnf::cst)))
             (cst-list-rep-matchp abnf::csts "line-comment")))
  :rule-classes :rewrite)

Theorem: cst-comment-conc1-rep-of-tree-fix-cst

(defthm cst-comment-conc1-rep-of-tree-fix-cst
  (equal (cst-comment-conc1-rep (abnf::tree-fix abnf::cst))
         (cst-comment-conc1-rep abnf::cst)))

Theorem: cst-comment-conc1-rep-tree-equiv-congruence-on-cst

(defthm cst-comment-conc1-rep-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-comment-conc1-rep abnf::cst)
                  (cst-comment-conc1-rep cst-equiv)))
  :rule-classes :congruence)

Function: cst-comment-conc2-rep

(defun cst-comment-conc2-rep (abnf::cst)
  (declare (xargs :guard (abnf::treep abnf::cst)))
  (declare (xargs :guard (and (cst-matchp abnf::cst "comment")
                              (equal (cst-comment-conc? abnf::cst)
                                     2))))
  (let ((__function__ 'cst-comment-conc2-rep))
    (declare (ignorable __function__))
    (abnf::tree-list-fix (nth 0 (cst-comment-conc2 abnf::cst)))))

Theorem: tree-listp-of-cst-comment-conc2-rep

(defthm tree-listp-of-cst-comment-conc2-rep
  (b* ((abnf::csts (cst-comment-conc2-rep abnf::cst)))
    (abnf::tree-listp abnf::csts))
  :rule-classes :rewrite)

Theorem: cst-comment-conc2-rep-match

(defthm cst-comment-conc2-rep-match
  (implies (and (cst-matchp abnf::cst "comment")
                (equal (cst-comment-conc? abnf::cst) 2))
           (b* ((abnf::csts (cst-comment-conc2-rep abnf::cst)))
             (cst-list-rep-matchp abnf::csts "block-comment")))
  :rule-classes :rewrite)

Theorem: cst-comment-conc2-rep-of-tree-fix-cst

(defthm cst-comment-conc2-rep-of-tree-fix-cst
  (equal (cst-comment-conc2-rep (abnf::tree-fix abnf::cst))
         (cst-comment-conc2-rep abnf::cst)))

Theorem: cst-comment-conc2-rep-tree-equiv-congruence-on-cst

(defthm cst-comment-conc2-rep-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-comment-conc2-rep abnf::cst)
                  (cst-comment-conc2-rep cst-equiv)))
  :rule-classes :congruence)

Function: cst-not-lf-or-cr-conc1-rep

(defun cst-not-lf-or-cr-conc1-rep (abnf::cst)
 (declare (xargs :guard (abnf::treep abnf::cst)))
 (declare
      (xargs :guard (and (cst-matchp abnf::cst "not-lf-or-cr")
                         (equal (cst-not-lf-or-cr-conc? abnf::cst)
                                1))))
 (let ((__function__ 'cst-not-lf-or-cr-conc1-rep))
  (declare (ignorable __function__))
  (abnf::tree-list-fix (nth 0 (cst-not-lf-or-cr-conc1 abnf::cst)))))

Theorem: tree-listp-of-cst-not-lf-or-cr-conc1-rep

(defthm tree-listp-of-cst-not-lf-or-cr-conc1-rep
  (b* ((abnf::csts (cst-not-lf-or-cr-conc1-rep abnf::cst)))
    (abnf::tree-listp abnf::csts))
  :rule-classes :rewrite)

Theorem: cst-not-lf-or-cr-conc1-rep-match

(defthm cst-not-lf-or-cr-conc1-rep-match
  (implies (and (cst-matchp abnf::cst "not-lf-or-cr")
                (equal (cst-not-lf-or-cr-conc? abnf::cst)
                       1))
           (b* ((abnf::csts (cst-not-lf-or-cr-conc1-rep abnf::cst)))
             (cst-list-rep-matchp abnf::csts "ht")))
  :rule-classes :rewrite)

Theorem: cst-not-lf-or-cr-conc1-rep-of-tree-fix-cst

(defthm cst-not-lf-or-cr-conc1-rep-of-tree-fix-cst
  (equal (cst-not-lf-or-cr-conc1-rep (abnf::tree-fix abnf::cst))
         (cst-not-lf-or-cr-conc1-rep abnf::cst)))

Theorem: cst-not-lf-or-cr-conc1-rep-tree-equiv-congruence-on-cst

(defthm cst-not-lf-or-cr-conc1-rep-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-not-lf-or-cr-conc1-rep abnf::cst)
                  (cst-not-lf-or-cr-conc1-rep cst-equiv)))
  :rule-classes :congruence)

Function: cst-not-lf-or-cr-conc2-rep

(defun cst-not-lf-or-cr-conc2-rep (abnf::cst)
 (declare (xargs :guard (abnf::treep abnf::cst)))
 (declare
      (xargs :guard (and (cst-matchp abnf::cst "not-lf-or-cr")
                         (equal (cst-not-lf-or-cr-conc? abnf::cst)
                                2))))
 (let ((__function__ 'cst-not-lf-or-cr-conc2-rep))
  (declare (ignorable __function__))
  (abnf::tree-list-fix (nth 0 (cst-not-lf-or-cr-conc2 abnf::cst)))))

Theorem: tree-listp-of-cst-not-lf-or-cr-conc2-rep

(defthm tree-listp-of-cst-not-lf-or-cr-conc2-rep
  (b* ((abnf::csts (cst-not-lf-or-cr-conc2-rep abnf::cst)))
    (abnf::tree-listp abnf::csts))
  :rule-classes :rewrite)

Theorem: cst-not-lf-or-cr-conc2-rep-match

(defthm cst-not-lf-or-cr-conc2-rep-match
  (implies (and (cst-matchp abnf::cst "not-lf-or-cr")
                (equal (cst-not-lf-or-cr-conc? abnf::cst)
                       2))
           (b* ((abnf::csts (cst-not-lf-or-cr-conc2-rep abnf::cst)))
             (cst-list-rep-matchp abnf::csts "sp")))
  :rule-classes :rewrite)

Theorem: cst-not-lf-or-cr-conc2-rep-of-tree-fix-cst

(defthm cst-not-lf-or-cr-conc2-rep-of-tree-fix-cst
  (equal (cst-not-lf-or-cr-conc2-rep (abnf::tree-fix abnf::cst))
         (cst-not-lf-or-cr-conc2-rep abnf::cst)))

Theorem: cst-not-lf-or-cr-conc2-rep-tree-equiv-congruence-on-cst

(defthm cst-not-lf-or-cr-conc2-rep-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-not-lf-or-cr-conc2-rep abnf::cst)
                  (cst-not-lf-or-cr-conc2-rep cst-equiv)))
  :rule-classes :congruence)

Function: cst-not-lf-or-cr-conc3-rep

(defun cst-not-lf-or-cr-conc3-rep (abnf::cst)
 (declare (xargs :guard (abnf::treep abnf::cst)))
 (declare
      (xargs :guard (and (cst-matchp abnf::cst "not-lf-or-cr")
                         (equal (cst-not-lf-or-cr-conc? abnf::cst)
                                3))))
 (let ((__function__ 'cst-not-lf-or-cr-conc3-rep))
  (declare (ignorable __function__))
  (abnf::tree-list-fix (nth 0 (cst-not-lf-or-cr-conc3 abnf::cst)))))

Theorem: tree-listp-of-cst-not-lf-or-cr-conc3-rep

(defthm tree-listp-of-cst-not-lf-or-cr-conc3-rep
  (b* ((abnf::csts (cst-not-lf-or-cr-conc3-rep abnf::cst)))
    (abnf::tree-listp abnf::csts))
  :rule-classes :rewrite)

Theorem: cst-not-lf-or-cr-conc3-rep-match

(defthm cst-not-lf-or-cr-conc3-rep-match
  (implies (and (cst-matchp abnf::cst "not-lf-or-cr")
                (equal (cst-not-lf-or-cr-conc? abnf::cst)
                       3))
           (b* ((abnf::csts (cst-not-lf-or-cr-conc3-rep abnf::cst)))
             (cst-list-rep-matchp abnf::csts "visible-ascii")))
  :rule-classes :rewrite)

Theorem: cst-not-lf-or-cr-conc3-rep-of-tree-fix-cst

(defthm cst-not-lf-or-cr-conc3-rep-of-tree-fix-cst
  (equal (cst-not-lf-or-cr-conc3-rep (abnf::tree-fix abnf::cst))
         (cst-not-lf-or-cr-conc3-rep abnf::cst)))

Theorem: cst-not-lf-or-cr-conc3-rep-tree-equiv-congruence-on-cst

(defthm cst-not-lf-or-cr-conc3-rep-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-not-lf-or-cr-conc3-rep abnf::cst)
                  (cst-not-lf-or-cr-conc3-rep cst-equiv)))
  :rule-classes :congruence)

Function: cst-not-lf-or-cr-conc4-rep

(defun cst-not-lf-or-cr-conc4-rep (abnf::cst)
 (declare (xargs :guard (abnf::treep abnf::cst)))
 (declare
      (xargs :guard (and (cst-matchp abnf::cst "not-lf-or-cr")
                         (equal (cst-not-lf-or-cr-conc? abnf::cst)
                                4))))
 (let ((__function__ 'cst-not-lf-or-cr-conc4-rep))
  (declare (ignorable __function__))
  (abnf::tree-list-fix (nth 0 (cst-not-lf-or-cr-conc4 abnf::cst)))))

Theorem: tree-listp-of-cst-not-lf-or-cr-conc4-rep

(defthm tree-listp-of-cst-not-lf-or-cr-conc4-rep
  (b* ((abnf::csts (cst-not-lf-or-cr-conc4-rep abnf::cst)))
    (abnf::tree-listp abnf::csts))
  :rule-classes :rewrite)

Theorem: cst-not-lf-or-cr-conc4-rep-match

(defthm cst-not-lf-or-cr-conc4-rep-match
  (implies (and (cst-matchp abnf::cst "not-lf-or-cr")
                (equal (cst-not-lf-or-cr-conc? abnf::cst)
                       4))
           (b* ((abnf::csts (cst-not-lf-or-cr-conc4-rep abnf::cst)))
             (cst-list-rep-matchp abnf::csts "safe-nonascii")))
  :rule-classes :rewrite)

Theorem: cst-not-lf-or-cr-conc4-rep-of-tree-fix-cst

(defthm cst-not-lf-or-cr-conc4-rep-of-tree-fix-cst
  (equal (cst-not-lf-or-cr-conc4-rep (abnf::tree-fix abnf::cst))
         (cst-not-lf-or-cr-conc4-rep abnf::cst)))

Theorem: cst-not-lf-or-cr-conc4-rep-tree-equiv-congruence-on-cst

(defthm cst-not-lf-or-cr-conc4-rep-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-not-lf-or-cr-conc4-rep abnf::cst)
                  (cst-not-lf-or-cr-conc4-rep cst-equiv)))
  :rule-classes :congruence)

Function: cst-uppercase-letter-conc-rep

(defun cst-uppercase-letter-conc-rep (abnf::cst)
  (declare (xargs :guard (abnf::treep abnf::cst)))
  (declare (xargs :guard (cst-matchp abnf::cst "uppercase-letter")))
  (let ((__function__ 'cst-uppercase-letter-conc-rep))
    (declare (ignorable __function__))
    (abnf::tree-list-fix
         (nth 0
              (cst-uppercase-letter-conc abnf::cst)))))

Theorem: tree-listp-of-cst-uppercase-letter-conc-rep

(defthm tree-listp-of-cst-uppercase-letter-conc-rep
  (b* ((abnf::csts (cst-uppercase-letter-conc-rep abnf::cst)))
    (abnf::tree-listp abnf::csts))
  :rule-classes :rewrite)

Theorem: cst-uppercase-letter-conc-rep-match

(defthm cst-uppercase-letter-conc-rep-match
  (implies
       (cst-matchp abnf::cst "uppercase-letter")
       (b* ((abnf::csts (cst-uppercase-letter-conc-rep abnf::cst)))
         (cst-list-rep-matchp abnf::csts "%x41-5A")))
  :rule-classes :rewrite)

Theorem: cst-uppercase-letter-conc-rep-of-tree-fix-cst

(defthm cst-uppercase-letter-conc-rep-of-tree-fix-cst
  (equal (cst-uppercase-letter-conc-rep (abnf::tree-fix abnf::cst))
         (cst-uppercase-letter-conc-rep abnf::cst)))

Theorem: cst-uppercase-letter-conc-rep-tree-equiv-congruence-on-cst

(defthm cst-uppercase-letter-conc-rep-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-uppercase-letter-conc-rep abnf::cst)
                  (cst-uppercase-letter-conc-rep cst-equiv)))
  :rule-classes :congruence)

Function: cst-lowercase-letter-conc-rep

(defun cst-lowercase-letter-conc-rep (abnf::cst)
  (declare (xargs :guard (abnf::treep abnf::cst)))
  (declare (xargs :guard (cst-matchp abnf::cst "lowercase-letter")))
  (let ((__function__ 'cst-lowercase-letter-conc-rep))
    (declare (ignorable __function__))
    (abnf::tree-list-fix
         (nth 0
              (cst-lowercase-letter-conc abnf::cst)))))

Theorem: tree-listp-of-cst-lowercase-letter-conc-rep

(defthm tree-listp-of-cst-lowercase-letter-conc-rep
  (b* ((abnf::csts (cst-lowercase-letter-conc-rep abnf::cst)))
    (abnf::tree-listp abnf::csts))
  :rule-classes :rewrite)

Theorem: cst-lowercase-letter-conc-rep-match

(defthm cst-lowercase-letter-conc-rep-match
  (implies
       (cst-matchp abnf::cst "lowercase-letter")
       (b* ((abnf::csts (cst-lowercase-letter-conc-rep abnf::cst)))
         (cst-list-rep-matchp abnf::csts "%x61-7A")))
  :rule-classes :rewrite)

Theorem: cst-lowercase-letter-conc-rep-of-tree-fix-cst

(defthm cst-lowercase-letter-conc-rep-of-tree-fix-cst
  (equal (cst-lowercase-letter-conc-rep (abnf::tree-fix abnf::cst))
         (cst-lowercase-letter-conc-rep abnf::cst)))

Theorem: cst-lowercase-letter-conc-rep-tree-equiv-congruence-on-cst

(defthm cst-lowercase-letter-conc-rep-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-lowercase-letter-conc-rep abnf::cst)
                  (cst-lowercase-letter-conc-rep cst-equiv)))
  :rule-classes :congruence)

Function: cst-letter-conc1-rep

(defun cst-letter-conc1-rep (abnf::cst)
  (declare (xargs :guard (abnf::treep abnf::cst)))
  (declare (xargs :guard (and (cst-matchp abnf::cst "letter")
                              (equal (cst-letter-conc? abnf::cst)
                                     1))))
  (let ((__function__ 'cst-letter-conc1-rep))
    (declare (ignorable __function__))
    (abnf::tree-list-fix (nth 0 (cst-letter-conc1 abnf::cst)))))

Theorem: tree-listp-of-cst-letter-conc1-rep

(defthm tree-listp-of-cst-letter-conc1-rep
  (b* ((abnf::csts (cst-letter-conc1-rep abnf::cst)))
    (abnf::tree-listp abnf::csts))
  :rule-classes :rewrite)

Theorem: cst-letter-conc1-rep-match

(defthm cst-letter-conc1-rep-match
  (implies (and (cst-matchp abnf::cst "letter")
                (equal (cst-letter-conc? abnf::cst) 1))
           (b* ((abnf::csts (cst-letter-conc1-rep abnf::cst)))
             (cst-list-rep-matchp abnf::csts "uppercase-letter")))
  :rule-classes :rewrite)

Theorem: cst-letter-conc1-rep-of-tree-fix-cst

(defthm cst-letter-conc1-rep-of-tree-fix-cst
  (equal (cst-letter-conc1-rep (abnf::tree-fix abnf::cst))
         (cst-letter-conc1-rep abnf::cst)))

Theorem: cst-letter-conc1-rep-tree-equiv-congruence-on-cst

(defthm cst-letter-conc1-rep-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-letter-conc1-rep abnf::cst)
                  (cst-letter-conc1-rep cst-equiv)))
  :rule-classes :congruence)

Function: cst-letter-conc2-rep

(defun cst-letter-conc2-rep (abnf::cst)
  (declare (xargs :guard (abnf::treep abnf::cst)))
  (declare (xargs :guard (and (cst-matchp abnf::cst "letter")
                              (equal (cst-letter-conc? abnf::cst)
                                     2))))
  (let ((__function__ 'cst-letter-conc2-rep))
    (declare (ignorable __function__))
    (abnf::tree-list-fix (nth 0 (cst-letter-conc2 abnf::cst)))))

Theorem: tree-listp-of-cst-letter-conc2-rep

(defthm tree-listp-of-cst-letter-conc2-rep
  (b* ((abnf::csts (cst-letter-conc2-rep abnf::cst)))
    (abnf::tree-listp abnf::csts))
  :rule-classes :rewrite)

Theorem: cst-letter-conc2-rep-match

(defthm cst-letter-conc2-rep-match
  (implies (and (cst-matchp abnf::cst "letter")
                (equal (cst-letter-conc? abnf::cst) 2))
           (b* ((abnf::csts (cst-letter-conc2-rep abnf::cst)))
             (cst-list-rep-matchp abnf::csts "lowercase-letter")))
  :rule-classes :rewrite)

Theorem: cst-letter-conc2-rep-of-tree-fix-cst

(defthm cst-letter-conc2-rep-of-tree-fix-cst
  (equal (cst-letter-conc2-rep (abnf::tree-fix abnf::cst))
         (cst-letter-conc2-rep abnf::cst)))

Theorem: cst-letter-conc2-rep-tree-equiv-congruence-on-cst

(defthm cst-letter-conc2-rep-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-letter-conc2-rep abnf::cst)
                  (cst-letter-conc2-rep cst-equiv)))
  :rule-classes :congruence)

Function: cst-digit-conc-rep

(defun cst-digit-conc-rep (abnf::cst)
  (declare (xargs :guard (abnf::treep abnf::cst)))
  (declare (xargs :guard (cst-matchp abnf::cst "digit")))
  (let ((__function__ 'cst-digit-conc-rep))
    (declare (ignorable __function__))
    (abnf::tree-list-fix (nth 0 (cst-digit-conc abnf::cst)))))

Theorem: tree-listp-of-cst-digit-conc-rep

(defthm tree-listp-of-cst-digit-conc-rep
  (b* ((abnf::csts (cst-digit-conc-rep abnf::cst)))
    (abnf::tree-listp abnf::csts))
  :rule-classes :rewrite)

Theorem: cst-digit-conc-rep-match

(defthm cst-digit-conc-rep-match
  (implies (cst-matchp abnf::cst "digit")
           (b* ((abnf::csts (cst-digit-conc-rep abnf::cst)))
             (cst-list-rep-matchp abnf::csts "%x30-39")))
  :rule-classes :rewrite)

Theorem: cst-digit-conc-rep-of-tree-fix-cst

(defthm cst-digit-conc-rep-of-tree-fix-cst
  (equal (cst-digit-conc-rep (abnf::tree-fix abnf::cst))
         (cst-digit-conc-rep abnf::cst)))

Theorem: cst-digit-conc-rep-tree-equiv-congruence-on-cst

(defthm cst-digit-conc-rep-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-digit-conc-rep abnf::cst)
                  (cst-digit-conc-rep cst-equiv)))
  :rule-classes :congruence)

Function: cst-integer-literal-conc1-rep

(defun cst-integer-literal-conc1-rep (abnf::cst)
 (declare (xargs :guard (abnf::treep abnf::cst)))
 (declare
     (xargs :guard (and (cst-matchp abnf::cst "integer-literal")
                        (equal (cst-integer-literal-conc? abnf::cst)
                               1))))
 (let ((__function__ 'cst-integer-literal-conc1-rep))
   (declare (ignorable __function__))
   (abnf::tree-list-fix
        (nth 0
             (cst-integer-literal-conc1 abnf::cst)))))

Theorem: tree-listp-of-cst-integer-literal-conc1-rep

(defthm tree-listp-of-cst-integer-literal-conc1-rep
  (b* ((abnf::csts (cst-integer-literal-conc1-rep abnf::cst)))
    (abnf::tree-listp abnf::csts))
  :rule-classes :rewrite)

Theorem: cst-integer-literal-conc1-rep-match

(defthm cst-integer-literal-conc1-rep-match
  (implies
       (and (cst-matchp abnf::cst "integer-literal")
            (equal (cst-integer-literal-conc? abnf::cst)
                   1))
       (b* ((abnf::csts (cst-integer-literal-conc1-rep abnf::cst)))
         (cst-list-rep-matchp abnf::csts "signed-literal")))
  :rule-classes :rewrite)

Theorem: cst-integer-literal-conc1-rep-of-tree-fix-cst

(defthm cst-integer-literal-conc1-rep-of-tree-fix-cst
  (equal (cst-integer-literal-conc1-rep (abnf::tree-fix abnf::cst))
         (cst-integer-literal-conc1-rep abnf::cst)))

Theorem: cst-integer-literal-conc1-rep-tree-equiv-congruence-on-cst

(defthm cst-integer-literal-conc1-rep-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-integer-literal-conc1-rep abnf::cst)
                  (cst-integer-literal-conc1-rep cst-equiv)))
  :rule-classes :congruence)

Function: cst-integer-literal-conc2-rep

(defun cst-integer-literal-conc2-rep (abnf::cst)
 (declare (xargs :guard (abnf::treep abnf::cst)))
 (declare
     (xargs :guard (and (cst-matchp abnf::cst "integer-literal")
                        (equal (cst-integer-literal-conc? abnf::cst)
                               2))))
 (let ((__function__ 'cst-integer-literal-conc2-rep))
   (declare (ignorable __function__))
   (abnf::tree-list-fix
        (nth 0
             (cst-integer-literal-conc2 abnf::cst)))))

Theorem: tree-listp-of-cst-integer-literal-conc2-rep

(defthm tree-listp-of-cst-integer-literal-conc2-rep
  (b* ((abnf::csts (cst-integer-literal-conc2-rep abnf::cst)))
    (abnf::tree-listp abnf::csts))
  :rule-classes :rewrite)

Theorem: cst-integer-literal-conc2-rep-match

(defthm cst-integer-literal-conc2-rep-match
  (implies
       (and (cst-matchp abnf::cst "integer-literal")
            (equal (cst-integer-literal-conc? abnf::cst)
                   2))
       (b* ((abnf::csts (cst-integer-literal-conc2-rep abnf::cst)))
         (cst-list-rep-matchp abnf::csts "unsigned-literal")))
  :rule-classes :rewrite)

Theorem: cst-integer-literal-conc2-rep-of-tree-fix-cst

(defthm cst-integer-literal-conc2-rep-of-tree-fix-cst
  (equal (cst-integer-literal-conc2-rep (abnf::tree-fix abnf::cst))
         (cst-integer-literal-conc2-rep abnf::cst)))

Theorem: cst-integer-literal-conc2-rep-tree-equiv-congruence-on-cst

(defthm cst-integer-literal-conc2-rep-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-integer-literal-conc2-rep abnf::cst)
                  (cst-integer-literal-conc2-rep cst-equiv)))
  :rule-classes :congruence)

Function: cst-arithmetic-literal-conc1-rep

(defun cst-arithmetic-literal-conc1-rep (abnf::cst)
 (declare (xargs :guard (abnf::treep abnf::cst)))
 (declare
  (xargs :guard (and (cst-matchp abnf::cst "arithmetic-literal")
                     (equal (cst-arithmetic-literal-conc? abnf::cst)
                            1))))
 (let ((__function__ 'cst-arithmetic-literal-conc1-rep))
   (declare (ignorable __function__))
   (abnf::tree-list-fix
        (nth 0
             (cst-arithmetic-literal-conc1 abnf::cst)))))

Theorem: tree-listp-of-cst-arithmetic-literal-conc1-rep

(defthm tree-listp-of-cst-arithmetic-literal-conc1-rep
  (b* ((abnf::csts (cst-arithmetic-literal-conc1-rep abnf::cst)))
    (abnf::tree-listp abnf::csts))
  :rule-classes :rewrite)

Theorem: cst-arithmetic-literal-conc1-rep-match

(defthm cst-arithmetic-literal-conc1-rep-match
 (implies
     (and (cst-matchp abnf::cst "arithmetic-literal")
          (equal (cst-arithmetic-literal-conc? abnf::cst)
                 1))
     (b* ((abnf::csts (cst-arithmetic-literal-conc1-rep abnf::cst)))
       (cst-list-rep-matchp abnf::csts "integer-literal")))
 :rule-classes :rewrite)

Theorem: cst-arithmetic-literal-conc1-rep-of-tree-fix-cst

(defthm cst-arithmetic-literal-conc1-rep-of-tree-fix-cst
  (equal
       (cst-arithmetic-literal-conc1-rep (abnf::tree-fix abnf::cst))
       (cst-arithmetic-literal-conc1-rep abnf::cst)))

Theorem: cst-arithmetic-literal-conc1-rep-tree-equiv-congruence-on-cst

(defthm
      cst-arithmetic-literal-conc1-rep-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-arithmetic-literal-conc1-rep abnf::cst)
                  (cst-arithmetic-literal-conc1-rep cst-equiv)))
  :rule-classes :congruence)

Function: cst-arithmetic-literal-conc2-rep

(defun cst-arithmetic-literal-conc2-rep (abnf::cst)
 (declare (xargs :guard (abnf::treep abnf::cst)))
 (declare
  (xargs :guard (and (cst-matchp abnf::cst "arithmetic-literal")
                     (equal (cst-arithmetic-literal-conc? abnf::cst)
                            2))))
 (let ((__function__ 'cst-arithmetic-literal-conc2-rep))
   (declare (ignorable __function__))
   (abnf::tree-list-fix
        (nth 0
             (cst-arithmetic-literal-conc2 abnf::cst)))))

Theorem: tree-listp-of-cst-arithmetic-literal-conc2-rep

(defthm tree-listp-of-cst-arithmetic-literal-conc2-rep
  (b* ((abnf::csts (cst-arithmetic-literal-conc2-rep abnf::cst)))
    (abnf::tree-listp abnf::csts))
  :rule-classes :rewrite)

Theorem: cst-arithmetic-literal-conc2-rep-match

(defthm cst-arithmetic-literal-conc2-rep-match
 (implies
     (and (cst-matchp abnf::cst "arithmetic-literal")
          (equal (cst-arithmetic-literal-conc? abnf::cst)
                 2))
     (b* ((abnf::csts (cst-arithmetic-literal-conc2-rep abnf::cst)))
       (cst-list-rep-matchp abnf::csts "field-literal")))
 :rule-classes :rewrite)

Theorem: cst-arithmetic-literal-conc2-rep-of-tree-fix-cst

(defthm cst-arithmetic-literal-conc2-rep-of-tree-fix-cst
  (equal
       (cst-arithmetic-literal-conc2-rep (abnf::tree-fix abnf::cst))
       (cst-arithmetic-literal-conc2-rep abnf::cst)))

Theorem: cst-arithmetic-literal-conc2-rep-tree-equiv-congruence-on-cst

(defthm
      cst-arithmetic-literal-conc2-rep-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-arithmetic-literal-conc2-rep abnf::cst)
                  (cst-arithmetic-literal-conc2-rep cst-equiv)))
  :rule-classes :congruence)

Function: cst-arithmetic-literal-conc3-rep

(defun cst-arithmetic-literal-conc3-rep (abnf::cst)
 (declare (xargs :guard (abnf::treep abnf::cst)))
 (declare
  (xargs :guard (and (cst-matchp abnf::cst "arithmetic-literal")
                     (equal (cst-arithmetic-literal-conc? abnf::cst)
                            3))))
 (let ((__function__ 'cst-arithmetic-literal-conc3-rep))
   (declare (ignorable __function__))
   (abnf::tree-list-fix
        (nth 0
             (cst-arithmetic-literal-conc3 abnf::cst)))))

Theorem: tree-listp-of-cst-arithmetic-literal-conc3-rep

(defthm tree-listp-of-cst-arithmetic-literal-conc3-rep
  (b* ((abnf::csts (cst-arithmetic-literal-conc3-rep abnf::cst)))
    (abnf::tree-listp abnf::csts))
  :rule-classes :rewrite)

Theorem: cst-arithmetic-literal-conc3-rep-match

(defthm cst-arithmetic-literal-conc3-rep-match
 (implies
     (and (cst-matchp abnf::cst "arithmetic-literal")
          (equal (cst-arithmetic-literal-conc? abnf::cst)
                 3))
     (b* ((abnf::csts (cst-arithmetic-literal-conc3-rep abnf::cst)))
       (cst-list-rep-matchp abnf::csts "group-literal")))
 :rule-classes :rewrite)

Theorem: cst-arithmetic-literal-conc3-rep-of-tree-fix-cst

(defthm cst-arithmetic-literal-conc3-rep-of-tree-fix-cst
  (equal
       (cst-arithmetic-literal-conc3-rep (abnf::tree-fix abnf::cst))
       (cst-arithmetic-literal-conc3-rep abnf::cst)))

Theorem: cst-arithmetic-literal-conc3-rep-tree-equiv-congruence-on-cst

(defthm
      cst-arithmetic-literal-conc3-rep-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-arithmetic-literal-conc3-rep abnf::cst)
                  (cst-arithmetic-literal-conc3-rep cst-equiv)))
  :rule-classes :congruence)

Function: cst-arithmetic-literal-conc4-rep

(defun cst-arithmetic-literal-conc4-rep (abnf::cst)
 (declare (xargs :guard (abnf::treep abnf::cst)))
 (declare
  (xargs :guard (and (cst-matchp abnf::cst "arithmetic-literal")
                     (equal (cst-arithmetic-literal-conc? abnf::cst)
                            4))))
 (let ((__function__ 'cst-arithmetic-literal-conc4-rep))
   (declare (ignorable __function__))
   (abnf::tree-list-fix
        (nth 0
             (cst-arithmetic-literal-conc4 abnf::cst)))))

Theorem: tree-listp-of-cst-arithmetic-literal-conc4-rep

(defthm tree-listp-of-cst-arithmetic-literal-conc4-rep
  (b* ((abnf::csts (cst-arithmetic-literal-conc4-rep abnf::cst)))
    (abnf::tree-listp abnf::csts))
  :rule-classes :rewrite)

Theorem: cst-arithmetic-literal-conc4-rep-match

(defthm cst-arithmetic-literal-conc4-rep-match
 (implies
     (and (cst-matchp abnf::cst "arithmetic-literal")
          (equal (cst-arithmetic-literal-conc? abnf::cst)
                 4))
     (b* ((abnf::csts (cst-arithmetic-literal-conc4-rep abnf::cst)))
       (cst-list-rep-matchp abnf::csts "scalar-literal")))
 :rule-classes :rewrite)

Theorem: cst-arithmetic-literal-conc4-rep-of-tree-fix-cst

(defthm cst-arithmetic-literal-conc4-rep-of-tree-fix-cst
  (equal
       (cst-arithmetic-literal-conc4-rep (abnf::tree-fix abnf::cst))
       (cst-arithmetic-literal-conc4-rep abnf::cst)))

Theorem: cst-arithmetic-literal-conc4-rep-tree-equiv-congruence-on-cst

(defthm
      cst-arithmetic-literal-conc4-rep-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-arithmetic-literal-conc4-rep abnf::cst)
                  (cst-arithmetic-literal-conc4-rep cst-equiv)))
  :rule-classes :congruence)

Function: cst-string-element-conc1-rep

(defun cst-string-element-conc1-rep (abnf::cst)
 (declare (xargs :guard (abnf::treep abnf::cst)))
 (declare
      (xargs :guard (and (cst-matchp abnf::cst "string-element")
                         (equal (cst-string-element-conc? abnf::cst)
                                1))))
 (let ((__function__ 'cst-string-element-conc1-rep))
  (declare (ignorable __function__))
  (abnf::tree-list-fix (nth 0
                            (cst-string-element-conc1 abnf::cst)))))

Theorem: tree-listp-of-cst-string-element-conc1-rep

(defthm tree-listp-of-cst-string-element-conc1-rep
  (b* ((abnf::csts (cst-string-element-conc1-rep abnf::cst)))
    (abnf::tree-listp abnf::csts))
  :rule-classes :rewrite)

Theorem: cst-string-element-conc1-rep-match

(defthm cst-string-element-conc1-rep-match
  (implies
       (and (cst-matchp abnf::cst "string-element")
            (equal (cst-string-element-conc? abnf::cst)
                   1))
       (b* ((abnf::csts (cst-string-element-conc1-rep abnf::cst)))
         (cst-list-rep-matchp abnf::csts "not-dq-or-backslash")))
  :rule-classes :rewrite)

Theorem: cst-string-element-conc1-rep-of-tree-fix-cst

(defthm cst-string-element-conc1-rep-of-tree-fix-cst
  (equal (cst-string-element-conc1-rep (abnf::tree-fix abnf::cst))
         (cst-string-element-conc1-rep abnf::cst)))

Theorem: cst-string-element-conc1-rep-tree-equiv-congruence-on-cst

(defthm cst-string-element-conc1-rep-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-string-element-conc1-rep abnf::cst)
                  (cst-string-element-conc1-rep cst-equiv)))
  :rule-classes :congruence)

Function: cst-string-element-conc2-rep

(defun cst-string-element-conc2-rep (abnf::cst)
 (declare (xargs :guard (abnf::treep abnf::cst)))
 (declare
      (xargs :guard (and (cst-matchp abnf::cst "string-element")
                         (equal (cst-string-element-conc? abnf::cst)
                                2))))
 (let ((__function__ 'cst-string-element-conc2-rep))
  (declare (ignorable __function__))
  (abnf::tree-list-fix (nth 0
                            (cst-string-element-conc2 abnf::cst)))))

Theorem: tree-listp-of-cst-string-element-conc2-rep

(defthm tree-listp-of-cst-string-element-conc2-rep
  (b* ((abnf::csts (cst-string-element-conc2-rep abnf::cst)))
    (abnf::tree-listp abnf::csts))
  :rule-classes :rewrite)

Theorem: cst-string-element-conc2-rep-match

(defthm cst-string-element-conc2-rep-match
  (implies
       (and (cst-matchp abnf::cst "string-element")
            (equal (cst-string-element-conc? abnf::cst)
                   2))
       (b* ((abnf::csts (cst-string-element-conc2-rep abnf::cst)))
         (cst-list-rep-matchp abnf::csts "escaped-char")))
  :rule-classes :rewrite)

Theorem: cst-string-element-conc2-rep-of-tree-fix-cst

(defthm cst-string-element-conc2-rep-of-tree-fix-cst
  (equal (cst-string-element-conc2-rep (abnf::tree-fix abnf::cst))
         (cst-string-element-conc2-rep abnf::cst)))

Theorem: cst-string-element-conc2-rep-tree-equiv-congruence-on-cst

(defthm cst-string-element-conc2-rep-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-string-element-conc2-rep abnf::cst)
                  (cst-string-element-conc2-rep cst-equiv)))
  :rule-classes :congruence)

Function: cst-string-element-conc3-rep

(defun cst-string-element-conc3-rep (abnf::cst)
 (declare (xargs :guard (abnf::treep abnf::cst)))
 (declare
      (xargs :guard (and (cst-matchp abnf::cst "string-element")
                         (equal (cst-string-element-conc? abnf::cst)
                                3))))
 (let ((__function__ 'cst-string-element-conc3-rep))
  (declare (ignorable __function__))
  (abnf::tree-list-fix (nth 0
                            (cst-string-element-conc3 abnf::cst)))))

Theorem: tree-listp-of-cst-string-element-conc3-rep

(defthm tree-listp-of-cst-string-element-conc3-rep
  (b* ((abnf::csts (cst-string-element-conc3-rep abnf::cst)))
    (abnf::tree-listp abnf::csts))
  :rule-classes :rewrite)

Theorem: cst-string-element-conc3-rep-match

(defthm cst-string-element-conc3-rep-match
  (implies
       (and (cst-matchp abnf::cst "string-element")
            (equal (cst-string-element-conc? abnf::cst)
                   3))
       (b* ((abnf::csts (cst-string-element-conc3-rep abnf::cst)))
         (cst-list-rep-matchp abnf::csts "escaped-ws")))
  :rule-classes :rewrite)

Theorem: cst-string-element-conc3-rep-of-tree-fix-cst

(defthm cst-string-element-conc3-rep-of-tree-fix-cst
  (equal (cst-string-element-conc3-rep (abnf::tree-fix abnf::cst))
         (cst-string-element-conc3-rep abnf::cst)))

Theorem: cst-string-element-conc3-rep-tree-equiv-congruence-on-cst

(defthm cst-string-element-conc3-rep-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-string-element-conc3-rep abnf::cst)
                  (cst-string-element-conc3-rep cst-equiv)))
  :rule-classes :congruence)

Function: cst-literal-conc1-rep

(defun cst-literal-conc1-rep (abnf::cst)
  (declare (xargs :guard (abnf::treep abnf::cst)))
  (declare (xargs :guard (and (cst-matchp abnf::cst "literal")
                              (equal (cst-literal-conc? abnf::cst)
                                     1))))
  (let ((__function__ 'cst-literal-conc1-rep))
    (declare (ignorable __function__))
    (abnf::tree-list-fix (nth 0 (cst-literal-conc1 abnf::cst)))))

Theorem: tree-listp-of-cst-literal-conc1-rep

(defthm tree-listp-of-cst-literal-conc1-rep
  (b* ((abnf::csts (cst-literal-conc1-rep abnf::cst)))
    (abnf::tree-listp abnf::csts))
  :rule-classes :rewrite)

Theorem: cst-literal-conc1-rep-match

(defthm cst-literal-conc1-rep-match
  (implies (and (cst-matchp abnf::cst "literal")
                (equal (cst-literal-conc? abnf::cst) 1))
           (b* ((abnf::csts (cst-literal-conc1-rep abnf::cst)))
             (cst-list-rep-matchp abnf::csts "arithmetic-literal")))
  :rule-classes :rewrite)

Theorem: cst-literal-conc1-rep-of-tree-fix-cst

(defthm cst-literal-conc1-rep-of-tree-fix-cst
  (equal (cst-literal-conc1-rep (abnf::tree-fix abnf::cst))
         (cst-literal-conc1-rep abnf::cst)))

Theorem: cst-literal-conc1-rep-tree-equiv-congruence-on-cst

(defthm cst-literal-conc1-rep-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-literal-conc1-rep abnf::cst)
                  (cst-literal-conc1-rep cst-equiv)))
  :rule-classes :congruence)

Function: cst-literal-conc2-rep

(defun cst-literal-conc2-rep (abnf::cst)
  (declare (xargs :guard (abnf::treep abnf::cst)))
  (declare (xargs :guard (and (cst-matchp abnf::cst "literal")
                              (equal (cst-literal-conc? abnf::cst)
                                     2))))
  (let ((__function__ 'cst-literal-conc2-rep))
    (declare (ignorable __function__))
    (abnf::tree-list-fix (nth 0 (cst-literal-conc2 abnf::cst)))))

Theorem: tree-listp-of-cst-literal-conc2-rep

(defthm tree-listp-of-cst-literal-conc2-rep
  (b* ((abnf::csts (cst-literal-conc2-rep abnf::cst)))
    (abnf::tree-listp abnf::csts))
  :rule-classes :rewrite)

Theorem: cst-literal-conc2-rep-match

(defthm cst-literal-conc2-rep-match
  (implies (and (cst-matchp abnf::cst "literal")
                (equal (cst-literal-conc? abnf::cst) 2))
           (b* ((abnf::csts (cst-literal-conc2-rep abnf::cst)))
             (cst-list-rep-matchp abnf::csts "address-literal")))
  :rule-classes :rewrite)

Theorem: cst-literal-conc2-rep-of-tree-fix-cst

(defthm cst-literal-conc2-rep-of-tree-fix-cst
  (equal (cst-literal-conc2-rep (abnf::tree-fix abnf::cst))
         (cst-literal-conc2-rep abnf::cst)))

Theorem: cst-literal-conc2-rep-tree-equiv-congruence-on-cst

(defthm cst-literal-conc2-rep-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-literal-conc2-rep abnf::cst)
                  (cst-literal-conc2-rep cst-equiv)))
  :rule-classes :congruence)

Function: cst-literal-conc3-rep

(defun cst-literal-conc3-rep (abnf::cst)
  (declare (xargs :guard (abnf::treep abnf::cst)))
  (declare (xargs :guard (and (cst-matchp abnf::cst "literal")
                              (equal (cst-literal-conc? abnf::cst)
                                     3))))
  (let ((__function__ 'cst-literal-conc3-rep))
    (declare (ignorable __function__))
    (abnf::tree-list-fix (nth 0 (cst-literal-conc3 abnf::cst)))))

Theorem: tree-listp-of-cst-literal-conc3-rep

(defthm tree-listp-of-cst-literal-conc3-rep
  (b* ((abnf::csts (cst-literal-conc3-rep abnf::cst)))
    (abnf::tree-listp abnf::csts))
  :rule-classes :rewrite)

Theorem: cst-literal-conc3-rep-match

(defthm cst-literal-conc3-rep-match
  (implies (and (cst-matchp abnf::cst "literal")
                (equal (cst-literal-conc? abnf::cst) 3))
           (b* ((abnf::csts (cst-literal-conc3-rep abnf::cst)))
             (cst-list-rep-matchp abnf::csts "boolean-literal")))
  :rule-classes :rewrite)

Theorem: cst-literal-conc3-rep-of-tree-fix-cst

(defthm cst-literal-conc3-rep-of-tree-fix-cst
  (equal (cst-literal-conc3-rep (abnf::tree-fix abnf::cst))
         (cst-literal-conc3-rep abnf::cst)))

Theorem: cst-literal-conc3-rep-tree-equiv-congruence-on-cst

(defthm cst-literal-conc3-rep-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-literal-conc3-rep abnf::cst)
                  (cst-literal-conc3-rep cst-equiv)))
  :rule-classes :congruence)

Function: cst-literal-conc4-rep

(defun cst-literal-conc4-rep (abnf::cst)
  (declare (xargs :guard (abnf::treep abnf::cst)))
  (declare (xargs :guard (and (cst-matchp abnf::cst "literal")
                              (equal (cst-literal-conc? abnf::cst)
                                     4))))
  (let ((__function__ 'cst-literal-conc4-rep))
    (declare (ignorable __function__))
    (abnf::tree-list-fix (nth 0 (cst-literal-conc4 abnf::cst)))))

Theorem: tree-listp-of-cst-literal-conc4-rep

(defthm tree-listp-of-cst-literal-conc4-rep
  (b* ((abnf::csts (cst-literal-conc4-rep abnf::cst)))
    (abnf::tree-listp abnf::csts))
  :rule-classes :rewrite)

Theorem: cst-literal-conc4-rep-match

(defthm cst-literal-conc4-rep-match
  (implies (and (cst-matchp abnf::cst "literal")
                (equal (cst-literal-conc? abnf::cst) 4))
           (b* ((abnf::csts (cst-literal-conc4-rep abnf::cst)))
             (cst-list-rep-matchp abnf::csts "string-literal")))
  :rule-classes :rewrite)

Theorem: cst-literal-conc4-rep-of-tree-fix-cst

(defthm cst-literal-conc4-rep-of-tree-fix-cst
  (equal (cst-literal-conc4-rep (abnf::tree-fix abnf::cst))
         (cst-literal-conc4-rep abnf::cst)))

Theorem: cst-literal-conc4-rep-tree-equiv-congruence-on-cst

(defthm cst-literal-conc4-rep-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-literal-conc4-rep abnf::cst)
                  (cst-literal-conc4-rep cst-equiv)))
  :rule-classes :congruence)

Function: cst-integer-type-conc1-rep

(defun cst-integer-type-conc1-rep (abnf::cst)
 (declare (xargs :guard (abnf::treep abnf::cst)))
 (declare
      (xargs :guard (and (cst-matchp abnf::cst "integer-type")
                         (equal (cst-integer-type-conc? abnf::cst)
                                1))))
 (let ((__function__ 'cst-integer-type-conc1-rep))
  (declare (ignorable __function__))
  (abnf::tree-list-fix (nth 0 (cst-integer-type-conc1 abnf::cst)))))

Theorem: tree-listp-of-cst-integer-type-conc1-rep

(defthm tree-listp-of-cst-integer-type-conc1-rep
  (b* ((abnf::csts (cst-integer-type-conc1-rep abnf::cst)))
    (abnf::tree-listp abnf::csts))
  :rule-classes :rewrite)

Theorem: cst-integer-type-conc1-rep-match

(defthm cst-integer-type-conc1-rep-match
  (implies (and (cst-matchp abnf::cst "integer-type")
                (equal (cst-integer-type-conc? abnf::cst)
                       1))
           (b* ((abnf::csts (cst-integer-type-conc1-rep abnf::cst)))
             (cst-list-rep-matchp abnf::csts "unsigned-type")))
  :rule-classes :rewrite)

Theorem: cst-integer-type-conc1-rep-of-tree-fix-cst

(defthm cst-integer-type-conc1-rep-of-tree-fix-cst
  (equal (cst-integer-type-conc1-rep (abnf::tree-fix abnf::cst))
         (cst-integer-type-conc1-rep abnf::cst)))

Theorem: cst-integer-type-conc1-rep-tree-equiv-congruence-on-cst

(defthm cst-integer-type-conc1-rep-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-integer-type-conc1-rep abnf::cst)
                  (cst-integer-type-conc1-rep cst-equiv)))
  :rule-classes :congruence)

Function: cst-integer-type-conc2-rep

(defun cst-integer-type-conc2-rep (abnf::cst)
 (declare (xargs :guard (abnf::treep abnf::cst)))
 (declare
      (xargs :guard (and (cst-matchp abnf::cst "integer-type")
                         (equal (cst-integer-type-conc? abnf::cst)
                                2))))
 (let ((__function__ 'cst-integer-type-conc2-rep))
  (declare (ignorable __function__))
  (abnf::tree-list-fix (nth 0 (cst-integer-type-conc2 abnf::cst)))))

Theorem: tree-listp-of-cst-integer-type-conc2-rep

(defthm tree-listp-of-cst-integer-type-conc2-rep
  (b* ((abnf::csts (cst-integer-type-conc2-rep abnf::cst)))
    (abnf::tree-listp abnf::csts))
  :rule-classes :rewrite)

Theorem: cst-integer-type-conc2-rep-match

(defthm cst-integer-type-conc2-rep-match
  (implies (and (cst-matchp abnf::cst "integer-type")
                (equal (cst-integer-type-conc? abnf::cst)
                       2))
           (b* ((abnf::csts (cst-integer-type-conc2-rep abnf::cst)))
             (cst-list-rep-matchp abnf::csts "signed-type")))
  :rule-classes :rewrite)

Theorem: cst-integer-type-conc2-rep-of-tree-fix-cst

(defthm cst-integer-type-conc2-rep-of-tree-fix-cst
  (equal (cst-integer-type-conc2-rep (abnf::tree-fix abnf::cst))
         (cst-integer-type-conc2-rep abnf::cst)))

Theorem: cst-integer-type-conc2-rep-tree-equiv-congruence-on-cst

(defthm cst-integer-type-conc2-rep-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-integer-type-conc2-rep abnf::cst)
                  (cst-integer-type-conc2-rep cst-equiv)))
  :rule-classes :congruence)

Function: cst-field-type-conc-rep

(defun cst-field-type-conc-rep (abnf::cst)
  (declare (xargs :guard (abnf::treep abnf::cst)))
  (declare (xargs :guard (cst-matchp abnf::cst "field-type")))
  (let ((__function__ 'cst-field-type-conc-rep))
    (declare (ignorable __function__))
    (abnf::tree-list-fix (nth 0 (cst-field-type-conc abnf::cst)))))

Theorem: tree-listp-of-cst-field-type-conc-rep

(defthm tree-listp-of-cst-field-type-conc-rep
  (b* ((abnf::csts (cst-field-type-conc-rep abnf::cst)))
    (abnf::tree-listp abnf::csts))
  :rule-classes :rewrite)

Theorem: cst-field-type-conc-rep-match

(defthm cst-field-type-conc-rep-match
  (implies (cst-matchp abnf::cst "field-type")
           (b* ((abnf::csts (cst-field-type-conc-rep abnf::cst)))
             (cst-list-rep-matchp abnf::csts "%s\"field\"")))
  :rule-classes :rewrite)

Theorem: cst-field-type-conc-rep-of-tree-fix-cst

(defthm cst-field-type-conc-rep-of-tree-fix-cst
  (equal (cst-field-type-conc-rep (abnf::tree-fix abnf::cst))
         (cst-field-type-conc-rep abnf::cst)))

Theorem: cst-field-type-conc-rep-tree-equiv-congruence-on-cst

(defthm cst-field-type-conc-rep-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-field-type-conc-rep abnf::cst)
                  (cst-field-type-conc-rep cst-equiv)))
  :rule-classes :congruence)

Function: cst-group-type-conc-rep

(defun cst-group-type-conc-rep (abnf::cst)
  (declare (xargs :guard (abnf::treep abnf::cst)))
  (declare (xargs :guard (cst-matchp abnf::cst "group-type")))
  (let ((__function__ 'cst-group-type-conc-rep))
    (declare (ignorable __function__))
    (abnf::tree-list-fix (nth 0 (cst-group-type-conc abnf::cst)))))

Theorem: tree-listp-of-cst-group-type-conc-rep

(defthm tree-listp-of-cst-group-type-conc-rep
  (b* ((abnf::csts (cst-group-type-conc-rep abnf::cst)))
    (abnf::tree-listp abnf::csts))
  :rule-classes :rewrite)

Theorem: cst-group-type-conc-rep-match

(defthm cst-group-type-conc-rep-match
  (implies (cst-matchp abnf::cst "group-type")
           (b* ((abnf::csts (cst-group-type-conc-rep abnf::cst)))
             (cst-list-rep-matchp abnf::csts "%s\"group\"")))
  :rule-classes :rewrite)

Theorem: cst-group-type-conc-rep-of-tree-fix-cst

(defthm cst-group-type-conc-rep-of-tree-fix-cst
  (equal (cst-group-type-conc-rep (abnf::tree-fix abnf::cst))
         (cst-group-type-conc-rep abnf::cst)))

Theorem: cst-group-type-conc-rep-tree-equiv-congruence-on-cst

(defthm cst-group-type-conc-rep-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-group-type-conc-rep abnf::cst)
                  (cst-group-type-conc-rep cst-equiv)))
  :rule-classes :congruence)

Function: cst-scalar-type-conc-rep

(defun cst-scalar-type-conc-rep (abnf::cst)
  (declare (xargs :guard (abnf::treep abnf::cst)))
  (declare (xargs :guard (cst-matchp abnf::cst "scalar-type")))
  (let ((__function__ 'cst-scalar-type-conc-rep))
    (declare (ignorable __function__))
    (abnf::tree-list-fix (nth 0 (cst-scalar-type-conc abnf::cst)))))

Theorem: tree-listp-of-cst-scalar-type-conc-rep

(defthm tree-listp-of-cst-scalar-type-conc-rep
  (b* ((abnf::csts (cst-scalar-type-conc-rep abnf::cst)))
    (abnf::tree-listp abnf::csts))
  :rule-classes :rewrite)

Theorem: cst-scalar-type-conc-rep-match

(defthm cst-scalar-type-conc-rep-match
  (implies (cst-matchp abnf::cst "scalar-type")
           (b* ((abnf::csts (cst-scalar-type-conc-rep abnf::cst)))
             (cst-list-rep-matchp abnf::csts "%s\"scalar\"")))
  :rule-classes :rewrite)

Theorem: cst-scalar-type-conc-rep-of-tree-fix-cst

(defthm cst-scalar-type-conc-rep-of-tree-fix-cst
  (equal (cst-scalar-type-conc-rep (abnf::tree-fix abnf::cst))
         (cst-scalar-type-conc-rep abnf::cst)))

Theorem: cst-scalar-type-conc-rep-tree-equiv-congruence-on-cst

(defthm cst-scalar-type-conc-rep-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-scalar-type-conc-rep abnf::cst)
                  (cst-scalar-type-conc-rep cst-equiv)))
  :rule-classes :congruence)

Function: cst-arithmetic-type-conc1-rep

(defun cst-arithmetic-type-conc1-rep (abnf::cst)
 (declare (xargs :guard (abnf::treep abnf::cst)))
 (declare
     (xargs :guard (and (cst-matchp abnf::cst "arithmetic-type")
                        (equal (cst-arithmetic-type-conc? abnf::cst)
                               1))))
 (let ((__function__ 'cst-arithmetic-type-conc1-rep))
   (declare (ignorable __function__))
   (abnf::tree-list-fix
        (nth 0
             (cst-arithmetic-type-conc1 abnf::cst)))))

Theorem: tree-listp-of-cst-arithmetic-type-conc1-rep

(defthm tree-listp-of-cst-arithmetic-type-conc1-rep
  (b* ((abnf::csts (cst-arithmetic-type-conc1-rep abnf::cst)))
    (abnf::tree-listp abnf::csts))
  :rule-classes :rewrite)

Theorem: cst-arithmetic-type-conc1-rep-match

(defthm cst-arithmetic-type-conc1-rep-match
  (implies
       (and (cst-matchp abnf::cst "arithmetic-type")
            (equal (cst-arithmetic-type-conc? abnf::cst)
                   1))
       (b* ((abnf::csts (cst-arithmetic-type-conc1-rep abnf::cst)))
         (cst-list-rep-matchp abnf::csts "integer-type")))
  :rule-classes :rewrite)

Theorem: cst-arithmetic-type-conc1-rep-of-tree-fix-cst

(defthm cst-arithmetic-type-conc1-rep-of-tree-fix-cst
  (equal (cst-arithmetic-type-conc1-rep (abnf::tree-fix abnf::cst))
         (cst-arithmetic-type-conc1-rep abnf::cst)))

Theorem: cst-arithmetic-type-conc1-rep-tree-equiv-congruence-on-cst

(defthm cst-arithmetic-type-conc1-rep-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-arithmetic-type-conc1-rep abnf::cst)
                  (cst-arithmetic-type-conc1-rep cst-equiv)))
  :rule-classes :congruence)

Function: cst-arithmetic-type-conc2-rep

(defun cst-arithmetic-type-conc2-rep (abnf::cst)
 (declare (xargs :guard (abnf::treep abnf::cst)))
 (declare
     (xargs :guard (and (cst-matchp abnf::cst "arithmetic-type")
                        (equal (cst-arithmetic-type-conc? abnf::cst)
                               2))))
 (let ((__function__ 'cst-arithmetic-type-conc2-rep))
   (declare (ignorable __function__))
   (abnf::tree-list-fix
        (nth 0
             (cst-arithmetic-type-conc2 abnf::cst)))))

Theorem: tree-listp-of-cst-arithmetic-type-conc2-rep

(defthm tree-listp-of-cst-arithmetic-type-conc2-rep
  (b* ((abnf::csts (cst-arithmetic-type-conc2-rep abnf::cst)))
    (abnf::tree-listp abnf::csts))
  :rule-classes :rewrite)

Theorem: cst-arithmetic-type-conc2-rep-match

(defthm cst-arithmetic-type-conc2-rep-match
  (implies
       (and (cst-matchp abnf::cst "arithmetic-type")
            (equal (cst-arithmetic-type-conc? abnf::cst)
                   2))
       (b* ((abnf::csts (cst-arithmetic-type-conc2-rep abnf::cst)))
         (cst-list-rep-matchp abnf::csts "field-type")))
  :rule-classes :rewrite)

Theorem: cst-arithmetic-type-conc2-rep-of-tree-fix-cst

(defthm cst-arithmetic-type-conc2-rep-of-tree-fix-cst
  (equal (cst-arithmetic-type-conc2-rep (abnf::tree-fix abnf::cst))
         (cst-arithmetic-type-conc2-rep abnf::cst)))

Theorem: cst-arithmetic-type-conc2-rep-tree-equiv-congruence-on-cst

(defthm cst-arithmetic-type-conc2-rep-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-arithmetic-type-conc2-rep abnf::cst)
                  (cst-arithmetic-type-conc2-rep cst-equiv)))
  :rule-classes :congruence)

Function: cst-arithmetic-type-conc3-rep

(defun cst-arithmetic-type-conc3-rep (abnf::cst)
 (declare (xargs :guard (abnf::treep abnf::cst)))
 (declare
     (xargs :guard (and (cst-matchp abnf::cst "arithmetic-type")
                        (equal (cst-arithmetic-type-conc? abnf::cst)
                               3))))
 (let ((__function__ 'cst-arithmetic-type-conc3-rep))
   (declare (ignorable __function__))
   (abnf::tree-list-fix
        (nth 0
             (cst-arithmetic-type-conc3 abnf::cst)))))

Theorem: tree-listp-of-cst-arithmetic-type-conc3-rep

(defthm tree-listp-of-cst-arithmetic-type-conc3-rep
  (b* ((abnf::csts (cst-arithmetic-type-conc3-rep abnf::cst)))
    (abnf::tree-listp abnf::csts))
  :rule-classes :rewrite)

Theorem: cst-arithmetic-type-conc3-rep-match

(defthm cst-arithmetic-type-conc3-rep-match
  (implies
       (and (cst-matchp abnf::cst "arithmetic-type")
            (equal (cst-arithmetic-type-conc? abnf::cst)
                   3))
       (b* ((abnf::csts (cst-arithmetic-type-conc3-rep abnf::cst)))
         (cst-list-rep-matchp abnf::csts "group-type")))
  :rule-classes :rewrite)

Theorem: cst-arithmetic-type-conc3-rep-of-tree-fix-cst

(defthm cst-arithmetic-type-conc3-rep-of-tree-fix-cst
  (equal (cst-arithmetic-type-conc3-rep (abnf::tree-fix abnf::cst))
         (cst-arithmetic-type-conc3-rep abnf::cst)))

Theorem: cst-arithmetic-type-conc3-rep-tree-equiv-congruence-on-cst

(defthm cst-arithmetic-type-conc3-rep-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-arithmetic-type-conc3-rep abnf::cst)
                  (cst-arithmetic-type-conc3-rep cst-equiv)))
  :rule-classes :congruence)

Function: cst-arithmetic-type-conc4-rep

(defun cst-arithmetic-type-conc4-rep (abnf::cst)
 (declare (xargs :guard (abnf::treep abnf::cst)))
 (declare
     (xargs :guard (and (cst-matchp abnf::cst "arithmetic-type")
                        (equal (cst-arithmetic-type-conc? abnf::cst)
                               4))))
 (let ((__function__ 'cst-arithmetic-type-conc4-rep))
   (declare (ignorable __function__))
   (abnf::tree-list-fix
        (nth 0
             (cst-arithmetic-type-conc4 abnf::cst)))))

Theorem: tree-listp-of-cst-arithmetic-type-conc4-rep

(defthm tree-listp-of-cst-arithmetic-type-conc4-rep
  (b* ((abnf::csts (cst-arithmetic-type-conc4-rep abnf::cst)))
    (abnf::tree-listp abnf::csts))
  :rule-classes :rewrite)

Theorem: cst-arithmetic-type-conc4-rep-match

(defthm cst-arithmetic-type-conc4-rep-match
  (implies
       (and (cst-matchp abnf::cst "arithmetic-type")
            (equal (cst-arithmetic-type-conc? abnf::cst)
                   4))
       (b* ((abnf::csts (cst-arithmetic-type-conc4-rep abnf::cst)))
         (cst-list-rep-matchp abnf::csts "scalar-type")))
  :rule-classes :rewrite)

Theorem: cst-arithmetic-type-conc4-rep-of-tree-fix-cst

(defthm cst-arithmetic-type-conc4-rep-of-tree-fix-cst
  (equal (cst-arithmetic-type-conc4-rep (abnf::tree-fix abnf::cst))
         (cst-arithmetic-type-conc4-rep abnf::cst)))

Theorem: cst-arithmetic-type-conc4-rep-tree-equiv-congruence-on-cst

(defthm cst-arithmetic-type-conc4-rep-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-arithmetic-type-conc4-rep abnf::cst)
                  (cst-arithmetic-type-conc4-rep cst-equiv)))
  :rule-classes :congruence)

Function: cst-address-type-conc-rep

(defun cst-address-type-conc-rep (abnf::cst)
 (declare (xargs :guard (abnf::treep abnf::cst)))
 (declare (xargs :guard (cst-matchp abnf::cst "address-type")))
 (let ((__function__ 'cst-address-type-conc-rep))
   (declare (ignorable __function__))
   (abnf::tree-list-fix (nth 0 (cst-address-type-conc abnf::cst)))))

Theorem: tree-listp-of-cst-address-type-conc-rep

(defthm tree-listp-of-cst-address-type-conc-rep
  (b* ((abnf::csts (cst-address-type-conc-rep abnf::cst)))
    (abnf::tree-listp abnf::csts))
  :rule-classes :rewrite)

Theorem: cst-address-type-conc-rep-match

(defthm cst-address-type-conc-rep-match
  (implies (cst-matchp abnf::cst "address-type")
           (b* ((abnf::csts (cst-address-type-conc-rep abnf::cst)))
             (cst-list-rep-matchp abnf::csts "%s\"address\"")))
  :rule-classes :rewrite)

Theorem: cst-address-type-conc-rep-of-tree-fix-cst

(defthm cst-address-type-conc-rep-of-tree-fix-cst
  (equal (cst-address-type-conc-rep (abnf::tree-fix abnf::cst))
         (cst-address-type-conc-rep abnf::cst)))

Theorem: cst-address-type-conc-rep-tree-equiv-congruence-on-cst

(defthm cst-address-type-conc-rep-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-address-type-conc-rep abnf::cst)
                  (cst-address-type-conc-rep cst-equiv)))
  :rule-classes :congruence)

Function: cst-boolean-type-conc-rep

(defun cst-boolean-type-conc-rep (abnf::cst)
 (declare (xargs :guard (abnf::treep abnf::cst)))
 (declare (xargs :guard (cst-matchp abnf::cst "boolean-type")))
 (let ((__function__ 'cst-boolean-type-conc-rep))
   (declare (ignorable __function__))
   (abnf::tree-list-fix (nth 0 (cst-boolean-type-conc abnf::cst)))))

Theorem: tree-listp-of-cst-boolean-type-conc-rep

(defthm tree-listp-of-cst-boolean-type-conc-rep
  (b* ((abnf::csts (cst-boolean-type-conc-rep abnf::cst)))
    (abnf::tree-listp abnf::csts))
  :rule-classes :rewrite)

Theorem: cst-boolean-type-conc-rep-match

(defthm cst-boolean-type-conc-rep-match
  (implies (cst-matchp abnf::cst "boolean-type")
           (b* ((abnf::csts (cst-boolean-type-conc-rep abnf::cst)))
             (cst-list-rep-matchp abnf::csts "%s\"boolean\"")))
  :rule-classes :rewrite)

Theorem: cst-boolean-type-conc-rep-of-tree-fix-cst

(defthm cst-boolean-type-conc-rep-of-tree-fix-cst
  (equal (cst-boolean-type-conc-rep (abnf::tree-fix abnf::cst))
         (cst-boolean-type-conc-rep abnf::cst)))

Theorem: cst-boolean-type-conc-rep-tree-equiv-congruence-on-cst

(defthm cst-boolean-type-conc-rep-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-boolean-type-conc-rep abnf::cst)
                  (cst-boolean-type-conc-rep cst-equiv)))
  :rule-classes :congruence)

Function: cst-string-type-conc-rep

(defun cst-string-type-conc-rep (abnf::cst)
  (declare (xargs :guard (abnf::treep abnf::cst)))
  (declare (xargs :guard (cst-matchp abnf::cst "string-type")))
  (let ((__function__ 'cst-string-type-conc-rep))
    (declare (ignorable __function__))
    (abnf::tree-list-fix (nth 0 (cst-string-type-conc abnf::cst)))))

Theorem: tree-listp-of-cst-string-type-conc-rep

(defthm tree-listp-of-cst-string-type-conc-rep
  (b* ((abnf::csts (cst-string-type-conc-rep abnf::cst)))
    (abnf::tree-listp abnf::csts))
  :rule-classes :rewrite)

Theorem: cst-string-type-conc-rep-match

(defthm cst-string-type-conc-rep-match
  (implies (cst-matchp abnf::cst "string-type")
           (b* ((abnf::csts (cst-string-type-conc-rep abnf::cst)))
             (cst-list-rep-matchp abnf::csts "%s\"string\"")))
  :rule-classes :rewrite)

Theorem: cst-string-type-conc-rep-of-tree-fix-cst

(defthm cst-string-type-conc-rep-of-tree-fix-cst
  (equal (cst-string-type-conc-rep (abnf::tree-fix abnf::cst))
         (cst-string-type-conc-rep abnf::cst)))

Theorem: cst-string-type-conc-rep-tree-equiv-congruence-on-cst

(defthm cst-string-type-conc-rep-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-string-type-conc-rep abnf::cst)
                  (cst-string-type-conc-rep cst-equiv)))
  :rule-classes :congruence)

Function: cst-literal-type-conc1-rep

(defun cst-literal-type-conc1-rep (abnf::cst)
 (declare (xargs :guard (abnf::treep abnf::cst)))
 (declare
      (xargs :guard (and (cst-matchp abnf::cst "literal-type")
                         (equal (cst-literal-type-conc? abnf::cst)
                                1))))
 (let ((__function__ 'cst-literal-type-conc1-rep))
  (declare (ignorable __function__))
  (abnf::tree-list-fix (nth 0 (cst-literal-type-conc1 abnf::cst)))))

Theorem: tree-listp-of-cst-literal-type-conc1-rep

(defthm tree-listp-of-cst-literal-type-conc1-rep
  (b* ((abnf::csts (cst-literal-type-conc1-rep abnf::cst)))
    (abnf::tree-listp abnf::csts))
  :rule-classes :rewrite)

Theorem: cst-literal-type-conc1-rep-match

(defthm cst-literal-type-conc1-rep-match
  (implies (and (cst-matchp abnf::cst "literal-type")
                (equal (cst-literal-type-conc? abnf::cst)
                       1))
           (b* ((abnf::csts (cst-literal-type-conc1-rep abnf::cst)))
             (cst-list-rep-matchp abnf::csts "arithmetic-type")))
  :rule-classes :rewrite)

Theorem: cst-literal-type-conc1-rep-of-tree-fix-cst

(defthm cst-literal-type-conc1-rep-of-tree-fix-cst
  (equal (cst-literal-type-conc1-rep (abnf::tree-fix abnf::cst))
         (cst-literal-type-conc1-rep abnf::cst)))

Theorem: cst-literal-type-conc1-rep-tree-equiv-congruence-on-cst

(defthm cst-literal-type-conc1-rep-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-literal-type-conc1-rep abnf::cst)
                  (cst-literal-type-conc1-rep cst-equiv)))
  :rule-classes :congruence)

Function: cst-literal-type-conc2-rep

(defun cst-literal-type-conc2-rep (abnf::cst)
 (declare (xargs :guard (abnf::treep abnf::cst)))
 (declare
      (xargs :guard (and (cst-matchp abnf::cst "literal-type")
                         (equal (cst-literal-type-conc? abnf::cst)
                                2))))
 (let ((__function__ 'cst-literal-type-conc2-rep))
  (declare (ignorable __function__))
  (abnf::tree-list-fix (nth 0 (cst-literal-type-conc2 abnf::cst)))))

Theorem: tree-listp-of-cst-literal-type-conc2-rep

(defthm tree-listp-of-cst-literal-type-conc2-rep
  (b* ((abnf::csts (cst-literal-type-conc2-rep abnf::cst)))
    (abnf::tree-listp abnf::csts))
  :rule-classes :rewrite)

Theorem: cst-literal-type-conc2-rep-match

(defthm cst-literal-type-conc2-rep-match
  (implies (and (cst-matchp abnf::cst "literal-type")
                (equal (cst-literal-type-conc? abnf::cst)
                       2))
           (b* ((abnf::csts (cst-literal-type-conc2-rep abnf::cst)))
             (cst-list-rep-matchp abnf::csts "address-type")))
  :rule-classes :rewrite)

Theorem: cst-literal-type-conc2-rep-of-tree-fix-cst

(defthm cst-literal-type-conc2-rep-of-tree-fix-cst
  (equal (cst-literal-type-conc2-rep (abnf::tree-fix abnf::cst))
         (cst-literal-type-conc2-rep abnf::cst)))

Theorem: cst-literal-type-conc2-rep-tree-equiv-congruence-on-cst

(defthm cst-literal-type-conc2-rep-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-literal-type-conc2-rep abnf::cst)
                  (cst-literal-type-conc2-rep cst-equiv)))
  :rule-classes :congruence)

Function: cst-literal-type-conc3-rep

(defun cst-literal-type-conc3-rep (abnf::cst)
 (declare (xargs :guard (abnf::treep abnf::cst)))
 (declare
      (xargs :guard (and (cst-matchp abnf::cst "literal-type")
                         (equal (cst-literal-type-conc? abnf::cst)
                                3))))
 (let ((__function__ 'cst-literal-type-conc3-rep))
  (declare (ignorable __function__))
  (abnf::tree-list-fix (nth 0 (cst-literal-type-conc3 abnf::cst)))))

Theorem: tree-listp-of-cst-literal-type-conc3-rep

(defthm tree-listp-of-cst-literal-type-conc3-rep
  (b* ((abnf::csts (cst-literal-type-conc3-rep abnf::cst)))
    (abnf::tree-listp abnf::csts))
  :rule-classes :rewrite)

Theorem: cst-literal-type-conc3-rep-match

(defthm cst-literal-type-conc3-rep-match
  (implies (and (cst-matchp abnf::cst "literal-type")
                (equal (cst-literal-type-conc? abnf::cst)
                       3))
           (b* ((abnf::csts (cst-literal-type-conc3-rep abnf::cst)))
             (cst-list-rep-matchp abnf::csts "boolean-type")))
  :rule-classes :rewrite)

Theorem: cst-literal-type-conc3-rep-of-tree-fix-cst

(defthm cst-literal-type-conc3-rep-of-tree-fix-cst
  (equal (cst-literal-type-conc3-rep (abnf::tree-fix abnf::cst))
         (cst-literal-type-conc3-rep abnf::cst)))

Theorem: cst-literal-type-conc3-rep-tree-equiv-congruence-on-cst

(defthm cst-literal-type-conc3-rep-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-literal-type-conc3-rep abnf::cst)
                  (cst-literal-type-conc3-rep cst-equiv)))
  :rule-classes :congruence)

Function: cst-literal-type-conc4-rep

(defun cst-literal-type-conc4-rep (abnf::cst)
 (declare (xargs :guard (abnf::treep abnf::cst)))
 (declare
      (xargs :guard (and (cst-matchp abnf::cst "literal-type")
                         (equal (cst-literal-type-conc? abnf::cst)
                                4))))
 (let ((__function__ 'cst-literal-type-conc4-rep))
  (declare (ignorable __function__))
  (abnf::tree-list-fix (nth 0 (cst-literal-type-conc4 abnf::cst)))))

Theorem: tree-listp-of-cst-literal-type-conc4-rep

(defthm tree-listp-of-cst-literal-type-conc4-rep
  (b* ((abnf::csts (cst-literal-type-conc4-rep abnf::cst)))
    (abnf::tree-listp abnf::csts))
  :rule-classes :rewrite)

Theorem: cst-literal-type-conc4-rep-match

(defthm cst-literal-type-conc4-rep-match
  (implies (and (cst-matchp abnf::cst "literal-type")
                (equal (cst-literal-type-conc? abnf::cst)
                       4))
           (b* ((abnf::csts (cst-literal-type-conc4-rep abnf::cst)))
             (cst-list-rep-matchp abnf::csts "string-type")))
  :rule-classes :rewrite)

Theorem: cst-literal-type-conc4-rep-of-tree-fix-cst

(defthm cst-literal-type-conc4-rep-of-tree-fix-cst
  (equal (cst-literal-type-conc4-rep (abnf::tree-fix abnf::cst))
         (cst-literal-type-conc4-rep abnf::cst)))

Theorem: cst-literal-type-conc4-rep-tree-equiv-congruence-on-cst

(defthm cst-literal-type-conc4-rep-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-literal-type-conc4-rep abnf::cst)
                  (cst-literal-type-conc4-rep cst-equiv)))
  :rule-classes :congruence)

Function: cst-plaintext-type-conc1-rep

(defun cst-plaintext-type-conc1-rep (abnf::cst)
 (declare (xargs :guard (abnf::treep abnf::cst)))
 (declare
      (xargs :guard (and (cst-matchp abnf::cst "plaintext-type")
                         (equal (cst-plaintext-type-conc? abnf::cst)
                                1))))
 (let ((__function__ 'cst-plaintext-type-conc1-rep))
  (declare (ignorable __function__))
  (abnf::tree-list-fix (nth 0
                            (cst-plaintext-type-conc1 abnf::cst)))))

Theorem: tree-listp-of-cst-plaintext-type-conc1-rep

(defthm tree-listp-of-cst-plaintext-type-conc1-rep
  (b* ((abnf::csts (cst-plaintext-type-conc1-rep abnf::cst)))
    (abnf::tree-listp abnf::csts))
  :rule-classes :rewrite)

Theorem: cst-plaintext-type-conc1-rep-match

(defthm cst-plaintext-type-conc1-rep-match
  (implies
       (and (cst-matchp abnf::cst "plaintext-type")
            (equal (cst-plaintext-type-conc? abnf::cst)
                   1))
       (b* ((abnf::csts (cst-plaintext-type-conc1-rep abnf::cst)))
         (cst-list-rep-matchp abnf::csts "literal-type")))
  :rule-classes :rewrite)

Theorem: cst-plaintext-type-conc1-rep-of-tree-fix-cst

(defthm cst-plaintext-type-conc1-rep-of-tree-fix-cst
  (equal (cst-plaintext-type-conc1-rep (abnf::tree-fix abnf::cst))
         (cst-plaintext-type-conc1-rep abnf::cst)))

Theorem: cst-plaintext-type-conc1-rep-tree-equiv-congruence-on-cst

(defthm cst-plaintext-type-conc1-rep-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-plaintext-type-conc1-rep abnf::cst)
                  (cst-plaintext-type-conc1-rep cst-equiv)))
  :rule-classes :congruence)

Function: cst-plaintext-type-conc2-rep

(defun cst-plaintext-type-conc2-rep (abnf::cst)
 (declare (xargs :guard (abnf::treep abnf::cst)))
 (declare
      (xargs :guard (and (cst-matchp abnf::cst "plaintext-type")
                         (equal (cst-plaintext-type-conc? abnf::cst)
                                2))))
 (let ((__function__ 'cst-plaintext-type-conc2-rep))
  (declare (ignorable __function__))
  (abnf::tree-list-fix (nth 0
                            (cst-plaintext-type-conc2 abnf::cst)))))

Theorem: tree-listp-of-cst-plaintext-type-conc2-rep

(defthm tree-listp-of-cst-plaintext-type-conc2-rep
  (b* ((abnf::csts (cst-plaintext-type-conc2-rep abnf::cst)))
    (abnf::tree-listp abnf::csts))
  :rule-classes :rewrite)

Theorem: cst-plaintext-type-conc2-rep-match

(defthm cst-plaintext-type-conc2-rep-match
  (implies
       (and (cst-matchp abnf::cst "plaintext-type")
            (equal (cst-plaintext-type-conc? abnf::cst)
                   2))
       (b* ((abnf::csts (cst-plaintext-type-conc2-rep abnf::cst)))
         (cst-list-rep-matchp abnf::csts "identifier")))
  :rule-classes :rewrite)

Theorem: cst-plaintext-type-conc2-rep-of-tree-fix-cst

(defthm cst-plaintext-type-conc2-rep-of-tree-fix-cst
  (equal (cst-plaintext-type-conc2-rep (abnf::tree-fix abnf::cst))
         (cst-plaintext-type-conc2-rep abnf::cst)))

Theorem: cst-plaintext-type-conc2-rep-tree-equiv-congruence-on-cst

(defthm cst-plaintext-type-conc2-rep-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-plaintext-type-conc2-rep abnf::cst)
                  (cst-plaintext-type-conc2-rep cst-equiv)))
  :rule-classes :congruence)

Function: cst-ternary-op-conc-rep

(defun cst-ternary-op-conc-rep (abnf::cst)
  (declare (xargs :guard (abnf::treep abnf::cst)))
  (declare (xargs :guard (cst-matchp abnf::cst "ternary-op")))
  (let ((__function__ 'cst-ternary-op-conc-rep))
    (declare (ignorable __function__))
    (abnf::tree-list-fix (nth 0 (cst-ternary-op-conc abnf::cst)))))

Theorem: tree-listp-of-cst-ternary-op-conc-rep

(defthm tree-listp-of-cst-ternary-op-conc-rep
  (b* ((abnf::csts (cst-ternary-op-conc-rep abnf::cst)))
    (abnf::tree-listp abnf::csts))
  :rule-classes :rewrite)

Theorem: cst-ternary-op-conc-rep-match

(defthm cst-ternary-op-conc-rep-match
  (implies (cst-matchp abnf::cst "ternary-op")
           (b* ((abnf::csts (cst-ternary-op-conc-rep abnf::cst)))
             (cst-list-rep-matchp abnf::csts "%s\"ternary\"")))
  :rule-classes :rewrite)

Theorem: cst-ternary-op-conc-rep-of-tree-fix-cst

(defthm cst-ternary-op-conc-rep-of-tree-fix-cst
  (equal (cst-ternary-op-conc-rep (abnf::tree-fix abnf::cst))
         (cst-ternary-op-conc-rep abnf::cst)))

Theorem: cst-ternary-op-conc-rep-tree-equiv-congruence-on-cst

(defthm cst-ternary-op-conc-rep-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-ternary-op-conc-rep abnf::cst)
                  (cst-ternary-op-conc-rep cst-equiv)))
  :rule-classes :congruence)

Function: cst-command-conc1-rep

(defun cst-command-conc1-rep (abnf::cst)
  (declare (xargs :guard (abnf::treep abnf::cst)))
  (declare (xargs :guard (and (cst-matchp abnf::cst "command")
                              (equal (cst-command-conc? abnf::cst)
                                     1))))
  (let ((__function__ 'cst-command-conc1-rep))
    (declare (ignorable __function__))
    (abnf::tree-list-fix (nth 0 (cst-command-conc1 abnf::cst)))))

Theorem: tree-listp-of-cst-command-conc1-rep

(defthm tree-listp-of-cst-command-conc1-rep
  (b* ((abnf::csts (cst-command-conc1-rep abnf::cst)))
    (abnf::tree-listp abnf::csts))
  :rule-classes :rewrite)

Theorem: cst-command-conc1-rep-match

(defthm cst-command-conc1-rep-match
  (implies (and (cst-matchp abnf::cst "command")
                (equal (cst-command-conc? abnf::cst) 1))
           (b* ((abnf::csts (cst-command-conc1-rep abnf::cst)))
             (cst-list-rep-matchp abnf::csts "decrement")))
  :rule-classes :rewrite)

Theorem: cst-command-conc1-rep-of-tree-fix-cst

(defthm cst-command-conc1-rep-of-tree-fix-cst
  (equal (cst-command-conc1-rep (abnf::tree-fix abnf::cst))
         (cst-command-conc1-rep abnf::cst)))

Theorem: cst-command-conc1-rep-tree-equiv-congruence-on-cst

(defthm cst-command-conc1-rep-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-command-conc1-rep abnf::cst)
                  (cst-command-conc1-rep cst-equiv)))
  :rule-classes :congruence)

Function: cst-command-conc2-rep

(defun cst-command-conc2-rep (abnf::cst)
  (declare (xargs :guard (abnf::treep abnf::cst)))
  (declare (xargs :guard (and (cst-matchp abnf::cst "command")
                              (equal (cst-command-conc? abnf::cst)
                                     2))))
  (let ((__function__ 'cst-command-conc2-rep))
    (declare (ignorable __function__))
    (abnf::tree-list-fix (nth 0 (cst-command-conc2 abnf::cst)))))

Theorem: tree-listp-of-cst-command-conc2-rep

(defthm tree-listp-of-cst-command-conc2-rep
  (b* ((abnf::csts (cst-command-conc2-rep abnf::cst)))
    (abnf::tree-listp abnf::csts))
  :rule-classes :rewrite)

Theorem: cst-command-conc2-rep-match

(defthm cst-command-conc2-rep-match
  (implies (and (cst-matchp abnf::cst "command")
                (equal (cst-command-conc? abnf::cst) 2))
           (b* ((abnf::csts (cst-command-conc2-rep abnf::cst)))
             (cst-list-rep-matchp abnf::csts "increment")))
  :rule-classes :rewrite)

Theorem: cst-command-conc2-rep-of-tree-fix-cst

(defthm cst-command-conc2-rep-of-tree-fix-cst
  (equal (cst-command-conc2-rep (abnf::tree-fix abnf::cst))
         (cst-command-conc2-rep abnf::cst)))

Theorem: cst-command-conc2-rep-tree-equiv-congruence-on-cst

(defthm cst-command-conc2-rep-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-command-conc2-rep abnf::cst)
                  (cst-command-conc2-rep cst-equiv)))
  :rule-classes :congruence)

Function: cst-command-conc3-rep

(defun cst-command-conc3-rep (abnf::cst)
  (declare (xargs :guard (abnf::treep abnf::cst)))
  (declare (xargs :guard (and (cst-matchp abnf::cst "command")
                              (equal (cst-command-conc? abnf::cst)
                                     3))))
  (let ((__function__ 'cst-command-conc3-rep))
    (declare (ignorable __function__))
    (abnf::tree-list-fix (nth 0 (cst-command-conc3 abnf::cst)))))

Theorem: tree-listp-of-cst-command-conc3-rep

(defthm tree-listp-of-cst-command-conc3-rep
  (b* ((abnf::csts (cst-command-conc3-rep abnf::cst)))
    (abnf::tree-listp abnf::csts))
  :rule-classes :rewrite)

Theorem: cst-command-conc3-rep-match

(defthm cst-command-conc3-rep-match
  (implies (and (cst-matchp abnf::cst "command")
                (equal (cst-command-conc? abnf::cst) 3))
           (b* ((abnf::csts (cst-command-conc3-rep abnf::cst)))
             (cst-list-rep-matchp abnf::csts "instruction")))
  :rule-classes :rewrite)

Theorem: cst-command-conc3-rep-of-tree-fix-cst

(defthm cst-command-conc3-rep-of-tree-fix-cst
  (equal (cst-command-conc3-rep (abnf::tree-fix abnf::cst))
         (cst-command-conc3-rep abnf::cst)))

Theorem: cst-command-conc3-rep-tree-equiv-congruence-on-cst

(defthm cst-command-conc3-rep-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-command-conc3-rep abnf::cst)
                  (cst-command-conc3-rep cst-equiv)))
  :rule-classes :congruence)

Function: cst-ht-conc-rep-elem

(defun cst-ht-conc-rep-elem (abnf::cst)
  (declare (xargs :guard (abnf::treep abnf::cst)))
  (declare (xargs :guard (cst-matchp abnf::cst "ht")))
  (let ((__function__ 'cst-ht-conc-rep-elem))
    (declare (ignorable __function__))
    (abnf::tree-fix (nth 0 (cst-ht-conc-rep abnf::cst)))))

Theorem: treep-of-cst-ht-conc-rep-elem

(defthm treep-of-cst-ht-conc-rep-elem
  (b* ((abnf::cst1 (cst-ht-conc-rep-elem abnf::cst)))
    (abnf::treep abnf::cst1))
  :rule-classes :rewrite)

Theorem: cst-ht-conc-rep-elem-match

(defthm cst-ht-conc-rep-elem-match
  (implies (cst-matchp abnf::cst "ht")
           (b* ((abnf::cst1 (cst-ht-conc-rep-elem abnf::cst)))
             (cst-matchp abnf::cst1 "%x9")))
  :rule-classes :rewrite)

Theorem: cst-ht-conc-rep-elem-of-tree-fix-cst

(defthm cst-ht-conc-rep-elem-of-tree-fix-cst
  (equal (cst-ht-conc-rep-elem (abnf::tree-fix abnf::cst))
         (cst-ht-conc-rep-elem abnf::cst)))

Theorem: cst-ht-conc-rep-elem-tree-equiv-congruence-on-cst

(defthm cst-ht-conc-rep-elem-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-ht-conc-rep-elem abnf::cst)
                  (cst-ht-conc-rep-elem cst-equiv)))
  :rule-classes :congruence)

Function: cst-lf-conc-rep-elem

(defun cst-lf-conc-rep-elem (abnf::cst)
  (declare (xargs :guard (abnf::treep abnf::cst)))
  (declare (xargs :guard (cst-matchp abnf::cst "lf")))
  (let ((__function__ 'cst-lf-conc-rep-elem))
    (declare (ignorable __function__))
    (abnf::tree-fix (nth 0 (cst-lf-conc-rep abnf::cst)))))

Theorem: treep-of-cst-lf-conc-rep-elem

(defthm treep-of-cst-lf-conc-rep-elem
  (b* ((abnf::cst1 (cst-lf-conc-rep-elem abnf::cst)))
    (abnf::treep abnf::cst1))
  :rule-classes :rewrite)

Theorem: cst-lf-conc-rep-elem-match

(defthm cst-lf-conc-rep-elem-match
  (implies (cst-matchp abnf::cst "lf")
           (b* ((abnf::cst1 (cst-lf-conc-rep-elem abnf::cst)))
             (cst-matchp abnf::cst1 "%xA")))
  :rule-classes :rewrite)

Theorem: cst-lf-conc-rep-elem-of-tree-fix-cst

(defthm cst-lf-conc-rep-elem-of-tree-fix-cst
  (equal (cst-lf-conc-rep-elem (abnf::tree-fix abnf::cst))
         (cst-lf-conc-rep-elem abnf::cst)))

Theorem: cst-lf-conc-rep-elem-tree-equiv-congruence-on-cst

(defthm cst-lf-conc-rep-elem-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-lf-conc-rep-elem abnf::cst)
                  (cst-lf-conc-rep-elem cst-equiv)))
  :rule-classes :congruence)

Function: cst-cr-conc-rep-elem

(defun cst-cr-conc-rep-elem (abnf::cst)
  (declare (xargs :guard (abnf::treep abnf::cst)))
  (declare (xargs :guard (cst-matchp abnf::cst "cr")))
  (let ((__function__ 'cst-cr-conc-rep-elem))
    (declare (ignorable __function__))
    (abnf::tree-fix (nth 0 (cst-cr-conc-rep abnf::cst)))))

Theorem: treep-of-cst-cr-conc-rep-elem

(defthm treep-of-cst-cr-conc-rep-elem
  (b* ((abnf::cst1 (cst-cr-conc-rep-elem abnf::cst)))
    (abnf::treep abnf::cst1))
  :rule-classes :rewrite)

Theorem: cst-cr-conc-rep-elem-match

(defthm cst-cr-conc-rep-elem-match
  (implies (cst-matchp abnf::cst "cr")
           (b* ((abnf::cst1 (cst-cr-conc-rep-elem abnf::cst)))
             (cst-matchp abnf::cst1 "%xD")))
  :rule-classes :rewrite)

Theorem: cst-cr-conc-rep-elem-of-tree-fix-cst

(defthm cst-cr-conc-rep-elem-of-tree-fix-cst
  (equal (cst-cr-conc-rep-elem (abnf::tree-fix abnf::cst))
         (cst-cr-conc-rep-elem abnf::cst)))

Theorem: cst-cr-conc-rep-elem-tree-equiv-congruence-on-cst

(defthm cst-cr-conc-rep-elem-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-cr-conc-rep-elem abnf::cst)
                  (cst-cr-conc-rep-elem cst-equiv)))
  :rule-classes :congruence)

Function: cst-sp-conc-rep-elem

(defun cst-sp-conc-rep-elem (abnf::cst)
  (declare (xargs :guard (abnf::treep abnf::cst)))
  (declare (xargs :guard (cst-matchp abnf::cst "sp")))
  (let ((__function__ 'cst-sp-conc-rep-elem))
    (declare (ignorable __function__))
    (abnf::tree-fix (nth 0 (cst-sp-conc-rep abnf::cst)))))

Theorem: treep-of-cst-sp-conc-rep-elem

(defthm treep-of-cst-sp-conc-rep-elem
  (b* ((abnf::cst1 (cst-sp-conc-rep-elem abnf::cst)))
    (abnf::treep abnf::cst1))
  :rule-classes :rewrite)

Theorem: cst-sp-conc-rep-elem-match

(defthm cst-sp-conc-rep-elem-match
  (implies (cst-matchp abnf::cst "sp")
           (b* ((abnf::cst1 (cst-sp-conc-rep-elem abnf::cst)))
             (cst-matchp abnf::cst1 "%x20")))
  :rule-classes :rewrite)

Theorem: cst-sp-conc-rep-elem-of-tree-fix-cst

(defthm cst-sp-conc-rep-elem-of-tree-fix-cst
  (equal (cst-sp-conc-rep-elem (abnf::tree-fix abnf::cst))
         (cst-sp-conc-rep-elem abnf::cst)))

Theorem: cst-sp-conc-rep-elem-tree-equiv-congruence-on-cst

(defthm cst-sp-conc-rep-elem-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-sp-conc-rep-elem abnf::cst)
                  (cst-sp-conc-rep-elem cst-equiv)))
  :rule-classes :congruence)

Function: cst-dq-conc-rep-elem

(defun cst-dq-conc-rep-elem (abnf::cst)
  (declare (xargs :guard (abnf::treep abnf::cst)))
  (declare (xargs :guard (cst-matchp abnf::cst "dq")))
  (let ((__function__ 'cst-dq-conc-rep-elem))
    (declare (ignorable __function__))
    (abnf::tree-fix (nth 0 (cst-dq-conc-rep abnf::cst)))))

Theorem: treep-of-cst-dq-conc-rep-elem

(defthm treep-of-cst-dq-conc-rep-elem
  (b* ((abnf::cst1 (cst-dq-conc-rep-elem abnf::cst)))
    (abnf::treep abnf::cst1))
  :rule-classes :rewrite)

Theorem: cst-dq-conc-rep-elem-match

(defthm cst-dq-conc-rep-elem-match
  (implies (cst-matchp abnf::cst "dq")
           (b* ((abnf::cst1 (cst-dq-conc-rep-elem abnf::cst)))
             (cst-matchp abnf::cst1 "%x22")))
  :rule-classes :rewrite)

Theorem: cst-dq-conc-rep-elem-of-tree-fix-cst

(defthm cst-dq-conc-rep-elem-of-tree-fix-cst
  (equal (cst-dq-conc-rep-elem (abnf::tree-fix abnf::cst))
         (cst-dq-conc-rep-elem abnf::cst)))

Theorem: cst-dq-conc-rep-elem-tree-equiv-congruence-on-cst

(defthm cst-dq-conc-rep-elem-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-dq-conc-rep-elem abnf::cst)
                  (cst-dq-conc-rep-elem cst-equiv)))
  :rule-classes :congruence)

Function: cst-visible-ascii-conc-rep-elem

(defun cst-visible-ascii-conc-rep-elem (abnf::cst)
  (declare (xargs :guard (abnf::treep abnf::cst)))
  (declare (xargs :guard (cst-matchp abnf::cst "visible-ascii")))
  (let ((__function__ 'cst-visible-ascii-conc-rep-elem))
    (declare (ignorable __function__))
    (abnf::tree-fix (nth 0
                         (cst-visible-ascii-conc-rep abnf::cst)))))

Theorem: treep-of-cst-visible-ascii-conc-rep-elem

(defthm treep-of-cst-visible-ascii-conc-rep-elem
  (b* ((abnf::cst1 (cst-visible-ascii-conc-rep-elem abnf::cst)))
    (abnf::treep abnf::cst1))
  :rule-classes :rewrite)

Theorem: cst-visible-ascii-conc-rep-elem-match

(defthm cst-visible-ascii-conc-rep-elem-match
 (implies
      (cst-matchp abnf::cst "visible-ascii")
      (b* ((abnf::cst1 (cst-visible-ascii-conc-rep-elem abnf::cst)))
        (cst-matchp abnf::cst1 "%x21-7E")))
 :rule-classes :rewrite)

Theorem: cst-visible-ascii-conc-rep-elem-of-tree-fix-cst

(defthm cst-visible-ascii-conc-rep-elem-of-tree-fix-cst
 (equal (cst-visible-ascii-conc-rep-elem (abnf::tree-fix abnf::cst))
        (cst-visible-ascii-conc-rep-elem abnf::cst)))

Theorem: cst-visible-ascii-conc-rep-elem-tree-equiv-congruence-on-cst

(defthm cst-visible-ascii-conc-rep-elem-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-visible-ascii-conc-rep-elem abnf::cst)
                  (cst-visible-ascii-conc-rep-elem cst-equiv)))
  :rule-classes :congruence)

Function: cst-safe-ascii-conc1-rep-elem

(defun cst-safe-ascii-conc1-rep-elem (abnf::cst)
 (declare (xargs :guard (abnf::treep abnf::cst)))
 (declare (xargs :guard (and (cst-matchp abnf::cst "safe-ascii")
                             (equal (cst-safe-ascii-conc? abnf::cst)
                                    1))))
 (let ((__function__ 'cst-safe-ascii-conc1-rep-elem))
   (declare (ignorable __function__))
   (abnf::tree-fix (nth 0
                        (cst-safe-ascii-conc1-rep abnf::cst)))))

Theorem: treep-of-cst-safe-ascii-conc1-rep-elem

(defthm treep-of-cst-safe-ascii-conc1-rep-elem
  (b* ((abnf::cst1 (cst-safe-ascii-conc1-rep-elem abnf::cst)))
    (abnf::treep abnf::cst1))
  :rule-classes :rewrite)

Theorem: cst-safe-ascii-conc1-rep-elem-match

(defthm cst-safe-ascii-conc1-rep-elem-match
  (implies
       (and (cst-matchp abnf::cst "safe-ascii")
            (equal (cst-safe-ascii-conc? abnf::cst)
                   1))
       (b* ((abnf::cst1 (cst-safe-ascii-conc1-rep-elem abnf::cst)))
         (cst-matchp abnf::cst1 "ht")))
  :rule-classes :rewrite)

Theorem: cst-safe-ascii-conc1-rep-elem-of-tree-fix-cst

(defthm cst-safe-ascii-conc1-rep-elem-of-tree-fix-cst
  (equal (cst-safe-ascii-conc1-rep-elem (abnf::tree-fix abnf::cst))
         (cst-safe-ascii-conc1-rep-elem abnf::cst)))

Theorem: cst-safe-ascii-conc1-rep-elem-tree-equiv-congruence-on-cst

(defthm cst-safe-ascii-conc1-rep-elem-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-safe-ascii-conc1-rep-elem abnf::cst)
                  (cst-safe-ascii-conc1-rep-elem cst-equiv)))
  :rule-classes :congruence)

Function: cst-safe-ascii-conc2-rep-elem

(defun cst-safe-ascii-conc2-rep-elem (abnf::cst)
 (declare (xargs :guard (abnf::treep abnf::cst)))
 (declare (xargs :guard (and (cst-matchp abnf::cst "safe-ascii")
                             (equal (cst-safe-ascii-conc? abnf::cst)
                                    2))))
 (let ((__function__ 'cst-safe-ascii-conc2-rep-elem))
   (declare (ignorable __function__))
   (abnf::tree-fix (nth 0
                        (cst-safe-ascii-conc2-rep abnf::cst)))))

Theorem: treep-of-cst-safe-ascii-conc2-rep-elem

(defthm treep-of-cst-safe-ascii-conc2-rep-elem
  (b* ((abnf::cst1 (cst-safe-ascii-conc2-rep-elem abnf::cst)))
    (abnf::treep abnf::cst1))
  :rule-classes :rewrite)

Theorem: cst-safe-ascii-conc2-rep-elem-match

(defthm cst-safe-ascii-conc2-rep-elem-match
  (implies
       (and (cst-matchp abnf::cst "safe-ascii")
            (equal (cst-safe-ascii-conc? abnf::cst)
                   2))
       (b* ((abnf::cst1 (cst-safe-ascii-conc2-rep-elem abnf::cst)))
         (cst-matchp abnf::cst1 "lf")))
  :rule-classes :rewrite)

Theorem: cst-safe-ascii-conc2-rep-elem-of-tree-fix-cst

(defthm cst-safe-ascii-conc2-rep-elem-of-tree-fix-cst
  (equal (cst-safe-ascii-conc2-rep-elem (abnf::tree-fix abnf::cst))
         (cst-safe-ascii-conc2-rep-elem abnf::cst)))

Theorem: cst-safe-ascii-conc2-rep-elem-tree-equiv-congruence-on-cst

(defthm cst-safe-ascii-conc2-rep-elem-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-safe-ascii-conc2-rep-elem abnf::cst)
                  (cst-safe-ascii-conc2-rep-elem cst-equiv)))
  :rule-classes :congruence)

Function: cst-safe-ascii-conc3-rep-elem

(defun cst-safe-ascii-conc3-rep-elem (abnf::cst)
 (declare (xargs :guard (abnf::treep abnf::cst)))
 (declare (xargs :guard (and (cst-matchp abnf::cst "safe-ascii")
                             (equal (cst-safe-ascii-conc? abnf::cst)
                                    3))))
 (let ((__function__ 'cst-safe-ascii-conc3-rep-elem))
   (declare (ignorable __function__))
   (abnf::tree-fix (nth 0
                        (cst-safe-ascii-conc3-rep abnf::cst)))))

Theorem: treep-of-cst-safe-ascii-conc3-rep-elem

(defthm treep-of-cst-safe-ascii-conc3-rep-elem
  (b* ((abnf::cst1 (cst-safe-ascii-conc3-rep-elem abnf::cst)))
    (abnf::treep abnf::cst1))
  :rule-classes :rewrite)

Theorem: cst-safe-ascii-conc3-rep-elem-match

(defthm cst-safe-ascii-conc3-rep-elem-match
  (implies
       (and (cst-matchp abnf::cst "safe-ascii")
            (equal (cst-safe-ascii-conc? abnf::cst)
                   3))
       (b* ((abnf::cst1 (cst-safe-ascii-conc3-rep-elem abnf::cst)))
         (cst-matchp abnf::cst1 "cr")))
  :rule-classes :rewrite)

Theorem: cst-safe-ascii-conc3-rep-elem-of-tree-fix-cst

(defthm cst-safe-ascii-conc3-rep-elem-of-tree-fix-cst
  (equal (cst-safe-ascii-conc3-rep-elem (abnf::tree-fix abnf::cst))
         (cst-safe-ascii-conc3-rep-elem abnf::cst)))

Theorem: cst-safe-ascii-conc3-rep-elem-tree-equiv-congruence-on-cst

(defthm cst-safe-ascii-conc3-rep-elem-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-safe-ascii-conc3-rep-elem abnf::cst)
                  (cst-safe-ascii-conc3-rep-elem cst-equiv)))
  :rule-classes :congruence)

Function: cst-safe-ascii-conc4-rep-elem

(defun cst-safe-ascii-conc4-rep-elem (abnf::cst)
 (declare (xargs :guard (abnf::treep abnf::cst)))
 (declare (xargs :guard (and (cst-matchp abnf::cst "safe-ascii")
                             (equal (cst-safe-ascii-conc? abnf::cst)
                                    4))))
 (let ((__function__ 'cst-safe-ascii-conc4-rep-elem))
   (declare (ignorable __function__))
   (abnf::tree-fix (nth 0
                        (cst-safe-ascii-conc4-rep abnf::cst)))))

Theorem: treep-of-cst-safe-ascii-conc4-rep-elem

(defthm treep-of-cst-safe-ascii-conc4-rep-elem
  (b* ((abnf::cst1 (cst-safe-ascii-conc4-rep-elem abnf::cst)))
    (abnf::treep abnf::cst1))
  :rule-classes :rewrite)

Theorem: cst-safe-ascii-conc4-rep-elem-match

(defthm cst-safe-ascii-conc4-rep-elem-match
  (implies
       (and (cst-matchp abnf::cst "safe-ascii")
            (equal (cst-safe-ascii-conc? abnf::cst)
                   4))
       (b* ((abnf::cst1 (cst-safe-ascii-conc4-rep-elem abnf::cst)))
         (cst-matchp abnf::cst1 "sp")))
  :rule-classes :rewrite)

Theorem: cst-safe-ascii-conc4-rep-elem-of-tree-fix-cst

(defthm cst-safe-ascii-conc4-rep-elem-of-tree-fix-cst
  (equal (cst-safe-ascii-conc4-rep-elem (abnf::tree-fix abnf::cst))
         (cst-safe-ascii-conc4-rep-elem abnf::cst)))

Theorem: cst-safe-ascii-conc4-rep-elem-tree-equiv-congruence-on-cst

(defthm cst-safe-ascii-conc4-rep-elem-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-safe-ascii-conc4-rep-elem abnf::cst)
                  (cst-safe-ascii-conc4-rep-elem cst-equiv)))
  :rule-classes :congruence)

Function: cst-safe-ascii-conc5-rep-elem

(defun cst-safe-ascii-conc5-rep-elem (abnf::cst)
 (declare (xargs :guard (abnf::treep abnf::cst)))
 (declare (xargs :guard (and (cst-matchp abnf::cst "safe-ascii")
                             (equal (cst-safe-ascii-conc? abnf::cst)
                                    5))))
 (let ((__function__ 'cst-safe-ascii-conc5-rep-elem))
   (declare (ignorable __function__))
   (abnf::tree-fix (nth 0
                        (cst-safe-ascii-conc5-rep abnf::cst)))))

Theorem: treep-of-cst-safe-ascii-conc5-rep-elem

(defthm treep-of-cst-safe-ascii-conc5-rep-elem
  (b* ((abnf::cst1 (cst-safe-ascii-conc5-rep-elem abnf::cst)))
    (abnf::treep abnf::cst1))
  :rule-classes :rewrite)

Theorem: cst-safe-ascii-conc5-rep-elem-match

(defthm cst-safe-ascii-conc5-rep-elem-match
  (implies
       (and (cst-matchp abnf::cst "safe-ascii")
            (equal (cst-safe-ascii-conc? abnf::cst)
                   5))
       (b* ((abnf::cst1 (cst-safe-ascii-conc5-rep-elem abnf::cst)))
         (cst-matchp abnf::cst1 "visible-ascii")))
  :rule-classes :rewrite)

Theorem: cst-safe-ascii-conc5-rep-elem-of-tree-fix-cst

(defthm cst-safe-ascii-conc5-rep-elem-of-tree-fix-cst
  (equal (cst-safe-ascii-conc5-rep-elem (abnf::tree-fix abnf::cst))
         (cst-safe-ascii-conc5-rep-elem abnf::cst)))

Theorem: cst-safe-ascii-conc5-rep-elem-tree-equiv-congruence-on-cst

(defthm cst-safe-ascii-conc5-rep-elem-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-safe-ascii-conc5-rep-elem abnf::cst)
                  (cst-safe-ascii-conc5-rep-elem cst-equiv)))
  :rule-classes :congruence)

Function: cst-character-conc1-rep-elem

(defun cst-character-conc1-rep-elem (abnf::cst)
  (declare (xargs :guard (abnf::treep abnf::cst)))
  (declare (xargs :guard (and (cst-matchp abnf::cst "character")
                              (equal (cst-character-conc? abnf::cst)
                                     1))))
  (let ((__function__ 'cst-character-conc1-rep-elem))
    (declare (ignorable __function__))
    (abnf::tree-fix (nth 0
                         (cst-character-conc1-rep abnf::cst)))))

Theorem: treep-of-cst-character-conc1-rep-elem

(defthm treep-of-cst-character-conc1-rep-elem
  (b* ((abnf::cst1 (cst-character-conc1-rep-elem abnf::cst)))
    (abnf::treep abnf::cst1))
  :rule-classes :rewrite)

Theorem: cst-character-conc1-rep-elem-match

(defthm cst-character-conc1-rep-elem-match
  (implies
       (and (cst-matchp abnf::cst "character")
            (equal (cst-character-conc? abnf::cst)
                   1))
       (b* ((abnf::cst1 (cst-character-conc1-rep-elem abnf::cst)))
         (cst-matchp abnf::cst1 "safe-ascii")))
  :rule-classes :rewrite)

Theorem: cst-character-conc1-rep-elem-of-tree-fix-cst

(defthm cst-character-conc1-rep-elem-of-tree-fix-cst
  (equal (cst-character-conc1-rep-elem (abnf::tree-fix abnf::cst))
         (cst-character-conc1-rep-elem abnf::cst)))

Theorem: cst-character-conc1-rep-elem-tree-equiv-congruence-on-cst

(defthm cst-character-conc1-rep-elem-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-character-conc1-rep-elem abnf::cst)
                  (cst-character-conc1-rep-elem cst-equiv)))
  :rule-classes :congruence)

Function: cst-character-conc2-rep-elem

(defun cst-character-conc2-rep-elem (abnf::cst)
  (declare (xargs :guard (abnf::treep abnf::cst)))
  (declare (xargs :guard (and (cst-matchp abnf::cst "character")
                              (equal (cst-character-conc? abnf::cst)
                                     2))))
  (let ((__function__ 'cst-character-conc2-rep-elem))
    (declare (ignorable __function__))
    (abnf::tree-fix (nth 0
                         (cst-character-conc2-rep abnf::cst)))))

Theorem: treep-of-cst-character-conc2-rep-elem

(defthm treep-of-cst-character-conc2-rep-elem
  (b* ((abnf::cst1 (cst-character-conc2-rep-elem abnf::cst)))
    (abnf::treep abnf::cst1))
  :rule-classes :rewrite)

Theorem: cst-character-conc2-rep-elem-match

(defthm cst-character-conc2-rep-elem-match
  (implies
       (and (cst-matchp abnf::cst "character")
            (equal (cst-character-conc? abnf::cst)
                   2))
       (b* ((abnf::cst1 (cst-character-conc2-rep-elem abnf::cst)))
         (cst-matchp abnf::cst1 "safe-nonascii")))
  :rule-classes :rewrite)

Theorem: cst-character-conc2-rep-elem-of-tree-fix-cst

(defthm cst-character-conc2-rep-elem-of-tree-fix-cst
  (equal (cst-character-conc2-rep-elem (abnf::tree-fix abnf::cst))
         (cst-character-conc2-rep-elem abnf::cst)))

Theorem: cst-character-conc2-rep-elem-tree-equiv-congruence-on-cst

(defthm cst-character-conc2-rep-elem-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-character-conc2-rep-elem abnf::cst)
                  (cst-character-conc2-rep-elem cst-equiv)))
  :rule-classes :congruence)

Function: cst-plain-ws-conc1-rep-elem

(defun cst-plain-ws-conc1-rep-elem (abnf::cst)
  (declare (xargs :guard (abnf::treep abnf::cst)))
  (declare (xargs :guard (and (cst-matchp abnf::cst "plain-ws")
                              (equal (cst-plain-ws-conc? abnf::cst)
                                     1))))
  (let ((__function__ 'cst-plain-ws-conc1-rep-elem))
    (declare (ignorable __function__))
    (abnf::tree-fix (nth 0 (cst-plain-ws-conc1-rep abnf::cst)))))

Theorem: treep-of-cst-plain-ws-conc1-rep-elem

(defthm treep-of-cst-plain-ws-conc1-rep-elem
  (b* ((abnf::cst1 (cst-plain-ws-conc1-rep-elem abnf::cst)))
    (abnf::treep abnf::cst1))
  :rule-classes :rewrite)

Theorem: cst-plain-ws-conc1-rep-elem-match

(defthm cst-plain-ws-conc1-rep-elem-match
 (implies (and (cst-matchp abnf::cst "plain-ws")
               (equal (cst-plain-ws-conc? abnf::cst)
                      1))
          (b* ((abnf::cst1 (cst-plain-ws-conc1-rep-elem abnf::cst)))
            (cst-matchp abnf::cst1 "ht")))
 :rule-classes :rewrite)

Theorem: cst-plain-ws-conc1-rep-elem-of-tree-fix-cst

(defthm cst-plain-ws-conc1-rep-elem-of-tree-fix-cst
  (equal (cst-plain-ws-conc1-rep-elem (abnf::tree-fix abnf::cst))
         (cst-plain-ws-conc1-rep-elem abnf::cst)))

Theorem: cst-plain-ws-conc1-rep-elem-tree-equiv-congruence-on-cst

(defthm cst-plain-ws-conc1-rep-elem-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-plain-ws-conc1-rep-elem abnf::cst)
                  (cst-plain-ws-conc1-rep-elem cst-equiv)))
  :rule-classes :congruence)

Function: cst-plain-ws-conc2-rep-elem

(defun cst-plain-ws-conc2-rep-elem (abnf::cst)
  (declare (xargs :guard (abnf::treep abnf::cst)))
  (declare (xargs :guard (and (cst-matchp abnf::cst "plain-ws")
                              (equal (cst-plain-ws-conc? abnf::cst)
                                     2))))
  (let ((__function__ 'cst-plain-ws-conc2-rep-elem))
    (declare (ignorable __function__))
    (abnf::tree-fix (nth 0 (cst-plain-ws-conc2-rep abnf::cst)))))

Theorem: treep-of-cst-plain-ws-conc2-rep-elem

(defthm treep-of-cst-plain-ws-conc2-rep-elem
  (b* ((abnf::cst1 (cst-plain-ws-conc2-rep-elem abnf::cst)))
    (abnf::treep abnf::cst1))
  :rule-classes :rewrite)

Theorem: cst-plain-ws-conc2-rep-elem-match

(defthm cst-plain-ws-conc2-rep-elem-match
 (implies (and (cst-matchp abnf::cst "plain-ws")
               (equal (cst-plain-ws-conc? abnf::cst)
                      2))
          (b* ((abnf::cst1 (cst-plain-ws-conc2-rep-elem abnf::cst)))
            (cst-matchp abnf::cst1 "sp")))
 :rule-classes :rewrite)

Theorem: cst-plain-ws-conc2-rep-elem-of-tree-fix-cst

(defthm cst-plain-ws-conc2-rep-elem-of-tree-fix-cst
  (equal (cst-plain-ws-conc2-rep-elem (abnf::tree-fix abnf::cst))
         (cst-plain-ws-conc2-rep-elem abnf::cst)))

Theorem: cst-plain-ws-conc2-rep-elem-tree-equiv-congruence-on-cst

(defthm cst-plain-ws-conc2-rep-elem-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-plain-ws-conc2-rep-elem abnf::cst)
                  (cst-plain-ws-conc2-rep-elem cst-equiv)))
  :rule-classes :congruence)

Function: cst-plain-ws-conc3-rep-elem

(defun cst-plain-ws-conc3-rep-elem (abnf::cst)
  (declare (xargs :guard (abnf::treep abnf::cst)))
  (declare (xargs :guard (and (cst-matchp abnf::cst "plain-ws")
                              (equal (cst-plain-ws-conc? abnf::cst)
                                     3))))
  (let ((__function__ 'cst-plain-ws-conc3-rep-elem))
    (declare (ignorable __function__))
    (abnf::tree-fix (nth 0 (cst-plain-ws-conc3-rep abnf::cst)))))

Theorem: treep-of-cst-plain-ws-conc3-rep-elem

(defthm treep-of-cst-plain-ws-conc3-rep-elem
  (b* ((abnf::cst1 (cst-plain-ws-conc3-rep-elem abnf::cst)))
    (abnf::treep abnf::cst1))
  :rule-classes :rewrite)

Theorem: cst-plain-ws-conc3-rep-elem-match

(defthm cst-plain-ws-conc3-rep-elem-match
 (implies (and (cst-matchp abnf::cst "plain-ws")
               (equal (cst-plain-ws-conc? abnf::cst)
                      3))
          (b* ((abnf::cst1 (cst-plain-ws-conc3-rep-elem abnf::cst)))
            (cst-matchp abnf::cst1 "lf")))
 :rule-classes :rewrite)

Theorem: cst-plain-ws-conc3-rep-elem-of-tree-fix-cst

(defthm cst-plain-ws-conc3-rep-elem-of-tree-fix-cst
  (equal (cst-plain-ws-conc3-rep-elem (abnf::tree-fix abnf::cst))
         (cst-plain-ws-conc3-rep-elem abnf::cst)))

Theorem: cst-plain-ws-conc3-rep-elem-tree-equiv-congruence-on-cst

(defthm cst-plain-ws-conc3-rep-elem-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-plain-ws-conc3-rep-elem abnf::cst)
                  (cst-plain-ws-conc3-rep-elem cst-equiv)))
  :rule-classes :congruence)

Function: cst-plain-ws-conc4-rep-elem

(defun cst-plain-ws-conc4-rep-elem (abnf::cst)
  (declare (xargs :guard (abnf::treep abnf::cst)))
  (declare (xargs :guard (and (cst-matchp abnf::cst "plain-ws")
                              (equal (cst-plain-ws-conc? abnf::cst)
                                     4))))
  (let ((__function__ 'cst-plain-ws-conc4-rep-elem))
    (declare (ignorable __function__))
    (abnf::tree-fix (nth 0 (cst-plain-ws-conc4-rep abnf::cst)))))

Theorem: treep-of-cst-plain-ws-conc4-rep-elem

(defthm treep-of-cst-plain-ws-conc4-rep-elem
  (b* ((abnf::cst1 (cst-plain-ws-conc4-rep-elem abnf::cst)))
    (abnf::treep abnf::cst1))
  :rule-classes :rewrite)

Theorem: cst-plain-ws-conc4-rep-elem-match

(defthm cst-plain-ws-conc4-rep-elem-match
 (implies (and (cst-matchp abnf::cst "plain-ws")
               (equal (cst-plain-ws-conc? abnf::cst)
                      4))
          (b* ((abnf::cst1 (cst-plain-ws-conc4-rep-elem abnf::cst)))
            (cst-matchp abnf::cst1 "cr")))
 :rule-classes :rewrite)

Theorem: cst-plain-ws-conc4-rep-elem-of-tree-fix-cst

(defthm cst-plain-ws-conc4-rep-elem-of-tree-fix-cst
  (equal (cst-plain-ws-conc4-rep-elem (abnf::tree-fix abnf::cst))
         (cst-plain-ws-conc4-rep-elem abnf::cst)))

Theorem: cst-plain-ws-conc4-rep-elem-tree-equiv-congruence-on-cst

(defthm cst-plain-ws-conc4-rep-elem-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-plain-ws-conc4-rep-elem abnf::cst)
                  (cst-plain-ws-conc4-rep-elem cst-equiv)))
  :rule-classes :congruence)

Function: cst-comment-conc1-rep-elem

(defun cst-comment-conc1-rep-elem (abnf::cst)
  (declare (xargs :guard (abnf::treep abnf::cst)))
  (declare (xargs :guard (and (cst-matchp abnf::cst "comment")
                              (equal (cst-comment-conc? abnf::cst)
                                     1))))
  (let ((__function__ 'cst-comment-conc1-rep-elem))
    (declare (ignorable __function__))
    (abnf::tree-fix (nth 0 (cst-comment-conc1-rep abnf::cst)))))

Theorem: treep-of-cst-comment-conc1-rep-elem

(defthm treep-of-cst-comment-conc1-rep-elem
  (b* ((abnf::cst1 (cst-comment-conc1-rep-elem abnf::cst)))
    (abnf::treep abnf::cst1))
  :rule-classes :rewrite)

Theorem: cst-comment-conc1-rep-elem-match

(defthm cst-comment-conc1-rep-elem-match
  (implies (and (cst-matchp abnf::cst "comment")
                (equal (cst-comment-conc? abnf::cst) 1))
           (b* ((abnf::cst1 (cst-comment-conc1-rep-elem abnf::cst)))
             (cst-matchp abnf::cst1 "line-comment")))
  :rule-classes :rewrite)

Theorem: cst-comment-conc1-rep-elem-of-tree-fix-cst

(defthm cst-comment-conc1-rep-elem-of-tree-fix-cst
  (equal (cst-comment-conc1-rep-elem (abnf::tree-fix abnf::cst))
         (cst-comment-conc1-rep-elem abnf::cst)))

Theorem: cst-comment-conc1-rep-elem-tree-equiv-congruence-on-cst

(defthm cst-comment-conc1-rep-elem-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-comment-conc1-rep-elem abnf::cst)
                  (cst-comment-conc1-rep-elem cst-equiv)))
  :rule-classes :congruence)

Function: cst-comment-conc2-rep-elem

(defun cst-comment-conc2-rep-elem (abnf::cst)
  (declare (xargs :guard (abnf::treep abnf::cst)))
  (declare (xargs :guard (and (cst-matchp abnf::cst "comment")
                              (equal (cst-comment-conc? abnf::cst)
                                     2))))
  (let ((__function__ 'cst-comment-conc2-rep-elem))
    (declare (ignorable __function__))
    (abnf::tree-fix (nth 0 (cst-comment-conc2-rep abnf::cst)))))

Theorem: treep-of-cst-comment-conc2-rep-elem

(defthm treep-of-cst-comment-conc2-rep-elem
  (b* ((abnf::cst1 (cst-comment-conc2-rep-elem abnf::cst)))
    (abnf::treep abnf::cst1))
  :rule-classes :rewrite)

Theorem: cst-comment-conc2-rep-elem-match

(defthm cst-comment-conc2-rep-elem-match
  (implies (and (cst-matchp abnf::cst "comment")
                (equal (cst-comment-conc? abnf::cst) 2))
           (b* ((abnf::cst1 (cst-comment-conc2-rep-elem abnf::cst)))
             (cst-matchp abnf::cst1 "block-comment")))
  :rule-classes :rewrite)

Theorem: cst-comment-conc2-rep-elem-of-tree-fix-cst

(defthm cst-comment-conc2-rep-elem-of-tree-fix-cst
  (equal (cst-comment-conc2-rep-elem (abnf::tree-fix abnf::cst))
         (cst-comment-conc2-rep-elem abnf::cst)))

Theorem: cst-comment-conc2-rep-elem-tree-equiv-congruence-on-cst

(defthm cst-comment-conc2-rep-elem-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-comment-conc2-rep-elem abnf::cst)
                  (cst-comment-conc2-rep-elem cst-equiv)))
  :rule-classes :congruence)

Function: cst-not-lf-or-cr-conc1-rep-elem

(defun cst-not-lf-or-cr-conc1-rep-elem (abnf::cst)
  (declare (xargs :guard (abnf::treep abnf::cst)))
  (declare
       (xargs :guard (and (cst-matchp abnf::cst "not-lf-or-cr")
                          (equal (cst-not-lf-or-cr-conc? abnf::cst)
                                 1))))
  (let ((__function__ 'cst-not-lf-or-cr-conc1-rep-elem))
    (declare (ignorable __function__))
    (abnf::tree-fix (nth 0
                         (cst-not-lf-or-cr-conc1-rep abnf::cst)))))

Theorem: treep-of-cst-not-lf-or-cr-conc1-rep-elem

(defthm treep-of-cst-not-lf-or-cr-conc1-rep-elem
  (b* ((abnf::cst1 (cst-not-lf-or-cr-conc1-rep-elem abnf::cst)))
    (abnf::treep abnf::cst1))
  :rule-classes :rewrite)

Theorem: cst-not-lf-or-cr-conc1-rep-elem-match

(defthm cst-not-lf-or-cr-conc1-rep-elem-match
 (implies
      (and (cst-matchp abnf::cst "not-lf-or-cr")
           (equal (cst-not-lf-or-cr-conc? abnf::cst)
                  1))
      (b* ((abnf::cst1 (cst-not-lf-or-cr-conc1-rep-elem abnf::cst)))
        (cst-matchp abnf::cst1 "ht")))
 :rule-classes :rewrite)

Theorem: cst-not-lf-or-cr-conc1-rep-elem-of-tree-fix-cst

(defthm cst-not-lf-or-cr-conc1-rep-elem-of-tree-fix-cst
 (equal (cst-not-lf-or-cr-conc1-rep-elem (abnf::tree-fix abnf::cst))
        (cst-not-lf-or-cr-conc1-rep-elem abnf::cst)))

Theorem: cst-not-lf-or-cr-conc1-rep-elem-tree-equiv-congruence-on-cst

(defthm cst-not-lf-or-cr-conc1-rep-elem-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-not-lf-or-cr-conc1-rep-elem abnf::cst)
                  (cst-not-lf-or-cr-conc1-rep-elem cst-equiv)))
  :rule-classes :congruence)

Function: cst-not-lf-or-cr-conc2-rep-elem

(defun cst-not-lf-or-cr-conc2-rep-elem (abnf::cst)
  (declare (xargs :guard (abnf::treep abnf::cst)))
  (declare
       (xargs :guard (and (cst-matchp abnf::cst "not-lf-or-cr")
                          (equal (cst-not-lf-or-cr-conc? abnf::cst)
                                 2))))
  (let ((__function__ 'cst-not-lf-or-cr-conc2-rep-elem))
    (declare (ignorable __function__))
    (abnf::tree-fix (nth 0
                         (cst-not-lf-or-cr-conc2-rep abnf::cst)))))

Theorem: treep-of-cst-not-lf-or-cr-conc2-rep-elem

(defthm treep-of-cst-not-lf-or-cr-conc2-rep-elem
  (b* ((abnf::cst1 (cst-not-lf-or-cr-conc2-rep-elem abnf::cst)))
    (abnf::treep abnf::cst1))
  :rule-classes :rewrite)

Theorem: cst-not-lf-or-cr-conc2-rep-elem-match

(defthm cst-not-lf-or-cr-conc2-rep-elem-match
 (implies
      (and (cst-matchp abnf::cst "not-lf-or-cr")
           (equal (cst-not-lf-or-cr-conc? abnf::cst)
                  2))
      (b* ((abnf::cst1 (cst-not-lf-or-cr-conc2-rep-elem abnf::cst)))
        (cst-matchp abnf::cst1 "sp")))
 :rule-classes :rewrite)

Theorem: cst-not-lf-or-cr-conc2-rep-elem-of-tree-fix-cst

(defthm cst-not-lf-or-cr-conc2-rep-elem-of-tree-fix-cst
 (equal (cst-not-lf-or-cr-conc2-rep-elem (abnf::tree-fix abnf::cst))
        (cst-not-lf-or-cr-conc2-rep-elem abnf::cst)))

Theorem: cst-not-lf-or-cr-conc2-rep-elem-tree-equiv-congruence-on-cst

(defthm cst-not-lf-or-cr-conc2-rep-elem-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-not-lf-or-cr-conc2-rep-elem abnf::cst)
                  (cst-not-lf-or-cr-conc2-rep-elem cst-equiv)))
  :rule-classes :congruence)

Function: cst-not-lf-or-cr-conc3-rep-elem

(defun cst-not-lf-or-cr-conc3-rep-elem (abnf::cst)
  (declare (xargs :guard (abnf::treep abnf::cst)))
  (declare
       (xargs :guard (and (cst-matchp abnf::cst "not-lf-or-cr")
                          (equal (cst-not-lf-or-cr-conc? abnf::cst)
                                 3))))
  (let ((__function__ 'cst-not-lf-or-cr-conc3-rep-elem))
    (declare (ignorable __function__))
    (abnf::tree-fix (nth 0
                         (cst-not-lf-or-cr-conc3-rep abnf::cst)))))

Theorem: treep-of-cst-not-lf-or-cr-conc3-rep-elem

(defthm treep-of-cst-not-lf-or-cr-conc3-rep-elem
  (b* ((abnf::cst1 (cst-not-lf-or-cr-conc3-rep-elem abnf::cst)))
    (abnf::treep abnf::cst1))
  :rule-classes :rewrite)

Theorem: cst-not-lf-or-cr-conc3-rep-elem-match

(defthm cst-not-lf-or-cr-conc3-rep-elem-match
 (implies
      (and (cst-matchp abnf::cst "not-lf-or-cr")
           (equal (cst-not-lf-or-cr-conc? abnf::cst)
                  3))
      (b* ((abnf::cst1 (cst-not-lf-or-cr-conc3-rep-elem abnf::cst)))
        (cst-matchp abnf::cst1 "visible-ascii")))
 :rule-classes :rewrite)

Theorem: cst-not-lf-or-cr-conc3-rep-elem-of-tree-fix-cst

(defthm cst-not-lf-or-cr-conc3-rep-elem-of-tree-fix-cst
 (equal (cst-not-lf-or-cr-conc3-rep-elem (abnf::tree-fix abnf::cst))
        (cst-not-lf-or-cr-conc3-rep-elem abnf::cst)))

Theorem: cst-not-lf-or-cr-conc3-rep-elem-tree-equiv-congruence-on-cst

(defthm cst-not-lf-or-cr-conc3-rep-elem-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-not-lf-or-cr-conc3-rep-elem abnf::cst)
                  (cst-not-lf-or-cr-conc3-rep-elem cst-equiv)))
  :rule-classes :congruence)

Function: cst-not-lf-or-cr-conc4-rep-elem

(defun cst-not-lf-or-cr-conc4-rep-elem (abnf::cst)
  (declare (xargs :guard (abnf::treep abnf::cst)))
  (declare
       (xargs :guard (and (cst-matchp abnf::cst "not-lf-or-cr")
                          (equal (cst-not-lf-or-cr-conc? abnf::cst)
                                 4))))
  (let ((__function__ 'cst-not-lf-or-cr-conc4-rep-elem))
    (declare (ignorable __function__))
    (abnf::tree-fix (nth 0
                         (cst-not-lf-or-cr-conc4-rep abnf::cst)))))

Theorem: treep-of-cst-not-lf-or-cr-conc4-rep-elem

(defthm treep-of-cst-not-lf-or-cr-conc4-rep-elem
  (b* ((abnf::cst1 (cst-not-lf-or-cr-conc4-rep-elem abnf::cst)))
    (abnf::treep abnf::cst1))
  :rule-classes :rewrite)

Theorem: cst-not-lf-or-cr-conc4-rep-elem-match

(defthm cst-not-lf-or-cr-conc4-rep-elem-match
 (implies
      (and (cst-matchp abnf::cst "not-lf-or-cr")
           (equal (cst-not-lf-or-cr-conc? abnf::cst)
                  4))
      (b* ((abnf::cst1 (cst-not-lf-or-cr-conc4-rep-elem abnf::cst)))
        (cst-matchp abnf::cst1 "safe-nonascii")))
 :rule-classes :rewrite)

Theorem: cst-not-lf-or-cr-conc4-rep-elem-of-tree-fix-cst

(defthm cst-not-lf-or-cr-conc4-rep-elem-of-tree-fix-cst
 (equal (cst-not-lf-or-cr-conc4-rep-elem (abnf::tree-fix abnf::cst))
        (cst-not-lf-or-cr-conc4-rep-elem abnf::cst)))

Theorem: cst-not-lf-or-cr-conc4-rep-elem-tree-equiv-congruence-on-cst

(defthm cst-not-lf-or-cr-conc4-rep-elem-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-not-lf-or-cr-conc4-rep-elem abnf::cst)
                  (cst-not-lf-or-cr-conc4-rep-elem cst-equiv)))
  :rule-classes :congruence)

Function: cst-uppercase-letter-conc-rep-elem

(defun cst-uppercase-letter-conc-rep-elem (abnf::cst)
 (declare (xargs :guard (abnf::treep abnf::cst)))
 (declare (xargs :guard (cst-matchp abnf::cst "uppercase-letter")))
 (let ((__function__ 'cst-uppercase-letter-conc-rep-elem))
  (declare (ignorable __function__))
  (abnf::tree-fix (nth 0
                       (cst-uppercase-letter-conc-rep abnf::cst)))))

Theorem: treep-of-cst-uppercase-letter-conc-rep-elem

(defthm treep-of-cst-uppercase-letter-conc-rep-elem
  (b* ((abnf::cst1 (cst-uppercase-letter-conc-rep-elem abnf::cst)))
    (abnf::treep abnf::cst1))
  :rule-classes :rewrite)

Theorem: cst-uppercase-letter-conc-rep-elem-match

(defthm cst-uppercase-letter-conc-rep-elem-match
 (implies
   (cst-matchp abnf::cst "uppercase-letter")
   (b* ((abnf::cst1 (cst-uppercase-letter-conc-rep-elem abnf::cst)))
     (cst-matchp abnf::cst1 "%x41-5A")))
 :rule-classes :rewrite)

Theorem: cst-uppercase-letter-conc-rep-elem-of-tree-fix-cst

(defthm cst-uppercase-letter-conc-rep-elem-of-tree-fix-cst
 (equal
     (cst-uppercase-letter-conc-rep-elem (abnf::tree-fix abnf::cst))
     (cst-uppercase-letter-conc-rep-elem abnf::cst)))

Theorem: cst-uppercase-letter-conc-rep-elem-tree-equiv-congruence-on-cst

(defthm
    cst-uppercase-letter-conc-rep-elem-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-uppercase-letter-conc-rep-elem abnf::cst)
                  (cst-uppercase-letter-conc-rep-elem cst-equiv)))
  :rule-classes :congruence)

Function: cst-lowercase-letter-conc-rep-elem

(defun cst-lowercase-letter-conc-rep-elem (abnf::cst)
 (declare (xargs :guard (abnf::treep abnf::cst)))
 (declare (xargs :guard (cst-matchp abnf::cst "lowercase-letter")))
 (let ((__function__ 'cst-lowercase-letter-conc-rep-elem))
  (declare (ignorable __function__))
  (abnf::tree-fix (nth 0
                       (cst-lowercase-letter-conc-rep abnf::cst)))))

Theorem: treep-of-cst-lowercase-letter-conc-rep-elem

(defthm treep-of-cst-lowercase-letter-conc-rep-elem
  (b* ((abnf::cst1 (cst-lowercase-letter-conc-rep-elem abnf::cst)))
    (abnf::treep abnf::cst1))
  :rule-classes :rewrite)

Theorem: cst-lowercase-letter-conc-rep-elem-match

(defthm cst-lowercase-letter-conc-rep-elem-match
 (implies
   (cst-matchp abnf::cst "lowercase-letter")
   (b* ((abnf::cst1 (cst-lowercase-letter-conc-rep-elem abnf::cst)))
     (cst-matchp abnf::cst1 "%x61-7A")))
 :rule-classes :rewrite)

Theorem: cst-lowercase-letter-conc-rep-elem-of-tree-fix-cst

(defthm cst-lowercase-letter-conc-rep-elem-of-tree-fix-cst
 (equal
     (cst-lowercase-letter-conc-rep-elem (abnf::tree-fix abnf::cst))
     (cst-lowercase-letter-conc-rep-elem abnf::cst)))

Theorem: cst-lowercase-letter-conc-rep-elem-tree-equiv-congruence-on-cst

(defthm
    cst-lowercase-letter-conc-rep-elem-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-lowercase-letter-conc-rep-elem abnf::cst)
                  (cst-lowercase-letter-conc-rep-elem cst-equiv)))
  :rule-classes :congruence)

Function: cst-letter-conc1-rep-elem

(defun cst-letter-conc1-rep-elem (abnf::cst)
  (declare (xargs :guard (abnf::treep abnf::cst)))
  (declare (xargs :guard (and (cst-matchp abnf::cst "letter")
                              (equal (cst-letter-conc? abnf::cst)
                                     1))))
  (let ((__function__ 'cst-letter-conc1-rep-elem))
    (declare (ignorable __function__))
    (abnf::tree-fix (nth 0 (cst-letter-conc1-rep abnf::cst)))))

Theorem: treep-of-cst-letter-conc1-rep-elem

(defthm treep-of-cst-letter-conc1-rep-elem
  (b* ((abnf::cst1 (cst-letter-conc1-rep-elem abnf::cst)))
    (abnf::treep abnf::cst1))
  :rule-classes :rewrite)

Theorem: cst-letter-conc1-rep-elem-match

(defthm cst-letter-conc1-rep-elem-match
  (implies (and (cst-matchp abnf::cst "letter")
                (equal (cst-letter-conc? abnf::cst) 1))
           (b* ((abnf::cst1 (cst-letter-conc1-rep-elem abnf::cst)))
             (cst-matchp abnf::cst1 "uppercase-letter")))
  :rule-classes :rewrite)

Theorem: cst-letter-conc1-rep-elem-of-tree-fix-cst

(defthm cst-letter-conc1-rep-elem-of-tree-fix-cst
  (equal (cst-letter-conc1-rep-elem (abnf::tree-fix abnf::cst))
         (cst-letter-conc1-rep-elem abnf::cst)))

Theorem: cst-letter-conc1-rep-elem-tree-equiv-congruence-on-cst

(defthm cst-letter-conc1-rep-elem-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-letter-conc1-rep-elem abnf::cst)
                  (cst-letter-conc1-rep-elem cst-equiv)))
  :rule-classes :congruence)

Function: cst-letter-conc2-rep-elem

(defun cst-letter-conc2-rep-elem (abnf::cst)
  (declare (xargs :guard (abnf::treep abnf::cst)))
  (declare (xargs :guard (and (cst-matchp abnf::cst "letter")
                              (equal (cst-letter-conc? abnf::cst)
                                     2))))
  (let ((__function__ 'cst-letter-conc2-rep-elem))
    (declare (ignorable __function__))
    (abnf::tree-fix (nth 0 (cst-letter-conc2-rep abnf::cst)))))

Theorem: treep-of-cst-letter-conc2-rep-elem

(defthm treep-of-cst-letter-conc2-rep-elem
  (b* ((abnf::cst1 (cst-letter-conc2-rep-elem abnf::cst)))
    (abnf::treep abnf::cst1))
  :rule-classes :rewrite)

Theorem: cst-letter-conc2-rep-elem-match

(defthm cst-letter-conc2-rep-elem-match
  (implies (and (cst-matchp abnf::cst "letter")
                (equal (cst-letter-conc? abnf::cst) 2))
           (b* ((abnf::cst1 (cst-letter-conc2-rep-elem abnf::cst)))
             (cst-matchp abnf::cst1 "lowercase-letter")))
  :rule-classes :rewrite)

Theorem: cst-letter-conc2-rep-elem-of-tree-fix-cst

(defthm cst-letter-conc2-rep-elem-of-tree-fix-cst
  (equal (cst-letter-conc2-rep-elem (abnf::tree-fix abnf::cst))
         (cst-letter-conc2-rep-elem abnf::cst)))

Theorem: cst-letter-conc2-rep-elem-tree-equiv-congruence-on-cst

(defthm cst-letter-conc2-rep-elem-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-letter-conc2-rep-elem abnf::cst)
                  (cst-letter-conc2-rep-elem cst-equiv)))
  :rule-classes :congruence)

Function: cst-digit-conc-rep-elem

(defun cst-digit-conc-rep-elem (abnf::cst)
  (declare (xargs :guard (abnf::treep abnf::cst)))
  (declare (xargs :guard (cst-matchp abnf::cst "digit")))
  (let ((__function__ 'cst-digit-conc-rep-elem))
    (declare (ignorable __function__))
    (abnf::tree-fix (nth 0 (cst-digit-conc-rep abnf::cst)))))

Theorem: treep-of-cst-digit-conc-rep-elem

(defthm treep-of-cst-digit-conc-rep-elem
  (b* ((abnf::cst1 (cst-digit-conc-rep-elem abnf::cst)))
    (abnf::treep abnf::cst1))
  :rule-classes :rewrite)

Theorem: cst-digit-conc-rep-elem-match

(defthm cst-digit-conc-rep-elem-match
  (implies (cst-matchp abnf::cst "digit")
           (b* ((abnf::cst1 (cst-digit-conc-rep-elem abnf::cst)))
             (cst-matchp abnf::cst1 "%x30-39")))
  :rule-classes :rewrite)

Theorem: cst-digit-conc-rep-elem-of-tree-fix-cst

(defthm cst-digit-conc-rep-elem-of-tree-fix-cst
  (equal (cst-digit-conc-rep-elem (abnf::tree-fix abnf::cst))
         (cst-digit-conc-rep-elem abnf::cst)))

Theorem: cst-digit-conc-rep-elem-tree-equiv-congruence-on-cst

(defthm cst-digit-conc-rep-elem-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-digit-conc-rep-elem abnf::cst)
                  (cst-digit-conc-rep-elem cst-equiv)))
  :rule-classes :congruence)

Function: cst-integer-literal-conc1-rep-elem

(defun cst-integer-literal-conc1-rep-elem (abnf::cst)
 (declare (xargs :guard (abnf::treep abnf::cst)))
 (declare
     (xargs :guard (and (cst-matchp abnf::cst "integer-literal")
                        (equal (cst-integer-literal-conc? abnf::cst)
                               1))))
 (let ((__function__ 'cst-integer-literal-conc1-rep-elem))
  (declare (ignorable __function__))
  (abnf::tree-fix (nth 0
                       (cst-integer-literal-conc1-rep abnf::cst)))))

Theorem: treep-of-cst-integer-literal-conc1-rep-elem

(defthm treep-of-cst-integer-literal-conc1-rep-elem
  (b* ((abnf::cst1 (cst-integer-literal-conc1-rep-elem abnf::cst)))
    (abnf::treep abnf::cst1))
  :rule-classes :rewrite)

Theorem: cst-integer-literal-conc1-rep-elem-match

(defthm cst-integer-literal-conc1-rep-elem-match
 (implies
   (and (cst-matchp abnf::cst "integer-literal")
        (equal (cst-integer-literal-conc? abnf::cst)
               1))
   (b* ((abnf::cst1 (cst-integer-literal-conc1-rep-elem abnf::cst)))
     (cst-matchp abnf::cst1 "signed-literal")))
 :rule-classes :rewrite)

Theorem: cst-integer-literal-conc1-rep-elem-of-tree-fix-cst

(defthm cst-integer-literal-conc1-rep-elem-of-tree-fix-cst
 (equal
     (cst-integer-literal-conc1-rep-elem (abnf::tree-fix abnf::cst))
     (cst-integer-literal-conc1-rep-elem abnf::cst)))

Theorem: cst-integer-literal-conc1-rep-elem-tree-equiv-congruence-on-cst

(defthm
    cst-integer-literal-conc1-rep-elem-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-integer-literal-conc1-rep-elem abnf::cst)
                  (cst-integer-literal-conc1-rep-elem cst-equiv)))
  :rule-classes :congruence)

Function: cst-integer-literal-conc2-rep-elem

(defun cst-integer-literal-conc2-rep-elem (abnf::cst)
 (declare (xargs :guard (abnf::treep abnf::cst)))
 (declare
     (xargs :guard (and (cst-matchp abnf::cst "integer-literal")
                        (equal (cst-integer-literal-conc? abnf::cst)
                               2))))
 (let ((__function__ 'cst-integer-literal-conc2-rep-elem))
  (declare (ignorable __function__))
  (abnf::tree-fix (nth 0
                       (cst-integer-literal-conc2-rep abnf::cst)))))

Theorem: treep-of-cst-integer-literal-conc2-rep-elem

(defthm treep-of-cst-integer-literal-conc2-rep-elem
  (b* ((abnf::cst1 (cst-integer-literal-conc2-rep-elem abnf::cst)))
    (abnf::treep abnf::cst1))
  :rule-classes :rewrite)

Theorem: cst-integer-literal-conc2-rep-elem-match

(defthm cst-integer-literal-conc2-rep-elem-match
 (implies
   (and (cst-matchp abnf::cst "integer-literal")
        (equal (cst-integer-literal-conc? abnf::cst)
               2))
   (b* ((abnf::cst1 (cst-integer-literal-conc2-rep-elem abnf::cst)))
     (cst-matchp abnf::cst1 "unsigned-literal")))
 :rule-classes :rewrite)

Theorem: cst-integer-literal-conc2-rep-elem-of-tree-fix-cst

(defthm cst-integer-literal-conc2-rep-elem-of-tree-fix-cst
 (equal
     (cst-integer-literal-conc2-rep-elem (abnf::tree-fix abnf::cst))
     (cst-integer-literal-conc2-rep-elem abnf::cst)))

Theorem: cst-integer-literal-conc2-rep-elem-tree-equiv-congruence-on-cst

(defthm
    cst-integer-literal-conc2-rep-elem-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-integer-literal-conc2-rep-elem abnf::cst)
                  (cst-integer-literal-conc2-rep-elem cst-equiv)))
  :rule-classes :congruence)

Function: cst-arithmetic-literal-conc1-rep-elem

(defun cst-arithmetic-literal-conc1-rep-elem (abnf::cst)
 (declare (xargs :guard (abnf::treep abnf::cst)))
 (declare
  (xargs :guard (and (cst-matchp abnf::cst "arithmetic-literal")
                     (equal (cst-arithmetic-literal-conc? abnf::cst)
                            1))))
 (let ((__function__ 'cst-arithmetic-literal-conc1-rep-elem))
   (declare (ignorable __function__))
   (abnf::tree-fix
        (nth 0
             (cst-arithmetic-literal-conc1-rep abnf::cst)))))

Theorem: treep-of-cst-arithmetic-literal-conc1-rep-elem

(defthm treep-of-cst-arithmetic-literal-conc1-rep-elem
  (b*
    ((abnf::cst1 (cst-arithmetic-literal-conc1-rep-elem abnf::cst)))
    (abnf::treep abnf::cst1))
  :rule-classes :rewrite)

Theorem: cst-arithmetic-literal-conc1-rep-elem-match

(defthm cst-arithmetic-literal-conc1-rep-elem-match
 (implies
   (and (cst-matchp abnf::cst "arithmetic-literal")
        (equal (cst-arithmetic-literal-conc? abnf::cst)
               1))
   (b*
    ((abnf::cst1 (cst-arithmetic-literal-conc1-rep-elem abnf::cst)))
    (cst-matchp abnf::cst1 "integer-literal")))
 :rule-classes :rewrite)

Theorem: cst-arithmetic-literal-conc1-rep-elem-of-tree-fix-cst

(defthm cst-arithmetic-literal-conc1-rep-elem-of-tree-fix-cst
 (equal
  (cst-arithmetic-literal-conc1-rep-elem (abnf::tree-fix abnf::cst))
  (cst-arithmetic-literal-conc1-rep-elem abnf::cst)))

Theorem: cst-arithmetic-literal-conc1-rep-elem-tree-equiv-congruence-on-cst

(defthm
 cst-arithmetic-literal-conc1-rep-elem-tree-equiv-congruence-on-cst
 (implies (abnf::tree-equiv abnf::cst cst-equiv)
          (equal (cst-arithmetic-literal-conc1-rep-elem abnf::cst)
                 (cst-arithmetic-literal-conc1-rep-elem cst-equiv)))
 :rule-classes :congruence)

Function: cst-arithmetic-literal-conc2-rep-elem

(defun cst-arithmetic-literal-conc2-rep-elem (abnf::cst)
 (declare (xargs :guard (abnf::treep abnf::cst)))
 (declare
  (xargs :guard (and (cst-matchp abnf::cst "arithmetic-literal")
                     (equal (cst-arithmetic-literal-conc? abnf::cst)
                            2))))
 (let ((__function__ 'cst-arithmetic-literal-conc2-rep-elem))
   (declare (ignorable __function__))
   (abnf::tree-fix
        (nth 0
             (cst-arithmetic-literal-conc2-rep abnf::cst)))))

Theorem: treep-of-cst-arithmetic-literal-conc2-rep-elem

(defthm treep-of-cst-arithmetic-literal-conc2-rep-elem
  (b*
    ((abnf::cst1 (cst-arithmetic-literal-conc2-rep-elem abnf::cst)))
    (abnf::treep abnf::cst1))
  :rule-classes :rewrite)

Theorem: cst-arithmetic-literal-conc2-rep-elem-match

(defthm cst-arithmetic-literal-conc2-rep-elem-match
 (implies
   (and (cst-matchp abnf::cst "arithmetic-literal")
        (equal (cst-arithmetic-literal-conc? abnf::cst)
               2))
   (b*
    ((abnf::cst1 (cst-arithmetic-literal-conc2-rep-elem abnf::cst)))
    (cst-matchp abnf::cst1 "field-literal")))
 :rule-classes :rewrite)

Theorem: cst-arithmetic-literal-conc2-rep-elem-of-tree-fix-cst

(defthm cst-arithmetic-literal-conc2-rep-elem-of-tree-fix-cst
 (equal
  (cst-arithmetic-literal-conc2-rep-elem (abnf::tree-fix abnf::cst))
  (cst-arithmetic-literal-conc2-rep-elem abnf::cst)))

Theorem: cst-arithmetic-literal-conc2-rep-elem-tree-equiv-congruence-on-cst

(defthm
 cst-arithmetic-literal-conc2-rep-elem-tree-equiv-congruence-on-cst
 (implies (abnf::tree-equiv abnf::cst cst-equiv)
          (equal (cst-arithmetic-literal-conc2-rep-elem abnf::cst)
                 (cst-arithmetic-literal-conc2-rep-elem cst-equiv)))
 :rule-classes :congruence)

Function: cst-arithmetic-literal-conc3-rep-elem

(defun cst-arithmetic-literal-conc3-rep-elem (abnf::cst)
 (declare (xargs :guard (abnf::treep abnf::cst)))
 (declare
  (xargs :guard (and (cst-matchp abnf::cst "arithmetic-literal")
                     (equal (cst-arithmetic-literal-conc? abnf::cst)
                            3))))
 (let ((__function__ 'cst-arithmetic-literal-conc3-rep-elem))
   (declare (ignorable __function__))
   (abnf::tree-fix
        (nth 0
             (cst-arithmetic-literal-conc3-rep abnf::cst)))))

Theorem: treep-of-cst-arithmetic-literal-conc3-rep-elem

(defthm treep-of-cst-arithmetic-literal-conc3-rep-elem
  (b*
    ((abnf::cst1 (cst-arithmetic-literal-conc3-rep-elem abnf::cst)))
    (abnf::treep abnf::cst1))
  :rule-classes :rewrite)

Theorem: cst-arithmetic-literal-conc3-rep-elem-match

(defthm cst-arithmetic-literal-conc3-rep-elem-match
 (implies
   (and (cst-matchp abnf::cst "arithmetic-literal")
        (equal (cst-arithmetic-literal-conc? abnf::cst)
               3))
   (b*
    ((abnf::cst1 (cst-arithmetic-literal-conc3-rep-elem abnf::cst)))
    (cst-matchp abnf::cst1 "group-literal")))
 :rule-classes :rewrite)

Theorem: cst-arithmetic-literal-conc3-rep-elem-of-tree-fix-cst

(defthm cst-arithmetic-literal-conc3-rep-elem-of-tree-fix-cst
 (equal
  (cst-arithmetic-literal-conc3-rep-elem (abnf::tree-fix abnf::cst))
  (cst-arithmetic-literal-conc3-rep-elem abnf::cst)))

Theorem: cst-arithmetic-literal-conc3-rep-elem-tree-equiv-congruence-on-cst

(defthm
 cst-arithmetic-literal-conc3-rep-elem-tree-equiv-congruence-on-cst
 (implies (abnf::tree-equiv abnf::cst cst-equiv)
          (equal (cst-arithmetic-literal-conc3-rep-elem abnf::cst)
                 (cst-arithmetic-literal-conc3-rep-elem cst-equiv)))
 :rule-classes :congruence)

Function: cst-arithmetic-literal-conc4-rep-elem

(defun cst-arithmetic-literal-conc4-rep-elem (abnf::cst)
 (declare (xargs :guard (abnf::treep abnf::cst)))
 (declare
  (xargs :guard (and (cst-matchp abnf::cst "arithmetic-literal")
                     (equal (cst-arithmetic-literal-conc? abnf::cst)
                            4))))
 (let ((__function__ 'cst-arithmetic-literal-conc4-rep-elem))
   (declare (ignorable __function__))
   (abnf::tree-fix
        (nth 0
             (cst-arithmetic-literal-conc4-rep abnf::cst)))))

Theorem: treep-of-cst-arithmetic-literal-conc4-rep-elem

(defthm treep-of-cst-arithmetic-literal-conc4-rep-elem
  (b*
    ((abnf::cst1 (cst-arithmetic-literal-conc4-rep-elem abnf::cst)))
    (abnf::treep abnf::cst1))
  :rule-classes :rewrite)

Theorem: cst-arithmetic-literal-conc4-rep-elem-match

(defthm cst-arithmetic-literal-conc4-rep-elem-match
 (implies
   (and (cst-matchp abnf::cst "arithmetic-literal")
        (equal (cst-arithmetic-literal-conc? abnf::cst)
               4))
   (b*
    ((abnf::cst1 (cst-arithmetic-literal-conc4-rep-elem abnf::cst)))
    (cst-matchp abnf::cst1 "scalar-literal")))
 :rule-classes :rewrite)

Theorem: cst-arithmetic-literal-conc4-rep-elem-of-tree-fix-cst

(defthm cst-arithmetic-literal-conc4-rep-elem-of-tree-fix-cst
 (equal
  (cst-arithmetic-literal-conc4-rep-elem (abnf::tree-fix abnf::cst))
  (cst-arithmetic-literal-conc4-rep-elem abnf::cst)))

Theorem: cst-arithmetic-literal-conc4-rep-elem-tree-equiv-congruence-on-cst

(defthm
 cst-arithmetic-literal-conc4-rep-elem-tree-equiv-congruence-on-cst
 (implies (abnf::tree-equiv abnf::cst cst-equiv)
          (equal (cst-arithmetic-literal-conc4-rep-elem abnf::cst)
                 (cst-arithmetic-literal-conc4-rep-elem cst-equiv)))
 :rule-classes :congruence)

Function: cst-string-element-conc1-rep-elem

(defun cst-string-element-conc1-rep-elem (abnf::cst)
 (declare (xargs :guard (abnf::treep abnf::cst)))
 (declare
      (xargs :guard (and (cst-matchp abnf::cst "string-element")
                         (equal (cst-string-element-conc? abnf::cst)
                                1))))
 (let ((__function__ 'cst-string-element-conc1-rep-elem))
   (declare (ignorable __function__))
   (abnf::tree-fix (nth 0
                        (cst-string-element-conc1-rep abnf::cst)))))

Theorem: treep-of-cst-string-element-conc1-rep-elem

(defthm treep-of-cst-string-element-conc1-rep-elem
  (b* ((abnf::cst1 (cst-string-element-conc1-rep-elem abnf::cst)))
    (abnf::treep abnf::cst1))
  :rule-classes :rewrite)

Theorem: cst-string-element-conc1-rep-elem-match

(defthm cst-string-element-conc1-rep-elem-match
 (implies
    (and (cst-matchp abnf::cst "string-element")
         (equal (cst-string-element-conc? abnf::cst)
                1))
    (b* ((abnf::cst1 (cst-string-element-conc1-rep-elem abnf::cst)))
      (cst-matchp abnf::cst1 "not-dq-or-backslash")))
 :rule-classes :rewrite)

Theorem: cst-string-element-conc1-rep-elem-of-tree-fix-cst

(defthm cst-string-element-conc1-rep-elem-of-tree-fix-cst
 (equal
      (cst-string-element-conc1-rep-elem (abnf::tree-fix abnf::cst))
      (cst-string-element-conc1-rep-elem abnf::cst)))

Theorem: cst-string-element-conc1-rep-elem-tree-equiv-congruence-on-cst

(defthm
     cst-string-element-conc1-rep-elem-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-string-element-conc1-rep-elem abnf::cst)
                  (cst-string-element-conc1-rep-elem cst-equiv)))
  :rule-classes :congruence)

Function: cst-string-element-conc2-rep-elem

(defun cst-string-element-conc2-rep-elem (abnf::cst)
 (declare (xargs :guard (abnf::treep abnf::cst)))
 (declare
      (xargs :guard (and (cst-matchp abnf::cst "string-element")
                         (equal (cst-string-element-conc? abnf::cst)
                                2))))
 (let ((__function__ 'cst-string-element-conc2-rep-elem))
   (declare (ignorable __function__))
   (abnf::tree-fix (nth 0
                        (cst-string-element-conc2-rep abnf::cst)))))

Theorem: treep-of-cst-string-element-conc2-rep-elem

(defthm treep-of-cst-string-element-conc2-rep-elem
  (b* ((abnf::cst1 (cst-string-element-conc2-rep-elem abnf::cst)))
    (abnf::treep abnf::cst1))
  :rule-classes :rewrite)

Theorem: cst-string-element-conc2-rep-elem-match

(defthm cst-string-element-conc2-rep-elem-match
 (implies
    (and (cst-matchp abnf::cst "string-element")
         (equal (cst-string-element-conc? abnf::cst)
                2))
    (b* ((abnf::cst1 (cst-string-element-conc2-rep-elem abnf::cst)))
      (cst-matchp abnf::cst1 "escaped-char")))
 :rule-classes :rewrite)

Theorem: cst-string-element-conc2-rep-elem-of-tree-fix-cst

(defthm cst-string-element-conc2-rep-elem-of-tree-fix-cst
 (equal
      (cst-string-element-conc2-rep-elem (abnf::tree-fix abnf::cst))
      (cst-string-element-conc2-rep-elem abnf::cst)))

Theorem: cst-string-element-conc2-rep-elem-tree-equiv-congruence-on-cst

(defthm
     cst-string-element-conc2-rep-elem-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-string-element-conc2-rep-elem abnf::cst)
                  (cst-string-element-conc2-rep-elem cst-equiv)))
  :rule-classes :congruence)

Function: cst-string-element-conc3-rep-elem

(defun cst-string-element-conc3-rep-elem (abnf::cst)
 (declare (xargs :guard (abnf::treep abnf::cst)))
 (declare
      (xargs :guard (and (cst-matchp abnf::cst "string-element")
                         (equal (cst-string-element-conc? abnf::cst)
                                3))))
 (let ((__function__ 'cst-string-element-conc3-rep-elem))
   (declare (ignorable __function__))
   (abnf::tree-fix (nth 0
                        (cst-string-element-conc3-rep abnf::cst)))))

Theorem: treep-of-cst-string-element-conc3-rep-elem

(defthm treep-of-cst-string-element-conc3-rep-elem
  (b* ((abnf::cst1 (cst-string-element-conc3-rep-elem abnf::cst)))
    (abnf::treep abnf::cst1))
  :rule-classes :rewrite)

Theorem: cst-string-element-conc3-rep-elem-match

(defthm cst-string-element-conc3-rep-elem-match
 (implies
    (and (cst-matchp abnf::cst "string-element")
         (equal (cst-string-element-conc? abnf::cst)
                3))
    (b* ((abnf::cst1 (cst-string-element-conc3-rep-elem abnf::cst)))
      (cst-matchp abnf::cst1 "escaped-ws")))
 :rule-classes :rewrite)

Theorem: cst-string-element-conc3-rep-elem-of-tree-fix-cst

(defthm cst-string-element-conc3-rep-elem-of-tree-fix-cst
 (equal
      (cst-string-element-conc3-rep-elem (abnf::tree-fix abnf::cst))
      (cst-string-element-conc3-rep-elem abnf::cst)))

Theorem: cst-string-element-conc3-rep-elem-tree-equiv-congruence-on-cst

(defthm
     cst-string-element-conc3-rep-elem-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-string-element-conc3-rep-elem abnf::cst)
                  (cst-string-element-conc3-rep-elem cst-equiv)))
  :rule-classes :congruence)

Function: cst-literal-conc1-rep-elem

(defun cst-literal-conc1-rep-elem (abnf::cst)
  (declare (xargs :guard (abnf::treep abnf::cst)))
  (declare (xargs :guard (and (cst-matchp abnf::cst "literal")
                              (equal (cst-literal-conc? abnf::cst)
                                     1))))
  (let ((__function__ 'cst-literal-conc1-rep-elem))
    (declare (ignorable __function__))
    (abnf::tree-fix (nth 0 (cst-literal-conc1-rep abnf::cst)))))

Theorem: treep-of-cst-literal-conc1-rep-elem

(defthm treep-of-cst-literal-conc1-rep-elem
  (b* ((abnf::cst1 (cst-literal-conc1-rep-elem abnf::cst)))
    (abnf::treep abnf::cst1))
  :rule-classes :rewrite)

Theorem: cst-literal-conc1-rep-elem-match

(defthm cst-literal-conc1-rep-elem-match
  (implies (and (cst-matchp abnf::cst "literal")
                (equal (cst-literal-conc? abnf::cst) 1))
           (b* ((abnf::cst1 (cst-literal-conc1-rep-elem abnf::cst)))
             (cst-matchp abnf::cst1 "arithmetic-literal")))
  :rule-classes :rewrite)

Theorem: cst-literal-conc1-rep-elem-of-tree-fix-cst

(defthm cst-literal-conc1-rep-elem-of-tree-fix-cst
  (equal (cst-literal-conc1-rep-elem (abnf::tree-fix abnf::cst))
         (cst-literal-conc1-rep-elem abnf::cst)))

Theorem: cst-literal-conc1-rep-elem-tree-equiv-congruence-on-cst

(defthm cst-literal-conc1-rep-elem-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-literal-conc1-rep-elem abnf::cst)
                  (cst-literal-conc1-rep-elem cst-equiv)))
  :rule-classes :congruence)

Function: cst-literal-conc2-rep-elem

(defun cst-literal-conc2-rep-elem (abnf::cst)
  (declare (xargs :guard (abnf::treep abnf::cst)))
  (declare (xargs :guard (and (cst-matchp abnf::cst "literal")
                              (equal (cst-literal-conc? abnf::cst)
                                     2))))
  (let ((__function__ 'cst-literal-conc2-rep-elem))
    (declare (ignorable __function__))
    (abnf::tree-fix (nth 0 (cst-literal-conc2-rep abnf::cst)))))

Theorem: treep-of-cst-literal-conc2-rep-elem

(defthm treep-of-cst-literal-conc2-rep-elem
  (b* ((abnf::cst1 (cst-literal-conc2-rep-elem abnf::cst)))
    (abnf::treep abnf::cst1))
  :rule-classes :rewrite)

Theorem: cst-literal-conc2-rep-elem-match

(defthm cst-literal-conc2-rep-elem-match
  (implies (and (cst-matchp abnf::cst "literal")
                (equal (cst-literal-conc? abnf::cst) 2))
           (b* ((abnf::cst1 (cst-literal-conc2-rep-elem abnf::cst)))
             (cst-matchp abnf::cst1 "address-literal")))
  :rule-classes :rewrite)

Theorem: cst-literal-conc2-rep-elem-of-tree-fix-cst

(defthm cst-literal-conc2-rep-elem-of-tree-fix-cst
  (equal (cst-literal-conc2-rep-elem (abnf::tree-fix abnf::cst))
         (cst-literal-conc2-rep-elem abnf::cst)))

Theorem: cst-literal-conc2-rep-elem-tree-equiv-congruence-on-cst

(defthm cst-literal-conc2-rep-elem-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-literal-conc2-rep-elem abnf::cst)
                  (cst-literal-conc2-rep-elem cst-equiv)))
  :rule-classes :congruence)

Function: cst-literal-conc3-rep-elem

(defun cst-literal-conc3-rep-elem (abnf::cst)
  (declare (xargs :guard (abnf::treep abnf::cst)))
  (declare (xargs :guard (and (cst-matchp abnf::cst "literal")
                              (equal (cst-literal-conc? abnf::cst)
                                     3))))
  (let ((__function__ 'cst-literal-conc3-rep-elem))
    (declare (ignorable __function__))
    (abnf::tree-fix (nth 0 (cst-literal-conc3-rep abnf::cst)))))

Theorem: treep-of-cst-literal-conc3-rep-elem

(defthm treep-of-cst-literal-conc3-rep-elem
  (b* ((abnf::cst1 (cst-literal-conc3-rep-elem abnf::cst)))
    (abnf::treep abnf::cst1))
  :rule-classes :rewrite)

Theorem: cst-literal-conc3-rep-elem-match

(defthm cst-literal-conc3-rep-elem-match
  (implies (and (cst-matchp abnf::cst "literal")
                (equal (cst-literal-conc? abnf::cst) 3))
           (b* ((abnf::cst1 (cst-literal-conc3-rep-elem abnf::cst)))
             (cst-matchp abnf::cst1 "boolean-literal")))
  :rule-classes :rewrite)

Theorem: cst-literal-conc3-rep-elem-of-tree-fix-cst

(defthm cst-literal-conc3-rep-elem-of-tree-fix-cst
  (equal (cst-literal-conc3-rep-elem (abnf::tree-fix abnf::cst))
         (cst-literal-conc3-rep-elem abnf::cst)))

Theorem: cst-literal-conc3-rep-elem-tree-equiv-congruence-on-cst

(defthm cst-literal-conc3-rep-elem-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-literal-conc3-rep-elem abnf::cst)
                  (cst-literal-conc3-rep-elem cst-equiv)))
  :rule-classes :congruence)

Function: cst-literal-conc4-rep-elem

(defun cst-literal-conc4-rep-elem (abnf::cst)
  (declare (xargs :guard (abnf::treep abnf::cst)))
  (declare (xargs :guard (and (cst-matchp abnf::cst "literal")
                              (equal (cst-literal-conc? abnf::cst)
                                     4))))
  (let ((__function__ 'cst-literal-conc4-rep-elem))
    (declare (ignorable __function__))
    (abnf::tree-fix (nth 0 (cst-literal-conc4-rep abnf::cst)))))

Theorem: treep-of-cst-literal-conc4-rep-elem

(defthm treep-of-cst-literal-conc4-rep-elem
  (b* ((abnf::cst1 (cst-literal-conc4-rep-elem abnf::cst)))
    (abnf::treep abnf::cst1))
  :rule-classes :rewrite)

Theorem: cst-literal-conc4-rep-elem-match

(defthm cst-literal-conc4-rep-elem-match
  (implies (and (cst-matchp abnf::cst "literal")
                (equal (cst-literal-conc? abnf::cst) 4))
           (b* ((abnf::cst1 (cst-literal-conc4-rep-elem abnf::cst)))
             (cst-matchp abnf::cst1 "string-literal")))
  :rule-classes :rewrite)

Theorem: cst-literal-conc4-rep-elem-of-tree-fix-cst

(defthm cst-literal-conc4-rep-elem-of-tree-fix-cst
  (equal (cst-literal-conc4-rep-elem (abnf::tree-fix abnf::cst))
         (cst-literal-conc4-rep-elem abnf::cst)))

Theorem: cst-literal-conc4-rep-elem-tree-equiv-congruence-on-cst

(defthm cst-literal-conc4-rep-elem-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-literal-conc4-rep-elem abnf::cst)
                  (cst-literal-conc4-rep-elem cst-equiv)))
  :rule-classes :congruence)

Function: cst-integer-type-conc1-rep-elem

(defun cst-integer-type-conc1-rep-elem (abnf::cst)
  (declare (xargs :guard (abnf::treep abnf::cst)))
  (declare
       (xargs :guard (and (cst-matchp abnf::cst "integer-type")
                          (equal (cst-integer-type-conc? abnf::cst)
                                 1))))
  (let ((__function__ 'cst-integer-type-conc1-rep-elem))
    (declare (ignorable __function__))
    (abnf::tree-fix (nth 0
                         (cst-integer-type-conc1-rep abnf::cst)))))

Theorem: treep-of-cst-integer-type-conc1-rep-elem

(defthm treep-of-cst-integer-type-conc1-rep-elem
  (b* ((abnf::cst1 (cst-integer-type-conc1-rep-elem abnf::cst)))
    (abnf::treep abnf::cst1))
  :rule-classes :rewrite)

Theorem: cst-integer-type-conc1-rep-elem-match

(defthm cst-integer-type-conc1-rep-elem-match
 (implies
      (and (cst-matchp abnf::cst "integer-type")
           (equal (cst-integer-type-conc? abnf::cst)
                  1))
      (b* ((abnf::cst1 (cst-integer-type-conc1-rep-elem abnf::cst)))
        (cst-matchp abnf::cst1 "unsigned-type")))
 :rule-classes :rewrite)

Theorem: cst-integer-type-conc1-rep-elem-of-tree-fix-cst

(defthm cst-integer-type-conc1-rep-elem-of-tree-fix-cst
 (equal (cst-integer-type-conc1-rep-elem (abnf::tree-fix abnf::cst))
        (cst-integer-type-conc1-rep-elem abnf::cst)))

Theorem: cst-integer-type-conc1-rep-elem-tree-equiv-congruence-on-cst

(defthm cst-integer-type-conc1-rep-elem-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-integer-type-conc1-rep-elem abnf::cst)
                  (cst-integer-type-conc1-rep-elem cst-equiv)))
  :rule-classes :congruence)

Function: cst-integer-type-conc2-rep-elem

(defun cst-integer-type-conc2-rep-elem (abnf::cst)
  (declare (xargs :guard (abnf::treep abnf::cst)))
  (declare
       (xargs :guard (and (cst-matchp abnf::cst "integer-type")
                          (equal (cst-integer-type-conc? abnf::cst)
                                 2))))
  (let ((__function__ 'cst-integer-type-conc2-rep-elem))
    (declare (ignorable __function__))
    (abnf::tree-fix (nth 0
                         (cst-integer-type-conc2-rep abnf::cst)))))

Theorem: treep-of-cst-integer-type-conc2-rep-elem

(defthm treep-of-cst-integer-type-conc2-rep-elem
  (b* ((abnf::cst1 (cst-integer-type-conc2-rep-elem abnf::cst)))
    (abnf::treep abnf::cst1))
  :rule-classes :rewrite)

Theorem: cst-integer-type-conc2-rep-elem-match

(defthm cst-integer-type-conc2-rep-elem-match
 (implies
      (and (cst-matchp abnf::cst "integer-type")
           (equal (cst-integer-type-conc? abnf::cst)
                  2))
      (b* ((abnf::cst1 (cst-integer-type-conc2-rep-elem abnf::cst)))
        (cst-matchp abnf::cst1 "signed-type")))
 :rule-classes :rewrite)

Theorem: cst-integer-type-conc2-rep-elem-of-tree-fix-cst

(defthm cst-integer-type-conc2-rep-elem-of-tree-fix-cst
 (equal (cst-integer-type-conc2-rep-elem (abnf::tree-fix abnf::cst))
        (cst-integer-type-conc2-rep-elem abnf::cst)))

Theorem: cst-integer-type-conc2-rep-elem-tree-equiv-congruence-on-cst

(defthm cst-integer-type-conc2-rep-elem-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-integer-type-conc2-rep-elem abnf::cst)
                  (cst-integer-type-conc2-rep-elem cst-equiv)))
  :rule-classes :congruence)

Function: cst-field-type-conc-rep-elem

(defun cst-field-type-conc-rep-elem (abnf::cst)
  (declare (xargs :guard (abnf::treep abnf::cst)))
  (declare (xargs :guard (cst-matchp abnf::cst "field-type")))
  (let ((__function__ 'cst-field-type-conc-rep-elem))
    (declare (ignorable __function__))
    (abnf::tree-fix (nth 0
                         (cst-field-type-conc-rep abnf::cst)))))

Theorem: treep-of-cst-field-type-conc-rep-elem

(defthm treep-of-cst-field-type-conc-rep-elem
  (b* ((abnf::cst1 (cst-field-type-conc-rep-elem abnf::cst)))
    (abnf::treep abnf::cst1))
  :rule-classes :rewrite)

Theorem: cst-field-type-conc-rep-elem-match

(defthm cst-field-type-conc-rep-elem-match
  (implies
       (cst-matchp abnf::cst "field-type")
       (b* ((abnf::cst1 (cst-field-type-conc-rep-elem abnf::cst)))
         (cst-matchp abnf::cst1 "%s\"field\"")))
  :rule-classes :rewrite)

Theorem: cst-field-type-conc-rep-elem-of-tree-fix-cst

(defthm cst-field-type-conc-rep-elem-of-tree-fix-cst
  (equal (cst-field-type-conc-rep-elem (abnf::tree-fix abnf::cst))
         (cst-field-type-conc-rep-elem abnf::cst)))

Theorem: cst-field-type-conc-rep-elem-tree-equiv-congruence-on-cst

(defthm cst-field-type-conc-rep-elem-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-field-type-conc-rep-elem abnf::cst)
                  (cst-field-type-conc-rep-elem cst-equiv)))
  :rule-classes :congruence)

Function: cst-group-type-conc-rep-elem

(defun cst-group-type-conc-rep-elem (abnf::cst)
  (declare (xargs :guard (abnf::treep abnf::cst)))
  (declare (xargs :guard (cst-matchp abnf::cst "group-type")))
  (let ((__function__ 'cst-group-type-conc-rep-elem))
    (declare (ignorable __function__))
    (abnf::tree-fix (nth 0
                         (cst-group-type-conc-rep abnf::cst)))))

Theorem: treep-of-cst-group-type-conc-rep-elem

(defthm treep-of-cst-group-type-conc-rep-elem
  (b* ((abnf::cst1 (cst-group-type-conc-rep-elem abnf::cst)))
    (abnf::treep abnf::cst1))
  :rule-classes :rewrite)

Theorem: cst-group-type-conc-rep-elem-match

(defthm cst-group-type-conc-rep-elem-match
  (implies
       (cst-matchp abnf::cst "group-type")
       (b* ((abnf::cst1 (cst-group-type-conc-rep-elem abnf::cst)))
         (cst-matchp abnf::cst1 "%s\"group\"")))
  :rule-classes :rewrite)

Theorem: cst-group-type-conc-rep-elem-of-tree-fix-cst

(defthm cst-group-type-conc-rep-elem-of-tree-fix-cst
  (equal (cst-group-type-conc-rep-elem (abnf::tree-fix abnf::cst))
         (cst-group-type-conc-rep-elem abnf::cst)))

Theorem: cst-group-type-conc-rep-elem-tree-equiv-congruence-on-cst

(defthm cst-group-type-conc-rep-elem-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-group-type-conc-rep-elem abnf::cst)
                  (cst-group-type-conc-rep-elem cst-equiv)))
  :rule-classes :congruence)

Function: cst-scalar-type-conc-rep-elem

(defun cst-scalar-type-conc-rep-elem (abnf::cst)
  (declare (xargs :guard (abnf::treep abnf::cst)))
  (declare (xargs :guard (cst-matchp abnf::cst "scalar-type")))
  (let ((__function__ 'cst-scalar-type-conc-rep-elem))
    (declare (ignorable __function__))
    (abnf::tree-fix (nth 0
                         (cst-scalar-type-conc-rep abnf::cst)))))

Theorem: treep-of-cst-scalar-type-conc-rep-elem

(defthm treep-of-cst-scalar-type-conc-rep-elem
  (b* ((abnf::cst1 (cst-scalar-type-conc-rep-elem abnf::cst)))
    (abnf::treep abnf::cst1))
  :rule-classes :rewrite)

Theorem: cst-scalar-type-conc-rep-elem-match

(defthm cst-scalar-type-conc-rep-elem-match
  (implies
       (cst-matchp abnf::cst "scalar-type")
       (b* ((abnf::cst1 (cst-scalar-type-conc-rep-elem abnf::cst)))
         (cst-matchp abnf::cst1 "%s\"scalar\"")))
  :rule-classes :rewrite)

Theorem: cst-scalar-type-conc-rep-elem-of-tree-fix-cst

(defthm cst-scalar-type-conc-rep-elem-of-tree-fix-cst
  (equal (cst-scalar-type-conc-rep-elem (abnf::tree-fix abnf::cst))
         (cst-scalar-type-conc-rep-elem abnf::cst)))

Theorem: cst-scalar-type-conc-rep-elem-tree-equiv-congruence-on-cst

(defthm cst-scalar-type-conc-rep-elem-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-scalar-type-conc-rep-elem abnf::cst)
                  (cst-scalar-type-conc-rep-elem cst-equiv)))
  :rule-classes :congruence)

Function: cst-arithmetic-type-conc1-rep-elem

(defun cst-arithmetic-type-conc1-rep-elem (abnf::cst)
 (declare (xargs :guard (abnf::treep abnf::cst)))
 (declare
     (xargs :guard (and (cst-matchp abnf::cst "arithmetic-type")
                        (equal (cst-arithmetic-type-conc? abnf::cst)
                               1))))
 (let ((__function__ 'cst-arithmetic-type-conc1-rep-elem))
  (declare (ignorable __function__))
  (abnf::tree-fix (nth 0
                       (cst-arithmetic-type-conc1-rep abnf::cst)))))

Theorem: treep-of-cst-arithmetic-type-conc1-rep-elem

(defthm treep-of-cst-arithmetic-type-conc1-rep-elem
  (b* ((abnf::cst1 (cst-arithmetic-type-conc1-rep-elem abnf::cst)))
    (abnf::treep abnf::cst1))
  :rule-classes :rewrite)

Theorem: cst-arithmetic-type-conc1-rep-elem-match

(defthm cst-arithmetic-type-conc1-rep-elem-match
 (implies
   (and (cst-matchp abnf::cst "arithmetic-type")
        (equal (cst-arithmetic-type-conc? abnf::cst)
               1))
   (b* ((abnf::cst1 (cst-arithmetic-type-conc1-rep-elem abnf::cst)))
     (cst-matchp abnf::cst1 "integer-type")))
 :rule-classes :rewrite)

Theorem: cst-arithmetic-type-conc1-rep-elem-of-tree-fix-cst

(defthm cst-arithmetic-type-conc1-rep-elem-of-tree-fix-cst
 (equal
     (cst-arithmetic-type-conc1-rep-elem (abnf::tree-fix abnf::cst))
     (cst-arithmetic-type-conc1-rep-elem abnf::cst)))

Theorem: cst-arithmetic-type-conc1-rep-elem-tree-equiv-congruence-on-cst

(defthm
    cst-arithmetic-type-conc1-rep-elem-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-arithmetic-type-conc1-rep-elem abnf::cst)
                  (cst-arithmetic-type-conc1-rep-elem cst-equiv)))
  :rule-classes :congruence)

Function: cst-arithmetic-type-conc2-rep-elem

(defun cst-arithmetic-type-conc2-rep-elem (abnf::cst)
 (declare (xargs :guard (abnf::treep abnf::cst)))
 (declare
     (xargs :guard (and (cst-matchp abnf::cst "arithmetic-type")
                        (equal (cst-arithmetic-type-conc? abnf::cst)
                               2))))
 (let ((__function__ 'cst-arithmetic-type-conc2-rep-elem))
  (declare (ignorable __function__))
  (abnf::tree-fix (nth 0
                       (cst-arithmetic-type-conc2-rep abnf::cst)))))

Theorem: treep-of-cst-arithmetic-type-conc2-rep-elem

(defthm treep-of-cst-arithmetic-type-conc2-rep-elem
  (b* ((abnf::cst1 (cst-arithmetic-type-conc2-rep-elem abnf::cst)))
    (abnf::treep abnf::cst1))
  :rule-classes :rewrite)

Theorem: cst-arithmetic-type-conc2-rep-elem-match

(defthm cst-arithmetic-type-conc2-rep-elem-match
 (implies
   (and (cst-matchp abnf::cst "arithmetic-type")
        (equal (cst-arithmetic-type-conc? abnf::cst)
               2))
   (b* ((abnf::cst1 (cst-arithmetic-type-conc2-rep-elem abnf::cst)))
     (cst-matchp abnf::cst1 "field-type")))
 :rule-classes :rewrite)

Theorem: cst-arithmetic-type-conc2-rep-elem-of-tree-fix-cst

(defthm cst-arithmetic-type-conc2-rep-elem-of-tree-fix-cst
 (equal
     (cst-arithmetic-type-conc2-rep-elem (abnf::tree-fix abnf::cst))
     (cst-arithmetic-type-conc2-rep-elem abnf::cst)))

Theorem: cst-arithmetic-type-conc2-rep-elem-tree-equiv-congruence-on-cst

(defthm
    cst-arithmetic-type-conc2-rep-elem-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-arithmetic-type-conc2-rep-elem abnf::cst)
                  (cst-arithmetic-type-conc2-rep-elem cst-equiv)))
  :rule-classes :congruence)

Function: cst-arithmetic-type-conc3-rep-elem

(defun cst-arithmetic-type-conc3-rep-elem (abnf::cst)
 (declare (xargs :guard (abnf::treep abnf::cst)))
 (declare
     (xargs :guard (and (cst-matchp abnf::cst "arithmetic-type")
                        (equal (cst-arithmetic-type-conc? abnf::cst)
                               3))))
 (let ((__function__ 'cst-arithmetic-type-conc3-rep-elem))
  (declare (ignorable __function__))
  (abnf::tree-fix (nth 0
                       (cst-arithmetic-type-conc3-rep abnf::cst)))))

Theorem: treep-of-cst-arithmetic-type-conc3-rep-elem

(defthm treep-of-cst-arithmetic-type-conc3-rep-elem
  (b* ((abnf::cst1 (cst-arithmetic-type-conc3-rep-elem abnf::cst)))
    (abnf::treep abnf::cst1))
  :rule-classes :rewrite)

Theorem: cst-arithmetic-type-conc3-rep-elem-match

(defthm cst-arithmetic-type-conc3-rep-elem-match
 (implies
   (and (cst-matchp abnf::cst "arithmetic-type")
        (equal (cst-arithmetic-type-conc? abnf::cst)
               3))
   (b* ((abnf::cst1 (cst-arithmetic-type-conc3-rep-elem abnf::cst)))
     (cst-matchp abnf::cst1 "group-type")))
 :rule-classes :rewrite)

Theorem: cst-arithmetic-type-conc3-rep-elem-of-tree-fix-cst

(defthm cst-arithmetic-type-conc3-rep-elem-of-tree-fix-cst
 (equal
     (cst-arithmetic-type-conc3-rep-elem (abnf::tree-fix abnf::cst))
     (cst-arithmetic-type-conc3-rep-elem abnf::cst)))

Theorem: cst-arithmetic-type-conc3-rep-elem-tree-equiv-congruence-on-cst

(defthm
    cst-arithmetic-type-conc3-rep-elem-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-arithmetic-type-conc3-rep-elem abnf::cst)
                  (cst-arithmetic-type-conc3-rep-elem cst-equiv)))
  :rule-classes :congruence)

Function: cst-arithmetic-type-conc4-rep-elem

(defun cst-arithmetic-type-conc4-rep-elem (abnf::cst)
 (declare (xargs :guard (abnf::treep abnf::cst)))
 (declare
     (xargs :guard (and (cst-matchp abnf::cst "arithmetic-type")
                        (equal (cst-arithmetic-type-conc? abnf::cst)
                               4))))
 (let ((__function__ 'cst-arithmetic-type-conc4-rep-elem))
  (declare (ignorable __function__))
  (abnf::tree-fix (nth 0
                       (cst-arithmetic-type-conc4-rep abnf::cst)))))

Theorem: treep-of-cst-arithmetic-type-conc4-rep-elem

(defthm treep-of-cst-arithmetic-type-conc4-rep-elem
  (b* ((abnf::cst1 (cst-arithmetic-type-conc4-rep-elem abnf::cst)))
    (abnf::treep abnf::cst1))
  :rule-classes :rewrite)

Theorem: cst-arithmetic-type-conc4-rep-elem-match

(defthm cst-arithmetic-type-conc4-rep-elem-match
 (implies
   (and (cst-matchp abnf::cst "arithmetic-type")
        (equal (cst-arithmetic-type-conc? abnf::cst)
               4))
   (b* ((abnf::cst1 (cst-arithmetic-type-conc4-rep-elem abnf::cst)))
     (cst-matchp abnf::cst1 "scalar-type")))
 :rule-classes :rewrite)

Theorem: cst-arithmetic-type-conc4-rep-elem-of-tree-fix-cst

(defthm cst-arithmetic-type-conc4-rep-elem-of-tree-fix-cst
 (equal
     (cst-arithmetic-type-conc4-rep-elem (abnf::tree-fix abnf::cst))
     (cst-arithmetic-type-conc4-rep-elem abnf::cst)))

Theorem: cst-arithmetic-type-conc4-rep-elem-tree-equiv-congruence-on-cst

(defthm
    cst-arithmetic-type-conc4-rep-elem-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-arithmetic-type-conc4-rep-elem abnf::cst)
                  (cst-arithmetic-type-conc4-rep-elem cst-equiv)))
  :rule-classes :congruence)

Function: cst-address-type-conc-rep-elem

(defun cst-address-type-conc-rep-elem (abnf::cst)
  (declare (xargs :guard (abnf::treep abnf::cst)))
  (declare (xargs :guard (cst-matchp abnf::cst "address-type")))
  (let ((__function__ 'cst-address-type-conc-rep-elem))
    (declare (ignorable __function__))
    (abnf::tree-fix (nth 0
                         (cst-address-type-conc-rep abnf::cst)))))

Theorem: treep-of-cst-address-type-conc-rep-elem

(defthm treep-of-cst-address-type-conc-rep-elem
  (b* ((abnf::cst1 (cst-address-type-conc-rep-elem abnf::cst)))
    (abnf::treep abnf::cst1))
  :rule-classes :rewrite)

Theorem: cst-address-type-conc-rep-elem-match

(defthm cst-address-type-conc-rep-elem-match
  (implies
       (cst-matchp abnf::cst "address-type")
       (b* ((abnf::cst1 (cst-address-type-conc-rep-elem abnf::cst)))
         (cst-matchp abnf::cst1 "%s\"address\"")))
  :rule-classes :rewrite)

Theorem: cst-address-type-conc-rep-elem-of-tree-fix-cst

(defthm cst-address-type-conc-rep-elem-of-tree-fix-cst
  (equal (cst-address-type-conc-rep-elem (abnf::tree-fix abnf::cst))
         (cst-address-type-conc-rep-elem abnf::cst)))

Theorem: cst-address-type-conc-rep-elem-tree-equiv-congruence-on-cst

(defthm cst-address-type-conc-rep-elem-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-address-type-conc-rep-elem abnf::cst)
                  (cst-address-type-conc-rep-elem cst-equiv)))
  :rule-classes :congruence)

Function: cst-boolean-type-conc-rep-elem

(defun cst-boolean-type-conc-rep-elem (abnf::cst)
  (declare (xargs :guard (abnf::treep abnf::cst)))
  (declare (xargs :guard (cst-matchp abnf::cst "boolean-type")))
  (let ((__function__ 'cst-boolean-type-conc-rep-elem))
    (declare (ignorable __function__))
    (abnf::tree-fix (nth 0
                         (cst-boolean-type-conc-rep abnf::cst)))))

Theorem: treep-of-cst-boolean-type-conc-rep-elem

(defthm treep-of-cst-boolean-type-conc-rep-elem
  (b* ((abnf::cst1 (cst-boolean-type-conc-rep-elem abnf::cst)))
    (abnf::treep abnf::cst1))
  :rule-classes :rewrite)

Theorem: cst-boolean-type-conc-rep-elem-match

(defthm cst-boolean-type-conc-rep-elem-match
  (implies
       (cst-matchp abnf::cst "boolean-type")
       (b* ((abnf::cst1 (cst-boolean-type-conc-rep-elem abnf::cst)))
         (cst-matchp abnf::cst1 "%s\"boolean\"")))
  :rule-classes :rewrite)

Theorem: cst-boolean-type-conc-rep-elem-of-tree-fix-cst

(defthm cst-boolean-type-conc-rep-elem-of-tree-fix-cst
  (equal (cst-boolean-type-conc-rep-elem (abnf::tree-fix abnf::cst))
         (cst-boolean-type-conc-rep-elem abnf::cst)))

Theorem: cst-boolean-type-conc-rep-elem-tree-equiv-congruence-on-cst

(defthm cst-boolean-type-conc-rep-elem-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-boolean-type-conc-rep-elem abnf::cst)
                  (cst-boolean-type-conc-rep-elem cst-equiv)))
  :rule-classes :congruence)

Function: cst-string-type-conc-rep-elem

(defun cst-string-type-conc-rep-elem (abnf::cst)
  (declare (xargs :guard (abnf::treep abnf::cst)))
  (declare (xargs :guard (cst-matchp abnf::cst "string-type")))
  (let ((__function__ 'cst-string-type-conc-rep-elem))
    (declare (ignorable __function__))
    (abnf::tree-fix (nth 0
                         (cst-string-type-conc-rep abnf::cst)))))

Theorem: treep-of-cst-string-type-conc-rep-elem

(defthm treep-of-cst-string-type-conc-rep-elem
  (b* ((abnf::cst1 (cst-string-type-conc-rep-elem abnf::cst)))
    (abnf::treep abnf::cst1))
  :rule-classes :rewrite)

Theorem: cst-string-type-conc-rep-elem-match

(defthm cst-string-type-conc-rep-elem-match
  (implies
       (cst-matchp abnf::cst "string-type")
       (b* ((abnf::cst1 (cst-string-type-conc-rep-elem abnf::cst)))
         (cst-matchp abnf::cst1 "%s\"string\"")))
  :rule-classes :rewrite)

Theorem: cst-string-type-conc-rep-elem-of-tree-fix-cst

(defthm cst-string-type-conc-rep-elem-of-tree-fix-cst
  (equal (cst-string-type-conc-rep-elem (abnf::tree-fix abnf::cst))
         (cst-string-type-conc-rep-elem abnf::cst)))

Theorem: cst-string-type-conc-rep-elem-tree-equiv-congruence-on-cst

(defthm cst-string-type-conc-rep-elem-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-string-type-conc-rep-elem abnf::cst)
                  (cst-string-type-conc-rep-elem cst-equiv)))
  :rule-classes :congruence)

Function: cst-literal-type-conc1-rep-elem

(defun cst-literal-type-conc1-rep-elem (abnf::cst)
  (declare (xargs :guard (abnf::treep abnf::cst)))
  (declare
       (xargs :guard (and (cst-matchp abnf::cst "literal-type")
                          (equal (cst-literal-type-conc? abnf::cst)
                                 1))))
  (let ((__function__ 'cst-literal-type-conc1-rep-elem))
    (declare (ignorable __function__))
    (abnf::tree-fix (nth 0
                         (cst-literal-type-conc1-rep abnf::cst)))))

Theorem: treep-of-cst-literal-type-conc1-rep-elem

(defthm treep-of-cst-literal-type-conc1-rep-elem
  (b* ((abnf::cst1 (cst-literal-type-conc1-rep-elem abnf::cst)))
    (abnf::treep abnf::cst1))
  :rule-classes :rewrite)

Theorem: cst-literal-type-conc1-rep-elem-match

(defthm cst-literal-type-conc1-rep-elem-match
 (implies
      (and (cst-matchp abnf::cst "literal-type")
           (equal (cst-literal-type-conc? abnf::cst)
                  1))
      (b* ((abnf::cst1 (cst-literal-type-conc1-rep-elem abnf::cst)))
        (cst-matchp abnf::cst1 "arithmetic-type")))
 :rule-classes :rewrite)

Theorem: cst-literal-type-conc1-rep-elem-of-tree-fix-cst

(defthm cst-literal-type-conc1-rep-elem-of-tree-fix-cst
 (equal (cst-literal-type-conc1-rep-elem (abnf::tree-fix abnf::cst))
        (cst-literal-type-conc1-rep-elem abnf::cst)))

Theorem: cst-literal-type-conc1-rep-elem-tree-equiv-congruence-on-cst

(defthm cst-literal-type-conc1-rep-elem-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-literal-type-conc1-rep-elem abnf::cst)
                  (cst-literal-type-conc1-rep-elem cst-equiv)))
  :rule-classes :congruence)

Function: cst-literal-type-conc2-rep-elem

(defun cst-literal-type-conc2-rep-elem (abnf::cst)
  (declare (xargs :guard (abnf::treep abnf::cst)))
  (declare
       (xargs :guard (and (cst-matchp abnf::cst "literal-type")
                          (equal (cst-literal-type-conc? abnf::cst)
                                 2))))
  (let ((__function__ 'cst-literal-type-conc2-rep-elem))
    (declare (ignorable __function__))
    (abnf::tree-fix (nth 0
                         (cst-literal-type-conc2-rep abnf::cst)))))

Theorem: treep-of-cst-literal-type-conc2-rep-elem

(defthm treep-of-cst-literal-type-conc2-rep-elem
  (b* ((abnf::cst1 (cst-literal-type-conc2-rep-elem abnf::cst)))
    (abnf::treep abnf::cst1))
  :rule-classes :rewrite)

Theorem: cst-literal-type-conc2-rep-elem-match

(defthm cst-literal-type-conc2-rep-elem-match
 (implies
      (and (cst-matchp abnf::cst "literal-type")
           (equal (cst-literal-type-conc? abnf::cst)
                  2))
      (b* ((abnf::cst1 (cst-literal-type-conc2-rep-elem abnf::cst)))
        (cst-matchp abnf::cst1 "address-type")))
 :rule-classes :rewrite)

Theorem: cst-literal-type-conc2-rep-elem-of-tree-fix-cst

(defthm cst-literal-type-conc2-rep-elem-of-tree-fix-cst
 (equal (cst-literal-type-conc2-rep-elem (abnf::tree-fix abnf::cst))
        (cst-literal-type-conc2-rep-elem abnf::cst)))

Theorem: cst-literal-type-conc2-rep-elem-tree-equiv-congruence-on-cst

(defthm cst-literal-type-conc2-rep-elem-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-literal-type-conc2-rep-elem abnf::cst)
                  (cst-literal-type-conc2-rep-elem cst-equiv)))
  :rule-classes :congruence)

Function: cst-literal-type-conc3-rep-elem

(defun cst-literal-type-conc3-rep-elem (abnf::cst)
  (declare (xargs :guard (abnf::treep abnf::cst)))
  (declare
       (xargs :guard (and (cst-matchp abnf::cst "literal-type")
                          (equal (cst-literal-type-conc? abnf::cst)
                                 3))))
  (let ((__function__ 'cst-literal-type-conc3-rep-elem))
    (declare (ignorable __function__))
    (abnf::tree-fix (nth 0
                         (cst-literal-type-conc3-rep abnf::cst)))))

Theorem: treep-of-cst-literal-type-conc3-rep-elem

(defthm treep-of-cst-literal-type-conc3-rep-elem
  (b* ((abnf::cst1 (cst-literal-type-conc3-rep-elem abnf::cst)))
    (abnf::treep abnf::cst1))
  :rule-classes :rewrite)

Theorem: cst-literal-type-conc3-rep-elem-match

(defthm cst-literal-type-conc3-rep-elem-match
 (implies
      (and (cst-matchp abnf::cst "literal-type")
           (equal (cst-literal-type-conc? abnf::cst)
                  3))
      (b* ((abnf::cst1 (cst-literal-type-conc3-rep-elem abnf::cst)))
        (cst-matchp abnf::cst1 "boolean-type")))
 :rule-classes :rewrite)

Theorem: cst-literal-type-conc3-rep-elem-of-tree-fix-cst

(defthm cst-literal-type-conc3-rep-elem-of-tree-fix-cst
 (equal (cst-literal-type-conc3-rep-elem (abnf::tree-fix abnf::cst))
        (cst-literal-type-conc3-rep-elem abnf::cst)))

Theorem: cst-literal-type-conc3-rep-elem-tree-equiv-congruence-on-cst

(defthm cst-literal-type-conc3-rep-elem-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-literal-type-conc3-rep-elem abnf::cst)
                  (cst-literal-type-conc3-rep-elem cst-equiv)))
  :rule-classes :congruence)

Function: cst-literal-type-conc4-rep-elem

(defun cst-literal-type-conc4-rep-elem (abnf::cst)
  (declare (xargs :guard (abnf::treep abnf::cst)))
  (declare
       (xargs :guard (and (cst-matchp abnf::cst "literal-type")
                          (equal (cst-literal-type-conc? abnf::cst)
                                 4))))
  (let ((__function__ 'cst-literal-type-conc4-rep-elem))
    (declare (ignorable __function__))
    (abnf::tree-fix (nth 0
                         (cst-literal-type-conc4-rep abnf::cst)))))

Theorem: treep-of-cst-literal-type-conc4-rep-elem

(defthm treep-of-cst-literal-type-conc4-rep-elem
  (b* ((abnf::cst1 (cst-literal-type-conc4-rep-elem abnf::cst)))
    (abnf::treep abnf::cst1))
  :rule-classes :rewrite)

Theorem: cst-literal-type-conc4-rep-elem-match

(defthm cst-literal-type-conc4-rep-elem-match
 (implies
      (and (cst-matchp abnf::cst "literal-type")
           (equal (cst-literal-type-conc? abnf::cst)
                  4))
      (b* ((abnf::cst1 (cst-literal-type-conc4-rep-elem abnf::cst)))
        (cst-matchp abnf::cst1 "string-type")))
 :rule-classes :rewrite)

Theorem: cst-literal-type-conc4-rep-elem-of-tree-fix-cst

(defthm cst-literal-type-conc4-rep-elem-of-tree-fix-cst
 (equal (cst-literal-type-conc4-rep-elem (abnf::tree-fix abnf::cst))
        (cst-literal-type-conc4-rep-elem abnf::cst)))

Theorem: cst-literal-type-conc4-rep-elem-tree-equiv-congruence-on-cst

(defthm cst-literal-type-conc4-rep-elem-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-literal-type-conc4-rep-elem abnf::cst)
                  (cst-literal-type-conc4-rep-elem cst-equiv)))
  :rule-classes :congruence)

Function: cst-plaintext-type-conc1-rep-elem

(defun cst-plaintext-type-conc1-rep-elem (abnf::cst)
 (declare (xargs :guard (abnf::treep abnf::cst)))
 (declare
      (xargs :guard (and (cst-matchp abnf::cst "plaintext-type")
                         (equal (cst-plaintext-type-conc? abnf::cst)
                                1))))
 (let ((__function__ 'cst-plaintext-type-conc1-rep-elem))
   (declare (ignorable __function__))
   (abnf::tree-fix (nth 0
                        (cst-plaintext-type-conc1-rep abnf::cst)))))

Theorem: treep-of-cst-plaintext-type-conc1-rep-elem

(defthm treep-of-cst-plaintext-type-conc1-rep-elem
  (b* ((abnf::cst1 (cst-plaintext-type-conc1-rep-elem abnf::cst)))
    (abnf::treep abnf::cst1))
  :rule-classes :rewrite)

Theorem: cst-plaintext-type-conc1-rep-elem-match

(defthm cst-plaintext-type-conc1-rep-elem-match
 (implies
    (and (cst-matchp abnf::cst "plaintext-type")
         (equal (cst-plaintext-type-conc? abnf::cst)
                1))
    (b* ((abnf::cst1 (cst-plaintext-type-conc1-rep-elem abnf::cst)))
      (cst-matchp abnf::cst1 "literal-type")))
 :rule-classes :rewrite)

Theorem: cst-plaintext-type-conc1-rep-elem-of-tree-fix-cst

(defthm cst-plaintext-type-conc1-rep-elem-of-tree-fix-cst
 (equal
      (cst-plaintext-type-conc1-rep-elem (abnf::tree-fix abnf::cst))
      (cst-plaintext-type-conc1-rep-elem abnf::cst)))

Theorem: cst-plaintext-type-conc1-rep-elem-tree-equiv-congruence-on-cst

(defthm
     cst-plaintext-type-conc1-rep-elem-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-plaintext-type-conc1-rep-elem abnf::cst)
                  (cst-plaintext-type-conc1-rep-elem cst-equiv)))
  :rule-classes :congruence)

Function: cst-plaintext-type-conc2-rep-elem

(defun cst-plaintext-type-conc2-rep-elem (abnf::cst)
 (declare (xargs :guard (abnf::treep abnf::cst)))
 (declare
      (xargs :guard (and (cst-matchp abnf::cst "plaintext-type")
                         (equal (cst-plaintext-type-conc? abnf::cst)
                                2))))
 (let ((__function__ 'cst-plaintext-type-conc2-rep-elem))
   (declare (ignorable __function__))
   (abnf::tree-fix (nth 0
                        (cst-plaintext-type-conc2-rep abnf::cst)))))

Theorem: treep-of-cst-plaintext-type-conc2-rep-elem

(defthm treep-of-cst-plaintext-type-conc2-rep-elem
  (b* ((abnf::cst1 (cst-plaintext-type-conc2-rep-elem abnf::cst)))
    (abnf::treep abnf::cst1))
  :rule-classes :rewrite)

Theorem: cst-plaintext-type-conc2-rep-elem-match

(defthm cst-plaintext-type-conc2-rep-elem-match
 (implies
    (and (cst-matchp abnf::cst "plaintext-type")
         (equal (cst-plaintext-type-conc? abnf::cst)
                2))
    (b* ((abnf::cst1 (cst-plaintext-type-conc2-rep-elem abnf::cst)))
      (cst-matchp abnf::cst1 "identifier")))
 :rule-classes :rewrite)

Theorem: cst-plaintext-type-conc2-rep-elem-of-tree-fix-cst

(defthm cst-plaintext-type-conc2-rep-elem-of-tree-fix-cst
 (equal
      (cst-plaintext-type-conc2-rep-elem (abnf::tree-fix abnf::cst))
      (cst-plaintext-type-conc2-rep-elem abnf::cst)))

Theorem: cst-plaintext-type-conc2-rep-elem-tree-equiv-congruence-on-cst

(defthm
     cst-plaintext-type-conc2-rep-elem-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-plaintext-type-conc2-rep-elem abnf::cst)
                  (cst-plaintext-type-conc2-rep-elem cst-equiv)))
  :rule-classes :congruence)

Function: cst-ternary-op-conc-rep-elem

(defun cst-ternary-op-conc-rep-elem (abnf::cst)
  (declare (xargs :guard (abnf::treep abnf::cst)))
  (declare (xargs :guard (cst-matchp abnf::cst "ternary-op")))
  (let ((__function__ 'cst-ternary-op-conc-rep-elem))
    (declare (ignorable __function__))
    (abnf::tree-fix (nth 0
                         (cst-ternary-op-conc-rep abnf::cst)))))

Theorem: treep-of-cst-ternary-op-conc-rep-elem

(defthm treep-of-cst-ternary-op-conc-rep-elem
  (b* ((abnf::cst1 (cst-ternary-op-conc-rep-elem abnf::cst)))
    (abnf::treep abnf::cst1))
  :rule-classes :rewrite)

Theorem: cst-ternary-op-conc-rep-elem-match

(defthm cst-ternary-op-conc-rep-elem-match
  (implies
       (cst-matchp abnf::cst "ternary-op")
       (b* ((abnf::cst1 (cst-ternary-op-conc-rep-elem abnf::cst)))
         (cst-matchp abnf::cst1 "%s\"ternary\"")))
  :rule-classes :rewrite)

Theorem: cst-ternary-op-conc-rep-elem-of-tree-fix-cst

(defthm cst-ternary-op-conc-rep-elem-of-tree-fix-cst
  (equal (cst-ternary-op-conc-rep-elem (abnf::tree-fix abnf::cst))
         (cst-ternary-op-conc-rep-elem abnf::cst)))

Theorem: cst-ternary-op-conc-rep-elem-tree-equiv-congruence-on-cst

(defthm cst-ternary-op-conc-rep-elem-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-ternary-op-conc-rep-elem abnf::cst)
                  (cst-ternary-op-conc-rep-elem cst-equiv)))
  :rule-classes :congruence)

Function: cst-command-conc1-rep-elem

(defun cst-command-conc1-rep-elem (abnf::cst)
  (declare (xargs :guard (abnf::treep abnf::cst)))
  (declare (xargs :guard (and (cst-matchp abnf::cst "command")
                              (equal (cst-command-conc? abnf::cst)
                                     1))))
  (let ((__function__ 'cst-command-conc1-rep-elem))
    (declare (ignorable __function__))
    (abnf::tree-fix (nth 0 (cst-command-conc1-rep abnf::cst)))))

Theorem: treep-of-cst-command-conc1-rep-elem

(defthm treep-of-cst-command-conc1-rep-elem
  (b* ((abnf::cst1 (cst-command-conc1-rep-elem abnf::cst)))
    (abnf::treep abnf::cst1))
  :rule-classes :rewrite)

Theorem: cst-command-conc1-rep-elem-match

(defthm cst-command-conc1-rep-elem-match
  (implies (and (cst-matchp abnf::cst "command")
                (equal (cst-command-conc? abnf::cst) 1))
           (b* ((abnf::cst1 (cst-command-conc1-rep-elem abnf::cst)))
             (cst-matchp abnf::cst1 "decrement")))
  :rule-classes :rewrite)

Theorem: cst-command-conc1-rep-elem-of-tree-fix-cst

(defthm cst-command-conc1-rep-elem-of-tree-fix-cst
  (equal (cst-command-conc1-rep-elem (abnf::tree-fix abnf::cst))
         (cst-command-conc1-rep-elem abnf::cst)))

Theorem: cst-command-conc1-rep-elem-tree-equiv-congruence-on-cst

(defthm cst-command-conc1-rep-elem-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-command-conc1-rep-elem abnf::cst)
                  (cst-command-conc1-rep-elem cst-equiv)))
  :rule-classes :congruence)

Function: cst-command-conc2-rep-elem

(defun cst-command-conc2-rep-elem (abnf::cst)
  (declare (xargs :guard (abnf::treep abnf::cst)))
  (declare (xargs :guard (and (cst-matchp abnf::cst "command")
                              (equal (cst-command-conc? abnf::cst)
                                     2))))
  (let ((__function__ 'cst-command-conc2-rep-elem))
    (declare (ignorable __function__))
    (abnf::tree-fix (nth 0 (cst-command-conc2-rep abnf::cst)))))

Theorem: treep-of-cst-command-conc2-rep-elem

(defthm treep-of-cst-command-conc2-rep-elem
  (b* ((abnf::cst1 (cst-command-conc2-rep-elem abnf::cst)))
    (abnf::treep abnf::cst1))
  :rule-classes :rewrite)

Theorem: cst-command-conc2-rep-elem-match

(defthm cst-command-conc2-rep-elem-match
  (implies (and (cst-matchp abnf::cst "command")
                (equal (cst-command-conc? abnf::cst) 2))
           (b* ((abnf::cst1 (cst-command-conc2-rep-elem abnf::cst)))
             (cst-matchp abnf::cst1 "increment")))
  :rule-classes :rewrite)

Theorem: cst-command-conc2-rep-elem-of-tree-fix-cst

(defthm cst-command-conc2-rep-elem-of-tree-fix-cst
  (equal (cst-command-conc2-rep-elem (abnf::tree-fix abnf::cst))
         (cst-command-conc2-rep-elem abnf::cst)))

Theorem: cst-command-conc2-rep-elem-tree-equiv-congruence-on-cst

(defthm cst-command-conc2-rep-elem-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-command-conc2-rep-elem abnf::cst)
                  (cst-command-conc2-rep-elem cst-equiv)))
  :rule-classes :congruence)

Function: cst-command-conc3-rep-elem

(defun cst-command-conc3-rep-elem (abnf::cst)
  (declare (xargs :guard (abnf::treep abnf::cst)))
  (declare (xargs :guard (and (cst-matchp abnf::cst "command")
                              (equal (cst-command-conc? abnf::cst)
                                     3))))
  (let ((__function__ 'cst-command-conc3-rep-elem))
    (declare (ignorable __function__))
    (abnf::tree-fix (nth 0 (cst-command-conc3-rep abnf::cst)))))

Theorem: treep-of-cst-command-conc3-rep-elem

(defthm treep-of-cst-command-conc3-rep-elem
  (b* ((abnf::cst1 (cst-command-conc3-rep-elem abnf::cst)))
    (abnf::treep abnf::cst1))
  :rule-classes :rewrite)

Theorem: cst-command-conc3-rep-elem-match

(defthm cst-command-conc3-rep-elem-match
  (implies (and (cst-matchp abnf::cst "command")
                (equal (cst-command-conc? abnf::cst) 3))
           (b* ((abnf::cst1 (cst-command-conc3-rep-elem abnf::cst)))
             (cst-matchp abnf::cst1 "instruction")))
  :rule-classes :rewrite)

Theorem: cst-command-conc3-rep-elem-of-tree-fix-cst

(defthm cst-command-conc3-rep-elem-of-tree-fix-cst
  (equal (cst-command-conc3-rep-elem (abnf::tree-fix abnf::cst))
         (cst-command-conc3-rep-elem abnf::cst)))

Theorem: cst-command-conc3-rep-elem-tree-equiv-congruence-on-cst

(defthm cst-command-conc3-rep-elem-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-command-conc3-rep-elem abnf::cst)
                  (cst-command-conc3-rep-elem cst-equiv)))
  :rule-classes :congruence)

*grammar*-tree-operations

Definitions and Theorems

grammar-tree-operations