		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-37-nat

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

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

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

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

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

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

(defthm cst-%x30-37-nat-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-%x30-37-nat abnf::cst)
                  (cst-%x30-37-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-37-nat-bounds

(defthm cst-%x30-37-nat-bounds
  (implies (cst-matchp abnf::cst "%x30-37")
           (and (<= 48 (cst-%x30-37-nat abnf::cst))
                (<= (cst-%x30-37-nat abnf::cst) 55)))
  :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-"&&="-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-"**="-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-"-="-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-"//"-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-"<<"-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-">"-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-"["-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-"\\"-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-"|="-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-%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"\n"-leafterm

(defthm |CST-%s"\\n"-LEAFTERM|
  (implies (cst-matchp abnf::cst "%s\"\\n\"")
           (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"\t"-leafterm

(defthm |CST-%s"\\t"-LEAFTERM|
  (implies (cst-matchp abnf::cst "%s\"\\t\"")
           (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"\x"-leafterm

(defthm |CST-%s"\\x"-LEAFTERM|
  (implies (cst-matchp abnf::cst "%s\"\\x\"")
           (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"aleo1"-leafterm

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

Theorem: cst-%s"assert"-leafterm

(defthm |CST-%s"assert"-LEAFTERM|
  (implies (cst-matchp abnf::cst "%s\"assert\"")
           (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"async"-leafterm

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

Theorem: cst-%s"bool"-leafterm

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

Theorem: cst-%s"console"-leafterm

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

Theorem: cst-%s"const"-leafterm

(defthm |CST-%s"const"-LEAFTERM|
  (implies (cst-matchp abnf::cst "%s\"const\"")
           (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"decrement"-leafterm

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

Theorem: cst-%s"else"-leafterm

(defthm |CST-%s"else"-LEAFTERM|
  (implies (cst-matchp abnf::cst "%s\"else\"")
           (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"for"-leafterm

(defthm |CST-%s"for"-LEAFTERM|
  (implies (cst-matchp abnf::cst "%s\"for\"")
           (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"group"-leafterm

(defthm |CST-%s"group"-LEAFTERM|
  (implies (cst-matchp abnf::cst "%s\"group\"")
           (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"if"-leafterm

(defthm |CST-%s"if"-LEAFTERM|
  (implies (cst-matchp abnf::cst "%s\"if\"")
           (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"in"-leafterm

(defthm |CST-%s"in"-LEAFTERM|
  (implies (cst-matchp abnf::cst "%s\"in\"")
           (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"let"-leafterm

(defthm |CST-%s"let"-LEAFTERM|
  (implies (cst-matchp abnf::cst "%s\"let\"")
           (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"output"-leafterm

(defthm |CST-%s"output"-LEAFTERM|
  (implies (cst-matchp abnf::cst "%s\"output\"")
           (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"program"-leafterm

(defthm |CST-%s"program"-LEAFTERM|
  (implies (cst-matchp abnf::cst "%s\"program\"")
           (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"return"-leafterm

(defthm |CST-%s"return"-LEAFTERM|
  (implies (cst-matchp abnf::cst "%s\"return\"")
           (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"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"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"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"u8"-leafterm

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

Theorem: cst-horizontal-tab-nonleaf

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

Theorem: cst-line-feed-nonleaf

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

Theorem: cst-carriage-return-nonleaf

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

Theorem: cst-space-nonleaf

(defthm cst-space-nonleaf
  (implies (cst-matchp abnf::cst "space")
           (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-line-terminator-nonleaf

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

Theorem: cst-whitespace-nonleaf

(defthm cst-whitespace-nonleaf
  (implies (cst-matchp abnf::cst "whitespace")
           (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-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-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-line-feed-or-carriage-return-nonleaf

(defthm cst-not-star-or-line-feed-or-carriage-return-nonleaf
  (implies (cst-matchp abnf::cst
                       "not-star-or-line-feed-or-carriage-return")
           (equal (abnf::tree-kind abnf::cst)
                  :nonleaf)))

Theorem: cst-not-star-or-slash-or-line-feed-or-carriage-return-nonleaf

(defthm
      cst-not-star-or-slash-or-line-feed-or-carriage-return-nonleaf
 (implies
    (cst-matchp abnf::cst
                "not-star-or-slash-or-line-feed-or-carriage-return")
    (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-line-feed-or-carriage-return-nonleaf

(defthm cst-not-line-feed-or-carriage-return-nonleaf
  (implies (cst-matchp abnf::cst
                       "not-line-feed-or-carriage-return")
           (equal (abnf::tree-kind abnf::cst)
                  :nonleaf)))

Theorem: cst-keyword-nonleaf

(defthm cst-keyword-nonleaf
  (implies (cst-matchp abnf::cst "keyword")
           (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-decimal-digit-nonleaf

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

Theorem: cst-octal-digit-nonleaf

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

Theorem: cst-hexadecimal-digit-nonleaf

(defthm cst-hexadecimal-digit-nonleaf
  (implies (cst-matchp abnf::cst "hexadecimal-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-numeral-nonleaf

(defthm cst-numeral-nonleaf
  (implies (cst-matchp abnf::cst "numeral")
           (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-signed-literal-nonleaf

(defthm cst-signed-literal-nonleaf
  (implies (cst-matchp abnf::cst "signed-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-product-group-literal-nonleaf

(defthm cst-product-group-literal-nonleaf
  (implies (cst-matchp abnf::cst "product-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-boolean-literal-nonleaf

(defthm cst-boolean-literal-nonleaf
  (implies (cst-matchp abnf::cst "boolean-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-single-quote-nonleaf

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

Theorem: cst-double-quote-nonleaf

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

Theorem: cst-single-quote-escape-nonleaf

(defthm cst-single-quote-escape-nonleaf
  (implies (cst-matchp abnf::cst "single-quote-escape")
           (equal (abnf::tree-kind abnf::cst)
                  :nonleaf)))

Theorem: cst-double-quote-escape-nonleaf

(defthm cst-double-quote-escape-nonleaf
  (implies (cst-matchp abnf::cst "double-quote-escape")
           (equal (abnf::tree-kind abnf::cst)
                  :nonleaf)))

Theorem: cst-backslash-escape-nonleaf

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

Theorem: cst-line-feed-escape-nonleaf

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

Theorem: cst-carriage-return-escape-nonleaf

(defthm cst-carriage-return-escape-nonleaf
  (implies (cst-matchp abnf::cst "carriage-return-escape")
           (equal (abnf::tree-kind abnf::cst)
                  :nonleaf)))

Theorem: cst-horizontal-tab-escape-nonleaf

(defthm cst-horizontal-tab-escape-nonleaf
  (implies (cst-matchp abnf::cst "horizontal-tab-escape")
           (equal (abnf::tree-kind abnf::cst)
                  :nonleaf)))

Theorem: cst-null-character-escape-nonleaf

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

Theorem: cst-simple-character-escape-nonleaf

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

Theorem: cst-ascii-character-escape-nonleaf

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

Theorem: cst-unicode-character-escape-nonleaf

(defthm cst-unicode-character-escape-nonleaf
  (implies (cst-matchp abnf::cst "unicode-character-escape")
           (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-literal-element-nonleaf

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

Theorem: cst-not-double-quote-or-backslash-or-line-feed-or-carriage-return-nonleaf

(defthm
 cst-not-double-quote-or-backslash-or-line-feed-or-carriage-return-nonleaf
 (implies
  (cst-matchp
    abnf::cst
    "not-double-quote-or-backslash-or-line-feed-or-carriage-return")
  (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-numeric-literal-nonleaf

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

Theorem: cst-atomic-literal-nonleaf

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

Theorem: cst-annotation-nonleaf

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

Theorem: cst-symbol-nonleaf

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

Theorem: cst-token-nonleaf

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

Theorem: cst-lexeme-nonleaf

(defthm cst-lexeme-nonleaf
  (implies (cst-matchp abnf::cst "lexeme")
           (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-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-boolean-type-nonleaf

(defthm cst-boolean-type-nonleaf
  (implies (cst-matchp abnf::cst "boolean-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-string-type-nonleaf

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

Theorem: cst-named-primitive-type-nonleaf

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

Theorem: cst-unit-type-nonleaf

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

Theorem: cst-primitive-type-nonleaf

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

Theorem: cst-named-type-nonleaf

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

Theorem: cst-tuple-type-nonleaf

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

Theorem: cst-type-nonleaf

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

Theorem: cst-group-coordinate-nonleaf

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

Theorem: cst-affine-group-literal-nonleaf

(defthm cst-affine-group-literal-nonleaf
  (implies (cst-matchp abnf::cst "affine-group-literal")
           (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-group-literal-nonleaf

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

Theorem: cst-primary-expression-nonleaf

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

Theorem: cst-variable-or-free-constant-nonleaf

(defthm cst-variable-or-free-constant-nonleaf
  (implies (cst-matchp abnf::cst "variable-or-free-constant")
           (equal (abnf::tree-kind abnf::cst)
                  :nonleaf)))

Theorem: cst-associated-constant-nonleaf

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

Theorem: cst-free-function-call-nonleaf

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

Theorem: cst-static-function-call-nonleaf

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

Theorem: cst-function-arguments-nonleaf

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

Theorem: cst-unit-expression-nonleaf

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

Theorem: cst-tuple-expression-nonleaf

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

Theorem: cst-struct-expression-nonleaf

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

Theorem: cst-struct-component-initializer-nonleaf

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

Theorem: cst-postfix-expression-nonleaf

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

Theorem: cst-tuple-component-expression-nonleaf

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

Theorem: cst-struct-component-expression-nonleaf

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

Theorem: cst-operator-call-nonleaf

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

Theorem: cst-unary-operator-call-nonleaf

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

Theorem: cst-binary-operator-call-nonleaf

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

Theorem: cst-unary-expression-nonleaf

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

Theorem: cst-exponential-expression-nonleaf

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

Theorem: cst-multiplicative-expression-nonleaf

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

Theorem: cst-additive-expression-nonleaf

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

Theorem: cst-shift-expression-nonleaf

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

Theorem: cst-conjunctive-expression-nonleaf

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

Theorem: cst-disjunctive-expression-nonleaf

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

Theorem: cst-exclusive-disjunctive-expression-nonleaf

(defthm cst-exclusive-disjunctive-expression-nonleaf
  (implies (cst-matchp abnf::cst
                       "exclusive-disjunctive-expression")
           (equal (abnf::tree-kind abnf::cst)
                  :nonleaf)))

Theorem: cst-ordering-expression-nonleaf

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

Theorem: cst-equality-expression-nonleaf

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

Theorem: cst-conditional-conjunctive-expression-nonleaf

(defthm cst-conditional-conjunctive-expression-nonleaf
  (implies (cst-matchp abnf::cst
                       "conditional-conjunctive-expression")
           (equal (abnf::tree-kind abnf::cst)
                  :nonleaf)))

Theorem: cst-conditional-disjunctive-expression-nonleaf

(defthm cst-conditional-disjunctive-expression-nonleaf
  (implies (cst-matchp abnf::cst
                       "conditional-disjunctive-expression")
           (equal (abnf::tree-kind abnf::cst)
                  :nonleaf)))

Theorem: cst-binary-expression-nonleaf

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

Theorem: cst-conditional-ternary-expression-nonleaf

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

Theorem: cst-expression-nonleaf

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

Theorem: cst-statement-nonleaf

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

Theorem: cst-block-nonleaf

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

Theorem: cst-return-statement-nonleaf

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

Theorem: cst-variable-declaration-nonleaf

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

Theorem: cst-constant-declaration-nonleaf

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

Theorem: cst-branch-nonleaf

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

Theorem: cst-conditional-statement-nonleaf

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

Theorem: cst-loop-statement-nonleaf

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

Theorem: cst-assignment-operator-nonleaf

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

Theorem: cst-assignment-statement-nonleaf

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

Theorem: cst-console-statement-nonleaf

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

Theorem: cst-console-call-nonleaf

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

Theorem: cst-assert-call-nonleaf

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

Theorem: cst-assert-equal-call-nonleaf

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

Theorem: cst-assert-not-equal-call-nonleaf

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

Theorem: cst-finalize-statement-nonleaf

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

Theorem: cst-increment-statement-nonleaf

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

Theorem: cst-decrement-statement-nonleaf

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

Theorem: cst-function-declaration-nonleaf

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

Theorem: cst-function-parameters-nonleaf

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

Theorem: cst-function-parameter-nonleaf

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

Theorem: cst-transition-declaration-nonleaf

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

Theorem: cst-finalizer-nonleaf

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

Theorem: cst-struct-declaration-nonleaf

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

Theorem: cst-struct-component-declarations-nonleaf

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

Theorem: cst-struct-component-declaration-nonleaf

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

Theorem: cst-record-declaration-nonleaf

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

Theorem: cst-mapping-declaration-nonleaf

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

Theorem: cst-program-item-nonleaf

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

Theorem: cst-program-declaration-nonleaf

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

Theorem: cst-import-declaration-nonleaf

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

Theorem: cst-file-nonleaf

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

Theorem: cst-input-type-nonleaf

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

Theorem: cst-input-expression-nonleaf

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

Theorem: cst-input-item-nonleaf

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

Theorem: cst-input-title-nonleaf

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

Theorem: cst-input-section-nonleaf

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

Theorem: cst-input-file-nonleaf

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

Theorem: cst-output-expression-nonleaf

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

Theorem: cst-output-item-nonleaf

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

Theorem: cst-output-title-nonleaf

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

Theorem: cst-output-section-nonleaf

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

Theorem: cst-output-file-nonleaf

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

Theorem: cst-horizontal-tab-rulename

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

Theorem: cst-line-feed-rulename

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

Theorem: cst-carriage-return-rulename

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

Theorem: cst-space-rulename

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

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-line-terminator-rulename

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

Theorem: cst-whitespace-rulename

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

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-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-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-line-feed-or-carriage-return-rulename

(defthm cst-not-star-or-line-feed-or-carriage-return-rulename
 (implies
  (cst-matchp abnf::cst
              "not-star-or-line-feed-or-carriage-return")
  (equal
      (abnf::tree-nonleaf->rulename? abnf::cst)
      (abnf::rulename "not-star-or-line-feed-or-carriage-return"))))

Theorem: cst-not-star-or-slash-or-line-feed-or-carriage-return-rulename

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

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-line-feed-or-carriage-return-rulename

(defthm cst-not-line-feed-or-carriage-return-rulename
  (implies
       (cst-matchp abnf::cst
                   "not-line-feed-or-carriage-return")
       (equal (abnf::tree-nonleaf->rulename? abnf::cst)
              (abnf::rulename "not-line-feed-or-carriage-return"))))

Theorem: cst-keyword-rulename

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

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-decimal-digit-rulename

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

Theorem: cst-octal-digit-rulename

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

Theorem: cst-hexadecimal-digit-rulename

(defthm cst-hexadecimal-digit-rulename
  (implies (cst-matchp abnf::cst "hexadecimal-digit")
           (equal (abnf::tree-nonleaf->rulename? abnf::cst)
                  (abnf::rulename "hexadecimal-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-numeral-rulename

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

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-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-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-product-group-literal-rulename

(defthm cst-product-group-literal-rulename
  (implies (cst-matchp abnf::cst "product-group-literal")
           (equal (abnf::tree-nonleaf->rulename? abnf::cst)
                  (abnf::rulename "product-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-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-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-single-quote-rulename

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

Theorem: cst-double-quote-rulename

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

Theorem: cst-single-quote-escape-rulename

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

Theorem: cst-double-quote-escape-rulename

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

Theorem: cst-backslash-escape-rulename

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

Theorem: cst-line-feed-escape-rulename

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

Theorem: cst-carriage-return-escape-rulename

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

Theorem: cst-horizontal-tab-escape-rulename

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

Theorem: cst-null-character-escape-rulename

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

Theorem: cst-simple-character-escape-rulename

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

Theorem: cst-ascii-character-escape-rulename

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

Theorem: cst-unicode-character-escape-rulename

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

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-literal-element-rulename

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

Theorem: cst-not-double-quote-or-backslash-or-line-feed-or-carriage-return-rulename

(defthm
 cst-not-double-quote-or-backslash-or-line-feed-or-carriage-return-rulename
 (implies
  (cst-matchp
    abnf::cst
    "not-double-quote-or-backslash-or-line-feed-or-carriage-return")
  (equal
   (abnf::tree-nonleaf->rulename? abnf::cst)
   (abnf::rulename
    "not-double-quote-or-backslash-or-line-feed-or-carriage-return"))))

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-numeric-literal-rulename

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

Theorem: cst-atomic-literal-rulename

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

Theorem: cst-annotation-rulename

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

Theorem: cst-symbol-rulename

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

Theorem: cst-token-rulename

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

Theorem: cst-lexeme-rulename

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

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-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-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-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-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-named-primitive-type-rulename

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

Theorem: cst-unit-type-rulename

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

Theorem: cst-primitive-type-rulename

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

Theorem: cst-named-type-rulename

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

Theorem: cst-tuple-type-rulename

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

Theorem: cst-type-rulename

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

Theorem: cst-group-coordinate-rulename

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

Theorem: cst-affine-group-literal-rulename

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

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-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-primary-expression-rulename

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

Theorem: cst-variable-or-free-constant-rulename

(defthm cst-variable-or-free-constant-rulename
  (implies (cst-matchp abnf::cst "variable-or-free-constant")
           (equal (abnf::tree-nonleaf->rulename? abnf::cst)
                  (abnf::rulename "variable-or-free-constant"))))

Theorem: cst-associated-constant-rulename

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

Theorem: cst-free-function-call-rulename

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

Theorem: cst-static-function-call-rulename

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

Theorem: cst-function-arguments-rulename

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

Theorem: cst-unit-expression-rulename

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

Theorem: cst-tuple-expression-rulename

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

Theorem: cst-struct-expression-rulename

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

Theorem: cst-struct-component-initializer-rulename

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

Theorem: cst-postfix-expression-rulename

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

Theorem: cst-tuple-component-expression-rulename

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

Theorem: cst-struct-component-expression-rulename

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

Theorem: cst-operator-call-rulename

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

Theorem: cst-unary-operator-call-rulename

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

Theorem: cst-binary-operator-call-rulename

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

Theorem: cst-unary-expression-rulename

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

Theorem: cst-exponential-expression-rulename

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

Theorem: cst-multiplicative-expression-rulename

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

Theorem: cst-additive-expression-rulename

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

Theorem: cst-shift-expression-rulename

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

Theorem: cst-conjunctive-expression-rulename

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

Theorem: cst-disjunctive-expression-rulename

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

Theorem: cst-exclusive-disjunctive-expression-rulename

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

Theorem: cst-ordering-expression-rulename

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

Theorem: cst-equality-expression-rulename

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

Theorem: cst-conditional-conjunctive-expression-rulename

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

Theorem: cst-conditional-disjunctive-expression-rulename

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

Theorem: cst-binary-expression-rulename

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

Theorem: cst-conditional-ternary-expression-rulename

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

Theorem: cst-expression-rulename

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

Theorem: cst-statement-rulename

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

Theorem: cst-block-rulename

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

Theorem: cst-return-statement-rulename

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

Theorem: cst-variable-declaration-rulename

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

Theorem: cst-constant-declaration-rulename

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

Theorem: cst-branch-rulename

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

Theorem: cst-conditional-statement-rulename

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

Theorem: cst-loop-statement-rulename

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

Theorem: cst-assignment-operator-rulename

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

Theorem: cst-assignment-statement-rulename

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

Theorem: cst-console-statement-rulename

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

Theorem: cst-console-call-rulename

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

Theorem: cst-assert-call-rulename

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

Theorem: cst-assert-equal-call-rulename

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

Theorem: cst-assert-not-equal-call-rulename

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

Theorem: cst-finalize-statement-rulename

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

Theorem: cst-increment-statement-rulename

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

Theorem: cst-decrement-statement-rulename

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

Theorem: cst-function-declaration-rulename

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

Theorem: cst-function-parameters-rulename

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

Theorem: cst-function-parameter-rulename

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

Theorem: cst-transition-declaration-rulename

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

Theorem: cst-finalizer-rulename

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

Theorem: cst-struct-declaration-rulename

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

Theorem: cst-struct-component-declarations-rulename

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

Theorem: cst-struct-component-declaration-rulename

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

Theorem: cst-record-declaration-rulename

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

Theorem: cst-mapping-declaration-rulename

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

Theorem: cst-program-item-rulename

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

Theorem: cst-program-declaration-rulename

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

Theorem: cst-import-declaration-rulename

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

Theorem: cst-file-rulename

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

Theorem: cst-input-type-rulename

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

Theorem: cst-input-expression-rulename

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

Theorem: cst-input-item-rulename

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

Theorem: cst-input-title-rulename

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

Theorem: cst-input-section-rulename

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

Theorem: cst-input-file-rulename

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

Theorem: cst-output-expression-rulename

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

Theorem: cst-output-item-rulename

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

Theorem: cst-output-title-rulename

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

Theorem: cst-output-section-rulename

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

Theorem: cst-output-file-rulename

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

Theorem: cst-horizontal-tab-branches-match-alt

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

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

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

Theorem: cst-carriage-return-branches-match-alt

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

Theorem: cst-space-branches-match-alt

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

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)
   "horizontal-tab / line-feed / carriage-return / space / 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-line-terminator-branches-match-alt

(defthm cst-line-terminator-branches-match-alt
 (implies
   (cst-matchp abnf::cst "line-terminator")
   (cst-list-list-alt-matchp
        (abnf::tree-nonleaf->branches abnf::cst)
        "line-feed / carriage-return / carriage-return line-feed")))

Theorem: cst-whitespace-branches-match-alt

(defthm cst-whitespace-branches-match-alt
  (implies (cst-matchp abnf::cst "whitespace")
           (cst-list-list-alt-matchp
                (abnf::tree-nonleaf->branches abnf::cst)
                "space / horizontal-tab / line-terminator")))

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)
                            "block-comment / line-comment")))

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-or-line-feed-or-carriage-return rest-of-block-comment / line-terminator rest-of-block-comment")))

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-or-line-feed-or-carriage-return rest-of-block-comment / line-terminator rest-of-block-comment")))

Theorem: cst-not-star-or-line-feed-or-carriage-return-branches-match-alt

(defthm
    cst-not-star-or-line-feed-or-carriage-return-branches-match-alt
  (implies
       (cst-matchp abnf::cst
                   "not-star-or-line-feed-or-carriage-return")
       (cst-list-list-alt-matchp
            (abnf::tree-nonleaf->branches abnf::cst)
            "horizontal-tab / %x20-29 / %x2B-7E / safe-nonascii")))

Theorem: cst-not-star-or-slash-or-line-feed-or-carriage-return-branches-match-alt

(defthm
 cst-not-star-or-slash-or-line-feed-or-carriage-return-branches-match-alt
 (implies
  (cst-matchp abnf::cst
              "not-star-or-slash-or-line-feed-or-carriage-return")
  (cst-list-list-alt-matchp
   (abnf::tree-nonleaf->branches abnf::cst)
   "horizontal-tab / %x20-29 / %x2B-2E / %x30-7E / safe-nonascii")))

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)
                "\"//\" *not-line-feed-or-carriage-return")))

Theorem: cst-not-line-feed-or-carriage-return-branches-match-alt

(defthm cst-not-line-feed-or-carriage-return-branches-match-alt
 (implies
    (cst-matchp abnf::cst
                "not-line-feed-or-carriage-return")
    (cst-list-list-alt-matchp
         (abnf::tree-nonleaf->branches abnf::cst)
         "horizontal-tab / space / visible-ascii / safe-nonascii")))

Theorem: cst-keyword-branches-match-alt

(defthm cst-keyword-branches-match-alt
 (implies
  (cst-matchp abnf::cst "keyword")
  (cst-list-list-alt-matchp
   (abnf::tree-nonleaf->branches abnf::cst)
   "%s\"address\" / %s\"async\" / %s\"bool\" / %s\"console\" / %s\"const\" / %s\"constant\" / %s\"decrement\" / %s\"else\" / %s\"field\" / %s\"finalize\" / %s\"for\" / %s\"function\" / %s\"group\" / %s\"i8\" / %s\"i16\" / %s\"i32\" / %s\"i64\" / %s\"i128\" / %s\"if\" / %s\"import\" / %s\"in\" / %s\"increment\" / %s\"let\" / %s\"mapping\" / %s\"program\" / %s\"public\" / %s\"record\" / %s\"return\" / %s\"scalar\" / %s\"string\" / %s\"struct\" / %s\"transition\" / %s\"u8\" / %s\"u16\" / %s\"u32\" / %s\"u64\" / %s\"u128\"")))

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-decimal-digit-branches-match-alt

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

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

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

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

(defthm cst-hexadecimal-digit-branches-match-alt
  (implies
       (cst-matchp abnf::cst "hexadecimal-digit")
       (cst-list-list-alt-matchp
            (abnf::tree-nonleaf->branches abnf::cst)
            "decimal-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 / decimal-digit / \"_\" )")))

Theorem: cst-numeral-branches-match-alt

(defthm cst-numeral-branches-match-alt
 (implies
  (cst-matchp abnf::cst "numeral")
  (cst-list-list-alt-matchp (abnf::tree-nonleaf->branches abnf::cst)
                            "1*decimal-digit")))

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)
    "numeral ( %s\"u8\" / %s\"u16\" / %s\"u32\" / %s\"u64\" / %s\"u128\" )")))

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)
    "numeral ( %s\"i8\" / %s\"i16\" / %s\"i32\" / %s\"i64\" / %s\"i128\" )")))

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)
                            "numeral %s\"field\"")))

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

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

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)
                            "numeral %s\"scalar\"")))

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-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\" 58( lowercase-letter / decimal-digit )")))

Theorem: cst-single-quote-branches-match-alt

(defthm cst-single-quote-branches-match-alt
 (implies
  (cst-matchp abnf::cst "single-quote")
  (cst-list-list-alt-matchp (abnf::tree-nonleaf->branches abnf::cst)
                            "%x27")))

Theorem: cst-double-quote-branches-match-alt

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

Theorem: cst-single-quote-escape-branches-match-alt

(defthm cst-single-quote-escape-branches-match-alt
 (implies
  (cst-matchp abnf::cst "single-quote-escape")
  (cst-list-list-alt-matchp (abnf::tree-nonleaf->branches abnf::cst)
                            "\"\\\" single-quote")))

Theorem: cst-double-quote-escape-branches-match-alt

(defthm cst-double-quote-escape-branches-match-alt
 (implies
  (cst-matchp abnf::cst "double-quote-escape")
  (cst-list-list-alt-matchp (abnf::tree-nonleaf->branches abnf::cst)
                            "\"\\\" double-quote")))

Theorem: cst-backslash-escape-branches-match-alt

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

Theorem: cst-line-feed-escape-branches-match-alt

(defthm cst-line-feed-escape-branches-match-alt
 (implies
  (cst-matchp abnf::cst "line-feed-escape")
  (cst-list-list-alt-matchp (abnf::tree-nonleaf->branches abnf::cst)
                            "%s\"\\n\"")))

Theorem: cst-carriage-return-escape-branches-match-alt

(defthm cst-carriage-return-escape-branches-match-alt
 (implies
  (cst-matchp abnf::cst "carriage-return-escape")
  (cst-list-list-alt-matchp (abnf::tree-nonleaf->branches abnf::cst)
                            "%s\"\\r\"")))

Theorem: cst-horizontal-tab-escape-branches-match-alt

(defthm cst-horizontal-tab-escape-branches-match-alt
 (implies
  (cst-matchp abnf::cst "horizontal-tab-escape")
  (cst-list-list-alt-matchp (abnf::tree-nonleaf->branches abnf::cst)
                            "%s\"\\t\"")))

Theorem: cst-null-character-escape-branches-match-alt

(defthm cst-null-character-escape-branches-match-alt
 (implies
  (cst-matchp abnf::cst "null-character-escape")
  (cst-list-list-alt-matchp (abnf::tree-nonleaf->branches abnf::cst)
                            "\"\\0\"")))

Theorem: cst-simple-character-escape-branches-match-alt

(defthm cst-simple-character-escape-branches-match-alt
 (implies
  (cst-matchp abnf::cst "simple-character-escape")
  (cst-list-list-alt-matchp
   (abnf::tree-nonleaf->branches abnf::cst)
   "single-quote-escape / double-quote-escape / backslash-escape / line-feed-escape / carriage-return-escape / horizontal-tab-escape / null-character-escape")))

Theorem: cst-ascii-character-escape-branches-match-alt

(defthm cst-ascii-character-escape-branches-match-alt
  (implies (cst-matchp abnf::cst "ascii-character-escape")
           (cst-list-list-alt-matchp
                (abnf::tree-nonleaf->branches abnf::cst)
                "%s\"\\x\" octal-digit hexadecimal-digit")))

Theorem: cst-unicode-character-escape-branches-match-alt

(defthm cst-unicode-character-escape-branches-match-alt
 (implies
  (cst-matchp abnf::cst "unicode-character-escape")
  (cst-list-list-alt-matchp (abnf::tree-nonleaf->branches abnf::cst)
                            "%s\"\\u{\" 1*6hexadecimal-digit \"}\"")))

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)
            "double-quote *string-literal-element double-quote")))

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

(defthm cst-string-literal-element-branches-match-alt
 (implies
  (cst-matchp abnf::cst "string-literal-element")
  (cst-list-list-alt-matchp
   (abnf::tree-nonleaf->branches abnf::cst)
   "not-double-quote-or-backslash-or-line-feed-or-carriage-return / simple-character-escape / ascii-character-escape / unicode-character-escape")))

Theorem: cst-not-double-quote-or-backslash-or-line-feed-or-carriage-return-branches-match-alt

(defthm
 cst-not-double-quote-or-backslash-or-line-feed-or-carriage-return-branches-match-alt
 (implies
  (cst-matchp
    abnf::cst
    "not-double-quote-or-backslash-or-line-feed-or-carriage-return")
  (cst-list-list-alt-matchp
   (abnf::tree-nonleaf->branches abnf::cst)
   "horizontal-tab / %x20-21 / %x23-5B / %x5D-7E / safe-nonascii")))

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)
                            "unsigned-literal / signed-literal")))

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

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

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

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

Theorem: cst-annotation-branches-match-alt

(defthm cst-annotation-branches-match-alt
 (implies
  (cst-matchp abnf::cst "annotation")
  (cst-list-list-alt-matchp (abnf::tree-nonleaf->branches abnf::cst)
                            "\"@\" identifier")))

Theorem: cst-symbol-branches-match-alt

(defthm cst-symbol-branches-match-alt
 (implies
  (cst-matchp abnf::cst "symbol")
  (cst-list-list-alt-matchp
   (abnf::tree-nonleaf->branches abnf::cst)
   "\"!\" / \"&&\" / \"||\" / \"==\" / \"!=\" / \"<\" / \"<=\" / \">\" / \">=\" / \"&\" / \"|\" / \"^\" / \"<<\" / \">>\" / \"+\" / \"-\" / \"*\" / \"/\" / \"%\" / \"**\" / \"=\" / \"+=\" / \"-=\" / \"*=\" / \"/=\" / \"%=\" / \"**=\" / \"<<=\" / \">>=\" / \"&=\" / \"|=\" / \"^=\" / \"&&=\" / \"||=\" / \"(\" / \")\" / \"[\" / \"]\" / \"{\" / \"}\" / \",\" / \".\" / \"..\" / \";\" / \":\" / \"::\" / \"?\" / \"->\" / \"=>\" / \"_\" / %s\")group\"")))

Theorem: cst-token-branches-match-alt

(defthm cst-token-branches-match-alt
 (implies
  (cst-matchp abnf::cst "token")
  (cst-list-list-alt-matchp
   (abnf::tree-nonleaf->branches abnf::cst)
   "keyword / identifier / atomic-literal / numeral / annotation / symbol")))

Theorem: cst-lexeme-branches-match-alt

(defthm cst-lexeme-branches-match-alt
 (implies
  (cst-matchp abnf::cst "lexeme")
  (cst-list-list-alt-matchp (abnf::tree-nonleaf->branches abnf::cst)
                            "token / comment / whitespace")))

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-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-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\"bool\"")))

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-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-named-primitive-type-branches-match-alt

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

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

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

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

(defthm cst-primitive-type-branches-match-alt
 (implies
  (cst-matchp abnf::cst "primitive-type")
  (cst-list-list-alt-matchp (abnf::tree-nonleaf->branches abnf::cst)
                            "named-primitive-type / unit-type")))

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

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

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

(defthm cst-tuple-type-branches-match-alt
 (implies
  (cst-matchp abnf::cst "tuple-type")
  (cst-list-list-alt-matchp (abnf::tree-nonleaf->branches abnf::cst)
                            "\"(\" type 1*( \",\" type ) [ \",\" ] \")\"")))

Theorem: cst-type-branches-match-alt

(defthm cst-type-branches-match-alt
 (implies
  (cst-matchp abnf::cst "type")
  (cst-list-list-alt-matchp (abnf::tree-nonleaf->branches abnf::cst)
                            "named-type / unit-type / tuple-type")))

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

(defthm cst-group-coordinate-branches-match-alt
  (implies (cst-matchp abnf::cst "group-coordinate")
           (cst-list-list-alt-matchp
                (abnf::tree-nonleaf->branches abnf::cst)
                "( [ \"-\" ] numeral ) / \"+\" / \"-\" / \"_\"")))

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

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

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)
                "atomic-literal / affine-group-literal")))

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)
                "product-group-literal / affine-group-literal")))

Theorem: cst-primary-expression-branches-match-alt

(defthm cst-primary-expression-branches-match-alt
 (implies
  (cst-matchp abnf::cst "primary-expression")
  (cst-list-list-alt-matchp
   (abnf::tree-nonleaf->branches abnf::cst)
   "literal / variable-or-free-constant / associated-constant / \"(\" expression \")\" / free-function-call / static-function-call / unit-expression / tuple-expression / struct-expression")))

Theorem: cst-variable-or-free-constant-branches-match-alt

(defthm cst-variable-or-free-constant-branches-match-alt
 (implies
  (cst-matchp abnf::cst "variable-or-free-constant")
  (cst-list-list-alt-matchp (abnf::tree-nonleaf->branches abnf::cst)
                            "identifier")))

Theorem: cst-associated-constant-branches-match-alt

(defthm cst-associated-constant-branches-match-alt
 (implies
  (cst-matchp abnf::cst "associated-constant")
  (cst-list-list-alt-matchp (abnf::tree-nonleaf->branches abnf::cst)
                            "named-type \"::\" identifier")))

Theorem: cst-free-function-call-branches-match-alt

(defthm cst-free-function-call-branches-match-alt
 (implies
  (cst-matchp abnf::cst "free-function-call")
  (cst-list-list-alt-matchp
     (abnf::tree-nonleaf->branches abnf::cst)
     "identifier function-arguments / locator function-arguments")))

Theorem: cst-static-function-call-branches-match-alt

(defthm cst-static-function-call-branches-match-alt
  (implies (cst-matchp abnf::cst "static-function-call")
           (cst-list-list-alt-matchp
                (abnf::tree-nonleaf->branches abnf::cst)
                "named-type \"::\" identifier function-arguments")))

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

(defthm cst-function-arguments-branches-match-alt
  (implies
       (cst-matchp abnf::cst "function-arguments")
       (cst-list-list-alt-matchp
            (abnf::tree-nonleaf->branches abnf::cst)
            "\"(\" [ expression *( \",\" expression ) [ \",\" ] ] \")\"")))

Theorem: cst-unit-expression-branches-match-alt

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

Theorem: cst-tuple-expression-branches-match-alt

(defthm cst-tuple-expression-branches-match-alt
  (implies (cst-matchp abnf::cst "tuple-expression")
           (cst-list-list-alt-matchp
                (abnf::tree-nonleaf->branches abnf::cst)
                "\"(\" expression 1*( \",\" expression ) [ \",\" ] \")\"")))

Theorem: cst-struct-expression-branches-match-alt

(defthm cst-struct-expression-branches-match-alt
 (implies
  (cst-matchp abnf::cst "struct-expression")
  (cst-list-list-alt-matchp
   (abnf::tree-nonleaf->branches abnf::cst)
   "identifier \"{\" struct-component-initializer *( \",\" struct-component-initializer ) [ \",\" ] \"}\"")))

Theorem: cst-struct-component-initializer-branches-match-alt

(defthm cst-struct-component-initializer-branches-match-alt
  (implies (cst-matchp abnf::cst
                       "struct-component-initializer")
           (cst-list-list-alt-matchp
                (abnf::tree-nonleaf->branches abnf::cst)
                "identifier / identifier \":\" expression")))

Theorem: cst-postfix-expression-branches-match-alt

(defthm cst-postfix-expression-branches-match-alt
 (implies
  (cst-matchp abnf::cst "postfix-expression")
  (cst-list-list-alt-matchp
   (abnf::tree-nonleaf->branches abnf::cst)
   "primary-expression / tuple-component-expression / struct-component-expression / operator-call")))

Theorem: cst-tuple-component-expression-branches-match-alt

(defthm cst-tuple-component-expression-branches-match-alt
 (implies
  (cst-matchp abnf::cst "tuple-component-expression")
  (cst-list-list-alt-matchp (abnf::tree-nonleaf->branches abnf::cst)
                            "postfix-expression \".\" numeral")))

Theorem: cst-struct-component-expression-branches-match-alt

(defthm cst-struct-component-expression-branches-match-alt
 (implies
  (cst-matchp abnf::cst "struct-component-expression")
  (cst-list-list-alt-matchp (abnf::tree-nonleaf->branches abnf::cst)
                            "postfix-expression \".\" identifier")))

Theorem: cst-operator-call-branches-match-alt

(defthm cst-operator-call-branches-match-alt
  (implies (cst-matchp abnf::cst "operator-call")
           (cst-list-list-alt-matchp
                (abnf::tree-nonleaf->branches abnf::cst)
                "unary-operator-call / binary-operator-call")))

Theorem: cst-unary-operator-call-branches-match-alt

(defthm cst-unary-operator-call-branches-match-alt
  (implies (cst-matchp abnf::cst "unary-operator-call")
           (cst-list-list-alt-matchp
                (abnf::tree-nonleaf->branches abnf::cst)
                "postfix-expression \".\" identifier \"(\" \")\"")))

Theorem: cst-binary-operator-call-branches-match-alt

(defthm cst-binary-operator-call-branches-match-alt
 (implies
  (cst-matchp abnf::cst "binary-operator-call")
  (cst-list-list-alt-matchp
   (abnf::tree-nonleaf->branches abnf::cst)
   "postfix-expression \".\" identifier \"(\" expression [ \",\" ] \")\"")))

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

(defthm cst-unary-expression-branches-match-alt
 (implies
  (cst-matchp abnf::cst "unary-expression")
  (cst-list-list-alt-matchp
   (abnf::tree-nonleaf->branches abnf::cst)
   "postfix-expression / \"!\" unary-expression / \"-\" unary-expression")))

Theorem: cst-exponential-expression-branches-match-alt

(defthm cst-exponential-expression-branches-match-alt
 (implies
  (cst-matchp abnf::cst "exponential-expression")
  (cst-list-list-alt-matchp
   (abnf::tree-nonleaf->branches abnf::cst)
   "unary-expression / unary-expression \"**\" exponential-expression")))

Theorem: cst-multiplicative-expression-branches-match-alt

(defthm cst-multiplicative-expression-branches-match-alt
 (implies
  (cst-matchp abnf::cst "multiplicative-expression")
  (cst-list-list-alt-matchp
   (abnf::tree-nonleaf->branches abnf::cst)
   "exponential-expression / multiplicative-expression \"*\" exponential-expression / multiplicative-expression \"/\" exponential-expression / multiplicative-expression \"%\" exponential-expression")))

Theorem: cst-additive-expression-branches-match-alt

(defthm cst-additive-expression-branches-match-alt
 (implies
  (cst-matchp abnf::cst "additive-expression")
  (cst-list-list-alt-matchp
   (abnf::tree-nonleaf->branches abnf::cst)
   "multiplicative-expression / additive-expression \"+\" multiplicative-expression / additive-expression \"-\" multiplicative-expression")))

Theorem: cst-shift-expression-branches-match-alt

(defthm cst-shift-expression-branches-match-alt
 (implies
  (cst-matchp abnf::cst "shift-expression")
  (cst-list-list-alt-matchp
   (abnf::tree-nonleaf->branches abnf::cst)
   "additive-expression / shift-expression \"<<\" additive-expression / shift-expression \">>\" additive-expression")))

Theorem: cst-conjunctive-expression-branches-match-alt

(defthm cst-conjunctive-expression-branches-match-alt
 (implies
  (cst-matchp abnf::cst "conjunctive-expression")
  (cst-list-list-alt-matchp
   (abnf::tree-nonleaf->branches abnf::cst)
   "shift-expression / conjunctive-expression \"&\" shift-expression")))

Theorem: cst-disjunctive-expression-branches-match-alt

(defthm cst-disjunctive-expression-branches-match-alt
 (implies
  (cst-matchp abnf::cst "disjunctive-expression")
  (cst-list-list-alt-matchp
   (abnf::tree-nonleaf->branches abnf::cst)
   "conjunctive-expression / disjunctive-expression \"|\" conjunctive-expression")))

Theorem: cst-exclusive-disjunctive-expression-branches-match-alt

(defthm cst-exclusive-disjunctive-expression-branches-match-alt
 (implies
  (cst-matchp abnf::cst
              "exclusive-disjunctive-expression")
  (cst-list-list-alt-matchp
   (abnf::tree-nonleaf->branches abnf::cst)
   "disjunctive-expression / exclusive-disjunctive-expression \"^\" disjunctive-expression")))

Theorem: cst-ordering-expression-branches-match-alt

(defthm cst-ordering-expression-branches-match-alt
 (implies
  (cst-matchp abnf::cst "ordering-expression")
  (cst-list-list-alt-matchp
   (abnf::tree-nonleaf->branches abnf::cst)
   "exclusive-disjunctive-expression / exclusive-disjunctive-expression \"<\" exclusive-disjunctive-expression / exclusive-disjunctive-expression \">\" exclusive-disjunctive-expression / exclusive-disjunctive-expression \"<=\" exclusive-disjunctive-expression / exclusive-disjunctive-expression \">=\" exclusive-disjunctive-expression")))

Theorem: cst-equality-expression-branches-match-alt

(defthm cst-equality-expression-branches-match-alt
 (implies
  (cst-matchp abnf::cst "equality-expression")
  (cst-list-list-alt-matchp
   (abnf::tree-nonleaf->branches abnf::cst)
   "ordering-expression / ordering-expression \"==\" ordering-expression / ordering-expression \"!=\" ordering-expression")))

Theorem: cst-conditional-conjunctive-expression-branches-match-alt

(defthm cst-conditional-conjunctive-expression-branches-match-alt
 (implies
  (cst-matchp abnf::cst
              "conditional-conjunctive-expression")
  (cst-list-list-alt-matchp
   (abnf::tree-nonleaf->branches abnf::cst)
   "equality-expression / conditional-conjunctive-expression \"&&\" equality-expression")))

Theorem: cst-conditional-disjunctive-expression-branches-match-alt

(defthm cst-conditional-disjunctive-expression-branches-match-alt
 (implies
  (cst-matchp abnf::cst
              "conditional-disjunctive-expression")
  (cst-list-list-alt-matchp
   (abnf::tree-nonleaf->branches abnf::cst)
   "conditional-conjunctive-expression / conditional-disjunctive-expression \"||\" conditional-conjunctive-expression")))

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

(defthm cst-binary-expression-branches-match-alt
 (implies
  (cst-matchp abnf::cst "binary-expression")
  (cst-list-list-alt-matchp (abnf::tree-nonleaf->branches abnf::cst)
                            "conditional-disjunctive-expression")))

Theorem: cst-conditional-ternary-expression-branches-match-alt

(defthm cst-conditional-ternary-expression-branches-match-alt
 (implies
  (cst-matchp abnf::cst
              "conditional-ternary-expression")
  (cst-list-list-alt-matchp
   (abnf::tree-nonleaf->branches abnf::cst)
   "binary-expression / binary-expression \"?\" expression \":\" expression")))

Theorem: cst-expression-branches-match-alt

(defthm cst-expression-branches-match-alt
 (implies
  (cst-matchp abnf::cst "expression")
  (cst-list-list-alt-matchp (abnf::tree-nonleaf->branches abnf::cst)
                            "conditional-ternary-expression")))

Theorem: cst-statement-branches-match-alt

(defthm cst-statement-branches-match-alt
 (implies
  (cst-matchp abnf::cst "statement")
  (cst-list-list-alt-matchp
   (abnf::tree-nonleaf->branches abnf::cst)
   "return-statement / variable-declaration / constant-declaration / conditional-statement / loop-statement / assignment-statement / console-statement / finalize-statement / increment-statement / decrement-statement / block")))

Theorem: cst-block-branches-match-alt

(defthm cst-block-branches-match-alt
 (implies
  (cst-matchp abnf::cst "block")
  (cst-list-list-alt-matchp (abnf::tree-nonleaf->branches abnf::cst)
                            "\"{\" *statement \"}\"")))

Theorem: cst-return-statement-branches-match-alt

(defthm cst-return-statement-branches-match-alt
 (implies
  (cst-matchp abnf::cst "return-statement")
  (cst-list-list-alt-matchp (abnf::tree-nonleaf->branches abnf::cst)
                            "%s\"return\" expression \";\"")))

Theorem: cst-variable-declaration-branches-match-alt

(defthm cst-variable-declaration-branches-match-alt
  (implies (cst-matchp abnf::cst "variable-declaration")
           (cst-list-list-alt-matchp
                (abnf::tree-nonleaf->branches abnf::cst)
                "%s\"let\" identifier \":\" type \"=\" expression \";\"")))

Theorem: cst-constant-declaration-branches-match-alt

(defthm cst-constant-declaration-branches-match-alt
 (implies (cst-matchp abnf::cst "constant-declaration")
          (cst-list-list-alt-matchp
               (abnf::tree-nonleaf->branches abnf::cst)
               "%s\"const\" identifier \":\" type \"=\" expression \";\"")))

Theorem: cst-branch-branches-match-alt

(defthm cst-branch-branches-match-alt
 (implies
  (cst-matchp abnf::cst "branch")
  (cst-list-list-alt-matchp (abnf::tree-nonleaf->branches abnf::cst)
                            "%s\"if\" expression block")))

Theorem: cst-conditional-statement-branches-match-alt

(defthm cst-conditional-statement-branches-match-alt
 (implies
  (cst-matchp abnf::cst "conditional-statement")
  (cst-list-list-alt-matchp
   (abnf::tree-nonleaf->branches abnf::cst)
   "branch / branch %s\"else\" block / branch %s\"else\" conditional-statement")))

Theorem: cst-loop-statement-branches-match-alt

(defthm cst-loop-statement-branches-match-alt
 (implies
  (cst-matchp abnf::cst "loop-statement")
  (cst-list-list-alt-matchp
   (abnf::tree-nonleaf->branches abnf::cst)
   "%s\"for\" identifier \":\" type %s\"in\" expression \"..\" [ \"=\" ] expression block")))

Theorem: cst-assignment-operator-branches-match-alt

(defthm cst-assignment-operator-branches-match-alt
 (implies
  (cst-matchp abnf::cst "assignment-operator")
  (cst-list-list-alt-matchp
   (abnf::tree-nonleaf->branches abnf::cst)
   "\"=\" / \"+=\" / \"-=\" / \"*=\" / \"/=\" / \"%=\" / \"**=\" / \"<<=\" / \">>=\" / \"&=\" / \"|=\" / \"^=\" / \"&&=\" / \"||=\"")))

Theorem: cst-assignment-statement-branches-match-alt

(defthm cst-assignment-statement-branches-match-alt
  (implies (cst-matchp abnf::cst "assignment-statement")
           (cst-list-list-alt-matchp
                (abnf::tree-nonleaf->branches abnf::cst)
                "expression assignment-operator expression \";\"")))

Theorem: cst-console-statement-branches-match-alt

(defthm cst-console-statement-branches-match-alt
 (implies
  (cst-matchp abnf::cst "console-statement")
  (cst-list-list-alt-matchp (abnf::tree-nonleaf->branches abnf::cst)
                            "%s\"console\" \".\" console-call \";\"")))

Theorem: cst-console-call-branches-match-alt

(defthm cst-console-call-branches-match-alt
 (implies
   (cst-matchp abnf::cst "console-call")
   (cst-list-list-alt-matchp
        (abnf::tree-nonleaf->branches abnf::cst)
        "assert-call / assert-equal-call / assert-not-equal-call")))

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

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

Theorem: cst-assert-equal-call-branches-match-alt

(defthm cst-assert-equal-call-branches-match-alt
 (implies
   (cst-matchp abnf::cst "assert-equal-call")
   (cst-list-list-alt-matchp
        (abnf::tree-nonleaf->branches abnf::cst)
        "%s\"assert_eq\" \"(\" expression \",\" expression [ \",\" ] \")\"")))

Theorem: cst-assert-not-equal-call-branches-match-alt

(defthm cst-assert-not-equal-call-branches-match-alt
 (implies
  (cst-matchp abnf::cst "assert-not-equal-call")
  (cst-list-list-alt-matchp
       (abnf::tree-nonleaf->branches abnf::cst)
       "%s\"assert_neq\" \"(\" expression \",\" expression [ \",\" ] \")\"")))

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

(defthm cst-finalize-statement-branches-match-alt
  (implies (cst-matchp abnf::cst "finalize-statement")
           (cst-list-list-alt-matchp
                (abnf::tree-nonleaf->branches abnf::cst)
                "%s\"async\" %s\"finalize\" function-arguments \";\"")))

Theorem: cst-increment-statement-branches-match-alt

(defthm cst-increment-statement-branches-match-alt
 (implies
  (cst-matchp abnf::cst "increment-statement")
  (cst-list-list-alt-matchp
   (abnf::tree-nonleaf->branches abnf::cst)
   "%s\"increment\" \"(\" identifier \",\" expression \",\" expression [ \",\" ] \")\" \";\"")))

Theorem: cst-decrement-statement-branches-match-alt

(defthm cst-decrement-statement-branches-match-alt
 (implies
  (cst-matchp abnf::cst "decrement-statement")
  (cst-list-list-alt-matchp
   (abnf::tree-nonleaf->branches abnf::cst)
   "%s\"decrement\" \"(\" identifier \",\" expression \",\" expression [ \",\" ] \")\" \";\"")))

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

(defthm cst-function-declaration-branches-match-alt
 (implies
  (cst-matchp abnf::cst "function-declaration")
  (cst-list-list-alt-matchp
   (abnf::tree-nonleaf->branches abnf::cst)
   "*annotation %s\"function\" identifier \"(\" [ function-parameters ] \")\" \"->\" type block")))

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

(defthm cst-function-parameters-branches-match-alt
 (implies
    (cst-matchp abnf::cst "function-parameters")
    (cst-list-list-alt-matchp
         (abnf::tree-nonleaf->branches abnf::cst)
         "function-parameter *( \",\" function-parameter ) [ \",\" ]")))

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

(defthm cst-function-parameter-branches-match-alt
 (implies
  (cst-matchp abnf::cst "function-parameter")
  (cst-list-list-alt-matchp
   (abnf::tree-nonleaf->branches abnf::cst)
   "[ %s\"public\" / %s\"constant\" / %s\"const\" ] identifier \":\" type")))

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

(defthm cst-transition-declaration-branches-match-alt
 (implies
  (cst-matchp abnf::cst "transition-declaration")
  (cst-list-list-alt-matchp
   (abnf::tree-nonleaf->branches abnf::cst)
   "*annotation %s\"transition\" identifier \"(\" [ function-parameters ] \")\" \"->\" type block [ finalizer ]")))

Theorem: cst-finalizer-branches-match-alt

(defthm cst-finalizer-branches-match-alt
 (implies
  (cst-matchp abnf::cst "finalizer")
  (cst-list-list-alt-matchp
   (abnf::tree-nonleaf->branches abnf::cst)
   "%s\"finalize\" identifier \"(\" [ function-parameters ] \")\" [ \"->\" type ] block")))

Theorem: cst-struct-declaration-branches-match-alt

(defthm cst-struct-declaration-branches-match-alt
 (implies
  (cst-matchp abnf::cst "struct-declaration")
  (cst-list-list-alt-matchp
    (abnf::tree-nonleaf->branches abnf::cst)
    "%s\"struct\" identifier \"{\" struct-component-declarations \"}\"")))

Theorem: cst-struct-component-declarations-branches-match-alt

(defthm cst-struct-component-declarations-branches-match-alt
 (implies
  (cst-matchp abnf::cst
              "struct-component-declarations")
  (cst-list-list-alt-matchp
   (abnf::tree-nonleaf->branches abnf::cst)
   "struct-component-declaration *( \",\" struct-component-declaration ) [ \",\" ]")))

Theorem: cst-struct-component-declaration-branches-match-alt

(defthm cst-struct-component-declaration-branches-match-alt
 (implies
  (cst-matchp abnf::cst
              "struct-component-declaration")
  (cst-list-list-alt-matchp (abnf::tree-nonleaf->branches abnf::cst)
                            "identifier \":\" type")))

Theorem: cst-record-declaration-branches-match-alt

(defthm cst-record-declaration-branches-match-alt
 (implies
  (cst-matchp abnf::cst "record-declaration")
  (cst-list-list-alt-matchp
    (abnf::tree-nonleaf->branches abnf::cst)
    "%s\"record\" identifier \"{\" struct-component-declarations \"}\"")))

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

(defthm cst-mapping-declaration-branches-match-alt
  (implies (cst-matchp abnf::cst "mapping-declaration")
           (cst-list-list-alt-matchp
                (abnf::tree-nonleaf->branches abnf::cst)
                "%s\"mapping\" identifier \":\" type \"=>\" type \";\"")))

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

(defthm cst-program-item-branches-match-alt
 (implies
  (cst-matchp abnf::cst "program-item")
  (cst-list-list-alt-matchp
   (abnf::tree-nonleaf->branches abnf::cst)
   "function-declaration / transition-declaration / struct-declaration / record-declaration / mapping-declaration")))

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

(defthm cst-program-declaration-branches-match-alt
  (implies (cst-matchp abnf::cst "program-declaration")
           (cst-list-list-alt-matchp
                (abnf::tree-nonleaf->branches abnf::cst)
                "%s\"program\" program-id \"{\" *program-item \"}\"")))

Theorem: cst-import-declaration-branches-match-alt

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

Theorem: cst-file-branches-match-alt

(defthm cst-file-branches-match-alt
  (implies (cst-matchp abnf::cst "file")
           (cst-list-list-alt-matchp
                (abnf::tree-nonleaf->branches abnf::cst)
                "*import-declaration program-declaration")))

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

(defthm cst-input-type-branches-match-alt
 (implies
  (cst-matchp abnf::cst "input-type")
  (cst-list-list-alt-matchp (abnf::tree-nonleaf->branches abnf::cst)
                            "type")))

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

(defthm cst-input-expression-branches-match-alt
 (implies
  (cst-matchp abnf::cst "input-expression")
  (cst-list-list-alt-matchp (abnf::tree-nonleaf->branches abnf::cst)
                            "expression")))

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

(defthm cst-input-item-branches-match-alt
  (implies
       (cst-matchp abnf::cst "input-item")
       (cst-list-list-alt-matchp
            (abnf::tree-nonleaf->branches abnf::cst)
            "identifier \":\" input-type \"=\" input-expression \";\"")))

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

(defthm cst-input-title-branches-match-alt
 (implies
  (cst-matchp abnf::cst "input-title")
  (cst-list-list-alt-matchp
   (abnf::tree-nonleaf->branches abnf::cst)
   "\"[\" ( %s\"public\" / %s\"private\" / %s\"constant\" / %s\"const\" ) \"]\"")))

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

(defthm cst-input-section-branches-match-alt
 (implies
  (cst-matchp abnf::cst "input-section")
  (cst-list-list-alt-matchp (abnf::tree-nonleaf->branches abnf::cst)
                            "input-title *input-item")))

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

(defthm cst-input-file-branches-match-alt
 (implies
  (cst-matchp abnf::cst "input-file")
  (cst-list-list-alt-matchp (abnf::tree-nonleaf->branches abnf::cst)
                            "*input-section")))

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

(defthm cst-output-expression-branches-match-alt
 (implies
  (cst-matchp abnf::cst "output-expression")
  (cst-list-list-alt-matchp (abnf::tree-nonleaf->branches abnf::cst)
                            "expression")))

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

(defthm cst-output-item-branches-match-alt
 (implies
  (cst-matchp abnf::cst "output-item")
  (cst-list-list-alt-matchp (abnf::tree-nonleaf->branches abnf::cst)
                            "output-expression \";\"")))

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

(defthm cst-output-title-branches-match-alt
 (implies
  (cst-matchp abnf::cst "output-title")
  (cst-list-list-alt-matchp (abnf::tree-nonleaf->branches abnf::cst)
                            "\"[\" %s\"output\" \"]\"")))

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

(defthm cst-output-section-branches-match-alt
 (implies
  (cst-matchp abnf::cst "output-section")
  (cst-list-list-alt-matchp (abnf::tree-nonleaf->branches abnf::cst)
                            "output-title output-item")))

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

(defthm cst-output-file-branches-match-alt
 (implies
  (cst-matchp abnf::cst "output-file")
  (cst-list-list-alt-matchp (abnf::tree-nonleaf->branches abnf::cst)
                            "output-section")))

Theorem: cst-horizontal-tab-concs

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

Theorem: cst-line-feed-concs

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

Theorem: cst-carriage-return-concs

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

Theorem: cst-space-concs

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

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
   "horizontal-tab / line-feed / carriage-return / space / visible-ascii")
  (or (cst-list-list-conc-matchp abnf::cstss "horizontal-tab")
      (cst-list-list-conc-matchp abnf::cstss "line-feed")
      (cst-list-list-conc-matchp abnf::cstss "carriage-return")
      (cst-list-list-conc-matchp abnf::cstss "space")
      (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-line-terminator-concs

(defthm cst-line-terminator-concs
 (implies
     (cst-list-list-alt-matchp
          abnf::cstss
          "line-feed / carriage-return / carriage-return line-feed")
     (or (cst-list-list-conc-matchp abnf::cstss "line-feed")
         (cst-list-list-conc-matchp abnf::cstss "carriage-return")
         (cst-list-list-conc-matchp abnf::cstss
                                    "carriage-return line-feed"))))

Theorem: cst-whitespace-concs

(defthm cst-whitespace-concs
 (implies
    (cst-list-list-alt-matchp
         abnf::cstss
         "space / horizontal-tab / line-terminator")
    (or (cst-list-list-conc-matchp abnf::cstss "space")
        (cst-list-list-conc-matchp abnf::cstss "horizontal-tab")
        (cst-list-list-conc-matchp abnf::cstss "line-terminator"))))

Theorem: cst-comment-concs

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

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-or-line-feed-or-carriage-return rest-of-block-comment / line-terminator 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-or-line-feed-or-carriage-return rest-of-block-comment")
   (cst-list-list-conc-matchp
        abnf::cstss
        "line-terminator rest-of-block-comment"))))

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-or-line-feed-or-carriage-return rest-of-block-comment / line-terminator 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-or-line-feed-or-carriage-return rest-of-block-comment")
   (cst-list-list-conc-matchp
        abnf::cstss
        "line-terminator rest-of-block-comment"))))

Theorem: cst-not-star-or-line-feed-or-carriage-return-concs

(defthm cst-not-star-or-line-feed-or-carriage-return-concs
 (implies
      (cst-list-list-alt-matchp
           abnf::cstss
           "horizontal-tab / %x20-29 / %x2B-7E / safe-nonascii")
      (or (cst-list-list-conc-matchp abnf::cstss "horizontal-tab")
          (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-not-star-or-slash-or-line-feed-or-carriage-return-concs

(defthm cst-not-star-or-slash-or-line-feed-or-carriage-return-concs
 (implies
  (cst-list-list-alt-matchp
     abnf::cstss
     "horizontal-tab / %x20-29 / %x2B-2E / %x30-7E / safe-nonascii")
  (or (cst-list-list-conc-matchp abnf::cstss "horizontal-tab")
      (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-line-comment-concs

(defthm cst-line-comment-concs
  (implies (cst-list-list-alt-matchp
                abnf::cstss
                "\"//\" *not-line-feed-or-carriage-return")
           (or (cst-list-list-conc-matchp
                    abnf::cstss
                    "\"//\" *not-line-feed-or-carriage-return"))))

Theorem: cst-not-line-feed-or-carriage-return-concs

(defthm cst-not-line-feed-or-carriage-return-concs
 (implies
      (cst-list-list-alt-matchp
           abnf::cstss
           "horizontal-tab / space / visible-ascii / safe-nonascii")
      (or (cst-list-list-conc-matchp abnf::cstss "horizontal-tab")
          (cst-list-list-conc-matchp abnf::cstss "space")
          (cst-list-list-conc-matchp abnf::cstss "visible-ascii")
          (cst-list-list-conc-matchp abnf::cstss "safe-nonascii"))))

Theorem: cst-keyword-concs

(defthm cst-keyword-concs
 (implies
  (cst-list-list-alt-matchp
   abnf::cstss
   "%s\"address\" / %s\"async\" / %s\"bool\" / %s\"console\" / %s\"const\" / %s\"constant\" / %s\"decrement\" / %s\"else\" / %s\"field\" / %s\"finalize\" / %s\"for\" / %s\"function\" / %s\"group\" / %s\"i8\" / %s\"i16\" / %s\"i32\" / %s\"i64\" / %s\"i128\" / %s\"if\" / %s\"import\" / %s\"in\" / %s\"increment\" / %s\"let\" / %s\"mapping\" / %s\"program\" / %s\"public\" / %s\"record\" / %s\"return\" / %s\"scalar\" / %s\"string\" / %s\"struct\" / %s\"transition\" / %s\"u8\" / %s\"u16\" / %s\"u32\" / %s\"u64\" / %s\"u128\"")
  (or (cst-list-list-conc-matchp abnf::cstss "%s\"address\"")
      (cst-list-list-conc-matchp abnf::cstss "%s\"async\"")
      (cst-list-list-conc-matchp abnf::cstss "%s\"bool\"")
      (cst-list-list-conc-matchp abnf::cstss "%s\"console\"")
      (cst-list-list-conc-matchp abnf::cstss "%s\"const\"")
      (cst-list-list-conc-matchp abnf::cstss "%s\"constant\"")
      (cst-list-list-conc-matchp abnf::cstss "%s\"decrement\"")
      (cst-list-list-conc-matchp abnf::cstss "%s\"else\"")
      (cst-list-list-conc-matchp abnf::cstss "%s\"field\"")
      (cst-list-list-conc-matchp abnf::cstss "%s\"finalize\"")
      (cst-list-list-conc-matchp abnf::cstss "%s\"for\"")
      (cst-list-list-conc-matchp abnf::cstss "%s\"function\"")
      (cst-list-list-conc-matchp abnf::cstss "%s\"group\"")
      (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\"")
      (cst-list-list-conc-matchp abnf::cstss "%s\"if\"")
      (cst-list-list-conc-matchp abnf::cstss "%s\"import\"")
      (cst-list-list-conc-matchp abnf::cstss "%s\"in\"")
      (cst-list-list-conc-matchp abnf::cstss "%s\"increment\"")
      (cst-list-list-conc-matchp abnf::cstss "%s\"let\"")
      (cst-list-list-conc-matchp abnf::cstss "%s\"mapping\"")
      (cst-list-list-conc-matchp abnf::cstss "%s\"program\"")
      (cst-list-list-conc-matchp abnf::cstss "%s\"public\"")
      (cst-list-list-conc-matchp abnf::cstss "%s\"record\"")
      (cst-list-list-conc-matchp abnf::cstss "%s\"return\"")
      (cst-list-list-conc-matchp abnf::cstss "%s\"scalar\"")
      (cst-list-list-conc-matchp abnf::cstss "%s\"string\"")
      (cst-list-list-conc-matchp abnf::cstss "%s\"struct\"")
      (cst-list-list-conc-matchp abnf::cstss "%s\"transition\"")
      (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-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-decimal-digit-concs

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

Theorem: cst-octal-digit-concs

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

Theorem: cst-hexadecimal-digit-concs

(defthm cst-hexadecimal-digit-concs
  (implies
       (cst-list-list-alt-matchp
            abnf::cstss
            "decimal-digit / \"a\" / \"b\" / \"c\" / \"d\" / \"e\" / \"f\"")
       (or (cst-list-list-conc-matchp abnf::cstss "decimal-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 / decimal-digit / \"_\" )")
           (or (cst-list-list-conc-matchp
                    abnf::cstss
                    "letter *( letter / decimal-digit / \"_\" )"))))

Theorem: cst-numeral-concs

(defthm cst-numeral-concs
 (implies
    (cst-list-list-alt-matchp abnf::cstss "1*decimal-digit")
    (or (cst-list-list-conc-matchp abnf::cstss "1*decimal-digit"))))

Theorem: cst-unsigned-literal-concs

(defthm cst-unsigned-literal-concs
 (implies
  (cst-list-list-alt-matchp
      abnf::cstss
      "numeral ( %s\"u8\" / %s\"u16\" / %s\"u32\" / %s\"u64\" / %s\"u128\" )")
  (or
   (cst-list-list-conc-matchp
    abnf::cstss
    "numeral ( %s\"u8\" / %s\"u16\" / %s\"u32\" / %s\"u64\" / %s\"u128\" )"))))

Theorem: cst-signed-literal-concs

(defthm cst-signed-literal-concs
 (implies
  (cst-list-list-alt-matchp
      abnf::cstss
      "numeral ( %s\"i8\" / %s\"i16\" / %s\"i32\" / %s\"i64\" / %s\"i128\" )")
  (or
   (cst-list-list-conc-matchp
    abnf::cstss
    "numeral ( %s\"i8\" / %s\"i16\" / %s\"i32\" / %s\"i64\" / %s\"i128\" )"))))

Theorem: cst-field-literal-concs

(defthm cst-field-literal-concs
 (implies
  (cst-list-list-alt-matchp abnf::cstss "numeral %s\"field\"")
  (or (cst-list-list-conc-matchp abnf::cstss "numeral %s\"field\""))))

Theorem: cst-product-group-literal-concs

(defthm cst-product-group-literal-concs
 (implies
  (cst-list-list-alt-matchp abnf::cstss "numeral %s\"group\"")
  (or (cst-list-list-conc-matchp abnf::cstss "numeral %s\"group\""))))

Theorem: cst-scalar-literal-concs

(defthm cst-scalar-literal-concs
 (implies
  (cst-list-list-alt-matchp abnf::cstss "numeral %s\"scalar\"")
  (or
     (cst-list-list-conc-matchp abnf::cstss "numeral %s\"scalar\""))))

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-address-literal-concs

(defthm cst-address-literal-concs
 (implies
     (cst-list-list-alt-matchp
          abnf::cstss
          "%s\"aleo1\" 58( lowercase-letter / decimal-digit )")
     (or (cst-list-list-conc-matchp
              abnf::cstss
              "%s\"aleo1\" 58( lowercase-letter / decimal-digit )"))))

Theorem: cst-single-quote-concs

(defthm cst-single-quote-concs
  (implies (cst-list-list-alt-matchp abnf::cstss "%x27")
           (or (cst-list-list-conc-matchp abnf::cstss "%x27"))))

Theorem: cst-double-quote-concs

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

Theorem: cst-single-quote-escape-concs

(defthm cst-single-quote-escape-concs
 (implies
   (cst-list-list-alt-matchp abnf::cstss "\"\\\" single-quote")
   (or (cst-list-list-conc-matchp abnf::cstss "\"\\\" single-quote"))))

Theorem: cst-double-quote-escape-concs

(defthm cst-double-quote-escape-concs
 (implies
   (cst-list-list-alt-matchp abnf::cstss "\"\\\" double-quote")
   (or (cst-list-list-conc-matchp abnf::cstss "\"\\\" double-quote"))))

Theorem: cst-backslash-escape-concs

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

Theorem: cst-line-feed-escape-concs

(defthm cst-line-feed-escape-concs
  (implies (cst-list-list-alt-matchp abnf::cstss "%s\"\\n\"")
           (or (cst-list-list-conc-matchp abnf::cstss "%s\"\\n\""))))

Theorem: cst-carriage-return-escape-concs

(defthm cst-carriage-return-escape-concs
  (implies (cst-list-list-alt-matchp abnf::cstss "%s\"\\r\"")
           (or (cst-list-list-conc-matchp abnf::cstss "%s\"\\r\""))))

Theorem: cst-horizontal-tab-escape-concs

(defthm cst-horizontal-tab-escape-concs
  (implies (cst-list-list-alt-matchp abnf::cstss "%s\"\\t\"")
           (or (cst-list-list-conc-matchp abnf::cstss "%s\"\\t\""))))

Theorem: cst-null-character-escape-concs

(defthm cst-null-character-escape-concs
  (implies (cst-list-list-alt-matchp abnf::cstss "\"\\0\"")
           (or (cst-list-list-conc-matchp abnf::cstss "\"\\0\""))))

Theorem: cst-simple-character-escape-concs

(defthm cst-simple-character-escape-concs
 (implies
  (cst-list-list-alt-matchp
   abnf::cstss
   "single-quote-escape / double-quote-escape / backslash-escape / line-feed-escape / carriage-return-escape / horizontal-tab-escape / null-character-escape")
  (or
    (cst-list-list-conc-matchp abnf::cstss "single-quote-escape")
    (cst-list-list-conc-matchp abnf::cstss "double-quote-escape")
    (cst-list-list-conc-matchp abnf::cstss "backslash-escape")
    (cst-list-list-conc-matchp abnf::cstss "line-feed-escape")
    (cst-list-list-conc-matchp abnf::cstss "carriage-return-escape")
    (cst-list-list-conc-matchp abnf::cstss "horizontal-tab-escape")
    (cst-list-list-conc-matchp
         abnf::cstss "null-character-escape"))))

Theorem: cst-ascii-character-escape-concs

(defthm cst-ascii-character-escape-concs
 (implies
   (cst-list-list-alt-matchp abnf::cstss
                             "%s\"\\x\" octal-digit hexadecimal-digit")
   (or (cst-list-list-conc-matchp
            abnf::cstss
            "%s\"\\x\" octal-digit hexadecimal-digit"))))

Theorem: cst-unicode-character-escape-concs

(defthm cst-unicode-character-escape-concs
 (implies
  (cst-list-list-alt-matchp abnf::cstss
                            "%s\"\\u{\" 1*6hexadecimal-digit \"}\"")
  (or
   (cst-list-list-conc-matchp abnf::cstss
                              "%s\"\\u{\" 1*6hexadecimal-digit \"}\""))))

Theorem: cst-string-literal-concs

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

Theorem: cst-string-literal-element-concs

(defthm cst-string-literal-element-concs
 (implies
  (cst-list-list-alt-matchp
   abnf::cstss
   "not-double-quote-or-backslash-or-line-feed-or-carriage-return / simple-character-escape / ascii-character-escape / unicode-character-escape")
  (or
   (cst-list-list-conc-matchp
    abnf::cstss
    "not-double-quote-or-backslash-or-line-feed-or-carriage-return")
   (cst-list-list-conc-matchp abnf::cstss "simple-character-escape")
   (cst-list-list-conc-matchp abnf::cstss "ascii-character-escape")
   (cst-list-list-conc-matchp abnf::cstss
                              "unicode-character-escape"))))

Theorem: cst-not-double-quote-or-backslash-or-line-feed-or-carriage-return-concs

(defthm
 cst-not-double-quote-or-backslash-or-line-feed-or-carriage-return-concs
 (implies
  (cst-list-list-alt-matchp
     abnf::cstss
     "horizontal-tab / %x20-21 / %x23-5B / %x5D-7E / safe-nonascii")
  (or (cst-list-list-conc-matchp abnf::cstss "horizontal-tab")
      (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-integer-literal-concs

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

Theorem: cst-numeric-literal-concs

(defthm cst-numeric-literal-concs
 (implies
  (cst-list-list-alt-matchp
   abnf::cstss
   "integer-literal / field-literal / product-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 "product-group-literal")
     (cst-list-list-conc-matchp abnf::cstss "scalar-literal"))))

Theorem: cst-atomic-literal-concs

(defthm cst-atomic-literal-concs
 (implies
  (cst-list-list-alt-matchp
   abnf::cstss
   "numeric-literal / boolean-literal / address-literal / string-literal")
  (or (cst-list-list-conc-matchp abnf::cstss "numeric-literal")
      (cst-list-list-conc-matchp abnf::cstss "boolean-literal")
      (cst-list-list-conc-matchp abnf::cstss "address-literal")
      (cst-list-list-conc-matchp abnf::cstss "string-literal"))))

Theorem: cst-annotation-concs

(defthm cst-annotation-concs
 (implies
     (cst-list-list-alt-matchp abnf::cstss "\"@\" identifier")
     (or (cst-list-list-conc-matchp abnf::cstss "\"@\" identifier"))))

Theorem: cst-symbol-concs

(defthm cst-symbol-concs
 (implies
  (cst-list-list-alt-matchp
   abnf::cstss
   "\"!\" / \"&&\" / \"||\" / \"==\" / \"!=\" / \"<\" / \"<=\" / \">\" / \">=\" / \"&\" / \"|\" / \"^\" / \"<<\" / \">>\" / \"+\" / \"-\" / \"*\" / \"/\" / \"%\" / \"**\" / \"=\" / \"+=\" / \"-=\" / \"*=\" / \"/=\" / \"%=\" / \"**=\" / \"<<=\" / \">>=\" / \"&=\" / \"|=\" / \"^=\" / \"&&=\" / \"||=\" / \"(\" / \")\" / \"[\" / \"]\" / \"{\" / \"}\" / \",\" / \".\" / \"..\" / \";\" / \":\" / \"::\" / \"?\" / \"->\" / \"=>\" / \"_\" / %s\")group\"")
  (or (cst-list-list-conc-matchp abnf::cstss "\"!\"")
      (cst-list-list-conc-matchp abnf::cstss "\"&&\"")
      (cst-list-list-conc-matchp abnf::cstss "\"||\"")
      (cst-list-list-conc-matchp abnf::cstss "\"==\"")
      (cst-list-list-conc-matchp abnf::cstss "\"!=\"")
      (cst-list-list-conc-matchp abnf::cstss "\"<\"")
      (cst-list-list-conc-matchp abnf::cstss "\"<=\"")
      (cst-list-list-conc-matchp abnf::cstss "\">\"")
      (cst-list-list-conc-matchp abnf::cstss "\">=\"")
      (cst-list-list-conc-matchp abnf::cstss "\"&\"")
      (cst-list-list-conc-matchp abnf::cstss "\"|\"")
      (cst-list-list-conc-matchp abnf::cstss "\"^\"")
      (cst-list-list-conc-matchp abnf::cstss "\"<<\"")
      (cst-list-list-conc-matchp abnf::cstss "\">>\"")
      (cst-list-list-conc-matchp abnf::cstss "\"+\"")
      (cst-list-list-conc-matchp abnf::cstss "\"-\"")
      (cst-list-list-conc-matchp abnf::cstss "\"*\"")
      (cst-list-list-conc-matchp abnf::cstss "\"/\"")
      (cst-list-list-conc-matchp abnf::cstss "\"%\"")
      (cst-list-list-conc-matchp abnf::cstss "\"**\"")
      (cst-list-list-conc-matchp abnf::cstss "\"=\"")
      (cst-list-list-conc-matchp abnf::cstss "\"+=\"")
      (cst-list-list-conc-matchp abnf::cstss "\"-=\"")
      (cst-list-list-conc-matchp abnf::cstss "\"*=\"")
      (cst-list-list-conc-matchp abnf::cstss "\"/=\"")
      (cst-list-list-conc-matchp abnf::cstss "\"%=\"")
      (cst-list-list-conc-matchp abnf::cstss "\"**=\"")
      (cst-list-list-conc-matchp abnf::cstss "\"<<=\"")
      (cst-list-list-conc-matchp abnf::cstss "\">>=\"")
      (cst-list-list-conc-matchp abnf::cstss "\"&=\"")
      (cst-list-list-conc-matchp abnf::cstss "\"|=\"")
      (cst-list-list-conc-matchp abnf::cstss "\"^=\"")
      (cst-list-list-conc-matchp abnf::cstss "\"&&=\"")
      (cst-list-list-conc-matchp abnf::cstss "\"||=\"")
      (cst-list-list-conc-matchp abnf::cstss "\"(\"")
      (cst-list-list-conc-matchp abnf::cstss "\")\"")
      (cst-list-list-conc-matchp abnf::cstss "\"[\"")
      (cst-list-list-conc-matchp abnf::cstss "\"]\"")
      (cst-list-list-conc-matchp abnf::cstss "\"{\"")
      (cst-list-list-conc-matchp abnf::cstss "\"}\"")
      (cst-list-list-conc-matchp abnf::cstss "\",\"")
      (cst-list-list-conc-matchp abnf::cstss "\".\"")
      (cst-list-list-conc-matchp abnf::cstss "\"..\"")
      (cst-list-list-conc-matchp abnf::cstss "\";\"")
      (cst-list-list-conc-matchp abnf::cstss "\":\"")
      (cst-list-list-conc-matchp abnf::cstss "\"::\"")
      (cst-list-list-conc-matchp abnf::cstss "\"?\"")
      (cst-list-list-conc-matchp abnf::cstss "\"->\"")
      (cst-list-list-conc-matchp abnf::cstss "\"=>\"")
      (cst-list-list-conc-matchp abnf::cstss "\"_\"")
      (cst-list-list-conc-matchp abnf::cstss "%s\")group\""))))

Theorem: cst-token-concs

(defthm cst-token-concs
 (implies
  (cst-list-list-alt-matchp
   abnf::cstss
   "keyword / identifier / atomic-literal / numeral / annotation / symbol")
  (or (cst-list-list-conc-matchp abnf::cstss "keyword")
      (cst-list-list-conc-matchp abnf::cstss "identifier")
      (cst-list-list-conc-matchp abnf::cstss "atomic-literal")
      (cst-list-list-conc-matchp abnf::cstss "numeral")
      (cst-list-list-conc-matchp abnf::cstss "annotation")
      (cst-list-list-conc-matchp abnf::cstss "symbol"))))

Theorem: cst-lexeme-concs

(defthm cst-lexeme-concs
  (implies
       (cst-list-list-alt-matchp abnf::cstss
                                 "token / comment / whitespace")
       (or (cst-list-list-conc-matchp abnf::cstss "token")
           (cst-list-list-conc-matchp abnf::cstss "comment")
           (cst-list-list-conc-matchp abnf::cstss "whitespace"))))

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-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-boolean-type-concs

(defthm cst-boolean-type-concs
  (implies (cst-list-list-alt-matchp abnf::cstss "%s\"bool\"")
           (or (cst-list-list-conc-matchp abnf::cstss "%s\"bool\""))))

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-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-named-primitive-type-concs

(defthm cst-named-primitive-type-concs
 (implies
  (cst-list-list-alt-matchp
      abnf::cstss
      "boolean-type / arithmetic-type / address-type / string-type")
  (or (cst-list-list-conc-matchp abnf::cstss "boolean-type")
      (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 "string-type"))))

Theorem: cst-unit-type-concs

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

Theorem: cst-primitive-type-concs

(defthm cst-primitive-type-concs
 (implies
  (cst-list-list-alt-matchp abnf::cstss
                            "named-primitive-type / unit-type")
  (or (cst-list-list-conc-matchp abnf::cstss "named-primitive-type")
      (cst-list-list-conc-matchp abnf::cstss "unit-type"))))

Theorem: cst-named-type-concs

(defthm cst-named-type-concs
 (implies
  (cst-list-list-alt-matchp
   abnf::cstss
   "named-primitive-type / identifier [ \".\" %s\"record\" ] / locator [ \".\" %s\"record\" ]")
  (or (cst-list-list-conc-matchp abnf::cstss "named-primitive-type")
      (cst-list-list-conc-matchp abnf::cstss
                                 "identifier [ \".\" %s\"record\" ]")
      (cst-list-list-conc-matchp abnf::cstss
                                 "locator [ \".\" %s\"record\" ]"))))

Theorem: cst-tuple-type-concs

(defthm cst-tuple-type-concs
 (implies
    (cst-list-list-alt-matchp abnf::cstss
                              "\"(\" type 1*( \",\" type ) [ \",\" ] \")\"")
    (or (cst-list-list-conc-matchp
             abnf::cstss
             "\"(\" type 1*( \",\" type ) [ \",\" ] \")\""))))

Theorem: cst-type-concs

(defthm cst-type-concs
 (implies
    (cst-list-list-alt-matchp abnf::cstss
                              "named-type / unit-type / tuple-type")
    (or (cst-list-list-conc-matchp abnf::cstss "named-type")
        (cst-list-list-conc-matchp abnf::cstss "unit-type")
        (cst-list-list-conc-matchp abnf::cstss "tuple-type"))))

Theorem: cst-group-coordinate-concs

(defthm cst-group-coordinate-concs
 (implies
  (cst-list-list-alt-matchp abnf::cstss
                            "( [ \"-\" ] numeral ) / \"+\" / \"-\" / \"_\"")
  (or (cst-list-list-conc-matchp abnf::cstss "( [ \"-\" ] numeral )")
      (cst-list-list-conc-matchp abnf::cstss "\"+\"")
      (cst-list-list-conc-matchp abnf::cstss "\"-\"")
      (cst-list-list-conc-matchp abnf::cstss "\"_\""))))

Theorem: cst-affine-group-literal-concs

(defthm cst-affine-group-literal-concs
 (implies
  (cst-list-list-alt-matchp
       abnf::cstss
       "\"(\" group-coordinate \",\" group-coordinate %s\")group\"")
  (or
     (cst-list-list-conc-matchp
          abnf::cstss
          "\"(\" group-coordinate \",\" group-coordinate %s\")group\""))))

Theorem: cst-literal-concs

(defthm cst-literal-concs
 (implies
  (cst-list-list-alt-matchp abnf::cstss
                            "atomic-literal / affine-group-literal")
  (or
   (cst-list-list-conc-matchp abnf::cstss "atomic-literal")
   (cst-list-list-conc-matchp abnf::cstss "affine-group-literal"))))

Theorem: cst-group-literal-concs

(defthm cst-group-literal-concs
 (implies
  (cst-list-list-alt-matchp
       abnf::cstss
       "product-group-literal / affine-group-literal")
  (or
   (cst-list-list-conc-matchp abnf::cstss "product-group-literal")
   (cst-list-list-conc-matchp abnf::cstss "affine-group-literal"))))

Theorem: cst-primary-expression-concs

(defthm cst-primary-expression-concs
 (implies
  (cst-list-list-alt-matchp
   abnf::cstss
   "literal / variable-or-free-constant / associated-constant / \"(\" expression \")\" / free-function-call / static-function-call / unit-expression / tuple-expression / struct-expression")
  (or (cst-list-list-conc-matchp abnf::cstss "literal")
      (cst-list-list-conc-matchp
           abnf::cstss "variable-or-free-constant")
      (cst-list-list-conc-matchp abnf::cstss "associated-constant")
      (cst-list-list-conc-matchp abnf::cstss "\"(\" expression \")\"")
      (cst-list-list-conc-matchp abnf::cstss "free-function-call")
      (cst-list-list-conc-matchp abnf::cstss "static-function-call")
      (cst-list-list-conc-matchp abnf::cstss "unit-expression")
      (cst-list-list-conc-matchp abnf::cstss "tuple-expression")
      (cst-list-list-conc-matchp abnf::cstss "struct-expression"))))

Theorem: cst-variable-or-free-constant-concs

(defthm cst-variable-or-free-constant-concs
  (implies
       (cst-list-list-alt-matchp abnf::cstss "identifier")
       (or (cst-list-list-conc-matchp abnf::cstss "identifier"))))

Theorem: cst-associated-constant-concs

(defthm cst-associated-constant-concs
 (implies
     (cst-list-list-alt-matchp abnf::cstss
                               "named-type \"::\" identifier")
     (or (cst-list-list-conc-matchp abnf::cstss
                                    "named-type \"::\" identifier"))))

Theorem: cst-free-function-call-concs

(defthm cst-free-function-call-concs
 (implies
  (cst-list-list-alt-matchp
       abnf::cstss
       "identifier function-arguments / locator function-arguments")
  (or (cst-list-list-conc-matchp abnf::cstss
                                 "identifier function-arguments")
      (cst-list-list-conc-matchp abnf::cstss
                                 "locator function-arguments"))))

Theorem: cst-static-function-call-concs

(defthm cst-static-function-call-concs
  (implies
       (cst-list-list-alt-matchp
            abnf::cstss
            "named-type \"::\" identifier function-arguments")
       (or (cst-list-list-conc-matchp
                abnf::cstss
                "named-type \"::\" identifier function-arguments"))))

Theorem: cst-function-arguments-concs

(defthm cst-function-arguments-concs
 (implies
   (cst-list-list-alt-matchp
        abnf::cstss
        "\"(\" [ expression *( \",\" expression ) [ \",\" ] ] \")\"")
   (or (cst-list-list-conc-matchp
            abnf::cstss
            "\"(\" [ expression *( \",\" expression ) [ \",\" ] ] \")\""))))

Theorem: cst-unit-expression-concs

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

Theorem: cst-tuple-expression-concs

(defthm cst-tuple-expression-concs
 (implies
      (cst-list-list-alt-matchp
           abnf::cstss
           "\"(\" expression 1*( \",\" expression ) [ \",\" ] \")\"")
      (or (cst-list-list-conc-matchp
               abnf::cstss
               "\"(\" expression 1*( \",\" expression ) [ \",\" ] \")\""))))

Theorem: cst-struct-expression-concs

(defthm cst-struct-expression-concs
 (implies
  (cst-list-list-alt-matchp
   abnf::cstss
   "identifier \"{\" struct-component-initializer *( \",\" struct-component-initializer ) [ \",\" ] \"}\"")
  (or
   (cst-list-list-conc-matchp
    abnf::cstss
    "identifier \"{\" struct-component-initializer *( \",\" struct-component-initializer ) [ \",\" ] \"}\""))))

Theorem: cst-struct-component-initializer-concs

(defthm cst-struct-component-initializer-concs
 (implies
      (cst-list-list-alt-matchp
           abnf::cstss
           "identifier / identifier \":\" expression")
      (or (cst-list-list-conc-matchp abnf::cstss "identifier")
          (cst-list-list-conc-matchp abnf::cstss
                                     "identifier \":\" expression"))))

Theorem: cst-postfix-expression-concs

(defthm cst-postfix-expression-concs
 (implies
  (cst-list-list-alt-matchp
   abnf::cstss
   "primary-expression / tuple-component-expression / struct-component-expression / operator-call")
  (or (cst-list-list-conc-matchp abnf::cstss "primary-expression")
      (cst-list-list-conc-matchp abnf::cstss
                                 "tuple-component-expression")
      (cst-list-list-conc-matchp abnf::cstss
                                 "struct-component-expression")
      (cst-list-list-conc-matchp abnf::cstss "operator-call"))))

Theorem: cst-tuple-component-expression-concs

(defthm cst-tuple-component-expression-concs
 (implies
  (cst-list-list-alt-matchp abnf::cstss
                            "postfix-expression \".\" numeral")
  (or
     (cst-list-list-conc-matchp abnf::cstss
                                "postfix-expression \".\" numeral"))))

Theorem: cst-struct-component-expression-concs

(defthm cst-struct-component-expression-concs
 (implies
      (cst-list-list-alt-matchp abnf::cstss
                                "postfix-expression \".\" identifier")
      (or (cst-list-list-conc-matchp
               abnf::cstss
               "postfix-expression \".\" identifier"))))

Theorem: cst-operator-call-concs

(defthm cst-operator-call-concs
 (implies
  (cst-list-list-alt-matchp
       abnf::cstss
       "unary-operator-call / binary-operator-call")
  (or
   (cst-list-list-conc-matchp abnf::cstss "unary-operator-call")
   (cst-list-list-conc-matchp abnf::cstss "binary-operator-call"))))

Theorem: cst-unary-operator-call-concs

(defthm cst-unary-operator-call-concs
  (implies (cst-list-list-alt-matchp
                abnf::cstss
                "postfix-expression \".\" identifier \"(\" \")\"")
           (or (cst-list-list-conc-matchp
                    abnf::cstss
                    "postfix-expression \".\" identifier \"(\" \")\""))))

Theorem: cst-binary-operator-call-concs

(defthm cst-binary-operator-call-concs
 (implies
  (cst-list-list-alt-matchp
     abnf::cstss
     "postfix-expression \".\" identifier \"(\" expression [ \",\" ] \")\"")
  (or
   (cst-list-list-conc-matchp
    abnf::cstss
    "postfix-expression \".\" identifier \"(\" expression [ \",\" ] \")\""))))

Theorem: cst-unary-expression-concs

(defthm cst-unary-expression-concs
 (implies
  (cst-list-list-alt-matchp
   abnf::cstss
   "postfix-expression / \"!\" unary-expression / \"-\" unary-expression")
  (or
   (cst-list-list-conc-matchp abnf::cstss "postfix-expression")
   (cst-list-list-conc-matchp abnf::cstss "\"!\" unary-expression")
   (cst-list-list-conc-matchp abnf::cstss "\"-\" unary-expression"))))

Theorem: cst-exponential-expression-concs

(defthm cst-exponential-expression-concs
 (implies
  (cst-list-list-alt-matchp
   abnf::cstss
   "unary-expression / unary-expression \"**\" exponential-expression")
  (or (cst-list-list-conc-matchp abnf::cstss "unary-expression")
      (cst-list-list-conc-matchp
           abnf::cstss
           "unary-expression \"**\" exponential-expression"))))

Theorem: cst-multiplicative-expression-concs

(defthm cst-multiplicative-expression-concs
 (implies
  (cst-list-list-alt-matchp
   abnf::cstss
   "exponential-expression / multiplicative-expression \"*\" exponential-expression / multiplicative-expression \"/\" exponential-expression / multiplicative-expression \"%\" exponential-expression")
  (or
    (cst-list-list-conc-matchp abnf::cstss "exponential-expression")
    (cst-list-list-conc-matchp
         abnf::cstss
         "multiplicative-expression \"*\" exponential-expression")
    (cst-list-list-conc-matchp
         abnf::cstss
         "multiplicative-expression \"/\" exponential-expression")
    (cst-list-list-conc-matchp
         abnf::cstss
         "multiplicative-expression \"%\" exponential-expression"))))

Theorem: cst-additive-expression-concs

(defthm cst-additive-expression-concs
 (implies
  (cst-list-list-alt-matchp
   abnf::cstss
   "multiplicative-expression / additive-expression \"+\" multiplicative-expression / additive-expression \"-\" multiplicative-expression")
  (or (cst-list-list-conc-matchp
           abnf::cstss "multiplicative-expression")
      (cst-list-list-conc-matchp
           abnf::cstss
           "additive-expression \"+\" multiplicative-expression")
      (cst-list-list-conc-matchp
           abnf::cstss
           "additive-expression \"-\" multiplicative-expression"))))

Theorem: cst-shift-expression-concs

(defthm cst-shift-expression-concs
 (implies
  (cst-list-list-alt-matchp
   abnf::cstss
   "additive-expression / shift-expression \"<<\" additive-expression / shift-expression \">>\" additive-expression")
  (or (cst-list-list-conc-matchp abnf::cstss "additive-expression")
      (cst-list-list-conc-matchp
           abnf::cstss
           "shift-expression \"<<\" additive-expression")
      (cst-list-list-conc-matchp
           abnf::cstss
           "shift-expression \">>\" additive-expression"))))

Theorem: cst-conjunctive-expression-concs

(defthm cst-conjunctive-expression-concs
 (implies
  (cst-list-list-alt-matchp
   abnf::cstss
   "shift-expression / conjunctive-expression \"&\" shift-expression")
  (or (cst-list-list-conc-matchp abnf::cstss "shift-expression")
      (cst-list-list-conc-matchp
           abnf::cstss
           "conjunctive-expression \"&\" shift-expression"))))

Theorem: cst-disjunctive-expression-concs

(defthm cst-disjunctive-expression-concs
 (implies
  (cst-list-list-alt-matchp
   abnf::cstss
   "conjunctive-expression / disjunctive-expression \"|\" conjunctive-expression")
  (or
    (cst-list-list-conc-matchp abnf::cstss "conjunctive-expression")
    (cst-list-list-conc-matchp
         abnf::cstss
         "disjunctive-expression \"|\" conjunctive-expression"))))

Theorem: cst-exclusive-disjunctive-expression-concs

(defthm cst-exclusive-disjunctive-expression-concs
 (implies
  (cst-list-list-alt-matchp
   abnf::cstss
   "disjunctive-expression / exclusive-disjunctive-expression \"^\" disjunctive-expression")
  (or
   (cst-list-list-conc-matchp abnf::cstss "disjunctive-expression")
   (cst-list-list-conc-matchp
    abnf::cstss
    "exclusive-disjunctive-expression \"^\" disjunctive-expression"))))

Theorem: cst-ordering-expression-concs

(defthm cst-ordering-expression-concs
 (implies
  (cst-list-list-alt-matchp
   abnf::cstss
   "exclusive-disjunctive-expression / exclusive-disjunctive-expression \"<\" exclusive-disjunctive-expression / exclusive-disjunctive-expression \">\" exclusive-disjunctive-expression / exclusive-disjunctive-expression \"<=\" exclusive-disjunctive-expression / exclusive-disjunctive-expression \">=\" exclusive-disjunctive-expression")
  (or
   (cst-list-list-conc-matchp abnf::cstss
                              "exclusive-disjunctive-expression")
   (cst-list-list-conc-matchp
    abnf::cstss
    "exclusive-disjunctive-expression \"<\" exclusive-disjunctive-expression")
   (cst-list-list-conc-matchp
    abnf::cstss
    "exclusive-disjunctive-expression \">\" exclusive-disjunctive-expression")
   (cst-list-list-conc-matchp
    abnf::cstss
    "exclusive-disjunctive-expression \"<=\" exclusive-disjunctive-expression")
   (cst-list-list-conc-matchp
    abnf::cstss
    "exclusive-disjunctive-expression \">=\" exclusive-disjunctive-expression"))))

Theorem: cst-equality-expression-concs

(defthm cst-equality-expression-concs
 (implies
  (cst-list-list-alt-matchp
   abnf::cstss
   "ordering-expression / ordering-expression \"==\" ordering-expression / ordering-expression \"!=\" ordering-expression")
  (or (cst-list-list-conc-matchp abnf::cstss "ordering-expression")
      (cst-list-list-conc-matchp
           abnf::cstss
           "ordering-expression \"==\" ordering-expression")
      (cst-list-list-conc-matchp
           abnf::cstss
           "ordering-expression \"!=\" ordering-expression"))))

Theorem: cst-conditional-conjunctive-expression-concs

(defthm cst-conditional-conjunctive-expression-concs
 (implies
  (cst-list-list-alt-matchp
   abnf::cstss
   "equality-expression / conditional-conjunctive-expression \"&&\" equality-expression")
  (or
   (cst-list-list-conc-matchp abnf::cstss "equality-expression")
   (cst-list-list-conc-matchp
    abnf::cstss
    "conditional-conjunctive-expression \"&&\" equality-expression"))))

Theorem: cst-conditional-disjunctive-expression-concs

(defthm cst-conditional-disjunctive-expression-concs
 (implies
  (cst-list-list-alt-matchp
   abnf::cstss
   "conditional-conjunctive-expression / conditional-disjunctive-expression \"||\" conditional-conjunctive-expression")
  (or
   (cst-list-list-conc-matchp abnf::cstss
                              "conditional-conjunctive-expression")
   (cst-list-list-conc-matchp
    abnf::cstss
    "conditional-disjunctive-expression \"||\" conditional-conjunctive-expression"))))

Theorem: cst-binary-expression-concs

(defthm cst-binary-expression-concs
 (implies
     (cst-list-list-alt-matchp abnf::cstss
                               "conditional-disjunctive-expression")
     (or (cst-list-list-conc-matchp
              abnf::cstss
              "conditional-disjunctive-expression"))))

Theorem: cst-conditional-ternary-expression-concs

(defthm cst-conditional-ternary-expression-concs
 (implies
  (cst-list-list-alt-matchp
   abnf::cstss
   "binary-expression / binary-expression \"?\" expression \":\" expression")
  (or (cst-list-list-conc-matchp abnf::cstss "binary-expression")
      (cst-list-list-conc-matchp
           abnf::cstss
           "binary-expression \"?\" expression \":\" expression"))))

Theorem: cst-expression-concs

(defthm cst-expression-concs
 (implies
  (cst-list-list-alt-matchp abnf::cstss
                            "conditional-ternary-expression")
  (or
     (cst-list-list-conc-matchp abnf::cstss
                                "conditional-ternary-expression"))))

Theorem: cst-statement-concs

(defthm cst-statement-concs
 (implies
  (cst-list-list-alt-matchp
   abnf::cstss
   "return-statement / variable-declaration / constant-declaration / conditional-statement / loop-statement / assignment-statement / console-statement / finalize-statement / increment-statement / decrement-statement / block")
  (or
     (cst-list-list-conc-matchp abnf::cstss "return-statement")
     (cst-list-list-conc-matchp abnf::cstss "variable-declaration")
     (cst-list-list-conc-matchp abnf::cstss "constant-declaration")
     (cst-list-list-conc-matchp abnf::cstss "conditional-statement")
     (cst-list-list-conc-matchp abnf::cstss "loop-statement")
     (cst-list-list-conc-matchp abnf::cstss "assignment-statement")
     (cst-list-list-conc-matchp abnf::cstss "console-statement")
     (cst-list-list-conc-matchp abnf::cstss "finalize-statement")
     (cst-list-list-conc-matchp abnf::cstss "increment-statement")
     (cst-list-list-conc-matchp abnf::cstss "decrement-statement")
     (cst-list-list-conc-matchp abnf::cstss "block"))))

Theorem: cst-block-concs

(defthm cst-block-concs
 (implies
  (cst-list-list-alt-matchp abnf::cstss "\"{\" *statement \"}\"")
  (or
     (cst-list-list-conc-matchp abnf::cstss "\"{\" *statement \"}\""))))

Theorem: cst-return-statement-concs

(defthm cst-return-statement-concs
 (implies
  (cst-list-list-alt-matchp abnf::cstss "%s\"return\" expression \";\"")
  (or (cst-list-list-conc-matchp abnf::cstss
                                 "%s\"return\" expression \";\""))))

Theorem: cst-variable-declaration-concs

(defthm cst-variable-declaration-concs
  (implies
       (cst-list-list-alt-matchp
            abnf::cstss
            "%s\"let\" identifier \":\" type \"=\" expression \";\"")
       (or (cst-list-list-conc-matchp
                abnf::cstss
                "%s\"let\" identifier \":\" type \"=\" expression \";\""))))

Theorem: cst-constant-declaration-concs

(defthm cst-constant-declaration-concs
 (implies
     (cst-list-list-alt-matchp
          abnf::cstss
          "%s\"const\" identifier \":\" type \"=\" expression \";\"")
     (or (cst-list-list-conc-matchp
              abnf::cstss
              "%s\"const\" identifier \":\" type \"=\" expression \";\""))))

Theorem: cst-branch-concs

(defthm cst-branch-concs
 (implies
    (cst-list-list-alt-matchp abnf::cstss "%s\"if\" expression block")
    (or (cst-list-list-conc-matchp abnf::cstss
                                   "%s\"if\" expression block"))))

Theorem: cst-conditional-statement-concs

(defthm cst-conditional-statement-concs
 (implies
  (cst-list-list-alt-matchp
   abnf::cstss
   "branch / branch %s\"else\" block / branch %s\"else\" conditional-statement")
  (or
     (cst-list-list-conc-matchp abnf::cstss "branch")
     (cst-list-list-conc-matchp abnf::cstss "branch %s\"else\" block")
     (cst-list-list-conc-matchp
          abnf::cstss
          "branch %s\"else\" conditional-statement"))))

Theorem: cst-loop-statement-concs

(defthm cst-loop-statement-concs
 (implies
  (cst-list-list-alt-matchp
   abnf::cstss
   "%s\"for\" identifier \":\" type %s\"in\" expression \"..\" [ \"=\" ] expression block")
  (or
   (cst-list-list-conc-matchp
    abnf::cstss
    "%s\"for\" identifier \":\" type %s\"in\" expression \"..\" [ \"=\" ] expression block"))))

Theorem: cst-assignment-operator-concs

(defthm cst-assignment-operator-concs
 (implies
  (cst-list-list-alt-matchp
   abnf::cstss
   "\"=\" / \"+=\" / \"-=\" / \"*=\" / \"/=\" / \"%=\" / \"**=\" / \"<<=\" / \">>=\" / \"&=\" / \"|=\" / \"^=\" / \"&&=\" / \"||=\"")
  (or (cst-list-list-conc-matchp abnf::cstss "\"=\"")
      (cst-list-list-conc-matchp abnf::cstss "\"+=\"")
      (cst-list-list-conc-matchp abnf::cstss "\"-=\"")
      (cst-list-list-conc-matchp abnf::cstss "\"*=\"")
      (cst-list-list-conc-matchp abnf::cstss "\"/=\"")
      (cst-list-list-conc-matchp abnf::cstss "\"%=\"")
      (cst-list-list-conc-matchp abnf::cstss "\"**=\"")
      (cst-list-list-conc-matchp abnf::cstss "\"<<=\"")
      (cst-list-list-conc-matchp abnf::cstss "\">>=\"")
      (cst-list-list-conc-matchp abnf::cstss "\"&=\"")
      (cst-list-list-conc-matchp abnf::cstss "\"|=\"")
      (cst-list-list-conc-matchp abnf::cstss "\"^=\"")
      (cst-list-list-conc-matchp abnf::cstss "\"&&=\"")
      (cst-list-list-conc-matchp abnf::cstss "\"||=\""))))

Theorem: cst-assignment-statement-concs

(defthm cst-assignment-statement-concs
  (implies
       (cst-list-list-alt-matchp
            abnf::cstss
            "expression assignment-operator expression \";\"")
       (or (cst-list-list-conc-matchp
                abnf::cstss
                "expression assignment-operator expression \";\""))))

Theorem: cst-console-statement-concs

(defthm cst-console-statement-concs
 (implies
  (cst-list-list-alt-matchp abnf::cstss
                            "%s\"console\" \".\" console-call \";\"")
  (or
   (cst-list-list-conc-matchp abnf::cstss
                              "%s\"console\" \".\" console-call \";\""))))

Theorem: cst-console-call-concs

(defthm cst-console-call-concs
 (implies
     (cst-list-list-alt-matchp
          abnf::cstss
          "assert-call / assert-equal-call / assert-not-equal-call")
     (or (cst-list-list-conc-matchp abnf::cstss "assert-call")
         (cst-list-list-conc-matchp abnf::cstss "assert-equal-call")
         (cst-list-list-conc-matchp
              abnf::cstss "assert-not-equal-call"))))

Theorem: cst-assert-call-concs

(defthm cst-assert-call-concs
 (implies
  (cst-list-list-alt-matchp abnf::cstss
                            "%s\"assert\" \"(\" expression \")\"")
  (or (cst-list-list-conc-matchp abnf::cstss
                                 "%s\"assert\" \"(\" expression \")\""))))

Theorem: cst-assert-equal-call-concs

(defthm cst-assert-equal-call-concs
 (implies
  (cst-list-list-alt-matchp
       abnf::cstss
       "%s\"assert_eq\" \"(\" expression \",\" expression [ \",\" ] \")\"")
  (or
   (cst-list-list-conc-matchp
       abnf::cstss
       "%s\"assert_eq\" \"(\" expression \",\" expression [ \",\" ] \")\""))))

Theorem: cst-assert-not-equal-call-concs

(defthm cst-assert-not-equal-call-concs
 (implies
  (cst-list-list-alt-matchp
       abnf::cstss
       "%s\"assert_neq\" \"(\" expression \",\" expression [ \",\" ] \")\"")
  (or
   (cst-list-list-conc-matchp
      abnf::cstss
      "%s\"assert_neq\" \"(\" expression \",\" expression [ \",\" ] \")\""))))

Theorem: cst-finalize-statement-concs

(defthm cst-finalize-statement-concs
  (implies
       (cst-list-list-alt-matchp
            abnf::cstss
            "%s\"async\" %s\"finalize\" function-arguments \";\"")
       (or (cst-list-list-conc-matchp
                abnf::cstss
                "%s\"async\" %s\"finalize\" function-arguments \";\""))))

Theorem: cst-increment-statement-concs

(defthm cst-increment-statement-concs
 (implies
  (cst-list-list-alt-matchp
   abnf::cstss
   "%s\"increment\" \"(\" identifier \",\" expression \",\" expression [ \",\" ] \")\" \";\"")
  (or
   (cst-list-list-conc-matchp
    abnf::cstss
    "%s\"increment\" \"(\" identifier \",\" expression \",\" expression [ \",\" ] \")\" \";\""))))

Theorem: cst-decrement-statement-concs

(defthm cst-decrement-statement-concs
 (implies
  (cst-list-list-alt-matchp
   abnf::cstss
   "%s\"decrement\" \"(\" identifier \",\" expression \",\" expression [ \",\" ] \")\" \";\"")
  (or
   (cst-list-list-conc-matchp
    abnf::cstss
    "%s\"decrement\" \"(\" identifier \",\" expression \",\" expression [ \",\" ] \")\" \";\""))))

Theorem: cst-function-declaration-concs

(defthm cst-function-declaration-concs
 (implies
  (cst-list-list-alt-matchp
   abnf::cstss
   "*annotation %s\"function\" identifier \"(\" [ function-parameters ] \")\" \"->\" type block")
  (or
   (cst-list-list-conc-matchp
    abnf::cstss
    "*annotation %s\"function\" identifier \"(\" [ function-parameters ] \")\" \"->\" type block"))))

Theorem: cst-function-parameters-concs

(defthm cst-function-parameters-concs
 (implies
  (cst-list-list-alt-matchp
       abnf::cstss
       "function-parameter *( \",\" function-parameter ) [ \",\" ]")
  (or
   (cst-list-list-conc-matchp
        abnf::cstss
        "function-parameter *( \",\" function-parameter ) [ \",\" ]"))))

Theorem: cst-function-parameter-concs

(defthm cst-function-parameter-concs
 (implies
  (cst-list-list-alt-matchp
    abnf::cstss
    "[ %s\"public\" / %s\"constant\" / %s\"const\" ] identifier \":\" type")
  (or
   (cst-list-list-conc-matchp
    abnf::cstss
    "[ %s\"public\" / %s\"constant\" / %s\"const\" ] identifier \":\" type"))))

Theorem: cst-transition-declaration-concs

(defthm cst-transition-declaration-concs
 (implies
  (cst-list-list-alt-matchp
   abnf::cstss
   "*annotation %s\"transition\" identifier \"(\" [ function-parameters ] \")\" \"->\" type block [ finalizer ]")
  (or
   (cst-list-list-conc-matchp
    abnf::cstss
    "*annotation %s\"transition\" identifier \"(\" [ function-parameters ] \")\" \"->\" type block [ finalizer ]"))))

Theorem: cst-finalizer-concs

(defthm cst-finalizer-concs
 (implies
  (cst-list-list-alt-matchp
   abnf::cstss
   "%s\"finalize\" identifier \"(\" [ function-parameters ] \")\" [ \"->\" type ] block")
  (or
   (cst-list-list-conc-matchp
    abnf::cstss
    "%s\"finalize\" identifier \"(\" [ function-parameters ] \")\" [ \"->\" type ] block"))))

Theorem: cst-struct-declaration-concs

(defthm cst-struct-declaration-concs
 (implies
  (cst-list-list-alt-matchp
      abnf::cstss
      "%s\"struct\" identifier \"{\" struct-component-declarations \"}\"")
  (or
   (cst-list-list-conc-matchp
    abnf::cstss
    "%s\"struct\" identifier \"{\" struct-component-declarations \"}\""))))

Theorem: cst-struct-component-declarations-concs

(defthm cst-struct-component-declarations-concs
 (implies
  (cst-list-list-alt-matchp
   abnf::cstss
   "struct-component-declaration *( \",\" struct-component-declaration ) [ \",\" ]")
  (or
   (cst-list-list-conc-matchp
    abnf::cstss
    "struct-component-declaration *( \",\" struct-component-declaration ) [ \",\" ]"))))

Theorem: cst-struct-component-declaration-concs

(defthm cst-struct-component-declaration-concs
 (implies
  (cst-list-list-alt-matchp abnf::cstss "identifier \":\" type")
  (or
    (cst-list-list-conc-matchp abnf::cstss "identifier \":\" type"))))

Theorem: cst-record-declaration-concs

(defthm cst-record-declaration-concs
 (implies
  (cst-list-list-alt-matchp
      abnf::cstss
      "%s\"record\" identifier \"{\" struct-component-declarations \"}\"")
  (or
   (cst-list-list-conc-matchp
    abnf::cstss
    "%s\"record\" identifier \"{\" struct-component-declarations \"}\""))))

Theorem: cst-mapping-declaration-concs

(defthm cst-mapping-declaration-concs
  (implies
       (cst-list-list-alt-matchp
            abnf::cstss
            "%s\"mapping\" identifier \":\" type \"=>\" type \";\"")
       (or (cst-list-list-conc-matchp
                abnf::cstss
                "%s\"mapping\" identifier \":\" type \"=>\" type \";\""))))

Theorem: cst-program-item-concs

(defthm cst-program-item-concs
 (implies
  (cst-list-list-alt-matchp
   abnf::cstss
   "function-declaration / transition-declaration / struct-declaration / record-declaration / mapping-declaration")
  (or
    (cst-list-list-conc-matchp abnf::cstss "function-declaration")
    (cst-list-list-conc-matchp abnf::cstss "transition-declaration")
    (cst-list-list-conc-matchp abnf::cstss "struct-declaration")
    (cst-list-list-conc-matchp abnf::cstss "record-declaration")
    (cst-list-list-conc-matchp abnf::cstss "mapping-declaration"))))

Theorem: cst-program-declaration-concs

(defthm cst-program-declaration-concs
  (implies
       (cst-list-list-alt-matchp
            abnf::cstss
            "%s\"program\" program-id \"{\" *program-item \"}\"")
       (or (cst-list-list-conc-matchp
                abnf::cstss
                "%s\"program\" program-id \"{\" *program-item \"}\""))))

Theorem: cst-import-declaration-concs

(defthm cst-import-declaration-concs
 (implies
  (cst-list-list-alt-matchp abnf::cstss "%s\"import\" program-id \";\"")
  (or (cst-list-list-conc-matchp abnf::cstss
                                 "%s\"import\" program-id \";\""))))

Theorem: cst-file-concs

(defthm cst-file-concs
  (implies (cst-list-list-alt-matchp
                abnf::cstss
                "*import-declaration program-declaration")
           (or (cst-list-list-conc-matchp
                    abnf::cstss
                    "*import-declaration program-declaration"))))

Theorem: cst-input-type-concs

(defthm cst-input-type-concs
  (implies (cst-list-list-alt-matchp abnf::cstss "type")
           (or (cst-list-list-conc-matchp abnf::cstss "type"))))

Theorem: cst-input-expression-concs

(defthm cst-input-expression-concs
  (implies
       (cst-list-list-alt-matchp abnf::cstss "expression")
       (or (cst-list-list-conc-matchp abnf::cstss "expression"))))

Theorem: cst-input-item-concs

(defthm cst-input-item-concs
 (implies
   (cst-list-list-alt-matchp
        abnf::cstss
        "identifier \":\" input-type \"=\" input-expression \";\"")
   (or (cst-list-list-conc-matchp
            abnf::cstss
            "identifier \":\" input-type \"=\" input-expression \";\""))))

Theorem: cst-input-title-concs

(defthm cst-input-title-concs
 (implies
  (cst-list-list-alt-matchp
   abnf::cstss
   "\"[\" ( %s\"public\" / %s\"private\" / %s\"constant\" / %s\"const\" ) \"]\"")
  (or
   (cst-list-list-conc-matchp
    abnf::cstss
    "\"[\" ( %s\"public\" / %s\"private\" / %s\"constant\" / %s\"const\" ) \"]\""))))

Theorem: cst-input-section-concs

(defthm cst-input-section-concs
 (implies
    (cst-list-list-alt-matchp abnf::cstss "input-title *input-item")
    (or (cst-list-list-conc-matchp abnf::cstss
                                   "input-title *input-item"))))

Theorem: cst-input-file-concs

(defthm cst-input-file-concs
 (implies
     (cst-list-list-alt-matchp abnf::cstss "*input-section")
     (or (cst-list-list-conc-matchp abnf::cstss "*input-section"))))

Theorem: cst-output-expression-concs

(defthm cst-output-expression-concs
  (implies
       (cst-list-list-alt-matchp abnf::cstss "expression")
       (or (cst-list-list-conc-matchp abnf::cstss "expression"))))

Theorem: cst-output-item-concs

(defthm cst-output-item-concs
 (implies
      (cst-list-list-alt-matchp abnf::cstss "output-expression \";\"")
      (or (cst-list-list-conc-matchp
               abnf::cstss "output-expression \";\""))))

Theorem: cst-output-title-concs

(defthm cst-output-title-concs
 (implies
  (cst-list-list-alt-matchp abnf::cstss "\"[\" %s\"output\" \"]\"")
  (or
     (cst-list-list-conc-matchp abnf::cstss "\"[\" %s\"output\" \"]\""))))

Theorem: cst-output-section-concs

(defthm cst-output-section-concs
 (implies
   (cst-list-list-alt-matchp abnf::cstss "output-title output-item")
   (or (cst-list-list-conc-matchp abnf::cstss
                                  "output-title output-item"))))

Theorem: cst-output-file-concs

(defthm cst-output-file-concs
 (implies
     (cst-list-list-alt-matchp abnf::cstss "output-section")
     (or (cst-list-list-conc-matchp abnf::cstss "output-section"))))

Theorem: cst-horizontal-tab-conc-matching

(defthm cst-horizontal-tab-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-line-feed-conc-matching

(defthm cst-line-feed-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-carriage-return-conc-matching

(defthm cst-carriage-return-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-space-conc-matching

(defthm cst-space-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-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 "horizontal-tab")
           (and (equal (len abnf::cstss) 1)
                (cst-list-rep-matchp (nth 0 abnf::cstss)
                                     "horizontal-tab"))))

Theorem: cst-safe-ascii-conc2-matching

(defthm cst-safe-ascii-conc2-matching
  (implies (cst-list-list-conc-matchp abnf::cstss "line-feed")
           (and (equal (len abnf::cstss) 1)
                (cst-list-rep-matchp (nth 0 abnf::cstss)
                                     "line-feed"))))

Theorem: cst-safe-ascii-conc3-matching

(defthm cst-safe-ascii-conc3-matching
  (implies (cst-list-list-conc-matchp abnf::cstss "carriage-return")
           (and (equal (len abnf::cstss) 1)
                (cst-list-rep-matchp (nth 0 abnf::cstss)
                                     "carriage-return"))))

Theorem: cst-safe-ascii-conc4-matching

(defthm cst-safe-ascii-conc4-matching
  (implies (cst-list-list-conc-matchp abnf::cstss "space")
           (and (equal (len abnf::cstss) 1)
                (cst-list-rep-matchp (nth 0 abnf::cstss)
                                     "space"))))

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-line-terminator-conc1-matching

(defthm cst-line-terminator-conc1-matching
  (implies (cst-list-list-conc-matchp abnf::cstss "line-feed")
           (and (equal (len abnf::cstss) 1)
                (cst-list-rep-matchp (nth 0 abnf::cstss)
                                     "line-feed"))))

Theorem: cst-line-terminator-conc2-matching

(defthm cst-line-terminator-conc2-matching
  (implies (cst-list-list-conc-matchp abnf::cstss "carriage-return")
           (and (equal (len abnf::cstss) 1)
                (cst-list-rep-matchp (nth 0 abnf::cstss)
                                     "carriage-return"))))

Theorem: cst-whitespace-conc1-matching

(defthm cst-whitespace-conc1-matching
  (implies (cst-list-list-conc-matchp abnf::cstss "space")
           (and (equal (len abnf::cstss) 1)
                (cst-list-rep-matchp (nth 0 abnf::cstss)
                                     "space"))))

Theorem: cst-whitespace-conc2-matching

(defthm cst-whitespace-conc2-matching
  (implies (cst-list-list-conc-matchp abnf::cstss "horizontal-tab")
           (and (equal (len abnf::cstss) 1)
                (cst-list-rep-matchp (nth 0 abnf::cstss)
                                     "horizontal-tab"))))

Theorem: cst-whitespace-conc3-matching

(defthm cst-whitespace-conc3-matching
  (implies (cst-list-list-conc-matchp abnf::cstss "line-terminator")
           (and (equal (len abnf::cstss) 1)
                (cst-list-rep-matchp (nth 0 abnf::cstss)
                                     "line-terminator"))))

Theorem: cst-comment-conc1-matching

(defthm cst-comment-conc1-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-comment-conc2-matching

(defthm cst-comment-conc2-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-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-line-feed-or-carriage-return-conc1-matching

(defthm cst-not-star-or-line-feed-or-carriage-return-conc1-matching
  (implies (cst-list-list-conc-matchp abnf::cstss "horizontal-tab")
           (and (equal (len abnf::cstss) 1)
                (cst-list-rep-matchp (nth 0 abnf::cstss)
                                     "horizontal-tab"))))

Theorem: cst-not-star-or-line-feed-or-carriage-return-conc2-matching

(defthm cst-not-star-or-line-feed-or-carriage-return-conc2-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-line-feed-or-carriage-return-conc3-matching

(defthm cst-not-star-or-line-feed-or-carriage-return-conc3-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-or-line-feed-or-carriage-return-conc4-matching

(defthm cst-not-star-or-line-feed-or-carriage-return-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-or-slash-or-line-feed-or-carriage-return-conc1-matching

(defthm
 cst-not-star-or-slash-or-line-feed-or-carriage-return-conc1-matching
 (implies (cst-list-list-conc-matchp abnf::cstss "horizontal-tab")
          (and (equal (len abnf::cstss) 1)
               (cst-list-rep-matchp (nth 0 abnf::cstss)
                                    "horizontal-tab"))))

Theorem: cst-not-star-or-slash-or-line-feed-or-carriage-return-conc2-matching

(defthm
 cst-not-star-or-slash-or-line-feed-or-carriage-return-conc2-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-or-line-feed-or-carriage-return-conc3-matching

(defthm
 cst-not-star-or-slash-or-line-feed-or-carriage-return-conc3-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-or-line-feed-or-carriage-return-conc4-matching

(defthm
 cst-not-star-or-slash-or-line-feed-or-carriage-return-conc4-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-or-line-feed-or-carriage-return-conc5-matching

(defthm
 cst-not-star-or-slash-or-line-feed-or-carriage-return-conc5-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-line-feed-or-carriage-return-conc1-matching

(defthm cst-not-line-feed-or-carriage-return-conc1-matching
  (implies (cst-list-list-conc-matchp abnf::cstss "horizontal-tab")
           (and (equal (len abnf::cstss) 1)
                (cst-list-rep-matchp (nth 0 abnf::cstss)
                                     "horizontal-tab"))))

Theorem: cst-not-line-feed-or-carriage-return-conc2-matching

(defthm cst-not-line-feed-or-carriage-return-conc2-matching
  (implies (cst-list-list-conc-matchp abnf::cstss "space")
           (and (equal (len abnf::cstss) 1)
                (cst-list-rep-matchp (nth 0 abnf::cstss)
                                     "space"))))

Theorem: cst-not-line-feed-or-carriage-return-conc3-matching

(defthm cst-not-line-feed-or-carriage-return-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-line-feed-or-carriage-return-conc4-matching

(defthm cst-not-line-feed-or-carriage-return-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-keyword-conc1-matching

(defthm cst-keyword-conc1-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-keyword-conc2-matching

(defthm cst-keyword-conc2-matching
  (implies (cst-list-list-conc-matchp abnf::cstss "%s\"async\"")
           (and (equal (len abnf::cstss) 1)
                (cst-list-rep-matchp (nth 0 abnf::cstss)
                                     "%s\"async\""))))

Theorem: cst-keyword-conc3-matching

(defthm cst-keyword-conc3-matching
  (implies (cst-list-list-conc-matchp abnf::cstss "%s\"bool\"")
           (and (equal (len abnf::cstss) 1)
                (cst-list-rep-matchp (nth 0 abnf::cstss)
                                     "%s\"bool\""))))

Theorem: cst-keyword-conc4-matching

(defthm cst-keyword-conc4-matching
  (implies (cst-list-list-conc-matchp abnf::cstss "%s\"console\"")
           (and (equal (len abnf::cstss) 1)
                (cst-list-rep-matchp (nth 0 abnf::cstss)
                                     "%s\"console\""))))

Theorem: cst-keyword-conc5-matching

(defthm cst-keyword-conc5-matching
  (implies (cst-list-list-conc-matchp abnf::cstss "%s\"const\"")
           (and (equal (len abnf::cstss) 1)
                (cst-list-rep-matchp (nth 0 abnf::cstss)
                                     "%s\"const\""))))

Theorem: cst-keyword-conc6-matching

(defthm cst-keyword-conc6-matching
  (implies (cst-list-list-conc-matchp abnf::cstss "%s\"constant\"")
           (and (equal (len abnf::cstss) 1)
                (cst-list-rep-matchp (nth 0 abnf::cstss)
                                     "%s\"constant\""))))

Theorem: cst-keyword-conc7-matching

(defthm cst-keyword-conc7-matching
  (implies (cst-list-list-conc-matchp abnf::cstss "%s\"decrement\"")
           (and (equal (len abnf::cstss) 1)
                (cst-list-rep-matchp (nth 0 abnf::cstss)
                                     "%s\"decrement\""))))

Theorem: cst-keyword-conc8-matching

(defthm cst-keyword-conc8-matching
  (implies (cst-list-list-conc-matchp abnf::cstss "%s\"else\"")
           (and (equal (len abnf::cstss) 1)
                (cst-list-rep-matchp (nth 0 abnf::cstss)
                                     "%s\"else\""))))

Theorem: cst-keyword-conc9-matching

(defthm cst-keyword-conc9-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-keyword-conc10-matching

(defthm cst-keyword-conc10-matching
  (implies (cst-list-list-conc-matchp abnf::cstss "%s\"finalize\"")
           (and (equal (len abnf::cstss) 1)
                (cst-list-rep-matchp (nth 0 abnf::cstss)
                                     "%s\"finalize\""))))

Theorem: cst-keyword-conc11-matching

(defthm cst-keyword-conc11-matching
  (implies (cst-list-list-conc-matchp abnf::cstss "%s\"for\"")
           (and (equal (len abnf::cstss) 1)
                (cst-list-rep-matchp (nth 0 abnf::cstss)
                                     "%s\"for\""))))

Theorem: cst-keyword-conc12-matching

(defthm cst-keyword-conc12-matching
  (implies (cst-list-list-conc-matchp abnf::cstss "%s\"function\"")
           (and (equal (len abnf::cstss) 1)
                (cst-list-rep-matchp (nth 0 abnf::cstss)
                                     "%s\"function\""))))

Theorem: cst-keyword-conc13-matching

(defthm cst-keyword-conc13-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-keyword-conc14-matching

(defthm cst-keyword-conc14-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-keyword-conc15-matching

(defthm cst-keyword-conc15-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-keyword-conc16-matching

(defthm cst-keyword-conc16-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-keyword-conc17-matching

(defthm cst-keyword-conc17-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-keyword-conc18-matching

(defthm cst-keyword-conc18-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-keyword-conc19-matching

(defthm cst-keyword-conc19-matching
  (implies (cst-list-list-conc-matchp abnf::cstss "%s\"if\"")
           (and (equal (len abnf::cstss) 1)
                (cst-list-rep-matchp (nth 0 abnf::cstss)
                                     "%s\"if\""))))

Theorem: cst-keyword-conc20-matching

(defthm cst-keyword-conc20-matching
  (implies (cst-list-list-conc-matchp abnf::cstss "%s\"import\"")
           (and (equal (len abnf::cstss) 1)
                (cst-list-rep-matchp (nth 0 abnf::cstss)
                                     "%s\"import\""))))

Theorem: cst-keyword-conc21-matching

(defthm cst-keyword-conc21-matching
  (implies (cst-list-list-conc-matchp abnf::cstss "%s\"in\"")
           (and (equal (len abnf::cstss) 1)
                (cst-list-rep-matchp (nth 0 abnf::cstss)
                                     "%s\"in\""))))

Theorem: cst-keyword-conc22-matching

(defthm cst-keyword-conc22-matching
  (implies (cst-list-list-conc-matchp abnf::cstss "%s\"increment\"")
           (and (equal (len abnf::cstss) 1)
                (cst-list-rep-matchp (nth 0 abnf::cstss)
                                     "%s\"increment\""))))

Theorem: cst-keyword-conc23-matching

(defthm cst-keyword-conc23-matching
  (implies (cst-list-list-conc-matchp abnf::cstss "%s\"let\"")
           (and (equal (len abnf::cstss) 1)
                (cst-list-rep-matchp (nth 0 abnf::cstss)
                                     "%s\"let\""))))

Theorem: cst-keyword-conc24-matching

(defthm cst-keyword-conc24-matching
  (implies (cst-list-list-conc-matchp abnf::cstss "%s\"mapping\"")
           (and (equal (len abnf::cstss) 1)
                (cst-list-rep-matchp (nth 0 abnf::cstss)
                                     "%s\"mapping\""))))

Theorem: cst-keyword-conc25-matching

(defthm cst-keyword-conc25-matching
  (implies (cst-list-list-conc-matchp abnf::cstss "%s\"program\"")
           (and (equal (len abnf::cstss) 1)
                (cst-list-rep-matchp (nth 0 abnf::cstss)
                                     "%s\"program\""))))

Theorem: cst-keyword-conc26-matching

(defthm cst-keyword-conc26-matching
  (implies (cst-list-list-conc-matchp abnf::cstss "%s\"public\"")
           (and (equal (len abnf::cstss) 1)
                (cst-list-rep-matchp (nth 0 abnf::cstss)
                                     "%s\"public\""))))

Theorem: cst-keyword-conc27-matching

(defthm cst-keyword-conc27-matching
  (implies (cst-list-list-conc-matchp abnf::cstss "%s\"record\"")
           (and (equal (len abnf::cstss) 1)
                (cst-list-rep-matchp (nth 0 abnf::cstss)
                                     "%s\"record\""))))

Theorem: cst-keyword-conc28-matching

(defthm cst-keyword-conc28-matching
  (implies (cst-list-list-conc-matchp abnf::cstss "%s\"return\"")
           (and (equal (len abnf::cstss) 1)
                (cst-list-rep-matchp (nth 0 abnf::cstss)
                                     "%s\"return\""))))

Theorem: cst-keyword-conc29-matching

(defthm cst-keyword-conc29-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-keyword-conc30-matching

(defthm cst-keyword-conc30-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-keyword-conc31-matching

(defthm cst-keyword-conc31-matching
  (implies (cst-list-list-conc-matchp abnf::cstss "%s\"struct\"")
           (and (equal (len abnf::cstss) 1)
                (cst-list-rep-matchp (nth 0 abnf::cstss)
                                     "%s\"struct\""))))

Theorem: cst-keyword-conc32-matching

(defthm cst-keyword-conc32-matching
  (implies (cst-list-list-conc-matchp abnf::cstss "%s\"transition\"")
           (and (equal (len abnf::cstss) 1)
                (cst-list-rep-matchp (nth 0 abnf::cstss)
                                     "%s\"transition\""))))

Theorem: cst-keyword-conc33-matching

(defthm cst-keyword-conc33-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-keyword-conc34-matching

(defthm cst-keyword-conc34-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-keyword-conc35-matching

(defthm cst-keyword-conc35-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-keyword-conc36-matching

(defthm cst-keyword-conc36-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-keyword-conc37-matching

(defthm cst-keyword-conc37-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-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-decimal-digit-conc-matching

(defthm cst-decimal-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-octal-digit-conc-matching

(defthm cst-octal-digit-conc-matching
  (implies (cst-list-list-conc-matchp abnf::cstss "%x30-37")
           (and (equal (len abnf::cstss) 1)
                (cst-list-rep-matchp (nth 0 abnf::cstss)
                                     "%x30-37"))))

Theorem: cst-hexadecimal-digit-conc1-matching

(defthm cst-hexadecimal-digit-conc1-matching
  (implies (cst-list-list-conc-matchp abnf::cstss "decimal-digit")
           (and (equal (len abnf::cstss) 1)
                (cst-list-rep-matchp (nth 0 abnf::cstss)
                                     "decimal-digit"))))

Theorem: cst-hexadecimal-digit-conc2-matching

(defthm cst-hexadecimal-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-hexadecimal-digit-conc3-matching

(defthm cst-hexadecimal-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-hexadecimal-digit-conc4-matching

(defthm cst-hexadecimal-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-hexadecimal-digit-conc5-matching

(defthm cst-hexadecimal-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-hexadecimal-digit-conc6-matching

(defthm cst-hexadecimal-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-hexadecimal-digit-conc7-matching

(defthm cst-hexadecimal-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-numeral-conc-matching

(defthm cst-numeral-conc-matching
  (implies (cst-list-list-conc-matchp abnf::cstss "1*decimal-digit")
           (and (equal (len abnf::cstss) 1)
                (cst-list-rep-matchp (nth 0 abnf::cstss)
                                     "1*decimal-digit"))))

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-single-quote-conc-matching

(defthm cst-single-quote-conc-matching
  (implies (cst-list-list-conc-matchp abnf::cstss "%x27")
           (and (equal (len abnf::cstss) 1)
                (cst-list-rep-matchp (nth 0 abnf::cstss)
                                     "%x27"))))

Theorem: cst-double-quote-conc-matching

(defthm cst-double-quote-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-backslash-escape-conc-matching

(defthm cst-backslash-escape-conc-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-line-feed-escape-conc-matching

(defthm cst-line-feed-escape-conc-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-carriage-return-escape-conc-matching

(defthm cst-carriage-return-escape-conc-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-horizontal-tab-escape-conc-matching

(defthm cst-horizontal-tab-escape-conc-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-null-character-escape-conc-matching

(defthm cst-null-character-escape-conc-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-simple-character-escape-conc1-matching

(defthm cst-simple-character-escape-conc1-matching
  (implies
       (cst-list-list-conc-matchp abnf::cstss "single-quote-escape")
       (and (equal (len abnf::cstss) 1)
            (cst-list-rep-matchp (nth 0 abnf::cstss)
                                 "single-quote-escape"))))

Theorem: cst-simple-character-escape-conc2-matching

(defthm cst-simple-character-escape-conc2-matching
  (implies
       (cst-list-list-conc-matchp abnf::cstss "double-quote-escape")
       (and (equal (len abnf::cstss) 1)
            (cst-list-rep-matchp (nth 0 abnf::cstss)
                                 "double-quote-escape"))))

Theorem: cst-simple-character-escape-conc3-matching

(defthm cst-simple-character-escape-conc3-matching
 (implies (cst-list-list-conc-matchp abnf::cstss "backslash-escape")
          (and (equal (len abnf::cstss) 1)
               (cst-list-rep-matchp (nth 0 abnf::cstss)
                                    "backslash-escape"))))

Theorem: cst-simple-character-escape-conc4-matching

(defthm cst-simple-character-escape-conc4-matching
 (implies (cst-list-list-conc-matchp abnf::cstss "line-feed-escape")
          (and (equal (len abnf::cstss) 1)
               (cst-list-rep-matchp (nth 0 abnf::cstss)
                                    "line-feed-escape"))))

Theorem: cst-simple-character-escape-conc5-matching

(defthm cst-simple-character-escape-conc5-matching
 (implies
    (cst-list-list-conc-matchp abnf::cstss "carriage-return-escape")
    (and (equal (len abnf::cstss) 1)
         (cst-list-rep-matchp (nth 0 abnf::cstss)
                              "carriage-return-escape"))))

Theorem: cst-simple-character-escape-conc6-matching

(defthm cst-simple-character-escape-conc6-matching
 (implies
     (cst-list-list-conc-matchp abnf::cstss "horizontal-tab-escape")
     (and (equal (len abnf::cstss) 1)
          (cst-list-rep-matchp (nth 0 abnf::cstss)
                               "horizontal-tab-escape"))))

Theorem: cst-simple-character-escape-conc7-matching

(defthm cst-simple-character-escape-conc7-matching
 (implies
     (cst-list-list-conc-matchp abnf::cstss "null-character-escape")
     (and (equal (len abnf::cstss) 1)
          (cst-list-rep-matchp (nth 0 abnf::cstss)
                               "null-character-escape"))))

Theorem: cst-string-literal-element-conc1-matching

(defthm cst-string-literal-element-conc1-matching
 (implies
  (cst-list-list-conc-matchp
    abnf::cstss
    "not-double-quote-or-backslash-or-line-feed-or-carriage-return")
  (and
   (equal (len abnf::cstss) 1)
   (cst-list-rep-matchp
    (nth 0 abnf::cstss)
    "not-double-quote-or-backslash-or-line-feed-or-carriage-return"))))

Theorem: cst-string-literal-element-conc2-matching

(defthm cst-string-literal-element-conc2-matching
 (implies
   (cst-list-list-conc-matchp abnf::cstss "simple-character-escape")
   (and (equal (len abnf::cstss) 1)
        (cst-list-rep-matchp (nth 0 abnf::cstss)
                             "simple-character-escape"))))

Theorem: cst-string-literal-element-conc3-matching

(defthm cst-string-literal-element-conc3-matching
 (implies
    (cst-list-list-conc-matchp abnf::cstss "ascii-character-escape")
    (and (equal (len abnf::cstss) 1)
         (cst-list-rep-matchp (nth 0 abnf::cstss)
                              "ascii-character-escape"))))

Theorem: cst-string-literal-element-conc4-matching

(defthm cst-string-literal-element-conc4-matching
 (implies
  (cst-list-list-conc-matchp abnf::cstss "unicode-character-escape")
  (and (equal (len abnf::cstss) 1)
       (cst-list-rep-matchp (nth 0 abnf::cstss)
                            "unicode-character-escape"))))

Theorem: cst-not-double-quote-or-backslash-or-line-feed-or-carriage-return-conc1-matching

(defthm
 cst-not-double-quote-or-backslash-or-line-feed-or-carriage-return-conc1-matching
 (implies (cst-list-list-conc-matchp abnf::cstss "horizontal-tab")
          (and (equal (len abnf::cstss) 1)
               (cst-list-rep-matchp (nth 0 abnf::cstss)
                                    "horizontal-tab"))))

Theorem: cst-not-double-quote-or-backslash-or-line-feed-or-carriage-return-conc2-matching

(defthm
 cst-not-double-quote-or-backslash-or-line-feed-or-carriage-return-conc2-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-double-quote-or-backslash-or-line-feed-or-carriage-return-conc3-matching

(defthm
 cst-not-double-quote-or-backslash-or-line-feed-or-carriage-return-conc3-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-double-quote-or-backslash-or-line-feed-or-carriage-return-conc4-matching

(defthm
 cst-not-double-quote-or-backslash-or-line-feed-or-carriage-return-conc4-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-double-quote-or-backslash-or-line-feed-or-carriage-return-conc5-matching

(defthm
 cst-not-double-quote-or-backslash-or-line-feed-or-carriage-return-conc5-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-integer-literal-conc1-matching

(defthm cst-integer-literal-conc1-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-integer-literal-conc2-matching

(defthm cst-integer-literal-conc2-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-numeric-literal-conc1-matching

(defthm cst-numeric-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-numeric-literal-conc2-matching

(defthm cst-numeric-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-numeric-literal-conc3-matching

(defthm cst-numeric-literal-conc3-matching
 (implies
     (cst-list-list-conc-matchp abnf::cstss "product-group-literal")
     (and (equal (len abnf::cstss) 1)
          (cst-list-rep-matchp (nth 0 abnf::cstss)
                               "product-group-literal"))))

Theorem: cst-numeric-literal-conc4-matching

(defthm cst-numeric-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-atomic-literal-conc1-matching

(defthm cst-atomic-literal-conc1-matching
  (implies (cst-list-list-conc-matchp abnf::cstss "numeric-literal")
           (and (equal (len abnf::cstss) 1)
                (cst-list-rep-matchp (nth 0 abnf::cstss)
                                     "numeric-literal"))))

Theorem: cst-atomic-literal-conc2-matching

(defthm cst-atomic-literal-conc2-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-atomic-literal-conc3-matching

(defthm cst-atomic-literal-conc3-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-atomic-literal-conc4-matching

(defthm cst-atomic-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-symbol-conc1-matching

(defthm cst-symbol-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-symbol-conc2-matching

(defthm cst-symbol-conc2-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-symbol-conc3-matching

(defthm cst-symbol-conc3-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-symbol-conc4-matching

(defthm cst-symbol-conc4-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-symbol-conc5-matching

(defthm cst-symbol-conc5-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-symbol-conc6-matching

(defthm cst-symbol-conc6-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-symbol-conc7-matching

(defthm cst-symbol-conc7-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-symbol-conc8-matching

(defthm cst-symbol-conc8-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-symbol-conc9-matching

(defthm cst-symbol-conc9-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-symbol-conc10-matching

(defthm cst-symbol-conc10-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-symbol-conc11-matching

(defthm cst-symbol-conc11-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-symbol-conc12-matching

(defthm cst-symbol-conc12-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-symbol-conc13-matching

(defthm cst-symbol-conc13-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-symbol-conc14-matching

(defthm cst-symbol-conc14-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-symbol-conc15-matching

(defthm cst-symbol-conc15-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-symbol-conc16-matching

(defthm cst-symbol-conc16-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-symbol-conc17-matching

(defthm cst-symbol-conc17-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-symbol-conc18-matching

(defthm cst-symbol-conc18-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-symbol-conc19-matching

(defthm cst-symbol-conc19-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-symbol-conc20-matching

(defthm cst-symbol-conc20-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-symbol-conc21-matching

(defthm cst-symbol-conc21-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-symbol-conc22-matching

(defthm cst-symbol-conc22-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-symbol-conc23-matching

(defthm cst-symbol-conc23-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-symbol-conc24-matching

(defthm cst-symbol-conc24-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-symbol-conc25-matching

(defthm cst-symbol-conc25-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-symbol-conc26-matching

(defthm cst-symbol-conc26-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-symbol-conc27-matching

(defthm cst-symbol-conc27-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-symbol-conc28-matching

(defthm cst-symbol-conc28-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-symbol-conc29-matching

(defthm cst-symbol-conc29-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-symbol-conc30-matching

(defthm cst-symbol-conc30-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-symbol-conc31-matching

(defthm cst-symbol-conc31-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-symbol-conc32-matching

(defthm cst-symbol-conc32-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-symbol-conc33-matching

(defthm cst-symbol-conc33-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-symbol-conc34-matching

(defthm cst-symbol-conc34-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-symbol-conc35-matching

(defthm cst-symbol-conc35-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-symbol-conc36-matching

(defthm cst-symbol-conc36-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-symbol-conc37-matching

(defthm cst-symbol-conc37-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-symbol-conc38-matching

(defthm cst-symbol-conc38-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-symbol-conc39-matching

(defthm cst-symbol-conc39-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-symbol-conc40-matching

(defthm cst-symbol-conc40-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-symbol-conc41-matching

(defthm cst-symbol-conc41-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-symbol-conc42-matching

(defthm cst-symbol-conc42-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-symbol-conc43-matching

(defthm cst-symbol-conc43-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-symbol-conc44-matching

(defthm cst-symbol-conc44-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-symbol-conc45-matching

(defthm cst-symbol-conc45-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-symbol-conc46-matching

(defthm cst-symbol-conc46-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-symbol-conc47-matching

(defthm cst-symbol-conc47-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-symbol-conc48-matching

(defthm cst-symbol-conc48-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-symbol-conc49-matching

(defthm cst-symbol-conc49-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-symbol-conc50-matching

(defthm cst-symbol-conc50-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-symbol-conc51-matching

(defthm cst-symbol-conc51-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-token-conc1-matching

(defthm cst-token-conc1-matching
  (implies (cst-list-list-conc-matchp abnf::cstss "keyword")
           (and (equal (len abnf::cstss) 1)
                (cst-list-rep-matchp (nth 0 abnf::cstss)
                                     "keyword"))))

Theorem: cst-token-conc2-matching

(defthm cst-token-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-token-conc3-matching

(defthm cst-token-conc3-matching
  (implies (cst-list-list-conc-matchp abnf::cstss "atomic-literal")
           (and (equal (len abnf::cstss) 1)
                (cst-list-rep-matchp (nth 0 abnf::cstss)
                                     "atomic-literal"))))

Theorem: cst-token-conc4-matching

(defthm cst-token-conc4-matching
  (implies (cst-list-list-conc-matchp abnf::cstss "numeral")
           (and (equal (len abnf::cstss) 1)
                (cst-list-rep-matchp (nth 0 abnf::cstss)
                                     "numeral"))))

Theorem: cst-token-conc5-matching

(defthm cst-token-conc5-matching
  (implies (cst-list-list-conc-matchp abnf::cstss "annotation")
           (and (equal (len abnf::cstss) 1)
                (cst-list-rep-matchp (nth 0 abnf::cstss)
                                     "annotation"))))

Theorem: cst-token-conc6-matching

(defthm cst-token-conc6-matching
  (implies (cst-list-list-conc-matchp abnf::cstss "symbol")
           (and (equal (len abnf::cstss) 1)
                (cst-list-rep-matchp (nth 0 abnf::cstss)
                                     "symbol"))))

Theorem: cst-lexeme-conc1-matching

(defthm cst-lexeme-conc1-matching
  (implies (cst-list-list-conc-matchp abnf::cstss "token")
           (and (equal (len abnf::cstss) 1)
                (cst-list-rep-matchp (nth 0 abnf::cstss)
                                     "token"))))

Theorem: cst-lexeme-conc2-matching

(defthm cst-lexeme-conc2-matching
  (implies (cst-list-list-conc-matchp abnf::cstss "comment")
           (and (equal (len abnf::cstss) 1)
                (cst-list-rep-matchp (nth 0 abnf::cstss)
                                     "comment"))))

Theorem: cst-lexeme-conc3-matching

(defthm cst-lexeme-conc3-matching
  (implies (cst-list-list-conc-matchp abnf::cstss "whitespace")
           (and (equal (len abnf::cstss) 1)
                (cst-list-rep-matchp (nth 0 abnf::cstss)
                                     "whitespace"))))

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-boolean-type-conc-matching

(defthm cst-boolean-type-conc-matching
  (implies (cst-list-list-conc-matchp abnf::cstss "%s\"bool\"")
           (and (equal (len abnf::cstss) 1)
                (cst-list-rep-matchp (nth 0 abnf::cstss)
                                     "%s\"bool\""))))

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-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-named-primitive-type-conc1-matching

(defthm cst-named-primitive-type-conc1-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-named-primitive-type-conc2-matching

(defthm cst-named-primitive-type-conc2-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-named-primitive-type-conc3-matching

(defthm cst-named-primitive-type-conc3-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-named-primitive-type-conc4-matching

(defthm cst-named-primitive-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-primitive-type-conc1-matching

(defthm cst-primitive-type-conc1-matching
 (implies
      (cst-list-list-conc-matchp abnf::cstss "named-primitive-type")
      (and (equal (len abnf::cstss) 1)
           (cst-list-rep-matchp (nth 0 abnf::cstss)
                                "named-primitive-type"))))

Theorem: cst-primitive-type-conc2-matching

(defthm cst-primitive-type-conc2-matching
  (implies (cst-list-list-conc-matchp abnf::cstss "unit-type")
           (and (equal (len abnf::cstss) 1)
                (cst-list-rep-matchp (nth 0 abnf::cstss)
                                     "unit-type"))))

Theorem: cst-named-type-conc1-matching

(defthm cst-named-type-conc1-matching
 (implies
      (cst-list-list-conc-matchp abnf::cstss "named-primitive-type")
      (and (equal (len abnf::cstss) 1)
           (cst-list-rep-matchp (nth 0 abnf::cstss)
                                "named-primitive-type"))))

Theorem: cst-type-conc1-matching

(defthm cst-type-conc1-matching
  (implies (cst-list-list-conc-matchp abnf::cstss "named-type")
           (and (equal (len abnf::cstss) 1)
                (cst-list-rep-matchp (nth 0 abnf::cstss)
                                     "named-type"))))

Theorem: cst-type-conc2-matching

(defthm cst-type-conc2-matching
  (implies (cst-list-list-conc-matchp abnf::cstss "unit-type")
           (and (equal (len abnf::cstss) 1)
                (cst-list-rep-matchp (nth 0 abnf::cstss)
                                     "unit-type"))))

Theorem: cst-type-conc3-matching

(defthm cst-type-conc3-matching
  (implies (cst-list-list-conc-matchp abnf::cstss "tuple-type")
           (and (equal (len abnf::cstss) 1)
                (cst-list-rep-matchp (nth 0 abnf::cstss)
                                     "tuple-type"))))

Theorem: cst-group-coordinate-conc1-matching

(defthm cst-group-coordinate-conc1-matching
  (implies
       (cst-list-list-conc-matchp abnf::cstss "( [ \"-\" ] numeral )")
       (and (equal (len abnf::cstss) 1)
            (cst-list-rep-matchp (nth 0 abnf::cstss)
                                 "( [ \"-\" ] numeral )"))))

Theorem: cst-group-coordinate-conc2-matching

(defthm cst-group-coordinate-conc2-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-group-coordinate-conc3-matching

(defthm cst-group-coordinate-conc3-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-group-coordinate-conc4-matching

(defthm cst-group-coordinate-conc4-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-literal-conc1-matching

(defthm cst-literal-conc1-matching
  (implies (cst-list-list-conc-matchp abnf::cstss "atomic-literal")
           (and (equal (len abnf::cstss) 1)
                (cst-list-rep-matchp (nth 0 abnf::cstss)
                                     "atomic-literal"))))

Theorem: cst-literal-conc2-matching

(defthm cst-literal-conc2-matching
 (implies
      (cst-list-list-conc-matchp abnf::cstss "affine-group-literal")
      (and (equal (len abnf::cstss) 1)
           (cst-list-rep-matchp (nth 0 abnf::cstss)
                                "affine-group-literal"))))

Theorem: cst-group-literal-conc1-matching

(defthm cst-group-literal-conc1-matching
 (implies
     (cst-list-list-conc-matchp abnf::cstss "product-group-literal")
     (and (equal (len abnf::cstss) 1)
          (cst-list-rep-matchp (nth 0 abnf::cstss)
                               "product-group-literal"))))

Theorem: cst-group-literal-conc2-matching

(defthm cst-group-literal-conc2-matching
 (implies
      (cst-list-list-conc-matchp abnf::cstss "affine-group-literal")
      (and (equal (len abnf::cstss) 1)
           (cst-list-rep-matchp (nth 0 abnf::cstss)
                                "affine-group-literal"))))

Theorem: cst-primary-expression-conc1-matching

(defthm cst-primary-expression-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-primary-expression-conc2-matching

(defthm cst-primary-expression-conc2-matching
  (implies (cst-list-list-conc-matchp
                abnf::cstss "variable-or-free-constant")
           (and (equal (len abnf::cstss) 1)
                (cst-list-rep-matchp (nth 0 abnf::cstss)
                                     "variable-or-free-constant"))))

Theorem: cst-primary-expression-conc3-matching

(defthm cst-primary-expression-conc3-matching
  (implies
       (cst-list-list-conc-matchp abnf::cstss "associated-constant")
       (and (equal (len abnf::cstss) 1)
            (cst-list-rep-matchp (nth 0 abnf::cstss)
                                 "associated-constant"))))

Theorem: cst-primary-expression-conc5-matching

(defthm cst-primary-expression-conc5-matching
  (implies
       (cst-list-list-conc-matchp abnf::cstss "free-function-call")
       (and (equal (len abnf::cstss) 1)
            (cst-list-rep-matchp (nth 0 abnf::cstss)
                                 "free-function-call"))))

Theorem: cst-primary-expression-conc6-matching

(defthm cst-primary-expression-conc6-matching
 (implies
      (cst-list-list-conc-matchp abnf::cstss "static-function-call")
      (and (equal (len abnf::cstss) 1)
           (cst-list-rep-matchp (nth 0 abnf::cstss)
                                "static-function-call"))))

Theorem: cst-primary-expression-conc7-matching

(defthm cst-primary-expression-conc7-matching
  (implies (cst-list-list-conc-matchp abnf::cstss "unit-expression")
           (and (equal (len abnf::cstss) 1)
                (cst-list-rep-matchp (nth 0 abnf::cstss)
                                     "unit-expression"))))

Theorem: cst-primary-expression-conc8-matching

(defthm cst-primary-expression-conc8-matching
 (implies (cst-list-list-conc-matchp abnf::cstss "tuple-expression")
          (and (equal (len abnf::cstss) 1)
               (cst-list-rep-matchp (nth 0 abnf::cstss)
                                    "tuple-expression"))))

Theorem: cst-primary-expression-conc9-matching

(defthm cst-primary-expression-conc9-matching
  (implies
       (cst-list-list-conc-matchp abnf::cstss "struct-expression")
       (and (equal (len abnf::cstss) 1)
            (cst-list-rep-matchp (nth 0 abnf::cstss)
                                 "struct-expression"))))

Theorem: cst-variable-or-free-constant-conc-matching

(defthm cst-variable-or-free-constant-conc-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-struct-component-initializer-conc1-matching

(defthm cst-struct-component-initializer-conc1-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-postfix-expression-conc1-matching

(defthm cst-postfix-expression-conc1-matching
  (implies
       (cst-list-list-conc-matchp abnf::cstss "primary-expression")
       (and (equal (len abnf::cstss) 1)
            (cst-list-rep-matchp (nth 0 abnf::cstss)
                                 "primary-expression"))))

Theorem: cst-postfix-expression-conc2-matching

(defthm cst-postfix-expression-conc2-matching
 (implies (cst-list-list-conc-matchp abnf::cstss
                                     "tuple-component-expression")
          (and (equal (len abnf::cstss) 1)
               (cst-list-rep-matchp (nth 0 abnf::cstss)
                                    "tuple-component-expression"))))

Theorem: cst-postfix-expression-conc3-matching

(defthm cst-postfix-expression-conc3-matching
  (implies
       (cst-list-list-conc-matchp abnf::cstss
                                  "struct-component-expression")
       (and (equal (len abnf::cstss) 1)
            (cst-list-rep-matchp (nth 0 abnf::cstss)
                                 "struct-component-expression"))))

Theorem: cst-postfix-expression-conc4-matching

(defthm cst-postfix-expression-conc4-matching
  (implies (cst-list-list-conc-matchp abnf::cstss "operator-call")
           (and (equal (len abnf::cstss) 1)
                (cst-list-rep-matchp (nth 0 abnf::cstss)
                                     "operator-call"))))

Theorem: cst-operator-call-conc1-matching

(defthm cst-operator-call-conc1-matching
  (implies
       (cst-list-list-conc-matchp abnf::cstss "unary-operator-call")
       (and (equal (len abnf::cstss) 1)
            (cst-list-rep-matchp (nth 0 abnf::cstss)
                                 "unary-operator-call"))))

Theorem: cst-operator-call-conc2-matching

(defthm cst-operator-call-conc2-matching
 (implies
      (cst-list-list-conc-matchp abnf::cstss "binary-operator-call")
      (and (equal (len abnf::cstss) 1)
           (cst-list-rep-matchp (nth 0 abnf::cstss)
                                "binary-operator-call"))))

Theorem: cst-unary-expression-conc1-matching

(defthm cst-unary-expression-conc1-matching
  (implies
       (cst-list-list-conc-matchp abnf::cstss "postfix-expression")
       (and (equal (len abnf::cstss) 1)
            (cst-list-rep-matchp (nth 0 abnf::cstss)
                                 "postfix-expression"))))

Theorem: cst-exponential-expression-conc1-matching

(defthm cst-exponential-expression-conc1-matching
 (implies (cst-list-list-conc-matchp abnf::cstss "unary-expression")
          (and (equal (len abnf::cstss) 1)
               (cst-list-rep-matchp (nth 0 abnf::cstss)
                                    "unary-expression"))))

Theorem: cst-multiplicative-expression-conc1-matching

(defthm cst-multiplicative-expression-conc1-matching
 (implies
    (cst-list-list-conc-matchp abnf::cstss "exponential-expression")
    (and (equal (len abnf::cstss) 1)
         (cst-list-rep-matchp (nth 0 abnf::cstss)
                              "exponential-expression"))))

Theorem: cst-additive-expression-conc1-matching

(defthm cst-additive-expression-conc1-matching
  (implies (cst-list-list-conc-matchp
                abnf::cstss "multiplicative-expression")
           (and (equal (len abnf::cstss) 1)
                (cst-list-rep-matchp (nth 0 abnf::cstss)
                                     "multiplicative-expression"))))

Theorem: cst-shift-expression-conc1-matching

(defthm cst-shift-expression-conc1-matching
  (implies
       (cst-list-list-conc-matchp abnf::cstss "additive-expression")
       (and (equal (len abnf::cstss) 1)
            (cst-list-rep-matchp (nth 0 abnf::cstss)
                                 "additive-expression"))))

Theorem: cst-conjunctive-expression-conc1-matching

(defthm cst-conjunctive-expression-conc1-matching
 (implies (cst-list-list-conc-matchp abnf::cstss "shift-expression")
          (and (equal (len abnf::cstss) 1)
               (cst-list-rep-matchp (nth 0 abnf::cstss)
                                    "shift-expression"))))

Theorem: cst-disjunctive-expression-conc1-matching

(defthm cst-disjunctive-expression-conc1-matching
 (implies
    (cst-list-list-conc-matchp abnf::cstss "conjunctive-expression")
    (and (equal (len abnf::cstss) 1)
         (cst-list-rep-matchp (nth 0 abnf::cstss)
                              "conjunctive-expression"))))

Theorem: cst-exclusive-disjunctive-expression-conc1-matching

(defthm cst-exclusive-disjunctive-expression-conc1-matching
 (implies
    (cst-list-list-conc-matchp abnf::cstss "disjunctive-expression")
    (and (equal (len abnf::cstss) 1)
         (cst-list-rep-matchp (nth 0 abnf::cstss)
                              "disjunctive-expression"))))

Theorem: cst-ordering-expression-conc1-matching

(defthm cst-ordering-expression-conc1-matching
 (implies
    (cst-list-list-conc-matchp abnf::cstss
                               "exclusive-disjunctive-expression")
    (and (equal (len abnf::cstss) 1)
         (cst-list-rep-matchp (nth 0 abnf::cstss)
                              "exclusive-disjunctive-expression"))))

Theorem: cst-equality-expression-conc1-matching

(defthm cst-equality-expression-conc1-matching
  (implies
       (cst-list-list-conc-matchp abnf::cstss "ordering-expression")
       (and (equal (len abnf::cstss) 1)
            (cst-list-rep-matchp (nth 0 abnf::cstss)
                                 "ordering-expression"))))

Theorem: cst-conditional-conjunctive-expression-conc1-matching

(defthm cst-conditional-conjunctive-expression-conc1-matching
  (implies
       (cst-list-list-conc-matchp abnf::cstss "equality-expression")
       (and (equal (len abnf::cstss) 1)
            (cst-list-rep-matchp (nth 0 abnf::cstss)
                                 "equality-expression"))))

Theorem: cst-conditional-disjunctive-expression-conc1-matching

(defthm cst-conditional-disjunctive-expression-conc1-matching
 (implies
  (cst-list-list-conc-matchp abnf::cstss
                             "conditional-conjunctive-expression")
  (and (equal (len abnf::cstss) 1)
       (cst-list-rep-matchp (nth 0 abnf::cstss)
                            "conditional-conjunctive-expression"))))

Theorem: cst-binary-expression-conc-matching

(defthm cst-binary-expression-conc-matching
 (implies
  (cst-list-list-conc-matchp abnf::cstss
                             "conditional-disjunctive-expression")
  (and (equal (len abnf::cstss) 1)
       (cst-list-rep-matchp (nth 0 abnf::cstss)
                            "conditional-disjunctive-expression"))))

Theorem: cst-conditional-ternary-expression-conc1-matching

(defthm cst-conditional-ternary-expression-conc1-matching
  (implies
       (cst-list-list-conc-matchp abnf::cstss "binary-expression")
       (and (equal (len abnf::cstss) 1)
            (cst-list-rep-matchp (nth 0 abnf::cstss)
                                 "binary-expression"))))

Theorem: cst-expression-conc-matching

(defthm cst-expression-conc-matching
 (implies
      (cst-list-list-conc-matchp abnf::cstss
                                 "conditional-ternary-expression")
      (and (equal (len abnf::cstss) 1)
           (cst-list-rep-matchp (nth 0 abnf::cstss)
                                "conditional-ternary-expression"))))

Theorem: cst-statement-conc1-matching

(defthm cst-statement-conc1-matching
 (implies (cst-list-list-conc-matchp abnf::cstss "return-statement")
          (and (equal (len abnf::cstss) 1)
               (cst-list-rep-matchp (nth 0 abnf::cstss)
                                    "return-statement"))))

Theorem: cst-statement-conc2-matching

(defthm cst-statement-conc2-matching
 (implies
      (cst-list-list-conc-matchp abnf::cstss "variable-declaration")
      (and (equal (len abnf::cstss) 1)
           (cst-list-rep-matchp (nth 0 abnf::cstss)
                                "variable-declaration"))))

Theorem: cst-statement-conc3-matching

(defthm cst-statement-conc3-matching
 (implies
      (cst-list-list-conc-matchp abnf::cstss "constant-declaration")
      (and (equal (len abnf::cstss) 1)
           (cst-list-rep-matchp (nth 0 abnf::cstss)
                                "constant-declaration"))))

Theorem: cst-statement-conc4-matching

(defthm cst-statement-conc4-matching
 (implies
     (cst-list-list-conc-matchp abnf::cstss "conditional-statement")
     (and (equal (len abnf::cstss) 1)
          (cst-list-rep-matchp (nth 0 abnf::cstss)
                               "conditional-statement"))))

Theorem: cst-statement-conc5-matching

(defthm cst-statement-conc5-matching
  (implies (cst-list-list-conc-matchp abnf::cstss "loop-statement")
           (and (equal (len abnf::cstss) 1)
                (cst-list-rep-matchp (nth 0 abnf::cstss)
                                     "loop-statement"))))

Theorem: cst-statement-conc6-matching

(defthm cst-statement-conc6-matching
 (implies
      (cst-list-list-conc-matchp abnf::cstss "assignment-statement")
      (and (equal (len abnf::cstss) 1)
           (cst-list-rep-matchp (nth 0 abnf::cstss)
                                "assignment-statement"))))

Theorem: cst-statement-conc7-matching

(defthm cst-statement-conc7-matching
  (implies
       (cst-list-list-conc-matchp abnf::cstss "console-statement")
       (and (equal (len abnf::cstss) 1)
            (cst-list-rep-matchp (nth 0 abnf::cstss)
                                 "console-statement"))))

Theorem: cst-statement-conc8-matching

(defthm cst-statement-conc8-matching
  (implies
       (cst-list-list-conc-matchp abnf::cstss "finalize-statement")
       (and (equal (len abnf::cstss) 1)
            (cst-list-rep-matchp (nth 0 abnf::cstss)
                                 "finalize-statement"))))

Theorem: cst-statement-conc9-matching

(defthm cst-statement-conc9-matching
  (implies
       (cst-list-list-conc-matchp abnf::cstss "increment-statement")
       (and (equal (len abnf::cstss) 1)
            (cst-list-rep-matchp (nth 0 abnf::cstss)
                                 "increment-statement"))))

Theorem: cst-statement-conc10-matching

(defthm cst-statement-conc10-matching
  (implies
       (cst-list-list-conc-matchp abnf::cstss "decrement-statement")
       (and (equal (len abnf::cstss) 1)
            (cst-list-rep-matchp (nth 0 abnf::cstss)
                                 "decrement-statement"))))

Theorem: cst-statement-conc11-matching

(defthm cst-statement-conc11-matching
  (implies (cst-list-list-conc-matchp abnf::cstss "block")
           (and (equal (len abnf::cstss) 1)
                (cst-list-rep-matchp (nth 0 abnf::cstss)
                                     "block"))))

Theorem: cst-conditional-statement-conc1-matching

(defthm cst-conditional-statement-conc1-matching
  (implies (cst-list-list-conc-matchp abnf::cstss "branch")
           (and (equal (len abnf::cstss) 1)
                (cst-list-rep-matchp (nth 0 abnf::cstss)
                                     "branch"))))

Theorem: cst-assignment-operator-conc1-matching

(defthm cst-assignment-operator-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-assignment-operator-conc2-matching

(defthm cst-assignment-operator-conc2-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-assignment-operator-conc3-matching

(defthm cst-assignment-operator-conc3-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-assignment-operator-conc4-matching

(defthm cst-assignment-operator-conc4-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-assignment-operator-conc5-matching

(defthm cst-assignment-operator-conc5-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-assignment-operator-conc6-matching

(defthm cst-assignment-operator-conc6-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-assignment-operator-conc7-matching

(defthm cst-assignment-operator-conc7-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-assignment-operator-conc8-matching

(defthm cst-assignment-operator-conc8-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-assignment-operator-conc9-matching

(defthm cst-assignment-operator-conc9-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-assignment-operator-conc10-matching

(defthm cst-assignment-operator-conc10-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-assignment-operator-conc11-matching

(defthm cst-assignment-operator-conc11-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-assignment-operator-conc12-matching

(defthm cst-assignment-operator-conc12-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-assignment-operator-conc13-matching

(defthm cst-assignment-operator-conc13-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-assignment-operator-conc14-matching

(defthm cst-assignment-operator-conc14-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-console-call-conc1-matching

(defthm cst-console-call-conc1-matching
  (implies (cst-list-list-conc-matchp abnf::cstss "assert-call")
           (and (equal (len abnf::cstss) 1)
                (cst-list-rep-matchp (nth 0 abnf::cstss)
                                     "assert-call"))))

Theorem: cst-console-call-conc2-matching

(defthm cst-console-call-conc2-matching
  (implies
       (cst-list-list-conc-matchp abnf::cstss "assert-equal-call")
       (and (equal (len abnf::cstss) 1)
            (cst-list-rep-matchp (nth 0 abnf::cstss)
                                 "assert-equal-call"))))

Theorem: cst-console-call-conc3-matching

(defthm cst-console-call-conc3-matching
 (implies
     (cst-list-list-conc-matchp abnf::cstss "assert-not-equal-call")
     (and (equal (len abnf::cstss) 1)
          (cst-list-rep-matchp (nth 0 abnf::cstss)
                               "assert-not-equal-call"))))

Theorem: cst-program-item-conc1-matching

(defthm cst-program-item-conc1-matching
 (implies
      (cst-list-list-conc-matchp abnf::cstss "function-declaration")
      (and (equal (len abnf::cstss) 1)
           (cst-list-rep-matchp (nth 0 abnf::cstss)
                                "function-declaration"))))

Theorem: cst-program-item-conc2-matching

(defthm cst-program-item-conc2-matching
 (implies
    (cst-list-list-conc-matchp abnf::cstss "transition-declaration")
    (and (equal (len abnf::cstss) 1)
         (cst-list-rep-matchp (nth 0 abnf::cstss)
                              "transition-declaration"))))

Theorem: cst-program-item-conc3-matching

(defthm cst-program-item-conc3-matching
  (implies
       (cst-list-list-conc-matchp abnf::cstss "struct-declaration")
       (and (equal (len abnf::cstss) 1)
            (cst-list-rep-matchp (nth 0 abnf::cstss)
                                 "struct-declaration"))))

Theorem: cst-program-item-conc4-matching

(defthm cst-program-item-conc4-matching
  (implies
       (cst-list-list-conc-matchp abnf::cstss "record-declaration")
       (and (equal (len abnf::cstss) 1)
            (cst-list-rep-matchp (nth 0 abnf::cstss)
                                 "record-declaration"))))

Theorem: cst-program-item-conc5-matching

(defthm cst-program-item-conc5-matching
  (implies
       (cst-list-list-conc-matchp abnf::cstss "mapping-declaration")
       (and (equal (len abnf::cstss) 1)
            (cst-list-rep-matchp (nth 0 abnf::cstss)
                                 "mapping-declaration"))))

Theorem: cst-input-type-conc-matching

(defthm cst-input-type-conc-matching
  (implies (cst-list-list-conc-matchp abnf::cstss "type")
           (and (equal (len abnf::cstss) 1)
                (cst-list-rep-matchp (nth 0 abnf::cstss)
                                     "type"))))

Theorem: cst-input-expression-conc-matching

(defthm cst-input-expression-conc-matching
  (implies (cst-list-list-conc-matchp abnf::cstss "expression")
           (and (equal (len abnf::cstss) 1)
                (cst-list-rep-matchp (nth 0 abnf::cstss)
                                     "expression"))))

Theorem: cst-input-file-conc-matching

(defthm cst-input-file-conc-matching
  (implies (cst-list-list-conc-matchp abnf::cstss "*input-section")
           (and (equal (len abnf::cstss) 1)
                (cst-list-rep-matchp (nth 0 abnf::cstss)
                                     "*input-section"))))

Theorem: cst-output-expression-conc-matching

(defthm cst-output-expression-conc-matching
  (implies (cst-list-list-conc-matchp abnf::cstss "expression")
           (and (equal (len abnf::cstss) 1)
                (cst-list-rep-matchp (nth 0 abnf::cstss)
                                     "expression"))))

Theorem: cst-output-file-conc-matching

(defthm cst-output-file-conc-matching
  (implies (cst-list-list-conc-matchp abnf::cstss "output-section")
           (and (equal (len abnf::cstss) 1)
                (cst-list-rep-matchp (nth 0 abnf::cstss)
                                     "output-section"))))

Theorem: cst-horizontal-tab-conc-rep-matching

(defthm cst-horizontal-tab-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-line-feed-conc-rep-matching

(defthm cst-line-feed-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-carriage-return-conc-rep-matching

(defthm cst-carriage-return-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-space-conc-rep-matching

(defthm cst-space-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-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 "horizontal-tab")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "horizontal-tab"))))

Theorem: cst-safe-ascii-conc2-rep-matching

(defthm cst-safe-ascii-conc2-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "line-feed")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "line-feed"))))

Theorem: cst-safe-ascii-conc3-rep-matching

(defthm cst-safe-ascii-conc3-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "carriage-return")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "carriage-return"))))

Theorem: cst-safe-ascii-conc4-rep-matching

(defthm cst-safe-ascii-conc4-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "space")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "space"))))

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-line-terminator-conc1-rep-matching

(defthm cst-line-terminator-conc1-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "line-feed")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "line-feed"))))

Theorem: cst-line-terminator-conc2-rep-matching

(defthm cst-line-terminator-conc2-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "carriage-return")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "carriage-return"))))

Theorem: cst-whitespace-conc1-rep-matching

(defthm cst-whitespace-conc1-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "space")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "space"))))

Theorem: cst-whitespace-conc2-rep-matching

(defthm cst-whitespace-conc2-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "horizontal-tab")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "horizontal-tab"))))

Theorem: cst-whitespace-conc3-rep-matching

(defthm cst-whitespace-conc3-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "line-terminator")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "line-terminator"))))

Theorem: cst-comment-conc1-rep-matching

(defthm cst-comment-conc1-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-comment-conc2-rep-matching

(defthm cst-comment-conc2-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-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-line-feed-or-carriage-return-conc1-rep-matching

(defthm
    cst-not-star-or-line-feed-or-carriage-return-conc1-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "horizontal-tab")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "horizontal-tab"))))

Theorem: cst-not-star-or-line-feed-or-carriage-return-conc2-rep-matching

(defthm
    cst-not-star-or-line-feed-or-carriage-return-conc2-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-line-feed-or-carriage-return-conc3-rep-matching

(defthm
    cst-not-star-or-line-feed-or-carriage-return-conc3-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-or-line-feed-or-carriage-return-conc4-rep-matching

(defthm
    cst-not-star-or-line-feed-or-carriage-return-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-or-slash-or-line-feed-or-carriage-return-conc1-rep-matching

(defthm
 cst-not-star-or-slash-or-line-feed-or-carriage-return-conc1-rep-matching
 (implies (cst-list-rep-matchp abnf::csts "horizontal-tab")
          (and (equal (len abnf::csts) 1)
               (cst-matchp (nth 0 abnf::csts)
                           "horizontal-tab"))))

Theorem: cst-not-star-or-slash-or-line-feed-or-carriage-return-conc2-rep-matching

(defthm
 cst-not-star-or-slash-or-line-feed-or-carriage-return-conc2-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-or-line-feed-or-carriage-return-conc3-rep-matching

(defthm
 cst-not-star-or-slash-or-line-feed-or-carriage-return-conc3-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-or-line-feed-or-carriage-return-conc4-rep-matching

(defthm
 cst-not-star-or-slash-or-line-feed-or-carriage-return-conc4-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-or-line-feed-or-carriage-return-conc5-rep-matching

(defthm
 cst-not-star-or-slash-or-line-feed-or-carriage-return-conc5-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-line-feed-or-carriage-return-conc1-rep-matching

(defthm cst-not-line-feed-or-carriage-return-conc1-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "horizontal-tab")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "horizontal-tab"))))

Theorem: cst-not-line-feed-or-carriage-return-conc2-rep-matching

(defthm cst-not-line-feed-or-carriage-return-conc2-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "space")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "space"))))

Theorem: cst-not-line-feed-or-carriage-return-conc3-rep-matching

(defthm cst-not-line-feed-or-carriage-return-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-line-feed-or-carriage-return-conc4-rep-matching

(defthm cst-not-line-feed-or-carriage-return-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-keyword-conc1-rep-matching

(defthm cst-keyword-conc1-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-keyword-conc2-rep-matching

(defthm cst-keyword-conc2-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "%s\"async\"")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "%s\"async\""))))

Theorem: cst-keyword-conc3-rep-matching

(defthm cst-keyword-conc3-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "%s\"bool\"")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "%s\"bool\""))))

Theorem: cst-keyword-conc4-rep-matching

(defthm cst-keyword-conc4-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "%s\"console\"")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "%s\"console\""))))

Theorem: cst-keyword-conc5-rep-matching

(defthm cst-keyword-conc5-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "%s\"const\"")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "%s\"const\""))))

Theorem: cst-keyword-conc6-rep-matching

(defthm cst-keyword-conc6-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "%s\"constant\"")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "%s\"constant\""))))

Theorem: cst-keyword-conc7-rep-matching

(defthm cst-keyword-conc7-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "%s\"decrement\"")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "%s\"decrement\""))))

Theorem: cst-keyword-conc8-rep-matching

(defthm cst-keyword-conc8-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "%s\"else\"")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "%s\"else\""))))

Theorem: cst-keyword-conc9-rep-matching

(defthm cst-keyword-conc9-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-keyword-conc10-rep-matching

(defthm cst-keyword-conc10-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "%s\"finalize\"")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "%s\"finalize\""))))

Theorem: cst-keyword-conc11-rep-matching

(defthm cst-keyword-conc11-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "%s\"for\"")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "%s\"for\""))))

Theorem: cst-keyword-conc12-rep-matching

(defthm cst-keyword-conc12-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "%s\"function\"")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "%s\"function\""))))

Theorem: cst-keyword-conc13-rep-matching

(defthm cst-keyword-conc13-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-keyword-conc14-rep-matching

(defthm cst-keyword-conc14-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-keyword-conc15-rep-matching

(defthm cst-keyword-conc15-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-keyword-conc16-rep-matching

(defthm cst-keyword-conc16-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-keyword-conc17-rep-matching

(defthm cst-keyword-conc17-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-keyword-conc18-rep-matching

(defthm cst-keyword-conc18-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-keyword-conc19-rep-matching

(defthm cst-keyword-conc19-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "%s\"if\"")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "%s\"if\""))))

Theorem: cst-keyword-conc20-rep-matching

(defthm cst-keyword-conc20-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "%s\"import\"")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "%s\"import\""))))

Theorem: cst-keyword-conc21-rep-matching

(defthm cst-keyword-conc21-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "%s\"in\"")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "%s\"in\""))))

Theorem: cst-keyword-conc22-rep-matching

(defthm cst-keyword-conc22-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "%s\"increment\"")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "%s\"increment\""))))

Theorem: cst-keyword-conc23-rep-matching

(defthm cst-keyword-conc23-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "%s\"let\"")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "%s\"let\""))))

Theorem: cst-keyword-conc24-rep-matching

(defthm cst-keyword-conc24-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "%s\"mapping\"")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "%s\"mapping\""))))

Theorem: cst-keyword-conc25-rep-matching

(defthm cst-keyword-conc25-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "%s\"program\"")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "%s\"program\""))))

Theorem: cst-keyword-conc26-rep-matching

(defthm cst-keyword-conc26-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "%s\"public\"")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "%s\"public\""))))

Theorem: cst-keyword-conc27-rep-matching

(defthm cst-keyword-conc27-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "%s\"record\"")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "%s\"record\""))))

Theorem: cst-keyword-conc28-rep-matching

(defthm cst-keyword-conc28-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "%s\"return\"")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "%s\"return\""))))

Theorem: cst-keyword-conc29-rep-matching

(defthm cst-keyword-conc29-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-keyword-conc30-rep-matching

(defthm cst-keyword-conc30-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-keyword-conc31-rep-matching

(defthm cst-keyword-conc31-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "%s\"struct\"")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "%s\"struct\""))))

Theorem: cst-keyword-conc32-rep-matching

(defthm cst-keyword-conc32-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "%s\"transition\"")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "%s\"transition\""))))

Theorem: cst-keyword-conc33-rep-matching

(defthm cst-keyword-conc33-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-keyword-conc34-rep-matching

(defthm cst-keyword-conc34-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-keyword-conc35-rep-matching

(defthm cst-keyword-conc35-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-keyword-conc36-rep-matching

(defthm cst-keyword-conc36-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-keyword-conc37-rep-matching

(defthm cst-keyword-conc37-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-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-decimal-digit-conc-rep-matching

(defthm cst-decimal-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-octal-digit-conc-rep-matching

(defthm cst-octal-digit-conc-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "%x30-37")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "%x30-37"))))

Theorem: cst-hexadecimal-digit-conc1-rep-matching

(defthm cst-hexadecimal-digit-conc1-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "decimal-digit")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "decimal-digit"))))

Theorem: cst-hexadecimal-digit-conc2-rep-matching

(defthm cst-hexadecimal-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-hexadecimal-digit-conc3-rep-matching

(defthm cst-hexadecimal-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-hexadecimal-digit-conc4-rep-matching

(defthm cst-hexadecimal-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-hexadecimal-digit-conc5-rep-matching

(defthm cst-hexadecimal-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-hexadecimal-digit-conc6-rep-matching

(defthm cst-hexadecimal-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-hexadecimal-digit-conc7-rep-matching

(defthm cst-hexadecimal-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-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-single-quote-conc-rep-matching

(defthm cst-single-quote-conc-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "%x27")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "%x27"))))

Theorem: cst-double-quote-conc-rep-matching

(defthm cst-double-quote-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-backslash-escape-conc-rep-matching

(defthm cst-backslash-escape-conc-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "\"\\\\\"")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "\"\\\\\""))))

Theorem: cst-line-feed-escape-conc-rep-matching

(defthm cst-line-feed-escape-conc-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-carriage-return-escape-conc-rep-matching

(defthm cst-carriage-return-escape-conc-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-horizontal-tab-escape-conc-rep-matching

(defthm cst-horizontal-tab-escape-conc-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-null-character-escape-conc-rep-matching

(defthm cst-null-character-escape-conc-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-simple-character-escape-conc1-rep-matching

(defthm cst-simple-character-escape-conc1-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "single-quote-escape")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "single-quote-escape"))))

Theorem: cst-simple-character-escape-conc2-rep-matching

(defthm cst-simple-character-escape-conc2-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "double-quote-escape")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "double-quote-escape"))))

Theorem: cst-simple-character-escape-conc3-rep-matching

(defthm cst-simple-character-escape-conc3-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "backslash-escape")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "backslash-escape"))))

Theorem: cst-simple-character-escape-conc4-rep-matching

(defthm cst-simple-character-escape-conc4-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "line-feed-escape")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "line-feed-escape"))))

Theorem: cst-simple-character-escape-conc5-rep-matching

(defthm cst-simple-character-escape-conc5-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "carriage-return-escape")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "carriage-return-escape"))))

Theorem: cst-simple-character-escape-conc6-rep-matching

(defthm cst-simple-character-escape-conc6-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "horizontal-tab-escape")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "horizontal-tab-escape"))))

Theorem: cst-simple-character-escape-conc7-rep-matching

(defthm cst-simple-character-escape-conc7-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "null-character-escape")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "null-character-escape"))))

Theorem: cst-string-literal-element-conc1-rep-matching

(defthm cst-string-literal-element-conc1-rep-matching
 (implies
  (cst-list-rep-matchp
    abnf::csts
    "not-double-quote-or-backslash-or-line-feed-or-carriage-return")
  (and
   (equal (len abnf::csts) 1)
   (cst-matchp
    (nth 0 abnf::csts)
    "not-double-quote-or-backslash-or-line-feed-or-carriage-return"))))

Theorem: cst-string-literal-element-conc2-rep-matching

(defthm cst-string-literal-element-conc2-rep-matching
 (implies (cst-list-rep-matchp abnf::csts "simple-character-escape")
          (and (equal (len abnf::csts) 1)
               (cst-matchp (nth 0 abnf::csts)
                           "simple-character-escape"))))

Theorem: cst-string-literal-element-conc3-rep-matching

(defthm cst-string-literal-element-conc3-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "ascii-character-escape")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "ascii-character-escape"))))

Theorem: cst-string-literal-element-conc4-rep-matching

(defthm cst-string-literal-element-conc4-rep-matching
  (implies
       (cst-list-rep-matchp abnf::csts "unicode-character-escape")
       (and (equal (len abnf::csts) 1)
            (cst-matchp (nth 0 abnf::csts)
                        "unicode-character-escape"))))

Theorem: cst-not-double-quote-or-backslash-or-line-feed-or-carriage-return-conc1-rep-matching

(defthm
 cst-not-double-quote-or-backslash-or-line-feed-or-carriage-return-conc1-rep-matching
 (implies (cst-list-rep-matchp abnf::csts "horizontal-tab")
          (and (equal (len abnf::csts) 1)
               (cst-matchp (nth 0 abnf::csts)
                           "horizontal-tab"))))

Theorem: cst-not-double-quote-or-backslash-or-line-feed-or-carriage-return-conc2-rep-matching

(defthm
 cst-not-double-quote-or-backslash-or-line-feed-or-carriage-return-conc2-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-double-quote-or-backslash-or-line-feed-or-carriage-return-conc3-rep-matching

(defthm
 cst-not-double-quote-or-backslash-or-line-feed-or-carriage-return-conc3-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-double-quote-or-backslash-or-line-feed-or-carriage-return-conc4-rep-matching

(defthm
 cst-not-double-quote-or-backslash-or-line-feed-or-carriage-return-conc4-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-double-quote-or-backslash-or-line-feed-or-carriage-return-conc5-rep-matching

(defthm
 cst-not-double-quote-or-backslash-or-line-feed-or-carriage-return-conc5-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-integer-literal-conc1-rep-matching

(defthm cst-integer-literal-conc1-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-integer-literal-conc2-rep-matching

(defthm cst-integer-literal-conc2-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-numeric-literal-conc1-rep-matching

(defthm cst-numeric-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-numeric-literal-conc2-rep-matching

(defthm cst-numeric-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-numeric-literal-conc3-rep-matching

(defthm cst-numeric-literal-conc3-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "product-group-literal")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "product-group-literal"))))

Theorem: cst-numeric-literal-conc4-rep-matching

(defthm cst-numeric-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-atomic-literal-conc1-rep-matching

(defthm cst-atomic-literal-conc1-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "numeric-literal")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "numeric-literal"))))

Theorem: cst-atomic-literal-conc2-rep-matching

(defthm cst-atomic-literal-conc2-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-atomic-literal-conc3-rep-matching

(defthm cst-atomic-literal-conc3-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-atomic-literal-conc4-rep-matching

(defthm cst-atomic-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-symbol-conc1-rep-matching

(defthm cst-symbol-conc1-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "\"!\"")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts) "\"!\""))))

Theorem: cst-symbol-conc2-rep-matching

(defthm cst-symbol-conc2-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "\"&&\"")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "\"&&\""))))

Theorem: cst-symbol-conc3-rep-matching

(defthm cst-symbol-conc3-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "\"||\"")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "\"||\""))))

Theorem: cst-symbol-conc4-rep-matching

(defthm cst-symbol-conc4-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "\"==\"")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "\"==\""))))

Theorem: cst-symbol-conc5-rep-matching

(defthm cst-symbol-conc5-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "\"!=\"")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "\"!=\""))))

Theorem: cst-symbol-conc6-rep-matching

(defthm cst-symbol-conc6-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "\"<\"")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts) "\"<\""))))

Theorem: cst-symbol-conc7-rep-matching

(defthm cst-symbol-conc7-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "\"<=\"")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "\"<=\""))))

Theorem: cst-symbol-conc8-rep-matching

(defthm cst-symbol-conc8-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "\">\"")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts) "\">\""))))

Theorem: cst-symbol-conc9-rep-matching

(defthm cst-symbol-conc9-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "\">=\"")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "\">=\""))))

Theorem: cst-symbol-conc10-rep-matching

(defthm cst-symbol-conc10-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "\"&\"")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts) "\"&\""))))

Theorem: cst-symbol-conc11-rep-matching

(defthm cst-symbol-conc11-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "\"|\"")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts) "\"|\""))))

Theorem: cst-symbol-conc12-rep-matching

(defthm cst-symbol-conc12-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "\"^\"")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts) "\"^\""))))

Theorem: cst-symbol-conc13-rep-matching

(defthm cst-symbol-conc13-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "\"<<\"")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "\"<<\""))))

Theorem: cst-symbol-conc14-rep-matching

(defthm cst-symbol-conc14-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "\">>\"")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "\">>\""))))

Theorem: cst-symbol-conc15-rep-matching

(defthm cst-symbol-conc15-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "\"+\"")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts) "\"+\""))))

Theorem: cst-symbol-conc16-rep-matching

(defthm cst-symbol-conc16-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "\"-\"")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts) "\"-\""))))

Theorem: cst-symbol-conc17-rep-matching

(defthm cst-symbol-conc17-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "\"*\"")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts) "\"*\""))))

Theorem: cst-symbol-conc18-rep-matching

(defthm cst-symbol-conc18-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "\"/\"")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts) "\"/\""))))

Theorem: cst-symbol-conc19-rep-matching

(defthm cst-symbol-conc19-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "\"%\"")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts) "\"%\""))))

Theorem: cst-symbol-conc20-rep-matching

(defthm cst-symbol-conc20-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "\"**\"")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "\"**\""))))

Theorem: cst-symbol-conc21-rep-matching

(defthm cst-symbol-conc21-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "\"=\"")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts) "\"=\""))))

Theorem: cst-symbol-conc22-rep-matching

(defthm cst-symbol-conc22-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "\"+=\"")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "\"+=\""))))

Theorem: cst-symbol-conc23-rep-matching

(defthm cst-symbol-conc23-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "\"-=\"")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "\"-=\""))))

Theorem: cst-symbol-conc24-rep-matching

(defthm cst-symbol-conc24-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "\"*=\"")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "\"*=\""))))

Theorem: cst-symbol-conc25-rep-matching

(defthm cst-symbol-conc25-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "\"/=\"")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "\"/=\""))))

Theorem: cst-symbol-conc26-rep-matching

(defthm cst-symbol-conc26-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "\"%=\"")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "\"%=\""))))

Theorem: cst-symbol-conc27-rep-matching

(defthm cst-symbol-conc27-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "\"**=\"")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "\"**=\""))))

Theorem: cst-symbol-conc28-rep-matching

(defthm cst-symbol-conc28-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "\"<<=\"")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "\"<<=\""))))

Theorem: cst-symbol-conc29-rep-matching

(defthm cst-symbol-conc29-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "\">>=\"")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "\">>=\""))))

Theorem: cst-symbol-conc30-rep-matching

(defthm cst-symbol-conc30-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "\"&=\"")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "\"&=\""))))

Theorem: cst-symbol-conc31-rep-matching

(defthm cst-symbol-conc31-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "\"|=\"")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "\"|=\""))))

Theorem: cst-symbol-conc32-rep-matching

(defthm cst-symbol-conc32-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "\"^=\"")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "\"^=\""))))

Theorem: cst-symbol-conc33-rep-matching

(defthm cst-symbol-conc33-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "\"&&=\"")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "\"&&=\""))))

Theorem: cst-symbol-conc34-rep-matching

(defthm cst-symbol-conc34-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "\"||=\"")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "\"||=\""))))

Theorem: cst-symbol-conc35-rep-matching

(defthm cst-symbol-conc35-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "\"(\"")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts) "\"(\""))))

Theorem: cst-symbol-conc36-rep-matching

(defthm cst-symbol-conc36-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "\")\"")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts) "\")\""))))

Theorem: cst-symbol-conc37-rep-matching

(defthm cst-symbol-conc37-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "\"[\"")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts) "\"[\""))))

Theorem: cst-symbol-conc38-rep-matching

(defthm cst-symbol-conc38-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "\"]\"")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts) "\"]\""))))

Theorem: cst-symbol-conc39-rep-matching

(defthm cst-symbol-conc39-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "\"{\"")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts) "\"{\""))))

Theorem: cst-symbol-conc40-rep-matching

(defthm cst-symbol-conc40-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "\"}\"")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts) "\"}\""))))

Theorem: cst-symbol-conc41-rep-matching

(defthm cst-symbol-conc41-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "\",\"")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts) "\",\""))))

Theorem: cst-symbol-conc42-rep-matching

(defthm cst-symbol-conc42-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "\".\"")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts) "\".\""))))

Theorem: cst-symbol-conc43-rep-matching

(defthm cst-symbol-conc43-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "\"..\"")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "\"..\""))))

Theorem: cst-symbol-conc44-rep-matching

(defthm cst-symbol-conc44-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "\";\"")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts) "\";\""))))

Theorem: cst-symbol-conc45-rep-matching

(defthm cst-symbol-conc45-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "\":\"")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts) "\":\""))))

Theorem: cst-symbol-conc46-rep-matching

(defthm cst-symbol-conc46-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "\"::\"")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "\"::\""))))

Theorem: cst-symbol-conc47-rep-matching

(defthm cst-symbol-conc47-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "\"?\"")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts) "\"?\""))))

Theorem: cst-symbol-conc48-rep-matching

(defthm cst-symbol-conc48-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "\"->\"")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "\"->\""))))

Theorem: cst-symbol-conc49-rep-matching

(defthm cst-symbol-conc49-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "\"=>\"")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "\"=>\""))))

Theorem: cst-symbol-conc50-rep-matching

(defthm cst-symbol-conc50-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "\"_\"")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts) "\"_\""))))

Theorem: cst-symbol-conc51-rep-matching

(defthm cst-symbol-conc51-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-token-conc1-rep-matching

(defthm cst-token-conc1-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "keyword")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "keyword"))))

Theorem: cst-token-conc2-rep-matching

(defthm cst-token-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-token-conc3-rep-matching

(defthm cst-token-conc3-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "atomic-literal")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "atomic-literal"))))

Theorem: cst-token-conc4-rep-matching

(defthm cst-token-conc4-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "numeral")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "numeral"))))

Theorem: cst-token-conc5-rep-matching

(defthm cst-token-conc5-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "annotation")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "annotation"))))

Theorem: cst-token-conc6-rep-matching

(defthm cst-token-conc6-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "symbol")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "symbol"))))

Theorem: cst-lexeme-conc1-rep-matching

(defthm cst-lexeme-conc1-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "token")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "token"))))

Theorem: cst-lexeme-conc2-rep-matching

(defthm cst-lexeme-conc2-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "comment")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "comment"))))

Theorem: cst-lexeme-conc3-rep-matching

(defthm cst-lexeme-conc3-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "whitespace")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "whitespace"))))

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-boolean-type-conc-rep-matching

(defthm cst-boolean-type-conc-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "%s\"bool\"")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "%s\"bool\""))))

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-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-named-primitive-type-conc1-rep-matching

(defthm cst-named-primitive-type-conc1-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-named-primitive-type-conc2-rep-matching

(defthm cst-named-primitive-type-conc2-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-named-primitive-type-conc3-rep-matching

(defthm cst-named-primitive-type-conc3-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-named-primitive-type-conc4-rep-matching

(defthm cst-named-primitive-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-primitive-type-conc1-rep-matching

(defthm cst-primitive-type-conc1-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "named-primitive-type")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "named-primitive-type"))))

Theorem: cst-primitive-type-conc2-rep-matching

(defthm cst-primitive-type-conc2-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "unit-type")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "unit-type"))))

Theorem: cst-named-type-conc1-rep-matching

(defthm cst-named-type-conc1-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "named-primitive-type")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "named-primitive-type"))))

Theorem: cst-type-conc1-rep-matching

(defthm cst-type-conc1-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "named-type")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "named-type"))))

Theorem: cst-type-conc2-rep-matching

(defthm cst-type-conc2-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "unit-type")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "unit-type"))))

Theorem: cst-type-conc3-rep-matching

(defthm cst-type-conc3-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "tuple-type")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "tuple-type"))))

Theorem: cst-group-coordinate-conc1-rep-matching

(defthm cst-group-coordinate-conc1-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "( [ \"-\" ] numeral )")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "( [ \"-\" ] numeral )"))))

Theorem: cst-group-coordinate-conc2-rep-matching

(defthm cst-group-coordinate-conc2-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "\"+\"")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts) "\"+\""))))

Theorem: cst-group-coordinate-conc3-rep-matching

(defthm cst-group-coordinate-conc3-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "\"-\"")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts) "\"-\""))))

Theorem: cst-group-coordinate-conc4-rep-matching

(defthm cst-group-coordinate-conc4-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "\"_\"")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts) "\"_\""))))

Theorem: cst-literal-conc1-rep-matching

(defthm cst-literal-conc1-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "atomic-literal")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "atomic-literal"))))

Theorem: cst-literal-conc2-rep-matching

(defthm cst-literal-conc2-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "affine-group-literal")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "affine-group-literal"))))

Theorem: cst-group-literal-conc1-rep-matching

(defthm cst-group-literal-conc1-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "product-group-literal")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "product-group-literal"))))

Theorem: cst-group-literal-conc2-rep-matching

(defthm cst-group-literal-conc2-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "affine-group-literal")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "affine-group-literal"))))

Theorem: cst-primary-expression-conc1-rep-matching

(defthm cst-primary-expression-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-primary-expression-conc2-rep-matching

(defthm cst-primary-expression-conc2-rep-matching
  (implies
       (cst-list-rep-matchp abnf::csts "variable-or-free-constant")
       (and (equal (len abnf::csts) 1)
            (cst-matchp (nth 0 abnf::csts)
                        "variable-or-free-constant"))))

Theorem: cst-primary-expression-conc3-rep-matching

(defthm cst-primary-expression-conc3-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "associated-constant")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "associated-constant"))))

Theorem: cst-primary-expression-conc5-rep-matching

(defthm cst-primary-expression-conc5-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "free-function-call")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "free-function-call"))))

Theorem: cst-primary-expression-conc6-rep-matching

(defthm cst-primary-expression-conc6-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "static-function-call")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "static-function-call"))))

Theorem: cst-primary-expression-conc7-rep-matching

(defthm cst-primary-expression-conc7-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "unit-expression")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "unit-expression"))))

Theorem: cst-primary-expression-conc8-rep-matching

(defthm cst-primary-expression-conc8-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "tuple-expression")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "tuple-expression"))))

Theorem: cst-primary-expression-conc9-rep-matching

(defthm cst-primary-expression-conc9-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "struct-expression")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "struct-expression"))))

Theorem: cst-variable-or-free-constant-conc-rep-matching

(defthm cst-variable-or-free-constant-conc-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-struct-component-initializer-conc1-rep-matching

(defthm cst-struct-component-initializer-conc1-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-postfix-expression-conc1-rep-matching

(defthm cst-postfix-expression-conc1-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "primary-expression")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "primary-expression"))))

Theorem: cst-postfix-expression-conc2-rep-matching

(defthm cst-postfix-expression-conc2-rep-matching
  (implies
       (cst-list-rep-matchp abnf::csts "tuple-component-expression")
       (and (equal (len abnf::csts) 1)
            (cst-matchp (nth 0 abnf::csts)
                        "tuple-component-expression"))))

Theorem: cst-postfix-expression-conc3-rep-matching

(defthm cst-postfix-expression-conc3-rep-matching
  (implies (cst-list-rep-matchp abnf::csts
                                "struct-component-expression")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "struct-component-expression"))))

Theorem: cst-postfix-expression-conc4-rep-matching

(defthm cst-postfix-expression-conc4-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "operator-call")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "operator-call"))))

Theorem: cst-operator-call-conc1-rep-matching

(defthm cst-operator-call-conc1-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "unary-operator-call")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "unary-operator-call"))))

Theorem: cst-operator-call-conc2-rep-matching

(defthm cst-operator-call-conc2-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "binary-operator-call")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "binary-operator-call"))))

Theorem: cst-unary-expression-conc1-rep-matching

(defthm cst-unary-expression-conc1-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "postfix-expression")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "postfix-expression"))))

Theorem: cst-exponential-expression-conc1-rep-matching

(defthm cst-exponential-expression-conc1-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "unary-expression")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "unary-expression"))))

Theorem: cst-multiplicative-expression-conc1-rep-matching

(defthm cst-multiplicative-expression-conc1-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "exponential-expression")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "exponential-expression"))))

Theorem: cst-additive-expression-conc1-rep-matching

(defthm cst-additive-expression-conc1-rep-matching
  (implies
       (cst-list-rep-matchp abnf::csts "multiplicative-expression")
       (and (equal (len abnf::csts) 1)
            (cst-matchp (nth 0 abnf::csts)
                        "multiplicative-expression"))))

Theorem: cst-shift-expression-conc1-rep-matching

(defthm cst-shift-expression-conc1-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "additive-expression")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "additive-expression"))))

Theorem: cst-conjunctive-expression-conc1-rep-matching

(defthm cst-conjunctive-expression-conc1-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "shift-expression")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "shift-expression"))))

Theorem: cst-disjunctive-expression-conc1-rep-matching

(defthm cst-disjunctive-expression-conc1-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "conjunctive-expression")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "conjunctive-expression"))))

Theorem: cst-exclusive-disjunctive-expression-conc1-rep-matching

(defthm cst-exclusive-disjunctive-expression-conc1-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "disjunctive-expression")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "disjunctive-expression"))))

Theorem: cst-ordering-expression-conc1-rep-matching

(defthm cst-ordering-expression-conc1-rep-matching
  (implies (cst-list-rep-matchp abnf::csts
                                "exclusive-disjunctive-expression")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "exclusive-disjunctive-expression"))))

Theorem: cst-equality-expression-conc1-rep-matching

(defthm cst-equality-expression-conc1-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "ordering-expression")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "ordering-expression"))))

Theorem: cst-conditional-conjunctive-expression-conc1-rep-matching

(defthm cst-conditional-conjunctive-expression-conc1-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "equality-expression")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "equality-expression"))))

Theorem: cst-conditional-disjunctive-expression-conc1-rep-matching

(defthm cst-conditional-disjunctive-expression-conc1-rep-matching
 (implies (cst-list-rep-matchp abnf::csts
                               "conditional-conjunctive-expression")
          (and (equal (len abnf::csts) 1)
               (cst-matchp (nth 0 abnf::csts)
                           "conditional-conjunctive-expression"))))

Theorem: cst-binary-expression-conc-rep-matching

(defthm cst-binary-expression-conc-rep-matching
 (implies (cst-list-rep-matchp abnf::csts
                               "conditional-disjunctive-expression")
          (and (equal (len abnf::csts) 1)
               (cst-matchp (nth 0 abnf::csts)
                           "conditional-disjunctive-expression"))))

Theorem: cst-conditional-ternary-expression-conc1-rep-matching

(defthm cst-conditional-ternary-expression-conc1-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "binary-expression")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "binary-expression"))))

Theorem: cst-expression-conc-rep-matching

(defthm cst-expression-conc-rep-matching
  (implies (cst-list-rep-matchp abnf::csts
                                "conditional-ternary-expression")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "conditional-ternary-expression"))))

Theorem: cst-statement-conc1-rep-matching

(defthm cst-statement-conc1-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "return-statement")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "return-statement"))))

Theorem: cst-statement-conc2-rep-matching

(defthm cst-statement-conc2-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "variable-declaration")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "variable-declaration"))))

Theorem: cst-statement-conc3-rep-matching

(defthm cst-statement-conc3-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "constant-declaration")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "constant-declaration"))))

Theorem: cst-statement-conc4-rep-matching

(defthm cst-statement-conc4-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "conditional-statement")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "conditional-statement"))))

Theorem: cst-statement-conc5-rep-matching

(defthm cst-statement-conc5-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "loop-statement")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "loop-statement"))))

Theorem: cst-statement-conc6-rep-matching

(defthm cst-statement-conc6-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "assignment-statement")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "assignment-statement"))))

Theorem: cst-statement-conc7-rep-matching

(defthm cst-statement-conc7-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "console-statement")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "console-statement"))))

Theorem: cst-statement-conc8-rep-matching

(defthm cst-statement-conc8-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "finalize-statement")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "finalize-statement"))))

Theorem: cst-statement-conc9-rep-matching

(defthm cst-statement-conc9-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "increment-statement")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "increment-statement"))))

Theorem: cst-statement-conc10-rep-matching

(defthm cst-statement-conc10-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "decrement-statement")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "decrement-statement"))))

Theorem: cst-statement-conc11-rep-matching

(defthm cst-statement-conc11-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "block")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "block"))))

Theorem: cst-conditional-statement-conc1-rep-matching

(defthm cst-conditional-statement-conc1-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "branch")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "branch"))))

Theorem: cst-assignment-operator-conc1-rep-matching

(defthm cst-assignment-operator-conc1-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "\"=\"")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts) "\"=\""))))

Theorem: cst-assignment-operator-conc2-rep-matching

(defthm cst-assignment-operator-conc2-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "\"+=\"")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "\"+=\""))))

Theorem: cst-assignment-operator-conc3-rep-matching

(defthm cst-assignment-operator-conc3-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "\"-=\"")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "\"-=\""))))

Theorem: cst-assignment-operator-conc4-rep-matching

(defthm cst-assignment-operator-conc4-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "\"*=\"")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "\"*=\""))))

Theorem: cst-assignment-operator-conc5-rep-matching

(defthm cst-assignment-operator-conc5-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "\"/=\"")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "\"/=\""))))

Theorem: cst-assignment-operator-conc6-rep-matching

(defthm cst-assignment-operator-conc6-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "\"%=\"")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "\"%=\""))))

Theorem: cst-assignment-operator-conc7-rep-matching

(defthm cst-assignment-operator-conc7-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "\"**=\"")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "\"**=\""))))

Theorem: cst-assignment-operator-conc8-rep-matching

(defthm cst-assignment-operator-conc8-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "\"<<=\"")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "\"<<=\""))))

Theorem: cst-assignment-operator-conc9-rep-matching

(defthm cst-assignment-operator-conc9-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "\">>=\"")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "\">>=\""))))

Theorem: cst-assignment-operator-conc10-rep-matching

(defthm cst-assignment-operator-conc10-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "\"&=\"")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "\"&=\""))))

Theorem: cst-assignment-operator-conc11-rep-matching

(defthm cst-assignment-operator-conc11-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "\"|=\"")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "\"|=\""))))

Theorem: cst-assignment-operator-conc12-rep-matching

(defthm cst-assignment-operator-conc12-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "\"^=\"")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "\"^=\""))))

Theorem: cst-assignment-operator-conc13-rep-matching

(defthm cst-assignment-operator-conc13-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "\"&&=\"")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "\"&&=\""))))

Theorem: cst-assignment-operator-conc14-rep-matching

(defthm cst-assignment-operator-conc14-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "\"||=\"")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "\"||=\""))))

Theorem: cst-console-call-conc1-rep-matching

(defthm cst-console-call-conc1-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "assert-call")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "assert-call"))))

Theorem: cst-console-call-conc2-rep-matching

(defthm cst-console-call-conc2-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "assert-equal-call")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "assert-equal-call"))))

Theorem: cst-console-call-conc3-rep-matching

(defthm cst-console-call-conc3-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "assert-not-equal-call")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "assert-not-equal-call"))))

Theorem: cst-program-item-conc1-rep-matching

(defthm cst-program-item-conc1-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "function-declaration")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "function-declaration"))))

Theorem: cst-program-item-conc2-rep-matching

(defthm cst-program-item-conc2-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "transition-declaration")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "transition-declaration"))))

Theorem: cst-program-item-conc3-rep-matching

(defthm cst-program-item-conc3-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "struct-declaration")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "struct-declaration"))))

Theorem: cst-program-item-conc4-rep-matching

(defthm cst-program-item-conc4-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "record-declaration")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "record-declaration"))))

Theorem: cst-program-item-conc5-rep-matching

(defthm cst-program-item-conc5-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "mapping-declaration")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "mapping-declaration"))))

Theorem: cst-input-type-conc-rep-matching

(defthm cst-input-type-conc-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "type")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "type"))))

Theorem: cst-input-expression-conc-rep-matching

(defthm cst-input-expression-conc-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "expression")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "expression"))))

Theorem: cst-output-expression-conc-rep-matching

(defthm cst-output-expression-conc-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "expression")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "expression"))))

Theorem: cst-output-file-conc-rep-matching

(defthm cst-output-file-conc-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "output-section")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "output-section"))))

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)
          "horizontal-tab")
     (equal
          (abnf::tree-nonleaf->rulename?
               (nth 0
                    (nth 0
                         (abnf::tree-nonleaf->branches abnf::cst))))
          (abnf::rulename "horizontal-tab")))
   (iff
     (cst-list-list-conc-matchp
          (abnf::tree-nonleaf->branches abnf::cst)
          "line-feed")
     (equal
          (abnf::tree-nonleaf->rulename?
               (nth 0
                    (nth 0
                         (abnf::tree-nonleaf->branches abnf::cst))))
          (abnf::rulename "line-feed")))
   (iff
     (cst-list-list-conc-matchp
          (abnf::tree-nonleaf->branches abnf::cst)
          "carriage-return")
     (equal
          (abnf::tree-nonleaf->rulename?
               (nth 0
                    (nth 0
                         (abnf::tree-nonleaf->branches abnf::cst))))
          (abnf::rulename "carriage-return")))
   (iff
     (cst-list-list-conc-matchp
          (abnf::tree-nonleaf->branches abnf::cst)
          "space")
     (equal
          (abnf::tree-nonleaf->rulename?
               (nth 0
                    (nth 0
                         (abnf::tree-nonleaf->branches abnf::cst))))
          (abnf::rulename "space")))
   (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-whitespace-conc-equivs

(defthm cst-whitespace-conc-equivs
 (implies
  (cst-matchp abnf::cst "whitespace")
  (and
   (iff
     (cst-list-list-conc-matchp
          (abnf::tree-nonleaf->branches abnf::cst)
          "space")
     (equal
          (abnf::tree-nonleaf->rulename?
               (nth 0
                    (nth 0
                         (abnf::tree-nonleaf->branches abnf::cst))))
          (abnf::rulename "space")))
   (iff
     (cst-list-list-conc-matchp
          (abnf::tree-nonleaf->branches abnf::cst)
          "horizontal-tab")
     (equal
          (abnf::tree-nonleaf->rulename?
               (nth 0
                    (nth 0
                         (abnf::tree-nonleaf->branches abnf::cst))))
          (abnf::rulename "horizontal-tab")))
   (iff
     (cst-list-list-conc-matchp
          (abnf::tree-nonleaf->branches abnf::cst)
          "line-terminator")
     (equal
          (abnf::tree-nonleaf->rulename?
               (nth 0
                    (nth 0
                         (abnf::tree-nonleaf->branches abnf::cst))))
          (abnf::rulename "line-terminator"))))))

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)
          "block-comment")
     (equal
          (abnf::tree-nonleaf->rulename?
               (nth 0
                    (nth 0
                         (abnf::tree-nonleaf->branches abnf::cst))))
          (abnf::rulename "block-comment")))
   (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"))))))

Theorem: cst-not-line-feed-or-carriage-return-conc-equivs

(defthm cst-not-line-feed-or-carriage-return-conc-equivs
 (implies
  (cst-matchp abnf::cst
              "not-line-feed-or-carriage-return")
  (and
   (iff
     (cst-list-list-conc-matchp
          (abnf::tree-nonleaf->branches abnf::cst)
          "horizontal-tab")
     (equal
          (abnf::tree-nonleaf->rulename?
               (nth 0
                    (nth 0
                         (abnf::tree-nonleaf->branches abnf::cst))))
          (abnf::rulename "horizontal-tab")))
   (iff
     (cst-list-list-conc-matchp
          (abnf::tree-nonleaf->branches abnf::cst)
          "space")
     (equal
          (abnf::tree-nonleaf->rulename?
               (nth 0
                    (nth 0
                         (abnf::tree-nonleaf->branches abnf::cst))))
          (abnf::rulename "space")))
   (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-simple-character-escape-conc-equivs

(defthm cst-simple-character-escape-conc-equivs
 (implies
  (cst-matchp abnf::cst "simple-character-escape")
  (and
   (iff
     (cst-list-list-conc-matchp
          (abnf::tree-nonleaf->branches abnf::cst)
          "single-quote-escape")
     (equal
          (abnf::tree-nonleaf->rulename?
               (nth 0
                    (nth 0
                         (abnf::tree-nonleaf->branches abnf::cst))))
          (abnf::rulename "single-quote-escape")))
   (iff
     (cst-list-list-conc-matchp
          (abnf::tree-nonleaf->branches abnf::cst)
          "double-quote-escape")
     (equal
          (abnf::tree-nonleaf->rulename?
               (nth 0
                    (nth 0
                         (abnf::tree-nonleaf->branches abnf::cst))))
          (abnf::rulename "double-quote-escape")))
   (iff
     (cst-list-list-conc-matchp
          (abnf::tree-nonleaf->branches abnf::cst)
          "backslash-escape")
     (equal
          (abnf::tree-nonleaf->rulename?
               (nth 0
                    (nth 0
                         (abnf::tree-nonleaf->branches abnf::cst))))
          (abnf::rulename "backslash-escape")))
   (iff
     (cst-list-list-conc-matchp
          (abnf::tree-nonleaf->branches abnf::cst)
          "line-feed-escape")
     (equal
          (abnf::tree-nonleaf->rulename?
               (nth 0
                    (nth 0
                         (abnf::tree-nonleaf->branches abnf::cst))))
          (abnf::rulename "line-feed-escape")))
   (iff
     (cst-list-list-conc-matchp
          (abnf::tree-nonleaf->branches abnf::cst)
          "carriage-return-escape")
     (equal
          (abnf::tree-nonleaf->rulename?
               (nth 0
                    (nth 0
                         (abnf::tree-nonleaf->branches abnf::cst))))
          (abnf::rulename "carriage-return-escape")))
   (iff
     (cst-list-list-conc-matchp
          (abnf::tree-nonleaf->branches abnf::cst)
          "horizontal-tab-escape")
     (equal
          (abnf::tree-nonleaf->rulename?
               (nth 0
                    (nth 0
                         (abnf::tree-nonleaf->branches abnf::cst))))
          (abnf::rulename "horizontal-tab-escape")))
   (iff
     (cst-list-list-conc-matchp
          (abnf::tree-nonleaf->branches abnf::cst)
          "null-character-escape")
     (equal
          (abnf::tree-nonleaf->rulename?
               (nth 0
                    (nth 0
                         (abnf::tree-nonleaf->branches abnf::cst))))
          (abnf::rulename "null-character-escape"))))))

Theorem: cst-string-literal-element-conc-equivs

(defthm cst-string-literal-element-conc-equivs
 (implies
  (cst-matchp abnf::cst "string-literal-element")
  (and
   (iff
    (cst-list-list-conc-matchp
     (abnf::tree-nonleaf->branches abnf::cst)
     "not-double-quote-or-backslash-or-line-feed-or-carriage-return")
    (equal
     (abnf::tree-nonleaf->rulename?
          (nth 0
               (nth 0
                    (abnf::tree-nonleaf->branches abnf::cst))))
     (abnf::rulename
      "not-double-quote-or-backslash-or-line-feed-or-carriage-return")))
   (iff
     (cst-list-list-conc-matchp
          (abnf::tree-nonleaf->branches abnf::cst)
          "simple-character-escape")
     (equal
          (abnf::tree-nonleaf->rulename?
               (nth 0
                    (nth 0
                         (abnf::tree-nonleaf->branches abnf::cst))))
          (abnf::rulename "simple-character-escape")))
   (iff
     (cst-list-list-conc-matchp
          (abnf::tree-nonleaf->branches abnf::cst)
          "ascii-character-escape")
     (equal
          (abnf::tree-nonleaf->rulename?
               (nth 0
                    (nth 0
                         (abnf::tree-nonleaf->branches abnf::cst))))
          (abnf::rulename "ascii-character-escape")))
   (iff
     (cst-list-list-conc-matchp
          (abnf::tree-nonleaf->branches abnf::cst)
          "unicode-character-escape")
     (equal
          (abnf::tree-nonleaf->rulename?
               (nth 0
                    (nth 0
                         (abnf::tree-nonleaf->branches abnf::cst))))
          (abnf::rulename "unicode-character-escape"))))))

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)
          "unsigned-literal")
     (equal
          (abnf::tree-nonleaf->rulename?
               (nth 0
                    (nth 0
                         (abnf::tree-nonleaf->branches abnf::cst))))
          (abnf::rulename "unsigned-literal")))
   (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"))))))

Theorem: cst-numeric-literal-conc-equivs

(defthm cst-numeric-literal-conc-equivs
 (implies
  (cst-matchp abnf::cst "numeric-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)
          "product-group-literal")
     (equal
          (abnf::tree-nonleaf->rulename?
               (nth 0
                    (nth 0
                         (abnf::tree-nonleaf->branches abnf::cst))))
          (abnf::rulename "product-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-atomic-literal-conc-equivs

(defthm cst-atomic-literal-conc-equivs
 (implies
  (cst-matchp abnf::cst "atomic-literal")
  (and
   (iff
     (cst-list-list-conc-matchp
          (abnf::tree-nonleaf->branches abnf::cst)
          "numeric-literal")
     (equal
          (abnf::tree-nonleaf->rulename?
               (nth 0
                    (nth 0
                         (abnf::tree-nonleaf->branches abnf::cst))))
          (abnf::rulename "numeric-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)
          "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)
          "string-literal")
     (equal
          (abnf::tree-nonleaf->rulename?
               (nth 0
                    (nth 0
                         (abnf::tree-nonleaf->branches abnf::cst))))
          (abnf::rulename "string-literal"))))))

Theorem: cst-token-conc-equivs

(defthm cst-token-conc-equivs
 (implies
  (cst-matchp abnf::cst "token")
  (and
   (iff
     (cst-list-list-conc-matchp
          (abnf::tree-nonleaf->branches abnf::cst)
          "keyword")
     (equal
          (abnf::tree-nonleaf->rulename?
               (nth 0
                    (nth 0
                         (abnf::tree-nonleaf->branches abnf::cst))))
          (abnf::rulename "keyword")))
   (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")))
   (iff
     (cst-list-list-conc-matchp
          (abnf::tree-nonleaf->branches abnf::cst)
          "atomic-literal")
     (equal
          (abnf::tree-nonleaf->rulename?
               (nth 0
                    (nth 0
                         (abnf::tree-nonleaf->branches abnf::cst))))
          (abnf::rulename "atomic-literal")))
   (iff
     (cst-list-list-conc-matchp
          (abnf::tree-nonleaf->branches abnf::cst)
          "numeral")
     (equal
          (abnf::tree-nonleaf->rulename?
               (nth 0
                    (nth 0
                         (abnf::tree-nonleaf->branches abnf::cst))))
          (abnf::rulename "numeral")))
   (iff
     (cst-list-list-conc-matchp
          (abnf::tree-nonleaf->branches abnf::cst)
          "annotation")
     (equal
          (abnf::tree-nonleaf->rulename?
               (nth 0
                    (nth 0
                         (abnf::tree-nonleaf->branches abnf::cst))))
          (abnf::rulename "annotation")))
   (iff
     (cst-list-list-conc-matchp
          (abnf::tree-nonleaf->branches abnf::cst)
          "symbol")
     (equal
          (abnf::tree-nonleaf->rulename?
               (nth 0
                    (nth 0
                         (abnf::tree-nonleaf->branches abnf::cst))))
          (abnf::rulename "symbol"))))))

Theorem: cst-lexeme-conc-equivs

(defthm cst-lexeme-conc-equivs
 (implies
  (cst-matchp abnf::cst "lexeme")
  (and
   (iff
     (cst-list-list-conc-matchp
          (abnf::tree-nonleaf->branches abnf::cst)
          "token")
     (equal
          (abnf::tree-nonleaf->rulename?
               (nth 0
                    (nth 0
                         (abnf::tree-nonleaf->branches abnf::cst))))
          (abnf::rulename "token")))
   (iff
     (cst-list-list-conc-matchp
          (abnf::tree-nonleaf->branches abnf::cst)
          "comment")
     (equal
          (abnf::tree-nonleaf->rulename?
               (nth 0
                    (nth 0
                         (abnf::tree-nonleaf->branches abnf::cst))))
          (abnf::rulename "comment")))
   (iff
     (cst-list-list-conc-matchp
          (abnf::tree-nonleaf->branches abnf::cst)
          "whitespace")
     (equal
          (abnf::tree-nonleaf->rulename?
               (nth 0
                    (nth 0
                         (abnf::tree-nonleaf->branches abnf::cst))))
          (abnf::rulename "whitespace"))))))

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-named-primitive-type-conc-equivs

(defthm cst-named-primitive-type-conc-equivs
 (implies
  (cst-matchp abnf::cst "named-primitive-type")
  (and
   (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)
          "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)
          "string-type")
     (equal
          (abnf::tree-nonleaf->rulename?
               (nth 0
                    (nth 0
                         (abnf::tree-nonleaf->branches abnf::cst))))
          (abnf::rulename "string-type"))))))

Theorem: cst-primitive-type-conc-equivs

(defthm cst-primitive-type-conc-equivs
 (implies
  (cst-matchp abnf::cst "primitive-type")
  (and
   (iff
     (cst-list-list-conc-matchp
          (abnf::tree-nonleaf->branches abnf::cst)
          "named-primitive-type")
     (equal
          (abnf::tree-nonleaf->rulename?
               (nth 0
                    (nth 0
                         (abnf::tree-nonleaf->branches abnf::cst))))
          (abnf::rulename "named-primitive-type")))
   (iff
     (cst-list-list-conc-matchp
          (abnf::tree-nonleaf->branches abnf::cst)
          "unit-type")
     (equal
          (abnf::tree-nonleaf->rulename?
               (nth 0
                    (nth 0
                         (abnf::tree-nonleaf->branches abnf::cst))))
          (abnf::rulename "unit-type"))))))

Theorem: cst-type-conc-equivs

(defthm cst-type-conc-equivs
 (implies
  (cst-matchp abnf::cst "type")
  (and
   (iff
     (cst-list-list-conc-matchp
          (abnf::tree-nonleaf->branches abnf::cst)
          "named-type")
     (equal
          (abnf::tree-nonleaf->rulename?
               (nth 0
                    (nth 0
                         (abnf::tree-nonleaf->branches abnf::cst))))
          (abnf::rulename "named-type")))
   (iff
     (cst-list-list-conc-matchp
          (abnf::tree-nonleaf->branches abnf::cst)
          "unit-type")
     (equal
          (abnf::tree-nonleaf->rulename?
               (nth 0
                    (nth 0
                         (abnf::tree-nonleaf->branches abnf::cst))))
          (abnf::rulename "unit-type")))
   (iff
     (cst-list-list-conc-matchp
          (abnf::tree-nonleaf->branches abnf::cst)
          "tuple-type")
     (equal
          (abnf::tree-nonleaf->rulename?
               (nth 0
                    (nth 0
                         (abnf::tree-nonleaf->branches abnf::cst))))
          (abnf::rulename "tuple-type"))))))

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)
          "atomic-literal")
     (equal
          (abnf::tree-nonleaf->rulename?
               (nth 0
                    (nth 0
                         (abnf::tree-nonleaf->branches abnf::cst))))
          (abnf::rulename "atomic-literal")))
   (iff
     (cst-list-list-conc-matchp
          (abnf::tree-nonleaf->branches abnf::cst)
          "affine-group-literal")
     (equal
          (abnf::tree-nonleaf->rulename?
               (nth 0
                    (nth 0
                         (abnf::tree-nonleaf->branches abnf::cst))))
          (abnf::rulename "affine-group-literal"))))))

Theorem: cst-group-literal-conc-equivs

(defthm cst-group-literal-conc-equivs
 (implies
  (cst-matchp abnf::cst "group-literal")
  (and
   (iff
     (cst-list-list-conc-matchp
          (abnf::tree-nonleaf->branches abnf::cst)
          "product-group-literal")
     (equal
          (abnf::tree-nonleaf->rulename?
               (nth 0
                    (nth 0
                         (abnf::tree-nonleaf->branches abnf::cst))))
          (abnf::rulename "product-group-literal")))
   (iff
     (cst-list-list-conc-matchp
          (abnf::tree-nonleaf->branches abnf::cst)
          "affine-group-literal")
     (equal
          (abnf::tree-nonleaf->rulename?
               (nth 0
                    (nth 0
                         (abnf::tree-nonleaf->branches abnf::cst))))
          (abnf::rulename "affine-group-literal"))))))

Theorem: cst-postfix-expression-conc-equivs

(defthm cst-postfix-expression-conc-equivs
 (implies
  (cst-matchp abnf::cst "postfix-expression")
  (and
   (iff
     (cst-list-list-conc-matchp
          (abnf::tree-nonleaf->branches abnf::cst)
          "primary-expression")
     (equal
          (abnf::tree-nonleaf->rulename?
               (nth 0
                    (nth 0
                         (abnf::tree-nonleaf->branches abnf::cst))))
          (abnf::rulename "primary-expression")))
   (iff
     (cst-list-list-conc-matchp
          (abnf::tree-nonleaf->branches abnf::cst)
          "tuple-component-expression")
     (equal
          (abnf::tree-nonleaf->rulename?
               (nth 0
                    (nth 0
                         (abnf::tree-nonleaf->branches abnf::cst))))
          (abnf::rulename "tuple-component-expression")))
   (iff
     (cst-list-list-conc-matchp
          (abnf::tree-nonleaf->branches abnf::cst)
          "struct-component-expression")
     (equal
          (abnf::tree-nonleaf->rulename?
               (nth 0
                    (nth 0
                         (abnf::tree-nonleaf->branches abnf::cst))))
          (abnf::rulename "struct-component-expression")))
   (iff
     (cst-list-list-conc-matchp
          (abnf::tree-nonleaf->branches abnf::cst)
          "operator-call")
     (equal
          (abnf::tree-nonleaf->rulename?
               (nth 0
                    (nth 0
                         (abnf::tree-nonleaf->branches abnf::cst))))
          (abnf::rulename "operator-call"))))))

Theorem: cst-operator-call-conc-equivs

(defthm cst-operator-call-conc-equivs
 (implies
  (cst-matchp abnf::cst "operator-call")
  (and
   (iff
     (cst-list-list-conc-matchp
          (abnf::tree-nonleaf->branches abnf::cst)
          "unary-operator-call")
     (equal
          (abnf::tree-nonleaf->rulename?
               (nth 0
                    (nth 0
                         (abnf::tree-nonleaf->branches abnf::cst))))
          (abnf::rulename "unary-operator-call")))
   (iff
     (cst-list-list-conc-matchp
          (abnf::tree-nonleaf->branches abnf::cst)
          "binary-operator-call")
     (equal
          (abnf::tree-nonleaf->rulename?
               (nth 0
                    (nth 0
                         (abnf::tree-nonleaf->branches abnf::cst))))
          (abnf::rulename "binary-operator-call"))))))

Theorem: cst-statement-conc-equivs

(defthm cst-statement-conc-equivs
 (implies
  (cst-matchp abnf::cst "statement")
  (and
   (iff
     (cst-list-list-conc-matchp
          (abnf::tree-nonleaf->branches abnf::cst)
          "return-statement")
     (equal
          (abnf::tree-nonleaf->rulename?
               (nth 0
                    (nth 0
                         (abnf::tree-nonleaf->branches abnf::cst))))
          (abnf::rulename "return-statement")))
   (iff
     (cst-list-list-conc-matchp
          (abnf::tree-nonleaf->branches abnf::cst)
          "variable-declaration")
     (equal
          (abnf::tree-nonleaf->rulename?
               (nth 0
                    (nth 0
                         (abnf::tree-nonleaf->branches abnf::cst))))
          (abnf::rulename "variable-declaration")))
   (iff
     (cst-list-list-conc-matchp
          (abnf::tree-nonleaf->branches abnf::cst)
          "constant-declaration")
     (equal
          (abnf::tree-nonleaf->rulename?
               (nth 0
                    (nth 0
                         (abnf::tree-nonleaf->branches abnf::cst))))
          (abnf::rulename "constant-declaration")))
   (iff
     (cst-list-list-conc-matchp
          (abnf::tree-nonleaf->branches abnf::cst)
          "conditional-statement")
     (equal
          (abnf::tree-nonleaf->rulename?
               (nth 0
                    (nth 0
                         (abnf::tree-nonleaf->branches abnf::cst))))
          (abnf::rulename "conditional-statement")))
   (iff
     (cst-list-list-conc-matchp
          (abnf::tree-nonleaf->branches abnf::cst)
          "loop-statement")
     (equal
          (abnf::tree-nonleaf->rulename?
               (nth 0
                    (nth 0
                         (abnf::tree-nonleaf->branches abnf::cst))))
          (abnf::rulename "loop-statement")))
   (iff
     (cst-list-list-conc-matchp
          (abnf::tree-nonleaf->branches abnf::cst)
          "assignment-statement")
     (equal
          (abnf::tree-nonleaf->rulename?
               (nth 0
                    (nth 0
                         (abnf::tree-nonleaf->branches abnf::cst))))
          (abnf::rulename "assignment-statement")))
   (iff
     (cst-list-list-conc-matchp
          (abnf::tree-nonleaf->branches abnf::cst)
          "console-statement")
     (equal
          (abnf::tree-nonleaf->rulename?
               (nth 0
                    (nth 0
                         (abnf::tree-nonleaf->branches abnf::cst))))
          (abnf::rulename "console-statement")))
   (iff
     (cst-list-list-conc-matchp
          (abnf::tree-nonleaf->branches abnf::cst)
          "finalize-statement")
     (equal
          (abnf::tree-nonleaf->rulename?
               (nth 0
                    (nth 0
                         (abnf::tree-nonleaf->branches abnf::cst))))
          (abnf::rulename "finalize-statement")))
   (iff
     (cst-list-list-conc-matchp
          (abnf::tree-nonleaf->branches abnf::cst)
          "increment-statement")
     (equal
          (abnf::tree-nonleaf->rulename?
               (nth 0
                    (nth 0
                         (abnf::tree-nonleaf->branches abnf::cst))))
          (abnf::rulename "increment-statement")))
   (iff
     (cst-list-list-conc-matchp
          (abnf::tree-nonleaf->branches abnf::cst)
          "decrement-statement")
     (equal
          (abnf::tree-nonleaf->rulename?
               (nth 0
                    (nth 0
                         (abnf::tree-nonleaf->branches abnf::cst))))
          (abnf::rulename "decrement-statement")))
   (iff
     (cst-list-list-conc-matchp
          (abnf::tree-nonleaf->branches abnf::cst)
          "block")
     (equal
          (abnf::tree-nonleaf->rulename?
               (nth 0
                    (nth 0
                         (abnf::tree-nonleaf->branches abnf::cst))))
          (abnf::rulename "block"))))))

Theorem: cst-console-call-conc-equivs

(defthm cst-console-call-conc-equivs
 (implies
  (cst-matchp abnf::cst "console-call")
  (and
   (iff
     (cst-list-list-conc-matchp
          (abnf::tree-nonleaf->branches abnf::cst)
          "assert-call")
     (equal
          (abnf::tree-nonleaf->rulename?
               (nth 0
                    (nth 0
                         (abnf::tree-nonleaf->branches abnf::cst))))
          (abnf::rulename "assert-call")))
   (iff
     (cst-list-list-conc-matchp
          (abnf::tree-nonleaf->branches abnf::cst)
          "assert-equal-call")
     (equal
          (abnf::tree-nonleaf->rulename?
               (nth 0
                    (nth 0
                         (abnf::tree-nonleaf->branches abnf::cst))))
          (abnf::rulename "assert-equal-call")))
   (iff
     (cst-list-list-conc-matchp
          (abnf::tree-nonleaf->branches abnf::cst)
          "assert-not-equal-call")
     (equal
          (abnf::tree-nonleaf->rulename?
               (nth 0
                    (nth 0
                         (abnf::tree-nonleaf->branches abnf::cst))))
          (abnf::rulename "assert-not-equal-call"))))))

Theorem: cst-program-item-conc-equivs

(defthm cst-program-item-conc-equivs
 (implies
  (cst-matchp abnf::cst "program-item")
  (and
   (iff
     (cst-list-list-conc-matchp
          (abnf::tree-nonleaf->branches abnf::cst)
          "function-declaration")
     (equal
          (abnf::tree-nonleaf->rulename?
               (nth 0
                    (nth 0
                         (abnf::tree-nonleaf->branches abnf::cst))))
          (abnf::rulename "function-declaration")))
   (iff
     (cst-list-list-conc-matchp
          (abnf::tree-nonleaf->branches abnf::cst)
          "transition-declaration")
     (equal
          (abnf::tree-nonleaf->rulename?
               (nth 0
                    (nth 0
                         (abnf::tree-nonleaf->branches abnf::cst))))
          (abnf::rulename "transition-declaration")))
   (iff
     (cst-list-list-conc-matchp
          (abnf::tree-nonleaf->branches abnf::cst)
          "struct-declaration")
     (equal
          (abnf::tree-nonleaf->rulename?
               (nth 0
                    (nth 0
                         (abnf::tree-nonleaf->branches abnf::cst))))
          (abnf::rulename "struct-declaration")))
   (iff
     (cst-list-list-conc-matchp
          (abnf::tree-nonleaf->branches abnf::cst)
          "record-declaration")
     (equal
          (abnf::tree-nonleaf->rulename?
               (nth 0
                    (nth 0
                         (abnf::tree-nonleaf->branches abnf::cst))))
          (abnf::rulename "record-declaration")))
   (iff
     (cst-list-list-conc-matchp
          (abnf::tree-nonleaf->branches abnf::cst)
          "mapping-declaration")
     (equal
          (abnf::tree-nonleaf->rulename?
               (nth 0
                    (nth 0
                         (abnf::tree-nonleaf->branches abnf::cst))))
          (abnf::rulename "mapping-declaration"))))))

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 "horizontal-tab"))
     1)
    ((equal
          (abnf::tree-nonleaf->rulename?
               (nth 0
                    (nth 0
                         (abnf::tree-nonleaf->branches abnf::cst))))
          (abnf::rulename "line-feed"))
     2)
    ((equal
          (abnf::tree-nonleaf->rulename?
               (nth 0
                    (nth 0
                         (abnf::tree-nonleaf->branches abnf::cst))))
          (abnf::rulename "carriage-return"))
     3)
    ((equal
          (abnf::tree-nonleaf->rulename?
               (nth 0
                    (nth 0
                         (abnf::tree-nonleaf->branches abnf::cst))))
          (abnf::rulename "space"))
     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)
                     "horizontal-tab"))))

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)
                     "line-feed"))))

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)
                     "carriage-return"))))

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)
                     "space"))))

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-whitespace-conc?

(defun cst-whitespace-conc? (abnf::cst)
 (declare (xargs :guard (abnf::treep abnf::cst)))
 (declare (xargs :guard (cst-matchp abnf::cst "whitespace")))
 (let ((__function__ 'cst-whitespace-conc?))
  (declare (ignorable __function__))
  (cond
    ((equal
          (abnf::tree-nonleaf->rulename?
               (nth 0
                    (nth 0
                         (abnf::tree-nonleaf->branches abnf::cst))))
          (abnf::rulename "space"))
     1)
    ((equal
          (abnf::tree-nonleaf->rulename?
               (nth 0
                    (nth 0
                         (abnf::tree-nonleaf->branches abnf::cst))))
          (abnf::rulename "horizontal-tab"))
     2)
    ((equal
          (abnf::tree-nonleaf->rulename?
               (nth 0
                    (nth 0
                         (abnf::tree-nonleaf->branches abnf::cst))))
          (abnf::rulename "line-terminator"))
     3)
    (t (prog2$ (impossible) 1)))))

Theorem: posp-of-cst-whitespace-conc?

(defthm posp-of-cst-whitespace-conc?
  (b* ((number (cst-whitespace-conc? abnf::cst)))
    (posp number))
  :rule-classes :rewrite)

Theorem: cst-whitespace-conc?-possibilities

(defthm cst-whitespace-conc?-possibilities
  (b* ((number (cst-whitespace-conc? abnf::cst)))
    (or (equal number 1)
        (equal number 2)
        (equal number 3)))
  :rule-classes
  ((:forward-chaining
        :trigger-terms ((cst-whitespace-conc? abnf::cst)))))

Theorem: cst-whitespace-conc?-of-tree-fix-cst

(defthm cst-whitespace-conc?-of-tree-fix-cst
  (equal (cst-whitespace-conc? (abnf::tree-fix abnf::cst))
         (cst-whitespace-conc? abnf::cst)))

Theorem: cst-whitespace-conc?-tree-equiv-congruence-on-cst

(defthm cst-whitespace-conc?-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-whitespace-conc? abnf::cst)
                  (cst-whitespace-conc? cst-equiv)))
  :rule-classes :congruence)

Theorem: cst-whitespace-conc?-1-iff-match-conc

(defthm cst-whitespace-conc?-1-iff-match-conc
  (implies (cst-matchp abnf::cst "whitespace")
           (iff (equal (cst-whitespace-conc? abnf::cst)
                       1)
                (cst-list-list-conc-matchp
                     (abnf::tree-nonleaf->branches abnf::cst)
                     "space"))))

Theorem: cst-whitespace-conc?-2-iff-match-conc

(defthm cst-whitespace-conc?-2-iff-match-conc
  (implies (cst-matchp abnf::cst "whitespace")
           (iff (equal (cst-whitespace-conc? abnf::cst)
                       2)
                (cst-list-list-conc-matchp
                     (abnf::tree-nonleaf->branches abnf::cst)
                     "horizontal-tab"))))

Theorem: cst-whitespace-conc?-3-iff-match-conc

(defthm cst-whitespace-conc?-3-iff-match-conc
  (implies (cst-matchp abnf::cst "whitespace")
           (iff (equal (cst-whitespace-conc? abnf::cst)
                       3)
                (cst-list-list-conc-matchp
                     (abnf::tree-nonleaf->branches abnf::cst)
                     "line-terminator"))))

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 "block-comment"))
     1)
    ((equal
          (abnf::tree-nonleaf->rulename?
               (nth 0
                    (nth 0
                         (abnf::tree-nonleaf->branches abnf::cst))))
          (abnf::rulename "line-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)
                     "block-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)
                     "line-comment"))))

Function: cst-not-line-feed-or-carriage-return-conc?

(defun cst-not-line-feed-or-carriage-return-conc? (abnf::cst)
 (declare (xargs :guard (abnf::treep abnf::cst)))
 (declare
     (xargs :guard (cst-matchp abnf::cst
                               "not-line-feed-or-carriage-return")))
 (let ((__function__ 'cst-not-line-feed-or-carriage-return-conc?))
  (declare (ignorable __function__))
  (cond
    ((equal
          (abnf::tree-nonleaf->rulename?
               (nth 0
                    (nth 0
                         (abnf::tree-nonleaf->branches abnf::cst))))
          (abnf::rulename "horizontal-tab"))
     1)
    ((equal
          (abnf::tree-nonleaf->rulename?
               (nth 0
                    (nth 0
                         (abnf::tree-nonleaf->branches abnf::cst))))
          (abnf::rulename "space"))
     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-line-feed-or-carriage-return-conc?

(defthm posp-of-cst-not-line-feed-or-carriage-return-conc?
  (b*
   ((number (cst-not-line-feed-or-carriage-return-conc? abnf::cst)))
   (posp number))
  :rule-classes :rewrite)

Theorem: cst-not-line-feed-or-carriage-return-conc?-possibilities

(defthm cst-not-line-feed-or-carriage-return-conc?-possibilities
  (b*
   ((number (cst-not-line-feed-or-carriage-return-conc? abnf::cst)))
   (or (equal number 1)
       (equal number 2)
       (equal number 3)
       (equal number 4)))
  :rule-classes
  ((:forward-chaining
        :trigger-terms
        ((cst-not-line-feed-or-carriage-return-conc? abnf::cst)))))

Theorem: cst-not-line-feed-or-carriage-return-conc?-of-tree-fix-cst

(defthm cst-not-line-feed-or-carriage-return-conc?-of-tree-fix-cst
  (equal (cst-not-line-feed-or-carriage-return-conc?
              (abnf::tree-fix abnf::cst))
         (cst-not-line-feed-or-carriage-return-conc? abnf::cst)))

Theorem: cst-not-line-feed-or-carriage-return-conc?-tree-equiv-congruence-on-cst

(defthm
 cst-not-line-feed-or-carriage-return-conc?-tree-equiv-congruence-on-cst
 (implies
     (abnf::tree-equiv abnf::cst cst-equiv)
     (equal (cst-not-line-feed-or-carriage-return-conc? abnf::cst)
            (cst-not-line-feed-or-carriage-return-conc? cst-equiv)))
 :rule-classes :congruence)

Theorem: cst-not-line-feed-or-carriage-return-conc?-1-iff-match-conc

(defthm cst-not-line-feed-or-carriage-return-conc?-1-iff-match-conc
 (implies
  (cst-matchp abnf::cst
              "not-line-feed-or-carriage-return")
  (iff (equal (cst-not-line-feed-or-carriage-return-conc? abnf::cst)
              1)
       (cst-list-list-conc-matchp
            (abnf::tree-nonleaf->branches abnf::cst)
            "horizontal-tab"))))

Theorem: cst-not-line-feed-or-carriage-return-conc?-2-iff-match-conc

(defthm cst-not-line-feed-or-carriage-return-conc?-2-iff-match-conc
 (implies
  (cst-matchp abnf::cst
              "not-line-feed-or-carriage-return")
  (iff (equal (cst-not-line-feed-or-carriage-return-conc? abnf::cst)
              2)
       (cst-list-list-conc-matchp
            (abnf::tree-nonleaf->branches abnf::cst)
            "space"))))

Theorem: cst-not-line-feed-or-carriage-return-conc?-3-iff-match-conc

(defthm cst-not-line-feed-or-carriage-return-conc?-3-iff-match-conc
 (implies
  (cst-matchp abnf::cst
              "not-line-feed-or-carriage-return")
  (iff (equal (cst-not-line-feed-or-carriage-return-conc? abnf::cst)
              3)
       (cst-list-list-conc-matchp
            (abnf::tree-nonleaf->branches abnf::cst)
            "visible-ascii"))))

Theorem: cst-not-line-feed-or-carriage-return-conc?-4-iff-match-conc

(defthm cst-not-line-feed-or-carriage-return-conc?-4-iff-match-conc
 (implies
  (cst-matchp abnf::cst
              "not-line-feed-or-carriage-return")
  (iff (equal (cst-not-line-feed-or-carriage-return-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-simple-character-escape-conc?

(defun cst-simple-character-escape-conc? (abnf::cst)
 (declare (xargs :guard (abnf::treep abnf::cst)))
 (declare
    (xargs :guard (cst-matchp abnf::cst "simple-character-escape")))
 (let ((__function__ 'cst-simple-character-escape-conc?))
  (declare (ignorable __function__))
  (cond
    ((equal
          (abnf::tree-nonleaf->rulename?
               (nth 0
                    (nth 0
                         (abnf::tree-nonleaf->branches abnf::cst))))
          (abnf::rulename "single-quote-escape"))
     1)
    ((equal
          (abnf::tree-nonleaf->rulename?
               (nth 0
                    (nth 0
                         (abnf::tree-nonleaf->branches abnf::cst))))
          (abnf::rulename "double-quote-escape"))
     2)
    ((equal
          (abnf::tree-nonleaf->rulename?
               (nth 0
                    (nth 0
                         (abnf::tree-nonleaf->branches abnf::cst))))
          (abnf::rulename "backslash-escape"))
     3)
    ((equal
          (abnf::tree-nonleaf->rulename?
               (nth 0
                    (nth 0
                         (abnf::tree-nonleaf->branches abnf::cst))))
          (abnf::rulename "line-feed-escape"))
     4)
    ((equal
          (abnf::tree-nonleaf->rulename?
               (nth 0
                    (nth 0
                         (abnf::tree-nonleaf->branches abnf::cst))))
          (abnf::rulename "carriage-return-escape"))
     5)
    ((equal
          (abnf::tree-nonleaf->rulename?
               (nth 0
                    (nth 0
                         (abnf::tree-nonleaf->branches abnf::cst))))
          (abnf::rulename "horizontal-tab-escape"))
     6)
    ((equal
          (abnf::tree-nonleaf->rulename?
               (nth 0
                    (nth 0
                         (abnf::tree-nonleaf->branches abnf::cst))))
          (abnf::rulename "null-character-escape"))
     7)
    (t (prog2$ (impossible) 1)))))

Theorem: posp-of-cst-simple-character-escape-conc?

(defthm posp-of-cst-simple-character-escape-conc?
  (b* ((number (cst-simple-character-escape-conc? abnf::cst)))
    (posp number))
  :rule-classes :rewrite)

Theorem: cst-simple-character-escape-conc?-possibilities

(defthm cst-simple-character-escape-conc?-possibilities
 (b* ((number (cst-simple-character-escape-conc? abnf::cst)))
   (or (equal number 1)
       (equal number 2)
       (equal number 3)
       (equal number 4)
       (equal number 5)
       (equal number 6)
       (equal number 7)))
 :rule-classes
 ((:forward-chaining
   :trigger-terms ((cst-simple-character-escape-conc? abnf::cst)))))

Theorem: cst-simple-character-escape-conc?-of-tree-fix-cst

(defthm cst-simple-character-escape-conc?-of-tree-fix-cst
 (equal
      (cst-simple-character-escape-conc? (abnf::tree-fix abnf::cst))
      (cst-simple-character-escape-conc? abnf::cst)))

Theorem: cst-simple-character-escape-conc?-tree-equiv-congruence-on-cst

(defthm
     cst-simple-character-escape-conc?-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-simple-character-escape-conc? abnf::cst)
                  (cst-simple-character-escape-conc? cst-equiv)))
  :rule-classes :congruence)

Theorem: cst-simple-character-escape-conc?-1-iff-match-conc

(defthm cst-simple-character-escape-conc?-1-iff-match-conc
  (implies (cst-matchp abnf::cst "simple-character-escape")
           (iff (equal (cst-simple-character-escape-conc? abnf::cst)
                       1)
                (cst-list-list-conc-matchp
                     (abnf::tree-nonleaf->branches abnf::cst)
                     "single-quote-escape"))))

Theorem: cst-simple-character-escape-conc?-2-iff-match-conc

(defthm cst-simple-character-escape-conc?-2-iff-match-conc
  (implies (cst-matchp abnf::cst "simple-character-escape")
           (iff (equal (cst-simple-character-escape-conc? abnf::cst)
                       2)
                (cst-list-list-conc-matchp
                     (abnf::tree-nonleaf->branches abnf::cst)
                     "double-quote-escape"))))

Theorem: cst-simple-character-escape-conc?-3-iff-match-conc

(defthm cst-simple-character-escape-conc?-3-iff-match-conc
  (implies (cst-matchp abnf::cst "simple-character-escape")
           (iff (equal (cst-simple-character-escape-conc? abnf::cst)
                       3)
                (cst-list-list-conc-matchp
                     (abnf::tree-nonleaf->branches abnf::cst)
                     "backslash-escape"))))

Theorem: cst-simple-character-escape-conc?-4-iff-match-conc

(defthm cst-simple-character-escape-conc?-4-iff-match-conc
  (implies (cst-matchp abnf::cst "simple-character-escape")
           (iff (equal (cst-simple-character-escape-conc? abnf::cst)
                       4)
                (cst-list-list-conc-matchp
                     (abnf::tree-nonleaf->branches abnf::cst)
                     "line-feed-escape"))))

Theorem: cst-simple-character-escape-conc?-5-iff-match-conc

(defthm cst-simple-character-escape-conc?-5-iff-match-conc
  (implies (cst-matchp abnf::cst "simple-character-escape")
           (iff (equal (cst-simple-character-escape-conc? abnf::cst)
                       5)
                (cst-list-list-conc-matchp
                     (abnf::tree-nonleaf->branches abnf::cst)
                     "carriage-return-escape"))))

Theorem: cst-simple-character-escape-conc?-6-iff-match-conc

(defthm cst-simple-character-escape-conc?-6-iff-match-conc
  (implies (cst-matchp abnf::cst "simple-character-escape")
           (iff (equal (cst-simple-character-escape-conc? abnf::cst)
                       6)
                (cst-list-list-conc-matchp
                     (abnf::tree-nonleaf->branches abnf::cst)
                     "horizontal-tab-escape"))))

Theorem: cst-simple-character-escape-conc?-7-iff-match-conc

(defthm cst-simple-character-escape-conc?-7-iff-match-conc
  (implies (cst-matchp abnf::cst "simple-character-escape")
           (iff (equal (cst-simple-character-escape-conc? abnf::cst)
                       7)
                (cst-list-list-conc-matchp
                     (abnf::tree-nonleaf->branches abnf::cst)
                     "null-character-escape"))))

Function: cst-string-literal-element-conc?

(defun cst-string-literal-element-conc? (abnf::cst)
 (declare (xargs :guard (abnf::treep abnf::cst)))
 (declare
     (xargs :guard (cst-matchp abnf::cst "string-literal-element")))
 (let ((__function__ 'cst-string-literal-element-conc?))
  (declare (ignorable __function__))
  (cond
   ((equal
     (abnf::tree-nonleaf->rulename?
          (nth 0
               (nth 0
                    (abnf::tree-nonleaf->branches abnf::cst))))
     (abnf::rulename
      "not-double-quote-or-backslash-or-line-feed-or-carriage-return"))
    1)
   ((equal
         (abnf::tree-nonleaf->rulename?
              (nth 0
                   (nth 0
                        (abnf::tree-nonleaf->branches abnf::cst))))
         (abnf::rulename "simple-character-escape"))
    2)
   ((equal
         (abnf::tree-nonleaf->rulename?
              (nth 0
                   (nth 0
                        (abnf::tree-nonleaf->branches abnf::cst))))
         (abnf::rulename "ascii-character-escape"))
    3)
   ((equal
         (abnf::tree-nonleaf->rulename?
              (nth 0
                   (nth 0
                        (abnf::tree-nonleaf->branches abnf::cst))))
         (abnf::rulename "unicode-character-escape"))
    4)
   (t (prog2$ (impossible) 1)))))

Theorem: posp-of-cst-string-literal-element-conc?

(defthm posp-of-cst-string-literal-element-conc?
  (b* ((number (cst-string-literal-element-conc? abnf::cst)))
    (posp number))
  :rule-classes :rewrite)

Theorem: cst-string-literal-element-conc?-possibilities

(defthm cst-string-literal-element-conc?-possibilities
 (b* ((number (cst-string-literal-element-conc? abnf::cst)))
   (or (equal number 1)
       (equal number 2)
       (equal number 3)
       (equal number 4)))
 :rule-classes
 ((:forward-chaining
    :trigger-terms ((cst-string-literal-element-conc? abnf::cst)))))

Theorem: cst-string-literal-element-conc?-of-tree-fix-cst

(defthm cst-string-literal-element-conc?-of-tree-fix-cst
  (equal
       (cst-string-literal-element-conc? (abnf::tree-fix abnf::cst))
       (cst-string-literal-element-conc? abnf::cst)))

Theorem: cst-string-literal-element-conc?-tree-equiv-congruence-on-cst

(defthm
      cst-string-literal-element-conc?-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-string-literal-element-conc? abnf::cst)
                  (cst-string-literal-element-conc? cst-equiv)))
  :rule-classes :congruence)

Theorem: cst-string-literal-element-conc?-1-iff-match-conc

(defthm cst-string-literal-element-conc?-1-iff-match-conc
 (implies
  (cst-matchp abnf::cst "string-literal-element")
  (iff
   (equal (cst-string-literal-element-conc? abnf::cst)
          1)
   (cst-list-list-conc-matchp
    (abnf::tree-nonleaf->branches abnf::cst)
    "not-double-quote-or-backslash-or-line-feed-or-carriage-return"))))

Theorem: cst-string-literal-element-conc?-2-iff-match-conc

(defthm cst-string-literal-element-conc?-2-iff-match-conc
  (implies (cst-matchp abnf::cst "string-literal-element")
           (iff (equal (cst-string-literal-element-conc? abnf::cst)
                       2)
                (cst-list-list-conc-matchp
                     (abnf::tree-nonleaf->branches abnf::cst)
                     "simple-character-escape"))))

Theorem: cst-string-literal-element-conc?-3-iff-match-conc

(defthm cst-string-literal-element-conc?-3-iff-match-conc
  (implies (cst-matchp abnf::cst "string-literal-element")
           (iff (equal (cst-string-literal-element-conc? abnf::cst)
                       3)
                (cst-list-list-conc-matchp
                     (abnf::tree-nonleaf->branches abnf::cst)
                     "ascii-character-escape"))))

Theorem: cst-string-literal-element-conc?-4-iff-match-conc

(defthm cst-string-literal-element-conc?-4-iff-match-conc
  (implies (cst-matchp abnf::cst "string-literal-element")
           (iff (equal (cst-string-literal-element-conc? abnf::cst)
                       4)
                (cst-list-list-conc-matchp
                     (abnf::tree-nonleaf->branches abnf::cst)
                     "unicode-character-escape"))))

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 "unsigned-literal"))
     1)
    ((equal
          (abnf::tree-nonleaf->rulename?
               (nth 0
                    (nth 0
                         (abnf::tree-nonleaf->branches abnf::cst))))
          (abnf::rulename "signed-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)
                     "unsigned-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)
                     "signed-literal"))))

Function: cst-numeric-literal-conc?

(defun cst-numeric-literal-conc? (abnf::cst)
 (declare (xargs :guard (abnf::treep abnf::cst)))
 (declare (xargs :guard (cst-matchp abnf::cst "numeric-literal")))
 (let ((__function__ 'cst-numeric-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 "product-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-numeric-literal-conc?

(defthm posp-of-cst-numeric-literal-conc?
  (b* ((number (cst-numeric-literal-conc? abnf::cst)))
    (posp number))
  :rule-classes :rewrite)

Theorem: cst-numeric-literal-conc?-possibilities

(defthm cst-numeric-literal-conc?-possibilities
  (b* ((number (cst-numeric-literal-conc? abnf::cst)))
    (or (equal number 1)
        (equal number 2)
        (equal number 3)
        (equal number 4)))
  :rule-classes
  ((:forward-chaining
        :trigger-terms ((cst-numeric-literal-conc? abnf::cst)))))

Theorem: cst-numeric-literal-conc?-of-tree-fix-cst

(defthm cst-numeric-literal-conc?-of-tree-fix-cst
  (equal (cst-numeric-literal-conc? (abnf::tree-fix abnf::cst))
         (cst-numeric-literal-conc? abnf::cst)))

Theorem: cst-numeric-literal-conc?-tree-equiv-congruence-on-cst

(defthm cst-numeric-literal-conc?-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-numeric-literal-conc? abnf::cst)
                  (cst-numeric-literal-conc? cst-equiv)))
  :rule-classes :congruence)

Theorem: cst-numeric-literal-conc?-1-iff-match-conc

(defthm cst-numeric-literal-conc?-1-iff-match-conc
  (implies (cst-matchp abnf::cst "numeric-literal")
           (iff (equal (cst-numeric-literal-conc? abnf::cst)
                       1)
                (cst-list-list-conc-matchp
                     (abnf::tree-nonleaf->branches abnf::cst)
                     "integer-literal"))))

Theorem: cst-numeric-literal-conc?-2-iff-match-conc

(defthm cst-numeric-literal-conc?-2-iff-match-conc
  (implies (cst-matchp abnf::cst "numeric-literal")
           (iff (equal (cst-numeric-literal-conc? abnf::cst)
                       2)
                (cst-list-list-conc-matchp
                     (abnf::tree-nonleaf->branches abnf::cst)
                     "field-literal"))))

Theorem: cst-numeric-literal-conc?-3-iff-match-conc

(defthm cst-numeric-literal-conc?-3-iff-match-conc
  (implies (cst-matchp abnf::cst "numeric-literal")
           (iff (equal (cst-numeric-literal-conc? abnf::cst)
                       3)
                (cst-list-list-conc-matchp
                     (abnf::tree-nonleaf->branches abnf::cst)
                     "product-group-literal"))))

Theorem: cst-numeric-literal-conc?-4-iff-match-conc

(defthm cst-numeric-literal-conc?-4-iff-match-conc
  (implies (cst-matchp abnf::cst "numeric-literal")
           (iff (equal (cst-numeric-literal-conc? abnf::cst)
                       4)
                (cst-list-list-conc-matchp
                     (abnf::tree-nonleaf->branches abnf::cst)
                     "scalar-literal"))))

Function: cst-atomic-literal-conc?

(defun cst-atomic-literal-conc? (abnf::cst)
 (declare (xargs :guard (abnf::treep abnf::cst)))
 (declare (xargs :guard (cst-matchp abnf::cst "atomic-literal")))
 (let ((__function__ 'cst-atomic-literal-conc?))
  (declare (ignorable __function__))
  (cond
    ((equal
          (abnf::tree-nonleaf->rulename?
               (nth 0
                    (nth 0
                         (abnf::tree-nonleaf->branches abnf::cst))))
          (abnf::rulename "numeric-literal"))
     1)
    ((equal
          (abnf::tree-nonleaf->rulename?
               (nth 0
                    (nth 0
                         (abnf::tree-nonleaf->branches abnf::cst))))
          (abnf::rulename "boolean-literal"))
     2)
    ((equal
          (abnf::tree-nonleaf->rulename?
               (nth 0
                    (nth 0
                         (abnf::tree-nonleaf->branches abnf::cst))))
          (abnf::rulename "address-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-atomic-literal-conc?

(defthm posp-of-cst-atomic-literal-conc?
  (b* ((number (cst-atomic-literal-conc? abnf::cst)))
    (posp number))
  :rule-classes :rewrite)

Theorem: cst-atomic-literal-conc?-possibilities

(defthm cst-atomic-literal-conc?-possibilities
  (b* ((number (cst-atomic-literal-conc? abnf::cst)))
    (or (equal number 1)
        (equal number 2)
        (equal number 3)
        (equal number 4)))
  :rule-classes
  ((:forward-chaining
        :trigger-terms ((cst-atomic-literal-conc? abnf::cst)))))

Theorem: cst-atomic-literal-conc?-of-tree-fix-cst

(defthm cst-atomic-literal-conc?-of-tree-fix-cst
  (equal (cst-atomic-literal-conc? (abnf::tree-fix abnf::cst))
         (cst-atomic-literal-conc? abnf::cst)))

Theorem: cst-atomic-literal-conc?-tree-equiv-congruence-on-cst

(defthm cst-atomic-literal-conc?-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-atomic-literal-conc? abnf::cst)
                  (cst-atomic-literal-conc? cst-equiv)))
  :rule-classes :congruence)

Theorem: cst-atomic-literal-conc?-1-iff-match-conc

(defthm cst-atomic-literal-conc?-1-iff-match-conc
  (implies (cst-matchp abnf::cst "atomic-literal")
           (iff (equal (cst-atomic-literal-conc? abnf::cst)
                       1)
                (cst-list-list-conc-matchp
                     (abnf::tree-nonleaf->branches abnf::cst)
                     "numeric-literal"))))

Theorem: cst-atomic-literal-conc?-2-iff-match-conc

(defthm cst-atomic-literal-conc?-2-iff-match-conc
  (implies (cst-matchp abnf::cst "atomic-literal")
           (iff (equal (cst-atomic-literal-conc? abnf::cst)
                       2)
                (cst-list-list-conc-matchp
                     (abnf::tree-nonleaf->branches abnf::cst)
                     "boolean-literal"))))

Theorem: cst-atomic-literal-conc?-3-iff-match-conc

(defthm cst-atomic-literal-conc?-3-iff-match-conc
  (implies (cst-matchp abnf::cst "atomic-literal")
           (iff (equal (cst-atomic-literal-conc? abnf::cst)
                       3)
                (cst-list-list-conc-matchp
                     (abnf::tree-nonleaf->branches abnf::cst)
                     "address-literal"))))

Theorem: cst-atomic-literal-conc?-4-iff-match-conc

(defthm cst-atomic-literal-conc?-4-iff-match-conc
  (implies (cst-matchp abnf::cst "atomic-literal")
           (iff (equal (cst-atomic-literal-conc? abnf::cst)
                       4)
                (cst-list-list-conc-matchp
                     (abnf::tree-nonleaf->branches abnf::cst)
                     "string-literal"))))

Function: cst-token-conc?

(defun cst-token-conc? (abnf::cst)
 (declare (xargs :guard (abnf::treep abnf::cst)))
 (declare (xargs :guard (cst-matchp abnf::cst "token")))
 (let ((__function__ 'cst-token-conc?))
  (declare (ignorable __function__))
  (cond
    ((equal
          (abnf::tree-nonleaf->rulename?
               (nth 0
                    (nth 0
                         (abnf::tree-nonleaf->branches abnf::cst))))
          (abnf::rulename "keyword"))
     1)
    ((equal
          (abnf::tree-nonleaf->rulename?
               (nth 0
                    (nth 0
                         (abnf::tree-nonleaf->branches abnf::cst))))
          (abnf::rulename "identifier"))
     2)
    ((equal
          (abnf::tree-nonleaf->rulename?
               (nth 0
                    (nth 0
                         (abnf::tree-nonleaf->branches abnf::cst))))
          (abnf::rulename "atomic-literal"))
     3)
    ((equal
          (abnf::tree-nonleaf->rulename?
               (nth 0
                    (nth 0
                         (abnf::tree-nonleaf->branches abnf::cst))))
          (abnf::rulename "numeral"))
     4)
    ((equal
          (abnf::tree-nonleaf->rulename?
               (nth 0
                    (nth 0
                         (abnf::tree-nonleaf->branches abnf::cst))))
          (abnf::rulename "annotation"))
     5)
    ((equal
          (abnf::tree-nonleaf->rulename?
               (nth 0
                    (nth 0
                         (abnf::tree-nonleaf->branches abnf::cst))))
          (abnf::rulename "symbol"))
     6)
    (t (prog2$ (impossible) 1)))))

Theorem: posp-of-cst-token-conc?

(defthm posp-of-cst-token-conc?
  (b* ((number (cst-token-conc? abnf::cst)))
    (posp number))
  :rule-classes :rewrite)

Theorem: cst-token-conc?-possibilities

(defthm cst-token-conc?-possibilities
 (b* ((number (cst-token-conc? abnf::cst)))
   (or (equal number 1)
       (equal number 2)
       (equal number 3)
       (equal number 4)
       (equal number 5)
       (equal number 6)))
 :rule-classes
 ((:forward-chaining :trigger-terms ((cst-token-conc? abnf::cst)))))

Theorem: cst-token-conc?-of-tree-fix-cst

(defthm cst-token-conc?-of-tree-fix-cst
  (equal (cst-token-conc? (abnf::tree-fix abnf::cst))
         (cst-token-conc? abnf::cst)))

Theorem: cst-token-conc?-tree-equiv-congruence-on-cst

(defthm cst-token-conc?-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-token-conc? abnf::cst)
                  (cst-token-conc? cst-equiv)))
  :rule-classes :congruence)

Theorem: cst-token-conc?-1-iff-match-conc

(defthm cst-token-conc?-1-iff-match-conc
  (implies (cst-matchp abnf::cst "token")
           (iff (equal (cst-token-conc? abnf::cst) 1)
                (cst-list-list-conc-matchp
                     (abnf::tree-nonleaf->branches abnf::cst)
                     "keyword"))))

Theorem: cst-token-conc?-2-iff-match-conc

(defthm cst-token-conc?-2-iff-match-conc
  (implies (cst-matchp abnf::cst "token")
           (iff (equal (cst-token-conc? abnf::cst) 2)
                (cst-list-list-conc-matchp
                     (abnf::tree-nonleaf->branches abnf::cst)
                     "identifier"))))

Theorem: cst-token-conc?-3-iff-match-conc

(defthm cst-token-conc?-3-iff-match-conc
  (implies (cst-matchp abnf::cst "token")
           (iff (equal (cst-token-conc? abnf::cst) 3)
                (cst-list-list-conc-matchp
                     (abnf::tree-nonleaf->branches abnf::cst)
                     "atomic-literal"))))

Theorem: cst-token-conc?-4-iff-match-conc

(defthm cst-token-conc?-4-iff-match-conc
  (implies (cst-matchp abnf::cst "token")
           (iff (equal (cst-token-conc? abnf::cst) 4)
                (cst-list-list-conc-matchp
                     (abnf::tree-nonleaf->branches abnf::cst)
                     "numeral"))))

Theorem: cst-token-conc?-5-iff-match-conc

(defthm cst-token-conc?-5-iff-match-conc
  (implies (cst-matchp abnf::cst "token")
           (iff (equal (cst-token-conc? abnf::cst) 5)
                (cst-list-list-conc-matchp
                     (abnf::tree-nonleaf->branches abnf::cst)
                     "annotation"))))

Theorem: cst-token-conc?-6-iff-match-conc

(defthm cst-token-conc?-6-iff-match-conc
  (implies (cst-matchp abnf::cst "token")
           (iff (equal (cst-token-conc? abnf::cst) 6)
                (cst-list-list-conc-matchp
                     (abnf::tree-nonleaf->branches abnf::cst)
                     "symbol"))))

Function: cst-lexeme-conc?

(defun cst-lexeme-conc? (abnf::cst)
 (declare (xargs :guard (abnf::treep abnf::cst)))
 (declare (xargs :guard (cst-matchp abnf::cst "lexeme")))
 (let ((__function__ 'cst-lexeme-conc?))
  (declare (ignorable __function__))
  (cond
    ((equal
          (abnf::tree-nonleaf->rulename?
               (nth 0
                    (nth 0
                         (abnf::tree-nonleaf->branches abnf::cst))))
          (abnf::rulename "token"))
     1)
    ((equal
          (abnf::tree-nonleaf->rulename?
               (nth 0
                    (nth 0
                         (abnf::tree-nonleaf->branches abnf::cst))))
          (abnf::rulename "comment"))
     2)
    ((equal
          (abnf::tree-nonleaf->rulename?
               (nth 0
                    (nth 0
                         (abnf::tree-nonleaf->branches abnf::cst))))
          (abnf::rulename "whitespace"))
     3)
    (t (prog2$ (impossible) 1)))))

Theorem: posp-of-cst-lexeme-conc?

(defthm posp-of-cst-lexeme-conc?
  (b* ((number (cst-lexeme-conc? abnf::cst)))
    (posp number))
  :rule-classes :rewrite)

Theorem: cst-lexeme-conc?-possibilities

(defthm cst-lexeme-conc?-possibilities
  (b* ((number (cst-lexeme-conc? abnf::cst)))
    (or (equal number 1)
        (equal number 2)
        (equal number 3)))
  :rule-classes
  ((:forward-chaining
        :trigger-terms ((cst-lexeme-conc? abnf::cst)))))

Theorem: cst-lexeme-conc?-of-tree-fix-cst

(defthm cst-lexeme-conc?-of-tree-fix-cst
  (equal (cst-lexeme-conc? (abnf::tree-fix abnf::cst))
         (cst-lexeme-conc? abnf::cst)))

Theorem: cst-lexeme-conc?-tree-equiv-congruence-on-cst

(defthm cst-lexeme-conc?-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-lexeme-conc? abnf::cst)
                  (cst-lexeme-conc? cst-equiv)))
  :rule-classes :congruence)

Theorem: cst-lexeme-conc?-1-iff-match-conc

(defthm cst-lexeme-conc?-1-iff-match-conc
  (implies (cst-matchp abnf::cst "lexeme")
           (iff (equal (cst-lexeme-conc? abnf::cst) 1)
                (cst-list-list-conc-matchp
                     (abnf::tree-nonleaf->branches abnf::cst)
                     "token"))))

Theorem: cst-lexeme-conc?-2-iff-match-conc

(defthm cst-lexeme-conc?-2-iff-match-conc
  (implies (cst-matchp abnf::cst "lexeme")
           (iff (equal (cst-lexeme-conc? abnf::cst) 2)
                (cst-list-list-conc-matchp
                     (abnf::tree-nonleaf->branches abnf::cst)
                     "comment"))))

Theorem: cst-lexeme-conc?-3-iff-match-conc

(defthm cst-lexeme-conc?-3-iff-match-conc
  (implies (cst-matchp abnf::cst "lexeme")
           (iff (equal (cst-lexeme-conc? abnf::cst) 3)
                (cst-list-list-conc-matchp
                     (abnf::tree-nonleaf->branches abnf::cst)
                     "whitespace"))))

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-named-primitive-type-conc?

(defun cst-named-primitive-type-conc? (abnf::cst)
 (declare (xargs :guard (abnf::treep abnf::cst)))
 (declare
      (xargs :guard (cst-matchp abnf::cst "named-primitive-type")))
 (let ((__function__ 'cst-named-primitive-type-conc?))
  (declare (ignorable __function__))
  (cond
    ((equal
          (abnf::tree-nonleaf->rulename?
               (nth 0
                    (nth 0
                         (abnf::tree-nonleaf->branches abnf::cst))))
          (abnf::rulename "boolean-type"))
     1)
    ((equal
          (abnf::tree-nonleaf->rulename?
               (nth 0
                    (nth 0
                         (abnf::tree-nonleaf->branches abnf::cst))))
          (abnf::rulename "arithmetic-type"))
     2)
    ((equal
          (abnf::tree-nonleaf->rulename?
               (nth 0
                    (nth 0
                         (abnf::tree-nonleaf->branches abnf::cst))))
          (abnf::rulename "address-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-named-primitive-type-conc?

(defthm posp-of-cst-named-primitive-type-conc?
  (b* ((number (cst-named-primitive-type-conc? abnf::cst)))
    (posp number))
  :rule-classes :rewrite)

Theorem: cst-named-primitive-type-conc?-possibilities

(defthm cst-named-primitive-type-conc?-possibilities
 (b* ((number (cst-named-primitive-type-conc? abnf::cst)))
   (or (equal number 1)
       (equal number 2)
       (equal number 3)
       (equal number 4)))
 :rule-classes
 ((:forward-chaining
      :trigger-terms ((cst-named-primitive-type-conc? abnf::cst)))))

Theorem: cst-named-primitive-type-conc?-of-tree-fix-cst

(defthm cst-named-primitive-type-conc?-of-tree-fix-cst
  (equal (cst-named-primitive-type-conc? (abnf::tree-fix abnf::cst))
         (cst-named-primitive-type-conc? abnf::cst)))

Theorem: cst-named-primitive-type-conc?-tree-equiv-congruence-on-cst

(defthm cst-named-primitive-type-conc?-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-named-primitive-type-conc? abnf::cst)
                  (cst-named-primitive-type-conc? cst-equiv)))
  :rule-classes :congruence)

Theorem: cst-named-primitive-type-conc?-1-iff-match-conc

(defthm cst-named-primitive-type-conc?-1-iff-match-conc
  (implies (cst-matchp abnf::cst "named-primitive-type")
           (iff (equal (cst-named-primitive-type-conc? abnf::cst)
                       1)
                (cst-list-list-conc-matchp
                     (abnf::tree-nonleaf->branches abnf::cst)
                     "boolean-type"))))

Theorem: cst-named-primitive-type-conc?-2-iff-match-conc

(defthm cst-named-primitive-type-conc?-2-iff-match-conc
  (implies (cst-matchp abnf::cst "named-primitive-type")
           (iff (equal (cst-named-primitive-type-conc? abnf::cst)
                       2)
                (cst-list-list-conc-matchp
                     (abnf::tree-nonleaf->branches abnf::cst)
                     "arithmetic-type"))))

Theorem: cst-named-primitive-type-conc?-3-iff-match-conc

(defthm cst-named-primitive-type-conc?-3-iff-match-conc
  (implies (cst-matchp abnf::cst "named-primitive-type")
           (iff (equal (cst-named-primitive-type-conc? abnf::cst)
                       3)
                (cst-list-list-conc-matchp
                     (abnf::tree-nonleaf->branches abnf::cst)
                     "address-type"))))

Theorem: cst-named-primitive-type-conc?-4-iff-match-conc

(defthm cst-named-primitive-type-conc?-4-iff-match-conc
  (implies (cst-matchp abnf::cst "named-primitive-type")
           (iff (equal (cst-named-primitive-type-conc? abnf::cst)
                       4)
                (cst-list-list-conc-matchp
                     (abnf::tree-nonleaf->branches abnf::cst)
                     "string-type"))))

Function: cst-primitive-type-conc?

(defun cst-primitive-type-conc? (abnf::cst)
 (declare (xargs :guard (abnf::treep abnf::cst)))
 (declare (xargs :guard (cst-matchp abnf::cst "primitive-type")))
 (let ((__function__ 'cst-primitive-type-conc?))
  (declare (ignorable __function__))
  (cond
    ((equal
          (abnf::tree-nonleaf->rulename?
               (nth 0
                    (nth 0
                         (abnf::tree-nonleaf->branches abnf::cst))))
          (abnf::rulename "named-primitive-type"))
     1)
    ((equal
          (abnf::tree-nonleaf->rulename?
               (nth 0
                    (nth 0
                         (abnf::tree-nonleaf->branches abnf::cst))))
          (abnf::rulename "unit-type"))
     2)
    (t (prog2$ (impossible) 1)))))

Theorem: posp-of-cst-primitive-type-conc?

(defthm posp-of-cst-primitive-type-conc?
  (b* ((number (cst-primitive-type-conc? abnf::cst)))
    (posp number))
  :rule-classes :rewrite)

Theorem: cst-primitive-type-conc?-possibilities

(defthm cst-primitive-type-conc?-possibilities
  (b* ((number (cst-primitive-type-conc? abnf::cst)))
    (or (equal number 1) (equal number 2)))
  :rule-classes
  ((:forward-chaining
        :trigger-terms ((cst-primitive-type-conc? abnf::cst)))))

Theorem: cst-primitive-type-conc?-of-tree-fix-cst

(defthm cst-primitive-type-conc?-of-tree-fix-cst
  (equal (cst-primitive-type-conc? (abnf::tree-fix abnf::cst))
         (cst-primitive-type-conc? abnf::cst)))

Theorem: cst-primitive-type-conc?-tree-equiv-congruence-on-cst

(defthm cst-primitive-type-conc?-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-primitive-type-conc? abnf::cst)
                  (cst-primitive-type-conc? cst-equiv)))
  :rule-classes :congruence)

Theorem: cst-primitive-type-conc?-1-iff-match-conc

(defthm cst-primitive-type-conc?-1-iff-match-conc
  (implies (cst-matchp abnf::cst "primitive-type")
           (iff (equal (cst-primitive-type-conc? abnf::cst)
                       1)
                (cst-list-list-conc-matchp
                     (abnf::tree-nonleaf->branches abnf::cst)
                     "named-primitive-type"))))

Theorem: cst-primitive-type-conc?-2-iff-match-conc

(defthm cst-primitive-type-conc?-2-iff-match-conc
  (implies (cst-matchp abnf::cst "primitive-type")
           (iff (equal (cst-primitive-type-conc? abnf::cst)
                       2)
                (cst-list-list-conc-matchp
                     (abnf::tree-nonleaf->branches abnf::cst)
                     "unit-type"))))

Function: cst-type-conc?

(defun cst-type-conc? (abnf::cst)
 (declare (xargs :guard (abnf::treep abnf::cst)))
 (declare (xargs :guard (cst-matchp abnf::cst "type")))
 (let ((__function__ 'cst-type-conc?))
  (declare (ignorable __function__))
  (cond
    ((equal
          (abnf::tree-nonleaf->rulename?
               (nth 0
                    (nth 0
                         (abnf::tree-nonleaf->branches abnf::cst))))
          (abnf::rulename "named-type"))
     1)
    ((equal
          (abnf::tree-nonleaf->rulename?
               (nth 0
                    (nth 0
                         (abnf::tree-nonleaf->branches abnf::cst))))
          (abnf::rulename "unit-type"))
     2)
    ((equal
          (abnf::tree-nonleaf->rulename?
               (nth 0
                    (nth 0
                         (abnf::tree-nonleaf->branches abnf::cst))))
          (abnf::rulename "tuple-type"))
     3)
    (t (prog2$ (impossible) 1)))))

Theorem: posp-of-cst-type-conc?

(defthm posp-of-cst-type-conc?
  (b* ((number (cst-type-conc? abnf::cst)))
    (posp number))
  :rule-classes :rewrite)

Theorem: cst-type-conc?-possibilities

(defthm cst-type-conc?-possibilities
  (b* ((number (cst-type-conc? abnf::cst)))
    (or (equal number 1)
        (equal number 2)
        (equal number 3)))
  :rule-classes
  ((:forward-chaining :trigger-terms ((cst-type-conc? abnf::cst)))))

Theorem: cst-type-conc?-of-tree-fix-cst

(defthm cst-type-conc?-of-tree-fix-cst
  (equal (cst-type-conc? (abnf::tree-fix abnf::cst))
         (cst-type-conc? abnf::cst)))

Theorem: cst-type-conc?-tree-equiv-congruence-on-cst

(defthm cst-type-conc?-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-type-conc? abnf::cst)
                  (cst-type-conc? cst-equiv)))
  :rule-classes :congruence)

Theorem: cst-type-conc?-1-iff-match-conc

(defthm cst-type-conc?-1-iff-match-conc
  (implies (cst-matchp abnf::cst "type")
           (iff (equal (cst-type-conc? abnf::cst) 1)
                (cst-list-list-conc-matchp
                     (abnf::tree-nonleaf->branches abnf::cst)
                     "named-type"))))

Theorem: cst-type-conc?-2-iff-match-conc

(defthm cst-type-conc?-2-iff-match-conc
  (implies (cst-matchp abnf::cst "type")
           (iff (equal (cst-type-conc? abnf::cst) 2)
                (cst-list-list-conc-matchp
                     (abnf::tree-nonleaf->branches abnf::cst)
                     "unit-type"))))

Theorem: cst-type-conc?-3-iff-match-conc

(defthm cst-type-conc?-3-iff-match-conc
  (implies (cst-matchp abnf::cst "type")
           (iff (equal (cst-type-conc? abnf::cst) 3)
                (cst-list-list-conc-matchp
                     (abnf::tree-nonleaf->branches abnf::cst)
                     "tuple-type"))))

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 "atomic-literal"))
     1)
    ((equal
          (abnf::tree-nonleaf->rulename?
               (nth 0
                    (nth 0
                         (abnf::tree-nonleaf->branches abnf::cst))))
          (abnf::rulename "affine-group-literal"))
     2)
    (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)))
  :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)
                     "atomic-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)
                     "affine-group-literal"))))

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__))
  (cond
    ((equal
          (abnf::tree-nonleaf->rulename?
               (nth 0
                    (nth 0
                         (abnf::tree-nonleaf->branches abnf::cst))))
          (abnf::rulename "product-group-literal"))
     1)
    ((equal
          (abnf::tree-nonleaf->rulename?
               (nth 0
                    (nth 0
                         (abnf::tree-nonleaf->branches abnf::cst))))
          (abnf::rulename "affine-group-literal"))
     2)
    (t (prog2$ (impossible) 1)))))

Theorem: posp-of-cst-group-literal-conc?

(defthm posp-of-cst-group-literal-conc?
  (b* ((number (cst-group-literal-conc? abnf::cst)))
    (posp number))
  :rule-classes :rewrite)

Theorem: cst-group-literal-conc?-possibilities

(defthm cst-group-literal-conc?-possibilities
  (b* ((number (cst-group-literal-conc? abnf::cst)))
    (or (equal number 1) (equal number 2)))
  :rule-classes
  ((:forward-chaining
        :trigger-terms ((cst-group-literal-conc? abnf::cst)))))

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)

Theorem: cst-group-literal-conc?-1-iff-match-conc

(defthm cst-group-literal-conc?-1-iff-match-conc
  (implies (cst-matchp abnf::cst "group-literal")
           (iff (equal (cst-group-literal-conc? abnf::cst)
                       1)
                (cst-list-list-conc-matchp
                     (abnf::tree-nonleaf->branches abnf::cst)
                     "product-group-literal"))))

Theorem: cst-group-literal-conc?-2-iff-match-conc

(defthm cst-group-literal-conc?-2-iff-match-conc
  (implies (cst-matchp abnf::cst "group-literal")
           (iff (equal (cst-group-literal-conc? abnf::cst)
                       2)
                (cst-list-list-conc-matchp
                     (abnf::tree-nonleaf->branches abnf::cst)
                     "affine-group-literal"))))

Function: cst-postfix-expression-conc?

(defun cst-postfix-expression-conc? (abnf::cst)
 (declare (xargs :guard (abnf::treep abnf::cst)))
 (declare
      (xargs :guard (cst-matchp abnf::cst "postfix-expression")))
 (let ((__function__ 'cst-postfix-expression-conc?))
  (declare (ignorable __function__))
  (cond
    ((equal
          (abnf::tree-nonleaf->rulename?
               (nth 0
                    (nth 0
                         (abnf::tree-nonleaf->branches abnf::cst))))
          (abnf::rulename "primary-expression"))
     1)
    ((equal
          (abnf::tree-nonleaf->rulename?
               (nth 0
                    (nth 0
                         (abnf::tree-nonleaf->branches abnf::cst))))
          (abnf::rulename "tuple-component-expression"))
     2)
    ((equal
          (abnf::tree-nonleaf->rulename?
               (nth 0
                    (nth 0
                         (abnf::tree-nonleaf->branches abnf::cst))))
          (abnf::rulename "struct-component-expression"))
     3)
    ((equal
          (abnf::tree-nonleaf->rulename?
               (nth 0
                    (nth 0
                         (abnf::tree-nonleaf->branches abnf::cst))))
          (abnf::rulename "operator-call"))
     4)
    (t (prog2$ (impossible) 1)))))

Theorem: posp-of-cst-postfix-expression-conc?

(defthm posp-of-cst-postfix-expression-conc?
  (b* ((number (cst-postfix-expression-conc? abnf::cst)))
    (posp number))
  :rule-classes :rewrite)

Theorem: cst-postfix-expression-conc?-possibilities

(defthm cst-postfix-expression-conc?-possibilities
  (b* ((number (cst-postfix-expression-conc? abnf::cst)))
    (or (equal number 1)
        (equal number 2)
        (equal number 3)
        (equal number 4)))
  :rule-classes
  ((:forward-chaining
        :trigger-terms ((cst-postfix-expression-conc? abnf::cst)))))

Theorem: cst-postfix-expression-conc?-of-tree-fix-cst

(defthm cst-postfix-expression-conc?-of-tree-fix-cst
  (equal (cst-postfix-expression-conc? (abnf::tree-fix abnf::cst))
         (cst-postfix-expression-conc? abnf::cst)))

Theorem: cst-postfix-expression-conc?-tree-equiv-congruence-on-cst

(defthm cst-postfix-expression-conc?-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-postfix-expression-conc? abnf::cst)
                  (cst-postfix-expression-conc? cst-equiv)))
  :rule-classes :congruence)

Theorem: cst-postfix-expression-conc?-1-iff-match-conc

(defthm cst-postfix-expression-conc?-1-iff-match-conc
  (implies (cst-matchp abnf::cst "postfix-expression")
           (iff (equal (cst-postfix-expression-conc? abnf::cst)
                       1)
                (cst-list-list-conc-matchp
                     (abnf::tree-nonleaf->branches abnf::cst)
                     "primary-expression"))))

Theorem: cst-postfix-expression-conc?-2-iff-match-conc

(defthm cst-postfix-expression-conc?-2-iff-match-conc
  (implies (cst-matchp abnf::cst "postfix-expression")
           (iff (equal (cst-postfix-expression-conc? abnf::cst)
                       2)
                (cst-list-list-conc-matchp
                     (abnf::tree-nonleaf->branches abnf::cst)
                     "tuple-component-expression"))))

Theorem: cst-postfix-expression-conc?-3-iff-match-conc

(defthm cst-postfix-expression-conc?-3-iff-match-conc
  (implies (cst-matchp abnf::cst "postfix-expression")
           (iff (equal (cst-postfix-expression-conc? abnf::cst)
                       3)
                (cst-list-list-conc-matchp
                     (abnf::tree-nonleaf->branches abnf::cst)
                     "struct-component-expression"))))

Theorem: cst-postfix-expression-conc?-4-iff-match-conc

(defthm cst-postfix-expression-conc?-4-iff-match-conc
  (implies (cst-matchp abnf::cst "postfix-expression")
           (iff (equal (cst-postfix-expression-conc? abnf::cst)
                       4)
                (cst-list-list-conc-matchp
                     (abnf::tree-nonleaf->branches abnf::cst)
                     "operator-call"))))

Function: cst-operator-call-conc?

(defun cst-operator-call-conc? (abnf::cst)
 (declare (xargs :guard (abnf::treep abnf::cst)))
 (declare (xargs :guard (cst-matchp abnf::cst "operator-call")))
 (let ((__function__ 'cst-operator-call-conc?))
  (declare (ignorable __function__))
  (cond
    ((equal
          (abnf::tree-nonleaf->rulename?
               (nth 0
                    (nth 0
                         (abnf::tree-nonleaf->branches abnf::cst))))
          (abnf::rulename "unary-operator-call"))
     1)
    ((equal
          (abnf::tree-nonleaf->rulename?
               (nth 0
                    (nth 0
                         (abnf::tree-nonleaf->branches abnf::cst))))
          (abnf::rulename "binary-operator-call"))
     2)
    (t (prog2$ (impossible) 1)))))

Theorem: posp-of-cst-operator-call-conc?

(defthm posp-of-cst-operator-call-conc?
  (b* ((number (cst-operator-call-conc? abnf::cst)))
    (posp number))
  :rule-classes :rewrite)

Theorem: cst-operator-call-conc?-possibilities

(defthm cst-operator-call-conc?-possibilities
  (b* ((number (cst-operator-call-conc? abnf::cst)))
    (or (equal number 1) (equal number 2)))
  :rule-classes
  ((:forward-chaining
        :trigger-terms ((cst-operator-call-conc? abnf::cst)))))

Theorem: cst-operator-call-conc?-of-tree-fix-cst

(defthm cst-operator-call-conc?-of-tree-fix-cst
  (equal (cst-operator-call-conc? (abnf::tree-fix abnf::cst))
         (cst-operator-call-conc? abnf::cst)))

Theorem: cst-operator-call-conc?-tree-equiv-congruence-on-cst

(defthm cst-operator-call-conc?-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-operator-call-conc? abnf::cst)
                  (cst-operator-call-conc? cst-equiv)))
  :rule-classes :congruence)

Theorem: cst-operator-call-conc?-1-iff-match-conc

(defthm cst-operator-call-conc?-1-iff-match-conc
  (implies (cst-matchp abnf::cst "operator-call")
           (iff (equal (cst-operator-call-conc? abnf::cst)
                       1)
                (cst-list-list-conc-matchp
                     (abnf::tree-nonleaf->branches abnf::cst)
                     "unary-operator-call"))))

Theorem: cst-operator-call-conc?-2-iff-match-conc

(defthm cst-operator-call-conc?-2-iff-match-conc
  (implies (cst-matchp abnf::cst "operator-call")
           (iff (equal (cst-operator-call-conc? abnf::cst)
                       2)
                (cst-list-list-conc-matchp
                     (abnf::tree-nonleaf->branches abnf::cst)
                     "binary-operator-call"))))

Function: cst-statement-conc?

(defun cst-statement-conc? (abnf::cst)
 (declare (xargs :guard (abnf::treep abnf::cst)))
 (declare (xargs :guard (cst-matchp abnf::cst "statement")))
 (let ((__function__ 'cst-statement-conc?))
  (declare (ignorable __function__))
  (cond
    ((equal
          (abnf::tree-nonleaf->rulename?
               (nth 0
                    (nth 0
                         (abnf::tree-nonleaf->branches abnf::cst))))
          (abnf::rulename "return-statement"))
     1)
    ((equal
          (abnf::tree-nonleaf->rulename?
               (nth 0
                    (nth 0
                         (abnf::tree-nonleaf->branches abnf::cst))))
          (abnf::rulename "variable-declaration"))
     2)
    ((equal
          (abnf::tree-nonleaf->rulename?
               (nth 0
                    (nth 0
                         (abnf::tree-nonleaf->branches abnf::cst))))
          (abnf::rulename "constant-declaration"))
     3)
    ((equal
          (abnf::tree-nonleaf->rulename?
               (nth 0
                    (nth 0
                         (abnf::tree-nonleaf->branches abnf::cst))))
          (abnf::rulename "conditional-statement"))
     4)
    ((equal
          (abnf::tree-nonleaf->rulename?
               (nth 0
                    (nth 0
                         (abnf::tree-nonleaf->branches abnf::cst))))
          (abnf::rulename "loop-statement"))
     5)
    ((equal
          (abnf::tree-nonleaf->rulename?
               (nth 0
                    (nth 0
                         (abnf::tree-nonleaf->branches abnf::cst))))
          (abnf::rulename "assignment-statement"))
     6)
    ((equal
          (abnf::tree-nonleaf->rulename?
               (nth 0
                    (nth 0
                         (abnf::tree-nonleaf->branches abnf::cst))))
          (abnf::rulename "console-statement"))
     7)
    ((equal
          (abnf::tree-nonleaf->rulename?
               (nth 0
                    (nth 0
                         (abnf::tree-nonleaf->branches abnf::cst))))
          (abnf::rulename "finalize-statement"))
     8)
    ((equal
          (abnf::tree-nonleaf->rulename?
               (nth 0
                    (nth 0
                         (abnf::tree-nonleaf->branches abnf::cst))))
          (abnf::rulename "increment-statement"))
     9)
    ((equal
          (abnf::tree-nonleaf->rulename?
               (nth 0
                    (nth 0
                         (abnf::tree-nonleaf->branches abnf::cst))))
          (abnf::rulename "decrement-statement"))
     10)
    ((equal
          (abnf::tree-nonleaf->rulename?
               (nth 0
                    (nth 0
                         (abnf::tree-nonleaf->branches abnf::cst))))
          (abnf::rulename "block"))
     11)
    (t (prog2$ (impossible) 1)))))

Theorem: posp-of-cst-statement-conc?

(defthm posp-of-cst-statement-conc?
  (b* ((number (cst-statement-conc? abnf::cst)))
    (posp number))
  :rule-classes :rewrite)

Theorem: cst-statement-conc?-possibilities

(defthm cst-statement-conc?-possibilities
  (b* ((number (cst-statement-conc? abnf::cst)))
    (or (equal number 1)
        (equal number 2)
        (equal number 3)
        (equal number 4)
        (equal number 5)
        (equal number 6)
        (equal number 7)
        (equal number 8)
        (equal number 9)
        (equal number 10)
        (equal number 11)))
  :rule-classes
  ((:forward-chaining
        :trigger-terms ((cst-statement-conc? abnf::cst)))))

Theorem: cst-statement-conc?-of-tree-fix-cst

(defthm cst-statement-conc?-of-tree-fix-cst
  (equal (cst-statement-conc? (abnf::tree-fix abnf::cst))
         (cst-statement-conc? abnf::cst)))

Theorem: cst-statement-conc?-tree-equiv-congruence-on-cst

(defthm cst-statement-conc?-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-statement-conc? abnf::cst)
                  (cst-statement-conc? cst-equiv)))
  :rule-classes :congruence)

Theorem: cst-statement-conc?-1-iff-match-conc

(defthm cst-statement-conc?-1-iff-match-conc
  (implies (cst-matchp abnf::cst "statement")
           (iff (equal (cst-statement-conc? abnf::cst)
                       1)
                (cst-list-list-conc-matchp
                     (abnf::tree-nonleaf->branches abnf::cst)
                     "return-statement"))))

Theorem: cst-statement-conc?-2-iff-match-conc

(defthm cst-statement-conc?-2-iff-match-conc
  (implies (cst-matchp abnf::cst "statement")
           (iff (equal (cst-statement-conc? abnf::cst)
                       2)
                (cst-list-list-conc-matchp
                     (abnf::tree-nonleaf->branches abnf::cst)
                     "variable-declaration"))))

Theorem: cst-statement-conc?-3-iff-match-conc

(defthm cst-statement-conc?-3-iff-match-conc
  (implies (cst-matchp abnf::cst "statement")
           (iff (equal (cst-statement-conc? abnf::cst)
                       3)
                (cst-list-list-conc-matchp
                     (abnf::tree-nonleaf->branches abnf::cst)
                     "constant-declaration"))))

Theorem: cst-statement-conc?-4-iff-match-conc

(defthm cst-statement-conc?-4-iff-match-conc
  (implies (cst-matchp abnf::cst "statement")
           (iff (equal (cst-statement-conc? abnf::cst)
                       4)
                (cst-list-list-conc-matchp
                     (abnf::tree-nonleaf->branches abnf::cst)
                     "conditional-statement"))))

Theorem: cst-statement-conc?-5-iff-match-conc

(defthm cst-statement-conc?-5-iff-match-conc
  (implies (cst-matchp abnf::cst "statement")
           (iff (equal (cst-statement-conc? abnf::cst)
                       5)
                (cst-list-list-conc-matchp
                     (abnf::tree-nonleaf->branches abnf::cst)
                     "loop-statement"))))

Theorem: cst-statement-conc?-6-iff-match-conc

(defthm cst-statement-conc?-6-iff-match-conc
  (implies (cst-matchp abnf::cst "statement")
           (iff (equal (cst-statement-conc? abnf::cst)
                       6)
                (cst-list-list-conc-matchp
                     (abnf::tree-nonleaf->branches abnf::cst)
                     "assignment-statement"))))

Theorem: cst-statement-conc?-7-iff-match-conc

(defthm cst-statement-conc?-7-iff-match-conc
  (implies (cst-matchp abnf::cst "statement")
           (iff (equal (cst-statement-conc? abnf::cst)
                       7)
                (cst-list-list-conc-matchp
                     (abnf::tree-nonleaf->branches abnf::cst)
                     "console-statement"))))

Theorem: cst-statement-conc?-8-iff-match-conc

(defthm cst-statement-conc?-8-iff-match-conc
  (implies (cst-matchp abnf::cst "statement")
           (iff (equal (cst-statement-conc? abnf::cst)
                       8)
                (cst-list-list-conc-matchp
                     (abnf::tree-nonleaf->branches abnf::cst)
                     "finalize-statement"))))

Theorem: cst-statement-conc?-9-iff-match-conc

(defthm cst-statement-conc?-9-iff-match-conc
  (implies (cst-matchp abnf::cst "statement")
           (iff (equal (cst-statement-conc? abnf::cst)
                       9)
                (cst-list-list-conc-matchp
                     (abnf::tree-nonleaf->branches abnf::cst)
                     "increment-statement"))))

Theorem: cst-statement-conc?-10-iff-match-conc

(defthm cst-statement-conc?-10-iff-match-conc
  (implies (cst-matchp abnf::cst "statement")
           (iff (equal (cst-statement-conc? abnf::cst)
                       10)
                (cst-list-list-conc-matchp
                     (abnf::tree-nonleaf->branches abnf::cst)
                     "decrement-statement"))))

Theorem: cst-statement-conc?-11-iff-match-conc

(defthm cst-statement-conc?-11-iff-match-conc
  (implies (cst-matchp abnf::cst "statement")
           (iff (equal (cst-statement-conc? abnf::cst)
                       11)
                (cst-list-list-conc-matchp
                     (abnf::tree-nonleaf->branches abnf::cst)
                     "block"))))

Function: cst-console-call-conc?

(defun cst-console-call-conc? (abnf::cst)
 (declare (xargs :guard (abnf::treep abnf::cst)))
 (declare (xargs :guard (cst-matchp abnf::cst "console-call")))
 (let ((__function__ 'cst-console-call-conc?))
  (declare (ignorable __function__))
  (cond
    ((equal
          (abnf::tree-nonleaf->rulename?
               (nth 0
                    (nth 0
                         (abnf::tree-nonleaf->branches abnf::cst))))
          (abnf::rulename "assert-call"))
     1)
    ((equal
          (abnf::tree-nonleaf->rulename?
               (nth 0
                    (nth 0
                         (abnf::tree-nonleaf->branches abnf::cst))))
          (abnf::rulename "assert-equal-call"))
     2)
    ((equal
          (abnf::tree-nonleaf->rulename?
               (nth 0
                    (nth 0
                         (abnf::tree-nonleaf->branches abnf::cst))))
          (abnf::rulename "assert-not-equal-call"))
     3)
    (t (prog2$ (impossible) 1)))))

Theorem: posp-of-cst-console-call-conc?

(defthm posp-of-cst-console-call-conc?
  (b* ((number (cst-console-call-conc? abnf::cst)))
    (posp number))
  :rule-classes :rewrite)

Theorem: cst-console-call-conc?-possibilities

(defthm cst-console-call-conc?-possibilities
  (b* ((number (cst-console-call-conc? abnf::cst)))
    (or (equal number 1)
        (equal number 2)
        (equal number 3)))
  :rule-classes
  ((:forward-chaining
        :trigger-terms ((cst-console-call-conc? abnf::cst)))))

Theorem: cst-console-call-conc?-of-tree-fix-cst

(defthm cst-console-call-conc?-of-tree-fix-cst
  (equal (cst-console-call-conc? (abnf::tree-fix abnf::cst))
         (cst-console-call-conc? abnf::cst)))

Theorem: cst-console-call-conc?-tree-equiv-congruence-on-cst

(defthm cst-console-call-conc?-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-console-call-conc? abnf::cst)
                  (cst-console-call-conc? cst-equiv)))
  :rule-classes :congruence)

Theorem: cst-console-call-conc?-1-iff-match-conc

(defthm cst-console-call-conc?-1-iff-match-conc
  (implies (cst-matchp abnf::cst "console-call")
           (iff (equal (cst-console-call-conc? abnf::cst)
                       1)
                (cst-list-list-conc-matchp
                     (abnf::tree-nonleaf->branches abnf::cst)
                     "assert-call"))))

Theorem: cst-console-call-conc?-2-iff-match-conc

(defthm cst-console-call-conc?-2-iff-match-conc
  (implies (cst-matchp abnf::cst "console-call")
           (iff (equal (cst-console-call-conc? abnf::cst)
                       2)
                (cst-list-list-conc-matchp
                     (abnf::tree-nonleaf->branches abnf::cst)
                     "assert-equal-call"))))

Theorem: cst-console-call-conc?-3-iff-match-conc

(defthm cst-console-call-conc?-3-iff-match-conc
  (implies (cst-matchp abnf::cst "console-call")
           (iff (equal (cst-console-call-conc? abnf::cst)
                       3)
                (cst-list-list-conc-matchp
                     (abnf::tree-nonleaf->branches abnf::cst)
                     "assert-not-equal-call"))))

Function: cst-program-item-conc?

(defun cst-program-item-conc? (abnf::cst)
 (declare (xargs :guard (abnf::treep abnf::cst)))
 (declare (xargs :guard (cst-matchp abnf::cst "program-item")))
 (let ((__function__ 'cst-program-item-conc?))
  (declare (ignorable __function__))
  (cond
    ((equal
          (abnf::tree-nonleaf->rulename?
               (nth 0
                    (nth 0
                         (abnf::tree-nonleaf->branches abnf::cst))))
          (abnf::rulename "function-declaration"))
     1)
    ((equal
          (abnf::tree-nonleaf->rulename?
               (nth 0
                    (nth 0
                         (abnf::tree-nonleaf->branches abnf::cst))))
          (abnf::rulename "transition-declaration"))
     2)
    ((equal
          (abnf::tree-nonleaf->rulename?
               (nth 0
                    (nth 0
                         (abnf::tree-nonleaf->branches abnf::cst))))
          (abnf::rulename "struct-declaration"))
     3)
    ((equal
          (abnf::tree-nonleaf->rulename?
               (nth 0
                    (nth 0
                         (abnf::tree-nonleaf->branches abnf::cst))))
          (abnf::rulename "record-declaration"))
     4)
    ((equal
          (abnf::tree-nonleaf->rulename?
               (nth 0
                    (nth 0
                         (abnf::tree-nonleaf->branches abnf::cst))))
          (abnf::rulename "mapping-declaration"))
     5)
    (t (prog2$ (impossible) 1)))))

Theorem: posp-of-cst-program-item-conc?

(defthm posp-of-cst-program-item-conc?
  (b* ((number (cst-program-item-conc? abnf::cst)))
    (posp number))
  :rule-classes :rewrite)

Theorem: cst-program-item-conc?-possibilities

(defthm cst-program-item-conc?-possibilities
  (b* ((number (cst-program-item-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-program-item-conc? abnf::cst)))))

Theorem: cst-program-item-conc?-of-tree-fix-cst

(defthm cst-program-item-conc?-of-tree-fix-cst
  (equal (cst-program-item-conc? (abnf::tree-fix abnf::cst))
         (cst-program-item-conc? abnf::cst)))

Theorem: cst-program-item-conc?-tree-equiv-congruence-on-cst

(defthm cst-program-item-conc?-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-program-item-conc? abnf::cst)
                  (cst-program-item-conc? cst-equiv)))
  :rule-classes :congruence)

Theorem: cst-program-item-conc?-1-iff-match-conc

(defthm cst-program-item-conc?-1-iff-match-conc
  (implies (cst-matchp abnf::cst "program-item")
           (iff (equal (cst-program-item-conc? abnf::cst)
                       1)
                (cst-list-list-conc-matchp
                     (abnf::tree-nonleaf->branches abnf::cst)
                     "function-declaration"))))

Theorem: cst-program-item-conc?-2-iff-match-conc

(defthm cst-program-item-conc?-2-iff-match-conc
  (implies (cst-matchp abnf::cst "program-item")
           (iff (equal (cst-program-item-conc? abnf::cst)
                       2)
                (cst-list-list-conc-matchp
                     (abnf::tree-nonleaf->branches abnf::cst)
                     "transition-declaration"))))

Theorem: cst-program-item-conc?-3-iff-match-conc

(defthm cst-program-item-conc?-3-iff-match-conc
  (implies (cst-matchp abnf::cst "program-item")
           (iff (equal (cst-program-item-conc? abnf::cst)
                       3)
                (cst-list-list-conc-matchp
                     (abnf::tree-nonleaf->branches abnf::cst)
                     "struct-declaration"))))

Theorem: cst-program-item-conc?-4-iff-match-conc

(defthm cst-program-item-conc?-4-iff-match-conc
  (implies (cst-matchp abnf::cst "program-item")
           (iff (equal (cst-program-item-conc? abnf::cst)
                       4)
                (cst-list-list-conc-matchp
                     (abnf::tree-nonleaf->branches abnf::cst)
                     "record-declaration"))))

Theorem: cst-program-item-conc?-5-iff-match-conc

(defthm cst-program-item-conc?-5-iff-match-conc
  (implies (cst-matchp abnf::cst "program-item")
           (iff (equal (cst-program-item-conc? abnf::cst)
                       5)
                (cst-list-list-conc-matchp
                     (abnf::tree-nonleaf->branches abnf::cst)
                     "mapping-declaration"))))

Function: cst-horizontal-tab-conc

(defun cst-horizontal-tab-conc (abnf::cst)
  (declare (xargs :guard (abnf::treep abnf::cst)))
  (declare (xargs :guard (cst-matchp abnf::cst "horizontal-tab")))
  (let ((__function__ 'cst-horizontal-tab-conc))
    (declare (ignorable __function__))
    (abnf::tree-nonleaf->branches abnf::cst)))

Theorem: tree-list-listp-of-cst-horizontal-tab-conc

(defthm tree-list-listp-of-cst-horizontal-tab-conc
  (b* ((abnf::cstss (cst-horizontal-tab-conc abnf::cst)))
    (abnf::tree-list-listp abnf::cstss))
  :rule-classes :rewrite)

Theorem: cst-horizontal-tab-conc-match

(defthm cst-horizontal-tab-conc-match
  (implies (cst-matchp abnf::cst "horizontal-tab")
           (b* ((abnf::cstss (cst-horizontal-tab-conc abnf::cst)))
             (cst-list-list-conc-matchp abnf::cstss "%x9")))
  :rule-classes :rewrite)

Theorem: cst-horizontal-tab-conc-of-tree-fix-cst

(defthm cst-horizontal-tab-conc-of-tree-fix-cst
  (equal (cst-horizontal-tab-conc (abnf::tree-fix abnf::cst))
         (cst-horizontal-tab-conc abnf::cst)))

Theorem: cst-horizontal-tab-conc-tree-equiv-congruence-on-cst

(defthm cst-horizontal-tab-conc-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-horizontal-tab-conc abnf::cst)
                  (cst-horizontal-tab-conc cst-equiv)))
  :rule-classes :congruence)

Function: cst-line-feed-conc

(defun cst-line-feed-conc (abnf::cst)
  (declare (xargs :guard (abnf::treep abnf::cst)))
  (declare (xargs :guard (cst-matchp abnf::cst "line-feed")))
  (let ((__function__ 'cst-line-feed-conc))
    (declare (ignorable __function__))
    (abnf::tree-nonleaf->branches abnf::cst)))

Theorem: tree-list-listp-of-cst-line-feed-conc

(defthm tree-list-listp-of-cst-line-feed-conc
  (b* ((abnf::cstss (cst-line-feed-conc abnf::cst)))
    (abnf::tree-list-listp abnf::cstss))
  :rule-classes :rewrite)

Theorem: cst-line-feed-conc-match

(defthm cst-line-feed-conc-match
  (implies (cst-matchp abnf::cst "line-feed")
           (b* ((abnf::cstss (cst-line-feed-conc abnf::cst)))
             (cst-list-list-conc-matchp abnf::cstss "%xA")))
  :rule-classes :rewrite)

Theorem: cst-line-feed-conc-of-tree-fix-cst

(defthm cst-line-feed-conc-of-tree-fix-cst
  (equal (cst-line-feed-conc (abnf::tree-fix abnf::cst))
         (cst-line-feed-conc abnf::cst)))

Theorem: cst-line-feed-conc-tree-equiv-congruence-on-cst

(defthm cst-line-feed-conc-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-line-feed-conc abnf::cst)
                  (cst-line-feed-conc cst-equiv)))
  :rule-classes :congruence)

Function: cst-carriage-return-conc

(defun cst-carriage-return-conc (abnf::cst)
  (declare (xargs :guard (abnf::treep abnf::cst)))
  (declare (xargs :guard (cst-matchp abnf::cst "carriage-return")))
  (let ((__function__ 'cst-carriage-return-conc))
    (declare (ignorable __function__))
    (abnf::tree-nonleaf->branches abnf::cst)))

Theorem: tree-list-listp-of-cst-carriage-return-conc

(defthm tree-list-listp-of-cst-carriage-return-conc
  (b* ((abnf::cstss (cst-carriage-return-conc abnf::cst)))
    (abnf::tree-list-listp abnf::cstss))
  :rule-classes :rewrite)

Theorem: cst-carriage-return-conc-match

(defthm cst-carriage-return-conc-match
  (implies (cst-matchp abnf::cst "carriage-return")
           (b* ((abnf::cstss (cst-carriage-return-conc abnf::cst)))
             (cst-list-list-conc-matchp abnf::cstss "%xD")))
  :rule-classes :rewrite)

Theorem: cst-carriage-return-conc-of-tree-fix-cst

(defthm cst-carriage-return-conc-of-tree-fix-cst
  (equal (cst-carriage-return-conc (abnf::tree-fix abnf::cst))
         (cst-carriage-return-conc abnf::cst)))

Theorem: cst-carriage-return-conc-tree-equiv-congruence-on-cst

(defthm cst-carriage-return-conc-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-carriage-return-conc abnf::cst)
                  (cst-carriage-return-conc cst-equiv)))
  :rule-classes :congruence)

Function: cst-space-conc

(defun cst-space-conc (abnf::cst)
  (declare (xargs :guard (abnf::treep abnf::cst)))
  (declare (xargs :guard (cst-matchp abnf::cst "space")))
  (let ((__function__ 'cst-space-conc))
    (declare (ignorable __function__))
    (abnf::tree-nonleaf->branches abnf::cst)))

Theorem: tree-list-listp-of-cst-space-conc

(defthm tree-list-listp-of-cst-space-conc
  (b* ((abnf::cstss (cst-space-conc abnf::cst)))
    (abnf::tree-list-listp abnf::cstss))
  :rule-classes :rewrite)

Theorem: cst-space-conc-match

(defthm cst-space-conc-match
  (implies (cst-matchp abnf::cst "space")
           (b* ((abnf::cstss (cst-space-conc abnf::cst)))
             (cst-list-list-conc-matchp abnf::cstss "%x20")))
  :rule-classes :rewrite)

Theorem: cst-space-conc-of-tree-fix-cst

(defthm cst-space-conc-of-tree-fix-cst
  (equal (cst-space-conc (abnf::tree-fix abnf::cst))
         (cst-space-conc abnf::cst)))

Theorem: cst-space-conc-tree-equiv-congruence-on-cst

(defthm cst-space-conc-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-space-conc abnf::cst)
                  (cst-space-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 "horizontal-tab")))
  :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 "line-feed")))
  :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 "carriage-return")))
  :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 "space")))
  :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-whitespace-conc1

(defun cst-whitespace-conc1 (abnf::cst)
 (declare (xargs :guard (abnf::treep abnf::cst)))
 (declare (xargs :guard (and (cst-matchp abnf::cst "whitespace")
                             (equal (cst-whitespace-conc? abnf::cst)
                                    1))))
 (let ((__function__ 'cst-whitespace-conc1))
   (declare (ignorable __function__))
   (abnf::tree-nonleaf->branches abnf::cst)))

Theorem: tree-list-listp-of-cst-whitespace-conc1

(defthm tree-list-listp-of-cst-whitespace-conc1
  (b* ((abnf::cstss (cst-whitespace-conc1 abnf::cst)))
    (abnf::tree-list-listp abnf::cstss))
  :rule-classes :rewrite)

Theorem: cst-whitespace-conc1-match

(defthm cst-whitespace-conc1-match
  (implies (and (cst-matchp abnf::cst "whitespace")
                (equal (cst-whitespace-conc? abnf::cst)
                       1))
           (b* ((abnf::cstss (cst-whitespace-conc1 abnf::cst)))
             (cst-list-list-conc-matchp abnf::cstss "space")))
  :rule-classes :rewrite)

Theorem: cst-whitespace-conc1-of-tree-fix-cst

(defthm cst-whitespace-conc1-of-tree-fix-cst
  (equal (cst-whitespace-conc1 (abnf::tree-fix abnf::cst))
         (cst-whitespace-conc1 abnf::cst)))

Theorem: cst-whitespace-conc1-tree-equiv-congruence-on-cst

(defthm cst-whitespace-conc1-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-whitespace-conc1 abnf::cst)
                  (cst-whitespace-conc1 cst-equiv)))
  :rule-classes :congruence)

Function: cst-whitespace-conc2

(defun cst-whitespace-conc2 (abnf::cst)
 (declare (xargs :guard (abnf::treep abnf::cst)))
 (declare (xargs :guard (and (cst-matchp abnf::cst "whitespace")
                             (equal (cst-whitespace-conc? abnf::cst)
                                    2))))
 (let ((__function__ 'cst-whitespace-conc2))
   (declare (ignorable __function__))
   (abnf::tree-nonleaf->branches abnf::cst)))

Theorem: tree-list-listp-of-cst-whitespace-conc2

(defthm tree-list-listp-of-cst-whitespace-conc2
  (b* ((abnf::cstss (cst-whitespace-conc2 abnf::cst)))
    (abnf::tree-list-listp abnf::cstss))
  :rule-classes :rewrite)

Theorem: cst-whitespace-conc2-match

(defthm cst-whitespace-conc2-match
  (implies
       (and (cst-matchp abnf::cst "whitespace")
            (equal (cst-whitespace-conc? abnf::cst)
                   2))
       (b* ((abnf::cstss (cst-whitespace-conc2 abnf::cst)))
         (cst-list-list-conc-matchp abnf::cstss "horizontal-tab")))
  :rule-classes :rewrite)

Theorem: cst-whitespace-conc2-of-tree-fix-cst

(defthm cst-whitespace-conc2-of-tree-fix-cst
  (equal (cst-whitespace-conc2 (abnf::tree-fix abnf::cst))
         (cst-whitespace-conc2 abnf::cst)))

Theorem: cst-whitespace-conc2-tree-equiv-congruence-on-cst

(defthm cst-whitespace-conc2-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-whitespace-conc2 abnf::cst)
                  (cst-whitespace-conc2 cst-equiv)))
  :rule-classes :congruence)

Function: cst-whitespace-conc3

(defun cst-whitespace-conc3 (abnf::cst)
 (declare (xargs :guard (abnf::treep abnf::cst)))
 (declare (xargs :guard (and (cst-matchp abnf::cst "whitespace")
                             (equal (cst-whitespace-conc? abnf::cst)
                                    3))))
 (let ((__function__ 'cst-whitespace-conc3))
   (declare (ignorable __function__))
   (abnf::tree-nonleaf->branches abnf::cst)))

Theorem: tree-list-listp-of-cst-whitespace-conc3

(defthm tree-list-listp-of-cst-whitespace-conc3
  (b* ((abnf::cstss (cst-whitespace-conc3 abnf::cst)))
    (abnf::tree-list-listp abnf::cstss))
  :rule-classes :rewrite)

Theorem: cst-whitespace-conc3-match

(defthm cst-whitespace-conc3-match
  (implies
       (and (cst-matchp abnf::cst "whitespace")
            (equal (cst-whitespace-conc? abnf::cst)
                   3))
       (b* ((abnf::cstss (cst-whitespace-conc3 abnf::cst)))
         (cst-list-list-conc-matchp abnf::cstss "line-terminator")))
  :rule-classes :rewrite)

Theorem: cst-whitespace-conc3-of-tree-fix-cst

(defthm cst-whitespace-conc3-of-tree-fix-cst
  (equal (cst-whitespace-conc3 (abnf::tree-fix abnf::cst))
         (cst-whitespace-conc3 abnf::cst)))

Theorem: cst-whitespace-conc3-tree-equiv-congruence-on-cst

(defthm cst-whitespace-conc3-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-whitespace-conc3 abnf::cst)
                  (cst-whitespace-conc3 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 "block-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 "line-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-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-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
                  "\"//\" *not-line-feed-or-carriage-return")))
  :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-line-feed-or-carriage-return-conc1

(defun cst-not-line-feed-or-carriage-return-conc1 (abnf::cst)
 (declare (xargs :guard (abnf::treep abnf::cst)))
 (declare
  (xargs
   :guard
   (and
       (cst-matchp abnf::cst
                   "not-line-feed-or-carriage-return")
       (equal (cst-not-line-feed-or-carriage-return-conc? abnf::cst)
              1))))
 (let ((__function__ 'cst-not-line-feed-or-carriage-return-conc1))
   (declare (ignorable __function__))
   (abnf::tree-nonleaf->branches abnf::cst)))

Theorem: tree-list-listp-of-cst-not-line-feed-or-carriage-return-conc1

(defthm
      tree-list-listp-of-cst-not-line-feed-or-carriage-return-conc1
  (b* ((abnf::cstss
            (cst-not-line-feed-or-carriage-return-conc1 abnf::cst)))
    (abnf::tree-list-listp abnf::cstss))
  :rule-classes :rewrite)

Theorem: cst-not-line-feed-or-carriage-return-conc1-match

(defthm cst-not-line-feed-or-carriage-return-conc1-match
 (implies
  (and (cst-matchp abnf::cst
                   "not-line-feed-or-carriage-return")
       (equal (cst-not-line-feed-or-carriage-return-conc? abnf::cst)
              1))
  (b* ((abnf::cstss
            (cst-not-line-feed-or-carriage-return-conc1 abnf::cst)))
    (cst-list-list-conc-matchp abnf::cstss "horizontal-tab")))
 :rule-classes :rewrite)

Theorem: cst-not-line-feed-or-carriage-return-conc1-of-tree-fix-cst

(defthm cst-not-line-feed-or-carriage-return-conc1-of-tree-fix-cst
  (equal (cst-not-line-feed-or-carriage-return-conc1
              (abnf::tree-fix abnf::cst))
         (cst-not-line-feed-or-carriage-return-conc1 abnf::cst)))

Theorem: cst-not-line-feed-or-carriage-return-conc1-tree-equiv-congruence-on-cst

(defthm
 cst-not-line-feed-or-carriage-return-conc1-tree-equiv-congruence-on-cst
 (implies
     (abnf::tree-equiv abnf::cst cst-equiv)
     (equal (cst-not-line-feed-or-carriage-return-conc1 abnf::cst)
            (cst-not-line-feed-or-carriage-return-conc1 cst-equiv)))
 :rule-classes :congruence)

Function: cst-not-line-feed-or-carriage-return-conc2

(defun cst-not-line-feed-or-carriage-return-conc2 (abnf::cst)
 (declare (xargs :guard (abnf::treep abnf::cst)))
 (declare
  (xargs
   :guard
   (and
       (cst-matchp abnf::cst
                   "not-line-feed-or-carriage-return")
       (equal (cst-not-line-feed-or-carriage-return-conc? abnf::cst)
              2))))
 (let ((__function__ 'cst-not-line-feed-or-carriage-return-conc2))
   (declare (ignorable __function__))
   (abnf::tree-nonleaf->branches abnf::cst)))

Theorem: tree-list-listp-of-cst-not-line-feed-or-carriage-return-conc2

(defthm
      tree-list-listp-of-cst-not-line-feed-or-carriage-return-conc2
  (b* ((abnf::cstss
            (cst-not-line-feed-or-carriage-return-conc2 abnf::cst)))
    (abnf::tree-list-listp abnf::cstss))
  :rule-classes :rewrite)

Theorem: cst-not-line-feed-or-carriage-return-conc2-match

(defthm cst-not-line-feed-or-carriage-return-conc2-match
 (implies
  (and (cst-matchp abnf::cst
                   "not-line-feed-or-carriage-return")
       (equal (cst-not-line-feed-or-carriage-return-conc? abnf::cst)
              2))
  (b* ((abnf::cstss
            (cst-not-line-feed-or-carriage-return-conc2 abnf::cst)))
    (cst-list-list-conc-matchp abnf::cstss "space")))
 :rule-classes :rewrite)

Theorem: cst-not-line-feed-or-carriage-return-conc2-of-tree-fix-cst

(defthm cst-not-line-feed-or-carriage-return-conc2-of-tree-fix-cst
  (equal (cst-not-line-feed-or-carriage-return-conc2
              (abnf::tree-fix abnf::cst))
         (cst-not-line-feed-or-carriage-return-conc2 abnf::cst)))

Theorem: cst-not-line-feed-or-carriage-return-conc2-tree-equiv-congruence-on-cst

(defthm
 cst-not-line-feed-or-carriage-return-conc2-tree-equiv-congruence-on-cst
 (implies
     (abnf::tree-equiv abnf::cst cst-equiv)
     (equal (cst-not-line-feed-or-carriage-return-conc2 abnf::cst)
            (cst-not-line-feed-or-carriage-return-conc2 cst-equiv)))
 :rule-classes :congruence)

Function: cst-not-line-feed-or-carriage-return-conc3

(defun cst-not-line-feed-or-carriage-return-conc3 (abnf::cst)
 (declare (xargs :guard (abnf::treep abnf::cst)))
 (declare
  (xargs
   :guard
   (and
       (cst-matchp abnf::cst
                   "not-line-feed-or-carriage-return")
       (equal (cst-not-line-feed-or-carriage-return-conc? abnf::cst)
              3))))
 (let ((__function__ 'cst-not-line-feed-or-carriage-return-conc3))
   (declare (ignorable __function__))
   (abnf::tree-nonleaf->branches abnf::cst)))

Theorem: tree-list-listp-of-cst-not-line-feed-or-carriage-return-conc3

(defthm
      tree-list-listp-of-cst-not-line-feed-or-carriage-return-conc3
  (b* ((abnf::cstss
            (cst-not-line-feed-or-carriage-return-conc3 abnf::cst)))
    (abnf::tree-list-listp abnf::cstss))
  :rule-classes :rewrite)

Theorem: cst-not-line-feed-or-carriage-return-conc3-match

(defthm cst-not-line-feed-or-carriage-return-conc3-match
 (implies
  (and (cst-matchp abnf::cst
                   "not-line-feed-or-carriage-return")
       (equal (cst-not-line-feed-or-carriage-return-conc? abnf::cst)
              3))
  (b* ((abnf::cstss
            (cst-not-line-feed-or-carriage-return-conc3 abnf::cst)))
    (cst-list-list-conc-matchp abnf::cstss "visible-ascii")))
 :rule-classes :rewrite)

Theorem: cst-not-line-feed-or-carriage-return-conc3-of-tree-fix-cst

(defthm cst-not-line-feed-or-carriage-return-conc3-of-tree-fix-cst
  (equal (cst-not-line-feed-or-carriage-return-conc3
              (abnf::tree-fix abnf::cst))
         (cst-not-line-feed-or-carriage-return-conc3 abnf::cst)))

Theorem: cst-not-line-feed-or-carriage-return-conc3-tree-equiv-congruence-on-cst

(defthm
 cst-not-line-feed-or-carriage-return-conc3-tree-equiv-congruence-on-cst
 (implies
     (abnf::tree-equiv abnf::cst cst-equiv)
     (equal (cst-not-line-feed-or-carriage-return-conc3 abnf::cst)
            (cst-not-line-feed-or-carriage-return-conc3 cst-equiv)))
 :rule-classes :congruence)

Function: cst-not-line-feed-or-carriage-return-conc4

(defun cst-not-line-feed-or-carriage-return-conc4 (abnf::cst)
 (declare (xargs :guard (abnf::treep abnf::cst)))
 (declare
  (xargs
   :guard
   (and
       (cst-matchp abnf::cst
                   "not-line-feed-or-carriage-return")
       (equal (cst-not-line-feed-or-carriage-return-conc? abnf::cst)
              4))))
 (let ((__function__ 'cst-not-line-feed-or-carriage-return-conc4))
   (declare (ignorable __function__))
   (abnf::tree-nonleaf->branches abnf::cst)))

Theorem: tree-list-listp-of-cst-not-line-feed-or-carriage-return-conc4

(defthm
      tree-list-listp-of-cst-not-line-feed-or-carriage-return-conc4
  (b* ((abnf::cstss
            (cst-not-line-feed-or-carriage-return-conc4 abnf::cst)))
    (abnf::tree-list-listp abnf::cstss))
  :rule-classes :rewrite)

Theorem: cst-not-line-feed-or-carriage-return-conc4-match

(defthm cst-not-line-feed-or-carriage-return-conc4-match
 (implies
  (and (cst-matchp abnf::cst
                   "not-line-feed-or-carriage-return")
       (equal (cst-not-line-feed-or-carriage-return-conc? abnf::cst)
              4))
  (b* ((abnf::cstss
            (cst-not-line-feed-or-carriage-return-conc4 abnf::cst)))
    (cst-list-list-conc-matchp abnf::cstss "safe-nonascii")))
 :rule-classes :rewrite)

Theorem: cst-not-line-feed-or-carriage-return-conc4-of-tree-fix-cst

(defthm cst-not-line-feed-or-carriage-return-conc4-of-tree-fix-cst
  (equal (cst-not-line-feed-or-carriage-return-conc4
              (abnf::tree-fix abnf::cst))
         (cst-not-line-feed-or-carriage-return-conc4 abnf::cst)))

Theorem: cst-not-line-feed-or-carriage-return-conc4-tree-equiv-congruence-on-cst

(defthm
 cst-not-line-feed-or-carriage-return-conc4-tree-equiv-congruence-on-cst
 (implies
     (abnf::tree-equiv abnf::cst cst-equiv)
     (equal (cst-not-line-feed-or-carriage-return-conc4 abnf::cst)
            (cst-not-line-feed-or-carriage-return-conc4 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-decimal-digit-conc

(defun cst-decimal-digit-conc (abnf::cst)
  (declare (xargs :guard (abnf::treep abnf::cst)))
  (declare (xargs :guard (cst-matchp abnf::cst "decimal-digit")))
  (let ((__function__ 'cst-decimal-digit-conc))
    (declare (ignorable __function__))
    (abnf::tree-nonleaf->branches abnf::cst)))

Theorem: tree-list-listp-of-cst-decimal-digit-conc

(defthm tree-list-listp-of-cst-decimal-digit-conc
  (b* ((abnf::cstss (cst-decimal-digit-conc abnf::cst)))
    (abnf::tree-list-listp abnf::cstss))
  :rule-classes :rewrite)

Theorem: cst-decimal-digit-conc-match

(defthm cst-decimal-digit-conc-match
  (implies (cst-matchp abnf::cst "decimal-digit")
           (b* ((abnf::cstss (cst-decimal-digit-conc abnf::cst)))
             (cst-list-list-conc-matchp abnf::cstss "%x30-39")))
  :rule-classes :rewrite)

Theorem: cst-decimal-digit-conc-of-tree-fix-cst

(defthm cst-decimal-digit-conc-of-tree-fix-cst
  (equal (cst-decimal-digit-conc (abnf::tree-fix abnf::cst))
         (cst-decimal-digit-conc abnf::cst)))

Theorem: cst-decimal-digit-conc-tree-equiv-congruence-on-cst

(defthm cst-decimal-digit-conc-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-decimal-digit-conc abnf::cst)
                  (cst-decimal-digit-conc cst-equiv)))
  :rule-classes :congruence)

Function: cst-octal-digit-conc

(defun cst-octal-digit-conc (abnf::cst)
  (declare (xargs :guard (abnf::treep abnf::cst)))
  (declare (xargs :guard (cst-matchp abnf::cst "octal-digit")))
  (let ((__function__ 'cst-octal-digit-conc))
    (declare (ignorable __function__))
    (abnf::tree-nonleaf->branches abnf::cst)))

Theorem: tree-list-listp-of-cst-octal-digit-conc

(defthm tree-list-listp-of-cst-octal-digit-conc
  (b* ((abnf::cstss (cst-octal-digit-conc abnf::cst)))
    (abnf::tree-list-listp abnf::cstss))
  :rule-classes :rewrite)

Theorem: cst-octal-digit-conc-match

(defthm cst-octal-digit-conc-match
  (implies (cst-matchp abnf::cst "octal-digit")
           (b* ((abnf::cstss (cst-octal-digit-conc abnf::cst)))
             (cst-list-list-conc-matchp abnf::cstss "%x30-37")))
  :rule-classes :rewrite)

Theorem: cst-octal-digit-conc-of-tree-fix-cst

(defthm cst-octal-digit-conc-of-tree-fix-cst
  (equal (cst-octal-digit-conc (abnf::tree-fix abnf::cst))
         (cst-octal-digit-conc abnf::cst)))

Theorem: cst-octal-digit-conc-tree-equiv-congruence-on-cst

(defthm cst-octal-digit-conc-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-octal-digit-conc abnf::cst)
                  (cst-octal-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 / decimal-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-numeral-conc

(defun cst-numeral-conc (abnf::cst)
  (declare (xargs :guard (abnf::treep abnf::cst)))
  (declare (xargs :guard (cst-matchp abnf::cst "numeral")))
  (let ((__function__ 'cst-numeral-conc))
    (declare (ignorable __function__))
    (abnf::tree-nonleaf->branches abnf::cst)))

Theorem: tree-list-listp-of-cst-numeral-conc

(defthm tree-list-listp-of-cst-numeral-conc
  (b* ((abnf::cstss (cst-numeral-conc abnf::cst)))
    (abnf::tree-list-listp abnf::cstss))
  :rule-classes :rewrite)

Theorem: cst-numeral-conc-match

(defthm cst-numeral-conc-match
  (implies
       (cst-matchp abnf::cst "numeral")
       (b* ((abnf::cstss (cst-numeral-conc abnf::cst)))
         (cst-list-list-conc-matchp abnf::cstss "1*decimal-digit")))
  :rule-classes :rewrite)

Theorem: cst-numeral-conc-of-tree-fix-cst

(defthm cst-numeral-conc-of-tree-fix-cst
  (equal (cst-numeral-conc (abnf::tree-fix abnf::cst))
         (cst-numeral-conc abnf::cst)))

Theorem: cst-numeral-conc-tree-equiv-congruence-on-cst

(defthm cst-numeral-conc-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-numeral-conc abnf::cst)
                  (cst-numeral-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
    "numeral ( %s\"u8\" / %s\"u16\" / %s\"u32\" / %s\"u64\" / %s\"u128\" )")))
 :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-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
    "numeral ( %s\"i8\" / %s\"i16\" / %s\"i32\" / %s\"i64\" / %s\"i128\" )")))
 :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-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 "numeral %s\"field\"")))
 :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-product-group-literal-conc

(defun cst-product-group-literal-conc (abnf::cst)
 (declare (xargs :guard (abnf::treep abnf::cst)))
 (declare
      (xargs :guard (cst-matchp abnf::cst "product-group-literal")))
 (let ((__function__ 'cst-product-group-literal-conc))
   (declare (ignorable __function__))
   (abnf::tree-nonleaf->branches abnf::cst)))

Theorem: tree-list-listp-of-cst-product-group-literal-conc

(defthm tree-list-listp-of-cst-product-group-literal-conc
  (b* ((abnf::cstss (cst-product-group-literal-conc abnf::cst)))
    (abnf::tree-list-listp abnf::cstss))
  :rule-classes :rewrite)

Theorem: cst-product-group-literal-conc-match

(defthm cst-product-group-literal-conc-match
 (implies
     (cst-matchp abnf::cst "product-group-literal")
     (b* ((abnf::cstss (cst-product-group-literal-conc abnf::cst)))
       (cst-list-list-conc-matchp abnf::cstss "numeral %s\"group\"")))
 :rule-classes :rewrite)

Theorem: cst-product-group-literal-conc-of-tree-fix-cst

(defthm cst-product-group-literal-conc-of-tree-fix-cst
  (equal (cst-product-group-literal-conc (abnf::tree-fix abnf::cst))
         (cst-product-group-literal-conc abnf::cst)))

Theorem: cst-product-group-literal-conc-tree-equiv-congruence-on-cst

(defthm cst-product-group-literal-conc-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-product-group-literal-conc abnf::cst)
                  (cst-product-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 "numeral %s\"scalar\"")))
 :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-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\" 58( lowercase-letter / decimal-digit )")))
  :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-single-quote-conc

(defun cst-single-quote-conc (abnf::cst)
  (declare (xargs :guard (abnf::treep abnf::cst)))
  (declare (xargs :guard (cst-matchp abnf::cst "single-quote")))
  (let ((__function__ 'cst-single-quote-conc))
    (declare (ignorable __function__))
    (abnf::tree-nonleaf->branches abnf::cst)))

Theorem: tree-list-listp-of-cst-single-quote-conc

(defthm tree-list-listp-of-cst-single-quote-conc
  (b* ((abnf::cstss (cst-single-quote-conc abnf::cst)))
    (abnf::tree-list-listp abnf::cstss))
  :rule-classes :rewrite)

Theorem: cst-single-quote-conc-match

(defthm cst-single-quote-conc-match
  (implies (cst-matchp abnf::cst "single-quote")
           (b* ((abnf::cstss (cst-single-quote-conc abnf::cst)))
             (cst-list-list-conc-matchp abnf::cstss "%x27")))
  :rule-classes :rewrite)

Theorem: cst-single-quote-conc-of-tree-fix-cst

(defthm cst-single-quote-conc-of-tree-fix-cst
  (equal (cst-single-quote-conc (abnf::tree-fix abnf::cst))
         (cst-single-quote-conc abnf::cst)))

Theorem: cst-single-quote-conc-tree-equiv-congruence-on-cst

(defthm cst-single-quote-conc-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-single-quote-conc abnf::cst)
                  (cst-single-quote-conc cst-equiv)))
  :rule-classes :congruence)

Function: cst-double-quote-conc

(defun cst-double-quote-conc (abnf::cst)
  (declare (xargs :guard (abnf::treep abnf::cst)))
  (declare (xargs :guard (cst-matchp abnf::cst "double-quote")))
  (let ((__function__ 'cst-double-quote-conc))
    (declare (ignorable __function__))
    (abnf::tree-nonleaf->branches abnf::cst)))

Theorem: tree-list-listp-of-cst-double-quote-conc

(defthm tree-list-listp-of-cst-double-quote-conc
  (b* ((abnf::cstss (cst-double-quote-conc abnf::cst)))
    (abnf::tree-list-listp abnf::cstss))
  :rule-classes :rewrite)

Theorem: cst-double-quote-conc-match

(defthm cst-double-quote-conc-match
  (implies (cst-matchp abnf::cst "double-quote")
           (b* ((abnf::cstss (cst-double-quote-conc abnf::cst)))
             (cst-list-list-conc-matchp abnf::cstss "%x22")))
  :rule-classes :rewrite)

Theorem: cst-double-quote-conc-of-tree-fix-cst

(defthm cst-double-quote-conc-of-tree-fix-cst
  (equal (cst-double-quote-conc (abnf::tree-fix abnf::cst))
         (cst-double-quote-conc abnf::cst)))

Theorem: cst-double-quote-conc-tree-equiv-congruence-on-cst

(defthm cst-double-quote-conc-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-double-quote-conc abnf::cst)
                  (cst-double-quote-conc cst-equiv)))
  :rule-classes :congruence)

Function: cst-single-quote-escape-conc

(defun cst-single-quote-escape-conc (abnf::cst)
  (declare (xargs :guard (abnf::treep abnf::cst)))
  (declare
       (xargs :guard (cst-matchp abnf::cst "single-quote-escape")))
  (let ((__function__ 'cst-single-quote-escape-conc))
    (declare (ignorable __function__))
    (abnf::tree-nonleaf->branches abnf::cst)))

Theorem: tree-list-listp-of-cst-single-quote-escape-conc

(defthm tree-list-listp-of-cst-single-quote-escape-conc
  (b* ((abnf::cstss (cst-single-quote-escape-conc abnf::cst)))
    (abnf::tree-list-listp abnf::cstss))
  :rule-classes :rewrite)

Theorem: cst-single-quote-escape-conc-match

(defthm cst-single-quote-escape-conc-match
 (implies
      (cst-matchp abnf::cst "single-quote-escape")
      (b* ((abnf::cstss (cst-single-quote-escape-conc abnf::cst)))
        (cst-list-list-conc-matchp abnf::cstss "\"\\\" single-quote")))
 :rule-classes :rewrite)

Theorem: cst-single-quote-escape-conc-of-tree-fix-cst

(defthm cst-single-quote-escape-conc-of-tree-fix-cst
  (equal (cst-single-quote-escape-conc (abnf::tree-fix abnf::cst))
         (cst-single-quote-escape-conc abnf::cst)))

Theorem: cst-single-quote-escape-conc-tree-equiv-congruence-on-cst

(defthm cst-single-quote-escape-conc-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-single-quote-escape-conc abnf::cst)
                  (cst-single-quote-escape-conc cst-equiv)))
  :rule-classes :congruence)

Function: cst-double-quote-escape-conc

(defun cst-double-quote-escape-conc (abnf::cst)
  (declare (xargs :guard (abnf::treep abnf::cst)))
  (declare
       (xargs :guard (cst-matchp abnf::cst "double-quote-escape")))
  (let ((__function__ 'cst-double-quote-escape-conc))
    (declare (ignorable __function__))
    (abnf::tree-nonleaf->branches abnf::cst)))

Theorem: tree-list-listp-of-cst-double-quote-escape-conc

(defthm tree-list-listp-of-cst-double-quote-escape-conc
  (b* ((abnf::cstss (cst-double-quote-escape-conc abnf::cst)))
    (abnf::tree-list-listp abnf::cstss))
  :rule-classes :rewrite)

Theorem: cst-double-quote-escape-conc-match

(defthm cst-double-quote-escape-conc-match
 (implies
      (cst-matchp abnf::cst "double-quote-escape")
      (b* ((abnf::cstss (cst-double-quote-escape-conc abnf::cst)))
        (cst-list-list-conc-matchp abnf::cstss "\"\\\" double-quote")))
 :rule-classes :rewrite)

Theorem: cst-double-quote-escape-conc-of-tree-fix-cst

(defthm cst-double-quote-escape-conc-of-tree-fix-cst
  (equal (cst-double-quote-escape-conc (abnf::tree-fix abnf::cst))
         (cst-double-quote-escape-conc abnf::cst)))

Theorem: cst-double-quote-escape-conc-tree-equiv-congruence-on-cst

(defthm cst-double-quote-escape-conc-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-double-quote-escape-conc abnf::cst)
                  (cst-double-quote-escape-conc cst-equiv)))
  :rule-classes :congruence)

Function: cst-backslash-escape-conc

(defun cst-backslash-escape-conc (abnf::cst)
  (declare (xargs :guard (abnf::treep abnf::cst)))
  (declare (xargs :guard (cst-matchp abnf::cst "backslash-escape")))
  (let ((__function__ 'cst-backslash-escape-conc))
    (declare (ignorable __function__))
    (abnf::tree-nonleaf->branches abnf::cst)))

Theorem: tree-list-listp-of-cst-backslash-escape-conc

(defthm tree-list-listp-of-cst-backslash-escape-conc
  (b* ((abnf::cstss (cst-backslash-escape-conc abnf::cst)))
    (abnf::tree-list-listp abnf::cstss))
  :rule-classes :rewrite)

Theorem: cst-backslash-escape-conc-match

(defthm cst-backslash-escape-conc-match
  (implies (cst-matchp abnf::cst "backslash-escape")
           (b* ((abnf::cstss (cst-backslash-escape-conc abnf::cst)))
             (cst-list-list-conc-matchp abnf::cstss "\"\\\\\"")))
  :rule-classes :rewrite)

Theorem: cst-backslash-escape-conc-of-tree-fix-cst

(defthm cst-backslash-escape-conc-of-tree-fix-cst
  (equal (cst-backslash-escape-conc (abnf::tree-fix abnf::cst))
         (cst-backslash-escape-conc abnf::cst)))

Theorem: cst-backslash-escape-conc-tree-equiv-congruence-on-cst

(defthm cst-backslash-escape-conc-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-backslash-escape-conc abnf::cst)
                  (cst-backslash-escape-conc cst-equiv)))
  :rule-classes :congruence)

Function: cst-line-feed-escape-conc

(defun cst-line-feed-escape-conc (abnf::cst)
  (declare (xargs :guard (abnf::treep abnf::cst)))
  (declare (xargs :guard (cst-matchp abnf::cst "line-feed-escape")))
  (let ((__function__ 'cst-line-feed-escape-conc))
    (declare (ignorable __function__))
    (abnf::tree-nonleaf->branches abnf::cst)))

Theorem: tree-list-listp-of-cst-line-feed-escape-conc

(defthm tree-list-listp-of-cst-line-feed-escape-conc
  (b* ((abnf::cstss (cst-line-feed-escape-conc abnf::cst)))
    (abnf::tree-list-listp abnf::cstss))
  :rule-classes :rewrite)

Theorem: cst-line-feed-escape-conc-match

(defthm cst-line-feed-escape-conc-match
  (implies (cst-matchp abnf::cst "line-feed-escape")
           (b* ((abnf::cstss (cst-line-feed-escape-conc abnf::cst)))
             (cst-list-list-conc-matchp abnf::cstss "%s\"\\n\"")))
  :rule-classes :rewrite)

Theorem: cst-line-feed-escape-conc-of-tree-fix-cst

(defthm cst-line-feed-escape-conc-of-tree-fix-cst
  (equal (cst-line-feed-escape-conc (abnf::tree-fix abnf::cst))
         (cst-line-feed-escape-conc abnf::cst)))

Theorem: cst-line-feed-escape-conc-tree-equiv-congruence-on-cst

(defthm cst-line-feed-escape-conc-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-line-feed-escape-conc abnf::cst)
                  (cst-line-feed-escape-conc cst-equiv)))
  :rule-classes :congruence)

Function: cst-carriage-return-escape-conc

(defun cst-carriage-return-escape-conc (abnf::cst)
 (declare (xargs :guard (abnf::treep abnf::cst)))
 (declare
     (xargs :guard (cst-matchp abnf::cst "carriage-return-escape")))
 (let ((__function__ 'cst-carriage-return-escape-conc))
   (declare (ignorable __function__))
   (abnf::tree-nonleaf->branches abnf::cst)))

Theorem: tree-list-listp-of-cst-carriage-return-escape-conc

(defthm tree-list-listp-of-cst-carriage-return-escape-conc
  (b* ((abnf::cstss (cst-carriage-return-escape-conc abnf::cst)))
    (abnf::tree-list-listp abnf::cstss))
  :rule-classes :rewrite)

Theorem: cst-carriage-return-escape-conc-match

(defthm cst-carriage-return-escape-conc-match
 (implies
     (cst-matchp abnf::cst "carriage-return-escape")
     (b* ((abnf::cstss (cst-carriage-return-escape-conc abnf::cst)))
       (cst-list-list-conc-matchp abnf::cstss "%s\"\\r\"")))
 :rule-classes :rewrite)

Theorem: cst-carriage-return-escape-conc-of-tree-fix-cst

(defthm cst-carriage-return-escape-conc-of-tree-fix-cst
 (equal (cst-carriage-return-escape-conc (abnf::tree-fix abnf::cst))
        (cst-carriage-return-escape-conc abnf::cst)))

Theorem: cst-carriage-return-escape-conc-tree-equiv-congruence-on-cst

(defthm cst-carriage-return-escape-conc-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-carriage-return-escape-conc abnf::cst)
                  (cst-carriage-return-escape-conc cst-equiv)))
  :rule-classes :congruence)

Function: cst-horizontal-tab-escape-conc

(defun cst-horizontal-tab-escape-conc (abnf::cst)
 (declare (xargs :guard (abnf::treep abnf::cst)))
 (declare
      (xargs :guard (cst-matchp abnf::cst "horizontal-tab-escape")))
 (let ((__function__ 'cst-horizontal-tab-escape-conc))
   (declare (ignorable __function__))
   (abnf::tree-nonleaf->branches abnf::cst)))

Theorem: tree-list-listp-of-cst-horizontal-tab-escape-conc

(defthm tree-list-listp-of-cst-horizontal-tab-escape-conc
  (b* ((abnf::cstss (cst-horizontal-tab-escape-conc abnf::cst)))
    (abnf::tree-list-listp abnf::cstss))
  :rule-classes :rewrite)

Theorem: cst-horizontal-tab-escape-conc-match

(defthm cst-horizontal-tab-escape-conc-match
 (implies
      (cst-matchp abnf::cst "horizontal-tab-escape")
      (b* ((abnf::cstss (cst-horizontal-tab-escape-conc abnf::cst)))
        (cst-list-list-conc-matchp abnf::cstss "%s\"\\t\"")))
 :rule-classes :rewrite)

Theorem: cst-horizontal-tab-escape-conc-of-tree-fix-cst

(defthm cst-horizontal-tab-escape-conc-of-tree-fix-cst
  (equal (cst-horizontal-tab-escape-conc (abnf::tree-fix abnf::cst))
         (cst-horizontal-tab-escape-conc abnf::cst)))

Theorem: cst-horizontal-tab-escape-conc-tree-equiv-congruence-on-cst

(defthm cst-horizontal-tab-escape-conc-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-horizontal-tab-escape-conc abnf::cst)
                  (cst-horizontal-tab-escape-conc cst-equiv)))
  :rule-classes :congruence)

Function: cst-null-character-escape-conc

(defun cst-null-character-escape-conc (abnf::cst)
 (declare (xargs :guard (abnf::treep abnf::cst)))
 (declare
      (xargs :guard (cst-matchp abnf::cst "null-character-escape")))
 (let ((__function__ 'cst-null-character-escape-conc))
   (declare (ignorable __function__))
   (abnf::tree-nonleaf->branches abnf::cst)))

Theorem: tree-list-listp-of-cst-null-character-escape-conc

(defthm tree-list-listp-of-cst-null-character-escape-conc
  (b* ((abnf::cstss (cst-null-character-escape-conc abnf::cst)))
    (abnf::tree-list-listp abnf::cstss))
  :rule-classes :rewrite)

Theorem: cst-null-character-escape-conc-match

(defthm cst-null-character-escape-conc-match
 (implies
      (cst-matchp abnf::cst "null-character-escape")
      (b* ((abnf::cstss (cst-null-character-escape-conc abnf::cst)))
        (cst-list-list-conc-matchp abnf::cstss "\"\\0\"")))
 :rule-classes :rewrite)

Theorem: cst-null-character-escape-conc-of-tree-fix-cst

(defthm cst-null-character-escape-conc-of-tree-fix-cst
  (equal (cst-null-character-escape-conc (abnf::tree-fix abnf::cst))
         (cst-null-character-escape-conc abnf::cst)))

Theorem: cst-null-character-escape-conc-tree-equiv-congruence-on-cst

(defthm cst-null-character-escape-conc-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-null-character-escape-conc abnf::cst)
                  (cst-null-character-escape-conc cst-equiv)))
  :rule-classes :congruence)

Function: cst-simple-character-escape-conc1

(defun cst-simple-character-escape-conc1 (abnf::cst)
 (declare (xargs :guard (abnf::treep abnf::cst)))
 (declare
  (xargs
    :guard (and (cst-matchp abnf::cst "simple-character-escape")
                (equal (cst-simple-character-escape-conc? abnf::cst)
                       1))))
 (let ((__function__ 'cst-simple-character-escape-conc1))
   (declare (ignorable __function__))
   (abnf::tree-nonleaf->branches abnf::cst)))

Theorem: tree-list-listp-of-cst-simple-character-escape-conc1

(defthm tree-list-listp-of-cst-simple-character-escape-conc1
  (b* ((abnf::cstss (cst-simple-character-escape-conc1 abnf::cst)))
    (abnf::tree-list-listp abnf::cstss))
  :rule-classes :rewrite)

Theorem: cst-simple-character-escape-conc1-match

(defthm cst-simple-character-escape-conc1-match
 (implies
   (and (cst-matchp abnf::cst "simple-character-escape")
        (equal (cst-simple-character-escape-conc? abnf::cst)
               1))
   (b* ((abnf::cstss (cst-simple-character-escape-conc1 abnf::cst)))
     (cst-list-list-conc-matchp abnf::cstss "single-quote-escape")))
 :rule-classes :rewrite)

Theorem: cst-simple-character-escape-conc1-of-tree-fix-cst

(defthm cst-simple-character-escape-conc1-of-tree-fix-cst
 (equal
      (cst-simple-character-escape-conc1 (abnf::tree-fix abnf::cst))
      (cst-simple-character-escape-conc1 abnf::cst)))

Theorem: cst-simple-character-escape-conc1-tree-equiv-congruence-on-cst

(defthm
     cst-simple-character-escape-conc1-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-simple-character-escape-conc1 abnf::cst)
                  (cst-simple-character-escape-conc1 cst-equiv)))
  :rule-classes :congruence)

Function: cst-simple-character-escape-conc2

(defun cst-simple-character-escape-conc2 (abnf::cst)
 (declare (xargs :guard (abnf::treep abnf::cst)))
 (declare
  (xargs
    :guard (and (cst-matchp abnf::cst "simple-character-escape")
                (equal (cst-simple-character-escape-conc? abnf::cst)
                       2))))
 (let ((__function__ 'cst-simple-character-escape-conc2))
   (declare (ignorable __function__))
   (abnf::tree-nonleaf->branches abnf::cst)))

Theorem: tree-list-listp-of-cst-simple-character-escape-conc2

(defthm tree-list-listp-of-cst-simple-character-escape-conc2
  (b* ((abnf::cstss (cst-simple-character-escape-conc2 abnf::cst)))
    (abnf::tree-list-listp abnf::cstss))
  :rule-classes :rewrite)

Theorem: cst-simple-character-escape-conc2-match

(defthm cst-simple-character-escape-conc2-match
 (implies
   (and (cst-matchp abnf::cst "simple-character-escape")
        (equal (cst-simple-character-escape-conc? abnf::cst)
               2))
   (b* ((abnf::cstss (cst-simple-character-escape-conc2 abnf::cst)))
     (cst-list-list-conc-matchp abnf::cstss "double-quote-escape")))
 :rule-classes :rewrite)

Theorem: cst-simple-character-escape-conc2-of-tree-fix-cst

(defthm cst-simple-character-escape-conc2-of-tree-fix-cst
 (equal
      (cst-simple-character-escape-conc2 (abnf::tree-fix abnf::cst))
      (cst-simple-character-escape-conc2 abnf::cst)))

Theorem: cst-simple-character-escape-conc2-tree-equiv-congruence-on-cst

(defthm
     cst-simple-character-escape-conc2-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-simple-character-escape-conc2 abnf::cst)
                  (cst-simple-character-escape-conc2 cst-equiv)))
  :rule-classes :congruence)

Function: cst-simple-character-escape-conc3

(defun cst-simple-character-escape-conc3 (abnf::cst)
 (declare (xargs :guard (abnf::treep abnf::cst)))
 (declare
  (xargs
    :guard (and (cst-matchp abnf::cst "simple-character-escape")
                (equal (cst-simple-character-escape-conc? abnf::cst)
                       3))))
 (let ((__function__ 'cst-simple-character-escape-conc3))
   (declare (ignorable __function__))
   (abnf::tree-nonleaf->branches abnf::cst)))

Theorem: tree-list-listp-of-cst-simple-character-escape-conc3

(defthm tree-list-listp-of-cst-simple-character-escape-conc3
  (b* ((abnf::cstss (cst-simple-character-escape-conc3 abnf::cst)))
    (abnf::tree-list-listp abnf::cstss))
  :rule-classes :rewrite)

Theorem: cst-simple-character-escape-conc3-match

(defthm cst-simple-character-escape-conc3-match
 (implies
   (and (cst-matchp abnf::cst "simple-character-escape")
        (equal (cst-simple-character-escape-conc? abnf::cst)
               3))
   (b* ((abnf::cstss (cst-simple-character-escape-conc3 abnf::cst)))
     (cst-list-list-conc-matchp abnf::cstss "backslash-escape")))
 :rule-classes :rewrite)

Theorem: cst-simple-character-escape-conc3-of-tree-fix-cst

(defthm cst-simple-character-escape-conc3-of-tree-fix-cst
 (equal
      (cst-simple-character-escape-conc3 (abnf::tree-fix abnf::cst))
      (cst-simple-character-escape-conc3 abnf::cst)))

Theorem: cst-simple-character-escape-conc3-tree-equiv-congruence-on-cst

(defthm
     cst-simple-character-escape-conc3-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-simple-character-escape-conc3 abnf::cst)
                  (cst-simple-character-escape-conc3 cst-equiv)))
  :rule-classes :congruence)

Function: cst-simple-character-escape-conc4

(defun cst-simple-character-escape-conc4 (abnf::cst)
 (declare (xargs :guard (abnf::treep abnf::cst)))
 (declare
  (xargs
    :guard (and (cst-matchp abnf::cst "simple-character-escape")
                (equal (cst-simple-character-escape-conc? abnf::cst)
                       4))))
 (let ((__function__ 'cst-simple-character-escape-conc4))
   (declare (ignorable __function__))
   (abnf::tree-nonleaf->branches abnf::cst)))

Theorem: tree-list-listp-of-cst-simple-character-escape-conc4

(defthm tree-list-listp-of-cst-simple-character-escape-conc4
  (b* ((abnf::cstss (cst-simple-character-escape-conc4 abnf::cst)))
    (abnf::tree-list-listp abnf::cstss))
  :rule-classes :rewrite)

Theorem: cst-simple-character-escape-conc4-match

(defthm cst-simple-character-escape-conc4-match
 (implies
   (and (cst-matchp abnf::cst "simple-character-escape")
        (equal (cst-simple-character-escape-conc? abnf::cst)
               4))
   (b* ((abnf::cstss (cst-simple-character-escape-conc4 abnf::cst)))
     (cst-list-list-conc-matchp abnf::cstss "line-feed-escape")))
 :rule-classes :rewrite)

Theorem: cst-simple-character-escape-conc4-of-tree-fix-cst

(defthm cst-simple-character-escape-conc4-of-tree-fix-cst
 (equal
      (cst-simple-character-escape-conc4 (abnf::tree-fix abnf::cst))
      (cst-simple-character-escape-conc4 abnf::cst)))

Theorem: cst-simple-character-escape-conc4-tree-equiv-congruence-on-cst

(defthm
     cst-simple-character-escape-conc4-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-simple-character-escape-conc4 abnf::cst)
                  (cst-simple-character-escape-conc4 cst-equiv)))
  :rule-classes :congruence)

Function: cst-simple-character-escape-conc5

(defun cst-simple-character-escape-conc5 (abnf::cst)
 (declare (xargs :guard (abnf::treep abnf::cst)))
 (declare
  (xargs
    :guard (and (cst-matchp abnf::cst "simple-character-escape")
                (equal (cst-simple-character-escape-conc? abnf::cst)
                       5))))
 (let ((__function__ 'cst-simple-character-escape-conc5))
   (declare (ignorable __function__))
   (abnf::tree-nonleaf->branches abnf::cst)))

Theorem: tree-list-listp-of-cst-simple-character-escape-conc5

(defthm tree-list-listp-of-cst-simple-character-escape-conc5
  (b* ((abnf::cstss (cst-simple-character-escape-conc5 abnf::cst)))
    (abnf::tree-list-listp abnf::cstss))
  :rule-classes :rewrite)

Theorem: cst-simple-character-escape-conc5-match

(defthm cst-simple-character-escape-conc5-match
 (implies
   (and (cst-matchp abnf::cst "simple-character-escape")
        (equal (cst-simple-character-escape-conc? abnf::cst)
               5))
   (b* ((abnf::cstss (cst-simple-character-escape-conc5 abnf::cst)))
     (cst-list-list-conc-matchp
          abnf::cstss "carriage-return-escape")))
 :rule-classes :rewrite)

Theorem: cst-simple-character-escape-conc5-of-tree-fix-cst

(defthm cst-simple-character-escape-conc5-of-tree-fix-cst
 (equal
      (cst-simple-character-escape-conc5 (abnf::tree-fix abnf::cst))
      (cst-simple-character-escape-conc5 abnf::cst)))

Theorem: cst-simple-character-escape-conc5-tree-equiv-congruence-on-cst

(defthm
     cst-simple-character-escape-conc5-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-simple-character-escape-conc5 abnf::cst)
                  (cst-simple-character-escape-conc5 cst-equiv)))
  :rule-classes :congruence)

Function: cst-simple-character-escape-conc6

(defun cst-simple-character-escape-conc6 (abnf::cst)
 (declare (xargs :guard (abnf::treep abnf::cst)))
 (declare
  (xargs
    :guard (and (cst-matchp abnf::cst "simple-character-escape")
                (equal (cst-simple-character-escape-conc? abnf::cst)
                       6))))
 (let ((__function__ 'cst-simple-character-escape-conc6))
   (declare (ignorable __function__))
   (abnf::tree-nonleaf->branches abnf::cst)))

Theorem: tree-list-listp-of-cst-simple-character-escape-conc6

(defthm tree-list-listp-of-cst-simple-character-escape-conc6
  (b* ((abnf::cstss (cst-simple-character-escape-conc6 abnf::cst)))
    (abnf::tree-list-listp abnf::cstss))
  :rule-classes :rewrite)

Theorem: cst-simple-character-escape-conc6-match

(defthm cst-simple-character-escape-conc6-match
 (implies
  (and (cst-matchp abnf::cst "simple-character-escape")
       (equal (cst-simple-character-escape-conc? abnf::cst)
              6))
  (b* ((abnf::cstss (cst-simple-character-escape-conc6 abnf::cst)))
   (cst-list-list-conc-matchp abnf::cstss "horizontal-tab-escape")))
 :rule-classes :rewrite)

Theorem: cst-simple-character-escape-conc6-of-tree-fix-cst

(defthm cst-simple-character-escape-conc6-of-tree-fix-cst
 (equal
      (cst-simple-character-escape-conc6 (abnf::tree-fix abnf::cst))
      (cst-simple-character-escape-conc6 abnf::cst)))

Theorem: cst-simple-character-escape-conc6-tree-equiv-congruence-on-cst

(defthm
     cst-simple-character-escape-conc6-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-simple-character-escape-conc6 abnf::cst)
                  (cst-simple-character-escape-conc6 cst-equiv)))
  :rule-classes :congruence)

Function: cst-simple-character-escape-conc7

(defun cst-simple-character-escape-conc7 (abnf::cst)
 (declare (xargs :guard (abnf::treep abnf::cst)))
 (declare
  (xargs
    :guard (and (cst-matchp abnf::cst "simple-character-escape")
                (equal (cst-simple-character-escape-conc? abnf::cst)
                       7))))
 (let ((__function__ 'cst-simple-character-escape-conc7))
   (declare (ignorable __function__))
   (abnf::tree-nonleaf->branches abnf::cst)))

Theorem: tree-list-listp-of-cst-simple-character-escape-conc7

(defthm tree-list-listp-of-cst-simple-character-escape-conc7
  (b* ((abnf::cstss (cst-simple-character-escape-conc7 abnf::cst)))
    (abnf::tree-list-listp abnf::cstss))
  :rule-classes :rewrite)

Theorem: cst-simple-character-escape-conc7-match

(defthm cst-simple-character-escape-conc7-match
 (implies
  (and (cst-matchp abnf::cst "simple-character-escape")
       (equal (cst-simple-character-escape-conc? abnf::cst)
              7))
  (b* ((abnf::cstss (cst-simple-character-escape-conc7 abnf::cst)))
   (cst-list-list-conc-matchp abnf::cstss "null-character-escape")))
 :rule-classes :rewrite)

Theorem: cst-simple-character-escape-conc7-of-tree-fix-cst

(defthm cst-simple-character-escape-conc7-of-tree-fix-cst
 (equal
      (cst-simple-character-escape-conc7 (abnf::tree-fix abnf::cst))
      (cst-simple-character-escape-conc7 abnf::cst)))

Theorem: cst-simple-character-escape-conc7-tree-equiv-congruence-on-cst

(defthm
     cst-simple-character-escape-conc7-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-simple-character-escape-conc7 abnf::cst)
                  (cst-simple-character-escape-conc7 cst-equiv)))
  :rule-classes :congruence)

Function: cst-ascii-character-escape-conc

(defun cst-ascii-character-escape-conc (abnf::cst)
 (declare (xargs :guard (abnf::treep abnf::cst)))
 (declare
     (xargs :guard (cst-matchp abnf::cst "ascii-character-escape")))
 (let ((__function__ 'cst-ascii-character-escape-conc))
   (declare (ignorable __function__))
   (abnf::tree-nonleaf->branches abnf::cst)))

Theorem: tree-list-listp-of-cst-ascii-character-escape-conc

(defthm tree-list-listp-of-cst-ascii-character-escape-conc
  (b* ((abnf::cstss (cst-ascii-character-escape-conc abnf::cst)))
    (abnf::tree-list-listp abnf::cstss))
  :rule-classes :rewrite)

Theorem: cst-ascii-character-escape-conc-match

(defthm cst-ascii-character-escape-conc-match
 (implies
     (cst-matchp abnf::cst "ascii-character-escape")
     (b* ((abnf::cstss (cst-ascii-character-escape-conc abnf::cst)))
       (cst-list-list-conc-matchp
            abnf::cstss
            "%s\"\\x\" octal-digit hexadecimal-digit")))
 :rule-classes :rewrite)

Theorem: cst-ascii-character-escape-conc-of-tree-fix-cst

(defthm cst-ascii-character-escape-conc-of-tree-fix-cst
 (equal (cst-ascii-character-escape-conc (abnf::tree-fix abnf::cst))
        (cst-ascii-character-escape-conc abnf::cst)))

Theorem: cst-ascii-character-escape-conc-tree-equiv-congruence-on-cst

(defthm cst-ascii-character-escape-conc-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-ascii-character-escape-conc abnf::cst)
                  (cst-ascii-character-escape-conc cst-equiv)))
  :rule-classes :congruence)

Function: cst-unicode-character-escape-conc

(defun cst-unicode-character-escape-conc (abnf::cst)
 (declare (xargs :guard (abnf::treep abnf::cst)))
 (declare
   (xargs :guard (cst-matchp abnf::cst "unicode-character-escape")))
 (let ((__function__ 'cst-unicode-character-escape-conc))
   (declare (ignorable __function__))
   (abnf::tree-nonleaf->branches abnf::cst)))

Theorem: tree-list-listp-of-cst-unicode-character-escape-conc

(defthm tree-list-listp-of-cst-unicode-character-escape-conc
  (b* ((abnf::cstss (cst-unicode-character-escape-conc abnf::cst)))
    (abnf::tree-list-listp abnf::cstss))
  :rule-classes :rewrite)

Theorem: cst-unicode-character-escape-conc-match

(defthm cst-unicode-character-escape-conc-match
 (implies
  (cst-matchp abnf::cst "unicode-character-escape")
  (b* ((abnf::cstss (cst-unicode-character-escape-conc abnf::cst)))
    (cst-list-list-conc-matchp abnf::cstss
                               "%s\"\\u{\" 1*6hexadecimal-digit \"}\"")))
 :rule-classes :rewrite)

Theorem: cst-unicode-character-escape-conc-of-tree-fix-cst

(defthm cst-unicode-character-escape-conc-of-tree-fix-cst
 (equal
      (cst-unicode-character-escape-conc (abnf::tree-fix abnf::cst))
      (cst-unicode-character-escape-conc abnf::cst)))

Theorem: cst-unicode-character-escape-conc-tree-equiv-congruence-on-cst

(defthm
     cst-unicode-character-escape-conc-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-unicode-character-escape-conc abnf::cst)
                  (cst-unicode-character-escape-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
              "double-quote *string-literal-element double-quote")))
  :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-literal-element-conc1

(defun cst-string-literal-element-conc1 (abnf::cst)
 (declare (xargs :guard (abnf::treep abnf::cst)))
 (declare
  (xargs
     :guard (and (cst-matchp abnf::cst "string-literal-element")
                 (equal (cst-string-literal-element-conc? abnf::cst)
                        1))))
 (let ((__function__ 'cst-string-literal-element-conc1))
   (declare (ignorable __function__))
   (abnf::tree-nonleaf->branches abnf::cst)))

Theorem: tree-list-listp-of-cst-string-literal-element-conc1

(defthm tree-list-listp-of-cst-string-literal-element-conc1
  (b* ((abnf::cstss (cst-string-literal-element-conc1 abnf::cst)))
    (abnf::tree-list-listp abnf::cstss))
  :rule-classes :rewrite)

Theorem: cst-string-literal-element-conc1-match

(defthm cst-string-literal-element-conc1-match
 (implies
  (and (cst-matchp abnf::cst "string-literal-element")
       (equal (cst-string-literal-element-conc? abnf::cst)
              1))
  (b* ((abnf::cstss (cst-string-literal-element-conc1 abnf::cst)))
   (cst-list-list-conc-matchp
    abnf::cstss
    "not-double-quote-or-backslash-or-line-feed-or-carriage-return")))
 :rule-classes :rewrite)

Theorem: cst-string-literal-element-conc1-of-tree-fix-cst

(defthm cst-string-literal-element-conc1-of-tree-fix-cst
  (equal
       (cst-string-literal-element-conc1 (abnf::tree-fix abnf::cst))
       (cst-string-literal-element-conc1 abnf::cst)))

Theorem: cst-string-literal-element-conc1-tree-equiv-congruence-on-cst

(defthm
      cst-string-literal-element-conc1-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-string-literal-element-conc1 abnf::cst)
                  (cst-string-literal-element-conc1 cst-equiv)))
  :rule-classes :congruence)

Function: cst-string-literal-element-conc2

(defun cst-string-literal-element-conc2 (abnf::cst)
 (declare (xargs :guard (abnf::treep abnf::cst)))
 (declare
  (xargs
     :guard (and (cst-matchp abnf::cst "string-literal-element")
                 (equal (cst-string-literal-element-conc? abnf::cst)
                        2))))
 (let ((__function__ 'cst-string-literal-element-conc2))
   (declare (ignorable __function__))
   (abnf::tree-nonleaf->branches abnf::cst)))

Theorem: tree-list-listp-of-cst-string-literal-element-conc2

(defthm tree-list-listp-of-cst-string-literal-element-conc2
  (b* ((abnf::cstss (cst-string-literal-element-conc2 abnf::cst)))
    (abnf::tree-list-listp abnf::cstss))
  :rule-classes :rewrite)

Theorem: cst-string-literal-element-conc2-match

(defthm cst-string-literal-element-conc2-match
 (implies
    (and (cst-matchp abnf::cst "string-literal-element")
         (equal (cst-string-literal-element-conc? abnf::cst)
                2))
    (b* ((abnf::cstss (cst-string-literal-element-conc2 abnf::cst)))
      (cst-list-list-conc-matchp
           abnf::cstss "simple-character-escape")))
 :rule-classes :rewrite)

Theorem: cst-string-literal-element-conc2-of-tree-fix-cst

(defthm cst-string-literal-element-conc2-of-tree-fix-cst
  (equal
       (cst-string-literal-element-conc2 (abnf::tree-fix abnf::cst))
       (cst-string-literal-element-conc2 abnf::cst)))

Theorem: cst-string-literal-element-conc2-tree-equiv-congruence-on-cst

(defthm
      cst-string-literal-element-conc2-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-string-literal-element-conc2 abnf::cst)
                  (cst-string-literal-element-conc2 cst-equiv)))
  :rule-classes :congruence)

Function: cst-string-literal-element-conc3

(defun cst-string-literal-element-conc3 (abnf::cst)
 (declare (xargs :guard (abnf::treep abnf::cst)))
 (declare
  (xargs
     :guard (and (cst-matchp abnf::cst "string-literal-element")
                 (equal (cst-string-literal-element-conc? abnf::cst)
                        3))))
 (let ((__function__ 'cst-string-literal-element-conc3))
   (declare (ignorable __function__))
   (abnf::tree-nonleaf->branches abnf::cst)))

Theorem: tree-list-listp-of-cst-string-literal-element-conc3

(defthm tree-list-listp-of-cst-string-literal-element-conc3
  (b* ((abnf::cstss (cst-string-literal-element-conc3 abnf::cst)))
    (abnf::tree-list-listp abnf::cstss))
  :rule-classes :rewrite)

Theorem: cst-string-literal-element-conc3-match

(defthm cst-string-literal-element-conc3-match
 (implies
    (and (cst-matchp abnf::cst "string-literal-element")
         (equal (cst-string-literal-element-conc? abnf::cst)
                3))
    (b* ((abnf::cstss (cst-string-literal-element-conc3 abnf::cst)))
      (cst-list-list-conc-matchp
           abnf::cstss "ascii-character-escape")))
 :rule-classes :rewrite)

Theorem: cst-string-literal-element-conc3-of-tree-fix-cst

(defthm cst-string-literal-element-conc3-of-tree-fix-cst
  (equal
       (cst-string-literal-element-conc3 (abnf::tree-fix abnf::cst))
       (cst-string-literal-element-conc3 abnf::cst)))

Theorem: cst-string-literal-element-conc3-tree-equiv-congruence-on-cst

(defthm
      cst-string-literal-element-conc3-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-string-literal-element-conc3 abnf::cst)
                  (cst-string-literal-element-conc3 cst-equiv)))
  :rule-classes :congruence)

Function: cst-string-literal-element-conc4

(defun cst-string-literal-element-conc4 (abnf::cst)
 (declare (xargs :guard (abnf::treep abnf::cst)))
 (declare
  (xargs
     :guard (and (cst-matchp abnf::cst "string-literal-element")
                 (equal (cst-string-literal-element-conc? abnf::cst)
                        4))))
 (let ((__function__ 'cst-string-literal-element-conc4))
   (declare (ignorable __function__))
   (abnf::tree-nonleaf->branches abnf::cst)))

Theorem: tree-list-listp-of-cst-string-literal-element-conc4

(defthm tree-list-listp-of-cst-string-literal-element-conc4
  (b* ((abnf::cstss (cst-string-literal-element-conc4 abnf::cst)))
    (abnf::tree-list-listp abnf::cstss))
  :rule-classes :rewrite)

Theorem: cst-string-literal-element-conc4-match

(defthm cst-string-literal-element-conc4-match
 (implies
    (and (cst-matchp abnf::cst "string-literal-element")
         (equal (cst-string-literal-element-conc? abnf::cst)
                4))
    (b* ((abnf::cstss (cst-string-literal-element-conc4 abnf::cst)))
      (cst-list-list-conc-matchp abnf::cstss
                                 "unicode-character-escape")))
 :rule-classes :rewrite)

Theorem: cst-string-literal-element-conc4-of-tree-fix-cst

(defthm cst-string-literal-element-conc4-of-tree-fix-cst
  (equal
       (cst-string-literal-element-conc4 (abnf::tree-fix abnf::cst))
       (cst-string-literal-element-conc4 abnf::cst)))

Theorem: cst-string-literal-element-conc4-tree-equiv-congruence-on-cst

(defthm
      cst-string-literal-element-conc4-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-string-literal-element-conc4 abnf::cst)
                  (cst-string-literal-element-conc4 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 "unsigned-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 "signed-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-numeric-literal-conc1

(defun cst-numeric-literal-conc1 (abnf::cst)
 (declare (xargs :guard (abnf::treep abnf::cst)))
 (declare
     (xargs :guard (and (cst-matchp abnf::cst "numeric-literal")
                        (equal (cst-numeric-literal-conc? abnf::cst)
                               1))))
 (let ((__function__ 'cst-numeric-literal-conc1))
   (declare (ignorable __function__))
   (abnf::tree-nonleaf->branches abnf::cst)))

Theorem: tree-list-listp-of-cst-numeric-literal-conc1

(defthm tree-list-listp-of-cst-numeric-literal-conc1
  (b* ((abnf::cstss (cst-numeric-literal-conc1 abnf::cst)))
    (abnf::tree-list-listp abnf::cstss))
  :rule-classes :rewrite)

Theorem: cst-numeric-literal-conc1-match

(defthm cst-numeric-literal-conc1-match
  (implies
       (and (cst-matchp abnf::cst "numeric-literal")
            (equal (cst-numeric-literal-conc? abnf::cst)
                   1))
       (b* ((abnf::cstss (cst-numeric-literal-conc1 abnf::cst)))
         (cst-list-list-conc-matchp abnf::cstss "integer-literal")))
  :rule-classes :rewrite)

Theorem: cst-numeric-literal-conc1-of-tree-fix-cst

(defthm cst-numeric-literal-conc1-of-tree-fix-cst
  (equal (cst-numeric-literal-conc1 (abnf::tree-fix abnf::cst))
         (cst-numeric-literal-conc1 abnf::cst)))

Theorem: cst-numeric-literal-conc1-tree-equiv-congruence-on-cst

(defthm cst-numeric-literal-conc1-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-numeric-literal-conc1 abnf::cst)
                  (cst-numeric-literal-conc1 cst-equiv)))
  :rule-classes :congruence)

Function: cst-numeric-literal-conc2

(defun cst-numeric-literal-conc2 (abnf::cst)
 (declare (xargs :guard (abnf::treep abnf::cst)))
 (declare
     (xargs :guard (and (cst-matchp abnf::cst "numeric-literal")
                        (equal (cst-numeric-literal-conc? abnf::cst)
                               2))))
 (let ((__function__ 'cst-numeric-literal-conc2))
   (declare (ignorable __function__))
   (abnf::tree-nonleaf->branches abnf::cst)))

Theorem: tree-list-listp-of-cst-numeric-literal-conc2

(defthm tree-list-listp-of-cst-numeric-literal-conc2
  (b* ((abnf::cstss (cst-numeric-literal-conc2 abnf::cst)))
    (abnf::tree-list-listp abnf::cstss))
  :rule-classes :rewrite)

Theorem: cst-numeric-literal-conc2-match

(defthm cst-numeric-literal-conc2-match
  (implies
       (and (cst-matchp abnf::cst "numeric-literal")
            (equal (cst-numeric-literal-conc? abnf::cst)
                   2))
       (b* ((abnf::cstss (cst-numeric-literal-conc2 abnf::cst)))
         (cst-list-list-conc-matchp abnf::cstss "field-literal")))
  :rule-classes :rewrite)

Theorem: cst-numeric-literal-conc2-of-tree-fix-cst

(defthm cst-numeric-literal-conc2-of-tree-fix-cst
  (equal (cst-numeric-literal-conc2 (abnf::tree-fix abnf::cst))
         (cst-numeric-literal-conc2 abnf::cst)))

Theorem: cst-numeric-literal-conc2-tree-equiv-congruence-on-cst

(defthm cst-numeric-literal-conc2-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-numeric-literal-conc2 abnf::cst)
                  (cst-numeric-literal-conc2 cst-equiv)))
  :rule-classes :congruence)

Function: cst-numeric-literal-conc3

(defun cst-numeric-literal-conc3 (abnf::cst)
 (declare (xargs :guard (abnf::treep abnf::cst)))
 (declare
     (xargs :guard (and (cst-matchp abnf::cst "numeric-literal")
                        (equal (cst-numeric-literal-conc? abnf::cst)
                               3))))
 (let ((__function__ 'cst-numeric-literal-conc3))
   (declare (ignorable __function__))
   (abnf::tree-nonleaf->branches abnf::cst)))

Theorem: tree-list-listp-of-cst-numeric-literal-conc3

(defthm tree-list-listp-of-cst-numeric-literal-conc3
  (b* ((abnf::cstss (cst-numeric-literal-conc3 abnf::cst)))
    (abnf::tree-list-listp abnf::cstss))
  :rule-classes :rewrite)

Theorem: cst-numeric-literal-conc3-match

(defthm cst-numeric-literal-conc3-match
 (implies
  (and (cst-matchp abnf::cst "numeric-literal")
       (equal (cst-numeric-literal-conc? abnf::cst)
              3))
  (b* ((abnf::cstss (cst-numeric-literal-conc3 abnf::cst)))
   (cst-list-list-conc-matchp abnf::cstss "product-group-literal")))
 :rule-classes :rewrite)

Theorem: cst-numeric-literal-conc3-of-tree-fix-cst

(defthm cst-numeric-literal-conc3-of-tree-fix-cst
  (equal (cst-numeric-literal-conc3 (abnf::tree-fix abnf::cst))
         (cst-numeric-literal-conc3 abnf::cst)))

Theorem: cst-numeric-literal-conc3-tree-equiv-congruence-on-cst

(defthm cst-numeric-literal-conc3-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-numeric-literal-conc3 abnf::cst)
                  (cst-numeric-literal-conc3 cst-equiv)))
  :rule-classes :congruence)

Function: cst-numeric-literal-conc4

(defun cst-numeric-literal-conc4 (abnf::cst)
 (declare (xargs :guard (abnf::treep abnf::cst)))
 (declare
     (xargs :guard (and (cst-matchp abnf::cst "numeric-literal")
                        (equal (cst-numeric-literal-conc? abnf::cst)
                               4))))
 (let ((__function__ 'cst-numeric-literal-conc4))
   (declare (ignorable __function__))
   (abnf::tree-nonleaf->branches abnf::cst)))

Theorem: tree-list-listp-of-cst-numeric-literal-conc4

(defthm tree-list-listp-of-cst-numeric-literal-conc4
  (b* ((abnf::cstss (cst-numeric-literal-conc4 abnf::cst)))
    (abnf::tree-list-listp abnf::cstss))
  :rule-classes :rewrite)

Theorem: cst-numeric-literal-conc4-match

(defthm cst-numeric-literal-conc4-match
  (implies
       (and (cst-matchp abnf::cst "numeric-literal")
            (equal (cst-numeric-literal-conc? abnf::cst)
                   4))
       (b* ((abnf::cstss (cst-numeric-literal-conc4 abnf::cst)))
         (cst-list-list-conc-matchp abnf::cstss "scalar-literal")))
  :rule-classes :rewrite)

Theorem: cst-numeric-literal-conc4-of-tree-fix-cst

(defthm cst-numeric-literal-conc4-of-tree-fix-cst
  (equal (cst-numeric-literal-conc4 (abnf::tree-fix abnf::cst))
         (cst-numeric-literal-conc4 abnf::cst)))

Theorem: cst-numeric-literal-conc4-tree-equiv-congruence-on-cst

(defthm cst-numeric-literal-conc4-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-numeric-literal-conc4 abnf::cst)
                  (cst-numeric-literal-conc4 cst-equiv)))
  :rule-classes :congruence)

Function: cst-atomic-literal-conc1

(defun cst-atomic-literal-conc1 (abnf::cst)
 (declare (xargs :guard (abnf::treep abnf::cst)))
 (declare
      (xargs :guard (and (cst-matchp abnf::cst "atomic-literal")
                         (equal (cst-atomic-literal-conc? abnf::cst)
                                1))))
 (let ((__function__ 'cst-atomic-literal-conc1))
   (declare (ignorable __function__))
   (abnf::tree-nonleaf->branches abnf::cst)))

Theorem: tree-list-listp-of-cst-atomic-literal-conc1

(defthm tree-list-listp-of-cst-atomic-literal-conc1
  (b* ((abnf::cstss (cst-atomic-literal-conc1 abnf::cst)))
    (abnf::tree-list-listp abnf::cstss))
  :rule-classes :rewrite)

Theorem: cst-atomic-literal-conc1-match

(defthm cst-atomic-literal-conc1-match
  (implies
       (and (cst-matchp abnf::cst "atomic-literal")
            (equal (cst-atomic-literal-conc? abnf::cst)
                   1))
       (b* ((abnf::cstss (cst-atomic-literal-conc1 abnf::cst)))
         (cst-list-list-conc-matchp abnf::cstss "numeric-literal")))
  :rule-classes :rewrite)

Theorem: cst-atomic-literal-conc1-of-tree-fix-cst

(defthm cst-atomic-literal-conc1-of-tree-fix-cst
  (equal (cst-atomic-literal-conc1 (abnf::tree-fix abnf::cst))
         (cst-atomic-literal-conc1 abnf::cst)))

Theorem: cst-atomic-literal-conc1-tree-equiv-congruence-on-cst

(defthm cst-atomic-literal-conc1-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-atomic-literal-conc1 abnf::cst)
                  (cst-atomic-literal-conc1 cst-equiv)))
  :rule-classes :congruence)

Function: cst-atomic-literal-conc2

(defun cst-atomic-literal-conc2 (abnf::cst)
 (declare (xargs :guard (abnf::treep abnf::cst)))
 (declare
      (xargs :guard (and (cst-matchp abnf::cst "atomic-literal")
                         (equal (cst-atomic-literal-conc? abnf::cst)
                                2))))
 (let ((__function__ 'cst-atomic-literal-conc2))
   (declare (ignorable __function__))
   (abnf::tree-nonleaf->branches abnf::cst)))

Theorem: tree-list-listp-of-cst-atomic-literal-conc2

(defthm tree-list-listp-of-cst-atomic-literal-conc2
  (b* ((abnf::cstss (cst-atomic-literal-conc2 abnf::cst)))
    (abnf::tree-list-listp abnf::cstss))
  :rule-classes :rewrite)

Theorem: cst-atomic-literal-conc2-match

(defthm cst-atomic-literal-conc2-match
  (implies
       (and (cst-matchp abnf::cst "atomic-literal")
            (equal (cst-atomic-literal-conc? abnf::cst)
                   2))
       (b* ((abnf::cstss (cst-atomic-literal-conc2 abnf::cst)))
         (cst-list-list-conc-matchp abnf::cstss "boolean-literal")))
  :rule-classes :rewrite)

Theorem: cst-atomic-literal-conc2-of-tree-fix-cst

(defthm cst-atomic-literal-conc2-of-tree-fix-cst
  (equal (cst-atomic-literal-conc2 (abnf::tree-fix abnf::cst))
         (cst-atomic-literal-conc2 abnf::cst)))

Theorem: cst-atomic-literal-conc2-tree-equiv-congruence-on-cst

(defthm cst-atomic-literal-conc2-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-atomic-literal-conc2 abnf::cst)
                  (cst-atomic-literal-conc2 cst-equiv)))
  :rule-classes :congruence)

Function: cst-atomic-literal-conc3

(defun cst-atomic-literal-conc3 (abnf::cst)
 (declare (xargs :guard (abnf::treep abnf::cst)))
 (declare
      (xargs :guard (and (cst-matchp abnf::cst "atomic-literal")
                         (equal (cst-atomic-literal-conc? abnf::cst)
                                3))))
 (let ((__function__ 'cst-atomic-literal-conc3))
   (declare (ignorable __function__))
   (abnf::tree-nonleaf->branches abnf::cst)))

Theorem: tree-list-listp-of-cst-atomic-literal-conc3

(defthm tree-list-listp-of-cst-atomic-literal-conc3
  (b* ((abnf::cstss (cst-atomic-literal-conc3 abnf::cst)))
    (abnf::tree-list-listp abnf::cstss))
  :rule-classes :rewrite)

Theorem: cst-atomic-literal-conc3-match

(defthm cst-atomic-literal-conc3-match
  (implies
       (and (cst-matchp abnf::cst "atomic-literal")
            (equal (cst-atomic-literal-conc? abnf::cst)
                   3))
       (b* ((abnf::cstss (cst-atomic-literal-conc3 abnf::cst)))
         (cst-list-list-conc-matchp abnf::cstss "address-literal")))
  :rule-classes :rewrite)

Theorem: cst-atomic-literal-conc3-of-tree-fix-cst

(defthm cst-atomic-literal-conc3-of-tree-fix-cst
  (equal (cst-atomic-literal-conc3 (abnf::tree-fix abnf::cst))
         (cst-atomic-literal-conc3 abnf::cst)))

Theorem: cst-atomic-literal-conc3-tree-equiv-congruence-on-cst

(defthm cst-atomic-literal-conc3-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-atomic-literal-conc3 abnf::cst)
                  (cst-atomic-literal-conc3 cst-equiv)))
  :rule-classes :congruence)

Function: cst-atomic-literal-conc4

(defun cst-atomic-literal-conc4 (abnf::cst)
 (declare (xargs :guard (abnf::treep abnf::cst)))
 (declare
      (xargs :guard (and (cst-matchp abnf::cst "atomic-literal")
                         (equal (cst-atomic-literal-conc? abnf::cst)
                                4))))
 (let ((__function__ 'cst-atomic-literal-conc4))
   (declare (ignorable __function__))
   (abnf::tree-nonleaf->branches abnf::cst)))

Theorem: tree-list-listp-of-cst-atomic-literal-conc4

(defthm tree-list-listp-of-cst-atomic-literal-conc4
  (b* ((abnf::cstss (cst-atomic-literal-conc4 abnf::cst)))
    (abnf::tree-list-listp abnf::cstss))
  :rule-classes :rewrite)

Theorem: cst-atomic-literal-conc4-match

(defthm cst-atomic-literal-conc4-match
  (implies
       (and (cst-matchp abnf::cst "atomic-literal")
            (equal (cst-atomic-literal-conc? abnf::cst)
                   4))
       (b* ((abnf::cstss (cst-atomic-literal-conc4 abnf::cst)))
         (cst-list-list-conc-matchp abnf::cstss "string-literal")))
  :rule-classes :rewrite)

Theorem: cst-atomic-literal-conc4-of-tree-fix-cst

(defthm cst-atomic-literal-conc4-of-tree-fix-cst
  (equal (cst-atomic-literal-conc4 (abnf::tree-fix abnf::cst))
         (cst-atomic-literal-conc4 abnf::cst)))

Theorem: cst-atomic-literal-conc4-tree-equiv-congruence-on-cst

(defthm cst-atomic-literal-conc4-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-atomic-literal-conc4 abnf::cst)
                  (cst-atomic-literal-conc4 cst-equiv)))
  :rule-classes :congruence)

Function: cst-annotation-conc

(defun cst-annotation-conc (abnf::cst)
  (declare (xargs :guard (abnf::treep abnf::cst)))
  (declare (xargs :guard (cst-matchp abnf::cst "annotation")))
  (let ((__function__ 'cst-annotation-conc))
    (declare (ignorable __function__))
    (abnf::tree-nonleaf->branches abnf::cst)))

Theorem: tree-list-listp-of-cst-annotation-conc

(defthm tree-list-listp-of-cst-annotation-conc
  (b* ((abnf::cstss (cst-annotation-conc abnf::cst)))
    (abnf::tree-list-listp abnf::cstss))
  :rule-classes :rewrite)

Theorem: cst-annotation-conc-match

(defthm cst-annotation-conc-match
  (implies
       (cst-matchp abnf::cst "annotation")
       (b* ((abnf::cstss (cst-annotation-conc abnf::cst)))
         (cst-list-list-conc-matchp abnf::cstss "\"@\" identifier")))
  :rule-classes :rewrite)

Theorem: cst-annotation-conc-of-tree-fix-cst

(defthm cst-annotation-conc-of-tree-fix-cst
  (equal (cst-annotation-conc (abnf::tree-fix abnf::cst))
         (cst-annotation-conc abnf::cst)))

Theorem: cst-annotation-conc-tree-equiv-congruence-on-cst

(defthm cst-annotation-conc-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-annotation-conc abnf::cst)
                  (cst-annotation-conc cst-equiv)))
  :rule-classes :congruence)

Function: cst-token-conc1

(defun cst-token-conc1 (abnf::cst)
  (declare (xargs :guard (abnf::treep abnf::cst)))
  (declare
       (xargs :guard (and (cst-matchp abnf::cst "token")
                          (equal (cst-token-conc? abnf::cst) 1))))
  (let ((__function__ 'cst-token-conc1))
    (declare (ignorable __function__))
    (abnf::tree-nonleaf->branches abnf::cst)))

Theorem: tree-list-listp-of-cst-token-conc1

(defthm tree-list-listp-of-cst-token-conc1
  (b* ((abnf::cstss (cst-token-conc1 abnf::cst)))
    (abnf::tree-list-listp abnf::cstss))
  :rule-classes :rewrite)

Theorem: cst-token-conc1-match

(defthm cst-token-conc1-match
  (implies (and (cst-matchp abnf::cst "token")
                (equal (cst-token-conc? abnf::cst) 1))
           (b* ((abnf::cstss (cst-token-conc1 abnf::cst)))
             (cst-list-list-conc-matchp abnf::cstss "keyword")))
  :rule-classes :rewrite)

Theorem: cst-token-conc1-of-tree-fix-cst

(defthm cst-token-conc1-of-tree-fix-cst
  (equal (cst-token-conc1 (abnf::tree-fix abnf::cst))
         (cst-token-conc1 abnf::cst)))

Theorem: cst-token-conc1-tree-equiv-congruence-on-cst

(defthm cst-token-conc1-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-token-conc1 abnf::cst)
                  (cst-token-conc1 cst-equiv)))
  :rule-classes :congruence)

Function: cst-token-conc2

(defun cst-token-conc2 (abnf::cst)
  (declare (xargs :guard (abnf::treep abnf::cst)))
  (declare
       (xargs :guard (and (cst-matchp abnf::cst "token")
                          (equal (cst-token-conc? abnf::cst) 2))))
  (let ((__function__ 'cst-token-conc2))
    (declare (ignorable __function__))
    (abnf::tree-nonleaf->branches abnf::cst)))

Theorem: tree-list-listp-of-cst-token-conc2

(defthm tree-list-listp-of-cst-token-conc2
  (b* ((abnf::cstss (cst-token-conc2 abnf::cst)))
    (abnf::tree-list-listp abnf::cstss))
  :rule-classes :rewrite)

Theorem: cst-token-conc2-match

(defthm cst-token-conc2-match
  (implies (and (cst-matchp abnf::cst "token")
                (equal (cst-token-conc? abnf::cst) 2))
           (b* ((abnf::cstss (cst-token-conc2 abnf::cst)))
             (cst-list-list-conc-matchp abnf::cstss "identifier")))
  :rule-classes :rewrite)

Theorem: cst-token-conc2-of-tree-fix-cst

(defthm cst-token-conc2-of-tree-fix-cst
  (equal (cst-token-conc2 (abnf::tree-fix abnf::cst))
         (cst-token-conc2 abnf::cst)))

Theorem: cst-token-conc2-tree-equiv-congruence-on-cst

(defthm cst-token-conc2-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-token-conc2 abnf::cst)
                  (cst-token-conc2 cst-equiv)))
  :rule-classes :congruence)

Function: cst-token-conc3

(defun cst-token-conc3 (abnf::cst)
  (declare (xargs :guard (abnf::treep abnf::cst)))
  (declare
       (xargs :guard (and (cst-matchp abnf::cst "token")
                          (equal (cst-token-conc? abnf::cst) 3))))
  (let ((__function__ 'cst-token-conc3))
    (declare (ignorable __function__))
    (abnf::tree-nonleaf->branches abnf::cst)))

Theorem: tree-list-listp-of-cst-token-conc3

(defthm tree-list-listp-of-cst-token-conc3
  (b* ((abnf::cstss (cst-token-conc3 abnf::cst)))
    (abnf::tree-list-listp abnf::cstss))
  :rule-classes :rewrite)

Theorem: cst-token-conc3-match

(defthm cst-token-conc3-match
  (implies
       (and (cst-matchp abnf::cst "token")
            (equal (cst-token-conc? abnf::cst) 3))
       (b* ((abnf::cstss (cst-token-conc3 abnf::cst)))
         (cst-list-list-conc-matchp abnf::cstss "atomic-literal")))
  :rule-classes :rewrite)

Theorem: cst-token-conc3-of-tree-fix-cst

(defthm cst-token-conc3-of-tree-fix-cst
  (equal (cst-token-conc3 (abnf::tree-fix abnf::cst))
         (cst-token-conc3 abnf::cst)))

Theorem: cst-token-conc3-tree-equiv-congruence-on-cst

(defthm cst-token-conc3-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-token-conc3 abnf::cst)
                  (cst-token-conc3 cst-equiv)))
  :rule-classes :congruence)

Function: cst-token-conc4

(defun cst-token-conc4 (abnf::cst)
  (declare (xargs :guard (abnf::treep abnf::cst)))
  (declare
       (xargs :guard (and (cst-matchp abnf::cst "token")
                          (equal (cst-token-conc? abnf::cst) 4))))
  (let ((__function__ 'cst-token-conc4))
    (declare (ignorable __function__))
    (abnf::tree-nonleaf->branches abnf::cst)))

Theorem: tree-list-listp-of-cst-token-conc4

(defthm tree-list-listp-of-cst-token-conc4
  (b* ((abnf::cstss (cst-token-conc4 abnf::cst)))
    (abnf::tree-list-listp abnf::cstss))
  :rule-classes :rewrite)

Theorem: cst-token-conc4-match

(defthm cst-token-conc4-match
  (implies (and (cst-matchp abnf::cst "token")
                (equal (cst-token-conc? abnf::cst) 4))
           (b* ((abnf::cstss (cst-token-conc4 abnf::cst)))
             (cst-list-list-conc-matchp abnf::cstss "numeral")))
  :rule-classes :rewrite)

Theorem: cst-token-conc4-of-tree-fix-cst

(defthm cst-token-conc4-of-tree-fix-cst
  (equal (cst-token-conc4 (abnf::tree-fix abnf::cst))
         (cst-token-conc4 abnf::cst)))

Theorem: cst-token-conc4-tree-equiv-congruence-on-cst

(defthm cst-token-conc4-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-token-conc4 abnf::cst)
                  (cst-token-conc4 cst-equiv)))
  :rule-classes :congruence)

Function: cst-token-conc5

(defun cst-token-conc5 (abnf::cst)
  (declare (xargs :guard (abnf::treep abnf::cst)))
  (declare
       (xargs :guard (and (cst-matchp abnf::cst "token")
                          (equal (cst-token-conc? abnf::cst) 5))))
  (let ((__function__ 'cst-token-conc5))
    (declare (ignorable __function__))
    (abnf::tree-nonleaf->branches abnf::cst)))

Theorem: tree-list-listp-of-cst-token-conc5

(defthm tree-list-listp-of-cst-token-conc5
  (b* ((abnf::cstss (cst-token-conc5 abnf::cst)))
    (abnf::tree-list-listp abnf::cstss))
  :rule-classes :rewrite)

Theorem: cst-token-conc5-match

(defthm cst-token-conc5-match
  (implies (and (cst-matchp abnf::cst "token")
                (equal (cst-token-conc? abnf::cst) 5))
           (b* ((abnf::cstss (cst-token-conc5 abnf::cst)))
             (cst-list-list-conc-matchp abnf::cstss "annotation")))
  :rule-classes :rewrite)

Theorem: cst-token-conc5-of-tree-fix-cst

(defthm cst-token-conc5-of-tree-fix-cst
  (equal (cst-token-conc5 (abnf::tree-fix abnf::cst))
         (cst-token-conc5 abnf::cst)))

Theorem: cst-token-conc5-tree-equiv-congruence-on-cst

(defthm cst-token-conc5-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-token-conc5 abnf::cst)
                  (cst-token-conc5 cst-equiv)))
  :rule-classes :congruence)

Function: cst-token-conc6

(defun cst-token-conc6 (abnf::cst)
  (declare (xargs :guard (abnf::treep abnf::cst)))
  (declare
       (xargs :guard (and (cst-matchp abnf::cst "token")
                          (equal (cst-token-conc? abnf::cst) 6))))
  (let ((__function__ 'cst-token-conc6))
    (declare (ignorable __function__))
    (abnf::tree-nonleaf->branches abnf::cst)))

Theorem: tree-list-listp-of-cst-token-conc6

(defthm tree-list-listp-of-cst-token-conc6
  (b* ((abnf::cstss (cst-token-conc6 abnf::cst)))
    (abnf::tree-list-listp abnf::cstss))
  :rule-classes :rewrite)

Theorem: cst-token-conc6-match

(defthm cst-token-conc6-match
  (implies (and (cst-matchp abnf::cst "token")
                (equal (cst-token-conc? abnf::cst) 6))
           (b* ((abnf::cstss (cst-token-conc6 abnf::cst)))
             (cst-list-list-conc-matchp abnf::cstss "symbol")))
  :rule-classes :rewrite)

Theorem: cst-token-conc6-of-tree-fix-cst

(defthm cst-token-conc6-of-tree-fix-cst
  (equal (cst-token-conc6 (abnf::tree-fix abnf::cst))
         (cst-token-conc6 abnf::cst)))

Theorem: cst-token-conc6-tree-equiv-congruence-on-cst

(defthm cst-token-conc6-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-token-conc6 abnf::cst)
                  (cst-token-conc6 cst-equiv)))
  :rule-classes :congruence)

Function: cst-lexeme-conc1

(defun cst-lexeme-conc1 (abnf::cst)
  (declare (xargs :guard (abnf::treep abnf::cst)))
  (declare (xargs :guard (and (cst-matchp abnf::cst "lexeme")
                              (equal (cst-lexeme-conc? abnf::cst)
                                     1))))
  (let ((__function__ 'cst-lexeme-conc1))
    (declare (ignorable __function__))
    (abnf::tree-nonleaf->branches abnf::cst)))

Theorem: tree-list-listp-of-cst-lexeme-conc1

(defthm tree-list-listp-of-cst-lexeme-conc1
  (b* ((abnf::cstss (cst-lexeme-conc1 abnf::cst)))
    (abnf::tree-list-listp abnf::cstss))
  :rule-classes :rewrite)

Theorem: cst-lexeme-conc1-match

(defthm cst-lexeme-conc1-match
  (implies (and (cst-matchp abnf::cst "lexeme")
                (equal (cst-lexeme-conc? abnf::cst) 1))
           (b* ((abnf::cstss (cst-lexeme-conc1 abnf::cst)))
             (cst-list-list-conc-matchp abnf::cstss "token")))
  :rule-classes :rewrite)

Theorem: cst-lexeme-conc1-of-tree-fix-cst

(defthm cst-lexeme-conc1-of-tree-fix-cst
  (equal (cst-lexeme-conc1 (abnf::tree-fix abnf::cst))
         (cst-lexeme-conc1 abnf::cst)))

Theorem: cst-lexeme-conc1-tree-equiv-congruence-on-cst

(defthm cst-lexeme-conc1-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-lexeme-conc1 abnf::cst)
                  (cst-lexeme-conc1 cst-equiv)))
  :rule-classes :congruence)

Function: cst-lexeme-conc2

(defun cst-lexeme-conc2 (abnf::cst)
  (declare (xargs :guard (abnf::treep abnf::cst)))
  (declare (xargs :guard (and (cst-matchp abnf::cst "lexeme")
                              (equal (cst-lexeme-conc? abnf::cst)
                                     2))))
  (let ((__function__ 'cst-lexeme-conc2))
    (declare (ignorable __function__))
    (abnf::tree-nonleaf->branches abnf::cst)))

Theorem: tree-list-listp-of-cst-lexeme-conc2

(defthm tree-list-listp-of-cst-lexeme-conc2
  (b* ((abnf::cstss (cst-lexeme-conc2 abnf::cst)))
    (abnf::tree-list-listp abnf::cstss))
  :rule-classes :rewrite)

Theorem: cst-lexeme-conc2-match

(defthm cst-lexeme-conc2-match
  (implies (and (cst-matchp abnf::cst "lexeme")
                (equal (cst-lexeme-conc? abnf::cst) 2))
           (b* ((abnf::cstss (cst-lexeme-conc2 abnf::cst)))
             (cst-list-list-conc-matchp abnf::cstss "comment")))
  :rule-classes :rewrite)

Theorem: cst-lexeme-conc2-of-tree-fix-cst

(defthm cst-lexeme-conc2-of-tree-fix-cst
  (equal (cst-lexeme-conc2 (abnf::tree-fix abnf::cst))
         (cst-lexeme-conc2 abnf::cst)))

Theorem: cst-lexeme-conc2-tree-equiv-congruence-on-cst

(defthm cst-lexeme-conc2-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-lexeme-conc2 abnf::cst)
                  (cst-lexeme-conc2 cst-equiv)))
  :rule-classes :congruence)

Function: cst-lexeme-conc3

(defun cst-lexeme-conc3 (abnf::cst)
  (declare (xargs :guard (abnf::treep abnf::cst)))
  (declare (xargs :guard (and (cst-matchp abnf::cst "lexeme")
                              (equal (cst-lexeme-conc? abnf::cst)
                                     3))))
  (let ((__function__ 'cst-lexeme-conc3))
    (declare (ignorable __function__))
    (abnf::tree-nonleaf->branches abnf::cst)))

Theorem: tree-list-listp-of-cst-lexeme-conc3

(defthm tree-list-listp-of-cst-lexeme-conc3
  (b* ((abnf::cstss (cst-lexeme-conc3 abnf::cst)))
    (abnf::tree-list-listp abnf::cstss))
  :rule-classes :rewrite)

Theorem: cst-lexeme-conc3-match

(defthm cst-lexeme-conc3-match
  (implies (and (cst-matchp abnf::cst "lexeme")
                (equal (cst-lexeme-conc? abnf::cst) 3))
           (b* ((abnf::cstss (cst-lexeme-conc3 abnf::cst)))
             (cst-list-list-conc-matchp abnf::cstss "whitespace")))
  :rule-classes :rewrite)

Theorem: cst-lexeme-conc3-of-tree-fix-cst

(defthm cst-lexeme-conc3-of-tree-fix-cst
  (equal (cst-lexeme-conc3 (abnf::tree-fix abnf::cst))
         (cst-lexeme-conc3 abnf::cst)))

Theorem: cst-lexeme-conc3-tree-equiv-congruence-on-cst

(defthm cst-lexeme-conc3-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-lexeme-conc3 abnf::cst)
                  (cst-lexeme-conc3 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-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-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\"bool\"")))
  :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-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-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-named-primitive-type-conc1

(defun cst-named-primitive-type-conc1 (abnf::cst)
 (declare (xargs :guard (abnf::treep abnf::cst)))
 (declare
  (xargs
       :guard (and (cst-matchp abnf::cst "named-primitive-type")
                   (equal (cst-named-primitive-type-conc? abnf::cst)
                          1))))
 (let ((__function__ 'cst-named-primitive-type-conc1))
   (declare (ignorable __function__))
   (abnf::tree-nonleaf->branches abnf::cst)))

Theorem: tree-list-listp-of-cst-named-primitive-type-conc1

(defthm tree-list-listp-of-cst-named-primitive-type-conc1
  (b* ((abnf::cstss (cst-named-primitive-type-conc1 abnf::cst)))
    (abnf::tree-list-listp abnf::cstss))
  :rule-classes :rewrite)

Theorem: cst-named-primitive-type-conc1-match

(defthm cst-named-primitive-type-conc1-match
 (implies
      (and (cst-matchp abnf::cst "named-primitive-type")
           (equal (cst-named-primitive-type-conc? abnf::cst)
                  1))
      (b* ((abnf::cstss (cst-named-primitive-type-conc1 abnf::cst)))
        (cst-list-list-conc-matchp abnf::cstss "boolean-type")))
 :rule-classes :rewrite)

Theorem: cst-named-primitive-type-conc1-of-tree-fix-cst

(defthm cst-named-primitive-type-conc1-of-tree-fix-cst
  (equal (cst-named-primitive-type-conc1 (abnf::tree-fix abnf::cst))
         (cst-named-primitive-type-conc1 abnf::cst)))

Theorem: cst-named-primitive-type-conc1-tree-equiv-congruence-on-cst

(defthm cst-named-primitive-type-conc1-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-named-primitive-type-conc1 abnf::cst)
                  (cst-named-primitive-type-conc1 cst-equiv)))
  :rule-classes :congruence)

Function: cst-named-primitive-type-conc2

(defun cst-named-primitive-type-conc2 (abnf::cst)
 (declare (xargs :guard (abnf::treep abnf::cst)))
 (declare
  (xargs
       :guard (and (cst-matchp abnf::cst "named-primitive-type")
                   (equal (cst-named-primitive-type-conc? abnf::cst)
                          2))))
 (let ((__function__ 'cst-named-primitive-type-conc2))
   (declare (ignorable __function__))
   (abnf::tree-nonleaf->branches abnf::cst)))

Theorem: tree-list-listp-of-cst-named-primitive-type-conc2

(defthm tree-list-listp-of-cst-named-primitive-type-conc2
  (b* ((abnf::cstss (cst-named-primitive-type-conc2 abnf::cst)))
    (abnf::tree-list-listp abnf::cstss))
  :rule-classes :rewrite)

Theorem: cst-named-primitive-type-conc2-match

(defthm cst-named-primitive-type-conc2-match
 (implies
      (and (cst-matchp abnf::cst "named-primitive-type")
           (equal (cst-named-primitive-type-conc? abnf::cst)
                  2))
      (b* ((abnf::cstss (cst-named-primitive-type-conc2 abnf::cst)))
        (cst-list-list-conc-matchp abnf::cstss "arithmetic-type")))
 :rule-classes :rewrite)

Theorem: cst-named-primitive-type-conc2-of-tree-fix-cst

(defthm cst-named-primitive-type-conc2-of-tree-fix-cst
  (equal (cst-named-primitive-type-conc2 (abnf::tree-fix abnf::cst))
         (cst-named-primitive-type-conc2 abnf::cst)))

Theorem: cst-named-primitive-type-conc2-tree-equiv-congruence-on-cst

(defthm cst-named-primitive-type-conc2-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-named-primitive-type-conc2 abnf::cst)
                  (cst-named-primitive-type-conc2 cst-equiv)))
  :rule-classes :congruence)

Function: cst-named-primitive-type-conc3

(defun cst-named-primitive-type-conc3 (abnf::cst)
 (declare (xargs :guard (abnf::treep abnf::cst)))
 (declare
  (xargs
       :guard (and (cst-matchp abnf::cst "named-primitive-type")
                   (equal (cst-named-primitive-type-conc? abnf::cst)
                          3))))
 (let ((__function__ 'cst-named-primitive-type-conc3))
   (declare (ignorable __function__))
   (abnf::tree-nonleaf->branches abnf::cst)))

Theorem: tree-list-listp-of-cst-named-primitive-type-conc3

(defthm tree-list-listp-of-cst-named-primitive-type-conc3
  (b* ((abnf::cstss (cst-named-primitive-type-conc3 abnf::cst)))
    (abnf::tree-list-listp abnf::cstss))
  :rule-classes :rewrite)

Theorem: cst-named-primitive-type-conc3-match

(defthm cst-named-primitive-type-conc3-match
 (implies
      (and (cst-matchp abnf::cst "named-primitive-type")
           (equal (cst-named-primitive-type-conc? abnf::cst)
                  3))
      (b* ((abnf::cstss (cst-named-primitive-type-conc3 abnf::cst)))
        (cst-list-list-conc-matchp abnf::cstss "address-type")))
 :rule-classes :rewrite)

Theorem: cst-named-primitive-type-conc3-of-tree-fix-cst

(defthm cst-named-primitive-type-conc3-of-tree-fix-cst
  (equal (cst-named-primitive-type-conc3 (abnf::tree-fix abnf::cst))
         (cst-named-primitive-type-conc3 abnf::cst)))

Theorem: cst-named-primitive-type-conc3-tree-equiv-congruence-on-cst

(defthm cst-named-primitive-type-conc3-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-named-primitive-type-conc3 abnf::cst)
                  (cst-named-primitive-type-conc3 cst-equiv)))
  :rule-classes :congruence)

Function: cst-named-primitive-type-conc4

(defun cst-named-primitive-type-conc4 (abnf::cst)
 (declare (xargs :guard (abnf::treep abnf::cst)))
 (declare
  (xargs
       :guard (and (cst-matchp abnf::cst "named-primitive-type")
                   (equal (cst-named-primitive-type-conc? abnf::cst)
                          4))))
 (let ((__function__ 'cst-named-primitive-type-conc4))
   (declare (ignorable __function__))
   (abnf::tree-nonleaf->branches abnf::cst)))

Theorem: tree-list-listp-of-cst-named-primitive-type-conc4

(defthm tree-list-listp-of-cst-named-primitive-type-conc4
  (b* ((abnf::cstss (cst-named-primitive-type-conc4 abnf::cst)))
    (abnf::tree-list-listp abnf::cstss))
  :rule-classes :rewrite)

Theorem: cst-named-primitive-type-conc4-match

(defthm cst-named-primitive-type-conc4-match
 (implies
      (and (cst-matchp abnf::cst "named-primitive-type")
           (equal (cst-named-primitive-type-conc? abnf::cst)
                  4))
      (b* ((abnf::cstss (cst-named-primitive-type-conc4 abnf::cst)))
        (cst-list-list-conc-matchp abnf::cstss "string-type")))
 :rule-classes :rewrite)

Theorem: cst-named-primitive-type-conc4-of-tree-fix-cst

(defthm cst-named-primitive-type-conc4-of-tree-fix-cst
  (equal (cst-named-primitive-type-conc4 (abnf::tree-fix abnf::cst))
         (cst-named-primitive-type-conc4 abnf::cst)))

Theorem: cst-named-primitive-type-conc4-tree-equiv-congruence-on-cst

(defthm cst-named-primitive-type-conc4-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-named-primitive-type-conc4 abnf::cst)
                  (cst-named-primitive-type-conc4 cst-equiv)))
  :rule-classes :congruence)

Function: cst-unit-type-conc

(defun cst-unit-type-conc (abnf::cst)
  (declare (xargs :guard (abnf::treep abnf::cst)))
  (declare (xargs :guard (cst-matchp abnf::cst "unit-type")))
  (let ((__function__ 'cst-unit-type-conc))
    (declare (ignorable __function__))
    (abnf::tree-nonleaf->branches abnf::cst)))

Theorem: tree-list-listp-of-cst-unit-type-conc

(defthm tree-list-listp-of-cst-unit-type-conc
  (b* ((abnf::cstss (cst-unit-type-conc abnf::cst)))
    (abnf::tree-list-listp abnf::cstss))
  :rule-classes :rewrite)

Theorem: cst-unit-type-conc-match

(defthm cst-unit-type-conc-match
  (implies (cst-matchp abnf::cst "unit-type")
           (b* ((abnf::cstss (cst-unit-type-conc abnf::cst)))
             (cst-list-list-conc-matchp abnf::cstss "\"(\" \")\"")))
  :rule-classes :rewrite)

Theorem: cst-unit-type-conc-of-tree-fix-cst

(defthm cst-unit-type-conc-of-tree-fix-cst
  (equal (cst-unit-type-conc (abnf::tree-fix abnf::cst))
         (cst-unit-type-conc abnf::cst)))

Theorem: cst-unit-type-conc-tree-equiv-congruence-on-cst

(defthm cst-unit-type-conc-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-unit-type-conc abnf::cst)
                  (cst-unit-type-conc cst-equiv)))
  :rule-classes :congruence)

Function: cst-primitive-type-conc1

(defun cst-primitive-type-conc1 (abnf::cst)
 (declare (xargs :guard (abnf::treep abnf::cst)))
 (declare
      (xargs :guard (and (cst-matchp abnf::cst "primitive-type")
                         (equal (cst-primitive-type-conc? abnf::cst)
                                1))))
 (let ((__function__ 'cst-primitive-type-conc1))
   (declare (ignorable __function__))
   (abnf::tree-nonleaf->branches abnf::cst)))

Theorem: tree-list-listp-of-cst-primitive-type-conc1

(defthm tree-list-listp-of-cst-primitive-type-conc1
  (b* ((abnf::cstss (cst-primitive-type-conc1 abnf::cst)))
    (abnf::tree-list-listp abnf::cstss))
  :rule-classes :rewrite)

Theorem: cst-primitive-type-conc1-match

(defthm cst-primitive-type-conc1-match
 (implies
  (and (cst-matchp abnf::cst "primitive-type")
       (equal (cst-primitive-type-conc? abnf::cst)
              1))
  (b* ((abnf::cstss (cst-primitive-type-conc1 abnf::cst)))
    (cst-list-list-conc-matchp abnf::cstss "named-primitive-type")))
 :rule-classes :rewrite)

Theorem: cst-primitive-type-conc1-of-tree-fix-cst

(defthm cst-primitive-type-conc1-of-tree-fix-cst
  (equal (cst-primitive-type-conc1 (abnf::tree-fix abnf::cst))
         (cst-primitive-type-conc1 abnf::cst)))

Theorem: cst-primitive-type-conc1-tree-equiv-congruence-on-cst

(defthm cst-primitive-type-conc1-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-primitive-type-conc1 abnf::cst)
                  (cst-primitive-type-conc1 cst-equiv)))
  :rule-classes :congruence)

Function: cst-primitive-type-conc2

(defun cst-primitive-type-conc2 (abnf::cst)
 (declare (xargs :guard (abnf::treep abnf::cst)))
 (declare
      (xargs :guard (and (cst-matchp abnf::cst "primitive-type")
                         (equal (cst-primitive-type-conc? abnf::cst)
                                2))))
 (let ((__function__ 'cst-primitive-type-conc2))
   (declare (ignorable __function__))
   (abnf::tree-nonleaf->branches abnf::cst)))

Theorem: tree-list-listp-of-cst-primitive-type-conc2

(defthm tree-list-listp-of-cst-primitive-type-conc2
  (b* ((abnf::cstss (cst-primitive-type-conc2 abnf::cst)))
    (abnf::tree-list-listp abnf::cstss))
  :rule-classes :rewrite)

Theorem: cst-primitive-type-conc2-match

(defthm cst-primitive-type-conc2-match
  (implies (and (cst-matchp abnf::cst "primitive-type")
                (equal (cst-primitive-type-conc? abnf::cst)
                       2))
           (b* ((abnf::cstss (cst-primitive-type-conc2 abnf::cst)))
             (cst-list-list-conc-matchp abnf::cstss "unit-type")))
  :rule-classes :rewrite)

Theorem: cst-primitive-type-conc2-of-tree-fix-cst

(defthm cst-primitive-type-conc2-of-tree-fix-cst
  (equal (cst-primitive-type-conc2 (abnf::tree-fix abnf::cst))
         (cst-primitive-type-conc2 abnf::cst)))

Theorem: cst-primitive-type-conc2-tree-equiv-congruence-on-cst

(defthm cst-primitive-type-conc2-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-primitive-type-conc2 abnf::cst)
                  (cst-primitive-type-conc2 cst-equiv)))
  :rule-classes :congruence)

Function: cst-tuple-type-conc

(defun cst-tuple-type-conc (abnf::cst)
  (declare (xargs :guard (abnf::treep abnf::cst)))
  (declare (xargs :guard (cst-matchp abnf::cst "tuple-type")))
  (let ((__function__ 'cst-tuple-type-conc))
    (declare (ignorable __function__))
    (abnf::tree-nonleaf->branches abnf::cst)))

Theorem: tree-list-listp-of-cst-tuple-type-conc

(defthm tree-list-listp-of-cst-tuple-type-conc
  (b* ((abnf::cstss (cst-tuple-type-conc abnf::cst)))
    (abnf::tree-list-listp abnf::cstss))
  :rule-classes :rewrite)

Theorem: cst-tuple-type-conc-match

(defthm cst-tuple-type-conc-match
  (implies (cst-matchp abnf::cst "tuple-type")
           (b* ((abnf::cstss (cst-tuple-type-conc abnf::cst)))
             (cst-list-list-conc-matchp
                  abnf::cstss
                  "\"(\" type 1*( \",\" type ) [ \",\" ] \")\"")))
  :rule-classes :rewrite)

Theorem: cst-tuple-type-conc-of-tree-fix-cst

(defthm cst-tuple-type-conc-of-tree-fix-cst
  (equal (cst-tuple-type-conc (abnf::tree-fix abnf::cst))
         (cst-tuple-type-conc abnf::cst)))

Theorem: cst-tuple-type-conc-tree-equiv-congruence-on-cst

(defthm cst-tuple-type-conc-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-tuple-type-conc abnf::cst)
                  (cst-tuple-type-conc cst-equiv)))
  :rule-classes :congruence)

Function: cst-type-conc1

(defun cst-type-conc1 (abnf::cst)
 (declare (xargs :guard (abnf::treep abnf::cst)))
 (declare (xargs :guard (and (cst-matchp abnf::cst "type")
                             (equal (cst-type-conc? abnf::cst) 1))))
 (let ((__function__ 'cst-type-conc1))
   (declare (ignorable __function__))
   (abnf::tree-nonleaf->branches abnf::cst)))

Theorem: tree-list-listp-of-cst-type-conc1

(defthm tree-list-listp-of-cst-type-conc1
  (b* ((abnf::cstss (cst-type-conc1 abnf::cst)))
    (abnf::tree-list-listp abnf::cstss))
  :rule-classes :rewrite)

Theorem: cst-type-conc1-match

(defthm cst-type-conc1-match
  (implies (and (cst-matchp abnf::cst "type")
                (equal (cst-type-conc? abnf::cst) 1))
           (b* ((abnf::cstss (cst-type-conc1 abnf::cst)))
             (cst-list-list-conc-matchp abnf::cstss "named-type")))
  :rule-classes :rewrite)

Theorem: cst-type-conc1-of-tree-fix-cst

(defthm cst-type-conc1-of-tree-fix-cst
  (equal (cst-type-conc1 (abnf::tree-fix abnf::cst))
         (cst-type-conc1 abnf::cst)))

Theorem: cst-type-conc1-tree-equiv-congruence-on-cst

(defthm cst-type-conc1-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-type-conc1 abnf::cst)
                  (cst-type-conc1 cst-equiv)))
  :rule-classes :congruence)

Function: cst-type-conc2

(defun cst-type-conc2 (abnf::cst)
 (declare (xargs :guard (abnf::treep abnf::cst)))
 (declare (xargs :guard (and (cst-matchp abnf::cst "type")
                             (equal (cst-type-conc? abnf::cst) 2))))
 (let ((__function__ 'cst-type-conc2))
   (declare (ignorable __function__))
   (abnf::tree-nonleaf->branches abnf::cst)))

Theorem: tree-list-listp-of-cst-type-conc2

(defthm tree-list-listp-of-cst-type-conc2
  (b* ((abnf::cstss (cst-type-conc2 abnf::cst)))
    (abnf::tree-list-listp abnf::cstss))
  :rule-classes :rewrite)

Theorem: cst-type-conc2-match

(defthm cst-type-conc2-match
  (implies (and (cst-matchp abnf::cst "type")
                (equal (cst-type-conc? abnf::cst) 2))
           (b* ((abnf::cstss (cst-type-conc2 abnf::cst)))
             (cst-list-list-conc-matchp abnf::cstss "unit-type")))
  :rule-classes :rewrite)

Theorem: cst-type-conc2-of-tree-fix-cst

(defthm cst-type-conc2-of-tree-fix-cst
  (equal (cst-type-conc2 (abnf::tree-fix abnf::cst))
         (cst-type-conc2 abnf::cst)))

Theorem: cst-type-conc2-tree-equiv-congruence-on-cst

(defthm cst-type-conc2-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-type-conc2 abnf::cst)
                  (cst-type-conc2 cst-equiv)))
  :rule-classes :congruence)

Function: cst-type-conc3

(defun cst-type-conc3 (abnf::cst)
 (declare (xargs :guard (abnf::treep abnf::cst)))
 (declare (xargs :guard (and (cst-matchp abnf::cst "type")
                             (equal (cst-type-conc? abnf::cst) 3))))
 (let ((__function__ 'cst-type-conc3))
   (declare (ignorable __function__))
   (abnf::tree-nonleaf->branches abnf::cst)))

Theorem: tree-list-listp-of-cst-type-conc3

(defthm tree-list-listp-of-cst-type-conc3
  (b* ((abnf::cstss (cst-type-conc3 abnf::cst)))
    (abnf::tree-list-listp abnf::cstss))
  :rule-classes :rewrite)

Theorem: cst-type-conc3-match

(defthm cst-type-conc3-match
  (implies (and (cst-matchp abnf::cst "type")
                (equal (cst-type-conc? abnf::cst) 3))
           (b* ((abnf::cstss (cst-type-conc3 abnf::cst)))
             (cst-list-list-conc-matchp abnf::cstss "tuple-type")))
  :rule-classes :rewrite)

Theorem: cst-type-conc3-of-tree-fix-cst

(defthm cst-type-conc3-of-tree-fix-cst
  (equal (cst-type-conc3 (abnf::tree-fix abnf::cst))
         (cst-type-conc3 abnf::cst)))

Theorem: cst-type-conc3-tree-equiv-congruence-on-cst

(defthm cst-type-conc3-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-type-conc3 abnf::cst)
                  (cst-type-conc3 cst-equiv)))
  :rule-classes :congruence)

Function: cst-affine-group-literal-conc

(defun cst-affine-group-literal-conc (abnf::cst)
  (declare (xargs :guard (abnf::treep abnf::cst)))
  (declare
       (xargs :guard (cst-matchp abnf::cst "affine-group-literal")))
  (let ((__function__ 'cst-affine-group-literal-conc))
    (declare (ignorable __function__))
    (abnf::tree-nonleaf->branches abnf::cst)))

Theorem: tree-list-listp-of-cst-affine-group-literal-conc

(defthm tree-list-listp-of-cst-affine-group-literal-conc
  (b* ((abnf::cstss (cst-affine-group-literal-conc abnf::cst)))
    (abnf::tree-list-listp abnf::cstss))
  :rule-classes :rewrite)

Theorem: cst-affine-group-literal-conc-match

(defthm cst-affine-group-literal-conc-match
 (implies
    (cst-matchp abnf::cst "affine-group-literal")
    (b* ((abnf::cstss (cst-affine-group-literal-conc abnf::cst)))
      (cst-list-list-conc-matchp
           abnf::cstss
           "\"(\" group-coordinate \",\" group-coordinate %s\")group\"")))
 :rule-classes :rewrite)

Theorem: cst-affine-group-literal-conc-of-tree-fix-cst

(defthm cst-affine-group-literal-conc-of-tree-fix-cst
  (equal (cst-affine-group-literal-conc (abnf::tree-fix abnf::cst))
         (cst-affine-group-literal-conc abnf::cst)))

Theorem: cst-affine-group-literal-conc-tree-equiv-congruence-on-cst

(defthm cst-affine-group-literal-conc-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-affine-group-literal-conc abnf::cst)
                  (cst-affine-group-literal-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 "atomic-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 "affine-group-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-group-literal-conc1

(defun cst-group-literal-conc1 (abnf::cst)
  (declare (xargs :guard (abnf::treep abnf::cst)))
  (declare
       (xargs :guard (and (cst-matchp abnf::cst "group-literal")
                          (equal (cst-group-literal-conc? abnf::cst)
                                 1))))
  (let ((__function__ 'cst-group-literal-conc1))
    (declare (ignorable __function__))
    (abnf::tree-nonleaf->branches abnf::cst)))

Theorem: tree-list-listp-of-cst-group-literal-conc1

(defthm tree-list-listp-of-cst-group-literal-conc1
  (b* ((abnf::cstss (cst-group-literal-conc1 abnf::cst)))
    (abnf::tree-list-listp abnf::cstss))
  :rule-classes :rewrite)

Theorem: cst-group-literal-conc1-match

(defthm cst-group-literal-conc1-match
 (implies
  (and (cst-matchp abnf::cst "group-literal")
       (equal (cst-group-literal-conc? abnf::cst)
              1))
  (b* ((abnf::cstss (cst-group-literal-conc1 abnf::cst)))
   (cst-list-list-conc-matchp abnf::cstss "product-group-literal")))
 :rule-classes :rewrite)

Theorem: cst-group-literal-conc1-of-tree-fix-cst

(defthm cst-group-literal-conc1-of-tree-fix-cst
  (equal (cst-group-literal-conc1 (abnf::tree-fix abnf::cst))
         (cst-group-literal-conc1 abnf::cst)))

Theorem: cst-group-literal-conc1-tree-equiv-congruence-on-cst

(defthm cst-group-literal-conc1-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-group-literal-conc1 abnf::cst)
                  (cst-group-literal-conc1 cst-equiv)))
  :rule-classes :congruence)

Function: cst-group-literal-conc2

(defun cst-group-literal-conc2 (abnf::cst)
  (declare (xargs :guard (abnf::treep abnf::cst)))
  (declare
       (xargs :guard (and (cst-matchp abnf::cst "group-literal")
                          (equal (cst-group-literal-conc? abnf::cst)
                                 2))))
  (let ((__function__ 'cst-group-literal-conc2))
    (declare (ignorable __function__))
    (abnf::tree-nonleaf->branches abnf::cst)))

Theorem: tree-list-listp-of-cst-group-literal-conc2

(defthm tree-list-listp-of-cst-group-literal-conc2
  (b* ((abnf::cstss (cst-group-literal-conc2 abnf::cst)))
    (abnf::tree-list-listp abnf::cstss))
  :rule-classes :rewrite)

Theorem: cst-group-literal-conc2-match

(defthm cst-group-literal-conc2-match
 (implies
  (and (cst-matchp abnf::cst "group-literal")
       (equal (cst-group-literal-conc? abnf::cst)
              2))
  (b* ((abnf::cstss (cst-group-literal-conc2 abnf::cst)))
    (cst-list-list-conc-matchp abnf::cstss "affine-group-literal")))
 :rule-classes :rewrite)

Theorem: cst-group-literal-conc2-of-tree-fix-cst

(defthm cst-group-literal-conc2-of-tree-fix-cst
  (equal (cst-group-literal-conc2 (abnf::tree-fix abnf::cst))
         (cst-group-literal-conc2 abnf::cst)))

Theorem: cst-group-literal-conc2-tree-equiv-congruence-on-cst

(defthm cst-group-literal-conc2-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-group-literal-conc2 abnf::cst)
                  (cst-group-literal-conc2 cst-equiv)))
  :rule-classes :congruence)

Function: cst-variable-or-free-constant-conc

(defun cst-variable-or-free-constant-conc (abnf::cst)
 (declare (xargs :guard (abnf::treep abnf::cst)))
 (declare
  (xargs :guard (cst-matchp abnf::cst "variable-or-free-constant")))
 (let ((__function__ 'cst-variable-or-free-constant-conc))
   (declare (ignorable __function__))
   (abnf::tree-nonleaf->branches abnf::cst)))

Theorem: tree-list-listp-of-cst-variable-or-free-constant-conc

(defthm tree-list-listp-of-cst-variable-or-free-constant-conc
  (b* ((abnf::cstss (cst-variable-or-free-constant-conc abnf::cst)))
    (abnf::tree-list-listp abnf::cstss))
  :rule-classes :rewrite)

Theorem: cst-variable-or-free-constant-conc-match

(defthm cst-variable-or-free-constant-conc-match
 (implies
  (cst-matchp abnf::cst "variable-or-free-constant")
  (b* ((abnf::cstss (cst-variable-or-free-constant-conc abnf::cst)))
    (cst-list-list-conc-matchp abnf::cstss "identifier")))
 :rule-classes :rewrite)

Theorem: cst-variable-or-free-constant-conc-of-tree-fix-cst

(defthm cst-variable-or-free-constant-conc-of-tree-fix-cst
 (equal
     (cst-variable-or-free-constant-conc (abnf::tree-fix abnf::cst))
     (cst-variable-or-free-constant-conc abnf::cst)))

Theorem: cst-variable-or-free-constant-conc-tree-equiv-congruence-on-cst

(defthm
    cst-variable-or-free-constant-conc-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-variable-or-free-constant-conc abnf::cst)
                  (cst-variable-or-free-constant-conc cst-equiv)))
  :rule-classes :congruence)

Function: cst-associated-constant-conc

(defun cst-associated-constant-conc (abnf::cst)
  (declare (xargs :guard (abnf::treep abnf::cst)))
  (declare
       (xargs :guard (cst-matchp abnf::cst "associated-constant")))
  (let ((__function__ 'cst-associated-constant-conc))
    (declare (ignorable __function__))
    (abnf::tree-nonleaf->branches abnf::cst)))

Theorem: tree-list-listp-of-cst-associated-constant-conc

(defthm tree-list-listp-of-cst-associated-constant-conc
  (b* ((abnf::cstss (cst-associated-constant-conc abnf::cst)))
    (abnf::tree-list-listp abnf::cstss))
  :rule-classes :rewrite)

Theorem: cst-associated-constant-conc-match

(defthm cst-associated-constant-conc-match
  (implies
       (cst-matchp abnf::cst "associated-constant")
       (b* ((abnf::cstss (cst-associated-constant-conc abnf::cst)))
         (cst-list-list-conc-matchp abnf::cstss
                                    "named-type \"::\" identifier")))
  :rule-classes :rewrite)

Theorem: cst-associated-constant-conc-of-tree-fix-cst

(defthm cst-associated-constant-conc-of-tree-fix-cst
  (equal (cst-associated-constant-conc (abnf::tree-fix abnf::cst))
         (cst-associated-constant-conc abnf::cst)))

Theorem: cst-associated-constant-conc-tree-equiv-congruence-on-cst

(defthm cst-associated-constant-conc-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-associated-constant-conc abnf::cst)
                  (cst-associated-constant-conc cst-equiv)))
  :rule-classes :congruence)

Function: cst-static-function-call-conc

(defun cst-static-function-call-conc (abnf::cst)
  (declare (xargs :guard (abnf::treep abnf::cst)))
  (declare
       (xargs :guard (cst-matchp abnf::cst "static-function-call")))
  (let ((__function__ 'cst-static-function-call-conc))
    (declare (ignorable __function__))
    (abnf::tree-nonleaf->branches abnf::cst)))

Theorem: tree-list-listp-of-cst-static-function-call-conc

(defthm tree-list-listp-of-cst-static-function-call-conc
  (b* ((abnf::cstss (cst-static-function-call-conc abnf::cst)))
    (abnf::tree-list-listp abnf::cstss))
  :rule-classes :rewrite)

Theorem: cst-static-function-call-conc-match

(defthm cst-static-function-call-conc-match
  (implies
       (cst-matchp abnf::cst "static-function-call")
       (b* ((abnf::cstss (cst-static-function-call-conc abnf::cst)))
         (cst-list-list-conc-matchp
              abnf::cstss
              "named-type \"::\" identifier function-arguments")))
  :rule-classes :rewrite)

Theorem: cst-static-function-call-conc-of-tree-fix-cst

(defthm cst-static-function-call-conc-of-tree-fix-cst
  (equal (cst-static-function-call-conc (abnf::tree-fix abnf::cst))
         (cst-static-function-call-conc abnf::cst)))

Theorem: cst-static-function-call-conc-tree-equiv-congruence-on-cst

(defthm cst-static-function-call-conc-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-static-function-call-conc abnf::cst)
                  (cst-static-function-call-conc cst-equiv)))
  :rule-classes :congruence)

Function: cst-function-arguments-conc

(defun cst-function-arguments-conc (abnf::cst)
  (declare (xargs :guard (abnf::treep abnf::cst)))
  (declare
       (xargs :guard (cst-matchp abnf::cst "function-arguments")))
  (let ((__function__ 'cst-function-arguments-conc))
    (declare (ignorable __function__))
    (abnf::tree-nonleaf->branches abnf::cst)))

Theorem: tree-list-listp-of-cst-function-arguments-conc

(defthm tree-list-listp-of-cst-function-arguments-conc
  (b* ((abnf::cstss (cst-function-arguments-conc abnf::cst)))
    (abnf::tree-list-listp abnf::cstss))
  :rule-classes :rewrite)

Theorem: cst-function-arguments-conc-match

(defthm cst-function-arguments-conc-match
 (implies
      (cst-matchp abnf::cst "function-arguments")
      (b* ((abnf::cstss (cst-function-arguments-conc abnf::cst)))
        (cst-list-list-conc-matchp
             abnf::cstss
             "\"(\" [ expression *( \",\" expression ) [ \",\" ] ] \")\"")))
 :rule-classes :rewrite)

Theorem: cst-function-arguments-conc-of-tree-fix-cst

(defthm cst-function-arguments-conc-of-tree-fix-cst
  (equal (cst-function-arguments-conc (abnf::tree-fix abnf::cst))
         (cst-function-arguments-conc abnf::cst)))

Theorem: cst-function-arguments-conc-tree-equiv-congruence-on-cst

(defthm cst-function-arguments-conc-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-function-arguments-conc abnf::cst)
                  (cst-function-arguments-conc cst-equiv)))
  :rule-classes :congruence)

Function: cst-unit-expression-conc

(defun cst-unit-expression-conc (abnf::cst)
  (declare (xargs :guard (abnf::treep abnf::cst)))
  (declare (xargs :guard (cst-matchp abnf::cst "unit-expression")))
  (let ((__function__ 'cst-unit-expression-conc))
    (declare (ignorable __function__))
    (abnf::tree-nonleaf->branches abnf::cst)))

Theorem: tree-list-listp-of-cst-unit-expression-conc

(defthm tree-list-listp-of-cst-unit-expression-conc
  (b* ((abnf::cstss (cst-unit-expression-conc abnf::cst)))
    (abnf::tree-list-listp abnf::cstss))
  :rule-classes :rewrite)

Theorem: cst-unit-expression-conc-match

(defthm cst-unit-expression-conc-match
  (implies (cst-matchp abnf::cst "unit-expression")
           (b* ((abnf::cstss (cst-unit-expression-conc abnf::cst)))
             (cst-list-list-conc-matchp abnf::cstss "\"(\" \")\"")))
  :rule-classes :rewrite)

Theorem: cst-unit-expression-conc-of-tree-fix-cst

(defthm cst-unit-expression-conc-of-tree-fix-cst
  (equal (cst-unit-expression-conc (abnf::tree-fix abnf::cst))
         (cst-unit-expression-conc abnf::cst)))

Theorem: cst-unit-expression-conc-tree-equiv-congruence-on-cst

(defthm cst-unit-expression-conc-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-unit-expression-conc abnf::cst)
                  (cst-unit-expression-conc cst-equiv)))
  :rule-classes :congruence)

Function: cst-tuple-expression-conc

(defun cst-tuple-expression-conc (abnf::cst)
  (declare (xargs :guard (abnf::treep abnf::cst)))
  (declare (xargs :guard (cst-matchp abnf::cst "tuple-expression")))
  (let ((__function__ 'cst-tuple-expression-conc))
    (declare (ignorable __function__))
    (abnf::tree-nonleaf->branches abnf::cst)))

Theorem: tree-list-listp-of-cst-tuple-expression-conc

(defthm tree-list-listp-of-cst-tuple-expression-conc
  (b* ((abnf::cstss (cst-tuple-expression-conc abnf::cst)))
    (abnf::tree-list-listp abnf::cstss))
  :rule-classes :rewrite)

Theorem: cst-tuple-expression-conc-match

(defthm cst-tuple-expression-conc-match
  (implies
       (cst-matchp abnf::cst "tuple-expression")
       (b* ((abnf::cstss (cst-tuple-expression-conc abnf::cst)))
         (cst-list-list-conc-matchp
              abnf::cstss
              "\"(\" expression 1*( \",\" expression ) [ \",\" ] \")\"")))
  :rule-classes :rewrite)

Theorem: cst-tuple-expression-conc-of-tree-fix-cst

(defthm cst-tuple-expression-conc-of-tree-fix-cst
  (equal (cst-tuple-expression-conc (abnf::tree-fix abnf::cst))
         (cst-tuple-expression-conc abnf::cst)))

Theorem: cst-tuple-expression-conc-tree-equiv-congruence-on-cst

(defthm cst-tuple-expression-conc-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-tuple-expression-conc abnf::cst)
                  (cst-tuple-expression-conc cst-equiv)))
  :rule-classes :congruence)

Function: cst-struct-expression-conc

(defun cst-struct-expression-conc (abnf::cst)
 (declare (xargs :guard (abnf::treep abnf::cst)))
 (declare (xargs :guard (cst-matchp abnf::cst "struct-expression")))
 (let ((__function__ 'cst-struct-expression-conc))
   (declare (ignorable __function__))
   (abnf::tree-nonleaf->branches abnf::cst)))

Theorem: tree-list-listp-of-cst-struct-expression-conc

(defthm tree-list-listp-of-cst-struct-expression-conc
  (b* ((abnf::cstss (cst-struct-expression-conc abnf::cst)))
    (abnf::tree-list-listp abnf::cstss))
  :rule-classes :rewrite)

Theorem: cst-struct-expression-conc-match

(defthm cst-struct-expression-conc-match
 (implies
  (cst-matchp abnf::cst "struct-expression")
  (b* ((abnf::cstss (cst-struct-expression-conc abnf::cst)))
   (cst-list-list-conc-matchp
    abnf::cstss
    "identifier \"{\" struct-component-initializer *( \",\" struct-component-initializer ) [ \",\" ] \"}\"")))
 :rule-classes :rewrite)

Theorem: cst-struct-expression-conc-of-tree-fix-cst

(defthm cst-struct-expression-conc-of-tree-fix-cst
  (equal (cst-struct-expression-conc (abnf::tree-fix abnf::cst))
         (cst-struct-expression-conc abnf::cst)))

Theorem: cst-struct-expression-conc-tree-equiv-congruence-on-cst

(defthm cst-struct-expression-conc-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-struct-expression-conc abnf::cst)
                  (cst-struct-expression-conc cst-equiv)))
  :rule-classes :congruence)

Function: cst-postfix-expression-conc1

(defun cst-postfix-expression-conc1 (abnf::cst)
 (declare (xargs :guard (abnf::treep abnf::cst)))
 (declare
  (xargs :guard (and (cst-matchp abnf::cst "postfix-expression")
                     (equal (cst-postfix-expression-conc? abnf::cst)
                            1))))
 (let ((__function__ 'cst-postfix-expression-conc1))
   (declare (ignorable __function__))
   (abnf::tree-nonleaf->branches abnf::cst)))

Theorem: tree-list-listp-of-cst-postfix-expression-conc1

(defthm tree-list-listp-of-cst-postfix-expression-conc1
  (b* ((abnf::cstss (cst-postfix-expression-conc1 abnf::cst)))
    (abnf::tree-list-listp abnf::cstss))
  :rule-classes :rewrite)

Theorem: cst-postfix-expression-conc1-match

(defthm cst-postfix-expression-conc1-match
 (implies
    (and (cst-matchp abnf::cst "postfix-expression")
         (equal (cst-postfix-expression-conc? abnf::cst)
                1))
    (b* ((abnf::cstss (cst-postfix-expression-conc1 abnf::cst)))
      (cst-list-list-conc-matchp abnf::cstss "primary-expression")))
 :rule-classes :rewrite)

Theorem: cst-postfix-expression-conc1-of-tree-fix-cst

(defthm cst-postfix-expression-conc1-of-tree-fix-cst
  (equal (cst-postfix-expression-conc1 (abnf::tree-fix abnf::cst))
         (cst-postfix-expression-conc1 abnf::cst)))

Theorem: cst-postfix-expression-conc1-tree-equiv-congruence-on-cst

(defthm cst-postfix-expression-conc1-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-postfix-expression-conc1 abnf::cst)
                  (cst-postfix-expression-conc1 cst-equiv)))
  :rule-classes :congruence)

Function: cst-postfix-expression-conc2

(defun cst-postfix-expression-conc2 (abnf::cst)
 (declare (xargs :guard (abnf::treep abnf::cst)))
 (declare
  (xargs :guard (and (cst-matchp abnf::cst "postfix-expression")
                     (equal (cst-postfix-expression-conc? abnf::cst)
                            2))))
 (let ((__function__ 'cst-postfix-expression-conc2))
   (declare (ignorable __function__))
   (abnf::tree-nonleaf->branches abnf::cst)))

Theorem: tree-list-listp-of-cst-postfix-expression-conc2

(defthm tree-list-listp-of-cst-postfix-expression-conc2
  (b* ((abnf::cstss (cst-postfix-expression-conc2 abnf::cst)))
    (abnf::tree-list-listp abnf::cstss))
  :rule-classes :rewrite)

Theorem: cst-postfix-expression-conc2-match

(defthm cst-postfix-expression-conc2-match
  (implies
       (and (cst-matchp abnf::cst "postfix-expression")
            (equal (cst-postfix-expression-conc? abnf::cst)
                   2))
       (b* ((abnf::cstss (cst-postfix-expression-conc2 abnf::cst)))
         (cst-list-list-conc-matchp abnf::cstss
                                    "tuple-component-expression")))
  :rule-classes :rewrite)

Theorem: cst-postfix-expression-conc2-of-tree-fix-cst

(defthm cst-postfix-expression-conc2-of-tree-fix-cst
  (equal (cst-postfix-expression-conc2 (abnf::tree-fix abnf::cst))
         (cst-postfix-expression-conc2 abnf::cst)))

Theorem: cst-postfix-expression-conc2-tree-equiv-congruence-on-cst

(defthm cst-postfix-expression-conc2-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-postfix-expression-conc2 abnf::cst)
                  (cst-postfix-expression-conc2 cst-equiv)))
  :rule-classes :congruence)

Function: cst-postfix-expression-conc3

(defun cst-postfix-expression-conc3 (abnf::cst)
 (declare (xargs :guard (abnf::treep abnf::cst)))
 (declare
  (xargs :guard (and (cst-matchp abnf::cst "postfix-expression")
                     (equal (cst-postfix-expression-conc? abnf::cst)
                            3))))
 (let ((__function__ 'cst-postfix-expression-conc3))
   (declare (ignorable __function__))
   (abnf::tree-nonleaf->branches abnf::cst)))

Theorem: tree-list-listp-of-cst-postfix-expression-conc3

(defthm tree-list-listp-of-cst-postfix-expression-conc3
  (b* ((abnf::cstss (cst-postfix-expression-conc3 abnf::cst)))
    (abnf::tree-list-listp abnf::cstss))
  :rule-classes :rewrite)

Theorem: cst-postfix-expression-conc3-match

(defthm cst-postfix-expression-conc3-match
  (implies
       (and (cst-matchp abnf::cst "postfix-expression")
            (equal (cst-postfix-expression-conc? abnf::cst)
                   3))
       (b* ((abnf::cstss (cst-postfix-expression-conc3 abnf::cst)))
         (cst-list-list-conc-matchp abnf::cstss
                                    "struct-component-expression")))
  :rule-classes :rewrite)

Theorem: cst-postfix-expression-conc3-of-tree-fix-cst

(defthm cst-postfix-expression-conc3-of-tree-fix-cst
  (equal (cst-postfix-expression-conc3 (abnf::tree-fix abnf::cst))
         (cst-postfix-expression-conc3 abnf::cst)))

Theorem: cst-postfix-expression-conc3-tree-equiv-congruence-on-cst

(defthm cst-postfix-expression-conc3-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-postfix-expression-conc3 abnf::cst)
                  (cst-postfix-expression-conc3 cst-equiv)))
  :rule-classes :congruence)

Function: cst-postfix-expression-conc4

(defun cst-postfix-expression-conc4 (abnf::cst)
 (declare (xargs :guard (abnf::treep abnf::cst)))
 (declare
  (xargs :guard (and (cst-matchp abnf::cst "postfix-expression")
                     (equal (cst-postfix-expression-conc? abnf::cst)
                            4))))
 (let ((__function__ 'cst-postfix-expression-conc4))
   (declare (ignorable __function__))
   (abnf::tree-nonleaf->branches abnf::cst)))

Theorem: tree-list-listp-of-cst-postfix-expression-conc4

(defthm tree-list-listp-of-cst-postfix-expression-conc4
  (b* ((abnf::cstss (cst-postfix-expression-conc4 abnf::cst)))
    (abnf::tree-list-listp abnf::cstss))
  :rule-classes :rewrite)

Theorem: cst-postfix-expression-conc4-match

(defthm cst-postfix-expression-conc4-match
  (implies
       (and (cst-matchp abnf::cst "postfix-expression")
            (equal (cst-postfix-expression-conc? abnf::cst)
                   4))
       (b* ((abnf::cstss (cst-postfix-expression-conc4 abnf::cst)))
         (cst-list-list-conc-matchp abnf::cstss "operator-call")))
  :rule-classes :rewrite)

Theorem: cst-postfix-expression-conc4-of-tree-fix-cst

(defthm cst-postfix-expression-conc4-of-tree-fix-cst
  (equal (cst-postfix-expression-conc4 (abnf::tree-fix abnf::cst))
         (cst-postfix-expression-conc4 abnf::cst)))

Theorem: cst-postfix-expression-conc4-tree-equiv-congruence-on-cst

(defthm cst-postfix-expression-conc4-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-postfix-expression-conc4 abnf::cst)
                  (cst-postfix-expression-conc4 cst-equiv)))
  :rule-classes :congruence)

Function: cst-tuple-component-expression-conc

(defun cst-tuple-component-expression-conc (abnf::cst)
  (declare (xargs :guard (abnf::treep abnf::cst)))
  (declare (xargs :guard (cst-matchp abnf::cst
                                     "tuple-component-expression")))
  (let ((__function__ 'cst-tuple-component-expression-conc))
    (declare (ignorable __function__))
    (abnf::tree-nonleaf->branches abnf::cst)))

Theorem: tree-list-listp-of-cst-tuple-component-expression-conc

(defthm tree-list-listp-of-cst-tuple-component-expression-conc
 (b* ((abnf::cstss (cst-tuple-component-expression-conc abnf::cst)))
   (abnf::tree-list-listp abnf::cstss))
 :rule-classes :rewrite)

Theorem: cst-tuple-component-expression-conc-match

(defthm cst-tuple-component-expression-conc-match
 (implies
   (cst-matchp abnf::cst "tuple-component-expression")
   (b*
     ((abnf::cstss (cst-tuple-component-expression-conc abnf::cst)))
     (cst-list-list-conc-matchp abnf::cstss
                                "postfix-expression \".\" numeral")))
 :rule-classes :rewrite)

Theorem: cst-tuple-component-expression-conc-of-tree-fix-cst

(defthm cst-tuple-component-expression-conc-of-tree-fix-cst
 (equal
    (cst-tuple-component-expression-conc (abnf::tree-fix abnf::cst))
    (cst-tuple-component-expression-conc abnf::cst)))

Theorem: cst-tuple-component-expression-conc-tree-equiv-congruence-on-cst

(defthm
   cst-tuple-component-expression-conc-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-tuple-component-expression-conc abnf::cst)
                  (cst-tuple-component-expression-conc cst-equiv)))
  :rule-classes :congruence)

Function: cst-struct-component-expression-conc

(defun cst-struct-component-expression-conc (abnf::cst)
 (declare (xargs :guard (abnf::treep abnf::cst)))
 (declare (xargs :guard (cst-matchp abnf::cst
                                    "struct-component-expression")))
 (let ((__function__ 'cst-struct-component-expression-conc))
   (declare (ignorable __function__))
   (abnf::tree-nonleaf->branches abnf::cst)))

Theorem: tree-list-listp-of-cst-struct-component-expression-conc

(defthm tree-list-listp-of-cst-struct-component-expression-conc
  (b*
    ((abnf::cstss (cst-struct-component-expression-conc abnf::cst)))
    (abnf::tree-list-listp abnf::cstss))
  :rule-classes :rewrite)

Theorem: cst-struct-component-expression-conc-match

(defthm cst-struct-component-expression-conc-match
 (implies
  (cst-matchp abnf::cst "struct-component-expression")
  (b*
   ((abnf::cstss (cst-struct-component-expression-conc abnf::cst)))
   (cst-list-list-conc-matchp abnf::cstss
                              "postfix-expression \".\" identifier")))
 :rule-classes :rewrite)

Theorem: cst-struct-component-expression-conc-of-tree-fix-cst

(defthm cst-struct-component-expression-conc-of-tree-fix-cst
 (equal
   (cst-struct-component-expression-conc (abnf::tree-fix abnf::cst))
   (cst-struct-component-expression-conc abnf::cst)))

Theorem: cst-struct-component-expression-conc-tree-equiv-congruence-on-cst

(defthm
  cst-struct-component-expression-conc-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-struct-component-expression-conc abnf::cst)
                  (cst-struct-component-expression-conc cst-equiv)))
  :rule-classes :congruence)

Function: cst-operator-call-conc1

(defun cst-operator-call-conc1 (abnf::cst)
  (declare (xargs :guard (abnf::treep abnf::cst)))
  (declare
       (xargs :guard (and (cst-matchp abnf::cst "operator-call")
                          (equal (cst-operator-call-conc? abnf::cst)
                                 1))))
  (let ((__function__ 'cst-operator-call-conc1))
    (declare (ignorable __function__))
    (abnf::tree-nonleaf->branches abnf::cst)))

Theorem: tree-list-listp-of-cst-operator-call-conc1

(defthm tree-list-listp-of-cst-operator-call-conc1
  (b* ((abnf::cstss (cst-operator-call-conc1 abnf::cst)))
    (abnf::tree-list-listp abnf::cstss))
  :rule-classes :rewrite)

Theorem: cst-operator-call-conc1-match

(defthm cst-operator-call-conc1-match
 (implies
   (and (cst-matchp abnf::cst "operator-call")
        (equal (cst-operator-call-conc? abnf::cst)
               1))
   (b* ((abnf::cstss (cst-operator-call-conc1 abnf::cst)))
     (cst-list-list-conc-matchp abnf::cstss "unary-operator-call")))
 :rule-classes :rewrite)

Theorem: cst-operator-call-conc1-of-tree-fix-cst

(defthm cst-operator-call-conc1-of-tree-fix-cst
  (equal (cst-operator-call-conc1 (abnf::tree-fix abnf::cst))
         (cst-operator-call-conc1 abnf::cst)))

Theorem: cst-operator-call-conc1-tree-equiv-congruence-on-cst

(defthm cst-operator-call-conc1-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-operator-call-conc1 abnf::cst)
                  (cst-operator-call-conc1 cst-equiv)))
  :rule-classes :congruence)

Function: cst-operator-call-conc2

(defun cst-operator-call-conc2 (abnf::cst)
  (declare (xargs :guard (abnf::treep abnf::cst)))
  (declare
       (xargs :guard (and (cst-matchp abnf::cst "operator-call")
                          (equal (cst-operator-call-conc? abnf::cst)
                                 2))))
  (let ((__function__ 'cst-operator-call-conc2))
    (declare (ignorable __function__))
    (abnf::tree-nonleaf->branches abnf::cst)))

Theorem: tree-list-listp-of-cst-operator-call-conc2

(defthm tree-list-listp-of-cst-operator-call-conc2
  (b* ((abnf::cstss (cst-operator-call-conc2 abnf::cst)))
    (abnf::tree-list-listp abnf::cstss))
  :rule-classes :rewrite)

Theorem: cst-operator-call-conc2-match

(defthm cst-operator-call-conc2-match
 (implies
  (and (cst-matchp abnf::cst "operator-call")
       (equal (cst-operator-call-conc? abnf::cst)
              2))
  (b* ((abnf::cstss (cst-operator-call-conc2 abnf::cst)))
    (cst-list-list-conc-matchp abnf::cstss "binary-operator-call")))
 :rule-classes :rewrite)

Theorem: cst-operator-call-conc2-of-tree-fix-cst

(defthm cst-operator-call-conc2-of-tree-fix-cst
  (equal (cst-operator-call-conc2 (abnf::tree-fix abnf::cst))
         (cst-operator-call-conc2 abnf::cst)))

Theorem: cst-operator-call-conc2-tree-equiv-congruence-on-cst

(defthm cst-operator-call-conc2-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-operator-call-conc2 abnf::cst)
                  (cst-operator-call-conc2 cst-equiv)))
  :rule-classes :congruence)

Function: cst-unary-operator-call-conc

(defun cst-unary-operator-call-conc (abnf::cst)
  (declare (xargs :guard (abnf::treep abnf::cst)))
  (declare
       (xargs :guard (cst-matchp abnf::cst "unary-operator-call")))
  (let ((__function__ 'cst-unary-operator-call-conc))
    (declare (ignorable __function__))
    (abnf::tree-nonleaf->branches abnf::cst)))

Theorem: tree-list-listp-of-cst-unary-operator-call-conc

(defthm tree-list-listp-of-cst-unary-operator-call-conc
  (b* ((abnf::cstss (cst-unary-operator-call-conc abnf::cst)))
    (abnf::tree-list-listp abnf::cstss))
  :rule-classes :rewrite)

Theorem: cst-unary-operator-call-conc-match

(defthm cst-unary-operator-call-conc-match
  (implies
       (cst-matchp abnf::cst "unary-operator-call")
       (b* ((abnf::cstss (cst-unary-operator-call-conc abnf::cst)))
         (cst-list-list-conc-matchp
              abnf::cstss
              "postfix-expression \".\" identifier \"(\" \")\"")))
  :rule-classes :rewrite)

Theorem: cst-unary-operator-call-conc-of-tree-fix-cst

(defthm cst-unary-operator-call-conc-of-tree-fix-cst
  (equal (cst-unary-operator-call-conc (abnf::tree-fix abnf::cst))
         (cst-unary-operator-call-conc abnf::cst)))

Theorem: cst-unary-operator-call-conc-tree-equiv-congruence-on-cst

(defthm cst-unary-operator-call-conc-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-unary-operator-call-conc abnf::cst)
                  (cst-unary-operator-call-conc cst-equiv)))
  :rule-classes :congruence)

Function: cst-binary-operator-call-conc

(defun cst-binary-operator-call-conc (abnf::cst)
  (declare (xargs :guard (abnf::treep abnf::cst)))
  (declare
       (xargs :guard (cst-matchp abnf::cst "binary-operator-call")))
  (let ((__function__ 'cst-binary-operator-call-conc))
    (declare (ignorable __function__))
    (abnf::tree-nonleaf->branches abnf::cst)))

Theorem: tree-list-listp-of-cst-binary-operator-call-conc

(defthm tree-list-listp-of-cst-binary-operator-call-conc
  (b* ((abnf::cstss (cst-binary-operator-call-conc abnf::cst)))
    (abnf::tree-list-listp abnf::cstss))
  :rule-classes :rewrite)

Theorem: cst-binary-operator-call-conc-match

(defthm cst-binary-operator-call-conc-match
 (implies
  (cst-matchp abnf::cst "binary-operator-call")
  (b* ((abnf::cstss (cst-binary-operator-call-conc abnf::cst)))
   (cst-list-list-conc-matchp
    abnf::cstss
    "postfix-expression \".\" identifier \"(\" expression [ \",\" ] \")\"")))
 :rule-classes :rewrite)

Theorem: cst-binary-operator-call-conc-of-tree-fix-cst

(defthm cst-binary-operator-call-conc-of-tree-fix-cst
  (equal (cst-binary-operator-call-conc (abnf::tree-fix abnf::cst))
         (cst-binary-operator-call-conc abnf::cst)))

Theorem: cst-binary-operator-call-conc-tree-equiv-congruence-on-cst

(defthm cst-binary-operator-call-conc-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-binary-operator-call-conc abnf::cst)
                  (cst-binary-operator-call-conc cst-equiv)))
  :rule-classes :congruence)

Function: cst-binary-expression-conc

(defun cst-binary-expression-conc (abnf::cst)
 (declare (xargs :guard (abnf::treep abnf::cst)))
 (declare (xargs :guard (cst-matchp abnf::cst "binary-expression")))
 (let ((__function__ 'cst-binary-expression-conc))
   (declare (ignorable __function__))
   (abnf::tree-nonleaf->branches abnf::cst)))

Theorem: tree-list-listp-of-cst-binary-expression-conc

(defthm tree-list-listp-of-cst-binary-expression-conc
  (b* ((abnf::cstss (cst-binary-expression-conc abnf::cst)))
    (abnf::tree-list-listp abnf::cstss))
  :rule-classes :rewrite)

Theorem: cst-binary-expression-conc-match

(defthm cst-binary-expression-conc-match
 (implies (cst-matchp abnf::cst "binary-expression")
          (b* ((abnf::cstss (cst-binary-expression-conc abnf::cst)))
            (cst-list-list-conc-matchp
                 abnf::cstss
                 "conditional-disjunctive-expression")))
 :rule-classes :rewrite)

Theorem: cst-binary-expression-conc-of-tree-fix-cst

(defthm cst-binary-expression-conc-of-tree-fix-cst
  (equal (cst-binary-expression-conc (abnf::tree-fix abnf::cst))
         (cst-binary-expression-conc abnf::cst)))

Theorem: cst-binary-expression-conc-tree-equiv-congruence-on-cst

(defthm cst-binary-expression-conc-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-binary-expression-conc abnf::cst)
                  (cst-binary-expression-conc cst-equiv)))
  :rule-classes :congruence)

Function: cst-expression-conc

(defun cst-expression-conc (abnf::cst)
  (declare (xargs :guard (abnf::treep abnf::cst)))
  (declare (xargs :guard (cst-matchp abnf::cst "expression")))
  (let ((__function__ 'cst-expression-conc))
    (declare (ignorable __function__))
    (abnf::tree-nonleaf->branches abnf::cst)))

Theorem: tree-list-listp-of-cst-expression-conc

(defthm tree-list-listp-of-cst-expression-conc
  (b* ((abnf::cstss (cst-expression-conc abnf::cst)))
    (abnf::tree-list-listp abnf::cstss))
  :rule-classes :rewrite)

Theorem: cst-expression-conc-match

(defthm cst-expression-conc-match
 (implies
    (cst-matchp abnf::cst "expression")
    (b* ((abnf::cstss (cst-expression-conc abnf::cst)))
      (cst-list-list-conc-matchp abnf::cstss
                                 "conditional-ternary-expression")))
 :rule-classes :rewrite)

Theorem: cst-expression-conc-of-tree-fix-cst

(defthm cst-expression-conc-of-tree-fix-cst
  (equal (cst-expression-conc (abnf::tree-fix abnf::cst))
         (cst-expression-conc abnf::cst)))

Theorem: cst-expression-conc-tree-equiv-congruence-on-cst

(defthm cst-expression-conc-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-expression-conc abnf::cst)
                  (cst-expression-conc cst-equiv)))
  :rule-classes :congruence)

Function: cst-statement-conc1

(defun cst-statement-conc1 (abnf::cst)
  (declare (xargs :guard (abnf::treep abnf::cst)))
  (declare (xargs :guard (and (cst-matchp abnf::cst "statement")
                              (equal (cst-statement-conc? abnf::cst)
                                     1))))
  (let ((__function__ 'cst-statement-conc1))
    (declare (ignorable __function__))
    (abnf::tree-nonleaf->branches abnf::cst)))

Theorem: tree-list-listp-of-cst-statement-conc1

(defthm tree-list-listp-of-cst-statement-conc1
  (b* ((abnf::cstss (cst-statement-conc1 abnf::cst)))
    (abnf::tree-list-listp abnf::cstss))
  :rule-classes :rewrite)

Theorem: cst-statement-conc1-match

(defthm cst-statement-conc1-match
 (implies
      (and (cst-matchp abnf::cst "statement")
           (equal (cst-statement-conc? abnf::cst)
                  1))
      (b* ((abnf::cstss (cst-statement-conc1 abnf::cst)))
        (cst-list-list-conc-matchp abnf::cstss "return-statement")))
 :rule-classes :rewrite)

Theorem: cst-statement-conc1-of-tree-fix-cst

(defthm cst-statement-conc1-of-tree-fix-cst
  (equal (cst-statement-conc1 (abnf::tree-fix abnf::cst))
         (cst-statement-conc1 abnf::cst)))

Theorem: cst-statement-conc1-tree-equiv-congruence-on-cst

(defthm cst-statement-conc1-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-statement-conc1 abnf::cst)
                  (cst-statement-conc1 cst-equiv)))
  :rule-classes :congruence)

Function: cst-statement-conc2

(defun cst-statement-conc2 (abnf::cst)
  (declare (xargs :guard (abnf::treep abnf::cst)))
  (declare (xargs :guard (and (cst-matchp abnf::cst "statement")
                              (equal (cst-statement-conc? abnf::cst)
                                     2))))
  (let ((__function__ 'cst-statement-conc2))
    (declare (ignorable __function__))
    (abnf::tree-nonleaf->branches abnf::cst)))

Theorem: tree-list-listp-of-cst-statement-conc2

(defthm tree-list-listp-of-cst-statement-conc2
  (b* ((abnf::cstss (cst-statement-conc2 abnf::cst)))
    (abnf::tree-list-listp abnf::cstss))
  :rule-classes :rewrite)

Theorem: cst-statement-conc2-match

(defthm cst-statement-conc2-match
 (implies
  (and (cst-matchp abnf::cst "statement")
       (equal (cst-statement-conc? abnf::cst)
              2))
  (b* ((abnf::cstss (cst-statement-conc2 abnf::cst)))
    (cst-list-list-conc-matchp abnf::cstss "variable-declaration")))
 :rule-classes :rewrite)

Theorem: cst-statement-conc2-of-tree-fix-cst

(defthm cst-statement-conc2-of-tree-fix-cst
  (equal (cst-statement-conc2 (abnf::tree-fix abnf::cst))
         (cst-statement-conc2 abnf::cst)))

Theorem: cst-statement-conc2-tree-equiv-congruence-on-cst

(defthm cst-statement-conc2-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-statement-conc2 abnf::cst)
                  (cst-statement-conc2 cst-equiv)))
  :rule-classes :congruence)

Function: cst-statement-conc3

(defun cst-statement-conc3 (abnf::cst)
  (declare (xargs :guard (abnf::treep abnf::cst)))
  (declare (xargs :guard (and (cst-matchp abnf::cst "statement")
                              (equal (cst-statement-conc? abnf::cst)
                                     3))))
  (let ((__function__ 'cst-statement-conc3))
    (declare (ignorable __function__))
    (abnf::tree-nonleaf->branches abnf::cst)))

Theorem: tree-list-listp-of-cst-statement-conc3

(defthm tree-list-listp-of-cst-statement-conc3
  (b* ((abnf::cstss (cst-statement-conc3 abnf::cst)))
    (abnf::tree-list-listp abnf::cstss))
  :rule-classes :rewrite)

Theorem: cst-statement-conc3-match

(defthm cst-statement-conc3-match
 (implies
  (and (cst-matchp abnf::cst "statement")
       (equal (cst-statement-conc? abnf::cst)
              3))
  (b* ((abnf::cstss (cst-statement-conc3 abnf::cst)))
    (cst-list-list-conc-matchp abnf::cstss "constant-declaration")))
 :rule-classes :rewrite)

Theorem: cst-statement-conc3-of-tree-fix-cst

(defthm cst-statement-conc3-of-tree-fix-cst
  (equal (cst-statement-conc3 (abnf::tree-fix abnf::cst))
         (cst-statement-conc3 abnf::cst)))

Theorem: cst-statement-conc3-tree-equiv-congruence-on-cst

(defthm cst-statement-conc3-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-statement-conc3 abnf::cst)
                  (cst-statement-conc3 cst-equiv)))
  :rule-classes :congruence)

Function: cst-statement-conc4

(defun cst-statement-conc4 (abnf::cst)
  (declare (xargs :guard (abnf::treep abnf::cst)))
  (declare (xargs :guard (and (cst-matchp abnf::cst "statement")
                              (equal (cst-statement-conc? abnf::cst)
                                     4))))
  (let ((__function__ 'cst-statement-conc4))
    (declare (ignorable __function__))
    (abnf::tree-nonleaf->branches abnf::cst)))

Theorem: tree-list-listp-of-cst-statement-conc4

(defthm tree-list-listp-of-cst-statement-conc4
  (b* ((abnf::cstss (cst-statement-conc4 abnf::cst)))
    (abnf::tree-list-listp abnf::cstss))
  :rule-classes :rewrite)

Theorem: cst-statement-conc4-match

(defthm cst-statement-conc4-match
 (implies
  (and (cst-matchp abnf::cst "statement")
       (equal (cst-statement-conc? abnf::cst)
              4))
  (b* ((abnf::cstss (cst-statement-conc4 abnf::cst)))
   (cst-list-list-conc-matchp abnf::cstss "conditional-statement")))
 :rule-classes :rewrite)

Theorem: cst-statement-conc4-of-tree-fix-cst

(defthm cst-statement-conc4-of-tree-fix-cst
  (equal (cst-statement-conc4 (abnf::tree-fix abnf::cst))
         (cst-statement-conc4 abnf::cst)))

Theorem: cst-statement-conc4-tree-equiv-congruence-on-cst

(defthm cst-statement-conc4-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-statement-conc4 abnf::cst)
                  (cst-statement-conc4 cst-equiv)))
  :rule-classes :congruence)

Function: cst-statement-conc5

(defun cst-statement-conc5 (abnf::cst)
  (declare (xargs :guard (abnf::treep abnf::cst)))
  (declare (xargs :guard (and (cst-matchp abnf::cst "statement")
                              (equal (cst-statement-conc? abnf::cst)
                                     5))))
  (let ((__function__ 'cst-statement-conc5))
    (declare (ignorable __function__))
    (abnf::tree-nonleaf->branches abnf::cst)))

Theorem: tree-list-listp-of-cst-statement-conc5

(defthm tree-list-listp-of-cst-statement-conc5
  (b* ((abnf::cstss (cst-statement-conc5 abnf::cst)))
    (abnf::tree-list-listp abnf::cstss))
  :rule-classes :rewrite)

Theorem: cst-statement-conc5-match

(defthm cst-statement-conc5-match
  (implies
       (and (cst-matchp abnf::cst "statement")
            (equal (cst-statement-conc? abnf::cst)
                   5))
       (b* ((abnf::cstss (cst-statement-conc5 abnf::cst)))
         (cst-list-list-conc-matchp abnf::cstss "loop-statement")))
  :rule-classes :rewrite)

Theorem: cst-statement-conc5-of-tree-fix-cst

(defthm cst-statement-conc5-of-tree-fix-cst
  (equal (cst-statement-conc5 (abnf::tree-fix abnf::cst))
         (cst-statement-conc5 abnf::cst)))

Theorem: cst-statement-conc5-tree-equiv-congruence-on-cst

(defthm cst-statement-conc5-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-statement-conc5 abnf::cst)
                  (cst-statement-conc5 cst-equiv)))
  :rule-classes :congruence)

Function: cst-statement-conc6

(defun cst-statement-conc6 (abnf::cst)
  (declare (xargs :guard (abnf::treep abnf::cst)))
  (declare (xargs :guard (and (cst-matchp abnf::cst "statement")
                              (equal (cst-statement-conc? abnf::cst)
                                     6))))
  (let ((__function__ 'cst-statement-conc6))
    (declare (ignorable __function__))
    (abnf::tree-nonleaf->branches abnf::cst)))

Theorem: tree-list-listp-of-cst-statement-conc6

(defthm tree-list-listp-of-cst-statement-conc6
  (b* ((abnf::cstss (cst-statement-conc6 abnf::cst)))
    (abnf::tree-list-listp abnf::cstss))
  :rule-classes :rewrite)

Theorem: cst-statement-conc6-match

(defthm cst-statement-conc6-match
 (implies
  (and (cst-matchp abnf::cst "statement")
       (equal (cst-statement-conc? abnf::cst)
              6))
  (b* ((abnf::cstss (cst-statement-conc6 abnf::cst)))
    (cst-list-list-conc-matchp abnf::cstss "assignment-statement")))
 :rule-classes :rewrite)

Theorem: cst-statement-conc6-of-tree-fix-cst

(defthm cst-statement-conc6-of-tree-fix-cst
  (equal (cst-statement-conc6 (abnf::tree-fix abnf::cst))
         (cst-statement-conc6 abnf::cst)))

Theorem: cst-statement-conc6-tree-equiv-congruence-on-cst

(defthm cst-statement-conc6-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-statement-conc6 abnf::cst)
                  (cst-statement-conc6 cst-equiv)))
  :rule-classes :congruence)

Function: cst-statement-conc7

(defun cst-statement-conc7 (abnf::cst)
  (declare (xargs :guard (abnf::treep abnf::cst)))
  (declare (xargs :guard (and (cst-matchp abnf::cst "statement")
                              (equal (cst-statement-conc? abnf::cst)
                                     7))))
  (let ((__function__ 'cst-statement-conc7))
    (declare (ignorable __function__))
    (abnf::tree-nonleaf->branches abnf::cst)))

Theorem: tree-list-listp-of-cst-statement-conc7

(defthm tree-list-listp-of-cst-statement-conc7
  (b* ((abnf::cstss (cst-statement-conc7 abnf::cst)))
    (abnf::tree-list-listp abnf::cstss))
  :rule-classes :rewrite)

Theorem: cst-statement-conc7-match

(defthm cst-statement-conc7-match
 (implies
     (and (cst-matchp abnf::cst "statement")
          (equal (cst-statement-conc? abnf::cst)
                 7))
     (b* ((abnf::cstss (cst-statement-conc7 abnf::cst)))
       (cst-list-list-conc-matchp abnf::cstss "console-statement")))
 :rule-classes :rewrite)

Theorem: cst-statement-conc7-of-tree-fix-cst

(defthm cst-statement-conc7-of-tree-fix-cst
  (equal (cst-statement-conc7 (abnf::tree-fix abnf::cst))
         (cst-statement-conc7 abnf::cst)))

Theorem: cst-statement-conc7-tree-equiv-congruence-on-cst

(defthm cst-statement-conc7-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-statement-conc7 abnf::cst)
                  (cst-statement-conc7 cst-equiv)))
  :rule-classes :congruence)

Function: cst-statement-conc8

(defun cst-statement-conc8 (abnf::cst)
  (declare (xargs :guard (abnf::treep abnf::cst)))
  (declare (xargs :guard (and (cst-matchp abnf::cst "statement")
                              (equal (cst-statement-conc? abnf::cst)
                                     8))))
  (let ((__function__ 'cst-statement-conc8))
    (declare (ignorable __function__))
    (abnf::tree-nonleaf->branches abnf::cst)))

Theorem: tree-list-listp-of-cst-statement-conc8

(defthm tree-list-listp-of-cst-statement-conc8
  (b* ((abnf::cstss (cst-statement-conc8 abnf::cst)))
    (abnf::tree-list-listp abnf::cstss))
  :rule-classes :rewrite)

Theorem: cst-statement-conc8-match

(defthm cst-statement-conc8-match
 (implies
    (and (cst-matchp abnf::cst "statement")
         (equal (cst-statement-conc? abnf::cst)
                8))
    (b* ((abnf::cstss (cst-statement-conc8 abnf::cst)))
      (cst-list-list-conc-matchp abnf::cstss "finalize-statement")))
 :rule-classes :rewrite)

Theorem: cst-statement-conc8-of-tree-fix-cst

(defthm cst-statement-conc8-of-tree-fix-cst
  (equal (cst-statement-conc8 (abnf::tree-fix abnf::cst))
         (cst-statement-conc8 abnf::cst)))

Theorem: cst-statement-conc8-tree-equiv-congruence-on-cst

(defthm cst-statement-conc8-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-statement-conc8 abnf::cst)
                  (cst-statement-conc8 cst-equiv)))
  :rule-classes :congruence)

Function: cst-statement-conc9

(defun cst-statement-conc9 (abnf::cst)
  (declare (xargs :guard (abnf::treep abnf::cst)))
  (declare (xargs :guard (and (cst-matchp abnf::cst "statement")
                              (equal (cst-statement-conc? abnf::cst)
                                     9))))
  (let ((__function__ 'cst-statement-conc9))
    (declare (ignorable __function__))
    (abnf::tree-nonleaf->branches abnf::cst)))

Theorem: tree-list-listp-of-cst-statement-conc9

(defthm tree-list-listp-of-cst-statement-conc9
  (b* ((abnf::cstss (cst-statement-conc9 abnf::cst)))
    (abnf::tree-list-listp abnf::cstss))
  :rule-classes :rewrite)

Theorem: cst-statement-conc9-match

(defthm cst-statement-conc9-match
 (implies
   (and (cst-matchp abnf::cst "statement")
        (equal (cst-statement-conc? abnf::cst)
               9))
   (b* ((abnf::cstss (cst-statement-conc9 abnf::cst)))
     (cst-list-list-conc-matchp abnf::cstss "increment-statement")))
 :rule-classes :rewrite)

Theorem: cst-statement-conc9-of-tree-fix-cst

(defthm cst-statement-conc9-of-tree-fix-cst
  (equal (cst-statement-conc9 (abnf::tree-fix abnf::cst))
         (cst-statement-conc9 abnf::cst)))

Theorem: cst-statement-conc9-tree-equiv-congruence-on-cst

(defthm cst-statement-conc9-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-statement-conc9 abnf::cst)
                  (cst-statement-conc9 cst-equiv)))
  :rule-classes :congruence)

Function: cst-statement-conc10

(defun cst-statement-conc10 (abnf::cst)
  (declare (xargs :guard (abnf::treep abnf::cst)))
  (declare (xargs :guard (and (cst-matchp abnf::cst "statement")
                              (equal (cst-statement-conc? abnf::cst)
                                     10))))
  (let ((__function__ 'cst-statement-conc10))
    (declare (ignorable __function__))
    (abnf::tree-nonleaf->branches abnf::cst)))

Theorem: tree-list-listp-of-cst-statement-conc10

(defthm tree-list-listp-of-cst-statement-conc10
  (b* ((abnf::cstss (cst-statement-conc10 abnf::cst)))
    (abnf::tree-list-listp abnf::cstss))
  :rule-classes :rewrite)

Theorem: cst-statement-conc10-match

(defthm cst-statement-conc10-match
 (implies
   (and (cst-matchp abnf::cst "statement")
        (equal (cst-statement-conc? abnf::cst)
               10))
   (b* ((abnf::cstss (cst-statement-conc10 abnf::cst)))
     (cst-list-list-conc-matchp abnf::cstss "decrement-statement")))
 :rule-classes :rewrite)

Theorem: cst-statement-conc10-of-tree-fix-cst

(defthm cst-statement-conc10-of-tree-fix-cst
  (equal (cst-statement-conc10 (abnf::tree-fix abnf::cst))
         (cst-statement-conc10 abnf::cst)))

Theorem: cst-statement-conc10-tree-equiv-congruence-on-cst

(defthm cst-statement-conc10-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-statement-conc10 abnf::cst)
                  (cst-statement-conc10 cst-equiv)))
  :rule-classes :congruence)

Function: cst-statement-conc11

(defun cst-statement-conc11 (abnf::cst)
  (declare (xargs :guard (abnf::treep abnf::cst)))
  (declare (xargs :guard (and (cst-matchp abnf::cst "statement")
                              (equal (cst-statement-conc? abnf::cst)
                                     11))))
  (let ((__function__ 'cst-statement-conc11))
    (declare (ignorable __function__))
    (abnf::tree-nonleaf->branches abnf::cst)))

Theorem: tree-list-listp-of-cst-statement-conc11

(defthm tree-list-listp-of-cst-statement-conc11
  (b* ((abnf::cstss (cst-statement-conc11 abnf::cst)))
    (abnf::tree-list-listp abnf::cstss))
  :rule-classes :rewrite)

Theorem: cst-statement-conc11-match

(defthm cst-statement-conc11-match
  (implies (and (cst-matchp abnf::cst "statement")
                (equal (cst-statement-conc? abnf::cst)
                       11))
           (b* ((abnf::cstss (cst-statement-conc11 abnf::cst)))
             (cst-list-list-conc-matchp abnf::cstss "block")))
  :rule-classes :rewrite)

Theorem: cst-statement-conc11-of-tree-fix-cst

(defthm cst-statement-conc11-of-tree-fix-cst
  (equal (cst-statement-conc11 (abnf::tree-fix abnf::cst))
         (cst-statement-conc11 abnf::cst)))

Theorem: cst-statement-conc11-tree-equiv-congruence-on-cst

(defthm cst-statement-conc11-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-statement-conc11 abnf::cst)
                  (cst-statement-conc11 cst-equiv)))
  :rule-classes :congruence)

Function: cst-block-conc

(defun cst-block-conc (abnf::cst)
  (declare (xargs :guard (abnf::treep abnf::cst)))
  (declare (xargs :guard (cst-matchp abnf::cst "block")))
  (let ((__function__ 'cst-block-conc))
    (declare (ignorable __function__))
    (abnf::tree-nonleaf->branches abnf::cst)))

Theorem: tree-list-listp-of-cst-block-conc

(defthm tree-list-listp-of-cst-block-conc
  (b* ((abnf::cstss (cst-block-conc abnf::cst)))
    (abnf::tree-list-listp abnf::cstss))
  :rule-classes :rewrite)

Theorem: cst-block-conc-match

(defthm cst-block-conc-match
 (implies
    (cst-matchp abnf::cst "block")
    (b* ((abnf::cstss (cst-block-conc abnf::cst)))
      (cst-list-list-conc-matchp abnf::cstss "\"{\" *statement \"}\"")))
 :rule-classes :rewrite)

Theorem: cst-block-conc-of-tree-fix-cst

(defthm cst-block-conc-of-tree-fix-cst
  (equal (cst-block-conc (abnf::tree-fix abnf::cst))
         (cst-block-conc abnf::cst)))

Theorem: cst-block-conc-tree-equiv-congruence-on-cst

(defthm cst-block-conc-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-block-conc abnf::cst)
                  (cst-block-conc cst-equiv)))
  :rule-classes :congruence)

Function: cst-return-statement-conc

(defun cst-return-statement-conc (abnf::cst)
  (declare (xargs :guard (abnf::treep abnf::cst)))
  (declare (xargs :guard (cst-matchp abnf::cst "return-statement")))
  (let ((__function__ 'cst-return-statement-conc))
    (declare (ignorable __function__))
    (abnf::tree-nonleaf->branches abnf::cst)))

Theorem: tree-list-listp-of-cst-return-statement-conc

(defthm tree-list-listp-of-cst-return-statement-conc
  (b* ((abnf::cstss (cst-return-statement-conc abnf::cst)))
    (abnf::tree-list-listp abnf::cstss))
  :rule-classes :rewrite)

Theorem: cst-return-statement-conc-match

(defthm cst-return-statement-conc-match
  (implies
       (cst-matchp abnf::cst "return-statement")
       (b* ((abnf::cstss (cst-return-statement-conc abnf::cst)))
         (cst-list-list-conc-matchp abnf::cstss
                                    "%s\"return\" expression \";\"")))
  :rule-classes :rewrite)

Theorem: cst-return-statement-conc-of-tree-fix-cst

(defthm cst-return-statement-conc-of-tree-fix-cst
  (equal (cst-return-statement-conc (abnf::tree-fix abnf::cst))
         (cst-return-statement-conc abnf::cst)))

Theorem: cst-return-statement-conc-tree-equiv-congruence-on-cst

(defthm cst-return-statement-conc-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-return-statement-conc abnf::cst)
                  (cst-return-statement-conc cst-equiv)))
  :rule-classes :congruence)

Function: cst-variable-declaration-conc

(defun cst-variable-declaration-conc (abnf::cst)
  (declare (xargs :guard (abnf::treep abnf::cst)))
  (declare
       (xargs :guard (cst-matchp abnf::cst "variable-declaration")))
  (let ((__function__ 'cst-variable-declaration-conc))
    (declare (ignorable __function__))
    (abnf::tree-nonleaf->branches abnf::cst)))

Theorem: tree-list-listp-of-cst-variable-declaration-conc

(defthm tree-list-listp-of-cst-variable-declaration-conc
  (b* ((abnf::cstss (cst-variable-declaration-conc abnf::cst)))
    (abnf::tree-list-listp abnf::cstss))
  :rule-classes :rewrite)

Theorem: cst-variable-declaration-conc-match

(defthm cst-variable-declaration-conc-match
  (implies
       (cst-matchp abnf::cst "variable-declaration")
       (b* ((abnf::cstss (cst-variable-declaration-conc abnf::cst)))
         (cst-list-list-conc-matchp
              abnf::cstss
              "%s\"let\" identifier \":\" type \"=\" expression \";\"")))
  :rule-classes :rewrite)

Theorem: cst-variable-declaration-conc-of-tree-fix-cst

(defthm cst-variable-declaration-conc-of-tree-fix-cst
  (equal (cst-variable-declaration-conc (abnf::tree-fix abnf::cst))
         (cst-variable-declaration-conc abnf::cst)))

Theorem: cst-variable-declaration-conc-tree-equiv-congruence-on-cst

(defthm cst-variable-declaration-conc-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-variable-declaration-conc abnf::cst)
                  (cst-variable-declaration-conc cst-equiv)))
  :rule-classes :congruence)

Function: cst-constant-declaration-conc

(defun cst-constant-declaration-conc (abnf::cst)
  (declare (xargs :guard (abnf::treep abnf::cst)))
  (declare
       (xargs :guard (cst-matchp abnf::cst "constant-declaration")))
  (let ((__function__ 'cst-constant-declaration-conc))
    (declare (ignorable __function__))
    (abnf::tree-nonleaf->branches abnf::cst)))

Theorem: tree-list-listp-of-cst-constant-declaration-conc

(defthm tree-list-listp-of-cst-constant-declaration-conc
  (b* ((abnf::cstss (cst-constant-declaration-conc abnf::cst)))
    (abnf::tree-list-listp abnf::cstss))
  :rule-classes :rewrite)

Theorem: cst-constant-declaration-conc-match

(defthm cst-constant-declaration-conc-match
  (implies
       (cst-matchp abnf::cst "constant-declaration")
       (b* ((abnf::cstss (cst-constant-declaration-conc abnf::cst)))
         (cst-list-list-conc-matchp
              abnf::cstss
              "%s\"const\" identifier \":\" type \"=\" expression \";\"")))
  :rule-classes :rewrite)

Theorem: cst-constant-declaration-conc-of-tree-fix-cst

(defthm cst-constant-declaration-conc-of-tree-fix-cst
  (equal (cst-constant-declaration-conc (abnf::tree-fix abnf::cst))
         (cst-constant-declaration-conc abnf::cst)))

Theorem: cst-constant-declaration-conc-tree-equiv-congruence-on-cst

(defthm cst-constant-declaration-conc-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-constant-declaration-conc abnf::cst)
                  (cst-constant-declaration-conc cst-equiv)))
  :rule-classes :congruence)

Function: cst-branch-conc

(defun cst-branch-conc (abnf::cst)
  (declare (xargs :guard (abnf::treep abnf::cst)))
  (declare (xargs :guard (cst-matchp abnf::cst "branch")))
  (let ((__function__ 'cst-branch-conc))
    (declare (ignorable __function__))
    (abnf::tree-nonleaf->branches abnf::cst)))

Theorem: tree-list-listp-of-cst-branch-conc

(defthm tree-list-listp-of-cst-branch-conc
  (b* ((abnf::cstss (cst-branch-conc abnf::cst)))
    (abnf::tree-list-listp abnf::cstss))
  :rule-classes :rewrite)

Theorem: cst-branch-conc-match

(defthm cst-branch-conc-match
  (implies (cst-matchp abnf::cst "branch")
           (b* ((abnf::cstss (cst-branch-conc abnf::cst)))
             (cst-list-list-conc-matchp
                  abnf::cstss "%s\"if\" expression block")))
  :rule-classes :rewrite)

Theorem: cst-branch-conc-of-tree-fix-cst

(defthm cst-branch-conc-of-tree-fix-cst
  (equal (cst-branch-conc (abnf::tree-fix abnf::cst))
         (cst-branch-conc abnf::cst)))

Theorem: cst-branch-conc-tree-equiv-congruence-on-cst

(defthm cst-branch-conc-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-branch-conc abnf::cst)
                  (cst-branch-conc cst-equiv)))
  :rule-classes :congruence)

Function: cst-loop-statement-conc

(defun cst-loop-statement-conc (abnf::cst)
  (declare (xargs :guard (abnf::treep abnf::cst)))
  (declare (xargs :guard (cst-matchp abnf::cst "loop-statement")))
  (let ((__function__ 'cst-loop-statement-conc))
    (declare (ignorable __function__))
    (abnf::tree-nonleaf->branches abnf::cst)))

Theorem: tree-list-listp-of-cst-loop-statement-conc

(defthm tree-list-listp-of-cst-loop-statement-conc
  (b* ((abnf::cstss (cst-loop-statement-conc abnf::cst)))
    (abnf::tree-list-listp abnf::cstss))
  :rule-classes :rewrite)

Theorem: cst-loop-statement-conc-match

(defthm cst-loop-statement-conc-match
 (implies
  (cst-matchp abnf::cst "loop-statement")
  (b* ((abnf::cstss (cst-loop-statement-conc abnf::cst)))
   (cst-list-list-conc-matchp
    abnf::cstss
    "%s\"for\" identifier \":\" type %s\"in\" expression \"..\" [ \"=\" ] expression block")))
 :rule-classes :rewrite)

Theorem: cst-loop-statement-conc-of-tree-fix-cst

(defthm cst-loop-statement-conc-of-tree-fix-cst
  (equal (cst-loop-statement-conc (abnf::tree-fix abnf::cst))
         (cst-loop-statement-conc abnf::cst)))

Theorem: cst-loop-statement-conc-tree-equiv-congruence-on-cst

(defthm cst-loop-statement-conc-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-loop-statement-conc abnf::cst)
                  (cst-loop-statement-conc cst-equiv)))
  :rule-classes :congruence)

Function: cst-assignment-statement-conc

(defun cst-assignment-statement-conc (abnf::cst)
  (declare (xargs :guard (abnf::treep abnf::cst)))
  (declare
       (xargs :guard (cst-matchp abnf::cst "assignment-statement")))
  (let ((__function__ 'cst-assignment-statement-conc))
    (declare (ignorable __function__))
    (abnf::tree-nonleaf->branches abnf::cst)))

Theorem: tree-list-listp-of-cst-assignment-statement-conc

(defthm tree-list-listp-of-cst-assignment-statement-conc
  (b* ((abnf::cstss (cst-assignment-statement-conc abnf::cst)))
    (abnf::tree-list-listp abnf::cstss))
  :rule-classes :rewrite)

Theorem: cst-assignment-statement-conc-match

(defthm cst-assignment-statement-conc-match
  (implies
       (cst-matchp abnf::cst "assignment-statement")
       (b* ((abnf::cstss (cst-assignment-statement-conc abnf::cst)))
         (cst-list-list-conc-matchp
              abnf::cstss
              "expression assignment-operator expression \";\"")))
  :rule-classes :rewrite)

Theorem: cst-assignment-statement-conc-of-tree-fix-cst

(defthm cst-assignment-statement-conc-of-tree-fix-cst
  (equal (cst-assignment-statement-conc (abnf::tree-fix abnf::cst))
         (cst-assignment-statement-conc abnf::cst)))

Theorem: cst-assignment-statement-conc-tree-equiv-congruence-on-cst

(defthm cst-assignment-statement-conc-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-assignment-statement-conc abnf::cst)
                  (cst-assignment-statement-conc cst-equiv)))
  :rule-classes :congruence)

Function: cst-console-statement-conc

(defun cst-console-statement-conc (abnf::cst)
 (declare (xargs :guard (abnf::treep abnf::cst)))
 (declare (xargs :guard (cst-matchp abnf::cst "console-statement")))
 (let ((__function__ 'cst-console-statement-conc))
   (declare (ignorable __function__))
   (abnf::tree-nonleaf->branches abnf::cst)))

Theorem: tree-list-listp-of-cst-console-statement-conc

(defthm tree-list-listp-of-cst-console-statement-conc
  (b* ((abnf::cstss (cst-console-statement-conc abnf::cst)))
    (abnf::tree-list-listp abnf::cstss))
  :rule-classes :rewrite)

Theorem: cst-console-statement-conc-match

(defthm cst-console-statement-conc-match
 (implies
  (cst-matchp abnf::cst "console-statement")
  (b* ((abnf::cstss (cst-console-statement-conc abnf::cst)))
    (cst-list-list-conc-matchp abnf::cstss
                               "%s\"console\" \".\" console-call \";\"")))
 :rule-classes :rewrite)

Theorem: cst-console-statement-conc-of-tree-fix-cst

(defthm cst-console-statement-conc-of-tree-fix-cst
  (equal (cst-console-statement-conc (abnf::tree-fix abnf::cst))
         (cst-console-statement-conc abnf::cst)))

Theorem: cst-console-statement-conc-tree-equiv-congruence-on-cst

(defthm cst-console-statement-conc-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-console-statement-conc abnf::cst)
                  (cst-console-statement-conc cst-equiv)))
  :rule-classes :congruence)

Function: cst-console-call-conc1

(defun cst-console-call-conc1 (abnf::cst)
  (declare (xargs :guard (abnf::treep abnf::cst)))
  (declare
       (xargs :guard (and (cst-matchp abnf::cst "console-call")
                          (equal (cst-console-call-conc? abnf::cst)
                                 1))))
  (let ((__function__ 'cst-console-call-conc1))
    (declare (ignorable __function__))
    (abnf::tree-nonleaf->branches abnf::cst)))

Theorem: tree-list-listp-of-cst-console-call-conc1

(defthm tree-list-listp-of-cst-console-call-conc1
  (b* ((abnf::cstss (cst-console-call-conc1 abnf::cst)))
    (abnf::tree-list-listp abnf::cstss))
  :rule-classes :rewrite)

Theorem: cst-console-call-conc1-match

(defthm cst-console-call-conc1-match
  (implies (and (cst-matchp abnf::cst "console-call")
                (equal (cst-console-call-conc? abnf::cst)
                       1))
           (b* ((abnf::cstss (cst-console-call-conc1 abnf::cst)))
             (cst-list-list-conc-matchp abnf::cstss "assert-call")))
  :rule-classes :rewrite)

Theorem: cst-console-call-conc1-of-tree-fix-cst

(defthm cst-console-call-conc1-of-tree-fix-cst
  (equal (cst-console-call-conc1 (abnf::tree-fix abnf::cst))
         (cst-console-call-conc1 abnf::cst)))

Theorem: cst-console-call-conc1-tree-equiv-congruence-on-cst

(defthm cst-console-call-conc1-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-console-call-conc1 abnf::cst)
                  (cst-console-call-conc1 cst-equiv)))
  :rule-classes :congruence)

Function: cst-console-call-conc2

(defun cst-console-call-conc2 (abnf::cst)
  (declare (xargs :guard (abnf::treep abnf::cst)))
  (declare
       (xargs :guard (and (cst-matchp abnf::cst "console-call")
                          (equal (cst-console-call-conc? abnf::cst)
                                 2))))
  (let ((__function__ 'cst-console-call-conc2))
    (declare (ignorable __function__))
    (abnf::tree-nonleaf->branches abnf::cst)))

Theorem: tree-list-listp-of-cst-console-call-conc2

(defthm tree-list-listp-of-cst-console-call-conc2
  (b* ((abnf::cstss (cst-console-call-conc2 abnf::cst)))
    (abnf::tree-list-listp abnf::cstss))
  :rule-classes :rewrite)

Theorem: cst-console-call-conc2-match

(defthm cst-console-call-conc2-match
 (implies
     (and (cst-matchp abnf::cst "console-call")
          (equal (cst-console-call-conc? abnf::cst)
                 2))
     (b* ((abnf::cstss (cst-console-call-conc2 abnf::cst)))
       (cst-list-list-conc-matchp abnf::cstss "assert-equal-call")))
 :rule-classes :rewrite)

Theorem: cst-console-call-conc2-of-tree-fix-cst

(defthm cst-console-call-conc2-of-tree-fix-cst
  (equal (cst-console-call-conc2 (abnf::tree-fix abnf::cst))
         (cst-console-call-conc2 abnf::cst)))

Theorem: cst-console-call-conc2-tree-equiv-congruence-on-cst

(defthm cst-console-call-conc2-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-console-call-conc2 abnf::cst)
                  (cst-console-call-conc2 cst-equiv)))
  :rule-classes :congruence)

Function: cst-console-call-conc3

(defun cst-console-call-conc3 (abnf::cst)
  (declare (xargs :guard (abnf::treep abnf::cst)))
  (declare
       (xargs :guard (and (cst-matchp abnf::cst "console-call")
                          (equal (cst-console-call-conc? abnf::cst)
                                 3))))
  (let ((__function__ 'cst-console-call-conc3))
    (declare (ignorable __function__))
    (abnf::tree-nonleaf->branches abnf::cst)))

Theorem: tree-list-listp-of-cst-console-call-conc3

(defthm tree-list-listp-of-cst-console-call-conc3
  (b* ((abnf::cstss (cst-console-call-conc3 abnf::cst)))
    (abnf::tree-list-listp abnf::cstss))
  :rule-classes :rewrite)

Theorem: cst-console-call-conc3-match

(defthm cst-console-call-conc3-match
 (implies
  (and (cst-matchp abnf::cst "console-call")
       (equal (cst-console-call-conc? abnf::cst)
              3))
  (b* ((abnf::cstss (cst-console-call-conc3 abnf::cst)))
   (cst-list-list-conc-matchp abnf::cstss "assert-not-equal-call")))
 :rule-classes :rewrite)

Theorem: cst-console-call-conc3-of-tree-fix-cst

(defthm cst-console-call-conc3-of-tree-fix-cst
  (equal (cst-console-call-conc3 (abnf::tree-fix abnf::cst))
         (cst-console-call-conc3 abnf::cst)))

Theorem: cst-console-call-conc3-tree-equiv-congruence-on-cst

(defthm cst-console-call-conc3-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-console-call-conc3 abnf::cst)
                  (cst-console-call-conc3 cst-equiv)))
  :rule-classes :congruence)

Function: cst-assert-call-conc

(defun cst-assert-call-conc (abnf::cst)
  (declare (xargs :guard (abnf::treep abnf::cst)))
  (declare (xargs :guard (cst-matchp abnf::cst "assert-call")))
  (let ((__function__ 'cst-assert-call-conc))
    (declare (ignorable __function__))
    (abnf::tree-nonleaf->branches abnf::cst)))

Theorem: tree-list-listp-of-cst-assert-call-conc

(defthm tree-list-listp-of-cst-assert-call-conc
  (b* ((abnf::cstss (cst-assert-call-conc abnf::cst)))
    (abnf::tree-list-listp abnf::cstss))
  :rule-classes :rewrite)

Theorem: cst-assert-call-conc-match

(defthm cst-assert-call-conc-match
 (implies
     (cst-matchp abnf::cst "assert-call")
     (b* ((abnf::cstss (cst-assert-call-conc abnf::cst)))
       (cst-list-list-conc-matchp abnf::cstss
                                  "%s\"assert\" \"(\" expression \")\"")))
 :rule-classes :rewrite)

Theorem: cst-assert-call-conc-of-tree-fix-cst

(defthm cst-assert-call-conc-of-tree-fix-cst
  (equal (cst-assert-call-conc (abnf::tree-fix abnf::cst))
         (cst-assert-call-conc abnf::cst)))

Theorem: cst-assert-call-conc-tree-equiv-congruence-on-cst

(defthm cst-assert-call-conc-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-assert-call-conc abnf::cst)
                  (cst-assert-call-conc cst-equiv)))
  :rule-classes :congruence)

Function: cst-assert-equal-call-conc

(defun cst-assert-equal-call-conc (abnf::cst)
 (declare (xargs :guard (abnf::treep abnf::cst)))
 (declare (xargs :guard (cst-matchp abnf::cst "assert-equal-call")))
 (let ((__function__ 'cst-assert-equal-call-conc))
   (declare (ignorable __function__))
   (abnf::tree-nonleaf->branches abnf::cst)))

Theorem: tree-list-listp-of-cst-assert-equal-call-conc

(defthm tree-list-listp-of-cst-assert-equal-call-conc
  (b* ((abnf::cstss (cst-assert-equal-call-conc abnf::cst)))
    (abnf::tree-list-listp abnf::cstss))
  :rule-classes :rewrite)

Theorem: cst-assert-equal-call-conc-match

(defthm cst-assert-equal-call-conc-match
 (implies
  (cst-matchp abnf::cst "assert-equal-call")
  (b* ((abnf::cstss (cst-assert-equal-call-conc abnf::cst)))
   (cst-list-list-conc-matchp
        abnf::cstss
        "%s\"assert_eq\" \"(\" expression \",\" expression [ \",\" ] \")\"")))
 :rule-classes :rewrite)

Theorem: cst-assert-equal-call-conc-of-tree-fix-cst

(defthm cst-assert-equal-call-conc-of-tree-fix-cst
  (equal (cst-assert-equal-call-conc (abnf::tree-fix abnf::cst))
         (cst-assert-equal-call-conc abnf::cst)))

Theorem: cst-assert-equal-call-conc-tree-equiv-congruence-on-cst

(defthm cst-assert-equal-call-conc-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-assert-equal-call-conc abnf::cst)
                  (cst-assert-equal-call-conc cst-equiv)))
  :rule-classes :congruence)

Function: cst-assert-not-equal-call-conc

(defun cst-assert-not-equal-call-conc (abnf::cst)
 (declare (xargs :guard (abnf::treep abnf::cst)))
 (declare
      (xargs :guard (cst-matchp abnf::cst "assert-not-equal-call")))
 (let ((__function__ 'cst-assert-not-equal-call-conc))
   (declare (ignorable __function__))
   (abnf::tree-nonleaf->branches abnf::cst)))

Theorem: tree-list-listp-of-cst-assert-not-equal-call-conc

(defthm tree-list-listp-of-cst-assert-not-equal-call-conc
  (b* ((abnf::cstss (cst-assert-not-equal-call-conc abnf::cst)))
    (abnf::tree-list-listp abnf::cstss))
  :rule-classes :rewrite)

Theorem: cst-assert-not-equal-call-conc-match

(defthm cst-assert-not-equal-call-conc-match
 (implies
  (cst-matchp abnf::cst "assert-not-equal-call")
  (b* ((abnf::cstss (cst-assert-not-equal-call-conc abnf::cst)))
   (cst-list-list-conc-matchp
       abnf::cstss
       "%s\"assert_neq\" \"(\" expression \",\" expression [ \",\" ] \")\"")))
 :rule-classes :rewrite)

Theorem: cst-assert-not-equal-call-conc-of-tree-fix-cst

(defthm cst-assert-not-equal-call-conc-of-tree-fix-cst
  (equal (cst-assert-not-equal-call-conc (abnf::tree-fix abnf::cst))
         (cst-assert-not-equal-call-conc abnf::cst)))

Theorem: cst-assert-not-equal-call-conc-tree-equiv-congruence-on-cst

(defthm cst-assert-not-equal-call-conc-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-assert-not-equal-call-conc abnf::cst)
                  (cst-assert-not-equal-call-conc cst-equiv)))
  :rule-classes :congruence)

Function: cst-finalize-statement-conc

(defun cst-finalize-statement-conc (abnf::cst)
  (declare (xargs :guard (abnf::treep abnf::cst)))
  (declare
       (xargs :guard (cst-matchp abnf::cst "finalize-statement")))
  (let ((__function__ 'cst-finalize-statement-conc))
    (declare (ignorable __function__))
    (abnf::tree-nonleaf->branches abnf::cst)))

Theorem: tree-list-listp-of-cst-finalize-statement-conc

(defthm tree-list-listp-of-cst-finalize-statement-conc
  (b* ((abnf::cstss (cst-finalize-statement-conc abnf::cst)))
    (abnf::tree-list-listp abnf::cstss))
  :rule-classes :rewrite)

Theorem: cst-finalize-statement-conc-match

(defthm cst-finalize-statement-conc-match
  (implies
       (cst-matchp abnf::cst "finalize-statement")
       (b* ((abnf::cstss (cst-finalize-statement-conc abnf::cst)))
         (cst-list-list-conc-matchp
              abnf::cstss
              "%s\"async\" %s\"finalize\" function-arguments \";\"")))
  :rule-classes :rewrite)

Theorem: cst-finalize-statement-conc-of-tree-fix-cst

(defthm cst-finalize-statement-conc-of-tree-fix-cst
  (equal (cst-finalize-statement-conc (abnf::tree-fix abnf::cst))
         (cst-finalize-statement-conc abnf::cst)))

Theorem: cst-finalize-statement-conc-tree-equiv-congruence-on-cst

(defthm cst-finalize-statement-conc-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-finalize-statement-conc abnf::cst)
                  (cst-finalize-statement-conc cst-equiv)))
  :rule-classes :congruence)

Function: cst-increment-statement-conc

(defun cst-increment-statement-conc (abnf::cst)
  (declare (xargs :guard (abnf::treep abnf::cst)))
  (declare
       (xargs :guard (cst-matchp abnf::cst "increment-statement")))
  (let ((__function__ 'cst-increment-statement-conc))
    (declare (ignorable __function__))
    (abnf::tree-nonleaf->branches abnf::cst)))

Theorem: tree-list-listp-of-cst-increment-statement-conc

(defthm tree-list-listp-of-cst-increment-statement-conc
  (b* ((abnf::cstss (cst-increment-statement-conc abnf::cst)))
    (abnf::tree-list-listp abnf::cstss))
  :rule-classes :rewrite)

Theorem: cst-increment-statement-conc-match

(defthm cst-increment-statement-conc-match
 (implies
  (cst-matchp abnf::cst "increment-statement")
  (b* ((abnf::cstss (cst-increment-statement-conc abnf::cst)))
   (cst-list-list-conc-matchp
    abnf::cstss
    "%s\"increment\" \"(\" identifier \",\" expression \",\" expression [ \",\" ] \")\" \";\"")))
 :rule-classes :rewrite)

Theorem: cst-increment-statement-conc-of-tree-fix-cst

(defthm cst-increment-statement-conc-of-tree-fix-cst
  (equal (cst-increment-statement-conc (abnf::tree-fix abnf::cst))
         (cst-increment-statement-conc abnf::cst)))

Theorem: cst-increment-statement-conc-tree-equiv-congruence-on-cst

(defthm cst-increment-statement-conc-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-increment-statement-conc abnf::cst)
                  (cst-increment-statement-conc cst-equiv)))
  :rule-classes :congruence)

Function: cst-decrement-statement-conc

(defun cst-decrement-statement-conc (abnf::cst)
  (declare (xargs :guard (abnf::treep abnf::cst)))
  (declare
       (xargs :guard (cst-matchp abnf::cst "decrement-statement")))
  (let ((__function__ 'cst-decrement-statement-conc))
    (declare (ignorable __function__))
    (abnf::tree-nonleaf->branches abnf::cst)))

Theorem: tree-list-listp-of-cst-decrement-statement-conc

(defthm tree-list-listp-of-cst-decrement-statement-conc
  (b* ((abnf::cstss (cst-decrement-statement-conc abnf::cst)))
    (abnf::tree-list-listp abnf::cstss))
  :rule-classes :rewrite)

Theorem: cst-decrement-statement-conc-match

(defthm cst-decrement-statement-conc-match
 (implies
  (cst-matchp abnf::cst "decrement-statement")
  (b* ((abnf::cstss (cst-decrement-statement-conc abnf::cst)))
   (cst-list-list-conc-matchp
    abnf::cstss
    "%s\"decrement\" \"(\" identifier \",\" expression \",\" expression [ \",\" ] \")\" \";\"")))
 :rule-classes :rewrite)

Theorem: cst-decrement-statement-conc-of-tree-fix-cst

(defthm cst-decrement-statement-conc-of-tree-fix-cst
  (equal (cst-decrement-statement-conc (abnf::tree-fix abnf::cst))
         (cst-decrement-statement-conc abnf::cst)))

Theorem: cst-decrement-statement-conc-tree-equiv-congruence-on-cst

(defthm cst-decrement-statement-conc-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-decrement-statement-conc abnf::cst)
                  (cst-decrement-statement-conc cst-equiv)))
  :rule-classes :congruence)

Function: cst-function-declaration-conc

(defun cst-function-declaration-conc (abnf::cst)
  (declare (xargs :guard (abnf::treep abnf::cst)))
  (declare
       (xargs :guard (cst-matchp abnf::cst "function-declaration")))
  (let ((__function__ 'cst-function-declaration-conc))
    (declare (ignorable __function__))
    (abnf::tree-nonleaf->branches abnf::cst)))

Theorem: tree-list-listp-of-cst-function-declaration-conc

(defthm tree-list-listp-of-cst-function-declaration-conc
  (b* ((abnf::cstss (cst-function-declaration-conc abnf::cst)))
    (abnf::tree-list-listp abnf::cstss))
  :rule-classes :rewrite)

Theorem: cst-function-declaration-conc-match

(defthm cst-function-declaration-conc-match
 (implies
  (cst-matchp abnf::cst "function-declaration")
  (b* ((abnf::cstss (cst-function-declaration-conc abnf::cst)))
   (cst-list-list-conc-matchp
    abnf::cstss
    "*annotation %s\"function\" identifier \"(\" [ function-parameters ] \")\" \"->\" type block")))
 :rule-classes :rewrite)

Theorem: cst-function-declaration-conc-of-tree-fix-cst

(defthm cst-function-declaration-conc-of-tree-fix-cst
  (equal (cst-function-declaration-conc (abnf::tree-fix abnf::cst))
         (cst-function-declaration-conc abnf::cst)))

Theorem: cst-function-declaration-conc-tree-equiv-congruence-on-cst

(defthm cst-function-declaration-conc-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-function-declaration-conc abnf::cst)
                  (cst-function-declaration-conc cst-equiv)))
  :rule-classes :congruence)

Function: cst-function-parameters-conc

(defun cst-function-parameters-conc (abnf::cst)
  (declare (xargs :guard (abnf::treep abnf::cst)))
  (declare
       (xargs :guard (cst-matchp abnf::cst "function-parameters")))
  (let ((__function__ 'cst-function-parameters-conc))
    (declare (ignorable __function__))
    (abnf::tree-nonleaf->branches abnf::cst)))

Theorem: tree-list-listp-of-cst-function-parameters-conc

(defthm tree-list-listp-of-cst-function-parameters-conc
  (b* ((abnf::cstss (cst-function-parameters-conc abnf::cst)))
    (abnf::tree-list-listp abnf::cstss))
  :rule-classes :rewrite)

Theorem: cst-function-parameters-conc-match

(defthm cst-function-parameters-conc-match
 (implies
  (cst-matchp abnf::cst "function-parameters")
  (b* ((abnf::cstss (cst-function-parameters-conc abnf::cst)))
    (cst-list-list-conc-matchp
         abnf::cstss
         "function-parameter *( \",\" function-parameter ) [ \",\" ]")))
 :rule-classes :rewrite)

Theorem: cst-function-parameters-conc-of-tree-fix-cst

(defthm cst-function-parameters-conc-of-tree-fix-cst
  (equal (cst-function-parameters-conc (abnf::tree-fix abnf::cst))
         (cst-function-parameters-conc abnf::cst)))

Theorem: cst-function-parameters-conc-tree-equiv-congruence-on-cst

(defthm cst-function-parameters-conc-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-function-parameters-conc abnf::cst)
                  (cst-function-parameters-conc cst-equiv)))
  :rule-classes :congruence)

Function: cst-function-parameter-conc

(defun cst-function-parameter-conc (abnf::cst)
  (declare (xargs :guard (abnf::treep abnf::cst)))
  (declare
       (xargs :guard (cst-matchp abnf::cst "function-parameter")))
  (let ((__function__ 'cst-function-parameter-conc))
    (declare (ignorable __function__))
    (abnf::tree-nonleaf->branches abnf::cst)))

Theorem: tree-list-listp-of-cst-function-parameter-conc

(defthm tree-list-listp-of-cst-function-parameter-conc
  (b* ((abnf::cstss (cst-function-parameter-conc abnf::cst)))
    (abnf::tree-list-listp abnf::cstss))
  :rule-classes :rewrite)

Theorem: cst-function-parameter-conc-match

(defthm cst-function-parameter-conc-match
 (implies
  (cst-matchp abnf::cst "function-parameter")
  (b* ((abnf::cstss (cst-function-parameter-conc abnf::cst)))
   (cst-list-list-conc-matchp
    abnf::cstss
    "[ %s\"public\" / %s\"constant\" / %s\"const\" ] identifier \":\" type")))
 :rule-classes :rewrite)

Theorem: cst-function-parameter-conc-of-tree-fix-cst

(defthm cst-function-parameter-conc-of-tree-fix-cst
  (equal (cst-function-parameter-conc (abnf::tree-fix abnf::cst))
         (cst-function-parameter-conc abnf::cst)))

Theorem: cst-function-parameter-conc-tree-equiv-congruence-on-cst

(defthm cst-function-parameter-conc-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-function-parameter-conc abnf::cst)
                  (cst-function-parameter-conc cst-equiv)))
  :rule-classes :congruence)

Function: cst-transition-declaration-conc

(defun cst-transition-declaration-conc (abnf::cst)
 (declare (xargs :guard (abnf::treep abnf::cst)))
 (declare
     (xargs :guard (cst-matchp abnf::cst "transition-declaration")))
 (let ((__function__ 'cst-transition-declaration-conc))
   (declare (ignorable __function__))
   (abnf::tree-nonleaf->branches abnf::cst)))

Theorem: tree-list-listp-of-cst-transition-declaration-conc

(defthm tree-list-listp-of-cst-transition-declaration-conc
  (b* ((abnf::cstss (cst-transition-declaration-conc abnf::cst)))
    (abnf::tree-list-listp abnf::cstss))
  :rule-classes :rewrite)

Theorem: cst-transition-declaration-conc-match

(defthm cst-transition-declaration-conc-match
 (implies
  (cst-matchp abnf::cst "transition-declaration")
  (b* ((abnf::cstss (cst-transition-declaration-conc abnf::cst)))
   (cst-list-list-conc-matchp
    abnf::cstss
    "*annotation %s\"transition\" identifier \"(\" [ function-parameters ] \")\" \"->\" type block [ finalizer ]")))
 :rule-classes :rewrite)

Theorem: cst-transition-declaration-conc-of-tree-fix-cst

(defthm cst-transition-declaration-conc-of-tree-fix-cst
 (equal (cst-transition-declaration-conc (abnf::tree-fix abnf::cst))
        (cst-transition-declaration-conc abnf::cst)))

Theorem: cst-transition-declaration-conc-tree-equiv-congruence-on-cst

(defthm cst-transition-declaration-conc-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-transition-declaration-conc abnf::cst)
                  (cst-transition-declaration-conc cst-equiv)))
  :rule-classes :congruence)

Function: cst-finalizer-conc

(defun cst-finalizer-conc (abnf::cst)
  (declare (xargs :guard (abnf::treep abnf::cst)))
  (declare (xargs :guard (cst-matchp abnf::cst "finalizer")))
  (let ((__function__ 'cst-finalizer-conc))
    (declare (ignorable __function__))
    (abnf::tree-nonleaf->branches abnf::cst)))

Theorem: tree-list-listp-of-cst-finalizer-conc

(defthm tree-list-listp-of-cst-finalizer-conc
  (b* ((abnf::cstss (cst-finalizer-conc abnf::cst)))
    (abnf::tree-list-listp abnf::cstss))
  :rule-classes :rewrite)

Theorem: cst-finalizer-conc-match

(defthm cst-finalizer-conc-match
 (implies
  (cst-matchp abnf::cst "finalizer")
  (b* ((abnf::cstss (cst-finalizer-conc abnf::cst)))
   (cst-list-list-conc-matchp
    abnf::cstss
    "%s\"finalize\" identifier \"(\" [ function-parameters ] \")\" [ \"->\" type ] block")))
 :rule-classes :rewrite)

Theorem: cst-finalizer-conc-of-tree-fix-cst

(defthm cst-finalizer-conc-of-tree-fix-cst
  (equal (cst-finalizer-conc (abnf::tree-fix abnf::cst))
         (cst-finalizer-conc abnf::cst)))

Theorem: cst-finalizer-conc-tree-equiv-congruence-on-cst

(defthm cst-finalizer-conc-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-finalizer-conc abnf::cst)
                  (cst-finalizer-conc cst-equiv)))
  :rule-classes :congruence)

Function: cst-struct-declaration-conc

(defun cst-struct-declaration-conc (abnf::cst)
  (declare (xargs :guard (abnf::treep abnf::cst)))
  (declare
       (xargs :guard (cst-matchp abnf::cst "struct-declaration")))
  (let ((__function__ 'cst-struct-declaration-conc))
    (declare (ignorable __function__))
    (abnf::tree-nonleaf->branches abnf::cst)))

Theorem: tree-list-listp-of-cst-struct-declaration-conc

(defthm tree-list-listp-of-cst-struct-declaration-conc
  (b* ((abnf::cstss (cst-struct-declaration-conc abnf::cst)))
    (abnf::tree-list-listp abnf::cstss))
  :rule-classes :rewrite)

Theorem: cst-struct-declaration-conc-match

(defthm cst-struct-declaration-conc-match
 (implies
  (cst-matchp abnf::cst "struct-declaration")
  (b* ((abnf::cstss (cst-struct-declaration-conc abnf::cst)))
   (cst-list-list-conc-matchp
    abnf::cstss
    "%s\"struct\" identifier \"{\" struct-component-declarations \"}\"")))
 :rule-classes :rewrite)

Theorem: cst-struct-declaration-conc-of-tree-fix-cst

(defthm cst-struct-declaration-conc-of-tree-fix-cst
  (equal (cst-struct-declaration-conc (abnf::tree-fix abnf::cst))
         (cst-struct-declaration-conc abnf::cst)))

Theorem: cst-struct-declaration-conc-tree-equiv-congruence-on-cst

(defthm cst-struct-declaration-conc-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-struct-declaration-conc abnf::cst)
                  (cst-struct-declaration-conc cst-equiv)))
  :rule-classes :congruence)

Function: cst-struct-component-declarations-conc

(defun cst-struct-component-declarations-conc (abnf::cst)
  (declare (xargs :guard (abnf::treep abnf::cst)))
  (declare
       (xargs :guard (cst-matchp abnf::cst
                                 "struct-component-declarations")))
  (let ((__function__ 'cst-struct-component-declarations-conc))
    (declare (ignorable __function__))
    (abnf::tree-nonleaf->branches abnf::cst)))

Theorem: tree-list-listp-of-cst-struct-component-declarations-conc

(defthm tree-list-listp-of-cst-struct-component-declarations-conc
 (b*
  ((abnf::cstss (cst-struct-component-declarations-conc abnf::cst)))
  (abnf::tree-list-listp abnf::cstss))
 :rule-classes :rewrite)

Theorem: cst-struct-component-declarations-conc-match

(defthm cst-struct-component-declarations-conc-match
 (implies
  (cst-matchp abnf::cst
              "struct-component-declarations")
  (b* ((abnf::cstss
            (cst-struct-component-declarations-conc abnf::cst)))
   (cst-list-list-conc-matchp
    abnf::cstss
    "struct-component-declaration *( \",\" struct-component-declaration ) [ \",\" ]")))
 :rule-classes :rewrite)

Theorem: cst-struct-component-declarations-conc-of-tree-fix-cst

(defthm cst-struct-component-declarations-conc-of-tree-fix-cst
  (equal (cst-struct-component-declarations-conc
              (abnf::tree-fix abnf::cst))
         (cst-struct-component-declarations-conc abnf::cst)))

Theorem: cst-struct-component-declarations-conc-tree-equiv-congruence-on-cst

(defthm
 cst-struct-component-declarations-conc-tree-equiv-congruence-on-cst
 (implies
      (abnf::tree-equiv abnf::cst cst-equiv)
      (equal (cst-struct-component-declarations-conc abnf::cst)
             (cst-struct-component-declarations-conc cst-equiv)))
 :rule-classes :congruence)

Function: cst-struct-component-declaration-conc

(defun cst-struct-component-declaration-conc (abnf::cst)
  (declare (xargs :guard (abnf::treep abnf::cst)))
  (declare
       (xargs :guard (cst-matchp abnf::cst
                                 "struct-component-declaration")))
  (let ((__function__ 'cst-struct-component-declaration-conc))
    (declare (ignorable __function__))
    (abnf::tree-nonleaf->branches abnf::cst)))

Theorem: tree-list-listp-of-cst-struct-component-declaration-conc

(defthm tree-list-listp-of-cst-struct-component-declaration-conc
  (b*
   ((abnf::cstss (cst-struct-component-declaration-conc abnf::cst)))
   (abnf::tree-list-listp abnf::cstss))
  :rule-classes :rewrite)

Theorem: cst-struct-component-declaration-conc-match

(defthm cst-struct-component-declaration-conc-match
 (implies
  (cst-matchp abnf::cst
              "struct-component-declaration")
  (b*
   ((abnf::cstss (cst-struct-component-declaration-conc abnf::cst)))
   (cst-list-list-conc-matchp abnf::cstss "identifier \":\" type")))
 :rule-classes :rewrite)

Theorem: cst-struct-component-declaration-conc-of-tree-fix-cst

(defthm cst-struct-component-declaration-conc-of-tree-fix-cst
 (equal
  (cst-struct-component-declaration-conc (abnf::tree-fix abnf::cst))
  (cst-struct-component-declaration-conc abnf::cst)))

Theorem: cst-struct-component-declaration-conc-tree-equiv-congruence-on-cst

(defthm
 cst-struct-component-declaration-conc-tree-equiv-congruence-on-cst
 (implies (abnf::tree-equiv abnf::cst cst-equiv)
          (equal (cst-struct-component-declaration-conc abnf::cst)
                 (cst-struct-component-declaration-conc cst-equiv)))
 :rule-classes :congruence)

Function: cst-record-declaration-conc

(defun cst-record-declaration-conc (abnf::cst)
  (declare (xargs :guard (abnf::treep abnf::cst)))
  (declare
       (xargs :guard (cst-matchp abnf::cst "record-declaration")))
  (let ((__function__ 'cst-record-declaration-conc))
    (declare (ignorable __function__))
    (abnf::tree-nonleaf->branches abnf::cst)))

Theorem: tree-list-listp-of-cst-record-declaration-conc

(defthm tree-list-listp-of-cst-record-declaration-conc
  (b* ((abnf::cstss (cst-record-declaration-conc abnf::cst)))
    (abnf::tree-list-listp abnf::cstss))
  :rule-classes :rewrite)

Theorem: cst-record-declaration-conc-match

(defthm cst-record-declaration-conc-match
 (implies
  (cst-matchp abnf::cst "record-declaration")
  (b* ((abnf::cstss (cst-record-declaration-conc abnf::cst)))
   (cst-list-list-conc-matchp
    abnf::cstss
    "%s\"record\" identifier \"{\" struct-component-declarations \"}\"")))
 :rule-classes :rewrite)

Theorem: cst-record-declaration-conc-of-tree-fix-cst

(defthm cst-record-declaration-conc-of-tree-fix-cst
  (equal (cst-record-declaration-conc (abnf::tree-fix abnf::cst))
         (cst-record-declaration-conc abnf::cst)))

Theorem: cst-record-declaration-conc-tree-equiv-congruence-on-cst

(defthm cst-record-declaration-conc-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-record-declaration-conc abnf::cst)
                  (cst-record-declaration-conc cst-equiv)))
  :rule-classes :congruence)

Function: cst-mapping-declaration-conc

(defun cst-mapping-declaration-conc (abnf::cst)
  (declare (xargs :guard (abnf::treep abnf::cst)))
  (declare
       (xargs :guard (cst-matchp abnf::cst "mapping-declaration")))
  (let ((__function__ 'cst-mapping-declaration-conc))
    (declare (ignorable __function__))
    (abnf::tree-nonleaf->branches abnf::cst)))

Theorem: tree-list-listp-of-cst-mapping-declaration-conc

(defthm tree-list-listp-of-cst-mapping-declaration-conc
  (b* ((abnf::cstss (cst-mapping-declaration-conc abnf::cst)))
    (abnf::tree-list-listp abnf::cstss))
  :rule-classes :rewrite)

Theorem: cst-mapping-declaration-conc-match

(defthm cst-mapping-declaration-conc-match
  (implies
       (cst-matchp abnf::cst "mapping-declaration")
       (b* ((abnf::cstss (cst-mapping-declaration-conc abnf::cst)))
         (cst-list-list-conc-matchp
              abnf::cstss
              "%s\"mapping\" identifier \":\" type \"=>\" type \";\"")))
  :rule-classes :rewrite)

Theorem: cst-mapping-declaration-conc-of-tree-fix-cst

(defthm cst-mapping-declaration-conc-of-tree-fix-cst
  (equal (cst-mapping-declaration-conc (abnf::tree-fix abnf::cst))
         (cst-mapping-declaration-conc abnf::cst)))

Theorem: cst-mapping-declaration-conc-tree-equiv-congruence-on-cst

(defthm cst-mapping-declaration-conc-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-mapping-declaration-conc abnf::cst)
                  (cst-mapping-declaration-conc cst-equiv)))
  :rule-classes :congruence)

Function: cst-program-item-conc1

(defun cst-program-item-conc1 (abnf::cst)
  (declare (xargs :guard (abnf::treep abnf::cst)))
  (declare
       (xargs :guard (and (cst-matchp abnf::cst "program-item")
                          (equal (cst-program-item-conc? abnf::cst)
                                 1))))
  (let ((__function__ 'cst-program-item-conc1))
    (declare (ignorable __function__))
    (abnf::tree-nonleaf->branches abnf::cst)))

Theorem: tree-list-listp-of-cst-program-item-conc1

(defthm tree-list-listp-of-cst-program-item-conc1
  (b* ((abnf::cstss (cst-program-item-conc1 abnf::cst)))
    (abnf::tree-list-listp abnf::cstss))
  :rule-classes :rewrite)

Theorem: cst-program-item-conc1-match

(defthm cst-program-item-conc1-match
 (implies
  (and (cst-matchp abnf::cst "program-item")
       (equal (cst-program-item-conc? abnf::cst)
              1))
  (b* ((abnf::cstss (cst-program-item-conc1 abnf::cst)))
    (cst-list-list-conc-matchp abnf::cstss "function-declaration")))
 :rule-classes :rewrite)

Theorem: cst-program-item-conc1-of-tree-fix-cst

(defthm cst-program-item-conc1-of-tree-fix-cst
  (equal (cst-program-item-conc1 (abnf::tree-fix abnf::cst))
         (cst-program-item-conc1 abnf::cst)))

Theorem: cst-program-item-conc1-tree-equiv-congruence-on-cst

(defthm cst-program-item-conc1-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-program-item-conc1 abnf::cst)
                  (cst-program-item-conc1 cst-equiv)))
  :rule-classes :congruence)

Function: cst-program-item-conc2

(defun cst-program-item-conc2 (abnf::cst)
  (declare (xargs :guard (abnf::treep abnf::cst)))
  (declare
       (xargs :guard (and (cst-matchp abnf::cst "program-item")
                          (equal (cst-program-item-conc? abnf::cst)
                                 2))))
  (let ((__function__ 'cst-program-item-conc2))
    (declare (ignorable __function__))
    (abnf::tree-nonleaf->branches abnf::cst)))

Theorem: tree-list-listp-of-cst-program-item-conc2

(defthm tree-list-listp-of-cst-program-item-conc2
  (b* ((abnf::cstss (cst-program-item-conc2 abnf::cst)))
    (abnf::tree-list-listp abnf::cstss))
  :rule-classes :rewrite)

Theorem: cst-program-item-conc2-match

(defthm cst-program-item-conc2-match
  (implies (and (cst-matchp abnf::cst "program-item")
                (equal (cst-program-item-conc? abnf::cst)
                       2))
           (b* ((abnf::cstss (cst-program-item-conc2 abnf::cst)))
             (cst-list-list-conc-matchp
                  abnf::cstss "transition-declaration")))
  :rule-classes :rewrite)

Theorem: cst-program-item-conc2-of-tree-fix-cst

(defthm cst-program-item-conc2-of-tree-fix-cst
  (equal (cst-program-item-conc2 (abnf::tree-fix abnf::cst))
         (cst-program-item-conc2 abnf::cst)))

Theorem: cst-program-item-conc2-tree-equiv-congruence-on-cst

(defthm cst-program-item-conc2-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-program-item-conc2 abnf::cst)
                  (cst-program-item-conc2 cst-equiv)))
  :rule-classes :congruence)

Function: cst-program-item-conc3

(defun cst-program-item-conc3 (abnf::cst)
  (declare (xargs :guard (abnf::treep abnf::cst)))
  (declare
       (xargs :guard (and (cst-matchp abnf::cst "program-item")
                          (equal (cst-program-item-conc? abnf::cst)
                                 3))))
  (let ((__function__ 'cst-program-item-conc3))
    (declare (ignorable __function__))
    (abnf::tree-nonleaf->branches abnf::cst)))

Theorem: tree-list-listp-of-cst-program-item-conc3

(defthm tree-list-listp-of-cst-program-item-conc3
  (b* ((abnf::cstss (cst-program-item-conc3 abnf::cst)))
    (abnf::tree-list-listp abnf::cstss))
  :rule-classes :rewrite)

Theorem: cst-program-item-conc3-match

(defthm cst-program-item-conc3-match
 (implies
    (and (cst-matchp abnf::cst "program-item")
         (equal (cst-program-item-conc? abnf::cst)
                3))
    (b* ((abnf::cstss (cst-program-item-conc3 abnf::cst)))
      (cst-list-list-conc-matchp abnf::cstss "struct-declaration")))
 :rule-classes :rewrite)

Theorem: cst-program-item-conc3-of-tree-fix-cst

(defthm cst-program-item-conc3-of-tree-fix-cst
  (equal (cst-program-item-conc3 (abnf::tree-fix abnf::cst))
         (cst-program-item-conc3 abnf::cst)))

Theorem: cst-program-item-conc3-tree-equiv-congruence-on-cst

(defthm cst-program-item-conc3-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-program-item-conc3 abnf::cst)
                  (cst-program-item-conc3 cst-equiv)))
  :rule-classes :congruence)

Function: cst-program-item-conc4

(defun cst-program-item-conc4 (abnf::cst)
  (declare (xargs :guard (abnf::treep abnf::cst)))
  (declare
       (xargs :guard (and (cst-matchp abnf::cst "program-item")
                          (equal (cst-program-item-conc? abnf::cst)
                                 4))))
  (let ((__function__ 'cst-program-item-conc4))
    (declare (ignorable __function__))
    (abnf::tree-nonleaf->branches abnf::cst)))

Theorem: tree-list-listp-of-cst-program-item-conc4

(defthm tree-list-listp-of-cst-program-item-conc4
  (b* ((abnf::cstss (cst-program-item-conc4 abnf::cst)))
    (abnf::tree-list-listp abnf::cstss))
  :rule-classes :rewrite)

Theorem: cst-program-item-conc4-match

(defthm cst-program-item-conc4-match
 (implies
    (and (cst-matchp abnf::cst "program-item")
         (equal (cst-program-item-conc? abnf::cst)
                4))
    (b* ((abnf::cstss (cst-program-item-conc4 abnf::cst)))
      (cst-list-list-conc-matchp abnf::cstss "record-declaration")))
 :rule-classes :rewrite)

Theorem: cst-program-item-conc4-of-tree-fix-cst

(defthm cst-program-item-conc4-of-tree-fix-cst
  (equal (cst-program-item-conc4 (abnf::tree-fix abnf::cst))
         (cst-program-item-conc4 abnf::cst)))

Theorem: cst-program-item-conc4-tree-equiv-congruence-on-cst

(defthm cst-program-item-conc4-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-program-item-conc4 abnf::cst)
                  (cst-program-item-conc4 cst-equiv)))
  :rule-classes :congruence)

Function: cst-program-item-conc5

(defun cst-program-item-conc5 (abnf::cst)
  (declare (xargs :guard (abnf::treep abnf::cst)))
  (declare
       (xargs :guard (and (cst-matchp abnf::cst "program-item")
                          (equal (cst-program-item-conc? abnf::cst)
                                 5))))
  (let ((__function__ 'cst-program-item-conc5))
    (declare (ignorable __function__))
    (abnf::tree-nonleaf->branches abnf::cst)))

Theorem: tree-list-listp-of-cst-program-item-conc5

(defthm tree-list-listp-of-cst-program-item-conc5
  (b* ((abnf::cstss (cst-program-item-conc5 abnf::cst)))
    (abnf::tree-list-listp abnf::cstss))
  :rule-classes :rewrite)

Theorem: cst-program-item-conc5-match

(defthm cst-program-item-conc5-match
 (implies
   (and (cst-matchp abnf::cst "program-item")
        (equal (cst-program-item-conc? abnf::cst)
               5))
   (b* ((abnf::cstss (cst-program-item-conc5 abnf::cst)))
     (cst-list-list-conc-matchp abnf::cstss "mapping-declaration")))
 :rule-classes :rewrite)

Theorem: cst-program-item-conc5-of-tree-fix-cst

(defthm cst-program-item-conc5-of-tree-fix-cst
  (equal (cst-program-item-conc5 (abnf::tree-fix abnf::cst))
         (cst-program-item-conc5 abnf::cst)))

Theorem: cst-program-item-conc5-tree-equiv-congruence-on-cst

(defthm cst-program-item-conc5-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-program-item-conc5 abnf::cst)
                  (cst-program-item-conc5 cst-equiv)))
  :rule-classes :congruence)

Function: cst-program-declaration-conc

(defun cst-program-declaration-conc (abnf::cst)
  (declare (xargs :guard (abnf::treep abnf::cst)))
  (declare
       (xargs :guard (cst-matchp abnf::cst "program-declaration")))
  (let ((__function__ 'cst-program-declaration-conc))
    (declare (ignorable __function__))
    (abnf::tree-nonleaf->branches abnf::cst)))

Theorem: tree-list-listp-of-cst-program-declaration-conc

(defthm tree-list-listp-of-cst-program-declaration-conc
  (b* ((abnf::cstss (cst-program-declaration-conc abnf::cst)))
    (abnf::tree-list-listp abnf::cstss))
  :rule-classes :rewrite)

Theorem: cst-program-declaration-conc-match

(defthm cst-program-declaration-conc-match
  (implies
       (cst-matchp abnf::cst "program-declaration")
       (b* ((abnf::cstss (cst-program-declaration-conc abnf::cst)))
         (cst-list-list-conc-matchp
              abnf::cstss
              "%s\"program\" program-id \"{\" *program-item \"}\"")))
  :rule-classes :rewrite)

Theorem: cst-program-declaration-conc-of-tree-fix-cst

(defthm cst-program-declaration-conc-of-tree-fix-cst
  (equal (cst-program-declaration-conc (abnf::tree-fix abnf::cst))
         (cst-program-declaration-conc abnf::cst)))

Theorem: cst-program-declaration-conc-tree-equiv-congruence-on-cst

(defthm cst-program-declaration-conc-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-program-declaration-conc abnf::cst)
                  (cst-program-declaration-conc cst-equiv)))
  :rule-classes :congruence)

Function: cst-import-declaration-conc

(defun cst-import-declaration-conc (abnf::cst)
  (declare (xargs :guard (abnf::treep abnf::cst)))
  (declare
       (xargs :guard (cst-matchp abnf::cst "import-declaration")))
  (let ((__function__ 'cst-import-declaration-conc))
    (declare (ignorable __function__))
    (abnf::tree-nonleaf->branches abnf::cst)))

Theorem: tree-list-listp-of-cst-import-declaration-conc

(defthm tree-list-listp-of-cst-import-declaration-conc
  (b* ((abnf::cstss (cst-import-declaration-conc abnf::cst)))
    (abnf::tree-list-listp abnf::cstss))
  :rule-classes :rewrite)

Theorem: cst-import-declaration-conc-match

(defthm cst-import-declaration-conc-match
  (implies
       (cst-matchp abnf::cst "import-declaration")
       (b* ((abnf::cstss (cst-import-declaration-conc abnf::cst)))
         (cst-list-list-conc-matchp abnf::cstss
                                    "%s\"import\" program-id \";\"")))
  :rule-classes :rewrite)

Theorem: cst-import-declaration-conc-of-tree-fix-cst

(defthm cst-import-declaration-conc-of-tree-fix-cst
  (equal (cst-import-declaration-conc (abnf::tree-fix abnf::cst))
         (cst-import-declaration-conc abnf::cst)))

Theorem: cst-import-declaration-conc-tree-equiv-congruence-on-cst

(defthm cst-import-declaration-conc-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-import-declaration-conc abnf::cst)
                  (cst-import-declaration-conc cst-equiv)))
  :rule-classes :congruence)

Function: cst-file-conc

(defun cst-file-conc (abnf::cst)
  (declare (xargs :guard (abnf::treep abnf::cst)))
  (declare (xargs :guard (cst-matchp abnf::cst "file")))
  (let ((__function__ 'cst-file-conc))
    (declare (ignorable __function__))
    (abnf::tree-nonleaf->branches abnf::cst)))

Theorem: tree-list-listp-of-cst-file-conc

(defthm tree-list-listp-of-cst-file-conc
  (b* ((abnf::cstss (cst-file-conc abnf::cst)))
    (abnf::tree-list-listp abnf::cstss))
  :rule-classes :rewrite)

Theorem: cst-file-conc-match

(defthm cst-file-conc-match
  (implies (cst-matchp abnf::cst "file")
           (b* ((abnf::cstss (cst-file-conc abnf::cst)))
             (cst-list-list-conc-matchp
                  abnf::cstss
                  "*import-declaration program-declaration")))
  :rule-classes :rewrite)

Theorem: cst-file-conc-of-tree-fix-cst

(defthm cst-file-conc-of-tree-fix-cst
  (equal (cst-file-conc (abnf::tree-fix abnf::cst))
         (cst-file-conc abnf::cst)))

Theorem: cst-file-conc-tree-equiv-congruence-on-cst

(defthm cst-file-conc-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-file-conc abnf::cst)
                  (cst-file-conc cst-equiv)))
  :rule-classes :congruence)

Function: cst-input-type-conc

(defun cst-input-type-conc (abnf::cst)
  (declare (xargs :guard (abnf::treep abnf::cst)))
  (declare (xargs :guard (cst-matchp abnf::cst "input-type")))
  (let ((__function__ 'cst-input-type-conc))
    (declare (ignorable __function__))
    (abnf::tree-nonleaf->branches abnf::cst)))

Theorem: tree-list-listp-of-cst-input-type-conc

(defthm tree-list-listp-of-cst-input-type-conc
  (b* ((abnf::cstss (cst-input-type-conc abnf::cst)))
    (abnf::tree-list-listp abnf::cstss))
  :rule-classes :rewrite)

Theorem: cst-input-type-conc-match

(defthm cst-input-type-conc-match
  (implies (cst-matchp abnf::cst "input-type")
           (b* ((abnf::cstss (cst-input-type-conc abnf::cst)))
             (cst-list-list-conc-matchp abnf::cstss "type")))
  :rule-classes :rewrite)

Theorem: cst-input-type-conc-of-tree-fix-cst

(defthm cst-input-type-conc-of-tree-fix-cst
  (equal (cst-input-type-conc (abnf::tree-fix abnf::cst))
         (cst-input-type-conc abnf::cst)))

Theorem: cst-input-type-conc-tree-equiv-congruence-on-cst

(defthm cst-input-type-conc-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-input-type-conc abnf::cst)
                  (cst-input-type-conc cst-equiv)))
  :rule-classes :congruence)

Function: cst-input-expression-conc

(defun cst-input-expression-conc (abnf::cst)
  (declare (xargs :guard (abnf::treep abnf::cst)))
  (declare (xargs :guard (cst-matchp abnf::cst "input-expression")))
  (let ((__function__ 'cst-input-expression-conc))
    (declare (ignorable __function__))
    (abnf::tree-nonleaf->branches abnf::cst)))

Theorem: tree-list-listp-of-cst-input-expression-conc

(defthm tree-list-listp-of-cst-input-expression-conc
  (b* ((abnf::cstss (cst-input-expression-conc abnf::cst)))
    (abnf::tree-list-listp abnf::cstss))
  :rule-classes :rewrite)

Theorem: cst-input-expression-conc-match

(defthm cst-input-expression-conc-match
  (implies (cst-matchp abnf::cst "input-expression")
           (b* ((abnf::cstss (cst-input-expression-conc abnf::cst)))
             (cst-list-list-conc-matchp abnf::cstss "expression")))
  :rule-classes :rewrite)

Theorem: cst-input-expression-conc-of-tree-fix-cst

(defthm cst-input-expression-conc-of-tree-fix-cst
  (equal (cst-input-expression-conc (abnf::tree-fix abnf::cst))
         (cst-input-expression-conc abnf::cst)))

Theorem: cst-input-expression-conc-tree-equiv-congruence-on-cst

(defthm cst-input-expression-conc-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-input-expression-conc abnf::cst)
                  (cst-input-expression-conc cst-equiv)))
  :rule-classes :congruence)

Function: cst-input-item-conc

(defun cst-input-item-conc (abnf::cst)
  (declare (xargs :guard (abnf::treep abnf::cst)))
  (declare (xargs :guard (cst-matchp abnf::cst "input-item")))
  (let ((__function__ 'cst-input-item-conc))
    (declare (ignorable __function__))
    (abnf::tree-nonleaf->branches abnf::cst)))

Theorem: tree-list-listp-of-cst-input-item-conc

(defthm tree-list-listp-of-cst-input-item-conc
  (b* ((abnf::cstss (cst-input-item-conc abnf::cst)))
    (abnf::tree-list-listp abnf::cstss))
  :rule-classes :rewrite)

Theorem: cst-input-item-conc-match

(defthm cst-input-item-conc-match
 (implies
      (cst-matchp abnf::cst "input-item")
      (b* ((abnf::cstss (cst-input-item-conc abnf::cst)))
        (cst-list-list-conc-matchp
             abnf::cstss
             "identifier \":\" input-type \"=\" input-expression \";\"")))
 :rule-classes :rewrite)

Theorem: cst-input-item-conc-of-tree-fix-cst

(defthm cst-input-item-conc-of-tree-fix-cst
  (equal (cst-input-item-conc (abnf::tree-fix abnf::cst))
         (cst-input-item-conc abnf::cst)))

Theorem: cst-input-item-conc-tree-equiv-congruence-on-cst

(defthm cst-input-item-conc-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-input-item-conc abnf::cst)
                  (cst-input-item-conc cst-equiv)))
  :rule-classes :congruence)

Function: cst-input-title-conc

(defun cst-input-title-conc (abnf::cst)
  (declare (xargs :guard (abnf::treep abnf::cst)))
  (declare (xargs :guard (cst-matchp abnf::cst "input-title")))
  (let ((__function__ 'cst-input-title-conc))
    (declare (ignorable __function__))
    (abnf::tree-nonleaf->branches abnf::cst)))

Theorem: tree-list-listp-of-cst-input-title-conc

(defthm tree-list-listp-of-cst-input-title-conc
  (b* ((abnf::cstss (cst-input-title-conc abnf::cst)))
    (abnf::tree-list-listp abnf::cstss))
  :rule-classes :rewrite)

Theorem: cst-input-title-conc-match

(defthm cst-input-title-conc-match
 (implies
  (cst-matchp abnf::cst "input-title")
  (b* ((abnf::cstss (cst-input-title-conc abnf::cst)))
   (cst-list-list-conc-matchp
    abnf::cstss
    "\"[\" ( %s\"public\" / %s\"private\" / %s\"constant\" / %s\"const\" ) \"]\"")))
 :rule-classes :rewrite)

Theorem: cst-input-title-conc-of-tree-fix-cst

(defthm cst-input-title-conc-of-tree-fix-cst
  (equal (cst-input-title-conc (abnf::tree-fix abnf::cst))
         (cst-input-title-conc abnf::cst)))

Theorem: cst-input-title-conc-tree-equiv-congruence-on-cst

(defthm cst-input-title-conc-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-input-title-conc abnf::cst)
                  (cst-input-title-conc cst-equiv)))
  :rule-classes :congruence)

Function: cst-input-section-conc

(defun cst-input-section-conc (abnf::cst)
  (declare (xargs :guard (abnf::treep abnf::cst)))
  (declare (xargs :guard (cst-matchp abnf::cst "input-section")))
  (let ((__function__ 'cst-input-section-conc))
    (declare (ignorable __function__))
    (abnf::tree-nonleaf->branches abnf::cst)))

Theorem: tree-list-listp-of-cst-input-section-conc

(defthm tree-list-listp-of-cst-input-section-conc
  (b* ((abnf::cstss (cst-input-section-conc abnf::cst)))
    (abnf::tree-list-listp abnf::cstss))
  :rule-classes :rewrite)

Theorem: cst-input-section-conc-match

(defthm cst-input-section-conc-match
  (implies (cst-matchp abnf::cst "input-section")
           (b* ((abnf::cstss (cst-input-section-conc abnf::cst)))
             (cst-list-list-conc-matchp
                  abnf::cstss "input-title *input-item")))
  :rule-classes :rewrite)

Theorem: cst-input-section-conc-of-tree-fix-cst

(defthm cst-input-section-conc-of-tree-fix-cst
  (equal (cst-input-section-conc (abnf::tree-fix abnf::cst))
         (cst-input-section-conc abnf::cst)))

Theorem: cst-input-section-conc-tree-equiv-congruence-on-cst

(defthm cst-input-section-conc-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-input-section-conc abnf::cst)
                  (cst-input-section-conc cst-equiv)))
  :rule-classes :congruence)

Function: cst-input-file-conc

(defun cst-input-file-conc (abnf::cst)
  (declare (xargs :guard (abnf::treep abnf::cst)))
  (declare (xargs :guard (cst-matchp abnf::cst "input-file")))
  (let ((__function__ 'cst-input-file-conc))
    (declare (ignorable __function__))
    (abnf::tree-nonleaf->branches abnf::cst)))

Theorem: tree-list-listp-of-cst-input-file-conc

(defthm tree-list-listp-of-cst-input-file-conc
  (b* ((abnf::cstss (cst-input-file-conc abnf::cst)))
    (abnf::tree-list-listp abnf::cstss))
  :rule-classes :rewrite)

Theorem: cst-input-file-conc-match

(defthm cst-input-file-conc-match
  (implies
       (cst-matchp abnf::cst "input-file")
       (b* ((abnf::cstss (cst-input-file-conc abnf::cst)))
         (cst-list-list-conc-matchp abnf::cstss "*input-section")))
  :rule-classes :rewrite)

Theorem: cst-input-file-conc-of-tree-fix-cst

(defthm cst-input-file-conc-of-tree-fix-cst
  (equal (cst-input-file-conc (abnf::tree-fix abnf::cst))
         (cst-input-file-conc abnf::cst)))

Theorem: cst-input-file-conc-tree-equiv-congruence-on-cst

(defthm cst-input-file-conc-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-input-file-conc abnf::cst)
                  (cst-input-file-conc cst-equiv)))
  :rule-classes :congruence)

Function: cst-output-expression-conc

(defun cst-output-expression-conc (abnf::cst)
 (declare (xargs :guard (abnf::treep abnf::cst)))
 (declare (xargs :guard (cst-matchp abnf::cst "output-expression")))
 (let ((__function__ 'cst-output-expression-conc))
   (declare (ignorable __function__))
   (abnf::tree-nonleaf->branches abnf::cst)))

Theorem: tree-list-listp-of-cst-output-expression-conc

(defthm tree-list-listp-of-cst-output-expression-conc
  (b* ((abnf::cstss (cst-output-expression-conc abnf::cst)))
    (abnf::tree-list-listp abnf::cstss))
  :rule-classes :rewrite)

Theorem: cst-output-expression-conc-match

(defthm cst-output-expression-conc-match
 (implies (cst-matchp abnf::cst "output-expression")
          (b* ((abnf::cstss (cst-output-expression-conc abnf::cst)))
            (cst-list-list-conc-matchp abnf::cstss "expression")))
 :rule-classes :rewrite)

Theorem: cst-output-expression-conc-of-tree-fix-cst

(defthm cst-output-expression-conc-of-tree-fix-cst
  (equal (cst-output-expression-conc (abnf::tree-fix abnf::cst))
         (cst-output-expression-conc abnf::cst)))

Theorem: cst-output-expression-conc-tree-equiv-congruence-on-cst

(defthm cst-output-expression-conc-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-output-expression-conc abnf::cst)
                  (cst-output-expression-conc cst-equiv)))
  :rule-classes :congruence)

Function: cst-output-item-conc

(defun cst-output-item-conc (abnf::cst)
  (declare (xargs :guard (abnf::treep abnf::cst)))
  (declare (xargs :guard (cst-matchp abnf::cst "output-item")))
  (let ((__function__ 'cst-output-item-conc))
    (declare (ignorable __function__))
    (abnf::tree-nonleaf->branches abnf::cst)))

Theorem: tree-list-listp-of-cst-output-item-conc

(defthm tree-list-listp-of-cst-output-item-conc
  (b* ((abnf::cstss (cst-output-item-conc abnf::cst)))
    (abnf::tree-list-listp abnf::cstss))
  :rule-classes :rewrite)

Theorem: cst-output-item-conc-match

(defthm cst-output-item-conc-match
 (implies
  (cst-matchp abnf::cst "output-item")
  (b* ((abnf::cstss (cst-output-item-conc abnf::cst)))
   (cst-list-list-conc-matchp abnf::cstss "output-expression \";\"")))
 :rule-classes :rewrite)

Theorem: cst-output-item-conc-of-tree-fix-cst

(defthm cst-output-item-conc-of-tree-fix-cst
  (equal (cst-output-item-conc (abnf::tree-fix abnf::cst))
         (cst-output-item-conc abnf::cst)))

Theorem: cst-output-item-conc-tree-equiv-congruence-on-cst

(defthm cst-output-item-conc-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-output-item-conc abnf::cst)
                  (cst-output-item-conc cst-equiv)))
  :rule-classes :congruence)

Function: cst-output-title-conc

(defun cst-output-title-conc (abnf::cst)
  (declare (xargs :guard (abnf::treep abnf::cst)))
  (declare (xargs :guard (cst-matchp abnf::cst "output-title")))
  (let ((__function__ 'cst-output-title-conc))
    (declare (ignorable __function__))
    (abnf::tree-nonleaf->branches abnf::cst)))

Theorem: tree-list-listp-of-cst-output-title-conc

(defthm tree-list-listp-of-cst-output-title-conc
  (b* ((abnf::cstss (cst-output-title-conc abnf::cst)))
    (abnf::tree-list-listp abnf::cstss))
  :rule-classes :rewrite)

Theorem: cst-output-title-conc-match

(defthm cst-output-title-conc-match
 (implies
    (cst-matchp abnf::cst "output-title")
    (b* ((abnf::cstss (cst-output-title-conc abnf::cst)))
      (cst-list-list-conc-matchp abnf::cstss "\"[\" %s\"output\" \"]\"")))
 :rule-classes :rewrite)

Theorem: cst-output-title-conc-of-tree-fix-cst

(defthm cst-output-title-conc-of-tree-fix-cst
  (equal (cst-output-title-conc (abnf::tree-fix abnf::cst))
         (cst-output-title-conc abnf::cst)))

Theorem: cst-output-title-conc-tree-equiv-congruence-on-cst

(defthm cst-output-title-conc-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-output-title-conc abnf::cst)
                  (cst-output-title-conc cst-equiv)))
  :rule-classes :congruence)

Function: cst-output-section-conc

(defun cst-output-section-conc (abnf::cst)
  (declare (xargs :guard (abnf::treep abnf::cst)))
  (declare (xargs :guard (cst-matchp abnf::cst "output-section")))
  (let ((__function__ 'cst-output-section-conc))
    (declare (ignorable __function__))
    (abnf::tree-nonleaf->branches abnf::cst)))

Theorem: tree-list-listp-of-cst-output-section-conc

(defthm tree-list-listp-of-cst-output-section-conc
  (b* ((abnf::cstss (cst-output-section-conc abnf::cst)))
    (abnf::tree-list-listp abnf::cstss))
  :rule-classes :rewrite)

Theorem: cst-output-section-conc-match

(defthm cst-output-section-conc-match
 (implies (cst-matchp abnf::cst "output-section")
          (b* ((abnf::cstss (cst-output-section-conc abnf::cst)))
            (cst-list-list-conc-matchp abnf::cstss
                                       "output-title output-item")))
 :rule-classes :rewrite)

Theorem: cst-output-section-conc-of-tree-fix-cst

(defthm cst-output-section-conc-of-tree-fix-cst
  (equal (cst-output-section-conc (abnf::tree-fix abnf::cst))
         (cst-output-section-conc abnf::cst)))

Theorem: cst-output-section-conc-tree-equiv-congruence-on-cst

(defthm cst-output-section-conc-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-output-section-conc abnf::cst)
                  (cst-output-section-conc cst-equiv)))
  :rule-classes :congruence)

Function: cst-output-file-conc

(defun cst-output-file-conc (abnf::cst)
  (declare (xargs :guard (abnf::treep abnf::cst)))
  (declare (xargs :guard (cst-matchp abnf::cst "output-file")))
  (let ((__function__ 'cst-output-file-conc))
    (declare (ignorable __function__))
    (abnf::tree-nonleaf->branches abnf::cst)))

Theorem: tree-list-listp-of-cst-output-file-conc

(defthm tree-list-listp-of-cst-output-file-conc
  (b* ((abnf::cstss (cst-output-file-conc abnf::cst)))
    (abnf::tree-list-listp abnf::cstss))
  :rule-classes :rewrite)

Theorem: cst-output-file-conc-match

(defthm cst-output-file-conc-match
  (implies
       (cst-matchp abnf::cst "output-file")
       (b* ((abnf::cstss (cst-output-file-conc abnf::cst)))
         (cst-list-list-conc-matchp abnf::cstss "output-section")))
  :rule-classes :rewrite)

Theorem: cst-output-file-conc-of-tree-fix-cst

(defthm cst-output-file-conc-of-tree-fix-cst
  (equal (cst-output-file-conc (abnf::tree-fix abnf::cst))
         (cst-output-file-conc abnf::cst)))

Theorem: cst-output-file-conc-tree-equiv-congruence-on-cst

(defthm cst-output-file-conc-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-output-file-conc abnf::cst)
                  (cst-output-file-conc cst-equiv)))
  :rule-classes :congruence)

Function: cst-horizontal-tab-conc-rep

(defun cst-horizontal-tab-conc-rep (abnf::cst)
 (declare (xargs :guard (abnf::treep abnf::cst)))
 (declare (xargs :guard (cst-matchp abnf::cst "horizontal-tab")))
 (let ((__function__ 'cst-horizontal-tab-conc-rep))
   (declare (ignorable __function__))
   (abnf::tree-list-fix (nth 0
                             (cst-horizontal-tab-conc abnf::cst)))))

Theorem: tree-listp-of-cst-horizontal-tab-conc-rep

(defthm tree-listp-of-cst-horizontal-tab-conc-rep
  (b* ((abnf::csts (cst-horizontal-tab-conc-rep abnf::cst)))
    (abnf::tree-listp abnf::csts))
  :rule-classes :rewrite)

Theorem: cst-horizontal-tab-conc-rep-match

(defthm cst-horizontal-tab-conc-rep-match
 (implies (cst-matchp abnf::cst "horizontal-tab")
          (b* ((abnf::csts (cst-horizontal-tab-conc-rep abnf::cst)))
            (cst-list-rep-matchp abnf::csts "%x9")))
 :rule-classes :rewrite)

Theorem: cst-horizontal-tab-conc-rep-of-tree-fix-cst

(defthm cst-horizontal-tab-conc-rep-of-tree-fix-cst
  (equal (cst-horizontal-tab-conc-rep (abnf::tree-fix abnf::cst))
         (cst-horizontal-tab-conc-rep abnf::cst)))

Theorem: cst-horizontal-tab-conc-rep-tree-equiv-congruence-on-cst

(defthm cst-horizontal-tab-conc-rep-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-horizontal-tab-conc-rep abnf::cst)
                  (cst-horizontal-tab-conc-rep cst-equiv)))
  :rule-classes :congruence)

Function: cst-line-feed-conc-rep

(defun cst-line-feed-conc-rep (abnf::cst)
  (declare (xargs :guard (abnf::treep abnf::cst)))
  (declare (xargs :guard (cst-matchp abnf::cst "line-feed")))
  (let ((__function__ 'cst-line-feed-conc-rep))
    (declare (ignorable __function__))
    (abnf::tree-list-fix (nth 0 (cst-line-feed-conc abnf::cst)))))

Theorem: tree-listp-of-cst-line-feed-conc-rep

(defthm tree-listp-of-cst-line-feed-conc-rep
  (b* ((abnf::csts (cst-line-feed-conc-rep abnf::cst)))
    (abnf::tree-listp abnf::csts))
  :rule-classes :rewrite)

Theorem: cst-line-feed-conc-rep-match

(defthm cst-line-feed-conc-rep-match
  (implies (cst-matchp abnf::cst "line-feed")
           (b* ((abnf::csts (cst-line-feed-conc-rep abnf::cst)))
             (cst-list-rep-matchp abnf::csts "%xA")))
  :rule-classes :rewrite)

Theorem: cst-line-feed-conc-rep-of-tree-fix-cst

(defthm cst-line-feed-conc-rep-of-tree-fix-cst
  (equal (cst-line-feed-conc-rep (abnf::tree-fix abnf::cst))
         (cst-line-feed-conc-rep abnf::cst)))

Theorem: cst-line-feed-conc-rep-tree-equiv-congruence-on-cst

(defthm cst-line-feed-conc-rep-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-line-feed-conc-rep abnf::cst)
                  (cst-line-feed-conc-rep cst-equiv)))
  :rule-classes :congruence)

Function: cst-carriage-return-conc-rep

(defun cst-carriage-return-conc-rep (abnf::cst)
 (declare (xargs :guard (abnf::treep abnf::cst)))
 (declare (xargs :guard (cst-matchp abnf::cst "carriage-return")))
 (let ((__function__ 'cst-carriage-return-conc-rep))
  (declare (ignorable __function__))
  (abnf::tree-list-fix (nth 0
                            (cst-carriage-return-conc abnf::cst)))))

Theorem: tree-listp-of-cst-carriage-return-conc-rep

(defthm tree-listp-of-cst-carriage-return-conc-rep
  (b* ((abnf::csts (cst-carriage-return-conc-rep abnf::cst)))
    (abnf::tree-listp abnf::csts))
  :rule-classes :rewrite)

Theorem: cst-carriage-return-conc-rep-match

(defthm cst-carriage-return-conc-rep-match
  (implies
       (cst-matchp abnf::cst "carriage-return")
       (b* ((abnf::csts (cst-carriage-return-conc-rep abnf::cst)))
         (cst-list-rep-matchp abnf::csts "%xD")))
  :rule-classes :rewrite)

Theorem: cst-carriage-return-conc-rep-of-tree-fix-cst

(defthm cst-carriage-return-conc-rep-of-tree-fix-cst
  (equal (cst-carriage-return-conc-rep (abnf::tree-fix abnf::cst))
         (cst-carriage-return-conc-rep abnf::cst)))

Theorem: cst-carriage-return-conc-rep-tree-equiv-congruence-on-cst

(defthm cst-carriage-return-conc-rep-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-carriage-return-conc-rep abnf::cst)
                  (cst-carriage-return-conc-rep cst-equiv)))
  :rule-classes :congruence)

Function: cst-space-conc-rep

(defun cst-space-conc-rep (abnf::cst)
  (declare (xargs :guard (abnf::treep abnf::cst)))
  (declare (xargs :guard (cst-matchp abnf::cst "space")))
  (let ((__function__ 'cst-space-conc-rep))
    (declare (ignorable __function__))
    (abnf::tree-list-fix (nth 0 (cst-space-conc abnf::cst)))))

Theorem: tree-listp-of-cst-space-conc-rep

(defthm tree-listp-of-cst-space-conc-rep
  (b* ((abnf::csts (cst-space-conc-rep abnf::cst)))
    (abnf::tree-listp abnf::csts))
  :rule-classes :rewrite)

Theorem: cst-space-conc-rep-match

(defthm cst-space-conc-rep-match
  (implies (cst-matchp abnf::cst "space")
           (b* ((abnf::csts (cst-space-conc-rep abnf::cst)))
             (cst-list-rep-matchp abnf::csts "%x20")))
  :rule-classes :rewrite)

Theorem: cst-space-conc-rep-of-tree-fix-cst

(defthm cst-space-conc-rep-of-tree-fix-cst
  (equal (cst-space-conc-rep (abnf::tree-fix abnf::cst))
         (cst-space-conc-rep abnf::cst)))

Theorem: cst-space-conc-rep-tree-equiv-congruence-on-cst

(defthm cst-space-conc-rep-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-space-conc-rep abnf::cst)
                  (cst-space-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 "horizontal-tab")))
  :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 "line-feed")))
  :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 "carriage-return")))
  :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 "space")))
  :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-whitespace-conc1-rep

(defun cst-whitespace-conc1-rep (abnf::cst)
 (declare (xargs :guard (abnf::treep abnf::cst)))
 (declare (xargs :guard (and (cst-matchp abnf::cst "whitespace")
                             (equal (cst-whitespace-conc? abnf::cst)
                                    1))))
 (let ((__function__ 'cst-whitespace-conc1-rep))
   (declare (ignorable __function__))
   (abnf::tree-list-fix (nth 0 (cst-whitespace-conc1 abnf::cst)))))

Theorem: tree-listp-of-cst-whitespace-conc1-rep

(defthm tree-listp-of-cst-whitespace-conc1-rep
  (b* ((abnf::csts (cst-whitespace-conc1-rep abnf::cst)))
    (abnf::tree-listp abnf::csts))
  :rule-classes :rewrite)

Theorem: cst-whitespace-conc1-rep-match

(defthm cst-whitespace-conc1-rep-match
  (implies (and (cst-matchp abnf::cst "whitespace")
                (equal (cst-whitespace-conc? abnf::cst)
                       1))
           (b* ((abnf::csts (cst-whitespace-conc1-rep abnf::cst)))
             (cst-list-rep-matchp abnf::csts "space")))
  :rule-classes :rewrite)

Theorem: cst-whitespace-conc1-rep-of-tree-fix-cst

(defthm cst-whitespace-conc1-rep-of-tree-fix-cst
  (equal (cst-whitespace-conc1-rep (abnf::tree-fix abnf::cst))
         (cst-whitespace-conc1-rep abnf::cst)))

Theorem: cst-whitespace-conc1-rep-tree-equiv-congruence-on-cst

(defthm cst-whitespace-conc1-rep-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-whitespace-conc1-rep abnf::cst)
                  (cst-whitespace-conc1-rep cst-equiv)))
  :rule-classes :congruence)

Function: cst-whitespace-conc2-rep

(defun cst-whitespace-conc2-rep (abnf::cst)
 (declare (xargs :guard (abnf::treep abnf::cst)))
 (declare (xargs :guard (and (cst-matchp abnf::cst "whitespace")
                             (equal (cst-whitespace-conc? abnf::cst)
                                    2))))
 (let ((__function__ 'cst-whitespace-conc2-rep))
   (declare (ignorable __function__))
   (abnf::tree-list-fix (nth 0 (cst-whitespace-conc2 abnf::cst)))))

Theorem: tree-listp-of-cst-whitespace-conc2-rep

(defthm tree-listp-of-cst-whitespace-conc2-rep
  (b* ((abnf::csts (cst-whitespace-conc2-rep abnf::cst)))
    (abnf::tree-listp abnf::csts))
  :rule-classes :rewrite)

Theorem: cst-whitespace-conc2-rep-match

(defthm cst-whitespace-conc2-rep-match
  (implies (and (cst-matchp abnf::cst "whitespace")
                (equal (cst-whitespace-conc? abnf::cst)
                       2))
           (b* ((abnf::csts (cst-whitespace-conc2-rep abnf::cst)))
             (cst-list-rep-matchp abnf::csts "horizontal-tab")))
  :rule-classes :rewrite)

Theorem: cst-whitespace-conc2-rep-of-tree-fix-cst

(defthm cst-whitespace-conc2-rep-of-tree-fix-cst
  (equal (cst-whitespace-conc2-rep (abnf::tree-fix abnf::cst))
         (cst-whitespace-conc2-rep abnf::cst)))

Theorem: cst-whitespace-conc2-rep-tree-equiv-congruence-on-cst

(defthm cst-whitespace-conc2-rep-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-whitespace-conc2-rep abnf::cst)
                  (cst-whitespace-conc2-rep cst-equiv)))
  :rule-classes :congruence)

Function: cst-whitespace-conc3-rep

(defun cst-whitespace-conc3-rep (abnf::cst)
 (declare (xargs :guard (abnf::treep abnf::cst)))
 (declare (xargs :guard (and (cst-matchp abnf::cst "whitespace")
                             (equal (cst-whitespace-conc? abnf::cst)
                                    3))))
 (let ((__function__ 'cst-whitespace-conc3-rep))
   (declare (ignorable __function__))
   (abnf::tree-list-fix (nth 0 (cst-whitespace-conc3 abnf::cst)))))

Theorem: tree-listp-of-cst-whitespace-conc3-rep

(defthm tree-listp-of-cst-whitespace-conc3-rep
  (b* ((abnf::csts (cst-whitespace-conc3-rep abnf::cst)))
    (abnf::tree-listp abnf::csts))
  :rule-classes :rewrite)

Theorem: cst-whitespace-conc3-rep-match

(defthm cst-whitespace-conc3-rep-match
  (implies (and (cst-matchp abnf::cst "whitespace")
                (equal (cst-whitespace-conc? abnf::cst)
                       3))
           (b* ((abnf::csts (cst-whitespace-conc3-rep abnf::cst)))
             (cst-list-rep-matchp abnf::csts "line-terminator")))
  :rule-classes :rewrite)

Theorem: cst-whitespace-conc3-rep-of-tree-fix-cst

(defthm cst-whitespace-conc3-rep-of-tree-fix-cst
  (equal (cst-whitespace-conc3-rep (abnf::tree-fix abnf::cst))
         (cst-whitespace-conc3-rep abnf::cst)))

Theorem: cst-whitespace-conc3-rep-tree-equiv-congruence-on-cst

(defthm cst-whitespace-conc3-rep-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-whitespace-conc3-rep abnf::cst)
                  (cst-whitespace-conc3-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 "block-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 "line-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-line-feed-or-carriage-return-conc1-rep

(defun cst-not-line-feed-or-carriage-return-conc1-rep (abnf::cst)
 (declare (xargs :guard (abnf::treep abnf::cst)))
 (declare
  (xargs
   :guard
   (and
       (cst-matchp abnf::cst
                   "not-line-feed-or-carriage-return")
       (equal (cst-not-line-feed-or-carriage-return-conc? abnf::cst)
              1))))
 (let
   ((__function__ 'cst-not-line-feed-or-carriage-return-conc1-rep))
  (declare (ignorable __function__))
  (abnf::tree-list-fix
     (nth 0
          (cst-not-line-feed-or-carriage-return-conc1 abnf::cst)))))

Theorem: tree-listp-of-cst-not-line-feed-or-carriage-return-conc1-rep

(defthm tree-listp-of-cst-not-line-feed-or-carriage-return-conc1-rep
 (b*
  ((abnf::csts
        (cst-not-line-feed-or-carriage-return-conc1-rep abnf::cst)))
  (abnf::tree-listp abnf::csts))
 :rule-classes :rewrite)

Theorem: cst-not-line-feed-or-carriage-return-conc1-rep-match

(defthm cst-not-line-feed-or-carriage-return-conc1-rep-match
 (implies
  (and (cst-matchp abnf::cst
                   "not-line-feed-or-carriage-return")
       (equal (cst-not-line-feed-or-carriage-return-conc? abnf::cst)
              1))
  (b*
   ((abnf::csts
        (cst-not-line-feed-or-carriage-return-conc1-rep abnf::cst)))
   (cst-list-rep-matchp abnf::csts "horizontal-tab")))
 :rule-classes :rewrite)

Theorem: cst-not-line-feed-or-carriage-return-conc1-rep-of-tree-fix-cst

(defthm
     cst-not-line-feed-or-carriage-return-conc1-rep-of-tree-fix-cst
 (equal (cst-not-line-feed-or-carriage-return-conc1-rep
             (abnf::tree-fix abnf::cst))
        (cst-not-line-feed-or-carriage-return-conc1-rep abnf::cst)))

Theorem: cst-not-line-feed-or-carriage-return-conc1-rep-tree-equiv-congruence-on-cst

(defthm
 cst-not-line-feed-or-carriage-return-conc1-rep-tree-equiv-congruence-on-cst
 (implies
   (abnf::tree-equiv abnf::cst cst-equiv)
   (equal
        (cst-not-line-feed-or-carriage-return-conc1-rep abnf::cst)
        (cst-not-line-feed-or-carriage-return-conc1-rep cst-equiv)))
 :rule-classes :congruence)

Function: cst-not-line-feed-or-carriage-return-conc2-rep

(defun cst-not-line-feed-or-carriage-return-conc2-rep (abnf::cst)
 (declare (xargs :guard (abnf::treep abnf::cst)))
 (declare
  (xargs
   :guard
   (and
       (cst-matchp abnf::cst
                   "not-line-feed-or-carriage-return")
       (equal (cst-not-line-feed-or-carriage-return-conc? abnf::cst)
              2))))
 (let
   ((__function__ 'cst-not-line-feed-or-carriage-return-conc2-rep))
  (declare (ignorable __function__))
  (abnf::tree-list-fix
     (nth 0
          (cst-not-line-feed-or-carriage-return-conc2 abnf::cst)))))

Theorem: tree-listp-of-cst-not-line-feed-or-carriage-return-conc2-rep

(defthm tree-listp-of-cst-not-line-feed-or-carriage-return-conc2-rep
 (b*
  ((abnf::csts
        (cst-not-line-feed-or-carriage-return-conc2-rep abnf::cst)))
  (abnf::tree-listp abnf::csts))
 :rule-classes :rewrite)

Theorem: cst-not-line-feed-or-carriage-return-conc2-rep-match

(defthm cst-not-line-feed-or-carriage-return-conc2-rep-match
 (implies
  (and (cst-matchp abnf::cst
                   "not-line-feed-or-carriage-return")
       (equal (cst-not-line-feed-or-carriage-return-conc? abnf::cst)
              2))
  (b*
   ((abnf::csts
        (cst-not-line-feed-or-carriage-return-conc2-rep abnf::cst)))
   (cst-list-rep-matchp abnf::csts "space")))
 :rule-classes :rewrite)

Theorem: cst-not-line-feed-or-carriage-return-conc2-rep-of-tree-fix-cst

(defthm
     cst-not-line-feed-or-carriage-return-conc2-rep-of-tree-fix-cst
 (equal (cst-not-line-feed-or-carriage-return-conc2-rep
             (abnf::tree-fix abnf::cst))
        (cst-not-line-feed-or-carriage-return-conc2-rep abnf::cst)))

Theorem: cst-not-line-feed-or-carriage-return-conc2-rep-tree-equiv-congruence-on-cst

(defthm
 cst-not-line-feed-or-carriage-return-conc2-rep-tree-equiv-congruence-on-cst
 (implies
   (abnf::tree-equiv abnf::cst cst-equiv)
   (equal
        (cst-not-line-feed-or-carriage-return-conc2-rep abnf::cst)
        (cst-not-line-feed-or-carriage-return-conc2-rep cst-equiv)))
 :rule-classes :congruence)

Function: cst-not-line-feed-or-carriage-return-conc3-rep

(defun cst-not-line-feed-or-carriage-return-conc3-rep (abnf::cst)
 (declare (xargs :guard (abnf::treep abnf::cst)))
 (declare
  (xargs
   :guard
   (and
       (cst-matchp abnf::cst
                   "not-line-feed-or-carriage-return")
       (equal (cst-not-line-feed-or-carriage-return-conc? abnf::cst)
              3))))
 (let
   ((__function__ 'cst-not-line-feed-or-carriage-return-conc3-rep))
  (declare (ignorable __function__))
  (abnf::tree-list-fix
     (nth 0
          (cst-not-line-feed-or-carriage-return-conc3 abnf::cst)))))

Theorem: tree-listp-of-cst-not-line-feed-or-carriage-return-conc3-rep

(defthm tree-listp-of-cst-not-line-feed-or-carriage-return-conc3-rep
 (b*
  ((abnf::csts
        (cst-not-line-feed-or-carriage-return-conc3-rep abnf::cst)))
  (abnf::tree-listp abnf::csts))
 :rule-classes :rewrite)

Theorem: cst-not-line-feed-or-carriage-return-conc3-rep-match

(defthm cst-not-line-feed-or-carriage-return-conc3-rep-match
 (implies
  (and (cst-matchp abnf::cst
                   "not-line-feed-or-carriage-return")
       (equal (cst-not-line-feed-or-carriage-return-conc? abnf::cst)
              3))
  (b*
   ((abnf::csts
        (cst-not-line-feed-or-carriage-return-conc3-rep abnf::cst)))
   (cst-list-rep-matchp abnf::csts "visible-ascii")))
 :rule-classes :rewrite)

Theorem: cst-not-line-feed-or-carriage-return-conc3-rep-of-tree-fix-cst

(defthm
     cst-not-line-feed-or-carriage-return-conc3-rep-of-tree-fix-cst
 (equal (cst-not-line-feed-or-carriage-return-conc3-rep
             (abnf::tree-fix abnf::cst))
        (cst-not-line-feed-or-carriage-return-conc3-rep abnf::cst)))

Theorem: cst-not-line-feed-or-carriage-return-conc3-rep-tree-equiv-congruence-on-cst

(defthm
 cst-not-line-feed-or-carriage-return-conc3-rep-tree-equiv-congruence-on-cst
 (implies
   (abnf::tree-equiv abnf::cst cst-equiv)
   (equal
        (cst-not-line-feed-or-carriage-return-conc3-rep abnf::cst)
        (cst-not-line-feed-or-carriage-return-conc3-rep cst-equiv)))
 :rule-classes :congruence)

Function: cst-not-line-feed-or-carriage-return-conc4-rep

(defun cst-not-line-feed-or-carriage-return-conc4-rep (abnf::cst)
 (declare (xargs :guard (abnf::treep abnf::cst)))
 (declare
  (xargs
   :guard
   (and
       (cst-matchp abnf::cst
                   "not-line-feed-or-carriage-return")
       (equal (cst-not-line-feed-or-carriage-return-conc? abnf::cst)
              4))))
 (let
   ((__function__ 'cst-not-line-feed-or-carriage-return-conc4-rep))
  (declare (ignorable __function__))
  (abnf::tree-list-fix
     (nth 0
          (cst-not-line-feed-or-carriage-return-conc4 abnf::cst)))))

Theorem: tree-listp-of-cst-not-line-feed-or-carriage-return-conc4-rep

(defthm tree-listp-of-cst-not-line-feed-or-carriage-return-conc4-rep
 (b*
  ((abnf::csts
        (cst-not-line-feed-or-carriage-return-conc4-rep abnf::cst)))
  (abnf::tree-listp abnf::csts))
 :rule-classes :rewrite)

Theorem: cst-not-line-feed-or-carriage-return-conc4-rep-match

(defthm cst-not-line-feed-or-carriage-return-conc4-rep-match
 (implies
  (and (cst-matchp abnf::cst
                   "not-line-feed-or-carriage-return")
       (equal (cst-not-line-feed-or-carriage-return-conc? abnf::cst)
              4))
  (b*
   ((abnf::csts
        (cst-not-line-feed-or-carriage-return-conc4-rep abnf::cst)))
   (cst-list-rep-matchp abnf::csts "safe-nonascii")))
 :rule-classes :rewrite)

Theorem: cst-not-line-feed-or-carriage-return-conc4-rep-of-tree-fix-cst

(defthm
     cst-not-line-feed-or-carriage-return-conc4-rep-of-tree-fix-cst
 (equal (cst-not-line-feed-or-carriage-return-conc4-rep
             (abnf::tree-fix abnf::cst))
        (cst-not-line-feed-or-carriage-return-conc4-rep abnf::cst)))

Theorem: cst-not-line-feed-or-carriage-return-conc4-rep-tree-equiv-congruence-on-cst

(defthm
 cst-not-line-feed-or-carriage-return-conc4-rep-tree-equiv-congruence-on-cst
 (implies
   (abnf::tree-equiv abnf::cst cst-equiv)
   (equal
        (cst-not-line-feed-or-carriage-return-conc4-rep abnf::cst)
        (cst-not-line-feed-or-carriage-return-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-decimal-digit-conc-rep

(defun cst-decimal-digit-conc-rep (abnf::cst)
 (declare (xargs :guard (abnf::treep abnf::cst)))
 (declare (xargs :guard (cst-matchp abnf::cst "decimal-digit")))
 (let ((__function__ 'cst-decimal-digit-conc-rep))
  (declare (ignorable __function__))
  (abnf::tree-list-fix (nth 0 (cst-decimal-digit-conc abnf::cst)))))

Theorem: tree-listp-of-cst-decimal-digit-conc-rep

(defthm tree-listp-of-cst-decimal-digit-conc-rep
  (b* ((abnf::csts (cst-decimal-digit-conc-rep abnf::cst)))
    (abnf::tree-listp abnf::csts))
  :rule-classes :rewrite)

Theorem: cst-decimal-digit-conc-rep-match

(defthm cst-decimal-digit-conc-rep-match
  (implies (cst-matchp abnf::cst "decimal-digit")
           (b* ((abnf::csts (cst-decimal-digit-conc-rep abnf::cst)))
             (cst-list-rep-matchp abnf::csts "%x30-39")))
  :rule-classes :rewrite)

Theorem: cst-decimal-digit-conc-rep-of-tree-fix-cst

(defthm cst-decimal-digit-conc-rep-of-tree-fix-cst
  (equal (cst-decimal-digit-conc-rep (abnf::tree-fix abnf::cst))
         (cst-decimal-digit-conc-rep abnf::cst)))

Theorem: cst-decimal-digit-conc-rep-tree-equiv-congruence-on-cst

(defthm cst-decimal-digit-conc-rep-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-decimal-digit-conc-rep abnf::cst)
                  (cst-decimal-digit-conc-rep cst-equiv)))
  :rule-classes :congruence)

Function: cst-octal-digit-conc-rep

(defun cst-octal-digit-conc-rep (abnf::cst)
  (declare (xargs :guard (abnf::treep abnf::cst)))
  (declare (xargs :guard (cst-matchp abnf::cst "octal-digit")))
  (let ((__function__ 'cst-octal-digit-conc-rep))
    (declare (ignorable __function__))
    (abnf::tree-list-fix (nth 0 (cst-octal-digit-conc abnf::cst)))))

Theorem: tree-listp-of-cst-octal-digit-conc-rep

(defthm tree-listp-of-cst-octal-digit-conc-rep
  (b* ((abnf::csts (cst-octal-digit-conc-rep abnf::cst)))
    (abnf::tree-listp abnf::csts))
  :rule-classes :rewrite)

Theorem: cst-octal-digit-conc-rep-match

(defthm cst-octal-digit-conc-rep-match
  (implies (cst-matchp abnf::cst "octal-digit")
           (b* ((abnf::csts (cst-octal-digit-conc-rep abnf::cst)))
             (cst-list-rep-matchp abnf::csts "%x30-37")))
  :rule-classes :rewrite)

Theorem: cst-octal-digit-conc-rep-of-tree-fix-cst

(defthm cst-octal-digit-conc-rep-of-tree-fix-cst
  (equal (cst-octal-digit-conc-rep (abnf::tree-fix abnf::cst))
         (cst-octal-digit-conc-rep abnf::cst)))

Theorem: cst-octal-digit-conc-rep-tree-equiv-congruence-on-cst

(defthm cst-octal-digit-conc-rep-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-octal-digit-conc-rep abnf::cst)
                  (cst-octal-digit-conc-rep cst-equiv)))
  :rule-classes :congruence)

Function: cst-single-quote-conc-rep

(defun cst-single-quote-conc-rep (abnf::cst)
 (declare (xargs :guard (abnf::treep abnf::cst)))
 (declare (xargs :guard (cst-matchp abnf::cst "single-quote")))
 (let ((__function__ 'cst-single-quote-conc-rep))
   (declare (ignorable __function__))
   (abnf::tree-list-fix (nth 0 (cst-single-quote-conc abnf::cst)))))

Theorem: tree-listp-of-cst-single-quote-conc-rep

(defthm tree-listp-of-cst-single-quote-conc-rep
  (b* ((abnf::csts (cst-single-quote-conc-rep abnf::cst)))
    (abnf::tree-listp abnf::csts))
  :rule-classes :rewrite)

Theorem: cst-single-quote-conc-rep-match

(defthm cst-single-quote-conc-rep-match
  (implies (cst-matchp abnf::cst "single-quote")
           (b* ((abnf::csts (cst-single-quote-conc-rep abnf::cst)))
             (cst-list-rep-matchp abnf::csts "%x27")))
  :rule-classes :rewrite)

Theorem: cst-single-quote-conc-rep-of-tree-fix-cst

(defthm cst-single-quote-conc-rep-of-tree-fix-cst
  (equal (cst-single-quote-conc-rep (abnf::tree-fix abnf::cst))
         (cst-single-quote-conc-rep abnf::cst)))

Theorem: cst-single-quote-conc-rep-tree-equiv-congruence-on-cst

(defthm cst-single-quote-conc-rep-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-single-quote-conc-rep abnf::cst)
                  (cst-single-quote-conc-rep cst-equiv)))
  :rule-classes :congruence)

Function: cst-double-quote-conc-rep

(defun cst-double-quote-conc-rep (abnf::cst)
 (declare (xargs :guard (abnf::treep abnf::cst)))
 (declare (xargs :guard (cst-matchp abnf::cst "double-quote")))
 (let ((__function__ 'cst-double-quote-conc-rep))
   (declare (ignorable __function__))
   (abnf::tree-list-fix (nth 0 (cst-double-quote-conc abnf::cst)))))

Theorem: tree-listp-of-cst-double-quote-conc-rep

(defthm tree-listp-of-cst-double-quote-conc-rep
  (b* ((abnf::csts (cst-double-quote-conc-rep abnf::cst)))
    (abnf::tree-listp abnf::csts))
  :rule-classes :rewrite)

Theorem: cst-double-quote-conc-rep-match

(defthm cst-double-quote-conc-rep-match
  (implies (cst-matchp abnf::cst "double-quote")
           (b* ((abnf::csts (cst-double-quote-conc-rep abnf::cst)))
             (cst-list-rep-matchp abnf::csts "%x22")))
  :rule-classes :rewrite)

Theorem: cst-double-quote-conc-rep-of-tree-fix-cst

(defthm cst-double-quote-conc-rep-of-tree-fix-cst
  (equal (cst-double-quote-conc-rep (abnf::tree-fix abnf::cst))
         (cst-double-quote-conc-rep abnf::cst)))

Theorem: cst-double-quote-conc-rep-tree-equiv-congruence-on-cst

(defthm cst-double-quote-conc-rep-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-double-quote-conc-rep abnf::cst)
                  (cst-double-quote-conc-rep cst-equiv)))
  :rule-classes :congruence)

Function: cst-backslash-escape-conc-rep

(defun cst-backslash-escape-conc-rep (abnf::cst)
  (declare (xargs :guard (abnf::treep abnf::cst)))
  (declare (xargs :guard (cst-matchp abnf::cst "backslash-escape")))
  (let ((__function__ 'cst-backslash-escape-conc-rep))
    (declare (ignorable __function__))
    (abnf::tree-list-fix
         (nth 0
              (cst-backslash-escape-conc abnf::cst)))))

Theorem: tree-listp-of-cst-backslash-escape-conc-rep

(defthm tree-listp-of-cst-backslash-escape-conc-rep
  (b* ((abnf::csts (cst-backslash-escape-conc-rep abnf::cst)))
    (abnf::tree-listp abnf::csts))
  :rule-classes :rewrite)

Theorem: cst-backslash-escape-conc-rep-match

(defthm cst-backslash-escape-conc-rep-match
  (implies
       (cst-matchp abnf::cst "backslash-escape")
       (b* ((abnf::csts (cst-backslash-escape-conc-rep abnf::cst)))
         (cst-list-rep-matchp abnf::csts "\"\\\\\"")))
  :rule-classes :rewrite)

Theorem: cst-backslash-escape-conc-rep-of-tree-fix-cst

(defthm cst-backslash-escape-conc-rep-of-tree-fix-cst
  (equal (cst-backslash-escape-conc-rep (abnf::tree-fix abnf::cst))
         (cst-backslash-escape-conc-rep abnf::cst)))

Theorem: cst-backslash-escape-conc-rep-tree-equiv-congruence-on-cst

(defthm cst-backslash-escape-conc-rep-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-backslash-escape-conc-rep abnf::cst)
                  (cst-backslash-escape-conc-rep cst-equiv)))
  :rule-classes :congruence)

Function: cst-line-feed-escape-conc-rep

(defun cst-line-feed-escape-conc-rep (abnf::cst)
  (declare (xargs :guard (abnf::treep abnf::cst)))
  (declare (xargs :guard (cst-matchp abnf::cst "line-feed-escape")))
  (let ((__function__ 'cst-line-feed-escape-conc-rep))
    (declare (ignorable __function__))
    (abnf::tree-list-fix
         (nth 0
              (cst-line-feed-escape-conc abnf::cst)))))

Theorem: tree-listp-of-cst-line-feed-escape-conc-rep

(defthm tree-listp-of-cst-line-feed-escape-conc-rep
  (b* ((abnf::csts (cst-line-feed-escape-conc-rep abnf::cst)))
    (abnf::tree-listp abnf::csts))
  :rule-classes :rewrite)

Theorem: cst-line-feed-escape-conc-rep-match

(defthm cst-line-feed-escape-conc-rep-match
  (implies
       (cst-matchp abnf::cst "line-feed-escape")
       (b* ((abnf::csts (cst-line-feed-escape-conc-rep abnf::cst)))
         (cst-list-rep-matchp abnf::csts "%s\"\\n\"")))
  :rule-classes :rewrite)

Theorem: cst-line-feed-escape-conc-rep-of-tree-fix-cst

(defthm cst-line-feed-escape-conc-rep-of-tree-fix-cst
  (equal (cst-line-feed-escape-conc-rep (abnf::tree-fix abnf::cst))
         (cst-line-feed-escape-conc-rep abnf::cst)))

Theorem: cst-line-feed-escape-conc-rep-tree-equiv-congruence-on-cst

(defthm cst-line-feed-escape-conc-rep-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-line-feed-escape-conc-rep abnf::cst)
                  (cst-line-feed-escape-conc-rep cst-equiv)))
  :rule-classes :congruence)

Function: cst-carriage-return-escape-conc-rep

(defun cst-carriage-return-escape-conc-rep (abnf::cst)
 (declare (xargs :guard (abnf::treep abnf::cst)))
 (declare
     (xargs :guard (cst-matchp abnf::cst "carriage-return-escape")))
 (let ((__function__ 'cst-carriage-return-escape-conc-rep))
   (declare (ignorable __function__))
   (abnf::tree-list-fix
        (nth 0
             (cst-carriage-return-escape-conc abnf::cst)))))

Theorem: tree-listp-of-cst-carriage-return-escape-conc-rep

(defthm tree-listp-of-cst-carriage-return-escape-conc-rep
  (b* ((abnf::csts (cst-carriage-return-escape-conc-rep abnf::cst)))
    (abnf::tree-listp abnf::csts))
  :rule-classes :rewrite)

Theorem: cst-carriage-return-escape-conc-rep-match

(defthm cst-carriage-return-escape-conc-rep-match
 (implies
  (cst-matchp abnf::cst "carriage-return-escape")
  (b* ((abnf::csts (cst-carriage-return-escape-conc-rep abnf::cst)))
    (cst-list-rep-matchp abnf::csts "%s\"\\r\"")))
 :rule-classes :rewrite)

Theorem: cst-carriage-return-escape-conc-rep-of-tree-fix-cst

(defthm cst-carriage-return-escape-conc-rep-of-tree-fix-cst
 (equal
    (cst-carriage-return-escape-conc-rep (abnf::tree-fix abnf::cst))
    (cst-carriage-return-escape-conc-rep abnf::cst)))

Theorem: cst-carriage-return-escape-conc-rep-tree-equiv-congruence-on-cst

(defthm
   cst-carriage-return-escape-conc-rep-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-carriage-return-escape-conc-rep abnf::cst)
                  (cst-carriage-return-escape-conc-rep cst-equiv)))
  :rule-classes :congruence)

Function: cst-horizontal-tab-escape-conc-rep

(defun cst-horizontal-tab-escape-conc-rep (abnf::cst)
 (declare (xargs :guard (abnf::treep abnf::cst)))
 (declare
      (xargs :guard (cst-matchp abnf::cst "horizontal-tab-escape")))
 (let ((__function__ 'cst-horizontal-tab-escape-conc-rep))
   (declare (ignorable __function__))
   (abnf::tree-list-fix
        (nth 0
             (cst-horizontal-tab-escape-conc abnf::cst)))))

Theorem: tree-listp-of-cst-horizontal-tab-escape-conc-rep

(defthm tree-listp-of-cst-horizontal-tab-escape-conc-rep
  (b* ((abnf::csts (cst-horizontal-tab-escape-conc-rep abnf::cst)))
    (abnf::tree-listp abnf::csts))
  :rule-classes :rewrite)

Theorem: cst-horizontal-tab-escape-conc-rep-match

(defthm cst-horizontal-tab-escape-conc-rep-match
 (implies
   (cst-matchp abnf::cst "horizontal-tab-escape")
   (b* ((abnf::csts (cst-horizontal-tab-escape-conc-rep abnf::cst)))
     (cst-list-rep-matchp abnf::csts "%s\"\\t\"")))
 :rule-classes :rewrite)

Theorem: cst-horizontal-tab-escape-conc-rep-of-tree-fix-cst

(defthm cst-horizontal-tab-escape-conc-rep-of-tree-fix-cst
 (equal
     (cst-horizontal-tab-escape-conc-rep (abnf::tree-fix abnf::cst))
     (cst-horizontal-tab-escape-conc-rep abnf::cst)))

Theorem: cst-horizontal-tab-escape-conc-rep-tree-equiv-congruence-on-cst

(defthm
    cst-horizontal-tab-escape-conc-rep-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-horizontal-tab-escape-conc-rep abnf::cst)
                  (cst-horizontal-tab-escape-conc-rep cst-equiv)))
  :rule-classes :congruence)

Function: cst-null-character-escape-conc-rep

(defun cst-null-character-escape-conc-rep (abnf::cst)
 (declare (xargs :guard (abnf::treep abnf::cst)))
 (declare
      (xargs :guard (cst-matchp abnf::cst "null-character-escape")))
 (let ((__function__ 'cst-null-character-escape-conc-rep))
   (declare (ignorable __function__))
   (abnf::tree-list-fix
        (nth 0
             (cst-null-character-escape-conc abnf::cst)))))

Theorem: tree-listp-of-cst-null-character-escape-conc-rep

(defthm tree-listp-of-cst-null-character-escape-conc-rep
  (b* ((abnf::csts (cst-null-character-escape-conc-rep abnf::cst)))
    (abnf::tree-listp abnf::csts))
  :rule-classes :rewrite)

Theorem: cst-null-character-escape-conc-rep-match

(defthm cst-null-character-escape-conc-rep-match
 (implies
   (cst-matchp abnf::cst "null-character-escape")
   (b* ((abnf::csts (cst-null-character-escape-conc-rep abnf::cst)))
     (cst-list-rep-matchp abnf::csts "\"\\0\"")))
 :rule-classes :rewrite)

Theorem: cst-null-character-escape-conc-rep-of-tree-fix-cst

(defthm cst-null-character-escape-conc-rep-of-tree-fix-cst
 (equal
     (cst-null-character-escape-conc-rep (abnf::tree-fix abnf::cst))
     (cst-null-character-escape-conc-rep abnf::cst)))

Theorem: cst-null-character-escape-conc-rep-tree-equiv-congruence-on-cst

(defthm
    cst-null-character-escape-conc-rep-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-null-character-escape-conc-rep abnf::cst)
                  (cst-null-character-escape-conc-rep cst-equiv)))
  :rule-classes :congruence)

Function: cst-simple-character-escape-conc1-rep

(defun cst-simple-character-escape-conc1-rep (abnf::cst)
 (declare (xargs :guard (abnf::treep abnf::cst)))
 (declare
  (xargs
    :guard (and (cst-matchp abnf::cst "simple-character-escape")
                (equal (cst-simple-character-escape-conc? abnf::cst)
                       1))))
 (let ((__function__ 'cst-simple-character-escape-conc1-rep))
   (declare (ignorable __function__))
   (abnf::tree-list-fix
        (nth 0
             (cst-simple-character-escape-conc1 abnf::cst)))))

Theorem: tree-listp-of-cst-simple-character-escape-conc1-rep

(defthm tree-listp-of-cst-simple-character-escape-conc1-rep
  (b*
    ((abnf::csts (cst-simple-character-escape-conc1-rep abnf::cst)))
    (abnf::tree-listp abnf::csts))
  :rule-classes :rewrite)

Theorem: cst-simple-character-escape-conc1-rep-match

(defthm cst-simple-character-escape-conc1-rep-match
 (implies
   (and (cst-matchp abnf::cst "simple-character-escape")
        (equal (cst-simple-character-escape-conc? abnf::cst)
               1))
   (b*
    ((abnf::csts (cst-simple-character-escape-conc1-rep abnf::cst)))
    (cst-list-rep-matchp abnf::csts "single-quote-escape")))
 :rule-classes :rewrite)

Theorem: cst-simple-character-escape-conc1-rep-of-tree-fix-cst

(defthm cst-simple-character-escape-conc1-rep-of-tree-fix-cst
 (equal
  (cst-simple-character-escape-conc1-rep (abnf::tree-fix abnf::cst))
  (cst-simple-character-escape-conc1-rep abnf::cst)))

Theorem: cst-simple-character-escape-conc1-rep-tree-equiv-congruence-on-cst

(defthm
 cst-simple-character-escape-conc1-rep-tree-equiv-congruence-on-cst
 (implies (abnf::tree-equiv abnf::cst cst-equiv)
          (equal (cst-simple-character-escape-conc1-rep abnf::cst)
                 (cst-simple-character-escape-conc1-rep cst-equiv)))
 :rule-classes :congruence)

Function: cst-simple-character-escape-conc2-rep

(defun cst-simple-character-escape-conc2-rep (abnf::cst)
 (declare (xargs :guard (abnf::treep abnf::cst)))
 (declare
  (xargs
    :guard (and (cst-matchp abnf::cst "simple-character-escape")
                (equal (cst-simple-character-escape-conc? abnf::cst)
                       2))))
 (let ((__function__ 'cst-simple-character-escape-conc2-rep))
   (declare (ignorable __function__))
   (abnf::tree-list-fix
        (nth 0
             (cst-simple-character-escape-conc2 abnf::cst)))))

Theorem: tree-listp-of-cst-simple-character-escape-conc2-rep

(defthm tree-listp-of-cst-simple-character-escape-conc2-rep
  (b*
    ((abnf::csts (cst-simple-character-escape-conc2-rep abnf::cst)))
    (abnf::tree-listp abnf::csts))
  :rule-classes :rewrite)

Theorem: cst-simple-character-escape-conc2-rep-match

(defthm cst-simple-character-escape-conc2-rep-match
 (implies
   (and (cst-matchp abnf::cst "simple-character-escape")
        (equal (cst-simple-character-escape-conc? abnf::cst)
               2))
   (b*
    ((abnf::csts (cst-simple-character-escape-conc2-rep abnf::cst)))
    (cst-list-rep-matchp abnf::csts "double-quote-escape")))
 :rule-classes :rewrite)

Theorem: cst-simple-character-escape-conc2-rep-of-tree-fix-cst

(defthm cst-simple-character-escape-conc2-rep-of-tree-fix-cst
 (equal
  (cst-simple-character-escape-conc2-rep (abnf::tree-fix abnf::cst))
  (cst-simple-character-escape-conc2-rep abnf::cst)))

Theorem: cst-simple-character-escape-conc2-rep-tree-equiv-congruence-on-cst

(defthm
 cst-simple-character-escape-conc2-rep-tree-equiv-congruence-on-cst
 (implies (abnf::tree-equiv abnf::cst cst-equiv)
          (equal (cst-simple-character-escape-conc2-rep abnf::cst)
                 (cst-simple-character-escape-conc2-rep cst-equiv)))
 :rule-classes :congruence)

Function: cst-simple-character-escape-conc3-rep

(defun cst-simple-character-escape-conc3-rep (abnf::cst)
 (declare (xargs :guard (abnf::treep abnf::cst)))
 (declare
  (xargs
    :guard (and (cst-matchp abnf::cst "simple-character-escape")
                (equal (cst-simple-character-escape-conc? abnf::cst)
                       3))))
 (let ((__function__ 'cst-simple-character-escape-conc3-rep))
   (declare (ignorable __function__))
   (abnf::tree-list-fix
        (nth 0
             (cst-simple-character-escape-conc3 abnf::cst)))))

Theorem: tree-listp-of-cst-simple-character-escape-conc3-rep

(defthm tree-listp-of-cst-simple-character-escape-conc3-rep
  (b*
    ((abnf::csts (cst-simple-character-escape-conc3-rep abnf::cst)))
    (abnf::tree-listp abnf::csts))
  :rule-classes :rewrite)

Theorem: cst-simple-character-escape-conc3-rep-match

(defthm cst-simple-character-escape-conc3-rep-match
 (implies
   (and (cst-matchp abnf::cst "simple-character-escape")
        (equal (cst-simple-character-escape-conc? abnf::cst)
               3))
   (b*
    ((abnf::csts (cst-simple-character-escape-conc3-rep abnf::cst)))
    (cst-list-rep-matchp abnf::csts "backslash-escape")))
 :rule-classes :rewrite)

Theorem: cst-simple-character-escape-conc3-rep-of-tree-fix-cst

(defthm cst-simple-character-escape-conc3-rep-of-tree-fix-cst
 (equal
  (cst-simple-character-escape-conc3-rep (abnf::tree-fix abnf::cst))
  (cst-simple-character-escape-conc3-rep abnf::cst)))

Theorem: cst-simple-character-escape-conc3-rep-tree-equiv-congruence-on-cst

(defthm
 cst-simple-character-escape-conc3-rep-tree-equiv-congruence-on-cst
 (implies (abnf::tree-equiv abnf::cst cst-equiv)
          (equal (cst-simple-character-escape-conc3-rep abnf::cst)
                 (cst-simple-character-escape-conc3-rep cst-equiv)))
 :rule-classes :congruence)

Function: cst-simple-character-escape-conc4-rep

(defun cst-simple-character-escape-conc4-rep (abnf::cst)
 (declare (xargs :guard (abnf::treep abnf::cst)))
 (declare
  (xargs
    :guard (and (cst-matchp abnf::cst "simple-character-escape")
                (equal (cst-simple-character-escape-conc? abnf::cst)
                       4))))
 (let ((__function__ 'cst-simple-character-escape-conc4-rep))
   (declare (ignorable __function__))
   (abnf::tree-list-fix
        (nth 0
             (cst-simple-character-escape-conc4 abnf::cst)))))

Theorem: tree-listp-of-cst-simple-character-escape-conc4-rep

(defthm tree-listp-of-cst-simple-character-escape-conc4-rep
  (b*
    ((abnf::csts (cst-simple-character-escape-conc4-rep abnf::cst)))
    (abnf::tree-listp abnf::csts))
  :rule-classes :rewrite)

Theorem: cst-simple-character-escape-conc4-rep-match

(defthm cst-simple-character-escape-conc4-rep-match
 (implies
   (and (cst-matchp abnf::cst "simple-character-escape")
        (equal (cst-simple-character-escape-conc? abnf::cst)
               4))
   (b*
    ((abnf::csts (cst-simple-character-escape-conc4-rep abnf::cst)))
    (cst-list-rep-matchp abnf::csts "line-feed-escape")))
 :rule-classes :rewrite)

Theorem: cst-simple-character-escape-conc4-rep-of-tree-fix-cst

(defthm cst-simple-character-escape-conc4-rep-of-tree-fix-cst
 (equal
  (cst-simple-character-escape-conc4-rep (abnf::tree-fix abnf::cst))
  (cst-simple-character-escape-conc4-rep abnf::cst)))

Theorem: cst-simple-character-escape-conc4-rep-tree-equiv-congruence-on-cst

(defthm
 cst-simple-character-escape-conc4-rep-tree-equiv-congruence-on-cst
 (implies (abnf::tree-equiv abnf::cst cst-equiv)
          (equal (cst-simple-character-escape-conc4-rep abnf::cst)
                 (cst-simple-character-escape-conc4-rep cst-equiv)))
 :rule-classes :congruence)

Function: cst-simple-character-escape-conc5-rep

(defun cst-simple-character-escape-conc5-rep (abnf::cst)
 (declare (xargs :guard (abnf::treep abnf::cst)))
 (declare
  (xargs
    :guard (and (cst-matchp abnf::cst "simple-character-escape")
                (equal (cst-simple-character-escape-conc? abnf::cst)
                       5))))
 (let ((__function__ 'cst-simple-character-escape-conc5-rep))
   (declare (ignorable __function__))
   (abnf::tree-list-fix
        (nth 0
             (cst-simple-character-escape-conc5 abnf::cst)))))

Theorem: tree-listp-of-cst-simple-character-escape-conc5-rep

(defthm tree-listp-of-cst-simple-character-escape-conc5-rep
  (b*
    ((abnf::csts (cst-simple-character-escape-conc5-rep abnf::cst)))
    (abnf::tree-listp abnf::csts))
  :rule-classes :rewrite)

Theorem: cst-simple-character-escape-conc5-rep-match

(defthm cst-simple-character-escape-conc5-rep-match
 (implies
   (and (cst-matchp abnf::cst "simple-character-escape")
        (equal (cst-simple-character-escape-conc? abnf::cst)
               5))
   (b*
    ((abnf::csts (cst-simple-character-escape-conc5-rep abnf::cst)))
    (cst-list-rep-matchp abnf::csts "carriage-return-escape")))
 :rule-classes :rewrite)

Theorem: cst-simple-character-escape-conc5-rep-of-tree-fix-cst

(defthm cst-simple-character-escape-conc5-rep-of-tree-fix-cst
 (equal
  (cst-simple-character-escape-conc5-rep (abnf::tree-fix abnf::cst))
  (cst-simple-character-escape-conc5-rep abnf::cst)))

Theorem: cst-simple-character-escape-conc5-rep-tree-equiv-congruence-on-cst

(defthm
 cst-simple-character-escape-conc5-rep-tree-equiv-congruence-on-cst
 (implies (abnf::tree-equiv abnf::cst cst-equiv)
          (equal (cst-simple-character-escape-conc5-rep abnf::cst)
                 (cst-simple-character-escape-conc5-rep cst-equiv)))
 :rule-classes :congruence)

Function: cst-simple-character-escape-conc6-rep

(defun cst-simple-character-escape-conc6-rep (abnf::cst)
 (declare (xargs :guard (abnf::treep abnf::cst)))
 (declare
  (xargs
    :guard (and (cst-matchp abnf::cst "simple-character-escape")
                (equal (cst-simple-character-escape-conc? abnf::cst)
                       6))))
 (let ((__function__ 'cst-simple-character-escape-conc6-rep))
   (declare (ignorable __function__))
   (abnf::tree-list-fix
        (nth 0
             (cst-simple-character-escape-conc6 abnf::cst)))))

Theorem: tree-listp-of-cst-simple-character-escape-conc6-rep

(defthm tree-listp-of-cst-simple-character-escape-conc6-rep
  (b*
    ((abnf::csts (cst-simple-character-escape-conc6-rep abnf::cst)))
    (abnf::tree-listp abnf::csts))
  :rule-classes :rewrite)

Theorem: cst-simple-character-escape-conc6-rep-match

(defthm cst-simple-character-escape-conc6-rep-match
 (implies
   (and (cst-matchp abnf::cst "simple-character-escape")
        (equal (cst-simple-character-escape-conc? abnf::cst)
               6))
   (b*
    ((abnf::csts (cst-simple-character-escape-conc6-rep abnf::cst)))
    (cst-list-rep-matchp abnf::csts "horizontal-tab-escape")))
 :rule-classes :rewrite)

Theorem: cst-simple-character-escape-conc6-rep-of-tree-fix-cst

(defthm cst-simple-character-escape-conc6-rep-of-tree-fix-cst
 (equal
  (cst-simple-character-escape-conc6-rep (abnf::tree-fix abnf::cst))
  (cst-simple-character-escape-conc6-rep abnf::cst)))

Theorem: cst-simple-character-escape-conc6-rep-tree-equiv-congruence-on-cst

(defthm
 cst-simple-character-escape-conc6-rep-tree-equiv-congruence-on-cst
 (implies (abnf::tree-equiv abnf::cst cst-equiv)
          (equal (cst-simple-character-escape-conc6-rep abnf::cst)
                 (cst-simple-character-escape-conc6-rep cst-equiv)))
 :rule-classes :congruence)

Function: cst-simple-character-escape-conc7-rep

(defun cst-simple-character-escape-conc7-rep (abnf::cst)
 (declare (xargs :guard (abnf::treep abnf::cst)))
 (declare
  (xargs
    :guard (and (cst-matchp abnf::cst "simple-character-escape")
                (equal (cst-simple-character-escape-conc? abnf::cst)
                       7))))
 (let ((__function__ 'cst-simple-character-escape-conc7-rep))
   (declare (ignorable __function__))
   (abnf::tree-list-fix
        (nth 0
             (cst-simple-character-escape-conc7 abnf::cst)))))

Theorem: tree-listp-of-cst-simple-character-escape-conc7-rep

(defthm tree-listp-of-cst-simple-character-escape-conc7-rep
  (b*
    ((abnf::csts (cst-simple-character-escape-conc7-rep abnf::cst)))
    (abnf::tree-listp abnf::csts))
  :rule-classes :rewrite)

Theorem: cst-simple-character-escape-conc7-rep-match

(defthm cst-simple-character-escape-conc7-rep-match
 (implies
   (and (cst-matchp abnf::cst "simple-character-escape")
        (equal (cst-simple-character-escape-conc? abnf::cst)
               7))
   (b*
    ((abnf::csts (cst-simple-character-escape-conc7-rep abnf::cst)))
    (cst-list-rep-matchp abnf::csts "null-character-escape")))
 :rule-classes :rewrite)

Theorem: cst-simple-character-escape-conc7-rep-of-tree-fix-cst

(defthm cst-simple-character-escape-conc7-rep-of-tree-fix-cst
 (equal
  (cst-simple-character-escape-conc7-rep (abnf::tree-fix abnf::cst))
  (cst-simple-character-escape-conc7-rep abnf::cst)))

Theorem: cst-simple-character-escape-conc7-rep-tree-equiv-congruence-on-cst

(defthm
 cst-simple-character-escape-conc7-rep-tree-equiv-congruence-on-cst
 (implies (abnf::tree-equiv abnf::cst cst-equiv)
          (equal (cst-simple-character-escape-conc7-rep abnf::cst)
                 (cst-simple-character-escape-conc7-rep cst-equiv)))
 :rule-classes :congruence)

Function: cst-string-literal-element-conc1-rep

(defun cst-string-literal-element-conc1-rep (abnf::cst)
 (declare (xargs :guard (abnf::treep abnf::cst)))
 (declare
  (xargs
     :guard (and (cst-matchp abnf::cst "string-literal-element")
                 (equal (cst-string-literal-element-conc? abnf::cst)
                        1))))
 (let ((__function__ 'cst-string-literal-element-conc1-rep))
   (declare (ignorable __function__))
   (abnf::tree-list-fix
        (nth 0
             (cst-string-literal-element-conc1 abnf::cst)))))

Theorem: tree-listp-of-cst-string-literal-element-conc1-rep

(defthm tree-listp-of-cst-string-literal-element-conc1-rep
 (b* ((abnf::csts (cst-string-literal-element-conc1-rep abnf::cst)))
   (abnf::tree-listp abnf::csts))
 :rule-classes :rewrite)

Theorem: cst-string-literal-element-conc1-rep-match

(defthm cst-string-literal-element-conc1-rep-match
 (implies
  (and (cst-matchp abnf::cst "string-literal-element")
       (equal (cst-string-literal-element-conc? abnf::cst)
              1))
  (b*
    ((abnf::csts (cst-string-literal-element-conc1-rep abnf::cst)))
   (cst-list-rep-matchp
    abnf::csts
    "not-double-quote-or-backslash-or-line-feed-or-carriage-return")))
 :rule-classes :rewrite)

Theorem: cst-string-literal-element-conc1-rep-of-tree-fix-cst

(defthm cst-string-literal-element-conc1-rep-of-tree-fix-cst
 (equal
   (cst-string-literal-element-conc1-rep (abnf::tree-fix abnf::cst))
   (cst-string-literal-element-conc1-rep abnf::cst)))

Theorem: cst-string-literal-element-conc1-rep-tree-equiv-congruence-on-cst

(defthm
  cst-string-literal-element-conc1-rep-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-string-literal-element-conc1-rep abnf::cst)
                  (cst-string-literal-element-conc1-rep cst-equiv)))
  :rule-classes :congruence)

Function: cst-string-literal-element-conc2-rep

(defun cst-string-literal-element-conc2-rep (abnf::cst)
 (declare (xargs :guard (abnf::treep abnf::cst)))
 (declare
  (xargs
     :guard (and (cst-matchp abnf::cst "string-literal-element")
                 (equal (cst-string-literal-element-conc? abnf::cst)
                        2))))
 (let ((__function__ 'cst-string-literal-element-conc2-rep))
   (declare (ignorable __function__))
   (abnf::tree-list-fix
        (nth 0
             (cst-string-literal-element-conc2 abnf::cst)))))

Theorem: tree-listp-of-cst-string-literal-element-conc2-rep

(defthm tree-listp-of-cst-string-literal-element-conc2-rep
 (b* ((abnf::csts (cst-string-literal-element-conc2-rep abnf::cst)))
   (abnf::tree-listp abnf::csts))
 :rule-classes :rewrite)

Theorem: cst-string-literal-element-conc2-rep-match

(defthm cst-string-literal-element-conc2-rep-match
 (implies
   (and (cst-matchp abnf::cst "string-literal-element")
        (equal (cst-string-literal-element-conc? abnf::cst)
               2))
   (b*
     ((abnf::csts (cst-string-literal-element-conc2-rep abnf::cst)))
     (cst-list-rep-matchp abnf::csts "simple-character-escape")))
 :rule-classes :rewrite)

Theorem: cst-string-literal-element-conc2-rep-of-tree-fix-cst

(defthm cst-string-literal-element-conc2-rep-of-tree-fix-cst
 (equal
   (cst-string-literal-element-conc2-rep (abnf::tree-fix abnf::cst))
   (cst-string-literal-element-conc2-rep abnf::cst)))

Theorem: cst-string-literal-element-conc2-rep-tree-equiv-congruence-on-cst

(defthm
  cst-string-literal-element-conc2-rep-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-string-literal-element-conc2-rep abnf::cst)
                  (cst-string-literal-element-conc2-rep cst-equiv)))
  :rule-classes :congruence)

Function: cst-string-literal-element-conc3-rep

(defun cst-string-literal-element-conc3-rep (abnf::cst)
 (declare (xargs :guard (abnf::treep abnf::cst)))
 (declare
  (xargs
     :guard (and (cst-matchp abnf::cst "string-literal-element")
                 (equal (cst-string-literal-element-conc? abnf::cst)
                        3))))
 (let ((__function__ 'cst-string-literal-element-conc3-rep))
   (declare (ignorable __function__))
   (abnf::tree-list-fix
        (nth 0
             (cst-string-literal-element-conc3 abnf::cst)))))

Theorem: tree-listp-of-cst-string-literal-element-conc3-rep

(defthm tree-listp-of-cst-string-literal-element-conc3-rep
 (b* ((abnf::csts (cst-string-literal-element-conc3-rep abnf::cst)))
   (abnf::tree-listp abnf::csts))
 :rule-classes :rewrite)

Theorem: cst-string-literal-element-conc3-rep-match

(defthm cst-string-literal-element-conc3-rep-match
 (implies
   (and (cst-matchp abnf::cst "string-literal-element")
        (equal (cst-string-literal-element-conc? abnf::cst)
               3))
   (b*
     ((abnf::csts (cst-string-literal-element-conc3-rep abnf::cst)))
     (cst-list-rep-matchp abnf::csts "ascii-character-escape")))
 :rule-classes :rewrite)

Theorem: cst-string-literal-element-conc3-rep-of-tree-fix-cst

(defthm cst-string-literal-element-conc3-rep-of-tree-fix-cst
 (equal
   (cst-string-literal-element-conc3-rep (abnf::tree-fix abnf::cst))
   (cst-string-literal-element-conc3-rep abnf::cst)))

Theorem: cst-string-literal-element-conc3-rep-tree-equiv-congruence-on-cst

(defthm
  cst-string-literal-element-conc3-rep-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-string-literal-element-conc3-rep abnf::cst)
                  (cst-string-literal-element-conc3-rep cst-equiv)))
  :rule-classes :congruence)

Function: cst-string-literal-element-conc4-rep

(defun cst-string-literal-element-conc4-rep (abnf::cst)
 (declare (xargs :guard (abnf::treep abnf::cst)))
 (declare
  (xargs
     :guard (and (cst-matchp abnf::cst "string-literal-element")
                 (equal (cst-string-literal-element-conc? abnf::cst)
                        4))))
 (let ((__function__ 'cst-string-literal-element-conc4-rep))
   (declare (ignorable __function__))
   (abnf::tree-list-fix
        (nth 0
             (cst-string-literal-element-conc4 abnf::cst)))))

Theorem: tree-listp-of-cst-string-literal-element-conc4-rep

(defthm tree-listp-of-cst-string-literal-element-conc4-rep
 (b* ((abnf::csts (cst-string-literal-element-conc4-rep abnf::cst)))
   (abnf::tree-listp abnf::csts))
 :rule-classes :rewrite)

Theorem: cst-string-literal-element-conc4-rep-match

(defthm cst-string-literal-element-conc4-rep-match
 (implies
   (and (cst-matchp abnf::cst "string-literal-element")
        (equal (cst-string-literal-element-conc? abnf::cst)
               4))
   (b*
     ((abnf::csts (cst-string-literal-element-conc4-rep abnf::cst)))
     (cst-list-rep-matchp abnf::csts "unicode-character-escape")))
 :rule-classes :rewrite)

Theorem: cst-string-literal-element-conc4-rep-of-tree-fix-cst

(defthm cst-string-literal-element-conc4-rep-of-tree-fix-cst
 (equal
   (cst-string-literal-element-conc4-rep (abnf::tree-fix abnf::cst))
   (cst-string-literal-element-conc4-rep abnf::cst)))

Theorem: cst-string-literal-element-conc4-rep-tree-equiv-congruence-on-cst

(defthm
  cst-string-literal-element-conc4-rep-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-string-literal-element-conc4-rep abnf::cst)
                  (cst-string-literal-element-conc4-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 "unsigned-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 "signed-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-numeric-literal-conc1-rep

(defun cst-numeric-literal-conc1-rep (abnf::cst)
 (declare (xargs :guard (abnf::treep abnf::cst)))
 (declare
     (xargs :guard (and (cst-matchp abnf::cst "numeric-literal")
                        (equal (cst-numeric-literal-conc? abnf::cst)
                               1))))
 (let ((__function__ 'cst-numeric-literal-conc1-rep))
   (declare (ignorable __function__))
   (abnf::tree-list-fix
        (nth 0
             (cst-numeric-literal-conc1 abnf::cst)))))

Theorem: tree-listp-of-cst-numeric-literal-conc1-rep

(defthm tree-listp-of-cst-numeric-literal-conc1-rep
  (b* ((abnf::csts (cst-numeric-literal-conc1-rep abnf::cst)))
    (abnf::tree-listp abnf::csts))
  :rule-classes :rewrite)

Theorem: cst-numeric-literal-conc1-rep-match

(defthm cst-numeric-literal-conc1-rep-match
  (implies
       (and (cst-matchp abnf::cst "numeric-literal")
            (equal (cst-numeric-literal-conc? abnf::cst)
                   1))
       (b* ((abnf::csts (cst-numeric-literal-conc1-rep abnf::cst)))
         (cst-list-rep-matchp abnf::csts "integer-literal")))
  :rule-classes :rewrite)

Theorem: cst-numeric-literal-conc1-rep-of-tree-fix-cst

(defthm cst-numeric-literal-conc1-rep-of-tree-fix-cst
  (equal (cst-numeric-literal-conc1-rep (abnf::tree-fix abnf::cst))
         (cst-numeric-literal-conc1-rep abnf::cst)))

Theorem: cst-numeric-literal-conc1-rep-tree-equiv-congruence-on-cst

(defthm cst-numeric-literal-conc1-rep-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-numeric-literal-conc1-rep abnf::cst)
                  (cst-numeric-literal-conc1-rep cst-equiv)))
  :rule-classes :congruence)

Function: cst-numeric-literal-conc2-rep

(defun cst-numeric-literal-conc2-rep (abnf::cst)
 (declare (xargs :guard (abnf::treep abnf::cst)))
 (declare
     (xargs :guard (and (cst-matchp abnf::cst "numeric-literal")
                        (equal (cst-numeric-literal-conc? abnf::cst)
                               2))))
 (let ((__function__ 'cst-numeric-literal-conc2-rep))
   (declare (ignorable __function__))
   (abnf::tree-list-fix
        (nth 0
             (cst-numeric-literal-conc2 abnf::cst)))))

Theorem: tree-listp-of-cst-numeric-literal-conc2-rep

(defthm tree-listp-of-cst-numeric-literal-conc2-rep
  (b* ((abnf::csts (cst-numeric-literal-conc2-rep abnf::cst)))
    (abnf::tree-listp abnf::csts))
  :rule-classes :rewrite)

Theorem: cst-numeric-literal-conc2-rep-match

(defthm cst-numeric-literal-conc2-rep-match
  (implies
       (and (cst-matchp abnf::cst "numeric-literal")
            (equal (cst-numeric-literal-conc? abnf::cst)
                   2))
       (b* ((abnf::csts (cst-numeric-literal-conc2-rep abnf::cst)))
         (cst-list-rep-matchp abnf::csts "field-literal")))
  :rule-classes :rewrite)

Theorem: cst-numeric-literal-conc2-rep-of-tree-fix-cst

(defthm cst-numeric-literal-conc2-rep-of-tree-fix-cst
  (equal (cst-numeric-literal-conc2-rep (abnf::tree-fix abnf::cst))
         (cst-numeric-literal-conc2-rep abnf::cst)))

Theorem: cst-numeric-literal-conc2-rep-tree-equiv-congruence-on-cst

(defthm cst-numeric-literal-conc2-rep-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-numeric-literal-conc2-rep abnf::cst)
                  (cst-numeric-literal-conc2-rep cst-equiv)))
  :rule-classes :congruence)

Function: cst-numeric-literal-conc3-rep

(defun cst-numeric-literal-conc3-rep (abnf::cst)
 (declare (xargs :guard (abnf::treep abnf::cst)))
 (declare
     (xargs :guard (and (cst-matchp abnf::cst "numeric-literal")
                        (equal (cst-numeric-literal-conc? abnf::cst)
                               3))))
 (let ((__function__ 'cst-numeric-literal-conc3-rep))
   (declare (ignorable __function__))
   (abnf::tree-list-fix
        (nth 0
             (cst-numeric-literal-conc3 abnf::cst)))))

Theorem: tree-listp-of-cst-numeric-literal-conc3-rep

(defthm tree-listp-of-cst-numeric-literal-conc3-rep
  (b* ((abnf::csts (cst-numeric-literal-conc3-rep abnf::cst)))
    (abnf::tree-listp abnf::csts))
  :rule-classes :rewrite)

Theorem: cst-numeric-literal-conc3-rep-match

(defthm cst-numeric-literal-conc3-rep-match
  (implies
       (and (cst-matchp abnf::cst "numeric-literal")
            (equal (cst-numeric-literal-conc? abnf::cst)
                   3))
       (b* ((abnf::csts (cst-numeric-literal-conc3-rep abnf::cst)))
         (cst-list-rep-matchp abnf::csts "product-group-literal")))
  :rule-classes :rewrite)

Theorem: cst-numeric-literal-conc3-rep-of-tree-fix-cst

(defthm cst-numeric-literal-conc3-rep-of-tree-fix-cst
  (equal (cst-numeric-literal-conc3-rep (abnf::tree-fix abnf::cst))
         (cst-numeric-literal-conc3-rep abnf::cst)))

Theorem: cst-numeric-literal-conc3-rep-tree-equiv-congruence-on-cst

(defthm cst-numeric-literal-conc3-rep-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-numeric-literal-conc3-rep abnf::cst)
                  (cst-numeric-literal-conc3-rep cst-equiv)))
  :rule-classes :congruence)

Function: cst-numeric-literal-conc4-rep

(defun cst-numeric-literal-conc4-rep (abnf::cst)
 (declare (xargs :guard (abnf::treep abnf::cst)))
 (declare
     (xargs :guard (and (cst-matchp abnf::cst "numeric-literal")
                        (equal (cst-numeric-literal-conc? abnf::cst)
                               4))))
 (let ((__function__ 'cst-numeric-literal-conc4-rep))
   (declare (ignorable __function__))
   (abnf::tree-list-fix
        (nth 0
             (cst-numeric-literal-conc4 abnf::cst)))))

Theorem: tree-listp-of-cst-numeric-literal-conc4-rep

(defthm tree-listp-of-cst-numeric-literal-conc4-rep
  (b* ((abnf::csts (cst-numeric-literal-conc4-rep abnf::cst)))
    (abnf::tree-listp abnf::csts))
  :rule-classes :rewrite)

Theorem: cst-numeric-literal-conc4-rep-match

(defthm cst-numeric-literal-conc4-rep-match
  (implies
       (and (cst-matchp abnf::cst "numeric-literal")
            (equal (cst-numeric-literal-conc? abnf::cst)
                   4))
       (b* ((abnf::csts (cst-numeric-literal-conc4-rep abnf::cst)))
         (cst-list-rep-matchp abnf::csts "scalar-literal")))
  :rule-classes :rewrite)

Theorem: cst-numeric-literal-conc4-rep-of-tree-fix-cst

(defthm cst-numeric-literal-conc4-rep-of-tree-fix-cst
  (equal (cst-numeric-literal-conc4-rep (abnf::tree-fix abnf::cst))
         (cst-numeric-literal-conc4-rep abnf::cst)))

Theorem: cst-numeric-literal-conc4-rep-tree-equiv-congruence-on-cst

(defthm cst-numeric-literal-conc4-rep-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-numeric-literal-conc4-rep abnf::cst)
                  (cst-numeric-literal-conc4-rep cst-equiv)))
  :rule-classes :congruence)

Function: cst-atomic-literal-conc1-rep

(defun cst-atomic-literal-conc1-rep (abnf::cst)
 (declare (xargs :guard (abnf::treep abnf::cst)))
 (declare
      (xargs :guard (and (cst-matchp abnf::cst "atomic-literal")
                         (equal (cst-atomic-literal-conc? abnf::cst)
                                1))))
 (let ((__function__ 'cst-atomic-literal-conc1-rep))
  (declare (ignorable __function__))
  (abnf::tree-list-fix (nth 0
                            (cst-atomic-literal-conc1 abnf::cst)))))

Theorem: tree-listp-of-cst-atomic-literal-conc1-rep

(defthm tree-listp-of-cst-atomic-literal-conc1-rep
  (b* ((abnf::csts (cst-atomic-literal-conc1-rep abnf::cst)))
    (abnf::tree-listp abnf::csts))
  :rule-classes :rewrite)

Theorem: cst-atomic-literal-conc1-rep-match

(defthm cst-atomic-literal-conc1-rep-match
  (implies
       (and (cst-matchp abnf::cst "atomic-literal")
            (equal (cst-atomic-literal-conc? abnf::cst)
                   1))
       (b* ((abnf::csts (cst-atomic-literal-conc1-rep abnf::cst)))
         (cst-list-rep-matchp abnf::csts "numeric-literal")))
  :rule-classes :rewrite)

Theorem: cst-atomic-literal-conc1-rep-of-tree-fix-cst

(defthm cst-atomic-literal-conc1-rep-of-tree-fix-cst
  (equal (cst-atomic-literal-conc1-rep (abnf::tree-fix abnf::cst))
         (cst-atomic-literal-conc1-rep abnf::cst)))

Theorem: cst-atomic-literal-conc1-rep-tree-equiv-congruence-on-cst

(defthm cst-atomic-literal-conc1-rep-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-atomic-literal-conc1-rep abnf::cst)
                  (cst-atomic-literal-conc1-rep cst-equiv)))
  :rule-classes :congruence)

Function: cst-atomic-literal-conc2-rep

(defun cst-atomic-literal-conc2-rep (abnf::cst)
 (declare (xargs :guard (abnf::treep abnf::cst)))
 (declare
      (xargs :guard (and (cst-matchp abnf::cst "atomic-literal")
                         (equal (cst-atomic-literal-conc? abnf::cst)
                                2))))
 (let ((__function__ 'cst-atomic-literal-conc2-rep))
  (declare (ignorable __function__))
  (abnf::tree-list-fix (nth 0
                            (cst-atomic-literal-conc2 abnf::cst)))))

Theorem: tree-listp-of-cst-atomic-literal-conc2-rep

(defthm tree-listp-of-cst-atomic-literal-conc2-rep
  (b* ((abnf::csts (cst-atomic-literal-conc2-rep abnf::cst)))
    (abnf::tree-listp abnf::csts))
  :rule-classes :rewrite)

Theorem: cst-atomic-literal-conc2-rep-match

(defthm cst-atomic-literal-conc2-rep-match
  (implies
       (and (cst-matchp abnf::cst "atomic-literal")
            (equal (cst-atomic-literal-conc? abnf::cst)
                   2))
       (b* ((abnf::csts (cst-atomic-literal-conc2-rep abnf::cst)))
         (cst-list-rep-matchp abnf::csts "boolean-literal")))
  :rule-classes :rewrite)

Theorem: cst-atomic-literal-conc2-rep-of-tree-fix-cst

(defthm cst-atomic-literal-conc2-rep-of-tree-fix-cst
  (equal (cst-atomic-literal-conc2-rep (abnf::tree-fix abnf::cst))
         (cst-atomic-literal-conc2-rep abnf::cst)))

Theorem: cst-atomic-literal-conc2-rep-tree-equiv-congruence-on-cst

(defthm cst-atomic-literal-conc2-rep-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-atomic-literal-conc2-rep abnf::cst)
                  (cst-atomic-literal-conc2-rep cst-equiv)))
  :rule-classes :congruence)

Function: cst-atomic-literal-conc3-rep

(defun cst-atomic-literal-conc3-rep (abnf::cst)
 (declare (xargs :guard (abnf::treep abnf::cst)))
 (declare
      (xargs :guard (and (cst-matchp abnf::cst "atomic-literal")
                         (equal (cst-atomic-literal-conc? abnf::cst)
                                3))))
 (let ((__function__ 'cst-atomic-literal-conc3-rep))
  (declare (ignorable __function__))
  (abnf::tree-list-fix (nth 0
                            (cst-atomic-literal-conc3 abnf::cst)))))

Theorem: tree-listp-of-cst-atomic-literal-conc3-rep

(defthm tree-listp-of-cst-atomic-literal-conc3-rep
  (b* ((abnf::csts (cst-atomic-literal-conc3-rep abnf::cst)))
    (abnf::tree-listp abnf::csts))
  :rule-classes :rewrite)

Theorem: cst-atomic-literal-conc3-rep-match

(defthm cst-atomic-literal-conc3-rep-match
  (implies
       (and (cst-matchp abnf::cst "atomic-literal")
            (equal (cst-atomic-literal-conc? abnf::cst)
                   3))
       (b* ((abnf::csts (cst-atomic-literal-conc3-rep abnf::cst)))
         (cst-list-rep-matchp abnf::csts "address-literal")))
  :rule-classes :rewrite)

Theorem: cst-atomic-literal-conc3-rep-of-tree-fix-cst

(defthm cst-atomic-literal-conc3-rep-of-tree-fix-cst
  (equal (cst-atomic-literal-conc3-rep (abnf::tree-fix abnf::cst))
         (cst-atomic-literal-conc3-rep abnf::cst)))

Theorem: cst-atomic-literal-conc3-rep-tree-equiv-congruence-on-cst

(defthm cst-atomic-literal-conc3-rep-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-atomic-literal-conc3-rep abnf::cst)
                  (cst-atomic-literal-conc3-rep cst-equiv)))
  :rule-classes :congruence)

Function: cst-atomic-literal-conc4-rep

(defun cst-atomic-literal-conc4-rep (abnf::cst)
 (declare (xargs :guard (abnf::treep abnf::cst)))
 (declare
      (xargs :guard (and (cst-matchp abnf::cst "atomic-literal")
                         (equal (cst-atomic-literal-conc? abnf::cst)
                                4))))
 (let ((__function__ 'cst-atomic-literal-conc4-rep))
  (declare (ignorable __function__))
  (abnf::tree-list-fix (nth 0
                            (cst-atomic-literal-conc4 abnf::cst)))))

Theorem: tree-listp-of-cst-atomic-literal-conc4-rep

(defthm tree-listp-of-cst-atomic-literal-conc4-rep
  (b* ((abnf::csts (cst-atomic-literal-conc4-rep abnf::cst)))
    (abnf::tree-listp abnf::csts))
  :rule-classes :rewrite)

Theorem: cst-atomic-literal-conc4-rep-match

(defthm cst-atomic-literal-conc4-rep-match
  (implies
       (and (cst-matchp abnf::cst "atomic-literal")
            (equal (cst-atomic-literal-conc? abnf::cst)
                   4))
       (b* ((abnf::csts (cst-atomic-literal-conc4-rep abnf::cst)))
         (cst-list-rep-matchp abnf::csts "string-literal")))
  :rule-classes :rewrite)

Theorem: cst-atomic-literal-conc4-rep-of-tree-fix-cst

(defthm cst-atomic-literal-conc4-rep-of-tree-fix-cst
  (equal (cst-atomic-literal-conc4-rep (abnf::tree-fix abnf::cst))
         (cst-atomic-literal-conc4-rep abnf::cst)))

Theorem: cst-atomic-literal-conc4-rep-tree-equiv-congruence-on-cst

(defthm cst-atomic-literal-conc4-rep-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-atomic-literal-conc4-rep abnf::cst)
                  (cst-atomic-literal-conc4-rep cst-equiv)))
  :rule-classes :congruence)

Function: cst-token-conc1-rep

(defun cst-token-conc1-rep (abnf::cst)
  (declare (xargs :guard (abnf::treep abnf::cst)))
  (declare
       (xargs :guard (and (cst-matchp abnf::cst "token")
                          (equal (cst-token-conc? abnf::cst) 1))))
  (let ((__function__ 'cst-token-conc1-rep))
    (declare (ignorable __function__))
    (abnf::tree-list-fix (nth 0 (cst-token-conc1 abnf::cst)))))

Theorem: tree-listp-of-cst-token-conc1-rep

(defthm tree-listp-of-cst-token-conc1-rep
  (b* ((abnf::csts (cst-token-conc1-rep abnf::cst)))
    (abnf::tree-listp abnf::csts))
  :rule-classes :rewrite)

Theorem: cst-token-conc1-rep-match

(defthm cst-token-conc1-rep-match
  (implies (and (cst-matchp abnf::cst "token")
                (equal (cst-token-conc? abnf::cst) 1))
           (b* ((abnf::csts (cst-token-conc1-rep abnf::cst)))
             (cst-list-rep-matchp abnf::csts "keyword")))
  :rule-classes :rewrite)

Theorem: cst-token-conc1-rep-of-tree-fix-cst

(defthm cst-token-conc1-rep-of-tree-fix-cst
  (equal (cst-token-conc1-rep (abnf::tree-fix abnf::cst))
         (cst-token-conc1-rep abnf::cst)))

Theorem: cst-token-conc1-rep-tree-equiv-congruence-on-cst

(defthm cst-token-conc1-rep-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-token-conc1-rep abnf::cst)
                  (cst-token-conc1-rep cst-equiv)))
  :rule-classes :congruence)

Function: cst-token-conc2-rep

(defun cst-token-conc2-rep (abnf::cst)
  (declare (xargs :guard (abnf::treep abnf::cst)))
  (declare
       (xargs :guard (and (cst-matchp abnf::cst "token")
                          (equal (cst-token-conc? abnf::cst) 2))))
  (let ((__function__ 'cst-token-conc2-rep))
    (declare (ignorable __function__))
    (abnf::tree-list-fix (nth 0 (cst-token-conc2 abnf::cst)))))

Theorem: tree-listp-of-cst-token-conc2-rep

(defthm tree-listp-of-cst-token-conc2-rep
  (b* ((abnf::csts (cst-token-conc2-rep abnf::cst)))
    (abnf::tree-listp abnf::csts))
  :rule-classes :rewrite)

Theorem: cst-token-conc2-rep-match

(defthm cst-token-conc2-rep-match
  (implies (and (cst-matchp abnf::cst "token")
                (equal (cst-token-conc? abnf::cst) 2))
           (b* ((abnf::csts (cst-token-conc2-rep abnf::cst)))
             (cst-list-rep-matchp abnf::csts "identifier")))
  :rule-classes :rewrite)

Theorem: cst-token-conc2-rep-of-tree-fix-cst

(defthm cst-token-conc2-rep-of-tree-fix-cst
  (equal (cst-token-conc2-rep (abnf::tree-fix abnf::cst))
         (cst-token-conc2-rep abnf::cst)))

Theorem: cst-token-conc2-rep-tree-equiv-congruence-on-cst

(defthm cst-token-conc2-rep-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-token-conc2-rep abnf::cst)
                  (cst-token-conc2-rep cst-equiv)))
  :rule-classes :congruence)

Function: cst-token-conc3-rep

(defun cst-token-conc3-rep (abnf::cst)
  (declare (xargs :guard (abnf::treep abnf::cst)))
  (declare
       (xargs :guard (and (cst-matchp abnf::cst "token")
                          (equal (cst-token-conc? abnf::cst) 3))))
  (let ((__function__ 'cst-token-conc3-rep))
    (declare (ignorable __function__))
    (abnf::tree-list-fix (nth 0 (cst-token-conc3 abnf::cst)))))

Theorem: tree-listp-of-cst-token-conc3-rep

(defthm tree-listp-of-cst-token-conc3-rep
  (b* ((abnf::csts (cst-token-conc3-rep abnf::cst)))
    (abnf::tree-listp abnf::csts))
  :rule-classes :rewrite)

Theorem: cst-token-conc3-rep-match

(defthm cst-token-conc3-rep-match
  (implies (and (cst-matchp abnf::cst "token")
                (equal (cst-token-conc? abnf::cst) 3))
           (b* ((abnf::csts (cst-token-conc3-rep abnf::cst)))
             (cst-list-rep-matchp abnf::csts "atomic-literal")))
  :rule-classes :rewrite)

Theorem: cst-token-conc3-rep-of-tree-fix-cst

(defthm cst-token-conc3-rep-of-tree-fix-cst
  (equal (cst-token-conc3-rep (abnf::tree-fix abnf::cst))
         (cst-token-conc3-rep abnf::cst)))

Theorem: cst-token-conc3-rep-tree-equiv-congruence-on-cst

(defthm cst-token-conc3-rep-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-token-conc3-rep abnf::cst)
                  (cst-token-conc3-rep cst-equiv)))
  :rule-classes :congruence)

Function: cst-token-conc4-rep

(defun cst-token-conc4-rep (abnf::cst)
  (declare (xargs :guard (abnf::treep abnf::cst)))
  (declare
       (xargs :guard (and (cst-matchp abnf::cst "token")
                          (equal (cst-token-conc? abnf::cst) 4))))
  (let ((__function__ 'cst-token-conc4-rep))
    (declare (ignorable __function__))
    (abnf::tree-list-fix (nth 0 (cst-token-conc4 abnf::cst)))))

Theorem: tree-listp-of-cst-token-conc4-rep

(defthm tree-listp-of-cst-token-conc4-rep
  (b* ((abnf::csts (cst-token-conc4-rep abnf::cst)))
    (abnf::tree-listp abnf::csts))
  :rule-classes :rewrite)

Theorem: cst-token-conc4-rep-match

(defthm cst-token-conc4-rep-match
  (implies (and (cst-matchp abnf::cst "token")
                (equal (cst-token-conc? abnf::cst) 4))
           (b* ((abnf::csts (cst-token-conc4-rep abnf::cst)))
             (cst-list-rep-matchp abnf::csts "numeral")))
  :rule-classes :rewrite)

Theorem: cst-token-conc4-rep-of-tree-fix-cst

(defthm cst-token-conc4-rep-of-tree-fix-cst
  (equal (cst-token-conc4-rep (abnf::tree-fix abnf::cst))
         (cst-token-conc4-rep abnf::cst)))

Theorem: cst-token-conc4-rep-tree-equiv-congruence-on-cst

(defthm cst-token-conc4-rep-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-token-conc4-rep abnf::cst)
                  (cst-token-conc4-rep cst-equiv)))
  :rule-classes :congruence)

Function: cst-token-conc5-rep

(defun cst-token-conc5-rep (abnf::cst)
  (declare (xargs :guard (abnf::treep abnf::cst)))
  (declare
       (xargs :guard (and (cst-matchp abnf::cst "token")
                          (equal (cst-token-conc? abnf::cst) 5))))
  (let ((__function__ 'cst-token-conc5-rep))
    (declare (ignorable __function__))
    (abnf::tree-list-fix (nth 0 (cst-token-conc5 abnf::cst)))))

Theorem: tree-listp-of-cst-token-conc5-rep

(defthm tree-listp-of-cst-token-conc5-rep
  (b* ((abnf::csts (cst-token-conc5-rep abnf::cst)))
    (abnf::tree-listp abnf::csts))
  :rule-classes :rewrite)

Theorem: cst-token-conc5-rep-match

(defthm cst-token-conc5-rep-match
  (implies (and (cst-matchp abnf::cst "token")
                (equal (cst-token-conc? abnf::cst) 5))
           (b* ((abnf::csts (cst-token-conc5-rep abnf::cst)))
             (cst-list-rep-matchp abnf::csts "annotation")))
  :rule-classes :rewrite)

Theorem: cst-token-conc5-rep-of-tree-fix-cst

(defthm cst-token-conc5-rep-of-tree-fix-cst
  (equal (cst-token-conc5-rep (abnf::tree-fix abnf::cst))
         (cst-token-conc5-rep abnf::cst)))

Theorem: cst-token-conc5-rep-tree-equiv-congruence-on-cst

(defthm cst-token-conc5-rep-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-token-conc5-rep abnf::cst)
                  (cst-token-conc5-rep cst-equiv)))
  :rule-classes :congruence)

Function: cst-token-conc6-rep

(defun cst-token-conc6-rep (abnf::cst)
  (declare (xargs :guard (abnf::treep abnf::cst)))
  (declare
       (xargs :guard (and (cst-matchp abnf::cst "token")
                          (equal (cst-token-conc? abnf::cst) 6))))
  (let ((__function__ 'cst-token-conc6-rep))
    (declare (ignorable __function__))
    (abnf::tree-list-fix (nth 0 (cst-token-conc6 abnf::cst)))))

Theorem: tree-listp-of-cst-token-conc6-rep

(defthm tree-listp-of-cst-token-conc6-rep
  (b* ((abnf::csts (cst-token-conc6-rep abnf::cst)))
    (abnf::tree-listp abnf::csts))
  :rule-classes :rewrite)

Theorem: cst-token-conc6-rep-match

(defthm cst-token-conc6-rep-match
  (implies (and (cst-matchp abnf::cst "token")
                (equal (cst-token-conc? abnf::cst) 6))
           (b* ((abnf::csts (cst-token-conc6-rep abnf::cst)))
             (cst-list-rep-matchp abnf::csts "symbol")))
  :rule-classes :rewrite)

Theorem: cst-token-conc6-rep-of-tree-fix-cst

(defthm cst-token-conc6-rep-of-tree-fix-cst
  (equal (cst-token-conc6-rep (abnf::tree-fix abnf::cst))
         (cst-token-conc6-rep abnf::cst)))

Theorem: cst-token-conc6-rep-tree-equiv-congruence-on-cst

(defthm cst-token-conc6-rep-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-token-conc6-rep abnf::cst)
                  (cst-token-conc6-rep cst-equiv)))
  :rule-classes :congruence)

Function: cst-lexeme-conc1-rep

(defun cst-lexeme-conc1-rep (abnf::cst)
  (declare (xargs :guard (abnf::treep abnf::cst)))
  (declare (xargs :guard (and (cst-matchp abnf::cst "lexeme")
                              (equal (cst-lexeme-conc? abnf::cst)
                                     1))))
  (let ((__function__ 'cst-lexeme-conc1-rep))
    (declare (ignorable __function__))
    (abnf::tree-list-fix (nth 0 (cst-lexeme-conc1 abnf::cst)))))

Theorem: tree-listp-of-cst-lexeme-conc1-rep

(defthm tree-listp-of-cst-lexeme-conc1-rep
  (b* ((abnf::csts (cst-lexeme-conc1-rep abnf::cst)))
    (abnf::tree-listp abnf::csts))
  :rule-classes :rewrite)

Theorem: cst-lexeme-conc1-rep-match

(defthm cst-lexeme-conc1-rep-match
  (implies (and (cst-matchp abnf::cst "lexeme")
                (equal (cst-lexeme-conc? abnf::cst) 1))
           (b* ((abnf::csts (cst-lexeme-conc1-rep abnf::cst)))
             (cst-list-rep-matchp abnf::csts "token")))
  :rule-classes :rewrite)

Theorem: cst-lexeme-conc1-rep-of-tree-fix-cst

(defthm cst-lexeme-conc1-rep-of-tree-fix-cst
  (equal (cst-lexeme-conc1-rep (abnf::tree-fix abnf::cst))
         (cst-lexeme-conc1-rep abnf::cst)))

Theorem: cst-lexeme-conc1-rep-tree-equiv-congruence-on-cst

(defthm cst-lexeme-conc1-rep-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-lexeme-conc1-rep abnf::cst)
                  (cst-lexeme-conc1-rep cst-equiv)))
  :rule-classes :congruence)

Function: cst-lexeme-conc2-rep

(defun cst-lexeme-conc2-rep (abnf::cst)
  (declare (xargs :guard (abnf::treep abnf::cst)))
  (declare (xargs :guard (and (cst-matchp abnf::cst "lexeme")
                              (equal (cst-lexeme-conc? abnf::cst)
                                     2))))
  (let ((__function__ 'cst-lexeme-conc2-rep))
    (declare (ignorable __function__))
    (abnf::tree-list-fix (nth 0 (cst-lexeme-conc2 abnf::cst)))))

Theorem: tree-listp-of-cst-lexeme-conc2-rep

(defthm tree-listp-of-cst-lexeme-conc2-rep
  (b* ((abnf::csts (cst-lexeme-conc2-rep abnf::cst)))
    (abnf::tree-listp abnf::csts))
  :rule-classes :rewrite)

Theorem: cst-lexeme-conc2-rep-match

(defthm cst-lexeme-conc2-rep-match
  (implies (and (cst-matchp abnf::cst "lexeme")
                (equal (cst-lexeme-conc? abnf::cst) 2))
           (b* ((abnf::csts (cst-lexeme-conc2-rep abnf::cst)))
             (cst-list-rep-matchp abnf::csts "comment")))
  :rule-classes :rewrite)

Theorem: cst-lexeme-conc2-rep-of-tree-fix-cst

(defthm cst-lexeme-conc2-rep-of-tree-fix-cst
  (equal (cst-lexeme-conc2-rep (abnf::tree-fix abnf::cst))
         (cst-lexeme-conc2-rep abnf::cst)))

Theorem: cst-lexeme-conc2-rep-tree-equiv-congruence-on-cst

(defthm cst-lexeme-conc2-rep-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-lexeme-conc2-rep abnf::cst)
                  (cst-lexeme-conc2-rep cst-equiv)))
  :rule-classes :congruence)

Function: cst-lexeme-conc3-rep

(defun cst-lexeme-conc3-rep (abnf::cst)
  (declare (xargs :guard (abnf::treep abnf::cst)))
  (declare (xargs :guard (and (cst-matchp abnf::cst "lexeme")
                              (equal (cst-lexeme-conc? abnf::cst)
                                     3))))
  (let ((__function__ 'cst-lexeme-conc3-rep))
    (declare (ignorable __function__))
    (abnf::tree-list-fix (nth 0 (cst-lexeme-conc3 abnf::cst)))))

Theorem: tree-listp-of-cst-lexeme-conc3-rep

(defthm tree-listp-of-cst-lexeme-conc3-rep
  (b* ((abnf::csts (cst-lexeme-conc3-rep abnf::cst)))
    (abnf::tree-listp abnf::csts))
  :rule-classes :rewrite)

Theorem: cst-lexeme-conc3-rep-match

(defthm cst-lexeme-conc3-rep-match
  (implies (and (cst-matchp abnf::cst "lexeme")
                (equal (cst-lexeme-conc? abnf::cst) 3))
           (b* ((abnf::csts (cst-lexeme-conc3-rep abnf::cst)))
             (cst-list-rep-matchp abnf::csts "whitespace")))
  :rule-classes :rewrite)

Theorem: cst-lexeme-conc3-rep-of-tree-fix-cst

(defthm cst-lexeme-conc3-rep-of-tree-fix-cst
  (equal (cst-lexeme-conc3-rep (abnf::tree-fix abnf::cst))
         (cst-lexeme-conc3-rep abnf::cst)))

Theorem: cst-lexeme-conc3-rep-tree-equiv-congruence-on-cst

(defthm cst-lexeme-conc3-rep-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-lexeme-conc3-rep abnf::cst)
                  (cst-lexeme-conc3-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-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\"bool\"")))
  :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-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-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-named-primitive-type-conc1-rep

(defun cst-named-primitive-type-conc1-rep (abnf::cst)
 (declare (xargs :guard (abnf::treep abnf::cst)))
 (declare
  (xargs
       :guard (and (cst-matchp abnf::cst "named-primitive-type")
                   (equal (cst-named-primitive-type-conc? abnf::cst)
                          1))))
 (let ((__function__ 'cst-named-primitive-type-conc1-rep))
   (declare (ignorable __function__))
   (abnf::tree-list-fix
        (nth 0
             (cst-named-primitive-type-conc1 abnf::cst)))))

Theorem: tree-listp-of-cst-named-primitive-type-conc1-rep

(defthm tree-listp-of-cst-named-primitive-type-conc1-rep
  (b* ((abnf::csts (cst-named-primitive-type-conc1-rep abnf::cst)))
    (abnf::tree-listp abnf::csts))
  :rule-classes :rewrite)

Theorem: cst-named-primitive-type-conc1-rep-match

(defthm cst-named-primitive-type-conc1-rep-match
 (implies
   (and (cst-matchp abnf::cst "named-primitive-type")
        (equal (cst-named-primitive-type-conc? abnf::cst)
               1))
   (b* ((abnf::csts (cst-named-primitive-type-conc1-rep abnf::cst)))
     (cst-list-rep-matchp abnf::csts "boolean-type")))
 :rule-classes :rewrite)

Theorem: cst-named-primitive-type-conc1-rep-of-tree-fix-cst

(defthm cst-named-primitive-type-conc1-rep-of-tree-fix-cst
 (equal
     (cst-named-primitive-type-conc1-rep (abnf::tree-fix abnf::cst))
     (cst-named-primitive-type-conc1-rep abnf::cst)))

Theorem: cst-named-primitive-type-conc1-rep-tree-equiv-congruence-on-cst

(defthm
    cst-named-primitive-type-conc1-rep-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-named-primitive-type-conc1-rep abnf::cst)
                  (cst-named-primitive-type-conc1-rep cst-equiv)))
  :rule-classes :congruence)

Function: cst-named-primitive-type-conc2-rep

(defun cst-named-primitive-type-conc2-rep (abnf::cst)
 (declare (xargs :guard (abnf::treep abnf::cst)))
 (declare
  (xargs
       :guard (and (cst-matchp abnf::cst "named-primitive-type")
                   (equal (cst-named-primitive-type-conc? abnf::cst)
                          2))))
 (let ((__function__ 'cst-named-primitive-type-conc2-rep))
   (declare (ignorable __function__))
   (abnf::tree-list-fix
        (nth 0
             (cst-named-primitive-type-conc2 abnf::cst)))))

Theorem: tree-listp-of-cst-named-primitive-type-conc2-rep

(defthm tree-listp-of-cst-named-primitive-type-conc2-rep
  (b* ((abnf::csts (cst-named-primitive-type-conc2-rep abnf::cst)))
    (abnf::tree-listp abnf::csts))
  :rule-classes :rewrite)

Theorem: cst-named-primitive-type-conc2-rep-match

(defthm cst-named-primitive-type-conc2-rep-match
 (implies
   (and (cst-matchp abnf::cst "named-primitive-type")
        (equal (cst-named-primitive-type-conc? abnf::cst)
               2))
   (b* ((abnf::csts (cst-named-primitive-type-conc2-rep abnf::cst)))
     (cst-list-rep-matchp abnf::csts "arithmetic-type")))
 :rule-classes :rewrite)

Theorem: cst-named-primitive-type-conc2-rep-of-tree-fix-cst

(defthm cst-named-primitive-type-conc2-rep-of-tree-fix-cst
 (equal
     (cst-named-primitive-type-conc2-rep (abnf::tree-fix abnf::cst))
     (cst-named-primitive-type-conc2-rep abnf::cst)))

Theorem: cst-named-primitive-type-conc2-rep-tree-equiv-congruence-on-cst

(defthm
    cst-named-primitive-type-conc2-rep-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-named-primitive-type-conc2-rep abnf::cst)
                  (cst-named-primitive-type-conc2-rep cst-equiv)))
  :rule-classes :congruence)

Function: cst-named-primitive-type-conc3-rep

(defun cst-named-primitive-type-conc3-rep (abnf::cst)
 (declare (xargs :guard (abnf::treep abnf::cst)))
 (declare
  (xargs
       :guard (and (cst-matchp abnf::cst "named-primitive-type")
                   (equal (cst-named-primitive-type-conc? abnf::cst)
                          3))))
 (let ((__function__ 'cst-named-primitive-type-conc3-rep))
   (declare (ignorable __function__))
   (abnf::tree-list-fix
        (nth 0
             (cst-named-primitive-type-conc3 abnf::cst)))))

Theorem: tree-listp-of-cst-named-primitive-type-conc3-rep

(defthm tree-listp-of-cst-named-primitive-type-conc3-rep
  (b* ((abnf::csts (cst-named-primitive-type-conc3-rep abnf::cst)))
    (abnf::tree-listp abnf::csts))
  :rule-classes :rewrite)

Theorem: cst-named-primitive-type-conc3-rep-match

(defthm cst-named-primitive-type-conc3-rep-match
 (implies
   (and (cst-matchp abnf::cst "named-primitive-type")
        (equal (cst-named-primitive-type-conc? abnf::cst)
               3))
   (b* ((abnf::csts (cst-named-primitive-type-conc3-rep abnf::cst)))
     (cst-list-rep-matchp abnf::csts "address-type")))
 :rule-classes :rewrite)

Theorem: cst-named-primitive-type-conc3-rep-of-tree-fix-cst

(defthm cst-named-primitive-type-conc3-rep-of-tree-fix-cst
 (equal
     (cst-named-primitive-type-conc3-rep (abnf::tree-fix abnf::cst))
     (cst-named-primitive-type-conc3-rep abnf::cst)))

Theorem: cst-named-primitive-type-conc3-rep-tree-equiv-congruence-on-cst

(defthm
    cst-named-primitive-type-conc3-rep-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-named-primitive-type-conc3-rep abnf::cst)
                  (cst-named-primitive-type-conc3-rep cst-equiv)))
  :rule-classes :congruence)

Function: cst-named-primitive-type-conc4-rep

(defun cst-named-primitive-type-conc4-rep (abnf::cst)
 (declare (xargs :guard (abnf::treep abnf::cst)))
 (declare
  (xargs
       :guard (and (cst-matchp abnf::cst "named-primitive-type")
                   (equal (cst-named-primitive-type-conc? abnf::cst)
                          4))))
 (let ((__function__ 'cst-named-primitive-type-conc4-rep))
   (declare (ignorable __function__))
   (abnf::tree-list-fix
        (nth 0
             (cst-named-primitive-type-conc4 abnf::cst)))))

Theorem: tree-listp-of-cst-named-primitive-type-conc4-rep

(defthm tree-listp-of-cst-named-primitive-type-conc4-rep
  (b* ((abnf::csts (cst-named-primitive-type-conc4-rep abnf::cst)))
    (abnf::tree-listp abnf::csts))
  :rule-classes :rewrite)

Theorem: cst-named-primitive-type-conc4-rep-match

(defthm cst-named-primitive-type-conc4-rep-match
 (implies
   (and (cst-matchp abnf::cst "named-primitive-type")
        (equal (cst-named-primitive-type-conc? abnf::cst)
               4))
   (b* ((abnf::csts (cst-named-primitive-type-conc4-rep abnf::cst)))
     (cst-list-rep-matchp abnf::csts "string-type")))
 :rule-classes :rewrite)

Theorem: cst-named-primitive-type-conc4-rep-of-tree-fix-cst

(defthm cst-named-primitive-type-conc4-rep-of-tree-fix-cst
 (equal
     (cst-named-primitive-type-conc4-rep (abnf::tree-fix abnf::cst))
     (cst-named-primitive-type-conc4-rep abnf::cst)))

Theorem: cst-named-primitive-type-conc4-rep-tree-equiv-congruence-on-cst

(defthm
    cst-named-primitive-type-conc4-rep-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-named-primitive-type-conc4-rep abnf::cst)
                  (cst-named-primitive-type-conc4-rep cst-equiv)))
  :rule-classes :congruence)

Function: cst-primitive-type-conc1-rep

(defun cst-primitive-type-conc1-rep (abnf::cst)
 (declare (xargs :guard (abnf::treep abnf::cst)))
 (declare
      (xargs :guard (and (cst-matchp abnf::cst "primitive-type")
                         (equal (cst-primitive-type-conc? abnf::cst)
                                1))))
 (let ((__function__ 'cst-primitive-type-conc1-rep))
  (declare (ignorable __function__))
  (abnf::tree-list-fix (nth 0
                            (cst-primitive-type-conc1 abnf::cst)))))

Theorem: tree-listp-of-cst-primitive-type-conc1-rep

(defthm tree-listp-of-cst-primitive-type-conc1-rep
  (b* ((abnf::csts (cst-primitive-type-conc1-rep abnf::cst)))
    (abnf::tree-listp abnf::csts))
  :rule-classes :rewrite)

Theorem: cst-primitive-type-conc1-rep-match

(defthm cst-primitive-type-conc1-rep-match
  (implies
       (and (cst-matchp abnf::cst "primitive-type")
            (equal (cst-primitive-type-conc? abnf::cst)
                   1))
       (b* ((abnf::csts (cst-primitive-type-conc1-rep abnf::cst)))
         (cst-list-rep-matchp abnf::csts "named-primitive-type")))
  :rule-classes :rewrite)

Theorem: cst-primitive-type-conc1-rep-of-tree-fix-cst

(defthm cst-primitive-type-conc1-rep-of-tree-fix-cst
  (equal (cst-primitive-type-conc1-rep (abnf::tree-fix abnf::cst))
         (cst-primitive-type-conc1-rep abnf::cst)))

Theorem: cst-primitive-type-conc1-rep-tree-equiv-congruence-on-cst

(defthm cst-primitive-type-conc1-rep-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-primitive-type-conc1-rep abnf::cst)
                  (cst-primitive-type-conc1-rep cst-equiv)))
  :rule-classes :congruence)

Function: cst-primitive-type-conc2-rep

(defun cst-primitive-type-conc2-rep (abnf::cst)
 (declare (xargs :guard (abnf::treep abnf::cst)))
 (declare
      (xargs :guard (and (cst-matchp abnf::cst "primitive-type")
                         (equal (cst-primitive-type-conc? abnf::cst)
                                2))))
 (let ((__function__ 'cst-primitive-type-conc2-rep))
  (declare (ignorable __function__))
  (abnf::tree-list-fix (nth 0
                            (cst-primitive-type-conc2 abnf::cst)))))

Theorem: tree-listp-of-cst-primitive-type-conc2-rep

(defthm tree-listp-of-cst-primitive-type-conc2-rep
  (b* ((abnf::csts (cst-primitive-type-conc2-rep abnf::cst)))
    (abnf::tree-listp abnf::csts))
  :rule-classes :rewrite)

Theorem: cst-primitive-type-conc2-rep-match

(defthm cst-primitive-type-conc2-rep-match
  (implies
       (and (cst-matchp abnf::cst "primitive-type")
            (equal (cst-primitive-type-conc? abnf::cst)
                   2))
       (b* ((abnf::csts (cst-primitive-type-conc2-rep abnf::cst)))
         (cst-list-rep-matchp abnf::csts "unit-type")))
  :rule-classes :rewrite)

Theorem: cst-primitive-type-conc2-rep-of-tree-fix-cst

(defthm cst-primitive-type-conc2-rep-of-tree-fix-cst
  (equal (cst-primitive-type-conc2-rep (abnf::tree-fix abnf::cst))
         (cst-primitive-type-conc2-rep abnf::cst)))

Theorem: cst-primitive-type-conc2-rep-tree-equiv-congruence-on-cst

(defthm cst-primitive-type-conc2-rep-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-primitive-type-conc2-rep abnf::cst)
                  (cst-primitive-type-conc2-rep cst-equiv)))
  :rule-classes :congruence)

Function: cst-type-conc1-rep

(defun cst-type-conc1-rep (abnf::cst)
 (declare (xargs :guard (abnf::treep abnf::cst)))
 (declare (xargs :guard (and (cst-matchp abnf::cst "type")
                             (equal (cst-type-conc? abnf::cst) 1))))
 (let ((__function__ 'cst-type-conc1-rep))
   (declare (ignorable __function__))
   (abnf::tree-list-fix (nth 0 (cst-type-conc1 abnf::cst)))))

Theorem: tree-listp-of-cst-type-conc1-rep

(defthm tree-listp-of-cst-type-conc1-rep
  (b* ((abnf::csts (cst-type-conc1-rep abnf::cst)))
    (abnf::tree-listp abnf::csts))
  :rule-classes :rewrite)

Theorem: cst-type-conc1-rep-match

(defthm cst-type-conc1-rep-match
  (implies (and (cst-matchp abnf::cst "type")
                (equal (cst-type-conc? abnf::cst) 1))
           (b* ((abnf::csts (cst-type-conc1-rep abnf::cst)))
             (cst-list-rep-matchp abnf::csts "named-type")))
  :rule-classes :rewrite)

Theorem: cst-type-conc1-rep-of-tree-fix-cst

(defthm cst-type-conc1-rep-of-tree-fix-cst
  (equal (cst-type-conc1-rep (abnf::tree-fix abnf::cst))
         (cst-type-conc1-rep abnf::cst)))

Theorem: cst-type-conc1-rep-tree-equiv-congruence-on-cst

(defthm cst-type-conc1-rep-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-type-conc1-rep abnf::cst)
                  (cst-type-conc1-rep cst-equiv)))
  :rule-classes :congruence)

Function: cst-type-conc2-rep

(defun cst-type-conc2-rep (abnf::cst)
 (declare (xargs :guard (abnf::treep abnf::cst)))
 (declare (xargs :guard (and (cst-matchp abnf::cst "type")
                             (equal (cst-type-conc? abnf::cst) 2))))
 (let ((__function__ 'cst-type-conc2-rep))
   (declare (ignorable __function__))
   (abnf::tree-list-fix (nth 0 (cst-type-conc2 abnf::cst)))))

Theorem: tree-listp-of-cst-type-conc2-rep

(defthm tree-listp-of-cst-type-conc2-rep
  (b* ((abnf::csts (cst-type-conc2-rep abnf::cst)))
    (abnf::tree-listp abnf::csts))
  :rule-classes :rewrite)

Theorem: cst-type-conc2-rep-match

(defthm cst-type-conc2-rep-match
  (implies (and (cst-matchp abnf::cst "type")
                (equal (cst-type-conc? abnf::cst) 2))
           (b* ((abnf::csts (cst-type-conc2-rep abnf::cst)))
             (cst-list-rep-matchp abnf::csts "unit-type")))
  :rule-classes :rewrite)

Theorem: cst-type-conc2-rep-of-tree-fix-cst

(defthm cst-type-conc2-rep-of-tree-fix-cst
  (equal (cst-type-conc2-rep (abnf::tree-fix abnf::cst))
         (cst-type-conc2-rep abnf::cst)))

Theorem: cst-type-conc2-rep-tree-equiv-congruence-on-cst

(defthm cst-type-conc2-rep-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-type-conc2-rep abnf::cst)
                  (cst-type-conc2-rep cst-equiv)))
  :rule-classes :congruence)

Function: cst-type-conc3-rep

(defun cst-type-conc3-rep (abnf::cst)
 (declare (xargs :guard (abnf::treep abnf::cst)))
 (declare (xargs :guard (and (cst-matchp abnf::cst "type")
                             (equal (cst-type-conc? abnf::cst) 3))))
 (let ((__function__ 'cst-type-conc3-rep))
   (declare (ignorable __function__))
   (abnf::tree-list-fix (nth 0 (cst-type-conc3 abnf::cst)))))

Theorem: tree-listp-of-cst-type-conc3-rep

(defthm tree-listp-of-cst-type-conc3-rep
  (b* ((abnf::csts (cst-type-conc3-rep abnf::cst)))
    (abnf::tree-listp abnf::csts))
  :rule-classes :rewrite)

Theorem: cst-type-conc3-rep-match

(defthm cst-type-conc3-rep-match
  (implies (and (cst-matchp abnf::cst "type")
                (equal (cst-type-conc? abnf::cst) 3))
           (b* ((abnf::csts (cst-type-conc3-rep abnf::cst)))
             (cst-list-rep-matchp abnf::csts "tuple-type")))
  :rule-classes :rewrite)

Theorem: cst-type-conc3-rep-of-tree-fix-cst

(defthm cst-type-conc3-rep-of-tree-fix-cst
  (equal (cst-type-conc3-rep (abnf::tree-fix abnf::cst))
         (cst-type-conc3-rep abnf::cst)))

Theorem: cst-type-conc3-rep-tree-equiv-congruence-on-cst

(defthm cst-type-conc3-rep-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-type-conc3-rep abnf::cst)
                  (cst-type-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 "atomic-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 "affine-group-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-group-literal-conc1-rep

(defun cst-group-literal-conc1-rep (abnf::cst)
 (declare (xargs :guard (abnf::treep abnf::cst)))
 (declare
      (xargs :guard (and (cst-matchp abnf::cst "group-literal")
                         (equal (cst-group-literal-conc? abnf::cst)
                                1))))
 (let ((__function__ 'cst-group-literal-conc1-rep))
   (declare (ignorable __function__))
   (abnf::tree-list-fix (nth 0
                             (cst-group-literal-conc1 abnf::cst)))))

Theorem: tree-listp-of-cst-group-literal-conc1-rep

(defthm tree-listp-of-cst-group-literal-conc1-rep
  (b* ((abnf::csts (cst-group-literal-conc1-rep abnf::cst)))
    (abnf::tree-listp abnf::csts))
  :rule-classes :rewrite)

Theorem: cst-group-literal-conc1-rep-match

(defthm cst-group-literal-conc1-rep-match
  (implies
       (and (cst-matchp abnf::cst "group-literal")
            (equal (cst-group-literal-conc? abnf::cst)
                   1))
       (b* ((abnf::csts (cst-group-literal-conc1-rep abnf::cst)))
         (cst-list-rep-matchp abnf::csts "product-group-literal")))
  :rule-classes :rewrite)

Theorem: cst-group-literal-conc1-rep-of-tree-fix-cst

(defthm cst-group-literal-conc1-rep-of-tree-fix-cst
  (equal (cst-group-literal-conc1-rep (abnf::tree-fix abnf::cst))
         (cst-group-literal-conc1-rep abnf::cst)))

Theorem: cst-group-literal-conc1-rep-tree-equiv-congruence-on-cst

(defthm cst-group-literal-conc1-rep-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-group-literal-conc1-rep abnf::cst)
                  (cst-group-literal-conc1-rep cst-equiv)))
  :rule-classes :congruence)

Function: cst-group-literal-conc2-rep

(defun cst-group-literal-conc2-rep (abnf::cst)
 (declare (xargs :guard (abnf::treep abnf::cst)))
 (declare
      (xargs :guard (and (cst-matchp abnf::cst "group-literal")
                         (equal (cst-group-literal-conc? abnf::cst)
                                2))))
 (let ((__function__ 'cst-group-literal-conc2-rep))
   (declare (ignorable __function__))
   (abnf::tree-list-fix (nth 0
                             (cst-group-literal-conc2 abnf::cst)))))

Theorem: tree-listp-of-cst-group-literal-conc2-rep

(defthm tree-listp-of-cst-group-literal-conc2-rep
  (b* ((abnf::csts (cst-group-literal-conc2-rep abnf::cst)))
    (abnf::tree-listp abnf::csts))
  :rule-classes :rewrite)

Theorem: cst-group-literal-conc2-rep-match

(defthm cst-group-literal-conc2-rep-match
  (implies
       (and (cst-matchp abnf::cst "group-literal")
            (equal (cst-group-literal-conc? abnf::cst)
                   2))
       (b* ((abnf::csts (cst-group-literal-conc2-rep abnf::cst)))
         (cst-list-rep-matchp abnf::csts "affine-group-literal")))
  :rule-classes :rewrite)

Theorem: cst-group-literal-conc2-rep-of-tree-fix-cst

(defthm cst-group-literal-conc2-rep-of-tree-fix-cst
  (equal (cst-group-literal-conc2-rep (abnf::tree-fix abnf::cst))
         (cst-group-literal-conc2-rep abnf::cst)))

Theorem: cst-group-literal-conc2-rep-tree-equiv-congruence-on-cst

(defthm cst-group-literal-conc2-rep-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-group-literal-conc2-rep abnf::cst)
                  (cst-group-literal-conc2-rep cst-equiv)))
  :rule-classes :congruence)

Function: cst-variable-or-free-constant-conc-rep

(defun cst-variable-or-free-constant-conc-rep (abnf::cst)
 (declare (xargs :guard (abnf::treep abnf::cst)))
 (declare
  (xargs :guard (cst-matchp abnf::cst "variable-or-free-constant")))
 (let ((__function__ 'cst-variable-or-free-constant-conc-rep))
   (declare (ignorable __function__))
   (abnf::tree-list-fix
        (nth 0
             (cst-variable-or-free-constant-conc abnf::cst)))))

Theorem: tree-listp-of-cst-variable-or-free-constant-conc-rep

(defthm tree-listp-of-cst-variable-or-free-constant-conc-rep
  (b*
   ((abnf::csts (cst-variable-or-free-constant-conc-rep abnf::cst)))
   (abnf::tree-listp abnf::csts))
  :rule-classes :rewrite)

Theorem: cst-variable-or-free-constant-conc-rep-match

(defthm cst-variable-or-free-constant-conc-rep-match
 (implies
  (cst-matchp abnf::cst "variable-or-free-constant")
  (b*
   ((abnf::csts (cst-variable-or-free-constant-conc-rep abnf::cst)))
   (cst-list-rep-matchp abnf::csts "identifier")))
 :rule-classes :rewrite)

Theorem: cst-variable-or-free-constant-conc-rep-of-tree-fix-cst

(defthm cst-variable-or-free-constant-conc-rep-of-tree-fix-cst
  (equal (cst-variable-or-free-constant-conc-rep
              (abnf::tree-fix abnf::cst))
         (cst-variable-or-free-constant-conc-rep abnf::cst)))

Theorem: cst-variable-or-free-constant-conc-rep-tree-equiv-congruence-on-cst

(defthm
 cst-variable-or-free-constant-conc-rep-tree-equiv-congruence-on-cst
 (implies
      (abnf::tree-equiv abnf::cst cst-equiv)
      (equal (cst-variable-or-free-constant-conc-rep abnf::cst)
             (cst-variable-or-free-constant-conc-rep cst-equiv)))
 :rule-classes :congruence)

Function: cst-postfix-expression-conc1-rep

(defun cst-postfix-expression-conc1-rep (abnf::cst)
 (declare (xargs :guard (abnf::treep abnf::cst)))
 (declare
  (xargs :guard (and (cst-matchp abnf::cst "postfix-expression")
                     (equal (cst-postfix-expression-conc? abnf::cst)
                            1))))
 (let ((__function__ 'cst-postfix-expression-conc1-rep))
   (declare (ignorable __function__))
   (abnf::tree-list-fix
        (nth 0
             (cst-postfix-expression-conc1 abnf::cst)))))

Theorem: tree-listp-of-cst-postfix-expression-conc1-rep

(defthm tree-listp-of-cst-postfix-expression-conc1-rep
  (b* ((abnf::csts (cst-postfix-expression-conc1-rep abnf::cst)))
    (abnf::tree-listp abnf::csts))
  :rule-classes :rewrite)

Theorem: cst-postfix-expression-conc1-rep-match

(defthm cst-postfix-expression-conc1-rep-match
 (implies
     (and (cst-matchp abnf::cst "postfix-expression")
          (equal (cst-postfix-expression-conc? abnf::cst)
                 1))
     (b* ((abnf::csts (cst-postfix-expression-conc1-rep abnf::cst)))
       (cst-list-rep-matchp abnf::csts "primary-expression")))
 :rule-classes :rewrite)

Theorem: cst-postfix-expression-conc1-rep-of-tree-fix-cst

(defthm cst-postfix-expression-conc1-rep-of-tree-fix-cst
  (equal
       (cst-postfix-expression-conc1-rep (abnf::tree-fix abnf::cst))
       (cst-postfix-expression-conc1-rep abnf::cst)))

Theorem: cst-postfix-expression-conc1-rep-tree-equiv-congruence-on-cst

(defthm
      cst-postfix-expression-conc1-rep-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-postfix-expression-conc1-rep abnf::cst)
                  (cst-postfix-expression-conc1-rep cst-equiv)))
  :rule-classes :congruence)

Function: cst-postfix-expression-conc2-rep

(defun cst-postfix-expression-conc2-rep (abnf::cst)
 (declare (xargs :guard (abnf::treep abnf::cst)))
 (declare
  (xargs :guard (and (cst-matchp abnf::cst "postfix-expression")
                     (equal (cst-postfix-expression-conc? abnf::cst)
                            2))))
 (let ((__function__ 'cst-postfix-expression-conc2-rep))
   (declare (ignorable __function__))
   (abnf::tree-list-fix
        (nth 0
             (cst-postfix-expression-conc2 abnf::cst)))))

Theorem: tree-listp-of-cst-postfix-expression-conc2-rep

(defthm tree-listp-of-cst-postfix-expression-conc2-rep
  (b* ((abnf::csts (cst-postfix-expression-conc2-rep abnf::cst)))
    (abnf::tree-listp abnf::csts))
  :rule-classes :rewrite)

Theorem: cst-postfix-expression-conc2-rep-match

(defthm cst-postfix-expression-conc2-rep-match
 (implies
     (and (cst-matchp abnf::cst "postfix-expression")
          (equal (cst-postfix-expression-conc? abnf::cst)
                 2))
     (b* ((abnf::csts (cst-postfix-expression-conc2-rep abnf::cst)))
       (cst-list-rep-matchp abnf::csts
                            "tuple-component-expression")))
 :rule-classes :rewrite)

Theorem: cst-postfix-expression-conc2-rep-of-tree-fix-cst

(defthm cst-postfix-expression-conc2-rep-of-tree-fix-cst
  (equal
       (cst-postfix-expression-conc2-rep (abnf::tree-fix abnf::cst))
       (cst-postfix-expression-conc2-rep abnf::cst)))

Theorem: cst-postfix-expression-conc2-rep-tree-equiv-congruence-on-cst

(defthm
      cst-postfix-expression-conc2-rep-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-postfix-expression-conc2-rep abnf::cst)
                  (cst-postfix-expression-conc2-rep cst-equiv)))
  :rule-classes :congruence)

Function: cst-postfix-expression-conc3-rep

(defun cst-postfix-expression-conc3-rep (abnf::cst)
 (declare (xargs :guard (abnf::treep abnf::cst)))
 (declare
  (xargs :guard (and (cst-matchp abnf::cst "postfix-expression")
                     (equal (cst-postfix-expression-conc? abnf::cst)
                            3))))
 (let ((__function__ 'cst-postfix-expression-conc3-rep))
   (declare (ignorable __function__))
   (abnf::tree-list-fix
        (nth 0
             (cst-postfix-expression-conc3 abnf::cst)))))

Theorem: tree-listp-of-cst-postfix-expression-conc3-rep

(defthm tree-listp-of-cst-postfix-expression-conc3-rep
  (b* ((abnf::csts (cst-postfix-expression-conc3-rep abnf::cst)))
    (abnf::tree-listp abnf::csts))
  :rule-classes :rewrite)

Theorem: cst-postfix-expression-conc3-rep-match

(defthm cst-postfix-expression-conc3-rep-match
 (implies
     (and (cst-matchp abnf::cst "postfix-expression")
          (equal (cst-postfix-expression-conc? abnf::cst)
                 3))
     (b* ((abnf::csts (cst-postfix-expression-conc3-rep abnf::cst)))
       (cst-list-rep-matchp abnf::csts
                            "struct-component-expression")))
 :rule-classes :rewrite)

Theorem: cst-postfix-expression-conc3-rep-of-tree-fix-cst

(defthm cst-postfix-expression-conc3-rep-of-tree-fix-cst
  (equal
       (cst-postfix-expression-conc3-rep (abnf::tree-fix abnf::cst))
       (cst-postfix-expression-conc3-rep abnf::cst)))

Theorem: cst-postfix-expression-conc3-rep-tree-equiv-congruence-on-cst

(defthm
      cst-postfix-expression-conc3-rep-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-postfix-expression-conc3-rep abnf::cst)
                  (cst-postfix-expression-conc3-rep cst-equiv)))
  :rule-classes :congruence)

Function: cst-postfix-expression-conc4-rep

(defun cst-postfix-expression-conc4-rep (abnf::cst)
 (declare (xargs :guard (abnf::treep abnf::cst)))
 (declare
  (xargs :guard (and (cst-matchp abnf::cst "postfix-expression")
                     (equal (cst-postfix-expression-conc? abnf::cst)
                            4))))
 (let ((__function__ 'cst-postfix-expression-conc4-rep))
   (declare (ignorable __function__))
   (abnf::tree-list-fix
        (nth 0
             (cst-postfix-expression-conc4 abnf::cst)))))

Theorem: tree-listp-of-cst-postfix-expression-conc4-rep

(defthm tree-listp-of-cst-postfix-expression-conc4-rep
  (b* ((abnf::csts (cst-postfix-expression-conc4-rep abnf::cst)))
    (abnf::tree-listp abnf::csts))
  :rule-classes :rewrite)

Theorem: cst-postfix-expression-conc4-rep-match

(defthm cst-postfix-expression-conc4-rep-match
 (implies
     (and (cst-matchp abnf::cst "postfix-expression")
          (equal (cst-postfix-expression-conc? abnf::cst)
                 4))
     (b* ((abnf::csts (cst-postfix-expression-conc4-rep abnf::cst)))
       (cst-list-rep-matchp abnf::csts "operator-call")))
 :rule-classes :rewrite)

Theorem: cst-postfix-expression-conc4-rep-of-tree-fix-cst

(defthm cst-postfix-expression-conc4-rep-of-tree-fix-cst
  (equal
       (cst-postfix-expression-conc4-rep (abnf::tree-fix abnf::cst))
       (cst-postfix-expression-conc4-rep abnf::cst)))

Theorem: cst-postfix-expression-conc4-rep-tree-equiv-congruence-on-cst

(defthm
      cst-postfix-expression-conc4-rep-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-postfix-expression-conc4-rep abnf::cst)
                  (cst-postfix-expression-conc4-rep cst-equiv)))
  :rule-classes :congruence)

Function: cst-operator-call-conc1-rep

(defun cst-operator-call-conc1-rep (abnf::cst)
 (declare (xargs :guard (abnf::treep abnf::cst)))
 (declare
      (xargs :guard (and (cst-matchp abnf::cst "operator-call")
                         (equal (cst-operator-call-conc? abnf::cst)
                                1))))
 (let ((__function__ 'cst-operator-call-conc1-rep))
   (declare (ignorable __function__))
   (abnf::tree-list-fix (nth 0
                             (cst-operator-call-conc1 abnf::cst)))))

Theorem: tree-listp-of-cst-operator-call-conc1-rep

(defthm tree-listp-of-cst-operator-call-conc1-rep
  (b* ((abnf::csts (cst-operator-call-conc1-rep abnf::cst)))
    (abnf::tree-listp abnf::csts))
  :rule-classes :rewrite)

Theorem: cst-operator-call-conc1-rep-match

(defthm cst-operator-call-conc1-rep-match
 (implies (and (cst-matchp abnf::cst "operator-call")
               (equal (cst-operator-call-conc? abnf::cst)
                      1))
          (b* ((abnf::csts (cst-operator-call-conc1-rep abnf::cst)))
            (cst-list-rep-matchp abnf::csts "unary-operator-call")))
 :rule-classes :rewrite)

Theorem: cst-operator-call-conc1-rep-of-tree-fix-cst

(defthm cst-operator-call-conc1-rep-of-tree-fix-cst
  (equal (cst-operator-call-conc1-rep (abnf::tree-fix abnf::cst))
         (cst-operator-call-conc1-rep abnf::cst)))

Theorem: cst-operator-call-conc1-rep-tree-equiv-congruence-on-cst

(defthm cst-operator-call-conc1-rep-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-operator-call-conc1-rep abnf::cst)
                  (cst-operator-call-conc1-rep cst-equiv)))
  :rule-classes :congruence)

Function: cst-operator-call-conc2-rep

(defun cst-operator-call-conc2-rep (abnf::cst)
 (declare (xargs :guard (abnf::treep abnf::cst)))
 (declare
      (xargs :guard (and (cst-matchp abnf::cst "operator-call")
                         (equal (cst-operator-call-conc? abnf::cst)
                                2))))
 (let ((__function__ 'cst-operator-call-conc2-rep))
   (declare (ignorable __function__))
   (abnf::tree-list-fix (nth 0
                             (cst-operator-call-conc2 abnf::cst)))))

Theorem: tree-listp-of-cst-operator-call-conc2-rep

(defthm tree-listp-of-cst-operator-call-conc2-rep
  (b* ((abnf::csts (cst-operator-call-conc2-rep abnf::cst)))
    (abnf::tree-listp abnf::csts))
  :rule-classes :rewrite)

Theorem: cst-operator-call-conc2-rep-match

(defthm cst-operator-call-conc2-rep-match
  (implies
       (and (cst-matchp abnf::cst "operator-call")
            (equal (cst-operator-call-conc? abnf::cst)
                   2))
       (b* ((abnf::csts (cst-operator-call-conc2-rep abnf::cst)))
         (cst-list-rep-matchp abnf::csts "binary-operator-call")))
  :rule-classes :rewrite)

Theorem: cst-operator-call-conc2-rep-of-tree-fix-cst

(defthm cst-operator-call-conc2-rep-of-tree-fix-cst
  (equal (cst-operator-call-conc2-rep (abnf::tree-fix abnf::cst))
         (cst-operator-call-conc2-rep abnf::cst)))

Theorem: cst-operator-call-conc2-rep-tree-equiv-congruence-on-cst

(defthm cst-operator-call-conc2-rep-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-operator-call-conc2-rep abnf::cst)
                  (cst-operator-call-conc2-rep cst-equiv)))
  :rule-classes :congruence)

Function: cst-binary-expression-conc-rep

(defun cst-binary-expression-conc-rep (abnf::cst)
 (declare (xargs :guard (abnf::treep abnf::cst)))
 (declare (xargs :guard (cst-matchp abnf::cst "binary-expression")))
 (let ((__function__ 'cst-binary-expression-conc-rep))
   (declare (ignorable __function__))
   (abnf::tree-list-fix
        (nth 0
             (cst-binary-expression-conc abnf::cst)))))

Theorem: tree-listp-of-cst-binary-expression-conc-rep

(defthm tree-listp-of-cst-binary-expression-conc-rep
  (b* ((abnf::csts (cst-binary-expression-conc-rep abnf::cst)))
    (abnf::tree-listp abnf::csts))
  :rule-classes :rewrite)

Theorem: cst-binary-expression-conc-rep-match

(defthm cst-binary-expression-conc-rep-match
 (implies
      (cst-matchp abnf::cst "binary-expression")
      (b* ((abnf::csts (cst-binary-expression-conc-rep abnf::cst)))
        (cst-list-rep-matchp abnf::csts
                             "conditional-disjunctive-expression")))
 :rule-classes :rewrite)

Theorem: cst-binary-expression-conc-rep-of-tree-fix-cst

(defthm cst-binary-expression-conc-rep-of-tree-fix-cst
  (equal (cst-binary-expression-conc-rep (abnf::tree-fix abnf::cst))
         (cst-binary-expression-conc-rep abnf::cst)))

Theorem: cst-binary-expression-conc-rep-tree-equiv-congruence-on-cst

(defthm cst-binary-expression-conc-rep-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-binary-expression-conc-rep abnf::cst)
                  (cst-binary-expression-conc-rep cst-equiv)))
  :rule-classes :congruence)

Function: cst-expression-conc-rep

(defun cst-expression-conc-rep (abnf::cst)
  (declare (xargs :guard (abnf::treep abnf::cst)))
  (declare (xargs :guard (cst-matchp abnf::cst "expression")))
  (let ((__function__ 'cst-expression-conc-rep))
    (declare (ignorable __function__))
    (abnf::tree-list-fix (nth 0 (cst-expression-conc abnf::cst)))))

Theorem: tree-listp-of-cst-expression-conc-rep

(defthm tree-listp-of-cst-expression-conc-rep
  (b* ((abnf::csts (cst-expression-conc-rep abnf::cst)))
    (abnf::tree-listp abnf::csts))
  :rule-classes :rewrite)

Theorem: cst-expression-conc-rep-match

(defthm cst-expression-conc-rep-match
 (implies (cst-matchp abnf::cst "expression")
          (b* ((abnf::csts (cst-expression-conc-rep abnf::cst)))
            (cst-list-rep-matchp abnf::csts
                                 "conditional-ternary-expression")))
 :rule-classes :rewrite)

Theorem: cst-expression-conc-rep-of-tree-fix-cst

(defthm cst-expression-conc-rep-of-tree-fix-cst
  (equal (cst-expression-conc-rep (abnf::tree-fix abnf::cst))
         (cst-expression-conc-rep abnf::cst)))

Theorem: cst-expression-conc-rep-tree-equiv-congruence-on-cst

(defthm cst-expression-conc-rep-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-expression-conc-rep abnf::cst)
                  (cst-expression-conc-rep cst-equiv)))
  :rule-classes :congruence)

Function: cst-statement-conc1-rep

(defun cst-statement-conc1-rep (abnf::cst)
  (declare (xargs :guard (abnf::treep abnf::cst)))
  (declare (xargs :guard (and (cst-matchp abnf::cst "statement")
                              (equal (cst-statement-conc? abnf::cst)
                                     1))))
  (let ((__function__ 'cst-statement-conc1-rep))
    (declare (ignorable __function__))
    (abnf::tree-list-fix (nth 0 (cst-statement-conc1 abnf::cst)))))

Theorem: tree-listp-of-cst-statement-conc1-rep

(defthm tree-listp-of-cst-statement-conc1-rep
  (b* ((abnf::csts (cst-statement-conc1-rep abnf::cst)))
    (abnf::tree-listp abnf::csts))
  :rule-classes :rewrite)

Theorem: cst-statement-conc1-rep-match

(defthm cst-statement-conc1-rep-match
  (implies (and (cst-matchp abnf::cst "statement")
                (equal (cst-statement-conc? abnf::cst)
                       1))
           (b* ((abnf::csts (cst-statement-conc1-rep abnf::cst)))
             (cst-list-rep-matchp abnf::csts "return-statement")))
  :rule-classes :rewrite)

Theorem: cst-statement-conc1-rep-of-tree-fix-cst

(defthm cst-statement-conc1-rep-of-tree-fix-cst
  (equal (cst-statement-conc1-rep (abnf::tree-fix abnf::cst))
         (cst-statement-conc1-rep abnf::cst)))

Theorem: cst-statement-conc1-rep-tree-equiv-congruence-on-cst

(defthm cst-statement-conc1-rep-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-statement-conc1-rep abnf::cst)
                  (cst-statement-conc1-rep cst-equiv)))
  :rule-classes :congruence)

Function: cst-statement-conc2-rep

(defun cst-statement-conc2-rep (abnf::cst)
  (declare (xargs :guard (abnf::treep abnf::cst)))
  (declare (xargs :guard (and (cst-matchp abnf::cst "statement")
                              (equal (cst-statement-conc? abnf::cst)
                                     2))))
  (let ((__function__ 'cst-statement-conc2-rep))
    (declare (ignorable __function__))
    (abnf::tree-list-fix (nth 0 (cst-statement-conc2 abnf::cst)))))

Theorem: tree-listp-of-cst-statement-conc2-rep

(defthm tree-listp-of-cst-statement-conc2-rep
  (b* ((abnf::csts (cst-statement-conc2-rep abnf::cst)))
    (abnf::tree-listp abnf::csts))
  :rule-classes :rewrite)

Theorem: cst-statement-conc2-rep-match

(defthm cst-statement-conc2-rep-match
  (implies
       (and (cst-matchp abnf::cst "statement")
            (equal (cst-statement-conc? abnf::cst)
                   2))
       (b* ((abnf::csts (cst-statement-conc2-rep abnf::cst)))
         (cst-list-rep-matchp abnf::csts "variable-declaration")))
  :rule-classes :rewrite)

Theorem: cst-statement-conc2-rep-of-tree-fix-cst

(defthm cst-statement-conc2-rep-of-tree-fix-cst
  (equal (cst-statement-conc2-rep (abnf::tree-fix abnf::cst))
         (cst-statement-conc2-rep abnf::cst)))

Theorem: cst-statement-conc2-rep-tree-equiv-congruence-on-cst

(defthm cst-statement-conc2-rep-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-statement-conc2-rep abnf::cst)
                  (cst-statement-conc2-rep cst-equiv)))
  :rule-classes :congruence)

Function: cst-statement-conc3-rep

(defun cst-statement-conc3-rep (abnf::cst)
  (declare (xargs :guard (abnf::treep abnf::cst)))
  (declare (xargs :guard (and (cst-matchp abnf::cst "statement")
                              (equal (cst-statement-conc? abnf::cst)
                                     3))))
  (let ((__function__ 'cst-statement-conc3-rep))
    (declare (ignorable __function__))
    (abnf::tree-list-fix (nth 0 (cst-statement-conc3 abnf::cst)))))

Theorem: tree-listp-of-cst-statement-conc3-rep

(defthm tree-listp-of-cst-statement-conc3-rep
  (b* ((abnf::csts (cst-statement-conc3-rep abnf::cst)))
    (abnf::tree-listp abnf::csts))
  :rule-classes :rewrite)

Theorem: cst-statement-conc3-rep-match

(defthm cst-statement-conc3-rep-match
  (implies
       (and (cst-matchp abnf::cst "statement")
            (equal (cst-statement-conc? abnf::cst)
                   3))
       (b* ((abnf::csts (cst-statement-conc3-rep abnf::cst)))
         (cst-list-rep-matchp abnf::csts "constant-declaration")))
  :rule-classes :rewrite)

Theorem: cst-statement-conc3-rep-of-tree-fix-cst

(defthm cst-statement-conc3-rep-of-tree-fix-cst
  (equal (cst-statement-conc3-rep (abnf::tree-fix abnf::cst))
         (cst-statement-conc3-rep abnf::cst)))

Theorem: cst-statement-conc3-rep-tree-equiv-congruence-on-cst

(defthm cst-statement-conc3-rep-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-statement-conc3-rep abnf::cst)
                  (cst-statement-conc3-rep cst-equiv)))
  :rule-classes :congruence)

Function: cst-statement-conc4-rep

(defun cst-statement-conc4-rep (abnf::cst)
  (declare (xargs :guard (abnf::treep abnf::cst)))
  (declare (xargs :guard (and (cst-matchp abnf::cst "statement")
                              (equal (cst-statement-conc? abnf::cst)
                                     4))))
  (let ((__function__ 'cst-statement-conc4-rep))
    (declare (ignorable __function__))
    (abnf::tree-list-fix (nth 0 (cst-statement-conc4 abnf::cst)))))

Theorem: tree-listp-of-cst-statement-conc4-rep

(defthm tree-listp-of-cst-statement-conc4-rep
  (b* ((abnf::csts (cst-statement-conc4-rep abnf::cst)))
    (abnf::tree-listp abnf::csts))
  :rule-classes :rewrite)

Theorem: cst-statement-conc4-rep-match

(defthm cst-statement-conc4-rep-match
  (implies
       (and (cst-matchp abnf::cst "statement")
            (equal (cst-statement-conc? abnf::cst)
                   4))
       (b* ((abnf::csts (cst-statement-conc4-rep abnf::cst)))
         (cst-list-rep-matchp abnf::csts "conditional-statement")))
  :rule-classes :rewrite)

Theorem: cst-statement-conc4-rep-of-tree-fix-cst

(defthm cst-statement-conc4-rep-of-tree-fix-cst
  (equal (cst-statement-conc4-rep (abnf::tree-fix abnf::cst))
         (cst-statement-conc4-rep abnf::cst)))

Theorem: cst-statement-conc4-rep-tree-equiv-congruence-on-cst

(defthm cst-statement-conc4-rep-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-statement-conc4-rep abnf::cst)
                  (cst-statement-conc4-rep cst-equiv)))
  :rule-classes :congruence)

Function: cst-statement-conc5-rep

(defun cst-statement-conc5-rep (abnf::cst)
  (declare (xargs :guard (abnf::treep abnf::cst)))
  (declare (xargs :guard (and (cst-matchp abnf::cst "statement")
                              (equal (cst-statement-conc? abnf::cst)
                                     5))))
  (let ((__function__ 'cst-statement-conc5-rep))
    (declare (ignorable __function__))
    (abnf::tree-list-fix (nth 0 (cst-statement-conc5 abnf::cst)))))

Theorem: tree-listp-of-cst-statement-conc5-rep

(defthm tree-listp-of-cst-statement-conc5-rep
  (b* ((abnf::csts (cst-statement-conc5-rep abnf::cst)))
    (abnf::tree-listp abnf::csts))
  :rule-classes :rewrite)

Theorem: cst-statement-conc5-rep-match

(defthm cst-statement-conc5-rep-match
  (implies (and (cst-matchp abnf::cst "statement")
                (equal (cst-statement-conc? abnf::cst)
                       5))
           (b* ((abnf::csts (cst-statement-conc5-rep abnf::cst)))
             (cst-list-rep-matchp abnf::csts "loop-statement")))
  :rule-classes :rewrite)

Theorem: cst-statement-conc5-rep-of-tree-fix-cst

(defthm cst-statement-conc5-rep-of-tree-fix-cst
  (equal (cst-statement-conc5-rep (abnf::tree-fix abnf::cst))
         (cst-statement-conc5-rep abnf::cst)))

Theorem: cst-statement-conc5-rep-tree-equiv-congruence-on-cst

(defthm cst-statement-conc5-rep-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-statement-conc5-rep abnf::cst)
                  (cst-statement-conc5-rep cst-equiv)))
  :rule-classes :congruence)

Function: cst-statement-conc6-rep

(defun cst-statement-conc6-rep (abnf::cst)
  (declare (xargs :guard (abnf::treep abnf::cst)))
  (declare (xargs :guard (and (cst-matchp abnf::cst "statement")
                              (equal (cst-statement-conc? abnf::cst)
                                     6))))
  (let ((__function__ 'cst-statement-conc6-rep))
    (declare (ignorable __function__))
    (abnf::tree-list-fix (nth 0 (cst-statement-conc6 abnf::cst)))))

Theorem: tree-listp-of-cst-statement-conc6-rep

(defthm tree-listp-of-cst-statement-conc6-rep
  (b* ((abnf::csts (cst-statement-conc6-rep abnf::cst)))
    (abnf::tree-listp abnf::csts))
  :rule-classes :rewrite)

Theorem: cst-statement-conc6-rep-match

(defthm cst-statement-conc6-rep-match
  (implies
       (and (cst-matchp abnf::cst "statement")
            (equal (cst-statement-conc? abnf::cst)
                   6))
       (b* ((abnf::csts (cst-statement-conc6-rep abnf::cst)))
         (cst-list-rep-matchp abnf::csts "assignment-statement")))
  :rule-classes :rewrite)

Theorem: cst-statement-conc6-rep-of-tree-fix-cst

(defthm cst-statement-conc6-rep-of-tree-fix-cst
  (equal (cst-statement-conc6-rep (abnf::tree-fix abnf::cst))
         (cst-statement-conc6-rep abnf::cst)))

Theorem: cst-statement-conc6-rep-tree-equiv-congruence-on-cst

(defthm cst-statement-conc6-rep-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-statement-conc6-rep abnf::cst)
                  (cst-statement-conc6-rep cst-equiv)))
  :rule-classes :congruence)

Function: cst-statement-conc7-rep

(defun cst-statement-conc7-rep (abnf::cst)
  (declare (xargs :guard (abnf::treep abnf::cst)))
  (declare (xargs :guard (and (cst-matchp abnf::cst "statement")
                              (equal (cst-statement-conc? abnf::cst)
                                     7))))
  (let ((__function__ 'cst-statement-conc7-rep))
    (declare (ignorable __function__))
    (abnf::tree-list-fix (nth 0 (cst-statement-conc7 abnf::cst)))))

Theorem: tree-listp-of-cst-statement-conc7-rep

(defthm tree-listp-of-cst-statement-conc7-rep
  (b* ((abnf::csts (cst-statement-conc7-rep abnf::cst)))
    (abnf::tree-listp abnf::csts))
  :rule-classes :rewrite)

Theorem: cst-statement-conc7-rep-match

(defthm cst-statement-conc7-rep-match
  (implies (and (cst-matchp abnf::cst "statement")
                (equal (cst-statement-conc? abnf::cst)
                       7))
           (b* ((abnf::csts (cst-statement-conc7-rep abnf::cst)))
             (cst-list-rep-matchp abnf::csts "console-statement")))
  :rule-classes :rewrite)

Theorem: cst-statement-conc7-rep-of-tree-fix-cst

(defthm cst-statement-conc7-rep-of-tree-fix-cst
  (equal (cst-statement-conc7-rep (abnf::tree-fix abnf::cst))
         (cst-statement-conc7-rep abnf::cst)))

Theorem: cst-statement-conc7-rep-tree-equiv-congruence-on-cst

(defthm cst-statement-conc7-rep-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-statement-conc7-rep abnf::cst)
                  (cst-statement-conc7-rep cst-equiv)))
  :rule-classes :congruence)

Function: cst-statement-conc8-rep

(defun cst-statement-conc8-rep (abnf::cst)
  (declare (xargs :guard (abnf::treep abnf::cst)))
  (declare (xargs :guard (and (cst-matchp abnf::cst "statement")
                              (equal (cst-statement-conc? abnf::cst)
                                     8))))
  (let ((__function__ 'cst-statement-conc8-rep))
    (declare (ignorable __function__))
    (abnf::tree-list-fix (nth 0 (cst-statement-conc8 abnf::cst)))))

Theorem: tree-listp-of-cst-statement-conc8-rep

(defthm tree-listp-of-cst-statement-conc8-rep
  (b* ((abnf::csts (cst-statement-conc8-rep abnf::cst)))
    (abnf::tree-listp abnf::csts))
  :rule-classes :rewrite)

Theorem: cst-statement-conc8-rep-match

(defthm cst-statement-conc8-rep-match
  (implies (and (cst-matchp abnf::cst "statement")
                (equal (cst-statement-conc? abnf::cst)
                       8))
           (b* ((abnf::csts (cst-statement-conc8-rep abnf::cst)))
             (cst-list-rep-matchp abnf::csts "finalize-statement")))
  :rule-classes :rewrite)

Theorem: cst-statement-conc8-rep-of-tree-fix-cst

(defthm cst-statement-conc8-rep-of-tree-fix-cst
  (equal (cst-statement-conc8-rep (abnf::tree-fix abnf::cst))
         (cst-statement-conc8-rep abnf::cst)))

Theorem: cst-statement-conc8-rep-tree-equiv-congruence-on-cst

(defthm cst-statement-conc8-rep-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-statement-conc8-rep abnf::cst)
                  (cst-statement-conc8-rep cst-equiv)))
  :rule-classes :congruence)

Function: cst-statement-conc9-rep

(defun cst-statement-conc9-rep (abnf::cst)
  (declare (xargs :guard (abnf::treep abnf::cst)))
  (declare (xargs :guard (and (cst-matchp abnf::cst "statement")
                              (equal (cst-statement-conc? abnf::cst)
                                     9))))
  (let ((__function__ 'cst-statement-conc9-rep))
    (declare (ignorable __function__))
    (abnf::tree-list-fix (nth 0 (cst-statement-conc9 abnf::cst)))))

Theorem: tree-listp-of-cst-statement-conc9-rep

(defthm tree-listp-of-cst-statement-conc9-rep
  (b* ((abnf::csts (cst-statement-conc9-rep abnf::cst)))
    (abnf::tree-listp abnf::csts))
  :rule-classes :rewrite)

Theorem: cst-statement-conc9-rep-match

(defthm cst-statement-conc9-rep-match
 (implies (and (cst-matchp abnf::cst "statement")
               (equal (cst-statement-conc? abnf::cst)
                      9))
          (b* ((abnf::csts (cst-statement-conc9-rep abnf::cst)))
            (cst-list-rep-matchp abnf::csts "increment-statement")))
 :rule-classes :rewrite)

Theorem: cst-statement-conc9-rep-of-tree-fix-cst

(defthm cst-statement-conc9-rep-of-tree-fix-cst
  (equal (cst-statement-conc9-rep (abnf::tree-fix abnf::cst))
         (cst-statement-conc9-rep abnf::cst)))

Theorem: cst-statement-conc9-rep-tree-equiv-congruence-on-cst

(defthm cst-statement-conc9-rep-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-statement-conc9-rep abnf::cst)
                  (cst-statement-conc9-rep cst-equiv)))
  :rule-classes :congruence)

Function: cst-statement-conc10-rep

(defun cst-statement-conc10-rep (abnf::cst)
  (declare (xargs :guard (abnf::treep abnf::cst)))
  (declare (xargs :guard (and (cst-matchp abnf::cst "statement")
                              (equal (cst-statement-conc? abnf::cst)
                                     10))))
  (let ((__function__ 'cst-statement-conc10-rep))
    (declare (ignorable __function__))
    (abnf::tree-list-fix (nth 0 (cst-statement-conc10 abnf::cst)))))

Theorem: tree-listp-of-cst-statement-conc10-rep

(defthm tree-listp-of-cst-statement-conc10-rep
  (b* ((abnf::csts (cst-statement-conc10-rep abnf::cst)))
    (abnf::tree-listp abnf::csts))
  :rule-classes :rewrite)

Theorem: cst-statement-conc10-rep-match

(defthm cst-statement-conc10-rep-match
 (implies (and (cst-matchp abnf::cst "statement")
               (equal (cst-statement-conc? abnf::cst)
                      10))
          (b* ((abnf::csts (cst-statement-conc10-rep abnf::cst)))
            (cst-list-rep-matchp abnf::csts "decrement-statement")))
 :rule-classes :rewrite)

Theorem: cst-statement-conc10-rep-of-tree-fix-cst

(defthm cst-statement-conc10-rep-of-tree-fix-cst
  (equal (cst-statement-conc10-rep (abnf::tree-fix abnf::cst))
         (cst-statement-conc10-rep abnf::cst)))

Theorem: cst-statement-conc10-rep-tree-equiv-congruence-on-cst

(defthm cst-statement-conc10-rep-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-statement-conc10-rep abnf::cst)
                  (cst-statement-conc10-rep cst-equiv)))
  :rule-classes :congruence)

Function: cst-statement-conc11-rep

(defun cst-statement-conc11-rep (abnf::cst)
  (declare (xargs :guard (abnf::treep abnf::cst)))
  (declare (xargs :guard (and (cst-matchp abnf::cst "statement")
                              (equal (cst-statement-conc? abnf::cst)
                                     11))))
  (let ((__function__ 'cst-statement-conc11-rep))
    (declare (ignorable __function__))
    (abnf::tree-list-fix (nth 0 (cst-statement-conc11 abnf::cst)))))

Theorem: tree-listp-of-cst-statement-conc11-rep

(defthm tree-listp-of-cst-statement-conc11-rep
  (b* ((abnf::csts (cst-statement-conc11-rep abnf::cst)))
    (abnf::tree-listp abnf::csts))
  :rule-classes :rewrite)

Theorem: cst-statement-conc11-rep-match

(defthm cst-statement-conc11-rep-match
  (implies (and (cst-matchp abnf::cst "statement")
                (equal (cst-statement-conc? abnf::cst)
                       11))
           (b* ((abnf::csts (cst-statement-conc11-rep abnf::cst)))
             (cst-list-rep-matchp abnf::csts "block")))
  :rule-classes :rewrite)

Theorem: cst-statement-conc11-rep-of-tree-fix-cst

(defthm cst-statement-conc11-rep-of-tree-fix-cst
  (equal (cst-statement-conc11-rep (abnf::tree-fix abnf::cst))
         (cst-statement-conc11-rep abnf::cst)))

Theorem: cst-statement-conc11-rep-tree-equiv-congruence-on-cst

(defthm cst-statement-conc11-rep-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-statement-conc11-rep abnf::cst)
                  (cst-statement-conc11-rep cst-equiv)))
  :rule-classes :congruence)

Function: cst-console-call-conc1-rep

(defun cst-console-call-conc1-rep (abnf::cst)
 (declare (xargs :guard (abnf::treep abnf::cst)))
 (declare
      (xargs :guard (and (cst-matchp abnf::cst "console-call")
                         (equal (cst-console-call-conc? abnf::cst)
                                1))))
 (let ((__function__ 'cst-console-call-conc1-rep))
  (declare (ignorable __function__))
  (abnf::tree-list-fix (nth 0 (cst-console-call-conc1 abnf::cst)))))

Theorem: tree-listp-of-cst-console-call-conc1-rep

(defthm tree-listp-of-cst-console-call-conc1-rep
  (b* ((abnf::csts (cst-console-call-conc1-rep abnf::cst)))
    (abnf::tree-listp abnf::csts))
  :rule-classes :rewrite)

Theorem: cst-console-call-conc1-rep-match

(defthm cst-console-call-conc1-rep-match
  (implies (and (cst-matchp abnf::cst "console-call")
                (equal (cst-console-call-conc? abnf::cst)
                       1))
           (b* ((abnf::csts (cst-console-call-conc1-rep abnf::cst)))
             (cst-list-rep-matchp abnf::csts "assert-call")))
  :rule-classes :rewrite)

Theorem: cst-console-call-conc1-rep-of-tree-fix-cst

(defthm cst-console-call-conc1-rep-of-tree-fix-cst
  (equal (cst-console-call-conc1-rep (abnf::tree-fix abnf::cst))
         (cst-console-call-conc1-rep abnf::cst)))

Theorem: cst-console-call-conc1-rep-tree-equiv-congruence-on-cst

(defthm cst-console-call-conc1-rep-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-console-call-conc1-rep abnf::cst)
                  (cst-console-call-conc1-rep cst-equiv)))
  :rule-classes :congruence)

Function: cst-console-call-conc2-rep

(defun cst-console-call-conc2-rep (abnf::cst)
 (declare (xargs :guard (abnf::treep abnf::cst)))
 (declare
      (xargs :guard (and (cst-matchp abnf::cst "console-call")
                         (equal (cst-console-call-conc? abnf::cst)
                                2))))
 (let ((__function__ 'cst-console-call-conc2-rep))
  (declare (ignorable __function__))
  (abnf::tree-list-fix (nth 0 (cst-console-call-conc2 abnf::cst)))))

Theorem: tree-listp-of-cst-console-call-conc2-rep

(defthm tree-listp-of-cst-console-call-conc2-rep
  (b* ((abnf::csts (cst-console-call-conc2-rep abnf::cst)))
    (abnf::tree-listp abnf::csts))
  :rule-classes :rewrite)

Theorem: cst-console-call-conc2-rep-match

(defthm cst-console-call-conc2-rep-match
  (implies (and (cst-matchp abnf::cst "console-call")
                (equal (cst-console-call-conc? abnf::cst)
                       2))
           (b* ((abnf::csts (cst-console-call-conc2-rep abnf::cst)))
             (cst-list-rep-matchp abnf::csts "assert-equal-call")))
  :rule-classes :rewrite)

Theorem: cst-console-call-conc2-rep-of-tree-fix-cst

(defthm cst-console-call-conc2-rep-of-tree-fix-cst
  (equal (cst-console-call-conc2-rep (abnf::tree-fix abnf::cst))
         (cst-console-call-conc2-rep abnf::cst)))

Theorem: cst-console-call-conc2-rep-tree-equiv-congruence-on-cst

(defthm cst-console-call-conc2-rep-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-console-call-conc2-rep abnf::cst)
                  (cst-console-call-conc2-rep cst-equiv)))
  :rule-classes :congruence)

Function: cst-console-call-conc3-rep

(defun cst-console-call-conc3-rep (abnf::cst)
 (declare (xargs :guard (abnf::treep abnf::cst)))
 (declare
      (xargs :guard (and (cst-matchp abnf::cst "console-call")
                         (equal (cst-console-call-conc? abnf::cst)
                                3))))
 (let ((__function__ 'cst-console-call-conc3-rep))
  (declare (ignorable __function__))
  (abnf::tree-list-fix (nth 0 (cst-console-call-conc3 abnf::cst)))))

Theorem: tree-listp-of-cst-console-call-conc3-rep

(defthm tree-listp-of-cst-console-call-conc3-rep
  (b* ((abnf::csts (cst-console-call-conc3-rep abnf::cst)))
    (abnf::tree-listp abnf::csts))
  :rule-classes :rewrite)

Theorem: cst-console-call-conc3-rep-match

(defthm cst-console-call-conc3-rep-match
  (implies
       (and (cst-matchp abnf::cst "console-call")
            (equal (cst-console-call-conc? abnf::cst)
                   3))
       (b* ((abnf::csts (cst-console-call-conc3-rep abnf::cst)))
         (cst-list-rep-matchp abnf::csts "assert-not-equal-call")))
  :rule-classes :rewrite)

Theorem: cst-console-call-conc3-rep-of-tree-fix-cst

(defthm cst-console-call-conc3-rep-of-tree-fix-cst
  (equal (cst-console-call-conc3-rep (abnf::tree-fix abnf::cst))
         (cst-console-call-conc3-rep abnf::cst)))

Theorem: cst-console-call-conc3-rep-tree-equiv-congruence-on-cst

(defthm cst-console-call-conc3-rep-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-console-call-conc3-rep abnf::cst)
                  (cst-console-call-conc3-rep cst-equiv)))
  :rule-classes :congruence)

Function: cst-program-item-conc1-rep

(defun cst-program-item-conc1-rep (abnf::cst)
 (declare (xargs :guard (abnf::treep abnf::cst)))
 (declare
      (xargs :guard (and (cst-matchp abnf::cst "program-item")
                         (equal (cst-program-item-conc? abnf::cst)
                                1))))
 (let ((__function__ 'cst-program-item-conc1-rep))
  (declare (ignorable __function__))
  (abnf::tree-list-fix (nth 0 (cst-program-item-conc1 abnf::cst)))))

Theorem: tree-listp-of-cst-program-item-conc1-rep

(defthm tree-listp-of-cst-program-item-conc1-rep
  (b* ((abnf::csts (cst-program-item-conc1-rep abnf::cst)))
    (abnf::tree-listp abnf::csts))
  :rule-classes :rewrite)

Theorem: cst-program-item-conc1-rep-match

(defthm cst-program-item-conc1-rep-match
  (implies
       (and (cst-matchp abnf::cst "program-item")
            (equal (cst-program-item-conc? abnf::cst)
                   1))
       (b* ((abnf::csts (cst-program-item-conc1-rep abnf::cst)))
         (cst-list-rep-matchp abnf::csts "function-declaration")))
  :rule-classes :rewrite)

Theorem: cst-program-item-conc1-rep-of-tree-fix-cst

(defthm cst-program-item-conc1-rep-of-tree-fix-cst
  (equal (cst-program-item-conc1-rep (abnf::tree-fix abnf::cst))
         (cst-program-item-conc1-rep abnf::cst)))

Theorem: cst-program-item-conc1-rep-tree-equiv-congruence-on-cst

(defthm cst-program-item-conc1-rep-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-program-item-conc1-rep abnf::cst)
                  (cst-program-item-conc1-rep cst-equiv)))
  :rule-classes :congruence)

Function: cst-program-item-conc2-rep

(defun cst-program-item-conc2-rep (abnf::cst)
 (declare (xargs :guard (abnf::treep abnf::cst)))
 (declare
      (xargs :guard (and (cst-matchp abnf::cst "program-item")
                         (equal (cst-program-item-conc? abnf::cst)
                                2))))
 (let ((__function__ 'cst-program-item-conc2-rep))
  (declare (ignorable __function__))
  (abnf::tree-list-fix (nth 0 (cst-program-item-conc2 abnf::cst)))))

Theorem: tree-listp-of-cst-program-item-conc2-rep

(defthm tree-listp-of-cst-program-item-conc2-rep
  (b* ((abnf::csts (cst-program-item-conc2-rep abnf::cst)))
    (abnf::tree-listp abnf::csts))
  :rule-classes :rewrite)

Theorem: cst-program-item-conc2-rep-match

(defthm cst-program-item-conc2-rep-match
  (implies
       (and (cst-matchp abnf::cst "program-item")
            (equal (cst-program-item-conc? abnf::cst)
                   2))
       (b* ((abnf::csts (cst-program-item-conc2-rep abnf::cst)))
         (cst-list-rep-matchp abnf::csts "transition-declaration")))
  :rule-classes :rewrite)

Theorem: cst-program-item-conc2-rep-of-tree-fix-cst

(defthm cst-program-item-conc2-rep-of-tree-fix-cst
  (equal (cst-program-item-conc2-rep (abnf::tree-fix abnf::cst))
         (cst-program-item-conc2-rep abnf::cst)))

Theorem: cst-program-item-conc2-rep-tree-equiv-congruence-on-cst

(defthm cst-program-item-conc2-rep-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-program-item-conc2-rep abnf::cst)
                  (cst-program-item-conc2-rep cst-equiv)))
  :rule-classes :congruence)

Function: cst-program-item-conc3-rep

(defun cst-program-item-conc3-rep (abnf::cst)
 (declare (xargs :guard (abnf::treep abnf::cst)))
 (declare
      (xargs :guard (and (cst-matchp abnf::cst "program-item")
                         (equal (cst-program-item-conc? abnf::cst)
                                3))))
 (let ((__function__ 'cst-program-item-conc3-rep))
  (declare (ignorable __function__))
  (abnf::tree-list-fix (nth 0 (cst-program-item-conc3 abnf::cst)))))

Theorem: tree-listp-of-cst-program-item-conc3-rep

(defthm tree-listp-of-cst-program-item-conc3-rep
  (b* ((abnf::csts (cst-program-item-conc3-rep abnf::cst)))
    (abnf::tree-listp abnf::csts))
  :rule-classes :rewrite)

Theorem: cst-program-item-conc3-rep-match

(defthm cst-program-item-conc3-rep-match
  (implies (and (cst-matchp abnf::cst "program-item")
                (equal (cst-program-item-conc? abnf::cst)
                       3))
           (b* ((abnf::csts (cst-program-item-conc3-rep abnf::cst)))
             (cst-list-rep-matchp abnf::csts "struct-declaration")))
  :rule-classes :rewrite)

Theorem: cst-program-item-conc3-rep-of-tree-fix-cst

(defthm cst-program-item-conc3-rep-of-tree-fix-cst
  (equal (cst-program-item-conc3-rep (abnf::tree-fix abnf::cst))
         (cst-program-item-conc3-rep abnf::cst)))

Theorem: cst-program-item-conc3-rep-tree-equiv-congruence-on-cst

(defthm cst-program-item-conc3-rep-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-program-item-conc3-rep abnf::cst)
                  (cst-program-item-conc3-rep cst-equiv)))
  :rule-classes :congruence)

Function: cst-program-item-conc4-rep

(defun cst-program-item-conc4-rep (abnf::cst)
 (declare (xargs :guard (abnf::treep abnf::cst)))
 (declare
      (xargs :guard (and (cst-matchp abnf::cst "program-item")
                         (equal (cst-program-item-conc? abnf::cst)
                                4))))
 (let ((__function__ 'cst-program-item-conc4-rep))
  (declare (ignorable __function__))
  (abnf::tree-list-fix (nth 0 (cst-program-item-conc4 abnf::cst)))))

Theorem: tree-listp-of-cst-program-item-conc4-rep

(defthm tree-listp-of-cst-program-item-conc4-rep
  (b* ((abnf::csts (cst-program-item-conc4-rep abnf::cst)))
    (abnf::tree-listp abnf::csts))
  :rule-classes :rewrite)

Theorem: cst-program-item-conc4-rep-match

(defthm cst-program-item-conc4-rep-match
  (implies (and (cst-matchp abnf::cst "program-item")
                (equal (cst-program-item-conc? abnf::cst)
                       4))
           (b* ((abnf::csts (cst-program-item-conc4-rep abnf::cst)))
             (cst-list-rep-matchp abnf::csts "record-declaration")))
  :rule-classes :rewrite)

Theorem: cst-program-item-conc4-rep-of-tree-fix-cst

(defthm cst-program-item-conc4-rep-of-tree-fix-cst
  (equal (cst-program-item-conc4-rep (abnf::tree-fix abnf::cst))
         (cst-program-item-conc4-rep abnf::cst)))

Theorem: cst-program-item-conc4-rep-tree-equiv-congruence-on-cst

(defthm cst-program-item-conc4-rep-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-program-item-conc4-rep abnf::cst)
                  (cst-program-item-conc4-rep cst-equiv)))
  :rule-classes :congruence)

Function: cst-program-item-conc5-rep

(defun cst-program-item-conc5-rep (abnf::cst)
 (declare (xargs :guard (abnf::treep abnf::cst)))
 (declare
      (xargs :guard (and (cst-matchp abnf::cst "program-item")
                         (equal (cst-program-item-conc? abnf::cst)
                                5))))
 (let ((__function__ 'cst-program-item-conc5-rep))
  (declare (ignorable __function__))
  (abnf::tree-list-fix (nth 0 (cst-program-item-conc5 abnf::cst)))))

Theorem: tree-listp-of-cst-program-item-conc5-rep

(defthm tree-listp-of-cst-program-item-conc5-rep
  (b* ((abnf::csts (cst-program-item-conc5-rep abnf::cst)))
    (abnf::tree-listp abnf::csts))
  :rule-classes :rewrite)

Theorem: cst-program-item-conc5-rep-match

(defthm cst-program-item-conc5-rep-match
 (implies (and (cst-matchp abnf::cst "program-item")
               (equal (cst-program-item-conc? abnf::cst)
                      5))
          (b* ((abnf::csts (cst-program-item-conc5-rep abnf::cst)))
            (cst-list-rep-matchp abnf::csts "mapping-declaration")))
 :rule-classes :rewrite)

Theorem: cst-program-item-conc5-rep-of-tree-fix-cst

(defthm cst-program-item-conc5-rep-of-tree-fix-cst
  (equal (cst-program-item-conc5-rep (abnf::tree-fix abnf::cst))
         (cst-program-item-conc5-rep abnf::cst)))

Theorem: cst-program-item-conc5-rep-tree-equiv-congruence-on-cst

(defthm cst-program-item-conc5-rep-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-program-item-conc5-rep abnf::cst)
                  (cst-program-item-conc5-rep cst-equiv)))
  :rule-classes :congruence)

Function: cst-input-type-conc-rep

(defun cst-input-type-conc-rep (abnf::cst)
  (declare (xargs :guard (abnf::treep abnf::cst)))
  (declare (xargs :guard (cst-matchp abnf::cst "input-type")))
  (let ((__function__ 'cst-input-type-conc-rep))
    (declare (ignorable __function__))
    (abnf::tree-list-fix (nth 0 (cst-input-type-conc abnf::cst)))))

Theorem: tree-listp-of-cst-input-type-conc-rep

(defthm tree-listp-of-cst-input-type-conc-rep
  (b* ((abnf::csts (cst-input-type-conc-rep abnf::cst)))
    (abnf::tree-listp abnf::csts))
  :rule-classes :rewrite)

Theorem: cst-input-type-conc-rep-match

(defthm cst-input-type-conc-rep-match
  (implies (cst-matchp abnf::cst "input-type")
           (b* ((abnf::csts (cst-input-type-conc-rep abnf::cst)))
             (cst-list-rep-matchp abnf::csts "type")))
  :rule-classes :rewrite)

Theorem: cst-input-type-conc-rep-of-tree-fix-cst

(defthm cst-input-type-conc-rep-of-tree-fix-cst
  (equal (cst-input-type-conc-rep (abnf::tree-fix abnf::cst))
         (cst-input-type-conc-rep abnf::cst)))

Theorem: cst-input-type-conc-rep-tree-equiv-congruence-on-cst

(defthm cst-input-type-conc-rep-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-input-type-conc-rep abnf::cst)
                  (cst-input-type-conc-rep cst-equiv)))
  :rule-classes :congruence)

Function: cst-input-expression-conc-rep

(defun cst-input-expression-conc-rep (abnf::cst)
  (declare (xargs :guard (abnf::treep abnf::cst)))
  (declare (xargs :guard (cst-matchp abnf::cst "input-expression")))
  (let ((__function__ 'cst-input-expression-conc-rep))
    (declare (ignorable __function__))
    (abnf::tree-list-fix
         (nth 0
              (cst-input-expression-conc abnf::cst)))))

Theorem: tree-listp-of-cst-input-expression-conc-rep

(defthm tree-listp-of-cst-input-expression-conc-rep
  (b* ((abnf::csts (cst-input-expression-conc-rep abnf::cst)))
    (abnf::tree-listp abnf::csts))
  :rule-classes :rewrite)

Theorem: cst-input-expression-conc-rep-match

(defthm cst-input-expression-conc-rep-match
  (implies
       (cst-matchp abnf::cst "input-expression")
       (b* ((abnf::csts (cst-input-expression-conc-rep abnf::cst)))
         (cst-list-rep-matchp abnf::csts "expression")))
  :rule-classes :rewrite)

Theorem: cst-input-expression-conc-rep-of-tree-fix-cst

(defthm cst-input-expression-conc-rep-of-tree-fix-cst
  (equal (cst-input-expression-conc-rep (abnf::tree-fix abnf::cst))
         (cst-input-expression-conc-rep abnf::cst)))

Theorem: cst-input-expression-conc-rep-tree-equiv-congruence-on-cst

(defthm cst-input-expression-conc-rep-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-input-expression-conc-rep abnf::cst)
                  (cst-input-expression-conc-rep cst-equiv)))
  :rule-classes :congruence)

Function: cst-output-expression-conc-rep

(defun cst-output-expression-conc-rep (abnf::cst)
 (declare (xargs :guard (abnf::treep abnf::cst)))
 (declare (xargs :guard (cst-matchp abnf::cst "output-expression")))
 (let ((__function__ 'cst-output-expression-conc-rep))
   (declare (ignorable __function__))
   (abnf::tree-list-fix
        (nth 0
             (cst-output-expression-conc abnf::cst)))))

Theorem: tree-listp-of-cst-output-expression-conc-rep

(defthm tree-listp-of-cst-output-expression-conc-rep
  (b* ((abnf::csts (cst-output-expression-conc-rep abnf::cst)))
    (abnf::tree-listp abnf::csts))
  :rule-classes :rewrite)

Theorem: cst-output-expression-conc-rep-match

(defthm cst-output-expression-conc-rep-match
  (implies
       (cst-matchp abnf::cst "output-expression")
       (b* ((abnf::csts (cst-output-expression-conc-rep abnf::cst)))
         (cst-list-rep-matchp abnf::csts "expression")))
  :rule-classes :rewrite)

Theorem: cst-output-expression-conc-rep-of-tree-fix-cst

(defthm cst-output-expression-conc-rep-of-tree-fix-cst
  (equal (cst-output-expression-conc-rep (abnf::tree-fix abnf::cst))
         (cst-output-expression-conc-rep abnf::cst)))

Theorem: cst-output-expression-conc-rep-tree-equiv-congruence-on-cst

(defthm cst-output-expression-conc-rep-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-output-expression-conc-rep abnf::cst)
                  (cst-output-expression-conc-rep cst-equiv)))
  :rule-classes :congruence)

Function: cst-output-file-conc-rep

(defun cst-output-file-conc-rep (abnf::cst)
  (declare (xargs :guard (abnf::treep abnf::cst)))
  (declare (xargs :guard (cst-matchp abnf::cst "output-file")))
  (let ((__function__ 'cst-output-file-conc-rep))
    (declare (ignorable __function__))
    (abnf::tree-list-fix (nth 0 (cst-output-file-conc abnf::cst)))))

Theorem: tree-listp-of-cst-output-file-conc-rep

(defthm tree-listp-of-cst-output-file-conc-rep
  (b* ((abnf::csts (cst-output-file-conc-rep abnf::cst)))
    (abnf::tree-listp abnf::csts))
  :rule-classes :rewrite)

Theorem: cst-output-file-conc-rep-match

(defthm cst-output-file-conc-rep-match
  (implies (cst-matchp abnf::cst "output-file")
           (b* ((abnf::csts (cst-output-file-conc-rep abnf::cst)))
             (cst-list-rep-matchp abnf::csts "output-section")))
  :rule-classes :rewrite)

Theorem: cst-output-file-conc-rep-of-tree-fix-cst

(defthm cst-output-file-conc-rep-of-tree-fix-cst
  (equal (cst-output-file-conc-rep (abnf::tree-fix abnf::cst))
         (cst-output-file-conc-rep abnf::cst)))

Theorem: cst-output-file-conc-rep-tree-equiv-congruence-on-cst

(defthm cst-output-file-conc-rep-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-output-file-conc-rep abnf::cst)
                  (cst-output-file-conc-rep cst-equiv)))
  :rule-classes :congruence)

Function: cst-horizontal-tab-conc-rep-elem

(defun cst-horizontal-tab-conc-rep-elem (abnf::cst)
  (declare (xargs :guard (abnf::treep abnf::cst)))
  (declare (xargs :guard (cst-matchp abnf::cst "horizontal-tab")))
  (let ((__function__ 'cst-horizontal-tab-conc-rep-elem))
    (declare (ignorable __function__))
    (abnf::tree-fix (nth 0
                         (cst-horizontal-tab-conc-rep abnf::cst)))))

Theorem: treep-of-cst-horizontal-tab-conc-rep-elem

(defthm treep-of-cst-horizontal-tab-conc-rep-elem
  (b* ((abnf::cst1 (cst-horizontal-tab-conc-rep-elem abnf::cst)))
    (abnf::treep abnf::cst1))
  :rule-classes :rewrite)

Theorem: cst-horizontal-tab-conc-rep-elem-match

(defthm cst-horizontal-tab-conc-rep-elem-match
 (implies
     (cst-matchp abnf::cst "horizontal-tab")
     (b* ((abnf::cst1 (cst-horizontal-tab-conc-rep-elem abnf::cst)))
       (cst-matchp abnf::cst1 "%x9")))
 :rule-classes :rewrite)

Theorem: cst-horizontal-tab-conc-rep-elem-of-tree-fix-cst

(defthm cst-horizontal-tab-conc-rep-elem-of-tree-fix-cst
  (equal
       (cst-horizontal-tab-conc-rep-elem (abnf::tree-fix abnf::cst))
       (cst-horizontal-tab-conc-rep-elem abnf::cst)))

Theorem: cst-horizontal-tab-conc-rep-elem-tree-equiv-congruence-on-cst

(defthm
      cst-horizontal-tab-conc-rep-elem-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-horizontal-tab-conc-rep-elem abnf::cst)
                  (cst-horizontal-tab-conc-rep-elem cst-equiv)))
  :rule-classes :congruence)

Function: cst-line-feed-conc-rep-elem

(defun cst-line-feed-conc-rep-elem (abnf::cst)
  (declare (xargs :guard (abnf::treep abnf::cst)))
  (declare (xargs :guard (cst-matchp abnf::cst "line-feed")))
  (let ((__function__ 'cst-line-feed-conc-rep-elem))
    (declare (ignorable __function__))
    (abnf::tree-fix (nth 0 (cst-line-feed-conc-rep abnf::cst)))))

Theorem: treep-of-cst-line-feed-conc-rep-elem

(defthm treep-of-cst-line-feed-conc-rep-elem
  (b* ((abnf::cst1 (cst-line-feed-conc-rep-elem abnf::cst)))
    (abnf::treep abnf::cst1))
  :rule-classes :rewrite)

Theorem: cst-line-feed-conc-rep-elem-match

(defthm cst-line-feed-conc-rep-elem-match
 (implies (cst-matchp abnf::cst "line-feed")
          (b* ((abnf::cst1 (cst-line-feed-conc-rep-elem abnf::cst)))
            (cst-matchp abnf::cst1 "%xA")))
 :rule-classes :rewrite)

Theorem: cst-line-feed-conc-rep-elem-of-tree-fix-cst

(defthm cst-line-feed-conc-rep-elem-of-tree-fix-cst
  (equal (cst-line-feed-conc-rep-elem (abnf::tree-fix abnf::cst))
         (cst-line-feed-conc-rep-elem abnf::cst)))

Theorem: cst-line-feed-conc-rep-elem-tree-equiv-congruence-on-cst

(defthm cst-line-feed-conc-rep-elem-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-line-feed-conc-rep-elem abnf::cst)
                  (cst-line-feed-conc-rep-elem cst-equiv)))
  :rule-classes :congruence)

Function: cst-carriage-return-conc-rep-elem

(defun cst-carriage-return-conc-rep-elem (abnf::cst)
 (declare (xargs :guard (abnf::treep abnf::cst)))
 (declare (xargs :guard (cst-matchp abnf::cst "carriage-return")))
 (let ((__function__ 'cst-carriage-return-conc-rep-elem))
   (declare (ignorable __function__))
   (abnf::tree-fix (nth 0
                        (cst-carriage-return-conc-rep abnf::cst)))))

Theorem: treep-of-cst-carriage-return-conc-rep-elem

(defthm treep-of-cst-carriage-return-conc-rep-elem
  (b* ((abnf::cst1 (cst-carriage-return-conc-rep-elem abnf::cst)))
    (abnf::treep abnf::cst1))
  :rule-classes :rewrite)

Theorem: cst-carriage-return-conc-rep-elem-match

(defthm cst-carriage-return-conc-rep-elem-match
 (implies
    (cst-matchp abnf::cst "carriage-return")
    (b* ((abnf::cst1 (cst-carriage-return-conc-rep-elem abnf::cst)))
      (cst-matchp abnf::cst1 "%xD")))
 :rule-classes :rewrite)

Theorem: cst-carriage-return-conc-rep-elem-of-tree-fix-cst

(defthm cst-carriage-return-conc-rep-elem-of-tree-fix-cst
 (equal
      (cst-carriage-return-conc-rep-elem (abnf::tree-fix abnf::cst))
      (cst-carriage-return-conc-rep-elem abnf::cst)))

Theorem: cst-carriage-return-conc-rep-elem-tree-equiv-congruence-on-cst

(defthm
     cst-carriage-return-conc-rep-elem-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-carriage-return-conc-rep-elem abnf::cst)
                  (cst-carriage-return-conc-rep-elem cst-equiv)))
  :rule-classes :congruence)

Function: cst-space-conc-rep-elem

(defun cst-space-conc-rep-elem (abnf::cst)
  (declare (xargs :guard (abnf::treep abnf::cst)))
  (declare (xargs :guard (cst-matchp abnf::cst "space")))
  (let ((__function__ 'cst-space-conc-rep-elem))
    (declare (ignorable __function__))
    (abnf::tree-fix (nth 0 (cst-space-conc-rep abnf::cst)))))

Theorem: treep-of-cst-space-conc-rep-elem

(defthm treep-of-cst-space-conc-rep-elem
  (b* ((abnf::cst1 (cst-space-conc-rep-elem abnf::cst)))
    (abnf::treep abnf::cst1))
  :rule-classes :rewrite)

Theorem: cst-space-conc-rep-elem-match

(defthm cst-space-conc-rep-elem-match
  (implies (cst-matchp abnf::cst "space")
           (b* ((abnf::cst1 (cst-space-conc-rep-elem abnf::cst)))
             (cst-matchp abnf::cst1 "%x20")))
  :rule-classes :rewrite)

Theorem: cst-space-conc-rep-elem-of-tree-fix-cst

(defthm cst-space-conc-rep-elem-of-tree-fix-cst
  (equal (cst-space-conc-rep-elem (abnf::tree-fix abnf::cst))
         (cst-space-conc-rep-elem abnf::cst)))

Theorem: cst-space-conc-rep-elem-tree-equiv-congruence-on-cst

(defthm cst-space-conc-rep-elem-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-space-conc-rep-elem abnf::cst)
                  (cst-space-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 "horizontal-tab")))
  :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 "line-feed")))
  :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 "carriage-return")))
  :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 "space")))
  :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-whitespace-conc1-rep-elem

(defun cst-whitespace-conc1-rep-elem (abnf::cst)
 (declare (xargs :guard (abnf::treep abnf::cst)))
 (declare (xargs :guard (and (cst-matchp abnf::cst "whitespace")
                             (equal (cst-whitespace-conc? abnf::cst)
                                    1))))
 (let ((__function__ 'cst-whitespace-conc1-rep-elem))
   (declare (ignorable __function__))
   (abnf::tree-fix (nth 0
                        (cst-whitespace-conc1-rep abnf::cst)))))

Theorem: treep-of-cst-whitespace-conc1-rep-elem

(defthm treep-of-cst-whitespace-conc1-rep-elem
  (b* ((abnf::cst1 (cst-whitespace-conc1-rep-elem abnf::cst)))
    (abnf::treep abnf::cst1))
  :rule-classes :rewrite)

Theorem: cst-whitespace-conc1-rep-elem-match

(defthm cst-whitespace-conc1-rep-elem-match
  (implies
       (and (cst-matchp abnf::cst "whitespace")
            (equal (cst-whitespace-conc? abnf::cst)
                   1))
       (b* ((abnf::cst1 (cst-whitespace-conc1-rep-elem abnf::cst)))
         (cst-matchp abnf::cst1 "space")))
  :rule-classes :rewrite)

Theorem: cst-whitespace-conc1-rep-elem-of-tree-fix-cst

(defthm cst-whitespace-conc1-rep-elem-of-tree-fix-cst
  (equal (cst-whitespace-conc1-rep-elem (abnf::tree-fix abnf::cst))
         (cst-whitespace-conc1-rep-elem abnf::cst)))

Theorem: cst-whitespace-conc1-rep-elem-tree-equiv-congruence-on-cst

(defthm cst-whitespace-conc1-rep-elem-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-whitespace-conc1-rep-elem abnf::cst)
                  (cst-whitespace-conc1-rep-elem cst-equiv)))
  :rule-classes :congruence)

Function: cst-whitespace-conc2-rep-elem

(defun cst-whitespace-conc2-rep-elem (abnf::cst)
 (declare (xargs :guard (abnf::treep abnf::cst)))
 (declare (xargs :guard (and (cst-matchp abnf::cst "whitespace")
                             (equal (cst-whitespace-conc? abnf::cst)
                                    2))))
 (let ((__function__ 'cst-whitespace-conc2-rep-elem))
   (declare (ignorable __function__))
   (abnf::tree-fix (nth 0
                        (cst-whitespace-conc2-rep abnf::cst)))))

Theorem: treep-of-cst-whitespace-conc2-rep-elem

(defthm treep-of-cst-whitespace-conc2-rep-elem
  (b* ((abnf::cst1 (cst-whitespace-conc2-rep-elem abnf::cst)))
    (abnf::treep abnf::cst1))
  :rule-classes :rewrite)

Theorem: cst-whitespace-conc2-rep-elem-match

(defthm cst-whitespace-conc2-rep-elem-match
  (implies
       (and (cst-matchp abnf::cst "whitespace")
            (equal (cst-whitespace-conc? abnf::cst)
                   2))
       (b* ((abnf::cst1 (cst-whitespace-conc2-rep-elem abnf::cst)))
         (cst-matchp abnf::cst1 "horizontal-tab")))
  :rule-classes :rewrite)

Theorem: cst-whitespace-conc2-rep-elem-of-tree-fix-cst

(defthm cst-whitespace-conc2-rep-elem-of-tree-fix-cst
  (equal (cst-whitespace-conc2-rep-elem (abnf::tree-fix abnf::cst))
         (cst-whitespace-conc2-rep-elem abnf::cst)))

Theorem: cst-whitespace-conc2-rep-elem-tree-equiv-congruence-on-cst

(defthm cst-whitespace-conc2-rep-elem-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-whitespace-conc2-rep-elem abnf::cst)
                  (cst-whitespace-conc2-rep-elem cst-equiv)))
  :rule-classes :congruence)

Function: cst-whitespace-conc3-rep-elem

(defun cst-whitespace-conc3-rep-elem (abnf::cst)
 (declare (xargs :guard (abnf::treep abnf::cst)))
 (declare (xargs :guard (and (cst-matchp abnf::cst "whitespace")
                             (equal (cst-whitespace-conc? abnf::cst)
                                    3))))
 (let ((__function__ 'cst-whitespace-conc3-rep-elem))
   (declare (ignorable __function__))
   (abnf::tree-fix (nth 0
                        (cst-whitespace-conc3-rep abnf::cst)))))

Theorem: treep-of-cst-whitespace-conc3-rep-elem

(defthm treep-of-cst-whitespace-conc3-rep-elem
  (b* ((abnf::cst1 (cst-whitespace-conc3-rep-elem abnf::cst)))
    (abnf::treep abnf::cst1))
  :rule-classes :rewrite)

Theorem: cst-whitespace-conc3-rep-elem-match

(defthm cst-whitespace-conc3-rep-elem-match
  (implies
       (and (cst-matchp abnf::cst "whitespace")
            (equal (cst-whitespace-conc? abnf::cst)
                   3))
       (b* ((abnf::cst1 (cst-whitespace-conc3-rep-elem abnf::cst)))
         (cst-matchp abnf::cst1 "line-terminator")))
  :rule-classes :rewrite)

Theorem: cst-whitespace-conc3-rep-elem-of-tree-fix-cst

(defthm cst-whitespace-conc3-rep-elem-of-tree-fix-cst
  (equal (cst-whitespace-conc3-rep-elem (abnf::tree-fix abnf::cst))
         (cst-whitespace-conc3-rep-elem abnf::cst)))

Theorem: cst-whitespace-conc3-rep-elem-tree-equiv-congruence-on-cst

(defthm cst-whitespace-conc3-rep-elem-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-whitespace-conc3-rep-elem abnf::cst)
                  (cst-whitespace-conc3-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 "block-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 "line-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-line-feed-or-carriage-return-conc1-rep-elem

(defun cst-not-line-feed-or-carriage-return-conc1-rep-elem
       (abnf::cst)
 (declare (xargs :guard (abnf::treep abnf::cst)))
 (declare
  (xargs
   :guard
   (and
       (cst-matchp abnf::cst
                   "not-line-feed-or-carriage-return")
       (equal (cst-not-line-feed-or-carriage-return-conc? abnf::cst)
              1))))
 (let ((__function__
            'cst-not-line-feed-or-carriage-return-conc1-rep-elem))
  (declare (ignorable __function__))
  (abnf::tree-fix
   (nth
      0
      (cst-not-line-feed-or-carriage-return-conc1-rep abnf::cst)))))

Theorem: treep-of-cst-not-line-feed-or-carriage-return-conc1-rep-elem

(defthm treep-of-cst-not-line-feed-or-carriage-return-conc1-rep-elem
  (b* ((abnf::cst1 (cst-not-line-feed-or-carriage-return-conc1-rep-elem
                        abnf::cst)))
    (abnf::treep abnf::cst1))
  :rule-classes :rewrite)

Theorem: cst-not-line-feed-or-carriage-return-conc1-rep-elem-match

(defthm cst-not-line-feed-or-carriage-return-conc1-rep-elem-match
 (implies
  (and (cst-matchp abnf::cst
                   "not-line-feed-or-carriage-return")
       (equal (cst-not-line-feed-or-carriage-return-conc? abnf::cst)
              1))
  (b* ((abnf::cst1 (cst-not-line-feed-or-carriage-return-conc1-rep-elem
                        abnf::cst)))
    (cst-matchp abnf::cst1 "horizontal-tab")))
 :rule-classes :rewrite)

Theorem: cst-not-line-feed-or-carriage-return-conc1-rep-elem-of-tree-fix-cst

(defthm
 cst-not-line-feed-or-carriage-return-conc1-rep-elem-of-tree-fix-cst
 (equal
   (cst-not-line-feed-or-carriage-return-conc1-rep-elem
        (abnf::tree-fix abnf::cst))
   (cst-not-line-feed-or-carriage-return-conc1-rep-elem abnf::cst)))

Theorem: cst-not-line-feed-or-carriage-return-conc1-rep-elem-tree-equiv-congruence-on-cst

(defthm
 cst-not-line-feed-or-carriage-return-conc1-rep-elem-tree-equiv-congruence-on-cst
 (implies
  (abnf::tree-equiv abnf::cst cst-equiv)
  (equal
   (cst-not-line-feed-or-carriage-return-conc1-rep-elem abnf::cst)
   (cst-not-line-feed-or-carriage-return-conc1-rep-elem cst-equiv)))
 :rule-classes :congruence)

Function: cst-not-line-feed-or-carriage-return-conc2-rep-elem

(defun cst-not-line-feed-or-carriage-return-conc2-rep-elem
       (abnf::cst)
 (declare (xargs :guard (abnf::treep abnf::cst)))
 (declare
  (xargs
   :guard
   (and
       (cst-matchp abnf::cst
                   "not-line-feed-or-carriage-return")
       (equal (cst-not-line-feed-or-carriage-return-conc? abnf::cst)
              2))))
 (let ((__function__
            'cst-not-line-feed-or-carriage-return-conc2-rep-elem))
  (declare (ignorable __function__))
  (abnf::tree-fix
   (nth
      0
      (cst-not-line-feed-or-carriage-return-conc2-rep abnf::cst)))))

Theorem: treep-of-cst-not-line-feed-or-carriage-return-conc2-rep-elem

(defthm treep-of-cst-not-line-feed-or-carriage-return-conc2-rep-elem
  (b* ((abnf::cst1 (cst-not-line-feed-or-carriage-return-conc2-rep-elem
                        abnf::cst)))
    (abnf::treep abnf::cst1))
  :rule-classes :rewrite)

Theorem: cst-not-line-feed-or-carriage-return-conc2-rep-elem-match

(defthm cst-not-line-feed-or-carriage-return-conc2-rep-elem-match
 (implies
  (and (cst-matchp abnf::cst
                   "not-line-feed-or-carriage-return")
       (equal (cst-not-line-feed-or-carriage-return-conc? abnf::cst)
              2))
  (b* ((abnf::cst1 (cst-not-line-feed-or-carriage-return-conc2-rep-elem
                        abnf::cst)))
    (cst-matchp abnf::cst1 "space")))
 :rule-classes :rewrite)

Theorem: cst-not-line-feed-or-carriage-return-conc2-rep-elem-of-tree-fix-cst

(defthm
 cst-not-line-feed-or-carriage-return-conc2-rep-elem-of-tree-fix-cst
 (equal
   (cst-not-line-feed-or-carriage-return-conc2-rep-elem
        (abnf::tree-fix abnf::cst))
   (cst-not-line-feed-or-carriage-return-conc2-rep-elem abnf::cst)))

Theorem: cst-not-line-feed-or-carriage-return-conc2-rep-elem-tree-equiv-congruence-on-cst

(defthm
 cst-not-line-feed-or-carriage-return-conc2-rep-elem-tree-equiv-congruence-on-cst
 (implies
  (abnf::tree-equiv abnf::cst cst-equiv)
  (equal
   (cst-not-line-feed-or-carriage-return-conc2-rep-elem abnf::cst)
   (cst-not-line-feed-or-carriage-return-conc2-rep-elem cst-equiv)))
 :rule-classes :congruence)

Function: cst-not-line-feed-or-carriage-return-conc3-rep-elem

(defun cst-not-line-feed-or-carriage-return-conc3-rep-elem
       (abnf::cst)
 (declare (xargs :guard (abnf::treep abnf::cst)))
 (declare
  (xargs
   :guard
   (and
       (cst-matchp abnf::cst
                   "not-line-feed-or-carriage-return")
       (equal (cst-not-line-feed-or-carriage-return-conc? abnf::cst)
              3))))
 (let ((__function__
            'cst-not-line-feed-or-carriage-return-conc3-rep-elem))
  (declare (ignorable __function__))
  (abnf::tree-fix
   (nth
      0
      (cst-not-line-feed-or-carriage-return-conc3-rep abnf::cst)))))

Theorem: treep-of-cst-not-line-feed-or-carriage-return-conc3-rep-elem

(defthm treep-of-cst-not-line-feed-or-carriage-return-conc3-rep-elem
  (b* ((abnf::cst1 (cst-not-line-feed-or-carriage-return-conc3-rep-elem
                        abnf::cst)))
    (abnf::treep abnf::cst1))
  :rule-classes :rewrite)

Theorem: cst-not-line-feed-or-carriage-return-conc3-rep-elem-match

(defthm cst-not-line-feed-or-carriage-return-conc3-rep-elem-match
 (implies
  (and (cst-matchp abnf::cst
                   "not-line-feed-or-carriage-return")
       (equal (cst-not-line-feed-or-carriage-return-conc? abnf::cst)
              3))
  (b* ((abnf::cst1 (cst-not-line-feed-or-carriage-return-conc3-rep-elem
                        abnf::cst)))
    (cst-matchp abnf::cst1 "visible-ascii")))
 :rule-classes :rewrite)

Theorem: cst-not-line-feed-or-carriage-return-conc3-rep-elem-of-tree-fix-cst

(defthm
 cst-not-line-feed-or-carriage-return-conc3-rep-elem-of-tree-fix-cst
 (equal
   (cst-not-line-feed-or-carriage-return-conc3-rep-elem
        (abnf::tree-fix abnf::cst))
   (cst-not-line-feed-or-carriage-return-conc3-rep-elem abnf::cst)))

Theorem: cst-not-line-feed-or-carriage-return-conc3-rep-elem-tree-equiv-congruence-on-cst

(defthm
 cst-not-line-feed-or-carriage-return-conc3-rep-elem-tree-equiv-congruence-on-cst
 (implies
  (abnf::tree-equiv abnf::cst cst-equiv)
  (equal
   (cst-not-line-feed-or-carriage-return-conc3-rep-elem abnf::cst)
   (cst-not-line-feed-or-carriage-return-conc3-rep-elem cst-equiv)))
 :rule-classes :congruence)

Function: cst-not-line-feed-or-carriage-return-conc4-rep-elem

(defun cst-not-line-feed-or-carriage-return-conc4-rep-elem
       (abnf::cst)
 (declare (xargs :guard (abnf::treep abnf::cst)))
 (declare
  (xargs
   :guard
   (and
       (cst-matchp abnf::cst
                   "not-line-feed-or-carriage-return")
       (equal (cst-not-line-feed-or-carriage-return-conc? abnf::cst)
              4))))
 (let ((__function__
            'cst-not-line-feed-or-carriage-return-conc4-rep-elem))
  (declare (ignorable __function__))
  (abnf::tree-fix
   (nth
      0
      (cst-not-line-feed-or-carriage-return-conc4-rep abnf::cst)))))

Theorem: treep-of-cst-not-line-feed-or-carriage-return-conc4-rep-elem

(defthm treep-of-cst-not-line-feed-or-carriage-return-conc4-rep-elem
  (b* ((abnf::cst1 (cst-not-line-feed-or-carriage-return-conc4-rep-elem
                        abnf::cst)))
    (abnf::treep abnf::cst1))
  :rule-classes :rewrite)

Theorem: cst-not-line-feed-or-carriage-return-conc4-rep-elem-match

(defthm cst-not-line-feed-or-carriage-return-conc4-rep-elem-match
 (implies
  (and (cst-matchp abnf::cst
                   "not-line-feed-or-carriage-return")
       (equal (cst-not-line-feed-or-carriage-return-conc? abnf::cst)
              4))
  (b* ((abnf::cst1 (cst-not-line-feed-or-carriage-return-conc4-rep-elem
                        abnf::cst)))
    (cst-matchp abnf::cst1 "safe-nonascii")))
 :rule-classes :rewrite)

Theorem: cst-not-line-feed-or-carriage-return-conc4-rep-elem-of-tree-fix-cst

(defthm
 cst-not-line-feed-or-carriage-return-conc4-rep-elem-of-tree-fix-cst
 (equal
   (cst-not-line-feed-or-carriage-return-conc4-rep-elem
        (abnf::tree-fix abnf::cst))
   (cst-not-line-feed-or-carriage-return-conc4-rep-elem abnf::cst)))

Theorem: cst-not-line-feed-or-carriage-return-conc4-rep-elem-tree-equiv-congruence-on-cst

(defthm
 cst-not-line-feed-or-carriage-return-conc4-rep-elem-tree-equiv-congruence-on-cst
 (implies
  (abnf::tree-equiv abnf::cst cst-equiv)
  (equal
   (cst-not-line-feed-or-carriage-return-conc4-rep-elem abnf::cst)
   (cst-not-line-feed-or-carriage-return-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-decimal-digit-conc-rep-elem

(defun cst-decimal-digit-conc-rep-elem (abnf::cst)
  (declare (xargs :guard (abnf::treep abnf::cst)))
  (declare (xargs :guard (cst-matchp abnf::cst "decimal-digit")))
  (let ((__function__ 'cst-decimal-digit-conc-rep-elem))
    (declare (ignorable __function__))
    (abnf::tree-fix (nth 0
                         (cst-decimal-digit-conc-rep abnf::cst)))))

Theorem: treep-of-cst-decimal-digit-conc-rep-elem

(defthm treep-of-cst-decimal-digit-conc-rep-elem
  (b* ((abnf::cst1 (cst-decimal-digit-conc-rep-elem abnf::cst)))
    (abnf::treep abnf::cst1))
  :rule-classes :rewrite)

Theorem: cst-decimal-digit-conc-rep-elem-match

(defthm cst-decimal-digit-conc-rep-elem-match
 (implies
      (cst-matchp abnf::cst "decimal-digit")
      (b* ((abnf::cst1 (cst-decimal-digit-conc-rep-elem abnf::cst)))
        (cst-matchp abnf::cst1 "%x30-39")))
 :rule-classes :rewrite)

Theorem: cst-decimal-digit-conc-rep-elem-of-tree-fix-cst

(defthm cst-decimal-digit-conc-rep-elem-of-tree-fix-cst
 (equal (cst-decimal-digit-conc-rep-elem (abnf::tree-fix abnf::cst))
        (cst-decimal-digit-conc-rep-elem abnf::cst)))

Theorem: cst-decimal-digit-conc-rep-elem-tree-equiv-congruence-on-cst

(defthm cst-decimal-digit-conc-rep-elem-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-decimal-digit-conc-rep-elem abnf::cst)
                  (cst-decimal-digit-conc-rep-elem cst-equiv)))
  :rule-classes :congruence)

Function: cst-octal-digit-conc-rep-elem

(defun cst-octal-digit-conc-rep-elem (abnf::cst)
  (declare (xargs :guard (abnf::treep abnf::cst)))
  (declare (xargs :guard (cst-matchp abnf::cst "octal-digit")))
  (let ((__function__ 'cst-octal-digit-conc-rep-elem))
    (declare (ignorable __function__))
    (abnf::tree-fix (nth 0
                         (cst-octal-digit-conc-rep abnf::cst)))))

Theorem: treep-of-cst-octal-digit-conc-rep-elem

(defthm treep-of-cst-octal-digit-conc-rep-elem
  (b* ((abnf::cst1 (cst-octal-digit-conc-rep-elem abnf::cst)))
    (abnf::treep abnf::cst1))
  :rule-classes :rewrite)

Theorem: cst-octal-digit-conc-rep-elem-match

(defthm cst-octal-digit-conc-rep-elem-match
  (implies
       (cst-matchp abnf::cst "octal-digit")
       (b* ((abnf::cst1 (cst-octal-digit-conc-rep-elem abnf::cst)))
         (cst-matchp abnf::cst1 "%x30-37")))
  :rule-classes :rewrite)

Theorem: cst-octal-digit-conc-rep-elem-of-tree-fix-cst

(defthm cst-octal-digit-conc-rep-elem-of-tree-fix-cst
  (equal (cst-octal-digit-conc-rep-elem (abnf::tree-fix abnf::cst))
         (cst-octal-digit-conc-rep-elem abnf::cst)))

Theorem: cst-octal-digit-conc-rep-elem-tree-equiv-congruence-on-cst

(defthm cst-octal-digit-conc-rep-elem-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-octal-digit-conc-rep-elem abnf::cst)
                  (cst-octal-digit-conc-rep-elem cst-equiv)))
  :rule-classes :congruence)

Function: cst-single-quote-conc-rep-elem

(defun cst-single-quote-conc-rep-elem (abnf::cst)
  (declare (xargs :guard (abnf::treep abnf::cst)))
  (declare (xargs :guard (cst-matchp abnf::cst "single-quote")))
  (let ((__function__ 'cst-single-quote-conc-rep-elem))
    (declare (ignorable __function__))
    (abnf::tree-fix (nth 0
                         (cst-single-quote-conc-rep abnf::cst)))))

Theorem: treep-of-cst-single-quote-conc-rep-elem

(defthm treep-of-cst-single-quote-conc-rep-elem
  (b* ((abnf::cst1 (cst-single-quote-conc-rep-elem abnf::cst)))
    (abnf::treep abnf::cst1))
  :rule-classes :rewrite)

Theorem: cst-single-quote-conc-rep-elem-match

(defthm cst-single-quote-conc-rep-elem-match
  (implies
       (cst-matchp abnf::cst "single-quote")
       (b* ((abnf::cst1 (cst-single-quote-conc-rep-elem abnf::cst)))
         (cst-matchp abnf::cst1 "%x27")))
  :rule-classes :rewrite)

Theorem: cst-single-quote-conc-rep-elem-of-tree-fix-cst

(defthm cst-single-quote-conc-rep-elem-of-tree-fix-cst
  (equal (cst-single-quote-conc-rep-elem (abnf::tree-fix abnf::cst))
         (cst-single-quote-conc-rep-elem abnf::cst)))

Theorem: cst-single-quote-conc-rep-elem-tree-equiv-congruence-on-cst

(defthm cst-single-quote-conc-rep-elem-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-single-quote-conc-rep-elem abnf::cst)
                  (cst-single-quote-conc-rep-elem cst-equiv)))
  :rule-classes :congruence)

Function: cst-double-quote-conc-rep-elem

(defun cst-double-quote-conc-rep-elem (abnf::cst)
  (declare (xargs :guard (abnf::treep abnf::cst)))
  (declare (xargs :guard (cst-matchp abnf::cst "double-quote")))
  (let ((__function__ 'cst-double-quote-conc-rep-elem))
    (declare (ignorable __function__))
    (abnf::tree-fix (nth 0
                         (cst-double-quote-conc-rep abnf::cst)))))

Theorem: treep-of-cst-double-quote-conc-rep-elem

(defthm treep-of-cst-double-quote-conc-rep-elem
  (b* ((abnf::cst1 (cst-double-quote-conc-rep-elem abnf::cst)))
    (abnf::treep abnf::cst1))
  :rule-classes :rewrite)

Theorem: cst-double-quote-conc-rep-elem-match

(defthm cst-double-quote-conc-rep-elem-match
  (implies
       (cst-matchp abnf::cst "double-quote")
       (b* ((abnf::cst1 (cst-double-quote-conc-rep-elem abnf::cst)))
         (cst-matchp abnf::cst1 "%x22")))
  :rule-classes :rewrite)

Theorem: cst-double-quote-conc-rep-elem-of-tree-fix-cst

(defthm cst-double-quote-conc-rep-elem-of-tree-fix-cst
  (equal (cst-double-quote-conc-rep-elem (abnf::tree-fix abnf::cst))
         (cst-double-quote-conc-rep-elem abnf::cst)))

Theorem: cst-double-quote-conc-rep-elem-tree-equiv-congruence-on-cst

(defthm cst-double-quote-conc-rep-elem-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-double-quote-conc-rep-elem abnf::cst)
                  (cst-double-quote-conc-rep-elem cst-equiv)))
  :rule-classes :congruence)

Function: cst-backslash-escape-conc-rep-elem

(defun cst-backslash-escape-conc-rep-elem (abnf::cst)
 (declare (xargs :guard (abnf::treep abnf::cst)))
 (declare (xargs :guard (cst-matchp abnf::cst "backslash-escape")))
 (let ((__function__ 'cst-backslash-escape-conc-rep-elem))
  (declare (ignorable __function__))
  (abnf::tree-fix (nth 0
                       (cst-backslash-escape-conc-rep abnf::cst)))))

Theorem: treep-of-cst-backslash-escape-conc-rep-elem

(defthm treep-of-cst-backslash-escape-conc-rep-elem
  (b* ((abnf::cst1 (cst-backslash-escape-conc-rep-elem abnf::cst)))
    (abnf::treep abnf::cst1))
  :rule-classes :rewrite)

Theorem: cst-backslash-escape-conc-rep-elem-match

(defthm cst-backslash-escape-conc-rep-elem-match
 (implies
   (cst-matchp abnf::cst "backslash-escape")
   (b* ((abnf::cst1 (cst-backslash-escape-conc-rep-elem abnf::cst)))
     (cst-matchp abnf::cst1 "\"\\\\\"")))
 :rule-classes :rewrite)

Theorem: cst-backslash-escape-conc-rep-elem-of-tree-fix-cst

(defthm cst-backslash-escape-conc-rep-elem-of-tree-fix-cst
 (equal
     (cst-backslash-escape-conc-rep-elem (abnf::tree-fix abnf::cst))
     (cst-backslash-escape-conc-rep-elem abnf::cst)))

Theorem: cst-backslash-escape-conc-rep-elem-tree-equiv-congruence-on-cst

(defthm
    cst-backslash-escape-conc-rep-elem-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-backslash-escape-conc-rep-elem abnf::cst)
                  (cst-backslash-escape-conc-rep-elem cst-equiv)))
  :rule-classes :congruence)

Function: cst-line-feed-escape-conc-rep-elem

(defun cst-line-feed-escape-conc-rep-elem (abnf::cst)
 (declare (xargs :guard (abnf::treep abnf::cst)))
 (declare (xargs :guard (cst-matchp abnf::cst "line-feed-escape")))
 (let ((__function__ 'cst-line-feed-escape-conc-rep-elem))
  (declare (ignorable __function__))
  (abnf::tree-fix (nth 0
                       (cst-line-feed-escape-conc-rep abnf::cst)))))

Theorem: treep-of-cst-line-feed-escape-conc-rep-elem

(defthm treep-of-cst-line-feed-escape-conc-rep-elem
  (b* ((abnf::cst1 (cst-line-feed-escape-conc-rep-elem abnf::cst)))
    (abnf::treep abnf::cst1))
  :rule-classes :rewrite)

Theorem: cst-line-feed-escape-conc-rep-elem-match

(defthm cst-line-feed-escape-conc-rep-elem-match
 (implies
   (cst-matchp abnf::cst "line-feed-escape")
   (b* ((abnf::cst1 (cst-line-feed-escape-conc-rep-elem abnf::cst)))
     (cst-matchp abnf::cst1 "%s\"\\n\"")))
 :rule-classes :rewrite)

Theorem: cst-line-feed-escape-conc-rep-elem-of-tree-fix-cst

(defthm cst-line-feed-escape-conc-rep-elem-of-tree-fix-cst
 (equal
     (cst-line-feed-escape-conc-rep-elem (abnf::tree-fix abnf::cst))
     (cst-line-feed-escape-conc-rep-elem abnf::cst)))

Theorem: cst-line-feed-escape-conc-rep-elem-tree-equiv-congruence-on-cst

(defthm
    cst-line-feed-escape-conc-rep-elem-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-line-feed-escape-conc-rep-elem abnf::cst)
                  (cst-line-feed-escape-conc-rep-elem cst-equiv)))
  :rule-classes :congruence)

Function: cst-carriage-return-escape-conc-rep-elem

(defun cst-carriage-return-escape-conc-rep-elem (abnf::cst)
 (declare (xargs :guard (abnf::treep abnf::cst)))
 (declare
     (xargs :guard (cst-matchp abnf::cst "carriage-return-escape")))
 (let ((__function__ 'cst-carriage-return-escape-conc-rep-elem))
   (declare (ignorable __function__))
   (abnf::tree-fix
        (nth 0
             (cst-carriage-return-escape-conc-rep abnf::cst)))))

Theorem: treep-of-cst-carriage-return-escape-conc-rep-elem

(defthm treep-of-cst-carriage-return-escape-conc-rep-elem
  (b* ((abnf::cst1
            (cst-carriage-return-escape-conc-rep-elem abnf::cst)))
    (abnf::treep abnf::cst1))
  :rule-classes :rewrite)

Theorem: cst-carriage-return-escape-conc-rep-elem-match

(defthm cst-carriage-return-escape-conc-rep-elem-match
 (implies
    (cst-matchp abnf::cst "carriage-return-escape")
    (b* ((abnf::cst1
              (cst-carriage-return-escape-conc-rep-elem abnf::cst)))
      (cst-matchp abnf::cst1 "%s\"\\r\"")))
 :rule-classes :rewrite)

Theorem: cst-carriage-return-escape-conc-rep-elem-of-tree-fix-cst

(defthm cst-carriage-return-escape-conc-rep-elem-of-tree-fix-cst
  (equal (cst-carriage-return-escape-conc-rep-elem
              (abnf::tree-fix abnf::cst))
         (cst-carriage-return-escape-conc-rep-elem abnf::cst)))

Theorem: cst-carriage-return-escape-conc-rep-elem-tree-equiv-congruence-on-cst

(defthm
 cst-carriage-return-escape-conc-rep-elem-tree-equiv-congruence-on-cst
 (implies
      (abnf::tree-equiv abnf::cst cst-equiv)
      (equal (cst-carriage-return-escape-conc-rep-elem abnf::cst)
             (cst-carriage-return-escape-conc-rep-elem cst-equiv)))
 :rule-classes :congruence)

Function: cst-horizontal-tab-escape-conc-rep-elem

(defun cst-horizontal-tab-escape-conc-rep-elem (abnf::cst)
 (declare (xargs :guard (abnf::treep abnf::cst)))
 (declare
      (xargs :guard (cst-matchp abnf::cst "horizontal-tab-escape")))
 (let ((__function__ 'cst-horizontal-tab-escape-conc-rep-elem))
   (declare (ignorable __function__))
   (abnf::tree-fix
        (nth 0
             (cst-horizontal-tab-escape-conc-rep abnf::cst)))))

Theorem: treep-of-cst-horizontal-tab-escape-conc-rep-elem

(defthm treep-of-cst-horizontal-tab-escape-conc-rep-elem
 (b*
  ((abnf::cst1 (cst-horizontal-tab-escape-conc-rep-elem abnf::cst)))
  (abnf::treep abnf::cst1))
 :rule-classes :rewrite)

Theorem: cst-horizontal-tab-escape-conc-rep-elem-match

(defthm cst-horizontal-tab-escape-conc-rep-elem-match
 (implies
     (cst-matchp abnf::cst "horizontal-tab-escape")
     (b* ((abnf::cst1
               (cst-horizontal-tab-escape-conc-rep-elem abnf::cst)))
       (cst-matchp abnf::cst1 "%s\"\\t\"")))
 :rule-classes :rewrite)

Theorem: cst-horizontal-tab-escape-conc-rep-elem-of-tree-fix-cst

(defthm cst-horizontal-tab-escape-conc-rep-elem-of-tree-fix-cst
  (equal (cst-horizontal-tab-escape-conc-rep-elem
              (abnf::tree-fix abnf::cst))
         (cst-horizontal-tab-escape-conc-rep-elem abnf::cst)))

Theorem: cst-horizontal-tab-escape-conc-rep-elem-tree-equiv-congruence-on-cst

(defthm
 cst-horizontal-tab-escape-conc-rep-elem-tree-equiv-congruence-on-cst
 (implies
      (abnf::tree-equiv abnf::cst cst-equiv)
      (equal (cst-horizontal-tab-escape-conc-rep-elem abnf::cst)
             (cst-horizontal-tab-escape-conc-rep-elem cst-equiv)))
 :rule-classes :congruence)

Function: cst-null-character-escape-conc-rep-elem

(defun cst-null-character-escape-conc-rep-elem (abnf::cst)
 (declare (xargs :guard (abnf::treep abnf::cst)))
 (declare
      (xargs :guard (cst-matchp abnf::cst "null-character-escape")))
 (let ((__function__ 'cst-null-character-escape-conc-rep-elem))
   (declare (ignorable __function__))
   (abnf::tree-fix
        (nth 0
             (cst-null-character-escape-conc-rep abnf::cst)))))

Theorem: treep-of-cst-null-character-escape-conc-rep-elem

(defthm treep-of-cst-null-character-escape-conc-rep-elem
 (b*
  ((abnf::cst1 (cst-null-character-escape-conc-rep-elem abnf::cst)))
  (abnf::treep abnf::cst1))
 :rule-classes :rewrite)

Theorem: cst-null-character-escape-conc-rep-elem-match

(defthm cst-null-character-escape-conc-rep-elem-match
 (implies
     (cst-matchp abnf::cst "null-character-escape")
     (b* ((abnf::cst1
               (cst-null-character-escape-conc-rep-elem abnf::cst)))
       (cst-matchp abnf::cst1 "\"\\0\"")))
 :rule-classes :rewrite)

Theorem: cst-null-character-escape-conc-rep-elem-of-tree-fix-cst

(defthm cst-null-character-escape-conc-rep-elem-of-tree-fix-cst
  (equal (cst-null-character-escape-conc-rep-elem
              (abnf::tree-fix abnf::cst))
         (cst-null-character-escape-conc-rep-elem abnf::cst)))

Theorem: cst-null-character-escape-conc-rep-elem-tree-equiv-congruence-on-cst

(defthm
 cst-null-character-escape-conc-rep-elem-tree-equiv-congruence-on-cst
 (implies
      (abnf::tree-equiv abnf::cst cst-equiv)
      (equal (cst-null-character-escape-conc-rep-elem abnf::cst)
             (cst-null-character-escape-conc-rep-elem cst-equiv)))
 :rule-classes :congruence)

Function: cst-simple-character-escape-conc1-rep-elem

(defun cst-simple-character-escape-conc1-rep-elem (abnf::cst)
 (declare (xargs :guard (abnf::treep abnf::cst)))
 (declare
  (xargs
    :guard (and (cst-matchp abnf::cst "simple-character-escape")
                (equal (cst-simple-character-escape-conc? abnf::cst)
                       1))))
 (let ((__function__ 'cst-simple-character-escape-conc1-rep-elem))
   (declare (ignorable __function__))
   (abnf::tree-fix
        (nth 0
             (cst-simple-character-escape-conc1-rep abnf::cst)))))

Theorem: treep-of-cst-simple-character-escape-conc1-rep-elem

(defthm treep-of-cst-simple-character-escape-conc1-rep-elem
  (b* ((abnf::cst1
            (cst-simple-character-escape-conc1-rep-elem abnf::cst)))
    (abnf::treep abnf::cst1))
  :rule-classes :rewrite)

Theorem: cst-simple-character-escape-conc1-rep-elem-match

(defthm cst-simple-character-escape-conc1-rep-elem-match
 (implies
  (and (cst-matchp abnf::cst "simple-character-escape")
       (equal (cst-simple-character-escape-conc? abnf::cst)
              1))
  (b* ((abnf::cst1
            (cst-simple-character-escape-conc1-rep-elem abnf::cst)))
    (cst-matchp abnf::cst1 "single-quote-escape")))
 :rule-classes :rewrite)

Theorem: cst-simple-character-escape-conc1-rep-elem-of-tree-fix-cst

(defthm cst-simple-character-escape-conc1-rep-elem-of-tree-fix-cst
  (equal (cst-simple-character-escape-conc1-rep-elem
              (abnf::tree-fix abnf::cst))
         (cst-simple-character-escape-conc1-rep-elem abnf::cst)))

Theorem: cst-simple-character-escape-conc1-rep-elem-tree-equiv-congruence-on-cst

(defthm
 cst-simple-character-escape-conc1-rep-elem-tree-equiv-congruence-on-cst
 (implies
     (abnf::tree-equiv abnf::cst cst-equiv)
     (equal (cst-simple-character-escape-conc1-rep-elem abnf::cst)
            (cst-simple-character-escape-conc1-rep-elem cst-equiv)))
 :rule-classes :congruence)

Function: cst-simple-character-escape-conc2-rep-elem

(defun cst-simple-character-escape-conc2-rep-elem (abnf::cst)
 (declare (xargs :guard (abnf::treep abnf::cst)))
 (declare
  (xargs
    :guard (and (cst-matchp abnf::cst "simple-character-escape")
                (equal (cst-simple-character-escape-conc? abnf::cst)
                       2))))
 (let ((__function__ 'cst-simple-character-escape-conc2-rep-elem))
   (declare (ignorable __function__))
   (abnf::tree-fix
        (nth 0
             (cst-simple-character-escape-conc2-rep abnf::cst)))))

Theorem: treep-of-cst-simple-character-escape-conc2-rep-elem

(defthm treep-of-cst-simple-character-escape-conc2-rep-elem
  (b* ((abnf::cst1
            (cst-simple-character-escape-conc2-rep-elem abnf::cst)))
    (abnf::treep abnf::cst1))
  :rule-classes :rewrite)

Theorem: cst-simple-character-escape-conc2-rep-elem-match

(defthm cst-simple-character-escape-conc2-rep-elem-match
 (implies
  (and (cst-matchp abnf::cst "simple-character-escape")
       (equal (cst-simple-character-escape-conc? abnf::cst)
              2))
  (b* ((abnf::cst1
            (cst-simple-character-escape-conc2-rep-elem abnf::cst)))
    (cst-matchp abnf::cst1 "double-quote-escape")))
 :rule-classes :rewrite)

Theorem: cst-simple-character-escape-conc2-rep-elem-of-tree-fix-cst

(defthm cst-simple-character-escape-conc2-rep-elem-of-tree-fix-cst
  (equal (cst-simple-character-escape-conc2-rep-elem
              (abnf::tree-fix abnf::cst))
         (cst-simple-character-escape-conc2-rep-elem abnf::cst)))

Theorem: cst-simple-character-escape-conc2-rep-elem-tree-equiv-congruence-on-cst

(defthm
 cst-simple-character-escape-conc2-rep-elem-tree-equiv-congruence-on-cst
 (implies
     (abnf::tree-equiv abnf::cst cst-equiv)
     (equal (cst-simple-character-escape-conc2-rep-elem abnf::cst)
            (cst-simple-character-escape-conc2-rep-elem cst-equiv)))
 :rule-classes :congruence)

Function: cst-simple-character-escape-conc3-rep-elem

(defun cst-simple-character-escape-conc3-rep-elem (abnf::cst)
 (declare (xargs :guard (abnf::treep abnf::cst)))
 (declare
  (xargs
    :guard (and (cst-matchp abnf::cst "simple-character-escape")
                (equal (cst-simple-character-escape-conc? abnf::cst)
                       3))))
 (let ((__function__ 'cst-simple-character-escape-conc3-rep-elem))
   (declare (ignorable __function__))
   (abnf::tree-fix
        (nth 0
             (cst-simple-character-escape-conc3-rep abnf::cst)))))

Theorem: treep-of-cst-simple-character-escape-conc3-rep-elem

(defthm treep-of-cst-simple-character-escape-conc3-rep-elem
  (b* ((abnf::cst1
            (cst-simple-character-escape-conc3-rep-elem abnf::cst)))
    (abnf::treep abnf::cst1))
  :rule-classes :rewrite)

Theorem: cst-simple-character-escape-conc3-rep-elem-match

(defthm cst-simple-character-escape-conc3-rep-elem-match
 (implies
  (and (cst-matchp abnf::cst "simple-character-escape")
       (equal (cst-simple-character-escape-conc? abnf::cst)
              3))
  (b* ((abnf::cst1
            (cst-simple-character-escape-conc3-rep-elem abnf::cst)))
    (cst-matchp abnf::cst1 "backslash-escape")))
 :rule-classes :rewrite)

Theorem: cst-simple-character-escape-conc3-rep-elem-of-tree-fix-cst

(defthm cst-simple-character-escape-conc3-rep-elem-of-tree-fix-cst
  (equal (cst-simple-character-escape-conc3-rep-elem
              (abnf::tree-fix abnf::cst))
         (cst-simple-character-escape-conc3-rep-elem abnf::cst)))

Theorem: cst-simple-character-escape-conc3-rep-elem-tree-equiv-congruence-on-cst

(defthm
 cst-simple-character-escape-conc3-rep-elem-tree-equiv-congruence-on-cst
 (implies
     (abnf::tree-equiv abnf::cst cst-equiv)
     (equal (cst-simple-character-escape-conc3-rep-elem abnf::cst)
            (cst-simple-character-escape-conc3-rep-elem cst-equiv)))
 :rule-classes :congruence)

Function: cst-simple-character-escape-conc4-rep-elem

(defun cst-simple-character-escape-conc4-rep-elem (abnf::cst)
 (declare (xargs :guard (abnf::treep abnf::cst)))
 (declare
  (xargs
    :guard (and (cst-matchp abnf::cst "simple-character-escape")
                (equal (cst-simple-character-escape-conc? abnf::cst)
                       4))))
 (let ((__function__ 'cst-simple-character-escape-conc4-rep-elem))
   (declare (ignorable __function__))
   (abnf::tree-fix
        (nth 0
             (cst-simple-character-escape-conc4-rep abnf::cst)))))

Theorem: treep-of-cst-simple-character-escape-conc4-rep-elem

(defthm treep-of-cst-simple-character-escape-conc4-rep-elem
  (b* ((abnf::cst1
            (cst-simple-character-escape-conc4-rep-elem abnf::cst)))
    (abnf::treep abnf::cst1))
  :rule-classes :rewrite)

Theorem: cst-simple-character-escape-conc4-rep-elem-match

(defthm cst-simple-character-escape-conc4-rep-elem-match
 (implies
  (and (cst-matchp abnf::cst "simple-character-escape")
       (equal (cst-simple-character-escape-conc? abnf::cst)
              4))
  (b* ((abnf::cst1
            (cst-simple-character-escape-conc4-rep-elem abnf::cst)))
    (cst-matchp abnf::cst1 "line-feed-escape")))
 :rule-classes :rewrite)

Theorem: cst-simple-character-escape-conc4-rep-elem-of-tree-fix-cst

(defthm cst-simple-character-escape-conc4-rep-elem-of-tree-fix-cst
  (equal (cst-simple-character-escape-conc4-rep-elem
              (abnf::tree-fix abnf::cst))
         (cst-simple-character-escape-conc4-rep-elem abnf::cst)))

Theorem: cst-simple-character-escape-conc4-rep-elem-tree-equiv-congruence-on-cst

(defthm
 cst-simple-character-escape-conc4-rep-elem-tree-equiv-congruence-on-cst
 (implies
     (abnf::tree-equiv abnf::cst cst-equiv)
     (equal (cst-simple-character-escape-conc4-rep-elem abnf::cst)
            (cst-simple-character-escape-conc4-rep-elem cst-equiv)))
 :rule-classes :congruence)

Function: cst-simple-character-escape-conc5-rep-elem

(defun cst-simple-character-escape-conc5-rep-elem (abnf::cst)
 (declare (xargs :guard (abnf::treep abnf::cst)))
 (declare
  (xargs
    :guard (and (cst-matchp abnf::cst "simple-character-escape")
                (equal (cst-simple-character-escape-conc? abnf::cst)
                       5))))
 (let ((__function__ 'cst-simple-character-escape-conc5-rep-elem))
   (declare (ignorable __function__))
   (abnf::tree-fix
        (nth 0
             (cst-simple-character-escape-conc5-rep abnf::cst)))))

Theorem: treep-of-cst-simple-character-escape-conc5-rep-elem

(defthm treep-of-cst-simple-character-escape-conc5-rep-elem
  (b* ((abnf::cst1
            (cst-simple-character-escape-conc5-rep-elem abnf::cst)))
    (abnf::treep abnf::cst1))
  :rule-classes :rewrite)

Theorem: cst-simple-character-escape-conc5-rep-elem-match

(defthm cst-simple-character-escape-conc5-rep-elem-match
 (implies
  (and (cst-matchp abnf::cst "simple-character-escape")
       (equal (cst-simple-character-escape-conc? abnf::cst)
              5))
  (b* ((abnf::cst1
            (cst-simple-character-escape-conc5-rep-elem abnf::cst)))
    (cst-matchp abnf::cst1 "carriage-return-escape")))
 :rule-classes :rewrite)

Theorem: cst-simple-character-escape-conc5-rep-elem-of-tree-fix-cst

(defthm cst-simple-character-escape-conc5-rep-elem-of-tree-fix-cst
  (equal (cst-simple-character-escape-conc5-rep-elem
              (abnf::tree-fix abnf::cst))
         (cst-simple-character-escape-conc5-rep-elem abnf::cst)))

Theorem: cst-simple-character-escape-conc5-rep-elem-tree-equiv-congruence-on-cst

(defthm
 cst-simple-character-escape-conc5-rep-elem-tree-equiv-congruence-on-cst
 (implies
     (abnf::tree-equiv abnf::cst cst-equiv)
     (equal (cst-simple-character-escape-conc5-rep-elem abnf::cst)
            (cst-simple-character-escape-conc5-rep-elem cst-equiv)))
 :rule-classes :congruence)

Function: cst-simple-character-escape-conc6-rep-elem

(defun cst-simple-character-escape-conc6-rep-elem (abnf::cst)
 (declare (xargs :guard (abnf::treep abnf::cst)))
 (declare
  (xargs
    :guard (and (cst-matchp abnf::cst "simple-character-escape")
                (equal (cst-simple-character-escape-conc? abnf::cst)
                       6))))
 (let ((__function__ 'cst-simple-character-escape-conc6-rep-elem))
   (declare (ignorable __function__))
   (abnf::tree-fix
        (nth 0
             (cst-simple-character-escape-conc6-rep abnf::cst)))))

Theorem: treep-of-cst-simple-character-escape-conc6-rep-elem

(defthm treep-of-cst-simple-character-escape-conc6-rep-elem
  (b* ((abnf::cst1
            (cst-simple-character-escape-conc6-rep-elem abnf::cst)))
    (abnf::treep abnf::cst1))
  :rule-classes :rewrite)

Theorem: cst-simple-character-escape-conc6-rep-elem-match

(defthm cst-simple-character-escape-conc6-rep-elem-match
 (implies
  (and (cst-matchp abnf::cst "simple-character-escape")
       (equal (cst-simple-character-escape-conc? abnf::cst)
              6))
  (b* ((abnf::cst1
            (cst-simple-character-escape-conc6-rep-elem abnf::cst)))
    (cst-matchp abnf::cst1 "horizontal-tab-escape")))
 :rule-classes :rewrite)

Theorem: cst-simple-character-escape-conc6-rep-elem-of-tree-fix-cst

(defthm cst-simple-character-escape-conc6-rep-elem-of-tree-fix-cst
  (equal (cst-simple-character-escape-conc6-rep-elem
              (abnf::tree-fix abnf::cst))
         (cst-simple-character-escape-conc6-rep-elem abnf::cst)))

Theorem: cst-simple-character-escape-conc6-rep-elem-tree-equiv-congruence-on-cst

(defthm
 cst-simple-character-escape-conc6-rep-elem-tree-equiv-congruence-on-cst
 (implies
     (abnf::tree-equiv abnf::cst cst-equiv)
     (equal (cst-simple-character-escape-conc6-rep-elem abnf::cst)
            (cst-simple-character-escape-conc6-rep-elem cst-equiv)))
 :rule-classes :congruence)

Function: cst-simple-character-escape-conc7-rep-elem

(defun cst-simple-character-escape-conc7-rep-elem (abnf::cst)
 (declare (xargs :guard (abnf::treep abnf::cst)))
 (declare
  (xargs
    :guard (and (cst-matchp abnf::cst "simple-character-escape")
                (equal (cst-simple-character-escape-conc? abnf::cst)
                       7))))
 (let ((__function__ 'cst-simple-character-escape-conc7-rep-elem))
   (declare (ignorable __function__))
   (abnf::tree-fix
        (nth 0
             (cst-simple-character-escape-conc7-rep abnf::cst)))))

Theorem: treep-of-cst-simple-character-escape-conc7-rep-elem

(defthm treep-of-cst-simple-character-escape-conc7-rep-elem
  (b* ((abnf::cst1
            (cst-simple-character-escape-conc7-rep-elem abnf::cst)))
    (abnf::treep abnf::cst1))
  :rule-classes :rewrite)

Theorem: cst-simple-character-escape-conc7-rep-elem-match

(defthm cst-simple-character-escape-conc7-rep-elem-match
 (implies
  (and (cst-matchp abnf::cst "simple-character-escape")
       (equal (cst-simple-character-escape-conc? abnf::cst)
              7))
  (b* ((abnf::cst1
            (cst-simple-character-escape-conc7-rep-elem abnf::cst)))
    (cst-matchp abnf::cst1 "null-character-escape")))
 :rule-classes :rewrite)

Theorem: cst-simple-character-escape-conc7-rep-elem-of-tree-fix-cst

(defthm cst-simple-character-escape-conc7-rep-elem-of-tree-fix-cst
  (equal (cst-simple-character-escape-conc7-rep-elem
              (abnf::tree-fix abnf::cst))
         (cst-simple-character-escape-conc7-rep-elem abnf::cst)))

Theorem: cst-simple-character-escape-conc7-rep-elem-tree-equiv-congruence-on-cst

(defthm
 cst-simple-character-escape-conc7-rep-elem-tree-equiv-congruence-on-cst
 (implies
     (abnf::tree-equiv abnf::cst cst-equiv)
     (equal (cst-simple-character-escape-conc7-rep-elem abnf::cst)
            (cst-simple-character-escape-conc7-rep-elem cst-equiv)))
 :rule-classes :congruence)

Function: cst-string-literal-element-conc1-rep-elem

(defun cst-string-literal-element-conc1-rep-elem (abnf::cst)
 (declare (xargs :guard (abnf::treep abnf::cst)))
 (declare
  (xargs
     :guard (and (cst-matchp abnf::cst "string-literal-element")
                 (equal (cst-string-literal-element-conc? abnf::cst)
                        1))))
 (let ((__function__ 'cst-string-literal-element-conc1-rep-elem))
   (declare (ignorable __function__))
   (abnf::tree-fix
        (nth 0
             (cst-string-literal-element-conc1-rep abnf::cst)))))

Theorem: treep-of-cst-string-literal-element-conc1-rep-elem

(defthm treep-of-cst-string-literal-element-conc1-rep-elem
  (b* ((abnf::cst1
            (cst-string-literal-element-conc1-rep-elem abnf::cst)))
    (abnf::treep abnf::cst1))
  :rule-classes :rewrite)

Theorem: cst-string-literal-element-conc1-rep-elem-match

(defthm cst-string-literal-element-conc1-rep-elem-match
 (implies
  (and (cst-matchp abnf::cst "string-literal-element")
       (equal (cst-string-literal-element-conc? abnf::cst)
              1))
  (b* ((abnf::cst1
            (cst-string-literal-element-conc1-rep-elem abnf::cst)))
   (cst-matchp
    abnf::cst1
    "not-double-quote-or-backslash-or-line-feed-or-carriage-return")))
 :rule-classes :rewrite)

Theorem: cst-string-literal-element-conc1-rep-elem-of-tree-fix-cst

(defthm cst-string-literal-element-conc1-rep-elem-of-tree-fix-cst
  (equal (cst-string-literal-element-conc1-rep-elem
              (abnf::tree-fix abnf::cst))
         (cst-string-literal-element-conc1-rep-elem abnf::cst)))

Theorem: cst-string-literal-element-conc1-rep-elem-tree-equiv-congruence-on-cst

(defthm
 cst-string-literal-element-conc1-rep-elem-tree-equiv-congruence-on-cst
 (implies
      (abnf::tree-equiv abnf::cst cst-equiv)
      (equal (cst-string-literal-element-conc1-rep-elem abnf::cst)
             (cst-string-literal-element-conc1-rep-elem cst-equiv)))
 :rule-classes :congruence)

Function: cst-string-literal-element-conc2-rep-elem

(defun cst-string-literal-element-conc2-rep-elem (abnf::cst)
 (declare (xargs :guard (abnf::treep abnf::cst)))
 (declare
  (xargs
     :guard (and (cst-matchp abnf::cst "string-literal-element")
                 (equal (cst-string-literal-element-conc? abnf::cst)
                        2))))
 (let ((__function__ 'cst-string-literal-element-conc2-rep-elem))
   (declare (ignorable __function__))
   (abnf::tree-fix
        (nth 0
             (cst-string-literal-element-conc2-rep abnf::cst)))))

Theorem: treep-of-cst-string-literal-element-conc2-rep-elem

(defthm treep-of-cst-string-literal-element-conc2-rep-elem
  (b* ((abnf::cst1
            (cst-string-literal-element-conc2-rep-elem abnf::cst)))
    (abnf::treep abnf::cst1))
  :rule-classes :rewrite)

Theorem: cst-string-literal-element-conc2-rep-elem-match

(defthm cst-string-literal-element-conc2-rep-elem-match
 (implies
   (and (cst-matchp abnf::cst "string-literal-element")
        (equal (cst-string-literal-element-conc? abnf::cst)
               2))
   (b* ((abnf::cst1
             (cst-string-literal-element-conc2-rep-elem abnf::cst)))
     (cst-matchp abnf::cst1 "simple-character-escape")))
 :rule-classes :rewrite)

Theorem: cst-string-literal-element-conc2-rep-elem-of-tree-fix-cst

(defthm cst-string-literal-element-conc2-rep-elem-of-tree-fix-cst
  (equal (cst-string-literal-element-conc2-rep-elem
              (abnf::tree-fix abnf::cst))
         (cst-string-literal-element-conc2-rep-elem abnf::cst)))

Theorem: cst-string-literal-element-conc2-rep-elem-tree-equiv-congruence-on-cst

(defthm
 cst-string-literal-element-conc2-rep-elem-tree-equiv-congruence-on-cst
 (implies
      (abnf::tree-equiv abnf::cst cst-equiv)
      (equal (cst-string-literal-element-conc2-rep-elem abnf::cst)
             (cst-string-literal-element-conc2-rep-elem cst-equiv)))
 :rule-classes :congruence)

Function: cst-string-literal-element-conc3-rep-elem

(defun cst-string-literal-element-conc3-rep-elem (abnf::cst)
 (declare (xargs :guard (abnf::treep abnf::cst)))
 (declare
  (xargs
     :guard (and (cst-matchp abnf::cst "string-literal-element")
                 (equal (cst-string-literal-element-conc? abnf::cst)
                        3))))
 (let ((__function__ 'cst-string-literal-element-conc3-rep-elem))
   (declare (ignorable __function__))
   (abnf::tree-fix
        (nth 0
             (cst-string-literal-element-conc3-rep abnf::cst)))))

Theorem: treep-of-cst-string-literal-element-conc3-rep-elem

(defthm treep-of-cst-string-literal-element-conc3-rep-elem
  (b* ((abnf::cst1
            (cst-string-literal-element-conc3-rep-elem abnf::cst)))
    (abnf::treep abnf::cst1))
  :rule-classes :rewrite)

Theorem: cst-string-literal-element-conc3-rep-elem-match

(defthm cst-string-literal-element-conc3-rep-elem-match
 (implies
   (and (cst-matchp abnf::cst "string-literal-element")
        (equal (cst-string-literal-element-conc? abnf::cst)
               3))
   (b* ((abnf::cst1
             (cst-string-literal-element-conc3-rep-elem abnf::cst)))
     (cst-matchp abnf::cst1 "ascii-character-escape")))
 :rule-classes :rewrite)

Theorem: cst-string-literal-element-conc3-rep-elem-of-tree-fix-cst

(defthm cst-string-literal-element-conc3-rep-elem-of-tree-fix-cst
  (equal (cst-string-literal-element-conc3-rep-elem
              (abnf::tree-fix abnf::cst))
         (cst-string-literal-element-conc3-rep-elem abnf::cst)))

Theorem: cst-string-literal-element-conc3-rep-elem-tree-equiv-congruence-on-cst

(defthm
 cst-string-literal-element-conc3-rep-elem-tree-equiv-congruence-on-cst
 (implies
      (abnf::tree-equiv abnf::cst cst-equiv)
      (equal (cst-string-literal-element-conc3-rep-elem abnf::cst)
             (cst-string-literal-element-conc3-rep-elem cst-equiv)))
 :rule-classes :congruence)

Function: cst-string-literal-element-conc4-rep-elem

(defun cst-string-literal-element-conc4-rep-elem (abnf::cst)
 (declare (xargs :guard (abnf::treep abnf::cst)))
 (declare
  (xargs
     :guard (and (cst-matchp abnf::cst "string-literal-element")
                 (equal (cst-string-literal-element-conc? abnf::cst)
                        4))))
 (let ((__function__ 'cst-string-literal-element-conc4-rep-elem))
   (declare (ignorable __function__))
   (abnf::tree-fix
        (nth 0
             (cst-string-literal-element-conc4-rep abnf::cst)))))

Theorem: treep-of-cst-string-literal-element-conc4-rep-elem

(defthm treep-of-cst-string-literal-element-conc4-rep-elem
  (b* ((abnf::cst1
            (cst-string-literal-element-conc4-rep-elem abnf::cst)))
    (abnf::treep abnf::cst1))
  :rule-classes :rewrite)

Theorem: cst-string-literal-element-conc4-rep-elem-match

(defthm cst-string-literal-element-conc4-rep-elem-match
 (implies
   (and (cst-matchp abnf::cst "string-literal-element")
        (equal (cst-string-literal-element-conc? abnf::cst)
               4))
   (b* ((abnf::cst1
             (cst-string-literal-element-conc4-rep-elem abnf::cst)))
     (cst-matchp abnf::cst1 "unicode-character-escape")))
 :rule-classes :rewrite)

Theorem: cst-string-literal-element-conc4-rep-elem-of-tree-fix-cst

(defthm cst-string-literal-element-conc4-rep-elem-of-tree-fix-cst
  (equal (cst-string-literal-element-conc4-rep-elem
              (abnf::tree-fix abnf::cst))
         (cst-string-literal-element-conc4-rep-elem abnf::cst)))

Theorem: cst-string-literal-element-conc4-rep-elem-tree-equiv-congruence-on-cst

(defthm
 cst-string-literal-element-conc4-rep-elem-tree-equiv-congruence-on-cst
 (implies
      (abnf::tree-equiv abnf::cst cst-equiv)
      (equal (cst-string-literal-element-conc4-rep-elem abnf::cst)
             (cst-string-literal-element-conc4-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 "unsigned-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 "signed-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-numeric-literal-conc1-rep-elem

(defun cst-numeric-literal-conc1-rep-elem (abnf::cst)
 (declare (xargs :guard (abnf::treep abnf::cst)))
 (declare
     (xargs :guard (and (cst-matchp abnf::cst "numeric-literal")
                        (equal (cst-numeric-literal-conc? abnf::cst)
                               1))))
 (let ((__function__ 'cst-numeric-literal-conc1-rep-elem))
  (declare (ignorable __function__))
  (abnf::tree-fix (nth 0
                       (cst-numeric-literal-conc1-rep abnf::cst)))))

Theorem: treep-of-cst-numeric-literal-conc1-rep-elem

(defthm treep-of-cst-numeric-literal-conc1-rep-elem
  (b* ((abnf::cst1 (cst-numeric-literal-conc1-rep-elem abnf::cst)))
    (abnf::treep abnf::cst1))
  :rule-classes :rewrite)

Theorem: cst-numeric-literal-conc1-rep-elem-match

(defthm cst-numeric-literal-conc1-rep-elem-match
 (implies
   (and (cst-matchp abnf::cst "numeric-literal")
        (equal (cst-numeric-literal-conc? abnf::cst)
               1))
   (b* ((abnf::cst1 (cst-numeric-literal-conc1-rep-elem abnf::cst)))
     (cst-matchp abnf::cst1 "integer-literal")))
 :rule-classes :rewrite)

Theorem: cst-numeric-literal-conc1-rep-elem-of-tree-fix-cst

(defthm cst-numeric-literal-conc1-rep-elem-of-tree-fix-cst
 (equal
     (cst-numeric-literal-conc1-rep-elem (abnf::tree-fix abnf::cst))
     (cst-numeric-literal-conc1-rep-elem abnf::cst)))

Theorem: cst-numeric-literal-conc1-rep-elem-tree-equiv-congruence-on-cst

(defthm
    cst-numeric-literal-conc1-rep-elem-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-numeric-literal-conc1-rep-elem abnf::cst)
                  (cst-numeric-literal-conc1-rep-elem cst-equiv)))
  :rule-classes :congruence)

Function: cst-numeric-literal-conc2-rep-elem

(defun cst-numeric-literal-conc2-rep-elem (abnf::cst)
 (declare (xargs :guard (abnf::treep abnf::cst)))
 (declare
     (xargs :guard (and (cst-matchp abnf::cst "numeric-literal")
                        (equal (cst-numeric-literal-conc? abnf::cst)
                               2))))
 (let ((__function__ 'cst-numeric-literal-conc2-rep-elem))
  (declare (ignorable __function__))
  (abnf::tree-fix (nth 0
                       (cst-numeric-literal-conc2-rep abnf::cst)))))

Theorem: treep-of-cst-numeric-literal-conc2-rep-elem

(defthm treep-of-cst-numeric-literal-conc2-rep-elem
  (b* ((abnf::cst1 (cst-numeric-literal-conc2-rep-elem abnf::cst)))
    (abnf::treep abnf::cst1))
  :rule-classes :rewrite)

Theorem: cst-numeric-literal-conc2-rep-elem-match

(defthm cst-numeric-literal-conc2-rep-elem-match
 (implies
   (and (cst-matchp abnf::cst "numeric-literal")
        (equal (cst-numeric-literal-conc? abnf::cst)
               2))
   (b* ((abnf::cst1 (cst-numeric-literal-conc2-rep-elem abnf::cst)))
     (cst-matchp abnf::cst1 "field-literal")))
 :rule-classes :rewrite)

Theorem: cst-numeric-literal-conc2-rep-elem-of-tree-fix-cst

(defthm cst-numeric-literal-conc2-rep-elem-of-tree-fix-cst
 (equal
     (cst-numeric-literal-conc2-rep-elem (abnf::tree-fix abnf::cst))
     (cst-numeric-literal-conc2-rep-elem abnf::cst)))

Theorem: cst-numeric-literal-conc2-rep-elem-tree-equiv-congruence-on-cst

(defthm
    cst-numeric-literal-conc2-rep-elem-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-numeric-literal-conc2-rep-elem abnf::cst)
                  (cst-numeric-literal-conc2-rep-elem cst-equiv)))
  :rule-classes :congruence)

Function: cst-numeric-literal-conc3-rep-elem

(defun cst-numeric-literal-conc3-rep-elem (abnf::cst)
 (declare (xargs :guard (abnf::treep abnf::cst)))
 (declare
     (xargs :guard (and (cst-matchp abnf::cst "numeric-literal")
                        (equal (cst-numeric-literal-conc? abnf::cst)
                               3))))
 (let ((__function__ 'cst-numeric-literal-conc3-rep-elem))
  (declare (ignorable __function__))
  (abnf::tree-fix (nth 0
                       (cst-numeric-literal-conc3-rep abnf::cst)))))

Theorem: treep-of-cst-numeric-literal-conc3-rep-elem

(defthm treep-of-cst-numeric-literal-conc3-rep-elem
  (b* ((abnf::cst1 (cst-numeric-literal-conc3-rep-elem abnf::cst)))
    (abnf::treep abnf::cst1))
  :rule-classes :rewrite)

Theorem: cst-numeric-literal-conc3-rep-elem-match

(defthm cst-numeric-literal-conc3-rep-elem-match
 (implies
   (and (cst-matchp abnf::cst "numeric-literal")
        (equal (cst-numeric-literal-conc? abnf::cst)
               3))
   (b* ((abnf::cst1 (cst-numeric-literal-conc3-rep-elem abnf::cst)))
     (cst-matchp abnf::cst1 "product-group-literal")))
 :rule-classes :rewrite)

Theorem: cst-numeric-literal-conc3-rep-elem-of-tree-fix-cst

(defthm cst-numeric-literal-conc3-rep-elem-of-tree-fix-cst
 (equal
     (cst-numeric-literal-conc3-rep-elem (abnf::tree-fix abnf::cst))
     (cst-numeric-literal-conc3-rep-elem abnf::cst)))

Theorem: cst-numeric-literal-conc3-rep-elem-tree-equiv-congruence-on-cst

(defthm
    cst-numeric-literal-conc3-rep-elem-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-numeric-literal-conc3-rep-elem abnf::cst)
                  (cst-numeric-literal-conc3-rep-elem cst-equiv)))
  :rule-classes :congruence)

Function: cst-numeric-literal-conc4-rep-elem

(defun cst-numeric-literal-conc4-rep-elem (abnf::cst)
 (declare (xargs :guard (abnf::treep abnf::cst)))
 (declare
     (xargs :guard (and (cst-matchp abnf::cst "numeric-literal")
                        (equal (cst-numeric-literal-conc? abnf::cst)
                               4))))
 (let ((__function__ 'cst-numeric-literal-conc4-rep-elem))
  (declare (ignorable __function__))
  (abnf::tree-fix (nth 0
                       (cst-numeric-literal-conc4-rep abnf::cst)))))

Theorem: treep-of-cst-numeric-literal-conc4-rep-elem

(defthm treep-of-cst-numeric-literal-conc4-rep-elem
  (b* ((abnf::cst1 (cst-numeric-literal-conc4-rep-elem abnf::cst)))
    (abnf::treep abnf::cst1))
  :rule-classes :rewrite)

Theorem: cst-numeric-literal-conc4-rep-elem-match

(defthm cst-numeric-literal-conc4-rep-elem-match
 (implies
   (and (cst-matchp abnf::cst "numeric-literal")
        (equal (cst-numeric-literal-conc? abnf::cst)
               4))
   (b* ((abnf::cst1 (cst-numeric-literal-conc4-rep-elem abnf::cst)))
     (cst-matchp abnf::cst1 "scalar-literal")))
 :rule-classes :rewrite)

Theorem: cst-numeric-literal-conc4-rep-elem-of-tree-fix-cst

(defthm cst-numeric-literal-conc4-rep-elem-of-tree-fix-cst
 (equal
     (cst-numeric-literal-conc4-rep-elem (abnf::tree-fix abnf::cst))
     (cst-numeric-literal-conc4-rep-elem abnf::cst)))

Theorem: cst-numeric-literal-conc4-rep-elem-tree-equiv-congruence-on-cst

(defthm
    cst-numeric-literal-conc4-rep-elem-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-numeric-literal-conc4-rep-elem abnf::cst)
                  (cst-numeric-literal-conc4-rep-elem cst-equiv)))
  :rule-classes :congruence)

Function: cst-atomic-literal-conc1-rep-elem

(defun cst-atomic-literal-conc1-rep-elem (abnf::cst)
 (declare (xargs :guard (abnf::treep abnf::cst)))
 (declare
      (xargs :guard (and (cst-matchp abnf::cst "atomic-literal")
                         (equal (cst-atomic-literal-conc? abnf::cst)
                                1))))
 (let ((__function__ 'cst-atomic-literal-conc1-rep-elem))
   (declare (ignorable __function__))
   (abnf::tree-fix (nth 0
                        (cst-atomic-literal-conc1-rep abnf::cst)))))

Theorem: treep-of-cst-atomic-literal-conc1-rep-elem

(defthm treep-of-cst-atomic-literal-conc1-rep-elem
  (b* ((abnf::cst1 (cst-atomic-literal-conc1-rep-elem abnf::cst)))
    (abnf::treep abnf::cst1))
  :rule-classes :rewrite)

Theorem: cst-atomic-literal-conc1-rep-elem-match

(defthm cst-atomic-literal-conc1-rep-elem-match
 (implies
    (and (cst-matchp abnf::cst "atomic-literal")
         (equal (cst-atomic-literal-conc? abnf::cst)
                1))
    (b* ((abnf::cst1 (cst-atomic-literal-conc1-rep-elem abnf::cst)))
      (cst-matchp abnf::cst1 "numeric-literal")))
 :rule-classes :rewrite)

Theorem: cst-atomic-literal-conc1-rep-elem-of-tree-fix-cst

(defthm cst-atomic-literal-conc1-rep-elem-of-tree-fix-cst
 (equal
      (cst-atomic-literal-conc1-rep-elem (abnf::tree-fix abnf::cst))
      (cst-atomic-literal-conc1-rep-elem abnf::cst)))

Theorem: cst-atomic-literal-conc1-rep-elem-tree-equiv-congruence-on-cst

(defthm
     cst-atomic-literal-conc1-rep-elem-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-atomic-literal-conc1-rep-elem abnf::cst)
                  (cst-atomic-literal-conc1-rep-elem cst-equiv)))
  :rule-classes :congruence)

Function: cst-atomic-literal-conc2-rep-elem

(defun cst-atomic-literal-conc2-rep-elem (abnf::cst)
 (declare (xargs :guard (abnf::treep abnf::cst)))
 (declare
      (xargs :guard (and (cst-matchp abnf::cst "atomic-literal")
                         (equal (cst-atomic-literal-conc? abnf::cst)
                                2))))
 (let ((__function__ 'cst-atomic-literal-conc2-rep-elem))
   (declare (ignorable __function__))
   (abnf::tree-fix (nth 0
                        (cst-atomic-literal-conc2-rep abnf::cst)))))

Theorem: treep-of-cst-atomic-literal-conc2-rep-elem

(defthm treep-of-cst-atomic-literal-conc2-rep-elem
  (b* ((abnf::cst1 (cst-atomic-literal-conc2-rep-elem abnf::cst)))
    (abnf::treep abnf::cst1))
  :rule-classes :rewrite)

Theorem: cst-atomic-literal-conc2-rep-elem-match

(defthm cst-atomic-literal-conc2-rep-elem-match
 (implies
    (and (cst-matchp abnf::cst "atomic-literal")
         (equal (cst-atomic-literal-conc? abnf::cst)
                2))
    (b* ((abnf::cst1 (cst-atomic-literal-conc2-rep-elem abnf::cst)))
      (cst-matchp abnf::cst1 "boolean-literal")))
 :rule-classes :rewrite)

Theorem: cst-atomic-literal-conc2-rep-elem-of-tree-fix-cst

(defthm cst-atomic-literal-conc2-rep-elem-of-tree-fix-cst
 (equal
      (cst-atomic-literal-conc2-rep-elem (abnf::tree-fix abnf::cst))
      (cst-atomic-literal-conc2-rep-elem abnf::cst)))

Theorem: cst-atomic-literal-conc2-rep-elem-tree-equiv-congruence-on-cst

(defthm
     cst-atomic-literal-conc2-rep-elem-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-atomic-literal-conc2-rep-elem abnf::cst)
                  (cst-atomic-literal-conc2-rep-elem cst-equiv)))
  :rule-classes :congruence)

Function: cst-atomic-literal-conc3-rep-elem

(defun cst-atomic-literal-conc3-rep-elem (abnf::cst)
 (declare (xargs :guard (abnf::treep abnf::cst)))
 (declare
      (xargs :guard (and (cst-matchp abnf::cst "atomic-literal")
                         (equal (cst-atomic-literal-conc? abnf::cst)
                                3))))
 (let ((__function__ 'cst-atomic-literal-conc3-rep-elem))
   (declare (ignorable __function__))
   (abnf::tree-fix (nth 0
                        (cst-atomic-literal-conc3-rep abnf::cst)))))

Theorem: treep-of-cst-atomic-literal-conc3-rep-elem

(defthm treep-of-cst-atomic-literal-conc3-rep-elem
  (b* ((abnf::cst1 (cst-atomic-literal-conc3-rep-elem abnf::cst)))
    (abnf::treep abnf::cst1))
  :rule-classes :rewrite)

Theorem: cst-atomic-literal-conc3-rep-elem-match

(defthm cst-atomic-literal-conc3-rep-elem-match
 (implies
    (and (cst-matchp abnf::cst "atomic-literal")
         (equal (cst-atomic-literal-conc? abnf::cst)
                3))
    (b* ((abnf::cst1 (cst-atomic-literal-conc3-rep-elem abnf::cst)))
      (cst-matchp abnf::cst1 "address-literal")))
 :rule-classes :rewrite)

Theorem: cst-atomic-literal-conc3-rep-elem-of-tree-fix-cst

(defthm cst-atomic-literal-conc3-rep-elem-of-tree-fix-cst
 (equal
      (cst-atomic-literal-conc3-rep-elem (abnf::tree-fix abnf::cst))
      (cst-atomic-literal-conc3-rep-elem abnf::cst)))

Theorem: cst-atomic-literal-conc3-rep-elem-tree-equiv-congruence-on-cst

(defthm
     cst-atomic-literal-conc3-rep-elem-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-atomic-literal-conc3-rep-elem abnf::cst)
                  (cst-atomic-literal-conc3-rep-elem cst-equiv)))
  :rule-classes :congruence)

Function: cst-atomic-literal-conc4-rep-elem

(defun cst-atomic-literal-conc4-rep-elem (abnf::cst)
 (declare (xargs :guard (abnf::treep abnf::cst)))
 (declare
      (xargs :guard (and (cst-matchp abnf::cst "atomic-literal")
                         (equal (cst-atomic-literal-conc? abnf::cst)
                                4))))
 (let ((__function__ 'cst-atomic-literal-conc4-rep-elem))
   (declare (ignorable __function__))
   (abnf::tree-fix (nth 0
                        (cst-atomic-literal-conc4-rep abnf::cst)))))

Theorem: treep-of-cst-atomic-literal-conc4-rep-elem

(defthm treep-of-cst-atomic-literal-conc4-rep-elem
  (b* ((abnf::cst1 (cst-atomic-literal-conc4-rep-elem abnf::cst)))
    (abnf::treep abnf::cst1))
  :rule-classes :rewrite)

Theorem: cst-atomic-literal-conc4-rep-elem-match

(defthm cst-atomic-literal-conc4-rep-elem-match
 (implies
    (and (cst-matchp abnf::cst "atomic-literal")
         (equal (cst-atomic-literal-conc? abnf::cst)
                4))
    (b* ((abnf::cst1 (cst-atomic-literal-conc4-rep-elem abnf::cst)))
      (cst-matchp abnf::cst1 "string-literal")))
 :rule-classes :rewrite)

Theorem: cst-atomic-literal-conc4-rep-elem-of-tree-fix-cst

(defthm cst-atomic-literal-conc4-rep-elem-of-tree-fix-cst
 (equal
      (cst-atomic-literal-conc4-rep-elem (abnf::tree-fix abnf::cst))
      (cst-atomic-literal-conc4-rep-elem abnf::cst)))

Theorem: cst-atomic-literal-conc4-rep-elem-tree-equiv-congruence-on-cst

(defthm
     cst-atomic-literal-conc4-rep-elem-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-atomic-literal-conc4-rep-elem abnf::cst)
                  (cst-atomic-literal-conc4-rep-elem cst-equiv)))
  :rule-classes :congruence)

Function: cst-token-conc1-rep-elem

(defun cst-token-conc1-rep-elem (abnf::cst)
  (declare (xargs :guard (abnf::treep abnf::cst)))
  (declare
       (xargs :guard (and (cst-matchp abnf::cst "token")
                          (equal (cst-token-conc? abnf::cst) 1))))
  (let ((__function__ 'cst-token-conc1-rep-elem))
    (declare (ignorable __function__))
    (abnf::tree-fix (nth 0 (cst-token-conc1-rep abnf::cst)))))

Theorem: treep-of-cst-token-conc1-rep-elem

(defthm treep-of-cst-token-conc1-rep-elem
  (b* ((abnf::cst1 (cst-token-conc1-rep-elem abnf::cst)))
    (abnf::treep abnf::cst1))
  :rule-classes :rewrite)

Theorem: cst-token-conc1-rep-elem-match

(defthm cst-token-conc1-rep-elem-match
  (implies (and (cst-matchp abnf::cst "token")
                (equal (cst-token-conc? abnf::cst) 1))
           (b* ((abnf::cst1 (cst-token-conc1-rep-elem abnf::cst)))
             (cst-matchp abnf::cst1 "keyword")))
  :rule-classes :rewrite)

Theorem: cst-token-conc1-rep-elem-of-tree-fix-cst

(defthm cst-token-conc1-rep-elem-of-tree-fix-cst
  (equal (cst-token-conc1-rep-elem (abnf::tree-fix abnf::cst))
         (cst-token-conc1-rep-elem abnf::cst)))

Theorem: cst-token-conc1-rep-elem-tree-equiv-congruence-on-cst

(defthm cst-token-conc1-rep-elem-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-token-conc1-rep-elem abnf::cst)
                  (cst-token-conc1-rep-elem cst-equiv)))
  :rule-classes :congruence)

Function: cst-token-conc2-rep-elem

(defun cst-token-conc2-rep-elem (abnf::cst)
  (declare (xargs :guard (abnf::treep abnf::cst)))
  (declare
       (xargs :guard (and (cst-matchp abnf::cst "token")
                          (equal (cst-token-conc? abnf::cst) 2))))
  (let ((__function__ 'cst-token-conc2-rep-elem))
    (declare (ignorable __function__))
    (abnf::tree-fix (nth 0 (cst-token-conc2-rep abnf::cst)))))

Theorem: treep-of-cst-token-conc2-rep-elem

(defthm treep-of-cst-token-conc2-rep-elem
  (b* ((abnf::cst1 (cst-token-conc2-rep-elem abnf::cst)))
    (abnf::treep abnf::cst1))
  :rule-classes :rewrite)

Theorem: cst-token-conc2-rep-elem-match

(defthm cst-token-conc2-rep-elem-match
  (implies (and (cst-matchp abnf::cst "token")
                (equal (cst-token-conc? abnf::cst) 2))
           (b* ((abnf::cst1 (cst-token-conc2-rep-elem abnf::cst)))
             (cst-matchp abnf::cst1 "identifier")))
  :rule-classes :rewrite)

Theorem: cst-token-conc2-rep-elem-of-tree-fix-cst

(defthm cst-token-conc2-rep-elem-of-tree-fix-cst
  (equal (cst-token-conc2-rep-elem (abnf::tree-fix abnf::cst))
         (cst-token-conc2-rep-elem abnf::cst)))

Theorem: cst-token-conc2-rep-elem-tree-equiv-congruence-on-cst

(defthm cst-token-conc2-rep-elem-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-token-conc2-rep-elem abnf::cst)
                  (cst-token-conc2-rep-elem cst-equiv)))
  :rule-classes :congruence)

Function: cst-token-conc3-rep-elem

(defun cst-token-conc3-rep-elem (abnf::cst)
  (declare (xargs :guard (abnf::treep abnf::cst)))
  (declare
       (xargs :guard (and (cst-matchp abnf::cst "token")
                          (equal (cst-token-conc? abnf::cst) 3))))
  (let ((__function__ 'cst-token-conc3-rep-elem))
    (declare (ignorable __function__))
    (abnf::tree-fix (nth 0 (cst-token-conc3-rep abnf::cst)))))

Theorem: treep-of-cst-token-conc3-rep-elem

(defthm treep-of-cst-token-conc3-rep-elem
  (b* ((abnf::cst1 (cst-token-conc3-rep-elem abnf::cst)))
    (abnf::treep abnf::cst1))
  :rule-classes :rewrite)

Theorem: cst-token-conc3-rep-elem-match

(defthm cst-token-conc3-rep-elem-match
  (implies (and (cst-matchp abnf::cst "token")
                (equal (cst-token-conc? abnf::cst) 3))
           (b* ((abnf::cst1 (cst-token-conc3-rep-elem abnf::cst)))
             (cst-matchp abnf::cst1 "atomic-literal")))
  :rule-classes :rewrite)

Theorem: cst-token-conc3-rep-elem-of-tree-fix-cst

(defthm cst-token-conc3-rep-elem-of-tree-fix-cst
  (equal (cst-token-conc3-rep-elem (abnf::tree-fix abnf::cst))
         (cst-token-conc3-rep-elem abnf::cst)))

Theorem: cst-token-conc3-rep-elem-tree-equiv-congruence-on-cst

(defthm cst-token-conc3-rep-elem-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-token-conc3-rep-elem abnf::cst)
                  (cst-token-conc3-rep-elem cst-equiv)))
  :rule-classes :congruence)

Function: cst-token-conc4-rep-elem

(defun cst-token-conc4-rep-elem (abnf::cst)
  (declare (xargs :guard (abnf::treep abnf::cst)))
  (declare
       (xargs :guard (and (cst-matchp abnf::cst "token")
                          (equal (cst-token-conc? abnf::cst) 4))))
  (let ((__function__ 'cst-token-conc4-rep-elem))
    (declare (ignorable __function__))
    (abnf::tree-fix (nth 0 (cst-token-conc4-rep abnf::cst)))))

Theorem: treep-of-cst-token-conc4-rep-elem

(defthm treep-of-cst-token-conc4-rep-elem
  (b* ((abnf::cst1 (cst-token-conc4-rep-elem abnf::cst)))
    (abnf::treep abnf::cst1))
  :rule-classes :rewrite)

Theorem: cst-token-conc4-rep-elem-match

(defthm cst-token-conc4-rep-elem-match
  (implies (and (cst-matchp abnf::cst "token")
                (equal (cst-token-conc? abnf::cst) 4))
           (b* ((abnf::cst1 (cst-token-conc4-rep-elem abnf::cst)))
             (cst-matchp abnf::cst1 "numeral")))
  :rule-classes :rewrite)

Theorem: cst-token-conc4-rep-elem-of-tree-fix-cst

(defthm cst-token-conc4-rep-elem-of-tree-fix-cst
  (equal (cst-token-conc4-rep-elem (abnf::tree-fix abnf::cst))
         (cst-token-conc4-rep-elem abnf::cst)))

Theorem: cst-token-conc4-rep-elem-tree-equiv-congruence-on-cst

(defthm cst-token-conc4-rep-elem-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-token-conc4-rep-elem abnf::cst)
                  (cst-token-conc4-rep-elem cst-equiv)))
  :rule-classes :congruence)

Function: cst-token-conc5-rep-elem

(defun cst-token-conc5-rep-elem (abnf::cst)
  (declare (xargs :guard (abnf::treep abnf::cst)))
  (declare
       (xargs :guard (and (cst-matchp abnf::cst "token")
                          (equal (cst-token-conc? abnf::cst) 5))))
  (let ((__function__ 'cst-token-conc5-rep-elem))
    (declare (ignorable __function__))
    (abnf::tree-fix (nth 0 (cst-token-conc5-rep abnf::cst)))))

Theorem: treep-of-cst-token-conc5-rep-elem

(defthm treep-of-cst-token-conc5-rep-elem
  (b* ((abnf::cst1 (cst-token-conc5-rep-elem abnf::cst)))
    (abnf::treep abnf::cst1))
  :rule-classes :rewrite)

Theorem: cst-token-conc5-rep-elem-match

(defthm cst-token-conc5-rep-elem-match
  (implies (and (cst-matchp abnf::cst "token")
                (equal (cst-token-conc? abnf::cst) 5))
           (b* ((abnf::cst1 (cst-token-conc5-rep-elem abnf::cst)))
             (cst-matchp abnf::cst1 "annotation")))
  :rule-classes :rewrite)

Theorem: cst-token-conc5-rep-elem-of-tree-fix-cst

(defthm cst-token-conc5-rep-elem-of-tree-fix-cst
  (equal (cst-token-conc5-rep-elem (abnf::tree-fix abnf::cst))
         (cst-token-conc5-rep-elem abnf::cst)))

Theorem: cst-token-conc5-rep-elem-tree-equiv-congruence-on-cst

(defthm cst-token-conc5-rep-elem-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-token-conc5-rep-elem abnf::cst)
                  (cst-token-conc5-rep-elem cst-equiv)))
  :rule-classes :congruence)

Function: cst-token-conc6-rep-elem

(defun cst-token-conc6-rep-elem (abnf::cst)
  (declare (xargs :guard (abnf::treep abnf::cst)))
  (declare
       (xargs :guard (and (cst-matchp abnf::cst "token")
                          (equal (cst-token-conc? abnf::cst) 6))))
  (let ((__function__ 'cst-token-conc6-rep-elem))
    (declare (ignorable __function__))
    (abnf::tree-fix (nth 0 (cst-token-conc6-rep abnf::cst)))))

Theorem: treep-of-cst-token-conc6-rep-elem

(defthm treep-of-cst-token-conc6-rep-elem
  (b* ((abnf::cst1 (cst-token-conc6-rep-elem abnf::cst)))
    (abnf::treep abnf::cst1))
  :rule-classes :rewrite)

Theorem: cst-token-conc6-rep-elem-match

(defthm cst-token-conc6-rep-elem-match
  (implies (and (cst-matchp abnf::cst "token")
                (equal (cst-token-conc? abnf::cst) 6))
           (b* ((abnf::cst1 (cst-token-conc6-rep-elem abnf::cst)))
             (cst-matchp abnf::cst1 "symbol")))
  :rule-classes :rewrite)

Theorem: cst-token-conc6-rep-elem-of-tree-fix-cst

(defthm cst-token-conc6-rep-elem-of-tree-fix-cst
  (equal (cst-token-conc6-rep-elem (abnf::tree-fix abnf::cst))
         (cst-token-conc6-rep-elem abnf::cst)))

Theorem: cst-token-conc6-rep-elem-tree-equiv-congruence-on-cst

(defthm cst-token-conc6-rep-elem-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-token-conc6-rep-elem abnf::cst)
                  (cst-token-conc6-rep-elem cst-equiv)))
  :rule-classes :congruence)

Function: cst-lexeme-conc1-rep-elem

(defun cst-lexeme-conc1-rep-elem (abnf::cst)
  (declare (xargs :guard (abnf::treep abnf::cst)))
  (declare (xargs :guard (and (cst-matchp abnf::cst "lexeme")
                              (equal (cst-lexeme-conc? abnf::cst)
                                     1))))
  (let ((__function__ 'cst-lexeme-conc1-rep-elem))
    (declare (ignorable __function__))
    (abnf::tree-fix (nth 0 (cst-lexeme-conc1-rep abnf::cst)))))

Theorem: treep-of-cst-lexeme-conc1-rep-elem

(defthm treep-of-cst-lexeme-conc1-rep-elem
  (b* ((abnf::cst1 (cst-lexeme-conc1-rep-elem abnf::cst)))
    (abnf::treep abnf::cst1))
  :rule-classes :rewrite)

Theorem: cst-lexeme-conc1-rep-elem-match

(defthm cst-lexeme-conc1-rep-elem-match
  (implies (and (cst-matchp abnf::cst "lexeme")
                (equal (cst-lexeme-conc? abnf::cst) 1))
           (b* ((abnf::cst1 (cst-lexeme-conc1-rep-elem abnf::cst)))
             (cst-matchp abnf::cst1 "token")))
  :rule-classes :rewrite)

Theorem: cst-lexeme-conc1-rep-elem-of-tree-fix-cst

(defthm cst-lexeme-conc1-rep-elem-of-tree-fix-cst
  (equal (cst-lexeme-conc1-rep-elem (abnf::tree-fix abnf::cst))
         (cst-lexeme-conc1-rep-elem abnf::cst)))

Theorem: cst-lexeme-conc1-rep-elem-tree-equiv-congruence-on-cst

(defthm cst-lexeme-conc1-rep-elem-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-lexeme-conc1-rep-elem abnf::cst)
                  (cst-lexeme-conc1-rep-elem cst-equiv)))
  :rule-classes :congruence)

Function: cst-lexeme-conc2-rep-elem

(defun cst-lexeme-conc2-rep-elem (abnf::cst)
  (declare (xargs :guard (abnf::treep abnf::cst)))
  (declare (xargs :guard (and (cst-matchp abnf::cst "lexeme")
                              (equal (cst-lexeme-conc? abnf::cst)
                                     2))))
  (let ((__function__ 'cst-lexeme-conc2-rep-elem))
    (declare (ignorable __function__))
    (abnf::tree-fix (nth 0 (cst-lexeme-conc2-rep abnf::cst)))))

Theorem: treep-of-cst-lexeme-conc2-rep-elem

(defthm treep-of-cst-lexeme-conc2-rep-elem
  (b* ((abnf::cst1 (cst-lexeme-conc2-rep-elem abnf::cst)))
    (abnf::treep abnf::cst1))
  :rule-classes :rewrite)

Theorem: cst-lexeme-conc2-rep-elem-match

(defthm cst-lexeme-conc2-rep-elem-match
  (implies (and (cst-matchp abnf::cst "lexeme")
                (equal (cst-lexeme-conc? abnf::cst) 2))
           (b* ((abnf::cst1 (cst-lexeme-conc2-rep-elem abnf::cst)))
             (cst-matchp abnf::cst1 "comment")))
  :rule-classes :rewrite)

Theorem: cst-lexeme-conc2-rep-elem-of-tree-fix-cst

(defthm cst-lexeme-conc2-rep-elem-of-tree-fix-cst
  (equal (cst-lexeme-conc2-rep-elem (abnf::tree-fix abnf::cst))
         (cst-lexeme-conc2-rep-elem abnf::cst)))

Theorem: cst-lexeme-conc2-rep-elem-tree-equiv-congruence-on-cst

(defthm cst-lexeme-conc2-rep-elem-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-lexeme-conc2-rep-elem abnf::cst)
                  (cst-lexeme-conc2-rep-elem cst-equiv)))
  :rule-classes :congruence)

Function: cst-lexeme-conc3-rep-elem

(defun cst-lexeme-conc3-rep-elem (abnf::cst)
  (declare (xargs :guard (abnf::treep abnf::cst)))
  (declare (xargs :guard (and (cst-matchp abnf::cst "lexeme")
                              (equal (cst-lexeme-conc? abnf::cst)
                                     3))))
  (let ((__function__ 'cst-lexeme-conc3-rep-elem))
    (declare (ignorable __function__))
    (abnf::tree-fix (nth 0 (cst-lexeme-conc3-rep abnf::cst)))))

Theorem: treep-of-cst-lexeme-conc3-rep-elem

(defthm treep-of-cst-lexeme-conc3-rep-elem
  (b* ((abnf::cst1 (cst-lexeme-conc3-rep-elem abnf::cst)))
    (abnf::treep abnf::cst1))
  :rule-classes :rewrite)

Theorem: cst-lexeme-conc3-rep-elem-match

(defthm cst-lexeme-conc3-rep-elem-match
  (implies (and (cst-matchp abnf::cst "lexeme")
                (equal (cst-lexeme-conc? abnf::cst) 3))
           (b* ((abnf::cst1 (cst-lexeme-conc3-rep-elem abnf::cst)))
             (cst-matchp abnf::cst1 "whitespace")))
  :rule-classes :rewrite)

Theorem: cst-lexeme-conc3-rep-elem-of-tree-fix-cst

(defthm cst-lexeme-conc3-rep-elem-of-tree-fix-cst
  (equal (cst-lexeme-conc3-rep-elem (abnf::tree-fix abnf::cst))
         (cst-lexeme-conc3-rep-elem abnf::cst)))

Theorem: cst-lexeme-conc3-rep-elem-tree-equiv-congruence-on-cst

(defthm cst-lexeme-conc3-rep-elem-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-lexeme-conc3-rep-elem abnf::cst)
                  (cst-lexeme-conc3-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-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\"bool\"")))
  :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-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-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-named-primitive-type-conc1-rep-elem

(defun cst-named-primitive-type-conc1-rep-elem (abnf::cst)
 (declare (xargs :guard (abnf::treep abnf::cst)))
 (declare
  (xargs
       :guard (and (cst-matchp abnf::cst "named-primitive-type")
                   (equal (cst-named-primitive-type-conc? abnf::cst)
                          1))))
 (let ((__function__ 'cst-named-primitive-type-conc1-rep-elem))
   (declare (ignorable __function__))
   (abnf::tree-fix
        (nth 0
             (cst-named-primitive-type-conc1-rep abnf::cst)))))

Theorem: treep-of-cst-named-primitive-type-conc1-rep-elem

(defthm treep-of-cst-named-primitive-type-conc1-rep-elem
 (b*
  ((abnf::cst1 (cst-named-primitive-type-conc1-rep-elem abnf::cst)))
  (abnf::treep abnf::cst1))
 :rule-classes :rewrite)

Theorem: cst-named-primitive-type-conc1-rep-elem-match

(defthm cst-named-primitive-type-conc1-rep-elem-match
 (implies
     (and (cst-matchp abnf::cst "named-primitive-type")
          (equal (cst-named-primitive-type-conc? abnf::cst)
                 1))
     (b* ((abnf::cst1
               (cst-named-primitive-type-conc1-rep-elem abnf::cst)))
       (cst-matchp abnf::cst1 "boolean-type")))
 :rule-classes :rewrite)

Theorem: cst-named-primitive-type-conc1-rep-elem-of-tree-fix-cst

(defthm cst-named-primitive-type-conc1-rep-elem-of-tree-fix-cst
  (equal (cst-named-primitive-type-conc1-rep-elem
              (abnf::tree-fix abnf::cst))
         (cst-named-primitive-type-conc1-rep-elem abnf::cst)))

Theorem: cst-named-primitive-type-conc1-rep-elem-tree-equiv-congruence-on-cst

(defthm
 cst-named-primitive-type-conc1-rep-elem-tree-equiv-congruence-on-cst
 (implies
      (abnf::tree-equiv abnf::cst cst-equiv)
      (equal (cst-named-primitive-type-conc1-rep-elem abnf::cst)
             (cst-named-primitive-type-conc1-rep-elem cst-equiv)))
 :rule-classes :congruence)

Function: cst-named-primitive-type-conc2-rep-elem

(defun cst-named-primitive-type-conc2-rep-elem (abnf::cst)
 (declare (xargs :guard (abnf::treep abnf::cst)))
 (declare
  (xargs
       :guard (and (cst-matchp abnf::cst "named-primitive-type")
                   (equal (cst-named-primitive-type-conc? abnf::cst)
                          2))))
 (let ((__function__ 'cst-named-primitive-type-conc2-rep-elem))
   (declare (ignorable __function__))
   (abnf::tree-fix
        (nth 0
             (cst-named-primitive-type-conc2-rep abnf::cst)))))

Theorem: treep-of-cst-named-primitive-type-conc2-rep-elem

(defthm treep-of-cst-named-primitive-type-conc2-rep-elem
 (b*
  ((abnf::cst1 (cst-named-primitive-type-conc2-rep-elem abnf::cst)))
  (abnf::treep abnf::cst1))
 :rule-classes :rewrite)

Theorem: cst-named-primitive-type-conc2-rep-elem-match

(defthm cst-named-primitive-type-conc2-rep-elem-match
 (implies
     (and (cst-matchp abnf::cst "named-primitive-type")
          (equal (cst-named-primitive-type-conc? abnf::cst)
                 2))
     (b* ((abnf::cst1
               (cst-named-primitive-type-conc2-rep-elem abnf::cst)))
       (cst-matchp abnf::cst1 "arithmetic-type")))
 :rule-classes :rewrite)

Theorem: cst-named-primitive-type-conc2-rep-elem-of-tree-fix-cst

(defthm cst-named-primitive-type-conc2-rep-elem-of-tree-fix-cst
  (equal (cst-named-primitive-type-conc2-rep-elem
              (abnf::tree-fix abnf::cst))
         (cst-named-primitive-type-conc2-rep-elem abnf::cst)))

Theorem: cst-named-primitive-type-conc2-rep-elem-tree-equiv-congruence-on-cst

(defthm
 cst-named-primitive-type-conc2-rep-elem-tree-equiv-congruence-on-cst
 (implies
      (abnf::tree-equiv abnf::cst cst-equiv)
      (equal (cst-named-primitive-type-conc2-rep-elem abnf::cst)
             (cst-named-primitive-type-conc2-rep-elem cst-equiv)))
 :rule-classes :congruence)

Function: cst-named-primitive-type-conc3-rep-elem

(defun cst-named-primitive-type-conc3-rep-elem (abnf::cst)
 (declare (xargs :guard (abnf::treep abnf::cst)))
 (declare
  (xargs
       :guard (and (cst-matchp abnf::cst "named-primitive-type")
                   (equal (cst-named-primitive-type-conc? abnf::cst)
                          3))))
 (let ((__function__ 'cst-named-primitive-type-conc3-rep-elem))
   (declare (ignorable __function__))
   (abnf::tree-fix
        (nth 0
             (cst-named-primitive-type-conc3-rep abnf::cst)))))

Theorem: treep-of-cst-named-primitive-type-conc3-rep-elem

(defthm treep-of-cst-named-primitive-type-conc3-rep-elem
 (b*
  ((abnf::cst1 (cst-named-primitive-type-conc3-rep-elem abnf::cst)))
  (abnf::treep abnf::cst1))
 :rule-classes :rewrite)

Theorem: cst-named-primitive-type-conc3-rep-elem-match

(defthm cst-named-primitive-type-conc3-rep-elem-match
 (implies
     (and (cst-matchp abnf::cst "named-primitive-type")
          (equal (cst-named-primitive-type-conc? abnf::cst)
                 3))
     (b* ((abnf::cst1
               (cst-named-primitive-type-conc3-rep-elem abnf::cst)))
       (cst-matchp abnf::cst1 "address-type")))
 :rule-classes :rewrite)

Theorem: cst-named-primitive-type-conc3-rep-elem-of-tree-fix-cst

(defthm cst-named-primitive-type-conc3-rep-elem-of-tree-fix-cst
  (equal (cst-named-primitive-type-conc3-rep-elem
              (abnf::tree-fix abnf::cst))
         (cst-named-primitive-type-conc3-rep-elem abnf::cst)))

Theorem: cst-named-primitive-type-conc3-rep-elem-tree-equiv-congruence-on-cst

(defthm
 cst-named-primitive-type-conc3-rep-elem-tree-equiv-congruence-on-cst
 (implies
      (abnf::tree-equiv abnf::cst cst-equiv)
      (equal (cst-named-primitive-type-conc3-rep-elem abnf::cst)
             (cst-named-primitive-type-conc3-rep-elem cst-equiv)))
 :rule-classes :congruence)

Function: cst-named-primitive-type-conc4-rep-elem

(defun cst-named-primitive-type-conc4-rep-elem (abnf::cst)
 (declare (xargs :guard (abnf::treep abnf::cst)))
 (declare
  (xargs
       :guard (and (cst-matchp abnf::cst "named-primitive-type")
                   (equal (cst-named-primitive-type-conc? abnf::cst)
                          4))))
 (let ((__function__ 'cst-named-primitive-type-conc4-rep-elem))
   (declare (ignorable __function__))
   (abnf::tree-fix
        (nth 0
             (cst-named-primitive-type-conc4-rep abnf::cst)))))

Theorem: treep-of-cst-named-primitive-type-conc4-rep-elem

(defthm treep-of-cst-named-primitive-type-conc4-rep-elem
 (b*
  ((abnf::cst1 (cst-named-primitive-type-conc4-rep-elem abnf::cst)))
  (abnf::treep abnf::cst1))
 :rule-classes :rewrite)

Theorem: cst-named-primitive-type-conc4-rep-elem-match

(defthm cst-named-primitive-type-conc4-rep-elem-match
 (implies
     (and (cst-matchp abnf::cst "named-primitive-type")
          (equal (cst-named-primitive-type-conc? abnf::cst)
                 4))
     (b* ((abnf::cst1
               (cst-named-primitive-type-conc4-rep-elem abnf::cst)))
       (cst-matchp abnf::cst1 "string-type")))
 :rule-classes :rewrite)

Theorem: cst-named-primitive-type-conc4-rep-elem-of-tree-fix-cst

(defthm cst-named-primitive-type-conc4-rep-elem-of-tree-fix-cst
  (equal (cst-named-primitive-type-conc4-rep-elem
              (abnf::tree-fix abnf::cst))
         (cst-named-primitive-type-conc4-rep-elem abnf::cst)))

Theorem: cst-named-primitive-type-conc4-rep-elem-tree-equiv-congruence-on-cst

(defthm
 cst-named-primitive-type-conc4-rep-elem-tree-equiv-congruence-on-cst
 (implies
      (abnf::tree-equiv abnf::cst cst-equiv)
      (equal (cst-named-primitive-type-conc4-rep-elem abnf::cst)
             (cst-named-primitive-type-conc4-rep-elem cst-equiv)))
 :rule-classes :congruence)

Function: cst-primitive-type-conc1-rep-elem

(defun cst-primitive-type-conc1-rep-elem (abnf::cst)
 (declare (xargs :guard (abnf::treep abnf::cst)))
 (declare
      (xargs :guard (and (cst-matchp abnf::cst "primitive-type")
                         (equal (cst-primitive-type-conc? abnf::cst)
                                1))))
 (let ((__function__ 'cst-primitive-type-conc1-rep-elem))
   (declare (ignorable __function__))
   (abnf::tree-fix (nth 0
                        (cst-primitive-type-conc1-rep abnf::cst)))))

Theorem: treep-of-cst-primitive-type-conc1-rep-elem

(defthm treep-of-cst-primitive-type-conc1-rep-elem
  (b* ((abnf::cst1 (cst-primitive-type-conc1-rep-elem abnf::cst)))
    (abnf::treep abnf::cst1))
  :rule-classes :rewrite)

Theorem: cst-primitive-type-conc1-rep-elem-match

(defthm cst-primitive-type-conc1-rep-elem-match
 (implies
    (and (cst-matchp abnf::cst "primitive-type")
         (equal (cst-primitive-type-conc? abnf::cst)
                1))
    (b* ((abnf::cst1 (cst-primitive-type-conc1-rep-elem abnf::cst)))
      (cst-matchp abnf::cst1 "named-primitive-type")))
 :rule-classes :rewrite)

Theorem: cst-primitive-type-conc1-rep-elem-of-tree-fix-cst

(defthm cst-primitive-type-conc1-rep-elem-of-tree-fix-cst
 (equal
      (cst-primitive-type-conc1-rep-elem (abnf::tree-fix abnf::cst))
      (cst-primitive-type-conc1-rep-elem abnf::cst)))

Theorem: cst-primitive-type-conc1-rep-elem-tree-equiv-congruence-on-cst

(defthm
     cst-primitive-type-conc1-rep-elem-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-primitive-type-conc1-rep-elem abnf::cst)
                  (cst-primitive-type-conc1-rep-elem cst-equiv)))
  :rule-classes :congruence)

Function: cst-primitive-type-conc2-rep-elem

(defun cst-primitive-type-conc2-rep-elem (abnf::cst)
 (declare (xargs :guard (abnf::treep abnf::cst)))
 (declare
      (xargs :guard (and (cst-matchp abnf::cst "primitive-type")
                         (equal (cst-primitive-type-conc? abnf::cst)
                                2))))
 (let ((__function__ 'cst-primitive-type-conc2-rep-elem))
   (declare (ignorable __function__))
   (abnf::tree-fix (nth 0
                        (cst-primitive-type-conc2-rep abnf::cst)))))

Theorem: treep-of-cst-primitive-type-conc2-rep-elem

(defthm treep-of-cst-primitive-type-conc2-rep-elem
  (b* ((abnf::cst1 (cst-primitive-type-conc2-rep-elem abnf::cst)))
    (abnf::treep abnf::cst1))
  :rule-classes :rewrite)

Theorem: cst-primitive-type-conc2-rep-elem-match

(defthm cst-primitive-type-conc2-rep-elem-match
 (implies
    (and (cst-matchp abnf::cst "primitive-type")
         (equal (cst-primitive-type-conc? abnf::cst)
                2))
    (b* ((abnf::cst1 (cst-primitive-type-conc2-rep-elem abnf::cst)))
      (cst-matchp abnf::cst1 "unit-type")))
 :rule-classes :rewrite)

Theorem: cst-primitive-type-conc2-rep-elem-of-tree-fix-cst

(defthm cst-primitive-type-conc2-rep-elem-of-tree-fix-cst
 (equal
      (cst-primitive-type-conc2-rep-elem (abnf::tree-fix abnf::cst))
      (cst-primitive-type-conc2-rep-elem abnf::cst)))

Theorem: cst-primitive-type-conc2-rep-elem-tree-equiv-congruence-on-cst

(defthm
     cst-primitive-type-conc2-rep-elem-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-primitive-type-conc2-rep-elem abnf::cst)
                  (cst-primitive-type-conc2-rep-elem cst-equiv)))
  :rule-classes :congruence)

Function: cst-type-conc1-rep-elem

(defun cst-type-conc1-rep-elem (abnf::cst)
 (declare (xargs :guard (abnf::treep abnf::cst)))
 (declare (xargs :guard (and (cst-matchp abnf::cst "type")
                             (equal (cst-type-conc? abnf::cst) 1))))
 (let ((__function__ 'cst-type-conc1-rep-elem))
   (declare (ignorable __function__))
   (abnf::tree-fix (nth 0 (cst-type-conc1-rep abnf::cst)))))

Theorem: treep-of-cst-type-conc1-rep-elem

(defthm treep-of-cst-type-conc1-rep-elem
  (b* ((abnf::cst1 (cst-type-conc1-rep-elem abnf::cst)))
    (abnf::treep abnf::cst1))
  :rule-classes :rewrite)

Theorem: cst-type-conc1-rep-elem-match

(defthm cst-type-conc1-rep-elem-match
  (implies (and (cst-matchp abnf::cst "type")
                (equal (cst-type-conc? abnf::cst) 1))
           (b* ((abnf::cst1 (cst-type-conc1-rep-elem abnf::cst)))
             (cst-matchp abnf::cst1 "named-type")))
  :rule-classes :rewrite)

Theorem: cst-type-conc1-rep-elem-of-tree-fix-cst

(defthm cst-type-conc1-rep-elem-of-tree-fix-cst
  (equal (cst-type-conc1-rep-elem (abnf::tree-fix abnf::cst))
         (cst-type-conc1-rep-elem abnf::cst)))

Theorem: cst-type-conc1-rep-elem-tree-equiv-congruence-on-cst

(defthm cst-type-conc1-rep-elem-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-type-conc1-rep-elem abnf::cst)
                  (cst-type-conc1-rep-elem cst-equiv)))
  :rule-classes :congruence)

Function: cst-type-conc2-rep-elem

(defun cst-type-conc2-rep-elem (abnf::cst)
 (declare (xargs :guard (abnf::treep abnf::cst)))
 (declare (xargs :guard (and (cst-matchp abnf::cst "type")
                             (equal (cst-type-conc? abnf::cst) 2))))
 (let ((__function__ 'cst-type-conc2-rep-elem))
   (declare (ignorable __function__))
   (abnf::tree-fix (nth 0 (cst-type-conc2-rep abnf::cst)))))

Theorem: treep-of-cst-type-conc2-rep-elem

(defthm treep-of-cst-type-conc2-rep-elem
  (b* ((abnf::cst1 (cst-type-conc2-rep-elem abnf::cst)))
    (abnf::treep abnf::cst1))
  :rule-classes :rewrite)

Theorem: cst-type-conc2-rep-elem-match

(defthm cst-type-conc2-rep-elem-match
  (implies (and (cst-matchp abnf::cst "type")
                (equal (cst-type-conc? abnf::cst) 2))
           (b* ((abnf::cst1 (cst-type-conc2-rep-elem abnf::cst)))
             (cst-matchp abnf::cst1 "unit-type")))
  :rule-classes :rewrite)

Theorem: cst-type-conc2-rep-elem-of-tree-fix-cst

(defthm cst-type-conc2-rep-elem-of-tree-fix-cst
  (equal (cst-type-conc2-rep-elem (abnf::tree-fix abnf::cst))
         (cst-type-conc2-rep-elem abnf::cst)))

Theorem: cst-type-conc2-rep-elem-tree-equiv-congruence-on-cst

(defthm cst-type-conc2-rep-elem-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-type-conc2-rep-elem abnf::cst)
                  (cst-type-conc2-rep-elem cst-equiv)))
  :rule-classes :congruence)

Function: cst-type-conc3-rep-elem

(defun cst-type-conc3-rep-elem (abnf::cst)
 (declare (xargs :guard (abnf::treep abnf::cst)))
 (declare (xargs :guard (and (cst-matchp abnf::cst "type")
                             (equal (cst-type-conc? abnf::cst) 3))))
 (let ((__function__ 'cst-type-conc3-rep-elem))
   (declare (ignorable __function__))
   (abnf::tree-fix (nth 0 (cst-type-conc3-rep abnf::cst)))))

Theorem: treep-of-cst-type-conc3-rep-elem

(defthm treep-of-cst-type-conc3-rep-elem
  (b* ((abnf::cst1 (cst-type-conc3-rep-elem abnf::cst)))
    (abnf::treep abnf::cst1))
  :rule-classes :rewrite)

Theorem: cst-type-conc3-rep-elem-match

(defthm cst-type-conc3-rep-elem-match
  (implies (and (cst-matchp abnf::cst "type")
                (equal (cst-type-conc? abnf::cst) 3))
           (b* ((abnf::cst1 (cst-type-conc3-rep-elem abnf::cst)))
             (cst-matchp abnf::cst1 "tuple-type")))
  :rule-classes :rewrite)

Theorem: cst-type-conc3-rep-elem-of-tree-fix-cst

(defthm cst-type-conc3-rep-elem-of-tree-fix-cst
  (equal (cst-type-conc3-rep-elem (abnf::tree-fix abnf::cst))
         (cst-type-conc3-rep-elem abnf::cst)))

Theorem: cst-type-conc3-rep-elem-tree-equiv-congruence-on-cst

(defthm cst-type-conc3-rep-elem-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-type-conc3-rep-elem abnf::cst)
                  (cst-type-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 "atomic-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 "affine-group-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-group-literal-conc1-rep-elem

(defun cst-group-literal-conc1-rep-elem (abnf::cst)
  (declare (xargs :guard (abnf::treep abnf::cst)))
  (declare
       (xargs :guard (and (cst-matchp abnf::cst "group-literal")
                          (equal (cst-group-literal-conc? abnf::cst)
                                 1))))
  (let ((__function__ 'cst-group-literal-conc1-rep-elem))
    (declare (ignorable __function__))
    (abnf::tree-fix (nth 0
                         (cst-group-literal-conc1-rep abnf::cst)))))

Theorem: treep-of-cst-group-literal-conc1-rep-elem

(defthm treep-of-cst-group-literal-conc1-rep-elem
  (b* ((abnf::cst1 (cst-group-literal-conc1-rep-elem abnf::cst)))
    (abnf::treep abnf::cst1))
  :rule-classes :rewrite)

Theorem: cst-group-literal-conc1-rep-elem-match

(defthm cst-group-literal-conc1-rep-elem-match
 (implies
     (and (cst-matchp abnf::cst "group-literal")
          (equal (cst-group-literal-conc? abnf::cst)
                 1))
     (b* ((abnf::cst1 (cst-group-literal-conc1-rep-elem abnf::cst)))
       (cst-matchp abnf::cst1 "product-group-literal")))
 :rule-classes :rewrite)

Theorem: cst-group-literal-conc1-rep-elem-of-tree-fix-cst

(defthm cst-group-literal-conc1-rep-elem-of-tree-fix-cst
  (equal
       (cst-group-literal-conc1-rep-elem (abnf::tree-fix abnf::cst))
       (cst-group-literal-conc1-rep-elem abnf::cst)))

Theorem: cst-group-literal-conc1-rep-elem-tree-equiv-congruence-on-cst

(defthm
      cst-group-literal-conc1-rep-elem-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-group-literal-conc1-rep-elem abnf::cst)
                  (cst-group-literal-conc1-rep-elem cst-equiv)))
  :rule-classes :congruence)

Function: cst-group-literal-conc2-rep-elem

(defun cst-group-literal-conc2-rep-elem (abnf::cst)
  (declare (xargs :guard (abnf::treep abnf::cst)))
  (declare
       (xargs :guard (and (cst-matchp abnf::cst "group-literal")
                          (equal (cst-group-literal-conc? abnf::cst)
                                 2))))
  (let ((__function__ 'cst-group-literal-conc2-rep-elem))
    (declare (ignorable __function__))
    (abnf::tree-fix (nth 0
                         (cst-group-literal-conc2-rep abnf::cst)))))

Theorem: treep-of-cst-group-literal-conc2-rep-elem

(defthm treep-of-cst-group-literal-conc2-rep-elem
  (b* ((abnf::cst1 (cst-group-literal-conc2-rep-elem abnf::cst)))
    (abnf::treep abnf::cst1))
  :rule-classes :rewrite)

Theorem: cst-group-literal-conc2-rep-elem-match

(defthm cst-group-literal-conc2-rep-elem-match
 (implies
     (and (cst-matchp abnf::cst "group-literal")
          (equal (cst-group-literal-conc? abnf::cst)
                 2))
     (b* ((abnf::cst1 (cst-group-literal-conc2-rep-elem abnf::cst)))
       (cst-matchp abnf::cst1 "affine-group-literal")))
 :rule-classes :rewrite)

Theorem: cst-group-literal-conc2-rep-elem-of-tree-fix-cst

(defthm cst-group-literal-conc2-rep-elem-of-tree-fix-cst
  (equal
       (cst-group-literal-conc2-rep-elem (abnf::tree-fix abnf::cst))
       (cst-group-literal-conc2-rep-elem abnf::cst)))

Theorem: cst-group-literal-conc2-rep-elem-tree-equiv-congruence-on-cst

(defthm
      cst-group-literal-conc2-rep-elem-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-group-literal-conc2-rep-elem abnf::cst)
                  (cst-group-literal-conc2-rep-elem cst-equiv)))
  :rule-classes :congruence)

Function: cst-variable-or-free-constant-conc-rep-elem

(defun cst-variable-or-free-constant-conc-rep-elem (abnf::cst)
 (declare (xargs :guard (abnf::treep abnf::cst)))
 (declare
  (xargs :guard (cst-matchp abnf::cst "variable-or-free-constant")))
 (let ((__function__ 'cst-variable-or-free-constant-conc-rep-elem))
   (declare (ignorable __function__))
   (abnf::tree-fix
        (nth 0
             (cst-variable-or-free-constant-conc-rep abnf::cst)))))

Theorem: treep-of-cst-variable-or-free-constant-conc-rep-elem

(defthm treep-of-cst-variable-or-free-constant-conc-rep-elem
 (b* ((abnf::cst1
           (cst-variable-or-free-constant-conc-rep-elem abnf::cst)))
   (abnf::treep abnf::cst1))
 :rule-classes :rewrite)

Theorem: cst-variable-or-free-constant-conc-rep-elem-match

(defthm cst-variable-or-free-constant-conc-rep-elem-match
 (implies
   (cst-matchp abnf::cst "variable-or-free-constant")
   (b*
     ((abnf::cst1
           (cst-variable-or-free-constant-conc-rep-elem abnf::cst)))
     (cst-matchp abnf::cst1 "identifier")))
 :rule-classes :rewrite)

Theorem: cst-variable-or-free-constant-conc-rep-elem-of-tree-fix-cst

(defthm cst-variable-or-free-constant-conc-rep-elem-of-tree-fix-cst
  (equal (cst-variable-or-free-constant-conc-rep-elem
              (abnf::tree-fix abnf::cst))
         (cst-variable-or-free-constant-conc-rep-elem abnf::cst)))

Theorem: cst-variable-or-free-constant-conc-rep-elem-tree-equiv-congruence-on-cst

(defthm
 cst-variable-or-free-constant-conc-rep-elem-tree-equiv-congruence-on-cst
 (implies
    (abnf::tree-equiv abnf::cst cst-equiv)
    (equal (cst-variable-or-free-constant-conc-rep-elem abnf::cst)
           (cst-variable-or-free-constant-conc-rep-elem cst-equiv)))
 :rule-classes :congruence)

Function: cst-postfix-expression-conc1-rep-elem

(defun cst-postfix-expression-conc1-rep-elem (abnf::cst)
 (declare (xargs :guard (abnf::treep abnf::cst)))
 (declare
  (xargs :guard (and (cst-matchp abnf::cst "postfix-expression")
                     (equal (cst-postfix-expression-conc? abnf::cst)
                            1))))
 (let ((__function__ 'cst-postfix-expression-conc1-rep-elem))
   (declare (ignorable __function__))
   (abnf::tree-fix
        (nth 0
             (cst-postfix-expression-conc1-rep abnf::cst)))))

Theorem: treep-of-cst-postfix-expression-conc1-rep-elem

(defthm treep-of-cst-postfix-expression-conc1-rep-elem
  (b*
    ((abnf::cst1 (cst-postfix-expression-conc1-rep-elem abnf::cst)))
    (abnf::treep abnf::cst1))
  :rule-classes :rewrite)

Theorem: cst-postfix-expression-conc1-rep-elem-match

(defthm cst-postfix-expression-conc1-rep-elem-match
 (implies
   (and (cst-matchp abnf::cst "postfix-expression")
        (equal (cst-postfix-expression-conc? abnf::cst)
               1))
   (b*
    ((abnf::cst1 (cst-postfix-expression-conc1-rep-elem abnf::cst)))
    (cst-matchp abnf::cst1 "primary-expression")))
 :rule-classes :rewrite)

Theorem: cst-postfix-expression-conc1-rep-elem-of-tree-fix-cst

(defthm cst-postfix-expression-conc1-rep-elem-of-tree-fix-cst
 (equal
  (cst-postfix-expression-conc1-rep-elem (abnf::tree-fix abnf::cst))
  (cst-postfix-expression-conc1-rep-elem abnf::cst)))

Theorem: cst-postfix-expression-conc1-rep-elem-tree-equiv-congruence-on-cst

(defthm
 cst-postfix-expression-conc1-rep-elem-tree-equiv-congruence-on-cst
 (implies (abnf::tree-equiv abnf::cst cst-equiv)
          (equal (cst-postfix-expression-conc1-rep-elem abnf::cst)
                 (cst-postfix-expression-conc1-rep-elem cst-equiv)))
 :rule-classes :congruence)

Function: cst-postfix-expression-conc2-rep-elem

(defun cst-postfix-expression-conc2-rep-elem (abnf::cst)
 (declare (xargs :guard (abnf::treep abnf::cst)))
 (declare
  (xargs :guard (and (cst-matchp abnf::cst "postfix-expression")
                     (equal (cst-postfix-expression-conc? abnf::cst)
                            2))))
 (let ((__function__ 'cst-postfix-expression-conc2-rep-elem))
   (declare (ignorable __function__))
   (abnf::tree-fix
        (nth 0
             (cst-postfix-expression-conc2-rep abnf::cst)))))

Theorem: treep-of-cst-postfix-expression-conc2-rep-elem

(defthm treep-of-cst-postfix-expression-conc2-rep-elem
  (b*
    ((abnf::cst1 (cst-postfix-expression-conc2-rep-elem abnf::cst)))
    (abnf::treep abnf::cst1))
  :rule-classes :rewrite)

Theorem: cst-postfix-expression-conc2-rep-elem-match

(defthm cst-postfix-expression-conc2-rep-elem-match
 (implies
   (and (cst-matchp abnf::cst "postfix-expression")
        (equal (cst-postfix-expression-conc? abnf::cst)
               2))
   (b*
    ((abnf::cst1 (cst-postfix-expression-conc2-rep-elem abnf::cst)))
    (cst-matchp abnf::cst1
                "tuple-component-expression")))
 :rule-classes :rewrite)

Theorem: cst-postfix-expression-conc2-rep-elem-of-tree-fix-cst

(defthm cst-postfix-expression-conc2-rep-elem-of-tree-fix-cst
 (equal
  (cst-postfix-expression-conc2-rep-elem (abnf::tree-fix abnf::cst))
  (cst-postfix-expression-conc2-rep-elem abnf::cst)))

Theorem: cst-postfix-expression-conc2-rep-elem-tree-equiv-congruence-on-cst

(defthm
 cst-postfix-expression-conc2-rep-elem-tree-equiv-congruence-on-cst
 (implies (abnf::tree-equiv abnf::cst cst-equiv)
          (equal (cst-postfix-expression-conc2-rep-elem abnf::cst)
                 (cst-postfix-expression-conc2-rep-elem cst-equiv)))
 :rule-classes :congruence)

Function: cst-postfix-expression-conc3-rep-elem

(defun cst-postfix-expression-conc3-rep-elem (abnf::cst)
 (declare (xargs :guard (abnf::treep abnf::cst)))
 (declare
  (xargs :guard (and (cst-matchp abnf::cst "postfix-expression")
                     (equal (cst-postfix-expression-conc? abnf::cst)
                            3))))
 (let ((__function__ 'cst-postfix-expression-conc3-rep-elem))
   (declare (ignorable __function__))
   (abnf::tree-fix
        (nth 0
             (cst-postfix-expression-conc3-rep abnf::cst)))))

Theorem: treep-of-cst-postfix-expression-conc3-rep-elem

(defthm treep-of-cst-postfix-expression-conc3-rep-elem
  (b*
    ((abnf::cst1 (cst-postfix-expression-conc3-rep-elem abnf::cst)))
    (abnf::treep abnf::cst1))
  :rule-classes :rewrite)

Theorem: cst-postfix-expression-conc3-rep-elem-match

(defthm cst-postfix-expression-conc3-rep-elem-match
 (implies
   (and (cst-matchp abnf::cst "postfix-expression")
        (equal (cst-postfix-expression-conc? abnf::cst)
               3))
   (b*
    ((abnf::cst1 (cst-postfix-expression-conc3-rep-elem abnf::cst)))
    (cst-matchp abnf::cst1
                "struct-component-expression")))
 :rule-classes :rewrite)

Theorem: cst-postfix-expression-conc3-rep-elem-of-tree-fix-cst

(defthm cst-postfix-expression-conc3-rep-elem-of-tree-fix-cst
 (equal
  (cst-postfix-expression-conc3-rep-elem (abnf::tree-fix abnf::cst))
  (cst-postfix-expression-conc3-rep-elem abnf::cst)))

Theorem: cst-postfix-expression-conc3-rep-elem-tree-equiv-congruence-on-cst

(defthm
 cst-postfix-expression-conc3-rep-elem-tree-equiv-congruence-on-cst
 (implies (abnf::tree-equiv abnf::cst cst-equiv)
          (equal (cst-postfix-expression-conc3-rep-elem abnf::cst)
                 (cst-postfix-expression-conc3-rep-elem cst-equiv)))
 :rule-classes :congruence)

Function: cst-postfix-expression-conc4-rep-elem

(defun cst-postfix-expression-conc4-rep-elem (abnf::cst)
 (declare (xargs :guard (abnf::treep abnf::cst)))
 (declare
  (xargs :guard (and (cst-matchp abnf::cst "postfix-expression")
                     (equal (cst-postfix-expression-conc? abnf::cst)
                            4))))
 (let ((__function__ 'cst-postfix-expression-conc4-rep-elem))
   (declare (ignorable __function__))
   (abnf::tree-fix
        (nth 0
             (cst-postfix-expression-conc4-rep abnf::cst)))))

Theorem: treep-of-cst-postfix-expression-conc4-rep-elem

(defthm treep-of-cst-postfix-expression-conc4-rep-elem
  (b*
    ((abnf::cst1 (cst-postfix-expression-conc4-rep-elem abnf::cst)))
    (abnf::treep abnf::cst1))
  :rule-classes :rewrite)

Theorem: cst-postfix-expression-conc4-rep-elem-match

(defthm cst-postfix-expression-conc4-rep-elem-match
 (implies
   (and (cst-matchp abnf::cst "postfix-expression")
        (equal (cst-postfix-expression-conc? abnf::cst)
               4))
   (b*
    ((abnf::cst1 (cst-postfix-expression-conc4-rep-elem abnf::cst)))
    (cst-matchp abnf::cst1 "operator-call")))
 :rule-classes :rewrite)

Theorem: cst-postfix-expression-conc4-rep-elem-of-tree-fix-cst

(defthm cst-postfix-expression-conc4-rep-elem-of-tree-fix-cst
 (equal
  (cst-postfix-expression-conc4-rep-elem (abnf::tree-fix abnf::cst))
  (cst-postfix-expression-conc4-rep-elem abnf::cst)))

Theorem: cst-postfix-expression-conc4-rep-elem-tree-equiv-congruence-on-cst

(defthm
 cst-postfix-expression-conc4-rep-elem-tree-equiv-congruence-on-cst
 (implies (abnf::tree-equiv abnf::cst cst-equiv)
          (equal (cst-postfix-expression-conc4-rep-elem abnf::cst)
                 (cst-postfix-expression-conc4-rep-elem cst-equiv)))
 :rule-classes :congruence)

Function: cst-operator-call-conc1-rep-elem

(defun cst-operator-call-conc1-rep-elem (abnf::cst)
  (declare (xargs :guard (abnf::treep abnf::cst)))
  (declare
       (xargs :guard (and (cst-matchp abnf::cst "operator-call")
                          (equal (cst-operator-call-conc? abnf::cst)
                                 1))))
  (let ((__function__ 'cst-operator-call-conc1-rep-elem))
    (declare (ignorable __function__))
    (abnf::tree-fix (nth 0
                         (cst-operator-call-conc1-rep abnf::cst)))))

Theorem: treep-of-cst-operator-call-conc1-rep-elem

(defthm treep-of-cst-operator-call-conc1-rep-elem
  (b* ((abnf::cst1 (cst-operator-call-conc1-rep-elem abnf::cst)))
    (abnf::treep abnf::cst1))
  :rule-classes :rewrite)

Theorem: cst-operator-call-conc1-rep-elem-match

(defthm cst-operator-call-conc1-rep-elem-match
 (implies
     (and (cst-matchp abnf::cst "operator-call")
          (equal (cst-operator-call-conc? abnf::cst)
                 1))
     (b* ((abnf::cst1 (cst-operator-call-conc1-rep-elem abnf::cst)))
       (cst-matchp abnf::cst1 "unary-operator-call")))
 :rule-classes :rewrite)

Theorem: cst-operator-call-conc1-rep-elem-of-tree-fix-cst

(defthm cst-operator-call-conc1-rep-elem-of-tree-fix-cst
  (equal
       (cst-operator-call-conc1-rep-elem (abnf::tree-fix abnf::cst))
       (cst-operator-call-conc1-rep-elem abnf::cst)))

Theorem: cst-operator-call-conc1-rep-elem-tree-equiv-congruence-on-cst

(defthm
      cst-operator-call-conc1-rep-elem-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-operator-call-conc1-rep-elem abnf::cst)
                  (cst-operator-call-conc1-rep-elem cst-equiv)))
  :rule-classes :congruence)

Function: cst-operator-call-conc2-rep-elem

(defun cst-operator-call-conc2-rep-elem (abnf::cst)
  (declare (xargs :guard (abnf::treep abnf::cst)))
  (declare
       (xargs :guard (and (cst-matchp abnf::cst "operator-call")
                          (equal (cst-operator-call-conc? abnf::cst)
                                 2))))
  (let ((__function__ 'cst-operator-call-conc2-rep-elem))
    (declare (ignorable __function__))
    (abnf::tree-fix (nth 0
                         (cst-operator-call-conc2-rep abnf::cst)))))

Theorem: treep-of-cst-operator-call-conc2-rep-elem

(defthm treep-of-cst-operator-call-conc2-rep-elem
  (b* ((abnf::cst1 (cst-operator-call-conc2-rep-elem abnf::cst)))
    (abnf::treep abnf::cst1))
  :rule-classes :rewrite)

Theorem: cst-operator-call-conc2-rep-elem-match

(defthm cst-operator-call-conc2-rep-elem-match
 (implies
     (and (cst-matchp abnf::cst "operator-call")
          (equal (cst-operator-call-conc? abnf::cst)
                 2))
     (b* ((abnf::cst1 (cst-operator-call-conc2-rep-elem abnf::cst)))
       (cst-matchp abnf::cst1 "binary-operator-call")))
 :rule-classes :rewrite)

Theorem: cst-operator-call-conc2-rep-elem-of-tree-fix-cst

(defthm cst-operator-call-conc2-rep-elem-of-tree-fix-cst
  (equal
       (cst-operator-call-conc2-rep-elem (abnf::tree-fix abnf::cst))
       (cst-operator-call-conc2-rep-elem abnf::cst)))

Theorem: cst-operator-call-conc2-rep-elem-tree-equiv-congruence-on-cst

(defthm
      cst-operator-call-conc2-rep-elem-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-operator-call-conc2-rep-elem abnf::cst)
                  (cst-operator-call-conc2-rep-elem cst-equiv)))
  :rule-classes :congruence)

Function: cst-binary-expression-conc-rep-elem

(defun cst-binary-expression-conc-rep-elem (abnf::cst)
 (declare (xargs :guard (abnf::treep abnf::cst)))
 (declare (xargs :guard (cst-matchp abnf::cst "binary-expression")))
 (let ((__function__ 'cst-binary-expression-conc-rep-elem))
   (declare (ignorable __function__))
   (abnf::tree-fix
        (nth 0
             (cst-binary-expression-conc-rep abnf::cst)))))

Theorem: treep-of-cst-binary-expression-conc-rep-elem

(defthm treep-of-cst-binary-expression-conc-rep-elem
  (b* ((abnf::cst1 (cst-binary-expression-conc-rep-elem abnf::cst)))
    (abnf::treep abnf::cst1))
  :rule-classes :rewrite)

Theorem: cst-binary-expression-conc-rep-elem-match

(defthm cst-binary-expression-conc-rep-elem-match
 (implies
  (cst-matchp abnf::cst "binary-expression")
  (b* ((abnf::cst1 (cst-binary-expression-conc-rep-elem abnf::cst)))
    (cst-matchp abnf::cst1
                "conditional-disjunctive-expression")))
 :rule-classes :rewrite)

Theorem: cst-binary-expression-conc-rep-elem-of-tree-fix-cst

(defthm cst-binary-expression-conc-rep-elem-of-tree-fix-cst
 (equal
    (cst-binary-expression-conc-rep-elem (abnf::tree-fix abnf::cst))
    (cst-binary-expression-conc-rep-elem abnf::cst)))

Theorem: cst-binary-expression-conc-rep-elem-tree-equiv-congruence-on-cst

(defthm
   cst-binary-expression-conc-rep-elem-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-binary-expression-conc-rep-elem abnf::cst)
                  (cst-binary-expression-conc-rep-elem cst-equiv)))
  :rule-classes :congruence)

Function: cst-expression-conc-rep-elem

(defun cst-expression-conc-rep-elem (abnf::cst)
  (declare (xargs :guard (abnf::treep abnf::cst)))
  (declare (xargs :guard (cst-matchp abnf::cst "expression")))
  (let ((__function__ 'cst-expression-conc-rep-elem))
    (declare (ignorable __function__))
    (abnf::tree-fix (nth 0
                         (cst-expression-conc-rep abnf::cst)))))

Theorem: treep-of-cst-expression-conc-rep-elem

(defthm treep-of-cst-expression-conc-rep-elem
  (b* ((abnf::cst1 (cst-expression-conc-rep-elem abnf::cst)))
    (abnf::treep abnf::cst1))
  :rule-classes :rewrite)

Theorem: cst-expression-conc-rep-elem-match

(defthm cst-expression-conc-rep-elem-match
  (implies
       (cst-matchp abnf::cst "expression")
       (b* ((abnf::cst1 (cst-expression-conc-rep-elem abnf::cst)))
         (cst-matchp abnf::cst1
                     "conditional-ternary-expression")))
  :rule-classes :rewrite)

Theorem: cst-expression-conc-rep-elem-of-tree-fix-cst

(defthm cst-expression-conc-rep-elem-of-tree-fix-cst
  (equal (cst-expression-conc-rep-elem (abnf::tree-fix abnf::cst))
         (cst-expression-conc-rep-elem abnf::cst)))

Theorem: cst-expression-conc-rep-elem-tree-equiv-congruence-on-cst

(defthm cst-expression-conc-rep-elem-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-expression-conc-rep-elem abnf::cst)
                  (cst-expression-conc-rep-elem cst-equiv)))
  :rule-classes :congruence)

Function: cst-statement-conc1-rep-elem

(defun cst-statement-conc1-rep-elem (abnf::cst)
  (declare (xargs :guard (abnf::treep abnf::cst)))
  (declare (xargs :guard (and (cst-matchp abnf::cst "statement")
                              (equal (cst-statement-conc? abnf::cst)
                                     1))))
  (let ((__function__ 'cst-statement-conc1-rep-elem))
    (declare (ignorable __function__))
    (abnf::tree-fix (nth 0
                         (cst-statement-conc1-rep abnf::cst)))))

Theorem: treep-of-cst-statement-conc1-rep-elem

(defthm treep-of-cst-statement-conc1-rep-elem
  (b* ((abnf::cst1 (cst-statement-conc1-rep-elem abnf::cst)))
    (abnf::treep abnf::cst1))
  :rule-classes :rewrite)

Theorem: cst-statement-conc1-rep-elem-match

(defthm cst-statement-conc1-rep-elem-match
  (implies
       (and (cst-matchp abnf::cst "statement")
            (equal (cst-statement-conc? abnf::cst)
                   1))
       (b* ((abnf::cst1 (cst-statement-conc1-rep-elem abnf::cst)))
         (cst-matchp abnf::cst1 "return-statement")))
  :rule-classes :rewrite)

Theorem: cst-statement-conc1-rep-elem-of-tree-fix-cst

(defthm cst-statement-conc1-rep-elem-of-tree-fix-cst
  (equal (cst-statement-conc1-rep-elem (abnf::tree-fix abnf::cst))
         (cst-statement-conc1-rep-elem abnf::cst)))

Theorem: cst-statement-conc1-rep-elem-tree-equiv-congruence-on-cst

(defthm cst-statement-conc1-rep-elem-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-statement-conc1-rep-elem abnf::cst)
                  (cst-statement-conc1-rep-elem cst-equiv)))
  :rule-classes :congruence)

Function: cst-statement-conc2-rep-elem

(defun cst-statement-conc2-rep-elem (abnf::cst)
  (declare (xargs :guard (abnf::treep abnf::cst)))
  (declare (xargs :guard (and (cst-matchp abnf::cst "statement")
                              (equal (cst-statement-conc? abnf::cst)
                                     2))))
  (let ((__function__ 'cst-statement-conc2-rep-elem))
    (declare (ignorable __function__))
    (abnf::tree-fix (nth 0
                         (cst-statement-conc2-rep abnf::cst)))))

Theorem: treep-of-cst-statement-conc2-rep-elem

(defthm treep-of-cst-statement-conc2-rep-elem
  (b* ((abnf::cst1 (cst-statement-conc2-rep-elem abnf::cst)))
    (abnf::treep abnf::cst1))
  :rule-classes :rewrite)

Theorem: cst-statement-conc2-rep-elem-match

(defthm cst-statement-conc2-rep-elem-match
  (implies
       (and (cst-matchp abnf::cst "statement")
            (equal (cst-statement-conc? abnf::cst)
                   2))
       (b* ((abnf::cst1 (cst-statement-conc2-rep-elem abnf::cst)))
         (cst-matchp abnf::cst1 "variable-declaration")))
  :rule-classes :rewrite)

Theorem: cst-statement-conc2-rep-elem-of-tree-fix-cst

(defthm cst-statement-conc2-rep-elem-of-tree-fix-cst
  (equal (cst-statement-conc2-rep-elem (abnf::tree-fix abnf::cst))
         (cst-statement-conc2-rep-elem abnf::cst)))

Theorem: cst-statement-conc2-rep-elem-tree-equiv-congruence-on-cst

(defthm cst-statement-conc2-rep-elem-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-statement-conc2-rep-elem abnf::cst)
                  (cst-statement-conc2-rep-elem cst-equiv)))
  :rule-classes :congruence)

Function: cst-statement-conc3-rep-elem

(defun cst-statement-conc3-rep-elem (abnf::cst)
  (declare (xargs :guard (abnf::treep abnf::cst)))
  (declare (xargs :guard (and (cst-matchp abnf::cst "statement")
                              (equal (cst-statement-conc? abnf::cst)
                                     3))))
  (let ((__function__ 'cst-statement-conc3-rep-elem))
    (declare (ignorable __function__))
    (abnf::tree-fix (nth 0
                         (cst-statement-conc3-rep abnf::cst)))))

Theorem: treep-of-cst-statement-conc3-rep-elem

(defthm treep-of-cst-statement-conc3-rep-elem
  (b* ((abnf::cst1 (cst-statement-conc3-rep-elem abnf::cst)))
    (abnf::treep abnf::cst1))
  :rule-classes :rewrite)

Theorem: cst-statement-conc3-rep-elem-match

(defthm cst-statement-conc3-rep-elem-match
  (implies
       (and (cst-matchp abnf::cst "statement")
            (equal (cst-statement-conc? abnf::cst)
                   3))
       (b* ((abnf::cst1 (cst-statement-conc3-rep-elem abnf::cst)))
         (cst-matchp abnf::cst1 "constant-declaration")))
  :rule-classes :rewrite)

Theorem: cst-statement-conc3-rep-elem-of-tree-fix-cst

(defthm cst-statement-conc3-rep-elem-of-tree-fix-cst
  (equal (cst-statement-conc3-rep-elem (abnf::tree-fix abnf::cst))
         (cst-statement-conc3-rep-elem abnf::cst)))

Theorem: cst-statement-conc3-rep-elem-tree-equiv-congruence-on-cst

(defthm cst-statement-conc3-rep-elem-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-statement-conc3-rep-elem abnf::cst)
                  (cst-statement-conc3-rep-elem cst-equiv)))
  :rule-classes :congruence)

Function: cst-statement-conc4-rep-elem

(defun cst-statement-conc4-rep-elem (abnf::cst)
  (declare (xargs :guard (abnf::treep abnf::cst)))
  (declare (xargs :guard (and (cst-matchp abnf::cst "statement")
                              (equal (cst-statement-conc? abnf::cst)
                                     4))))
  (let ((__function__ 'cst-statement-conc4-rep-elem))
    (declare (ignorable __function__))
    (abnf::tree-fix (nth 0
                         (cst-statement-conc4-rep abnf::cst)))))

Theorem: treep-of-cst-statement-conc4-rep-elem

(defthm treep-of-cst-statement-conc4-rep-elem
  (b* ((abnf::cst1 (cst-statement-conc4-rep-elem abnf::cst)))
    (abnf::treep abnf::cst1))
  :rule-classes :rewrite)

Theorem: cst-statement-conc4-rep-elem-match

(defthm cst-statement-conc4-rep-elem-match
  (implies
       (and (cst-matchp abnf::cst "statement")
            (equal (cst-statement-conc? abnf::cst)
                   4))
       (b* ((abnf::cst1 (cst-statement-conc4-rep-elem abnf::cst)))
         (cst-matchp abnf::cst1 "conditional-statement")))
  :rule-classes :rewrite)

Theorem: cst-statement-conc4-rep-elem-of-tree-fix-cst

(defthm cst-statement-conc4-rep-elem-of-tree-fix-cst
  (equal (cst-statement-conc4-rep-elem (abnf::tree-fix abnf::cst))
         (cst-statement-conc4-rep-elem abnf::cst)))

Theorem: cst-statement-conc4-rep-elem-tree-equiv-congruence-on-cst

(defthm cst-statement-conc4-rep-elem-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-statement-conc4-rep-elem abnf::cst)
                  (cst-statement-conc4-rep-elem cst-equiv)))
  :rule-classes :congruence)

Function: cst-statement-conc5-rep-elem

(defun cst-statement-conc5-rep-elem (abnf::cst)
  (declare (xargs :guard (abnf::treep abnf::cst)))
  (declare (xargs :guard (and (cst-matchp abnf::cst "statement")
                              (equal (cst-statement-conc? abnf::cst)
                                     5))))
  (let ((__function__ 'cst-statement-conc5-rep-elem))
    (declare (ignorable __function__))
    (abnf::tree-fix (nth 0
                         (cst-statement-conc5-rep abnf::cst)))))

Theorem: treep-of-cst-statement-conc5-rep-elem

(defthm treep-of-cst-statement-conc5-rep-elem
  (b* ((abnf::cst1 (cst-statement-conc5-rep-elem abnf::cst)))
    (abnf::treep abnf::cst1))
  :rule-classes :rewrite)

Theorem: cst-statement-conc5-rep-elem-match

(defthm cst-statement-conc5-rep-elem-match
  (implies
       (and (cst-matchp abnf::cst "statement")
            (equal (cst-statement-conc? abnf::cst)
                   5))
       (b* ((abnf::cst1 (cst-statement-conc5-rep-elem abnf::cst)))
         (cst-matchp abnf::cst1 "loop-statement")))
  :rule-classes :rewrite)

Theorem: cst-statement-conc5-rep-elem-of-tree-fix-cst

(defthm cst-statement-conc5-rep-elem-of-tree-fix-cst
  (equal (cst-statement-conc5-rep-elem (abnf::tree-fix abnf::cst))
         (cst-statement-conc5-rep-elem abnf::cst)))

Theorem: cst-statement-conc5-rep-elem-tree-equiv-congruence-on-cst

(defthm cst-statement-conc5-rep-elem-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-statement-conc5-rep-elem abnf::cst)
                  (cst-statement-conc5-rep-elem cst-equiv)))
  :rule-classes :congruence)

Function: cst-statement-conc6-rep-elem

(defun cst-statement-conc6-rep-elem (abnf::cst)
  (declare (xargs :guard (abnf::treep abnf::cst)))
  (declare (xargs :guard (and (cst-matchp abnf::cst "statement")
                              (equal (cst-statement-conc? abnf::cst)
                                     6))))
  (let ((__function__ 'cst-statement-conc6-rep-elem))
    (declare (ignorable __function__))
    (abnf::tree-fix (nth 0
                         (cst-statement-conc6-rep abnf::cst)))))

Theorem: treep-of-cst-statement-conc6-rep-elem

(defthm treep-of-cst-statement-conc6-rep-elem
  (b* ((abnf::cst1 (cst-statement-conc6-rep-elem abnf::cst)))
    (abnf::treep abnf::cst1))
  :rule-classes :rewrite)

Theorem: cst-statement-conc6-rep-elem-match

(defthm cst-statement-conc6-rep-elem-match
  (implies
       (and (cst-matchp abnf::cst "statement")
            (equal (cst-statement-conc? abnf::cst)
                   6))
       (b* ((abnf::cst1 (cst-statement-conc6-rep-elem abnf::cst)))
         (cst-matchp abnf::cst1 "assignment-statement")))
  :rule-classes :rewrite)

Theorem: cst-statement-conc6-rep-elem-of-tree-fix-cst

(defthm cst-statement-conc6-rep-elem-of-tree-fix-cst
  (equal (cst-statement-conc6-rep-elem (abnf::tree-fix abnf::cst))
         (cst-statement-conc6-rep-elem abnf::cst)))

Theorem: cst-statement-conc6-rep-elem-tree-equiv-congruence-on-cst

(defthm cst-statement-conc6-rep-elem-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-statement-conc6-rep-elem abnf::cst)
                  (cst-statement-conc6-rep-elem cst-equiv)))
  :rule-classes :congruence)

Function: cst-statement-conc7-rep-elem

(defun cst-statement-conc7-rep-elem (abnf::cst)
  (declare (xargs :guard (abnf::treep abnf::cst)))
  (declare (xargs :guard (and (cst-matchp abnf::cst "statement")
                              (equal (cst-statement-conc? abnf::cst)
                                     7))))
  (let ((__function__ 'cst-statement-conc7-rep-elem))
    (declare (ignorable __function__))
    (abnf::tree-fix (nth 0
                         (cst-statement-conc7-rep abnf::cst)))))

Theorem: treep-of-cst-statement-conc7-rep-elem

(defthm treep-of-cst-statement-conc7-rep-elem
  (b* ((abnf::cst1 (cst-statement-conc7-rep-elem abnf::cst)))
    (abnf::treep abnf::cst1))
  :rule-classes :rewrite)

Theorem: cst-statement-conc7-rep-elem-match

(defthm cst-statement-conc7-rep-elem-match
  (implies
       (and (cst-matchp abnf::cst "statement")
            (equal (cst-statement-conc? abnf::cst)
                   7))
       (b* ((abnf::cst1 (cst-statement-conc7-rep-elem abnf::cst)))
         (cst-matchp abnf::cst1 "console-statement")))
  :rule-classes :rewrite)

Theorem: cst-statement-conc7-rep-elem-of-tree-fix-cst

(defthm cst-statement-conc7-rep-elem-of-tree-fix-cst
  (equal (cst-statement-conc7-rep-elem (abnf::tree-fix abnf::cst))
         (cst-statement-conc7-rep-elem abnf::cst)))

Theorem: cst-statement-conc7-rep-elem-tree-equiv-congruence-on-cst

(defthm cst-statement-conc7-rep-elem-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-statement-conc7-rep-elem abnf::cst)
                  (cst-statement-conc7-rep-elem cst-equiv)))
  :rule-classes :congruence)

Function: cst-statement-conc8-rep-elem

(defun cst-statement-conc8-rep-elem (abnf::cst)
  (declare (xargs :guard (abnf::treep abnf::cst)))
  (declare (xargs :guard (and (cst-matchp abnf::cst "statement")
                              (equal (cst-statement-conc? abnf::cst)
                                     8))))
  (let ((__function__ 'cst-statement-conc8-rep-elem))
    (declare (ignorable __function__))
    (abnf::tree-fix (nth 0
                         (cst-statement-conc8-rep abnf::cst)))))

Theorem: treep-of-cst-statement-conc8-rep-elem

(defthm treep-of-cst-statement-conc8-rep-elem
  (b* ((abnf::cst1 (cst-statement-conc8-rep-elem abnf::cst)))
    (abnf::treep abnf::cst1))
  :rule-classes :rewrite)

Theorem: cst-statement-conc8-rep-elem-match

(defthm cst-statement-conc8-rep-elem-match
  (implies
       (and (cst-matchp abnf::cst "statement")
            (equal (cst-statement-conc? abnf::cst)
                   8))
       (b* ((abnf::cst1 (cst-statement-conc8-rep-elem abnf::cst)))
         (cst-matchp abnf::cst1 "finalize-statement")))
  :rule-classes :rewrite)

Theorem: cst-statement-conc8-rep-elem-of-tree-fix-cst

(defthm cst-statement-conc8-rep-elem-of-tree-fix-cst
  (equal (cst-statement-conc8-rep-elem (abnf::tree-fix abnf::cst))
         (cst-statement-conc8-rep-elem abnf::cst)))

Theorem: cst-statement-conc8-rep-elem-tree-equiv-congruence-on-cst

(defthm cst-statement-conc8-rep-elem-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-statement-conc8-rep-elem abnf::cst)
                  (cst-statement-conc8-rep-elem cst-equiv)))
  :rule-classes :congruence)

Function: cst-statement-conc9-rep-elem

(defun cst-statement-conc9-rep-elem (abnf::cst)
  (declare (xargs :guard (abnf::treep abnf::cst)))
  (declare (xargs :guard (and (cst-matchp abnf::cst "statement")
                              (equal (cst-statement-conc? abnf::cst)
                                     9))))
  (let ((__function__ 'cst-statement-conc9-rep-elem))
    (declare (ignorable __function__))
    (abnf::tree-fix (nth 0
                         (cst-statement-conc9-rep abnf::cst)))))

Theorem: treep-of-cst-statement-conc9-rep-elem

(defthm treep-of-cst-statement-conc9-rep-elem
  (b* ((abnf::cst1 (cst-statement-conc9-rep-elem abnf::cst)))
    (abnf::treep abnf::cst1))
  :rule-classes :rewrite)

Theorem: cst-statement-conc9-rep-elem-match

(defthm cst-statement-conc9-rep-elem-match
  (implies
       (and (cst-matchp abnf::cst "statement")
            (equal (cst-statement-conc? abnf::cst)
                   9))
       (b* ((abnf::cst1 (cst-statement-conc9-rep-elem abnf::cst)))
         (cst-matchp abnf::cst1 "increment-statement")))
  :rule-classes :rewrite)

Theorem: cst-statement-conc9-rep-elem-of-tree-fix-cst

(defthm cst-statement-conc9-rep-elem-of-tree-fix-cst
  (equal (cst-statement-conc9-rep-elem (abnf::tree-fix abnf::cst))
         (cst-statement-conc9-rep-elem abnf::cst)))

Theorem: cst-statement-conc9-rep-elem-tree-equiv-congruence-on-cst

(defthm cst-statement-conc9-rep-elem-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-statement-conc9-rep-elem abnf::cst)
                  (cst-statement-conc9-rep-elem cst-equiv)))
  :rule-classes :congruence)

Function: cst-statement-conc10-rep-elem

(defun cst-statement-conc10-rep-elem (abnf::cst)
  (declare (xargs :guard (abnf::treep abnf::cst)))
  (declare (xargs :guard (and (cst-matchp abnf::cst "statement")
                              (equal (cst-statement-conc? abnf::cst)
                                     10))))
  (let ((__function__ 'cst-statement-conc10-rep-elem))
    (declare (ignorable __function__))
    (abnf::tree-fix (nth 0
                         (cst-statement-conc10-rep abnf::cst)))))

Theorem: treep-of-cst-statement-conc10-rep-elem

(defthm treep-of-cst-statement-conc10-rep-elem
  (b* ((abnf::cst1 (cst-statement-conc10-rep-elem abnf::cst)))
    (abnf::treep abnf::cst1))
  :rule-classes :rewrite)

Theorem: cst-statement-conc10-rep-elem-match

(defthm cst-statement-conc10-rep-elem-match
  (implies
       (and (cst-matchp abnf::cst "statement")
            (equal (cst-statement-conc? abnf::cst)
                   10))
       (b* ((abnf::cst1 (cst-statement-conc10-rep-elem abnf::cst)))
         (cst-matchp abnf::cst1 "decrement-statement")))
  :rule-classes :rewrite)

Theorem: cst-statement-conc10-rep-elem-of-tree-fix-cst

(defthm cst-statement-conc10-rep-elem-of-tree-fix-cst
  (equal (cst-statement-conc10-rep-elem (abnf::tree-fix abnf::cst))
         (cst-statement-conc10-rep-elem abnf::cst)))

Theorem: cst-statement-conc10-rep-elem-tree-equiv-congruence-on-cst

(defthm cst-statement-conc10-rep-elem-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-statement-conc10-rep-elem abnf::cst)
                  (cst-statement-conc10-rep-elem cst-equiv)))
  :rule-classes :congruence)

Function: cst-statement-conc11-rep-elem

(defun cst-statement-conc11-rep-elem (abnf::cst)
  (declare (xargs :guard (abnf::treep abnf::cst)))
  (declare (xargs :guard (and (cst-matchp abnf::cst "statement")
                              (equal (cst-statement-conc? abnf::cst)
                                     11))))
  (let ((__function__ 'cst-statement-conc11-rep-elem))
    (declare (ignorable __function__))
    (abnf::tree-fix (nth 0
                         (cst-statement-conc11-rep abnf::cst)))))

Theorem: treep-of-cst-statement-conc11-rep-elem

(defthm treep-of-cst-statement-conc11-rep-elem
  (b* ((abnf::cst1 (cst-statement-conc11-rep-elem abnf::cst)))
    (abnf::treep abnf::cst1))
  :rule-classes :rewrite)

Theorem: cst-statement-conc11-rep-elem-match

(defthm cst-statement-conc11-rep-elem-match
  (implies
       (and (cst-matchp abnf::cst "statement")
            (equal (cst-statement-conc? abnf::cst)
                   11))
       (b* ((abnf::cst1 (cst-statement-conc11-rep-elem abnf::cst)))
         (cst-matchp abnf::cst1 "block")))
  :rule-classes :rewrite)

Theorem: cst-statement-conc11-rep-elem-of-tree-fix-cst

(defthm cst-statement-conc11-rep-elem-of-tree-fix-cst
  (equal (cst-statement-conc11-rep-elem (abnf::tree-fix abnf::cst))
         (cst-statement-conc11-rep-elem abnf::cst)))

Theorem: cst-statement-conc11-rep-elem-tree-equiv-congruence-on-cst

(defthm cst-statement-conc11-rep-elem-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-statement-conc11-rep-elem abnf::cst)
                  (cst-statement-conc11-rep-elem cst-equiv)))
  :rule-classes :congruence)

Function: cst-console-call-conc1-rep-elem

(defun cst-console-call-conc1-rep-elem (abnf::cst)
  (declare (xargs :guard (abnf::treep abnf::cst)))
  (declare
       (xargs :guard (and (cst-matchp abnf::cst "console-call")
                          (equal (cst-console-call-conc? abnf::cst)
                                 1))))
  (let ((__function__ 'cst-console-call-conc1-rep-elem))
    (declare (ignorable __function__))
    (abnf::tree-fix (nth 0
                         (cst-console-call-conc1-rep abnf::cst)))))

Theorem: treep-of-cst-console-call-conc1-rep-elem

(defthm treep-of-cst-console-call-conc1-rep-elem
  (b* ((abnf::cst1 (cst-console-call-conc1-rep-elem abnf::cst)))
    (abnf::treep abnf::cst1))
  :rule-classes :rewrite)

Theorem: cst-console-call-conc1-rep-elem-match

(defthm cst-console-call-conc1-rep-elem-match
 (implies
      (and (cst-matchp abnf::cst "console-call")
           (equal (cst-console-call-conc? abnf::cst)
                  1))
      (b* ((abnf::cst1 (cst-console-call-conc1-rep-elem abnf::cst)))
        (cst-matchp abnf::cst1 "assert-call")))
 :rule-classes :rewrite)

Theorem: cst-console-call-conc1-rep-elem-of-tree-fix-cst

(defthm cst-console-call-conc1-rep-elem-of-tree-fix-cst
 (equal (cst-console-call-conc1-rep-elem (abnf::tree-fix abnf::cst))
        (cst-console-call-conc1-rep-elem abnf::cst)))

Theorem: cst-console-call-conc1-rep-elem-tree-equiv-congruence-on-cst

(defthm cst-console-call-conc1-rep-elem-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-console-call-conc1-rep-elem abnf::cst)
                  (cst-console-call-conc1-rep-elem cst-equiv)))
  :rule-classes :congruence)

Function: cst-console-call-conc2-rep-elem

(defun cst-console-call-conc2-rep-elem (abnf::cst)
  (declare (xargs :guard (abnf::treep abnf::cst)))
  (declare
       (xargs :guard (and (cst-matchp abnf::cst "console-call")
                          (equal (cst-console-call-conc? abnf::cst)
                                 2))))
  (let ((__function__ 'cst-console-call-conc2-rep-elem))
    (declare (ignorable __function__))
    (abnf::tree-fix (nth 0
                         (cst-console-call-conc2-rep abnf::cst)))))

Theorem: treep-of-cst-console-call-conc2-rep-elem

(defthm treep-of-cst-console-call-conc2-rep-elem
  (b* ((abnf::cst1 (cst-console-call-conc2-rep-elem abnf::cst)))
    (abnf::treep abnf::cst1))
  :rule-classes :rewrite)

Theorem: cst-console-call-conc2-rep-elem-match

(defthm cst-console-call-conc2-rep-elem-match
 (implies
      (and (cst-matchp abnf::cst "console-call")
           (equal (cst-console-call-conc? abnf::cst)
                  2))
      (b* ((abnf::cst1 (cst-console-call-conc2-rep-elem abnf::cst)))
        (cst-matchp abnf::cst1 "assert-equal-call")))
 :rule-classes :rewrite)

Theorem: cst-console-call-conc2-rep-elem-of-tree-fix-cst

(defthm cst-console-call-conc2-rep-elem-of-tree-fix-cst
 (equal (cst-console-call-conc2-rep-elem (abnf::tree-fix abnf::cst))
        (cst-console-call-conc2-rep-elem abnf::cst)))

Theorem: cst-console-call-conc2-rep-elem-tree-equiv-congruence-on-cst

(defthm cst-console-call-conc2-rep-elem-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-console-call-conc2-rep-elem abnf::cst)
                  (cst-console-call-conc2-rep-elem cst-equiv)))
  :rule-classes :congruence)

Function: cst-console-call-conc3-rep-elem

(defun cst-console-call-conc3-rep-elem (abnf::cst)
  (declare (xargs :guard (abnf::treep abnf::cst)))
  (declare
       (xargs :guard (and (cst-matchp abnf::cst "console-call")
                          (equal (cst-console-call-conc? abnf::cst)
                                 3))))
  (let ((__function__ 'cst-console-call-conc3-rep-elem))
    (declare (ignorable __function__))
    (abnf::tree-fix (nth 0
                         (cst-console-call-conc3-rep abnf::cst)))))

Theorem: treep-of-cst-console-call-conc3-rep-elem

(defthm treep-of-cst-console-call-conc3-rep-elem
  (b* ((abnf::cst1 (cst-console-call-conc3-rep-elem abnf::cst)))
    (abnf::treep abnf::cst1))
  :rule-classes :rewrite)

Theorem: cst-console-call-conc3-rep-elem-match

(defthm cst-console-call-conc3-rep-elem-match
 (implies
      (and (cst-matchp abnf::cst "console-call")
           (equal (cst-console-call-conc? abnf::cst)
                  3))
      (b* ((abnf::cst1 (cst-console-call-conc3-rep-elem abnf::cst)))
        (cst-matchp abnf::cst1 "assert-not-equal-call")))
 :rule-classes :rewrite)

Theorem: cst-console-call-conc3-rep-elem-of-tree-fix-cst

(defthm cst-console-call-conc3-rep-elem-of-tree-fix-cst
 (equal (cst-console-call-conc3-rep-elem (abnf::tree-fix abnf::cst))
        (cst-console-call-conc3-rep-elem abnf::cst)))

Theorem: cst-console-call-conc3-rep-elem-tree-equiv-congruence-on-cst

(defthm cst-console-call-conc3-rep-elem-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-console-call-conc3-rep-elem abnf::cst)
                  (cst-console-call-conc3-rep-elem cst-equiv)))
  :rule-classes :congruence)

Function: cst-program-item-conc1-rep-elem

(defun cst-program-item-conc1-rep-elem (abnf::cst)
  (declare (xargs :guard (abnf::treep abnf::cst)))
  (declare
       (xargs :guard (and (cst-matchp abnf::cst "program-item")
                          (equal (cst-program-item-conc? abnf::cst)
                                 1))))
  (let ((__function__ 'cst-program-item-conc1-rep-elem))
    (declare (ignorable __function__))
    (abnf::tree-fix (nth 0
                         (cst-program-item-conc1-rep abnf::cst)))))

Theorem: treep-of-cst-program-item-conc1-rep-elem

(defthm treep-of-cst-program-item-conc1-rep-elem
  (b* ((abnf::cst1 (cst-program-item-conc1-rep-elem abnf::cst)))
    (abnf::treep abnf::cst1))
  :rule-classes :rewrite)

Theorem: cst-program-item-conc1-rep-elem-match

(defthm cst-program-item-conc1-rep-elem-match
 (implies
      (and (cst-matchp abnf::cst "program-item")
           (equal (cst-program-item-conc? abnf::cst)
                  1))
      (b* ((abnf::cst1 (cst-program-item-conc1-rep-elem abnf::cst)))
        (cst-matchp abnf::cst1 "function-declaration")))
 :rule-classes :rewrite)

Theorem: cst-program-item-conc1-rep-elem-of-tree-fix-cst

(defthm cst-program-item-conc1-rep-elem-of-tree-fix-cst
 (equal (cst-program-item-conc1-rep-elem (abnf::tree-fix abnf::cst))
        (cst-program-item-conc1-rep-elem abnf::cst)))

Theorem: cst-program-item-conc1-rep-elem-tree-equiv-congruence-on-cst

(defthm cst-program-item-conc1-rep-elem-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-program-item-conc1-rep-elem abnf::cst)
                  (cst-program-item-conc1-rep-elem cst-equiv)))
  :rule-classes :congruence)

Function: cst-program-item-conc2-rep-elem

(defun cst-program-item-conc2-rep-elem (abnf::cst)
  (declare (xargs :guard (abnf::treep abnf::cst)))
  (declare
       (xargs :guard (and (cst-matchp abnf::cst "program-item")
                          (equal (cst-program-item-conc? abnf::cst)
                                 2))))
  (let ((__function__ 'cst-program-item-conc2-rep-elem))
    (declare (ignorable __function__))
    (abnf::tree-fix (nth 0
                         (cst-program-item-conc2-rep abnf::cst)))))

Theorem: treep-of-cst-program-item-conc2-rep-elem

(defthm treep-of-cst-program-item-conc2-rep-elem
  (b* ((abnf::cst1 (cst-program-item-conc2-rep-elem abnf::cst)))
    (abnf::treep abnf::cst1))
  :rule-classes :rewrite)

Theorem: cst-program-item-conc2-rep-elem-match

(defthm cst-program-item-conc2-rep-elem-match
 (implies
      (and (cst-matchp abnf::cst "program-item")
           (equal (cst-program-item-conc? abnf::cst)
                  2))
      (b* ((abnf::cst1 (cst-program-item-conc2-rep-elem abnf::cst)))
        (cst-matchp abnf::cst1 "transition-declaration")))
 :rule-classes :rewrite)

Theorem: cst-program-item-conc2-rep-elem-of-tree-fix-cst

(defthm cst-program-item-conc2-rep-elem-of-tree-fix-cst
 (equal (cst-program-item-conc2-rep-elem (abnf::tree-fix abnf::cst))
        (cst-program-item-conc2-rep-elem abnf::cst)))

Theorem: cst-program-item-conc2-rep-elem-tree-equiv-congruence-on-cst

(defthm cst-program-item-conc2-rep-elem-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-program-item-conc2-rep-elem abnf::cst)
                  (cst-program-item-conc2-rep-elem cst-equiv)))
  :rule-classes :congruence)

Function: cst-program-item-conc3-rep-elem

(defun cst-program-item-conc3-rep-elem (abnf::cst)
  (declare (xargs :guard (abnf::treep abnf::cst)))
  (declare
       (xargs :guard (and (cst-matchp abnf::cst "program-item")
                          (equal (cst-program-item-conc? abnf::cst)
                                 3))))
  (let ((__function__ 'cst-program-item-conc3-rep-elem))
    (declare (ignorable __function__))
    (abnf::tree-fix (nth 0
                         (cst-program-item-conc3-rep abnf::cst)))))

Theorem: treep-of-cst-program-item-conc3-rep-elem

(defthm treep-of-cst-program-item-conc3-rep-elem
  (b* ((abnf::cst1 (cst-program-item-conc3-rep-elem abnf::cst)))
    (abnf::treep abnf::cst1))
  :rule-classes :rewrite)

Theorem: cst-program-item-conc3-rep-elem-match

(defthm cst-program-item-conc3-rep-elem-match
 (implies
      (and (cst-matchp abnf::cst "program-item")
           (equal (cst-program-item-conc? abnf::cst)
                  3))
      (b* ((abnf::cst1 (cst-program-item-conc3-rep-elem abnf::cst)))
        (cst-matchp abnf::cst1 "struct-declaration")))
 :rule-classes :rewrite)

Theorem: cst-program-item-conc3-rep-elem-of-tree-fix-cst

(defthm cst-program-item-conc3-rep-elem-of-tree-fix-cst
 (equal (cst-program-item-conc3-rep-elem (abnf::tree-fix abnf::cst))
        (cst-program-item-conc3-rep-elem abnf::cst)))

Theorem: cst-program-item-conc3-rep-elem-tree-equiv-congruence-on-cst

(defthm cst-program-item-conc3-rep-elem-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-program-item-conc3-rep-elem abnf::cst)
                  (cst-program-item-conc3-rep-elem cst-equiv)))
  :rule-classes :congruence)

Function: cst-program-item-conc4-rep-elem

(defun cst-program-item-conc4-rep-elem (abnf::cst)
  (declare (xargs :guard (abnf::treep abnf::cst)))
  (declare
       (xargs :guard (and (cst-matchp abnf::cst "program-item")
                          (equal (cst-program-item-conc? abnf::cst)
                                 4))))
  (let ((__function__ 'cst-program-item-conc4-rep-elem))
    (declare (ignorable __function__))
    (abnf::tree-fix (nth 0
                         (cst-program-item-conc4-rep abnf::cst)))))

Theorem: treep-of-cst-program-item-conc4-rep-elem

(defthm treep-of-cst-program-item-conc4-rep-elem
  (b* ((abnf::cst1 (cst-program-item-conc4-rep-elem abnf::cst)))
    (abnf::treep abnf::cst1))
  :rule-classes :rewrite)

Theorem: cst-program-item-conc4-rep-elem-match

(defthm cst-program-item-conc4-rep-elem-match
 (implies
      (and (cst-matchp abnf::cst "program-item")
           (equal (cst-program-item-conc? abnf::cst)
                  4))
      (b* ((abnf::cst1 (cst-program-item-conc4-rep-elem abnf::cst)))
        (cst-matchp abnf::cst1 "record-declaration")))
 :rule-classes :rewrite)

Theorem: cst-program-item-conc4-rep-elem-of-tree-fix-cst

(defthm cst-program-item-conc4-rep-elem-of-tree-fix-cst
 (equal (cst-program-item-conc4-rep-elem (abnf::tree-fix abnf::cst))
        (cst-program-item-conc4-rep-elem abnf::cst)))

Theorem: cst-program-item-conc4-rep-elem-tree-equiv-congruence-on-cst

(defthm cst-program-item-conc4-rep-elem-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-program-item-conc4-rep-elem abnf::cst)
                  (cst-program-item-conc4-rep-elem cst-equiv)))
  :rule-classes :congruence)

Function: cst-program-item-conc5-rep-elem

(defun cst-program-item-conc5-rep-elem (abnf::cst)
  (declare (xargs :guard (abnf::treep abnf::cst)))
  (declare
       (xargs :guard (and (cst-matchp abnf::cst "program-item")
                          (equal (cst-program-item-conc? abnf::cst)
                                 5))))
  (let ((__function__ 'cst-program-item-conc5-rep-elem))
    (declare (ignorable __function__))
    (abnf::tree-fix (nth 0
                         (cst-program-item-conc5-rep abnf::cst)))))

Theorem: treep-of-cst-program-item-conc5-rep-elem

(defthm treep-of-cst-program-item-conc5-rep-elem
  (b* ((abnf::cst1 (cst-program-item-conc5-rep-elem abnf::cst)))
    (abnf::treep abnf::cst1))
  :rule-classes :rewrite)

Theorem: cst-program-item-conc5-rep-elem-match

(defthm cst-program-item-conc5-rep-elem-match
 (implies
      (and (cst-matchp abnf::cst "program-item")
           (equal (cst-program-item-conc? abnf::cst)
                  5))
      (b* ((abnf::cst1 (cst-program-item-conc5-rep-elem abnf::cst)))
        (cst-matchp abnf::cst1 "mapping-declaration")))
 :rule-classes :rewrite)

Theorem: cst-program-item-conc5-rep-elem-of-tree-fix-cst

(defthm cst-program-item-conc5-rep-elem-of-tree-fix-cst
 (equal (cst-program-item-conc5-rep-elem (abnf::tree-fix abnf::cst))
        (cst-program-item-conc5-rep-elem abnf::cst)))

Theorem: cst-program-item-conc5-rep-elem-tree-equiv-congruence-on-cst

(defthm cst-program-item-conc5-rep-elem-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-program-item-conc5-rep-elem abnf::cst)
                  (cst-program-item-conc5-rep-elem cst-equiv)))
  :rule-classes :congruence)

Function: cst-input-type-conc-rep-elem

(defun cst-input-type-conc-rep-elem (abnf::cst)
  (declare (xargs :guard (abnf::treep abnf::cst)))
  (declare (xargs :guard (cst-matchp abnf::cst "input-type")))
  (let ((__function__ 'cst-input-type-conc-rep-elem))
    (declare (ignorable __function__))
    (abnf::tree-fix (nth 0
                         (cst-input-type-conc-rep abnf::cst)))))

Theorem: treep-of-cst-input-type-conc-rep-elem

(defthm treep-of-cst-input-type-conc-rep-elem
  (b* ((abnf::cst1 (cst-input-type-conc-rep-elem abnf::cst)))
    (abnf::treep abnf::cst1))
  :rule-classes :rewrite)

Theorem: cst-input-type-conc-rep-elem-match

(defthm cst-input-type-conc-rep-elem-match
  (implies
       (cst-matchp abnf::cst "input-type")
       (b* ((abnf::cst1 (cst-input-type-conc-rep-elem abnf::cst)))
         (cst-matchp abnf::cst1 "type")))
  :rule-classes :rewrite)

Theorem: cst-input-type-conc-rep-elem-of-tree-fix-cst

(defthm cst-input-type-conc-rep-elem-of-tree-fix-cst
  (equal (cst-input-type-conc-rep-elem (abnf::tree-fix abnf::cst))
         (cst-input-type-conc-rep-elem abnf::cst)))

Theorem: cst-input-type-conc-rep-elem-tree-equiv-congruence-on-cst

(defthm cst-input-type-conc-rep-elem-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-input-type-conc-rep-elem abnf::cst)
                  (cst-input-type-conc-rep-elem cst-equiv)))
  :rule-classes :congruence)

Function: cst-input-expression-conc-rep-elem

(defun cst-input-expression-conc-rep-elem (abnf::cst)
 (declare (xargs :guard (abnf::treep abnf::cst)))
 (declare (xargs :guard (cst-matchp abnf::cst "input-expression")))
 (let ((__function__ 'cst-input-expression-conc-rep-elem))
  (declare (ignorable __function__))
  (abnf::tree-fix (nth 0
                       (cst-input-expression-conc-rep abnf::cst)))))

Theorem: treep-of-cst-input-expression-conc-rep-elem

(defthm treep-of-cst-input-expression-conc-rep-elem
  (b* ((abnf::cst1 (cst-input-expression-conc-rep-elem abnf::cst)))
    (abnf::treep abnf::cst1))
  :rule-classes :rewrite)

Theorem: cst-input-expression-conc-rep-elem-match

(defthm cst-input-expression-conc-rep-elem-match
 (implies
   (cst-matchp abnf::cst "input-expression")
   (b* ((abnf::cst1 (cst-input-expression-conc-rep-elem abnf::cst)))
     (cst-matchp abnf::cst1 "expression")))
 :rule-classes :rewrite)

Theorem: cst-input-expression-conc-rep-elem-of-tree-fix-cst

(defthm cst-input-expression-conc-rep-elem-of-tree-fix-cst
 (equal
     (cst-input-expression-conc-rep-elem (abnf::tree-fix abnf::cst))
     (cst-input-expression-conc-rep-elem abnf::cst)))

Theorem: cst-input-expression-conc-rep-elem-tree-equiv-congruence-on-cst

(defthm
    cst-input-expression-conc-rep-elem-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-input-expression-conc-rep-elem abnf::cst)
                  (cst-input-expression-conc-rep-elem cst-equiv)))
  :rule-classes :congruence)

Function: cst-output-expression-conc-rep-elem

(defun cst-output-expression-conc-rep-elem (abnf::cst)
 (declare (xargs :guard (abnf::treep abnf::cst)))
 (declare (xargs :guard (cst-matchp abnf::cst "output-expression")))
 (let ((__function__ 'cst-output-expression-conc-rep-elem))
   (declare (ignorable __function__))
   (abnf::tree-fix
        (nth 0
             (cst-output-expression-conc-rep abnf::cst)))))

Theorem: treep-of-cst-output-expression-conc-rep-elem

(defthm treep-of-cst-output-expression-conc-rep-elem
  (b* ((abnf::cst1 (cst-output-expression-conc-rep-elem abnf::cst)))
    (abnf::treep abnf::cst1))
  :rule-classes :rewrite)

Theorem: cst-output-expression-conc-rep-elem-match

(defthm cst-output-expression-conc-rep-elem-match
 (implies
  (cst-matchp abnf::cst "output-expression")
  (b* ((abnf::cst1 (cst-output-expression-conc-rep-elem abnf::cst)))
    (cst-matchp abnf::cst1 "expression")))
 :rule-classes :rewrite)

Theorem: cst-output-expression-conc-rep-elem-of-tree-fix-cst

(defthm cst-output-expression-conc-rep-elem-of-tree-fix-cst
 (equal
    (cst-output-expression-conc-rep-elem (abnf::tree-fix abnf::cst))
    (cst-output-expression-conc-rep-elem abnf::cst)))

Theorem: cst-output-expression-conc-rep-elem-tree-equiv-congruence-on-cst

(defthm
   cst-output-expression-conc-rep-elem-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-output-expression-conc-rep-elem abnf::cst)
                  (cst-output-expression-conc-rep-elem cst-equiv)))
  :rule-classes :congruence)

Function: cst-output-file-conc-rep-elem

(defun cst-output-file-conc-rep-elem (abnf::cst)
  (declare (xargs :guard (abnf::treep abnf::cst)))
  (declare (xargs :guard (cst-matchp abnf::cst "output-file")))
  (let ((__function__ 'cst-output-file-conc-rep-elem))
    (declare (ignorable __function__))
    (abnf::tree-fix (nth 0
                         (cst-output-file-conc-rep abnf::cst)))))

Theorem: treep-of-cst-output-file-conc-rep-elem

(defthm treep-of-cst-output-file-conc-rep-elem
  (b* ((abnf::cst1 (cst-output-file-conc-rep-elem abnf::cst)))
    (abnf::treep abnf::cst1))
  :rule-classes :rewrite)

Theorem: cst-output-file-conc-rep-elem-match

(defthm cst-output-file-conc-rep-elem-match
  (implies
       (cst-matchp abnf::cst "output-file")
       (b* ((abnf::cst1 (cst-output-file-conc-rep-elem abnf::cst)))
         (cst-matchp abnf::cst1 "output-section")))
  :rule-classes :rewrite)

Theorem: cst-output-file-conc-rep-elem-of-tree-fix-cst

(defthm cst-output-file-conc-rep-elem-of-tree-fix-cst
  (equal (cst-output-file-conc-rep-elem (abnf::tree-fix abnf::cst))
         (cst-output-file-conc-rep-elem abnf::cst)))

Theorem: cst-output-file-conc-rep-elem-tree-equiv-congruence-on-cst

(defthm cst-output-file-conc-rep-elem-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-output-file-conc-rep-elem abnf::cst)
                  (cst-output-file-conc-rep-elem cst-equiv)))
  :rule-classes :congruence)

*grammar*-tree-operations

Definitions and Theorems

grammar-tree-operations