		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-%x21-23-nat

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

Theorem: natp-of-cst-%x21-23-nat

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

Theorem: cst-%x21-23-nat-of-tree-fix-cst

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

Theorem: cst-%x21-23-nat-tree-equiv-congruence-on-cst

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

Function: cst-%x25-26-nat

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

Theorem: natp-of-cst-%x25-26-nat

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

Theorem: cst-%x25-26-nat-of-tree-fix-cst

(defthm cst-%x25-26-nat-of-tree-fix-cst
  (equal (cst-%x25-26-nat (abnf::tree-fix abnf::cst))
         (cst-%x25-26-nat abnf::cst)))

Theorem: cst-%x25-26-nat-tree-equiv-congruence-on-cst

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

Function: cst-%x25-29-nat

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

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

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

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

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

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

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

Function: cst-%x25-2f-nat

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

Theorem: natp-of-cst-%x25-2f-nat

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

Theorem: cst-%x25-2f-nat-of-tree-fix-cst

(defthm cst-%x25-2f-nat-of-tree-fix-cst
  (equal (cst-%x25-2f-nat (abnf::tree-fix abnf::cst))
         (cst-%x25-2f-nat abnf::cst)))

Theorem: cst-%x25-2f-nat-tree-equiv-congruence-on-cst

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

Function: cst-%x28-2f-nat

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

Theorem: natp-of-cst-%x28-2f-nat

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

Theorem: cst-%x28-2f-nat-of-tree-fix-cst

(defthm cst-%x28-2f-nat-of-tree-fix-cst
  (equal (cst-%x28-2f-nat (abnf::tree-fix abnf::cst))
         (cst-%x28-2f-nat abnf::cst)))

Theorem: cst-%x28-2f-nat-tree-equiv-congruence-on-cst

(defthm cst-%x28-2f-nat-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-%x28-2f-nat abnf::cst)
                  (cst-%x28-2f-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-2f-nat

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

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

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

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

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

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

(defthm cst-%x2b-2f-nat-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-%x2b-2f-nat abnf::cst)
                  (cst-%x2b-2f-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-%x31-39-nat

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

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

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

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

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

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

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

Function: cst-%x3a-3d-nat

(defun cst-%x3a-3d-nat (abnf::cst)
  (declare (xargs :guard (abnf::treep abnf::cst)))
  (declare (xargs :guard (cst-matchp abnf::cst "%x3A-3D")))
  (let ((__function__ 'cst-%x3a-3d-nat))
    (declare (ignorable __function__))
    (lnfix (nth 0
                (abnf::tree-leafterm->get abnf::cst)))))

Theorem: natp-of-cst-%x3a-3d-nat

(defthm natp-of-cst-%x3a-3d-nat
  (b* ((nat (cst-%x3a-3d-nat abnf::cst)))
    (natp nat))
  :rule-classes :rewrite)

Theorem: cst-%x3a-3d-nat-of-tree-fix-cst

(defthm cst-%x3a-3d-nat-of-tree-fix-cst
  (equal (cst-%x3a-3d-nat (abnf::tree-fix abnf::cst))
         (cst-%x3a-3d-nat abnf::cst)))

Theorem: cst-%x3a-3d-nat-tree-equiv-congruence-on-cst

(defthm cst-%x3a-3d-nat-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-%x3a-3d-nat abnf::cst)
                  (cst-%x3a-3d-nat cst-equiv)))
  :rule-classes :congruence)

Function: cst-%x3a-3f-nat

(defun cst-%x3a-3f-nat (abnf::cst)
  (declare (xargs :guard (abnf::treep abnf::cst)))
  (declare (xargs :guard (cst-matchp abnf::cst "%x3A-3F")))
  (let ((__function__ 'cst-%x3a-3f-nat))
    (declare (ignorable __function__))
    (lnfix (nth 0
                (abnf::tree-leafterm->get abnf::cst)))))

Theorem: natp-of-cst-%x3a-3f-nat

(defthm natp-of-cst-%x3a-3f-nat
  (b* ((nat (cst-%x3a-3f-nat abnf::cst)))
    (natp nat))
  :rule-classes :rewrite)

Theorem: cst-%x3a-3f-nat-of-tree-fix-cst

(defthm cst-%x3a-3f-nat-of-tree-fix-cst
  (equal (cst-%x3a-3f-nat (abnf::tree-fix abnf::cst))
         (cst-%x3a-3f-nat abnf::cst)))

Theorem: cst-%x3a-3f-nat-tree-equiv-congruence-on-cst

(defthm cst-%x3a-3f-nat-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-%x3a-3f-nat abnf::cst)
                  (cst-%x3a-3f-nat cst-equiv)))
  :rule-classes :congruence)

Function: cst-%x41-46-nat

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

Theorem: natp-of-cst-%x41-46-nat

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

Theorem: cst-%x41-46-nat-of-tree-fix-cst

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

Theorem: cst-%x41-46-nat-tree-equiv-congruence-on-cst

(defthm cst-%x41-46-nat-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-%x41-46-nat abnf::cst)
                  (cst-%x41-46-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-%x5b-5f-nat

(defun cst-%x5b-5f-nat (abnf::cst)
  (declare (xargs :guard (abnf::treep abnf::cst)))
  (declare (xargs :guard (cst-matchp abnf::cst "%x5B-5F")))
  (let ((__function__ 'cst-%x5b-5f-nat))
    (declare (ignorable __function__))
    (lnfix (nth 0
                (abnf::tree-leafterm->get abnf::cst)))))

Theorem: natp-of-cst-%x5b-5f-nat

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

Theorem: cst-%x5b-5f-nat-of-tree-fix-cst

(defthm cst-%x5b-5f-nat-of-tree-fix-cst
  (equal (cst-%x5b-5f-nat (abnf::tree-fix abnf::cst))
         (cst-%x5b-5f-nat abnf::cst)))

Theorem: cst-%x5b-5f-nat-tree-equiv-congruence-on-cst

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

Function: cst-%x5d-5f-nat

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

Theorem: natp-of-cst-%x5d-5f-nat

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

Theorem: cst-%x5d-5f-nat-of-tree-fix-cst

(defthm cst-%x5d-5f-nat-of-tree-fix-cst
  (equal (cst-%x5d-5f-nat (abnf::tree-fix abnf::cst))
         (cst-%x5d-5f-nat abnf::cst)))

Theorem: cst-%x5d-5f-nat-tree-equiv-congruence-on-cst

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

Function: cst-%x61-66-nat

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

Theorem: natp-of-cst-%x61-66-nat

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

Theorem: cst-%x61-66-nat-of-tree-fix-cst

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

Theorem: cst-%x61-66-nat-tree-equiv-congruence-on-cst

(defthm cst-%x61-66-nat-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-%x61-66-nat abnf::cst)
                  (cst-%x61-66-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-%x7b-7e-nat

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

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

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

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

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

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

(defthm cst-%x7b-7e-nat-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-%x7b-7e-nat abnf::cst)
                  (cst-%x7b-7e-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-%x21-23-nat-bounds

(defthm cst-%x21-23-nat-bounds
  (implies (cst-matchp abnf::cst "%x21-23")
           (and (<= 33 (cst-%x21-23-nat abnf::cst))
                (<= (cst-%x21-23-nat abnf::cst) 35)))
  :rule-classes :linear)

Theorem: cst-%x25-26-nat-bounds

(defthm cst-%x25-26-nat-bounds
  (implies (cst-matchp abnf::cst "%x25-26")
           (and (<= 37 (cst-%x25-26-nat abnf::cst))
                (<= (cst-%x25-26-nat abnf::cst) 38)))
  :rule-classes :linear)

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

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

Theorem: cst-%x25-2f-nat-bounds

(defthm cst-%x25-2f-nat-bounds
  (implies (cst-matchp abnf::cst "%x25-2F")
           (and (<= 37 (cst-%x25-2f-nat abnf::cst))
                (<= (cst-%x25-2f-nat abnf::cst) 47)))
  :rule-classes :linear)

Theorem: cst-%x28-2f-nat-bounds

(defthm cst-%x28-2f-nat-bounds
  (implies (cst-matchp abnf::cst "%x28-2F")
           (and (<= 40 (cst-%x28-2f-nat abnf::cst))
                (<= (cst-%x28-2f-nat abnf::cst) 47)))
  :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-2f-nat-bounds

(defthm cst-%x2b-2f-nat-bounds
  (implies (cst-matchp abnf::cst "%x2B-2F")
           (and (<= 43 (cst-%x2b-2f-nat abnf::cst))
                (<= (cst-%x2b-2f-nat abnf::cst) 47)))
  :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-%x31-39-nat-bounds

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

Theorem: cst-%x3a-3d-nat-bounds

(defthm cst-%x3a-3d-nat-bounds
  (implies (cst-matchp abnf::cst "%x3A-3D")
           (and (<= 58 (cst-%x3a-3d-nat abnf::cst))
                (<= (cst-%x3a-3d-nat abnf::cst) 61)))
  :rule-classes :linear)

Theorem: cst-%x3a-3f-nat-bounds

(defthm cst-%x3a-3f-nat-bounds
  (implies (cst-matchp abnf::cst "%x3A-3F")
           (and (<= 58 (cst-%x3a-3f-nat abnf::cst))
                (<= (cst-%x3a-3f-nat abnf::cst) 63)))
  :rule-classes :linear)

Theorem: cst-%x41-46-nat-bounds

(defthm cst-%x41-46-nat-bounds
  (implies (cst-matchp abnf::cst "%x41-46")
           (and (<= 65 (cst-%x41-46-nat abnf::cst))
                (<= (cst-%x41-46-nat abnf::cst) 70)))
  :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-%x5b-5f-nat-bounds

(defthm cst-%x5b-5f-nat-bounds
  (implies (cst-matchp abnf::cst "%x5B-5F")
           (and (<= 91 (cst-%x5b-5f-nat abnf::cst))
                (<= (cst-%x5b-5f-nat abnf::cst) 95)))
  :rule-classes :linear)

Theorem: cst-%x5d-5f-nat-bounds

(defthm cst-%x5d-5f-nat-bounds
  (implies (cst-matchp abnf::cst "%x5D-5F")
           (and (<= 93 (cst-%x5d-5f-nat abnf::cst))
                (<= (cst-%x5d-5f-nat abnf::cst) 95)))
  :rule-classes :linear)

Theorem: cst-%x61-66-nat-bounds

(defthm cst-%x61-66-nat-bounds
  (implies (cst-matchp abnf::cst "%x61-66")
           (and (<= 97 (cst-%x61-66-nat abnf::cst))
                (<= (cst-%x61-66-nat abnf::cst) 102)))
  :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-%x7b-7e-nat-bounds

(defthm cst-%x7b-7e-nat-bounds
  (implies (cst-matchp abnf::cst "%x7B-7E")
           (and (<= 123 (cst-%x7b-7e-nat abnf::cst))
                (<= (cst-%x7b-7e-nat abnf::cst) 126)))
  :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-"0"-leafterm

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

Theorem: cst-"128"-leafterm

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

Theorem: cst-"16"-leafterm

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

Theorem: cst-"32"-leafterm

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

Theorem: cst-"64"-leafterm

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

Theorem: cst-":"-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-%i"0x"-leafterm

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

Theorem: cst-%i"e"-leafterm

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

Theorem: cst-%i"f"-leafterm

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

Theorem: cst-%i"l"-leafterm

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

Theorem: cst-%i"p"-leafterm

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

Theorem: cst-%i"u"-leafterm

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

Theorem: cst-%i"u'"-leafterm

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

Theorem: cst-%s"default"-leafterm

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

Theorem: cst-%s"l"-leafterm

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

Theorem: cst-%s"l'"-leafterm

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

Theorem: cst-%s"ll"-leafterm

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

Theorem: cst-%s"off"-leafterm

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

Theorem: cst-%s"on"-leafterm

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

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

Theorem: cst-%s"\b"-leafterm

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

Theorem: cst-%s"\f"-leafterm

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

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

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

Theorem: cst-%s"_alignof"-leafterm

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

Theorem: cst-%s"_atomic"-leafterm

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

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

Theorem: cst-%s"_float128"-leafterm

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

Theorem: cst-%s"_float128x"-leafterm

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

Theorem: cst-%s"_float16"-leafterm

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

Theorem: cst-%s"_float16x"-leafterm

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

Theorem: cst-%s"_float32"-leafterm

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

Theorem: cst-%s"_float32x"-leafterm

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

Theorem: cst-%s"_float64"-leafterm

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

Theorem: cst-%s"_float64x"-leafterm

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

Theorem: cst-%s"_generic"-leafterm

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

Theorem: cst-%s"_imaginary"-leafterm

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

Theorem: cst-%s"_noreturn"-leafterm

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

Theorem: cst-%s"_static_assert"-leafterm

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

Theorem: cst-%s"_thread_local"-leafterm

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

Theorem: cst-%s"__alignof"-leafterm

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

Theorem: cst-%s"__alignof__"-leafterm

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

Theorem: cst-%s"__asm"-leafterm

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

Theorem: cst-%s"__asm__"-leafterm

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

Theorem: cst-%s"__attribute"-leafterm

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

Theorem: cst-%s"__attribute__"-leafterm

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

Theorem: cst-%s"__auto_type"-leafterm

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

Theorem: cst-%s"__builtin_offsetof"-leafterm

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

Theorem: cst-%s"__builtin_types_compatible_p"-leafterm

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

Theorem: cst-%s"__builtin_va_arg"-leafterm

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

Theorem: cst-%s"__builtin_va_list"-leafterm

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

Theorem: cst-%s"__declspec"-leafterm

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

Theorem: cst-%s"__extension__"-leafterm

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

Theorem: cst-%s"__float128"-leafterm

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

Theorem: cst-%s"__float80"-leafterm

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

Theorem: cst-%s"__imag__"-leafterm

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

Theorem: cst-%s"__inline"-leafterm

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

Theorem: cst-%s"__inline__"-leafterm

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

Theorem: cst-%s"__int128"-leafterm

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

Theorem: cst-%s"__int128_t"-leafterm

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

Theorem: cst-%s"__label__"-leafterm

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

Theorem: cst-%s"__real__"-leafterm

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

Theorem: cst-%s"__restrict"-leafterm

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

Theorem: cst-%s"__restrict__"-leafterm

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

Theorem: cst-%s"__seg_fs"-leafterm

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

Theorem: cst-%s"__seg_gs"-leafterm

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

Theorem: cst-%s"__signed"-leafterm

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

Theorem: cst-%s"__signed__"-leafterm

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

Theorem: cst-%s"__stdcall"-leafterm

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

Theorem: cst-%s"__typeof"-leafterm

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

Theorem: cst-%s"__typeof__"-leafterm

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

Theorem: cst-%s"__volatile"-leafterm

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

Theorem: cst-%s"__volatile__"-leafterm

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

Theorem: cst-%s"asm"-leafterm

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

Theorem: cst-%s"auto"-leafterm

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

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

Theorem: cst-%s"case"-leafterm

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

Theorem: cst-%s"char"-leafterm

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

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

Theorem: cst-%s"default"-leafterm

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

Theorem: cst-%s"define"-leafterm

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

Theorem: cst-%s"do"-leafterm

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

Theorem: cst-%s"double"-leafterm

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

Theorem: cst-%s"elif"-leafterm

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

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

Theorem: cst-%s"enum"-leafterm

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

Theorem: cst-%s"error"-leafterm

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

Theorem: cst-%s"extern"-leafterm

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

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

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

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

Theorem: cst-%s"ifndef"-leafterm

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

Theorem: cst-%s"include"-leafterm

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

Theorem: cst-%s"inline"-leafterm

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

Theorem: cst-%s"int"-leafterm

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

Theorem: cst-%s"line"-leafterm

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

Theorem: cst-%s"ll"-leafterm

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

Theorem: cst-%s"long"-leafterm

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

Theorem: cst-%s"pragma"-leafterm

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

Theorem: cst-%s"register"-leafterm

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

Theorem: cst-%s"restrict"-leafterm

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

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

Theorem: cst-%s"signed"-leafterm

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

Theorem: cst-%s"sizeof"-leafterm

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

Theorem: cst-%s"static"-leafterm

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

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

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

Theorem: cst-%s"typeof"-leafterm

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

Theorem: cst-%s"u8"-leafterm

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

Theorem: cst-%s"undef"-leafterm

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

Theorem: cst-%s"union"-leafterm

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

Theorem: cst-%s"unsigned"-leafterm

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

Theorem: cst-%s"void"-leafterm

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

Theorem: cst-%s"volatile"-leafterm

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

Theorem: cst-%s"while"-leafterm

(defthm |CST-%s"while"-LEAFTERM|
  (implies (cst-matchp abnf::cst "%s\"while\"")
           (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-uppercase-letter-nonleaf

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

Theorem: cst-lowercase-letter-nonleaf

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

Theorem: cst-letter-nonleaf

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

Theorem: cst-digit-nonleaf

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

Theorem: cst-double-quote-nonleaf

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

Theorem: cst-graphic-character-nonleaf

(defthm cst-graphic-character-nonleaf
  (implies (cst-matchp abnf::cst "graphic-character")
           (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-horizontal-tab-nonleaf

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

Theorem: cst-vertical-tab-nonleaf

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

Theorem: cst-form-feed-nonleaf

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

Theorem: cst-control-character-nonleaf

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

Theorem: cst-basic-character-nonleaf

(defthm cst-basic-character-nonleaf
  (implies (cst-matchp abnf::cst "basic-character")
           (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-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-extended-character-nonleaf

(defthm cst-extended-character-nonleaf
  (implies (cst-matchp abnf::cst "extended-character")
           (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-new-line-nonleaf

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

Theorem: cst-extended-character-not-new-line-nonleaf

(defthm cst-extended-character-not-new-line-nonleaf
  (implies (cst-matchp abnf::cst
                       "extended-character-not-new-line")
           (equal (abnf::tree-kind abnf::cst)
                  :nonleaf)))

Theorem: cst-graphic-character-not-star-nonleaf

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

Theorem: cst-graphic-character-not-greater-than-nonleaf

(defthm cst-graphic-character-not-greater-than-nonleaf
  (implies (cst-matchp abnf::cst
                       "graphic-character-not-greater-than")
           (equal (abnf::tree-kind abnf::cst)
                  :nonleaf)))

Theorem: cst-graphic-character-not-double-quote-nonleaf

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

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

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

Theorem: cst-graphic-character-not-single-quote-or-backslash-nonleaf

(defthm cst-graphic-character-not-single-quote-or-backslash-nonleaf
 (implies
      (cst-matchp abnf::cst
                  "graphic-character-not-single-quote-or-backslash")
      (equal (abnf::tree-kind abnf::cst)
             :nonleaf)))

Theorem: cst-graphic-character-not-double-quote-or-backslash-nonleaf

(defthm cst-graphic-character-not-double-quote-or-backslash-nonleaf
 (implies
      (cst-matchp abnf::cst
                  "graphic-character-not-double-quote-or-backslash")
      (equal (abnf::tree-kind abnf::cst)
             :nonleaf)))

Theorem: cst-basic-character-not-star-nonleaf

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

Theorem: cst-basic-character-not-greater-than-nonleaf

(defthm cst-basic-character-not-greater-than-nonleaf
  (implies (cst-matchp abnf::cst
                       "basic-character-not-greater-than")
           (equal (abnf::tree-kind abnf::cst)
                  :nonleaf)))

Theorem: cst-basic-character-not-double-quote-nonleaf

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

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

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

Theorem: cst-basic-character-not-single-quote-or-backslash-nonleaf

(defthm cst-basic-character-not-single-quote-or-backslash-nonleaf
  (implies
       (cst-matchp abnf::cst
                   "basic-character-not-single-quote-or-backslash")
       (equal (abnf::tree-kind abnf::cst)
              :nonleaf)))

Theorem: cst-basic-character-not-double-quote-or-backslash-nonleaf

(defthm cst-basic-character-not-double-quote-or-backslash-nonleaf
  (implies
       (cst-matchp abnf::cst
                   "basic-character-not-double-quote-or-backslash")
       (equal (abnf::tree-kind abnf::cst)
              :nonleaf)))

Theorem: cst-character-not-new-line-nonleaf

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

Theorem: cst-character-not-star-nonleaf

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

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

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

Theorem: cst-character-not-greater-than-or-new-line-nonleaf

(defthm cst-character-not-greater-than-or-new-line-nonleaf
  (implies (cst-matchp abnf::cst
                       "character-not-greater-than-or-new-line")
           (equal (abnf::tree-kind abnf::cst)
                  :nonleaf)))

Theorem: cst-character-not-double-quote-or-new-line-nonleaf

(defthm cst-character-not-double-quote-or-new-line-nonleaf
  (implies (cst-matchp abnf::cst
                       "character-not-double-quote-or-new-line")
           (equal (abnf::tree-kind abnf::cst)
                  :nonleaf)))

Theorem: cst-character-not-single-quote-or-backslash-or-new-line-nonleaf

(defthm
    cst-character-not-single-quote-or-backslash-or-new-line-nonleaf
 (implies
  (cst-matchp abnf::cst
              "character-not-single-quote-or-backslash-or-new-line")
  (equal (abnf::tree-kind abnf::cst)
         :nonleaf)))

Theorem: cst-character-not-double-quote-or-backslash-or-new-line-nonleaf

(defthm
    cst-character-not-double-quote-or-backslash-or-new-line-nonleaf
 (implies
  (cst-matchp abnf::cst
              "character-not-double-quote-or-backslash-or-new-line")
  (equal (abnf::tree-kind abnf::cst)
         :nonleaf)))

Theorem: cst-white-space-nonleaf

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

Theorem: cst-header-name-nonleaf

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

Theorem: cst-h-char-sequence-nonleaf

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

Theorem: cst-h-char-nonleaf

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

Theorem: cst-q-char-sequence-nonleaf

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

Theorem: cst-q-char-nonleaf

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

Theorem: cst-pp-number-nonleaf

(defthm cst-pp-number-nonleaf
  (implies (cst-matchp abnf::cst "pp-number")
           (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-line-comment-nonleaf

(defthm cst-line-comment-nonleaf
  (implies (cst-matchp abnf::cst "line-comment")
           (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-preprocessing-token-nonleaf

(defthm cst-preprocessing-token-nonleaf
  (implies (cst-matchp abnf::cst "preprocessing-token")
           (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-gcc-keyword-nonleaf

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

Theorem: cst-alignof-keyword-nonleaf

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

Theorem: cst-asm-keyword-nonleaf

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

Theorem: cst-attribute-keyword-nonleaf

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

Theorem: cst-inline-keyword-nonleaf

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

Theorem: cst-restrict-keyword-nonleaf

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

Theorem: cst-signed-keyword-nonleaf

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

Theorem: cst-typeof-keyword-nonleaf

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

Theorem: cst-volatile-keyword-nonleaf

(defthm cst-volatile-keyword-nonleaf
  (implies (cst-matchp abnf::cst "volatile-keyword")
           (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-identifier-nondigit-nonleaf

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

Theorem: cst-nondigit-nonleaf

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

Theorem: cst-universal-character-name-nonleaf

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

Theorem: cst-hex-quad-nonleaf

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

Theorem: cst-constant-nonleaf

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

Theorem: cst-integer-constant-nonleaf

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

Theorem: cst-decimal-constant-nonleaf

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

Theorem: cst-octal-constant-nonleaf

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

Theorem: cst-hexadecimal-constant-nonleaf

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

Theorem: cst-hexadecimal-prefix-nonleaf

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

Theorem: cst-nonzero-digit-nonleaf

(defthm cst-nonzero-digit-nonleaf
  (implies (cst-matchp abnf::cst "nonzero-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-integer-suffix-nonleaf

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

Theorem: cst-unsigned-suffix-nonleaf

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

Theorem: cst-long-suffix-nonleaf

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

Theorem: cst-long-long-suffix-nonleaf

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

Theorem: cst-floating-constant-nonleaf

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

Theorem: cst-decimal-floating-constant-nonleaf

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

Theorem: cst-hexadecimal-floating-constant-nonleaf

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

Theorem: cst-fractional-constant-nonleaf

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

Theorem: cst-exponent-part-nonleaf

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

Theorem: cst-sign-nonleaf

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

Theorem: cst-digit-sequence-nonleaf

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

Theorem: cst-hexadecimal-fractional-constant-nonleaf

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

Theorem: cst-binary-exponent-part-nonleaf

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

Theorem: cst-hexadecimal-digit-sequence-nonleaf

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

Theorem: cst-floating-suffix-nonleaf

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

Theorem: cst-enumeration-constant-nonleaf

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

Theorem: cst-character-constant-nonleaf

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

Theorem: cst-c-char-sequence-nonleaf

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

Theorem: cst-c-char-nonleaf

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

Theorem: cst-escape-sequence-nonleaf

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

Theorem: cst-simple-escape-sequence-nonleaf

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

Theorem: cst-octal-escape-sequence-nonleaf

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

Theorem: cst-hexadecimal-escape-sequence-nonleaf

(defthm cst-hexadecimal-escape-sequence-nonleaf
  (implies (cst-matchp abnf::cst "hexadecimal-escape-sequence")
           (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-encoding-prefix-nonleaf

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

Theorem: cst-s-char-sequence-nonleaf

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

Theorem: cst-s-char-nonleaf

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

Theorem: cst-punctuator-nonleaf

(defthm cst-punctuator-nonleaf
  (implies (cst-matchp abnf::cst "punctuator")
           (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-primary-expression-nonleaf

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

Theorem: cst-types-compatible-call-nonleaf

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

Theorem: cst-offsetof-call-nonleaf

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

Theorem: cst-offsetof-member-designator-nonleaf

(defthm cst-offsetof-member-designator-nonleaf
  (implies (cst-matchp abnf::cst "offsetof-member-designator")
           (equal (abnf::tree-kind abnf::cst)
                  :nonleaf)))

Theorem: cst-va-arg-call-nonleaf

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

Theorem: cst-generic-selection-nonleaf

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

Theorem: cst-generic-assoc-list-nonleaf

(defthm cst-generic-assoc-list-nonleaf
  (implies (cst-matchp abnf::cst "generic-assoc-list")
           (equal (abnf::tree-kind abnf::cst)
                  :nonleaf)))

Theorem: cst-generic-association-nonleaf

(defthm cst-generic-association-nonleaf
  (implies (cst-matchp abnf::cst "generic-association")
           (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-argument-expression-list-nonleaf

(defthm cst-argument-expression-list-nonleaf
  (implies (cst-matchp abnf::cst "argument-expression-list")
           (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-unary-operator-nonleaf

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

Theorem: cst-cast-expression-nonleaf

(defthm cst-cast-expression-nonleaf
  (implies (cst-matchp abnf::cst "cast-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-relational-expression-nonleaf

(defthm cst-relational-expression-nonleaf
  (implies (cst-matchp abnf::cst "relational-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-and-expression-nonleaf

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

Theorem: cst-exclusive-or-expression-nonleaf

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

Theorem: cst-inclusive-or-expression-nonleaf

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

Theorem: cst-logical-and-expression-nonleaf

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

Theorem: cst-logical-or-expression-nonleaf

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

Theorem: cst-conditional-expression-nonleaf

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

Theorem: cst-assignment-expression-nonleaf

(defthm cst-assignment-expression-nonleaf
  (implies (cst-matchp abnf::cst "assignment-expression")
           (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-expression-nonleaf

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

Theorem: cst-constant-expression-nonleaf

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

Theorem: cst-attribute-name-nonleaf

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

Theorem: cst-attribute-parameters-nonleaf

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

Theorem: cst-attribute-nonleaf

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

Theorem: cst-attribute-list-nonleaf

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

Theorem: cst-attribute-specifier-nonleaf

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

Theorem: cst-asm-name-specifier-nonleaf

(defthm cst-asm-name-specifier-nonleaf
  (implies (cst-matchp abnf::cst "asm-name-specifier")
           (equal (abnf::tree-kind abnf::cst)
                  :nonleaf)))

Theorem: cst-asm-qualifier-nonleaf

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

Theorem: cst-asm-statement-nonleaf

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

Theorem: cst-asm-output-operands-nonleaf

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

Theorem: cst-asm-output-operand-nonleaf

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

Theorem: cst-asm-input-operands-nonleaf

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

Theorem: cst-asm-input-operand-nonleaf

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

Theorem: cst-asm-clobbers-nonleaf

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

Theorem: cst-asm-clobber-nonleaf

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

Theorem: cst-asm-goto-labels-nonleaf

(defthm cst-asm-goto-labels-nonleaf
  (implies (cst-matchp abnf::cst "asm-goto-labels")
           (equal (abnf::tree-kind abnf::cst)
                  :nonleaf)))

Theorem: cst-declaration-nonleaf

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

Theorem: cst-declaration-specifiers-nonleaf

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

Theorem: cst-init-declarator-list-nonleaf

(defthm cst-init-declarator-list-nonleaf
  (implies (cst-matchp abnf::cst "init-declarator-list")
           (equal (abnf::tree-kind abnf::cst)
                  :nonleaf)))

Theorem: cst-init-declarator-nonleaf

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

Theorem: cst-storage-class-specifier-nonleaf

(defthm cst-storage-class-specifier-nonleaf
  (implies (cst-matchp abnf::cst "storage-class-specifier")
           (equal (abnf::tree-kind abnf::cst)
                  :nonleaf)))

Theorem: cst-type-specifier-nonleaf

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

Theorem: cst-struct-or-union-specifier-nonleaf

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

Theorem: cst-struct-or-union-nonleaf

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

Theorem: cst-struct-declaration-list-nonleaf

(defthm cst-struct-declaration-list-nonleaf
  (implies (cst-matchp abnf::cst "struct-declaration-list")
           (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-specifier-qualifier-list-nonleaf

(defthm cst-specifier-qualifier-list-nonleaf
  (implies (cst-matchp abnf::cst "specifier-qualifier-list")
           (equal (abnf::tree-kind abnf::cst)
                  :nonleaf)))

Theorem: cst-struct-declarator-list-nonleaf

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

Theorem: cst-struct-declarator-nonleaf

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

Theorem: cst-enum-specifier-nonleaf

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

Theorem: cst-enumerator-list-nonleaf

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

Theorem: cst-enumerator-nonleaf

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

Theorem: cst-atomic-type-specifier-nonleaf

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

Theorem: cst-type-qualifier-nonleaf

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

Theorem: cst-function-specifier-nonleaf

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

Theorem: cst-alignment-specifier-nonleaf

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

Theorem: cst-declarator-nonleaf

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

Theorem: cst-direct-declarator-nonleaf

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

Theorem: cst-pointer-nonleaf

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

Theorem: cst-type-qualifier-or-attribute-specifier-nonleaf

(defthm cst-type-qualifier-or-attribute-specifier-nonleaf
  (implies (cst-matchp abnf::cst
                       "type-qualifier-or-attribute-specifier")
           (equal (abnf::tree-kind abnf::cst)
                  :nonleaf)))

Theorem: cst-type-qualifier-and-attribute-specifier-list-nonleaf

(defthm cst-type-qualifier-and-attribute-specifier-list-nonleaf
 (implies (cst-matchp abnf::cst
                      "type-qualifier-and-attribute-specifier-list")
          (equal (abnf::tree-kind abnf::cst)
                 :nonleaf)))

Theorem: cst-parameter-type-list-nonleaf

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

Theorem: cst-parameter-list-nonleaf

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

Theorem: cst-parameter-declaration-nonleaf

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

Theorem: cst-identifier-list-nonleaf

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

Theorem: cst-type-name-nonleaf

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

Theorem: cst-abstract-declarator-nonleaf

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

Theorem: cst-direct-abstract-declarator-nonleaf

(defthm cst-direct-abstract-declarator-nonleaf
  (implies (cst-matchp abnf::cst "direct-abstract-declarator")
           (equal (abnf::tree-kind abnf::cst)
                  :nonleaf)))

Theorem: cst-typedef-name-nonleaf

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

Theorem: cst-initializer-nonleaf

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

Theorem: cst-initializer-list-nonleaf

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

Theorem: cst-designation-nonleaf

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

Theorem: cst-designator-list-nonleaf

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

Theorem: cst-designator-nonleaf

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

Theorem: cst-static-assert-declaration-nonleaf

(defthm cst-static-assert-declaration-nonleaf
  (implies (cst-matchp abnf::cst "static-assert-declaration")
           (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-labeled-statement-nonleaf

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

Theorem: cst-label-declaration-nonleaf

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

Theorem: cst-compound-statement-nonleaf

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

Theorem: cst-block-item-list-nonleaf

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

Theorem: cst-block-item-nonleaf

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

Theorem: cst-expression-statement-nonleaf

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

Theorem: cst-selection-statement-nonleaf

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

Theorem: cst-iteration-statement-nonleaf

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

Theorem: cst-jump-statement-nonleaf

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

Theorem: cst-translation-unit-nonleaf

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

Theorem: cst-external-declaration-nonleaf

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

Theorem: cst-function-definition-nonleaf

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

Theorem: cst-declaration-list-nonleaf

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

Theorem: cst-preprocessing-file-nonleaf

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

Theorem: cst-group-nonleaf

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

Theorem: cst-group-part-nonleaf

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

Theorem: cst-if-section-nonleaf

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

Theorem: cst-if-group-nonleaf

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

Theorem: cst-elif-groups-nonleaf

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

Theorem: cst-elif-group-nonleaf

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

Theorem: cst-else-group-nonleaf

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

Theorem: cst-endif-line-nonleaf

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

Theorem: cst-control-line-nonleaf

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

Theorem: cst-text-line-nonleaf

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

Theorem: cst-non-directive-nonleaf

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

Theorem: cst-lparen-nonleaf

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

Theorem: cst-replacement-list-nonleaf

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

Theorem: cst-pp-tokens-nonleaf

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

Theorem: cst-on-off-switch-nonleaf

(defthm cst-on-off-switch-nonleaf
  (implies (cst-matchp abnf::cst "on-off-switch")
           (equal (abnf::tree-kind abnf::cst)
                  :nonleaf)))

Theorem: cst-uppercase-letter-rulename

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

Theorem: cst-lowercase-letter-rulename

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

Theorem: cst-letter-rulename

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

Theorem: cst-digit-rulename

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

Theorem: cst-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-graphic-character-rulename

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

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-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-vertical-tab-rulename

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

Theorem: cst-form-feed-rulename

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

Theorem: cst-control-character-rulename

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

Theorem: cst-basic-character-rulename

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

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-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-extended-character-rulename

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

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

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

Theorem: cst-extended-character-not-new-line-rulename

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

Theorem: cst-graphic-character-not-star-rulename

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

Theorem: cst-graphic-character-not-greater-than-rulename

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

Theorem: cst-graphic-character-not-double-quote-rulename

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

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

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

Theorem: cst-graphic-character-not-single-quote-or-backslash-rulename

(defthm cst-graphic-character-not-single-quote-or-backslash-rulename
 (implies
   (cst-matchp abnf::cst
               "graphic-character-not-single-quote-or-backslash")
   (equal (abnf::tree-nonleaf->rulename? abnf::cst)
          (abnf::rulename
               "graphic-character-not-single-quote-or-backslash"))))

Theorem: cst-graphic-character-not-double-quote-or-backslash-rulename

(defthm cst-graphic-character-not-double-quote-or-backslash-rulename
 (implies
   (cst-matchp abnf::cst
               "graphic-character-not-double-quote-or-backslash")
   (equal (abnf::tree-nonleaf->rulename? abnf::cst)
          (abnf::rulename
               "graphic-character-not-double-quote-or-backslash"))))

Theorem: cst-basic-character-not-star-rulename

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

Theorem: cst-basic-character-not-greater-than-rulename

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

Theorem: cst-basic-character-not-double-quote-rulename

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

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

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

Theorem: cst-basic-character-not-single-quote-or-backslash-rulename

(defthm cst-basic-character-not-single-quote-or-backslash-rulename
 (implies
     (cst-matchp abnf::cst
                 "basic-character-not-single-quote-or-backslash")
     (equal (abnf::tree-nonleaf->rulename? abnf::cst)
            (abnf::rulename
                 "basic-character-not-single-quote-or-backslash"))))

Theorem: cst-basic-character-not-double-quote-or-backslash-rulename

(defthm cst-basic-character-not-double-quote-or-backslash-rulename
 (implies
     (cst-matchp abnf::cst
                 "basic-character-not-double-quote-or-backslash")
     (equal (abnf::tree-nonleaf->rulename? abnf::cst)
            (abnf::rulename
                 "basic-character-not-double-quote-or-backslash"))))

Theorem: cst-character-not-new-line-rulename

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

Theorem: cst-character-not-star-rulename

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

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

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

Theorem: cst-character-not-greater-than-or-new-line-rulename

(defthm cst-character-not-greater-than-or-new-line-rulename
 (implies
   (cst-matchp abnf::cst
               "character-not-greater-than-or-new-line")
   (equal
        (abnf::tree-nonleaf->rulename? abnf::cst)
        (abnf::rulename "character-not-greater-than-or-new-line"))))

Theorem: cst-character-not-double-quote-or-new-line-rulename

(defthm cst-character-not-double-quote-or-new-line-rulename
 (implies
   (cst-matchp abnf::cst
               "character-not-double-quote-or-new-line")
   (equal
        (abnf::tree-nonleaf->rulename? abnf::cst)
        (abnf::rulename "character-not-double-quote-or-new-line"))))

Theorem: cst-character-not-single-quote-or-backslash-or-new-line-rulename

(defthm
   cst-character-not-single-quote-or-backslash-or-new-line-rulename
 (implies
  (cst-matchp abnf::cst
              "character-not-single-quote-or-backslash-or-new-line")
  (equal
      (abnf::tree-nonleaf->rulename? abnf::cst)
      (abnf::rulename
           "character-not-single-quote-or-backslash-or-new-line"))))

Theorem: cst-character-not-double-quote-or-backslash-or-new-line-rulename

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

Theorem: cst-white-space-rulename

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

Theorem: cst-header-name-rulename

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

Theorem: cst-h-char-sequence-rulename

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

Theorem: cst-h-char-rulename

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

Theorem: cst-q-char-sequence-rulename

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

Theorem: cst-q-char-rulename

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

Theorem: cst-pp-number-rulename

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

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-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-token-rulename

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

Theorem: cst-preprocessing-token-rulename

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

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-gcc-keyword-rulename

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

Theorem: cst-alignof-keyword-rulename

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

Theorem: cst-asm-keyword-rulename

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

Theorem: cst-attribute-keyword-rulename

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

Theorem: cst-inline-keyword-rulename

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

Theorem: cst-restrict-keyword-rulename

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

Theorem: cst-signed-keyword-rulename

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

Theorem: cst-typeof-keyword-rulename

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

Theorem: cst-volatile-keyword-rulename

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

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-identifier-nondigit-rulename

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

Theorem: cst-nondigit-rulename

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

Theorem: cst-universal-character-name-rulename

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

Theorem: cst-hex-quad-rulename

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

Theorem: cst-constant-rulename

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

Theorem: cst-integer-constant-rulename

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

Theorem: cst-decimal-constant-rulename

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

Theorem: cst-octal-constant-rulename

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

Theorem: cst-hexadecimal-constant-rulename

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

Theorem: cst-hexadecimal-prefix-rulename

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

Theorem: cst-nonzero-digit-rulename

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

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

Theorem: cst-unsigned-suffix-rulename

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

Theorem: cst-long-suffix-rulename

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

Theorem: cst-long-long-suffix-rulename

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

Theorem: cst-floating-constant-rulename

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

Theorem: cst-decimal-floating-constant-rulename

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

Theorem: cst-hexadecimal-floating-constant-rulename

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

Theorem: cst-fractional-constant-rulename

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

Theorem: cst-exponent-part-rulename

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

Theorem: cst-sign-rulename

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

Theorem: cst-digit-sequence-rulename

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

Theorem: cst-hexadecimal-fractional-constant-rulename

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

Theorem: cst-binary-exponent-part-rulename

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

Theorem: cst-hexadecimal-digit-sequence-rulename

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

Theorem: cst-floating-suffix-rulename

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

Theorem: cst-enumeration-constant-rulename

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

Theorem: cst-character-constant-rulename

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

Theorem: cst-c-char-sequence-rulename

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

Theorem: cst-c-char-rulename

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

Theorem: cst-escape-sequence-rulename

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

Theorem: cst-simple-escape-sequence-rulename

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

Theorem: cst-octal-escape-sequence-rulename

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

Theorem: cst-hexadecimal-escape-sequence-rulename

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

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-encoding-prefix-rulename

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

Theorem: cst-s-char-sequence-rulename

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

Theorem: cst-s-char-rulename

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

Theorem: cst-punctuator-rulename

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

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-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-types-compatible-call-rulename

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

Theorem: cst-offsetof-call-rulename

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

Theorem: cst-offsetof-member-designator-rulename

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

Theorem: cst-va-arg-call-rulename

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

Theorem: cst-generic-selection-rulename

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

Theorem: cst-generic-assoc-list-rulename

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

Theorem: cst-generic-association-rulename

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

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-argument-expression-list-rulename

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

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-unary-operator-rulename

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

Theorem: cst-cast-expression-rulename

(defthm cst-cast-expression-rulename
  (implies (cst-matchp abnf::cst "cast-expression")
           (equal (abnf::tree-nonleaf->rulename? abnf::cst)
                  (abnf::rulename "cast-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-relational-expression-rulename

(defthm cst-relational-expression-rulename
  (implies (cst-matchp abnf::cst "relational-expression")
           (equal (abnf::tree-nonleaf->rulename? abnf::cst)
                  (abnf::rulename "relational-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-and-expression-rulename

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

Theorem: cst-exclusive-or-expression-rulename

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

Theorem: cst-inclusive-or-expression-rulename

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

Theorem: cst-logical-and-expression-rulename

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

Theorem: cst-logical-or-expression-rulename

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

Theorem: cst-conditional-expression-rulename

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

Theorem: cst-assignment-expression-rulename

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

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

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

Theorem: cst-constant-expression-rulename

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

Theorem: cst-attribute-name-rulename

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

Theorem: cst-attribute-parameters-rulename

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

Theorem: cst-attribute-rulename

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

Theorem: cst-attribute-list-rulename

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

Theorem: cst-attribute-specifier-rulename

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

Theorem: cst-asm-name-specifier-rulename

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

Theorem: cst-asm-qualifier-rulename

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

Theorem: cst-asm-statement-rulename

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

Theorem: cst-asm-output-operands-rulename

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

Theorem: cst-asm-output-operand-rulename

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

Theorem: cst-asm-input-operands-rulename

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

Theorem: cst-asm-input-operand-rulename

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

Theorem: cst-asm-clobbers-rulename

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

Theorem: cst-asm-clobber-rulename

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

Theorem: cst-asm-goto-labels-rulename

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

Theorem: cst-declaration-rulename

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

Theorem: cst-declaration-specifiers-rulename

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

Theorem: cst-init-declarator-list-rulename

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

Theorem: cst-init-declarator-rulename

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

Theorem: cst-storage-class-specifier-rulename

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

Theorem: cst-type-specifier-rulename

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

Theorem: cst-struct-or-union-specifier-rulename

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

Theorem: cst-struct-or-union-rulename

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

Theorem: cst-struct-declaration-list-rulename

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

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-specifier-qualifier-list-rulename

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

Theorem: cst-struct-declarator-list-rulename

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

Theorem: cst-struct-declarator-rulename

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

Theorem: cst-enum-specifier-rulename

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

Theorem: cst-enumerator-list-rulename

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

Theorem: cst-enumerator-rulename

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

Theorem: cst-atomic-type-specifier-rulename

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

Theorem: cst-type-qualifier-rulename

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

Theorem: cst-function-specifier-rulename

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

Theorem: cst-alignment-specifier-rulename

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

Theorem: cst-declarator-rulename

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

Theorem: cst-direct-declarator-rulename

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

Theorem: cst-pointer-rulename

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

Theorem: cst-type-qualifier-or-attribute-specifier-rulename

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

Theorem: cst-type-qualifier-and-attribute-specifier-list-rulename

(defthm cst-type-qualifier-and-attribute-specifier-list-rulename
 (implies
  (cst-matchp abnf::cst
              "type-qualifier-and-attribute-specifier-list")
  (equal
   (abnf::tree-nonleaf->rulename? abnf::cst)
   (abnf::rulename "type-qualifier-and-attribute-specifier-list"))))

Theorem: cst-parameter-type-list-rulename

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

Theorem: cst-parameter-list-rulename

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

Theorem: cst-parameter-declaration-rulename

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

Theorem: cst-identifier-list-rulename

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

Theorem: cst-type-name-rulename

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

Theorem: cst-abstract-declarator-rulename

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

Theorem: cst-direct-abstract-declarator-rulename

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

Theorem: cst-typedef-name-rulename

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

Theorem: cst-initializer-rulename

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

Theorem: cst-initializer-list-rulename

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

Theorem: cst-designation-rulename

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

Theorem: cst-designator-list-rulename

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

Theorem: cst-designator-rulename

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

Theorem: cst-static-assert-declaration-rulename

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

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-labeled-statement-rulename

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

Theorem: cst-label-declaration-rulename

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

Theorem: cst-compound-statement-rulename

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

Theorem: cst-block-item-list-rulename

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

Theorem: cst-block-item-rulename

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

Theorem: cst-expression-statement-rulename

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

Theorem: cst-selection-statement-rulename

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

Theorem: cst-iteration-statement-rulename

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

Theorem: cst-jump-statement-rulename

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

Theorem: cst-translation-unit-rulename

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

Theorem: cst-external-declaration-rulename

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

Theorem: cst-function-definition-rulename

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

Theorem: cst-declaration-list-rulename

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

Theorem: cst-preprocessing-file-rulename

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

Theorem: cst-group-rulename

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

Theorem: cst-group-part-rulename

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

Theorem: cst-if-section-rulename

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

Theorem: cst-if-group-rulename

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

Theorem: cst-elif-groups-rulename

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

Theorem: cst-elif-group-rulename

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

Theorem: cst-else-group-rulename

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

Theorem: cst-endif-line-rulename

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

Theorem: cst-control-line-rulename

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

Theorem: cst-text-line-rulename

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

Theorem: cst-non-directive-rulename

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

Theorem: cst-lparen-rulename

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

Theorem: cst-replacement-list-rulename

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

Theorem: cst-pp-tokens-rulename

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

Theorem: cst-on-off-switch-rulename

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

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

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

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

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

Theorem: cst-letter-branches-match-alt

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

Theorem: cst-digit-branches-match-alt

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

Theorem: cst-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-graphic-character-branches-match-alt

(defthm cst-graphic-character-branches-match-alt
  (implies (cst-matchp abnf::cst "graphic-character")
           (cst-list-list-alt-matchp
                (abnf::tree-nonleaf->branches abnf::cst)
                "%x21-23 / %x25-2F / %x3A-3F / %x5B-5F / %x7B-7E")))

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-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-vertical-tab-branches-match-alt

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

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

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

Theorem: cst-control-character-branches-match-alt

(defthm cst-control-character-branches-match-alt
  (implies (cst-matchp abnf::cst "control-character")
           (cst-list-list-alt-matchp
                (abnf::tree-nonleaf->branches abnf::cst)
                "horizontal-tab / vertical-tab / form-feed")))

Theorem: cst-basic-character-branches-match-alt

(defthm cst-basic-character-branches-match-alt
 (implies
  (cst-matchp abnf::cst "basic-character")
  (cst-list-list-alt-matchp
   (abnf::tree-nonleaf->branches abnf::cst)
   "letter / digit / graphic-character / space / control-character")))

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-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-extended-character-branches-match-alt

(defthm cst-extended-character-branches-match-alt
 (implies
  (cst-matchp abnf::cst "extended-character")
  (cst-list-list-alt-matchp
   (abnf::tree-nonleaf->branches abnf::cst)
   "%x24 / %x40 / %x60 / line-feed / carriage-return / safe-nonascii")))

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)
                "basic-character / extended-character")))

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

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

Theorem: cst-extended-character-not-new-line-branches-match-alt

(defthm cst-extended-character-not-new-line-branches-match-alt
 (implies
  (cst-matchp abnf::cst
              "extended-character-not-new-line")
  (cst-list-list-alt-matchp (abnf::tree-nonleaf->branches abnf::cst)
                            "%x24 / %x40 / %x60 / safe-nonascii")))

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

(defthm cst-graphic-character-not-star-branches-match-alt
 (implies
  (cst-matchp abnf::cst "graphic-character-not-star")
  (cst-list-list-alt-matchp
      (abnf::tree-nonleaf->branches abnf::cst)
      "%x21-23 / %x25-29 / %x2B-2F / %x3A-3F / %x5B-5F / %x7B-7E")))

Theorem: cst-graphic-character-not-greater-than-branches-match-alt

(defthm cst-graphic-character-not-greater-than-branches-match-alt
 (implies
    (cst-matchp abnf::cst
                "graphic-character-not-greater-than")
    (cst-list-list-alt-matchp
         (abnf::tree-nonleaf->branches abnf::cst)
         "%x21-23 / %x25-2F / %x3A-3D / %x3F / %x5B-5F / %x7B-7E")))

Theorem: cst-graphic-character-not-double-quote-branches-match-alt

(defthm cst-graphic-character-not-double-quote-branches-match-alt
  (implies
       (cst-matchp abnf::cst
                   "graphic-character-not-double-quote")
       (cst-list-list-alt-matchp
            (abnf::tree-nonleaf->branches abnf::cst)
            "%x21 / %x23 / %x25-2F / %x3A-3F / %x5B-5F / %x7B-7E")))

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

(defthm cst-graphic-character-not-star-or-slash-branches-match-alt
 (implies
  (cst-matchp abnf::cst
              "graphic-character-not-star-or-slash")
  (cst-list-list-alt-matchp
      (abnf::tree-nonleaf->branches abnf::cst)
      "%x21-23 / %x25-29 / %x2B-2E / %x3A-3F / %x5B-5F / %x7B-7E")))

Theorem: cst-graphic-character-not-single-quote-or-backslash-branches-match-alt

(defthm
 cst-graphic-character-not-single-quote-or-backslash-branches-match-alt
 (implies
  (cst-matchp abnf::cst
              "graphic-character-not-single-quote-or-backslash")
  (cst-list-list-alt-matchp
   (abnf::tree-nonleaf->branches abnf::cst)
   "%x21-23 / %x25-26 / %x28-2F / %x3A-3F / %x5B / %x5D-5F / %x7B-7E")))

Theorem: cst-graphic-character-not-double-quote-or-backslash-branches-match-alt

(defthm
 cst-graphic-character-not-double-quote-or-backslash-branches-match-alt
 (implies
  (cst-matchp abnf::cst
              "graphic-character-not-double-quote-or-backslash")
  (cst-list-list-alt-matchp
     (abnf::tree-nonleaf->branches abnf::cst)
     "%x21 / %x23 / %x25-2F / %x3A-3F / %x5B / %x5D-5F / %x7B-7E")))

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

(defthm cst-basic-character-not-star-branches-match-alt
 (implies
  (cst-matchp abnf::cst "basic-character-not-star")
  (cst-list-list-alt-matchp
   (abnf::tree-nonleaf->branches abnf::cst)
   "letter / digit / graphic-character-not-star / space / control-character")))

Theorem: cst-basic-character-not-greater-than-branches-match-alt

(defthm cst-basic-character-not-greater-than-branches-match-alt
 (implies
  (cst-matchp abnf::cst
              "basic-character-not-greater-than")
  (cst-list-list-alt-matchp
   (abnf::tree-nonleaf->branches abnf::cst)
   "letter / digit / graphic-character-not-greater-than / space / control-character")))

Theorem: cst-basic-character-not-double-quote-branches-match-alt

(defthm cst-basic-character-not-double-quote-branches-match-alt
 (implies
  (cst-matchp abnf::cst
              "basic-character-not-double-quote")
  (cst-list-list-alt-matchp
   (abnf::tree-nonleaf->branches abnf::cst)
   "letter / digit / graphic-character-not-double-quote / space / control-character")))

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

(defthm cst-basic-character-not-star-or-slash-branches-match-alt
 (implies
  (cst-matchp abnf::cst
              "basic-character-not-star-or-slash")
  (cst-list-list-alt-matchp
   (abnf::tree-nonleaf->branches abnf::cst)
   "letter / digit / graphic-character-not-star-or-slash / space / control-character")))

Theorem: cst-basic-character-not-single-quote-or-backslash-branches-match-alt

(defthm
 cst-basic-character-not-single-quote-or-backslash-branches-match-alt
 (implies
  (cst-matchp abnf::cst
              "basic-character-not-single-quote-or-backslash")
  (cst-list-list-alt-matchp
   (abnf::tree-nonleaf->branches abnf::cst)
   "letter / digit / graphic-character-not-single-quote-or-backslash / space / control-character")))

Theorem: cst-basic-character-not-double-quote-or-backslash-branches-match-alt

(defthm
 cst-basic-character-not-double-quote-or-backslash-branches-match-alt
 (implies
  (cst-matchp abnf::cst
              "basic-character-not-double-quote-or-backslash")
  (cst-list-list-alt-matchp
   (abnf::tree-nonleaf->branches abnf::cst)
   "letter / digit / graphic-character-not-double-quote-or-backslash / space / control-character")))

Theorem: cst-character-not-new-line-branches-match-alt

(defthm cst-character-not-new-line-branches-match-alt
  (implies
       (cst-matchp abnf::cst "character-not-new-line")
       (cst-list-list-alt-matchp
            (abnf::tree-nonleaf->branches abnf::cst)
            "basic-character / extended-character-not-new-line")))

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

(defthm cst-character-not-star-branches-match-alt
  (implies (cst-matchp abnf::cst "character-not-star")
           (cst-list-list-alt-matchp
                (abnf::tree-nonleaf->branches abnf::cst)
                "basic-character-not-star / extended-character")))

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

(defthm cst-character-not-star-or-slash-branches-match-alt
 (implies
    (cst-matchp abnf::cst "character-not-star-or-slash")
    (cst-list-list-alt-matchp
         (abnf::tree-nonleaf->branches abnf::cst)
         "basic-character-not-star-or-slash / extended-character")))

Theorem: cst-character-not-greater-than-or-new-line-branches-match-alt

(defthm
      cst-character-not-greater-than-or-new-line-branches-match-alt
 (implies
  (cst-matchp abnf::cst
              "character-not-greater-than-or-new-line")
  (cst-list-list-alt-matchp
   (abnf::tree-nonleaf->branches abnf::cst)
   "basic-character-not-greater-than / extended-character-not-new-line")))

Theorem: cst-character-not-double-quote-or-new-line-branches-match-alt

(defthm
      cst-character-not-double-quote-or-new-line-branches-match-alt
 (implies
  (cst-matchp abnf::cst
              "character-not-double-quote-or-new-line")
  (cst-list-list-alt-matchp
   (abnf::tree-nonleaf->branches abnf::cst)
   "basic-character-not-double-quote / extended-character-not-new-line")))

Theorem: cst-character-not-single-quote-or-backslash-or-new-line-branches-match-alt

(defthm
 cst-character-not-single-quote-or-backslash-or-new-line-branches-match-alt
 (implies
  (cst-matchp abnf::cst
              "character-not-single-quote-or-backslash-or-new-line")
  (cst-list-list-alt-matchp
   (abnf::tree-nonleaf->branches abnf::cst)
   "basic-character-not-single-quote-or-backslash / extended-character-not-new-line")))

Theorem: cst-character-not-double-quote-or-backslash-or-new-line-branches-match-alt

(defthm
 cst-character-not-double-quote-or-backslash-or-new-line-branches-match-alt
 (implies
  (cst-matchp abnf::cst
              "character-not-double-quote-or-backslash-or-new-line")
  (cst-list-list-alt-matchp
   (abnf::tree-nonleaf->branches abnf::cst)
   "basic-character-not-double-quote-or-backslash / extended-character-not-new-line")))

Theorem: cst-white-space-branches-match-alt

(defthm cst-white-space-branches-match-alt
 (implies
  (cst-matchp abnf::cst "white-space")
  (cst-list-list-alt-matchp
   (abnf::tree-nonleaf->branches abnf::cst)
   "space / horizontal-tab / vertical-tab / form-feed / new-line")))

Theorem: cst-header-name-branches-match-alt

(defthm cst-header-name-branches-match-alt
 (implies
  (cst-matchp abnf::cst "header-name")
  (cst-list-list-alt-matchp
   (abnf::tree-nonleaf->branches abnf::cst)
   "\"<\" h-char-sequence \">\" / double-quote q-char-sequence double-quote")))

Theorem: cst-h-char-sequence-branches-match-alt

(defthm cst-h-char-sequence-branches-match-alt
 (implies
  (cst-matchp abnf::cst "h-char-sequence")
  (cst-list-list-alt-matchp (abnf::tree-nonleaf->branches abnf::cst)
                            "h-char / h-char-sequence h-char")))

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

(defthm cst-h-char-branches-match-alt
  (implies (cst-matchp abnf::cst "h-char")
           (cst-list-list-alt-matchp
                (abnf::tree-nonleaf->branches abnf::cst)
                "character-not-greater-than-or-new-line")))

Theorem: cst-q-char-sequence-branches-match-alt

(defthm cst-q-char-sequence-branches-match-alt
 (implies
  (cst-matchp abnf::cst "q-char-sequence")
  (cst-list-list-alt-matchp (abnf::tree-nonleaf->branches abnf::cst)
                            "q-char / q-char-sequence q-char")))

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

(defthm cst-q-char-branches-match-alt
  (implies (cst-matchp abnf::cst "q-char")
           (cst-list-list-alt-matchp
                (abnf::tree-nonleaf->branches abnf::cst)
                "character-not-double-quote-or-new-line")))

Theorem: cst-pp-number-branches-match-alt

(defthm cst-pp-number-branches-match-alt
 (implies
  (cst-matchp abnf::cst "pp-number")
  (cst-list-list-alt-matchp
   (abnf::tree-nonleaf->branches abnf::cst)
   "digit / \".\" digit / pp-number digit / pp-number identifier-nondigit / pp-number %i\"e\" sign / pp-number %i\"p\" sign / pp-number \".\"")))

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 / character-not-star 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 / character-not-star-or-slash rest-of-block-comment")))

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

(defthm cst-line-comment-branches-match-alt
  (implies (cst-matchp abnf::cst "line-comment")
           (cst-list-list-alt-matchp
                (abnf::tree-nonleaf->branches abnf::cst)
                "\"//\" *character-not-new-line new-line")))

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 / constant / string-literal / punctuator")))

Theorem: cst-preprocessing-token-branches-match-alt

(defthm cst-preprocessing-token-branches-match-alt
 (implies
  (cst-matchp abnf::cst "preprocessing-token")
  (cst-list-list-alt-matchp
   (abnf::tree-nonleaf->branches abnf::cst)
   "header-name / identifier / pp-number / character-constant / string-literal / punctuator / character")))

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\"auto\" / %s\"bool\" / %s\"break\" / %s\"case\" / %s\"char\" / %s\"const\" / %s\"continue\" / %s\"default\" / %s\"do\" / %s\"double\" / %s\"else\" / %s\"enum\" / %s\"extern\" / %s\"false\" / %s\"float\" / %s\"for\" / %s\"goto\" / %s\"if\" / %s\"inline\" / %s\"int\" / %s\"long\" / %s\"register\" / %s\"restrict\" / %s\"return\" / %s\"short\" / %s\"signed\" / %s\"sizeof\" / %s\"static\" / %s\"struct\" / %s\"switch\" / %s\"true\" / %s\"typedef\" / %s\"union\" / %s\"unsigned\" / %s\"void\" / %s\"volatile\" / %s\"while\" / %s\"_Alignas\" / %s\"_Alignof\" / %s\"_Atomic\" / %s\"_Bool\" / %s\"_Complex\" / %s\"_Generic\" / %s\"_Imaginary\" / %s\"_Noreturn\" / %s\"_Static_assert\" / %s\"_Thread_local\"")))

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

(defthm cst-gcc-keyword-branches-match-alt
 (implies
  (cst-matchp abnf::cst "gcc-keyword")
  (cst-list-list-alt-matchp
   (abnf::tree-nonleaf->branches abnf::cst)
   "%s\"__alignof\" / %s\"__alignof__\" / %s\"asm\" / %s\"__asm\" / %s\"__asm__\" / %s\"__attribute\" / %s\"__attribute__\" / %s\"__auto_type\" / %s\"__builtin_offsetof\" / %s\"__builtin_types_compatible_p\" / %s\"__builtin_va_list\" / %s\"__declspec\" / %s\"__extension__\" / %s\"__float80\" / %s\"__float128\" / %s\"_Float16\" / %s\"_Float16x\" / %s\"_Float32\" / %s\"_Float32x\" / %s\"_Float64\" / %s\"_Float64x\" / %s\"_Float128\" / %s\"_Float128x\" / %s\"__imag__\" / %s\"__inline\" / %s\"__inline__\" / %s\"__int128\" / %s\"__int128_t\" / %s\"__label__\" / %s\"__real__\" / %s\"__restrict\" / %s\"__restrict__\" / %s\"__signed\" / %s\"__signed__\" / %s\"__stdcall\" / %s\"typeof\" / %s\"__typeof\" / %s\"__typeof__\" / %s\"__volatile\" / %s\"__volatile__\"")))

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

(defthm cst-alignof-keyword-branches-match-alt
  (implies (cst-matchp abnf::cst "alignof-keyword")
           (cst-list-list-alt-matchp
                (abnf::tree-nonleaf->branches abnf::cst)
                "%s\"_Alignof\" / %s\"__alignof\" / %s\"__alignof__\"")))

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

(defthm cst-asm-keyword-branches-match-alt
 (implies
  (cst-matchp abnf::cst "asm-keyword")
  (cst-list-list-alt-matchp (abnf::tree-nonleaf->branches abnf::cst)
                            "%s\"asm\" / %s\"__asm\" / %s\"__asm__\"")))

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

(defthm cst-attribute-keyword-branches-match-alt
 (implies
  (cst-matchp abnf::cst "attribute-keyword")
  (cst-list-list-alt-matchp (abnf::tree-nonleaf->branches abnf::cst)
                            "%s\"__attribute\" / %s\"__attribute__\"")))

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

(defthm cst-inline-keyword-branches-match-alt
  (implies (cst-matchp abnf::cst "inline-keyword")
           (cst-list-list-alt-matchp
                (abnf::tree-nonleaf->branches abnf::cst)
                "%s\"inline\" / %s\"__inline\" / %s\"__inline__\"")))

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

(defthm cst-restrict-keyword-branches-match-alt
 (implies (cst-matchp abnf::cst "restrict-keyword")
          (cst-list-list-alt-matchp
               (abnf::tree-nonleaf->branches abnf::cst)
               "%s\"restrict\" / %s\"__restrict\" / %s\"__restrict__\"")))

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

(defthm cst-signed-keyword-branches-match-alt
  (implies (cst-matchp abnf::cst "signed-keyword")
           (cst-list-list-alt-matchp
                (abnf::tree-nonleaf->branches abnf::cst)
                "%s\"signed\" / %s\"__signed\" / %s\"__signed__\"")))

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

(defthm cst-typeof-keyword-branches-match-alt
  (implies (cst-matchp abnf::cst "typeof-keyword")
           (cst-list-list-alt-matchp
                (abnf::tree-nonleaf->branches abnf::cst)
                "%s\"typeof\" / %s\"__typeof\" / %s\"__typeof__\"")))

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

(defthm cst-volatile-keyword-branches-match-alt
 (implies (cst-matchp abnf::cst "volatile-keyword")
          (cst-list-list-alt-matchp
               (abnf::tree-nonleaf->branches abnf::cst)
               "%s\"volatile\" / %s\"__volatile\" / %s\"__volatile__\"")))

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)
   "identifier-nondigit / identifier identifier-nondigit / identifier digit")))

Theorem: cst-identifier-nondigit-branches-match-alt

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

Theorem: cst-nondigit-branches-match-alt

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

Theorem: cst-universal-character-name-branches-match-alt

(defthm cst-universal-character-name-branches-match-alt
  (implies (cst-matchp abnf::cst "universal-character-name")
           (cst-list-list-alt-matchp
                (abnf::tree-nonleaf->branches abnf::cst)
                "%s\"\\u\" hex-quad / %s\"\\U\" hex-quad hex-quad")))

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

(defthm cst-hex-quad-branches-match-alt
 (implies
  (cst-matchp abnf::cst "hex-quad")
  (cst-list-list-alt-matchp
   (abnf::tree-nonleaf->branches abnf::cst)
   "hexadecimal-digit hexadecimal-digit hexadecimal-digit hexadecimal-digit")))

Theorem: cst-constant-branches-match-alt

(defthm cst-constant-branches-match-alt
 (implies
  (cst-matchp abnf::cst "constant")
  (cst-list-list-alt-matchp
   (abnf::tree-nonleaf->branches abnf::cst)
   "integer-constant / floating-constant / enumeration-constant / character-constant")))

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

(defthm cst-integer-constant-branches-match-alt
 (implies
  (cst-matchp abnf::cst "integer-constant")
  (cst-list-list-alt-matchp
   (abnf::tree-nonleaf->branches abnf::cst)
   "decimal-constant [ integer-suffix ] / octal-constant [ integer-suffix ] / hexadecimal-constant [ integer-suffix ]")))

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

(defthm cst-decimal-constant-branches-match-alt
  (implies (cst-matchp abnf::cst "decimal-constant")
           (cst-list-list-alt-matchp
                (abnf::tree-nonleaf->branches abnf::cst)
                "nonzero-digit / decimal-constant digit")))

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

(defthm cst-octal-constant-branches-match-alt
 (implies
  (cst-matchp abnf::cst "octal-constant")
  (cst-list-list-alt-matchp (abnf::tree-nonleaf->branches abnf::cst)
                            "\"0\" / octal-constant octal-digit")))

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

(defthm cst-hexadecimal-constant-branches-match-alt
 (implies
  (cst-matchp abnf::cst "hexadecimal-constant")
  (cst-list-list-alt-matchp
   (abnf::tree-nonleaf->branches abnf::cst)
   "hexadecimal-prefix hexadecimal-digit / hexadecimal-constant hexadecimal-digit")))

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

(defthm cst-hexadecimal-prefix-branches-match-alt
 (implies
  (cst-matchp abnf::cst "hexadecimal-prefix")
  (cst-list-list-alt-matchp (abnf::tree-nonleaf->branches abnf::cst)
                            "%i\"0x\"")))

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

(defthm cst-nonzero-digit-branches-match-alt
 (implies
  (cst-matchp abnf::cst "nonzero-digit")
  (cst-list-list-alt-matchp (abnf::tree-nonleaf->branches abnf::cst)
                            "%x31-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)
                            "%x30-39 / %x61-66 / %x41-46")))

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

(defthm cst-integer-suffix-branches-match-alt
 (implies
  (cst-matchp abnf::cst "integer-suffix")
  (cst-list-list-alt-matchp
   (abnf::tree-nonleaf->branches abnf::cst)
   "unsigned-suffix [ long-suffix ] / unsigned-suffix [ long-long-suffix ] / long-suffix [ unsigned-suffix ] / long-long-suffix [ unsigned-suffix ]")))

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

(defthm cst-unsigned-suffix-branches-match-alt
 (implies
  (cst-matchp abnf::cst "unsigned-suffix")
  (cst-list-list-alt-matchp (abnf::tree-nonleaf->branches abnf::cst)
                            "%i\"u\"")))

Theorem: cst-long-suffix-branches-match-alt

(defthm cst-long-suffix-branches-match-alt
 (implies
  (cst-matchp abnf::cst "long-suffix")
  (cst-list-list-alt-matchp (abnf::tree-nonleaf->branches abnf::cst)
                            "%i\"l\"")))

Theorem: cst-long-long-suffix-branches-match-alt

(defthm cst-long-long-suffix-branches-match-alt
 (implies
  (cst-matchp abnf::cst "long-long-suffix")
  (cst-list-list-alt-matchp (abnf::tree-nonleaf->branches abnf::cst)
                            "%s\"ll\" / %s\"LL\"")))

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

(defthm cst-floating-constant-branches-match-alt
 (implies
  (cst-matchp abnf::cst "floating-constant")
  (cst-list-list-alt-matchp
      (abnf::tree-nonleaf->branches abnf::cst)
      "decimal-floating-constant / hexadecimal-floating-constant")))

Theorem: cst-decimal-floating-constant-branches-match-alt

(defthm cst-decimal-floating-constant-branches-match-alt
 (implies
  (cst-matchp abnf::cst "decimal-floating-constant")
  (cst-list-list-alt-matchp
   (abnf::tree-nonleaf->branches abnf::cst)
   "fractional-constant [ exponent-part ] [ floating-suffix ] / digit-sequence exponent-part [ floating-suffix ]")))

Theorem: cst-hexadecimal-floating-constant-branches-match-alt

(defthm cst-hexadecimal-floating-constant-branches-match-alt
 (implies
  (cst-matchp abnf::cst
              "hexadecimal-floating-constant")
  (cst-list-list-alt-matchp
   (abnf::tree-nonleaf->branches abnf::cst)
   "hexadecimal-prefix hexadecimal-fractional-constant binary-exponent-part [ floating-suffix ] / hexadecimal-prefix hexadecimal-digit-sequence binary-exponent-part [ floating-suffix ]")))

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

(defthm cst-fractional-constant-branches-match-alt
 (implies
  (cst-matchp abnf::cst "fractional-constant")
  (cst-list-list-alt-matchp
     (abnf::tree-nonleaf->branches abnf::cst)
     "[ digit-sequence ] \".\" digit-sequence / digit-sequence \".\"")))

Theorem: cst-exponent-part-branches-match-alt

(defthm cst-exponent-part-branches-match-alt
 (implies
  (cst-matchp abnf::cst "exponent-part")
  (cst-list-list-alt-matchp (abnf::tree-nonleaf->branches abnf::cst)
                            "%i\"e\" [ sign ] digit-sequence")))

Theorem: cst-sign-branches-match-alt

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

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

(defthm cst-digit-sequence-branches-match-alt
 (implies
  (cst-matchp abnf::cst "digit-sequence")
  (cst-list-list-alt-matchp (abnf::tree-nonleaf->branches abnf::cst)
                            "digit / digit-sequence digit")))

Theorem: cst-hexadecimal-fractional-constant-branches-match-alt

(defthm cst-hexadecimal-fractional-constant-branches-match-alt
 (implies
  (cst-matchp abnf::cst
              "hexadecimal-fractional-constant")
  (cst-list-list-alt-matchp
   (abnf::tree-nonleaf->branches abnf::cst)
   "[ hexadecimal-digit-sequence ] \".\" hexadecimal-digit-sequence / hexadecimal-digit-sequence \".\"")))

Theorem: cst-binary-exponent-part-branches-match-alt

(defthm cst-binary-exponent-part-branches-match-alt
 (implies
  (cst-matchp abnf::cst "binary-exponent-part")
  (cst-list-list-alt-matchp (abnf::tree-nonleaf->branches abnf::cst)
                            "%i\"p\" [ sign ] digit-sequence")))

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

(defthm cst-hexadecimal-digit-sequence-branches-match-alt
 (implies
  (cst-matchp abnf::cst "hexadecimal-digit-sequence")
  (cst-list-list-alt-matchp
   (abnf::tree-nonleaf->branches abnf::cst)
   "hexadecimal-digit / hexadecimal-digit-sequence hexadecimal-digit")))

Theorem: cst-floating-suffix-branches-match-alt

(defthm cst-floating-suffix-branches-match-alt
 (implies
  (cst-matchp abnf::cst "floating-suffix")
  (cst-list-list-alt-matchp
     (abnf::tree-nonleaf->branches abnf::cst)
     "%i\"f\" / %i\"l\" / %i\"f\" ( \"16\" / \"32\" / \"64\" / \"128\" ) %s\"x\"")))

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

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

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

(defthm cst-character-constant-branches-match-alt
 (implies
  (cst-matchp abnf::cst "character-constant")
  (cst-list-list-alt-matchp
   (abnf::tree-nonleaf->branches abnf::cst)
   "\"'\" c-char-sequence \"'\" / %s\"L'\" c-char-sequence \"'\" / %i\"u'\" c-char-sequence \"'\"")))

Theorem: cst-c-char-sequence-branches-match-alt

(defthm cst-c-char-sequence-branches-match-alt
 (implies
  (cst-matchp abnf::cst "c-char-sequence")
  (cst-list-list-alt-matchp (abnf::tree-nonleaf->branches abnf::cst)
                            "c-char / c-char-sequence c-char")))

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

(defthm cst-c-char-branches-match-alt
 (implies
  (cst-matchp abnf::cst "c-char")
  (cst-list-list-alt-matchp
   (abnf::tree-nonleaf->branches abnf::cst)
   "character-not-single-quote-or-backslash-or-new-line / escape-sequence")))

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

(defthm cst-escape-sequence-branches-match-alt
 (implies
  (cst-matchp abnf::cst "escape-sequence")
  (cst-list-list-alt-matchp
   (abnf::tree-nonleaf->branches abnf::cst)
   "simple-escape-sequence / octal-escape-sequence / hexadecimal-escape-sequence / universal-character-name")))

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

(defthm cst-simple-escape-sequence-branches-match-alt
 (implies
  (cst-matchp abnf::cst "simple-escape-sequence")
  (cst-list-list-alt-matchp
   (abnf::tree-nonleaf->branches abnf::cst)
   "\"\\'\" / \"\\\" double-quote / \"\\?\" / \"\\\\\" / %s\"\\a\" / %s\"\\b\" / %s\"\\f\" / %s\"\\n\" / %s\"\\r\" / %s\"\\t\" / %s\"\\v\" / \"\\%\"")))

Theorem: cst-octal-escape-sequence-branches-match-alt

(defthm cst-octal-escape-sequence-branches-match-alt
 (implies
  (cst-matchp abnf::cst "octal-escape-sequence")
  (cst-list-list-alt-matchp
   (abnf::tree-nonleaf->branches abnf::cst)
   "\"\\\" octal-digit / \"\\\" octal-digit octal-digit / \"\\\" octal-digit octal-digit octal-digit")))

Theorem: cst-hexadecimal-escape-sequence-branches-match-alt

(defthm cst-hexadecimal-escape-sequence-branches-match-alt
 (implies
  (cst-matchp abnf::cst "hexadecimal-escape-sequence")
  (cst-list-list-alt-matchp
   (abnf::tree-nonleaf->branches abnf::cst)
   "%s\"\\x\" hexadecimal-digit / hexadecimal-escape-sequence hexadecimal-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)
   "[ encoding-prefix ] double-quote [ s-char-sequence ] double-quote")))

Theorem: cst-encoding-prefix-branches-match-alt

(defthm cst-encoding-prefix-branches-match-alt
 (implies
  (cst-matchp abnf::cst "encoding-prefix")
  (cst-list-list-alt-matchp (abnf::tree-nonleaf->branches abnf::cst)
                            "%s\"u8\" / %i\"u\" / %s\"L\"")))

Theorem: cst-s-char-sequence-branches-match-alt

(defthm cst-s-char-sequence-branches-match-alt
 (implies
  (cst-matchp abnf::cst "s-char-sequence")
  (cst-list-list-alt-matchp (abnf::tree-nonleaf->branches abnf::cst)
                            "s-char / s-char-sequence s-char")))

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

(defthm cst-s-char-branches-match-alt
 (implies
  (cst-matchp abnf::cst "s-char")
  (cst-list-list-alt-matchp
   (abnf::tree-nonleaf->branches abnf::cst)
   "character-not-double-quote-or-backslash-or-new-line / escape-sequence")))

Theorem: cst-punctuator-branches-match-alt

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

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 / control-line / white-space")))

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)
   "identifier / constant / 1*string-literal / \"(\" expression \")\" / generic-selection / \"(\" compound-statement \")\" / types-compatible-call / offsetof-call / va-arg-call / %s\"__extension__\" primary-expression / %s\"true\" / %s\"false\"")))

Theorem: cst-types-compatible-call-branches-match-alt

(defthm cst-types-compatible-call-branches-match-alt
 (implies
  (cst-matchp abnf::cst "types-compatible-call")
  (cst-list-list-alt-matchp
   (abnf::tree-nonleaf->branches abnf::cst)
   "%s\"__builtin_types_compatible_p\" \"(\" type-name \",\" type-name \")\"")))

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

(defthm cst-offsetof-call-branches-match-alt
 (implies
  (cst-matchp abnf::cst "offsetof-call")
  (cst-list-list-alt-matchp
   (abnf::tree-nonleaf->branches abnf::cst)
   "%s\"__builtin_offsetof\" \"(\" type-name \",\" offsetof-member-designator \")\"")))

Theorem: cst-offsetof-member-designator-branches-match-alt

(defthm cst-offsetof-member-designator-branches-match-alt
 (implies
  (cst-matchp abnf::cst "offsetof-member-designator")
  (cst-list-list-alt-matchp
   (abnf::tree-nonleaf->branches abnf::cst)
   "identifier / offsetof-member-designator \".\" identifier / offsetof-member-designator \"[\" expression \"]\"")))

Theorem: cst-va-arg-call-branches-match-alt

(defthm cst-va-arg-call-branches-match-alt
 (implies
  (cst-matchp abnf::cst "va-arg-call")
  (cst-list-list-alt-matchp
   (abnf::tree-nonleaf->branches abnf::cst)
   "%s\"__builtin_va_arg\" \"(\" assignment-expression \",\" type-name \")\"")))

Theorem: cst-generic-selection-branches-match-alt

(defthm cst-generic-selection-branches-match-alt
 (implies
  (cst-matchp abnf::cst "generic-selection")
  (cst-list-list-alt-matchp
   (abnf::tree-nonleaf->branches abnf::cst)
   "%s\"_Generic\" \"(\" assignment-expression \",\" generic-assoc-list \")\"")))

Theorem: cst-generic-assoc-list-branches-match-alt

(defthm cst-generic-assoc-list-branches-match-alt
 (implies
  (cst-matchp abnf::cst "generic-assoc-list")
  (cst-list-list-alt-matchp
   (abnf::tree-nonleaf->branches abnf::cst)
   "generic-association / generic-assoc-list \",\" generic-association")))

Theorem: cst-generic-association-branches-match-alt

(defthm cst-generic-association-branches-match-alt
 (implies
  (cst-matchp abnf::cst "generic-association")
  (cst-list-list-alt-matchp
   (abnf::tree-nonleaf->branches abnf::cst)
   "type-name \":\" assignment-expression / %s\"default\" \":\" assignment-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 / postfix-expression \"[\" expression \"]\" / postfix-expression \"(\" [ argument-expression-list ] \")\" / postfix-expression \".\" identifier / postfix-expression \"->\" identifier / postfix-expression \"++\" / postfix-expression \"--\" / \"(\" type-name \")\" \"{\" initializer-list \"}\" / \"(\" type-name \")\" \"{\" initializer-list \",\" \"}\" / \"(\" type-name \")\" \"{\" \"}\"")))

Theorem: cst-argument-expression-list-branches-match-alt

(defthm cst-argument-expression-list-branches-match-alt
 (implies
  (cst-matchp abnf::cst "argument-expression-list")
  (cst-list-list-alt-matchp
   (abnf::tree-nonleaf->branches abnf::cst)
   "assignment-expression / argument-expression-list \",\" assignment-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 / unary-operator cast-expression / %s\"sizeof\" unary-expression / %s\"sizeof\" \"(\" type-name \")\" / alignof-keyword unary-expression / alignof-keyword \"(\" type-name \")\" / %s\"__real__\" cast-expression / %s\"__imag__\" cast-expression / \"&&\" identifier")))

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

(defthm cst-unary-operator-branches-match-alt
 (implies
  (cst-matchp abnf::cst "unary-operator")
  (cst-list-list-alt-matchp (abnf::tree-nonleaf->branches abnf::cst)
                            "\"&\" / \"*\" / \"+\" / \"-\" / \"~\" / \"!\"")))

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

(defthm cst-cast-expression-branches-match-alt
 (implies
      (cst-matchp abnf::cst "cast-expression")
      (cst-list-list-alt-matchp
           (abnf::tree-nonleaf->branches abnf::cst)
           "unary-expression / \"(\" type-name \")\" cast-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)
   "cast-expression / multiplicative-expression \"*\" cast-expression / multiplicative-expression \"/\" cast-expression / multiplicative-expression \"%\" cast-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-relational-expression-branches-match-alt

(defthm cst-relational-expression-branches-match-alt
 (implies
  (cst-matchp abnf::cst "relational-expression")
  (cst-list-list-alt-matchp
   (abnf::tree-nonleaf->branches abnf::cst)
   "shift-expression / relational-expression \"<\" shift-expression / relational-expression \">\" shift-expression / relational-expression \"<=\" shift-expression / relational-expression \">=\" shift-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)
   "relational-expression / equality-expression \"==\" relational-expression / equality-expression \"!=\" relational-expression")))

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

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

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

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

Theorem: cst-inclusive-or-expression-branches-match-alt

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

Theorem: cst-logical-and-expression-branches-match-alt

(defthm cst-logical-and-expression-branches-match-alt
 (implies
  (cst-matchp abnf::cst "logical-and-expression")
  (cst-list-list-alt-matchp
   (abnf::tree-nonleaf->branches abnf::cst)
   "inclusive-or-expression / logical-and-expression \"&&\" inclusive-or-expression")))

Theorem: cst-logical-or-expression-branches-match-alt

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

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

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

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

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

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-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)
   "assignment-expression / expression \",\" assignment-expression")))

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

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

Theorem: cst-attribute-name-branches-match-alt

(defthm cst-attribute-name-branches-match-alt
 (implies
  (cst-matchp abnf::cst "attribute-name")
  (cst-list-list-alt-matchp (abnf::tree-nonleaf->branches abnf::cst)
                            "identifier / keyword")))

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

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

Theorem: cst-attribute-branches-match-alt

(defthm cst-attribute-branches-match-alt
  (implies (cst-matchp abnf::cst "attribute")
           (cst-list-list-alt-matchp
                (abnf::tree-nonleaf->branches abnf::cst)
                "attribute-name [ attribute-parameters ]")))

Theorem: cst-attribute-list-branches-match-alt

(defthm cst-attribute-list-branches-match-alt
 (implies
  (cst-matchp abnf::cst "attribute-list")
  (cst-list-list-alt-matchp (abnf::tree-nonleaf->branches abnf::cst)
                            "attribute *( \",\" attribute )")))

Theorem: cst-attribute-specifier-branches-match-alt

(defthm cst-attribute-specifier-branches-match-alt
 (implies
      (cst-matchp abnf::cst "attribute-specifier")
      (cst-list-list-alt-matchp
           (abnf::tree-nonleaf->branches abnf::cst)
           "attribute-keyword \"(\" \"(\" [ attribute-list ] \")\" \")\"")))

Theorem: cst-asm-name-specifier-branches-match-alt

(defthm cst-asm-name-specifier-branches-match-alt
  (implies (cst-matchp abnf::cst "asm-name-specifier")
           (cst-list-list-alt-matchp
                (abnf::tree-nonleaf->branches abnf::cst)
                "asm-keyword \"(\" 1*string-literal \")\"")))

Theorem: cst-asm-qualifier-branches-match-alt

(defthm cst-asm-qualifier-branches-match-alt
  (implies (cst-matchp abnf::cst "asm-qualifier")
           (cst-list-list-alt-matchp
                (abnf::tree-nonleaf->branches abnf::cst)
                "volatile-keyword / inline-keyword / %s\"goto\"")))

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

(defthm cst-asm-statement-branches-match-alt
 (implies
  (cst-matchp abnf::cst "asm-statement")
  (cst-list-list-alt-matchp
   (abnf::tree-nonleaf->branches abnf::cst)
   "asm-keyword *asm-qualifier \"(\" 1*string-literal [ \":\" asm-output-operands [ \":\" asm-input-operands [ \":\" asm-clobbers [ \":\" asm-goto-labels ] ] ] ] \")\" \";\"")))

Theorem: cst-asm-output-operands-branches-match-alt

(defthm cst-asm-output-operands-branches-match-alt
  (implies
       (cst-matchp abnf::cst "asm-output-operands")
       (cst-list-list-alt-matchp
            (abnf::tree-nonleaf->branches abnf::cst)
            "[ asm-output-operand *( \",\" asm-output-operand ) ]")))

Theorem: cst-asm-output-operand-branches-match-alt

(defthm cst-asm-output-operand-branches-match-alt
 (implies
  (cst-matchp abnf::cst "asm-output-operand")
  (cst-list-list-alt-matchp
     (abnf::tree-nonleaf->branches abnf::cst)
     "[ \"[\" identifier \"]\" ] 1*string-literal \"(\" expression \")\"")))

Theorem: cst-asm-input-operands-branches-match-alt

(defthm cst-asm-input-operands-branches-match-alt
 (implies (cst-matchp abnf::cst "asm-input-operands")
          (cst-list-list-alt-matchp
               (abnf::tree-nonleaf->branches abnf::cst)
               "[ asm-input-operand *( \",\" asm-input-operand ) ]")))

Theorem: cst-asm-input-operand-branches-match-alt

(defthm cst-asm-input-operand-branches-match-alt
 (implies
  (cst-matchp abnf::cst "asm-input-operand")
  (cst-list-list-alt-matchp
     (abnf::tree-nonleaf->branches abnf::cst)
     "[ \"[\" identifier \"]\" ] 1*string-literal \"(\" expression \")\"")))

Theorem: cst-asm-clobbers-branches-match-alt

(defthm cst-asm-clobbers-branches-match-alt
  (implies (cst-matchp abnf::cst "asm-clobbers")
           (cst-list-list-alt-matchp
                (abnf::tree-nonleaf->branches abnf::cst)
                "[ asm-clobber *( \",\" asm-clobber ) ]")))

Theorem: cst-asm-clobber-branches-match-alt

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

Theorem: cst-asm-goto-labels-branches-match-alt

(defthm cst-asm-goto-labels-branches-match-alt
 (implies
  (cst-matchp abnf::cst "asm-goto-labels")
  (cst-list-list-alt-matchp (abnf::tree-nonleaf->branches abnf::cst)
                            "[ identifier *( \",\" identifier ) ]")))

Theorem: cst-declaration-branches-match-alt

(defthm cst-declaration-branches-match-alt
 (implies
  (cst-matchp abnf::cst "declaration")
  (cst-list-list-alt-matchp
   (abnf::tree-nonleaf->branches abnf::cst)
   "[ %s\"__extension__\" ] declaration-specifiers [ init-declarator-list ] \";\" / static-assert-declaration")))

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

(defthm cst-declaration-specifiers-branches-match-alt
 (implies
  (cst-matchp abnf::cst "declaration-specifiers")
  (cst-list-list-alt-matchp
   (abnf::tree-nonleaf->branches abnf::cst)
   "storage-class-specifier [ declaration-specifiers ] / type-specifier [ declaration-specifiers ] / type-qualifier [ declaration-specifiers ] / function-specifier [ declaration-specifiers ] / alignment-specifier [ declaration-specifiers ] / attribute-specifier [ declaration-specifiers ] / %s\"__stdcall\" [ declaration-specifiers ] / %s\"__declspec\" \"(\" identifier \")\" [ declaration-specifiers ]")))

Theorem: cst-init-declarator-list-branches-match-alt

(defthm cst-init-declarator-list-branches-match-alt
 (implies
  (cst-matchp abnf::cst "init-declarator-list")
  (cst-list-list-alt-matchp
     (abnf::tree-nonleaf->branches abnf::cst)
     "init-declarator / init-declarator-list \",\" init-declarator")))

Theorem: cst-init-declarator-branches-match-alt

(defthm cst-init-declarator-branches-match-alt
 (implies
  (cst-matchp abnf::cst "init-declarator")
  (cst-list-list-alt-matchp
   (abnf::tree-nonleaf->branches abnf::cst)
   "declarator [ asm-name-specifier ] *attribute-specifier / declarator [ asm-name-specifier ] *attribute-specifier \"=\" initializer")))

Theorem: cst-storage-class-specifier-branches-match-alt

(defthm cst-storage-class-specifier-branches-match-alt
 (implies
  (cst-matchp abnf::cst "storage-class-specifier")
  (cst-list-list-alt-matchp
   (abnf::tree-nonleaf->branches abnf::cst)
   "%s\"typedef\" / %s\"extern\" / %s\"static\" / %s\"_Thread_local\" / %s\"auto\" / %s\"register\"")))

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

(defthm cst-type-specifier-branches-match-alt
 (implies
  (cst-matchp abnf::cst "type-specifier")
  (cst-list-list-alt-matchp
   (abnf::tree-nonleaf->branches abnf::cst)
   "%s\"void\" / %s\"char\" / %s\"short\" / %s\"int\" / %s\"long\" / %s\"float\" / %s\"double\" / signed-keyword / %s\"unsigned\" / %s\"bool\" / %s\"_Bool\" / %s\"_Complex\" / atomic-type-specifier / struct-or-union-specifier / enum-specifier / typedef-name / %s\"__int128\" / %s\"__float80\" / %s\"__float128\" / %s\"_Float16\" / %s\"_Float16x\" / %s\"_Float32\" / %s\"_Float32x\" / %s\"_Float64\" / %s\"_Float64x\" / %s\"_Float128\" / %s\"_Float128x\" / %s\"__builtin_va_list\" / typeof-keyword \"(\" expression \")\" / typeof-keyword \"(\" type-name \")\" / %s\"__auto_type\"")))

Theorem: cst-struct-or-union-specifier-branches-match-alt

(defthm cst-struct-or-union-specifier-branches-match-alt
 (implies
  (cst-matchp abnf::cst "struct-or-union-specifier")
  (cst-list-list-alt-matchp
   (abnf::tree-nonleaf->branches abnf::cst)
   "struct-or-union *attribute-specifier [ identifier ] \"{\" struct-declaration-list \"}\" / struct-or-union *attribute-specifier identifier / %s\"struct\" *attribute-specifier [ identifier ] \"{\" \"}\"")))

Theorem: cst-struct-or-union-branches-match-alt

(defthm cst-struct-or-union-branches-match-alt
 (implies
  (cst-matchp abnf::cst "struct-or-union")
  (cst-list-list-alt-matchp (abnf::tree-nonleaf->branches abnf::cst)
                            "%s\"struct\" / %s\"union\"")))

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

(defthm cst-struct-declaration-list-branches-match-alt
 (implies
  (cst-matchp abnf::cst "struct-declaration-list")
  (cst-list-list-alt-matchp
   (abnf::tree-nonleaf->branches abnf::cst)
   "struct-declaration / struct-declaration-list struct-declaration")))

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\"__extension__\" ] specifier-qualifier-list [ struct-declarator-list ] *attribute-specifier \";\" / static-assert-declaration / \";\"")))

Theorem: cst-specifier-qualifier-list-branches-match-alt

(defthm cst-specifier-qualifier-list-branches-match-alt
 (implies
  (cst-matchp abnf::cst "specifier-qualifier-list")
  (cst-list-list-alt-matchp
   (abnf::tree-nonleaf->branches abnf::cst)
   "type-specifier [ specifier-qualifier-list ] / type-qualifier [ specifier-qualifier-list ] / alignment-specifier [ specifier-qualifier-list ] / attribute-specifier [ specifier-qualifier-list ]")))

Theorem: cst-struct-declarator-list-branches-match-alt

(defthm cst-struct-declarator-list-branches-match-alt
 (implies
  (cst-matchp abnf::cst "struct-declarator-list")
  (cst-list-list-alt-matchp
   (abnf::tree-nonleaf->branches abnf::cst)
   "struct-declarator / struct-declarator-list \",\" struct-declarator")))

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

(defthm cst-struct-declarator-branches-match-alt
  (implies
       (cst-matchp abnf::cst "struct-declarator")
       (cst-list-list-alt-matchp
            (abnf::tree-nonleaf->branches abnf::cst)
            "declarator / [ declarator ] \":\" constant-expression")))

Theorem: cst-enum-specifier-branches-match-alt

(defthm cst-enum-specifier-branches-match-alt
 (implies
  (cst-matchp abnf::cst "enum-specifier")
  (cst-list-list-alt-matchp
   (abnf::tree-nonleaf->branches abnf::cst)
   "%s\"enum\" [ identifier ] \"{\" enumerator-list \"}\" / %s\"enum\" [ identifier ] \"{\" enumerator-list \",\" \"}\" / %s\"enum\" identifier")))

Theorem: cst-enumerator-list-branches-match-alt

(defthm cst-enumerator-list-branches-match-alt
  (implies (cst-matchp abnf::cst "enumerator-list")
           (cst-list-list-alt-matchp
                (abnf::tree-nonleaf->branches abnf::cst)
                "enumerator / enumerator-list \",\" enumerator")))

Theorem: cst-enumerator-branches-match-alt

(defthm cst-enumerator-branches-match-alt
 (implies
  (cst-matchp abnf::cst "enumerator")
  (cst-list-list-alt-matchp
   (abnf::tree-nonleaf->branches abnf::cst)
   "enumeration-constant / enumeration-constant \"=\" constant-expression")))

Theorem: cst-atomic-type-specifier-branches-match-alt

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

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

(defthm cst-type-qualifier-branches-match-alt
 (implies
  (cst-matchp abnf::cst "type-qualifier")
  (cst-list-list-alt-matchp
   (abnf::tree-nonleaf->branches abnf::cst)
   "%s\"const\" / restrict-keyword / volatile-keyword / %s\"_Atomic\" / %s\"__seg_fs\" / %s\"__seg_gs\"")))

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

(defthm cst-function-specifier-branches-match-alt
 (implies
  (cst-matchp abnf::cst "function-specifier")
  (cst-list-list-alt-matchp (abnf::tree-nonleaf->branches abnf::cst)
                            "inline-keyword / %s\"_Noreturn\"")))

Theorem: cst-alignment-specifier-branches-match-alt

(defthm cst-alignment-specifier-branches-match-alt
 (implies
  (cst-matchp abnf::cst "alignment-specifier")
  (cst-list-list-alt-matchp
   (abnf::tree-nonleaf->branches abnf::cst)
   "%s\"_Alignas\" \"(\" type-name \")\" / %s\"_Alignas\" \"(\" constant-expression \")\"")))

Theorem: cst-declarator-branches-match-alt

(defthm cst-declarator-branches-match-alt
 (implies
  (cst-matchp abnf::cst "declarator")
  (cst-list-list-alt-matchp (abnf::tree-nonleaf->branches abnf::cst)
                            "[ pointer ] direct-declarator")))

Theorem: cst-direct-declarator-branches-match-alt

(defthm cst-direct-declarator-branches-match-alt
 (implies
  (cst-matchp abnf::cst "direct-declarator")
  (cst-list-list-alt-matchp
   (abnf::tree-nonleaf->branches abnf::cst)
   "identifier / \"(\" declarator \")\" / direct-declarator \"[\" [ type-qualifier-and-attribute-specifier-list ] [ assignment-expression ] \"]\" / direct-declarator \"[\" %s\"static\" [ type-qualifier-and-attribute-specifier-list ] assignment-expression \"]\" / direct-declarator \"[\" type-qualifier-and-attribute-specifier-list %s\"static\" assignment-expression \"]\" / direct-declarator \"[\" [ type-qualifier-and-attribute-specifier-list ] \"*\" \"]\" / direct-declarator \"(\" parameter-type-list \")\" / direct-declarator \"(\" [ identifier-list ] \")\"")))

Theorem: cst-pointer-branches-match-alt

(defthm cst-pointer-branches-match-alt
 (implies
  (cst-matchp abnf::cst "pointer")
  (cst-list-list-alt-matchp
   (abnf::tree-nonleaf->branches abnf::cst)
   "\"*\" [ type-qualifier-and-attribute-specifier-list ] / \"*\" [ type-qualifier-and-attribute-specifier-list ] pointer")))

Theorem: cst-type-qualifier-or-attribute-specifier-branches-match-alt

(defthm cst-type-qualifier-or-attribute-specifier-branches-match-alt
  (implies (cst-matchp abnf::cst
                       "type-qualifier-or-attribute-specifier")
           (cst-list-list-alt-matchp
                (abnf::tree-nonleaf->branches abnf::cst)
                "type-qualifier / attribute-specifier")))

Theorem: cst-type-qualifier-and-attribute-specifier-list-branches-match-alt

(defthm
 cst-type-qualifier-and-attribute-specifier-list-branches-match-alt
 (implies
  (cst-matchp abnf::cst
              "type-qualifier-and-attribute-specifier-list")
  (cst-list-list-alt-matchp
   (abnf::tree-nonleaf->branches abnf::cst)
   "type-qualifier-or-attribute-specifier / type-qualifier-and-attribute-specifier-list type-qualifier-or-attribute-specifier")))

Theorem: cst-parameter-type-list-branches-match-alt

(defthm cst-parameter-type-list-branches-match-alt
  (implies (cst-matchp abnf::cst "parameter-type-list")
           (cst-list-list-alt-matchp
                (abnf::tree-nonleaf->branches abnf::cst)
                "parameter-list / parameter-list \",\" \"...\"")))

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

(defthm cst-parameter-list-branches-match-alt
 (implies
  (cst-matchp abnf::cst "parameter-list")
  (cst-list-list-alt-matchp
   (abnf::tree-nonleaf->branches abnf::cst)
   "parameter-declaration / parameter-list \",\" parameter-declaration")))

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

(defthm cst-parameter-declaration-branches-match-alt
 (implies
  (cst-matchp abnf::cst "parameter-declaration")
  (cst-list-list-alt-matchp
   (abnf::tree-nonleaf->branches abnf::cst)
   "declaration-specifiers declarator *attribute-specifier / declaration-specifiers [ abstract-declarator ] *attribute-specifier")))

Theorem: cst-identifier-list-branches-match-alt

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

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

(defthm cst-type-name-branches-match-alt
 (implies (cst-matchp abnf::cst "type-name")
          (cst-list-list-alt-matchp
               (abnf::tree-nonleaf->branches abnf::cst)
               "specifier-qualifier-list [ abstract-declarator ]")))

Theorem: cst-abstract-declarator-branches-match-alt

(defthm cst-abstract-declarator-branches-match-alt
 (implies (cst-matchp abnf::cst "abstract-declarator")
          (cst-list-list-alt-matchp
               (abnf::tree-nonleaf->branches abnf::cst)
               "pointer / [ pointer ] direct-abstract-declarator")))

Theorem: cst-direct-abstract-declarator-branches-match-alt

(defthm cst-direct-abstract-declarator-branches-match-alt
 (implies
  (cst-matchp abnf::cst "direct-abstract-declarator")
  (cst-list-list-alt-matchp
   (abnf::tree-nonleaf->branches abnf::cst)
   "\"(\" abstract-declarator \")\" / [ direct-abstract-declarator ] \"[\" [ type-qualifier-and-attribute-specifier-list ] [ assignment-expression ] \"]\" / [ direct-abstract-declarator ] \"[\" %s\"static\" [ type-qualifier-and-attribute-specifier-list ] assignment-expression \"]\" / [ direct-abstract-declarator ] \"[\" type-qualifier-and-attribute-specifier-list %s\"static\" assignment-expression \"]\" / [ direct-abstract-declarator ] \"[\" \"*\" \"]\" / [ direct-abstract-declarator ] \"(\" [ parameter-type-list ] \")\"")))

Theorem: cst-typedef-name-branches-match-alt

(defthm cst-typedef-name-branches-match-alt
 (implies
  (cst-matchp abnf::cst "typedef-name")
  (cst-list-list-alt-matchp (abnf::tree-nonleaf->branches abnf::cst)
                            "identifier")))

Theorem: cst-initializer-branches-match-alt

(defthm cst-initializer-branches-match-alt
 (implies
  (cst-matchp abnf::cst "initializer")
  (cst-list-list-alt-matchp
   (abnf::tree-nonleaf->branches abnf::cst)
   "assignment-expression / \"{\" initializer-list \"}\" / \"{\" initializer-list \",\" \"}\" / \"{\" \"}\"")))

Theorem: cst-initializer-list-branches-match-alt

(defthm cst-initializer-list-branches-match-alt
 (implies
  (cst-matchp abnf::cst "initializer-list")
  (cst-list-list-alt-matchp
   (abnf::tree-nonleaf->branches abnf::cst)
   "[ designation ] initializer / initializer-list \",\" [ designation ] initializer")))

Theorem: cst-designation-branches-match-alt

(defthm cst-designation-branches-match-alt
 (implies
  (cst-matchp abnf::cst "designation")
  (cst-list-list-alt-matchp (abnf::tree-nonleaf->branches abnf::cst)
                            "designator-list \"=\"")))

Theorem: cst-designator-list-branches-match-alt

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

Theorem: cst-designator-branches-match-alt

(defthm cst-designator-branches-match-alt
 (implies
  (cst-matchp abnf::cst "designator")
  (cst-list-list-alt-matchp
   (abnf::tree-nonleaf->branches abnf::cst)
   "\"[\" constant-expression [ \"...\" constant-expression ] \"]\" / \".\" identifier")))

Theorem: cst-static-assert-declaration-branches-match-alt

(defthm cst-static-assert-declaration-branches-match-alt
 (implies
  (cst-matchp abnf::cst "static-assert-declaration")
  (cst-list-list-alt-matchp
   (abnf::tree-nonleaf->branches abnf::cst)
   "%s\"_Static_assert\" \"(\" constant-expression \",\" 1*string-literal \")\" \";\"")))

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)
   "labeled-statement / compound-statement / expression-statement / selection-statement / iteration-statement / jump-statement / asm-statement")))

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

(defthm cst-labeled-statement-branches-match-alt
 (implies
  (cst-matchp abnf::cst "labeled-statement")
  (cst-list-list-alt-matchp
   (abnf::tree-nonleaf->branches abnf::cst)
   "identifier \":\" *attribute-specifier statement / %s\"case\" constant-expression [ \"...\" constant-expression ] \":\" statement / %s\"default\" \":\" statement")))

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

(defthm cst-label-declaration-branches-match-alt
 (implies (cst-matchp abnf::cst "label-declaration")
          (cst-list-list-alt-matchp
               (abnf::tree-nonleaf->branches abnf::cst)
               "%s\"__label__\" identifier *( \",\" identifier ) \";\"")))

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

(defthm cst-compound-statement-branches-match-alt
  (implies (cst-matchp abnf::cst "compound-statement")
           (cst-list-list-alt-matchp
                (abnf::tree-nonleaf->branches abnf::cst)
                "\"{\" *label-declaration [ block-item-list ] \"}\"")))

Theorem: cst-block-item-list-branches-match-alt

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

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

(defthm cst-block-item-branches-match-alt
 (implies
  (cst-matchp abnf::cst "block-item")
  (cst-list-list-alt-matchp (abnf::tree-nonleaf->branches abnf::cst)
                            "declaration / statement")))

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

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

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

(defthm cst-selection-statement-branches-match-alt
 (implies
  (cst-matchp abnf::cst "selection-statement")
  (cst-list-list-alt-matchp
   (abnf::tree-nonleaf->branches abnf::cst)
   "%s\"if\" \"(\" expression \")\" statement / %s\"if\" \"(\" expression \")\" statement %s\"else\" statement / %s\"switch\" \"(\" expression \")\" statement")))

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

(defthm cst-iteration-statement-branches-match-alt
 (implies
  (cst-matchp abnf::cst "iteration-statement")
  (cst-list-list-alt-matchp
   (abnf::tree-nonleaf->branches abnf::cst)
   "%s\"while\" \"(\" expression \")\" statement / %s\"do\" statement %s\"while\" \"(\" expression \")\" \";\" / %s\"for\" \"(\" [ expression ] \";\" [ expression ] \";\" [ expression ] \")\" statement / %s\"for\" \"(\" declaration [ expression ] \";\" [ expression ] \")\" statement")))

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

(defthm cst-jump-statement-branches-match-alt
 (implies
  (cst-matchp abnf::cst "jump-statement")
  (cst-list-list-alt-matchp
   (abnf::tree-nonleaf->branches abnf::cst)
   "%s\"goto\" identifier \";\" / %s\"goto\" expression \";\" / %s\"continue\" \";\" / %s\"break\" \";\" / %s\"return\" [ expression ] \";\"")))

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

(defthm cst-translation-unit-branches-match-alt
 (implies
  (cst-matchp abnf::cst "translation-unit")
  (cst-list-list-alt-matchp (abnf::tree-nonleaf->branches abnf::cst)
                            "*external-declaration")))

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

(defthm cst-external-declaration-branches-match-alt
 (implies
   (cst-matchp abnf::cst "external-declaration")
   (cst-list-list-alt-matchp
        (abnf::tree-nonleaf->branches abnf::cst)
        "function-definition / declaration / \";\" / asm-statement")))

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

(defthm cst-function-definition-branches-match-alt
 (implies
  (cst-matchp abnf::cst "function-definition")
  (cst-list-list-alt-matchp
   (abnf::tree-nonleaf->branches abnf::cst)
   "[ %s\"__extension__\" ] declaration-specifiers declarator [ asm-name-specifier ] *attribute-specifier [ declaration-list ] compound-statement")))

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

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

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

(defthm cst-preprocessing-file-branches-match-alt
 (implies
  (cst-matchp abnf::cst "preprocessing-file")
  (cst-list-list-alt-matchp (abnf::tree-nonleaf->branches abnf::cst)
                            "[ group ]")))

Theorem: cst-group-branches-match-alt

(defthm cst-group-branches-match-alt
 (implies
  (cst-matchp abnf::cst "group")
  (cst-list-list-alt-matchp (abnf::tree-nonleaf->branches abnf::cst)
                            "group-part / group group-part")))

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

(defthm cst-group-part-branches-match-alt
 (implies
  (cst-matchp abnf::cst "group-part")
  (cst-list-list-alt-matchp
      (abnf::tree-nonleaf->branches abnf::cst)
      "if-section / control-line / text-line / \"#\" non-directive")))

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

(defthm cst-if-section-branches-match-alt
  (implies
       (cst-matchp abnf::cst "if-section")
       (cst-list-list-alt-matchp
            (abnf::tree-nonleaf->branches abnf::cst)
            "if-group [ elif-groups ] [ else-group ] endif-line")))

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

(defthm cst-if-group-branches-match-alt
 (implies
  (cst-matchp abnf::cst "if-group")
  (cst-list-list-alt-matchp
   (abnf::tree-nonleaf->branches abnf::cst)
   "\"#\" %s\"if\" constant-expression new-line [ group ] / \"#\" %s\"ifdef\" identifier new-line [ group ] / \"#\" %s\"ifndef\" identifier new-line [ group ]")))

Theorem: cst-elif-groups-branches-match-alt

(defthm cst-elif-groups-branches-match-alt
 (implies
  (cst-matchp abnf::cst "elif-groups")
  (cst-list-list-alt-matchp (abnf::tree-nonleaf->branches abnf::cst)
                            "elif-group / elif-groups elif-group")))

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

(defthm cst-elif-group-branches-match-alt
  (implies
       (cst-matchp abnf::cst "elif-group")
       (cst-list-list-alt-matchp
            (abnf::tree-nonleaf->branches abnf::cst)
            "\"#\" %s\"elif\" constant-expression new-line [ group ]")))

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

(defthm cst-else-group-branches-match-alt
 (implies
  (cst-matchp abnf::cst "else-group")
  (cst-list-list-alt-matchp (abnf::tree-nonleaf->branches abnf::cst)
                            "\"#\" %s\"else\" new-line [ group ]")))

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

(defthm cst-endif-line-branches-match-alt
 (implies
  (cst-matchp abnf::cst "endif-line")
  (cst-list-list-alt-matchp (abnf::tree-nonleaf->branches abnf::cst)
                            "\"#\" %s\"endif\" new-line")))

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

(defthm cst-control-line-branches-match-alt
 (implies
  (cst-matchp abnf::cst "control-line")
  (cst-list-list-alt-matchp
   (abnf::tree-nonleaf->branches abnf::cst)
   "\"#\" %s\"include\" pp-tokens new-line / \"#\" %s\"define\" identifier replacement-list new-line / \"#\" %s\"define\" identifier lparen [ identifier-list ] \")\" replacement-list new-line / \"#\" %s\"define\" identifier lparen \"...\" \")\" replacement-list new-line / \"#\" %s\"define\" identifier lparen identifier-list \",\" \"...\" \")\" replacement-list new-line / \"#\" %s\"undef\" identifier new-line / \"#\" %s\"line\" pp-tokens new-line / \"#\" %s\"error\" [ pp-tokens ] new-line / \"#\" %s\"pragma\" [ pp-tokens ] new-line / \"#\" new-line")))

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

(defthm cst-text-line-branches-match-alt
 (implies
  (cst-matchp abnf::cst "text-line")
  (cst-list-list-alt-matchp (abnf::tree-nonleaf->branches abnf::cst)
                            "[ pp-tokens ] new-line")))

Theorem: cst-non-directive-branches-match-alt

(defthm cst-non-directive-branches-match-alt
 (implies
  (cst-matchp abnf::cst "non-directive")
  (cst-list-list-alt-matchp (abnf::tree-nonleaf->branches abnf::cst)
                            "pp-tokens new-line")))

Theorem: cst-lparen-branches-match-alt

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

Theorem: cst-replacement-list-branches-match-alt

(defthm cst-replacement-list-branches-match-alt
 (implies
  (cst-matchp abnf::cst "replacement-list")
  (cst-list-list-alt-matchp (abnf::tree-nonleaf->branches abnf::cst)
                            "[ pp-tokens ]")))

Theorem: cst-pp-tokens-branches-match-alt

(defthm cst-pp-tokens-branches-match-alt
  (implies
       (cst-matchp abnf::cst "pp-tokens")
       (cst-list-list-alt-matchp
            (abnf::tree-nonleaf->branches abnf::cst)
            "preprocessing-token / pp-tokens preprocessing-token")))

Theorem: cst-on-off-switch-branches-match-alt

(defthm cst-on-off-switch-branches-match-alt
 (implies
  (cst-matchp abnf::cst "on-off-switch")
  (cst-list-list-alt-matchp (abnf::tree-nonleaf->branches abnf::cst)
                            "%s\"ON\" / %s\"OFF\" / %s\"DEFAULT\"")))

Theorem: cst-uppercase-letter-concs

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

Theorem: cst-lowercase-letter-concs

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

Theorem: cst-letter-concs

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

Theorem: cst-digit-concs

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

Theorem: cst-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-graphic-character-concs

(defthm cst-graphic-character-concs
  (implies (cst-list-list-alt-matchp
                abnf::cstss
                "%x21-23 / %x25-2F / %x3A-3F / %x5B-5F / %x7B-7E")
           (or (cst-list-list-conc-matchp abnf::cstss "%x21-23")
               (cst-list-list-conc-matchp abnf::cstss "%x25-2F")
               (cst-list-list-conc-matchp abnf::cstss "%x3A-3F")
               (cst-list-list-conc-matchp abnf::cstss "%x5B-5F")
               (cst-list-list-conc-matchp abnf::cstss "%x7B-7E"))))

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-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-vertical-tab-concs

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

Theorem: cst-form-feed-concs

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

Theorem: cst-control-character-concs

(defthm cst-control-character-concs
  (implies
       (cst-list-list-alt-matchp
            abnf::cstss
            "horizontal-tab / vertical-tab / form-feed")
       (or (cst-list-list-conc-matchp abnf::cstss "horizontal-tab")
           (cst-list-list-conc-matchp abnf::cstss "vertical-tab")
           (cst-list-list-conc-matchp abnf::cstss "form-feed"))))

Theorem: cst-basic-character-concs

(defthm cst-basic-character-concs
 (implies
  (cst-list-list-alt-matchp
   abnf::cstss
   "letter / digit / graphic-character / space / control-character")
  (or (cst-list-list-conc-matchp abnf::cstss "letter")
      (cst-list-list-conc-matchp abnf::cstss "digit")
      (cst-list-list-conc-matchp abnf::cstss "graphic-character")
      (cst-list-list-conc-matchp abnf::cstss "space")
      (cst-list-list-conc-matchp abnf::cstss "control-character"))))

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-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-extended-character-concs

(defthm cst-extended-character-concs
 (implies
  (cst-list-list-alt-matchp
   abnf::cstss
   "%x24 / %x40 / %x60 / line-feed / carriage-return / safe-nonascii")
  (or (cst-list-list-conc-matchp abnf::cstss "%x24")
      (cst-list-list-conc-matchp abnf::cstss "%x40")
      (cst-list-list-conc-matchp abnf::cstss "%x60")
      (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 "safe-nonascii"))))

Theorem: cst-character-concs

(defthm cst-character-concs
 (implies
  (cst-list-list-alt-matchp abnf::cstss
                            "basic-character / extended-character")
  (or
     (cst-list-list-conc-matchp abnf::cstss "basic-character")
     (cst-list-list-conc-matchp abnf::cstss "extended-character"))))

Theorem: cst-new-line-concs

(defthm cst-new-line-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-extended-character-not-new-line-concs

(defthm cst-extended-character-not-new-line-concs
 (implies
     (cst-list-list-alt-matchp abnf::cstss
                               "%x24 / %x40 / %x60 / safe-nonascii")
     (or (cst-list-list-conc-matchp abnf::cstss "%x24")
         (cst-list-list-conc-matchp abnf::cstss "%x40")
         (cst-list-list-conc-matchp abnf::cstss "%x60")
         (cst-list-list-conc-matchp abnf::cstss "safe-nonascii"))))

Theorem: cst-graphic-character-not-star-concs

(defthm cst-graphic-character-not-star-concs
 (implies
   (cst-list-list-alt-matchp
        abnf::cstss
        "%x21-23 / %x25-29 / %x2B-2F / %x3A-3F / %x5B-5F / %x7B-7E")
   (or (cst-list-list-conc-matchp abnf::cstss "%x21-23")
       (cst-list-list-conc-matchp abnf::cstss "%x25-29")
       (cst-list-list-conc-matchp abnf::cstss "%x2B-2F")
       (cst-list-list-conc-matchp abnf::cstss "%x3A-3F")
       (cst-list-list-conc-matchp abnf::cstss "%x5B-5F")
       (cst-list-list-conc-matchp abnf::cstss "%x7B-7E"))))

Theorem: cst-graphic-character-not-greater-than-concs

(defthm cst-graphic-character-not-greater-than-concs
 (implies
      (cst-list-list-alt-matchp
           abnf::cstss
           "%x21-23 / %x25-2F / %x3A-3D / %x3F / %x5B-5F / %x7B-7E")
      (or (cst-list-list-conc-matchp abnf::cstss "%x21-23")
          (cst-list-list-conc-matchp abnf::cstss "%x25-2F")
          (cst-list-list-conc-matchp abnf::cstss "%x3A-3D")
          (cst-list-list-conc-matchp abnf::cstss "%x3F")
          (cst-list-list-conc-matchp abnf::cstss "%x5B-5F")
          (cst-list-list-conc-matchp abnf::cstss "%x7B-7E"))))

Theorem: cst-graphic-character-not-double-quote-concs

(defthm cst-graphic-character-not-double-quote-concs
  (implies
       (cst-list-list-alt-matchp
            abnf::cstss
            "%x21 / %x23 / %x25-2F / %x3A-3F / %x5B-5F / %x7B-7E")
       (or (cst-list-list-conc-matchp abnf::cstss "%x21")
           (cst-list-list-conc-matchp abnf::cstss "%x23")
           (cst-list-list-conc-matchp abnf::cstss "%x25-2F")
           (cst-list-list-conc-matchp abnf::cstss "%x3A-3F")
           (cst-list-list-conc-matchp abnf::cstss "%x5B-5F")
           (cst-list-list-conc-matchp abnf::cstss "%x7B-7E"))))

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

(defthm cst-graphic-character-not-star-or-slash-concs
 (implies
   (cst-list-list-alt-matchp
        abnf::cstss
        "%x21-23 / %x25-29 / %x2B-2E / %x3A-3F / %x5B-5F / %x7B-7E")
   (or (cst-list-list-conc-matchp abnf::cstss "%x21-23")
       (cst-list-list-conc-matchp abnf::cstss "%x25-29")
       (cst-list-list-conc-matchp abnf::cstss "%x2B-2E")
       (cst-list-list-conc-matchp abnf::cstss "%x3A-3F")
       (cst-list-list-conc-matchp abnf::cstss "%x5B-5F")
       (cst-list-list-conc-matchp abnf::cstss "%x7B-7E"))))

Theorem: cst-graphic-character-not-single-quote-or-backslash-concs

(defthm cst-graphic-character-not-single-quote-or-backslash-concs
 (implies
  (cst-list-list-alt-matchp
   abnf::cstss
   "%x21-23 / %x25-26 / %x28-2F / %x3A-3F / %x5B / %x5D-5F / %x7B-7E")
  (or (cst-list-list-conc-matchp abnf::cstss "%x21-23")
      (cst-list-list-conc-matchp abnf::cstss "%x25-26")
      (cst-list-list-conc-matchp abnf::cstss "%x28-2F")
      (cst-list-list-conc-matchp abnf::cstss "%x3A-3F")
      (cst-list-list-conc-matchp abnf::cstss "%x5B")
      (cst-list-list-conc-matchp abnf::cstss "%x5D-5F")
      (cst-list-list-conc-matchp abnf::cstss "%x7B-7E"))))

Theorem: cst-graphic-character-not-double-quote-or-backslash-concs

(defthm cst-graphic-character-not-double-quote-or-backslash-concs
 (implies
  (cst-list-list-alt-matchp
       abnf::cstss
       "%x21 / %x23 / %x25-2F / %x3A-3F / %x5B / %x5D-5F / %x7B-7E")
  (or (cst-list-list-conc-matchp abnf::cstss "%x21")
      (cst-list-list-conc-matchp abnf::cstss "%x23")
      (cst-list-list-conc-matchp abnf::cstss "%x25-2F")
      (cst-list-list-conc-matchp abnf::cstss "%x3A-3F")
      (cst-list-list-conc-matchp abnf::cstss "%x5B")
      (cst-list-list-conc-matchp abnf::cstss "%x5D-5F")
      (cst-list-list-conc-matchp abnf::cstss "%x7B-7E"))))

Theorem: cst-basic-character-not-star-concs

(defthm cst-basic-character-not-star-concs
 (implies
  (cst-list-list-alt-matchp
   abnf::cstss
   "letter / digit / graphic-character-not-star / space / control-character")
  (or (cst-list-list-conc-matchp abnf::cstss "letter")
      (cst-list-list-conc-matchp abnf::cstss "digit")
      (cst-list-list-conc-matchp abnf::cstss
                                 "graphic-character-not-star")
      (cst-list-list-conc-matchp abnf::cstss "space")
      (cst-list-list-conc-matchp abnf::cstss "control-character"))))

Theorem: cst-basic-character-not-greater-than-concs

(defthm cst-basic-character-not-greater-than-concs
 (implies
  (cst-list-list-alt-matchp
   abnf::cstss
   "letter / digit / graphic-character-not-greater-than / space / control-character")
  (or
    (cst-list-list-conc-matchp abnf::cstss "letter")
    (cst-list-list-conc-matchp abnf::cstss "digit")
    (cst-list-list-conc-matchp abnf::cstss
                               "graphic-character-not-greater-than")
    (cst-list-list-conc-matchp abnf::cstss "space")
    (cst-list-list-conc-matchp abnf::cstss "control-character"))))

Theorem: cst-basic-character-not-double-quote-concs

(defthm cst-basic-character-not-double-quote-concs
 (implies
  (cst-list-list-alt-matchp
   abnf::cstss
   "letter / digit / graphic-character-not-double-quote / space / control-character")
  (or
    (cst-list-list-conc-matchp abnf::cstss "letter")
    (cst-list-list-conc-matchp abnf::cstss "digit")
    (cst-list-list-conc-matchp abnf::cstss
                               "graphic-character-not-double-quote")
    (cst-list-list-conc-matchp abnf::cstss "space")
    (cst-list-list-conc-matchp abnf::cstss "control-character"))))

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

(defthm cst-basic-character-not-star-or-slash-concs
 (implies
  (cst-list-list-alt-matchp
   abnf::cstss
   "letter / digit / graphic-character-not-star-or-slash / space / control-character")
  (or
   (cst-list-list-conc-matchp abnf::cstss "letter")
   (cst-list-list-conc-matchp abnf::cstss "digit")
   (cst-list-list-conc-matchp abnf::cstss
                              "graphic-character-not-star-or-slash")
   (cst-list-list-conc-matchp abnf::cstss "space")
   (cst-list-list-conc-matchp abnf::cstss "control-character"))))

Theorem: cst-basic-character-not-single-quote-or-backslash-concs

(defthm cst-basic-character-not-single-quote-or-backslash-concs
 (implies
  (cst-list-list-alt-matchp
   abnf::cstss
   "letter / digit / graphic-character-not-single-quote-or-backslash / space / control-character")
  (or (cst-list-list-conc-matchp abnf::cstss "letter")
      (cst-list-list-conc-matchp abnf::cstss "digit")
      (cst-list-list-conc-matchp
           abnf::cstss
           "graphic-character-not-single-quote-or-backslash")
      (cst-list-list-conc-matchp abnf::cstss "space")
      (cst-list-list-conc-matchp abnf::cstss "control-character"))))

Theorem: cst-basic-character-not-double-quote-or-backslash-concs

(defthm cst-basic-character-not-double-quote-or-backslash-concs
 (implies
  (cst-list-list-alt-matchp
   abnf::cstss
   "letter / digit / graphic-character-not-double-quote-or-backslash / space / control-character")
  (or (cst-list-list-conc-matchp abnf::cstss "letter")
      (cst-list-list-conc-matchp abnf::cstss "digit")
      (cst-list-list-conc-matchp
           abnf::cstss
           "graphic-character-not-double-quote-or-backslash")
      (cst-list-list-conc-matchp abnf::cstss "space")
      (cst-list-list-conc-matchp abnf::cstss "control-character"))))

Theorem: cst-character-not-new-line-concs

(defthm cst-character-not-new-line-concs
 (implies
  (cst-list-list-alt-matchp
       abnf::cstss
       "basic-character / extended-character-not-new-line")
  (or
    (cst-list-list-conc-matchp abnf::cstss "basic-character")
    (cst-list-list-conc-matchp abnf::cstss
                               "extended-character-not-new-line"))))

Theorem: cst-character-not-star-concs

(defthm cst-character-not-star-concs
 (implies
  (cst-list-list-alt-matchp
       abnf::cstss
       "basic-character-not-star / extended-character")
  (or
     (cst-list-list-conc-matchp
          abnf::cstss "basic-character-not-star")
     (cst-list-list-conc-matchp abnf::cstss "extended-character"))))

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

(defthm cst-character-not-star-or-slash-concs
 (implies
  (cst-list-list-alt-matchp
       abnf::cstss
       "basic-character-not-star-or-slash / extended-character")
  (or
     (cst-list-list-conc-matchp abnf::cstss
                                "basic-character-not-star-or-slash")
     (cst-list-list-conc-matchp abnf::cstss "extended-character"))))

Theorem: cst-character-not-greater-than-or-new-line-concs

(defthm cst-character-not-greater-than-or-new-line-concs
 (implies
  (cst-list-list-alt-matchp
   abnf::cstss
   "basic-character-not-greater-than / extended-character-not-new-line")
  (or
    (cst-list-list-conc-matchp abnf::cstss
                               "basic-character-not-greater-than")
    (cst-list-list-conc-matchp abnf::cstss
                               "extended-character-not-new-line"))))

Theorem: cst-character-not-double-quote-or-new-line-concs

(defthm cst-character-not-double-quote-or-new-line-concs
 (implies
  (cst-list-list-alt-matchp
   abnf::cstss
   "basic-character-not-double-quote / extended-character-not-new-line")
  (or
    (cst-list-list-conc-matchp abnf::cstss
                               "basic-character-not-double-quote")
    (cst-list-list-conc-matchp abnf::cstss
                               "extended-character-not-new-line"))))

Theorem: cst-character-not-single-quote-or-backslash-or-new-line-concs

(defthm
      cst-character-not-single-quote-or-backslash-or-new-line-concs
 (implies
  (cst-list-list-alt-matchp
   abnf::cstss
   "basic-character-not-single-quote-or-backslash / extended-character-not-new-line")
  (or
    (cst-list-list-conc-matchp
         abnf::cstss
         "basic-character-not-single-quote-or-backslash")
    (cst-list-list-conc-matchp abnf::cstss
                               "extended-character-not-new-line"))))

Theorem: cst-character-not-double-quote-or-backslash-or-new-line-concs

(defthm
      cst-character-not-double-quote-or-backslash-or-new-line-concs
 (implies
  (cst-list-list-alt-matchp
   abnf::cstss
   "basic-character-not-double-quote-or-backslash / extended-character-not-new-line")
  (or
    (cst-list-list-conc-matchp
         abnf::cstss
         "basic-character-not-double-quote-or-backslash")
    (cst-list-list-conc-matchp abnf::cstss
                               "extended-character-not-new-line"))))

Theorem: cst-white-space-concs

(defthm cst-white-space-concs
 (implies
  (cst-list-list-alt-matchp
     abnf::cstss
     "space / horizontal-tab / vertical-tab / form-feed / new-line")
  (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 "vertical-tab")
      (cst-list-list-conc-matchp abnf::cstss "form-feed")
      (cst-list-list-conc-matchp abnf::cstss "new-line"))))

Theorem: cst-header-name-concs

(defthm cst-header-name-concs
 (implies
  (cst-list-list-alt-matchp
   abnf::cstss
   "\"<\" h-char-sequence \">\" / double-quote q-char-sequence double-quote")
  (or
   (cst-list-list-conc-matchp abnf::cstss "\"<\" h-char-sequence \">\"")
   (cst-list-list-conc-matchp
        abnf::cstss
        "double-quote q-char-sequence double-quote"))))

Theorem: cst-h-char-sequence-concs

(defthm cst-h-char-sequence-concs
  (implies
       (cst-list-list-alt-matchp abnf::cstss
                                 "h-char / h-char-sequence h-char")
       (or (cst-list-list-conc-matchp abnf::cstss "h-char")
           (cst-list-list-conc-matchp
                abnf::cstss "h-char-sequence h-char"))))

Theorem: cst-h-char-concs

(defthm cst-h-char-concs
  (implies (cst-list-list-alt-matchp
                abnf::cstss
                "character-not-greater-than-or-new-line")
           (or (cst-list-list-conc-matchp
                    abnf::cstss
                    "character-not-greater-than-or-new-line"))))

Theorem: cst-q-char-sequence-concs

(defthm cst-q-char-sequence-concs
  (implies
       (cst-list-list-alt-matchp abnf::cstss
                                 "q-char / q-char-sequence q-char")
       (or (cst-list-list-conc-matchp abnf::cstss "q-char")
           (cst-list-list-conc-matchp
                abnf::cstss "q-char-sequence q-char"))))

Theorem: cst-q-char-concs

(defthm cst-q-char-concs
  (implies (cst-list-list-alt-matchp
                abnf::cstss
                "character-not-double-quote-or-new-line")
           (or (cst-list-list-conc-matchp
                    abnf::cstss
                    "character-not-double-quote-or-new-line"))))

Theorem: cst-pp-number-concs

(defthm cst-pp-number-concs
 (implies
  (cst-list-list-alt-matchp
   abnf::cstss
   "digit / \".\" digit / pp-number digit / pp-number identifier-nondigit / pp-number %i\"e\" sign / pp-number %i\"p\" sign / pp-number \".\"")
  (or (cst-list-list-conc-matchp abnf::cstss "digit")
      (cst-list-list-conc-matchp abnf::cstss "\".\" digit")
      (cst-list-list-conc-matchp abnf::cstss "pp-number digit")
      (cst-list-list-conc-matchp abnf::cstss
                                 "pp-number identifier-nondigit")
      (cst-list-list-conc-matchp abnf::cstss "pp-number %i\"e\" sign")
      (cst-list-list-conc-matchp abnf::cstss "pp-number %i\"p\" sign")
      (cst-list-list-conc-matchp abnf::cstss "pp-number \".\""))))

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 / character-not-star rest-of-block-comment")
  (or (cst-list-list-conc-matchp
           abnf::cstss
           "\"*\" rest-of-block-comment-after-star")
      (cst-list-list-conc-matchp
           abnf::cstss
           "character-not-star 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 / character-not-star-or-slash rest-of-block-comment")
  (or (cst-list-list-conc-matchp abnf::cstss "\"/\"")
      (cst-list-list-conc-matchp
           abnf::cstss
           "\"*\" rest-of-block-comment-after-star")
      (cst-list-list-conc-matchp
           abnf::cstss
           "character-not-star-or-slash rest-of-block-comment"))))

Theorem: cst-line-comment-concs

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

Theorem: cst-token-concs

(defthm cst-token-concs
 (implies
  (cst-list-list-alt-matchp
    abnf::cstss
    "keyword / identifier / constant / string-literal / punctuator")
  (or (cst-list-list-conc-matchp abnf::cstss "keyword")
      (cst-list-list-conc-matchp abnf::cstss "identifier")
      (cst-list-list-conc-matchp abnf::cstss "constant")
      (cst-list-list-conc-matchp abnf::cstss "string-literal")
      (cst-list-list-conc-matchp abnf::cstss "punctuator"))))

Theorem: cst-preprocessing-token-concs

(defthm cst-preprocessing-token-concs
 (implies
  (cst-list-list-alt-matchp
   abnf::cstss
   "header-name / identifier / pp-number / character-constant / string-literal / punctuator / character")
  (or (cst-list-list-conc-matchp abnf::cstss "header-name")
      (cst-list-list-conc-matchp abnf::cstss "identifier")
      (cst-list-list-conc-matchp abnf::cstss "pp-number")
      (cst-list-list-conc-matchp abnf::cstss "character-constant")
      (cst-list-list-conc-matchp abnf::cstss "string-literal")
      (cst-list-list-conc-matchp abnf::cstss "punctuator")
      (cst-list-list-conc-matchp abnf::cstss "character"))))

Theorem: cst-keyword-concs

(defthm cst-keyword-concs
 (implies
  (cst-list-list-alt-matchp
   abnf::cstss
   "%s\"auto\" / %s\"bool\" / %s\"break\" / %s\"case\" / %s\"char\" / %s\"const\" / %s\"continue\" / %s\"default\" / %s\"do\" / %s\"double\" / %s\"else\" / %s\"enum\" / %s\"extern\" / %s\"false\" / %s\"float\" / %s\"for\" / %s\"goto\" / %s\"if\" / %s\"inline\" / %s\"int\" / %s\"long\" / %s\"register\" / %s\"restrict\" / %s\"return\" / %s\"short\" / %s\"signed\" / %s\"sizeof\" / %s\"static\" / %s\"struct\" / %s\"switch\" / %s\"true\" / %s\"typedef\" / %s\"union\" / %s\"unsigned\" / %s\"void\" / %s\"volatile\" / %s\"while\" / %s\"_Alignas\" / %s\"_Alignof\" / %s\"_Atomic\" / %s\"_Bool\" / %s\"_Complex\" / %s\"_Generic\" / %s\"_Imaginary\" / %s\"_Noreturn\" / %s\"_Static_assert\" / %s\"_Thread_local\"")
  (or (cst-list-list-conc-matchp abnf::cstss "%s\"auto\"")
      (cst-list-list-conc-matchp abnf::cstss "%s\"bool\"")
      (cst-list-list-conc-matchp abnf::cstss "%s\"break\"")
      (cst-list-list-conc-matchp abnf::cstss "%s\"case\"")
      (cst-list-list-conc-matchp abnf::cstss "%s\"char\"")
      (cst-list-list-conc-matchp abnf::cstss "%s\"const\"")
      (cst-list-list-conc-matchp abnf::cstss "%s\"continue\"")
      (cst-list-list-conc-matchp abnf::cstss "%s\"default\"")
      (cst-list-list-conc-matchp abnf::cstss "%s\"do\"")
      (cst-list-list-conc-matchp abnf::cstss "%s\"double\"")
      (cst-list-list-conc-matchp abnf::cstss "%s\"else\"")
      (cst-list-list-conc-matchp abnf::cstss "%s\"enum\"")
      (cst-list-list-conc-matchp abnf::cstss "%s\"extern\"")
      (cst-list-list-conc-matchp abnf::cstss "%s\"false\"")
      (cst-list-list-conc-matchp abnf::cstss "%s\"float\"")
      (cst-list-list-conc-matchp abnf::cstss "%s\"for\"")
      (cst-list-list-conc-matchp abnf::cstss "%s\"goto\"")
      (cst-list-list-conc-matchp abnf::cstss "%s\"if\"")
      (cst-list-list-conc-matchp abnf::cstss "%s\"inline\"")
      (cst-list-list-conc-matchp abnf::cstss "%s\"int\"")
      (cst-list-list-conc-matchp abnf::cstss "%s\"long\"")
      (cst-list-list-conc-matchp abnf::cstss "%s\"register\"")
      (cst-list-list-conc-matchp abnf::cstss "%s\"restrict\"")
      (cst-list-list-conc-matchp abnf::cstss "%s\"return\"")
      (cst-list-list-conc-matchp abnf::cstss "%s\"short\"")
      (cst-list-list-conc-matchp abnf::cstss "%s\"signed\"")
      (cst-list-list-conc-matchp abnf::cstss "%s\"sizeof\"")
      (cst-list-list-conc-matchp abnf::cstss "%s\"static\"")
      (cst-list-list-conc-matchp abnf::cstss "%s\"struct\"")
      (cst-list-list-conc-matchp abnf::cstss "%s\"switch\"")
      (cst-list-list-conc-matchp abnf::cstss "%s\"true\"")
      (cst-list-list-conc-matchp abnf::cstss "%s\"typedef\"")
      (cst-list-list-conc-matchp abnf::cstss "%s\"union\"")
      (cst-list-list-conc-matchp abnf::cstss "%s\"unsigned\"")
      (cst-list-list-conc-matchp abnf::cstss "%s\"void\"")
      (cst-list-list-conc-matchp abnf::cstss "%s\"volatile\"")
      (cst-list-list-conc-matchp abnf::cstss "%s\"while\"")
      (cst-list-list-conc-matchp abnf::cstss "%s\"_Alignas\"")
      (cst-list-list-conc-matchp abnf::cstss "%s\"_Alignof\"")
      (cst-list-list-conc-matchp abnf::cstss "%s\"_Atomic\"")
      (cst-list-list-conc-matchp abnf::cstss "%s\"_Bool\"")
      (cst-list-list-conc-matchp abnf::cstss "%s\"_Complex\"")
      (cst-list-list-conc-matchp abnf::cstss "%s\"_Generic\"")
      (cst-list-list-conc-matchp abnf::cstss "%s\"_Imaginary\"")
      (cst-list-list-conc-matchp abnf::cstss "%s\"_Noreturn\"")
      (cst-list-list-conc-matchp abnf::cstss "%s\"_Static_assert\"")
      (cst-list-list-conc-matchp abnf::cstss "%s\"_Thread_local\""))))

Theorem: cst-gcc-keyword-concs

(defthm cst-gcc-keyword-concs
 (implies
  (cst-list-list-alt-matchp
   abnf::cstss
   "%s\"__alignof\" / %s\"__alignof__\" / %s\"asm\" / %s\"__asm\" / %s\"__asm__\" / %s\"__attribute\" / %s\"__attribute__\" / %s\"__auto_type\" / %s\"__builtin_offsetof\" / %s\"__builtin_types_compatible_p\" / %s\"__builtin_va_list\" / %s\"__declspec\" / %s\"__extension__\" / %s\"__float80\" / %s\"__float128\" / %s\"_Float16\" / %s\"_Float16x\" / %s\"_Float32\" / %s\"_Float32x\" / %s\"_Float64\" / %s\"_Float64x\" / %s\"_Float128\" / %s\"_Float128x\" / %s\"__imag__\" / %s\"__inline\" / %s\"__inline__\" / %s\"__int128\" / %s\"__int128_t\" / %s\"__label__\" / %s\"__real__\" / %s\"__restrict\" / %s\"__restrict__\" / %s\"__signed\" / %s\"__signed__\" / %s\"__stdcall\" / %s\"typeof\" / %s\"__typeof\" / %s\"__typeof__\" / %s\"__volatile\" / %s\"__volatile__\"")
  (or
    (cst-list-list-conc-matchp abnf::cstss "%s\"__alignof\"")
    (cst-list-list-conc-matchp abnf::cstss "%s\"__alignof__\"")
    (cst-list-list-conc-matchp abnf::cstss "%s\"asm\"")
    (cst-list-list-conc-matchp abnf::cstss "%s\"__asm\"")
    (cst-list-list-conc-matchp abnf::cstss "%s\"__asm__\"")
    (cst-list-list-conc-matchp abnf::cstss "%s\"__attribute\"")
    (cst-list-list-conc-matchp abnf::cstss "%s\"__attribute__\"")
    (cst-list-list-conc-matchp abnf::cstss "%s\"__auto_type\"")
    (cst-list-list-conc-matchp abnf::cstss "%s\"__builtin_offsetof\"")
    (cst-list-list-conc-matchp abnf::cstss
                               "%s\"__builtin_types_compatible_p\"")
    (cst-list-list-conc-matchp abnf::cstss "%s\"__builtin_va_list\"")
    (cst-list-list-conc-matchp abnf::cstss "%s\"__declspec\"")
    (cst-list-list-conc-matchp abnf::cstss "%s\"__extension__\"")
    (cst-list-list-conc-matchp abnf::cstss "%s\"__float80\"")
    (cst-list-list-conc-matchp abnf::cstss "%s\"__float128\"")
    (cst-list-list-conc-matchp abnf::cstss "%s\"_Float16\"")
    (cst-list-list-conc-matchp abnf::cstss "%s\"_Float16x\"")
    (cst-list-list-conc-matchp abnf::cstss "%s\"_Float32\"")
    (cst-list-list-conc-matchp abnf::cstss "%s\"_Float32x\"")
    (cst-list-list-conc-matchp abnf::cstss "%s\"_Float64\"")
    (cst-list-list-conc-matchp abnf::cstss "%s\"_Float64x\"")
    (cst-list-list-conc-matchp abnf::cstss "%s\"_Float128\"")
    (cst-list-list-conc-matchp abnf::cstss "%s\"_Float128x\"")
    (cst-list-list-conc-matchp abnf::cstss "%s\"__imag__\"")
    (cst-list-list-conc-matchp abnf::cstss "%s\"__inline\"")
    (cst-list-list-conc-matchp abnf::cstss "%s\"__inline__\"")
    (cst-list-list-conc-matchp abnf::cstss "%s\"__int128\"")
    (cst-list-list-conc-matchp abnf::cstss "%s\"__int128_t\"")
    (cst-list-list-conc-matchp abnf::cstss "%s\"__label__\"")
    (cst-list-list-conc-matchp abnf::cstss "%s\"__real__\"")
    (cst-list-list-conc-matchp abnf::cstss "%s\"__restrict\"")
    (cst-list-list-conc-matchp abnf::cstss "%s\"__restrict__\"")
    (cst-list-list-conc-matchp abnf::cstss "%s\"__signed\"")
    (cst-list-list-conc-matchp abnf::cstss "%s\"__signed__\"")
    (cst-list-list-conc-matchp abnf::cstss "%s\"__stdcall\"")
    (cst-list-list-conc-matchp abnf::cstss "%s\"typeof\"")
    (cst-list-list-conc-matchp abnf::cstss "%s\"__typeof\"")
    (cst-list-list-conc-matchp abnf::cstss "%s\"__typeof__\"")
    (cst-list-list-conc-matchp abnf::cstss "%s\"__volatile\"")
    (cst-list-list-conc-matchp abnf::cstss "%s\"__volatile__\""))))

Theorem: cst-alignof-keyword-concs

(defthm cst-alignof-keyword-concs
 (implies
    (cst-list-list-alt-matchp
         abnf::cstss
         "%s\"_Alignof\" / %s\"__alignof\" / %s\"__alignof__\"")
    (or (cst-list-list-conc-matchp abnf::cstss "%s\"_Alignof\"")
        (cst-list-list-conc-matchp abnf::cstss "%s\"__alignof\"")
        (cst-list-list-conc-matchp abnf::cstss "%s\"__alignof__\""))))

Theorem: cst-asm-keyword-concs

(defthm cst-asm-keyword-concs
 (implies
      (cst-list-list-alt-matchp abnf::cstss
                                "%s\"asm\" / %s\"__asm\" / %s\"__asm__\"")
      (or (cst-list-list-conc-matchp abnf::cstss "%s\"asm\"")
          (cst-list-list-conc-matchp abnf::cstss "%s\"__asm\"")
          (cst-list-list-conc-matchp abnf::cstss "%s\"__asm__\""))))

Theorem: cst-attribute-keyword-concs

(defthm cst-attribute-keyword-concs
 (implies
  (cst-list-list-alt-matchp abnf::cstss
                            "%s\"__attribute\" / %s\"__attribute__\"")
  (or (cst-list-list-conc-matchp abnf::cstss "%s\"__attribute\"")
      (cst-list-list-conc-matchp abnf::cstss "%s\"__attribute__\""))))

Theorem: cst-inline-keyword-concs

(defthm cst-inline-keyword-concs
 (implies
     (cst-list-list-alt-matchp
          abnf::cstss
          "%s\"inline\" / %s\"__inline\" / %s\"__inline__\"")
     (or (cst-list-list-conc-matchp abnf::cstss "%s\"inline\"")
         (cst-list-list-conc-matchp abnf::cstss "%s\"__inline\"")
         (cst-list-list-conc-matchp abnf::cstss "%s\"__inline__\""))))

Theorem: cst-restrict-keyword-concs

(defthm cst-restrict-keyword-concs
 (implies
   (cst-list-list-alt-matchp
        abnf::cstss
        "%s\"restrict\" / %s\"__restrict\" / %s\"__restrict__\"")
   (or (cst-list-list-conc-matchp abnf::cstss "%s\"restrict\"")
       (cst-list-list-conc-matchp abnf::cstss "%s\"__restrict\"")
       (cst-list-list-conc-matchp abnf::cstss "%s\"__restrict__\""))))

Theorem: cst-signed-keyword-concs

(defthm cst-signed-keyword-concs
 (implies
     (cst-list-list-alt-matchp
          abnf::cstss
          "%s\"signed\" / %s\"__signed\" / %s\"__signed__\"")
     (or (cst-list-list-conc-matchp abnf::cstss "%s\"signed\"")
         (cst-list-list-conc-matchp abnf::cstss "%s\"__signed\"")
         (cst-list-list-conc-matchp abnf::cstss "%s\"__signed__\""))))

Theorem: cst-typeof-keyword-concs

(defthm cst-typeof-keyword-concs
 (implies
     (cst-list-list-alt-matchp
          abnf::cstss
          "%s\"typeof\" / %s\"__typeof\" / %s\"__typeof__\"")
     (or (cst-list-list-conc-matchp abnf::cstss "%s\"typeof\"")
         (cst-list-list-conc-matchp abnf::cstss "%s\"__typeof\"")
         (cst-list-list-conc-matchp abnf::cstss "%s\"__typeof__\""))))

Theorem: cst-volatile-keyword-concs

(defthm cst-volatile-keyword-concs
 (implies
   (cst-list-list-alt-matchp
        abnf::cstss
        "%s\"volatile\" / %s\"__volatile\" / %s\"__volatile__\"")
   (or (cst-list-list-conc-matchp abnf::cstss "%s\"volatile\"")
       (cst-list-list-conc-matchp abnf::cstss "%s\"__volatile\"")
       (cst-list-list-conc-matchp abnf::cstss "%s\"__volatile__\""))))

Theorem: cst-identifier-concs

(defthm cst-identifier-concs
 (implies
  (cst-list-list-alt-matchp
   abnf::cstss
   "identifier-nondigit / identifier identifier-nondigit / identifier digit")
  (or (cst-list-list-conc-matchp abnf::cstss "identifier-nondigit")
      (cst-list-list-conc-matchp abnf::cstss
                                 "identifier identifier-nondigit")
      (cst-list-list-conc-matchp abnf::cstss "identifier digit"))))

Theorem: cst-identifier-nondigit-concs

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

Theorem: cst-nondigit-concs

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

Theorem: cst-universal-character-name-concs

(defthm cst-universal-character-name-concs
  (implies
       (cst-list-list-alt-matchp
            abnf::cstss
            "%s\"\\u\" hex-quad / %s\"\\U\" hex-quad hex-quad")
       (or (cst-list-list-conc-matchp abnf::cstss "%s\"\\u\" hex-quad")
           (cst-list-list-conc-matchp abnf::cstss
                                      "%s\"\\U\" hex-quad hex-quad"))))

Theorem: cst-hex-quad-concs

(defthm cst-hex-quad-concs
 (implies
  (cst-list-list-alt-matchp
   abnf::cstss
   "hexadecimal-digit hexadecimal-digit hexadecimal-digit hexadecimal-digit")
  (or
   (cst-list-list-conc-matchp
    abnf::cstss
    "hexadecimal-digit hexadecimal-digit hexadecimal-digit hexadecimal-digit"))))

Theorem: cst-constant-concs

(defthm cst-constant-concs
 (implies
  (cst-list-list-alt-matchp
   abnf::cstss
   "integer-constant / floating-constant / enumeration-constant / character-constant")
  (or
     (cst-list-list-conc-matchp abnf::cstss "integer-constant")
     (cst-list-list-conc-matchp abnf::cstss "floating-constant")
     (cst-list-list-conc-matchp abnf::cstss "enumeration-constant")
     (cst-list-list-conc-matchp abnf::cstss "character-constant"))))

Theorem: cst-integer-constant-concs

(defthm cst-integer-constant-concs
 (implies
  (cst-list-list-alt-matchp
   abnf::cstss
   "decimal-constant [ integer-suffix ] / octal-constant [ integer-suffix ] / hexadecimal-constant [ integer-suffix ]")
  (or
   (cst-list-list-conc-matchp abnf::cstss
                              "decimal-constant [ integer-suffix ]")
   (cst-list-list-conc-matchp abnf::cstss
                              "octal-constant [ integer-suffix ]")
   (cst-list-list-conc-matchp
        abnf::cstss
        "hexadecimal-constant [ integer-suffix ]"))))

Theorem: cst-decimal-constant-concs

(defthm cst-decimal-constant-concs
  (implies
       (cst-list-list-alt-matchp
            abnf::cstss
            "nonzero-digit / decimal-constant digit")
       (or (cst-list-list-conc-matchp abnf::cstss "nonzero-digit")
           (cst-list-list-conc-matchp
                abnf::cstss "decimal-constant digit"))))

Theorem: cst-octal-constant-concs

(defthm cst-octal-constant-concs
 (implies
     (cst-list-list-alt-matchp abnf::cstss
                               "\"0\" / octal-constant octal-digit")
     (or (cst-list-list-conc-matchp abnf::cstss "\"0\"")
         (cst-list-list-conc-matchp abnf::cstss
                                    "octal-constant octal-digit"))))

Theorem: cst-hexadecimal-constant-concs

(defthm cst-hexadecimal-constant-concs
 (implies
  (cst-list-list-alt-matchp
   abnf::cstss
   "hexadecimal-prefix hexadecimal-digit / hexadecimal-constant hexadecimal-digit")
  (or (cst-list-list-conc-matchp
           abnf::cstss
           "hexadecimal-prefix hexadecimal-digit")
      (cst-list-list-conc-matchp
           abnf::cstss
           "hexadecimal-constant hexadecimal-digit"))))

Theorem: cst-hexadecimal-prefix-concs

(defthm cst-hexadecimal-prefix-concs
  (implies (cst-list-list-alt-matchp abnf::cstss "%i\"0x\"")
           (or (cst-list-list-conc-matchp abnf::cstss "%i\"0x\""))))

Theorem: cst-nonzero-digit-concs

(defthm cst-nonzero-digit-concs
  (implies (cst-list-list-alt-matchp abnf::cstss "%x31-39")
           (or (cst-list-list-conc-matchp abnf::cstss "%x31-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
                                     "%x30-39 / %x61-66 / %x41-46")
           (or (cst-list-list-conc-matchp abnf::cstss "%x30-39")
               (cst-list-list-conc-matchp abnf::cstss "%x61-66")
               (cst-list-list-conc-matchp abnf::cstss "%x41-46"))))

Theorem: cst-integer-suffix-concs

(defthm cst-integer-suffix-concs
 (implies
  (cst-list-list-alt-matchp
   abnf::cstss
   "unsigned-suffix [ long-suffix ] / unsigned-suffix [ long-long-suffix ] / long-suffix [ unsigned-suffix ] / long-long-suffix [ unsigned-suffix ]")
  (or (cst-list-list-conc-matchp abnf::cstss
                                 "unsigned-suffix [ long-suffix ]")
      (cst-list-list-conc-matchp
           abnf::cstss
           "unsigned-suffix [ long-long-suffix ]")
      (cst-list-list-conc-matchp abnf::cstss
                                 "long-suffix [ unsigned-suffix ]")
      (cst-list-list-conc-matchp
           abnf::cstss
           "long-long-suffix [ unsigned-suffix ]"))))

Theorem: cst-unsigned-suffix-concs

(defthm cst-unsigned-suffix-concs
  (implies (cst-list-list-alt-matchp abnf::cstss "%i\"u\"")
           (or (cst-list-list-conc-matchp abnf::cstss "%i\"u\""))))

Theorem: cst-long-suffix-concs

(defthm cst-long-suffix-concs
  (implies (cst-list-list-alt-matchp abnf::cstss "%i\"l\"")
           (or (cst-list-list-conc-matchp abnf::cstss "%i\"l\""))))

Theorem: cst-long-long-suffix-concs

(defthm cst-long-long-suffix-concs
  (implies (cst-list-list-alt-matchp abnf::cstss "%s\"ll\" / %s\"LL\"")
           (or (cst-list-list-conc-matchp abnf::cstss "%s\"ll\"")
               (cst-list-list-conc-matchp abnf::cstss "%s\"LL\""))))

Theorem: cst-floating-constant-concs

(defthm cst-floating-constant-concs
 (implies
  (cst-list-list-alt-matchp
       abnf::cstss
       "decimal-floating-constant / hexadecimal-floating-constant")
  (or (cst-list-list-conc-matchp
           abnf::cstss "decimal-floating-constant")
      (cst-list-list-conc-matchp abnf::cstss
                                 "hexadecimal-floating-constant"))))

Theorem: cst-decimal-floating-constant-concs

(defthm cst-decimal-floating-constant-concs
 (implies
  (cst-list-list-alt-matchp
   abnf::cstss
   "fractional-constant [ exponent-part ] [ floating-suffix ] / digit-sequence exponent-part [ floating-suffix ]")
  (or
   (cst-list-list-conc-matchp
        abnf::cstss
        "fractional-constant [ exponent-part ] [ floating-suffix ]")
   (cst-list-list-conc-matchp
        abnf::cstss
        "digit-sequence exponent-part [ floating-suffix ]"))))

Theorem: cst-hexadecimal-floating-constant-concs

(defthm cst-hexadecimal-floating-constant-concs
 (implies
  (cst-list-list-alt-matchp
   abnf::cstss
   "hexadecimal-prefix hexadecimal-fractional-constant binary-exponent-part [ floating-suffix ] / hexadecimal-prefix hexadecimal-digit-sequence binary-exponent-part [ floating-suffix ]")
  (or
   (cst-list-list-conc-matchp
    abnf::cstss
    "hexadecimal-prefix hexadecimal-fractional-constant binary-exponent-part [ floating-suffix ]")
   (cst-list-list-conc-matchp
    abnf::cstss
    "hexadecimal-prefix hexadecimal-digit-sequence binary-exponent-part [ floating-suffix ]"))))

Theorem: cst-fractional-constant-concs

(defthm cst-fractional-constant-concs
 (implies
  (cst-list-list-alt-matchp
       abnf::cstss
       "[ digit-sequence ] \".\" digit-sequence / digit-sequence \".\"")
  (or
     (cst-list-list-conc-matchp
          abnf::cstss
          "[ digit-sequence ] \".\" digit-sequence")
     (cst-list-list-conc-matchp abnf::cstss "digit-sequence \".\""))))

Theorem: cst-exponent-part-concs

(defthm cst-exponent-part-concs
 (implies
  (cst-list-list-alt-matchp abnf::cstss
                            "%i\"e\" [ sign ] digit-sequence")
  (or (cst-list-list-conc-matchp abnf::cstss
                                 "%i\"e\" [ sign ] digit-sequence"))))

Theorem: cst-sign-concs

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

Theorem: cst-digit-sequence-concs

(defthm cst-digit-sequence-concs
 (implies
  (cst-list-list-alt-matchp abnf::cstss
                            "digit / digit-sequence digit")
  (or
   (cst-list-list-conc-matchp abnf::cstss "digit")
   (cst-list-list-conc-matchp abnf::cstss "digit-sequence digit"))))

Theorem: cst-hexadecimal-fractional-constant-concs

(defthm cst-hexadecimal-fractional-constant-concs
 (implies
  (cst-list-list-alt-matchp
   abnf::cstss
   "[ hexadecimal-digit-sequence ] \".\" hexadecimal-digit-sequence / hexadecimal-digit-sequence \".\"")
  (or
   (cst-list-list-conc-matchp
    abnf::cstss
    "[ hexadecimal-digit-sequence ] \".\" hexadecimal-digit-sequence")
   (cst-list-list-conc-matchp abnf::cstss
                              "hexadecimal-digit-sequence \".\""))))

Theorem: cst-binary-exponent-part-concs

(defthm cst-binary-exponent-part-concs
 (implies
  (cst-list-list-alt-matchp abnf::cstss
                            "%i\"p\" [ sign ] digit-sequence")
  (or (cst-list-list-conc-matchp abnf::cstss
                                 "%i\"p\" [ sign ] digit-sequence"))))

Theorem: cst-hexadecimal-digit-sequence-concs

(defthm cst-hexadecimal-digit-sequence-concs
 (implies
  (cst-list-list-alt-matchp
   abnf::cstss
   "hexadecimal-digit / hexadecimal-digit-sequence hexadecimal-digit")
  (or (cst-list-list-conc-matchp abnf::cstss "hexadecimal-digit")
      (cst-list-list-conc-matchp
           abnf::cstss
           "hexadecimal-digit-sequence hexadecimal-digit"))))

Theorem: cst-floating-suffix-concs

(defthm cst-floating-suffix-concs
 (implies
  (cst-list-list-alt-matchp
       abnf::cstss
       "%i\"f\" / %i\"l\" / %i\"f\" ( \"16\" / \"32\" / \"64\" / \"128\" ) %s\"x\"")
  (or (cst-list-list-conc-matchp abnf::cstss "%i\"f\"")
      (cst-list-list-conc-matchp abnf::cstss "%i\"l\"")
      (cst-list-list-conc-matchp
           abnf::cstss
           "%i\"f\" ( \"16\" / \"32\" / \"64\" / \"128\" ) %s\"x\""))))

Theorem: cst-enumeration-constant-concs

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

Theorem: cst-character-constant-concs

(defthm cst-character-constant-concs
 (implies
  (cst-list-list-alt-matchp
   abnf::cstss
   "\"'\" c-char-sequence \"'\" / %s\"L'\" c-char-sequence \"'\" / %i\"u'\" c-char-sequence \"'\"")
  (or
   (cst-list-list-conc-matchp abnf::cstss "\"'\" c-char-sequence \"'\"")
   (cst-list-list-conc-matchp abnf::cstss
                              "%s\"L'\" c-char-sequence \"'\"")
   (cst-list-list-conc-matchp abnf::cstss
                              "%i\"u'\" c-char-sequence \"'\""))))

Theorem: cst-c-char-sequence-concs

(defthm cst-c-char-sequence-concs
  (implies
       (cst-list-list-alt-matchp abnf::cstss
                                 "c-char / c-char-sequence c-char")
       (or (cst-list-list-conc-matchp abnf::cstss "c-char")
           (cst-list-list-conc-matchp
                abnf::cstss "c-char-sequence c-char"))))

Theorem: cst-c-char-concs

(defthm cst-c-char-concs
 (implies
  (cst-list-list-alt-matchp
   abnf::cstss
   "character-not-single-quote-or-backslash-or-new-line / escape-sequence")
  (or (cst-list-list-conc-matchp
           abnf::cstss
           "character-not-single-quote-or-backslash-or-new-line")
      (cst-list-list-conc-matchp abnf::cstss "escape-sequence"))))

Theorem: cst-escape-sequence-concs

(defthm cst-escape-sequence-concs
 (implies
  (cst-list-list-alt-matchp
   abnf::cstss
   "simple-escape-sequence / octal-escape-sequence / hexadecimal-escape-sequence / universal-character-name")
  (or
    (cst-list-list-conc-matchp abnf::cstss "simple-escape-sequence")
    (cst-list-list-conc-matchp abnf::cstss "octal-escape-sequence")
    (cst-list-list-conc-matchp abnf::cstss
                               "hexadecimal-escape-sequence")
    (cst-list-list-conc-matchp abnf::cstss
                               "universal-character-name"))))

Theorem: cst-simple-escape-sequence-concs

(defthm cst-simple-escape-sequence-concs
 (implies
  (cst-list-list-alt-matchp
   abnf::cstss
   "\"\\'\" / \"\\\" double-quote / \"\\?\" / \"\\\\\" / %s\"\\a\" / %s\"\\b\" / %s\"\\f\" / %s\"\\n\" / %s\"\\r\" / %s\"\\t\" / %s\"\\v\" / \"\\%\"")
  (or (cst-list-list-conc-matchp abnf::cstss "\"\\'\"")
      (cst-list-list-conc-matchp abnf::cstss "\"\\\" double-quote")
      (cst-list-list-conc-matchp abnf::cstss "\"\\?\"")
      (cst-list-list-conc-matchp abnf::cstss "\"\\\\\"")
      (cst-list-list-conc-matchp abnf::cstss "%s\"\\a\"")
      (cst-list-list-conc-matchp abnf::cstss "%s\"\\b\"")
      (cst-list-list-conc-matchp abnf::cstss "%s\"\\f\"")
      (cst-list-list-conc-matchp abnf::cstss "%s\"\\n\"")
      (cst-list-list-conc-matchp abnf::cstss "%s\"\\r\"")
      (cst-list-list-conc-matchp abnf::cstss "%s\"\\t\"")
      (cst-list-list-conc-matchp abnf::cstss "%s\"\\v\"")
      (cst-list-list-conc-matchp abnf::cstss "\"\\%\""))))

Theorem: cst-octal-escape-sequence-concs

(defthm cst-octal-escape-sequence-concs
 (implies
  (cst-list-list-alt-matchp
   abnf::cstss
   "\"\\\" octal-digit / \"\\\" octal-digit octal-digit / \"\\\" octal-digit octal-digit octal-digit")
  (or (cst-list-list-conc-matchp abnf::cstss "\"\\\" octal-digit")
      (cst-list-list-conc-matchp abnf::cstss
                                 "\"\\\" octal-digit octal-digit")
      (cst-list-list-conc-matchp
           abnf::cstss
           "\"\\\" octal-digit octal-digit octal-digit"))))

Theorem: cst-hexadecimal-escape-sequence-concs

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

Theorem: cst-string-literal-concs

(defthm cst-string-literal-concs
 (implies
  (cst-list-list-alt-matchp
   abnf::cstss
   "[ encoding-prefix ] double-quote [ s-char-sequence ] double-quote")
  (or
   (cst-list-list-conc-matchp
    abnf::cstss
    "[ encoding-prefix ] double-quote [ s-char-sequence ] double-quote"))))

Theorem: cst-encoding-prefix-concs

(defthm cst-encoding-prefix-concs
 (implies
     (cst-list-list-alt-matchp abnf::cstss "%s\"u8\" / %i\"u\" / %s\"L\"")
     (or (cst-list-list-conc-matchp abnf::cstss "%s\"u8\"")
         (cst-list-list-conc-matchp abnf::cstss "%i\"u\"")
         (cst-list-list-conc-matchp abnf::cstss "%s\"L\""))))

Theorem: cst-s-char-sequence-concs

(defthm cst-s-char-sequence-concs
  (implies
       (cst-list-list-alt-matchp abnf::cstss
                                 "s-char / s-char-sequence s-char")
       (or (cst-list-list-conc-matchp abnf::cstss "s-char")
           (cst-list-list-conc-matchp
                abnf::cstss "s-char-sequence s-char"))))

Theorem: cst-s-char-concs

(defthm cst-s-char-concs
 (implies
  (cst-list-list-alt-matchp
   abnf::cstss
   "character-not-double-quote-or-backslash-or-new-line / escape-sequence")
  (or (cst-list-list-conc-matchp
           abnf::cstss
           "character-not-double-quote-or-backslash-or-new-line")
      (cst-list-list-conc-matchp abnf::cstss "escape-sequence"))))

Theorem: cst-punctuator-concs

(defthm cst-punctuator-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 "\"-\"")
      (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 "\"%:%:\""))))

Theorem: cst-lexeme-concs

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

Theorem: cst-primary-expression-concs

(defthm cst-primary-expression-concs
 (implies
  (cst-list-list-alt-matchp
   abnf::cstss
   "identifier / constant / 1*string-literal / \"(\" expression \")\" / generic-selection / \"(\" compound-statement \")\" / types-compatible-call / offsetof-call / va-arg-call / %s\"__extension__\" primary-expression / %s\"true\" / %s\"false\"")
  (or
     (cst-list-list-conc-matchp abnf::cstss "identifier")
     (cst-list-list-conc-matchp abnf::cstss "constant")
     (cst-list-list-conc-matchp abnf::cstss "1*string-literal")
     (cst-list-list-conc-matchp abnf::cstss "\"(\" expression \")\"")
     (cst-list-list-conc-matchp abnf::cstss "generic-selection")
     (cst-list-list-conc-matchp abnf::cstss
                                "\"(\" compound-statement \")\"")
     (cst-list-list-conc-matchp abnf::cstss "types-compatible-call")
     (cst-list-list-conc-matchp abnf::cstss "offsetof-call")
     (cst-list-list-conc-matchp abnf::cstss "va-arg-call")
     (cst-list-list-conc-matchp
          abnf::cstss
          "%s\"__extension__\" primary-expression")
     (cst-list-list-conc-matchp abnf::cstss "%s\"true\"")
     (cst-list-list-conc-matchp abnf::cstss "%s\"false\""))))

Theorem: cst-types-compatible-call-concs

(defthm cst-types-compatible-call-concs
 (implies
  (cst-list-list-alt-matchp
   abnf::cstss
   "%s\"__builtin_types_compatible_p\" \"(\" type-name \",\" type-name \")\"")
  (or
   (cst-list-list-conc-matchp
    abnf::cstss
    "%s\"__builtin_types_compatible_p\" \"(\" type-name \",\" type-name \")\""))))

Theorem: cst-offsetof-call-concs

(defthm cst-offsetof-call-concs
 (implies
  (cst-list-list-alt-matchp
   abnf::cstss
   "%s\"__builtin_offsetof\" \"(\" type-name \",\" offsetof-member-designator \")\"")
  (or
   (cst-list-list-conc-matchp
    abnf::cstss
    "%s\"__builtin_offsetof\" \"(\" type-name \",\" offsetof-member-designator \")\""))))

Theorem: cst-offsetof-member-designator-concs

(defthm cst-offsetof-member-designator-concs
 (implies
  (cst-list-list-alt-matchp
   abnf::cstss
   "identifier / offsetof-member-designator \".\" identifier / offsetof-member-designator \"[\" expression \"]\"")
  (or (cst-list-list-conc-matchp abnf::cstss "identifier")
      (cst-list-list-conc-matchp
           abnf::cstss
           "offsetof-member-designator \".\" identifier")
      (cst-list-list-conc-matchp
           abnf::cstss
           "offsetof-member-designator \"[\" expression \"]\""))))

Theorem: cst-va-arg-call-concs

(defthm cst-va-arg-call-concs
 (implies
  (cst-list-list-alt-matchp
   abnf::cstss
   "%s\"__builtin_va_arg\" \"(\" assignment-expression \",\" type-name \")\"")
  (or
   (cst-list-list-conc-matchp
    abnf::cstss
    "%s\"__builtin_va_arg\" \"(\" assignment-expression \",\" type-name \")\""))))

Theorem: cst-generic-selection-concs

(defthm cst-generic-selection-concs
 (implies
  (cst-list-list-alt-matchp
   abnf::cstss
   "%s\"_Generic\" \"(\" assignment-expression \",\" generic-assoc-list \")\"")
  (or
   (cst-list-list-conc-matchp
    abnf::cstss
    "%s\"_Generic\" \"(\" assignment-expression \",\" generic-assoc-list \")\""))))

Theorem: cst-generic-assoc-list-concs

(defthm cst-generic-assoc-list-concs
 (implies
  (cst-list-list-alt-matchp
   abnf::cstss
   "generic-association / generic-assoc-list \",\" generic-association")
  (or (cst-list-list-conc-matchp abnf::cstss "generic-association")
      (cst-list-list-conc-matchp
           abnf::cstss
           "generic-assoc-list \",\" generic-association"))))

Theorem: cst-generic-association-concs

(defthm cst-generic-association-concs
 (implies
  (cst-list-list-alt-matchp
   abnf::cstss
   "type-name \":\" assignment-expression / %s\"default\" \":\" assignment-expression")
  (or
   (cst-list-list-conc-matchp abnf::cstss
                              "type-name \":\" assignment-expression")
   (cst-list-list-conc-matchp
        abnf::cstss
        "%s\"default\" \":\" assignment-expression"))))

Theorem: cst-postfix-expression-concs

(defthm cst-postfix-expression-concs
 (implies
  (cst-list-list-alt-matchp
   abnf::cstss
   "primary-expression / postfix-expression \"[\" expression \"]\" / postfix-expression \"(\" [ argument-expression-list ] \")\" / postfix-expression \".\" identifier / postfix-expression \"->\" identifier / postfix-expression \"++\" / postfix-expression \"--\" / \"(\" type-name \")\" \"{\" initializer-list \"}\" / \"(\" type-name \")\" \"{\" initializer-list \",\" \"}\" / \"(\" type-name \")\" \"{\" \"}\"")
  (or
   (cst-list-list-conc-matchp abnf::cstss "primary-expression")
   (cst-list-list-conc-matchp
        abnf::cstss
        "postfix-expression \"[\" expression \"]\"")
   (cst-list-list-conc-matchp
        abnf::cstss
        "postfix-expression \"(\" [ argument-expression-list ] \")\"")
   (cst-list-list-conc-matchp abnf::cstss
                              "postfix-expression \".\" identifier")
   (cst-list-list-conc-matchp abnf::cstss
                              "postfix-expression \"->\" identifier")
   (cst-list-list-conc-matchp abnf::cstss "postfix-expression \"++\"")
   (cst-list-list-conc-matchp abnf::cstss "postfix-expression \"--\"")
   (cst-list-list-conc-matchp
        abnf::cstss
        "\"(\" type-name \")\" \"{\" initializer-list \"}\"")
   (cst-list-list-conc-matchp
        abnf::cstss
        "\"(\" type-name \")\" \"{\" initializer-list \",\" \"}\"")
   (cst-list-list-conc-matchp abnf::cstss
                              "\"(\" type-name \")\" \"{\" \"}\""))))

Theorem: cst-argument-expression-list-concs

(defthm cst-argument-expression-list-concs
 (implies
  (cst-list-list-alt-matchp
   abnf::cstss
   "assignment-expression / argument-expression-list \",\" assignment-expression")
  (or
     (cst-list-list-conc-matchp abnf::cstss "assignment-expression")
     (cst-list-list-conc-matchp
          abnf::cstss
          "argument-expression-list \",\" assignment-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 / unary-operator cast-expression / %s\"sizeof\" unary-expression / %s\"sizeof\" \"(\" type-name \")\" / alignof-keyword unary-expression / alignof-keyword \"(\" type-name \")\" / %s\"__real__\" cast-expression / %s\"__imag__\" cast-expression / \"&&\" identifier")
  (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")
     (cst-list-list-conc-matchp abnf::cstss
                                "unary-operator cast-expression")
     (cst-list-list-conc-matchp abnf::cstss
                                "%s\"sizeof\" unary-expression")
     (cst-list-list-conc-matchp abnf::cstss
                                "%s\"sizeof\" \"(\" type-name \")\"")
     (cst-list-list-conc-matchp abnf::cstss
                                "alignof-keyword unary-expression")
     (cst-list-list-conc-matchp abnf::cstss
                                "alignof-keyword \"(\" type-name \")\"")
     (cst-list-list-conc-matchp abnf::cstss
                                "%s\"__real__\" cast-expression")
     (cst-list-list-conc-matchp abnf::cstss
                                "%s\"__imag__\" cast-expression")
     (cst-list-list-conc-matchp abnf::cstss "\"&&\" identifier"))))

Theorem: cst-unary-operator-concs

(defthm cst-unary-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 "\"!\""))))

Theorem: cst-cast-expression-concs

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

Theorem: cst-multiplicative-expression-concs

(defthm cst-multiplicative-expression-concs
 (implies
  (cst-list-list-alt-matchp
   abnf::cstss
   "cast-expression / multiplicative-expression \"*\" cast-expression / multiplicative-expression \"/\" cast-expression / multiplicative-expression \"%\" cast-expression")
  (or (cst-list-list-conc-matchp abnf::cstss "cast-expression")
      (cst-list-list-conc-matchp
           abnf::cstss
           "multiplicative-expression \"*\" cast-expression")
      (cst-list-list-conc-matchp
           abnf::cstss
           "multiplicative-expression \"/\" cast-expression")
      (cst-list-list-conc-matchp
           abnf::cstss
           "multiplicative-expression \"%\" cast-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-relational-expression-concs

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

Theorem: cst-equality-expression-concs

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

Theorem: cst-and-expression-concs

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

Theorem: cst-exclusive-or-expression-concs

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

Theorem: cst-inclusive-or-expression-concs

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

Theorem: cst-logical-and-expression-concs

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

Theorem: cst-logical-or-expression-concs

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

Theorem: cst-conditional-expression-concs

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

Theorem: cst-assignment-expression-concs

(defthm cst-assignment-expression-concs
 (implies
  (cst-list-list-alt-matchp
   abnf::cstss
   "conditional-expression / unary-expression assignment-operator assignment-expression")
  (or
   (cst-list-list-conc-matchp abnf::cstss "conditional-expression")
   (cst-list-list-conc-matchp
    abnf::cstss
    "unary-expression assignment-operator assignment-expression"))))

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

Theorem: cst-expression-concs

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

Theorem: cst-constant-expression-concs

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

Theorem: cst-attribute-name-concs

(defthm cst-attribute-name-concs
  (implies
       (cst-list-list-alt-matchp abnf::cstss "identifier / keyword")
       (or (cst-list-list-conc-matchp abnf::cstss "identifier")
           (cst-list-list-conc-matchp abnf::cstss "keyword"))))

Theorem: cst-attribute-parameters-concs

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

Theorem: cst-attribute-concs

(defthm cst-attribute-concs
  (implies (cst-list-list-alt-matchp
                abnf::cstss
                "attribute-name [ attribute-parameters ]")
           (or (cst-list-list-conc-matchp
                    abnf::cstss
                    "attribute-name [ attribute-parameters ]"))))

Theorem: cst-attribute-list-concs

(defthm cst-attribute-list-concs
 (implies
   (cst-list-list-alt-matchp abnf::cstss
                             "attribute *( \",\" attribute )")
   (or (cst-list-list-conc-matchp abnf::cstss
                                  "attribute *( \",\" attribute )"))))

Theorem: cst-attribute-specifier-concs

(defthm cst-attribute-specifier-concs
 (implies
  (cst-list-list-alt-matchp
       abnf::cstss
       "attribute-keyword \"(\" \"(\" [ attribute-list ] \")\" \")\"")
  (or
     (cst-list-list-conc-matchp
          abnf::cstss
          "attribute-keyword \"(\" \"(\" [ attribute-list ] \")\" \")\""))))

Theorem: cst-asm-name-specifier-concs

(defthm cst-asm-name-specifier-concs
 (implies
   (cst-list-list-alt-matchp abnf::cstss
                             "asm-keyword \"(\" 1*string-literal \")\"")
   (or (cst-list-list-conc-matchp
            abnf::cstss
            "asm-keyword \"(\" 1*string-literal \")\""))))

Theorem: cst-asm-qualifier-concs

(defthm cst-asm-qualifier-concs
 (implies
      (cst-list-list-alt-matchp
           abnf::cstss
           "volatile-keyword / inline-keyword / %s\"goto\"")
      (or (cst-list-list-conc-matchp abnf::cstss "volatile-keyword")
          (cst-list-list-conc-matchp abnf::cstss "inline-keyword")
          (cst-list-list-conc-matchp abnf::cstss "%s\"goto\""))))

Theorem: cst-asm-statement-concs

(defthm cst-asm-statement-concs
 (implies
  (cst-list-list-alt-matchp
   abnf::cstss
   "asm-keyword *asm-qualifier \"(\" 1*string-literal [ \":\" asm-output-operands [ \":\" asm-input-operands [ \":\" asm-clobbers [ \":\" asm-goto-labels ] ] ] ] \")\" \";\"")
  (or
   (cst-list-list-conc-matchp
    abnf::cstss
    "asm-keyword *asm-qualifier \"(\" 1*string-literal [ \":\" asm-output-operands [ \":\" asm-input-operands [ \":\" asm-clobbers [ \":\" asm-goto-labels ] ] ] ] \")\" \";\""))))

Theorem: cst-asm-output-operands-concs

(defthm cst-asm-output-operands-concs
 (implies
   (cst-list-list-alt-matchp
        abnf::cstss
        "[ asm-output-operand *( \",\" asm-output-operand ) ]")
   (or (cst-list-list-conc-matchp
            abnf::cstss
            "[ asm-output-operand *( \",\" asm-output-operand ) ]"))))

Theorem: cst-asm-output-operand-concs

(defthm cst-asm-output-operand-concs
 (implies
  (cst-list-list-alt-matchp
       abnf::cstss
       "[ \"[\" identifier \"]\" ] 1*string-literal \"(\" expression \")\"")
  (or
   (cst-list-list-conc-matchp
    abnf::cstss
    "[ \"[\" identifier \"]\" ] 1*string-literal \"(\" expression \")\""))))

Theorem: cst-asm-input-operands-concs

(defthm cst-asm-input-operands-concs
 (implies
     (cst-list-list-alt-matchp
          abnf::cstss
          "[ asm-input-operand *( \",\" asm-input-operand ) ]")
     (or (cst-list-list-conc-matchp
              abnf::cstss
              "[ asm-input-operand *( \",\" asm-input-operand ) ]"))))

Theorem: cst-asm-input-operand-concs

(defthm cst-asm-input-operand-concs
 (implies
  (cst-list-list-alt-matchp
       abnf::cstss
       "[ \"[\" identifier \"]\" ] 1*string-literal \"(\" expression \")\"")
  (or
   (cst-list-list-conc-matchp
    abnf::cstss
    "[ \"[\" identifier \"]\" ] 1*string-literal \"(\" expression \")\""))))

Theorem: cst-asm-clobbers-concs

(defthm cst-asm-clobbers-concs
 (implies
   (cst-list-list-alt-matchp abnf::cstss
                             "[ asm-clobber *( \",\" asm-clobber ) ]")
   (or (cst-list-list-conc-matchp
            abnf::cstss
            "[ asm-clobber *( \",\" asm-clobber ) ]"))))

Theorem: cst-asm-clobber-concs

(defthm cst-asm-clobber-concs
 (implies
   (cst-list-list-alt-matchp abnf::cstss "1*string-literal")
   (or (cst-list-list-conc-matchp abnf::cstss "1*string-literal"))))

Theorem: cst-asm-goto-labels-concs

(defthm cst-asm-goto-labels-concs
 (implies
     (cst-list-list-alt-matchp abnf::cstss
                               "[ identifier *( \",\" identifier ) ]")
     (or (cst-list-list-conc-matchp
              abnf::cstss
              "[ identifier *( \",\" identifier ) ]"))))

Theorem: cst-declaration-concs

(defthm cst-declaration-concs
 (implies
  (cst-list-list-alt-matchp
   abnf::cstss
   "[ %s\"__extension__\" ] declaration-specifiers [ init-declarator-list ] \";\" / static-assert-declaration")
  (or
   (cst-list-list-conc-matchp
    abnf::cstss
    "[ %s\"__extension__\" ] declaration-specifiers [ init-declarator-list ] \";\"")
   (cst-list-list-conc-matchp abnf::cstss
                              "static-assert-declaration"))))

Theorem: cst-declaration-specifiers-concs

(defthm cst-declaration-specifiers-concs
 (implies
  (cst-list-list-alt-matchp
   abnf::cstss
   "storage-class-specifier [ declaration-specifiers ] / type-specifier [ declaration-specifiers ] / type-qualifier [ declaration-specifiers ] / function-specifier [ declaration-specifiers ] / alignment-specifier [ declaration-specifiers ] / attribute-specifier [ declaration-specifiers ] / %s\"__stdcall\" [ declaration-specifiers ] / %s\"__declspec\" \"(\" identifier \")\" [ declaration-specifiers ]")
  (or
   (cst-list-list-conc-matchp
        abnf::cstss
        "storage-class-specifier [ declaration-specifiers ]")
   (cst-list-list-conc-matchp
        abnf::cstss
        "type-specifier [ declaration-specifiers ]")
   (cst-list-list-conc-matchp
        abnf::cstss
        "type-qualifier [ declaration-specifiers ]")
   (cst-list-list-conc-matchp
        abnf::cstss
        "function-specifier [ declaration-specifiers ]")
   (cst-list-list-conc-matchp
        abnf::cstss
        "alignment-specifier [ declaration-specifiers ]")
   (cst-list-list-conc-matchp
        abnf::cstss
        "attribute-specifier [ declaration-specifiers ]")
   (cst-list-list-conc-matchp
        abnf::cstss
        "%s\"__stdcall\" [ declaration-specifiers ]")
   (cst-list-list-conc-matchp
    abnf::cstss
    "%s\"__declspec\" \"(\" identifier \")\" [ declaration-specifiers ]"))))

Theorem: cst-init-declarator-list-concs

(defthm cst-init-declarator-list-concs
 (implies
  (cst-list-list-alt-matchp
       abnf::cstss
       "init-declarator / init-declarator-list \",\" init-declarator")
  (or (cst-list-list-conc-matchp abnf::cstss "init-declarator")
      (cst-list-list-conc-matchp
           abnf::cstss
           "init-declarator-list \",\" init-declarator"))))

Theorem: cst-init-declarator-concs

(defthm cst-init-declarator-concs
 (implies
  (cst-list-list-alt-matchp
   abnf::cstss
   "declarator [ asm-name-specifier ] *attribute-specifier / declarator [ asm-name-specifier ] *attribute-specifier \"=\" initializer")
  (or
   (cst-list-list-conc-matchp
        abnf::cstss
        "declarator [ asm-name-specifier ] *attribute-specifier")
   (cst-list-list-conc-matchp
    abnf::cstss
    "declarator [ asm-name-specifier ] *attribute-specifier \"=\" initializer"))))

Theorem: cst-storage-class-specifier-concs

(defthm cst-storage-class-specifier-concs
 (implies
  (cst-list-list-alt-matchp
   abnf::cstss
   "%s\"typedef\" / %s\"extern\" / %s\"static\" / %s\"_Thread_local\" / %s\"auto\" / %s\"register\"")
  (or (cst-list-list-conc-matchp abnf::cstss "%s\"typedef\"")
      (cst-list-list-conc-matchp abnf::cstss "%s\"extern\"")
      (cst-list-list-conc-matchp abnf::cstss "%s\"static\"")
      (cst-list-list-conc-matchp abnf::cstss "%s\"_Thread_local\"")
      (cst-list-list-conc-matchp abnf::cstss "%s\"auto\"")
      (cst-list-list-conc-matchp abnf::cstss "%s\"register\""))))

Theorem: cst-type-specifier-concs

(defthm cst-type-specifier-concs
 (implies
  (cst-list-list-alt-matchp
   abnf::cstss
   "%s\"void\" / %s\"char\" / %s\"short\" / %s\"int\" / %s\"long\" / %s\"float\" / %s\"double\" / signed-keyword / %s\"unsigned\" / %s\"bool\" / %s\"_Bool\" / %s\"_Complex\" / atomic-type-specifier / struct-or-union-specifier / enum-specifier / typedef-name / %s\"__int128\" / %s\"__float80\" / %s\"__float128\" / %s\"_Float16\" / %s\"_Float16x\" / %s\"_Float32\" / %s\"_Float32x\" / %s\"_Float64\" / %s\"_Float64x\" / %s\"_Float128\" / %s\"_Float128x\" / %s\"__builtin_va_list\" / typeof-keyword \"(\" expression \")\" / typeof-keyword \"(\" type-name \")\" / %s\"__auto_type\"")
  (or
     (cst-list-list-conc-matchp abnf::cstss "%s\"void\"")
     (cst-list-list-conc-matchp abnf::cstss "%s\"char\"")
     (cst-list-list-conc-matchp abnf::cstss "%s\"short\"")
     (cst-list-list-conc-matchp abnf::cstss "%s\"int\"")
     (cst-list-list-conc-matchp abnf::cstss "%s\"long\"")
     (cst-list-list-conc-matchp abnf::cstss "%s\"float\"")
     (cst-list-list-conc-matchp abnf::cstss "%s\"double\"")
     (cst-list-list-conc-matchp abnf::cstss "signed-keyword")
     (cst-list-list-conc-matchp abnf::cstss "%s\"unsigned\"")
     (cst-list-list-conc-matchp abnf::cstss "%s\"bool\"")
     (cst-list-list-conc-matchp abnf::cstss "%s\"_Bool\"")
     (cst-list-list-conc-matchp abnf::cstss "%s\"_Complex\"")
     (cst-list-list-conc-matchp abnf::cstss "atomic-type-specifier")
     (cst-list-list-conc-matchp
          abnf::cstss "struct-or-union-specifier")
     (cst-list-list-conc-matchp abnf::cstss "enum-specifier")
     (cst-list-list-conc-matchp abnf::cstss "typedef-name")
     (cst-list-list-conc-matchp abnf::cstss "%s\"__int128\"")
     (cst-list-list-conc-matchp abnf::cstss "%s\"__float80\"")
     (cst-list-list-conc-matchp abnf::cstss "%s\"__float128\"")
     (cst-list-list-conc-matchp abnf::cstss "%s\"_Float16\"")
     (cst-list-list-conc-matchp abnf::cstss "%s\"_Float16x\"")
     (cst-list-list-conc-matchp abnf::cstss "%s\"_Float32\"")
     (cst-list-list-conc-matchp abnf::cstss "%s\"_Float32x\"")
     (cst-list-list-conc-matchp abnf::cstss "%s\"_Float64\"")
     (cst-list-list-conc-matchp abnf::cstss "%s\"_Float64x\"")
     (cst-list-list-conc-matchp abnf::cstss "%s\"_Float128\"")
     (cst-list-list-conc-matchp abnf::cstss "%s\"_Float128x\"")
     (cst-list-list-conc-matchp abnf::cstss "%s\"__builtin_va_list\"")
     (cst-list-list-conc-matchp abnf::cstss
                                "typeof-keyword \"(\" expression \")\"")
     (cst-list-list-conc-matchp abnf::cstss
                                "typeof-keyword \"(\" type-name \")\"")
     (cst-list-list-conc-matchp abnf::cstss "%s\"__auto_type\""))))

Theorem: cst-struct-or-union-specifier-concs

(defthm cst-struct-or-union-specifier-concs
 (implies
  (cst-list-list-alt-matchp
   abnf::cstss
   "struct-or-union *attribute-specifier [ identifier ] \"{\" struct-declaration-list \"}\" / struct-or-union *attribute-specifier identifier / %s\"struct\" *attribute-specifier [ identifier ] \"{\" \"}\"")
  (or
   (cst-list-list-conc-matchp
    abnf::cstss
    "struct-or-union *attribute-specifier [ identifier ] \"{\" struct-declaration-list \"}\"")
   (cst-list-list-conc-matchp
        abnf::cstss
        "struct-or-union *attribute-specifier identifier")
   (cst-list-list-conc-matchp
        abnf::cstss
        "%s\"struct\" *attribute-specifier [ identifier ] \"{\" \"}\""))))

Theorem: cst-struct-or-union-concs

(defthm cst-struct-or-union-concs
 (implies
     (cst-list-list-alt-matchp abnf::cstss "%s\"struct\" / %s\"union\"")
     (or (cst-list-list-conc-matchp abnf::cstss "%s\"struct\"")
         (cst-list-list-conc-matchp abnf::cstss "%s\"union\""))))

Theorem: cst-struct-declaration-list-concs

(defthm cst-struct-declaration-list-concs
 (implies
  (cst-list-list-alt-matchp
   abnf::cstss
   "struct-declaration / struct-declaration-list struct-declaration")
  (or (cst-list-list-conc-matchp abnf::cstss "struct-declaration")
      (cst-list-list-conc-matchp
           abnf::cstss
           "struct-declaration-list struct-declaration"))))

Theorem: cst-struct-declaration-concs

(defthm cst-struct-declaration-concs
 (implies
  (cst-list-list-alt-matchp
   abnf::cstss
   "[ %s\"__extension__\" ] specifier-qualifier-list [ struct-declarator-list ] *attribute-specifier \";\" / static-assert-declaration / \";\"")
  (or
   (cst-list-list-conc-matchp
    abnf::cstss
    "[ %s\"__extension__\" ] specifier-qualifier-list [ struct-declarator-list ] *attribute-specifier \";\"")
   (cst-list-list-conc-matchp
        abnf::cstss "static-assert-declaration")
   (cst-list-list-conc-matchp abnf::cstss "\";\""))))

Theorem: cst-specifier-qualifier-list-concs

(defthm cst-specifier-qualifier-list-concs
 (implies
  (cst-list-list-alt-matchp
   abnf::cstss
   "type-specifier [ specifier-qualifier-list ] / type-qualifier [ specifier-qualifier-list ] / alignment-specifier [ specifier-qualifier-list ] / attribute-specifier [ specifier-qualifier-list ]")
  (or (cst-list-list-conc-matchp
           abnf::cstss
           "type-specifier [ specifier-qualifier-list ]")
      (cst-list-list-conc-matchp
           abnf::cstss
           "type-qualifier [ specifier-qualifier-list ]")
      (cst-list-list-conc-matchp
           abnf::cstss
           "alignment-specifier [ specifier-qualifier-list ]")
      (cst-list-list-conc-matchp
           abnf::cstss
           "attribute-specifier [ specifier-qualifier-list ]"))))

Theorem: cst-struct-declarator-list-concs

(defthm cst-struct-declarator-list-concs
 (implies
  (cst-list-list-alt-matchp
   abnf::cstss
   "struct-declarator / struct-declarator-list \",\" struct-declarator")
  (or (cst-list-list-conc-matchp abnf::cstss "struct-declarator")
      (cst-list-list-conc-matchp
           abnf::cstss
           "struct-declarator-list \",\" struct-declarator"))))

Theorem: cst-struct-declarator-concs

(defthm cst-struct-declarator-concs
  (implies
       (cst-list-list-alt-matchp
            abnf::cstss
            "declarator / [ declarator ] \":\" constant-expression")
       (or (cst-list-list-conc-matchp abnf::cstss "declarator")
           (cst-list-list-conc-matchp
                abnf::cstss
                "[ declarator ] \":\" constant-expression"))))

Theorem: cst-enum-specifier-concs

(defthm cst-enum-specifier-concs
 (implies
  (cst-list-list-alt-matchp
   abnf::cstss
   "%s\"enum\" [ identifier ] \"{\" enumerator-list \"}\" / %s\"enum\" [ identifier ] \"{\" enumerator-list \",\" \"}\" / %s\"enum\" identifier")
  (or
    (cst-list-list-conc-matchp
         abnf::cstss
         "%s\"enum\" [ identifier ] \"{\" enumerator-list \"}\"")
    (cst-list-list-conc-matchp
         abnf::cstss
         "%s\"enum\" [ identifier ] \"{\" enumerator-list \",\" \"}\"")
    (cst-list-list-conc-matchp abnf::cstss "%s\"enum\" identifier"))))

Theorem: cst-enumerator-list-concs

(defthm cst-enumerator-list-concs
 (implies
  (cst-list-list-alt-matchp
       abnf::cstss
       "enumerator / enumerator-list \",\" enumerator")
  (or
     (cst-list-list-conc-matchp abnf::cstss "enumerator")
     (cst-list-list-conc-matchp abnf::cstss
                                "enumerator-list \",\" enumerator"))))

Theorem: cst-enumerator-concs

(defthm cst-enumerator-concs
 (implies
  (cst-list-list-alt-matchp
   abnf::cstss
   "enumeration-constant / enumeration-constant \"=\" constant-expression")
  (or (cst-list-list-conc-matchp abnf::cstss "enumeration-constant")
      (cst-list-list-conc-matchp
           abnf::cstss
           "enumeration-constant \"=\" constant-expression"))))

Theorem: cst-atomic-type-specifier-concs

(defthm cst-atomic-type-specifier-concs
 (implies
  (cst-list-list-alt-matchp abnf::cstss
                            "%s\"_Atomic\" \"(\" type-name \")\"")
  (or (cst-list-list-conc-matchp abnf::cstss
                                 "%s\"_Atomic\" \"(\" type-name \")\""))))

Theorem: cst-type-qualifier-concs

(defthm cst-type-qualifier-concs
 (implies
  (cst-list-list-alt-matchp
   abnf::cstss
   "%s\"const\" / restrict-keyword / volatile-keyword / %s\"_Atomic\" / %s\"__seg_fs\" / %s\"__seg_gs\"")
  (or (cst-list-list-conc-matchp abnf::cstss "%s\"const\"")
      (cst-list-list-conc-matchp abnf::cstss "restrict-keyword")
      (cst-list-list-conc-matchp abnf::cstss "volatile-keyword")
      (cst-list-list-conc-matchp abnf::cstss "%s\"_Atomic\"")
      (cst-list-list-conc-matchp abnf::cstss "%s\"__seg_fs\"")
      (cst-list-list-conc-matchp abnf::cstss "%s\"__seg_gs\""))))

Theorem: cst-function-specifier-concs

(defthm cst-function-specifier-concs
 (implies
      (cst-list-list-alt-matchp abnf::cstss
                                "inline-keyword / %s\"_Noreturn\"")
      (or (cst-list-list-conc-matchp abnf::cstss "inline-keyword")
          (cst-list-list-conc-matchp abnf::cstss "%s\"_Noreturn\""))))

Theorem: cst-alignment-specifier-concs

(defthm cst-alignment-specifier-concs
 (implies
  (cst-list-list-alt-matchp
   abnf::cstss
   "%s\"_Alignas\" \"(\" type-name \")\" / %s\"_Alignas\" \"(\" constant-expression \")\"")
  (or (cst-list-list-conc-matchp abnf::cstss
                                 "%s\"_Alignas\" \"(\" type-name \")\"")
      (cst-list-list-conc-matchp
           abnf::cstss
           "%s\"_Alignas\" \"(\" constant-expression \")\""))))

Theorem: cst-declarator-concs

(defthm cst-declarator-concs
 (implies
  (cst-list-list-alt-matchp abnf::cstss
                            "[ pointer ] direct-declarator")
  (or (cst-list-list-conc-matchp abnf::cstss
                                 "[ pointer ] direct-declarator"))))

Theorem: cst-direct-declarator-concs

(defthm cst-direct-declarator-concs
 (implies
  (cst-list-list-alt-matchp
   abnf::cstss
   "identifier / \"(\" declarator \")\" / direct-declarator \"[\" [ type-qualifier-and-attribute-specifier-list ] [ assignment-expression ] \"]\" / direct-declarator \"[\" %s\"static\" [ type-qualifier-and-attribute-specifier-list ] assignment-expression \"]\" / direct-declarator \"[\" type-qualifier-and-attribute-specifier-list %s\"static\" assignment-expression \"]\" / direct-declarator \"[\" [ type-qualifier-and-attribute-specifier-list ] \"*\" \"]\" / direct-declarator \"(\" parameter-type-list \")\" / direct-declarator \"(\" [ identifier-list ] \")\"")
  (or
   (cst-list-list-conc-matchp abnf::cstss "identifier")
   (cst-list-list-conc-matchp abnf::cstss "\"(\" declarator \")\"")
   (cst-list-list-conc-matchp
    abnf::cstss
    "direct-declarator \"[\" [ type-qualifier-and-attribute-specifier-list ] [ assignment-expression ] \"]\"")
   (cst-list-list-conc-matchp
    abnf::cstss
    "direct-declarator \"[\" %s\"static\" [ type-qualifier-and-attribute-specifier-list ] assignment-expression \"]\"")
   (cst-list-list-conc-matchp
    abnf::cstss
    "direct-declarator \"[\" type-qualifier-and-attribute-specifier-list %s\"static\" assignment-expression \"]\"")
   (cst-list-list-conc-matchp
    abnf::cstss
    "direct-declarator \"[\" [ type-qualifier-and-attribute-specifier-list ] \"*\" \"]\"")
   (cst-list-list-conc-matchp
        abnf::cstss
        "direct-declarator \"(\" parameter-type-list \")\"")
   (cst-list-list-conc-matchp
        abnf::cstss
        "direct-declarator \"(\" [ identifier-list ] \")\""))))

Theorem: cst-pointer-concs

(defthm cst-pointer-concs
 (implies
  (cst-list-list-alt-matchp
   abnf::cstss
   "\"*\" [ type-qualifier-and-attribute-specifier-list ] / \"*\" [ type-qualifier-and-attribute-specifier-list ] pointer")
  (or
   (cst-list-list-conc-matchp
        abnf::cstss
        "\"*\" [ type-qualifier-and-attribute-specifier-list ]")
   (cst-list-list-conc-matchp
    abnf::cstss
    "\"*\" [ type-qualifier-and-attribute-specifier-list ] pointer"))))

Theorem: cst-type-qualifier-or-attribute-specifier-concs

(defthm cst-type-qualifier-or-attribute-specifier-concs
 (implies
  (cst-list-list-alt-matchp abnf::cstss
                            "type-qualifier / attribute-specifier")
  (or
    (cst-list-list-conc-matchp abnf::cstss "type-qualifier")
    (cst-list-list-conc-matchp abnf::cstss "attribute-specifier"))))

Theorem: cst-type-qualifier-and-attribute-specifier-list-concs

(defthm cst-type-qualifier-and-attribute-specifier-list-concs
 (implies
  (cst-list-list-alt-matchp
   abnf::cstss
   "type-qualifier-or-attribute-specifier / type-qualifier-and-attribute-specifier-list type-qualifier-or-attribute-specifier")
  (or
   (cst-list-list-conc-matchp
        abnf::cstss
        "type-qualifier-or-attribute-specifier")
   (cst-list-list-conc-matchp
    abnf::cstss
    "type-qualifier-and-attribute-specifier-list type-qualifier-or-attribute-specifier"))))

Theorem: cst-parameter-type-list-concs

(defthm cst-parameter-type-list-concs
  (implies
       (cst-list-list-alt-matchp
            abnf::cstss
            "parameter-list / parameter-list \",\" \"...\"")
       (or (cst-list-list-conc-matchp abnf::cstss "parameter-list")
           (cst-list-list-conc-matchp abnf::cstss
                                      "parameter-list \",\" \"...\""))))

Theorem: cst-parameter-list-concs

(defthm cst-parameter-list-concs
 (implies
  (cst-list-list-alt-matchp
   abnf::cstss
   "parameter-declaration / parameter-list \",\" parameter-declaration")
  (or
     (cst-list-list-conc-matchp abnf::cstss "parameter-declaration")
     (cst-list-list-conc-matchp
          abnf::cstss
          "parameter-list \",\" parameter-declaration"))))

Theorem: cst-parameter-declaration-concs

(defthm cst-parameter-declaration-concs
 (implies
  (cst-list-list-alt-matchp
   abnf::cstss
   "declaration-specifiers declarator *attribute-specifier / declaration-specifiers [ abstract-declarator ] *attribute-specifier")
  (or
   (cst-list-list-conc-matchp
        abnf::cstss
        "declaration-specifiers declarator *attribute-specifier")
   (cst-list-list-conc-matchp
    abnf::cstss
    "declaration-specifiers [ abstract-declarator ] *attribute-specifier"))))

Theorem: cst-identifier-list-concs

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

Theorem: cst-type-name-concs

(defthm cst-type-name-concs
 (implies
     (cst-list-list-alt-matchp
          abnf::cstss
          "specifier-qualifier-list [ abstract-declarator ]")
     (or (cst-list-list-conc-matchp
              abnf::cstss
              "specifier-qualifier-list [ abstract-declarator ]"))))

Theorem: cst-abstract-declarator-concs

(defthm cst-abstract-declarator-concs
  (implies (cst-list-list-alt-matchp
                abnf::cstss
                "pointer / [ pointer ] direct-abstract-declarator")
           (or (cst-list-list-conc-matchp abnf::cstss "pointer")
               (cst-list-list-conc-matchp
                    abnf::cstss
                    "[ pointer ] direct-abstract-declarator"))))

Theorem: cst-direct-abstract-declarator-concs

(defthm cst-direct-abstract-declarator-concs
 (implies
  (cst-list-list-alt-matchp
   abnf::cstss
   "\"(\" abstract-declarator \")\" / [ direct-abstract-declarator ] \"[\" [ type-qualifier-and-attribute-specifier-list ] [ assignment-expression ] \"]\" / [ direct-abstract-declarator ] \"[\" %s\"static\" [ type-qualifier-and-attribute-specifier-list ] assignment-expression \"]\" / [ direct-abstract-declarator ] \"[\" type-qualifier-and-attribute-specifier-list %s\"static\" assignment-expression \"]\" / [ direct-abstract-declarator ] \"[\" \"*\" \"]\" / [ direct-abstract-declarator ] \"(\" [ parameter-type-list ] \")\"")
  (or
   (cst-list-list-conc-matchp abnf::cstss
                              "\"(\" abstract-declarator \")\"")
   (cst-list-list-conc-matchp
    abnf::cstss
    "[ direct-abstract-declarator ] \"[\" [ type-qualifier-and-attribute-specifier-list ] [ assignment-expression ] \"]\"")
   (cst-list-list-conc-matchp
    abnf::cstss
    "[ direct-abstract-declarator ] \"[\" %s\"static\" [ type-qualifier-and-attribute-specifier-list ] assignment-expression \"]\"")
   (cst-list-list-conc-matchp
    abnf::cstss
    "[ direct-abstract-declarator ] \"[\" type-qualifier-and-attribute-specifier-list %s\"static\" assignment-expression \"]\"")
   (cst-list-list-conc-matchp
        abnf::cstss
        "[ direct-abstract-declarator ] \"[\" \"*\" \"]\"")
   (cst-list-list-conc-matchp
    abnf::cstss
    "[ direct-abstract-declarator ] \"(\" [ parameter-type-list ] \")\""))))

Theorem: cst-typedef-name-concs

(defthm cst-typedef-name-concs
  (implies
       (cst-list-list-alt-matchp abnf::cstss "identifier")
       (or (cst-list-list-conc-matchp abnf::cstss "identifier"))))

Theorem: cst-initializer-concs

(defthm cst-initializer-concs
 (implies
  (cst-list-list-alt-matchp
   abnf::cstss
   "assignment-expression / \"{\" initializer-list \"}\" / \"{\" initializer-list \",\" \"}\" / \"{\" \"}\"")
  (or
     (cst-list-list-conc-matchp abnf::cstss "assignment-expression")
     (cst-list-list-conc-matchp
          abnf::cstss "\"{\" initializer-list \"}\"")
     (cst-list-list-conc-matchp abnf::cstss
                                "\"{\" initializer-list \",\" \"}\"")
     (cst-list-list-conc-matchp abnf::cstss "\"{\" \"}\""))))

Theorem: cst-initializer-list-concs

(defthm cst-initializer-list-concs
 (implies
  (cst-list-list-alt-matchp
   abnf::cstss
   "[ designation ] initializer / initializer-list \",\" [ designation ] initializer")
  (or (cst-list-list-conc-matchp abnf::cstss
                                 "[ designation ] initializer")
      (cst-list-list-conc-matchp
           abnf::cstss
           "initializer-list \",\" [ designation ] initializer"))))

Theorem: cst-designation-concs

(defthm cst-designation-concs
 (implies
  (cst-list-list-alt-matchp abnf::cstss "designator-list \"=\"")
  (or
    (cst-list-list-conc-matchp abnf::cstss "designator-list \"=\""))))

Theorem: cst-designator-list-concs

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

Theorem: cst-designator-concs

(defthm cst-designator-concs
 (implies
  (cst-list-list-alt-matchp
   abnf::cstss
   "\"[\" constant-expression [ \"...\" constant-expression ] \"]\" / \".\" identifier")
  (or
   (cst-list-list-conc-matchp
        abnf::cstss
        "\"[\" constant-expression [ \"...\" constant-expression ] \"]\"")
   (cst-list-list-conc-matchp abnf::cstss "\".\" identifier"))))

Theorem: cst-static-assert-declaration-concs

(defthm cst-static-assert-declaration-concs
 (implies
  (cst-list-list-alt-matchp
   abnf::cstss
   "%s\"_Static_assert\" \"(\" constant-expression \",\" 1*string-literal \")\" \";\"")
  (or
   (cst-list-list-conc-matchp
    abnf::cstss
    "%s\"_Static_assert\" \"(\" constant-expression \",\" 1*string-literal \")\" \";\""))))

Theorem: cst-statement-concs

(defthm cst-statement-concs
 (implies
  (cst-list-list-alt-matchp
   abnf::cstss
   "labeled-statement / compound-statement / expression-statement / selection-statement / iteration-statement / jump-statement / asm-statement")
  (or (cst-list-list-conc-matchp abnf::cstss "labeled-statement")
      (cst-list-list-conc-matchp abnf::cstss "compound-statement")
      (cst-list-list-conc-matchp abnf::cstss "expression-statement")
      (cst-list-list-conc-matchp abnf::cstss "selection-statement")
      (cst-list-list-conc-matchp abnf::cstss "iteration-statement")
      (cst-list-list-conc-matchp abnf::cstss "jump-statement")
      (cst-list-list-conc-matchp abnf::cstss "asm-statement"))))

Theorem: cst-labeled-statement-concs

(defthm cst-labeled-statement-concs
 (implies
  (cst-list-list-alt-matchp
   abnf::cstss
   "identifier \":\" *attribute-specifier statement / %s\"case\" constant-expression [ \"...\" constant-expression ] \":\" statement / %s\"default\" \":\" statement")
  (or
   (cst-list-list-conc-matchp
        abnf::cstss
        "identifier \":\" *attribute-specifier statement")
   (cst-list-list-conc-matchp
    abnf::cstss
    "%s\"case\" constant-expression [ \"...\" constant-expression ] \":\" statement")
   (cst-list-list-conc-matchp abnf::cstss
                              "%s\"default\" \":\" statement"))))

Theorem: cst-label-declaration-concs

(defthm cst-label-declaration-concs
 (implies
     (cst-list-list-alt-matchp
          abnf::cstss
          "%s\"__label__\" identifier *( \",\" identifier ) \";\"")
     (or (cst-list-list-conc-matchp
              abnf::cstss
              "%s\"__label__\" identifier *( \",\" identifier ) \";\""))))

Theorem: cst-compound-statement-concs

(defthm cst-compound-statement-concs
  (implies
       (cst-list-list-alt-matchp
            abnf::cstss
            "\"{\" *label-declaration [ block-item-list ] \"}\"")
       (or (cst-list-list-conc-matchp
                abnf::cstss
                "\"{\" *label-declaration [ block-item-list ] \"}\""))))

Theorem: cst-block-item-list-concs

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

Theorem: cst-block-item-concs

(defthm cst-block-item-concs
 (implies
    (cst-list-list-alt-matchp abnf::cstss "declaration / statement")
    (or (cst-list-list-conc-matchp abnf::cstss "declaration")
        (cst-list-list-conc-matchp abnf::cstss "statement"))))

Theorem: cst-expression-statement-concs

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

Theorem: cst-selection-statement-concs

(defthm cst-selection-statement-concs
 (implies
  (cst-list-list-alt-matchp
   abnf::cstss
   "%s\"if\" \"(\" expression \")\" statement / %s\"if\" \"(\" expression \")\" statement %s\"else\" statement / %s\"switch\" \"(\" expression \")\" statement")
  (or
   (cst-list-list-conc-matchp abnf::cstss
                              "%s\"if\" \"(\" expression \")\" statement")
   (cst-list-list-conc-matchp
        abnf::cstss
        "%s\"if\" \"(\" expression \")\" statement %s\"else\" statement")
   (cst-list-list-conc-matchp
        abnf::cstss
        "%s\"switch\" \"(\" expression \")\" statement"))))

Theorem: cst-iteration-statement-concs

(defthm cst-iteration-statement-concs
 (implies
  (cst-list-list-alt-matchp
   abnf::cstss
   "%s\"while\" \"(\" expression \")\" statement / %s\"do\" statement %s\"while\" \"(\" expression \")\" \";\" / %s\"for\" \"(\" [ expression ] \";\" [ expression ] \";\" [ expression ] \")\" statement / %s\"for\" \"(\" declaration [ expression ] \";\" [ expression ] \")\" statement")
  (or
   (cst-list-list-conc-matchp
        abnf::cstss
        "%s\"while\" \"(\" expression \")\" statement")
   (cst-list-list-conc-matchp
        abnf::cstss
        "%s\"do\" statement %s\"while\" \"(\" expression \")\" \";\"")
   (cst-list-list-conc-matchp
    abnf::cstss
    "%s\"for\" \"(\" [ expression ] \";\" [ expression ] \";\" [ expression ] \")\" statement")
   (cst-list-list-conc-matchp
    abnf::cstss
    "%s\"for\" \"(\" declaration [ expression ] \";\" [ expression ] \")\" statement"))))

Theorem: cst-jump-statement-concs

(defthm cst-jump-statement-concs
 (implies
  (cst-list-list-alt-matchp
   abnf::cstss
   "%s\"goto\" identifier \";\" / %s\"goto\" expression \";\" / %s\"continue\" \";\" / %s\"break\" \";\" / %s\"return\" [ expression ] \";\"")
  (or
   (cst-list-list-conc-matchp abnf::cstss "%s\"goto\" identifier \";\"")
   (cst-list-list-conc-matchp abnf::cstss "%s\"goto\" expression \";\"")
   (cst-list-list-conc-matchp abnf::cstss "%s\"continue\" \";\"")
   (cst-list-list-conc-matchp abnf::cstss "%s\"break\" \";\"")
   (cst-list-list-conc-matchp abnf::cstss
                              "%s\"return\" [ expression ] \";\""))))

Theorem: cst-translation-unit-concs

(defthm cst-translation-unit-concs
 (implies
      (cst-list-list-alt-matchp abnf::cstss "*external-declaration")
      (or (cst-list-list-conc-matchp
               abnf::cstss "*external-declaration"))))

Theorem: cst-external-declaration-concs

(defthm cst-external-declaration-concs
 (implies
   (cst-list-list-alt-matchp
        abnf::cstss
        "function-definition / declaration / \";\" / asm-statement")
   (or (cst-list-list-conc-matchp abnf::cstss "function-definition")
       (cst-list-list-conc-matchp abnf::cstss "declaration")
       (cst-list-list-conc-matchp abnf::cstss "\";\"")
       (cst-list-list-conc-matchp abnf::cstss "asm-statement"))))

Theorem: cst-function-definition-concs

(defthm cst-function-definition-concs
 (implies
  (cst-list-list-alt-matchp
   abnf::cstss
   "[ %s\"__extension__\" ] declaration-specifiers declarator [ asm-name-specifier ] *attribute-specifier [ declaration-list ] compound-statement")
  (or
   (cst-list-list-conc-matchp
    abnf::cstss
    "[ %s\"__extension__\" ] declaration-specifiers declarator [ asm-name-specifier ] *attribute-specifier [ declaration-list ] compound-statement"))))

Theorem: cst-declaration-list-concs

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

Theorem: cst-preprocessing-file-concs

(defthm cst-preprocessing-file-concs
 (implies (cst-list-list-alt-matchp abnf::cstss "[ group ]")
          (or (cst-list-list-conc-matchp abnf::cstss "[ group ]"))))

Theorem: cst-group-concs

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

Theorem: cst-group-part-concs

(defthm cst-group-part-concs
 (implies
  (cst-list-list-alt-matchp
       abnf::cstss
       "if-section / control-line / text-line / \"#\" non-directive")
  (or (cst-list-list-conc-matchp abnf::cstss "if-section")
      (cst-list-list-conc-matchp abnf::cstss "control-line")
      (cst-list-list-conc-matchp abnf::cstss "text-line")
      (cst-list-list-conc-matchp abnf::cstss "\"#\" non-directive"))))

Theorem: cst-if-section-concs

(defthm cst-if-section-concs
 (implies
   (cst-list-list-alt-matchp
        abnf::cstss
        "if-group [ elif-groups ] [ else-group ] endif-line")
   (or (cst-list-list-conc-matchp
            abnf::cstss
            "if-group [ elif-groups ] [ else-group ] endif-line"))))

Theorem: cst-if-group-concs

(defthm cst-if-group-concs
 (implies
  (cst-list-list-alt-matchp
   abnf::cstss
   "\"#\" %s\"if\" constant-expression new-line [ group ] / \"#\" %s\"ifdef\" identifier new-line [ group ] / \"#\" %s\"ifndef\" identifier new-line [ group ]")
  (or (cst-list-list-conc-matchp
           abnf::cstss
           "\"#\" %s\"if\" constant-expression new-line [ group ]")
      (cst-list-list-conc-matchp
           abnf::cstss
           "\"#\" %s\"ifdef\" identifier new-line [ group ]")
      (cst-list-list-conc-matchp
           abnf::cstss
           "\"#\" %s\"ifndef\" identifier new-line [ group ]"))))

Theorem: cst-elif-groups-concs

(defthm cst-elif-groups-concs
 (implies
    (cst-list-list-alt-matchp abnf::cstss
                              "elif-group / elif-groups elif-group")
    (or (cst-list-list-conc-matchp abnf::cstss "elif-group")
        (cst-list-list-conc-matchp
             abnf::cstss "elif-groups elif-group"))))

Theorem: cst-elif-group-concs

(defthm cst-elif-group-concs
 (implies
  (cst-list-list-alt-matchp
       abnf::cstss
       "\"#\" %s\"elif\" constant-expression new-line [ group ]")
  (or (cst-list-list-conc-matchp
           abnf::cstss
           "\"#\" %s\"elif\" constant-expression new-line [ group ]"))))

Theorem: cst-else-group-concs

(defthm cst-else-group-concs
 (implies
  (cst-list-list-alt-matchp abnf::cstss
                            "\"#\" %s\"else\" new-line [ group ]")
  (or
    (cst-list-list-conc-matchp abnf::cstss
                               "\"#\" %s\"else\" new-line [ group ]"))))

Theorem: cst-endif-line-concs

(defthm cst-endif-line-concs
 (implies
     (cst-list-list-alt-matchp abnf::cstss "\"#\" %s\"endif\" new-line")
     (or (cst-list-list-conc-matchp
              abnf::cstss "\"#\" %s\"endif\" new-line"))))

Theorem: cst-control-line-concs

(defthm cst-control-line-concs
 (implies
  (cst-list-list-alt-matchp
   abnf::cstss
   "\"#\" %s\"include\" pp-tokens new-line / \"#\" %s\"define\" identifier replacement-list new-line / \"#\" %s\"define\" identifier lparen [ identifier-list ] \")\" replacement-list new-line / \"#\" %s\"define\" identifier lparen \"...\" \")\" replacement-list new-line / \"#\" %s\"define\" identifier lparen identifier-list \",\" \"...\" \")\" replacement-list new-line / \"#\" %s\"undef\" identifier new-line / \"#\" %s\"line\" pp-tokens new-line / \"#\" %s\"error\" [ pp-tokens ] new-line / \"#\" %s\"pragma\" [ pp-tokens ] new-line / \"#\" new-line")
  (or
   (cst-list-list-conc-matchp abnf::cstss
                              "\"#\" %s\"include\" pp-tokens new-line")
   (cst-list-list-conc-matchp
        abnf::cstss
        "\"#\" %s\"define\" identifier replacement-list new-line")
   (cst-list-list-conc-matchp
    abnf::cstss
    "\"#\" %s\"define\" identifier lparen [ identifier-list ] \")\" replacement-list new-line")
   (cst-list-list-conc-matchp
    abnf::cstss
    "\"#\" %s\"define\" identifier lparen \"...\" \")\" replacement-list new-line")
   (cst-list-list-conc-matchp
    abnf::cstss
    "\"#\" %s\"define\" identifier lparen identifier-list \",\" \"...\" \")\" replacement-list new-line")
   (cst-list-list-conc-matchp abnf::cstss
                              "\"#\" %s\"undef\" identifier new-line")
   (cst-list-list-conc-matchp abnf::cstss
                              "\"#\" %s\"line\" pp-tokens new-line")
   (cst-list-list-conc-matchp
        abnf::cstss
        "\"#\" %s\"error\" [ pp-tokens ] new-line")
   (cst-list-list-conc-matchp
        abnf::cstss
        "\"#\" %s\"pragma\" [ pp-tokens ] new-line")
   (cst-list-list-conc-matchp abnf::cstss "\"#\" new-line"))))

Theorem: cst-text-line-concs

(defthm cst-text-line-concs
 (implies
     (cst-list-list-alt-matchp abnf::cstss "[ pp-tokens ] new-line")
     (or (cst-list-list-conc-matchp
              abnf::cstss "[ pp-tokens ] new-line"))))

Theorem: cst-non-directive-concs

(defthm cst-non-directive-concs
 (implies
  (cst-list-list-alt-matchp abnf::cstss "pp-tokens new-line")
  (or
     (cst-list-list-conc-matchp abnf::cstss "pp-tokens new-line"))))

Theorem: cst-lparen-concs

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

Theorem: cst-replacement-list-concs

(defthm cst-replacement-list-concs
 (implies
      (cst-list-list-alt-matchp abnf::cstss "[ pp-tokens ]")
      (or (cst-list-list-conc-matchp abnf::cstss "[ pp-tokens ]"))))

Theorem: cst-pp-tokens-concs

(defthm cst-pp-tokens-concs
 (implies
  (cst-list-list-alt-matchp
       abnf::cstss
       "preprocessing-token / pp-tokens preprocessing-token")
  (or (cst-list-list-conc-matchp abnf::cstss "preprocessing-token")
      (cst-list-list-conc-matchp abnf::cstss
                                 "pp-tokens preprocessing-token"))))

Theorem: cst-on-off-switch-concs

(defthm cst-on-off-switch-concs
  (implies
       (cst-list-list-alt-matchp abnf::cstss
                                 "%s\"ON\" / %s\"OFF\" / %s\"DEFAULT\"")
       (or (cst-list-list-conc-matchp abnf::cstss "%s\"ON\"")
           (cst-list-list-conc-matchp abnf::cstss "%s\"OFF\"")
           (cst-list-list-conc-matchp abnf::cstss "%s\"DEFAULT\""))))

Theorem: cst-uppercase-letter-conc-matching

(defthm cst-uppercase-letter-conc-matching
  (implies (cst-list-list-conc-matchp abnf::cstss "%x41-5A")
           (and (equal (len abnf::cstss) 1)
                (cst-list-rep-matchp (nth 0 abnf::cstss)
                                     "%x41-5A"))))

Theorem: cst-lowercase-letter-conc-matching

(defthm cst-lowercase-letter-conc-matching
  (implies (cst-list-list-conc-matchp abnf::cstss "%x61-7A")
           (and (equal (len abnf::cstss) 1)
                (cst-list-rep-matchp (nth 0 abnf::cstss)
                                     "%x61-7A"))))

Theorem: cst-letter-conc1-matching

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

Theorem: cst-letter-conc2-matching

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

Theorem: cst-digit-conc-matching

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

Theorem: cst-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-graphic-character-conc1-matching

(defthm cst-graphic-character-conc1-matching
  (implies (cst-list-list-conc-matchp abnf::cstss "%x21-23")
           (and (equal (len abnf::cstss) 1)
                (cst-list-rep-matchp (nth 0 abnf::cstss)
                                     "%x21-23"))))

Theorem: cst-graphic-character-conc2-matching

(defthm cst-graphic-character-conc2-matching
  (implies (cst-list-list-conc-matchp abnf::cstss "%x25-2F")
           (and (equal (len abnf::cstss) 1)
                (cst-list-rep-matchp (nth 0 abnf::cstss)
                                     "%x25-2F"))))

Theorem: cst-graphic-character-conc3-matching

(defthm cst-graphic-character-conc3-matching
  (implies (cst-list-list-conc-matchp abnf::cstss "%x3A-3F")
           (and (equal (len abnf::cstss) 1)
                (cst-list-rep-matchp (nth 0 abnf::cstss)
                                     "%x3A-3F"))))

Theorem: cst-graphic-character-conc4-matching

(defthm cst-graphic-character-conc4-matching
  (implies (cst-list-list-conc-matchp abnf::cstss "%x5B-5F")
           (and (equal (len abnf::cstss) 1)
                (cst-list-rep-matchp (nth 0 abnf::cstss)
                                     "%x5B-5F"))))

Theorem: cst-graphic-character-conc5-matching

(defthm cst-graphic-character-conc5-matching
  (implies (cst-list-list-conc-matchp abnf::cstss "%x7B-7E")
           (and (equal (len abnf::cstss) 1)
                (cst-list-rep-matchp (nth 0 abnf::cstss)
                                     "%x7B-7E"))))

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-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-vertical-tab-conc-matching

(defthm cst-vertical-tab-conc-matching
  (implies (cst-list-list-conc-matchp abnf::cstss "%xB")
           (and (equal (len abnf::cstss) 1)
                (cst-list-rep-matchp (nth 0 abnf::cstss)
                                     "%xB"))))

Theorem: cst-form-feed-conc-matching

(defthm cst-form-feed-conc-matching
  (implies (cst-list-list-conc-matchp abnf::cstss "%xC")
           (and (equal (len abnf::cstss) 1)
                (cst-list-rep-matchp (nth 0 abnf::cstss)
                                     "%xC"))))

Theorem: cst-control-character-conc1-matching

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

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

Theorem: cst-control-character-conc3-matching

(defthm cst-control-character-conc3-matching
  (implies (cst-list-list-conc-matchp abnf::cstss "form-feed")
           (and (equal (len abnf::cstss) 1)
                (cst-list-rep-matchp (nth 0 abnf::cstss)
                                     "form-feed"))))

Theorem: cst-basic-character-conc1-matching

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

Theorem: cst-basic-character-conc2-matching

(defthm cst-basic-character-conc2-matching
  (implies (cst-list-list-conc-matchp abnf::cstss "digit")
           (and (equal (len abnf::cstss) 1)
                (cst-list-rep-matchp (nth 0 abnf::cstss)
                                     "digit"))))

Theorem: cst-basic-character-conc3-matching

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

Theorem: cst-basic-character-conc4-matching

(defthm cst-basic-character-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-basic-character-conc5-matching

(defthm cst-basic-character-conc5-matching
  (implies
       (cst-list-list-conc-matchp abnf::cstss "control-character")
       (and (equal (len abnf::cstss) 1)
            (cst-list-rep-matchp (nth 0 abnf::cstss)
                                 "control-character"))))

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-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-extended-character-conc1-matching

(defthm cst-extended-character-conc1-matching
  (implies (cst-list-list-conc-matchp abnf::cstss "%x24")
           (and (equal (len abnf::cstss) 1)
                (cst-list-rep-matchp (nth 0 abnf::cstss)
                                     "%x24"))))

Theorem: cst-extended-character-conc2-matching

(defthm cst-extended-character-conc2-matching
  (implies (cst-list-list-conc-matchp abnf::cstss "%x40")
           (and (equal (len abnf::cstss) 1)
                (cst-list-rep-matchp (nth 0 abnf::cstss)
                                     "%x40"))))

Theorem: cst-extended-character-conc3-matching

(defthm cst-extended-character-conc3-matching
  (implies (cst-list-list-conc-matchp abnf::cstss "%x60")
           (and (equal (len abnf::cstss) 1)
                (cst-list-rep-matchp (nth 0 abnf::cstss)
                                     "%x60"))))

Theorem: cst-extended-character-conc4-matching

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

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

(defthm cst-extended-character-conc6-matching
  (implies (cst-list-list-conc-matchp abnf::cstss "safe-nonascii")
           (and (equal (len abnf::cstss) 1)
                (cst-list-rep-matchp (nth 0 abnf::cstss)
                                     "safe-nonascii"))))

Theorem: cst-character-conc1-matching

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

Theorem: cst-character-conc2-matching

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

Theorem: cst-new-line-conc1-matching

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

(defthm cst-new-line-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-extended-character-not-new-line-conc1-matching

(defthm cst-extended-character-not-new-line-conc1-matching
  (implies (cst-list-list-conc-matchp abnf::cstss "%x24")
           (and (equal (len abnf::cstss) 1)
                (cst-list-rep-matchp (nth 0 abnf::cstss)
                                     "%x24"))))

Theorem: cst-extended-character-not-new-line-conc2-matching

(defthm cst-extended-character-not-new-line-conc2-matching
  (implies (cst-list-list-conc-matchp abnf::cstss "%x40")
           (and (equal (len abnf::cstss) 1)
                (cst-list-rep-matchp (nth 0 abnf::cstss)
                                     "%x40"))))

Theorem: cst-extended-character-not-new-line-conc3-matching

(defthm cst-extended-character-not-new-line-conc3-matching
  (implies (cst-list-list-conc-matchp abnf::cstss "%x60")
           (and (equal (len abnf::cstss) 1)
                (cst-list-rep-matchp (nth 0 abnf::cstss)
                                     "%x60"))))

Theorem: cst-extended-character-not-new-line-conc4-matching

(defthm cst-extended-character-not-new-line-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-graphic-character-not-star-conc1-matching

(defthm cst-graphic-character-not-star-conc1-matching
  (implies (cst-list-list-conc-matchp abnf::cstss "%x21-23")
           (and (equal (len abnf::cstss) 1)
                (cst-list-rep-matchp (nth 0 abnf::cstss)
                                     "%x21-23"))))

Theorem: cst-graphic-character-not-star-conc2-matching

(defthm cst-graphic-character-not-star-conc2-matching
  (implies (cst-list-list-conc-matchp abnf::cstss "%x25-29")
           (and (equal (len abnf::cstss) 1)
                (cst-list-rep-matchp (nth 0 abnf::cstss)
                                     "%x25-29"))))

Theorem: cst-graphic-character-not-star-conc3-matching

(defthm cst-graphic-character-not-star-conc3-matching
  (implies (cst-list-list-conc-matchp abnf::cstss "%x2B-2F")
           (and (equal (len abnf::cstss) 1)
                (cst-list-rep-matchp (nth 0 abnf::cstss)
                                     "%x2B-2F"))))

Theorem: cst-graphic-character-not-star-conc4-matching

(defthm cst-graphic-character-not-star-conc4-matching
  (implies (cst-list-list-conc-matchp abnf::cstss "%x3A-3F")
           (and (equal (len abnf::cstss) 1)
                (cst-list-rep-matchp (nth 0 abnf::cstss)
                                     "%x3A-3F"))))

Theorem: cst-graphic-character-not-star-conc5-matching

(defthm cst-graphic-character-not-star-conc5-matching
  (implies (cst-list-list-conc-matchp abnf::cstss "%x5B-5F")
           (and (equal (len abnf::cstss) 1)
                (cst-list-rep-matchp (nth 0 abnf::cstss)
                                     "%x5B-5F"))))

Theorem: cst-graphic-character-not-star-conc6-matching

(defthm cst-graphic-character-not-star-conc6-matching
  (implies (cst-list-list-conc-matchp abnf::cstss "%x7B-7E")
           (and (equal (len abnf::cstss) 1)
                (cst-list-rep-matchp (nth 0 abnf::cstss)
                                     "%x7B-7E"))))

Theorem: cst-graphic-character-not-greater-than-conc1-matching

(defthm cst-graphic-character-not-greater-than-conc1-matching
  (implies (cst-list-list-conc-matchp abnf::cstss "%x21-23")
           (and (equal (len abnf::cstss) 1)
                (cst-list-rep-matchp (nth 0 abnf::cstss)
                                     "%x21-23"))))

Theorem: cst-graphic-character-not-greater-than-conc2-matching

(defthm cst-graphic-character-not-greater-than-conc2-matching
  (implies (cst-list-list-conc-matchp abnf::cstss "%x25-2F")
           (and (equal (len abnf::cstss) 1)
                (cst-list-rep-matchp (nth 0 abnf::cstss)
                                     "%x25-2F"))))

Theorem: cst-graphic-character-not-greater-than-conc3-matching

(defthm cst-graphic-character-not-greater-than-conc3-matching
  (implies (cst-list-list-conc-matchp abnf::cstss "%x3A-3D")
           (and (equal (len abnf::cstss) 1)
                (cst-list-rep-matchp (nth 0 abnf::cstss)
                                     "%x3A-3D"))))

Theorem: cst-graphic-character-not-greater-than-conc4-matching

(defthm cst-graphic-character-not-greater-than-conc4-matching
  (implies (cst-list-list-conc-matchp abnf::cstss "%x3F")
           (and (equal (len abnf::cstss) 1)
                (cst-list-rep-matchp (nth 0 abnf::cstss)
                                     "%x3F"))))

Theorem: cst-graphic-character-not-greater-than-conc5-matching

(defthm cst-graphic-character-not-greater-than-conc5-matching
  (implies (cst-list-list-conc-matchp abnf::cstss "%x5B-5F")
           (and (equal (len abnf::cstss) 1)
                (cst-list-rep-matchp (nth 0 abnf::cstss)
                                     "%x5B-5F"))))

Theorem: cst-graphic-character-not-greater-than-conc6-matching

(defthm cst-graphic-character-not-greater-than-conc6-matching
  (implies (cst-list-list-conc-matchp abnf::cstss "%x7B-7E")
           (and (equal (len abnf::cstss) 1)
                (cst-list-rep-matchp (nth 0 abnf::cstss)
                                     "%x7B-7E"))))

Theorem: cst-graphic-character-not-double-quote-conc1-matching

(defthm cst-graphic-character-not-double-quote-conc1-matching
  (implies (cst-list-list-conc-matchp abnf::cstss "%x21")
           (and (equal (len abnf::cstss) 1)
                (cst-list-rep-matchp (nth 0 abnf::cstss)
                                     "%x21"))))

Theorem: cst-graphic-character-not-double-quote-conc2-matching

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

Theorem: cst-graphic-character-not-double-quote-conc3-matching

(defthm cst-graphic-character-not-double-quote-conc3-matching
  (implies (cst-list-list-conc-matchp abnf::cstss "%x25-2F")
           (and (equal (len abnf::cstss) 1)
                (cst-list-rep-matchp (nth 0 abnf::cstss)
                                     "%x25-2F"))))

Theorem: cst-graphic-character-not-double-quote-conc4-matching

(defthm cst-graphic-character-not-double-quote-conc4-matching
  (implies (cst-list-list-conc-matchp abnf::cstss "%x3A-3F")
           (and (equal (len abnf::cstss) 1)
                (cst-list-rep-matchp (nth 0 abnf::cstss)
                                     "%x3A-3F"))))

Theorem: cst-graphic-character-not-double-quote-conc5-matching

(defthm cst-graphic-character-not-double-quote-conc5-matching
  (implies (cst-list-list-conc-matchp abnf::cstss "%x5B-5F")
           (and (equal (len abnf::cstss) 1)
                (cst-list-rep-matchp (nth 0 abnf::cstss)
                                     "%x5B-5F"))))

Theorem: cst-graphic-character-not-double-quote-conc6-matching

(defthm cst-graphic-character-not-double-quote-conc6-matching
  (implies (cst-list-list-conc-matchp abnf::cstss "%x7B-7E")
           (and (equal (len abnf::cstss) 1)
                (cst-list-rep-matchp (nth 0 abnf::cstss)
                                     "%x7B-7E"))))

Theorem: cst-graphic-character-not-star-or-slash-conc1-matching

(defthm cst-graphic-character-not-star-or-slash-conc1-matching
  (implies (cst-list-list-conc-matchp abnf::cstss "%x21-23")
           (and (equal (len abnf::cstss) 1)
                (cst-list-rep-matchp (nth 0 abnf::cstss)
                                     "%x21-23"))))

Theorem: cst-graphic-character-not-star-or-slash-conc2-matching

(defthm cst-graphic-character-not-star-or-slash-conc2-matching
  (implies (cst-list-list-conc-matchp abnf::cstss "%x25-29")
           (and (equal (len abnf::cstss) 1)
                (cst-list-rep-matchp (nth 0 abnf::cstss)
                                     "%x25-29"))))

Theorem: cst-graphic-character-not-star-or-slash-conc3-matching

(defthm cst-graphic-character-not-star-or-slash-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-graphic-character-not-star-or-slash-conc4-matching

(defthm cst-graphic-character-not-star-or-slash-conc4-matching
  (implies (cst-list-list-conc-matchp abnf::cstss "%x3A-3F")
           (and (equal (len abnf::cstss) 1)
                (cst-list-rep-matchp (nth 0 abnf::cstss)
                                     "%x3A-3F"))))

Theorem: cst-graphic-character-not-star-or-slash-conc5-matching

(defthm cst-graphic-character-not-star-or-slash-conc5-matching
  (implies (cst-list-list-conc-matchp abnf::cstss "%x5B-5F")
           (and (equal (len abnf::cstss) 1)
                (cst-list-rep-matchp (nth 0 abnf::cstss)
                                     "%x5B-5F"))))

Theorem: cst-graphic-character-not-star-or-slash-conc6-matching

(defthm cst-graphic-character-not-star-or-slash-conc6-matching
  (implies (cst-list-list-conc-matchp abnf::cstss "%x7B-7E")
           (and (equal (len abnf::cstss) 1)
                (cst-list-rep-matchp (nth 0 abnf::cstss)
                                     "%x7B-7E"))))

Theorem: cst-graphic-character-not-single-quote-or-backslash-conc1-matching

(defthm
 cst-graphic-character-not-single-quote-or-backslash-conc1-matching
 (implies (cst-list-list-conc-matchp abnf::cstss "%x21-23")
          (and (equal (len abnf::cstss) 1)
               (cst-list-rep-matchp (nth 0 abnf::cstss)
                                    "%x21-23"))))

Theorem: cst-graphic-character-not-single-quote-or-backslash-conc2-matching

(defthm
 cst-graphic-character-not-single-quote-or-backslash-conc2-matching
 (implies (cst-list-list-conc-matchp abnf::cstss "%x25-26")
          (and (equal (len abnf::cstss) 1)
               (cst-list-rep-matchp (nth 0 abnf::cstss)
                                    "%x25-26"))))

Theorem: cst-graphic-character-not-single-quote-or-backslash-conc3-matching

(defthm
 cst-graphic-character-not-single-quote-or-backslash-conc3-matching
 (implies (cst-list-list-conc-matchp abnf::cstss "%x28-2F")
          (and (equal (len abnf::cstss) 1)
               (cst-list-rep-matchp (nth 0 abnf::cstss)
                                    "%x28-2F"))))

Theorem: cst-graphic-character-not-single-quote-or-backslash-conc4-matching

(defthm
 cst-graphic-character-not-single-quote-or-backslash-conc4-matching
 (implies (cst-list-list-conc-matchp abnf::cstss "%x3A-3F")
          (and (equal (len abnf::cstss) 1)
               (cst-list-rep-matchp (nth 0 abnf::cstss)
                                    "%x3A-3F"))))

Theorem: cst-graphic-character-not-single-quote-or-backslash-conc5-matching

(defthm
 cst-graphic-character-not-single-quote-or-backslash-conc5-matching
 (implies (cst-list-list-conc-matchp abnf::cstss "%x5B")
          (and (equal (len abnf::cstss) 1)
               (cst-list-rep-matchp (nth 0 abnf::cstss)
                                    "%x5B"))))

Theorem: cst-graphic-character-not-single-quote-or-backslash-conc6-matching

(defthm
 cst-graphic-character-not-single-quote-or-backslash-conc6-matching
 (implies (cst-list-list-conc-matchp abnf::cstss "%x5D-5F")
          (and (equal (len abnf::cstss) 1)
               (cst-list-rep-matchp (nth 0 abnf::cstss)
                                    "%x5D-5F"))))

Theorem: cst-graphic-character-not-single-quote-or-backslash-conc7-matching

(defthm
 cst-graphic-character-not-single-quote-or-backslash-conc7-matching
 (implies (cst-list-list-conc-matchp abnf::cstss "%x7B-7E")
          (and (equal (len abnf::cstss) 1)
               (cst-list-rep-matchp (nth 0 abnf::cstss)
                                    "%x7B-7E"))))

Theorem: cst-graphic-character-not-double-quote-or-backslash-conc1-matching

(defthm
 cst-graphic-character-not-double-quote-or-backslash-conc1-matching
 (implies (cst-list-list-conc-matchp abnf::cstss "%x21")
          (and (equal (len abnf::cstss) 1)
               (cst-list-rep-matchp (nth 0 abnf::cstss)
                                    "%x21"))))

Theorem: cst-graphic-character-not-double-quote-or-backslash-conc2-matching

(defthm
 cst-graphic-character-not-double-quote-or-backslash-conc2-matching
 (implies (cst-list-list-conc-matchp abnf::cstss "%x23")
          (and (equal (len abnf::cstss) 1)
               (cst-list-rep-matchp (nth 0 abnf::cstss)
                                    "%x23"))))

Theorem: cst-graphic-character-not-double-quote-or-backslash-conc3-matching

(defthm
 cst-graphic-character-not-double-quote-or-backslash-conc3-matching
 (implies (cst-list-list-conc-matchp abnf::cstss "%x25-2F")
          (and (equal (len abnf::cstss) 1)
               (cst-list-rep-matchp (nth 0 abnf::cstss)
                                    "%x25-2F"))))

Theorem: cst-graphic-character-not-double-quote-or-backslash-conc4-matching

(defthm
 cst-graphic-character-not-double-quote-or-backslash-conc4-matching
 (implies (cst-list-list-conc-matchp abnf::cstss "%x3A-3F")
          (and (equal (len abnf::cstss) 1)
               (cst-list-rep-matchp (nth 0 abnf::cstss)
                                    "%x3A-3F"))))

Theorem: cst-graphic-character-not-double-quote-or-backslash-conc5-matching

(defthm
 cst-graphic-character-not-double-quote-or-backslash-conc5-matching
 (implies (cst-list-list-conc-matchp abnf::cstss "%x5B")
          (and (equal (len abnf::cstss) 1)
               (cst-list-rep-matchp (nth 0 abnf::cstss)
                                    "%x5B"))))

Theorem: cst-graphic-character-not-double-quote-or-backslash-conc6-matching

(defthm
 cst-graphic-character-not-double-quote-or-backslash-conc6-matching
 (implies (cst-list-list-conc-matchp abnf::cstss "%x5D-5F")
          (and (equal (len abnf::cstss) 1)
               (cst-list-rep-matchp (nth 0 abnf::cstss)
                                    "%x5D-5F"))))

Theorem: cst-graphic-character-not-double-quote-or-backslash-conc7-matching

(defthm
 cst-graphic-character-not-double-quote-or-backslash-conc7-matching
 (implies (cst-list-list-conc-matchp abnf::cstss "%x7B-7E")
          (and (equal (len abnf::cstss) 1)
               (cst-list-rep-matchp (nth 0 abnf::cstss)
                                    "%x7B-7E"))))

Theorem: cst-basic-character-not-star-conc1-matching

(defthm cst-basic-character-not-star-conc1-matching
  (implies (cst-list-list-conc-matchp abnf::cstss "letter")
           (and (equal (len abnf::cstss) 1)
                (cst-list-rep-matchp (nth 0 abnf::cstss)
                                     "letter"))))

Theorem: cst-basic-character-not-star-conc2-matching

(defthm cst-basic-character-not-star-conc2-matching
  (implies (cst-list-list-conc-matchp abnf::cstss "digit")
           (and (equal (len abnf::cstss) 1)
                (cst-list-rep-matchp (nth 0 abnf::cstss)
                                     "digit"))))

Theorem: cst-basic-character-not-star-conc3-matching

(defthm cst-basic-character-not-star-conc3-matching
 (implies (cst-list-list-conc-matchp abnf::cstss
                                     "graphic-character-not-star")
          (and (equal (len abnf::cstss) 1)
               (cst-list-rep-matchp (nth 0 abnf::cstss)
                                    "graphic-character-not-star"))))

Theorem: cst-basic-character-not-star-conc4-matching

(defthm cst-basic-character-not-star-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-basic-character-not-star-conc5-matching

(defthm cst-basic-character-not-star-conc5-matching
  (implies
       (cst-list-list-conc-matchp abnf::cstss "control-character")
       (and (equal (len abnf::cstss) 1)
            (cst-list-rep-matchp (nth 0 abnf::cstss)
                                 "control-character"))))

Theorem: cst-basic-character-not-greater-than-conc1-matching

(defthm cst-basic-character-not-greater-than-conc1-matching
  (implies (cst-list-list-conc-matchp abnf::cstss "letter")
           (and (equal (len abnf::cstss) 1)
                (cst-list-rep-matchp (nth 0 abnf::cstss)
                                     "letter"))))

Theorem: cst-basic-character-not-greater-than-conc2-matching

(defthm cst-basic-character-not-greater-than-conc2-matching
  (implies (cst-list-list-conc-matchp abnf::cstss "digit")
           (and (equal (len abnf::cstss) 1)
                (cst-list-rep-matchp (nth 0 abnf::cstss)
                                     "digit"))))

Theorem: cst-basic-character-not-greater-than-conc3-matching

(defthm cst-basic-character-not-greater-than-conc3-matching
 (implies
  (cst-list-list-conc-matchp abnf::cstss
                             "graphic-character-not-greater-than")
  (and (equal (len abnf::cstss) 1)
       (cst-list-rep-matchp (nth 0 abnf::cstss)
                            "graphic-character-not-greater-than"))))

Theorem: cst-basic-character-not-greater-than-conc4-matching

(defthm cst-basic-character-not-greater-than-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-basic-character-not-greater-than-conc5-matching

(defthm cst-basic-character-not-greater-than-conc5-matching
  (implies
       (cst-list-list-conc-matchp abnf::cstss "control-character")
       (and (equal (len abnf::cstss) 1)
            (cst-list-rep-matchp (nth 0 abnf::cstss)
                                 "control-character"))))

Theorem: cst-basic-character-not-double-quote-conc1-matching

(defthm cst-basic-character-not-double-quote-conc1-matching
  (implies (cst-list-list-conc-matchp abnf::cstss "letter")
           (and (equal (len abnf::cstss) 1)
                (cst-list-rep-matchp (nth 0 abnf::cstss)
                                     "letter"))))

Theorem: cst-basic-character-not-double-quote-conc2-matching

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

Theorem: cst-basic-character-not-double-quote-conc3-matching

(defthm cst-basic-character-not-double-quote-conc3-matching
 (implies
  (cst-list-list-conc-matchp abnf::cstss
                             "graphic-character-not-double-quote")
  (and (equal (len abnf::cstss) 1)
       (cst-list-rep-matchp (nth 0 abnf::cstss)
                            "graphic-character-not-double-quote"))))

Theorem: cst-basic-character-not-double-quote-conc4-matching

(defthm cst-basic-character-not-double-quote-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-basic-character-not-double-quote-conc5-matching

(defthm cst-basic-character-not-double-quote-conc5-matching
  (implies
       (cst-list-list-conc-matchp abnf::cstss "control-character")
       (and (equal (len abnf::cstss) 1)
            (cst-list-rep-matchp (nth 0 abnf::cstss)
                                 "control-character"))))

Theorem: cst-basic-character-not-star-or-slash-conc1-matching

(defthm cst-basic-character-not-star-or-slash-conc1-matching
  (implies (cst-list-list-conc-matchp abnf::cstss "letter")
           (and (equal (len abnf::cstss) 1)
                (cst-list-rep-matchp (nth 0 abnf::cstss)
                                     "letter"))))

Theorem: cst-basic-character-not-star-or-slash-conc2-matching

(defthm cst-basic-character-not-star-or-slash-conc2-matching
  (implies (cst-list-list-conc-matchp abnf::cstss "digit")
           (and (equal (len abnf::cstss) 1)
                (cst-list-rep-matchp (nth 0 abnf::cstss)
                                     "digit"))))

Theorem: cst-basic-character-not-star-or-slash-conc3-matching

(defthm cst-basic-character-not-star-or-slash-conc3-matching
 (implies
  (cst-list-list-conc-matchp abnf::cstss
                             "graphic-character-not-star-or-slash")
  (and
      (equal (len abnf::cstss) 1)
      (cst-list-rep-matchp (nth 0 abnf::cstss)
                           "graphic-character-not-star-or-slash"))))

Theorem: cst-basic-character-not-star-or-slash-conc4-matching

(defthm cst-basic-character-not-star-or-slash-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-basic-character-not-star-or-slash-conc5-matching

(defthm cst-basic-character-not-star-or-slash-conc5-matching
  (implies
       (cst-list-list-conc-matchp abnf::cstss "control-character")
       (and (equal (len abnf::cstss) 1)
            (cst-list-rep-matchp (nth 0 abnf::cstss)
                                 "control-character"))))

Theorem: cst-basic-character-not-single-quote-or-backslash-conc1-matching

(defthm
   cst-basic-character-not-single-quote-or-backslash-conc1-matching
  (implies (cst-list-list-conc-matchp abnf::cstss "letter")
           (and (equal (len abnf::cstss) 1)
                (cst-list-rep-matchp (nth 0 abnf::cstss)
                                     "letter"))))

Theorem: cst-basic-character-not-single-quote-or-backslash-conc2-matching

(defthm
   cst-basic-character-not-single-quote-or-backslash-conc2-matching
  (implies (cst-list-list-conc-matchp abnf::cstss "digit")
           (and (equal (len abnf::cstss) 1)
                (cst-list-rep-matchp (nth 0 abnf::cstss)
                                     "digit"))))

Theorem: cst-basic-character-not-single-quote-or-backslash-conc3-matching

(defthm
   cst-basic-character-not-single-quote-or-backslash-conc3-matching
 (implies
     (cst-list-list-conc-matchp
          abnf::cstss
          "graphic-character-not-single-quote-or-backslash")
     (and (equal (len abnf::cstss) 1)
          (cst-list-rep-matchp
               (nth 0 abnf::cstss)
               "graphic-character-not-single-quote-or-backslash"))))

Theorem: cst-basic-character-not-single-quote-or-backslash-conc4-matching

(defthm
   cst-basic-character-not-single-quote-or-backslash-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-basic-character-not-single-quote-or-backslash-conc5-matching

(defthm
   cst-basic-character-not-single-quote-or-backslash-conc5-matching
  (implies
       (cst-list-list-conc-matchp abnf::cstss "control-character")
       (and (equal (len abnf::cstss) 1)
            (cst-list-rep-matchp (nth 0 abnf::cstss)
                                 "control-character"))))

Theorem: cst-basic-character-not-double-quote-or-backslash-conc1-matching

(defthm
   cst-basic-character-not-double-quote-or-backslash-conc1-matching
  (implies (cst-list-list-conc-matchp abnf::cstss "letter")
           (and (equal (len abnf::cstss) 1)
                (cst-list-rep-matchp (nth 0 abnf::cstss)
                                     "letter"))))

Theorem: cst-basic-character-not-double-quote-or-backslash-conc2-matching

(defthm
   cst-basic-character-not-double-quote-or-backslash-conc2-matching
  (implies (cst-list-list-conc-matchp abnf::cstss "digit")
           (and (equal (len abnf::cstss) 1)
                (cst-list-rep-matchp (nth 0 abnf::cstss)
                                     "digit"))))

Theorem: cst-basic-character-not-double-quote-or-backslash-conc3-matching

(defthm
   cst-basic-character-not-double-quote-or-backslash-conc3-matching
 (implies
     (cst-list-list-conc-matchp
          abnf::cstss
          "graphic-character-not-double-quote-or-backslash")
     (and (equal (len abnf::cstss) 1)
          (cst-list-rep-matchp
               (nth 0 abnf::cstss)
               "graphic-character-not-double-quote-or-backslash"))))

Theorem: cst-basic-character-not-double-quote-or-backslash-conc4-matching

(defthm
   cst-basic-character-not-double-quote-or-backslash-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-basic-character-not-double-quote-or-backslash-conc5-matching

(defthm
   cst-basic-character-not-double-quote-or-backslash-conc5-matching
  (implies
       (cst-list-list-conc-matchp abnf::cstss "control-character")
       (and (equal (len abnf::cstss) 1)
            (cst-list-rep-matchp (nth 0 abnf::cstss)
                                 "control-character"))))

Theorem: cst-character-not-new-line-conc1-matching

(defthm cst-character-not-new-line-conc1-matching
  (implies (cst-list-list-conc-matchp abnf::cstss "basic-character")
           (and (equal (len abnf::cstss) 1)
                (cst-list-rep-matchp (nth 0 abnf::cstss)
                                     "basic-character"))))

Theorem: cst-character-not-new-line-conc2-matching

(defthm cst-character-not-new-line-conc2-matching
 (implies
     (cst-list-list-conc-matchp abnf::cstss
                                "extended-character-not-new-line")
     (and (equal (len abnf::cstss) 1)
          (cst-list-rep-matchp (nth 0 abnf::cstss)
                               "extended-character-not-new-line"))))

Theorem: cst-character-not-star-conc1-matching

(defthm cst-character-not-star-conc1-matching
 (implies
  (cst-list-list-conc-matchp abnf::cstss "basic-character-not-star")
  (and (equal (len abnf::cstss) 1)
       (cst-list-rep-matchp (nth 0 abnf::cstss)
                            "basic-character-not-star"))))

Theorem: cst-character-not-star-conc2-matching

(defthm cst-character-not-star-conc2-matching
  (implies
       (cst-list-list-conc-matchp abnf::cstss "extended-character")
       (and (equal (len abnf::cstss) 1)
            (cst-list-rep-matchp (nth 0 abnf::cstss)
                                 "extended-character"))))

Theorem: cst-character-not-star-or-slash-conc1-matching

(defthm cst-character-not-star-or-slash-conc1-matching
 (implies
   (cst-list-list-conc-matchp abnf::cstss
                              "basic-character-not-star-or-slash")
   (and (equal (len abnf::cstss) 1)
        (cst-list-rep-matchp (nth 0 abnf::cstss)
                             "basic-character-not-star-or-slash"))))

Theorem: cst-character-not-star-or-slash-conc2-matching

(defthm cst-character-not-star-or-slash-conc2-matching
  (implies
       (cst-list-list-conc-matchp abnf::cstss "extended-character")
       (and (equal (len abnf::cstss) 1)
            (cst-list-rep-matchp (nth 0 abnf::cstss)
                                 "extended-character"))))

Theorem: cst-character-not-greater-than-or-new-line-conc1-matching

(defthm cst-character-not-greater-than-or-new-line-conc1-matching
 (implies
    (cst-list-list-conc-matchp abnf::cstss
                               "basic-character-not-greater-than")
    (and (equal (len abnf::cstss) 1)
         (cst-list-rep-matchp (nth 0 abnf::cstss)
                              "basic-character-not-greater-than"))))

Theorem: cst-character-not-greater-than-or-new-line-conc2-matching

(defthm cst-character-not-greater-than-or-new-line-conc2-matching
 (implies
     (cst-list-list-conc-matchp abnf::cstss
                                "extended-character-not-new-line")
     (and (equal (len abnf::cstss) 1)
          (cst-list-rep-matchp (nth 0 abnf::cstss)
                               "extended-character-not-new-line"))))

Theorem: cst-character-not-double-quote-or-new-line-conc1-matching

(defthm cst-character-not-double-quote-or-new-line-conc1-matching
 (implies
    (cst-list-list-conc-matchp abnf::cstss
                               "basic-character-not-double-quote")
    (and (equal (len abnf::cstss) 1)
         (cst-list-rep-matchp (nth 0 abnf::cstss)
                              "basic-character-not-double-quote"))))

Theorem: cst-character-not-double-quote-or-new-line-conc2-matching

(defthm cst-character-not-double-quote-or-new-line-conc2-matching
 (implies
     (cst-list-list-conc-matchp abnf::cstss
                                "extended-character-not-new-line")
     (and (equal (len abnf::cstss) 1)
          (cst-list-rep-matchp (nth 0 abnf::cstss)
                               "extended-character-not-new-line"))))

Theorem: cst-character-not-single-quote-or-backslash-or-new-line-conc1-matching

(defthm
 cst-character-not-single-quote-or-backslash-or-new-line-conc1-matching
 (implies
      (cst-list-list-conc-matchp
           abnf::cstss
           "basic-character-not-single-quote-or-backslash")
      (and (equal (len abnf::cstss) 1)
           (cst-list-rep-matchp
                (nth 0 abnf::cstss)
                "basic-character-not-single-quote-or-backslash"))))

Theorem: cst-character-not-single-quote-or-backslash-or-new-line-conc2-matching

(defthm
 cst-character-not-single-quote-or-backslash-or-new-line-conc2-matching
 (implies
     (cst-list-list-conc-matchp abnf::cstss
                                "extended-character-not-new-line")
     (and (equal (len abnf::cstss) 1)
          (cst-list-rep-matchp (nth 0 abnf::cstss)
                               "extended-character-not-new-line"))))

Theorem: cst-character-not-double-quote-or-backslash-or-new-line-conc1-matching

(defthm
 cst-character-not-double-quote-or-backslash-or-new-line-conc1-matching
 (implies
      (cst-list-list-conc-matchp
           abnf::cstss
           "basic-character-not-double-quote-or-backslash")
      (and (equal (len abnf::cstss) 1)
           (cst-list-rep-matchp
                (nth 0 abnf::cstss)
                "basic-character-not-double-quote-or-backslash"))))

Theorem: cst-character-not-double-quote-or-backslash-or-new-line-conc2-matching

(defthm
 cst-character-not-double-quote-or-backslash-or-new-line-conc2-matching
 (implies
     (cst-list-list-conc-matchp abnf::cstss
                                "extended-character-not-new-line")
     (and (equal (len abnf::cstss) 1)
          (cst-list-rep-matchp (nth 0 abnf::cstss)
                               "extended-character-not-new-line"))))

Theorem: cst-white-space-conc1-matching

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

(defthm cst-white-space-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-white-space-conc3-matching

(defthm cst-white-space-conc3-matching
  (implies (cst-list-list-conc-matchp abnf::cstss "vertical-tab")
           (and (equal (len abnf::cstss) 1)
                (cst-list-rep-matchp (nth 0 abnf::cstss)
                                     "vertical-tab"))))

Theorem: cst-white-space-conc4-matching

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

Theorem: cst-white-space-conc5-matching

(defthm cst-white-space-conc5-matching
  (implies (cst-list-list-conc-matchp abnf::cstss "new-line")
           (and (equal (len abnf::cstss) 1)
                (cst-list-rep-matchp (nth 0 abnf::cstss)
                                     "new-line"))))

Theorem: cst-h-char-sequence-conc1-matching

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

Theorem: cst-h-char-conc-matching

(defthm cst-h-char-conc-matching
 (implies
  (cst-list-list-conc-matchp
       abnf::cstss
       "character-not-greater-than-or-new-line")
  (and
   (equal (len abnf::cstss) 1)
   (cst-list-rep-matchp (nth 0 abnf::cstss)
                        "character-not-greater-than-or-new-line"))))

Theorem: cst-q-char-sequence-conc1-matching

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

Theorem: cst-q-char-conc-matching

(defthm cst-q-char-conc-matching
 (implies
  (cst-list-list-conc-matchp
       abnf::cstss
       "character-not-double-quote-or-new-line")
  (and
   (equal (len abnf::cstss) 1)
   (cst-list-rep-matchp (nth 0 abnf::cstss)
                        "character-not-double-quote-or-new-line"))))

Theorem: cst-pp-number-conc1-matching

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

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

Theorem: cst-token-conc4-matching

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

(defthm cst-token-conc5-matching
  (implies (cst-list-list-conc-matchp abnf::cstss "punctuator")
           (and (equal (len abnf::cstss) 1)
                (cst-list-rep-matchp (nth 0 abnf::cstss)
                                     "punctuator"))))

Theorem: cst-preprocessing-token-conc1-matching

(defthm cst-preprocessing-token-conc1-matching
  (implies (cst-list-list-conc-matchp abnf::cstss "header-name")
           (and (equal (len abnf::cstss) 1)
                (cst-list-rep-matchp (nth 0 abnf::cstss)
                                     "header-name"))))

Theorem: cst-preprocessing-token-conc2-matching

(defthm cst-preprocessing-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-preprocessing-token-conc3-matching

(defthm cst-preprocessing-token-conc3-matching
  (implies (cst-list-list-conc-matchp abnf::cstss "pp-number")
           (and (equal (len abnf::cstss) 1)
                (cst-list-rep-matchp (nth 0 abnf::cstss)
                                     "pp-number"))))

Theorem: cst-preprocessing-token-conc4-matching

(defthm cst-preprocessing-token-conc4-matching
  (implies
       (cst-list-list-conc-matchp abnf::cstss "character-constant")
       (and (equal (len abnf::cstss) 1)
            (cst-list-rep-matchp (nth 0 abnf::cstss)
                                 "character-constant"))))

Theorem: cst-preprocessing-token-conc5-matching

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

(defthm cst-preprocessing-token-conc6-matching
  (implies (cst-list-list-conc-matchp abnf::cstss "punctuator")
           (and (equal (len abnf::cstss) 1)
                (cst-list-rep-matchp (nth 0 abnf::cstss)
                                     "punctuator"))))

Theorem: cst-preprocessing-token-conc7-matching

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

Theorem: cst-keyword-conc1-matching

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

Theorem: cst-keyword-conc2-matching

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

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

Theorem: cst-keyword-conc4-matching

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

Theorem: cst-keyword-conc5-matching

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

Theorem: cst-keyword-conc6-matching

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

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

Theorem: cst-keyword-conc8-matching

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

Theorem: cst-keyword-conc9-matching

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

Theorem: cst-keyword-conc10-matching

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

Theorem: cst-keyword-conc11-matching

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

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

Theorem: cst-keyword-conc13-matching

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

Theorem: cst-keyword-conc14-matching

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

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

Theorem: cst-keyword-conc16-matching

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

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

Theorem: cst-keyword-conc18-matching

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

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

Theorem: cst-keyword-conc20-matching

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

Theorem: cst-keyword-conc21-matching

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

Theorem: cst-keyword-conc22-matching

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

Theorem: cst-keyword-conc23-matching

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

Theorem: cst-keyword-conc24-matching

(defthm cst-keyword-conc24-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-conc25-matching

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

Theorem: cst-keyword-conc26-matching

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

Theorem: cst-keyword-conc27-matching

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

Theorem: cst-keyword-conc28-matching

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

Theorem: cst-keyword-conc29-matching

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

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

Theorem: cst-keyword-conc31-matching

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

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

Theorem: cst-keyword-conc33-matching

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

Theorem: cst-keyword-conc34-matching

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

Theorem: cst-keyword-conc35-matching

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

Theorem: cst-keyword-conc36-matching

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

Theorem: cst-keyword-conc37-matching

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

Theorem: cst-keyword-conc38-matching

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

Theorem: cst-keyword-conc39-matching

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

Theorem: cst-keyword-conc40-matching

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

Theorem: cst-keyword-conc41-matching

(defthm cst-keyword-conc41-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-conc42-matching

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

Theorem: cst-keyword-conc43-matching

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

Theorem: cst-keyword-conc44-matching

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

Theorem: cst-keyword-conc45-matching

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

Theorem: cst-keyword-conc46-matching

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

Theorem: cst-keyword-conc47-matching

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

Theorem: cst-gcc-keyword-conc1-matching

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

Theorem: cst-gcc-keyword-conc2-matching

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

Theorem: cst-gcc-keyword-conc3-matching

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

Theorem: cst-gcc-keyword-conc4-matching

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

Theorem: cst-gcc-keyword-conc5-matching

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

Theorem: cst-gcc-keyword-conc6-matching

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

Theorem: cst-gcc-keyword-conc7-matching

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

Theorem: cst-gcc-keyword-conc8-matching

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

Theorem: cst-gcc-keyword-conc9-matching

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

Theorem: cst-gcc-keyword-conc10-matching

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

Theorem: cst-gcc-keyword-conc11-matching

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

Theorem: cst-gcc-keyword-conc12-matching

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

Theorem: cst-gcc-keyword-conc13-matching

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

Theorem: cst-gcc-keyword-conc14-matching

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

Theorem: cst-gcc-keyword-conc15-matching

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

Theorem: cst-gcc-keyword-conc16-matching

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

Theorem: cst-gcc-keyword-conc17-matching

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

Theorem: cst-gcc-keyword-conc18-matching

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

Theorem: cst-gcc-keyword-conc19-matching

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

Theorem: cst-gcc-keyword-conc20-matching

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

Theorem: cst-gcc-keyword-conc21-matching

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

Theorem: cst-gcc-keyword-conc22-matching

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

Theorem: cst-gcc-keyword-conc23-matching

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

Theorem: cst-gcc-keyword-conc24-matching

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

Theorem: cst-gcc-keyword-conc25-matching

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

Theorem: cst-gcc-keyword-conc26-matching

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

Theorem: cst-gcc-keyword-conc27-matching

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

Theorem: cst-gcc-keyword-conc28-matching

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

Theorem: cst-gcc-keyword-conc29-matching

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

Theorem: cst-gcc-keyword-conc30-matching

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

Theorem: cst-gcc-keyword-conc31-matching

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

Theorem: cst-gcc-keyword-conc32-matching

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

Theorem: cst-gcc-keyword-conc33-matching

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

Theorem: cst-gcc-keyword-conc34-matching

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

Theorem: cst-gcc-keyword-conc35-matching

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

Theorem: cst-gcc-keyword-conc36-matching

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

Theorem: cst-gcc-keyword-conc37-matching

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

Theorem: cst-gcc-keyword-conc38-matching

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

Theorem: cst-gcc-keyword-conc39-matching

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

Theorem: cst-gcc-keyword-conc40-matching

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

Theorem: cst-alignof-keyword-conc1-matching

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

Theorem: cst-alignof-keyword-conc2-matching

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

Theorem: cst-alignof-keyword-conc3-matching

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

Theorem: cst-asm-keyword-conc1-matching

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

Theorem: cst-asm-keyword-conc2-matching

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

Theorem: cst-asm-keyword-conc3-matching

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

Theorem: cst-attribute-keyword-conc1-matching

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

Theorem: cst-attribute-keyword-conc2-matching

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

Theorem: cst-inline-keyword-conc1-matching

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

Theorem: cst-inline-keyword-conc2-matching

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

Theorem: cst-inline-keyword-conc3-matching

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

Theorem: cst-restrict-keyword-conc1-matching

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

Theorem: cst-restrict-keyword-conc2-matching

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

Theorem: cst-restrict-keyword-conc3-matching

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

Theorem: cst-signed-keyword-conc1-matching

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

Theorem: cst-signed-keyword-conc2-matching

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

Theorem: cst-signed-keyword-conc3-matching

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

Theorem: cst-typeof-keyword-conc1-matching

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

Theorem: cst-typeof-keyword-conc2-matching

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

Theorem: cst-typeof-keyword-conc3-matching

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

Theorem: cst-volatile-keyword-conc1-matching

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

Theorem: cst-volatile-keyword-conc2-matching

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

Theorem: cst-volatile-keyword-conc3-matching

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

Theorem: cst-identifier-conc1-matching

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

Theorem: cst-identifier-nondigit-conc-matching

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

Theorem: cst-nondigit-conc1-matching

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

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

Theorem: cst-constant-conc1-matching

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

Theorem: cst-constant-conc2-matching

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

Theorem: cst-constant-conc3-matching

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

Theorem: cst-constant-conc4-matching

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

Theorem: cst-decimal-constant-conc1-matching

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

Theorem: cst-octal-constant-conc1-matching

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

Theorem: cst-hexadecimal-prefix-conc-matching

(defthm cst-hexadecimal-prefix-conc-matching
  (implies (cst-list-list-conc-matchp abnf::cstss "%i\"0x\"")
           (and (equal (len abnf::cstss) 1)
                (cst-list-rep-matchp (nth 0 abnf::cstss)
                                     "%i\"0x\""))))

Theorem: cst-nonzero-digit-conc-matching

(defthm cst-nonzero-digit-conc-matching
  (implies (cst-list-list-conc-matchp abnf::cstss "%x31-39")
           (and (equal (len abnf::cstss) 1)
                (cst-list-rep-matchp (nth 0 abnf::cstss)
                                     "%x31-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 "%x30-39")
           (and (equal (len abnf::cstss) 1)
                (cst-list-rep-matchp (nth 0 abnf::cstss)
                                     "%x30-39"))))

Theorem: cst-hexadecimal-digit-conc2-matching

(defthm cst-hexadecimal-digit-conc2-matching
  (implies (cst-list-list-conc-matchp abnf::cstss "%x61-66")
           (and (equal (len abnf::cstss) 1)
                (cst-list-rep-matchp (nth 0 abnf::cstss)
                                     "%x61-66"))))

Theorem: cst-hexadecimal-digit-conc3-matching

(defthm cst-hexadecimal-digit-conc3-matching
  (implies (cst-list-list-conc-matchp abnf::cstss "%x41-46")
           (and (equal (len abnf::cstss) 1)
                (cst-list-rep-matchp (nth 0 abnf::cstss)
                                     "%x41-46"))))

Theorem: cst-unsigned-suffix-conc-matching

(defthm cst-unsigned-suffix-conc-matching
  (implies (cst-list-list-conc-matchp abnf::cstss "%i\"u\"")
           (and (equal (len abnf::cstss) 1)
                (cst-list-rep-matchp (nth 0 abnf::cstss)
                                     "%i\"u\""))))

Theorem: cst-long-suffix-conc-matching

(defthm cst-long-suffix-conc-matching
  (implies (cst-list-list-conc-matchp abnf::cstss "%i\"l\"")
           (and (equal (len abnf::cstss) 1)
                (cst-list-rep-matchp (nth 0 abnf::cstss)
                                     "%i\"l\""))))

Theorem: cst-long-long-suffix-conc1-matching

(defthm cst-long-long-suffix-conc1-matching
  (implies (cst-list-list-conc-matchp abnf::cstss "%s\"ll\"")
           (and (equal (len abnf::cstss) 1)
                (cst-list-rep-matchp (nth 0 abnf::cstss)
                                     "%s\"ll\""))))

Theorem: cst-long-long-suffix-conc2-matching

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

Theorem: cst-floating-constant-conc1-matching

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

Theorem: cst-floating-constant-conc2-matching

(defthm cst-floating-constant-conc2-matching
  (implies
       (cst-list-list-conc-matchp abnf::cstss
                                  "hexadecimal-floating-constant")
       (and (equal (len abnf::cstss) 1)
            (cst-list-rep-matchp (nth 0 abnf::cstss)
                                 "hexadecimal-floating-constant"))))

Theorem: cst-sign-conc1-matching

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

(defthm cst-sign-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-digit-sequence-conc1-matching

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

Theorem: cst-hexadecimal-digit-sequence-conc1-matching

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

Theorem: cst-floating-suffix-conc1-matching

(defthm cst-floating-suffix-conc1-matching
  (implies (cst-list-list-conc-matchp abnf::cstss "%i\"f\"")
           (and (equal (len abnf::cstss) 1)
                (cst-list-rep-matchp (nth 0 abnf::cstss)
                                     "%i\"f\""))))

Theorem: cst-floating-suffix-conc2-matching

(defthm cst-floating-suffix-conc2-matching
  (implies (cst-list-list-conc-matchp abnf::cstss "%i\"l\"")
           (and (equal (len abnf::cstss) 1)
                (cst-list-rep-matchp (nth 0 abnf::cstss)
                                     "%i\"l\""))))

Theorem: cst-enumeration-constant-conc-matching

(defthm cst-enumeration-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-c-char-sequence-conc1-matching

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

Theorem: cst-c-char-conc1-matching

(defthm cst-c-char-conc1-matching
 (implies
  (cst-list-list-conc-matchp
       abnf::cstss
       "character-not-single-quote-or-backslash-or-new-line")
  (and
      (equal (len abnf::cstss) 1)
      (cst-list-rep-matchp
           (nth 0 abnf::cstss)
           "character-not-single-quote-or-backslash-or-new-line"))))

Theorem: cst-c-char-conc2-matching

(defthm cst-c-char-conc2-matching
  (implies (cst-list-list-conc-matchp abnf::cstss "escape-sequence")
           (and (equal (len abnf::cstss) 1)
                (cst-list-rep-matchp (nth 0 abnf::cstss)
                                     "escape-sequence"))))

Theorem: cst-escape-sequence-conc1-matching

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

Theorem: cst-escape-sequence-conc2-matching

(defthm cst-escape-sequence-conc2-matching
 (implies
     (cst-list-list-conc-matchp abnf::cstss "octal-escape-sequence")
     (and (equal (len abnf::cstss) 1)
          (cst-list-rep-matchp (nth 0 abnf::cstss)
                               "octal-escape-sequence"))))

Theorem: cst-escape-sequence-conc3-matching

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

Theorem: cst-escape-sequence-conc4-matching

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

Theorem: cst-simple-escape-sequence-conc1-matching

(defthm cst-simple-escape-sequence-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-simple-escape-sequence-conc3-matching

(defthm cst-simple-escape-sequence-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-simple-escape-sequence-conc4-matching

(defthm cst-simple-escape-sequence-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-simple-escape-sequence-conc5-matching

(defthm cst-simple-escape-sequence-conc5-matching
  (implies (cst-list-list-conc-matchp abnf::cstss "%s\"\\a\"")
           (and (equal (len abnf::cstss) 1)
                (cst-list-rep-matchp (nth 0 abnf::cstss)
                                     "%s\"\\a\""))))

Theorem: cst-simple-escape-sequence-conc6-matching

(defthm cst-simple-escape-sequence-conc6-matching
  (implies (cst-list-list-conc-matchp abnf::cstss "%s\"\\b\"")
           (and (equal (len abnf::cstss) 1)
                (cst-list-rep-matchp (nth 0 abnf::cstss)
                                     "%s\"\\b\""))))

Theorem: cst-simple-escape-sequence-conc7-matching

(defthm cst-simple-escape-sequence-conc7-matching
  (implies (cst-list-list-conc-matchp abnf::cstss "%s\"\\f\"")
           (and (equal (len abnf::cstss) 1)
                (cst-list-rep-matchp (nth 0 abnf::cstss)
                                     "%s\"\\f\""))))

Theorem: cst-simple-escape-sequence-conc8-matching

(defthm cst-simple-escape-sequence-conc8-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-simple-escape-sequence-conc9-matching

(defthm cst-simple-escape-sequence-conc9-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-simple-escape-sequence-conc10-matching

(defthm cst-simple-escape-sequence-conc10-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-simple-escape-sequence-conc11-matching

(defthm cst-simple-escape-sequence-conc11-matching
  (implies (cst-list-list-conc-matchp abnf::cstss "%s\"\\v\"")
           (and (equal (len abnf::cstss) 1)
                (cst-list-rep-matchp (nth 0 abnf::cstss)
                                     "%s\"\\v\""))))

Theorem: cst-simple-escape-sequence-conc12-matching

(defthm cst-simple-escape-sequence-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-encoding-prefix-conc1-matching

(defthm cst-encoding-prefix-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-encoding-prefix-conc2-matching

(defthm cst-encoding-prefix-conc2-matching
  (implies (cst-list-list-conc-matchp abnf::cstss "%i\"u\"")
           (and (equal (len abnf::cstss) 1)
                (cst-list-rep-matchp (nth 0 abnf::cstss)
                                     "%i\"u\""))))

Theorem: cst-encoding-prefix-conc3-matching

(defthm cst-encoding-prefix-conc3-matching
  (implies (cst-list-list-conc-matchp abnf::cstss "%s\"L\"")
           (and (equal (len abnf::cstss) 1)
                (cst-list-rep-matchp (nth 0 abnf::cstss)
                                     "%s\"L\""))))

Theorem: cst-s-char-sequence-conc1-matching

(defthm cst-s-char-sequence-conc1-matching
  (implies (cst-list-list-conc-matchp abnf::cstss "s-char")
           (and (equal (len abnf::cstss) 1)
                (cst-list-rep-matchp (nth 0 abnf::cstss)
                                     "s-char"))))

Theorem: cst-s-char-conc1-matching

(defthm cst-s-char-conc1-matching
 (implies
  (cst-list-list-conc-matchp
       abnf::cstss
       "character-not-double-quote-or-backslash-or-new-line")
  (and
      (equal (len abnf::cstss) 1)
      (cst-list-rep-matchp
           (nth 0 abnf::cstss)
           "character-not-double-quote-or-backslash-or-new-line"))))

Theorem: cst-s-char-conc2-matching

(defthm cst-s-char-conc2-matching
  (implies (cst-list-list-conc-matchp abnf::cstss "escape-sequence")
           (and (equal (len abnf::cstss) 1)
                (cst-list-rep-matchp (nth 0 abnf::cstss)
                                     "escape-sequence"))))

Theorem: cst-punctuator-conc1-matching

(defthm cst-punctuator-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-punctuator-conc2-matching

(defthm cst-punctuator-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-punctuator-conc3-matching

(defthm cst-punctuator-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-punctuator-conc4-matching

(defthm cst-punctuator-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-punctuator-conc5-matching

(defthm cst-punctuator-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-punctuator-conc6-matching

(defthm cst-punctuator-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-punctuator-conc7-matching

(defthm cst-punctuator-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-punctuator-conc8-matching

(defthm cst-punctuator-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-punctuator-conc9-matching

(defthm cst-punctuator-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-punctuator-conc10-matching

(defthm cst-punctuator-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-punctuator-conc11-matching

(defthm cst-punctuator-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-punctuator-conc12-matching

(defthm cst-punctuator-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-punctuator-conc13-matching

(defthm cst-punctuator-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-punctuator-conc14-matching

(defthm cst-punctuator-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-punctuator-conc15-matching

(defthm cst-punctuator-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-punctuator-conc16-matching

(defthm cst-punctuator-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-punctuator-conc17-matching

(defthm cst-punctuator-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-punctuator-conc18-matching

(defthm cst-punctuator-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-punctuator-conc19-matching

(defthm cst-punctuator-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-punctuator-conc20-matching

(defthm cst-punctuator-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-punctuator-conc21-matching

(defthm cst-punctuator-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-punctuator-conc22-matching

(defthm cst-punctuator-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-punctuator-conc23-matching

(defthm cst-punctuator-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-punctuator-conc24-matching

(defthm cst-punctuator-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-punctuator-conc25-matching

(defthm cst-punctuator-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-punctuator-conc26-matching

(defthm cst-punctuator-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-punctuator-conc27-matching

(defthm cst-punctuator-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-punctuator-conc28-matching

(defthm cst-punctuator-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-punctuator-conc29-matching

(defthm cst-punctuator-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-punctuator-conc30-matching

(defthm cst-punctuator-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-punctuator-conc31-matching

(defthm cst-punctuator-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-punctuator-conc32-matching

(defthm cst-punctuator-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-punctuator-conc33-matching

(defthm cst-punctuator-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-punctuator-conc34-matching

(defthm cst-punctuator-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-punctuator-conc35-matching

(defthm cst-punctuator-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-punctuator-conc36-matching

(defthm cst-punctuator-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-punctuator-conc37-matching

(defthm cst-punctuator-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-punctuator-conc38-matching

(defthm cst-punctuator-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-punctuator-conc39-matching

(defthm cst-punctuator-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-punctuator-conc40-matching

(defthm cst-punctuator-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-punctuator-conc41-matching

(defthm cst-punctuator-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-punctuator-conc42-matching

(defthm cst-punctuator-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-punctuator-conc43-matching

(defthm cst-punctuator-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-punctuator-conc44-matching

(defthm cst-punctuator-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-punctuator-conc45-matching

(defthm cst-punctuator-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-punctuator-conc46-matching

(defthm cst-punctuator-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-punctuator-conc47-matching

(defthm cst-punctuator-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-punctuator-conc48-matching

(defthm cst-punctuator-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-punctuator-conc49-matching

(defthm cst-punctuator-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-punctuator-conc50-matching

(defthm cst-punctuator-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-punctuator-conc51-matching

(defthm cst-punctuator-conc51-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-punctuator-conc52-matching

(defthm cst-punctuator-conc52-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-punctuator-conc53-matching

(defthm cst-punctuator-conc53-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-punctuator-conc54-matching

(defthm cst-punctuator-conc54-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-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 "control-line")
           (and (equal (len abnf::cstss) 1)
                (cst-list-rep-matchp (nth 0 abnf::cstss)
                                     "control-line"))))

Theorem: cst-lexeme-conc4-matching

(defthm cst-lexeme-conc4-matching
  (implies (cst-list-list-conc-matchp abnf::cstss "white-space")
           (and (equal (len abnf::cstss) 1)
                (cst-list-rep-matchp (nth 0 abnf::cstss)
                                     "white-space"))))

Theorem: cst-primary-expression-conc1-matching

(defthm cst-primary-expression-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-primary-expression-conc2-matching

(defthm cst-primary-expression-conc2-matching
  (implies (cst-list-list-conc-matchp abnf::cstss "constant")
           (and (equal (len abnf::cstss) 1)
                (cst-list-rep-matchp (nth 0 abnf::cstss)
                                     "constant"))))

Theorem: cst-primary-expression-conc3-matching

(defthm cst-primary-expression-conc3-matching
 (implies (cst-list-list-conc-matchp abnf::cstss "1*string-literal")
          (and (equal (len abnf::cstss) 1)
               (cst-list-rep-matchp (nth 0 abnf::cstss)
                                    "1*string-literal"))))

Theorem: cst-primary-expression-conc5-matching

(defthm cst-primary-expression-conc5-matching
  (implies
       (cst-list-list-conc-matchp abnf::cstss "generic-selection")
       (and (equal (len abnf::cstss) 1)
            (cst-list-rep-matchp (nth 0 abnf::cstss)
                                 "generic-selection"))))

Theorem: cst-primary-expression-conc7-matching

(defthm cst-primary-expression-conc7-matching
 (implies
     (cst-list-list-conc-matchp abnf::cstss "types-compatible-call")
     (and (equal (len abnf::cstss) 1)
          (cst-list-rep-matchp (nth 0 abnf::cstss)
                               "types-compatible-call"))))

Theorem: cst-primary-expression-conc8-matching

(defthm cst-primary-expression-conc8-matching
  (implies (cst-list-list-conc-matchp abnf::cstss "offsetof-call")
           (and (equal (len abnf::cstss) 1)
                (cst-list-rep-matchp (nth 0 abnf::cstss)
                                     "offsetof-call"))))

Theorem: cst-primary-expression-conc9-matching

(defthm cst-primary-expression-conc9-matching
  (implies (cst-list-list-conc-matchp abnf::cstss "va-arg-call")
           (and (equal (len abnf::cstss) 1)
                (cst-list-rep-matchp (nth 0 abnf::cstss)
                                     "va-arg-call"))))

Theorem: cst-primary-expression-conc11-matching

(defthm cst-primary-expression-conc11-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-primary-expression-conc12-matching

(defthm cst-primary-expression-conc12-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-offsetof-member-designator-conc1-matching

(defthm cst-offsetof-member-designator-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-generic-assoc-list-conc1-matching

(defthm cst-generic-assoc-list-conc1-matching
  (implies
       (cst-list-list-conc-matchp abnf::cstss "generic-association")
       (and (equal (len abnf::cstss) 1)
            (cst-list-rep-matchp (nth 0 abnf::cstss)
                                 "generic-association"))))

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-argument-expression-list-conc1-matching

(defthm cst-argument-expression-list-conc1-matching
 (implies
     (cst-list-list-conc-matchp abnf::cstss "assignment-expression")
     (and (equal (len abnf::cstss) 1)
          (cst-list-rep-matchp (nth 0 abnf::cstss)
                               "assignment-expression"))))

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-unary-operator-conc1-matching

(defthm cst-unary-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-unary-operator-conc2-matching

(defthm cst-unary-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-unary-operator-conc3-matching

(defthm cst-unary-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-unary-operator-conc4-matching

(defthm cst-unary-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-unary-operator-conc5-matching

(defthm cst-unary-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-unary-operator-conc6-matching

(defthm cst-unary-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-cast-expression-conc1-matching

(defthm cst-cast-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 "cast-expression")
           (and (equal (len abnf::cstss) 1)
                (cst-list-rep-matchp (nth 0 abnf::cstss)
                                     "cast-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-relational-expression-conc1-matching

(defthm cst-relational-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-equality-expression-conc1-matching

(defthm cst-equality-expression-conc1-matching
 (implies
     (cst-list-list-conc-matchp abnf::cstss "relational-expression")
     (and (equal (len abnf::cstss) 1)
          (cst-list-rep-matchp (nth 0 abnf::cstss)
                               "relational-expression"))))

Theorem: cst-and-expression-conc1-matching

(defthm cst-and-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-exclusive-or-expression-conc1-matching

(defthm cst-exclusive-or-expression-conc1-matching
  (implies (cst-list-list-conc-matchp abnf::cstss "and-expression")
           (and (equal (len abnf::cstss) 1)
                (cst-list-rep-matchp (nth 0 abnf::cstss)
                                     "and-expression"))))

Theorem: cst-inclusive-or-expression-conc1-matching

(defthm cst-inclusive-or-expression-conc1-matching
 (implies
   (cst-list-list-conc-matchp abnf::cstss "exclusive-or-expression")
   (and (equal (len abnf::cstss) 1)
        (cst-list-rep-matchp (nth 0 abnf::cstss)
                             "exclusive-or-expression"))))

Theorem: cst-logical-and-expression-conc1-matching

(defthm cst-logical-and-expression-conc1-matching
 (implies
   (cst-list-list-conc-matchp abnf::cstss "inclusive-or-expression")
   (and (equal (len abnf::cstss) 1)
        (cst-list-rep-matchp (nth 0 abnf::cstss)
                             "inclusive-or-expression"))))

Theorem: cst-logical-or-expression-conc1-matching

(defthm cst-logical-or-expression-conc1-matching
 (implies
    (cst-list-list-conc-matchp abnf::cstss "logical-and-expression")
    (and (equal (len abnf::cstss) 1)
         (cst-list-rep-matchp (nth 0 abnf::cstss)
                              "logical-and-expression"))))

Theorem: cst-conditional-expression-conc1-matching

(defthm cst-conditional-expression-conc1-matching
 (implies
     (cst-list-list-conc-matchp abnf::cstss "logical-or-expression")
     (and (equal (len abnf::cstss) 1)
          (cst-list-rep-matchp (nth 0 abnf::cstss)
                               "logical-or-expression"))))

Theorem: cst-assignment-expression-conc1-matching

(defthm cst-assignment-expression-conc1-matching
 (implies
    (cst-list-list-conc-matchp abnf::cstss "conditional-expression")
    (and (equal (len abnf::cstss) 1)
         (cst-list-rep-matchp (nth 0 abnf::cstss)
                              "conditional-expression"))))

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-expression-conc1-matching

(defthm cst-expression-conc1-matching
 (implies
     (cst-list-list-conc-matchp abnf::cstss "assignment-expression")
     (and (equal (len abnf::cstss) 1)
          (cst-list-rep-matchp (nth 0 abnf::cstss)
                               "assignment-expression"))))

Theorem: cst-constant-expression-conc-matching

(defthm cst-constant-expression-conc-matching
 (implies
    (cst-list-list-conc-matchp abnf::cstss "conditional-expression")
    (and (equal (len abnf::cstss) 1)
         (cst-list-rep-matchp (nth 0 abnf::cstss)
                              "conditional-expression"))))

Theorem: cst-attribute-name-conc1-matching

(defthm cst-attribute-name-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-attribute-name-conc2-matching

(defthm cst-attribute-name-conc2-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-asm-qualifier-conc1-matching

(defthm cst-asm-qualifier-conc1-matching
 (implies (cst-list-list-conc-matchp abnf::cstss "volatile-keyword")
          (and (equal (len abnf::cstss) 1)
               (cst-list-rep-matchp (nth 0 abnf::cstss)
                                    "volatile-keyword"))))

Theorem: cst-asm-qualifier-conc2-matching

(defthm cst-asm-qualifier-conc2-matching
  (implies (cst-list-list-conc-matchp abnf::cstss "inline-keyword")
           (and (equal (len abnf::cstss) 1)
                (cst-list-rep-matchp (nth 0 abnf::cstss)
                                     "inline-keyword"))))

Theorem: cst-asm-qualifier-conc3-matching

(defthm cst-asm-qualifier-conc3-matching
  (implies (cst-list-list-conc-matchp abnf::cstss "%s\"goto\"")
           (and (equal (len abnf::cstss) 1)
                (cst-list-rep-matchp (nth 0 abnf::cstss)
                                     "%s\"goto\""))))

Theorem: cst-asm-output-operands-conc-matching

(defthm cst-asm-output-operands-conc-matching
 (implies
  (cst-list-list-conc-matchp
       abnf::cstss
       "[ asm-output-operand *( \",\" asm-output-operand ) ]")
  (and (equal (len abnf::cstss) 1)
       (cst-list-rep-matchp
            (nth 0 abnf::cstss)
            "[ asm-output-operand *( \",\" asm-output-operand ) ]"))))

Theorem: cst-asm-input-operands-conc-matching

(defthm cst-asm-input-operands-conc-matching
 (implies
    (cst-list-list-conc-matchp
         abnf::cstss
         "[ asm-input-operand *( \",\" asm-input-operand ) ]")
    (and (equal (len abnf::cstss) 1)
         (cst-list-rep-matchp
              (nth 0 abnf::cstss)
              "[ asm-input-operand *( \",\" asm-input-operand ) ]"))))

Theorem: cst-asm-clobbers-conc-matching

(defthm cst-asm-clobbers-conc-matching
 (implies
  (cst-list-list-conc-matchp abnf::cstss
                             "[ asm-clobber *( \",\" asm-clobber ) ]")
  (and
     (equal (len abnf::cstss) 1)
     (cst-list-rep-matchp (nth 0 abnf::cstss)
                          "[ asm-clobber *( \",\" asm-clobber ) ]"))))

Theorem: cst-asm-clobber-conc-matching

(defthm cst-asm-clobber-conc-matching
 (implies (cst-list-list-conc-matchp abnf::cstss "1*string-literal")
          (and (equal (len abnf::cstss) 1)
               (cst-list-rep-matchp (nth 0 abnf::cstss)
                                    "1*string-literal"))))

Theorem: cst-asm-goto-labels-conc-matching

(defthm cst-asm-goto-labels-conc-matching
 (implies
  (cst-list-list-conc-matchp abnf::cstss
                             "[ identifier *( \",\" identifier ) ]")
  (and (equal (len abnf::cstss) 1)
       (cst-list-rep-matchp (nth 0 abnf::cstss)
                            "[ identifier *( \",\" identifier ) ]"))))

Theorem: cst-declaration-conc2-matching

(defthm cst-declaration-conc2-matching
  (implies (cst-list-list-conc-matchp
                abnf::cstss "static-assert-declaration")
           (and (equal (len abnf::cstss) 1)
                (cst-list-rep-matchp (nth 0 abnf::cstss)
                                     "static-assert-declaration"))))

Theorem: cst-init-declarator-list-conc1-matching

(defthm cst-init-declarator-list-conc1-matching
  (implies (cst-list-list-conc-matchp abnf::cstss "init-declarator")
           (and (equal (len abnf::cstss) 1)
                (cst-list-rep-matchp (nth 0 abnf::cstss)
                                     "init-declarator"))))

Theorem: cst-storage-class-specifier-conc1-matching

(defthm cst-storage-class-specifier-conc1-matching
  (implies (cst-list-list-conc-matchp abnf::cstss "%s\"typedef\"")
           (and (equal (len abnf::cstss) 1)
                (cst-list-rep-matchp (nth 0 abnf::cstss)
                                     "%s\"typedef\""))))

Theorem: cst-storage-class-specifier-conc2-matching

(defthm cst-storage-class-specifier-conc2-matching
  (implies (cst-list-list-conc-matchp abnf::cstss "%s\"extern\"")
           (and (equal (len abnf::cstss) 1)
                (cst-list-rep-matchp (nth 0 abnf::cstss)
                                     "%s\"extern\""))))

Theorem: cst-storage-class-specifier-conc3-matching

(defthm cst-storage-class-specifier-conc3-matching
  (implies (cst-list-list-conc-matchp abnf::cstss "%s\"static\"")
           (and (equal (len abnf::cstss) 1)
                (cst-list-rep-matchp (nth 0 abnf::cstss)
                                     "%s\"static\""))))

Theorem: cst-storage-class-specifier-conc4-matching

(defthm cst-storage-class-specifier-conc4-matching
  (implies
       (cst-list-list-conc-matchp abnf::cstss "%s\"_Thread_local\"")
       (and (equal (len abnf::cstss) 1)
            (cst-list-rep-matchp (nth 0 abnf::cstss)
                                 "%s\"_Thread_local\""))))

Theorem: cst-storage-class-specifier-conc5-matching

(defthm cst-storage-class-specifier-conc5-matching
  (implies (cst-list-list-conc-matchp abnf::cstss "%s\"auto\"")
           (and (equal (len abnf::cstss) 1)
                (cst-list-rep-matchp (nth 0 abnf::cstss)
                                     "%s\"auto\""))))

Theorem: cst-storage-class-specifier-conc6-matching

(defthm cst-storage-class-specifier-conc6-matching
  (implies (cst-list-list-conc-matchp abnf::cstss "%s\"register\"")
           (and (equal (len abnf::cstss) 1)
                (cst-list-rep-matchp (nth 0 abnf::cstss)
                                     "%s\"register\""))))

Theorem: cst-type-specifier-conc1-matching

(defthm cst-type-specifier-conc1-matching
  (implies (cst-list-list-conc-matchp abnf::cstss "%s\"void\"")
           (and (equal (len abnf::cstss) 1)
                (cst-list-rep-matchp (nth 0 abnf::cstss)
                                     "%s\"void\""))))

Theorem: cst-type-specifier-conc2-matching

(defthm cst-type-specifier-conc2-matching
  (implies (cst-list-list-conc-matchp abnf::cstss "%s\"char\"")
           (and (equal (len abnf::cstss) 1)
                (cst-list-rep-matchp (nth 0 abnf::cstss)
                                     "%s\"char\""))))

Theorem: cst-type-specifier-conc3-matching

(defthm cst-type-specifier-conc3-matching
  (implies (cst-list-list-conc-matchp abnf::cstss "%s\"short\"")
           (and (equal (len abnf::cstss) 1)
                (cst-list-rep-matchp (nth 0 abnf::cstss)
                                     "%s\"short\""))))

Theorem: cst-type-specifier-conc4-matching

(defthm cst-type-specifier-conc4-matching
  (implies (cst-list-list-conc-matchp abnf::cstss "%s\"int\"")
           (and (equal (len abnf::cstss) 1)
                (cst-list-rep-matchp (nth 0 abnf::cstss)
                                     "%s\"int\""))))

Theorem: cst-type-specifier-conc5-matching

(defthm cst-type-specifier-conc5-matching
  (implies (cst-list-list-conc-matchp abnf::cstss "%s\"long\"")
           (and (equal (len abnf::cstss) 1)
                (cst-list-rep-matchp (nth 0 abnf::cstss)
                                     "%s\"long\""))))

Theorem: cst-type-specifier-conc6-matching

(defthm cst-type-specifier-conc6-matching
  (implies (cst-list-list-conc-matchp abnf::cstss "%s\"float\"")
           (and (equal (len abnf::cstss) 1)
                (cst-list-rep-matchp (nth 0 abnf::cstss)
                                     "%s\"float\""))))

Theorem: cst-type-specifier-conc7-matching

(defthm cst-type-specifier-conc7-matching
  (implies (cst-list-list-conc-matchp abnf::cstss "%s\"double\"")
           (and (equal (len abnf::cstss) 1)
                (cst-list-rep-matchp (nth 0 abnf::cstss)
                                     "%s\"double\""))))

Theorem: cst-type-specifier-conc8-matching

(defthm cst-type-specifier-conc8-matching
  (implies (cst-list-list-conc-matchp abnf::cstss "signed-keyword")
           (and (equal (len abnf::cstss) 1)
                (cst-list-rep-matchp (nth 0 abnf::cstss)
                                     "signed-keyword"))))

Theorem: cst-type-specifier-conc9-matching

(defthm cst-type-specifier-conc9-matching
  (implies (cst-list-list-conc-matchp abnf::cstss "%s\"unsigned\"")
           (and (equal (len abnf::cstss) 1)
                (cst-list-rep-matchp (nth 0 abnf::cstss)
                                     "%s\"unsigned\""))))

Theorem: cst-type-specifier-conc10-matching

(defthm cst-type-specifier-conc10-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-type-specifier-conc11-matching

(defthm cst-type-specifier-conc11-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-type-specifier-conc12-matching

(defthm cst-type-specifier-conc12-matching
  (implies (cst-list-list-conc-matchp abnf::cstss "%s\"_Complex\"")
           (and (equal (len abnf::cstss) 1)
                (cst-list-rep-matchp (nth 0 abnf::cstss)
                                     "%s\"_Complex\""))))

Theorem: cst-type-specifier-conc13-matching

(defthm cst-type-specifier-conc13-matching
 (implies
     (cst-list-list-conc-matchp abnf::cstss "atomic-type-specifier")
     (and (equal (len abnf::cstss) 1)
          (cst-list-rep-matchp (nth 0 abnf::cstss)
                               "atomic-type-specifier"))))

Theorem: cst-type-specifier-conc14-matching

(defthm cst-type-specifier-conc14-matching
  (implies (cst-list-list-conc-matchp
                abnf::cstss "struct-or-union-specifier")
           (and (equal (len abnf::cstss) 1)
                (cst-list-rep-matchp (nth 0 abnf::cstss)
                                     "struct-or-union-specifier"))))

Theorem: cst-type-specifier-conc15-matching

(defthm cst-type-specifier-conc15-matching
  (implies (cst-list-list-conc-matchp abnf::cstss "enum-specifier")
           (and (equal (len abnf::cstss) 1)
                (cst-list-rep-matchp (nth 0 abnf::cstss)
                                     "enum-specifier"))))

Theorem: cst-type-specifier-conc16-matching

(defthm cst-type-specifier-conc16-matching
  (implies (cst-list-list-conc-matchp abnf::cstss "typedef-name")
           (and (equal (len abnf::cstss) 1)
                (cst-list-rep-matchp (nth 0 abnf::cstss)
                                     "typedef-name"))))

Theorem: cst-type-specifier-conc17-matching

(defthm cst-type-specifier-conc17-matching
  (implies (cst-list-list-conc-matchp abnf::cstss "%s\"__int128\"")
           (and (equal (len abnf::cstss) 1)
                (cst-list-rep-matchp (nth 0 abnf::cstss)
                                     "%s\"__int128\""))))

Theorem: cst-type-specifier-conc18-matching

(defthm cst-type-specifier-conc18-matching
  (implies (cst-list-list-conc-matchp abnf::cstss "%s\"__float80\"")
           (and (equal (len abnf::cstss) 1)
                (cst-list-rep-matchp (nth 0 abnf::cstss)
                                     "%s\"__float80\""))))

Theorem: cst-type-specifier-conc19-matching

(defthm cst-type-specifier-conc19-matching
  (implies (cst-list-list-conc-matchp abnf::cstss "%s\"__float128\"")
           (and (equal (len abnf::cstss) 1)
                (cst-list-rep-matchp (nth 0 abnf::cstss)
                                     "%s\"__float128\""))))

Theorem: cst-type-specifier-conc20-matching

(defthm cst-type-specifier-conc20-matching
  (implies (cst-list-list-conc-matchp abnf::cstss "%s\"_Float16\"")
           (and (equal (len abnf::cstss) 1)
                (cst-list-rep-matchp (nth 0 abnf::cstss)
                                     "%s\"_Float16\""))))

Theorem: cst-type-specifier-conc21-matching

(defthm cst-type-specifier-conc21-matching
  (implies (cst-list-list-conc-matchp abnf::cstss "%s\"_Float16x\"")
           (and (equal (len abnf::cstss) 1)
                (cst-list-rep-matchp (nth 0 abnf::cstss)
                                     "%s\"_Float16x\""))))

Theorem: cst-type-specifier-conc22-matching

(defthm cst-type-specifier-conc22-matching
  (implies (cst-list-list-conc-matchp abnf::cstss "%s\"_Float32\"")
           (and (equal (len abnf::cstss) 1)
                (cst-list-rep-matchp (nth 0 abnf::cstss)
                                     "%s\"_Float32\""))))

Theorem: cst-type-specifier-conc23-matching

(defthm cst-type-specifier-conc23-matching
  (implies (cst-list-list-conc-matchp abnf::cstss "%s\"_Float32x\"")
           (and (equal (len abnf::cstss) 1)
                (cst-list-rep-matchp (nth 0 abnf::cstss)
                                     "%s\"_Float32x\""))))

Theorem: cst-type-specifier-conc24-matching

(defthm cst-type-specifier-conc24-matching
  (implies (cst-list-list-conc-matchp abnf::cstss "%s\"_Float64\"")
           (and (equal (len abnf::cstss) 1)
                (cst-list-rep-matchp (nth 0 abnf::cstss)
                                     "%s\"_Float64\""))))

Theorem: cst-type-specifier-conc25-matching

(defthm cst-type-specifier-conc25-matching
  (implies (cst-list-list-conc-matchp abnf::cstss "%s\"_Float64x\"")
           (and (equal (len abnf::cstss) 1)
                (cst-list-rep-matchp (nth 0 abnf::cstss)
                                     "%s\"_Float64x\""))))

Theorem: cst-type-specifier-conc26-matching

(defthm cst-type-specifier-conc26-matching
  (implies (cst-list-list-conc-matchp abnf::cstss "%s\"_Float128\"")
           (and (equal (len abnf::cstss) 1)
                (cst-list-rep-matchp (nth 0 abnf::cstss)
                                     "%s\"_Float128\""))))

Theorem: cst-type-specifier-conc27-matching

(defthm cst-type-specifier-conc27-matching
  (implies (cst-list-list-conc-matchp abnf::cstss "%s\"_Float128x\"")
           (and (equal (len abnf::cstss) 1)
                (cst-list-rep-matchp (nth 0 abnf::cstss)
                                     "%s\"_Float128x\""))))

Theorem: cst-type-specifier-conc28-matching

(defthm cst-type-specifier-conc28-matching
 (implies
     (cst-list-list-conc-matchp abnf::cstss "%s\"__builtin_va_list\"")
     (and (equal (len abnf::cstss) 1)
          (cst-list-rep-matchp (nth 0 abnf::cstss)
                               "%s\"__builtin_va_list\""))))

Theorem: cst-type-specifier-conc31-matching

(defthm cst-type-specifier-conc31-matching
  (implies (cst-list-list-conc-matchp abnf::cstss "%s\"__auto_type\"")
           (and (equal (len abnf::cstss) 1)
                (cst-list-rep-matchp (nth 0 abnf::cstss)
                                     "%s\"__auto_type\""))))

Theorem: cst-struct-or-union-conc1-matching

(defthm cst-struct-or-union-conc1-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-struct-or-union-conc2-matching

(defthm cst-struct-or-union-conc2-matching
  (implies (cst-list-list-conc-matchp abnf::cstss "%s\"union\"")
           (and (equal (len abnf::cstss) 1)
                (cst-list-rep-matchp (nth 0 abnf::cstss)
                                     "%s\"union\""))))

Theorem: cst-struct-declaration-list-conc1-matching

(defthm cst-struct-declaration-list-conc1-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-struct-declaration-conc2-matching

(defthm cst-struct-declaration-conc2-matching
  (implies (cst-list-list-conc-matchp
                abnf::cstss "static-assert-declaration")
           (and (equal (len abnf::cstss) 1)
                (cst-list-rep-matchp (nth 0 abnf::cstss)
                                     "static-assert-declaration"))))

Theorem: cst-struct-declaration-conc3-matching

(defthm cst-struct-declaration-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-struct-declarator-list-conc1-matching

(defthm cst-struct-declarator-list-conc1-matching
  (implies
       (cst-list-list-conc-matchp abnf::cstss "struct-declarator")
       (and (equal (len abnf::cstss) 1)
            (cst-list-rep-matchp (nth 0 abnf::cstss)
                                 "struct-declarator"))))

Theorem: cst-struct-declarator-conc1-matching

(defthm cst-struct-declarator-conc1-matching
  (implies (cst-list-list-conc-matchp abnf::cstss "declarator")
           (and (equal (len abnf::cstss) 1)
                (cst-list-rep-matchp (nth 0 abnf::cstss)
                                     "declarator"))))

Theorem: cst-enumerator-list-conc1-matching

(defthm cst-enumerator-list-conc1-matching
  (implies (cst-list-list-conc-matchp abnf::cstss "enumerator")
           (and (equal (len abnf::cstss) 1)
                (cst-list-rep-matchp (nth 0 abnf::cstss)
                                     "enumerator"))))

Theorem: cst-enumerator-conc1-matching

(defthm cst-enumerator-conc1-matching
 (implies
      (cst-list-list-conc-matchp abnf::cstss "enumeration-constant")
      (and (equal (len abnf::cstss) 1)
           (cst-list-rep-matchp (nth 0 abnf::cstss)
                                "enumeration-constant"))))

Theorem: cst-type-qualifier-conc1-matching

(defthm cst-type-qualifier-conc1-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-type-qualifier-conc2-matching

(defthm cst-type-qualifier-conc2-matching
 (implies (cst-list-list-conc-matchp abnf::cstss "restrict-keyword")
          (and (equal (len abnf::cstss) 1)
               (cst-list-rep-matchp (nth 0 abnf::cstss)
                                    "restrict-keyword"))))

Theorem: cst-type-qualifier-conc3-matching

(defthm cst-type-qualifier-conc3-matching
 (implies (cst-list-list-conc-matchp abnf::cstss "volatile-keyword")
          (and (equal (len abnf::cstss) 1)
               (cst-list-rep-matchp (nth 0 abnf::cstss)
                                    "volatile-keyword"))))

Theorem: cst-type-qualifier-conc4-matching

(defthm cst-type-qualifier-conc4-matching
  (implies (cst-list-list-conc-matchp abnf::cstss "%s\"_Atomic\"")
           (and (equal (len abnf::cstss) 1)
                (cst-list-rep-matchp (nth 0 abnf::cstss)
                                     "%s\"_Atomic\""))))

Theorem: cst-type-qualifier-conc5-matching

(defthm cst-type-qualifier-conc5-matching
  (implies (cst-list-list-conc-matchp abnf::cstss "%s\"__seg_fs\"")
           (and (equal (len abnf::cstss) 1)
                (cst-list-rep-matchp (nth 0 abnf::cstss)
                                     "%s\"__seg_fs\""))))

Theorem: cst-type-qualifier-conc6-matching

(defthm cst-type-qualifier-conc6-matching
  (implies (cst-list-list-conc-matchp abnf::cstss "%s\"__seg_gs\"")
           (and (equal (len abnf::cstss) 1)
                (cst-list-rep-matchp (nth 0 abnf::cstss)
                                     "%s\"__seg_gs\""))))

Theorem: cst-function-specifier-conc1-matching

(defthm cst-function-specifier-conc1-matching
  (implies (cst-list-list-conc-matchp abnf::cstss "inline-keyword")
           (and (equal (len abnf::cstss) 1)
                (cst-list-rep-matchp (nth 0 abnf::cstss)
                                     "inline-keyword"))))

Theorem: cst-function-specifier-conc2-matching

(defthm cst-function-specifier-conc2-matching
  (implies (cst-list-list-conc-matchp abnf::cstss "%s\"_Noreturn\"")
           (and (equal (len abnf::cstss) 1)
                (cst-list-rep-matchp (nth 0 abnf::cstss)
                                     "%s\"_Noreturn\""))))

Theorem: cst-direct-declarator-conc1-matching

(defthm cst-direct-declarator-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-type-qualifier-or-attribute-specifier-conc1-matching

(defthm cst-type-qualifier-or-attribute-specifier-conc1-matching
  (implies (cst-list-list-conc-matchp abnf::cstss "type-qualifier")
           (and (equal (len abnf::cstss) 1)
                (cst-list-rep-matchp (nth 0 abnf::cstss)
                                     "type-qualifier"))))

Theorem: cst-type-qualifier-or-attribute-specifier-conc2-matching

(defthm cst-type-qualifier-or-attribute-specifier-conc2-matching
  (implies
       (cst-list-list-conc-matchp abnf::cstss "attribute-specifier")
       (and (equal (len abnf::cstss) 1)
            (cst-list-rep-matchp (nth 0 abnf::cstss)
                                 "attribute-specifier"))))

Theorem: cst-type-qualifier-and-attribute-specifier-list-conc1-matching

(defthm
     cst-type-qualifier-and-attribute-specifier-list-conc1-matching
 (implies
  (cst-list-list-conc-matchp
       abnf::cstss
       "type-qualifier-or-attribute-specifier")
  (and
    (equal (len abnf::cstss) 1)
    (cst-list-rep-matchp (nth 0 abnf::cstss)
                         "type-qualifier-or-attribute-specifier"))))

Theorem: cst-parameter-type-list-conc1-matching

(defthm cst-parameter-type-list-conc1-matching
  (implies (cst-list-list-conc-matchp abnf::cstss "parameter-list")
           (and (equal (len abnf::cstss) 1)
                (cst-list-rep-matchp (nth 0 abnf::cstss)
                                     "parameter-list"))))

Theorem: cst-parameter-list-conc1-matching

(defthm cst-parameter-list-conc1-matching
 (implies
     (cst-list-list-conc-matchp abnf::cstss "parameter-declaration")
     (and (equal (len abnf::cstss) 1)
          (cst-list-rep-matchp (nth 0 abnf::cstss)
                               "parameter-declaration"))))

Theorem: cst-identifier-list-conc1-matching

(defthm cst-identifier-list-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-abstract-declarator-conc1-matching

(defthm cst-abstract-declarator-conc1-matching
  (implies (cst-list-list-conc-matchp abnf::cstss "pointer")
           (and (equal (len abnf::cstss) 1)
                (cst-list-rep-matchp (nth 0 abnf::cstss)
                                     "pointer"))))

Theorem: cst-typedef-name-conc-matching

(defthm cst-typedef-name-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-initializer-conc1-matching

(defthm cst-initializer-conc1-matching
 (implies
     (cst-list-list-conc-matchp abnf::cstss "assignment-expression")
     (and (equal (len abnf::cstss) 1)
          (cst-list-rep-matchp (nth 0 abnf::cstss)
                               "assignment-expression"))))

Theorem: cst-designator-list-conc1-matching

(defthm cst-designator-list-conc1-matching
  (implies (cst-list-list-conc-matchp abnf::cstss "designator")
           (and (equal (len abnf::cstss) 1)
                (cst-list-rep-matchp (nth 0 abnf::cstss)
                                     "designator"))))

Theorem: cst-statement-conc1-matching

(defthm cst-statement-conc1-matching
  (implies
       (cst-list-list-conc-matchp abnf::cstss "labeled-statement")
       (and (equal (len abnf::cstss) 1)
            (cst-list-rep-matchp (nth 0 abnf::cstss)
                                 "labeled-statement"))))

Theorem: cst-statement-conc2-matching

(defthm cst-statement-conc2-matching
  (implies
       (cst-list-list-conc-matchp abnf::cstss "compound-statement")
       (and (equal (len abnf::cstss) 1)
            (cst-list-rep-matchp (nth 0 abnf::cstss)
                                 "compound-statement"))))

Theorem: cst-statement-conc3-matching

(defthm cst-statement-conc3-matching
 (implies
      (cst-list-list-conc-matchp abnf::cstss "expression-statement")
      (and (equal (len abnf::cstss) 1)
           (cst-list-rep-matchp (nth 0 abnf::cstss)
                                "expression-statement"))))

Theorem: cst-statement-conc4-matching

(defthm cst-statement-conc4-matching
  (implies
       (cst-list-list-conc-matchp abnf::cstss "selection-statement")
       (and (equal (len abnf::cstss) 1)
            (cst-list-rep-matchp (nth 0 abnf::cstss)
                                 "selection-statement"))))

Theorem: cst-statement-conc5-matching

(defthm cst-statement-conc5-matching
  (implies
       (cst-list-list-conc-matchp abnf::cstss "iteration-statement")
       (and (equal (len abnf::cstss) 1)
            (cst-list-rep-matchp (nth 0 abnf::cstss)
                                 "iteration-statement"))))

Theorem: cst-statement-conc6-matching

(defthm cst-statement-conc6-matching
  (implies (cst-list-list-conc-matchp abnf::cstss "jump-statement")
           (and (equal (len abnf::cstss) 1)
                (cst-list-rep-matchp (nth 0 abnf::cstss)
                                     "jump-statement"))))

Theorem: cst-statement-conc7-matching

(defthm cst-statement-conc7-matching
  (implies (cst-list-list-conc-matchp abnf::cstss "asm-statement")
           (and (equal (len abnf::cstss) 1)
                (cst-list-rep-matchp (nth 0 abnf::cstss)
                                     "asm-statement"))))

Theorem: cst-block-item-list-conc1-matching

(defthm cst-block-item-list-conc1-matching
  (implies (cst-list-list-conc-matchp abnf::cstss "block-item")
           (and (equal (len abnf::cstss) 1)
                (cst-list-rep-matchp (nth 0 abnf::cstss)
                                     "block-item"))))

Theorem: cst-block-item-conc1-matching

(defthm cst-block-item-conc1-matching
  (implies (cst-list-list-conc-matchp abnf::cstss "declaration")
           (and (equal (len abnf::cstss) 1)
                (cst-list-rep-matchp (nth 0 abnf::cstss)
                                     "declaration"))))

Theorem: cst-block-item-conc2-matching

(defthm cst-block-item-conc2-matching
  (implies (cst-list-list-conc-matchp abnf::cstss "statement")
           (and (equal (len abnf::cstss) 1)
                (cst-list-rep-matchp (nth 0 abnf::cstss)
                                     "statement"))))

Theorem: cst-translation-unit-conc-matching

(defthm cst-translation-unit-conc-matching
 (implies
     (cst-list-list-conc-matchp abnf::cstss "*external-declaration")
     (and (equal (len abnf::cstss) 1)
          (cst-list-rep-matchp (nth 0 abnf::cstss)
                               "*external-declaration"))))

Theorem: cst-external-declaration-conc1-matching

(defthm cst-external-declaration-conc1-matching
  (implies
       (cst-list-list-conc-matchp abnf::cstss "function-definition")
       (and (equal (len abnf::cstss) 1)
            (cst-list-rep-matchp (nth 0 abnf::cstss)
                                 "function-definition"))))

Theorem: cst-external-declaration-conc2-matching

(defthm cst-external-declaration-conc2-matching
  (implies (cst-list-list-conc-matchp abnf::cstss "declaration")
           (and (equal (len abnf::cstss) 1)
                (cst-list-rep-matchp (nth 0 abnf::cstss)
                                     "declaration"))))

Theorem: cst-external-declaration-conc3-matching

(defthm cst-external-declaration-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-external-declaration-conc4-matching

(defthm cst-external-declaration-conc4-matching
  (implies (cst-list-list-conc-matchp abnf::cstss "asm-statement")
           (and (equal (len abnf::cstss) 1)
                (cst-list-rep-matchp (nth 0 abnf::cstss)
                                     "asm-statement"))))

Theorem: cst-declaration-list-conc1-matching

(defthm cst-declaration-list-conc1-matching
  (implies (cst-list-list-conc-matchp abnf::cstss "declaration")
           (and (equal (len abnf::cstss) 1)
                (cst-list-rep-matchp (nth 0 abnf::cstss)
                                     "declaration"))))

Theorem: cst-preprocessing-file-conc-matching

(defthm cst-preprocessing-file-conc-matching
  (implies (cst-list-list-conc-matchp abnf::cstss "[ group ]")
           (and (equal (len abnf::cstss) 1)
                (cst-list-rep-matchp (nth 0 abnf::cstss)
                                     "[ group ]"))))

Theorem: cst-group-conc1-matching

(defthm cst-group-conc1-matching
  (implies (cst-list-list-conc-matchp abnf::cstss "group-part")
           (and (equal (len abnf::cstss) 1)
                (cst-list-rep-matchp (nth 0 abnf::cstss)
                                     "group-part"))))

Theorem: cst-group-part-conc1-matching

(defthm cst-group-part-conc1-matching
  (implies (cst-list-list-conc-matchp abnf::cstss "if-section")
           (and (equal (len abnf::cstss) 1)
                (cst-list-rep-matchp (nth 0 abnf::cstss)
                                     "if-section"))))

Theorem: cst-group-part-conc2-matching

(defthm cst-group-part-conc2-matching
  (implies (cst-list-list-conc-matchp abnf::cstss "control-line")
           (and (equal (len abnf::cstss) 1)
                (cst-list-rep-matchp (nth 0 abnf::cstss)
                                     "control-line"))))

Theorem: cst-group-part-conc3-matching

(defthm cst-group-part-conc3-matching
  (implies (cst-list-list-conc-matchp abnf::cstss "text-line")
           (and (equal (len abnf::cstss) 1)
                (cst-list-rep-matchp (nth 0 abnf::cstss)
                                     "text-line"))))

Theorem: cst-elif-groups-conc1-matching

(defthm cst-elif-groups-conc1-matching
  (implies (cst-list-list-conc-matchp abnf::cstss "elif-group")
           (and (equal (len abnf::cstss) 1)
                (cst-list-rep-matchp (nth 0 abnf::cstss)
                                     "elif-group"))))

Theorem: cst-lparen-conc-matching

(defthm cst-lparen-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-replacement-list-conc-matching

(defthm cst-replacement-list-conc-matching
  (implies (cst-list-list-conc-matchp abnf::cstss "[ pp-tokens ]")
           (and (equal (len abnf::cstss) 1)
                (cst-list-rep-matchp (nth 0 abnf::cstss)
                                     "[ pp-tokens ]"))))

Theorem: cst-pp-tokens-conc1-matching

(defthm cst-pp-tokens-conc1-matching
  (implies
       (cst-list-list-conc-matchp abnf::cstss "preprocessing-token")
       (and (equal (len abnf::cstss) 1)
            (cst-list-rep-matchp (nth 0 abnf::cstss)
                                 "preprocessing-token"))))

Theorem: cst-on-off-switch-conc1-matching

(defthm cst-on-off-switch-conc1-matching
  (implies (cst-list-list-conc-matchp abnf::cstss "%s\"ON\"")
           (and (equal (len abnf::cstss) 1)
                (cst-list-rep-matchp (nth 0 abnf::cstss)
                                     "%s\"ON\""))))

Theorem: cst-on-off-switch-conc2-matching

(defthm cst-on-off-switch-conc2-matching
  (implies (cst-list-list-conc-matchp abnf::cstss "%s\"OFF\"")
           (and (equal (len abnf::cstss) 1)
                (cst-list-rep-matchp (nth 0 abnf::cstss)
                                     "%s\"OFF\""))))

Theorem: cst-on-off-switch-conc3-matching

(defthm cst-on-off-switch-conc3-matching
  (implies (cst-list-list-conc-matchp abnf::cstss "%s\"DEFAULT\"")
           (and (equal (len abnf::cstss) 1)
                (cst-list-rep-matchp (nth 0 abnf::cstss)
                                     "%s\"DEFAULT\""))))

Theorem: cst-uppercase-letter-conc-rep-matching

(defthm cst-uppercase-letter-conc-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "%x41-5A")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "%x41-5A"))))

Theorem: cst-lowercase-letter-conc-rep-matching

(defthm cst-lowercase-letter-conc-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "%x61-7A")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "%x61-7A"))))

Theorem: cst-letter-conc1-rep-matching

(defthm cst-letter-conc1-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "uppercase-letter")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "uppercase-letter"))))

Theorem: cst-letter-conc2-rep-matching

(defthm cst-letter-conc2-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "lowercase-letter")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "lowercase-letter"))))

Theorem: cst-digit-conc-rep-matching

(defthm cst-digit-conc-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "%x30-39")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "%x30-39"))))

Theorem: cst-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-graphic-character-conc1-rep-matching

(defthm cst-graphic-character-conc1-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "%x21-23")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "%x21-23"))))

Theorem: cst-graphic-character-conc2-rep-matching

(defthm cst-graphic-character-conc2-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "%x25-2F")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "%x25-2F"))))

Theorem: cst-graphic-character-conc3-rep-matching

(defthm cst-graphic-character-conc3-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "%x3A-3F")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "%x3A-3F"))))

Theorem: cst-graphic-character-conc4-rep-matching

(defthm cst-graphic-character-conc4-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "%x5B-5F")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "%x5B-5F"))))

Theorem: cst-graphic-character-conc5-rep-matching

(defthm cst-graphic-character-conc5-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "%x7B-7E")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "%x7B-7E"))))

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-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-vertical-tab-conc-rep-matching

(defthm cst-vertical-tab-conc-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "%xB")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts) "%xB"))))

Theorem: cst-form-feed-conc-rep-matching

(defthm cst-form-feed-conc-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "%xC")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts) "%xC"))))

Theorem: cst-control-character-conc1-rep-matching

(defthm cst-control-character-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-control-character-conc2-rep-matching

(defthm cst-control-character-conc2-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "vertical-tab")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "vertical-tab"))))

Theorem: cst-control-character-conc3-rep-matching

(defthm cst-control-character-conc3-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "form-feed")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "form-feed"))))

Theorem: cst-basic-character-conc1-rep-matching

(defthm cst-basic-character-conc1-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "letter")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "letter"))))

Theorem: cst-basic-character-conc2-rep-matching

(defthm cst-basic-character-conc2-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "digit")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "digit"))))

Theorem: cst-basic-character-conc3-rep-matching

(defthm cst-basic-character-conc3-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "graphic-character")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "graphic-character"))))

Theorem: cst-basic-character-conc4-rep-matching

(defthm cst-basic-character-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-basic-character-conc5-rep-matching

(defthm cst-basic-character-conc5-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "control-character")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "control-character"))))

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-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-extended-character-conc1-rep-matching

(defthm cst-extended-character-conc1-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "%x24")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "%x24"))))

Theorem: cst-extended-character-conc2-rep-matching

(defthm cst-extended-character-conc2-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "%x40")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "%x40"))))

Theorem: cst-extended-character-conc3-rep-matching

(defthm cst-extended-character-conc3-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "%x60")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "%x60"))))

Theorem: cst-extended-character-conc4-rep-matching

(defthm cst-extended-character-conc4-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-extended-character-conc5-rep-matching

(defthm cst-extended-character-conc5-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-extended-character-conc6-rep-matching

(defthm cst-extended-character-conc6-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "safe-nonascii")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "safe-nonascii"))))

Theorem: cst-character-conc1-rep-matching

(defthm cst-character-conc1-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "basic-character")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "basic-character"))))

Theorem: cst-character-conc2-rep-matching

(defthm cst-character-conc2-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "extended-character")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "extended-character"))))

Theorem: cst-new-line-conc1-rep-matching

(defthm cst-new-line-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-new-line-conc2-rep-matching

(defthm cst-new-line-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-extended-character-not-new-line-conc1-rep-matching

(defthm cst-extended-character-not-new-line-conc1-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "%x24")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "%x24"))))

Theorem: cst-extended-character-not-new-line-conc2-rep-matching

(defthm cst-extended-character-not-new-line-conc2-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "%x40")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "%x40"))))

Theorem: cst-extended-character-not-new-line-conc3-rep-matching

(defthm cst-extended-character-not-new-line-conc3-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "%x60")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "%x60"))))

Theorem: cst-extended-character-not-new-line-conc4-rep-matching

(defthm cst-extended-character-not-new-line-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-graphic-character-not-star-conc1-rep-matching

(defthm cst-graphic-character-not-star-conc1-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "%x21-23")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "%x21-23"))))

Theorem: cst-graphic-character-not-star-conc2-rep-matching

(defthm cst-graphic-character-not-star-conc2-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "%x25-29")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "%x25-29"))))

Theorem: cst-graphic-character-not-star-conc3-rep-matching

(defthm cst-graphic-character-not-star-conc3-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "%x2B-2F")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "%x2B-2F"))))

Theorem: cst-graphic-character-not-star-conc4-rep-matching

(defthm cst-graphic-character-not-star-conc4-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "%x3A-3F")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "%x3A-3F"))))

Theorem: cst-graphic-character-not-star-conc5-rep-matching

(defthm cst-graphic-character-not-star-conc5-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "%x5B-5F")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "%x5B-5F"))))

Theorem: cst-graphic-character-not-star-conc6-rep-matching

(defthm cst-graphic-character-not-star-conc6-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "%x7B-7E")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "%x7B-7E"))))

Theorem: cst-graphic-character-not-greater-than-conc1-rep-matching

(defthm cst-graphic-character-not-greater-than-conc1-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "%x21-23")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "%x21-23"))))

Theorem: cst-graphic-character-not-greater-than-conc2-rep-matching

(defthm cst-graphic-character-not-greater-than-conc2-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "%x25-2F")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "%x25-2F"))))

Theorem: cst-graphic-character-not-greater-than-conc3-rep-matching

(defthm cst-graphic-character-not-greater-than-conc3-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "%x3A-3D")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "%x3A-3D"))))

Theorem: cst-graphic-character-not-greater-than-conc4-rep-matching

(defthm cst-graphic-character-not-greater-than-conc4-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "%x3F")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "%x3F"))))

Theorem: cst-graphic-character-not-greater-than-conc5-rep-matching

(defthm cst-graphic-character-not-greater-than-conc5-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "%x5B-5F")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "%x5B-5F"))))

Theorem: cst-graphic-character-not-greater-than-conc6-rep-matching

(defthm cst-graphic-character-not-greater-than-conc6-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "%x7B-7E")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "%x7B-7E"))))

Theorem: cst-graphic-character-not-double-quote-conc1-rep-matching

(defthm cst-graphic-character-not-double-quote-conc1-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "%x21")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "%x21"))))

Theorem: cst-graphic-character-not-double-quote-conc2-rep-matching

(defthm cst-graphic-character-not-double-quote-conc2-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "%x23")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "%x23"))))

Theorem: cst-graphic-character-not-double-quote-conc3-rep-matching

(defthm cst-graphic-character-not-double-quote-conc3-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "%x25-2F")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "%x25-2F"))))

Theorem: cst-graphic-character-not-double-quote-conc4-rep-matching

(defthm cst-graphic-character-not-double-quote-conc4-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "%x3A-3F")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "%x3A-3F"))))

Theorem: cst-graphic-character-not-double-quote-conc5-rep-matching

(defthm cst-graphic-character-not-double-quote-conc5-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "%x5B-5F")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "%x5B-5F"))))

Theorem: cst-graphic-character-not-double-quote-conc6-rep-matching

(defthm cst-graphic-character-not-double-quote-conc6-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "%x7B-7E")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "%x7B-7E"))))

Theorem: cst-graphic-character-not-star-or-slash-conc1-rep-matching

(defthm cst-graphic-character-not-star-or-slash-conc1-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "%x21-23")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "%x21-23"))))

Theorem: cst-graphic-character-not-star-or-slash-conc2-rep-matching

(defthm cst-graphic-character-not-star-or-slash-conc2-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "%x25-29")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "%x25-29"))))

Theorem: cst-graphic-character-not-star-or-slash-conc3-rep-matching

(defthm cst-graphic-character-not-star-or-slash-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-graphic-character-not-star-or-slash-conc4-rep-matching

(defthm cst-graphic-character-not-star-or-slash-conc4-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "%x3A-3F")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "%x3A-3F"))))

Theorem: cst-graphic-character-not-star-or-slash-conc5-rep-matching

(defthm cst-graphic-character-not-star-or-slash-conc5-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "%x5B-5F")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "%x5B-5F"))))

Theorem: cst-graphic-character-not-star-or-slash-conc6-rep-matching

(defthm cst-graphic-character-not-star-or-slash-conc6-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "%x7B-7E")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "%x7B-7E"))))

Theorem: cst-graphic-character-not-single-quote-or-backslash-conc1-rep-matching

(defthm
 cst-graphic-character-not-single-quote-or-backslash-conc1-rep-matching
 (implies (cst-list-rep-matchp abnf::csts "%x21-23")
          (and (equal (len abnf::csts) 1)
               (cst-matchp (nth 0 abnf::csts)
                           "%x21-23"))))

Theorem: cst-graphic-character-not-single-quote-or-backslash-conc2-rep-matching

(defthm
 cst-graphic-character-not-single-quote-or-backslash-conc2-rep-matching
 (implies (cst-list-rep-matchp abnf::csts "%x25-26")
          (and (equal (len abnf::csts) 1)
               (cst-matchp (nth 0 abnf::csts)
                           "%x25-26"))))

Theorem: cst-graphic-character-not-single-quote-or-backslash-conc3-rep-matching

(defthm
 cst-graphic-character-not-single-quote-or-backslash-conc3-rep-matching
 (implies (cst-list-rep-matchp abnf::csts "%x28-2F")
          (and (equal (len abnf::csts) 1)
               (cst-matchp (nth 0 abnf::csts)
                           "%x28-2F"))))

Theorem: cst-graphic-character-not-single-quote-or-backslash-conc4-rep-matching

(defthm
 cst-graphic-character-not-single-quote-or-backslash-conc4-rep-matching
 (implies (cst-list-rep-matchp abnf::csts "%x3A-3F")
          (and (equal (len abnf::csts) 1)
               (cst-matchp (nth 0 abnf::csts)
                           "%x3A-3F"))))

Theorem: cst-graphic-character-not-single-quote-or-backslash-conc5-rep-matching

(defthm
 cst-graphic-character-not-single-quote-or-backslash-conc5-rep-matching
 (implies (cst-list-rep-matchp abnf::csts "%x5B")
          (and (equal (len abnf::csts) 1)
               (cst-matchp (nth 0 abnf::csts)
                           "%x5B"))))

Theorem: cst-graphic-character-not-single-quote-or-backslash-conc6-rep-matching

(defthm
 cst-graphic-character-not-single-quote-or-backslash-conc6-rep-matching
 (implies (cst-list-rep-matchp abnf::csts "%x5D-5F")
          (and (equal (len abnf::csts) 1)
               (cst-matchp (nth 0 abnf::csts)
                           "%x5D-5F"))))

Theorem: cst-graphic-character-not-single-quote-or-backslash-conc7-rep-matching

(defthm
 cst-graphic-character-not-single-quote-or-backslash-conc7-rep-matching
 (implies (cst-list-rep-matchp abnf::csts "%x7B-7E")
          (and (equal (len abnf::csts) 1)
               (cst-matchp (nth 0 abnf::csts)
                           "%x7B-7E"))))

Theorem: cst-graphic-character-not-double-quote-or-backslash-conc1-rep-matching

(defthm
 cst-graphic-character-not-double-quote-or-backslash-conc1-rep-matching
 (implies (cst-list-rep-matchp abnf::csts "%x21")
          (and (equal (len abnf::csts) 1)
               (cst-matchp (nth 0 abnf::csts)
                           "%x21"))))

Theorem: cst-graphic-character-not-double-quote-or-backslash-conc2-rep-matching

(defthm
 cst-graphic-character-not-double-quote-or-backslash-conc2-rep-matching
 (implies (cst-list-rep-matchp abnf::csts "%x23")
          (and (equal (len abnf::csts) 1)
               (cst-matchp (nth 0 abnf::csts)
                           "%x23"))))

Theorem: cst-graphic-character-not-double-quote-or-backslash-conc3-rep-matching

(defthm
 cst-graphic-character-not-double-quote-or-backslash-conc3-rep-matching
 (implies (cst-list-rep-matchp abnf::csts "%x25-2F")
          (and (equal (len abnf::csts) 1)
               (cst-matchp (nth 0 abnf::csts)
                           "%x25-2F"))))

Theorem: cst-graphic-character-not-double-quote-or-backslash-conc4-rep-matching

(defthm
 cst-graphic-character-not-double-quote-or-backslash-conc4-rep-matching
 (implies (cst-list-rep-matchp abnf::csts "%x3A-3F")
          (and (equal (len abnf::csts) 1)
               (cst-matchp (nth 0 abnf::csts)
                           "%x3A-3F"))))

Theorem: cst-graphic-character-not-double-quote-or-backslash-conc5-rep-matching

(defthm
 cst-graphic-character-not-double-quote-or-backslash-conc5-rep-matching
 (implies (cst-list-rep-matchp abnf::csts "%x5B")
          (and (equal (len abnf::csts) 1)
               (cst-matchp (nth 0 abnf::csts)
                           "%x5B"))))

Theorem: cst-graphic-character-not-double-quote-or-backslash-conc6-rep-matching

(defthm
 cst-graphic-character-not-double-quote-or-backslash-conc6-rep-matching
 (implies (cst-list-rep-matchp abnf::csts "%x5D-5F")
          (and (equal (len abnf::csts) 1)
               (cst-matchp (nth 0 abnf::csts)
                           "%x5D-5F"))))

Theorem: cst-graphic-character-not-double-quote-or-backslash-conc7-rep-matching

(defthm
 cst-graphic-character-not-double-quote-or-backslash-conc7-rep-matching
 (implies (cst-list-rep-matchp abnf::csts "%x7B-7E")
          (and (equal (len abnf::csts) 1)
               (cst-matchp (nth 0 abnf::csts)
                           "%x7B-7E"))))

Theorem: cst-basic-character-not-star-conc1-rep-matching

(defthm cst-basic-character-not-star-conc1-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "letter")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "letter"))))

Theorem: cst-basic-character-not-star-conc2-rep-matching

(defthm cst-basic-character-not-star-conc2-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "digit")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "digit"))))

Theorem: cst-basic-character-not-star-conc3-rep-matching

(defthm cst-basic-character-not-star-conc3-rep-matching
  (implies
       (cst-list-rep-matchp abnf::csts "graphic-character-not-star")
       (and (equal (len abnf::csts) 1)
            (cst-matchp (nth 0 abnf::csts)
                        "graphic-character-not-star"))))

Theorem: cst-basic-character-not-star-conc4-rep-matching

(defthm cst-basic-character-not-star-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-basic-character-not-star-conc5-rep-matching

(defthm cst-basic-character-not-star-conc5-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "control-character")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "control-character"))))

Theorem: cst-basic-character-not-greater-than-conc1-rep-matching

(defthm cst-basic-character-not-greater-than-conc1-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "letter")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "letter"))))

Theorem: cst-basic-character-not-greater-than-conc2-rep-matching

(defthm cst-basic-character-not-greater-than-conc2-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "digit")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "digit"))))

Theorem: cst-basic-character-not-greater-than-conc3-rep-matching

(defthm cst-basic-character-not-greater-than-conc3-rep-matching
 (implies (cst-list-rep-matchp abnf::csts
                               "graphic-character-not-greater-than")
          (and (equal (len abnf::csts) 1)
               (cst-matchp (nth 0 abnf::csts)
                           "graphic-character-not-greater-than"))))

Theorem: cst-basic-character-not-greater-than-conc4-rep-matching

(defthm cst-basic-character-not-greater-than-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-basic-character-not-greater-than-conc5-rep-matching

(defthm cst-basic-character-not-greater-than-conc5-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "control-character")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "control-character"))))

Theorem: cst-basic-character-not-double-quote-conc1-rep-matching

(defthm cst-basic-character-not-double-quote-conc1-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "letter")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "letter"))))

Theorem: cst-basic-character-not-double-quote-conc2-rep-matching

(defthm cst-basic-character-not-double-quote-conc2-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "digit")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "digit"))))

Theorem: cst-basic-character-not-double-quote-conc3-rep-matching

(defthm cst-basic-character-not-double-quote-conc3-rep-matching
 (implies (cst-list-rep-matchp abnf::csts
                               "graphic-character-not-double-quote")
          (and (equal (len abnf::csts) 1)
               (cst-matchp (nth 0 abnf::csts)
                           "graphic-character-not-double-quote"))))

Theorem: cst-basic-character-not-double-quote-conc4-rep-matching

(defthm cst-basic-character-not-double-quote-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-basic-character-not-double-quote-conc5-rep-matching

(defthm cst-basic-character-not-double-quote-conc5-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "control-character")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "control-character"))))

Theorem: cst-basic-character-not-star-or-slash-conc1-rep-matching

(defthm cst-basic-character-not-star-or-slash-conc1-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "letter")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "letter"))))

Theorem: cst-basic-character-not-star-or-slash-conc2-rep-matching

(defthm cst-basic-character-not-star-or-slash-conc2-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "digit")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "digit"))))

Theorem: cst-basic-character-not-star-or-slash-conc3-rep-matching

(defthm cst-basic-character-not-star-or-slash-conc3-rep-matching
  (implies
       (cst-list-rep-matchp abnf::csts
                            "graphic-character-not-star-or-slash")
       (and (equal (len abnf::csts) 1)
            (cst-matchp (nth 0 abnf::csts)
                        "graphic-character-not-star-or-slash"))))

Theorem: cst-basic-character-not-star-or-slash-conc4-rep-matching

(defthm cst-basic-character-not-star-or-slash-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-basic-character-not-star-or-slash-conc5-rep-matching

(defthm cst-basic-character-not-star-or-slash-conc5-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "control-character")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "control-character"))))

Theorem: cst-basic-character-not-single-quote-or-backslash-conc1-rep-matching

(defthm
 cst-basic-character-not-single-quote-or-backslash-conc1-rep-matching
 (implies (cst-list-rep-matchp abnf::csts "letter")
          (and (equal (len abnf::csts) 1)
               (cst-matchp (nth 0 abnf::csts)
                           "letter"))))

Theorem: cst-basic-character-not-single-quote-or-backslash-conc2-rep-matching

(defthm
 cst-basic-character-not-single-quote-or-backslash-conc2-rep-matching
 (implies (cst-list-rep-matchp abnf::csts "digit")
          (and (equal (len abnf::csts) 1)
               (cst-matchp (nth 0 abnf::csts)
                           "digit"))))

Theorem: cst-basic-character-not-single-quote-or-backslash-conc3-rep-matching

(defthm
 cst-basic-character-not-single-quote-or-backslash-conc3-rep-matching
 (implies
  (cst-list-rep-matchp
       abnf::csts
       "graphic-character-not-single-quote-or-backslash")
  (and
   (equal (len abnf::csts) 1)
   (cst-matchp (nth 0 abnf::csts)
               "graphic-character-not-single-quote-or-backslash"))))

Theorem: cst-basic-character-not-single-quote-or-backslash-conc4-rep-matching

(defthm
 cst-basic-character-not-single-quote-or-backslash-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-basic-character-not-single-quote-or-backslash-conc5-rep-matching

(defthm
 cst-basic-character-not-single-quote-or-backslash-conc5-rep-matching
 (implies (cst-list-rep-matchp abnf::csts "control-character")
          (and (equal (len abnf::csts) 1)
               (cst-matchp (nth 0 abnf::csts)
                           "control-character"))))

Theorem: cst-basic-character-not-double-quote-or-backslash-conc1-rep-matching

(defthm
 cst-basic-character-not-double-quote-or-backslash-conc1-rep-matching
 (implies (cst-list-rep-matchp abnf::csts "letter")
          (and (equal (len abnf::csts) 1)
               (cst-matchp (nth 0 abnf::csts)
                           "letter"))))

Theorem: cst-basic-character-not-double-quote-or-backslash-conc2-rep-matching

(defthm
 cst-basic-character-not-double-quote-or-backslash-conc2-rep-matching
 (implies (cst-list-rep-matchp abnf::csts "digit")
          (and (equal (len abnf::csts) 1)
               (cst-matchp (nth 0 abnf::csts)
                           "digit"))))

Theorem: cst-basic-character-not-double-quote-or-backslash-conc3-rep-matching

(defthm
 cst-basic-character-not-double-quote-or-backslash-conc3-rep-matching
 (implies
  (cst-list-rep-matchp
       abnf::csts
       "graphic-character-not-double-quote-or-backslash")
  (and
   (equal (len abnf::csts) 1)
   (cst-matchp (nth 0 abnf::csts)
               "graphic-character-not-double-quote-or-backslash"))))

Theorem: cst-basic-character-not-double-quote-or-backslash-conc4-rep-matching

(defthm
 cst-basic-character-not-double-quote-or-backslash-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-basic-character-not-double-quote-or-backslash-conc5-rep-matching

(defthm
 cst-basic-character-not-double-quote-or-backslash-conc5-rep-matching
 (implies (cst-list-rep-matchp abnf::csts "control-character")
          (and (equal (len abnf::csts) 1)
               (cst-matchp (nth 0 abnf::csts)
                           "control-character"))))

Theorem: cst-character-not-new-line-conc1-rep-matching

(defthm cst-character-not-new-line-conc1-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "basic-character")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "basic-character"))))

Theorem: cst-character-not-new-line-conc2-rep-matching

(defthm cst-character-not-new-line-conc2-rep-matching
  (implies (cst-list-rep-matchp abnf::csts
                                "extended-character-not-new-line")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "extended-character-not-new-line"))))

Theorem: cst-character-not-star-conc1-rep-matching

(defthm cst-character-not-star-conc1-rep-matching
  (implies
       (cst-list-rep-matchp abnf::csts "basic-character-not-star")
       (and (equal (len abnf::csts) 1)
            (cst-matchp (nth 0 abnf::csts)
                        "basic-character-not-star"))))

Theorem: cst-character-not-star-conc2-rep-matching

(defthm cst-character-not-star-conc2-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "extended-character")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "extended-character"))))

Theorem: cst-character-not-star-or-slash-conc1-rep-matching

(defthm cst-character-not-star-or-slash-conc1-rep-matching
  (implies (cst-list-rep-matchp abnf::csts
                                "basic-character-not-star-or-slash")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "basic-character-not-star-or-slash"))))

Theorem: cst-character-not-star-or-slash-conc2-rep-matching

(defthm cst-character-not-star-or-slash-conc2-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "extended-character")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "extended-character"))))

Theorem: cst-character-not-greater-than-or-new-line-conc1-rep-matching

(defthm
      cst-character-not-greater-than-or-new-line-conc1-rep-matching
  (implies (cst-list-rep-matchp abnf::csts
                                "basic-character-not-greater-than")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "basic-character-not-greater-than"))))

Theorem: cst-character-not-greater-than-or-new-line-conc2-rep-matching

(defthm
      cst-character-not-greater-than-or-new-line-conc2-rep-matching
  (implies (cst-list-rep-matchp abnf::csts
                                "extended-character-not-new-line")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "extended-character-not-new-line"))))

Theorem: cst-character-not-double-quote-or-new-line-conc1-rep-matching

(defthm
      cst-character-not-double-quote-or-new-line-conc1-rep-matching
  (implies (cst-list-rep-matchp abnf::csts
                                "basic-character-not-double-quote")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "basic-character-not-double-quote"))))

Theorem: cst-character-not-double-quote-or-new-line-conc2-rep-matching

(defthm
      cst-character-not-double-quote-or-new-line-conc2-rep-matching
  (implies (cst-list-rep-matchp abnf::csts
                                "extended-character-not-new-line")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "extended-character-not-new-line"))))

Theorem: cst-character-not-single-quote-or-backslash-or-new-line-conc1-rep-matching

(defthm
 cst-character-not-single-quote-or-backslash-or-new-line-conc1-rep-matching
 (implies
  (cst-list-rep-matchp
       abnf::csts
       "basic-character-not-single-quote-or-backslash")
  (and
     (equal (len abnf::csts) 1)
     (cst-matchp (nth 0 abnf::csts)
                 "basic-character-not-single-quote-or-backslash"))))

Theorem: cst-character-not-single-quote-or-backslash-or-new-line-conc2-rep-matching

(defthm
 cst-character-not-single-quote-or-backslash-or-new-line-conc2-rep-matching
 (implies (cst-list-rep-matchp abnf::csts
                               "extended-character-not-new-line")
          (and (equal (len abnf::csts) 1)
               (cst-matchp (nth 0 abnf::csts)
                           "extended-character-not-new-line"))))

Theorem: cst-character-not-double-quote-or-backslash-or-new-line-conc1-rep-matching

(defthm
 cst-character-not-double-quote-or-backslash-or-new-line-conc1-rep-matching
 (implies
  (cst-list-rep-matchp
       abnf::csts
       "basic-character-not-double-quote-or-backslash")
  (and
     (equal (len abnf::csts) 1)
     (cst-matchp (nth 0 abnf::csts)
                 "basic-character-not-double-quote-or-backslash"))))

Theorem: cst-character-not-double-quote-or-backslash-or-new-line-conc2-rep-matching

(defthm
 cst-character-not-double-quote-or-backslash-or-new-line-conc2-rep-matching
 (implies (cst-list-rep-matchp abnf::csts
                               "extended-character-not-new-line")
          (and (equal (len abnf::csts) 1)
               (cst-matchp (nth 0 abnf::csts)
                           "extended-character-not-new-line"))))

Theorem: cst-white-space-conc1-rep-matching

(defthm cst-white-space-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-white-space-conc2-rep-matching

(defthm cst-white-space-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-white-space-conc3-rep-matching

(defthm cst-white-space-conc3-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "vertical-tab")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "vertical-tab"))))

Theorem: cst-white-space-conc4-rep-matching

(defthm cst-white-space-conc4-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "form-feed")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "form-feed"))))

Theorem: cst-white-space-conc5-rep-matching

(defthm cst-white-space-conc5-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "new-line")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "new-line"))))

Theorem: cst-h-char-sequence-conc1-rep-matching

(defthm cst-h-char-sequence-conc1-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "h-char")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "h-char"))))

Theorem: cst-h-char-conc-rep-matching

(defthm cst-h-char-conc-rep-matching
 (implies
      (cst-list-rep-matchp abnf::csts
                           "character-not-greater-than-or-new-line")
      (and (equal (len abnf::csts) 1)
           (cst-matchp (nth 0 abnf::csts)
                       "character-not-greater-than-or-new-line"))))

Theorem: cst-q-char-sequence-conc1-rep-matching

(defthm cst-q-char-sequence-conc1-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "q-char")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "q-char"))))

Theorem: cst-q-char-conc-rep-matching

(defthm cst-q-char-conc-rep-matching
 (implies
      (cst-list-rep-matchp abnf::csts
                           "character-not-double-quote-or-new-line")
      (and (equal (len abnf::csts) 1)
           (cst-matchp (nth 0 abnf::csts)
                       "character-not-double-quote-or-new-line"))))

Theorem: cst-pp-number-conc1-rep-matching

(defthm cst-pp-number-conc1-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "digit")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "digit"))))

Theorem: cst-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-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 "constant")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "constant"))))

Theorem: cst-token-conc4-rep-matching

(defthm cst-token-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-token-conc5-rep-matching

(defthm cst-token-conc5-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "punctuator")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "punctuator"))))

Theorem: cst-preprocessing-token-conc1-rep-matching

(defthm cst-preprocessing-token-conc1-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "header-name")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "header-name"))))

Theorem: cst-preprocessing-token-conc2-rep-matching

(defthm cst-preprocessing-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-preprocessing-token-conc3-rep-matching

(defthm cst-preprocessing-token-conc3-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "pp-number")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "pp-number"))))

Theorem: cst-preprocessing-token-conc4-rep-matching

(defthm cst-preprocessing-token-conc4-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "character-constant")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "character-constant"))))

Theorem: cst-preprocessing-token-conc5-rep-matching

(defthm cst-preprocessing-token-conc5-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-preprocessing-token-conc6-rep-matching

(defthm cst-preprocessing-token-conc6-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "punctuator")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "punctuator"))))

Theorem: cst-preprocessing-token-conc7-rep-matching

(defthm cst-preprocessing-token-conc7-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "character")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "character"))))

Theorem: cst-keyword-conc1-rep-matching

(defthm cst-keyword-conc1-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "%s\"auto\"")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "%s\"auto\""))))

Theorem: cst-keyword-conc2-rep-matching

(defthm cst-keyword-conc2-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-conc3-rep-matching

(defthm cst-keyword-conc3-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "%s\"break\"")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "%s\"break\""))))

Theorem: cst-keyword-conc4-rep-matching

(defthm cst-keyword-conc4-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "%s\"case\"")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "%s\"case\""))))

Theorem: cst-keyword-conc5-rep-matching

(defthm cst-keyword-conc5-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "%s\"char\"")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "%s\"char\""))))

Theorem: cst-keyword-conc6-rep-matching

(defthm cst-keyword-conc6-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-conc7-rep-matching

(defthm cst-keyword-conc7-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "%s\"continue\"")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "%s\"continue\""))))

Theorem: cst-keyword-conc8-rep-matching

(defthm cst-keyword-conc8-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "%s\"default\"")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "%s\"default\""))))

Theorem: cst-keyword-conc9-rep-matching

(defthm cst-keyword-conc9-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "%s\"do\"")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "%s\"do\""))))

Theorem: cst-keyword-conc10-rep-matching

(defthm cst-keyword-conc10-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "%s\"double\"")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "%s\"double\""))))

Theorem: cst-keyword-conc11-rep-matching

(defthm cst-keyword-conc11-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-conc12-rep-matching

(defthm cst-keyword-conc12-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "%s\"enum\"")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "%s\"enum\""))))

Theorem: cst-keyword-conc13-rep-matching

(defthm cst-keyword-conc13-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "%s\"extern\"")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "%s\"extern\""))))

Theorem: cst-keyword-conc14-rep-matching

(defthm cst-keyword-conc14-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-keyword-conc15-rep-matching

(defthm cst-keyword-conc15-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "%s\"float\"")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "%s\"float\""))))

Theorem: cst-keyword-conc16-rep-matching

(defthm cst-keyword-conc16-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-conc17-rep-matching

(defthm cst-keyword-conc17-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "%s\"goto\"")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "%s\"goto\""))))

Theorem: cst-keyword-conc18-rep-matching

(defthm cst-keyword-conc18-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-conc19-rep-matching

(defthm cst-keyword-conc19-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "%s\"inline\"")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "%s\"inline\""))))

Theorem: cst-keyword-conc20-rep-matching

(defthm cst-keyword-conc20-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "%s\"int\"")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "%s\"int\""))))

Theorem: cst-keyword-conc21-rep-matching

(defthm cst-keyword-conc21-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "%s\"long\"")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "%s\"long\""))))

Theorem: cst-keyword-conc22-rep-matching

(defthm cst-keyword-conc22-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "%s\"register\"")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "%s\"register\""))))

Theorem: cst-keyword-conc23-rep-matching

(defthm cst-keyword-conc23-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "%s\"restrict\"")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "%s\"restrict\""))))

Theorem: cst-keyword-conc24-rep-matching

(defthm cst-keyword-conc24-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-conc25-rep-matching

(defthm cst-keyword-conc25-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "%s\"short\"")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "%s\"short\""))))

Theorem: cst-keyword-conc26-rep-matching

(defthm cst-keyword-conc26-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "%s\"signed\"")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "%s\"signed\""))))

Theorem: cst-keyword-conc27-rep-matching

(defthm cst-keyword-conc27-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "%s\"sizeof\"")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "%s\"sizeof\""))))

Theorem: cst-keyword-conc28-rep-matching

(defthm cst-keyword-conc28-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "%s\"static\"")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "%s\"static\""))))

Theorem: cst-keyword-conc29-rep-matching

(defthm cst-keyword-conc29-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-conc30-rep-matching

(defthm cst-keyword-conc30-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "%s\"switch\"")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "%s\"switch\""))))

Theorem: cst-keyword-conc31-rep-matching

(defthm cst-keyword-conc31-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-keyword-conc32-rep-matching

(defthm cst-keyword-conc32-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "%s\"typedef\"")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "%s\"typedef\""))))

Theorem: cst-keyword-conc33-rep-matching

(defthm cst-keyword-conc33-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "%s\"union\"")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "%s\"union\""))))

Theorem: cst-keyword-conc34-rep-matching

(defthm cst-keyword-conc34-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "%s\"unsigned\"")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "%s\"unsigned\""))))

Theorem: cst-keyword-conc35-rep-matching

(defthm cst-keyword-conc35-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "%s\"void\"")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "%s\"void\""))))

Theorem: cst-keyword-conc36-rep-matching

(defthm cst-keyword-conc36-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "%s\"volatile\"")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "%s\"volatile\""))))

Theorem: cst-keyword-conc37-rep-matching

(defthm cst-keyword-conc37-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "%s\"while\"")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "%s\"while\""))))

Theorem: cst-keyword-conc38-rep-matching

(defthm cst-keyword-conc38-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "%s\"_Alignas\"")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "%s\"_Alignas\""))))

Theorem: cst-keyword-conc39-rep-matching

(defthm cst-keyword-conc39-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "%s\"_Alignof\"")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "%s\"_Alignof\""))))

Theorem: cst-keyword-conc40-rep-matching

(defthm cst-keyword-conc40-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "%s\"_Atomic\"")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "%s\"_Atomic\""))))

Theorem: cst-keyword-conc41-rep-matching

(defthm cst-keyword-conc41-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-conc42-rep-matching

(defthm cst-keyword-conc42-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "%s\"_Complex\"")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "%s\"_Complex\""))))

Theorem: cst-keyword-conc43-rep-matching

(defthm cst-keyword-conc43-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "%s\"_Generic\"")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "%s\"_Generic\""))))

Theorem: cst-keyword-conc44-rep-matching

(defthm cst-keyword-conc44-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "%s\"_Imaginary\"")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "%s\"_Imaginary\""))))

Theorem: cst-keyword-conc45-rep-matching

(defthm cst-keyword-conc45-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "%s\"_Noreturn\"")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "%s\"_Noreturn\""))))

Theorem: cst-keyword-conc46-rep-matching

(defthm cst-keyword-conc46-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "%s\"_Static_assert\"")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "%s\"_Static_assert\""))))

Theorem: cst-keyword-conc47-rep-matching

(defthm cst-keyword-conc47-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "%s\"_Thread_local\"")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "%s\"_Thread_local\""))))

Theorem: cst-gcc-keyword-conc1-rep-matching

(defthm cst-gcc-keyword-conc1-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "%s\"__alignof\"")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "%s\"__alignof\""))))

Theorem: cst-gcc-keyword-conc2-rep-matching

(defthm cst-gcc-keyword-conc2-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "%s\"__alignof__\"")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "%s\"__alignof__\""))))

Theorem: cst-gcc-keyword-conc3-rep-matching

(defthm cst-gcc-keyword-conc3-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "%s\"asm\"")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "%s\"asm\""))))

Theorem: cst-gcc-keyword-conc4-rep-matching

(defthm cst-gcc-keyword-conc4-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "%s\"__asm\"")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "%s\"__asm\""))))

Theorem: cst-gcc-keyword-conc5-rep-matching

(defthm cst-gcc-keyword-conc5-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "%s\"__asm__\"")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "%s\"__asm__\""))))

Theorem: cst-gcc-keyword-conc6-rep-matching

(defthm cst-gcc-keyword-conc6-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "%s\"__attribute\"")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "%s\"__attribute\""))))

Theorem: cst-gcc-keyword-conc7-rep-matching

(defthm cst-gcc-keyword-conc7-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "%s\"__attribute__\"")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "%s\"__attribute__\""))))

Theorem: cst-gcc-keyword-conc8-rep-matching

(defthm cst-gcc-keyword-conc8-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "%s\"__auto_type\"")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "%s\"__auto_type\""))))

Theorem: cst-gcc-keyword-conc9-rep-matching

(defthm cst-gcc-keyword-conc9-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "%s\"__builtin_offsetof\"")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "%s\"__builtin_offsetof\""))))

Theorem: cst-gcc-keyword-conc10-rep-matching

(defthm cst-gcc-keyword-conc10-rep-matching
  (implies (cst-list-rep-matchp abnf::csts
                                "%s\"__builtin_types_compatible_p\"")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "%s\"__builtin_types_compatible_p\""))))

Theorem: cst-gcc-keyword-conc11-rep-matching

(defthm cst-gcc-keyword-conc11-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "%s\"__builtin_va_list\"")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "%s\"__builtin_va_list\""))))

Theorem: cst-gcc-keyword-conc12-rep-matching

(defthm cst-gcc-keyword-conc12-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "%s\"__declspec\"")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "%s\"__declspec\""))))

Theorem: cst-gcc-keyword-conc13-rep-matching

(defthm cst-gcc-keyword-conc13-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "%s\"__extension__\"")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "%s\"__extension__\""))))

Theorem: cst-gcc-keyword-conc14-rep-matching

(defthm cst-gcc-keyword-conc14-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "%s\"__float80\"")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "%s\"__float80\""))))

Theorem: cst-gcc-keyword-conc15-rep-matching

(defthm cst-gcc-keyword-conc15-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "%s\"__float128\"")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "%s\"__float128\""))))

Theorem: cst-gcc-keyword-conc16-rep-matching

(defthm cst-gcc-keyword-conc16-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "%s\"_Float16\"")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "%s\"_Float16\""))))

Theorem: cst-gcc-keyword-conc17-rep-matching

(defthm cst-gcc-keyword-conc17-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "%s\"_Float16x\"")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "%s\"_Float16x\""))))

Theorem: cst-gcc-keyword-conc18-rep-matching

(defthm cst-gcc-keyword-conc18-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "%s\"_Float32\"")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "%s\"_Float32\""))))

Theorem: cst-gcc-keyword-conc19-rep-matching

(defthm cst-gcc-keyword-conc19-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "%s\"_Float32x\"")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "%s\"_Float32x\""))))

Theorem: cst-gcc-keyword-conc20-rep-matching

(defthm cst-gcc-keyword-conc20-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "%s\"_Float64\"")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "%s\"_Float64\""))))

Theorem: cst-gcc-keyword-conc21-rep-matching

(defthm cst-gcc-keyword-conc21-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "%s\"_Float64x\"")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "%s\"_Float64x\""))))

Theorem: cst-gcc-keyword-conc22-rep-matching

(defthm cst-gcc-keyword-conc22-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "%s\"_Float128\"")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "%s\"_Float128\""))))

Theorem: cst-gcc-keyword-conc23-rep-matching

(defthm cst-gcc-keyword-conc23-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "%s\"_Float128x\"")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "%s\"_Float128x\""))))

Theorem: cst-gcc-keyword-conc24-rep-matching

(defthm cst-gcc-keyword-conc24-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "%s\"__imag__\"")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "%s\"__imag__\""))))

Theorem: cst-gcc-keyword-conc25-rep-matching

(defthm cst-gcc-keyword-conc25-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "%s\"__inline\"")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "%s\"__inline\""))))

Theorem: cst-gcc-keyword-conc26-rep-matching

(defthm cst-gcc-keyword-conc26-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "%s\"__inline__\"")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "%s\"__inline__\""))))

Theorem: cst-gcc-keyword-conc27-rep-matching

(defthm cst-gcc-keyword-conc27-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "%s\"__int128\"")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "%s\"__int128\""))))

Theorem: cst-gcc-keyword-conc28-rep-matching

(defthm cst-gcc-keyword-conc28-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "%s\"__int128_t\"")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "%s\"__int128_t\""))))

Theorem: cst-gcc-keyword-conc29-rep-matching

(defthm cst-gcc-keyword-conc29-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "%s\"__label__\"")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "%s\"__label__\""))))

Theorem: cst-gcc-keyword-conc30-rep-matching

(defthm cst-gcc-keyword-conc30-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "%s\"__real__\"")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "%s\"__real__\""))))

Theorem: cst-gcc-keyword-conc31-rep-matching

(defthm cst-gcc-keyword-conc31-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "%s\"__restrict\"")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "%s\"__restrict\""))))

Theorem: cst-gcc-keyword-conc32-rep-matching

(defthm cst-gcc-keyword-conc32-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "%s\"__restrict__\"")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "%s\"__restrict__\""))))

Theorem: cst-gcc-keyword-conc33-rep-matching

(defthm cst-gcc-keyword-conc33-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "%s\"__signed\"")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "%s\"__signed\""))))

Theorem: cst-gcc-keyword-conc34-rep-matching

(defthm cst-gcc-keyword-conc34-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "%s\"__signed__\"")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "%s\"__signed__\""))))

Theorem: cst-gcc-keyword-conc35-rep-matching

(defthm cst-gcc-keyword-conc35-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "%s\"__stdcall\"")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "%s\"__stdcall\""))))

Theorem: cst-gcc-keyword-conc36-rep-matching

(defthm cst-gcc-keyword-conc36-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "%s\"typeof\"")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "%s\"typeof\""))))

Theorem: cst-gcc-keyword-conc37-rep-matching

(defthm cst-gcc-keyword-conc37-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "%s\"__typeof\"")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "%s\"__typeof\""))))

Theorem: cst-gcc-keyword-conc38-rep-matching

(defthm cst-gcc-keyword-conc38-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "%s\"__typeof__\"")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "%s\"__typeof__\""))))

Theorem: cst-gcc-keyword-conc39-rep-matching

(defthm cst-gcc-keyword-conc39-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "%s\"__volatile\"")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "%s\"__volatile\""))))

Theorem: cst-gcc-keyword-conc40-rep-matching

(defthm cst-gcc-keyword-conc40-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "%s\"__volatile__\"")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "%s\"__volatile__\""))))

Theorem: cst-alignof-keyword-conc1-rep-matching

(defthm cst-alignof-keyword-conc1-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "%s\"_Alignof\"")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "%s\"_Alignof\""))))

Theorem: cst-alignof-keyword-conc2-rep-matching

(defthm cst-alignof-keyword-conc2-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "%s\"__alignof\"")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "%s\"__alignof\""))))

Theorem: cst-alignof-keyword-conc3-rep-matching

(defthm cst-alignof-keyword-conc3-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "%s\"__alignof__\"")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "%s\"__alignof__\""))))

Theorem: cst-asm-keyword-conc1-rep-matching

(defthm cst-asm-keyword-conc1-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "%s\"asm\"")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "%s\"asm\""))))

Theorem: cst-asm-keyword-conc2-rep-matching

(defthm cst-asm-keyword-conc2-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "%s\"__asm\"")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "%s\"__asm\""))))

Theorem: cst-asm-keyword-conc3-rep-matching

(defthm cst-asm-keyword-conc3-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "%s\"__asm__\"")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "%s\"__asm__\""))))

Theorem: cst-attribute-keyword-conc1-rep-matching

(defthm cst-attribute-keyword-conc1-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "%s\"__attribute\"")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "%s\"__attribute\""))))

Theorem: cst-attribute-keyword-conc2-rep-matching

(defthm cst-attribute-keyword-conc2-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "%s\"__attribute__\"")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "%s\"__attribute__\""))))

Theorem: cst-inline-keyword-conc1-rep-matching

(defthm cst-inline-keyword-conc1-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "%s\"inline\"")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "%s\"inline\""))))

Theorem: cst-inline-keyword-conc2-rep-matching

(defthm cst-inline-keyword-conc2-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "%s\"__inline\"")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "%s\"__inline\""))))

Theorem: cst-inline-keyword-conc3-rep-matching

(defthm cst-inline-keyword-conc3-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "%s\"__inline__\"")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "%s\"__inline__\""))))

Theorem: cst-restrict-keyword-conc1-rep-matching

(defthm cst-restrict-keyword-conc1-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "%s\"restrict\"")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "%s\"restrict\""))))

Theorem: cst-restrict-keyword-conc2-rep-matching

(defthm cst-restrict-keyword-conc2-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "%s\"__restrict\"")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "%s\"__restrict\""))))

Theorem: cst-restrict-keyword-conc3-rep-matching

(defthm cst-restrict-keyword-conc3-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "%s\"__restrict__\"")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "%s\"__restrict__\""))))

Theorem: cst-signed-keyword-conc1-rep-matching

(defthm cst-signed-keyword-conc1-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "%s\"signed\"")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "%s\"signed\""))))

Theorem: cst-signed-keyword-conc2-rep-matching

(defthm cst-signed-keyword-conc2-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "%s\"__signed\"")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "%s\"__signed\""))))

Theorem: cst-signed-keyword-conc3-rep-matching

(defthm cst-signed-keyword-conc3-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "%s\"__signed__\"")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "%s\"__signed__\""))))

Theorem: cst-typeof-keyword-conc1-rep-matching

(defthm cst-typeof-keyword-conc1-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "%s\"typeof\"")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "%s\"typeof\""))))

Theorem: cst-typeof-keyword-conc2-rep-matching

(defthm cst-typeof-keyword-conc2-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "%s\"__typeof\"")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "%s\"__typeof\""))))

Theorem: cst-typeof-keyword-conc3-rep-matching

(defthm cst-typeof-keyword-conc3-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "%s\"__typeof__\"")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "%s\"__typeof__\""))))

Theorem: cst-volatile-keyword-conc1-rep-matching

(defthm cst-volatile-keyword-conc1-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "%s\"volatile\"")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "%s\"volatile\""))))

Theorem: cst-volatile-keyword-conc2-rep-matching

(defthm cst-volatile-keyword-conc2-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "%s\"__volatile\"")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "%s\"__volatile\""))))

Theorem: cst-volatile-keyword-conc3-rep-matching

(defthm cst-volatile-keyword-conc3-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "%s\"__volatile__\"")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "%s\"__volatile__\""))))

Theorem: cst-identifier-conc1-rep-matching

(defthm cst-identifier-conc1-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "identifier-nondigit")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "identifier-nondigit"))))

Theorem: cst-identifier-nondigit-conc-rep-matching

(defthm cst-identifier-nondigit-conc-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "nondigit")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "nondigit"))))

Theorem: cst-nondigit-conc1-rep-matching

(defthm cst-nondigit-conc1-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "\"_\"")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts) "\"_\""))))

Theorem: cst-nondigit-conc2-rep-matching

(defthm cst-nondigit-conc2-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "letter")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "letter"))))

Theorem: cst-constant-conc1-rep-matching

(defthm cst-constant-conc1-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "integer-constant")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "integer-constant"))))

Theorem: cst-constant-conc2-rep-matching

(defthm cst-constant-conc2-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "floating-constant")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "floating-constant"))))

Theorem: cst-constant-conc3-rep-matching

(defthm cst-constant-conc3-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "enumeration-constant")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "enumeration-constant"))))

Theorem: cst-constant-conc4-rep-matching

(defthm cst-constant-conc4-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "character-constant")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "character-constant"))))

Theorem: cst-decimal-constant-conc1-rep-matching

(defthm cst-decimal-constant-conc1-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "nonzero-digit")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "nonzero-digit"))))

Theorem: cst-octal-constant-conc1-rep-matching

(defthm cst-octal-constant-conc1-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "\"0\"")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts) "\"0\""))))

Theorem: cst-hexadecimal-prefix-conc-rep-matching

(defthm cst-hexadecimal-prefix-conc-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "%i\"0x\"")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "%i\"0x\""))))

Theorem: cst-nonzero-digit-conc-rep-matching

(defthm cst-nonzero-digit-conc-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "%x31-39")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "%x31-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 "%x30-39")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "%x30-39"))))

Theorem: cst-hexadecimal-digit-conc2-rep-matching

(defthm cst-hexadecimal-digit-conc2-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "%x61-66")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "%x61-66"))))

Theorem: cst-hexadecimal-digit-conc3-rep-matching

(defthm cst-hexadecimal-digit-conc3-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "%x41-46")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "%x41-46"))))

Theorem: cst-unsigned-suffix-conc-rep-matching

(defthm cst-unsigned-suffix-conc-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "%i\"u\"")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "%i\"u\""))))

Theorem: cst-long-suffix-conc-rep-matching

(defthm cst-long-suffix-conc-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "%i\"l\"")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "%i\"l\""))))

Theorem: cst-long-long-suffix-conc1-rep-matching

(defthm cst-long-long-suffix-conc1-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "%s\"ll\"")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "%s\"ll\""))))

Theorem: cst-long-long-suffix-conc2-rep-matching

(defthm cst-long-long-suffix-conc2-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "%s\"LL\"")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "%s\"LL\""))))

Theorem: cst-floating-constant-conc1-rep-matching

(defthm cst-floating-constant-conc1-rep-matching
  (implies
       (cst-list-rep-matchp abnf::csts "decimal-floating-constant")
       (and (equal (len abnf::csts) 1)
            (cst-matchp (nth 0 abnf::csts)
                        "decimal-floating-constant"))))

Theorem: cst-floating-constant-conc2-rep-matching

(defthm cst-floating-constant-conc2-rep-matching
  (implies (cst-list-rep-matchp abnf::csts
                                "hexadecimal-floating-constant")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "hexadecimal-floating-constant"))))

Theorem: cst-sign-conc1-rep-matching

(defthm cst-sign-conc1-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "\"+\"")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts) "\"+\""))))

Theorem: cst-sign-conc2-rep-matching

(defthm cst-sign-conc2-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "\"-\"")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts) "\"-\""))))

Theorem: cst-digit-sequence-conc1-rep-matching

(defthm cst-digit-sequence-conc1-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "digit")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "digit"))))

Theorem: cst-hexadecimal-digit-sequence-conc1-rep-matching

(defthm cst-hexadecimal-digit-sequence-conc1-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "hexadecimal-digit")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "hexadecimal-digit"))))

Theorem: cst-floating-suffix-conc1-rep-matching

(defthm cst-floating-suffix-conc1-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "%i\"f\"")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "%i\"f\""))))

Theorem: cst-floating-suffix-conc2-rep-matching

(defthm cst-floating-suffix-conc2-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "%i\"l\"")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "%i\"l\""))))

Theorem: cst-enumeration-constant-conc-rep-matching

(defthm cst-enumeration-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-c-char-sequence-conc1-rep-matching

(defthm cst-c-char-sequence-conc1-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "c-char")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "c-char"))))

Theorem: cst-c-char-conc1-rep-matching

(defthm cst-c-char-conc1-rep-matching
 (implies
  (cst-list-rep-matchp
       abnf::csts
       "character-not-single-quote-or-backslash-or-new-line")
  (and
      (equal (len abnf::csts) 1)
      (cst-matchp
           (nth 0 abnf::csts)
           "character-not-single-quote-or-backslash-or-new-line"))))

Theorem: cst-c-char-conc2-rep-matching

(defthm cst-c-char-conc2-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "escape-sequence")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "escape-sequence"))))

Theorem: cst-escape-sequence-conc1-rep-matching

(defthm cst-escape-sequence-conc1-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "simple-escape-sequence")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "simple-escape-sequence"))))

Theorem: cst-escape-sequence-conc2-rep-matching

(defthm cst-escape-sequence-conc2-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "octal-escape-sequence")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "octal-escape-sequence"))))

Theorem: cst-escape-sequence-conc3-rep-matching

(defthm cst-escape-sequence-conc3-rep-matching
  (implies (cst-list-rep-matchp abnf::csts
                                "hexadecimal-escape-sequence")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "hexadecimal-escape-sequence"))))

Theorem: cst-escape-sequence-conc4-rep-matching

(defthm cst-escape-sequence-conc4-rep-matching
  (implies
       (cst-list-rep-matchp abnf::csts "universal-character-name")
       (and (equal (len abnf::csts) 1)
            (cst-matchp (nth 0 abnf::csts)
                        "universal-character-name"))))

Theorem: cst-simple-escape-sequence-conc1-rep-matching

(defthm cst-simple-escape-sequence-conc1-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "\"\\'\"")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "\"\\'\""))))

Theorem: cst-simple-escape-sequence-conc3-rep-matching

(defthm cst-simple-escape-sequence-conc3-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "\"\\?\"")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "\"\\?\""))))

Theorem: cst-simple-escape-sequence-conc4-rep-matching

(defthm cst-simple-escape-sequence-conc4-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "\"\\\\\"")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "\"\\\\\""))))

Theorem: cst-simple-escape-sequence-conc5-rep-matching

(defthm cst-simple-escape-sequence-conc5-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "%s\"\\a\"")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "%s\"\\a\""))))

Theorem: cst-simple-escape-sequence-conc6-rep-matching

(defthm cst-simple-escape-sequence-conc6-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "%s\"\\b\"")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "%s\"\\b\""))))

Theorem: cst-simple-escape-sequence-conc7-rep-matching

(defthm cst-simple-escape-sequence-conc7-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "%s\"\\f\"")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "%s\"\\f\""))))

Theorem: cst-simple-escape-sequence-conc8-rep-matching

(defthm cst-simple-escape-sequence-conc8-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-simple-escape-sequence-conc9-rep-matching

(defthm cst-simple-escape-sequence-conc9-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-simple-escape-sequence-conc10-rep-matching

(defthm cst-simple-escape-sequence-conc10-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-simple-escape-sequence-conc11-rep-matching

(defthm cst-simple-escape-sequence-conc11-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "%s\"\\v\"")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "%s\"\\v\""))))

Theorem: cst-simple-escape-sequence-conc12-rep-matching

(defthm cst-simple-escape-sequence-conc12-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "\"\\%\"")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "\"\\%\""))))

Theorem: cst-encoding-prefix-conc1-rep-matching

(defthm cst-encoding-prefix-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-encoding-prefix-conc2-rep-matching

(defthm cst-encoding-prefix-conc2-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "%i\"u\"")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "%i\"u\""))))

Theorem: cst-encoding-prefix-conc3-rep-matching

(defthm cst-encoding-prefix-conc3-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "%s\"L\"")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "%s\"L\""))))

Theorem: cst-s-char-sequence-conc1-rep-matching

(defthm cst-s-char-sequence-conc1-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "s-char")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "s-char"))))

Theorem: cst-s-char-conc1-rep-matching

(defthm cst-s-char-conc1-rep-matching
 (implies
  (cst-list-rep-matchp
       abnf::csts
       "character-not-double-quote-or-backslash-or-new-line")
  (and
      (equal (len abnf::csts) 1)
      (cst-matchp
           (nth 0 abnf::csts)
           "character-not-double-quote-or-backslash-or-new-line"))))

Theorem: cst-s-char-conc2-rep-matching

(defthm cst-s-char-conc2-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "escape-sequence")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "escape-sequence"))))

Theorem: cst-punctuator-conc1-rep-matching

(defthm cst-punctuator-conc1-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "\"[\"")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts) "\"[\""))))

Theorem: cst-punctuator-conc2-rep-matching

(defthm cst-punctuator-conc2-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "\"]\"")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts) "\"]\""))))

Theorem: cst-punctuator-conc3-rep-matching

(defthm cst-punctuator-conc3-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "\"(\"")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts) "\"(\""))))

Theorem: cst-punctuator-conc4-rep-matching

(defthm cst-punctuator-conc4-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "\")\"")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts) "\")\""))))

Theorem: cst-punctuator-conc5-rep-matching

(defthm cst-punctuator-conc5-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "\"{\"")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts) "\"{\""))))

Theorem: cst-punctuator-conc6-rep-matching

(defthm cst-punctuator-conc6-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "\"}\"")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts) "\"}\""))))

Theorem: cst-punctuator-conc7-rep-matching

(defthm cst-punctuator-conc7-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "\".\"")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts) "\".\""))))

Theorem: cst-punctuator-conc8-rep-matching

(defthm cst-punctuator-conc8-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "\"->\"")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "\"->\""))))

Theorem: cst-punctuator-conc9-rep-matching

(defthm cst-punctuator-conc9-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "\"++\"")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "\"++\""))))

Theorem: cst-punctuator-conc10-rep-matching

(defthm cst-punctuator-conc10-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "\"--\"")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "\"--\""))))

Theorem: cst-punctuator-conc11-rep-matching

(defthm cst-punctuator-conc11-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "\"&\"")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts) "\"&\""))))

Theorem: cst-punctuator-conc12-rep-matching

(defthm cst-punctuator-conc12-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "\"*\"")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts) "\"*\""))))

Theorem: cst-punctuator-conc13-rep-matching

(defthm cst-punctuator-conc13-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "\"+\"")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts) "\"+\""))))

Theorem: cst-punctuator-conc14-rep-matching

(defthm cst-punctuator-conc14-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "\"-\"")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts) "\"-\""))))

Theorem: cst-punctuator-conc15-rep-matching

(defthm cst-punctuator-conc15-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "\"~\"")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts) "\"~\""))))

Theorem: cst-punctuator-conc16-rep-matching

(defthm cst-punctuator-conc16-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "\"!\"")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts) "\"!\""))))

Theorem: cst-punctuator-conc17-rep-matching

(defthm cst-punctuator-conc17-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "\"/\"")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts) "\"/\""))))

Theorem: cst-punctuator-conc18-rep-matching

(defthm cst-punctuator-conc18-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "\"%\"")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts) "\"%\""))))

Theorem: cst-punctuator-conc19-rep-matching

(defthm cst-punctuator-conc19-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "\"<<\"")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "\"<<\""))))

Theorem: cst-punctuator-conc20-rep-matching

(defthm cst-punctuator-conc20-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "\">>\"")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "\">>\""))))

Theorem: cst-punctuator-conc21-rep-matching

(defthm cst-punctuator-conc21-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "\"<\"")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts) "\"<\""))))

Theorem: cst-punctuator-conc22-rep-matching

(defthm cst-punctuator-conc22-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "\">\"")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts) "\">\""))))

Theorem: cst-punctuator-conc23-rep-matching

(defthm cst-punctuator-conc23-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "\"<=\"")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "\"<=\""))))

Theorem: cst-punctuator-conc24-rep-matching

(defthm cst-punctuator-conc24-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "\">=\"")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "\">=\""))))

Theorem: cst-punctuator-conc25-rep-matching

(defthm cst-punctuator-conc25-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "\"==\"")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "\"==\""))))

Theorem: cst-punctuator-conc26-rep-matching

(defthm cst-punctuator-conc26-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "\"!=\"")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "\"!=\""))))

Theorem: cst-punctuator-conc27-rep-matching

(defthm cst-punctuator-conc27-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "\"^\"")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts) "\"^\""))))

Theorem: cst-punctuator-conc28-rep-matching

(defthm cst-punctuator-conc28-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "\"|\"")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts) "\"|\""))))

Theorem: cst-punctuator-conc29-rep-matching

(defthm cst-punctuator-conc29-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "\"&&\"")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "\"&&\""))))

Theorem: cst-punctuator-conc30-rep-matching

(defthm cst-punctuator-conc30-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "\"||\"")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "\"||\""))))

Theorem: cst-punctuator-conc31-rep-matching

(defthm cst-punctuator-conc31-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "\"?\"")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts) "\"?\""))))

Theorem: cst-punctuator-conc32-rep-matching

(defthm cst-punctuator-conc32-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "\":\"")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts) "\":\""))))

Theorem: cst-punctuator-conc33-rep-matching

(defthm cst-punctuator-conc33-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "\";\"")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts) "\";\""))))

Theorem: cst-punctuator-conc34-rep-matching

(defthm cst-punctuator-conc34-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "\"...\"")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "\"...\""))))

Theorem: cst-punctuator-conc35-rep-matching

(defthm cst-punctuator-conc35-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "\"=\"")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts) "\"=\""))))

Theorem: cst-punctuator-conc36-rep-matching

(defthm cst-punctuator-conc36-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "\"*=\"")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "\"*=\""))))

Theorem: cst-punctuator-conc37-rep-matching

(defthm cst-punctuator-conc37-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "\"/=\"")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "\"/=\""))))

Theorem: cst-punctuator-conc38-rep-matching

(defthm cst-punctuator-conc38-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "\"%=\"")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "\"%=\""))))

Theorem: cst-punctuator-conc39-rep-matching

(defthm cst-punctuator-conc39-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "\"+=\"")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "\"+=\""))))

Theorem: cst-punctuator-conc40-rep-matching

(defthm cst-punctuator-conc40-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "\"-=\"")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "\"-=\""))))

Theorem: cst-punctuator-conc41-rep-matching

(defthm cst-punctuator-conc41-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "\"<<=\"")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "\"<<=\""))))

Theorem: cst-punctuator-conc42-rep-matching

(defthm cst-punctuator-conc42-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "\">>=\"")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "\">>=\""))))

Theorem: cst-punctuator-conc43-rep-matching

(defthm cst-punctuator-conc43-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "\"&=\"")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "\"&=\""))))

Theorem: cst-punctuator-conc44-rep-matching

(defthm cst-punctuator-conc44-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "\"^=\"")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "\"^=\""))))

Theorem: cst-punctuator-conc45-rep-matching

(defthm cst-punctuator-conc45-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "\"|=\"")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "\"|=\""))))

Theorem: cst-punctuator-conc46-rep-matching

(defthm cst-punctuator-conc46-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "\",\"")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts) "\",\""))))

Theorem: cst-punctuator-conc47-rep-matching

(defthm cst-punctuator-conc47-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "\"#\"")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts) "\"#\""))))

Theorem: cst-punctuator-conc48-rep-matching

(defthm cst-punctuator-conc48-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "\"##\"")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "\"##\""))))

Theorem: cst-punctuator-conc49-rep-matching

(defthm cst-punctuator-conc49-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "\"<:\"")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "\"<:\""))))

Theorem: cst-punctuator-conc50-rep-matching

(defthm cst-punctuator-conc50-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "\":>\"")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "\":>\""))))

Theorem: cst-punctuator-conc51-rep-matching

(defthm cst-punctuator-conc51-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "\"<%\"")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "\"<%\""))))

Theorem: cst-punctuator-conc52-rep-matching

(defthm cst-punctuator-conc52-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "\"%>\"")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "\"%>\""))))

Theorem: cst-punctuator-conc53-rep-matching

(defthm cst-punctuator-conc53-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "\"%:\"")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "\"%:\""))))

Theorem: cst-punctuator-conc54-rep-matching

(defthm cst-punctuator-conc54-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "\"%:%:\"")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "\"%:%:\""))))

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 "control-line")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "control-line"))))

Theorem: cst-lexeme-conc4-rep-matching

(defthm cst-lexeme-conc4-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "white-space")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "white-space"))))

Theorem: cst-primary-expression-conc1-rep-matching

(defthm cst-primary-expression-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-primary-expression-conc2-rep-matching

(defthm cst-primary-expression-conc2-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "constant")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "constant"))))

Theorem: cst-primary-expression-conc5-rep-matching

(defthm cst-primary-expression-conc5-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "generic-selection")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "generic-selection"))))

Theorem: cst-primary-expression-conc7-rep-matching

(defthm cst-primary-expression-conc7-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "types-compatible-call")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "types-compatible-call"))))

Theorem: cst-primary-expression-conc8-rep-matching

(defthm cst-primary-expression-conc8-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "offsetof-call")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "offsetof-call"))))

Theorem: cst-primary-expression-conc9-rep-matching

(defthm cst-primary-expression-conc9-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "va-arg-call")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "va-arg-call"))))

Theorem: cst-primary-expression-conc11-rep-matching

(defthm cst-primary-expression-conc11-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-primary-expression-conc12-rep-matching

(defthm cst-primary-expression-conc12-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-offsetof-member-designator-conc1-rep-matching

(defthm cst-offsetof-member-designator-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-generic-assoc-list-conc1-rep-matching

(defthm cst-generic-assoc-list-conc1-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "generic-association")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "generic-association"))))

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-argument-expression-list-conc1-rep-matching

(defthm cst-argument-expression-list-conc1-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "assignment-expression")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "assignment-expression"))))

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-unary-operator-conc1-rep-matching

(defthm cst-unary-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-unary-operator-conc2-rep-matching

(defthm cst-unary-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-unary-operator-conc3-rep-matching

(defthm cst-unary-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-unary-operator-conc4-rep-matching

(defthm cst-unary-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-unary-operator-conc5-rep-matching

(defthm cst-unary-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-unary-operator-conc6-rep-matching

(defthm cst-unary-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-cast-expression-conc1-rep-matching

(defthm cst-cast-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 "cast-expression")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "cast-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-relational-expression-conc1-rep-matching

(defthm cst-relational-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-equality-expression-conc1-rep-matching

(defthm cst-equality-expression-conc1-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "relational-expression")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "relational-expression"))))

Theorem: cst-and-expression-conc1-rep-matching

(defthm cst-and-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-exclusive-or-expression-conc1-rep-matching

(defthm cst-exclusive-or-expression-conc1-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "and-expression")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "and-expression"))))

Theorem: cst-inclusive-or-expression-conc1-rep-matching

(defthm cst-inclusive-or-expression-conc1-rep-matching
 (implies (cst-list-rep-matchp abnf::csts "exclusive-or-expression")
          (and (equal (len abnf::csts) 1)
               (cst-matchp (nth 0 abnf::csts)
                           "exclusive-or-expression"))))

Theorem: cst-logical-and-expression-conc1-rep-matching

(defthm cst-logical-and-expression-conc1-rep-matching
 (implies (cst-list-rep-matchp abnf::csts "inclusive-or-expression")
          (and (equal (len abnf::csts) 1)
               (cst-matchp (nth 0 abnf::csts)
                           "inclusive-or-expression"))))

Theorem: cst-logical-or-expression-conc1-rep-matching

(defthm cst-logical-or-expression-conc1-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "logical-and-expression")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "logical-and-expression"))))

Theorem: cst-conditional-expression-conc1-rep-matching

(defthm cst-conditional-expression-conc1-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "logical-or-expression")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "logical-or-expression"))))

Theorem: cst-assignment-expression-conc1-rep-matching

(defthm cst-assignment-expression-conc1-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "conditional-expression")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "conditional-expression"))))

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-expression-conc1-rep-matching

(defthm cst-expression-conc1-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "assignment-expression")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "assignment-expression"))))

Theorem: cst-constant-expression-conc-rep-matching

(defthm cst-constant-expression-conc-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "conditional-expression")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "conditional-expression"))))

Theorem: cst-attribute-name-conc1-rep-matching

(defthm cst-attribute-name-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-attribute-name-conc2-rep-matching

(defthm cst-attribute-name-conc2-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-asm-qualifier-conc1-rep-matching

(defthm cst-asm-qualifier-conc1-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "volatile-keyword")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "volatile-keyword"))))

Theorem: cst-asm-qualifier-conc2-rep-matching

(defthm cst-asm-qualifier-conc2-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "inline-keyword")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "inline-keyword"))))

Theorem: cst-asm-qualifier-conc3-rep-matching

(defthm cst-asm-qualifier-conc3-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "%s\"goto\"")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "%s\"goto\""))))

Theorem: cst-asm-output-operands-conc-rep-matching

(defthm cst-asm-output-operands-conc-rep-matching
 (implies
  (cst-list-rep-matchp
       abnf::csts
       "[ asm-output-operand *( \",\" asm-output-operand ) ]")
  (and (equal (len abnf::csts) 1)
       (cst-matchp
            (nth 0 abnf::csts)
            "[ asm-output-operand *( \",\" asm-output-operand ) ]"))))

Theorem: cst-asm-input-operands-conc-rep-matching

(defthm cst-asm-input-operands-conc-rep-matching
 (implies
    (cst-list-rep-matchp
         abnf::csts
         "[ asm-input-operand *( \",\" asm-input-operand ) ]")
    (and (equal (len abnf::csts) 1)
         (cst-matchp
              (nth 0 abnf::csts)
              "[ asm-input-operand *( \",\" asm-input-operand ) ]"))))

Theorem: cst-asm-clobbers-conc-rep-matching

(defthm cst-asm-clobbers-conc-rep-matching
  (implies
       (cst-list-rep-matchp abnf::csts
                            "[ asm-clobber *( \",\" asm-clobber ) ]")
       (and (equal (len abnf::csts) 1)
            (cst-matchp (nth 0 abnf::csts)
                        "[ asm-clobber *( \",\" asm-clobber ) ]"))))

Theorem: cst-asm-goto-labels-conc-rep-matching

(defthm cst-asm-goto-labels-conc-rep-matching
 (implies (cst-list-rep-matchp abnf::csts
                               "[ identifier *( \",\" identifier ) ]")
          (and (equal (len abnf::csts) 1)
               (cst-matchp (nth 0 abnf::csts)
                           "[ identifier *( \",\" identifier ) ]"))))

Theorem: cst-declaration-conc2-rep-matching

(defthm cst-declaration-conc2-rep-matching
  (implies
       (cst-list-rep-matchp abnf::csts "static-assert-declaration")
       (and (equal (len abnf::csts) 1)
            (cst-matchp (nth 0 abnf::csts)
                        "static-assert-declaration"))))

Theorem: cst-init-declarator-list-conc1-rep-matching

(defthm cst-init-declarator-list-conc1-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "init-declarator")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "init-declarator"))))

Theorem: cst-storage-class-specifier-conc1-rep-matching

(defthm cst-storage-class-specifier-conc1-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "%s\"typedef\"")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "%s\"typedef\""))))

Theorem: cst-storage-class-specifier-conc2-rep-matching

(defthm cst-storage-class-specifier-conc2-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "%s\"extern\"")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "%s\"extern\""))))

Theorem: cst-storage-class-specifier-conc3-rep-matching

(defthm cst-storage-class-specifier-conc3-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "%s\"static\"")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "%s\"static\""))))

Theorem: cst-storage-class-specifier-conc4-rep-matching

(defthm cst-storage-class-specifier-conc4-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "%s\"_Thread_local\"")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "%s\"_Thread_local\""))))

Theorem: cst-storage-class-specifier-conc5-rep-matching

(defthm cst-storage-class-specifier-conc5-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "%s\"auto\"")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "%s\"auto\""))))

Theorem: cst-storage-class-specifier-conc6-rep-matching

(defthm cst-storage-class-specifier-conc6-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "%s\"register\"")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "%s\"register\""))))

Theorem: cst-type-specifier-conc1-rep-matching

(defthm cst-type-specifier-conc1-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "%s\"void\"")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "%s\"void\""))))

Theorem: cst-type-specifier-conc2-rep-matching

(defthm cst-type-specifier-conc2-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "%s\"char\"")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "%s\"char\""))))

Theorem: cst-type-specifier-conc3-rep-matching

(defthm cst-type-specifier-conc3-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "%s\"short\"")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "%s\"short\""))))

Theorem: cst-type-specifier-conc4-rep-matching

(defthm cst-type-specifier-conc4-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "%s\"int\"")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "%s\"int\""))))

Theorem: cst-type-specifier-conc5-rep-matching

(defthm cst-type-specifier-conc5-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "%s\"long\"")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "%s\"long\""))))

Theorem: cst-type-specifier-conc6-rep-matching

(defthm cst-type-specifier-conc6-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "%s\"float\"")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "%s\"float\""))))

Theorem: cst-type-specifier-conc7-rep-matching

(defthm cst-type-specifier-conc7-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "%s\"double\"")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "%s\"double\""))))

Theorem: cst-type-specifier-conc8-rep-matching

(defthm cst-type-specifier-conc8-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "signed-keyword")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "signed-keyword"))))

Theorem: cst-type-specifier-conc9-rep-matching

(defthm cst-type-specifier-conc9-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "%s\"unsigned\"")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "%s\"unsigned\""))))

Theorem: cst-type-specifier-conc10-rep-matching

(defthm cst-type-specifier-conc10-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-type-specifier-conc11-rep-matching

(defthm cst-type-specifier-conc11-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-type-specifier-conc12-rep-matching

(defthm cst-type-specifier-conc12-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "%s\"_Complex\"")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "%s\"_Complex\""))))

Theorem: cst-type-specifier-conc13-rep-matching

(defthm cst-type-specifier-conc13-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "atomic-type-specifier")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "atomic-type-specifier"))))

Theorem: cst-type-specifier-conc14-rep-matching

(defthm cst-type-specifier-conc14-rep-matching
  (implies
       (cst-list-rep-matchp abnf::csts "struct-or-union-specifier")
       (and (equal (len abnf::csts) 1)
            (cst-matchp (nth 0 abnf::csts)
                        "struct-or-union-specifier"))))

Theorem: cst-type-specifier-conc15-rep-matching

(defthm cst-type-specifier-conc15-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "enum-specifier")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "enum-specifier"))))

Theorem: cst-type-specifier-conc16-rep-matching

(defthm cst-type-specifier-conc16-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "typedef-name")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "typedef-name"))))

Theorem: cst-type-specifier-conc17-rep-matching

(defthm cst-type-specifier-conc17-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "%s\"__int128\"")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "%s\"__int128\""))))

Theorem: cst-type-specifier-conc18-rep-matching

(defthm cst-type-specifier-conc18-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "%s\"__float80\"")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "%s\"__float80\""))))

Theorem: cst-type-specifier-conc19-rep-matching

(defthm cst-type-specifier-conc19-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "%s\"__float128\"")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "%s\"__float128\""))))

Theorem: cst-type-specifier-conc20-rep-matching

(defthm cst-type-specifier-conc20-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "%s\"_Float16\"")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "%s\"_Float16\""))))

Theorem: cst-type-specifier-conc21-rep-matching

(defthm cst-type-specifier-conc21-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "%s\"_Float16x\"")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "%s\"_Float16x\""))))

Theorem: cst-type-specifier-conc22-rep-matching

(defthm cst-type-specifier-conc22-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "%s\"_Float32\"")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "%s\"_Float32\""))))

Theorem: cst-type-specifier-conc23-rep-matching

(defthm cst-type-specifier-conc23-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "%s\"_Float32x\"")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "%s\"_Float32x\""))))

Theorem: cst-type-specifier-conc24-rep-matching

(defthm cst-type-specifier-conc24-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "%s\"_Float64\"")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "%s\"_Float64\""))))

Theorem: cst-type-specifier-conc25-rep-matching

(defthm cst-type-specifier-conc25-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "%s\"_Float64x\"")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "%s\"_Float64x\""))))

Theorem: cst-type-specifier-conc26-rep-matching

(defthm cst-type-specifier-conc26-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "%s\"_Float128\"")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "%s\"_Float128\""))))

Theorem: cst-type-specifier-conc27-rep-matching

(defthm cst-type-specifier-conc27-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "%s\"_Float128x\"")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "%s\"_Float128x\""))))

Theorem: cst-type-specifier-conc28-rep-matching

(defthm cst-type-specifier-conc28-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "%s\"__builtin_va_list\"")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "%s\"__builtin_va_list\""))))

Theorem: cst-type-specifier-conc31-rep-matching

(defthm cst-type-specifier-conc31-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "%s\"__auto_type\"")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "%s\"__auto_type\""))))

Theorem: cst-struct-or-union-conc1-rep-matching

(defthm cst-struct-or-union-conc1-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-struct-or-union-conc2-rep-matching

(defthm cst-struct-or-union-conc2-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "%s\"union\"")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "%s\"union\""))))

Theorem: cst-struct-declaration-list-conc1-rep-matching

(defthm cst-struct-declaration-list-conc1-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-struct-declaration-conc2-rep-matching

(defthm cst-struct-declaration-conc2-rep-matching
  (implies
       (cst-list-rep-matchp abnf::csts "static-assert-declaration")
       (and (equal (len abnf::csts) 1)
            (cst-matchp (nth 0 abnf::csts)
                        "static-assert-declaration"))))

Theorem: cst-struct-declaration-conc3-rep-matching

(defthm cst-struct-declaration-conc3-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "\";\"")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts) "\";\""))))

Theorem: cst-struct-declarator-list-conc1-rep-matching

(defthm cst-struct-declarator-list-conc1-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "struct-declarator")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "struct-declarator"))))

Theorem: cst-struct-declarator-conc1-rep-matching

(defthm cst-struct-declarator-conc1-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "declarator")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "declarator"))))

Theorem: cst-enumerator-list-conc1-rep-matching

(defthm cst-enumerator-list-conc1-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "enumerator")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "enumerator"))))

Theorem: cst-enumerator-conc1-rep-matching

(defthm cst-enumerator-conc1-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "enumeration-constant")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "enumeration-constant"))))

Theorem: cst-type-qualifier-conc1-rep-matching

(defthm cst-type-qualifier-conc1-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-type-qualifier-conc2-rep-matching

(defthm cst-type-qualifier-conc2-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "restrict-keyword")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "restrict-keyword"))))

Theorem: cst-type-qualifier-conc3-rep-matching

(defthm cst-type-qualifier-conc3-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "volatile-keyword")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "volatile-keyword"))))

Theorem: cst-type-qualifier-conc4-rep-matching

(defthm cst-type-qualifier-conc4-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "%s\"_Atomic\"")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "%s\"_Atomic\""))))

Theorem: cst-type-qualifier-conc5-rep-matching

(defthm cst-type-qualifier-conc5-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "%s\"__seg_fs\"")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "%s\"__seg_fs\""))))

Theorem: cst-type-qualifier-conc6-rep-matching

(defthm cst-type-qualifier-conc6-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "%s\"__seg_gs\"")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "%s\"__seg_gs\""))))

Theorem: cst-function-specifier-conc1-rep-matching

(defthm cst-function-specifier-conc1-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "inline-keyword")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "inline-keyword"))))

Theorem: cst-function-specifier-conc2-rep-matching

(defthm cst-function-specifier-conc2-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "%s\"_Noreturn\"")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "%s\"_Noreturn\""))))

Theorem: cst-direct-declarator-conc1-rep-matching

(defthm cst-direct-declarator-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-type-qualifier-or-attribute-specifier-conc1-rep-matching

(defthm cst-type-qualifier-or-attribute-specifier-conc1-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "type-qualifier")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "type-qualifier"))))

Theorem: cst-type-qualifier-or-attribute-specifier-conc2-rep-matching

(defthm cst-type-qualifier-or-attribute-specifier-conc2-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "attribute-specifier")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "attribute-specifier"))))

Theorem: cst-type-qualifier-and-attribute-specifier-list-conc1-rep-matching

(defthm
 cst-type-qualifier-and-attribute-specifier-list-conc1-rep-matching
 (implies
      (cst-list-rep-matchp abnf::csts
                           "type-qualifier-or-attribute-specifier")
      (and (equal (len abnf::csts) 1)
           (cst-matchp (nth 0 abnf::csts)
                       "type-qualifier-or-attribute-specifier"))))

Theorem: cst-parameter-type-list-conc1-rep-matching

(defthm cst-parameter-type-list-conc1-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "parameter-list")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "parameter-list"))))

Theorem: cst-parameter-list-conc1-rep-matching

(defthm cst-parameter-list-conc1-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "parameter-declaration")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "parameter-declaration"))))

Theorem: cst-identifier-list-conc1-rep-matching

(defthm cst-identifier-list-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-abstract-declarator-conc1-rep-matching

(defthm cst-abstract-declarator-conc1-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "pointer")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "pointer"))))

Theorem: cst-typedef-name-conc-rep-matching

(defthm cst-typedef-name-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-initializer-conc1-rep-matching

(defthm cst-initializer-conc1-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "assignment-expression")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "assignment-expression"))))

Theorem: cst-designator-list-conc1-rep-matching

(defthm cst-designator-list-conc1-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "designator")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "designator"))))

Theorem: cst-statement-conc1-rep-matching

(defthm cst-statement-conc1-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "labeled-statement")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "labeled-statement"))))

Theorem: cst-statement-conc2-rep-matching

(defthm cst-statement-conc2-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "compound-statement")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "compound-statement"))))

Theorem: cst-statement-conc3-rep-matching

(defthm cst-statement-conc3-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "expression-statement")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "expression-statement"))))

Theorem: cst-statement-conc4-rep-matching

(defthm cst-statement-conc4-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "selection-statement")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "selection-statement"))))

Theorem: cst-statement-conc5-rep-matching

(defthm cst-statement-conc5-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "iteration-statement")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "iteration-statement"))))

Theorem: cst-statement-conc6-rep-matching

(defthm cst-statement-conc6-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "jump-statement")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "jump-statement"))))

Theorem: cst-statement-conc7-rep-matching

(defthm cst-statement-conc7-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "asm-statement")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "asm-statement"))))

Theorem: cst-block-item-list-conc1-rep-matching

(defthm cst-block-item-list-conc1-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "block-item")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "block-item"))))

Theorem: cst-block-item-conc1-rep-matching

(defthm cst-block-item-conc1-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "declaration")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "declaration"))))

Theorem: cst-block-item-conc2-rep-matching

(defthm cst-block-item-conc2-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "statement")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "statement"))))

Theorem: cst-external-declaration-conc1-rep-matching

(defthm cst-external-declaration-conc1-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "function-definition")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "function-definition"))))

Theorem: cst-external-declaration-conc2-rep-matching

(defthm cst-external-declaration-conc2-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "declaration")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "declaration"))))

Theorem: cst-external-declaration-conc3-rep-matching

(defthm cst-external-declaration-conc3-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "\";\"")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts) "\";\""))))

Theorem: cst-external-declaration-conc4-rep-matching

(defthm cst-external-declaration-conc4-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "asm-statement")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "asm-statement"))))

Theorem: cst-declaration-list-conc1-rep-matching

(defthm cst-declaration-list-conc1-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "declaration")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "declaration"))))

Theorem: cst-preprocessing-file-conc-rep-matching

(defthm cst-preprocessing-file-conc-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "[ group ]")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "[ group ]"))))

Theorem: cst-group-conc1-rep-matching

(defthm cst-group-conc1-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "group-part")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "group-part"))))

Theorem: cst-group-part-conc1-rep-matching

(defthm cst-group-part-conc1-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "if-section")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "if-section"))))

Theorem: cst-group-part-conc2-rep-matching

(defthm cst-group-part-conc2-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "control-line")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "control-line"))))

Theorem: cst-group-part-conc3-rep-matching

(defthm cst-group-part-conc3-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "text-line")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "text-line"))))

Theorem: cst-elif-groups-conc1-rep-matching

(defthm cst-elif-groups-conc1-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "elif-group")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "elif-group"))))

Theorem: cst-lparen-conc-rep-matching

(defthm cst-lparen-conc-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "\"(\"")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts) "\"(\""))))

Theorem: cst-replacement-list-conc-rep-matching

(defthm cst-replacement-list-conc-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "[ pp-tokens ]")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "[ pp-tokens ]"))))

Theorem: cst-pp-tokens-conc1-rep-matching

(defthm cst-pp-tokens-conc1-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "preprocessing-token")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "preprocessing-token"))))

Theorem: cst-on-off-switch-conc1-rep-matching

(defthm cst-on-off-switch-conc1-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "%s\"ON\"")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "%s\"ON\""))))

Theorem: cst-on-off-switch-conc2-rep-matching

(defthm cst-on-off-switch-conc2-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "%s\"OFF\"")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "%s\"OFF\""))))

Theorem: cst-on-off-switch-conc3-rep-matching

(defthm cst-on-off-switch-conc3-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "%s\"DEFAULT\"")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "%s\"DEFAULT\""))))

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-control-character-conc-equivs

(defthm cst-control-character-conc-equivs
 (implies
  (cst-matchp abnf::cst "control-character")
  (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)
          "vertical-tab")
     (equal
          (abnf::tree-nonleaf->rulename?
               (nth 0
                    (nth 0
                         (abnf::tree-nonleaf->branches abnf::cst))))
          (abnf::rulename "vertical-tab")))
   (iff
     (cst-list-list-conc-matchp
          (abnf::tree-nonleaf->branches abnf::cst)
          "form-feed")
     (equal
          (abnf::tree-nonleaf->rulename?
               (nth 0
                    (nth 0
                         (abnf::tree-nonleaf->branches abnf::cst))))
          (abnf::rulename "form-feed"))))))

Theorem: cst-basic-character-conc-equivs

(defthm cst-basic-character-conc-equivs
 (implies
  (cst-matchp abnf::cst "basic-character")
  (and
   (iff
     (cst-list-list-conc-matchp
          (abnf::tree-nonleaf->branches abnf::cst)
          "letter")
     (equal
          (abnf::tree-nonleaf->rulename?
               (nth 0
                    (nth 0
                         (abnf::tree-nonleaf->branches abnf::cst))))
          (abnf::rulename "letter")))
   (iff
     (cst-list-list-conc-matchp
          (abnf::tree-nonleaf->branches abnf::cst)
          "digit")
     (equal
          (abnf::tree-nonleaf->rulename?
               (nth 0
                    (nth 0
                         (abnf::tree-nonleaf->branches abnf::cst))))
          (abnf::rulename "digit")))
   (iff
     (cst-list-list-conc-matchp
          (abnf::tree-nonleaf->branches abnf::cst)
          "graphic-character")
     (equal
          (abnf::tree-nonleaf->rulename?
               (nth 0
                    (nth 0
                         (abnf::tree-nonleaf->branches abnf::cst))))
          (abnf::rulename "graphic-character")))
   (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)
          "control-character")
     (equal
          (abnf::tree-nonleaf->rulename?
               (nth 0
                    (nth 0
                         (abnf::tree-nonleaf->branches abnf::cst))))
          (abnf::rulename "control-character"))))))

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)
          "basic-character")
     (equal
          (abnf::tree-nonleaf->rulename?
               (nth 0
                    (nth 0
                         (abnf::tree-nonleaf->branches abnf::cst))))
          (abnf::rulename "basic-character")))
   (iff
     (cst-list-list-conc-matchp
          (abnf::tree-nonleaf->branches abnf::cst)
          "extended-character")
     (equal
          (abnf::tree-nonleaf->rulename?
               (nth 0
                    (nth 0
                         (abnf::tree-nonleaf->branches abnf::cst))))
          (abnf::rulename "extended-character"))))))

Theorem: cst-basic-character-not-star-conc-equivs

(defthm cst-basic-character-not-star-conc-equivs
 (implies
  (cst-matchp abnf::cst "basic-character-not-star")
  (and
   (iff
     (cst-list-list-conc-matchp
          (abnf::tree-nonleaf->branches abnf::cst)
          "letter")
     (equal
          (abnf::tree-nonleaf->rulename?
               (nth 0
                    (nth 0
                         (abnf::tree-nonleaf->branches abnf::cst))))
          (abnf::rulename "letter")))
   (iff
     (cst-list-list-conc-matchp
          (abnf::tree-nonleaf->branches abnf::cst)
          "digit")
     (equal
          (abnf::tree-nonleaf->rulename?
               (nth 0
                    (nth 0
                         (abnf::tree-nonleaf->branches abnf::cst))))
          (abnf::rulename "digit")))
   (iff
     (cst-list-list-conc-matchp
          (abnf::tree-nonleaf->branches abnf::cst)
          "graphic-character-not-star")
     (equal
          (abnf::tree-nonleaf->rulename?
               (nth 0
                    (nth 0
                         (abnf::tree-nonleaf->branches abnf::cst))))
          (abnf::rulename "graphic-character-not-star")))
   (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)
          "control-character")
     (equal
          (abnf::tree-nonleaf->rulename?
               (nth 0
                    (nth 0
                         (abnf::tree-nonleaf->branches abnf::cst))))
          (abnf::rulename "control-character"))))))

Theorem: cst-basic-character-not-greater-than-conc-equivs

(defthm cst-basic-character-not-greater-than-conc-equivs
 (implies
  (cst-matchp abnf::cst
              "basic-character-not-greater-than")
  (and
   (iff
     (cst-list-list-conc-matchp
          (abnf::tree-nonleaf->branches abnf::cst)
          "letter")
     (equal
          (abnf::tree-nonleaf->rulename?
               (nth 0
                    (nth 0
                         (abnf::tree-nonleaf->branches abnf::cst))))
          (abnf::rulename "letter")))
   (iff
     (cst-list-list-conc-matchp
          (abnf::tree-nonleaf->branches abnf::cst)
          "digit")
     (equal
          (abnf::tree-nonleaf->rulename?
               (nth 0
                    (nth 0
                         (abnf::tree-nonleaf->branches abnf::cst))))
          (abnf::rulename "digit")))
   (iff
     (cst-list-list-conc-matchp
          (abnf::tree-nonleaf->branches abnf::cst)
          "graphic-character-not-greater-than")
     (equal
          (abnf::tree-nonleaf->rulename?
               (nth 0
                    (nth 0
                         (abnf::tree-nonleaf->branches abnf::cst))))
          (abnf::rulename "graphic-character-not-greater-than")))
   (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)
          "control-character")
     (equal
          (abnf::tree-nonleaf->rulename?
               (nth 0
                    (nth 0
                         (abnf::tree-nonleaf->branches abnf::cst))))
          (abnf::rulename "control-character"))))))

Theorem: cst-basic-character-not-double-quote-conc-equivs

(defthm cst-basic-character-not-double-quote-conc-equivs
 (implies
  (cst-matchp abnf::cst
              "basic-character-not-double-quote")
  (and
   (iff
     (cst-list-list-conc-matchp
          (abnf::tree-nonleaf->branches abnf::cst)
          "letter")
     (equal
          (abnf::tree-nonleaf->rulename?
               (nth 0
                    (nth 0
                         (abnf::tree-nonleaf->branches abnf::cst))))
          (abnf::rulename "letter")))
   (iff
     (cst-list-list-conc-matchp
          (abnf::tree-nonleaf->branches abnf::cst)
          "digit")
     (equal
          (abnf::tree-nonleaf->rulename?
               (nth 0
                    (nth 0
                         (abnf::tree-nonleaf->branches abnf::cst))))
          (abnf::rulename "digit")))
   (iff
     (cst-list-list-conc-matchp
          (abnf::tree-nonleaf->branches abnf::cst)
          "graphic-character-not-double-quote")
     (equal
          (abnf::tree-nonleaf->rulename?
               (nth 0
                    (nth 0
                         (abnf::tree-nonleaf->branches abnf::cst))))
          (abnf::rulename "graphic-character-not-double-quote")))
   (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)
          "control-character")
     (equal
          (abnf::tree-nonleaf->rulename?
               (nth 0
                    (nth 0
                         (abnf::tree-nonleaf->branches abnf::cst))))
          (abnf::rulename "control-character"))))))

Theorem: cst-basic-character-not-star-or-slash-conc-equivs

(defthm cst-basic-character-not-star-or-slash-conc-equivs
 (implies
  (cst-matchp abnf::cst
              "basic-character-not-star-or-slash")
  (and
   (iff
     (cst-list-list-conc-matchp
          (abnf::tree-nonleaf->branches abnf::cst)
          "letter")
     (equal
          (abnf::tree-nonleaf->rulename?
               (nth 0
                    (nth 0
                         (abnf::tree-nonleaf->branches abnf::cst))))
          (abnf::rulename "letter")))
   (iff
     (cst-list-list-conc-matchp
          (abnf::tree-nonleaf->branches abnf::cst)
          "digit")
     (equal
          (abnf::tree-nonleaf->rulename?
               (nth 0
                    (nth 0
                         (abnf::tree-nonleaf->branches abnf::cst))))
          (abnf::rulename "digit")))
   (iff
     (cst-list-list-conc-matchp
          (abnf::tree-nonleaf->branches abnf::cst)
          "graphic-character-not-star-or-slash")
     (equal
          (abnf::tree-nonleaf->rulename?
               (nth 0
                    (nth 0
                         (abnf::tree-nonleaf->branches abnf::cst))))
          (abnf::rulename "graphic-character-not-star-or-slash")))
   (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)
          "control-character")
     (equal
          (abnf::tree-nonleaf->rulename?
               (nth 0
                    (nth 0
                         (abnf::tree-nonleaf->branches abnf::cst))))
          (abnf::rulename "control-character"))))))

Theorem: cst-basic-character-not-single-quote-or-backslash-conc-equivs

(defthm
      cst-basic-character-not-single-quote-or-backslash-conc-equivs
 (implies
  (cst-matchp abnf::cst
              "basic-character-not-single-quote-or-backslash")
  (and
   (iff
     (cst-list-list-conc-matchp
          (abnf::tree-nonleaf->branches abnf::cst)
          "letter")
     (equal
          (abnf::tree-nonleaf->rulename?
               (nth 0
                    (nth 0
                         (abnf::tree-nonleaf->branches abnf::cst))))
          (abnf::rulename "letter")))
   (iff
     (cst-list-list-conc-matchp
          (abnf::tree-nonleaf->branches abnf::cst)
          "digit")
     (equal
          (abnf::tree-nonleaf->rulename?
               (nth 0
                    (nth 0
                         (abnf::tree-nonleaf->branches abnf::cst))))
          (abnf::rulename "digit")))
   (iff
     (cst-list-list-conc-matchp
          (abnf::tree-nonleaf->branches abnf::cst)
          "graphic-character-not-single-quote-or-backslash")
     (equal
          (abnf::tree-nonleaf->rulename?
               (nth 0
                    (nth 0
                         (abnf::tree-nonleaf->branches abnf::cst))))
          (abnf::rulename
               "graphic-character-not-single-quote-or-backslash")))
   (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)
          "control-character")
     (equal
          (abnf::tree-nonleaf->rulename?
               (nth 0
                    (nth 0
                         (abnf::tree-nonleaf->branches abnf::cst))))
          (abnf::rulename "control-character"))))))

Theorem: cst-basic-character-not-double-quote-or-backslash-conc-equivs

(defthm
      cst-basic-character-not-double-quote-or-backslash-conc-equivs
 (implies
  (cst-matchp abnf::cst
              "basic-character-not-double-quote-or-backslash")
  (and
   (iff
     (cst-list-list-conc-matchp
          (abnf::tree-nonleaf->branches abnf::cst)
          "letter")
     (equal
          (abnf::tree-nonleaf->rulename?
               (nth 0
                    (nth 0
                         (abnf::tree-nonleaf->branches abnf::cst))))
          (abnf::rulename "letter")))
   (iff
     (cst-list-list-conc-matchp
          (abnf::tree-nonleaf->branches abnf::cst)
          "digit")
     (equal
          (abnf::tree-nonleaf->rulename?
               (nth 0
                    (nth 0
                         (abnf::tree-nonleaf->branches abnf::cst))))
          (abnf::rulename "digit")))
   (iff
     (cst-list-list-conc-matchp
          (abnf::tree-nonleaf->branches abnf::cst)
          "graphic-character-not-double-quote-or-backslash")
     (equal
          (abnf::tree-nonleaf->rulename?
               (nth 0
                    (nth 0
                         (abnf::tree-nonleaf->branches abnf::cst))))
          (abnf::rulename
               "graphic-character-not-double-quote-or-backslash")))
   (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)
          "control-character")
     (equal
          (abnf::tree-nonleaf->rulename?
               (nth 0
                    (nth 0
                         (abnf::tree-nonleaf->branches abnf::cst))))
          (abnf::rulename "control-character"))))))

Theorem: cst-character-not-new-line-conc-equivs

(defthm cst-character-not-new-line-conc-equivs
 (implies
  (cst-matchp abnf::cst "character-not-new-line")
  (and
   (iff
     (cst-list-list-conc-matchp
          (abnf::tree-nonleaf->branches abnf::cst)
          "basic-character")
     (equal
          (abnf::tree-nonleaf->rulename?
               (nth 0
                    (nth 0
                         (abnf::tree-nonleaf->branches abnf::cst))))
          (abnf::rulename "basic-character")))
   (iff
     (cst-list-list-conc-matchp
          (abnf::tree-nonleaf->branches abnf::cst)
          "extended-character-not-new-line")
     (equal
          (abnf::tree-nonleaf->rulename?
               (nth 0
                    (nth 0
                         (abnf::tree-nonleaf->branches abnf::cst))))
          (abnf::rulename "extended-character-not-new-line"))))))

Theorem: cst-character-not-star-conc-equivs

(defthm cst-character-not-star-conc-equivs
 (implies
  (cst-matchp abnf::cst "character-not-star")
  (and
   (iff
     (cst-list-list-conc-matchp
          (abnf::tree-nonleaf->branches abnf::cst)
          "basic-character-not-star")
     (equal
          (abnf::tree-nonleaf->rulename?
               (nth 0
                    (nth 0
                         (abnf::tree-nonleaf->branches abnf::cst))))
          (abnf::rulename "basic-character-not-star")))
   (iff
     (cst-list-list-conc-matchp
          (abnf::tree-nonleaf->branches abnf::cst)
          "extended-character")
     (equal
          (abnf::tree-nonleaf->rulename?
               (nth 0
                    (nth 0
                         (abnf::tree-nonleaf->branches abnf::cst))))
          (abnf::rulename "extended-character"))))))

Theorem: cst-character-not-star-or-slash-conc-equivs

(defthm cst-character-not-star-or-slash-conc-equivs
 (implies
  (cst-matchp abnf::cst "character-not-star-or-slash")
  (and
   (iff
     (cst-list-list-conc-matchp
          (abnf::tree-nonleaf->branches abnf::cst)
          "basic-character-not-star-or-slash")
     (equal
          (abnf::tree-nonleaf->rulename?
               (nth 0
                    (nth 0
                         (abnf::tree-nonleaf->branches abnf::cst))))
          (abnf::rulename "basic-character-not-star-or-slash")))
   (iff
     (cst-list-list-conc-matchp
          (abnf::tree-nonleaf->branches abnf::cst)
          "extended-character")
     (equal
          (abnf::tree-nonleaf->rulename?
               (nth 0
                    (nth 0
                         (abnf::tree-nonleaf->branches abnf::cst))))
          (abnf::rulename "extended-character"))))))

Theorem: cst-character-not-greater-than-or-new-line-conc-equivs

(defthm cst-character-not-greater-than-or-new-line-conc-equivs
 (implies
  (cst-matchp abnf::cst
              "character-not-greater-than-or-new-line")
  (and
   (iff
     (cst-list-list-conc-matchp
          (abnf::tree-nonleaf->branches abnf::cst)
          "basic-character-not-greater-than")
     (equal
          (abnf::tree-nonleaf->rulename?
               (nth 0
                    (nth 0
                         (abnf::tree-nonleaf->branches abnf::cst))))
          (abnf::rulename "basic-character-not-greater-than")))
   (iff
     (cst-list-list-conc-matchp
          (abnf::tree-nonleaf->branches abnf::cst)
          "extended-character-not-new-line")
     (equal
          (abnf::tree-nonleaf->rulename?
               (nth 0
                    (nth 0
                         (abnf::tree-nonleaf->branches abnf::cst))))
          (abnf::rulename "extended-character-not-new-line"))))))

Theorem: cst-character-not-double-quote-or-new-line-conc-equivs

(defthm cst-character-not-double-quote-or-new-line-conc-equivs
 (implies
  (cst-matchp abnf::cst
              "character-not-double-quote-or-new-line")
  (and
   (iff
     (cst-list-list-conc-matchp
          (abnf::tree-nonleaf->branches abnf::cst)
          "basic-character-not-double-quote")
     (equal
          (abnf::tree-nonleaf->rulename?
               (nth 0
                    (nth 0
                         (abnf::tree-nonleaf->branches abnf::cst))))
          (abnf::rulename "basic-character-not-double-quote")))
   (iff
     (cst-list-list-conc-matchp
          (abnf::tree-nonleaf->branches abnf::cst)
          "extended-character-not-new-line")
     (equal
          (abnf::tree-nonleaf->rulename?
               (nth 0
                    (nth 0
                         (abnf::tree-nonleaf->branches abnf::cst))))
          (abnf::rulename "extended-character-not-new-line"))))))

Theorem: cst-character-not-single-quote-or-backslash-or-new-line-conc-equivs

(defthm
 cst-character-not-single-quote-or-backslash-or-new-line-conc-equivs
 (implies
  (cst-matchp abnf::cst
              "character-not-single-quote-or-backslash-or-new-line")
  (and
   (iff
     (cst-list-list-conc-matchp
          (abnf::tree-nonleaf->branches abnf::cst)
          "basic-character-not-single-quote-or-backslash")
     (equal
          (abnf::tree-nonleaf->rulename?
               (nth 0
                    (nth 0
                         (abnf::tree-nonleaf->branches abnf::cst))))
          (abnf::rulename
               "basic-character-not-single-quote-or-backslash")))
   (iff
     (cst-list-list-conc-matchp
          (abnf::tree-nonleaf->branches abnf::cst)
          "extended-character-not-new-line")
     (equal
          (abnf::tree-nonleaf->rulename?
               (nth 0
                    (nth 0
                         (abnf::tree-nonleaf->branches abnf::cst))))
          (abnf::rulename "extended-character-not-new-line"))))))

Theorem: cst-character-not-double-quote-or-backslash-or-new-line-conc-equivs

(defthm
 cst-character-not-double-quote-or-backslash-or-new-line-conc-equivs
 (implies
  (cst-matchp abnf::cst
              "character-not-double-quote-or-backslash-or-new-line")
  (and
   (iff
     (cst-list-list-conc-matchp
          (abnf::tree-nonleaf->branches abnf::cst)
          "basic-character-not-double-quote-or-backslash")
     (equal
          (abnf::tree-nonleaf->rulename?
               (nth 0
                    (nth 0
                         (abnf::tree-nonleaf->branches abnf::cst))))
          (abnf::rulename
               "basic-character-not-double-quote-or-backslash")))
   (iff
     (cst-list-list-conc-matchp
          (abnf::tree-nonleaf->branches abnf::cst)
          "extended-character-not-new-line")
     (equal
          (abnf::tree-nonleaf->rulename?
               (nth 0
                    (nth 0
                         (abnf::tree-nonleaf->branches abnf::cst))))
          (abnf::rulename "extended-character-not-new-line"))))))

Theorem: cst-white-space-conc-equivs

(defthm cst-white-space-conc-equivs
 (implies
  (cst-matchp abnf::cst "white-space")
  (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)
          "vertical-tab")
     (equal
          (abnf::tree-nonleaf->rulename?
               (nth 0
                    (nth 0
                         (abnf::tree-nonleaf->branches abnf::cst))))
          (abnf::rulename "vertical-tab")))
   (iff
     (cst-list-list-conc-matchp
          (abnf::tree-nonleaf->branches abnf::cst)
          "form-feed")
     (equal
          (abnf::tree-nonleaf->rulename?
               (nth 0
                    (nth 0
                         (abnf::tree-nonleaf->branches abnf::cst))))
          (abnf::rulename "form-feed")))
   (iff
     (cst-list-list-conc-matchp
          (abnf::tree-nonleaf->branches abnf::cst)
          "new-line")
     (equal
          (abnf::tree-nonleaf->rulename?
               (nth 0
                    (nth 0
                         (abnf::tree-nonleaf->branches abnf::cst))))
          (abnf::rulename "new-line"))))))

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-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)
          "constant")
     (equal
          (abnf::tree-nonleaf->rulename?
               (nth 0
                    (nth 0
                         (abnf::tree-nonleaf->branches abnf::cst))))
          (abnf::rulename "constant")))
   (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")))
   (iff
     (cst-list-list-conc-matchp
          (abnf::tree-nonleaf->branches abnf::cst)
          "punctuator")
     (equal
          (abnf::tree-nonleaf->rulename?
               (nth 0
                    (nth 0
                         (abnf::tree-nonleaf->branches abnf::cst))))
          (abnf::rulename "punctuator"))))))

Theorem: cst-preprocessing-token-conc-equivs

(defthm cst-preprocessing-token-conc-equivs
 (implies
  (cst-matchp abnf::cst "preprocessing-token")
  (and
   (iff
     (cst-list-list-conc-matchp
          (abnf::tree-nonleaf->branches abnf::cst)
          "header-name")
     (equal
          (abnf::tree-nonleaf->rulename?
               (nth 0
                    (nth 0
                         (abnf::tree-nonleaf->branches abnf::cst))))
          (abnf::rulename "header-name")))
   (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)
          "pp-number")
     (equal
          (abnf::tree-nonleaf->rulename?
               (nth 0
                    (nth 0
                         (abnf::tree-nonleaf->branches abnf::cst))))
          (abnf::rulename "pp-number")))
   (iff
     (cst-list-list-conc-matchp
          (abnf::tree-nonleaf->branches abnf::cst)
          "character-constant")
     (equal
          (abnf::tree-nonleaf->rulename?
               (nth 0
                    (nth 0
                         (abnf::tree-nonleaf->branches abnf::cst))))
          (abnf::rulename "character-constant")))
   (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")))
   (iff
     (cst-list-list-conc-matchp
          (abnf::tree-nonleaf->branches abnf::cst)
          "punctuator")
     (equal
          (abnf::tree-nonleaf->rulename?
               (nth 0
                    (nth 0
                         (abnf::tree-nonleaf->branches abnf::cst))))
          (abnf::rulename "punctuator")))
   (iff
     (cst-list-list-conc-matchp
          (abnf::tree-nonleaf->branches abnf::cst)
          "character")
     (equal
          (abnf::tree-nonleaf->rulename?
               (nth 0
                    (nth 0
                         (abnf::tree-nonleaf->branches abnf::cst))))
          (abnf::rulename "character"))))))

Theorem: cst-nondigit-conc-equivs

(defthm cst-nondigit-conc-equivs
 (implies
  (cst-matchp abnf::cst "nondigit")
  (and
      (iff (cst-list-list-conc-matchp
                (abnf::tree-nonleaf->branches abnf::cst)
                "\"_\"")
           (abnf::tree-case
                (nth 0
                     (nth 0
                          (abnf::tree-nonleaf->branches abnf::cst)))
                :leafterm))
      (iff (cst-list-list-conc-matchp
                (abnf::tree-nonleaf->branches abnf::cst)
                "letter")
           (abnf::tree-case
                (nth 0
                     (nth 0
                          (abnf::tree-nonleaf->branches abnf::cst)))
                :nonleaf)))))

Theorem: cst-constant-conc-equivs

(defthm cst-constant-conc-equivs
 (implies
  (cst-matchp abnf::cst "constant")
  (and
   (iff
     (cst-list-list-conc-matchp
          (abnf::tree-nonleaf->branches abnf::cst)
          "integer-constant")
     (equal
          (abnf::tree-nonleaf->rulename?
               (nth 0
                    (nth 0
                         (abnf::tree-nonleaf->branches abnf::cst))))
          (abnf::rulename "integer-constant")))
   (iff
     (cst-list-list-conc-matchp
          (abnf::tree-nonleaf->branches abnf::cst)
          "floating-constant")
     (equal
          (abnf::tree-nonleaf->rulename?
               (nth 0
                    (nth 0
                         (abnf::tree-nonleaf->branches abnf::cst))))
          (abnf::rulename "floating-constant")))
   (iff
     (cst-list-list-conc-matchp
          (abnf::tree-nonleaf->branches abnf::cst)
          "enumeration-constant")
     (equal
          (abnf::tree-nonleaf->rulename?
               (nth 0
                    (nth 0
                         (abnf::tree-nonleaf->branches abnf::cst))))
          (abnf::rulename "enumeration-constant")))
   (iff
     (cst-list-list-conc-matchp
          (abnf::tree-nonleaf->branches abnf::cst)
          "character-constant")
     (equal
          (abnf::tree-nonleaf->rulename?
               (nth 0
                    (nth 0
                         (abnf::tree-nonleaf->branches abnf::cst))))
          (abnf::rulename "character-constant"))))))

Theorem: cst-floating-constant-conc-equivs

(defthm cst-floating-constant-conc-equivs
 (implies
  (cst-matchp abnf::cst "floating-constant")
  (and
   (iff
     (cst-list-list-conc-matchp
          (abnf::tree-nonleaf->branches abnf::cst)
          "decimal-floating-constant")
     (equal
          (abnf::tree-nonleaf->rulename?
               (nth 0
                    (nth 0
                         (abnf::tree-nonleaf->branches abnf::cst))))
          (abnf::rulename "decimal-floating-constant")))
   (iff
     (cst-list-list-conc-matchp
          (abnf::tree-nonleaf->branches abnf::cst)
          "hexadecimal-floating-constant")
     (equal
          (abnf::tree-nonleaf->rulename?
               (nth 0
                    (nth 0
                         (abnf::tree-nonleaf->branches abnf::cst))))
          (abnf::rulename "hexadecimal-floating-constant"))))))

Theorem: cst-c-char-conc-equivs

(defthm cst-c-char-conc-equivs
 (implies
  (cst-matchp abnf::cst "c-char")
  (and
   (iff
    (cst-list-list-conc-matchp
         (abnf::tree-nonleaf->branches abnf::cst)
         "character-not-single-quote-or-backslash-or-new-line")
    (equal
       (abnf::tree-nonleaf->rulename?
            (nth 0
                 (nth 0
                      (abnf::tree-nonleaf->branches abnf::cst))))
       (abnf::rulename
            "character-not-single-quote-or-backslash-or-new-line")))
   (iff
     (cst-list-list-conc-matchp
          (abnf::tree-nonleaf->branches abnf::cst)
          "escape-sequence")
     (equal
          (abnf::tree-nonleaf->rulename?
               (nth 0
                    (nth 0
                         (abnf::tree-nonleaf->branches abnf::cst))))
          (abnf::rulename "escape-sequence"))))))

Theorem: cst-escape-sequence-conc-equivs

(defthm cst-escape-sequence-conc-equivs
 (implies
  (cst-matchp abnf::cst "escape-sequence")
  (and
   (iff
     (cst-list-list-conc-matchp
          (abnf::tree-nonleaf->branches abnf::cst)
          "simple-escape-sequence")
     (equal
          (abnf::tree-nonleaf->rulename?
               (nth 0
                    (nth 0
                         (abnf::tree-nonleaf->branches abnf::cst))))
          (abnf::rulename "simple-escape-sequence")))
   (iff
     (cst-list-list-conc-matchp
          (abnf::tree-nonleaf->branches abnf::cst)
          "octal-escape-sequence")
     (equal
          (abnf::tree-nonleaf->rulename?
               (nth 0
                    (nth 0
                         (abnf::tree-nonleaf->branches abnf::cst))))
          (abnf::rulename "octal-escape-sequence")))
   (iff
     (cst-list-list-conc-matchp
          (abnf::tree-nonleaf->branches abnf::cst)
          "hexadecimal-escape-sequence")
     (equal
          (abnf::tree-nonleaf->rulename?
               (nth 0
                    (nth 0
                         (abnf::tree-nonleaf->branches abnf::cst))))
          (abnf::rulename "hexadecimal-escape-sequence")))
   (iff
     (cst-list-list-conc-matchp
          (abnf::tree-nonleaf->branches abnf::cst)
          "universal-character-name")
     (equal
          (abnf::tree-nonleaf->rulename?
               (nth 0
                    (nth 0
                         (abnf::tree-nonleaf->branches abnf::cst))))
          (abnf::rulename "universal-character-name"))))))

Theorem: cst-s-char-conc-equivs

(defthm cst-s-char-conc-equivs
 (implies
  (cst-matchp abnf::cst "s-char")
  (and
   (iff
    (cst-list-list-conc-matchp
         (abnf::tree-nonleaf->branches abnf::cst)
         "character-not-double-quote-or-backslash-or-new-line")
    (equal
       (abnf::tree-nonleaf->rulename?
            (nth 0
                 (nth 0
                      (abnf::tree-nonleaf->branches abnf::cst))))
       (abnf::rulename
            "character-not-double-quote-or-backslash-or-new-line")))
   (iff
     (cst-list-list-conc-matchp
          (abnf::tree-nonleaf->branches abnf::cst)
          "escape-sequence")
     (equal
          (abnf::tree-nonleaf->rulename?
               (nth 0
                    (nth 0
                         (abnf::tree-nonleaf->branches abnf::cst))))
          (abnf::rulename "escape-sequence"))))))

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)
          "control-line")
     (equal
          (abnf::tree-nonleaf->rulename?
               (nth 0
                    (nth 0
                         (abnf::tree-nonleaf->branches abnf::cst))))
          (abnf::rulename "control-line")))
   (iff
     (cst-list-list-conc-matchp
          (abnf::tree-nonleaf->branches abnf::cst)
          "white-space")
     (equal
          (abnf::tree-nonleaf->rulename?
               (nth 0
                    (nth 0
                         (abnf::tree-nonleaf->branches abnf::cst))))
          (abnf::rulename "white-space"))))))

Theorem: cst-attribute-name-conc-equivs

(defthm cst-attribute-name-conc-equivs
 (implies
  (cst-matchp abnf::cst "attribute-name")
  (and
   (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)
          "keyword")
     (equal
          (abnf::tree-nonleaf->rulename?
               (nth 0
                    (nth 0
                         (abnf::tree-nonleaf->branches abnf::cst))))
          (abnf::rulename "keyword"))))))

Theorem: cst-function-specifier-conc-equivs

(defthm cst-function-specifier-conc-equivs
 (implies
  (cst-matchp abnf::cst "function-specifier")
  (and
      (iff (cst-list-list-conc-matchp
                (abnf::tree-nonleaf->branches abnf::cst)
                "inline-keyword")
           (abnf::tree-case
                (nth 0
                     (nth 0
                          (abnf::tree-nonleaf->branches abnf::cst)))
                :nonleaf))
      (iff (cst-list-list-conc-matchp
                (abnf::tree-nonleaf->branches abnf::cst)
                "%s\"_Noreturn\"")
           (abnf::tree-case
                (nth 0
                     (nth 0
                          (abnf::tree-nonleaf->branches abnf::cst)))
                :leafterm)))))

Theorem: cst-type-qualifier-or-attribute-specifier-conc-equivs

(defthm cst-type-qualifier-or-attribute-specifier-conc-equivs
 (implies
  (cst-matchp abnf::cst
              "type-qualifier-or-attribute-specifier")
  (and
   (iff
     (cst-list-list-conc-matchp
          (abnf::tree-nonleaf->branches abnf::cst)
          "type-qualifier")
     (equal
          (abnf::tree-nonleaf->rulename?
               (nth 0
                    (nth 0
                         (abnf::tree-nonleaf->branches abnf::cst))))
          (abnf::rulename "type-qualifier")))
   (iff
     (cst-list-list-conc-matchp
          (abnf::tree-nonleaf->branches abnf::cst)
          "attribute-specifier")
     (equal
          (abnf::tree-nonleaf->rulename?
               (nth 0
                    (nth 0
                         (abnf::tree-nonleaf->branches abnf::cst))))
          (abnf::rulename "attribute-specifier"))))))

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)
          "labeled-statement")
     (equal
          (abnf::tree-nonleaf->rulename?
               (nth 0
                    (nth 0
                         (abnf::tree-nonleaf->branches abnf::cst))))
          (abnf::rulename "labeled-statement")))
   (iff
     (cst-list-list-conc-matchp
          (abnf::tree-nonleaf->branches abnf::cst)
          "compound-statement")
     (equal
          (abnf::tree-nonleaf->rulename?
               (nth 0
                    (nth 0
                         (abnf::tree-nonleaf->branches abnf::cst))))
          (abnf::rulename "compound-statement")))
   (iff
     (cst-list-list-conc-matchp
          (abnf::tree-nonleaf->branches abnf::cst)
          "expression-statement")
     (equal
          (abnf::tree-nonleaf->rulename?
               (nth 0
                    (nth 0
                         (abnf::tree-nonleaf->branches abnf::cst))))
          (abnf::rulename "expression-statement")))
   (iff
     (cst-list-list-conc-matchp
          (abnf::tree-nonleaf->branches abnf::cst)
          "selection-statement")
     (equal
          (abnf::tree-nonleaf->rulename?
               (nth 0
                    (nth 0
                         (abnf::tree-nonleaf->branches abnf::cst))))
          (abnf::rulename "selection-statement")))
   (iff
     (cst-list-list-conc-matchp
          (abnf::tree-nonleaf->branches abnf::cst)
          "iteration-statement")
     (equal
          (abnf::tree-nonleaf->rulename?
               (nth 0
                    (nth 0
                         (abnf::tree-nonleaf->branches abnf::cst))))
          (abnf::rulename "iteration-statement")))
   (iff
     (cst-list-list-conc-matchp
          (abnf::tree-nonleaf->branches abnf::cst)
          "jump-statement")
     (equal
          (abnf::tree-nonleaf->rulename?
               (nth 0
                    (nth 0
                         (abnf::tree-nonleaf->branches abnf::cst))))
          (abnf::rulename "jump-statement")))
   (iff
     (cst-list-list-conc-matchp
          (abnf::tree-nonleaf->branches abnf::cst)
          "asm-statement")
     (equal
          (abnf::tree-nonleaf->rulename?
               (nth 0
                    (nth 0
                         (abnf::tree-nonleaf->branches abnf::cst))))
          (abnf::rulename "asm-statement"))))))

Theorem: cst-block-item-conc-equivs

(defthm cst-block-item-conc-equivs
 (implies
  (cst-matchp abnf::cst "block-item")
  (and
   (iff
     (cst-list-list-conc-matchp
          (abnf::tree-nonleaf->branches abnf::cst)
          "declaration")
     (equal
          (abnf::tree-nonleaf->rulename?
               (nth 0
                    (nth 0
                         (abnf::tree-nonleaf->branches abnf::cst))))
          (abnf::rulename "declaration")))
   (iff
     (cst-list-list-conc-matchp
          (abnf::tree-nonleaf->branches abnf::cst)
          "statement")
     (equal
          (abnf::tree-nonleaf->rulename?
               (nth 0
                    (nth 0
                         (abnf::tree-nonleaf->branches abnf::cst))))
          (abnf::rulename "statement"))))))

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-control-character-conc?

(defun cst-control-character-conc? (abnf::cst)
 (declare (xargs :guard (abnf::treep abnf::cst)))
 (declare (xargs :guard (cst-matchp abnf::cst "control-character")))
 (let ((__function__ 'cst-control-character-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 "vertical-tab"))
     2)
    ((equal
          (abnf::tree-nonleaf->rulename?
               (nth 0
                    (nth 0
                         (abnf::tree-nonleaf->branches abnf::cst))))
          (abnf::rulename "form-feed"))
     3)
    (t (prog2$ (impossible) 1)))))

Theorem: posp-of-cst-control-character-conc?

(defthm posp-of-cst-control-character-conc?
  (b* ((number (cst-control-character-conc? abnf::cst)))
    (posp number))
  :rule-classes :rewrite)

Theorem: cst-control-character-conc?-possibilities

(defthm cst-control-character-conc?-possibilities
  (b* ((number (cst-control-character-conc? abnf::cst)))
    (or (equal number 1)
        (equal number 2)
        (equal number 3)))
  :rule-classes
  ((:forward-chaining
        :trigger-terms ((cst-control-character-conc? abnf::cst)))))

Theorem: cst-control-character-conc?-of-tree-fix-cst

(defthm cst-control-character-conc?-of-tree-fix-cst
  (equal (cst-control-character-conc? (abnf::tree-fix abnf::cst))
         (cst-control-character-conc? abnf::cst)))

Theorem: cst-control-character-conc?-tree-equiv-congruence-on-cst

(defthm cst-control-character-conc?-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-control-character-conc? abnf::cst)
                  (cst-control-character-conc? cst-equiv)))
  :rule-classes :congruence)

Theorem: cst-control-character-conc?-1-iff-match-conc

(defthm cst-control-character-conc?-1-iff-match-conc
  (implies (cst-matchp abnf::cst "control-character")
           (iff (equal (cst-control-character-conc? abnf::cst)
                       1)
                (cst-list-list-conc-matchp
                     (abnf::tree-nonleaf->branches abnf::cst)
                     "horizontal-tab"))))

Theorem: cst-control-character-conc?-2-iff-match-conc

(defthm cst-control-character-conc?-2-iff-match-conc
  (implies (cst-matchp abnf::cst "control-character")
           (iff (equal (cst-control-character-conc? abnf::cst)
                       2)
                (cst-list-list-conc-matchp
                     (abnf::tree-nonleaf->branches abnf::cst)
                     "vertical-tab"))))

Theorem: cst-control-character-conc?-3-iff-match-conc

(defthm cst-control-character-conc?-3-iff-match-conc
  (implies (cst-matchp abnf::cst "control-character")
           (iff (equal (cst-control-character-conc? abnf::cst)
                       3)
                (cst-list-list-conc-matchp
                     (abnf::tree-nonleaf->branches abnf::cst)
                     "form-feed"))))

Function: cst-basic-character-conc?

(defun cst-basic-character-conc? (abnf::cst)
 (declare (xargs :guard (abnf::treep abnf::cst)))
 (declare (xargs :guard (cst-matchp abnf::cst "basic-character")))
 (let ((__function__ 'cst-basic-character-conc?))
  (declare (ignorable __function__))
  (cond
    ((equal
          (abnf::tree-nonleaf->rulename?
               (nth 0
                    (nth 0
                         (abnf::tree-nonleaf->branches abnf::cst))))
          (abnf::rulename "letter"))
     1)
    ((equal
          (abnf::tree-nonleaf->rulename?
               (nth 0
                    (nth 0
                         (abnf::tree-nonleaf->branches abnf::cst))))
          (abnf::rulename "digit"))
     2)
    ((equal
          (abnf::tree-nonleaf->rulename?
               (nth 0
                    (nth 0
                         (abnf::tree-nonleaf->branches abnf::cst))))
          (abnf::rulename "graphic-character"))
     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 "control-character"))
     5)
    (t (prog2$ (impossible) 1)))))

Theorem: posp-of-cst-basic-character-conc?

(defthm posp-of-cst-basic-character-conc?
  (b* ((number (cst-basic-character-conc? abnf::cst)))
    (posp number))
  :rule-classes :rewrite)

Theorem: cst-basic-character-conc?-possibilities

(defthm cst-basic-character-conc?-possibilities
  (b* ((number (cst-basic-character-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-basic-character-conc? abnf::cst)))))

Theorem: cst-basic-character-conc?-of-tree-fix-cst

(defthm cst-basic-character-conc?-of-tree-fix-cst
  (equal (cst-basic-character-conc? (abnf::tree-fix abnf::cst))
         (cst-basic-character-conc? abnf::cst)))

Theorem: cst-basic-character-conc?-tree-equiv-congruence-on-cst

(defthm cst-basic-character-conc?-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-basic-character-conc? abnf::cst)
                  (cst-basic-character-conc? cst-equiv)))
  :rule-classes :congruence)

Theorem: cst-basic-character-conc?-1-iff-match-conc

(defthm cst-basic-character-conc?-1-iff-match-conc
  (implies (cst-matchp abnf::cst "basic-character")
           (iff (equal (cst-basic-character-conc? abnf::cst)
                       1)
                (cst-list-list-conc-matchp
                     (abnf::tree-nonleaf->branches abnf::cst)
                     "letter"))))

Theorem: cst-basic-character-conc?-2-iff-match-conc

(defthm cst-basic-character-conc?-2-iff-match-conc
  (implies (cst-matchp abnf::cst "basic-character")
           (iff (equal (cst-basic-character-conc? abnf::cst)
                       2)
                (cst-list-list-conc-matchp
                     (abnf::tree-nonleaf->branches abnf::cst)
                     "digit"))))

Theorem: cst-basic-character-conc?-3-iff-match-conc

(defthm cst-basic-character-conc?-3-iff-match-conc
  (implies (cst-matchp abnf::cst "basic-character")
           (iff (equal (cst-basic-character-conc? abnf::cst)
                       3)
                (cst-list-list-conc-matchp
                     (abnf::tree-nonleaf->branches abnf::cst)
                     "graphic-character"))))

Theorem: cst-basic-character-conc?-4-iff-match-conc

(defthm cst-basic-character-conc?-4-iff-match-conc
  (implies (cst-matchp abnf::cst "basic-character")
           (iff (equal (cst-basic-character-conc? abnf::cst)
                       4)
                (cst-list-list-conc-matchp
                     (abnf::tree-nonleaf->branches abnf::cst)
                     "space"))))

Theorem: cst-basic-character-conc?-5-iff-match-conc

(defthm cst-basic-character-conc?-5-iff-match-conc
  (implies (cst-matchp abnf::cst "basic-character")
           (iff (equal (cst-basic-character-conc? abnf::cst)
                       5)
                (cst-list-list-conc-matchp
                     (abnf::tree-nonleaf->branches abnf::cst)
                     "control-character"))))

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 "basic-character"))
     1)
    ((equal
          (abnf::tree-nonleaf->rulename?
               (nth 0
                    (nth 0
                         (abnf::tree-nonleaf->branches abnf::cst))))
          (abnf::rulename "extended-character"))
     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)
                     "basic-character"))))

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)
                     "extended-character"))))

Function: cst-basic-character-not-star-conc?

(defun cst-basic-character-not-star-conc? (abnf::cst)
 (declare (xargs :guard (abnf::treep abnf::cst)))
 (declare
   (xargs :guard (cst-matchp abnf::cst "basic-character-not-star")))
 (let ((__function__ 'cst-basic-character-not-star-conc?))
  (declare (ignorable __function__))
  (cond
    ((equal
          (abnf::tree-nonleaf->rulename?
               (nth 0
                    (nth 0
                         (abnf::tree-nonleaf->branches abnf::cst))))
          (abnf::rulename "letter"))
     1)
    ((equal
          (abnf::tree-nonleaf->rulename?
               (nth 0
                    (nth 0
                         (abnf::tree-nonleaf->branches abnf::cst))))
          (abnf::rulename "digit"))
     2)
    ((equal
          (abnf::tree-nonleaf->rulename?
               (nth 0
                    (nth 0
                         (abnf::tree-nonleaf->branches abnf::cst))))
          (abnf::rulename "graphic-character-not-star"))
     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 "control-character"))
     5)
    (t (prog2$ (impossible) 1)))))

Theorem: posp-of-cst-basic-character-not-star-conc?

(defthm posp-of-cst-basic-character-not-star-conc?
  (b* ((number (cst-basic-character-not-star-conc? abnf::cst)))
    (posp number))
  :rule-classes :rewrite)

Theorem: cst-basic-character-not-star-conc?-possibilities

(defthm cst-basic-character-not-star-conc?-possibilities
  (b* ((number (cst-basic-character-not-star-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-basic-character-not-star-conc? abnf::cst)))))

Theorem: cst-basic-character-not-star-conc?-of-tree-fix-cst

(defthm cst-basic-character-not-star-conc?-of-tree-fix-cst
 (equal
     (cst-basic-character-not-star-conc? (abnf::tree-fix abnf::cst))
     (cst-basic-character-not-star-conc? abnf::cst)))

Theorem: cst-basic-character-not-star-conc?-tree-equiv-congruence-on-cst

(defthm
    cst-basic-character-not-star-conc?-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-basic-character-not-star-conc? abnf::cst)
                  (cst-basic-character-not-star-conc? cst-equiv)))
  :rule-classes :congruence)

Theorem: cst-basic-character-not-star-conc?-1-iff-match-conc

(defthm cst-basic-character-not-star-conc?-1-iff-match-conc
 (implies (cst-matchp abnf::cst "basic-character-not-star")
          (iff (equal (cst-basic-character-not-star-conc? abnf::cst)
                      1)
               (cst-list-list-conc-matchp
                    (abnf::tree-nonleaf->branches abnf::cst)
                    "letter"))))

Theorem: cst-basic-character-not-star-conc?-2-iff-match-conc

(defthm cst-basic-character-not-star-conc?-2-iff-match-conc
 (implies (cst-matchp abnf::cst "basic-character-not-star")
          (iff (equal (cst-basic-character-not-star-conc? abnf::cst)
                      2)
               (cst-list-list-conc-matchp
                    (abnf::tree-nonleaf->branches abnf::cst)
                    "digit"))))

Theorem: cst-basic-character-not-star-conc?-3-iff-match-conc

(defthm cst-basic-character-not-star-conc?-3-iff-match-conc
 (implies (cst-matchp abnf::cst "basic-character-not-star")
          (iff (equal (cst-basic-character-not-star-conc? abnf::cst)
                      3)
               (cst-list-list-conc-matchp
                    (abnf::tree-nonleaf->branches abnf::cst)
                    "graphic-character-not-star"))))

Theorem: cst-basic-character-not-star-conc?-4-iff-match-conc

(defthm cst-basic-character-not-star-conc?-4-iff-match-conc
 (implies (cst-matchp abnf::cst "basic-character-not-star")
          (iff (equal (cst-basic-character-not-star-conc? abnf::cst)
                      4)
               (cst-list-list-conc-matchp
                    (abnf::tree-nonleaf->branches abnf::cst)
                    "space"))))

Theorem: cst-basic-character-not-star-conc?-5-iff-match-conc

(defthm cst-basic-character-not-star-conc?-5-iff-match-conc
 (implies (cst-matchp abnf::cst "basic-character-not-star")
          (iff (equal (cst-basic-character-not-star-conc? abnf::cst)
                      5)
               (cst-list-list-conc-matchp
                    (abnf::tree-nonleaf->branches abnf::cst)
                    "control-character"))))

Function: cst-basic-character-not-greater-than-conc?

(defun cst-basic-character-not-greater-than-conc? (abnf::cst)
 (declare (xargs :guard (abnf::treep abnf::cst)))
 (declare
     (xargs :guard (cst-matchp abnf::cst
                               "basic-character-not-greater-than")))
 (let ((__function__ 'cst-basic-character-not-greater-than-conc?))
  (declare (ignorable __function__))
  (cond
    ((equal
          (abnf::tree-nonleaf->rulename?
               (nth 0
                    (nth 0
                         (abnf::tree-nonleaf->branches abnf::cst))))
          (abnf::rulename "letter"))
     1)
    ((equal
          (abnf::tree-nonleaf->rulename?
               (nth 0
                    (nth 0
                         (abnf::tree-nonleaf->branches abnf::cst))))
          (abnf::rulename "digit"))
     2)
    ((equal
          (abnf::tree-nonleaf->rulename?
               (nth 0
                    (nth 0
                         (abnf::tree-nonleaf->branches abnf::cst))))
          (abnf::rulename "graphic-character-not-greater-than"))
     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 "control-character"))
     5)
    (t (prog2$ (impossible) 1)))))

Theorem: posp-of-cst-basic-character-not-greater-than-conc?

(defthm posp-of-cst-basic-character-not-greater-than-conc?
  (b*
   ((number (cst-basic-character-not-greater-than-conc? abnf::cst)))
   (posp number))
  :rule-classes :rewrite)

Theorem: cst-basic-character-not-greater-than-conc?-possibilities

(defthm cst-basic-character-not-greater-than-conc?-possibilities
  (b*
   ((number (cst-basic-character-not-greater-than-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-basic-character-not-greater-than-conc? abnf::cst)))))

Theorem: cst-basic-character-not-greater-than-conc?-of-tree-fix-cst

(defthm cst-basic-character-not-greater-than-conc?-of-tree-fix-cst
  (equal (cst-basic-character-not-greater-than-conc?
              (abnf::tree-fix abnf::cst))
         (cst-basic-character-not-greater-than-conc? abnf::cst)))

Theorem: cst-basic-character-not-greater-than-conc?-tree-equiv-congruence-on-cst

(defthm
 cst-basic-character-not-greater-than-conc?-tree-equiv-congruence-on-cst
 (implies
     (abnf::tree-equiv abnf::cst cst-equiv)
     (equal (cst-basic-character-not-greater-than-conc? abnf::cst)
            (cst-basic-character-not-greater-than-conc? cst-equiv)))
 :rule-classes :congruence)

Theorem: cst-basic-character-not-greater-than-conc?-1-iff-match-conc

(defthm cst-basic-character-not-greater-than-conc?-1-iff-match-conc
 (implies
  (cst-matchp abnf::cst
              "basic-character-not-greater-than")
  (iff (equal (cst-basic-character-not-greater-than-conc? abnf::cst)
              1)
       (cst-list-list-conc-matchp
            (abnf::tree-nonleaf->branches abnf::cst)
            "letter"))))

Theorem: cst-basic-character-not-greater-than-conc?-2-iff-match-conc

(defthm cst-basic-character-not-greater-than-conc?-2-iff-match-conc
 (implies
  (cst-matchp abnf::cst
              "basic-character-not-greater-than")
  (iff (equal (cst-basic-character-not-greater-than-conc? abnf::cst)
              2)
       (cst-list-list-conc-matchp
            (abnf::tree-nonleaf->branches abnf::cst)
            "digit"))))

Theorem: cst-basic-character-not-greater-than-conc?-3-iff-match-conc

(defthm cst-basic-character-not-greater-than-conc?-3-iff-match-conc
 (implies
  (cst-matchp abnf::cst
              "basic-character-not-greater-than")
  (iff (equal (cst-basic-character-not-greater-than-conc? abnf::cst)
              3)
       (cst-list-list-conc-matchp
            (abnf::tree-nonleaf->branches abnf::cst)
            "graphic-character-not-greater-than"))))

Theorem: cst-basic-character-not-greater-than-conc?-4-iff-match-conc

(defthm cst-basic-character-not-greater-than-conc?-4-iff-match-conc
 (implies
  (cst-matchp abnf::cst
              "basic-character-not-greater-than")
  (iff (equal (cst-basic-character-not-greater-than-conc? abnf::cst)
              4)
       (cst-list-list-conc-matchp
            (abnf::tree-nonleaf->branches abnf::cst)
            "space"))))

Theorem: cst-basic-character-not-greater-than-conc?-5-iff-match-conc

(defthm cst-basic-character-not-greater-than-conc?-5-iff-match-conc
 (implies
  (cst-matchp abnf::cst
              "basic-character-not-greater-than")
  (iff (equal (cst-basic-character-not-greater-than-conc? abnf::cst)
              5)
       (cst-list-list-conc-matchp
            (abnf::tree-nonleaf->branches abnf::cst)
            "control-character"))))

Function: cst-basic-character-not-double-quote-conc?

(defun cst-basic-character-not-double-quote-conc? (abnf::cst)
 (declare (xargs :guard (abnf::treep abnf::cst)))
 (declare
     (xargs :guard (cst-matchp abnf::cst
                               "basic-character-not-double-quote")))
 (let ((__function__ 'cst-basic-character-not-double-quote-conc?))
  (declare (ignorable __function__))
  (cond
    ((equal
          (abnf::tree-nonleaf->rulename?
               (nth 0
                    (nth 0
                         (abnf::tree-nonleaf->branches abnf::cst))))
          (abnf::rulename "letter"))
     1)
    ((equal
          (abnf::tree-nonleaf->rulename?
               (nth 0
                    (nth 0
                         (abnf::tree-nonleaf->branches abnf::cst))))
          (abnf::rulename "digit"))
     2)
    ((equal
          (abnf::tree-nonleaf->rulename?
               (nth 0
                    (nth 0
                         (abnf::tree-nonleaf->branches abnf::cst))))
          (abnf::rulename "graphic-character-not-double-quote"))
     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 "control-character"))
     5)
    (t (prog2$ (impossible) 1)))))

Theorem: posp-of-cst-basic-character-not-double-quote-conc?

(defthm posp-of-cst-basic-character-not-double-quote-conc?
  (b*
   ((number (cst-basic-character-not-double-quote-conc? abnf::cst)))
   (posp number))
  :rule-classes :rewrite)

Theorem: cst-basic-character-not-double-quote-conc?-possibilities

(defthm cst-basic-character-not-double-quote-conc?-possibilities
  (b*
   ((number (cst-basic-character-not-double-quote-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-basic-character-not-double-quote-conc? abnf::cst)))))

Theorem: cst-basic-character-not-double-quote-conc?-of-tree-fix-cst

(defthm cst-basic-character-not-double-quote-conc?-of-tree-fix-cst
  (equal (cst-basic-character-not-double-quote-conc?
              (abnf::tree-fix abnf::cst))
         (cst-basic-character-not-double-quote-conc? abnf::cst)))

Theorem: cst-basic-character-not-double-quote-conc?-tree-equiv-congruence-on-cst

(defthm
 cst-basic-character-not-double-quote-conc?-tree-equiv-congruence-on-cst
 (implies
     (abnf::tree-equiv abnf::cst cst-equiv)
     (equal (cst-basic-character-not-double-quote-conc? abnf::cst)
            (cst-basic-character-not-double-quote-conc? cst-equiv)))
 :rule-classes :congruence)

Theorem: cst-basic-character-not-double-quote-conc?-1-iff-match-conc

(defthm cst-basic-character-not-double-quote-conc?-1-iff-match-conc
 (implies
  (cst-matchp abnf::cst
              "basic-character-not-double-quote")
  (iff (equal (cst-basic-character-not-double-quote-conc? abnf::cst)
              1)
       (cst-list-list-conc-matchp
            (abnf::tree-nonleaf->branches abnf::cst)
            "letter"))))

Theorem: cst-basic-character-not-double-quote-conc?-2-iff-match-conc

(defthm cst-basic-character-not-double-quote-conc?-2-iff-match-conc
 (implies
  (cst-matchp abnf::cst
              "basic-character-not-double-quote")
  (iff (equal (cst-basic-character-not-double-quote-conc? abnf::cst)
              2)
       (cst-list-list-conc-matchp
            (abnf::tree-nonleaf->branches abnf::cst)
            "digit"))))

Theorem: cst-basic-character-not-double-quote-conc?-3-iff-match-conc

(defthm cst-basic-character-not-double-quote-conc?-3-iff-match-conc
 (implies
  (cst-matchp abnf::cst
              "basic-character-not-double-quote")
  (iff (equal (cst-basic-character-not-double-quote-conc? abnf::cst)
              3)
       (cst-list-list-conc-matchp
            (abnf::tree-nonleaf->branches abnf::cst)
            "graphic-character-not-double-quote"))))

Theorem: cst-basic-character-not-double-quote-conc?-4-iff-match-conc

(defthm cst-basic-character-not-double-quote-conc?-4-iff-match-conc
 (implies
  (cst-matchp abnf::cst
              "basic-character-not-double-quote")
  (iff (equal (cst-basic-character-not-double-quote-conc? abnf::cst)
              4)
       (cst-list-list-conc-matchp
            (abnf::tree-nonleaf->branches abnf::cst)
            "space"))))

Theorem: cst-basic-character-not-double-quote-conc?-5-iff-match-conc

(defthm cst-basic-character-not-double-quote-conc?-5-iff-match-conc
 (implies
  (cst-matchp abnf::cst
              "basic-character-not-double-quote")
  (iff (equal (cst-basic-character-not-double-quote-conc? abnf::cst)
              5)
       (cst-list-list-conc-matchp
            (abnf::tree-nonleaf->branches abnf::cst)
            "control-character"))))

Function: cst-basic-character-not-star-or-slash-conc?

(defun cst-basic-character-not-star-or-slash-conc? (abnf::cst)
 (declare (xargs :guard (abnf::treep abnf::cst)))
 (declare
    (xargs :guard (cst-matchp abnf::cst
                              "basic-character-not-star-or-slash")))
 (let ((__function__ 'cst-basic-character-not-star-or-slash-conc?))
  (declare (ignorable __function__))
  (cond
    ((equal
          (abnf::tree-nonleaf->rulename?
               (nth 0
                    (nth 0
                         (abnf::tree-nonleaf->branches abnf::cst))))
          (abnf::rulename "letter"))
     1)
    ((equal
          (abnf::tree-nonleaf->rulename?
               (nth 0
                    (nth 0
                         (abnf::tree-nonleaf->branches abnf::cst))))
          (abnf::rulename "digit"))
     2)
    ((equal
          (abnf::tree-nonleaf->rulename?
               (nth 0
                    (nth 0
                         (abnf::tree-nonleaf->branches abnf::cst))))
          (abnf::rulename "graphic-character-not-star-or-slash"))
     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 "control-character"))
     5)
    (t (prog2$ (impossible) 1)))))

Theorem: posp-of-cst-basic-character-not-star-or-slash-conc?

(defthm posp-of-cst-basic-character-not-star-or-slash-conc?
 (b*
  ((number (cst-basic-character-not-star-or-slash-conc? abnf::cst)))
  (posp number))
 :rule-classes :rewrite)

Theorem: cst-basic-character-not-star-or-slash-conc?-possibilities

(defthm cst-basic-character-not-star-or-slash-conc?-possibilities
 (b*
  ((number (cst-basic-character-not-star-or-slash-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-basic-character-not-star-or-slash-conc? abnf::cst)))))

Theorem: cst-basic-character-not-star-or-slash-conc?-of-tree-fix-cst

(defthm cst-basic-character-not-star-or-slash-conc?-of-tree-fix-cst
  (equal (cst-basic-character-not-star-or-slash-conc?
              (abnf::tree-fix abnf::cst))
         (cst-basic-character-not-star-or-slash-conc? abnf::cst)))

Theorem: cst-basic-character-not-star-or-slash-conc?-tree-equiv-congruence-on-cst

(defthm
 cst-basic-character-not-star-or-slash-conc?-tree-equiv-congruence-on-cst
 (implies
    (abnf::tree-equiv abnf::cst cst-equiv)
    (equal (cst-basic-character-not-star-or-slash-conc? abnf::cst)
           (cst-basic-character-not-star-or-slash-conc? cst-equiv)))
 :rule-classes :congruence)

Theorem: cst-basic-character-not-star-or-slash-conc?-1-iff-match-conc

(defthm cst-basic-character-not-star-or-slash-conc?-1-iff-match-conc
 (implies
  (cst-matchp abnf::cst
              "basic-character-not-star-or-slash")
  (iff
      (equal (cst-basic-character-not-star-or-slash-conc? abnf::cst)
             1)
      (cst-list-list-conc-matchp
           (abnf::tree-nonleaf->branches abnf::cst)
           "letter"))))

Theorem: cst-basic-character-not-star-or-slash-conc?-2-iff-match-conc

(defthm cst-basic-character-not-star-or-slash-conc?-2-iff-match-conc
 (implies
  (cst-matchp abnf::cst
              "basic-character-not-star-or-slash")
  (iff
      (equal (cst-basic-character-not-star-or-slash-conc? abnf::cst)
             2)
      (cst-list-list-conc-matchp
           (abnf::tree-nonleaf->branches abnf::cst)
           "digit"))))

Theorem: cst-basic-character-not-star-or-slash-conc?-3-iff-match-conc

(defthm cst-basic-character-not-star-or-slash-conc?-3-iff-match-conc
 (implies
  (cst-matchp abnf::cst
              "basic-character-not-star-or-slash")
  (iff
      (equal (cst-basic-character-not-star-or-slash-conc? abnf::cst)
             3)
      (cst-list-list-conc-matchp
           (abnf::tree-nonleaf->branches abnf::cst)
           "graphic-character-not-star-or-slash"))))

Theorem: cst-basic-character-not-star-or-slash-conc?-4-iff-match-conc

(defthm cst-basic-character-not-star-or-slash-conc?-4-iff-match-conc
 (implies
  (cst-matchp abnf::cst
              "basic-character-not-star-or-slash")
  (iff
      (equal (cst-basic-character-not-star-or-slash-conc? abnf::cst)
             4)
      (cst-list-list-conc-matchp
           (abnf::tree-nonleaf->branches abnf::cst)
           "space"))))

Theorem: cst-basic-character-not-star-or-slash-conc?-5-iff-match-conc

(defthm cst-basic-character-not-star-or-slash-conc?-5-iff-match-conc
 (implies
  (cst-matchp abnf::cst
              "basic-character-not-star-or-slash")
  (iff
      (equal (cst-basic-character-not-star-or-slash-conc? abnf::cst)
             5)
      (cst-list-list-conc-matchp
           (abnf::tree-nonleaf->branches abnf::cst)
           "control-character"))))

Function: cst-basic-character-not-single-quote-or-backslash-conc?

(defun cst-basic-character-not-single-quote-or-backslash-conc?
       (abnf::cst)
 (declare (xargs :guard (abnf::treep abnf::cst)))
 (declare
  (xargs
      :guard
      (cst-matchp abnf::cst
                  "basic-character-not-single-quote-or-backslash")))
 (let
   ((__function__
         'cst-basic-character-not-single-quote-or-backslash-conc?))
  (declare (ignorable __function__))
  (cond
    ((equal
          (abnf::tree-nonleaf->rulename?
               (nth 0
                    (nth 0
                         (abnf::tree-nonleaf->branches abnf::cst))))
          (abnf::rulename "letter"))
     1)
    ((equal
          (abnf::tree-nonleaf->rulename?
               (nth 0
                    (nth 0
                         (abnf::tree-nonleaf->branches abnf::cst))))
          (abnf::rulename "digit"))
     2)
    ((equal
          (abnf::tree-nonleaf->rulename?
               (nth 0
                    (nth 0
                         (abnf::tree-nonleaf->branches abnf::cst))))
          (abnf::rulename
               "graphic-character-not-single-quote-or-backslash"))
     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 "control-character"))
     5)
    (t (prog2$ (impossible) 1)))))

Theorem: posp-of-cst-basic-character-not-single-quote-or-backslash-conc?

(defthm
    posp-of-cst-basic-character-not-single-quote-or-backslash-conc?
  (b* ((number (cst-basic-character-not-single-quote-or-backslash-conc?
                    abnf::cst)))
    (posp number))
  :rule-classes :rewrite)

Theorem: cst-basic-character-not-single-quote-or-backslash-conc?-possibilities

(defthm
 cst-basic-character-not-single-quote-or-backslash-conc?-possibilities
 (b* ((number (cst-basic-character-not-single-quote-or-backslash-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-basic-character-not-single-quote-or-backslash-conc?
                                          abnf::cst)))))

Theorem: cst-basic-character-not-single-quote-or-backslash-conc?-of-tree-fix-cst

(defthm
 cst-basic-character-not-single-quote-or-backslash-conc?-of-tree-fix-cst
 (equal (cst-basic-character-not-single-quote-or-backslash-conc?
             (abnf::tree-fix abnf::cst))
        (cst-basic-character-not-single-quote-or-backslash-conc?
             abnf::cst)))

Theorem: cst-basic-character-not-single-quote-or-backslash-conc?-tree-equiv-congruence-on-cst

(defthm
 cst-basic-character-not-single-quote-or-backslash-conc?-tree-equiv-congruence-on-cst
 (implies (abnf::tree-equiv abnf::cst cst-equiv)
          (equal (cst-basic-character-not-single-quote-or-backslash-conc?
                      abnf::cst)
                 (cst-basic-character-not-single-quote-or-backslash-conc?
                      cst-equiv)))
 :rule-classes :congruence)

Theorem: cst-basic-character-not-single-quote-or-backslash-conc?-1-iff-match-conc

(defthm
 cst-basic-character-not-single-quote-or-backslash-conc?-1-iff-match-conc
 (implies
      (cst-matchp abnf::cst
                  "basic-character-not-single-quote-or-backslash")
      (iff (equal (cst-basic-character-not-single-quote-or-backslash-conc?
                       abnf::cst)
                  1)
           (cst-list-list-conc-matchp
                (abnf::tree-nonleaf->branches abnf::cst)
                "letter"))))

Theorem: cst-basic-character-not-single-quote-or-backslash-conc?-2-iff-match-conc

(defthm
 cst-basic-character-not-single-quote-or-backslash-conc?-2-iff-match-conc
 (implies
      (cst-matchp abnf::cst
                  "basic-character-not-single-quote-or-backslash")
      (iff (equal (cst-basic-character-not-single-quote-or-backslash-conc?
                       abnf::cst)
                  2)
           (cst-list-list-conc-matchp
                (abnf::tree-nonleaf->branches abnf::cst)
                "digit"))))

Theorem: cst-basic-character-not-single-quote-or-backslash-conc?-3-iff-match-conc

(defthm
 cst-basic-character-not-single-quote-or-backslash-conc?-3-iff-match-conc
 (implies
     (cst-matchp abnf::cst
                 "basic-character-not-single-quote-or-backslash")
     (iff (equal (cst-basic-character-not-single-quote-or-backslash-conc?
                      abnf::cst)
                 3)
          (cst-list-list-conc-matchp
               (abnf::tree-nonleaf->branches abnf::cst)
               "graphic-character-not-single-quote-or-backslash"))))

Theorem: cst-basic-character-not-single-quote-or-backslash-conc?-4-iff-match-conc

(defthm
 cst-basic-character-not-single-quote-or-backslash-conc?-4-iff-match-conc
 (implies
      (cst-matchp abnf::cst
                  "basic-character-not-single-quote-or-backslash")
      (iff (equal (cst-basic-character-not-single-quote-or-backslash-conc?
                       abnf::cst)
                  4)
           (cst-list-list-conc-matchp
                (abnf::tree-nonleaf->branches abnf::cst)
                "space"))))

Theorem: cst-basic-character-not-single-quote-or-backslash-conc?-5-iff-match-conc

(defthm
 cst-basic-character-not-single-quote-or-backslash-conc?-5-iff-match-conc
 (implies
      (cst-matchp abnf::cst
                  "basic-character-not-single-quote-or-backslash")
      (iff (equal (cst-basic-character-not-single-quote-or-backslash-conc?
                       abnf::cst)
                  5)
           (cst-list-list-conc-matchp
                (abnf::tree-nonleaf->branches abnf::cst)
                "control-character"))))

Function: cst-basic-character-not-double-quote-or-backslash-conc?

(defun cst-basic-character-not-double-quote-or-backslash-conc?
       (abnf::cst)
 (declare (xargs :guard (abnf::treep abnf::cst)))
 (declare
  (xargs
      :guard
      (cst-matchp abnf::cst
                  "basic-character-not-double-quote-or-backslash")))
 (let
   ((__function__
         'cst-basic-character-not-double-quote-or-backslash-conc?))
  (declare (ignorable __function__))
  (cond
    ((equal
          (abnf::tree-nonleaf->rulename?
               (nth 0
                    (nth 0
                         (abnf::tree-nonleaf->branches abnf::cst))))
          (abnf::rulename "letter"))
     1)
    ((equal
          (abnf::tree-nonleaf->rulename?
               (nth 0
                    (nth 0
                         (abnf::tree-nonleaf->branches abnf::cst))))
          (abnf::rulename "digit"))
     2)
    ((equal
          (abnf::tree-nonleaf->rulename?
               (nth 0
                    (nth 0
                         (abnf::tree-nonleaf->branches abnf::cst))))
          (abnf::rulename
               "graphic-character-not-double-quote-or-backslash"))
     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 "control-character"))
     5)
    (t (prog2$ (impossible) 1)))))

Theorem: posp-of-cst-basic-character-not-double-quote-or-backslash-conc?

(defthm
    posp-of-cst-basic-character-not-double-quote-or-backslash-conc?
  (b* ((number (cst-basic-character-not-double-quote-or-backslash-conc?
                    abnf::cst)))
    (posp number))
  :rule-classes :rewrite)

Theorem: cst-basic-character-not-double-quote-or-backslash-conc?-possibilities

(defthm
 cst-basic-character-not-double-quote-or-backslash-conc?-possibilities
 (b* ((number (cst-basic-character-not-double-quote-or-backslash-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-basic-character-not-double-quote-or-backslash-conc?
                                          abnf::cst)))))

Theorem: cst-basic-character-not-double-quote-or-backslash-conc?-of-tree-fix-cst

(defthm
 cst-basic-character-not-double-quote-or-backslash-conc?-of-tree-fix-cst
 (equal (cst-basic-character-not-double-quote-or-backslash-conc?
             (abnf::tree-fix abnf::cst))
        (cst-basic-character-not-double-quote-or-backslash-conc?
             abnf::cst)))

Theorem: cst-basic-character-not-double-quote-or-backslash-conc?-tree-equiv-congruence-on-cst

(defthm
 cst-basic-character-not-double-quote-or-backslash-conc?-tree-equiv-congruence-on-cst
 (implies (abnf::tree-equiv abnf::cst cst-equiv)
          (equal (cst-basic-character-not-double-quote-or-backslash-conc?
                      abnf::cst)
                 (cst-basic-character-not-double-quote-or-backslash-conc?
                      cst-equiv)))
 :rule-classes :congruence)

Theorem: cst-basic-character-not-double-quote-or-backslash-conc?-1-iff-match-conc

(defthm
 cst-basic-character-not-double-quote-or-backslash-conc?-1-iff-match-conc
 (implies
      (cst-matchp abnf::cst
                  "basic-character-not-double-quote-or-backslash")
      (iff (equal (cst-basic-character-not-double-quote-or-backslash-conc?
                       abnf::cst)
                  1)
           (cst-list-list-conc-matchp
                (abnf::tree-nonleaf->branches abnf::cst)
                "letter"))))

Theorem: cst-basic-character-not-double-quote-or-backslash-conc?-2-iff-match-conc

(defthm
 cst-basic-character-not-double-quote-or-backslash-conc?-2-iff-match-conc
 (implies
      (cst-matchp abnf::cst
                  "basic-character-not-double-quote-or-backslash")
      (iff (equal (cst-basic-character-not-double-quote-or-backslash-conc?
                       abnf::cst)
                  2)
           (cst-list-list-conc-matchp
                (abnf::tree-nonleaf->branches abnf::cst)
                "digit"))))

Theorem: cst-basic-character-not-double-quote-or-backslash-conc?-3-iff-match-conc

(defthm
 cst-basic-character-not-double-quote-or-backslash-conc?-3-iff-match-conc
 (implies
     (cst-matchp abnf::cst
                 "basic-character-not-double-quote-or-backslash")
     (iff (equal (cst-basic-character-not-double-quote-or-backslash-conc?
                      abnf::cst)
                 3)
          (cst-list-list-conc-matchp
               (abnf::tree-nonleaf->branches abnf::cst)
               "graphic-character-not-double-quote-or-backslash"))))

Theorem: cst-basic-character-not-double-quote-or-backslash-conc?-4-iff-match-conc

(defthm
 cst-basic-character-not-double-quote-or-backslash-conc?-4-iff-match-conc
 (implies
      (cst-matchp abnf::cst
                  "basic-character-not-double-quote-or-backslash")
      (iff (equal (cst-basic-character-not-double-quote-or-backslash-conc?
                       abnf::cst)
                  4)
           (cst-list-list-conc-matchp
                (abnf::tree-nonleaf->branches abnf::cst)
                "space"))))

Theorem: cst-basic-character-not-double-quote-or-backslash-conc?-5-iff-match-conc

(defthm
 cst-basic-character-not-double-quote-or-backslash-conc?-5-iff-match-conc
 (implies
      (cst-matchp abnf::cst
                  "basic-character-not-double-quote-or-backslash")
      (iff (equal (cst-basic-character-not-double-quote-or-backslash-conc?
                       abnf::cst)
                  5)
           (cst-list-list-conc-matchp
                (abnf::tree-nonleaf->branches abnf::cst)
                "control-character"))))

Function: cst-character-not-new-line-conc?

(defun cst-character-not-new-line-conc? (abnf::cst)
 (declare (xargs :guard (abnf::treep abnf::cst)))
 (declare
     (xargs :guard (cst-matchp abnf::cst "character-not-new-line")))
 (let ((__function__ 'cst-character-not-new-line-conc?))
  (declare (ignorable __function__))
  (cond
    ((equal
          (abnf::tree-nonleaf->rulename?
               (nth 0
                    (nth 0
                         (abnf::tree-nonleaf->branches abnf::cst))))
          (abnf::rulename "basic-character"))
     1)
    ((equal
          (abnf::tree-nonleaf->rulename?
               (nth 0
                    (nth 0
                         (abnf::tree-nonleaf->branches abnf::cst))))
          (abnf::rulename "extended-character-not-new-line"))
     2)
    (t (prog2$ (impossible) 1)))))

Theorem: posp-of-cst-character-not-new-line-conc?

(defthm posp-of-cst-character-not-new-line-conc?
  (b* ((number (cst-character-not-new-line-conc? abnf::cst)))
    (posp number))
  :rule-classes :rewrite)

Theorem: cst-character-not-new-line-conc?-possibilities

(defthm cst-character-not-new-line-conc?-possibilities
 (b* ((number (cst-character-not-new-line-conc? abnf::cst)))
   (or (equal number 1) (equal number 2)))
 :rule-classes
 ((:forward-chaining
    :trigger-terms ((cst-character-not-new-line-conc? abnf::cst)))))

Theorem: cst-character-not-new-line-conc?-of-tree-fix-cst

(defthm cst-character-not-new-line-conc?-of-tree-fix-cst
  (equal
       (cst-character-not-new-line-conc? (abnf::tree-fix abnf::cst))
       (cst-character-not-new-line-conc? abnf::cst)))

Theorem: cst-character-not-new-line-conc?-tree-equiv-congruence-on-cst

(defthm
      cst-character-not-new-line-conc?-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-character-not-new-line-conc? abnf::cst)
                  (cst-character-not-new-line-conc? cst-equiv)))
  :rule-classes :congruence)

Theorem: cst-character-not-new-line-conc?-1-iff-match-conc

(defthm cst-character-not-new-line-conc?-1-iff-match-conc
  (implies (cst-matchp abnf::cst "character-not-new-line")
           (iff (equal (cst-character-not-new-line-conc? abnf::cst)
                       1)
                (cst-list-list-conc-matchp
                     (abnf::tree-nonleaf->branches abnf::cst)
                     "basic-character"))))

Theorem: cst-character-not-new-line-conc?-2-iff-match-conc

(defthm cst-character-not-new-line-conc?-2-iff-match-conc
  (implies (cst-matchp abnf::cst "character-not-new-line")
           (iff (equal (cst-character-not-new-line-conc? abnf::cst)
                       2)
                (cst-list-list-conc-matchp
                     (abnf::tree-nonleaf->branches abnf::cst)
                     "extended-character-not-new-line"))))

Function: cst-character-not-star-conc?

(defun cst-character-not-star-conc? (abnf::cst)
 (declare (xargs :guard (abnf::treep abnf::cst)))
 (declare
      (xargs :guard (cst-matchp abnf::cst "character-not-star")))
 (let ((__function__ 'cst-character-not-star-conc?))
  (declare (ignorable __function__))
  (cond
    ((equal
          (abnf::tree-nonleaf->rulename?
               (nth 0
                    (nth 0
                         (abnf::tree-nonleaf->branches abnf::cst))))
          (abnf::rulename "basic-character-not-star"))
     1)
    ((equal
          (abnf::tree-nonleaf->rulename?
               (nth 0
                    (nth 0
                         (abnf::tree-nonleaf->branches abnf::cst))))
          (abnf::rulename "extended-character"))
     2)
    (t (prog2$ (impossible) 1)))))

Theorem: posp-of-cst-character-not-star-conc?

(defthm posp-of-cst-character-not-star-conc?
  (b* ((number (cst-character-not-star-conc? abnf::cst)))
    (posp number))
  :rule-classes :rewrite)

Theorem: cst-character-not-star-conc?-possibilities

(defthm cst-character-not-star-conc?-possibilities
  (b* ((number (cst-character-not-star-conc? abnf::cst)))
    (or (equal number 1) (equal number 2)))
  :rule-classes
  ((:forward-chaining
        :trigger-terms ((cst-character-not-star-conc? abnf::cst)))))

Theorem: cst-character-not-star-conc?-of-tree-fix-cst

(defthm cst-character-not-star-conc?-of-tree-fix-cst
  (equal (cst-character-not-star-conc? (abnf::tree-fix abnf::cst))
         (cst-character-not-star-conc? abnf::cst)))

Theorem: cst-character-not-star-conc?-tree-equiv-congruence-on-cst

(defthm cst-character-not-star-conc?-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-character-not-star-conc? abnf::cst)
                  (cst-character-not-star-conc? cst-equiv)))
  :rule-classes :congruence)

Theorem: cst-character-not-star-conc?-1-iff-match-conc

(defthm cst-character-not-star-conc?-1-iff-match-conc
  (implies (cst-matchp abnf::cst "character-not-star")
           (iff (equal (cst-character-not-star-conc? abnf::cst)
                       1)
                (cst-list-list-conc-matchp
                     (abnf::tree-nonleaf->branches abnf::cst)
                     "basic-character-not-star"))))

Theorem: cst-character-not-star-conc?-2-iff-match-conc

(defthm cst-character-not-star-conc?-2-iff-match-conc
  (implies (cst-matchp abnf::cst "character-not-star")
           (iff (equal (cst-character-not-star-conc? abnf::cst)
                       2)
                (cst-list-list-conc-matchp
                     (abnf::tree-nonleaf->branches abnf::cst)
                     "extended-character"))))

Function: cst-character-not-star-or-slash-conc?

(defun cst-character-not-star-or-slash-conc? (abnf::cst)
 (declare (xargs :guard (abnf::treep abnf::cst)))
 (declare (xargs :guard (cst-matchp abnf::cst
                                    "character-not-star-or-slash")))
 (let ((__function__ 'cst-character-not-star-or-slash-conc?))
  (declare (ignorable __function__))
  (cond
    ((equal
          (abnf::tree-nonleaf->rulename?
               (nth 0
                    (nth 0
                         (abnf::tree-nonleaf->branches abnf::cst))))
          (abnf::rulename "basic-character-not-star-or-slash"))
     1)
    ((equal
          (abnf::tree-nonleaf->rulename?
               (nth 0
                    (nth 0
                         (abnf::tree-nonleaf->branches abnf::cst))))
          (abnf::rulename "extended-character"))
     2)
    (t (prog2$ (impossible) 1)))))

Theorem: posp-of-cst-character-not-star-or-slash-conc?

(defthm posp-of-cst-character-not-star-or-slash-conc?
  (b* ((number (cst-character-not-star-or-slash-conc? abnf::cst)))
    (posp number))
  :rule-classes :rewrite)

Theorem: cst-character-not-star-or-slash-conc?-possibilities

(defthm cst-character-not-star-or-slash-conc?-possibilities
  (b* ((number (cst-character-not-star-or-slash-conc? abnf::cst)))
    (or (equal number 1) (equal number 2)))
  :rule-classes
  ((:forward-chaining
        :trigger-terms
        ((cst-character-not-star-or-slash-conc? abnf::cst)))))

Theorem: cst-character-not-star-or-slash-conc?-of-tree-fix-cst

(defthm cst-character-not-star-or-slash-conc?-of-tree-fix-cst
 (equal
  (cst-character-not-star-or-slash-conc? (abnf::tree-fix abnf::cst))
  (cst-character-not-star-or-slash-conc? abnf::cst)))

Theorem: cst-character-not-star-or-slash-conc?-tree-equiv-congruence-on-cst

(defthm
 cst-character-not-star-or-slash-conc?-tree-equiv-congruence-on-cst
 (implies (abnf::tree-equiv abnf::cst cst-equiv)
          (equal (cst-character-not-star-or-slash-conc? abnf::cst)
                 (cst-character-not-star-or-slash-conc? cst-equiv)))
 :rule-classes :congruence)

Theorem: cst-character-not-star-or-slash-conc?-1-iff-match-conc

(defthm cst-character-not-star-or-slash-conc?-1-iff-match-conc
  (implies
       (cst-matchp abnf::cst "character-not-star-or-slash")
       (iff (equal (cst-character-not-star-or-slash-conc? abnf::cst)
                   1)
            (cst-list-list-conc-matchp
                 (abnf::tree-nonleaf->branches abnf::cst)
                 "basic-character-not-star-or-slash"))))

Theorem: cst-character-not-star-or-slash-conc?-2-iff-match-conc

(defthm cst-character-not-star-or-slash-conc?-2-iff-match-conc
  (implies
       (cst-matchp abnf::cst "character-not-star-or-slash")
       (iff (equal (cst-character-not-star-or-slash-conc? abnf::cst)
                   2)
            (cst-list-list-conc-matchp
                 (abnf::tree-nonleaf->branches abnf::cst)
                 "extended-character"))))

Function: cst-character-not-greater-than-or-new-line-conc?

(defun cst-character-not-greater-than-or-new-line-conc? (abnf::cst)
 (declare (xargs :guard (abnf::treep abnf::cst)))
 (declare
  (xargs
      :guard (cst-matchp abnf::cst
                         "character-not-greater-than-or-new-line")))
 (let
  ((__function__ 'cst-character-not-greater-than-or-new-line-conc?))
  (declare (ignorable __function__))
  (cond
    ((equal
          (abnf::tree-nonleaf->rulename?
               (nth 0
                    (nth 0
                         (abnf::tree-nonleaf->branches abnf::cst))))
          (abnf::rulename "basic-character-not-greater-than"))
     1)
    ((equal
          (abnf::tree-nonleaf->rulename?
               (nth 0
                    (nth 0
                         (abnf::tree-nonleaf->branches abnf::cst))))
          (abnf::rulename "extended-character-not-new-line"))
     2)
    (t (prog2$ (impossible) 1)))))

Theorem: posp-of-cst-character-not-greater-than-or-new-line-conc?

(defthm posp-of-cst-character-not-greater-than-or-new-line-conc?
 (b*
  ((number
      (cst-character-not-greater-than-or-new-line-conc? abnf::cst)))
  (posp number))
 :rule-classes :rewrite)

Theorem: cst-character-not-greater-than-or-new-line-conc?-possibilities

(defthm
     cst-character-not-greater-than-or-new-line-conc?-possibilities
 (b*
  ((number
      (cst-character-not-greater-than-or-new-line-conc? abnf::cst)))
  (or (equal number 1) (equal number 2)))
 :rule-classes
 ((:forward-chaining
   :trigger-terms
   ((cst-character-not-greater-than-or-new-line-conc? abnf::cst)))))

Theorem: cst-character-not-greater-than-or-new-line-conc?-of-tree-fix-cst

(defthm
   cst-character-not-greater-than-or-new-line-conc?-of-tree-fix-cst
 (equal
      (cst-character-not-greater-than-or-new-line-conc?
           (abnf::tree-fix abnf::cst))
      (cst-character-not-greater-than-or-new-line-conc? abnf::cst)))

Theorem: cst-character-not-greater-than-or-new-line-conc?-tree-equiv-congruence-on-cst

(defthm
 cst-character-not-greater-than-or-new-line-conc?-tree-equiv-congruence-on-cst
 (implies
  (abnf::tree-equiv abnf::cst cst-equiv)
  (equal
      (cst-character-not-greater-than-or-new-line-conc? abnf::cst)
      (cst-character-not-greater-than-or-new-line-conc? cst-equiv)))
 :rule-classes :congruence)

Theorem: cst-character-not-greater-than-or-new-line-conc?-1-iff-match-conc

(defthm
  cst-character-not-greater-than-or-new-line-conc?-1-iff-match-conc
 (implies
  (cst-matchp abnf::cst
              "character-not-greater-than-or-new-line")
  (iff
   (equal
        (cst-character-not-greater-than-or-new-line-conc? abnf::cst)
        1)
   (cst-list-list-conc-matchp
        (abnf::tree-nonleaf->branches abnf::cst)
        "basic-character-not-greater-than"))))

Theorem: cst-character-not-greater-than-or-new-line-conc?-2-iff-match-conc

(defthm
  cst-character-not-greater-than-or-new-line-conc?-2-iff-match-conc
 (implies
  (cst-matchp abnf::cst
              "character-not-greater-than-or-new-line")
  (iff
   (equal
        (cst-character-not-greater-than-or-new-line-conc? abnf::cst)
        2)
   (cst-list-list-conc-matchp
        (abnf::tree-nonleaf->branches abnf::cst)
        "extended-character-not-new-line"))))

Function: cst-character-not-double-quote-or-new-line-conc?

(defun cst-character-not-double-quote-or-new-line-conc? (abnf::cst)
 (declare (xargs :guard (abnf::treep abnf::cst)))
 (declare
  (xargs
      :guard (cst-matchp abnf::cst
                         "character-not-double-quote-or-new-line")))
 (let
  ((__function__ 'cst-character-not-double-quote-or-new-line-conc?))
  (declare (ignorable __function__))
  (cond
    ((equal
          (abnf::tree-nonleaf->rulename?
               (nth 0
                    (nth 0
                         (abnf::tree-nonleaf->branches abnf::cst))))
          (abnf::rulename "basic-character-not-double-quote"))
     1)
    ((equal
          (abnf::tree-nonleaf->rulename?
               (nth 0
                    (nth 0
                         (abnf::tree-nonleaf->branches abnf::cst))))
          (abnf::rulename "extended-character-not-new-line"))
     2)
    (t (prog2$ (impossible) 1)))))

Theorem: posp-of-cst-character-not-double-quote-or-new-line-conc?

(defthm posp-of-cst-character-not-double-quote-or-new-line-conc?
 (b*
  ((number
      (cst-character-not-double-quote-or-new-line-conc? abnf::cst)))
  (posp number))
 :rule-classes :rewrite)

Theorem: cst-character-not-double-quote-or-new-line-conc?-possibilities

(defthm
     cst-character-not-double-quote-or-new-line-conc?-possibilities
 (b*
  ((number
      (cst-character-not-double-quote-or-new-line-conc? abnf::cst)))
  (or (equal number 1) (equal number 2)))
 :rule-classes
 ((:forward-chaining
   :trigger-terms
   ((cst-character-not-double-quote-or-new-line-conc? abnf::cst)))))

Theorem: cst-character-not-double-quote-or-new-line-conc?-of-tree-fix-cst

(defthm
   cst-character-not-double-quote-or-new-line-conc?-of-tree-fix-cst
 (equal
      (cst-character-not-double-quote-or-new-line-conc?
           (abnf::tree-fix abnf::cst))
      (cst-character-not-double-quote-or-new-line-conc? abnf::cst)))

Theorem: cst-character-not-double-quote-or-new-line-conc?-tree-equiv-congruence-on-cst

(defthm
 cst-character-not-double-quote-or-new-line-conc?-tree-equiv-congruence-on-cst
 (implies
  (abnf::tree-equiv abnf::cst cst-equiv)
  (equal
      (cst-character-not-double-quote-or-new-line-conc? abnf::cst)
      (cst-character-not-double-quote-or-new-line-conc? cst-equiv)))
 :rule-classes :congruence)

Theorem: cst-character-not-double-quote-or-new-line-conc?-1-iff-match-conc

(defthm
  cst-character-not-double-quote-or-new-line-conc?-1-iff-match-conc
 (implies
  (cst-matchp abnf::cst
              "character-not-double-quote-or-new-line")
  (iff
   (equal
        (cst-character-not-double-quote-or-new-line-conc? abnf::cst)
        1)
   (cst-list-list-conc-matchp
        (abnf::tree-nonleaf->branches abnf::cst)
        "basic-character-not-double-quote"))))

Theorem: cst-character-not-double-quote-or-new-line-conc?-2-iff-match-conc

(defthm
  cst-character-not-double-quote-or-new-line-conc?-2-iff-match-conc
 (implies
  (cst-matchp abnf::cst
              "character-not-double-quote-or-new-line")
  (iff
   (equal
        (cst-character-not-double-quote-or-new-line-conc? abnf::cst)
        2)
   (cst-list-list-conc-matchp
        (abnf::tree-nonleaf->branches abnf::cst)
        "extended-character-not-new-line"))))

Function: cst-character-not-single-quote-or-backslash-or-new-line-conc?

(defun cst-character-not-single-quote-or-backslash-or-new-line-conc?
       (abnf::cst)
 (declare (xargs :guard (abnf::treep abnf::cst)))
 (declare
  (xargs
       :guard
       (cst-matchp
            abnf::cst
            "character-not-single-quote-or-backslash-or-new-line")))
 (let
  ((__function__
    'cst-character-not-single-quote-or-backslash-or-new-line-conc?))
  (declare (ignorable __function__))
  (cond
    ((equal
          (abnf::tree-nonleaf->rulename?
               (nth 0
                    (nth 0
                         (abnf::tree-nonleaf->branches abnf::cst))))
          (abnf::rulename
               "basic-character-not-single-quote-or-backslash"))
     1)
    ((equal
          (abnf::tree-nonleaf->rulename?
               (nth 0
                    (nth 0
                         (abnf::tree-nonleaf->branches abnf::cst))))
          (abnf::rulename "extended-character-not-new-line"))
     2)
    (t (prog2$ (impossible) 1)))))

Theorem: posp-of-cst-character-not-single-quote-or-backslash-or-new-line-conc?

(defthm
 posp-of-cst-character-not-single-quote-or-backslash-or-new-line-conc?
 (b* ((number (cst-character-not-single-quote-or-backslash-or-new-line-conc?
                   abnf::cst)))
   (posp number))
 :rule-classes :rewrite)

Theorem: cst-character-not-single-quote-or-backslash-or-new-line-conc?-possibilities

(defthm
 cst-character-not-single-quote-or-backslash-or-new-line-conc?-possibilities
 (b* ((number (cst-character-not-single-quote-or-backslash-or-new-line-conc?
                   abnf::cst)))
   (or (equal number 1) (equal number 2)))
 :rule-classes
 ((:forward-chaining :trigger-terms ((cst-character-not-single-quote-or-backslash-or-new-line-conc?
                                          abnf::cst)))))

Theorem: cst-character-not-single-quote-or-backslash-or-new-line-conc?-of-tree-fix-cst

(defthm
 cst-character-not-single-quote-or-backslash-or-new-line-conc?-of-tree-fix-cst
 (equal (cst-character-not-single-quote-or-backslash-or-new-line-conc?
             (abnf::tree-fix abnf::cst))
        (cst-character-not-single-quote-or-backslash-or-new-line-conc?
             abnf::cst)))

Theorem: cst-character-not-single-quote-or-backslash-or-new-line-conc?-tree-equiv-congruence-on-cst

(defthm
 cst-character-not-single-quote-or-backslash-or-new-line-conc?-tree-equiv-congruence-on-cst
 (implies (abnf::tree-equiv abnf::cst cst-equiv)
          (equal (cst-character-not-single-quote-or-backslash-or-new-line-conc?
                      abnf::cst)
                 (cst-character-not-single-quote-or-backslash-or-new-line-conc?
                      cst-equiv)))
 :rule-classes :congruence)

Theorem: cst-character-not-single-quote-or-backslash-or-new-line-conc?-1-iff-match-conc

(defthm
 cst-character-not-single-quote-or-backslash-or-new-line-conc?-1-iff-match-conc
 (implies
  (cst-matchp abnf::cst
              "character-not-single-quote-or-backslash-or-new-line")
  (iff (equal (cst-character-not-single-quote-or-backslash-or-new-line-conc?
                   abnf::cst)
              1)
       (cst-list-list-conc-matchp
            (abnf::tree-nonleaf->branches abnf::cst)
            "basic-character-not-single-quote-or-backslash"))))

Theorem: cst-character-not-single-quote-or-backslash-or-new-line-conc?-2-iff-match-conc

(defthm
 cst-character-not-single-quote-or-backslash-or-new-line-conc?-2-iff-match-conc
 (implies
  (cst-matchp abnf::cst
              "character-not-single-quote-or-backslash-or-new-line")
  (iff (equal (cst-character-not-single-quote-or-backslash-or-new-line-conc?
                   abnf::cst)
              2)
       (cst-list-list-conc-matchp
            (abnf::tree-nonleaf->branches abnf::cst)
            "extended-character-not-new-line"))))

Function: cst-character-not-double-quote-or-backslash-or-new-line-conc?

(defun cst-character-not-double-quote-or-backslash-or-new-line-conc?
       (abnf::cst)
 (declare (xargs :guard (abnf::treep abnf::cst)))
 (declare
  (xargs
       :guard
       (cst-matchp
            abnf::cst
            "character-not-double-quote-or-backslash-or-new-line")))
 (let
  ((__function__
    'cst-character-not-double-quote-or-backslash-or-new-line-conc?))
  (declare (ignorable __function__))
  (cond
    ((equal
          (abnf::tree-nonleaf->rulename?
               (nth 0
                    (nth 0
                         (abnf::tree-nonleaf->branches abnf::cst))))
          (abnf::rulename
               "basic-character-not-double-quote-or-backslash"))
     1)
    ((equal
          (abnf::tree-nonleaf->rulename?
               (nth 0
                    (nth 0
                         (abnf::tree-nonleaf->branches abnf::cst))))
          (abnf::rulename "extended-character-not-new-line"))
     2)
    (t (prog2$ (impossible) 1)))))

Theorem: posp-of-cst-character-not-double-quote-or-backslash-or-new-line-conc?

(defthm
 posp-of-cst-character-not-double-quote-or-backslash-or-new-line-conc?
 (b* ((number (cst-character-not-double-quote-or-backslash-or-new-line-conc?
                   abnf::cst)))
   (posp number))
 :rule-classes :rewrite)

Theorem: cst-character-not-double-quote-or-backslash-or-new-line-conc?-possibilities

(defthm
 cst-character-not-double-quote-or-backslash-or-new-line-conc?-possibilities
 (b* ((number (cst-character-not-double-quote-or-backslash-or-new-line-conc?
                   abnf::cst)))
   (or (equal number 1) (equal number 2)))
 :rule-classes
 ((:forward-chaining :trigger-terms ((cst-character-not-double-quote-or-backslash-or-new-line-conc?
                                          abnf::cst)))))

Theorem: cst-character-not-double-quote-or-backslash-or-new-line-conc?-of-tree-fix-cst

(defthm
 cst-character-not-double-quote-or-backslash-or-new-line-conc?-of-tree-fix-cst
 (equal (cst-character-not-double-quote-or-backslash-or-new-line-conc?
             (abnf::tree-fix abnf::cst))
        (cst-character-not-double-quote-or-backslash-or-new-line-conc?
             abnf::cst)))

Theorem: cst-character-not-double-quote-or-backslash-or-new-line-conc?-tree-equiv-congruence-on-cst

(defthm
 cst-character-not-double-quote-or-backslash-or-new-line-conc?-tree-equiv-congruence-on-cst
 (implies (abnf::tree-equiv abnf::cst cst-equiv)
          (equal (cst-character-not-double-quote-or-backslash-or-new-line-conc?
                      abnf::cst)
                 (cst-character-not-double-quote-or-backslash-or-new-line-conc?
                      cst-equiv)))
 :rule-classes :congruence)

Theorem: cst-character-not-double-quote-or-backslash-or-new-line-conc?-1-iff-match-conc

(defthm
 cst-character-not-double-quote-or-backslash-or-new-line-conc?-1-iff-match-conc
 (implies
  (cst-matchp abnf::cst
              "character-not-double-quote-or-backslash-or-new-line")
  (iff (equal (cst-character-not-double-quote-or-backslash-or-new-line-conc?
                   abnf::cst)
              1)
       (cst-list-list-conc-matchp
            (abnf::tree-nonleaf->branches abnf::cst)
            "basic-character-not-double-quote-or-backslash"))))

Theorem: cst-character-not-double-quote-or-backslash-or-new-line-conc?-2-iff-match-conc

(defthm
 cst-character-not-double-quote-or-backslash-or-new-line-conc?-2-iff-match-conc
 (implies
  (cst-matchp abnf::cst
              "character-not-double-quote-or-backslash-or-new-line")
  (iff (equal (cst-character-not-double-quote-or-backslash-or-new-line-conc?
                   abnf::cst)
              2)
       (cst-list-list-conc-matchp
            (abnf::tree-nonleaf->branches abnf::cst)
            "extended-character-not-new-line"))))

Function: cst-white-space-conc?

(defun cst-white-space-conc? (abnf::cst)
 (declare (xargs :guard (abnf::treep abnf::cst)))
 (declare (xargs :guard (cst-matchp abnf::cst "white-space")))
 (let ((__function__ 'cst-white-space-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 "vertical-tab"))
     3)
    ((equal
          (abnf::tree-nonleaf->rulename?
               (nth 0
                    (nth 0
                         (abnf::tree-nonleaf->branches abnf::cst))))
          (abnf::rulename "form-feed"))
     4)
    ((equal
          (abnf::tree-nonleaf->rulename?
               (nth 0
                    (nth 0
                         (abnf::tree-nonleaf->branches abnf::cst))))
          (abnf::rulename "new-line"))
     5)
    (t (prog2$ (impossible) 1)))))

Theorem: posp-of-cst-white-space-conc?

(defthm posp-of-cst-white-space-conc?
  (b* ((number (cst-white-space-conc? abnf::cst)))
    (posp number))
  :rule-classes :rewrite)

Theorem: cst-white-space-conc?-possibilities

(defthm cst-white-space-conc?-possibilities
  (b* ((number (cst-white-space-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-white-space-conc? abnf::cst)))))

Theorem: cst-white-space-conc?-of-tree-fix-cst

(defthm cst-white-space-conc?-of-tree-fix-cst
  (equal (cst-white-space-conc? (abnf::tree-fix abnf::cst))
         (cst-white-space-conc? abnf::cst)))

Theorem: cst-white-space-conc?-tree-equiv-congruence-on-cst

(defthm cst-white-space-conc?-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-white-space-conc? abnf::cst)
                  (cst-white-space-conc? cst-equiv)))
  :rule-classes :congruence)

Theorem: cst-white-space-conc?-1-iff-match-conc

(defthm cst-white-space-conc?-1-iff-match-conc
  (implies (cst-matchp abnf::cst "white-space")
           (iff (equal (cst-white-space-conc? abnf::cst)
                       1)
                (cst-list-list-conc-matchp
                     (abnf::tree-nonleaf->branches abnf::cst)
                     "space"))))

Theorem: cst-white-space-conc?-2-iff-match-conc

(defthm cst-white-space-conc?-2-iff-match-conc
  (implies (cst-matchp abnf::cst "white-space")
           (iff (equal (cst-white-space-conc? abnf::cst)
                       2)
                (cst-list-list-conc-matchp
                     (abnf::tree-nonleaf->branches abnf::cst)
                     "horizontal-tab"))))

Theorem: cst-white-space-conc?-3-iff-match-conc

(defthm cst-white-space-conc?-3-iff-match-conc
  (implies (cst-matchp abnf::cst "white-space")
           (iff (equal (cst-white-space-conc? abnf::cst)
                       3)
                (cst-list-list-conc-matchp
                     (abnf::tree-nonleaf->branches abnf::cst)
                     "vertical-tab"))))

Theorem: cst-white-space-conc?-4-iff-match-conc

(defthm cst-white-space-conc?-4-iff-match-conc
  (implies (cst-matchp abnf::cst "white-space")
           (iff (equal (cst-white-space-conc? abnf::cst)
                       4)
                (cst-list-list-conc-matchp
                     (abnf::tree-nonleaf->branches abnf::cst)
                     "form-feed"))))

Theorem: cst-white-space-conc?-5-iff-match-conc

(defthm cst-white-space-conc?-5-iff-match-conc
  (implies (cst-matchp abnf::cst "white-space")
           (iff (equal (cst-white-space-conc? abnf::cst)
                       5)
                (cst-list-list-conc-matchp
                     (abnf::tree-nonleaf->branches abnf::cst)
                     "new-line"))))

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-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 "constant"))
     3)
    ((equal
          (abnf::tree-nonleaf->rulename?
               (nth 0
                    (nth 0
                         (abnf::tree-nonleaf->branches abnf::cst))))
          (abnf::rulename "string-literal"))
     4)
    ((equal
          (abnf::tree-nonleaf->rulename?
               (nth 0
                    (nth 0
                         (abnf::tree-nonleaf->branches abnf::cst))))
          (abnf::rulename "punctuator"))
     5)
    (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)))
 :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)
                     "constant"))))

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)
                     "string-literal"))))

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)
                     "punctuator"))))

Function: cst-preprocessing-token-conc?

(defun cst-preprocessing-token-conc? (abnf::cst)
 (declare (xargs :guard (abnf::treep abnf::cst)))
 (declare
      (xargs :guard (cst-matchp abnf::cst "preprocessing-token")))
 (let ((__function__ 'cst-preprocessing-token-conc?))
  (declare (ignorable __function__))
  (cond
    ((equal
          (abnf::tree-nonleaf->rulename?
               (nth 0
                    (nth 0
                         (abnf::tree-nonleaf->branches abnf::cst))))
          (abnf::rulename "header-name"))
     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 "pp-number"))
     3)
    ((equal
          (abnf::tree-nonleaf->rulename?
               (nth 0
                    (nth 0
                         (abnf::tree-nonleaf->branches abnf::cst))))
          (abnf::rulename "character-constant"))
     4)
    ((equal
          (abnf::tree-nonleaf->rulename?
               (nth 0
                    (nth 0
                         (abnf::tree-nonleaf->branches abnf::cst))))
          (abnf::rulename "string-literal"))
     5)
    ((equal
          (abnf::tree-nonleaf->rulename?
               (nth 0
                    (nth 0
                         (abnf::tree-nonleaf->branches abnf::cst))))
          (abnf::rulename "punctuator"))
     6)
    ((equal
          (abnf::tree-nonleaf->rulename?
               (nth 0
                    (nth 0
                         (abnf::tree-nonleaf->branches abnf::cst))))
          (abnf::rulename "character"))
     7)
    (t (prog2$ (impossible) 1)))))

Theorem: posp-of-cst-preprocessing-token-conc?

(defthm posp-of-cst-preprocessing-token-conc?
  (b* ((number (cst-preprocessing-token-conc? abnf::cst)))
    (posp number))
  :rule-classes :rewrite)

Theorem: cst-preprocessing-token-conc?-possibilities

(defthm cst-preprocessing-token-conc?-possibilities
 (b* ((number (cst-preprocessing-token-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-preprocessing-token-conc? abnf::cst)))))

Theorem: cst-preprocessing-token-conc?-of-tree-fix-cst

(defthm cst-preprocessing-token-conc?-of-tree-fix-cst
  (equal (cst-preprocessing-token-conc? (abnf::tree-fix abnf::cst))
         (cst-preprocessing-token-conc? abnf::cst)))

Theorem: cst-preprocessing-token-conc?-tree-equiv-congruence-on-cst

(defthm cst-preprocessing-token-conc?-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-preprocessing-token-conc? abnf::cst)
                  (cst-preprocessing-token-conc? cst-equiv)))
  :rule-classes :congruence)

Theorem: cst-preprocessing-token-conc?-1-iff-match-conc

(defthm cst-preprocessing-token-conc?-1-iff-match-conc
  (implies (cst-matchp abnf::cst "preprocessing-token")
           (iff (equal (cst-preprocessing-token-conc? abnf::cst)
                       1)
                (cst-list-list-conc-matchp
                     (abnf::tree-nonleaf->branches abnf::cst)
                     "header-name"))))

Theorem: cst-preprocessing-token-conc?-2-iff-match-conc

(defthm cst-preprocessing-token-conc?-2-iff-match-conc
  (implies (cst-matchp abnf::cst "preprocessing-token")
           (iff (equal (cst-preprocessing-token-conc? abnf::cst)
                       2)
                (cst-list-list-conc-matchp
                     (abnf::tree-nonleaf->branches abnf::cst)
                     "identifier"))))

Theorem: cst-preprocessing-token-conc?-3-iff-match-conc

(defthm cst-preprocessing-token-conc?-3-iff-match-conc
  (implies (cst-matchp abnf::cst "preprocessing-token")
           (iff (equal (cst-preprocessing-token-conc? abnf::cst)
                       3)
                (cst-list-list-conc-matchp
                     (abnf::tree-nonleaf->branches abnf::cst)
                     "pp-number"))))

Theorem: cst-preprocessing-token-conc?-4-iff-match-conc

(defthm cst-preprocessing-token-conc?-4-iff-match-conc
  (implies (cst-matchp abnf::cst "preprocessing-token")
           (iff (equal (cst-preprocessing-token-conc? abnf::cst)
                       4)
                (cst-list-list-conc-matchp
                     (abnf::tree-nonleaf->branches abnf::cst)
                     "character-constant"))))

Theorem: cst-preprocessing-token-conc?-5-iff-match-conc

(defthm cst-preprocessing-token-conc?-5-iff-match-conc
  (implies (cst-matchp abnf::cst "preprocessing-token")
           (iff (equal (cst-preprocessing-token-conc? abnf::cst)
                       5)
                (cst-list-list-conc-matchp
                     (abnf::tree-nonleaf->branches abnf::cst)
                     "string-literal"))))

Theorem: cst-preprocessing-token-conc?-6-iff-match-conc

(defthm cst-preprocessing-token-conc?-6-iff-match-conc
  (implies (cst-matchp abnf::cst "preprocessing-token")
           (iff (equal (cst-preprocessing-token-conc? abnf::cst)
                       6)
                (cst-list-list-conc-matchp
                     (abnf::tree-nonleaf->branches abnf::cst)
                     "punctuator"))))

Theorem: cst-preprocessing-token-conc?-7-iff-match-conc

(defthm cst-preprocessing-token-conc?-7-iff-match-conc
  (implies (cst-matchp abnf::cst "preprocessing-token")
           (iff (equal (cst-preprocessing-token-conc? abnf::cst)
                       7)
                (cst-list-list-conc-matchp
                     (abnf::tree-nonleaf->branches abnf::cst)
                     "character"))))

Function: cst-constant-conc?

(defun cst-constant-conc? (abnf::cst)
 (declare (xargs :guard (abnf::treep abnf::cst)))
 (declare (xargs :guard (cst-matchp abnf::cst "constant")))
 (let ((__function__ 'cst-constant-conc?))
  (declare (ignorable __function__))
  (cond
    ((equal
          (abnf::tree-nonleaf->rulename?
               (nth 0
                    (nth 0
                         (abnf::tree-nonleaf->branches abnf::cst))))
          (abnf::rulename "integer-constant"))
     1)
    ((equal
          (abnf::tree-nonleaf->rulename?
               (nth 0
                    (nth 0
                         (abnf::tree-nonleaf->branches abnf::cst))))
          (abnf::rulename "floating-constant"))
     2)
    ((equal
          (abnf::tree-nonleaf->rulename?
               (nth 0
                    (nth 0
                         (abnf::tree-nonleaf->branches abnf::cst))))
          (abnf::rulename "enumeration-constant"))
     3)
    ((equal
          (abnf::tree-nonleaf->rulename?
               (nth 0
                    (nth 0
                         (abnf::tree-nonleaf->branches abnf::cst))))
          (abnf::rulename "character-constant"))
     4)
    (t (prog2$ (impossible) 1)))))

Theorem: posp-of-cst-constant-conc?

(defthm posp-of-cst-constant-conc?
  (b* ((number (cst-constant-conc? abnf::cst)))
    (posp number))
  :rule-classes :rewrite)

Theorem: cst-constant-conc?-possibilities

(defthm cst-constant-conc?-possibilities
  (b* ((number (cst-constant-conc? abnf::cst)))
    (or (equal number 1)
        (equal number 2)
        (equal number 3)
        (equal number 4)))
  :rule-classes
  ((:forward-chaining
        :trigger-terms ((cst-constant-conc? abnf::cst)))))

Theorem: cst-constant-conc?-of-tree-fix-cst

(defthm cst-constant-conc?-of-tree-fix-cst
  (equal (cst-constant-conc? (abnf::tree-fix abnf::cst))
         (cst-constant-conc? abnf::cst)))

Theorem: cst-constant-conc?-tree-equiv-congruence-on-cst

(defthm cst-constant-conc?-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-constant-conc? abnf::cst)
                  (cst-constant-conc? cst-equiv)))
  :rule-classes :congruence)

Theorem: cst-constant-conc?-1-iff-match-conc

(defthm cst-constant-conc?-1-iff-match-conc
  (implies (cst-matchp abnf::cst "constant")
           (iff (equal (cst-constant-conc? abnf::cst) 1)
                (cst-list-list-conc-matchp
                     (abnf::tree-nonleaf->branches abnf::cst)
                     "integer-constant"))))

Theorem: cst-constant-conc?-2-iff-match-conc

(defthm cst-constant-conc?-2-iff-match-conc
  (implies (cst-matchp abnf::cst "constant")
           (iff (equal (cst-constant-conc? abnf::cst) 2)
                (cst-list-list-conc-matchp
                     (abnf::tree-nonleaf->branches abnf::cst)
                     "floating-constant"))))

Theorem: cst-constant-conc?-3-iff-match-conc

(defthm cst-constant-conc?-3-iff-match-conc
  (implies (cst-matchp abnf::cst "constant")
           (iff (equal (cst-constant-conc? abnf::cst) 3)
                (cst-list-list-conc-matchp
                     (abnf::tree-nonleaf->branches abnf::cst)
                     "enumeration-constant"))))

Theorem: cst-constant-conc?-4-iff-match-conc

(defthm cst-constant-conc?-4-iff-match-conc
  (implies (cst-matchp abnf::cst "constant")
           (iff (equal (cst-constant-conc? abnf::cst) 4)
                (cst-list-list-conc-matchp
                     (abnf::tree-nonleaf->branches abnf::cst)
                     "character-constant"))))

Function: cst-floating-constant-conc?

(defun cst-floating-constant-conc? (abnf::cst)
 (declare (xargs :guard (abnf::treep abnf::cst)))
 (declare (xargs :guard (cst-matchp abnf::cst "floating-constant")))
 (let ((__function__ 'cst-floating-constant-conc?))
  (declare (ignorable __function__))
  (cond
    ((equal
          (abnf::tree-nonleaf->rulename?
               (nth 0
                    (nth 0
                         (abnf::tree-nonleaf->branches abnf::cst))))
          (abnf::rulename "decimal-floating-constant"))
     1)
    ((equal
          (abnf::tree-nonleaf->rulename?
               (nth 0
                    (nth 0
                         (abnf::tree-nonleaf->branches abnf::cst))))
          (abnf::rulename "hexadecimal-floating-constant"))
     2)
    (t (prog2$ (impossible) 1)))))

Theorem: posp-of-cst-floating-constant-conc?

(defthm posp-of-cst-floating-constant-conc?
  (b* ((number (cst-floating-constant-conc? abnf::cst)))
    (posp number))
  :rule-classes :rewrite)

Theorem: cst-floating-constant-conc?-possibilities

(defthm cst-floating-constant-conc?-possibilities
  (b* ((number (cst-floating-constant-conc? abnf::cst)))
    (or (equal number 1) (equal number 2)))
  :rule-classes
  ((:forward-chaining
        :trigger-terms ((cst-floating-constant-conc? abnf::cst)))))

Theorem: cst-floating-constant-conc?-of-tree-fix-cst

(defthm cst-floating-constant-conc?-of-tree-fix-cst
  (equal (cst-floating-constant-conc? (abnf::tree-fix abnf::cst))
         (cst-floating-constant-conc? abnf::cst)))

Theorem: cst-floating-constant-conc?-tree-equiv-congruence-on-cst

(defthm cst-floating-constant-conc?-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-floating-constant-conc? abnf::cst)
                  (cst-floating-constant-conc? cst-equiv)))
  :rule-classes :congruence)

Theorem: cst-floating-constant-conc?-1-iff-match-conc

(defthm cst-floating-constant-conc?-1-iff-match-conc
  (implies (cst-matchp abnf::cst "floating-constant")
           (iff (equal (cst-floating-constant-conc? abnf::cst)
                       1)
                (cst-list-list-conc-matchp
                     (abnf::tree-nonleaf->branches abnf::cst)
                     "decimal-floating-constant"))))

Theorem: cst-floating-constant-conc?-2-iff-match-conc

(defthm cst-floating-constant-conc?-2-iff-match-conc
  (implies (cst-matchp abnf::cst "floating-constant")
           (iff (equal (cst-floating-constant-conc? abnf::cst)
                       2)
                (cst-list-list-conc-matchp
                     (abnf::tree-nonleaf->branches abnf::cst)
                     "hexadecimal-floating-constant"))))

Function: cst-c-char-conc?

(defun cst-c-char-conc? (abnf::cst)
 (declare (xargs :guard (abnf::treep abnf::cst)))
 (declare (xargs :guard (cst-matchp abnf::cst "c-char")))
 (let ((__function__ 'cst-c-char-conc?))
  (declare (ignorable __function__))
  (cond
   ((equal
        (abnf::tree-nonleaf->rulename?
             (nth 0
                  (nth 0
                       (abnf::tree-nonleaf->branches abnf::cst))))
        (abnf::rulename
             "character-not-single-quote-or-backslash-or-new-line"))
    1)
   ((equal
         (abnf::tree-nonleaf->rulename?
              (nth 0
                   (nth 0
                        (abnf::tree-nonleaf->branches abnf::cst))))
         (abnf::rulename "escape-sequence"))
    2)
   (t (prog2$ (impossible) 1)))))

Theorem: posp-of-cst-c-char-conc?

(defthm posp-of-cst-c-char-conc?
  (b* ((number (cst-c-char-conc? abnf::cst)))
    (posp number))
  :rule-classes :rewrite)

Theorem: cst-c-char-conc?-possibilities

(defthm cst-c-char-conc?-possibilities
  (b* ((number (cst-c-char-conc? abnf::cst)))
    (or (equal number 1) (equal number 2)))
  :rule-classes
  ((:forward-chaining
        :trigger-terms ((cst-c-char-conc? abnf::cst)))))

Theorem: cst-c-char-conc?-of-tree-fix-cst

(defthm cst-c-char-conc?-of-tree-fix-cst
  (equal (cst-c-char-conc? (abnf::tree-fix abnf::cst))
         (cst-c-char-conc? abnf::cst)))

Theorem: cst-c-char-conc?-tree-equiv-congruence-on-cst

(defthm cst-c-char-conc?-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-c-char-conc? abnf::cst)
                  (cst-c-char-conc? cst-equiv)))
  :rule-classes :congruence)

Theorem: cst-c-char-conc?-1-iff-match-conc

(defthm cst-c-char-conc?-1-iff-match-conc
 (implies
  (cst-matchp abnf::cst "c-char")
  (iff
      (equal (cst-c-char-conc? abnf::cst) 1)
      (cst-list-list-conc-matchp
           (abnf::tree-nonleaf->branches abnf::cst)
           "character-not-single-quote-or-backslash-or-new-line"))))

Theorem: cst-c-char-conc?-2-iff-match-conc

(defthm cst-c-char-conc?-2-iff-match-conc
  (implies (cst-matchp abnf::cst "c-char")
           (iff (equal (cst-c-char-conc? abnf::cst) 2)
                (cst-list-list-conc-matchp
                     (abnf::tree-nonleaf->branches abnf::cst)
                     "escape-sequence"))))

Function: cst-escape-sequence-conc?

(defun cst-escape-sequence-conc? (abnf::cst)
 (declare (xargs :guard (abnf::treep abnf::cst)))
 (declare (xargs :guard (cst-matchp abnf::cst "escape-sequence")))
 (let ((__function__ 'cst-escape-sequence-conc?))
  (declare (ignorable __function__))
  (cond
    ((equal
          (abnf::tree-nonleaf->rulename?
               (nth 0
                    (nth 0
                         (abnf::tree-nonleaf->branches abnf::cst))))
          (abnf::rulename "simple-escape-sequence"))
     1)
    ((equal
          (abnf::tree-nonleaf->rulename?
               (nth 0
                    (nth 0
                         (abnf::tree-nonleaf->branches abnf::cst))))
          (abnf::rulename "octal-escape-sequence"))
     2)
    ((equal
          (abnf::tree-nonleaf->rulename?
               (nth 0
                    (nth 0
                         (abnf::tree-nonleaf->branches abnf::cst))))
          (abnf::rulename "hexadecimal-escape-sequence"))
     3)
    ((equal
          (abnf::tree-nonleaf->rulename?
               (nth 0
                    (nth 0
                         (abnf::tree-nonleaf->branches abnf::cst))))
          (abnf::rulename "universal-character-name"))
     4)
    (t (prog2$ (impossible) 1)))))

Theorem: posp-of-cst-escape-sequence-conc?

(defthm posp-of-cst-escape-sequence-conc?
  (b* ((number (cst-escape-sequence-conc? abnf::cst)))
    (posp number))
  :rule-classes :rewrite)

Theorem: cst-escape-sequence-conc?-possibilities

(defthm cst-escape-sequence-conc?-possibilities
  (b* ((number (cst-escape-sequence-conc? abnf::cst)))
    (or (equal number 1)
        (equal number 2)
        (equal number 3)
        (equal number 4)))
  :rule-classes
  ((:forward-chaining
        :trigger-terms ((cst-escape-sequence-conc? abnf::cst)))))

Theorem: cst-escape-sequence-conc?-of-tree-fix-cst

(defthm cst-escape-sequence-conc?-of-tree-fix-cst
  (equal (cst-escape-sequence-conc? (abnf::tree-fix abnf::cst))
         (cst-escape-sequence-conc? abnf::cst)))

Theorem: cst-escape-sequence-conc?-tree-equiv-congruence-on-cst

(defthm cst-escape-sequence-conc?-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-escape-sequence-conc? abnf::cst)
                  (cst-escape-sequence-conc? cst-equiv)))
  :rule-classes :congruence)

Theorem: cst-escape-sequence-conc?-1-iff-match-conc

(defthm cst-escape-sequence-conc?-1-iff-match-conc
  (implies (cst-matchp abnf::cst "escape-sequence")
           (iff (equal (cst-escape-sequence-conc? abnf::cst)
                       1)
                (cst-list-list-conc-matchp
                     (abnf::tree-nonleaf->branches abnf::cst)
                     "simple-escape-sequence"))))

Theorem: cst-escape-sequence-conc?-2-iff-match-conc

(defthm cst-escape-sequence-conc?-2-iff-match-conc
  (implies (cst-matchp abnf::cst "escape-sequence")
           (iff (equal (cst-escape-sequence-conc? abnf::cst)
                       2)
                (cst-list-list-conc-matchp
                     (abnf::tree-nonleaf->branches abnf::cst)
                     "octal-escape-sequence"))))

Theorem: cst-escape-sequence-conc?-3-iff-match-conc

(defthm cst-escape-sequence-conc?-3-iff-match-conc
  (implies (cst-matchp abnf::cst "escape-sequence")
           (iff (equal (cst-escape-sequence-conc? abnf::cst)
                       3)
                (cst-list-list-conc-matchp
                     (abnf::tree-nonleaf->branches abnf::cst)
                     "hexadecimal-escape-sequence"))))

Theorem: cst-escape-sequence-conc?-4-iff-match-conc

(defthm cst-escape-sequence-conc?-4-iff-match-conc
  (implies (cst-matchp abnf::cst "escape-sequence")
           (iff (equal (cst-escape-sequence-conc? abnf::cst)
                       4)
                (cst-list-list-conc-matchp
                     (abnf::tree-nonleaf->branches abnf::cst)
                     "universal-character-name"))))

Function: cst-s-char-conc?

(defun cst-s-char-conc? (abnf::cst)
 (declare (xargs :guard (abnf::treep abnf::cst)))
 (declare (xargs :guard (cst-matchp abnf::cst "s-char")))
 (let ((__function__ 'cst-s-char-conc?))
  (declare (ignorable __function__))
  (cond
   ((equal
        (abnf::tree-nonleaf->rulename?
             (nth 0
                  (nth 0
                       (abnf::tree-nonleaf->branches abnf::cst))))
        (abnf::rulename
             "character-not-double-quote-or-backslash-or-new-line"))
    1)
   ((equal
         (abnf::tree-nonleaf->rulename?
              (nth 0
                   (nth 0
                        (abnf::tree-nonleaf->branches abnf::cst))))
         (abnf::rulename "escape-sequence"))
    2)
   (t (prog2$ (impossible) 1)))))

Theorem: posp-of-cst-s-char-conc?

(defthm posp-of-cst-s-char-conc?
  (b* ((number (cst-s-char-conc? abnf::cst)))
    (posp number))
  :rule-classes :rewrite)

Theorem: cst-s-char-conc?-possibilities

(defthm cst-s-char-conc?-possibilities
  (b* ((number (cst-s-char-conc? abnf::cst)))
    (or (equal number 1) (equal number 2)))
  :rule-classes
  ((:forward-chaining
        :trigger-terms ((cst-s-char-conc? abnf::cst)))))

Theorem: cst-s-char-conc?-of-tree-fix-cst

(defthm cst-s-char-conc?-of-tree-fix-cst
  (equal (cst-s-char-conc? (abnf::tree-fix abnf::cst))
         (cst-s-char-conc? abnf::cst)))

Theorem: cst-s-char-conc?-tree-equiv-congruence-on-cst

(defthm cst-s-char-conc?-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-s-char-conc? abnf::cst)
                  (cst-s-char-conc? cst-equiv)))
  :rule-classes :congruence)

Theorem: cst-s-char-conc?-1-iff-match-conc

(defthm cst-s-char-conc?-1-iff-match-conc
 (implies
  (cst-matchp abnf::cst "s-char")
  (iff
      (equal (cst-s-char-conc? abnf::cst) 1)
      (cst-list-list-conc-matchp
           (abnf::tree-nonleaf->branches abnf::cst)
           "character-not-double-quote-or-backslash-or-new-line"))))

Theorem: cst-s-char-conc?-2-iff-match-conc

(defthm cst-s-char-conc?-2-iff-match-conc
  (implies (cst-matchp abnf::cst "s-char")
           (iff (equal (cst-s-char-conc? abnf::cst) 2)
                (cst-list-list-conc-matchp
                     (abnf::tree-nonleaf->branches abnf::cst)
                     "escape-sequence"))))

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 "control-line"))
     3)
    ((equal
          (abnf::tree-nonleaf->rulename?
               (nth 0
                    (nth 0
                         (abnf::tree-nonleaf->branches abnf::cst))))
          (abnf::rulename "white-space"))
     4)
    (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)
        (equal number 4)))
  :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)
                     "control-line"))))

Theorem: cst-lexeme-conc?-4-iff-match-conc

(defthm cst-lexeme-conc?-4-iff-match-conc
  (implies (cst-matchp abnf::cst "lexeme")
           (iff (equal (cst-lexeme-conc? abnf::cst) 4)
                (cst-list-list-conc-matchp
                     (abnf::tree-nonleaf->branches abnf::cst)
                     "white-space"))))

Function: cst-attribute-name-conc?

(defun cst-attribute-name-conc? (abnf::cst)
 (declare (xargs :guard (abnf::treep abnf::cst)))
 (declare (xargs :guard (cst-matchp abnf::cst "attribute-name")))
 (let ((__function__ 'cst-attribute-name-conc?))
  (declare (ignorable __function__))
  (cond
    ((equal
          (abnf::tree-nonleaf->rulename?
               (nth 0
                    (nth 0
                         (abnf::tree-nonleaf->branches abnf::cst))))
          (abnf::rulename "identifier"))
     1)
    ((equal
          (abnf::tree-nonleaf->rulename?
               (nth 0
                    (nth 0
                         (abnf::tree-nonleaf->branches abnf::cst))))
          (abnf::rulename "keyword"))
     2)
    (t (prog2$ (impossible) 1)))))

Theorem: posp-of-cst-attribute-name-conc?

(defthm posp-of-cst-attribute-name-conc?
  (b* ((number (cst-attribute-name-conc? abnf::cst)))
    (posp number))
  :rule-classes :rewrite)

Theorem: cst-attribute-name-conc?-possibilities

(defthm cst-attribute-name-conc?-possibilities
  (b* ((number (cst-attribute-name-conc? abnf::cst)))
    (or (equal number 1) (equal number 2)))
  :rule-classes
  ((:forward-chaining
        :trigger-terms ((cst-attribute-name-conc? abnf::cst)))))

Theorem: cst-attribute-name-conc?-of-tree-fix-cst

(defthm cst-attribute-name-conc?-of-tree-fix-cst
  (equal (cst-attribute-name-conc? (abnf::tree-fix abnf::cst))
         (cst-attribute-name-conc? abnf::cst)))

Theorem: cst-attribute-name-conc?-tree-equiv-congruence-on-cst

(defthm cst-attribute-name-conc?-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-attribute-name-conc? abnf::cst)
                  (cst-attribute-name-conc? cst-equiv)))
  :rule-classes :congruence)

Theorem: cst-attribute-name-conc?-1-iff-match-conc

(defthm cst-attribute-name-conc?-1-iff-match-conc
  (implies (cst-matchp abnf::cst "attribute-name")
           (iff (equal (cst-attribute-name-conc? abnf::cst)
                       1)
                (cst-list-list-conc-matchp
                     (abnf::tree-nonleaf->branches abnf::cst)
                     "identifier"))))

Theorem: cst-attribute-name-conc?-2-iff-match-conc

(defthm cst-attribute-name-conc?-2-iff-match-conc
  (implies (cst-matchp abnf::cst "attribute-name")
           (iff (equal (cst-attribute-name-conc? abnf::cst)
                       2)
                (cst-list-list-conc-matchp
                     (abnf::tree-nonleaf->branches abnf::cst)
                     "keyword"))))

Function: cst-type-qualifier-or-attribute-specifier-conc?

(defun cst-type-qualifier-or-attribute-specifier-conc? (abnf::cst)
 (declare (xargs :guard (abnf::treep abnf::cst)))
 (declare
  (xargs
       :guard (cst-matchp abnf::cst
                          "type-qualifier-or-attribute-specifier")))
 (let
  ((__function__ 'cst-type-qualifier-or-attribute-specifier-conc?))
  (declare (ignorable __function__))
  (cond
    ((equal
          (abnf::tree-nonleaf->rulename?
               (nth 0
                    (nth 0
                         (abnf::tree-nonleaf->branches abnf::cst))))
          (abnf::rulename "type-qualifier"))
     1)
    ((equal
          (abnf::tree-nonleaf->rulename?
               (nth 0
                    (nth 0
                         (abnf::tree-nonleaf->branches abnf::cst))))
          (abnf::rulename "attribute-specifier"))
     2)
    (t (prog2$ (impossible) 1)))))

Theorem: posp-of-cst-type-qualifier-or-attribute-specifier-conc?

(defthm posp-of-cst-type-qualifier-or-attribute-specifier-conc?
 (b*
  ((number
       (cst-type-qualifier-or-attribute-specifier-conc? abnf::cst)))
  (posp number))
 :rule-classes :rewrite)

Theorem: cst-type-qualifier-or-attribute-specifier-conc?-possibilities

(defthm
      cst-type-qualifier-or-attribute-specifier-conc?-possibilities
 (b*
  ((number
       (cst-type-qualifier-or-attribute-specifier-conc? abnf::cst)))
  (or (equal number 1) (equal number 2)))
 :rule-classes
 ((:forward-chaining
    :trigger-terms
    ((cst-type-qualifier-or-attribute-specifier-conc? abnf::cst)))))

Theorem: cst-type-qualifier-or-attribute-specifier-conc?-of-tree-fix-cst

(defthm
    cst-type-qualifier-or-attribute-specifier-conc?-of-tree-fix-cst
  (equal
       (cst-type-qualifier-or-attribute-specifier-conc?
            (abnf::tree-fix abnf::cst))
       (cst-type-qualifier-or-attribute-specifier-conc? abnf::cst)))

Theorem: cst-type-qualifier-or-attribute-specifier-conc?-tree-equiv-congruence-on-cst

(defthm
 cst-type-qualifier-or-attribute-specifier-conc?-tree-equiv-congruence-on-cst
 (implies
  (abnf::tree-equiv abnf::cst cst-equiv)
  (equal
       (cst-type-qualifier-or-attribute-specifier-conc? abnf::cst)
       (cst-type-qualifier-or-attribute-specifier-conc? cst-equiv)))
 :rule-classes :congruence)

Theorem: cst-type-qualifier-or-attribute-specifier-conc?-1-iff-match-conc

(defthm
   cst-type-qualifier-or-attribute-specifier-conc?-1-iff-match-conc
 (implies
  (cst-matchp abnf::cst
              "type-qualifier-or-attribute-specifier")
  (iff
    (equal
         (cst-type-qualifier-or-attribute-specifier-conc? abnf::cst)
         1)
    (cst-list-list-conc-matchp
         (abnf::tree-nonleaf->branches abnf::cst)
         "type-qualifier"))))

Theorem: cst-type-qualifier-or-attribute-specifier-conc?-2-iff-match-conc

(defthm
   cst-type-qualifier-or-attribute-specifier-conc?-2-iff-match-conc
 (implies
  (cst-matchp abnf::cst
              "type-qualifier-or-attribute-specifier")
  (iff
    (equal
         (cst-type-qualifier-or-attribute-specifier-conc? abnf::cst)
         2)
    (cst-list-list-conc-matchp
         (abnf::tree-nonleaf->branches abnf::cst)
         "attribute-specifier"))))

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 "labeled-statement"))
     1)
    ((equal
          (abnf::tree-nonleaf->rulename?
               (nth 0
                    (nth 0
                         (abnf::tree-nonleaf->branches abnf::cst))))
          (abnf::rulename "compound-statement"))
     2)
    ((equal
          (abnf::tree-nonleaf->rulename?
               (nth 0
                    (nth 0
                         (abnf::tree-nonleaf->branches abnf::cst))))
          (abnf::rulename "expression-statement"))
     3)
    ((equal
          (abnf::tree-nonleaf->rulename?
               (nth 0
                    (nth 0
                         (abnf::tree-nonleaf->branches abnf::cst))))
          (abnf::rulename "selection-statement"))
     4)
    ((equal
          (abnf::tree-nonleaf->rulename?
               (nth 0
                    (nth 0
                         (abnf::tree-nonleaf->branches abnf::cst))))
          (abnf::rulename "iteration-statement"))
     5)
    ((equal
          (abnf::tree-nonleaf->rulename?
               (nth 0
                    (nth 0
                         (abnf::tree-nonleaf->branches abnf::cst))))
          (abnf::rulename "jump-statement"))
     6)
    ((equal
          (abnf::tree-nonleaf->rulename?
               (nth 0
                    (nth 0
                         (abnf::tree-nonleaf->branches abnf::cst))))
          (abnf::rulename "asm-statement"))
     7)
    (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)))
  :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)
                     "labeled-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)
                     "compound-statement"))))

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)
                     "expression-statement"))))

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)
                     "selection-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)
                     "iteration-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)
                     "jump-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)
                     "asm-statement"))))

Function: cst-block-item-conc?

(defun cst-block-item-conc? (abnf::cst)
 (declare (xargs :guard (abnf::treep abnf::cst)))
 (declare (xargs :guard (cst-matchp abnf::cst "block-item")))
 (let ((__function__ 'cst-block-item-conc?))
  (declare (ignorable __function__))
  (cond
    ((equal
          (abnf::tree-nonleaf->rulename?
               (nth 0
                    (nth 0
                         (abnf::tree-nonleaf->branches abnf::cst))))
          (abnf::rulename "declaration"))
     1)
    ((equal
          (abnf::tree-nonleaf->rulename?
               (nth 0
                    (nth 0
                         (abnf::tree-nonleaf->branches abnf::cst))))
          (abnf::rulename "statement"))
     2)
    (t (prog2$ (impossible) 1)))))

Theorem: posp-of-cst-block-item-conc?

(defthm posp-of-cst-block-item-conc?
  (b* ((number (cst-block-item-conc? abnf::cst)))
    (posp number))
  :rule-classes :rewrite)

Theorem: cst-block-item-conc?-possibilities

(defthm cst-block-item-conc?-possibilities
  (b* ((number (cst-block-item-conc? abnf::cst)))
    (or (equal number 1) (equal number 2)))
  :rule-classes
  ((:forward-chaining
        :trigger-terms ((cst-block-item-conc? abnf::cst)))))

Theorem: cst-block-item-conc?-of-tree-fix-cst

(defthm cst-block-item-conc?-of-tree-fix-cst
  (equal (cst-block-item-conc? (abnf::tree-fix abnf::cst))
         (cst-block-item-conc? abnf::cst)))

Theorem: cst-block-item-conc?-tree-equiv-congruence-on-cst

(defthm cst-block-item-conc?-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-block-item-conc? abnf::cst)
                  (cst-block-item-conc? cst-equiv)))
  :rule-classes :congruence)

Theorem: cst-block-item-conc?-1-iff-match-conc

(defthm cst-block-item-conc?-1-iff-match-conc
  (implies (cst-matchp abnf::cst "block-item")
           (iff (equal (cst-block-item-conc? abnf::cst)
                       1)
                (cst-list-list-conc-matchp
                     (abnf::tree-nonleaf->branches abnf::cst)
                     "declaration"))))

Theorem: cst-block-item-conc?-2-iff-match-conc

(defthm cst-block-item-conc?-2-iff-match-conc
  (implies (cst-matchp abnf::cst "block-item")
           (iff (equal (cst-block-item-conc? abnf::cst)
                       2)
                (cst-list-list-conc-matchp
                     (abnf::tree-nonleaf->branches abnf::cst)
                     "statement"))))

Function: cst-uppercase-letter-conc

(defun cst-uppercase-letter-conc (abnf::cst)
  (declare (xargs :guard (abnf::treep abnf::cst)))
  (declare (xargs :guard (cst-matchp abnf::cst "uppercase-letter")))
  (let ((__function__ 'cst-uppercase-letter-conc))
    (declare (ignorable __function__))
    (abnf::tree-nonleaf->branches abnf::cst)))

Theorem: tree-list-listp-of-cst-uppercase-letter-conc

(defthm tree-list-listp-of-cst-uppercase-letter-conc
  (b* ((abnf::cstss (cst-uppercase-letter-conc abnf::cst)))
    (abnf::tree-list-listp abnf::cstss))
  :rule-classes :rewrite)

Theorem: cst-uppercase-letter-conc-match

(defthm cst-uppercase-letter-conc-match
  (implies (cst-matchp abnf::cst "uppercase-letter")
           (b* ((abnf::cstss (cst-uppercase-letter-conc abnf::cst)))
             (cst-list-list-conc-matchp abnf::cstss "%x41-5A")))
  :rule-classes :rewrite)

Theorem: cst-uppercase-letter-conc-of-tree-fix-cst

(defthm cst-uppercase-letter-conc-of-tree-fix-cst
  (equal (cst-uppercase-letter-conc (abnf::tree-fix abnf::cst))
         (cst-uppercase-letter-conc abnf::cst)))

Theorem: cst-uppercase-letter-conc-tree-equiv-congruence-on-cst

(defthm cst-uppercase-letter-conc-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-uppercase-letter-conc abnf::cst)
                  (cst-uppercase-letter-conc cst-equiv)))
  :rule-classes :congruence)

Function: cst-lowercase-letter-conc

(defun cst-lowercase-letter-conc (abnf::cst)
  (declare (xargs :guard (abnf::treep abnf::cst)))
  (declare (xargs :guard (cst-matchp abnf::cst "lowercase-letter")))
  (let ((__function__ 'cst-lowercase-letter-conc))
    (declare (ignorable __function__))
    (abnf::tree-nonleaf->branches abnf::cst)))

Theorem: tree-list-listp-of-cst-lowercase-letter-conc

(defthm tree-list-listp-of-cst-lowercase-letter-conc
  (b* ((abnf::cstss (cst-lowercase-letter-conc abnf::cst)))
    (abnf::tree-list-listp abnf::cstss))
  :rule-classes :rewrite)

Theorem: cst-lowercase-letter-conc-match

(defthm cst-lowercase-letter-conc-match
  (implies (cst-matchp abnf::cst "lowercase-letter")
           (b* ((abnf::cstss (cst-lowercase-letter-conc abnf::cst)))
             (cst-list-list-conc-matchp abnf::cstss "%x61-7A")))
  :rule-classes :rewrite)

Theorem: cst-lowercase-letter-conc-of-tree-fix-cst

(defthm cst-lowercase-letter-conc-of-tree-fix-cst
  (equal (cst-lowercase-letter-conc (abnf::tree-fix abnf::cst))
         (cst-lowercase-letter-conc abnf::cst)))

Theorem: cst-lowercase-letter-conc-tree-equiv-congruence-on-cst

(defthm cst-lowercase-letter-conc-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-lowercase-letter-conc abnf::cst)
                  (cst-lowercase-letter-conc cst-equiv)))
  :rule-classes :congruence)

Function: cst-letter-conc1

(defun cst-letter-conc1 (abnf::cst)
  (declare (xargs :guard (abnf::treep abnf::cst)))
  (declare (xargs :guard (and (cst-matchp abnf::cst "letter")
                              (equal (cst-letter-conc? abnf::cst)
                                     1))))
  (let ((__function__ 'cst-letter-conc1))
    (declare (ignorable __function__))
    (abnf::tree-nonleaf->branches abnf::cst)))

Theorem: tree-list-listp-of-cst-letter-conc1

(defthm tree-list-listp-of-cst-letter-conc1
  (b* ((abnf::cstss (cst-letter-conc1 abnf::cst)))
    (abnf::tree-list-listp abnf::cstss))
  :rule-classes :rewrite)

Theorem: cst-letter-conc1-match

(defthm cst-letter-conc1-match
 (implies
      (and (cst-matchp abnf::cst "letter")
           (equal (cst-letter-conc? abnf::cst) 1))
      (b* ((abnf::cstss (cst-letter-conc1 abnf::cst)))
        (cst-list-list-conc-matchp abnf::cstss "uppercase-letter")))
 :rule-classes :rewrite)

Theorem: cst-letter-conc1-of-tree-fix-cst

(defthm cst-letter-conc1-of-tree-fix-cst
  (equal (cst-letter-conc1 (abnf::tree-fix abnf::cst))
         (cst-letter-conc1 abnf::cst)))

Theorem: cst-letter-conc1-tree-equiv-congruence-on-cst

(defthm cst-letter-conc1-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-letter-conc1 abnf::cst)
                  (cst-letter-conc1 cst-equiv)))
  :rule-classes :congruence)

Function: cst-letter-conc2

(defun cst-letter-conc2 (abnf::cst)
  (declare (xargs :guard (abnf::treep abnf::cst)))
  (declare (xargs :guard (and (cst-matchp abnf::cst "letter")
                              (equal (cst-letter-conc? abnf::cst)
                                     2))))
  (let ((__function__ 'cst-letter-conc2))
    (declare (ignorable __function__))
    (abnf::tree-nonleaf->branches abnf::cst)))

Theorem: tree-list-listp-of-cst-letter-conc2

(defthm tree-list-listp-of-cst-letter-conc2
  (b* ((abnf::cstss (cst-letter-conc2 abnf::cst)))
    (abnf::tree-list-listp abnf::cstss))
  :rule-classes :rewrite)

Theorem: cst-letter-conc2-match

(defthm cst-letter-conc2-match
 (implies
      (and (cst-matchp abnf::cst "letter")
           (equal (cst-letter-conc? abnf::cst) 2))
      (b* ((abnf::cstss (cst-letter-conc2 abnf::cst)))
        (cst-list-list-conc-matchp abnf::cstss "lowercase-letter")))
 :rule-classes :rewrite)

Theorem: cst-letter-conc2-of-tree-fix-cst

(defthm cst-letter-conc2-of-tree-fix-cst
  (equal (cst-letter-conc2 (abnf::tree-fix abnf::cst))
         (cst-letter-conc2 abnf::cst)))

Theorem: cst-letter-conc2-tree-equiv-congruence-on-cst

(defthm cst-letter-conc2-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-letter-conc2 abnf::cst)
                  (cst-letter-conc2 cst-equiv)))
  :rule-classes :congruence)

Function: cst-digit-conc

(defun cst-digit-conc (abnf::cst)
  (declare (xargs :guard (abnf::treep abnf::cst)))
  (declare (xargs :guard (cst-matchp abnf::cst "digit")))
  (let ((__function__ 'cst-digit-conc))
    (declare (ignorable __function__))
    (abnf::tree-nonleaf->branches abnf::cst)))

Theorem: tree-list-listp-of-cst-digit-conc

(defthm tree-list-listp-of-cst-digit-conc
  (b* ((abnf::cstss (cst-digit-conc abnf::cst)))
    (abnf::tree-list-listp abnf::cstss))
  :rule-classes :rewrite)

Theorem: cst-digit-conc-match

(defthm cst-digit-conc-match
  (implies (cst-matchp abnf::cst "digit")
           (b* ((abnf::cstss (cst-digit-conc abnf::cst)))
             (cst-list-list-conc-matchp abnf::cstss "%x30-39")))
  :rule-classes :rewrite)

Theorem: cst-digit-conc-of-tree-fix-cst

(defthm cst-digit-conc-of-tree-fix-cst
  (equal (cst-digit-conc (abnf::tree-fix abnf::cst))
         (cst-digit-conc abnf::cst)))

Theorem: cst-digit-conc-tree-equiv-congruence-on-cst

(defthm cst-digit-conc-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-digit-conc abnf::cst)
                  (cst-digit-conc cst-equiv)))
  :rule-classes :congruence)

Function: cst-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-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-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-vertical-tab-conc

(defun cst-vertical-tab-conc (abnf::cst)
  (declare (xargs :guard (abnf::treep abnf::cst)))
  (declare (xargs :guard (cst-matchp abnf::cst "vertical-tab")))
  (let ((__function__ 'cst-vertical-tab-conc))
    (declare (ignorable __function__))
    (abnf::tree-nonleaf->branches abnf::cst)))

Theorem: tree-list-listp-of-cst-vertical-tab-conc

(defthm tree-list-listp-of-cst-vertical-tab-conc
  (b* ((abnf::cstss (cst-vertical-tab-conc abnf::cst)))
    (abnf::tree-list-listp abnf::cstss))
  :rule-classes :rewrite)

Theorem: cst-vertical-tab-conc-match

(defthm cst-vertical-tab-conc-match
  (implies (cst-matchp abnf::cst "vertical-tab")
           (b* ((abnf::cstss (cst-vertical-tab-conc abnf::cst)))
             (cst-list-list-conc-matchp abnf::cstss "%xB")))
  :rule-classes :rewrite)

Theorem: cst-vertical-tab-conc-of-tree-fix-cst

(defthm cst-vertical-tab-conc-of-tree-fix-cst
  (equal (cst-vertical-tab-conc (abnf::tree-fix abnf::cst))
         (cst-vertical-tab-conc abnf::cst)))

Theorem: cst-vertical-tab-conc-tree-equiv-congruence-on-cst

(defthm cst-vertical-tab-conc-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-vertical-tab-conc abnf::cst)
                  (cst-vertical-tab-conc cst-equiv)))
  :rule-classes :congruence)

Function: cst-form-feed-conc

(defun cst-form-feed-conc (abnf::cst)
  (declare (xargs :guard (abnf::treep abnf::cst)))
  (declare (xargs :guard (cst-matchp abnf::cst "form-feed")))
  (let ((__function__ 'cst-form-feed-conc))
    (declare (ignorable __function__))
    (abnf::tree-nonleaf->branches abnf::cst)))

Theorem: tree-list-listp-of-cst-form-feed-conc

(defthm tree-list-listp-of-cst-form-feed-conc
  (b* ((abnf::cstss (cst-form-feed-conc abnf::cst)))
    (abnf::tree-list-listp abnf::cstss))
  :rule-classes :rewrite)

Theorem: cst-form-feed-conc-match

(defthm cst-form-feed-conc-match
  (implies (cst-matchp abnf::cst "form-feed")
           (b* ((abnf::cstss (cst-form-feed-conc abnf::cst)))
             (cst-list-list-conc-matchp abnf::cstss "%xC")))
  :rule-classes :rewrite)

Theorem: cst-form-feed-conc-of-tree-fix-cst

(defthm cst-form-feed-conc-of-tree-fix-cst
  (equal (cst-form-feed-conc (abnf::tree-fix abnf::cst))
         (cst-form-feed-conc abnf::cst)))

Theorem: cst-form-feed-conc-tree-equiv-congruence-on-cst

(defthm cst-form-feed-conc-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-form-feed-conc abnf::cst)
                  (cst-form-feed-conc cst-equiv)))
  :rule-classes :congruence)

Function: cst-control-character-conc1

(defun cst-control-character-conc1 (abnf::cst)
 (declare (xargs :guard (abnf::treep abnf::cst)))
 (declare
   (xargs :guard (and (cst-matchp abnf::cst "control-character")
                      (equal (cst-control-character-conc? abnf::cst)
                             1))))
 (let ((__function__ 'cst-control-character-conc1))
   (declare (ignorable __function__))
   (abnf::tree-nonleaf->branches abnf::cst)))

Theorem: tree-list-listp-of-cst-control-character-conc1

(defthm tree-list-listp-of-cst-control-character-conc1
  (b* ((abnf::cstss (cst-control-character-conc1 abnf::cst)))
    (abnf::tree-list-listp abnf::cstss))
  :rule-classes :rewrite)

Theorem: cst-control-character-conc1-match

(defthm cst-control-character-conc1-match
  (implies
       (and (cst-matchp abnf::cst "control-character")
            (equal (cst-control-character-conc? abnf::cst)
                   1))
       (b* ((abnf::cstss (cst-control-character-conc1 abnf::cst)))
         (cst-list-list-conc-matchp abnf::cstss "horizontal-tab")))
  :rule-classes :rewrite)

Theorem: cst-control-character-conc1-of-tree-fix-cst

(defthm cst-control-character-conc1-of-tree-fix-cst
  (equal (cst-control-character-conc1 (abnf::tree-fix abnf::cst))
         (cst-control-character-conc1 abnf::cst)))

Theorem: cst-control-character-conc1-tree-equiv-congruence-on-cst

(defthm cst-control-character-conc1-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-control-character-conc1 abnf::cst)
                  (cst-control-character-conc1 cst-equiv)))
  :rule-classes :congruence)

Function: cst-control-character-conc2

(defun cst-control-character-conc2 (abnf::cst)
 (declare (xargs :guard (abnf::treep abnf::cst)))
 (declare
   (xargs :guard (and (cst-matchp abnf::cst "control-character")
                      (equal (cst-control-character-conc? abnf::cst)
                             2))))
 (let ((__function__ 'cst-control-character-conc2))
   (declare (ignorable __function__))
   (abnf::tree-nonleaf->branches abnf::cst)))

Theorem: tree-list-listp-of-cst-control-character-conc2

(defthm tree-list-listp-of-cst-control-character-conc2
  (b* ((abnf::cstss (cst-control-character-conc2 abnf::cst)))
    (abnf::tree-list-listp abnf::cstss))
  :rule-classes :rewrite)

Theorem: cst-control-character-conc2-match

(defthm cst-control-character-conc2-match
  (implies
       (and (cst-matchp abnf::cst "control-character")
            (equal (cst-control-character-conc? abnf::cst)
                   2))
       (b* ((abnf::cstss (cst-control-character-conc2 abnf::cst)))
         (cst-list-list-conc-matchp abnf::cstss "vertical-tab")))
  :rule-classes :rewrite)

Theorem: cst-control-character-conc2-of-tree-fix-cst

(defthm cst-control-character-conc2-of-tree-fix-cst
  (equal (cst-control-character-conc2 (abnf::tree-fix abnf::cst))
         (cst-control-character-conc2 abnf::cst)))

Theorem: cst-control-character-conc2-tree-equiv-congruence-on-cst

(defthm cst-control-character-conc2-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-control-character-conc2 abnf::cst)
                  (cst-control-character-conc2 cst-equiv)))
  :rule-classes :congruence)

Function: cst-control-character-conc3

(defun cst-control-character-conc3 (abnf::cst)
 (declare (xargs :guard (abnf::treep abnf::cst)))
 (declare
   (xargs :guard (and (cst-matchp abnf::cst "control-character")
                      (equal (cst-control-character-conc? abnf::cst)
                             3))))
 (let ((__function__ 'cst-control-character-conc3))
   (declare (ignorable __function__))
   (abnf::tree-nonleaf->branches abnf::cst)))

Theorem: tree-list-listp-of-cst-control-character-conc3

(defthm tree-list-listp-of-cst-control-character-conc3
  (b* ((abnf::cstss (cst-control-character-conc3 abnf::cst)))
    (abnf::tree-list-listp abnf::cstss))
  :rule-classes :rewrite)

Theorem: cst-control-character-conc3-match

(defthm cst-control-character-conc3-match
  (implies
       (and (cst-matchp abnf::cst "control-character")
            (equal (cst-control-character-conc? abnf::cst)
                   3))
       (b* ((abnf::cstss (cst-control-character-conc3 abnf::cst)))
         (cst-list-list-conc-matchp abnf::cstss "form-feed")))
  :rule-classes :rewrite)

Theorem: cst-control-character-conc3-of-tree-fix-cst

(defthm cst-control-character-conc3-of-tree-fix-cst
  (equal (cst-control-character-conc3 (abnf::tree-fix abnf::cst))
         (cst-control-character-conc3 abnf::cst)))

Theorem: cst-control-character-conc3-tree-equiv-congruence-on-cst

(defthm cst-control-character-conc3-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-control-character-conc3 abnf::cst)
                  (cst-control-character-conc3 cst-equiv)))
  :rule-classes :congruence)

Function: cst-basic-character-conc1

(defun cst-basic-character-conc1 (abnf::cst)
 (declare (xargs :guard (abnf::treep abnf::cst)))
 (declare
     (xargs :guard (and (cst-matchp abnf::cst "basic-character")
                        (equal (cst-basic-character-conc? abnf::cst)
                               1))))
 (let ((__function__ 'cst-basic-character-conc1))
   (declare (ignorable __function__))
   (abnf::tree-nonleaf->branches abnf::cst)))

Theorem: tree-list-listp-of-cst-basic-character-conc1

(defthm tree-list-listp-of-cst-basic-character-conc1
  (b* ((abnf::cstss (cst-basic-character-conc1 abnf::cst)))
    (abnf::tree-list-listp abnf::cstss))
  :rule-classes :rewrite)

Theorem: cst-basic-character-conc1-match

(defthm cst-basic-character-conc1-match
  (implies (and (cst-matchp abnf::cst "basic-character")
                (equal (cst-basic-character-conc? abnf::cst)
                       1))
           (b* ((abnf::cstss (cst-basic-character-conc1 abnf::cst)))
             (cst-list-list-conc-matchp abnf::cstss "letter")))
  :rule-classes :rewrite)

Theorem: cst-basic-character-conc1-of-tree-fix-cst

(defthm cst-basic-character-conc1-of-tree-fix-cst
  (equal (cst-basic-character-conc1 (abnf::tree-fix abnf::cst))
         (cst-basic-character-conc1 abnf::cst)))

Theorem: cst-basic-character-conc1-tree-equiv-congruence-on-cst

(defthm cst-basic-character-conc1-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-basic-character-conc1 abnf::cst)
                  (cst-basic-character-conc1 cst-equiv)))
  :rule-classes :congruence)

Function: cst-basic-character-conc2

(defun cst-basic-character-conc2 (abnf::cst)
 (declare (xargs :guard (abnf::treep abnf::cst)))
 (declare
     (xargs :guard (and (cst-matchp abnf::cst "basic-character")
                        (equal (cst-basic-character-conc? abnf::cst)
                               2))))
 (let ((__function__ 'cst-basic-character-conc2))
   (declare (ignorable __function__))
   (abnf::tree-nonleaf->branches abnf::cst)))

Theorem: tree-list-listp-of-cst-basic-character-conc2

(defthm tree-list-listp-of-cst-basic-character-conc2
  (b* ((abnf::cstss (cst-basic-character-conc2 abnf::cst)))
    (abnf::tree-list-listp abnf::cstss))
  :rule-classes :rewrite)

Theorem: cst-basic-character-conc2-match

(defthm cst-basic-character-conc2-match
  (implies (and (cst-matchp abnf::cst "basic-character")
                (equal (cst-basic-character-conc? abnf::cst)
                       2))
           (b* ((abnf::cstss (cst-basic-character-conc2 abnf::cst)))
             (cst-list-list-conc-matchp abnf::cstss "digit")))
  :rule-classes :rewrite)

Theorem: cst-basic-character-conc2-of-tree-fix-cst

(defthm cst-basic-character-conc2-of-tree-fix-cst
  (equal (cst-basic-character-conc2 (abnf::tree-fix abnf::cst))
         (cst-basic-character-conc2 abnf::cst)))

Theorem: cst-basic-character-conc2-tree-equiv-congruence-on-cst

(defthm cst-basic-character-conc2-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-basic-character-conc2 abnf::cst)
                  (cst-basic-character-conc2 cst-equiv)))
  :rule-classes :congruence)

Function: cst-basic-character-conc3

(defun cst-basic-character-conc3 (abnf::cst)
 (declare (xargs :guard (abnf::treep abnf::cst)))
 (declare
     (xargs :guard (and (cst-matchp abnf::cst "basic-character")
                        (equal (cst-basic-character-conc? abnf::cst)
                               3))))
 (let ((__function__ 'cst-basic-character-conc3))
   (declare (ignorable __function__))
   (abnf::tree-nonleaf->branches abnf::cst)))

Theorem: tree-list-listp-of-cst-basic-character-conc3

(defthm tree-list-listp-of-cst-basic-character-conc3
  (b* ((abnf::cstss (cst-basic-character-conc3 abnf::cst)))
    (abnf::tree-list-listp abnf::cstss))
  :rule-classes :rewrite)

Theorem: cst-basic-character-conc3-match

(defthm cst-basic-character-conc3-match
 (implies
     (and (cst-matchp abnf::cst "basic-character")
          (equal (cst-basic-character-conc? abnf::cst)
                 3))
     (b* ((abnf::cstss (cst-basic-character-conc3 abnf::cst)))
       (cst-list-list-conc-matchp abnf::cstss "graphic-character")))
 :rule-classes :rewrite)

Theorem: cst-basic-character-conc3-of-tree-fix-cst

(defthm cst-basic-character-conc3-of-tree-fix-cst
  (equal (cst-basic-character-conc3 (abnf::tree-fix abnf::cst))
         (cst-basic-character-conc3 abnf::cst)))

Theorem: cst-basic-character-conc3-tree-equiv-congruence-on-cst

(defthm cst-basic-character-conc3-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-basic-character-conc3 abnf::cst)
                  (cst-basic-character-conc3 cst-equiv)))
  :rule-classes :congruence)

Function: cst-basic-character-conc4

(defun cst-basic-character-conc4 (abnf::cst)
 (declare (xargs :guard (abnf::treep abnf::cst)))
 (declare
     (xargs :guard (and (cst-matchp abnf::cst "basic-character")
                        (equal (cst-basic-character-conc? abnf::cst)
                               4))))
 (let ((__function__ 'cst-basic-character-conc4))
   (declare (ignorable __function__))
   (abnf::tree-nonleaf->branches abnf::cst)))

Theorem: tree-list-listp-of-cst-basic-character-conc4

(defthm tree-list-listp-of-cst-basic-character-conc4
  (b* ((abnf::cstss (cst-basic-character-conc4 abnf::cst)))
    (abnf::tree-list-listp abnf::cstss))
  :rule-classes :rewrite)

Theorem: cst-basic-character-conc4-match

(defthm cst-basic-character-conc4-match
  (implies (and (cst-matchp abnf::cst "basic-character")
                (equal (cst-basic-character-conc? abnf::cst)
                       4))
           (b* ((abnf::cstss (cst-basic-character-conc4 abnf::cst)))
             (cst-list-list-conc-matchp abnf::cstss "space")))
  :rule-classes :rewrite)

Theorem: cst-basic-character-conc4-of-tree-fix-cst

(defthm cst-basic-character-conc4-of-tree-fix-cst
  (equal (cst-basic-character-conc4 (abnf::tree-fix abnf::cst))
         (cst-basic-character-conc4 abnf::cst)))

Theorem: cst-basic-character-conc4-tree-equiv-congruence-on-cst

(defthm cst-basic-character-conc4-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-basic-character-conc4 abnf::cst)
                  (cst-basic-character-conc4 cst-equiv)))
  :rule-classes :congruence)

Function: cst-basic-character-conc5

(defun cst-basic-character-conc5 (abnf::cst)
 (declare (xargs :guard (abnf::treep abnf::cst)))
 (declare
     (xargs :guard (and (cst-matchp abnf::cst "basic-character")
                        (equal (cst-basic-character-conc? abnf::cst)
                               5))))
 (let ((__function__ 'cst-basic-character-conc5))
   (declare (ignorable __function__))
   (abnf::tree-nonleaf->branches abnf::cst)))

Theorem: tree-list-listp-of-cst-basic-character-conc5

(defthm tree-list-listp-of-cst-basic-character-conc5
  (b* ((abnf::cstss (cst-basic-character-conc5 abnf::cst)))
    (abnf::tree-list-listp abnf::cstss))
  :rule-classes :rewrite)

Theorem: cst-basic-character-conc5-match

(defthm cst-basic-character-conc5-match
 (implies
     (and (cst-matchp abnf::cst "basic-character")
          (equal (cst-basic-character-conc? abnf::cst)
                 5))
     (b* ((abnf::cstss (cst-basic-character-conc5 abnf::cst)))
       (cst-list-list-conc-matchp abnf::cstss "control-character")))
 :rule-classes :rewrite)

Theorem: cst-basic-character-conc5-of-tree-fix-cst

(defthm cst-basic-character-conc5-of-tree-fix-cst
  (equal (cst-basic-character-conc5 (abnf::tree-fix abnf::cst))
         (cst-basic-character-conc5 abnf::cst)))

Theorem: cst-basic-character-conc5-tree-equiv-congruence-on-cst

(defthm cst-basic-character-conc5-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-basic-character-conc5 abnf::cst)
                  (cst-basic-character-conc5 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-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 "basic-character")))
  :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 "extended-character")))
 :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-basic-character-not-star-conc1

(defun cst-basic-character-not-star-conc1 (abnf::cst)
 (declare (xargs :guard (abnf::treep abnf::cst)))
 (declare
  (xargs
   :guard (and (cst-matchp abnf::cst "basic-character-not-star")
               (equal (cst-basic-character-not-star-conc? abnf::cst)
                      1))))
 (let ((__function__ 'cst-basic-character-not-star-conc1))
   (declare (ignorable __function__))
   (abnf::tree-nonleaf->branches abnf::cst)))

Theorem: tree-list-listp-of-cst-basic-character-not-star-conc1

(defthm tree-list-listp-of-cst-basic-character-not-star-conc1
  (b* ((abnf::cstss (cst-basic-character-not-star-conc1 abnf::cst)))
    (abnf::tree-list-listp abnf::cstss))
  :rule-classes :rewrite)

Theorem: cst-basic-character-not-star-conc1-match

(defthm cst-basic-character-not-star-conc1-match
 (implies
  (and (cst-matchp abnf::cst "basic-character-not-star")
       (equal (cst-basic-character-not-star-conc? abnf::cst)
              1))
  (b* ((abnf::cstss (cst-basic-character-not-star-conc1 abnf::cst)))
    (cst-list-list-conc-matchp abnf::cstss "letter")))
 :rule-classes :rewrite)

Theorem: cst-basic-character-not-star-conc1-of-tree-fix-cst

(defthm cst-basic-character-not-star-conc1-of-tree-fix-cst
 (equal
     (cst-basic-character-not-star-conc1 (abnf::tree-fix abnf::cst))
     (cst-basic-character-not-star-conc1 abnf::cst)))

Theorem: cst-basic-character-not-star-conc1-tree-equiv-congruence-on-cst

(defthm
    cst-basic-character-not-star-conc1-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-basic-character-not-star-conc1 abnf::cst)
                  (cst-basic-character-not-star-conc1 cst-equiv)))
  :rule-classes :congruence)

Function: cst-basic-character-not-star-conc2

(defun cst-basic-character-not-star-conc2 (abnf::cst)
 (declare (xargs :guard (abnf::treep abnf::cst)))
 (declare
  (xargs
   :guard (and (cst-matchp abnf::cst "basic-character-not-star")
               (equal (cst-basic-character-not-star-conc? abnf::cst)
                      2))))
 (let ((__function__ 'cst-basic-character-not-star-conc2))
   (declare (ignorable __function__))
   (abnf::tree-nonleaf->branches abnf::cst)))

Theorem: tree-list-listp-of-cst-basic-character-not-star-conc2

(defthm tree-list-listp-of-cst-basic-character-not-star-conc2
  (b* ((abnf::cstss (cst-basic-character-not-star-conc2 abnf::cst)))
    (abnf::tree-list-listp abnf::cstss))
  :rule-classes :rewrite)

Theorem: cst-basic-character-not-star-conc2-match

(defthm cst-basic-character-not-star-conc2-match
 (implies
  (and (cst-matchp abnf::cst "basic-character-not-star")
       (equal (cst-basic-character-not-star-conc? abnf::cst)
              2))
  (b* ((abnf::cstss (cst-basic-character-not-star-conc2 abnf::cst)))
    (cst-list-list-conc-matchp abnf::cstss "digit")))
 :rule-classes :rewrite)

Theorem: cst-basic-character-not-star-conc2-of-tree-fix-cst

(defthm cst-basic-character-not-star-conc2-of-tree-fix-cst
 (equal
     (cst-basic-character-not-star-conc2 (abnf::tree-fix abnf::cst))
     (cst-basic-character-not-star-conc2 abnf::cst)))

Theorem: cst-basic-character-not-star-conc2-tree-equiv-congruence-on-cst

(defthm
    cst-basic-character-not-star-conc2-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-basic-character-not-star-conc2 abnf::cst)
                  (cst-basic-character-not-star-conc2 cst-equiv)))
  :rule-classes :congruence)

Function: cst-basic-character-not-star-conc3

(defun cst-basic-character-not-star-conc3 (abnf::cst)
 (declare (xargs :guard (abnf::treep abnf::cst)))
 (declare
  (xargs
   :guard (and (cst-matchp abnf::cst "basic-character-not-star")
               (equal (cst-basic-character-not-star-conc? abnf::cst)
                      3))))
 (let ((__function__ 'cst-basic-character-not-star-conc3))
   (declare (ignorable __function__))
   (abnf::tree-nonleaf->branches abnf::cst)))

Theorem: tree-list-listp-of-cst-basic-character-not-star-conc3

(defthm tree-list-listp-of-cst-basic-character-not-star-conc3
  (b* ((abnf::cstss (cst-basic-character-not-star-conc3 abnf::cst)))
    (abnf::tree-list-listp abnf::cstss))
  :rule-classes :rewrite)

Theorem: cst-basic-character-not-star-conc3-match

(defthm cst-basic-character-not-star-conc3-match
 (implies
  (and (cst-matchp abnf::cst "basic-character-not-star")
       (equal (cst-basic-character-not-star-conc? abnf::cst)
              3))
  (b* ((abnf::cstss (cst-basic-character-not-star-conc3 abnf::cst)))
    (cst-list-list-conc-matchp abnf::cstss
                               "graphic-character-not-star")))
 :rule-classes :rewrite)

Theorem: cst-basic-character-not-star-conc3-of-tree-fix-cst

(defthm cst-basic-character-not-star-conc3-of-tree-fix-cst
 (equal
     (cst-basic-character-not-star-conc3 (abnf::tree-fix abnf::cst))
     (cst-basic-character-not-star-conc3 abnf::cst)))

Theorem: cst-basic-character-not-star-conc3-tree-equiv-congruence-on-cst

(defthm
    cst-basic-character-not-star-conc3-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-basic-character-not-star-conc3 abnf::cst)
                  (cst-basic-character-not-star-conc3 cst-equiv)))
  :rule-classes :congruence)

Function: cst-basic-character-not-star-conc4

(defun cst-basic-character-not-star-conc4 (abnf::cst)
 (declare (xargs :guard (abnf::treep abnf::cst)))
 (declare
  (xargs
   :guard (and (cst-matchp abnf::cst "basic-character-not-star")
               (equal (cst-basic-character-not-star-conc? abnf::cst)
                      4))))
 (let ((__function__ 'cst-basic-character-not-star-conc4))
   (declare (ignorable __function__))
   (abnf::tree-nonleaf->branches abnf::cst)))

Theorem: tree-list-listp-of-cst-basic-character-not-star-conc4

(defthm tree-list-listp-of-cst-basic-character-not-star-conc4
  (b* ((abnf::cstss (cst-basic-character-not-star-conc4 abnf::cst)))
    (abnf::tree-list-listp abnf::cstss))
  :rule-classes :rewrite)

Theorem: cst-basic-character-not-star-conc4-match

(defthm cst-basic-character-not-star-conc4-match
 (implies
  (and (cst-matchp abnf::cst "basic-character-not-star")
       (equal (cst-basic-character-not-star-conc? abnf::cst)
              4))
  (b* ((abnf::cstss (cst-basic-character-not-star-conc4 abnf::cst)))
    (cst-list-list-conc-matchp abnf::cstss "space")))
 :rule-classes :rewrite)

Theorem: cst-basic-character-not-star-conc4-of-tree-fix-cst

(defthm cst-basic-character-not-star-conc4-of-tree-fix-cst
 (equal
     (cst-basic-character-not-star-conc4 (abnf::tree-fix abnf::cst))
     (cst-basic-character-not-star-conc4 abnf::cst)))

Theorem: cst-basic-character-not-star-conc4-tree-equiv-congruence-on-cst

(defthm
    cst-basic-character-not-star-conc4-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-basic-character-not-star-conc4 abnf::cst)
                  (cst-basic-character-not-star-conc4 cst-equiv)))
  :rule-classes :congruence)

Function: cst-basic-character-not-star-conc5

(defun cst-basic-character-not-star-conc5 (abnf::cst)
 (declare (xargs :guard (abnf::treep abnf::cst)))
 (declare
  (xargs
   :guard (and (cst-matchp abnf::cst "basic-character-not-star")
               (equal (cst-basic-character-not-star-conc? abnf::cst)
                      5))))
 (let ((__function__ 'cst-basic-character-not-star-conc5))
   (declare (ignorable __function__))
   (abnf::tree-nonleaf->branches abnf::cst)))

Theorem: tree-list-listp-of-cst-basic-character-not-star-conc5

(defthm tree-list-listp-of-cst-basic-character-not-star-conc5
  (b* ((abnf::cstss (cst-basic-character-not-star-conc5 abnf::cst)))
    (abnf::tree-list-listp abnf::cstss))
  :rule-classes :rewrite)

Theorem: cst-basic-character-not-star-conc5-match

(defthm cst-basic-character-not-star-conc5-match
 (implies
  (and (cst-matchp abnf::cst "basic-character-not-star")
       (equal (cst-basic-character-not-star-conc? abnf::cst)
              5))
  (b* ((abnf::cstss (cst-basic-character-not-star-conc5 abnf::cst)))
    (cst-list-list-conc-matchp abnf::cstss "control-character")))
 :rule-classes :rewrite)

Theorem: cst-basic-character-not-star-conc5-of-tree-fix-cst

(defthm cst-basic-character-not-star-conc5-of-tree-fix-cst
 (equal
     (cst-basic-character-not-star-conc5 (abnf::tree-fix abnf::cst))
     (cst-basic-character-not-star-conc5 abnf::cst)))

Theorem: cst-basic-character-not-star-conc5-tree-equiv-congruence-on-cst

(defthm
    cst-basic-character-not-star-conc5-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-basic-character-not-star-conc5 abnf::cst)
                  (cst-basic-character-not-star-conc5 cst-equiv)))
  :rule-classes :congruence)

Function: cst-basic-character-not-greater-than-conc1

(defun cst-basic-character-not-greater-than-conc1 (abnf::cst)
 (declare (xargs :guard (abnf::treep abnf::cst)))
 (declare
  (xargs
   :guard
   (and
       (cst-matchp abnf::cst
                   "basic-character-not-greater-than")
       (equal (cst-basic-character-not-greater-than-conc? abnf::cst)
              1))))
 (let ((__function__ 'cst-basic-character-not-greater-than-conc1))
   (declare (ignorable __function__))
   (abnf::tree-nonleaf->branches abnf::cst)))

Theorem: tree-list-listp-of-cst-basic-character-not-greater-than-conc1

(defthm
      tree-list-listp-of-cst-basic-character-not-greater-than-conc1
  (b* ((abnf::cstss
            (cst-basic-character-not-greater-than-conc1 abnf::cst)))
    (abnf::tree-list-listp abnf::cstss))
  :rule-classes :rewrite)

Theorem: cst-basic-character-not-greater-than-conc1-match

(defthm cst-basic-character-not-greater-than-conc1-match
 (implies
  (and (cst-matchp abnf::cst
                   "basic-character-not-greater-than")
       (equal (cst-basic-character-not-greater-than-conc? abnf::cst)
              1))
  (b* ((abnf::cstss
            (cst-basic-character-not-greater-than-conc1 abnf::cst)))
    (cst-list-list-conc-matchp abnf::cstss "letter")))
 :rule-classes :rewrite)

Theorem: cst-basic-character-not-greater-than-conc1-of-tree-fix-cst

(defthm cst-basic-character-not-greater-than-conc1-of-tree-fix-cst
  (equal (cst-basic-character-not-greater-than-conc1
              (abnf::tree-fix abnf::cst))
         (cst-basic-character-not-greater-than-conc1 abnf::cst)))

Theorem: cst-basic-character-not-greater-than-conc1-tree-equiv-congruence-on-cst

(defthm
 cst-basic-character-not-greater-than-conc1-tree-equiv-congruence-on-cst
 (implies
     (abnf::tree-equiv abnf::cst cst-equiv)
     (equal (cst-basic-character-not-greater-than-conc1 abnf::cst)
            (cst-basic-character-not-greater-than-conc1 cst-equiv)))
 :rule-classes :congruence)

Function: cst-basic-character-not-greater-than-conc2

(defun cst-basic-character-not-greater-than-conc2 (abnf::cst)
 (declare (xargs :guard (abnf::treep abnf::cst)))
 (declare
  (xargs
   :guard
   (and
       (cst-matchp abnf::cst
                   "basic-character-not-greater-than")
       (equal (cst-basic-character-not-greater-than-conc? abnf::cst)
              2))))
 (let ((__function__ 'cst-basic-character-not-greater-than-conc2))
   (declare (ignorable __function__))
   (abnf::tree-nonleaf->branches abnf::cst)))

Theorem: tree-list-listp-of-cst-basic-character-not-greater-than-conc2

(defthm
      tree-list-listp-of-cst-basic-character-not-greater-than-conc2
  (b* ((abnf::cstss
            (cst-basic-character-not-greater-than-conc2 abnf::cst)))
    (abnf::tree-list-listp abnf::cstss))
  :rule-classes :rewrite)

Theorem: cst-basic-character-not-greater-than-conc2-match

(defthm cst-basic-character-not-greater-than-conc2-match
 (implies
  (and (cst-matchp abnf::cst
                   "basic-character-not-greater-than")
       (equal (cst-basic-character-not-greater-than-conc? abnf::cst)
              2))
  (b* ((abnf::cstss
            (cst-basic-character-not-greater-than-conc2 abnf::cst)))
    (cst-list-list-conc-matchp abnf::cstss "digit")))
 :rule-classes :rewrite)

Theorem: cst-basic-character-not-greater-than-conc2-of-tree-fix-cst

(defthm cst-basic-character-not-greater-than-conc2-of-tree-fix-cst
  (equal (cst-basic-character-not-greater-than-conc2
              (abnf::tree-fix abnf::cst))
         (cst-basic-character-not-greater-than-conc2 abnf::cst)))

Theorem: cst-basic-character-not-greater-than-conc2-tree-equiv-congruence-on-cst

(defthm
 cst-basic-character-not-greater-than-conc2-tree-equiv-congruence-on-cst
 (implies
     (abnf::tree-equiv abnf::cst cst-equiv)
     (equal (cst-basic-character-not-greater-than-conc2 abnf::cst)
            (cst-basic-character-not-greater-than-conc2 cst-equiv)))
 :rule-classes :congruence)

Function: cst-basic-character-not-greater-than-conc3

(defun cst-basic-character-not-greater-than-conc3 (abnf::cst)
 (declare (xargs :guard (abnf::treep abnf::cst)))
 (declare
  (xargs
   :guard
   (and
       (cst-matchp abnf::cst
                   "basic-character-not-greater-than")
       (equal (cst-basic-character-not-greater-than-conc? abnf::cst)
              3))))
 (let ((__function__ 'cst-basic-character-not-greater-than-conc3))
   (declare (ignorable __function__))
   (abnf::tree-nonleaf->branches abnf::cst)))

Theorem: tree-list-listp-of-cst-basic-character-not-greater-than-conc3

(defthm
      tree-list-listp-of-cst-basic-character-not-greater-than-conc3
  (b* ((abnf::cstss
            (cst-basic-character-not-greater-than-conc3 abnf::cst)))
    (abnf::tree-list-listp abnf::cstss))
  :rule-classes :rewrite)

Theorem: cst-basic-character-not-greater-than-conc3-match

(defthm cst-basic-character-not-greater-than-conc3-match
 (implies
  (and (cst-matchp abnf::cst
                   "basic-character-not-greater-than")
       (equal (cst-basic-character-not-greater-than-conc? abnf::cst)
              3))
  (b* ((abnf::cstss
            (cst-basic-character-not-greater-than-conc3 abnf::cst)))
    (cst-list-list-conc-matchp
         abnf::cstss
         "graphic-character-not-greater-than")))
 :rule-classes :rewrite)

Theorem: cst-basic-character-not-greater-than-conc3-of-tree-fix-cst

(defthm cst-basic-character-not-greater-than-conc3-of-tree-fix-cst
  (equal (cst-basic-character-not-greater-than-conc3
              (abnf::tree-fix abnf::cst))
         (cst-basic-character-not-greater-than-conc3 abnf::cst)))

Theorem: cst-basic-character-not-greater-than-conc3-tree-equiv-congruence-on-cst

(defthm
 cst-basic-character-not-greater-than-conc3-tree-equiv-congruence-on-cst
 (implies
     (abnf::tree-equiv abnf::cst cst-equiv)
     (equal (cst-basic-character-not-greater-than-conc3 abnf::cst)
            (cst-basic-character-not-greater-than-conc3 cst-equiv)))
 :rule-classes :congruence)

Function: cst-basic-character-not-greater-than-conc4

(defun cst-basic-character-not-greater-than-conc4 (abnf::cst)
 (declare (xargs :guard (abnf::treep abnf::cst)))
 (declare
  (xargs
   :guard
   (and
       (cst-matchp abnf::cst
                   "basic-character-not-greater-than")
       (equal (cst-basic-character-not-greater-than-conc? abnf::cst)
              4))))
 (let ((__function__ 'cst-basic-character-not-greater-than-conc4))
   (declare (ignorable __function__))
   (abnf::tree-nonleaf->branches abnf::cst)))

Theorem: tree-list-listp-of-cst-basic-character-not-greater-than-conc4

(defthm
      tree-list-listp-of-cst-basic-character-not-greater-than-conc4
  (b* ((abnf::cstss
            (cst-basic-character-not-greater-than-conc4 abnf::cst)))
    (abnf::tree-list-listp abnf::cstss))
  :rule-classes :rewrite)

Theorem: cst-basic-character-not-greater-than-conc4-match

(defthm cst-basic-character-not-greater-than-conc4-match
 (implies
  (and (cst-matchp abnf::cst
                   "basic-character-not-greater-than")
       (equal (cst-basic-character-not-greater-than-conc? abnf::cst)
              4))
  (b* ((abnf::cstss
            (cst-basic-character-not-greater-than-conc4 abnf::cst)))
    (cst-list-list-conc-matchp abnf::cstss "space")))
 :rule-classes :rewrite)

Theorem: cst-basic-character-not-greater-than-conc4-of-tree-fix-cst

(defthm cst-basic-character-not-greater-than-conc4-of-tree-fix-cst
  (equal (cst-basic-character-not-greater-than-conc4
              (abnf::tree-fix abnf::cst))
         (cst-basic-character-not-greater-than-conc4 abnf::cst)))

Theorem: cst-basic-character-not-greater-than-conc4-tree-equiv-congruence-on-cst

(defthm
 cst-basic-character-not-greater-than-conc4-tree-equiv-congruence-on-cst
 (implies
     (abnf::tree-equiv abnf::cst cst-equiv)
     (equal (cst-basic-character-not-greater-than-conc4 abnf::cst)
            (cst-basic-character-not-greater-than-conc4 cst-equiv)))
 :rule-classes :congruence)

Function: cst-basic-character-not-greater-than-conc5

(defun cst-basic-character-not-greater-than-conc5 (abnf::cst)
 (declare (xargs :guard (abnf::treep abnf::cst)))
 (declare
  (xargs
   :guard
   (and
       (cst-matchp abnf::cst
                   "basic-character-not-greater-than")
       (equal (cst-basic-character-not-greater-than-conc? abnf::cst)
              5))))
 (let ((__function__ 'cst-basic-character-not-greater-than-conc5))
   (declare (ignorable __function__))
   (abnf::tree-nonleaf->branches abnf::cst)))

Theorem: tree-list-listp-of-cst-basic-character-not-greater-than-conc5

(defthm
      tree-list-listp-of-cst-basic-character-not-greater-than-conc5
  (b* ((abnf::cstss
            (cst-basic-character-not-greater-than-conc5 abnf::cst)))
    (abnf::tree-list-listp abnf::cstss))
  :rule-classes :rewrite)

Theorem: cst-basic-character-not-greater-than-conc5-match

(defthm cst-basic-character-not-greater-than-conc5-match
 (implies
  (and (cst-matchp abnf::cst
                   "basic-character-not-greater-than")
       (equal (cst-basic-character-not-greater-than-conc? abnf::cst)
              5))
  (b* ((abnf::cstss
            (cst-basic-character-not-greater-than-conc5 abnf::cst)))
    (cst-list-list-conc-matchp abnf::cstss "control-character")))
 :rule-classes :rewrite)

Theorem: cst-basic-character-not-greater-than-conc5-of-tree-fix-cst

(defthm cst-basic-character-not-greater-than-conc5-of-tree-fix-cst
  (equal (cst-basic-character-not-greater-than-conc5
              (abnf::tree-fix abnf::cst))
         (cst-basic-character-not-greater-than-conc5 abnf::cst)))

Theorem: cst-basic-character-not-greater-than-conc5-tree-equiv-congruence-on-cst

(defthm
 cst-basic-character-not-greater-than-conc5-tree-equiv-congruence-on-cst
 (implies
     (abnf::tree-equiv abnf::cst cst-equiv)
     (equal (cst-basic-character-not-greater-than-conc5 abnf::cst)
            (cst-basic-character-not-greater-than-conc5 cst-equiv)))
 :rule-classes :congruence)

Function: cst-basic-character-not-double-quote-conc1

(defun cst-basic-character-not-double-quote-conc1 (abnf::cst)
 (declare (xargs :guard (abnf::treep abnf::cst)))
 (declare
  (xargs
   :guard
   (and
       (cst-matchp abnf::cst
                   "basic-character-not-double-quote")
       (equal (cst-basic-character-not-double-quote-conc? abnf::cst)
              1))))
 (let ((__function__ 'cst-basic-character-not-double-quote-conc1))
   (declare (ignorable __function__))
   (abnf::tree-nonleaf->branches abnf::cst)))

Theorem: tree-list-listp-of-cst-basic-character-not-double-quote-conc1

(defthm
      tree-list-listp-of-cst-basic-character-not-double-quote-conc1
  (b* ((abnf::cstss
            (cst-basic-character-not-double-quote-conc1 abnf::cst)))
    (abnf::tree-list-listp abnf::cstss))
  :rule-classes :rewrite)

Theorem: cst-basic-character-not-double-quote-conc1-match

(defthm cst-basic-character-not-double-quote-conc1-match
 (implies
  (and (cst-matchp abnf::cst
                   "basic-character-not-double-quote")
       (equal (cst-basic-character-not-double-quote-conc? abnf::cst)
              1))
  (b* ((abnf::cstss
            (cst-basic-character-not-double-quote-conc1 abnf::cst)))
    (cst-list-list-conc-matchp abnf::cstss "letter")))
 :rule-classes :rewrite)

Theorem: cst-basic-character-not-double-quote-conc1-of-tree-fix-cst

(defthm cst-basic-character-not-double-quote-conc1-of-tree-fix-cst
  (equal (cst-basic-character-not-double-quote-conc1
              (abnf::tree-fix abnf::cst))
         (cst-basic-character-not-double-quote-conc1 abnf::cst)))

Theorem: cst-basic-character-not-double-quote-conc1-tree-equiv-congruence-on-cst

(defthm
 cst-basic-character-not-double-quote-conc1-tree-equiv-congruence-on-cst
 (implies
     (abnf::tree-equiv abnf::cst cst-equiv)
     (equal (cst-basic-character-not-double-quote-conc1 abnf::cst)
            (cst-basic-character-not-double-quote-conc1 cst-equiv)))
 :rule-classes :congruence)

Function: cst-basic-character-not-double-quote-conc2

(defun cst-basic-character-not-double-quote-conc2 (abnf::cst)
 (declare (xargs :guard (abnf::treep abnf::cst)))
 (declare
  (xargs
   :guard
   (and
       (cst-matchp abnf::cst
                   "basic-character-not-double-quote")
       (equal (cst-basic-character-not-double-quote-conc? abnf::cst)
              2))))
 (let ((__function__ 'cst-basic-character-not-double-quote-conc2))
   (declare (ignorable __function__))
   (abnf::tree-nonleaf->branches abnf::cst)))

Theorem: tree-list-listp-of-cst-basic-character-not-double-quote-conc2

(defthm
      tree-list-listp-of-cst-basic-character-not-double-quote-conc2
  (b* ((abnf::cstss
            (cst-basic-character-not-double-quote-conc2 abnf::cst)))
    (abnf::tree-list-listp abnf::cstss))
  :rule-classes :rewrite)

Theorem: cst-basic-character-not-double-quote-conc2-match

(defthm cst-basic-character-not-double-quote-conc2-match
 (implies
  (and (cst-matchp abnf::cst
                   "basic-character-not-double-quote")
       (equal (cst-basic-character-not-double-quote-conc? abnf::cst)
              2))
  (b* ((abnf::cstss
            (cst-basic-character-not-double-quote-conc2 abnf::cst)))
    (cst-list-list-conc-matchp abnf::cstss "digit")))
 :rule-classes :rewrite)

Theorem: cst-basic-character-not-double-quote-conc2-of-tree-fix-cst

(defthm cst-basic-character-not-double-quote-conc2-of-tree-fix-cst
  (equal (cst-basic-character-not-double-quote-conc2
              (abnf::tree-fix abnf::cst))
         (cst-basic-character-not-double-quote-conc2 abnf::cst)))

Theorem: cst-basic-character-not-double-quote-conc2-tree-equiv-congruence-on-cst

(defthm
 cst-basic-character-not-double-quote-conc2-tree-equiv-congruence-on-cst
 (implies
     (abnf::tree-equiv abnf::cst cst-equiv)
     (equal (cst-basic-character-not-double-quote-conc2 abnf::cst)
            (cst-basic-character-not-double-quote-conc2 cst-equiv)))
 :rule-classes :congruence)

Function: cst-basic-character-not-double-quote-conc3

(defun cst-basic-character-not-double-quote-conc3 (abnf::cst)
 (declare (xargs :guard (abnf::treep abnf::cst)))
 (declare
  (xargs
   :guard
   (and
       (cst-matchp abnf::cst
                   "basic-character-not-double-quote")
       (equal (cst-basic-character-not-double-quote-conc? abnf::cst)
              3))))
 (let ((__function__ 'cst-basic-character-not-double-quote-conc3))
   (declare (ignorable __function__))
   (abnf::tree-nonleaf->branches abnf::cst)))

Theorem: tree-list-listp-of-cst-basic-character-not-double-quote-conc3

(defthm
      tree-list-listp-of-cst-basic-character-not-double-quote-conc3
  (b* ((abnf::cstss
            (cst-basic-character-not-double-quote-conc3 abnf::cst)))
    (abnf::tree-list-listp abnf::cstss))
  :rule-classes :rewrite)

Theorem: cst-basic-character-not-double-quote-conc3-match

(defthm cst-basic-character-not-double-quote-conc3-match
 (implies
  (and (cst-matchp abnf::cst
                   "basic-character-not-double-quote")
       (equal (cst-basic-character-not-double-quote-conc? abnf::cst)
              3))
  (b* ((abnf::cstss
            (cst-basic-character-not-double-quote-conc3 abnf::cst)))
    (cst-list-list-conc-matchp
         abnf::cstss
         "graphic-character-not-double-quote")))
 :rule-classes :rewrite)

Theorem: cst-basic-character-not-double-quote-conc3-of-tree-fix-cst

(defthm cst-basic-character-not-double-quote-conc3-of-tree-fix-cst
  (equal (cst-basic-character-not-double-quote-conc3
              (abnf::tree-fix abnf::cst))
         (cst-basic-character-not-double-quote-conc3 abnf::cst)))

Theorem: cst-basic-character-not-double-quote-conc3-tree-equiv-congruence-on-cst

(defthm
 cst-basic-character-not-double-quote-conc3-tree-equiv-congruence-on-cst
 (implies
     (abnf::tree-equiv abnf::cst cst-equiv)
     (equal (cst-basic-character-not-double-quote-conc3 abnf::cst)
            (cst-basic-character-not-double-quote-conc3 cst-equiv)))
 :rule-classes :congruence)

Function: cst-basic-character-not-double-quote-conc4

(defun cst-basic-character-not-double-quote-conc4 (abnf::cst)
 (declare (xargs :guard (abnf::treep abnf::cst)))
 (declare
  (xargs
   :guard
   (and
       (cst-matchp abnf::cst
                   "basic-character-not-double-quote")
       (equal (cst-basic-character-not-double-quote-conc? abnf::cst)
              4))))
 (let ((__function__ 'cst-basic-character-not-double-quote-conc4))
   (declare (ignorable __function__))
   (abnf::tree-nonleaf->branches abnf::cst)))

Theorem: tree-list-listp-of-cst-basic-character-not-double-quote-conc4

(defthm
      tree-list-listp-of-cst-basic-character-not-double-quote-conc4
  (b* ((abnf::cstss
            (cst-basic-character-not-double-quote-conc4 abnf::cst)))
    (abnf::tree-list-listp abnf::cstss))
  :rule-classes :rewrite)

Theorem: cst-basic-character-not-double-quote-conc4-match

(defthm cst-basic-character-not-double-quote-conc4-match
 (implies
  (and (cst-matchp abnf::cst
                   "basic-character-not-double-quote")
       (equal (cst-basic-character-not-double-quote-conc? abnf::cst)
              4))
  (b* ((abnf::cstss
            (cst-basic-character-not-double-quote-conc4 abnf::cst)))
    (cst-list-list-conc-matchp abnf::cstss "space")))
 :rule-classes :rewrite)

Theorem: cst-basic-character-not-double-quote-conc4-of-tree-fix-cst

(defthm cst-basic-character-not-double-quote-conc4-of-tree-fix-cst
  (equal (cst-basic-character-not-double-quote-conc4
              (abnf::tree-fix abnf::cst))
         (cst-basic-character-not-double-quote-conc4 abnf::cst)))

Theorem: cst-basic-character-not-double-quote-conc4-tree-equiv-congruence-on-cst

(defthm
 cst-basic-character-not-double-quote-conc4-tree-equiv-congruence-on-cst
 (implies
     (abnf::tree-equiv abnf::cst cst-equiv)
     (equal (cst-basic-character-not-double-quote-conc4 abnf::cst)
            (cst-basic-character-not-double-quote-conc4 cst-equiv)))
 :rule-classes :congruence)

Function: cst-basic-character-not-double-quote-conc5

(defun cst-basic-character-not-double-quote-conc5 (abnf::cst)
 (declare (xargs :guard (abnf::treep abnf::cst)))
 (declare
  (xargs
   :guard
   (and
       (cst-matchp abnf::cst
                   "basic-character-not-double-quote")
       (equal (cst-basic-character-not-double-quote-conc? abnf::cst)
              5))))
 (let ((__function__ 'cst-basic-character-not-double-quote-conc5))
   (declare (ignorable __function__))
   (abnf::tree-nonleaf->branches abnf::cst)))

Theorem: tree-list-listp-of-cst-basic-character-not-double-quote-conc5

(defthm
      tree-list-listp-of-cst-basic-character-not-double-quote-conc5
  (b* ((abnf::cstss
            (cst-basic-character-not-double-quote-conc5 abnf::cst)))
    (abnf::tree-list-listp abnf::cstss))
  :rule-classes :rewrite)

Theorem: cst-basic-character-not-double-quote-conc5-match

(defthm cst-basic-character-not-double-quote-conc5-match
 (implies
  (and (cst-matchp abnf::cst
                   "basic-character-not-double-quote")
       (equal (cst-basic-character-not-double-quote-conc? abnf::cst)
              5))
  (b* ((abnf::cstss
            (cst-basic-character-not-double-quote-conc5 abnf::cst)))
    (cst-list-list-conc-matchp abnf::cstss "control-character")))
 :rule-classes :rewrite)

Theorem: cst-basic-character-not-double-quote-conc5-of-tree-fix-cst

(defthm cst-basic-character-not-double-quote-conc5-of-tree-fix-cst
  (equal (cst-basic-character-not-double-quote-conc5
              (abnf::tree-fix abnf::cst))
         (cst-basic-character-not-double-quote-conc5 abnf::cst)))

Theorem: cst-basic-character-not-double-quote-conc5-tree-equiv-congruence-on-cst

(defthm
 cst-basic-character-not-double-quote-conc5-tree-equiv-congruence-on-cst
 (implies
     (abnf::tree-equiv abnf::cst cst-equiv)
     (equal (cst-basic-character-not-double-quote-conc5 abnf::cst)
            (cst-basic-character-not-double-quote-conc5 cst-equiv)))
 :rule-classes :congruence)

Function: cst-basic-character-not-star-or-slash-conc1

(defun cst-basic-character-not-star-or-slash-conc1 (abnf::cst)
 (declare (xargs :guard (abnf::treep abnf::cst)))
 (declare
  (xargs
   :guard
   (and
      (cst-matchp abnf::cst
                  "basic-character-not-star-or-slash")
      (equal (cst-basic-character-not-star-or-slash-conc? abnf::cst)
             1))))
 (let ((__function__ 'cst-basic-character-not-star-or-slash-conc1))
   (declare (ignorable __function__))
   (abnf::tree-nonleaf->branches abnf::cst)))

Theorem: tree-list-listp-of-cst-basic-character-not-star-or-slash-conc1

(defthm
     tree-list-listp-of-cst-basic-character-not-star-or-slash-conc1
 (b* ((abnf::cstss
           (cst-basic-character-not-star-or-slash-conc1 abnf::cst)))
   (abnf::tree-list-listp abnf::cstss))
 :rule-classes :rewrite)

Theorem: cst-basic-character-not-star-or-slash-conc1-match

(defthm cst-basic-character-not-star-or-slash-conc1-match
 (implies
  (and
      (cst-matchp abnf::cst
                  "basic-character-not-star-or-slash")
      (equal (cst-basic-character-not-star-or-slash-conc? abnf::cst)
             1))
  (b*
    ((abnf::cstss
          (cst-basic-character-not-star-or-slash-conc1 abnf::cst)))
    (cst-list-list-conc-matchp abnf::cstss "letter")))
 :rule-classes :rewrite)

Theorem: cst-basic-character-not-star-or-slash-conc1-of-tree-fix-cst

(defthm cst-basic-character-not-star-or-slash-conc1-of-tree-fix-cst
  (equal (cst-basic-character-not-star-or-slash-conc1
              (abnf::tree-fix abnf::cst))
         (cst-basic-character-not-star-or-slash-conc1 abnf::cst)))

Theorem: cst-basic-character-not-star-or-slash-conc1-tree-equiv-congruence-on-cst

(defthm
 cst-basic-character-not-star-or-slash-conc1-tree-equiv-congruence-on-cst
 (implies
    (abnf::tree-equiv abnf::cst cst-equiv)
    (equal (cst-basic-character-not-star-or-slash-conc1 abnf::cst)
           (cst-basic-character-not-star-or-slash-conc1 cst-equiv)))
 :rule-classes :congruence)

Function: cst-basic-character-not-star-or-slash-conc2

(defun cst-basic-character-not-star-or-slash-conc2 (abnf::cst)
 (declare (xargs :guard (abnf::treep abnf::cst)))
 (declare
  (xargs
   :guard
   (and
      (cst-matchp abnf::cst
                  "basic-character-not-star-or-slash")
      (equal (cst-basic-character-not-star-or-slash-conc? abnf::cst)
             2))))
 (let ((__function__ 'cst-basic-character-not-star-or-slash-conc2))
   (declare (ignorable __function__))
   (abnf::tree-nonleaf->branches abnf::cst)))

Theorem: tree-list-listp-of-cst-basic-character-not-star-or-slash-conc2

(defthm
     tree-list-listp-of-cst-basic-character-not-star-or-slash-conc2
 (b* ((abnf::cstss
           (cst-basic-character-not-star-or-slash-conc2 abnf::cst)))
   (abnf::tree-list-listp abnf::cstss))
 :rule-classes :rewrite)

Theorem: cst-basic-character-not-star-or-slash-conc2-match

(defthm cst-basic-character-not-star-or-slash-conc2-match
 (implies
  (and
      (cst-matchp abnf::cst
                  "basic-character-not-star-or-slash")
      (equal (cst-basic-character-not-star-or-slash-conc? abnf::cst)
             2))
  (b*
    ((abnf::cstss
          (cst-basic-character-not-star-or-slash-conc2 abnf::cst)))
    (cst-list-list-conc-matchp abnf::cstss "digit")))
 :rule-classes :rewrite)

Theorem: cst-basic-character-not-star-or-slash-conc2-of-tree-fix-cst

(defthm cst-basic-character-not-star-or-slash-conc2-of-tree-fix-cst
  (equal (cst-basic-character-not-star-or-slash-conc2
              (abnf::tree-fix abnf::cst))
         (cst-basic-character-not-star-or-slash-conc2 abnf::cst)))

Theorem: cst-basic-character-not-star-or-slash-conc2-tree-equiv-congruence-on-cst

(defthm
 cst-basic-character-not-star-or-slash-conc2-tree-equiv-congruence-on-cst
 (implies
    (abnf::tree-equiv abnf::cst cst-equiv)
    (equal (cst-basic-character-not-star-or-slash-conc2 abnf::cst)
           (cst-basic-character-not-star-or-slash-conc2 cst-equiv)))
 :rule-classes :congruence)

Function: cst-basic-character-not-star-or-slash-conc3

(defun cst-basic-character-not-star-or-slash-conc3 (abnf::cst)
 (declare (xargs :guard (abnf::treep abnf::cst)))
 (declare
  (xargs
   :guard
   (and
      (cst-matchp abnf::cst
                  "basic-character-not-star-or-slash")
      (equal (cst-basic-character-not-star-or-slash-conc? abnf::cst)
             3))))
 (let ((__function__ 'cst-basic-character-not-star-or-slash-conc3))
   (declare (ignorable __function__))
   (abnf::tree-nonleaf->branches abnf::cst)))

Theorem: tree-list-listp-of-cst-basic-character-not-star-or-slash-conc3

(defthm
     tree-list-listp-of-cst-basic-character-not-star-or-slash-conc3
 (b* ((abnf::cstss
           (cst-basic-character-not-star-or-slash-conc3 abnf::cst)))
   (abnf::tree-list-listp abnf::cstss))
 :rule-classes :rewrite)

Theorem: cst-basic-character-not-star-or-slash-conc3-match

(defthm cst-basic-character-not-star-or-slash-conc3-match
 (implies
  (and
      (cst-matchp abnf::cst
                  "basic-character-not-star-or-slash")
      (equal (cst-basic-character-not-star-or-slash-conc? abnf::cst)
             3))
  (b*
    ((abnf::cstss
          (cst-basic-character-not-star-or-slash-conc3 abnf::cst)))
    (cst-list-list-conc-matchp
         abnf::cstss
         "graphic-character-not-star-or-slash")))
 :rule-classes :rewrite)

Theorem: cst-basic-character-not-star-or-slash-conc3-of-tree-fix-cst

(defthm cst-basic-character-not-star-or-slash-conc3-of-tree-fix-cst
  (equal (cst-basic-character-not-star-or-slash-conc3
              (abnf::tree-fix abnf::cst))
         (cst-basic-character-not-star-or-slash-conc3 abnf::cst)))

Theorem: cst-basic-character-not-star-or-slash-conc3-tree-equiv-congruence-on-cst

(defthm
 cst-basic-character-not-star-or-slash-conc3-tree-equiv-congruence-on-cst
 (implies
    (abnf::tree-equiv abnf::cst cst-equiv)
    (equal (cst-basic-character-not-star-or-slash-conc3 abnf::cst)
           (cst-basic-character-not-star-or-slash-conc3 cst-equiv)))
 :rule-classes :congruence)

Function: cst-basic-character-not-star-or-slash-conc4

(defun cst-basic-character-not-star-or-slash-conc4 (abnf::cst)
 (declare (xargs :guard (abnf::treep abnf::cst)))
 (declare
  (xargs
   :guard
   (and
      (cst-matchp abnf::cst
                  "basic-character-not-star-or-slash")
      (equal (cst-basic-character-not-star-or-slash-conc? abnf::cst)
             4))))
 (let ((__function__ 'cst-basic-character-not-star-or-slash-conc4))
   (declare (ignorable __function__))
   (abnf::tree-nonleaf->branches abnf::cst)))

Theorem: tree-list-listp-of-cst-basic-character-not-star-or-slash-conc4

(defthm
     tree-list-listp-of-cst-basic-character-not-star-or-slash-conc4
 (b* ((abnf::cstss
           (cst-basic-character-not-star-or-slash-conc4 abnf::cst)))
   (abnf::tree-list-listp abnf::cstss))
 :rule-classes :rewrite)

Theorem: cst-basic-character-not-star-or-slash-conc4-match

(defthm cst-basic-character-not-star-or-slash-conc4-match
 (implies
  (and
      (cst-matchp abnf::cst
                  "basic-character-not-star-or-slash")
      (equal (cst-basic-character-not-star-or-slash-conc? abnf::cst)
             4))
  (b*
    ((abnf::cstss
          (cst-basic-character-not-star-or-slash-conc4 abnf::cst)))
    (cst-list-list-conc-matchp abnf::cstss "space")))
 :rule-classes :rewrite)

Theorem: cst-basic-character-not-star-or-slash-conc4-of-tree-fix-cst

(defthm cst-basic-character-not-star-or-slash-conc4-of-tree-fix-cst
  (equal (cst-basic-character-not-star-or-slash-conc4
              (abnf::tree-fix abnf::cst))
         (cst-basic-character-not-star-or-slash-conc4 abnf::cst)))

Theorem: cst-basic-character-not-star-or-slash-conc4-tree-equiv-congruence-on-cst

(defthm
 cst-basic-character-not-star-or-slash-conc4-tree-equiv-congruence-on-cst
 (implies
    (abnf::tree-equiv abnf::cst cst-equiv)
    (equal (cst-basic-character-not-star-or-slash-conc4 abnf::cst)
           (cst-basic-character-not-star-or-slash-conc4 cst-equiv)))
 :rule-classes :congruence)

Function: cst-basic-character-not-star-or-slash-conc5

(defun cst-basic-character-not-star-or-slash-conc5 (abnf::cst)
 (declare (xargs :guard (abnf::treep abnf::cst)))
 (declare
  (xargs
   :guard
   (and
      (cst-matchp abnf::cst
                  "basic-character-not-star-or-slash")
      (equal (cst-basic-character-not-star-or-slash-conc? abnf::cst)
             5))))
 (let ((__function__ 'cst-basic-character-not-star-or-slash-conc5))
   (declare (ignorable __function__))
   (abnf::tree-nonleaf->branches abnf::cst)))

Theorem: tree-list-listp-of-cst-basic-character-not-star-or-slash-conc5

(defthm
     tree-list-listp-of-cst-basic-character-not-star-or-slash-conc5
 (b* ((abnf::cstss
           (cst-basic-character-not-star-or-slash-conc5 abnf::cst)))
   (abnf::tree-list-listp abnf::cstss))
 :rule-classes :rewrite)

Theorem: cst-basic-character-not-star-or-slash-conc5-match

(defthm cst-basic-character-not-star-or-slash-conc5-match
 (implies
  (and
      (cst-matchp abnf::cst
                  "basic-character-not-star-or-slash")
      (equal (cst-basic-character-not-star-or-slash-conc? abnf::cst)
             5))
  (b*
    ((abnf::cstss
          (cst-basic-character-not-star-or-slash-conc5 abnf::cst)))
    (cst-list-list-conc-matchp abnf::cstss "control-character")))
 :rule-classes :rewrite)

Theorem: cst-basic-character-not-star-or-slash-conc5-of-tree-fix-cst

(defthm cst-basic-character-not-star-or-slash-conc5-of-tree-fix-cst
  (equal (cst-basic-character-not-star-or-slash-conc5
              (abnf::tree-fix abnf::cst))
         (cst-basic-character-not-star-or-slash-conc5 abnf::cst)))

Theorem: cst-basic-character-not-star-or-slash-conc5-tree-equiv-congruence-on-cst

(defthm
 cst-basic-character-not-star-or-slash-conc5-tree-equiv-congruence-on-cst
 (implies
    (abnf::tree-equiv abnf::cst cst-equiv)
    (equal (cst-basic-character-not-star-or-slash-conc5 abnf::cst)
           (cst-basic-character-not-star-or-slash-conc5 cst-equiv)))
 :rule-classes :congruence)

Function: cst-basic-character-not-single-quote-or-backslash-conc1

(defun cst-basic-character-not-single-quote-or-backslash-conc1
       (abnf::cst)
 (declare (xargs :guard (abnf::treep abnf::cst)))
 (declare
  (xargs
   :guard
   (and (cst-matchp abnf::cst
                    "basic-character-not-single-quote-or-backslash")
        (equal (cst-basic-character-not-single-quote-or-backslash-conc?
                    abnf::cst)
               1))))
 (let
   ((__function__
         'cst-basic-character-not-single-quote-or-backslash-conc1))
   (declare (ignorable __function__))
   (abnf::tree-nonleaf->branches abnf::cst)))

Theorem: tree-list-listp-of-cst-basic-character-not-single-quote-or-backslash-conc1

(defthm
 tree-list-listp-of-cst-basic-character-not-single-quote-or-backslash-conc1
 (b* ((abnf::cstss (cst-basic-character-not-single-quote-or-backslash-conc1
                        abnf::cst)))
   (abnf::tree-list-listp abnf::cstss))
 :rule-classes :rewrite)

Theorem: cst-basic-character-not-single-quote-or-backslash-conc1-match

(defthm
      cst-basic-character-not-single-quote-or-backslash-conc1-match
 (implies
   (and (cst-matchp abnf::cst
                    "basic-character-not-single-quote-or-backslash")
        (equal (cst-basic-character-not-single-quote-or-backslash-conc?
                    abnf::cst)
               1))
   (b* ((abnf::cstss (cst-basic-character-not-single-quote-or-backslash-conc1
                          abnf::cst)))
     (cst-list-list-conc-matchp abnf::cstss "letter")))
 :rule-classes :rewrite)

Theorem: cst-basic-character-not-single-quote-or-backslash-conc1-of-tree-fix-cst

(defthm
 cst-basic-character-not-single-quote-or-backslash-conc1-of-tree-fix-cst
 (equal (cst-basic-character-not-single-quote-or-backslash-conc1
             (abnf::tree-fix abnf::cst))
        (cst-basic-character-not-single-quote-or-backslash-conc1
             abnf::cst)))

Theorem: cst-basic-character-not-single-quote-or-backslash-conc1-tree-equiv-congruence-on-cst

(defthm
 cst-basic-character-not-single-quote-or-backslash-conc1-tree-equiv-congruence-on-cst
 (implies (abnf::tree-equiv abnf::cst cst-equiv)
          (equal (cst-basic-character-not-single-quote-or-backslash-conc1
                      abnf::cst)
                 (cst-basic-character-not-single-quote-or-backslash-conc1
                      cst-equiv)))
 :rule-classes :congruence)

Function: cst-basic-character-not-single-quote-or-backslash-conc2

(defun cst-basic-character-not-single-quote-or-backslash-conc2
       (abnf::cst)
 (declare (xargs :guard (abnf::treep abnf::cst)))
 (declare
  (xargs
   :guard
   (and (cst-matchp abnf::cst
                    "basic-character-not-single-quote-or-backslash")
        (equal (cst-basic-character-not-single-quote-or-backslash-conc?
                    abnf::cst)
               2))))
 (let
   ((__function__
         'cst-basic-character-not-single-quote-or-backslash-conc2))
   (declare (ignorable __function__))
   (abnf::tree-nonleaf->branches abnf::cst)))

Theorem: tree-list-listp-of-cst-basic-character-not-single-quote-or-backslash-conc2

(defthm
 tree-list-listp-of-cst-basic-character-not-single-quote-or-backslash-conc2
 (b* ((abnf::cstss (cst-basic-character-not-single-quote-or-backslash-conc2
                        abnf::cst)))
   (abnf::tree-list-listp abnf::cstss))
 :rule-classes :rewrite)

Theorem: cst-basic-character-not-single-quote-or-backslash-conc2-match

(defthm
      cst-basic-character-not-single-quote-or-backslash-conc2-match
 (implies
   (and (cst-matchp abnf::cst
                    "basic-character-not-single-quote-or-backslash")
        (equal (cst-basic-character-not-single-quote-or-backslash-conc?
                    abnf::cst)
               2))
   (b* ((abnf::cstss (cst-basic-character-not-single-quote-or-backslash-conc2
                          abnf::cst)))
     (cst-list-list-conc-matchp abnf::cstss "digit")))
 :rule-classes :rewrite)

Theorem: cst-basic-character-not-single-quote-or-backslash-conc2-of-tree-fix-cst

(defthm
 cst-basic-character-not-single-quote-or-backslash-conc2-of-tree-fix-cst
 (equal (cst-basic-character-not-single-quote-or-backslash-conc2
             (abnf::tree-fix abnf::cst))
        (cst-basic-character-not-single-quote-or-backslash-conc2
             abnf::cst)))

Theorem: cst-basic-character-not-single-quote-or-backslash-conc2-tree-equiv-congruence-on-cst

(defthm
 cst-basic-character-not-single-quote-or-backslash-conc2-tree-equiv-congruence-on-cst
 (implies (abnf::tree-equiv abnf::cst cst-equiv)
          (equal (cst-basic-character-not-single-quote-or-backslash-conc2
                      abnf::cst)
                 (cst-basic-character-not-single-quote-or-backslash-conc2
                      cst-equiv)))
 :rule-classes :congruence)

Function: cst-basic-character-not-single-quote-or-backslash-conc3

(defun cst-basic-character-not-single-quote-or-backslash-conc3
       (abnf::cst)
 (declare (xargs :guard (abnf::treep abnf::cst)))
 (declare
  (xargs
   :guard
   (and (cst-matchp abnf::cst
                    "basic-character-not-single-quote-or-backslash")
        (equal (cst-basic-character-not-single-quote-or-backslash-conc?
                    abnf::cst)
               3))))
 (let
   ((__function__
         'cst-basic-character-not-single-quote-or-backslash-conc3))
   (declare (ignorable __function__))
   (abnf::tree-nonleaf->branches abnf::cst)))

Theorem: tree-list-listp-of-cst-basic-character-not-single-quote-or-backslash-conc3

(defthm
 tree-list-listp-of-cst-basic-character-not-single-quote-or-backslash-conc3
 (b* ((abnf::cstss (cst-basic-character-not-single-quote-or-backslash-conc3
                        abnf::cst)))
   (abnf::tree-list-listp abnf::cstss))
 :rule-classes :rewrite)

Theorem: cst-basic-character-not-single-quote-or-backslash-conc3-match

(defthm
      cst-basic-character-not-single-quote-or-backslash-conc3-match
 (implies
   (and (cst-matchp abnf::cst
                    "basic-character-not-single-quote-or-backslash")
        (equal (cst-basic-character-not-single-quote-or-backslash-conc?
                    abnf::cst)
               3))
   (b* ((abnf::cstss (cst-basic-character-not-single-quote-or-backslash-conc3
                          abnf::cst)))
     (cst-list-list-conc-matchp
          abnf::cstss
          "graphic-character-not-single-quote-or-backslash")))
 :rule-classes :rewrite)

Theorem: cst-basic-character-not-single-quote-or-backslash-conc3-of-tree-fix-cst

(defthm
 cst-basic-character-not-single-quote-or-backslash-conc3-of-tree-fix-cst
 (equal (cst-basic-character-not-single-quote-or-backslash-conc3
             (abnf::tree-fix abnf::cst))
        (cst-basic-character-not-single-quote-or-backslash-conc3
             abnf::cst)))

Theorem: cst-basic-character-not-single-quote-or-backslash-conc3-tree-equiv-congruence-on-cst

(defthm
 cst-basic-character-not-single-quote-or-backslash-conc3-tree-equiv-congruence-on-cst
 (implies (abnf::tree-equiv abnf::cst cst-equiv)
          (equal (cst-basic-character-not-single-quote-or-backslash-conc3
                      abnf::cst)
                 (cst-basic-character-not-single-quote-or-backslash-conc3
                      cst-equiv)))
 :rule-classes :congruence)

Function: cst-basic-character-not-single-quote-or-backslash-conc4

(defun cst-basic-character-not-single-quote-or-backslash-conc4
       (abnf::cst)
 (declare (xargs :guard (abnf::treep abnf::cst)))
 (declare
  (xargs
   :guard
   (and (cst-matchp abnf::cst
                    "basic-character-not-single-quote-or-backslash")
        (equal (cst-basic-character-not-single-quote-or-backslash-conc?
                    abnf::cst)
               4))))
 (let
   ((__function__
         'cst-basic-character-not-single-quote-or-backslash-conc4))
   (declare (ignorable __function__))
   (abnf::tree-nonleaf->branches abnf::cst)))

Theorem: tree-list-listp-of-cst-basic-character-not-single-quote-or-backslash-conc4

(defthm
 tree-list-listp-of-cst-basic-character-not-single-quote-or-backslash-conc4
 (b* ((abnf::cstss (cst-basic-character-not-single-quote-or-backslash-conc4
                        abnf::cst)))
   (abnf::tree-list-listp abnf::cstss))
 :rule-classes :rewrite)

Theorem: cst-basic-character-not-single-quote-or-backslash-conc4-match

(defthm
      cst-basic-character-not-single-quote-or-backslash-conc4-match
 (implies
   (and (cst-matchp abnf::cst
                    "basic-character-not-single-quote-or-backslash")
        (equal (cst-basic-character-not-single-quote-or-backslash-conc?
                    abnf::cst)
               4))
   (b* ((abnf::cstss (cst-basic-character-not-single-quote-or-backslash-conc4
                          abnf::cst)))
     (cst-list-list-conc-matchp abnf::cstss "space")))
 :rule-classes :rewrite)

Theorem: cst-basic-character-not-single-quote-or-backslash-conc4-of-tree-fix-cst

(defthm
 cst-basic-character-not-single-quote-or-backslash-conc4-of-tree-fix-cst
 (equal (cst-basic-character-not-single-quote-or-backslash-conc4
             (abnf::tree-fix abnf::cst))
        (cst-basic-character-not-single-quote-or-backslash-conc4
             abnf::cst)))

Theorem: cst-basic-character-not-single-quote-or-backslash-conc4-tree-equiv-congruence-on-cst

(defthm
 cst-basic-character-not-single-quote-or-backslash-conc4-tree-equiv-congruence-on-cst
 (implies (abnf::tree-equiv abnf::cst cst-equiv)
          (equal (cst-basic-character-not-single-quote-or-backslash-conc4
                      abnf::cst)
                 (cst-basic-character-not-single-quote-or-backslash-conc4
                      cst-equiv)))
 :rule-classes :congruence)

Function: cst-basic-character-not-single-quote-or-backslash-conc5

(defun cst-basic-character-not-single-quote-or-backslash-conc5
       (abnf::cst)
 (declare (xargs :guard (abnf::treep abnf::cst)))
 (declare
  (xargs
   :guard
   (and (cst-matchp abnf::cst
                    "basic-character-not-single-quote-or-backslash")
        (equal (cst-basic-character-not-single-quote-or-backslash-conc?
                    abnf::cst)
               5))))
 (let
   ((__function__
         'cst-basic-character-not-single-quote-or-backslash-conc5))
   (declare (ignorable __function__))
   (abnf::tree-nonleaf->branches abnf::cst)))

Theorem: tree-list-listp-of-cst-basic-character-not-single-quote-or-backslash-conc5

(defthm
 tree-list-listp-of-cst-basic-character-not-single-quote-or-backslash-conc5
 (b* ((abnf::cstss (cst-basic-character-not-single-quote-or-backslash-conc5
                        abnf::cst)))
   (abnf::tree-list-listp abnf::cstss))
 :rule-classes :rewrite)

Theorem: cst-basic-character-not-single-quote-or-backslash-conc5-match

(defthm
      cst-basic-character-not-single-quote-or-backslash-conc5-match
 (implies
   (and (cst-matchp abnf::cst
                    "basic-character-not-single-quote-or-backslash")
        (equal (cst-basic-character-not-single-quote-or-backslash-conc?
                    abnf::cst)
               5))
   (b* ((abnf::cstss (cst-basic-character-not-single-quote-or-backslash-conc5
                          abnf::cst)))
     (cst-list-list-conc-matchp abnf::cstss "control-character")))
 :rule-classes :rewrite)

Theorem: cst-basic-character-not-single-quote-or-backslash-conc5-of-tree-fix-cst

(defthm
 cst-basic-character-not-single-quote-or-backslash-conc5-of-tree-fix-cst
 (equal (cst-basic-character-not-single-quote-or-backslash-conc5
             (abnf::tree-fix abnf::cst))
        (cst-basic-character-not-single-quote-or-backslash-conc5
             abnf::cst)))

Theorem: cst-basic-character-not-single-quote-or-backslash-conc5-tree-equiv-congruence-on-cst

(defthm
 cst-basic-character-not-single-quote-or-backslash-conc5-tree-equiv-congruence-on-cst
 (implies (abnf::tree-equiv abnf::cst cst-equiv)
          (equal (cst-basic-character-not-single-quote-or-backslash-conc5
                      abnf::cst)
                 (cst-basic-character-not-single-quote-or-backslash-conc5
                      cst-equiv)))
 :rule-classes :congruence)

Function: cst-basic-character-not-double-quote-or-backslash-conc1

(defun cst-basic-character-not-double-quote-or-backslash-conc1
       (abnf::cst)
 (declare (xargs :guard (abnf::treep abnf::cst)))
 (declare
  (xargs
   :guard
   (and (cst-matchp abnf::cst
                    "basic-character-not-double-quote-or-backslash")
        (equal (cst-basic-character-not-double-quote-or-backslash-conc?
                    abnf::cst)
               1))))
 (let
   ((__function__
         'cst-basic-character-not-double-quote-or-backslash-conc1))
   (declare (ignorable __function__))
   (abnf::tree-nonleaf->branches abnf::cst)))

Theorem: tree-list-listp-of-cst-basic-character-not-double-quote-or-backslash-conc1

(defthm
 tree-list-listp-of-cst-basic-character-not-double-quote-or-backslash-conc1
 (b* ((abnf::cstss (cst-basic-character-not-double-quote-or-backslash-conc1
                        abnf::cst)))
   (abnf::tree-list-listp abnf::cstss))
 :rule-classes :rewrite)

Theorem: cst-basic-character-not-double-quote-or-backslash-conc1-match

(defthm
      cst-basic-character-not-double-quote-or-backslash-conc1-match
 (implies
   (and (cst-matchp abnf::cst
                    "basic-character-not-double-quote-or-backslash")
        (equal (cst-basic-character-not-double-quote-or-backslash-conc?
                    abnf::cst)
               1))
   (b* ((abnf::cstss (cst-basic-character-not-double-quote-or-backslash-conc1
                          abnf::cst)))
     (cst-list-list-conc-matchp abnf::cstss "letter")))
 :rule-classes :rewrite)

Theorem: cst-basic-character-not-double-quote-or-backslash-conc1-of-tree-fix-cst

(defthm
 cst-basic-character-not-double-quote-or-backslash-conc1-of-tree-fix-cst
 (equal (cst-basic-character-not-double-quote-or-backslash-conc1
             (abnf::tree-fix abnf::cst))
        (cst-basic-character-not-double-quote-or-backslash-conc1
             abnf::cst)))

Theorem: cst-basic-character-not-double-quote-or-backslash-conc1-tree-equiv-congruence-on-cst

(defthm
 cst-basic-character-not-double-quote-or-backslash-conc1-tree-equiv-congruence-on-cst
 (implies (abnf::tree-equiv abnf::cst cst-equiv)
          (equal (cst-basic-character-not-double-quote-or-backslash-conc1
                      abnf::cst)
                 (cst-basic-character-not-double-quote-or-backslash-conc1
                      cst-equiv)))
 :rule-classes :congruence)

Function: cst-basic-character-not-double-quote-or-backslash-conc2

(defun cst-basic-character-not-double-quote-or-backslash-conc2
       (abnf::cst)
 (declare (xargs :guard (abnf::treep abnf::cst)))
 (declare
  (xargs
   :guard
   (and (cst-matchp abnf::cst
                    "basic-character-not-double-quote-or-backslash")
        (equal (cst-basic-character-not-double-quote-or-backslash-conc?
                    abnf::cst)
               2))))
 (let
   ((__function__
         'cst-basic-character-not-double-quote-or-backslash-conc2))
   (declare (ignorable __function__))
   (abnf::tree-nonleaf->branches abnf::cst)))

Theorem: tree-list-listp-of-cst-basic-character-not-double-quote-or-backslash-conc2

(defthm
 tree-list-listp-of-cst-basic-character-not-double-quote-or-backslash-conc2
 (b* ((abnf::cstss (cst-basic-character-not-double-quote-or-backslash-conc2
                        abnf::cst)))
   (abnf::tree-list-listp abnf::cstss))
 :rule-classes :rewrite)

Theorem: cst-basic-character-not-double-quote-or-backslash-conc2-match

(defthm
      cst-basic-character-not-double-quote-or-backslash-conc2-match
 (implies
   (and (cst-matchp abnf::cst
                    "basic-character-not-double-quote-or-backslash")
        (equal (cst-basic-character-not-double-quote-or-backslash-conc?
                    abnf::cst)
               2))
   (b* ((abnf::cstss (cst-basic-character-not-double-quote-or-backslash-conc2
                          abnf::cst)))
     (cst-list-list-conc-matchp abnf::cstss "digit")))
 :rule-classes :rewrite)

Theorem: cst-basic-character-not-double-quote-or-backslash-conc2-of-tree-fix-cst

(defthm
 cst-basic-character-not-double-quote-or-backslash-conc2-of-tree-fix-cst
 (equal (cst-basic-character-not-double-quote-or-backslash-conc2
             (abnf::tree-fix abnf::cst))
        (cst-basic-character-not-double-quote-or-backslash-conc2
             abnf::cst)))

Theorem: cst-basic-character-not-double-quote-or-backslash-conc2-tree-equiv-congruence-on-cst

(defthm
 cst-basic-character-not-double-quote-or-backslash-conc2-tree-equiv-congruence-on-cst
 (implies (abnf::tree-equiv abnf::cst cst-equiv)
          (equal (cst-basic-character-not-double-quote-or-backslash-conc2
                      abnf::cst)
                 (cst-basic-character-not-double-quote-or-backslash-conc2
                      cst-equiv)))
 :rule-classes :congruence)

Function: cst-basic-character-not-double-quote-or-backslash-conc3

(defun cst-basic-character-not-double-quote-or-backslash-conc3
       (abnf::cst)
 (declare (xargs :guard (abnf::treep abnf::cst)))
 (declare
  (xargs
   :guard
   (and (cst-matchp abnf::cst
                    "basic-character-not-double-quote-or-backslash")
        (equal (cst-basic-character-not-double-quote-or-backslash-conc?
                    abnf::cst)
               3))))
 (let
   ((__function__
         'cst-basic-character-not-double-quote-or-backslash-conc3))
   (declare (ignorable __function__))
   (abnf::tree-nonleaf->branches abnf::cst)))

Theorem: tree-list-listp-of-cst-basic-character-not-double-quote-or-backslash-conc3

(defthm
 tree-list-listp-of-cst-basic-character-not-double-quote-or-backslash-conc3
 (b* ((abnf::cstss (cst-basic-character-not-double-quote-or-backslash-conc3
                        abnf::cst)))
   (abnf::tree-list-listp abnf::cstss))
 :rule-classes :rewrite)

Theorem: cst-basic-character-not-double-quote-or-backslash-conc3-match

(defthm
      cst-basic-character-not-double-quote-or-backslash-conc3-match
 (implies
   (and (cst-matchp abnf::cst
                    "basic-character-not-double-quote-or-backslash")
        (equal (cst-basic-character-not-double-quote-or-backslash-conc?
                    abnf::cst)
               3))
   (b* ((abnf::cstss (cst-basic-character-not-double-quote-or-backslash-conc3
                          abnf::cst)))
     (cst-list-list-conc-matchp
          abnf::cstss
          "graphic-character-not-double-quote-or-backslash")))
 :rule-classes :rewrite)

Theorem: cst-basic-character-not-double-quote-or-backslash-conc3-of-tree-fix-cst

(defthm
 cst-basic-character-not-double-quote-or-backslash-conc3-of-tree-fix-cst
 (equal (cst-basic-character-not-double-quote-or-backslash-conc3
             (abnf::tree-fix abnf::cst))
        (cst-basic-character-not-double-quote-or-backslash-conc3
             abnf::cst)))

Theorem: cst-basic-character-not-double-quote-or-backslash-conc3-tree-equiv-congruence-on-cst

(defthm
 cst-basic-character-not-double-quote-or-backslash-conc3-tree-equiv-congruence-on-cst
 (implies (abnf::tree-equiv abnf::cst cst-equiv)
          (equal (cst-basic-character-not-double-quote-or-backslash-conc3
                      abnf::cst)
                 (cst-basic-character-not-double-quote-or-backslash-conc3
                      cst-equiv)))
 :rule-classes :congruence)

Function: cst-basic-character-not-double-quote-or-backslash-conc4

(defun cst-basic-character-not-double-quote-or-backslash-conc4
       (abnf::cst)
 (declare (xargs :guard (abnf::treep abnf::cst)))
 (declare
  (xargs
   :guard
   (and (cst-matchp abnf::cst
                    "basic-character-not-double-quote-or-backslash")
        (equal (cst-basic-character-not-double-quote-or-backslash-conc?
                    abnf::cst)
               4))))
 (let
   ((__function__
         'cst-basic-character-not-double-quote-or-backslash-conc4))
   (declare (ignorable __function__))
   (abnf::tree-nonleaf->branches abnf::cst)))

Theorem: tree-list-listp-of-cst-basic-character-not-double-quote-or-backslash-conc4

(defthm
 tree-list-listp-of-cst-basic-character-not-double-quote-or-backslash-conc4
 (b* ((abnf::cstss (cst-basic-character-not-double-quote-or-backslash-conc4
                        abnf::cst)))
   (abnf::tree-list-listp abnf::cstss))
 :rule-classes :rewrite)

Theorem: cst-basic-character-not-double-quote-or-backslash-conc4-match

(defthm
      cst-basic-character-not-double-quote-or-backslash-conc4-match
 (implies
   (and (cst-matchp abnf::cst
                    "basic-character-not-double-quote-or-backslash")
        (equal (cst-basic-character-not-double-quote-or-backslash-conc?
                    abnf::cst)
               4))
   (b* ((abnf::cstss (cst-basic-character-not-double-quote-or-backslash-conc4
                          abnf::cst)))
     (cst-list-list-conc-matchp abnf::cstss "space")))
 :rule-classes :rewrite)

Theorem: cst-basic-character-not-double-quote-or-backslash-conc4-of-tree-fix-cst

(defthm
 cst-basic-character-not-double-quote-or-backslash-conc4-of-tree-fix-cst
 (equal (cst-basic-character-not-double-quote-or-backslash-conc4
             (abnf::tree-fix abnf::cst))
        (cst-basic-character-not-double-quote-or-backslash-conc4
             abnf::cst)))

Theorem: cst-basic-character-not-double-quote-or-backslash-conc4-tree-equiv-congruence-on-cst

(defthm
 cst-basic-character-not-double-quote-or-backslash-conc4-tree-equiv-congruence-on-cst
 (implies (abnf::tree-equiv abnf::cst cst-equiv)
          (equal (cst-basic-character-not-double-quote-or-backslash-conc4
                      abnf::cst)
                 (cst-basic-character-not-double-quote-or-backslash-conc4
                      cst-equiv)))
 :rule-classes :congruence)

Function: cst-basic-character-not-double-quote-or-backslash-conc5

(defun cst-basic-character-not-double-quote-or-backslash-conc5
       (abnf::cst)
 (declare (xargs :guard (abnf::treep abnf::cst)))
 (declare
  (xargs
   :guard
   (and (cst-matchp abnf::cst
                    "basic-character-not-double-quote-or-backslash")
        (equal (cst-basic-character-not-double-quote-or-backslash-conc?
                    abnf::cst)
               5))))
 (let
   ((__function__
         'cst-basic-character-not-double-quote-or-backslash-conc5))
   (declare (ignorable __function__))
   (abnf::tree-nonleaf->branches abnf::cst)))

Theorem: tree-list-listp-of-cst-basic-character-not-double-quote-or-backslash-conc5

(defthm
 tree-list-listp-of-cst-basic-character-not-double-quote-or-backslash-conc5
 (b* ((abnf::cstss (cst-basic-character-not-double-quote-or-backslash-conc5
                        abnf::cst)))
   (abnf::tree-list-listp abnf::cstss))
 :rule-classes :rewrite)

Theorem: cst-basic-character-not-double-quote-or-backslash-conc5-match

(defthm
      cst-basic-character-not-double-quote-or-backslash-conc5-match
 (implies
   (and (cst-matchp abnf::cst
                    "basic-character-not-double-quote-or-backslash")
        (equal (cst-basic-character-not-double-quote-or-backslash-conc?
                    abnf::cst)
               5))
   (b* ((abnf::cstss (cst-basic-character-not-double-quote-or-backslash-conc5
                          abnf::cst)))
     (cst-list-list-conc-matchp abnf::cstss "control-character")))
 :rule-classes :rewrite)

Theorem: cst-basic-character-not-double-quote-or-backslash-conc5-of-tree-fix-cst

(defthm
 cst-basic-character-not-double-quote-or-backslash-conc5-of-tree-fix-cst
 (equal (cst-basic-character-not-double-quote-or-backslash-conc5
             (abnf::tree-fix abnf::cst))
        (cst-basic-character-not-double-quote-or-backslash-conc5
             abnf::cst)))

Theorem: cst-basic-character-not-double-quote-or-backslash-conc5-tree-equiv-congruence-on-cst

(defthm
 cst-basic-character-not-double-quote-or-backslash-conc5-tree-equiv-congruence-on-cst
 (implies (abnf::tree-equiv abnf::cst cst-equiv)
          (equal (cst-basic-character-not-double-quote-or-backslash-conc5
                      abnf::cst)
                 (cst-basic-character-not-double-quote-or-backslash-conc5
                      cst-equiv)))
 :rule-classes :congruence)

Function: cst-character-not-new-line-conc1

(defun cst-character-not-new-line-conc1 (abnf::cst)
 (declare (xargs :guard (abnf::treep abnf::cst)))
 (declare
  (xargs
     :guard (and (cst-matchp abnf::cst "character-not-new-line")
                 (equal (cst-character-not-new-line-conc? abnf::cst)
                        1))))
 (let ((__function__ 'cst-character-not-new-line-conc1))
   (declare (ignorable __function__))
   (abnf::tree-nonleaf->branches abnf::cst)))

Theorem: tree-list-listp-of-cst-character-not-new-line-conc1

(defthm tree-list-listp-of-cst-character-not-new-line-conc1
  (b* ((abnf::cstss (cst-character-not-new-line-conc1 abnf::cst)))
    (abnf::tree-list-listp abnf::cstss))
  :rule-classes :rewrite)

Theorem: cst-character-not-new-line-conc1-match

(defthm cst-character-not-new-line-conc1-match
 (implies
    (and (cst-matchp abnf::cst "character-not-new-line")
         (equal (cst-character-not-new-line-conc? abnf::cst)
                1))
    (b* ((abnf::cstss (cst-character-not-new-line-conc1 abnf::cst)))
      (cst-list-list-conc-matchp abnf::cstss "basic-character")))
 :rule-classes :rewrite)

Theorem: cst-character-not-new-line-conc1-of-tree-fix-cst

(defthm cst-character-not-new-line-conc1-of-tree-fix-cst
  (equal
       (cst-character-not-new-line-conc1 (abnf::tree-fix abnf::cst))
       (cst-character-not-new-line-conc1 abnf::cst)))

Theorem: cst-character-not-new-line-conc1-tree-equiv-congruence-on-cst

(defthm
      cst-character-not-new-line-conc1-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-character-not-new-line-conc1 abnf::cst)
                  (cst-character-not-new-line-conc1 cst-equiv)))
  :rule-classes :congruence)

Function: cst-character-not-new-line-conc2

(defun cst-character-not-new-line-conc2 (abnf::cst)
 (declare (xargs :guard (abnf::treep abnf::cst)))
 (declare
  (xargs
     :guard (and (cst-matchp abnf::cst "character-not-new-line")
                 (equal (cst-character-not-new-line-conc? abnf::cst)
                        2))))
 (let ((__function__ 'cst-character-not-new-line-conc2))
   (declare (ignorable __function__))
   (abnf::tree-nonleaf->branches abnf::cst)))

Theorem: tree-list-listp-of-cst-character-not-new-line-conc2

(defthm tree-list-listp-of-cst-character-not-new-line-conc2
  (b* ((abnf::cstss (cst-character-not-new-line-conc2 abnf::cst)))
    (abnf::tree-list-listp abnf::cstss))
  :rule-classes :rewrite)

Theorem: cst-character-not-new-line-conc2-match

(defthm cst-character-not-new-line-conc2-match
 (implies
   (and (cst-matchp abnf::cst "character-not-new-line")
        (equal (cst-character-not-new-line-conc? abnf::cst)
               2))
   (b* ((abnf::cstss (cst-character-not-new-line-conc2 abnf::cst)))
     (cst-list-list-conc-matchp abnf::cstss
                                "extended-character-not-new-line")))
 :rule-classes :rewrite)

Theorem: cst-character-not-new-line-conc2-of-tree-fix-cst

(defthm cst-character-not-new-line-conc2-of-tree-fix-cst
  (equal
       (cst-character-not-new-line-conc2 (abnf::tree-fix abnf::cst))
       (cst-character-not-new-line-conc2 abnf::cst)))

Theorem: cst-character-not-new-line-conc2-tree-equiv-congruence-on-cst

(defthm
      cst-character-not-new-line-conc2-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-character-not-new-line-conc2 abnf::cst)
                  (cst-character-not-new-line-conc2 cst-equiv)))
  :rule-classes :congruence)

Function: cst-character-not-star-conc1

(defun cst-character-not-star-conc1 (abnf::cst)
 (declare (xargs :guard (abnf::treep abnf::cst)))
 (declare
  (xargs :guard (and (cst-matchp abnf::cst "character-not-star")
                     (equal (cst-character-not-star-conc? abnf::cst)
                            1))))
 (let ((__function__ 'cst-character-not-star-conc1))
   (declare (ignorable __function__))
   (abnf::tree-nonleaf->branches abnf::cst)))

Theorem: tree-list-listp-of-cst-character-not-star-conc1

(defthm tree-list-listp-of-cst-character-not-star-conc1
  (b* ((abnf::cstss (cst-character-not-star-conc1 abnf::cst)))
    (abnf::tree-list-listp abnf::cstss))
  :rule-classes :rewrite)

Theorem: cst-character-not-star-conc1-match

(defthm cst-character-not-star-conc1-match
  (implies
       (and (cst-matchp abnf::cst "character-not-star")
            (equal (cst-character-not-star-conc? abnf::cst)
                   1))
       (b* ((abnf::cstss (cst-character-not-star-conc1 abnf::cst)))
         (cst-list-list-conc-matchp abnf::cstss
                                    "basic-character-not-star")))
  :rule-classes :rewrite)

Theorem: cst-character-not-star-conc1-of-tree-fix-cst

(defthm cst-character-not-star-conc1-of-tree-fix-cst
  (equal (cst-character-not-star-conc1 (abnf::tree-fix abnf::cst))
         (cst-character-not-star-conc1 abnf::cst)))

Theorem: cst-character-not-star-conc1-tree-equiv-congruence-on-cst

(defthm cst-character-not-star-conc1-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-character-not-star-conc1 abnf::cst)
                  (cst-character-not-star-conc1 cst-equiv)))
  :rule-classes :congruence)

Function: cst-character-not-star-conc2

(defun cst-character-not-star-conc2 (abnf::cst)
 (declare (xargs :guard (abnf::treep abnf::cst)))
 (declare
  (xargs :guard (and (cst-matchp abnf::cst "character-not-star")
                     (equal (cst-character-not-star-conc? abnf::cst)
                            2))))
 (let ((__function__ 'cst-character-not-star-conc2))
   (declare (ignorable __function__))
   (abnf::tree-nonleaf->branches abnf::cst)))

Theorem: tree-list-listp-of-cst-character-not-star-conc2

(defthm tree-list-listp-of-cst-character-not-star-conc2
  (b* ((abnf::cstss (cst-character-not-star-conc2 abnf::cst)))
    (abnf::tree-list-listp abnf::cstss))
  :rule-classes :rewrite)

Theorem: cst-character-not-star-conc2-match

(defthm cst-character-not-star-conc2-match
 (implies
    (and (cst-matchp abnf::cst "character-not-star")
         (equal (cst-character-not-star-conc? abnf::cst)
                2))
    (b* ((abnf::cstss (cst-character-not-star-conc2 abnf::cst)))
      (cst-list-list-conc-matchp abnf::cstss "extended-character")))
 :rule-classes :rewrite)

Theorem: cst-character-not-star-conc2-of-tree-fix-cst

(defthm cst-character-not-star-conc2-of-tree-fix-cst
  (equal (cst-character-not-star-conc2 (abnf::tree-fix abnf::cst))
         (cst-character-not-star-conc2 abnf::cst)))

Theorem: cst-character-not-star-conc2-tree-equiv-congruence-on-cst

(defthm cst-character-not-star-conc2-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-character-not-star-conc2 abnf::cst)
                  (cst-character-not-star-conc2 cst-equiv)))
  :rule-classes :congruence)

Function: cst-character-not-star-or-slash-conc1

(defun cst-character-not-star-or-slash-conc1 (abnf::cst)
 (declare (xargs :guard (abnf::treep abnf::cst)))
 (declare
  (xargs
       :guard
       (and (cst-matchp abnf::cst "character-not-star-or-slash")
            (equal (cst-character-not-star-or-slash-conc? abnf::cst)
                   1))))
 (let ((__function__ 'cst-character-not-star-or-slash-conc1))
   (declare (ignorable __function__))
   (abnf::tree-nonleaf->branches abnf::cst)))

Theorem: tree-list-listp-of-cst-character-not-star-or-slash-conc1

(defthm tree-list-listp-of-cst-character-not-star-or-slash-conc1
  (b*
   ((abnf::cstss (cst-character-not-star-or-slash-conc1 abnf::cst)))
   (abnf::tree-list-listp abnf::cstss))
  :rule-classes :rewrite)

Theorem: cst-character-not-star-or-slash-conc1-match

(defthm cst-character-not-star-or-slash-conc1-match
 (implies
  (and (cst-matchp abnf::cst "character-not-star-or-slash")
       (equal (cst-character-not-star-or-slash-conc? abnf::cst)
              1))
  (b*
   ((abnf::cstss (cst-character-not-star-or-slash-conc1 abnf::cst)))
   (cst-list-list-conc-matchp abnf::cstss
                              "basic-character-not-star-or-slash")))
 :rule-classes :rewrite)

Theorem: cst-character-not-star-or-slash-conc1-of-tree-fix-cst

(defthm cst-character-not-star-or-slash-conc1-of-tree-fix-cst
 (equal
  (cst-character-not-star-or-slash-conc1 (abnf::tree-fix abnf::cst))
  (cst-character-not-star-or-slash-conc1 abnf::cst)))

Theorem: cst-character-not-star-or-slash-conc1-tree-equiv-congruence-on-cst

(defthm
 cst-character-not-star-or-slash-conc1-tree-equiv-congruence-on-cst
 (implies (abnf::tree-equiv abnf::cst cst-equiv)
          (equal (cst-character-not-star-or-slash-conc1 abnf::cst)
                 (cst-character-not-star-or-slash-conc1 cst-equiv)))
 :rule-classes :congruence)

Function: cst-character-not-star-or-slash-conc2

(defun cst-character-not-star-or-slash-conc2 (abnf::cst)
 (declare (xargs :guard (abnf::treep abnf::cst)))
 (declare
  (xargs
       :guard
       (and (cst-matchp abnf::cst "character-not-star-or-slash")
            (equal (cst-character-not-star-or-slash-conc? abnf::cst)
                   2))))
 (let ((__function__ 'cst-character-not-star-or-slash-conc2))
   (declare (ignorable __function__))
   (abnf::tree-nonleaf->branches abnf::cst)))

Theorem: tree-list-listp-of-cst-character-not-star-or-slash-conc2

(defthm tree-list-listp-of-cst-character-not-star-or-slash-conc2
  (b*
   ((abnf::cstss (cst-character-not-star-or-slash-conc2 abnf::cst)))
   (abnf::tree-list-listp abnf::cstss))
  :rule-classes :rewrite)

Theorem: cst-character-not-star-or-slash-conc2-match

(defthm cst-character-not-star-or-slash-conc2-match
 (implies
  (and (cst-matchp abnf::cst "character-not-star-or-slash")
       (equal (cst-character-not-star-or-slash-conc? abnf::cst)
              2))
  (b*
   ((abnf::cstss (cst-character-not-star-or-slash-conc2 abnf::cst)))
   (cst-list-list-conc-matchp abnf::cstss "extended-character")))
 :rule-classes :rewrite)

Theorem: cst-character-not-star-or-slash-conc2-of-tree-fix-cst

(defthm cst-character-not-star-or-slash-conc2-of-tree-fix-cst
 (equal
  (cst-character-not-star-or-slash-conc2 (abnf::tree-fix abnf::cst))
  (cst-character-not-star-or-slash-conc2 abnf::cst)))

Theorem: cst-character-not-star-or-slash-conc2-tree-equiv-congruence-on-cst

(defthm
 cst-character-not-star-or-slash-conc2-tree-equiv-congruence-on-cst
 (implies (abnf::tree-equiv abnf::cst cst-equiv)
          (equal (cst-character-not-star-or-slash-conc2 abnf::cst)
                 (cst-character-not-star-or-slash-conc2 cst-equiv)))
 :rule-classes :congruence)

Function: cst-character-not-greater-than-or-new-line-conc1

(defun cst-character-not-greater-than-or-new-line-conc1 (abnf::cst)
 (declare (xargs :guard (abnf::treep abnf::cst)))
 (declare
  (xargs
   :guard
   (and
    (cst-matchp abnf::cst
                "character-not-greater-than-or-new-line")
    (equal
        (cst-character-not-greater-than-or-new-line-conc? abnf::cst)
        1))))
 (let
  ((__function__ 'cst-character-not-greater-than-or-new-line-conc1))
  (declare (ignorable __function__))
  (abnf::tree-nonleaf->branches abnf::cst)))

Theorem: tree-list-listp-of-cst-character-not-greater-than-or-new-line-conc1

(defthm
 tree-list-listp-of-cst-character-not-greater-than-or-new-line-conc1
 (b*
  ((abnf::cstss
      (cst-character-not-greater-than-or-new-line-conc1 abnf::cst)))
  (abnf::tree-list-listp abnf::cstss))
 :rule-classes :rewrite)

Theorem: cst-character-not-greater-than-or-new-line-conc1-match

(defthm cst-character-not-greater-than-or-new-line-conc1-match
 (implies
  (and
   (cst-matchp abnf::cst
               "character-not-greater-than-or-new-line")
   (equal
        (cst-character-not-greater-than-or-new-line-conc? abnf::cst)
        1))
  (b*
   ((abnf::cstss
      (cst-character-not-greater-than-or-new-line-conc1 abnf::cst)))
   (cst-list-list-conc-matchp abnf::cstss
                              "basic-character-not-greater-than")))
 :rule-classes :rewrite)

Theorem: cst-character-not-greater-than-or-new-line-conc1-of-tree-fix-cst

(defthm
   cst-character-not-greater-than-or-new-line-conc1-of-tree-fix-cst
 (equal
      (cst-character-not-greater-than-or-new-line-conc1
           (abnf::tree-fix abnf::cst))
      (cst-character-not-greater-than-or-new-line-conc1 abnf::cst)))

Theorem: cst-character-not-greater-than-or-new-line-conc1-tree-equiv-congruence-on-cst

(defthm
 cst-character-not-greater-than-or-new-line-conc1-tree-equiv-congruence-on-cst
 (implies
  (abnf::tree-equiv abnf::cst cst-equiv)
  (equal
      (cst-character-not-greater-than-or-new-line-conc1 abnf::cst)
      (cst-character-not-greater-than-or-new-line-conc1 cst-equiv)))
 :rule-classes :congruence)

Function: cst-character-not-greater-than-or-new-line-conc2

(defun cst-character-not-greater-than-or-new-line-conc2 (abnf::cst)
 (declare (xargs :guard (abnf::treep abnf::cst)))
 (declare
  (xargs
   :guard
   (and
    (cst-matchp abnf::cst
                "character-not-greater-than-or-new-line")
    (equal
        (cst-character-not-greater-than-or-new-line-conc? abnf::cst)
        2))))
 (let
  ((__function__ 'cst-character-not-greater-than-or-new-line-conc2))
  (declare (ignorable __function__))
  (abnf::tree-nonleaf->branches abnf::cst)))

Theorem: tree-list-listp-of-cst-character-not-greater-than-or-new-line-conc2

(defthm
 tree-list-listp-of-cst-character-not-greater-than-or-new-line-conc2
 (b*
  ((abnf::cstss
      (cst-character-not-greater-than-or-new-line-conc2 abnf::cst)))
  (abnf::tree-list-listp abnf::cstss))
 :rule-classes :rewrite)

Theorem: cst-character-not-greater-than-or-new-line-conc2-match

(defthm cst-character-not-greater-than-or-new-line-conc2-match
 (implies
  (and
   (cst-matchp abnf::cst
               "character-not-greater-than-or-new-line")
   (equal
        (cst-character-not-greater-than-or-new-line-conc? abnf::cst)
        2))
  (b*
   ((abnf::cstss
      (cst-character-not-greater-than-or-new-line-conc2 abnf::cst)))
   (cst-list-list-conc-matchp abnf::cstss
                              "extended-character-not-new-line")))
 :rule-classes :rewrite)

Theorem: cst-character-not-greater-than-or-new-line-conc2-of-tree-fix-cst

(defthm
   cst-character-not-greater-than-or-new-line-conc2-of-tree-fix-cst
 (equal
      (cst-character-not-greater-than-or-new-line-conc2
           (abnf::tree-fix abnf::cst))
      (cst-character-not-greater-than-or-new-line-conc2 abnf::cst)))

Theorem: cst-character-not-greater-than-or-new-line-conc2-tree-equiv-congruence-on-cst

(defthm
 cst-character-not-greater-than-or-new-line-conc2-tree-equiv-congruence-on-cst
 (implies
  (abnf::tree-equiv abnf::cst cst-equiv)
  (equal
      (cst-character-not-greater-than-or-new-line-conc2 abnf::cst)
      (cst-character-not-greater-than-or-new-line-conc2 cst-equiv)))
 :rule-classes :congruence)

Function: cst-character-not-double-quote-or-new-line-conc1

(defun cst-character-not-double-quote-or-new-line-conc1 (abnf::cst)
 (declare (xargs :guard (abnf::treep abnf::cst)))
 (declare
  (xargs
   :guard
   (and
    (cst-matchp abnf::cst
                "character-not-double-quote-or-new-line")
    (equal
        (cst-character-not-double-quote-or-new-line-conc? abnf::cst)
        1))))
 (let
  ((__function__ 'cst-character-not-double-quote-or-new-line-conc1))
  (declare (ignorable __function__))
  (abnf::tree-nonleaf->branches abnf::cst)))

Theorem: tree-list-listp-of-cst-character-not-double-quote-or-new-line-conc1

(defthm
 tree-list-listp-of-cst-character-not-double-quote-or-new-line-conc1
 (b*
  ((abnf::cstss
      (cst-character-not-double-quote-or-new-line-conc1 abnf::cst)))
  (abnf::tree-list-listp abnf::cstss))
 :rule-classes :rewrite)

Theorem: cst-character-not-double-quote-or-new-line-conc1-match

(defthm cst-character-not-double-quote-or-new-line-conc1-match
 (implies
  (and
   (cst-matchp abnf::cst
               "character-not-double-quote-or-new-line")
   (equal
        (cst-character-not-double-quote-or-new-line-conc? abnf::cst)
        1))
  (b*
   ((abnf::cstss
      (cst-character-not-double-quote-or-new-line-conc1 abnf::cst)))
   (cst-list-list-conc-matchp abnf::cstss
                              "basic-character-not-double-quote")))
 :rule-classes :rewrite)

Theorem: cst-character-not-double-quote-or-new-line-conc1-of-tree-fix-cst

(defthm
   cst-character-not-double-quote-or-new-line-conc1-of-tree-fix-cst
 (equal
      (cst-character-not-double-quote-or-new-line-conc1
           (abnf::tree-fix abnf::cst))
      (cst-character-not-double-quote-or-new-line-conc1 abnf::cst)))

Theorem: cst-character-not-double-quote-or-new-line-conc1-tree-equiv-congruence-on-cst

(defthm
 cst-character-not-double-quote-or-new-line-conc1-tree-equiv-congruence-on-cst
 (implies
  (abnf::tree-equiv abnf::cst cst-equiv)
  (equal
      (cst-character-not-double-quote-or-new-line-conc1 abnf::cst)
      (cst-character-not-double-quote-or-new-line-conc1 cst-equiv)))
 :rule-classes :congruence)

Function: cst-character-not-double-quote-or-new-line-conc2

(defun cst-character-not-double-quote-or-new-line-conc2 (abnf::cst)
 (declare (xargs :guard (abnf::treep abnf::cst)))
 (declare
  (xargs
   :guard
   (and
    (cst-matchp abnf::cst
                "character-not-double-quote-or-new-line")
    (equal
        (cst-character-not-double-quote-or-new-line-conc? abnf::cst)
        2))))
 (let
  ((__function__ 'cst-character-not-double-quote-or-new-line-conc2))
  (declare (ignorable __function__))
  (abnf::tree-nonleaf->branches abnf::cst)))

Theorem: tree-list-listp-of-cst-character-not-double-quote-or-new-line-conc2

(defthm
 tree-list-listp-of-cst-character-not-double-quote-or-new-line-conc2
 (b*
  ((abnf::cstss
      (cst-character-not-double-quote-or-new-line-conc2 abnf::cst)))
  (abnf::tree-list-listp abnf::cstss))
 :rule-classes :rewrite)

Theorem: cst-character-not-double-quote-or-new-line-conc2-match

(defthm cst-character-not-double-quote-or-new-line-conc2-match
 (implies
  (and
   (cst-matchp abnf::cst
               "character-not-double-quote-or-new-line")
   (equal
        (cst-character-not-double-quote-or-new-line-conc? abnf::cst)
        2))
  (b*
   ((abnf::cstss
      (cst-character-not-double-quote-or-new-line-conc2 abnf::cst)))
   (cst-list-list-conc-matchp abnf::cstss
                              "extended-character-not-new-line")))
 :rule-classes :rewrite)

Theorem: cst-character-not-double-quote-or-new-line-conc2-of-tree-fix-cst

(defthm
   cst-character-not-double-quote-or-new-line-conc2-of-tree-fix-cst
 (equal
      (cst-character-not-double-quote-or-new-line-conc2
           (abnf::tree-fix abnf::cst))
      (cst-character-not-double-quote-or-new-line-conc2 abnf::cst)))

Theorem: cst-character-not-double-quote-or-new-line-conc2-tree-equiv-congruence-on-cst

(defthm
 cst-character-not-double-quote-or-new-line-conc2-tree-equiv-congruence-on-cst
 (implies
  (abnf::tree-equiv abnf::cst cst-equiv)
  (equal
      (cst-character-not-double-quote-or-new-line-conc2 abnf::cst)
      (cst-character-not-double-quote-or-new-line-conc2 cst-equiv)))
 :rule-classes :congruence)

Function: cst-character-not-single-quote-or-backslash-or-new-line-conc1

(defun cst-character-not-single-quote-or-backslash-or-new-line-conc1
       (abnf::cst)
 (declare (xargs :guard (abnf::treep abnf::cst)))
 (declare
  (xargs
    :guard
    (and (cst-matchp
              abnf::cst
              "character-not-single-quote-or-backslash-or-new-line")
         (equal (cst-character-not-single-quote-or-backslash-or-new-line-conc?
                     abnf::cst)
                1))))
 (let
  ((__function__
    'cst-character-not-single-quote-or-backslash-or-new-line-conc1))
  (declare (ignorable __function__))
  (abnf::tree-nonleaf->branches abnf::cst)))

Theorem: tree-list-listp-of-cst-character-not-single-quote-or-backslash-or-new-line-conc1

(defthm
 tree-list-listp-of-cst-character-not-single-quote-or-backslash-or-new-line-conc1
 (b* ((abnf::cstss (cst-character-not-single-quote-or-backslash-or-new-line-conc1
                        abnf::cst)))
   (abnf::tree-list-listp abnf::cstss))
 :rule-classes :rewrite)

Theorem: cst-character-not-single-quote-or-backslash-or-new-line-conc1-match

(defthm
 cst-character-not-single-quote-or-backslash-or-new-line-conc1-match
 (implies
    (and (cst-matchp
              abnf::cst
              "character-not-single-quote-or-backslash-or-new-line")
         (equal (cst-character-not-single-quote-or-backslash-or-new-line-conc?
                     abnf::cst)
                1))
    (b* ((abnf::cstss (cst-character-not-single-quote-or-backslash-or-new-line-conc1
                           abnf::cst)))
      (cst-list-list-conc-matchp
           abnf::cstss
           "basic-character-not-single-quote-or-backslash")))
 :rule-classes :rewrite)

Theorem: cst-character-not-single-quote-or-backslash-or-new-line-conc1-of-tree-fix-cst

(defthm
 cst-character-not-single-quote-or-backslash-or-new-line-conc1-of-tree-fix-cst
 (equal (cst-character-not-single-quote-or-backslash-or-new-line-conc1
             (abnf::tree-fix abnf::cst))
        (cst-character-not-single-quote-or-backslash-or-new-line-conc1
             abnf::cst)))

Theorem: cst-character-not-single-quote-or-backslash-or-new-line-conc1-tree-equiv-congruence-on-cst

(defthm
 cst-character-not-single-quote-or-backslash-or-new-line-conc1-tree-equiv-congruence-on-cst
 (implies (abnf::tree-equiv abnf::cst cst-equiv)
          (equal (cst-character-not-single-quote-or-backslash-or-new-line-conc1
                      abnf::cst)
                 (cst-character-not-single-quote-or-backslash-or-new-line-conc1
                      cst-equiv)))
 :rule-classes :congruence)

Function: cst-character-not-single-quote-or-backslash-or-new-line-conc2

(defun cst-character-not-single-quote-or-backslash-or-new-line-conc2
       (abnf::cst)
 (declare (xargs :guard (abnf::treep abnf::cst)))
 (declare
  (xargs
    :guard
    (and (cst-matchp
              abnf::cst
              "character-not-single-quote-or-backslash-or-new-line")
         (equal (cst-character-not-single-quote-or-backslash-or-new-line-conc?
                     abnf::cst)
                2))))
 (let
  ((__function__
    'cst-character-not-single-quote-or-backslash-or-new-line-conc2))
  (declare (ignorable __function__))
  (abnf::tree-nonleaf->branches abnf::cst)))

Theorem: tree-list-listp-of-cst-character-not-single-quote-or-backslash-or-new-line-conc2

(defthm
 tree-list-listp-of-cst-character-not-single-quote-or-backslash-or-new-line-conc2
 (b* ((abnf::cstss (cst-character-not-single-quote-or-backslash-or-new-line-conc2
                        abnf::cst)))
   (abnf::tree-list-listp abnf::cstss))
 :rule-classes :rewrite)

Theorem: cst-character-not-single-quote-or-backslash-or-new-line-conc2-match

(defthm
 cst-character-not-single-quote-or-backslash-or-new-line-conc2-match
 (implies
   (and (cst-matchp
             abnf::cst
             "character-not-single-quote-or-backslash-or-new-line")
        (equal (cst-character-not-single-quote-or-backslash-or-new-line-conc?
                    abnf::cst)
               2))
   (b* ((abnf::cstss (cst-character-not-single-quote-or-backslash-or-new-line-conc2
                          abnf::cst)))
     (cst-list-list-conc-matchp abnf::cstss
                                "extended-character-not-new-line")))
 :rule-classes :rewrite)

Theorem: cst-character-not-single-quote-or-backslash-or-new-line-conc2-of-tree-fix-cst

(defthm
 cst-character-not-single-quote-or-backslash-or-new-line-conc2-of-tree-fix-cst
 (equal (cst-character-not-single-quote-or-backslash-or-new-line-conc2
             (abnf::tree-fix abnf::cst))
        (cst-character-not-single-quote-or-backslash-or-new-line-conc2
             abnf::cst)))

Theorem: cst-character-not-single-quote-or-backslash-or-new-line-conc2-tree-equiv-congruence-on-cst

(defthm
 cst-character-not-single-quote-or-backslash-or-new-line-conc2-tree-equiv-congruence-on-cst
 (implies (abnf::tree-equiv abnf::cst cst-equiv)
          (equal (cst-character-not-single-quote-or-backslash-or-new-line-conc2
                      abnf::cst)
                 (cst-character-not-single-quote-or-backslash-or-new-line-conc2
                      cst-equiv)))
 :rule-classes :congruence)

Function: cst-character-not-double-quote-or-backslash-or-new-line-conc1

(defun cst-character-not-double-quote-or-backslash-or-new-line-conc1
       (abnf::cst)
 (declare (xargs :guard (abnf::treep abnf::cst)))
 (declare
  (xargs
    :guard
    (and (cst-matchp
              abnf::cst
              "character-not-double-quote-or-backslash-or-new-line")
         (equal (cst-character-not-double-quote-or-backslash-or-new-line-conc?
                     abnf::cst)
                1))))
 (let
  ((__function__
    'cst-character-not-double-quote-or-backslash-or-new-line-conc1))
  (declare (ignorable __function__))
  (abnf::tree-nonleaf->branches abnf::cst)))

Theorem: tree-list-listp-of-cst-character-not-double-quote-or-backslash-or-new-line-conc1

(defthm
 tree-list-listp-of-cst-character-not-double-quote-or-backslash-or-new-line-conc1
 (b* ((abnf::cstss (cst-character-not-double-quote-or-backslash-or-new-line-conc1
                        abnf::cst)))
   (abnf::tree-list-listp abnf::cstss))
 :rule-classes :rewrite)

Theorem: cst-character-not-double-quote-or-backslash-or-new-line-conc1-match

(defthm
 cst-character-not-double-quote-or-backslash-or-new-line-conc1-match
 (implies
    (and (cst-matchp
              abnf::cst
              "character-not-double-quote-or-backslash-or-new-line")
         (equal (cst-character-not-double-quote-or-backslash-or-new-line-conc?
                     abnf::cst)
                1))
    (b* ((abnf::cstss (cst-character-not-double-quote-or-backslash-or-new-line-conc1
                           abnf::cst)))
      (cst-list-list-conc-matchp
           abnf::cstss
           "basic-character-not-double-quote-or-backslash")))
 :rule-classes :rewrite)

Theorem: cst-character-not-double-quote-or-backslash-or-new-line-conc1-of-tree-fix-cst

(defthm
 cst-character-not-double-quote-or-backslash-or-new-line-conc1-of-tree-fix-cst
 (equal (cst-character-not-double-quote-or-backslash-or-new-line-conc1
             (abnf::tree-fix abnf::cst))
        (cst-character-not-double-quote-or-backslash-or-new-line-conc1
             abnf::cst)))

Theorem: cst-character-not-double-quote-or-backslash-or-new-line-conc1-tree-equiv-congruence-on-cst

(defthm
 cst-character-not-double-quote-or-backslash-or-new-line-conc1-tree-equiv-congruence-on-cst
 (implies (abnf::tree-equiv abnf::cst cst-equiv)
          (equal (cst-character-not-double-quote-or-backslash-or-new-line-conc1
                      abnf::cst)
                 (cst-character-not-double-quote-or-backslash-or-new-line-conc1
                      cst-equiv)))
 :rule-classes :congruence)

Function: cst-character-not-double-quote-or-backslash-or-new-line-conc2

(defun cst-character-not-double-quote-or-backslash-or-new-line-conc2
       (abnf::cst)
 (declare (xargs :guard (abnf::treep abnf::cst)))
 (declare
  (xargs
    :guard
    (and (cst-matchp
              abnf::cst
              "character-not-double-quote-or-backslash-or-new-line")
         (equal (cst-character-not-double-quote-or-backslash-or-new-line-conc?
                     abnf::cst)
                2))))
 (let
  ((__function__
    'cst-character-not-double-quote-or-backslash-or-new-line-conc2))
  (declare (ignorable __function__))
  (abnf::tree-nonleaf->branches abnf::cst)))

Theorem: tree-list-listp-of-cst-character-not-double-quote-or-backslash-or-new-line-conc2

(defthm
 tree-list-listp-of-cst-character-not-double-quote-or-backslash-or-new-line-conc2
 (b* ((abnf::cstss (cst-character-not-double-quote-or-backslash-or-new-line-conc2
                        abnf::cst)))
   (abnf::tree-list-listp abnf::cstss))
 :rule-classes :rewrite)

Theorem: cst-character-not-double-quote-or-backslash-or-new-line-conc2-match

(defthm
 cst-character-not-double-quote-or-backslash-or-new-line-conc2-match
 (implies
   (and (cst-matchp
             abnf::cst
             "character-not-double-quote-or-backslash-or-new-line")
        (equal (cst-character-not-double-quote-or-backslash-or-new-line-conc?
                    abnf::cst)
               2))
   (b* ((abnf::cstss (cst-character-not-double-quote-or-backslash-or-new-line-conc2
                          abnf::cst)))
     (cst-list-list-conc-matchp abnf::cstss
                                "extended-character-not-new-line")))
 :rule-classes :rewrite)

Theorem: cst-character-not-double-quote-or-backslash-or-new-line-conc2-of-tree-fix-cst

(defthm
 cst-character-not-double-quote-or-backslash-or-new-line-conc2-of-tree-fix-cst
 (equal (cst-character-not-double-quote-or-backslash-or-new-line-conc2
             (abnf::tree-fix abnf::cst))
        (cst-character-not-double-quote-or-backslash-or-new-line-conc2
             abnf::cst)))

Theorem: cst-character-not-double-quote-or-backslash-or-new-line-conc2-tree-equiv-congruence-on-cst

(defthm
 cst-character-not-double-quote-or-backslash-or-new-line-conc2-tree-equiv-congruence-on-cst
 (implies (abnf::tree-equiv abnf::cst cst-equiv)
          (equal (cst-character-not-double-quote-or-backslash-or-new-line-conc2
                      abnf::cst)
                 (cst-character-not-double-quote-or-backslash-or-new-line-conc2
                      cst-equiv)))
 :rule-classes :congruence)

Function: cst-white-space-conc1

(defun cst-white-space-conc1 (abnf::cst)
  (declare (xargs :guard (abnf::treep abnf::cst)))
  (declare
       (xargs :guard (and (cst-matchp abnf::cst "white-space")
                          (equal (cst-white-space-conc? abnf::cst)
                                 1))))
  (let ((__function__ 'cst-white-space-conc1))
    (declare (ignorable __function__))
    (abnf::tree-nonleaf->branches abnf::cst)))

Theorem: tree-list-listp-of-cst-white-space-conc1

(defthm tree-list-listp-of-cst-white-space-conc1
  (b* ((abnf::cstss (cst-white-space-conc1 abnf::cst)))
    (abnf::tree-list-listp abnf::cstss))
  :rule-classes :rewrite)

Theorem: cst-white-space-conc1-match

(defthm cst-white-space-conc1-match
  (implies (and (cst-matchp abnf::cst "white-space")
                (equal (cst-white-space-conc? abnf::cst)
                       1))
           (b* ((abnf::cstss (cst-white-space-conc1 abnf::cst)))
             (cst-list-list-conc-matchp abnf::cstss "space")))
  :rule-classes :rewrite)

Theorem: cst-white-space-conc1-of-tree-fix-cst

(defthm cst-white-space-conc1-of-tree-fix-cst
  (equal (cst-white-space-conc1 (abnf::tree-fix abnf::cst))
         (cst-white-space-conc1 abnf::cst)))

Theorem: cst-white-space-conc1-tree-equiv-congruence-on-cst

(defthm cst-white-space-conc1-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-white-space-conc1 abnf::cst)
                  (cst-white-space-conc1 cst-equiv)))
  :rule-classes :congruence)

Function: cst-white-space-conc2

(defun cst-white-space-conc2 (abnf::cst)
  (declare (xargs :guard (abnf::treep abnf::cst)))
  (declare
       (xargs :guard (and (cst-matchp abnf::cst "white-space")
                          (equal (cst-white-space-conc? abnf::cst)
                                 2))))
  (let ((__function__ 'cst-white-space-conc2))
    (declare (ignorable __function__))
    (abnf::tree-nonleaf->branches abnf::cst)))

Theorem: tree-list-listp-of-cst-white-space-conc2

(defthm tree-list-listp-of-cst-white-space-conc2
  (b* ((abnf::cstss (cst-white-space-conc2 abnf::cst)))
    (abnf::tree-list-listp abnf::cstss))
  :rule-classes :rewrite)

Theorem: cst-white-space-conc2-match

(defthm cst-white-space-conc2-match
  (implies
       (and (cst-matchp abnf::cst "white-space")
            (equal (cst-white-space-conc? abnf::cst)
                   2))
       (b* ((abnf::cstss (cst-white-space-conc2 abnf::cst)))
         (cst-list-list-conc-matchp abnf::cstss "horizontal-tab")))
  :rule-classes :rewrite)

Theorem: cst-white-space-conc2-of-tree-fix-cst

(defthm cst-white-space-conc2-of-tree-fix-cst
  (equal (cst-white-space-conc2 (abnf::tree-fix abnf::cst))
         (cst-white-space-conc2 abnf::cst)))

Theorem: cst-white-space-conc2-tree-equiv-congruence-on-cst

(defthm cst-white-space-conc2-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-white-space-conc2 abnf::cst)
                  (cst-white-space-conc2 cst-equiv)))
  :rule-classes :congruence)

Function: cst-white-space-conc3

(defun cst-white-space-conc3 (abnf::cst)
  (declare (xargs :guard (abnf::treep abnf::cst)))
  (declare
       (xargs :guard (and (cst-matchp abnf::cst "white-space")
                          (equal (cst-white-space-conc? abnf::cst)
                                 3))))
  (let ((__function__ 'cst-white-space-conc3))
    (declare (ignorable __function__))
    (abnf::tree-nonleaf->branches abnf::cst)))

Theorem: tree-list-listp-of-cst-white-space-conc3

(defthm tree-list-listp-of-cst-white-space-conc3
  (b* ((abnf::cstss (cst-white-space-conc3 abnf::cst)))
    (abnf::tree-list-listp abnf::cstss))
  :rule-classes :rewrite)

Theorem: cst-white-space-conc3-match

(defthm cst-white-space-conc3-match
 (implies (and (cst-matchp abnf::cst "white-space")
               (equal (cst-white-space-conc? abnf::cst)
                      3))
          (b* ((abnf::cstss (cst-white-space-conc3 abnf::cst)))
            (cst-list-list-conc-matchp abnf::cstss "vertical-tab")))
 :rule-classes :rewrite)

Theorem: cst-white-space-conc3-of-tree-fix-cst

(defthm cst-white-space-conc3-of-tree-fix-cst
  (equal (cst-white-space-conc3 (abnf::tree-fix abnf::cst))
         (cst-white-space-conc3 abnf::cst)))

Theorem: cst-white-space-conc3-tree-equiv-congruence-on-cst

(defthm cst-white-space-conc3-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-white-space-conc3 abnf::cst)
                  (cst-white-space-conc3 cst-equiv)))
  :rule-classes :congruence)

Function: cst-white-space-conc4

(defun cst-white-space-conc4 (abnf::cst)
  (declare (xargs :guard (abnf::treep abnf::cst)))
  (declare
       (xargs :guard (and (cst-matchp abnf::cst "white-space")
                          (equal (cst-white-space-conc? abnf::cst)
                                 4))))
  (let ((__function__ 'cst-white-space-conc4))
    (declare (ignorable __function__))
    (abnf::tree-nonleaf->branches abnf::cst)))

Theorem: tree-list-listp-of-cst-white-space-conc4

(defthm tree-list-listp-of-cst-white-space-conc4
  (b* ((abnf::cstss (cst-white-space-conc4 abnf::cst)))
    (abnf::tree-list-listp abnf::cstss))
  :rule-classes :rewrite)

Theorem: cst-white-space-conc4-match

(defthm cst-white-space-conc4-match
  (implies (and (cst-matchp abnf::cst "white-space")
                (equal (cst-white-space-conc? abnf::cst)
                       4))
           (b* ((abnf::cstss (cst-white-space-conc4 abnf::cst)))
             (cst-list-list-conc-matchp abnf::cstss "form-feed")))
  :rule-classes :rewrite)

Theorem: cst-white-space-conc4-of-tree-fix-cst

(defthm cst-white-space-conc4-of-tree-fix-cst
  (equal (cst-white-space-conc4 (abnf::tree-fix abnf::cst))
         (cst-white-space-conc4 abnf::cst)))

Theorem: cst-white-space-conc4-tree-equiv-congruence-on-cst

(defthm cst-white-space-conc4-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-white-space-conc4 abnf::cst)
                  (cst-white-space-conc4 cst-equiv)))
  :rule-classes :congruence)

Function: cst-white-space-conc5

(defun cst-white-space-conc5 (abnf::cst)
  (declare (xargs :guard (abnf::treep abnf::cst)))
  (declare
       (xargs :guard (and (cst-matchp abnf::cst "white-space")
                          (equal (cst-white-space-conc? abnf::cst)
                                 5))))
  (let ((__function__ 'cst-white-space-conc5))
    (declare (ignorable __function__))
    (abnf::tree-nonleaf->branches abnf::cst)))

Theorem: tree-list-listp-of-cst-white-space-conc5

(defthm tree-list-listp-of-cst-white-space-conc5
  (b* ((abnf::cstss (cst-white-space-conc5 abnf::cst)))
    (abnf::tree-list-listp abnf::cstss))
  :rule-classes :rewrite)

Theorem: cst-white-space-conc5-match

(defthm cst-white-space-conc5-match
  (implies (and (cst-matchp abnf::cst "white-space")
                (equal (cst-white-space-conc? abnf::cst)
                       5))
           (b* ((abnf::cstss (cst-white-space-conc5 abnf::cst)))
             (cst-list-list-conc-matchp abnf::cstss "new-line")))
  :rule-classes :rewrite)

Theorem: cst-white-space-conc5-of-tree-fix-cst

(defthm cst-white-space-conc5-of-tree-fix-cst
  (equal (cst-white-space-conc5 (abnf::tree-fix abnf::cst))
         (cst-white-space-conc5 abnf::cst)))

Theorem: cst-white-space-conc5-tree-equiv-congruence-on-cst

(defthm cst-white-space-conc5-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-white-space-conc5 abnf::cst)
                  (cst-white-space-conc5 cst-equiv)))
  :rule-classes :congruence)

Function: cst-h-char-conc

(defun cst-h-char-conc (abnf::cst)
  (declare (xargs :guard (abnf::treep abnf::cst)))
  (declare (xargs :guard (cst-matchp abnf::cst "h-char")))
  (let ((__function__ 'cst-h-char-conc))
    (declare (ignorable __function__))
    (abnf::tree-nonleaf->branches abnf::cst)))

Theorem: tree-list-listp-of-cst-h-char-conc

(defthm tree-list-listp-of-cst-h-char-conc
  (b* ((abnf::cstss (cst-h-char-conc abnf::cst)))
    (abnf::tree-list-listp abnf::cstss))
  :rule-classes :rewrite)

Theorem: cst-h-char-conc-match

(defthm cst-h-char-conc-match
  (implies (cst-matchp abnf::cst "h-char")
           (b* ((abnf::cstss (cst-h-char-conc abnf::cst)))
             (cst-list-list-conc-matchp
                  abnf::cstss
                  "character-not-greater-than-or-new-line")))
  :rule-classes :rewrite)

Theorem: cst-h-char-conc-of-tree-fix-cst

(defthm cst-h-char-conc-of-tree-fix-cst
  (equal (cst-h-char-conc (abnf::tree-fix abnf::cst))
         (cst-h-char-conc abnf::cst)))

Theorem: cst-h-char-conc-tree-equiv-congruence-on-cst

(defthm cst-h-char-conc-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-h-char-conc abnf::cst)
                  (cst-h-char-conc cst-equiv)))
  :rule-classes :congruence)

Function: cst-q-char-conc

(defun cst-q-char-conc (abnf::cst)
  (declare (xargs :guard (abnf::treep abnf::cst)))
  (declare (xargs :guard (cst-matchp abnf::cst "q-char")))
  (let ((__function__ 'cst-q-char-conc))
    (declare (ignorable __function__))
    (abnf::tree-nonleaf->branches abnf::cst)))

Theorem: tree-list-listp-of-cst-q-char-conc

(defthm tree-list-listp-of-cst-q-char-conc
  (b* ((abnf::cstss (cst-q-char-conc abnf::cst)))
    (abnf::tree-list-listp abnf::cstss))
  :rule-classes :rewrite)

Theorem: cst-q-char-conc-match

(defthm cst-q-char-conc-match
  (implies (cst-matchp abnf::cst "q-char")
           (b* ((abnf::cstss (cst-q-char-conc abnf::cst)))
             (cst-list-list-conc-matchp
                  abnf::cstss
                  "character-not-double-quote-or-new-line")))
  :rule-classes :rewrite)

Theorem: cst-q-char-conc-of-tree-fix-cst

(defthm cst-q-char-conc-of-tree-fix-cst
  (equal (cst-q-char-conc (abnf::tree-fix abnf::cst))
         (cst-q-char-conc abnf::cst)))

Theorem: cst-q-char-conc-tree-equiv-congruence-on-cst

(defthm cst-q-char-conc-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-q-char-conc abnf::cst)
                  (cst-q-char-conc cst-equiv)))
  :rule-classes :congruence)

Function: cst-comment-conc1

(defun cst-comment-conc1 (abnf::cst)
  (declare (xargs :guard (abnf::treep abnf::cst)))
  (declare (xargs :guard (and (cst-matchp abnf::cst "comment")
                              (equal (cst-comment-conc? abnf::cst)
                                     1))))
  (let ((__function__ 'cst-comment-conc1))
    (declare (ignorable __function__))
    (abnf::tree-nonleaf->branches abnf::cst)))

Theorem: tree-list-listp-of-cst-comment-conc1

(defthm tree-list-listp-of-cst-comment-conc1
  (b* ((abnf::cstss (cst-comment-conc1 abnf::cst)))
    (abnf::tree-list-listp abnf::cstss))
  :rule-classes :rewrite)

Theorem: cst-comment-conc1-match

(defthm cst-comment-conc1-match
  (implies
       (and (cst-matchp abnf::cst "comment")
            (equal (cst-comment-conc? abnf::cst) 1))
       (b* ((abnf::cstss (cst-comment-conc1 abnf::cst)))
         (cst-list-list-conc-matchp abnf::cstss "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
                  "\"//\" *character-not-new-line new-line")))
  :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-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 "constant")))
  :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 "string-literal")))
  :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 "punctuator")))
  :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-preprocessing-token-conc1

(defun cst-preprocessing-token-conc1 (abnf::cst)
 (declare (xargs :guard (abnf::treep abnf::cst)))
 (declare
   (xargs
        :guard (and (cst-matchp abnf::cst "preprocessing-token")
                    (equal (cst-preprocessing-token-conc? abnf::cst)
                           1))))
 (let ((__function__ 'cst-preprocessing-token-conc1))
   (declare (ignorable __function__))
   (abnf::tree-nonleaf->branches abnf::cst)))

Theorem: tree-list-listp-of-cst-preprocessing-token-conc1

(defthm tree-list-listp-of-cst-preprocessing-token-conc1
  (b* ((abnf::cstss (cst-preprocessing-token-conc1 abnf::cst)))
    (abnf::tree-list-listp abnf::cstss))
  :rule-classes :rewrite)

Theorem: cst-preprocessing-token-conc1-match

(defthm cst-preprocessing-token-conc1-match
  (implies
       (and (cst-matchp abnf::cst "preprocessing-token")
            (equal (cst-preprocessing-token-conc? abnf::cst)
                   1))
       (b* ((abnf::cstss (cst-preprocessing-token-conc1 abnf::cst)))
         (cst-list-list-conc-matchp abnf::cstss "header-name")))
  :rule-classes :rewrite)

Theorem: cst-preprocessing-token-conc1-of-tree-fix-cst

(defthm cst-preprocessing-token-conc1-of-tree-fix-cst
  (equal (cst-preprocessing-token-conc1 (abnf::tree-fix abnf::cst))
         (cst-preprocessing-token-conc1 abnf::cst)))

Theorem: cst-preprocessing-token-conc1-tree-equiv-congruence-on-cst

(defthm cst-preprocessing-token-conc1-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-preprocessing-token-conc1 abnf::cst)
                  (cst-preprocessing-token-conc1 cst-equiv)))
  :rule-classes :congruence)

Function: cst-preprocessing-token-conc2

(defun cst-preprocessing-token-conc2 (abnf::cst)
 (declare (xargs :guard (abnf::treep abnf::cst)))
 (declare
   (xargs
        :guard (and (cst-matchp abnf::cst "preprocessing-token")
                    (equal (cst-preprocessing-token-conc? abnf::cst)
                           2))))
 (let ((__function__ 'cst-preprocessing-token-conc2))
   (declare (ignorable __function__))
   (abnf::tree-nonleaf->branches abnf::cst)))

Theorem: tree-list-listp-of-cst-preprocessing-token-conc2

(defthm tree-list-listp-of-cst-preprocessing-token-conc2
  (b* ((abnf::cstss (cst-preprocessing-token-conc2 abnf::cst)))
    (abnf::tree-list-listp abnf::cstss))
  :rule-classes :rewrite)

Theorem: cst-preprocessing-token-conc2-match

(defthm cst-preprocessing-token-conc2-match
  (implies
       (and (cst-matchp abnf::cst "preprocessing-token")
            (equal (cst-preprocessing-token-conc? abnf::cst)
                   2))
       (b* ((abnf::cstss (cst-preprocessing-token-conc2 abnf::cst)))
         (cst-list-list-conc-matchp abnf::cstss "identifier")))
  :rule-classes :rewrite)

Theorem: cst-preprocessing-token-conc2-of-tree-fix-cst

(defthm cst-preprocessing-token-conc2-of-tree-fix-cst
  (equal (cst-preprocessing-token-conc2 (abnf::tree-fix abnf::cst))
         (cst-preprocessing-token-conc2 abnf::cst)))

Theorem: cst-preprocessing-token-conc2-tree-equiv-congruence-on-cst

(defthm cst-preprocessing-token-conc2-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-preprocessing-token-conc2 abnf::cst)
                  (cst-preprocessing-token-conc2 cst-equiv)))
  :rule-classes :congruence)

Function: cst-preprocessing-token-conc3

(defun cst-preprocessing-token-conc3 (abnf::cst)
 (declare (xargs :guard (abnf::treep abnf::cst)))
 (declare
   (xargs
        :guard (and (cst-matchp abnf::cst "preprocessing-token")
                    (equal (cst-preprocessing-token-conc? abnf::cst)
                           3))))
 (let ((__function__ 'cst-preprocessing-token-conc3))
   (declare (ignorable __function__))
   (abnf::tree-nonleaf->branches abnf::cst)))

Theorem: tree-list-listp-of-cst-preprocessing-token-conc3

(defthm tree-list-listp-of-cst-preprocessing-token-conc3
  (b* ((abnf::cstss (cst-preprocessing-token-conc3 abnf::cst)))
    (abnf::tree-list-listp abnf::cstss))
  :rule-classes :rewrite)

Theorem: cst-preprocessing-token-conc3-match

(defthm cst-preprocessing-token-conc3-match
  (implies
       (and (cst-matchp abnf::cst "preprocessing-token")
            (equal (cst-preprocessing-token-conc? abnf::cst)
                   3))
       (b* ((abnf::cstss (cst-preprocessing-token-conc3 abnf::cst)))
         (cst-list-list-conc-matchp abnf::cstss "pp-number")))
  :rule-classes :rewrite)

Theorem: cst-preprocessing-token-conc3-of-tree-fix-cst

(defthm cst-preprocessing-token-conc3-of-tree-fix-cst
  (equal (cst-preprocessing-token-conc3 (abnf::tree-fix abnf::cst))
         (cst-preprocessing-token-conc3 abnf::cst)))

Theorem: cst-preprocessing-token-conc3-tree-equiv-congruence-on-cst

(defthm cst-preprocessing-token-conc3-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-preprocessing-token-conc3 abnf::cst)
                  (cst-preprocessing-token-conc3 cst-equiv)))
  :rule-classes :congruence)

Function: cst-preprocessing-token-conc4

(defun cst-preprocessing-token-conc4 (abnf::cst)
 (declare (xargs :guard (abnf::treep abnf::cst)))
 (declare
   (xargs
        :guard (and (cst-matchp abnf::cst "preprocessing-token")
                    (equal (cst-preprocessing-token-conc? abnf::cst)
                           4))))
 (let ((__function__ 'cst-preprocessing-token-conc4))
   (declare (ignorable __function__))
   (abnf::tree-nonleaf->branches abnf::cst)))

Theorem: tree-list-listp-of-cst-preprocessing-token-conc4

(defthm tree-list-listp-of-cst-preprocessing-token-conc4
  (b* ((abnf::cstss (cst-preprocessing-token-conc4 abnf::cst)))
    (abnf::tree-list-listp abnf::cstss))
  :rule-classes :rewrite)

Theorem: cst-preprocessing-token-conc4-match

(defthm cst-preprocessing-token-conc4-match
 (implies
    (and (cst-matchp abnf::cst "preprocessing-token")
         (equal (cst-preprocessing-token-conc? abnf::cst)
                4))
    (b* ((abnf::cstss (cst-preprocessing-token-conc4 abnf::cst)))
      (cst-list-list-conc-matchp abnf::cstss "character-constant")))
 :rule-classes :rewrite)

Theorem: cst-preprocessing-token-conc4-of-tree-fix-cst

(defthm cst-preprocessing-token-conc4-of-tree-fix-cst
  (equal (cst-preprocessing-token-conc4 (abnf::tree-fix abnf::cst))
         (cst-preprocessing-token-conc4 abnf::cst)))

Theorem: cst-preprocessing-token-conc4-tree-equiv-congruence-on-cst

(defthm cst-preprocessing-token-conc4-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-preprocessing-token-conc4 abnf::cst)
                  (cst-preprocessing-token-conc4 cst-equiv)))
  :rule-classes :congruence)

Function: cst-preprocessing-token-conc5

(defun cst-preprocessing-token-conc5 (abnf::cst)
 (declare (xargs :guard (abnf::treep abnf::cst)))
 (declare
   (xargs
        :guard (and (cst-matchp abnf::cst "preprocessing-token")
                    (equal (cst-preprocessing-token-conc? abnf::cst)
                           5))))
 (let ((__function__ 'cst-preprocessing-token-conc5))
   (declare (ignorable __function__))
   (abnf::tree-nonleaf->branches abnf::cst)))

Theorem: tree-list-listp-of-cst-preprocessing-token-conc5

(defthm tree-list-listp-of-cst-preprocessing-token-conc5
  (b* ((abnf::cstss (cst-preprocessing-token-conc5 abnf::cst)))
    (abnf::tree-list-listp abnf::cstss))
  :rule-classes :rewrite)

Theorem: cst-preprocessing-token-conc5-match

(defthm cst-preprocessing-token-conc5-match
  (implies
       (and (cst-matchp abnf::cst "preprocessing-token")
            (equal (cst-preprocessing-token-conc? abnf::cst)
                   5))
       (b* ((abnf::cstss (cst-preprocessing-token-conc5 abnf::cst)))
         (cst-list-list-conc-matchp abnf::cstss "string-literal")))
  :rule-classes :rewrite)

Theorem: cst-preprocessing-token-conc5-of-tree-fix-cst

(defthm cst-preprocessing-token-conc5-of-tree-fix-cst
  (equal (cst-preprocessing-token-conc5 (abnf::tree-fix abnf::cst))
         (cst-preprocessing-token-conc5 abnf::cst)))

Theorem: cst-preprocessing-token-conc5-tree-equiv-congruence-on-cst

(defthm cst-preprocessing-token-conc5-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-preprocessing-token-conc5 abnf::cst)
                  (cst-preprocessing-token-conc5 cst-equiv)))
  :rule-classes :congruence)

Function: cst-preprocessing-token-conc6

(defun cst-preprocessing-token-conc6 (abnf::cst)
 (declare (xargs :guard (abnf::treep abnf::cst)))
 (declare
   (xargs
        :guard (and (cst-matchp abnf::cst "preprocessing-token")
                    (equal (cst-preprocessing-token-conc? abnf::cst)
                           6))))
 (let ((__function__ 'cst-preprocessing-token-conc6))
   (declare (ignorable __function__))
   (abnf::tree-nonleaf->branches abnf::cst)))

Theorem: tree-list-listp-of-cst-preprocessing-token-conc6

(defthm tree-list-listp-of-cst-preprocessing-token-conc6
  (b* ((abnf::cstss (cst-preprocessing-token-conc6 abnf::cst)))
    (abnf::tree-list-listp abnf::cstss))
  :rule-classes :rewrite)

Theorem: cst-preprocessing-token-conc6-match

(defthm cst-preprocessing-token-conc6-match
  (implies
       (and (cst-matchp abnf::cst "preprocessing-token")
            (equal (cst-preprocessing-token-conc? abnf::cst)
                   6))
       (b* ((abnf::cstss (cst-preprocessing-token-conc6 abnf::cst)))
         (cst-list-list-conc-matchp abnf::cstss "punctuator")))
  :rule-classes :rewrite)

Theorem: cst-preprocessing-token-conc6-of-tree-fix-cst

(defthm cst-preprocessing-token-conc6-of-tree-fix-cst
  (equal (cst-preprocessing-token-conc6 (abnf::tree-fix abnf::cst))
         (cst-preprocessing-token-conc6 abnf::cst)))

Theorem: cst-preprocessing-token-conc6-tree-equiv-congruence-on-cst

(defthm cst-preprocessing-token-conc6-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-preprocessing-token-conc6 abnf::cst)
                  (cst-preprocessing-token-conc6 cst-equiv)))
  :rule-classes :congruence)

Function: cst-preprocessing-token-conc7

(defun cst-preprocessing-token-conc7 (abnf::cst)
 (declare (xargs :guard (abnf::treep abnf::cst)))
 (declare
   (xargs
        :guard (and (cst-matchp abnf::cst "preprocessing-token")
                    (equal (cst-preprocessing-token-conc? abnf::cst)
                           7))))
 (let ((__function__ 'cst-preprocessing-token-conc7))
   (declare (ignorable __function__))
   (abnf::tree-nonleaf->branches abnf::cst)))

Theorem: tree-list-listp-of-cst-preprocessing-token-conc7

(defthm tree-list-listp-of-cst-preprocessing-token-conc7
  (b* ((abnf::cstss (cst-preprocessing-token-conc7 abnf::cst)))
    (abnf::tree-list-listp abnf::cstss))
  :rule-classes :rewrite)

Theorem: cst-preprocessing-token-conc7-match

(defthm cst-preprocessing-token-conc7-match
  (implies
       (and (cst-matchp abnf::cst "preprocessing-token")
            (equal (cst-preprocessing-token-conc? abnf::cst)
                   7))
       (b* ((abnf::cstss (cst-preprocessing-token-conc7 abnf::cst)))
         (cst-list-list-conc-matchp abnf::cstss "character")))
  :rule-classes :rewrite)

Theorem: cst-preprocessing-token-conc7-of-tree-fix-cst

(defthm cst-preprocessing-token-conc7-of-tree-fix-cst
  (equal (cst-preprocessing-token-conc7 (abnf::tree-fix abnf::cst))
         (cst-preprocessing-token-conc7 abnf::cst)))

Theorem: cst-preprocessing-token-conc7-tree-equiv-congruence-on-cst

(defthm cst-preprocessing-token-conc7-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-preprocessing-token-conc7 abnf::cst)
                  (cst-preprocessing-token-conc7 cst-equiv)))
  :rule-classes :congruence)

Function: cst-identifier-nondigit-conc

(defun cst-identifier-nondigit-conc (abnf::cst)
  (declare (xargs :guard (abnf::treep abnf::cst)))
  (declare
       (xargs :guard (cst-matchp abnf::cst "identifier-nondigit")))
  (let ((__function__ 'cst-identifier-nondigit-conc))
    (declare (ignorable __function__))
    (abnf::tree-nonleaf->branches abnf::cst)))

Theorem: tree-list-listp-of-cst-identifier-nondigit-conc

(defthm tree-list-listp-of-cst-identifier-nondigit-conc
  (b* ((abnf::cstss (cst-identifier-nondigit-conc abnf::cst)))
    (abnf::tree-list-listp abnf::cstss))
  :rule-classes :rewrite)

Theorem: cst-identifier-nondigit-conc-match

(defthm cst-identifier-nondigit-conc-match
  (implies
       (cst-matchp abnf::cst "identifier-nondigit")
       (b* ((abnf::cstss (cst-identifier-nondigit-conc abnf::cst)))
         (cst-list-list-conc-matchp abnf::cstss "nondigit")))
  :rule-classes :rewrite)

Theorem: cst-identifier-nondigit-conc-of-tree-fix-cst

(defthm cst-identifier-nondigit-conc-of-tree-fix-cst
  (equal (cst-identifier-nondigit-conc (abnf::tree-fix abnf::cst))
         (cst-identifier-nondigit-conc abnf::cst)))

Theorem: cst-identifier-nondigit-conc-tree-equiv-congruence-on-cst

(defthm cst-identifier-nondigit-conc-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-identifier-nondigit-conc abnf::cst)
                  (cst-identifier-nondigit-conc cst-equiv)))
  :rule-classes :congruence)

Function: cst-hex-quad-conc

(defun cst-hex-quad-conc (abnf::cst)
  (declare (xargs :guard (abnf::treep abnf::cst)))
  (declare (xargs :guard (cst-matchp abnf::cst "hex-quad")))
  (let ((__function__ 'cst-hex-quad-conc))
    (declare (ignorable __function__))
    (abnf::tree-nonleaf->branches abnf::cst)))

Theorem: tree-list-listp-of-cst-hex-quad-conc

(defthm tree-list-listp-of-cst-hex-quad-conc
  (b* ((abnf::cstss (cst-hex-quad-conc abnf::cst)))
    (abnf::tree-list-listp abnf::cstss))
  :rule-classes :rewrite)

Theorem: cst-hex-quad-conc-match

(defthm cst-hex-quad-conc-match
 (implies
  (cst-matchp abnf::cst "hex-quad")
  (b* ((abnf::cstss (cst-hex-quad-conc abnf::cst)))
   (cst-list-list-conc-matchp
    abnf::cstss
    "hexadecimal-digit hexadecimal-digit hexadecimal-digit hexadecimal-digit")))
 :rule-classes :rewrite)

Theorem: cst-hex-quad-conc-of-tree-fix-cst

(defthm cst-hex-quad-conc-of-tree-fix-cst
  (equal (cst-hex-quad-conc (abnf::tree-fix abnf::cst))
         (cst-hex-quad-conc abnf::cst)))

Theorem: cst-hex-quad-conc-tree-equiv-congruence-on-cst

(defthm cst-hex-quad-conc-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-hex-quad-conc abnf::cst)
                  (cst-hex-quad-conc cst-equiv)))
  :rule-classes :congruence)

Function: cst-constant-conc1

(defun cst-constant-conc1 (abnf::cst)
  (declare (xargs :guard (abnf::treep abnf::cst)))
  (declare (xargs :guard (and (cst-matchp abnf::cst "constant")
                              (equal (cst-constant-conc? abnf::cst)
                                     1))))
  (let ((__function__ 'cst-constant-conc1))
    (declare (ignorable __function__))
    (abnf::tree-nonleaf->branches abnf::cst)))

Theorem: tree-list-listp-of-cst-constant-conc1

(defthm tree-list-listp-of-cst-constant-conc1
  (b* ((abnf::cstss (cst-constant-conc1 abnf::cst)))
    (abnf::tree-list-listp abnf::cstss))
  :rule-classes :rewrite)

Theorem: cst-constant-conc1-match

(defthm cst-constant-conc1-match
 (implies
      (and (cst-matchp abnf::cst "constant")
           (equal (cst-constant-conc? abnf::cst)
                  1))
      (b* ((abnf::cstss (cst-constant-conc1 abnf::cst)))
        (cst-list-list-conc-matchp abnf::cstss "integer-constant")))
 :rule-classes :rewrite)

Theorem: cst-constant-conc1-of-tree-fix-cst

(defthm cst-constant-conc1-of-tree-fix-cst
  (equal (cst-constant-conc1 (abnf::tree-fix abnf::cst))
         (cst-constant-conc1 abnf::cst)))

Theorem: cst-constant-conc1-tree-equiv-congruence-on-cst

(defthm cst-constant-conc1-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-constant-conc1 abnf::cst)
                  (cst-constant-conc1 cst-equiv)))
  :rule-classes :congruence)

Function: cst-constant-conc2

(defun cst-constant-conc2 (abnf::cst)
  (declare (xargs :guard (abnf::treep abnf::cst)))
  (declare (xargs :guard (and (cst-matchp abnf::cst "constant")
                              (equal (cst-constant-conc? abnf::cst)
                                     2))))
  (let ((__function__ 'cst-constant-conc2))
    (declare (ignorable __function__))
    (abnf::tree-nonleaf->branches abnf::cst)))

Theorem: tree-list-listp-of-cst-constant-conc2

(defthm tree-list-listp-of-cst-constant-conc2
  (b* ((abnf::cstss (cst-constant-conc2 abnf::cst)))
    (abnf::tree-list-listp abnf::cstss))
  :rule-classes :rewrite)

Theorem: cst-constant-conc2-match

(defthm cst-constant-conc2-match
 (implies
     (and (cst-matchp abnf::cst "constant")
          (equal (cst-constant-conc? abnf::cst)
                 2))
     (b* ((abnf::cstss (cst-constant-conc2 abnf::cst)))
       (cst-list-list-conc-matchp abnf::cstss "floating-constant")))
 :rule-classes :rewrite)

Theorem: cst-constant-conc2-of-tree-fix-cst

(defthm cst-constant-conc2-of-tree-fix-cst
  (equal (cst-constant-conc2 (abnf::tree-fix abnf::cst))
         (cst-constant-conc2 abnf::cst)))

Theorem: cst-constant-conc2-tree-equiv-congruence-on-cst

(defthm cst-constant-conc2-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-constant-conc2 abnf::cst)
                  (cst-constant-conc2 cst-equiv)))
  :rule-classes :congruence)

Function: cst-constant-conc3

(defun cst-constant-conc3 (abnf::cst)
  (declare (xargs :guard (abnf::treep abnf::cst)))
  (declare (xargs :guard (and (cst-matchp abnf::cst "constant")
                              (equal (cst-constant-conc? abnf::cst)
                                     3))))
  (let ((__function__ 'cst-constant-conc3))
    (declare (ignorable __function__))
    (abnf::tree-nonleaf->branches abnf::cst)))

Theorem: tree-list-listp-of-cst-constant-conc3

(defthm tree-list-listp-of-cst-constant-conc3
  (b* ((abnf::cstss (cst-constant-conc3 abnf::cst)))
    (abnf::tree-list-listp abnf::cstss))
  :rule-classes :rewrite)

Theorem: cst-constant-conc3-match

(defthm cst-constant-conc3-match
 (implies
  (and (cst-matchp abnf::cst "constant")
       (equal (cst-constant-conc? abnf::cst)
              3))
  (b* ((abnf::cstss (cst-constant-conc3 abnf::cst)))
    (cst-list-list-conc-matchp abnf::cstss "enumeration-constant")))
 :rule-classes :rewrite)

Theorem: cst-constant-conc3-of-tree-fix-cst

(defthm cst-constant-conc3-of-tree-fix-cst
  (equal (cst-constant-conc3 (abnf::tree-fix abnf::cst))
         (cst-constant-conc3 abnf::cst)))

Theorem: cst-constant-conc3-tree-equiv-congruence-on-cst

(defthm cst-constant-conc3-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-constant-conc3 abnf::cst)
                  (cst-constant-conc3 cst-equiv)))
  :rule-classes :congruence)

Function: cst-constant-conc4

(defun cst-constant-conc4 (abnf::cst)
  (declare (xargs :guard (abnf::treep abnf::cst)))
  (declare (xargs :guard (and (cst-matchp abnf::cst "constant")
                              (equal (cst-constant-conc? abnf::cst)
                                     4))))
  (let ((__function__ 'cst-constant-conc4))
    (declare (ignorable __function__))
    (abnf::tree-nonleaf->branches abnf::cst)))

Theorem: tree-list-listp-of-cst-constant-conc4

(defthm tree-list-listp-of-cst-constant-conc4
  (b* ((abnf::cstss (cst-constant-conc4 abnf::cst)))
    (abnf::tree-list-listp abnf::cstss))
  :rule-classes :rewrite)

Theorem: cst-constant-conc4-match

(defthm cst-constant-conc4-match
 (implies
    (and (cst-matchp abnf::cst "constant")
         (equal (cst-constant-conc? abnf::cst)
                4))
    (b* ((abnf::cstss (cst-constant-conc4 abnf::cst)))
      (cst-list-list-conc-matchp abnf::cstss "character-constant")))
 :rule-classes :rewrite)

Theorem: cst-constant-conc4-of-tree-fix-cst

(defthm cst-constant-conc4-of-tree-fix-cst
  (equal (cst-constant-conc4 (abnf::tree-fix abnf::cst))
         (cst-constant-conc4 abnf::cst)))

Theorem: cst-constant-conc4-tree-equiv-congruence-on-cst

(defthm cst-constant-conc4-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-constant-conc4 abnf::cst)
                  (cst-constant-conc4 cst-equiv)))
  :rule-classes :congruence)

Function: cst-hexadecimal-prefix-conc

(defun cst-hexadecimal-prefix-conc (abnf::cst)
  (declare (xargs :guard (abnf::treep abnf::cst)))
  (declare
       (xargs :guard (cst-matchp abnf::cst "hexadecimal-prefix")))
  (let ((__function__ 'cst-hexadecimal-prefix-conc))
    (declare (ignorable __function__))
    (abnf::tree-nonleaf->branches abnf::cst)))

Theorem: tree-list-listp-of-cst-hexadecimal-prefix-conc

(defthm tree-list-listp-of-cst-hexadecimal-prefix-conc
  (b* ((abnf::cstss (cst-hexadecimal-prefix-conc abnf::cst)))
    (abnf::tree-list-listp abnf::cstss))
  :rule-classes :rewrite)

Theorem: cst-hexadecimal-prefix-conc-match

(defthm cst-hexadecimal-prefix-conc-match
  (implies
       (cst-matchp abnf::cst "hexadecimal-prefix")
       (b* ((abnf::cstss (cst-hexadecimal-prefix-conc abnf::cst)))
         (cst-list-list-conc-matchp abnf::cstss "%i\"0x\"")))
  :rule-classes :rewrite)

Theorem: cst-hexadecimal-prefix-conc-of-tree-fix-cst

(defthm cst-hexadecimal-prefix-conc-of-tree-fix-cst
  (equal (cst-hexadecimal-prefix-conc (abnf::tree-fix abnf::cst))
         (cst-hexadecimal-prefix-conc abnf::cst)))

Theorem: cst-hexadecimal-prefix-conc-tree-equiv-congruence-on-cst

(defthm cst-hexadecimal-prefix-conc-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-hexadecimal-prefix-conc abnf::cst)
                  (cst-hexadecimal-prefix-conc cst-equiv)))
  :rule-classes :congruence)

Function: cst-nonzero-digit-conc

(defun cst-nonzero-digit-conc (abnf::cst)
  (declare (xargs :guard (abnf::treep abnf::cst)))
  (declare (xargs :guard (cst-matchp abnf::cst "nonzero-digit")))
  (let ((__function__ 'cst-nonzero-digit-conc))
    (declare (ignorable __function__))
    (abnf::tree-nonleaf->branches abnf::cst)))

Theorem: tree-list-listp-of-cst-nonzero-digit-conc

(defthm tree-list-listp-of-cst-nonzero-digit-conc
  (b* ((abnf::cstss (cst-nonzero-digit-conc abnf::cst)))
    (abnf::tree-list-listp abnf::cstss))
  :rule-classes :rewrite)

Theorem: cst-nonzero-digit-conc-match

(defthm cst-nonzero-digit-conc-match
  (implies (cst-matchp abnf::cst "nonzero-digit")
           (b* ((abnf::cstss (cst-nonzero-digit-conc abnf::cst)))
             (cst-list-list-conc-matchp abnf::cstss "%x31-39")))
  :rule-classes :rewrite)

Theorem: cst-nonzero-digit-conc-of-tree-fix-cst

(defthm cst-nonzero-digit-conc-of-tree-fix-cst
  (equal (cst-nonzero-digit-conc (abnf::tree-fix abnf::cst))
         (cst-nonzero-digit-conc abnf::cst)))

Theorem: cst-nonzero-digit-conc-tree-equiv-congruence-on-cst

(defthm cst-nonzero-digit-conc-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-nonzero-digit-conc abnf::cst)
                  (cst-nonzero-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-unsigned-suffix-conc

(defun cst-unsigned-suffix-conc (abnf::cst)
  (declare (xargs :guard (abnf::treep abnf::cst)))
  (declare (xargs :guard (cst-matchp abnf::cst "unsigned-suffix")))
  (let ((__function__ 'cst-unsigned-suffix-conc))
    (declare (ignorable __function__))
    (abnf::tree-nonleaf->branches abnf::cst)))

Theorem: tree-list-listp-of-cst-unsigned-suffix-conc

(defthm tree-list-listp-of-cst-unsigned-suffix-conc
  (b* ((abnf::cstss (cst-unsigned-suffix-conc abnf::cst)))
    (abnf::tree-list-listp abnf::cstss))
  :rule-classes :rewrite)

Theorem: cst-unsigned-suffix-conc-match

(defthm cst-unsigned-suffix-conc-match
  (implies (cst-matchp abnf::cst "unsigned-suffix")
           (b* ((abnf::cstss (cst-unsigned-suffix-conc abnf::cst)))
             (cst-list-list-conc-matchp abnf::cstss "%i\"u\"")))
  :rule-classes :rewrite)

Theorem: cst-unsigned-suffix-conc-of-tree-fix-cst

(defthm cst-unsigned-suffix-conc-of-tree-fix-cst
  (equal (cst-unsigned-suffix-conc (abnf::tree-fix abnf::cst))
         (cst-unsigned-suffix-conc abnf::cst)))

Theorem: cst-unsigned-suffix-conc-tree-equiv-congruence-on-cst

(defthm cst-unsigned-suffix-conc-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-unsigned-suffix-conc abnf::cst)
                  (cst-unsigned-suffix-conc cst-equiv)))
  :rule-classes :congruence)

Function: cst-long-suffix-conc

(defun cst-long-suffix-conc (abnf::cst)
  (declare (xargs :guard (abnf::treep abnf::cst)))
  (declare (xargs :guard (cst-matchp abnf::cst "long-suffix")))
  (let ((__function__ 'cst-long-suffix-conc))
    (declare (ignorable __function__))
    (abnf::tree-nonleaf->branches abnf::cst)))

Theorem: tree-list-listp-of-cst-long-suffix-conc

(defthm tree-list-listp-of-cst-long-suffix-conc
  (b* ((abnf::cstss (cst-long-suffix-conc abnf::cst)))
    (abnf::tree-list-listp abnf::cstss))
  :rule-classes :rewrite)

Theorem: cst-long-suffix-conc-match

(defthm cst-long-suffix-conc-match
  (implies (cst-matchp abnf::cst "long-suffix")
           (b* ((abnf::cstss (cst-long-suffix-conc abnf::cst)))
             (cst-list-list-conc-matchp abnf::cstss "%i\"l\"")))
  :rule-classes :rewrite)

Theorem: cst-long-suffix-conc-of-tree-fix-cst

(defthm cst-long-suffix-conc-of-tree-fix-cst
  (equal (cst-long-suffix-conc (abnf::tree-fix abnf::cst))
         (cst-long-suffix-conc abnf::cst)))

Theorem: cst-long-suffix-conc-tree-equiv-congruence-on-cst

(defthm cst-long-suffix-conc-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-long-suffix-conc abnf::cst)
                  (cst-long-suffix-conc cst-equiv)))
  :rule-classes :congruence)

Function: cst-floating-constant-conc1

(defun cst-floating-constant-conc1 (abnf::cst)
 (declare (xargs :guard (abnf::treep abnf::cst)))
 (declare
   (xargs :guard (and (cst-matchp abnf::cst "floating-constant")
                      (equal (cst-floating-constant-conc? abnf::cst)
                             1))))
 (let ((__function__ 'cst-floating-constant-conc1))
   (declare (ignorable __function__))
   (abnf::tree-nonleaf->branches abnf::cst)))

Theorem: tree-list-listp-of-cst-floating-constant-conc1

(defthm tree-list-listp-of-cst-floating-constant-conc1
  (b* ((abnf::cstss (cst-floating-constant-conc1 abnf::cst)))
    (abnf::tree-list-listp abnf::cstss))
  :rule-classes :rewrite)

Theorem: cst-floating-constant-conc1-match

(defthm cst-floating-constant-conc1-match
  (implies
       (and (cst-matchp abnf::cst "floating-constant")
            (equal (cst-floating-constant-conc? abnf::cst)
                   1))
       (b* ((abnf::cstss (cst-floating-constant-conc1 abnf::cst)))
         (cst-list-list-conc-matchp abnf::cstss
                                    "decimal-floating-constant")))
  :rule-classes :rewrite)

Theorem: cst-floating-constant-conc1-of-tree-fix-cst

(defthm cst-floating-constant-conc1-of-tree-fix-cst
  (equal (cst-floating-constant-conc1 (abnf::tree-fix abnf::cst))
         (cst-floating-constant-conc1 abnf::cst)))

Theorem: cst-floating-constant-conc1-tree-equiv-congruence-on-cst

(defthm cst-floating-constant-conc1-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-floating-constant-conc1 abnf::cst)
                  (cst-floating-constant-conc1 cst-equiv)))
  :rule-classes :congruence)

Function: cst-floating-constant-conc2

(defun cst-floating-constant-conc2 (abnf::cst)
 (declare (xargs :guard (abnf::treep abnf::cst)))
 (declare
   (xargs :guard (and (cst-matchp abnf::cst "floating-constant")
                      (equal (cst-floating-constant-conc? abnf::cst)
                             2))))
 (let ((__function__ 'cst-floating-constant-conc2))
   (declare (ignorable __function__))
   (abnf::tree-nonleaf->branches abnf::cst)))

Theorem: tree-list-listp-of-cst-floating-constant-conc2

(defthm tree-list-listp-of-cst-floating-constant-conc2
  (b* ((abnf::cstss (cst-floating-constant-conc2 abnf::cst)))
    (abnf::tree-list-listp abnf::cstss))
  :rule-classes :rewrite)

Theorem: cst-floating-constant-conc2-match

(defthm cst-floating-constant-conc2-match
 (implies
     (and (cst-matchp abnf::cst "floating-constant")
          (equal (cst-floating-constant-conc? abnf::cst)
                 2))
     (b* ((abnf::cstss (cst-floating-constant-conc2 abnf::cst)))
       (cst-list-list-conc-matchp abnf::cstss
                                  "hexadecimal-floating-constant")))
 :rule-classes :rewrite)

Theorem: cst-floating-constant-conc2-of-tree-fix-cst

(defthm cst-floating-constant-conc2-of-tree-fix-cst
  (equal (cst-floating-constant-conc2 (abnf::tree-fix abnf::cst))
         (cst-floating-constant-conc2 abnf::cst)))

Theorem: cst-floating-constant-conc2-tree-equiv-congruence-on-cst

(defthm cst-floating-constant-conc2-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-floating-constant-conc2 abnf::cst)
                  (cst-floating-constant-conc2 cst-equiv)))
  :rule-classes :congruence)

Function: cst-exponent-part-conc

(defun cst-exponent-part-conc (abnf::cst)
  (declare (xargs :guard (abnf::treep abnf::cst)))
  (declare (xargs :guard (cst-matchp abnf::cst "exponent-part")))
  (let ((__function__ 'cst-exponent-part-conc))
    (declare (ignorable __function__))
    (abnf::tree-nonleaf->branches abnf::cst)))

Theorem: tree-list-listp-of-cst-exponent-part-conc

(defthm tree-list-listp-of-cst-exponent-part-conc
  (b* ((abnf::cstss (cst-exponent-part-conc abnf::cst)))
    (abnf::tree-list-listp abnf::cstss))
  :rule-classes :rewrite)

Theorem: cst-exponent-part-conc-match

(defthm cst-exponent-part-conc-match
 (implies
     (cst-matchp abnf::cst "exponent-part")
     (b* ((abnf::cstss (cst-exponent-part-conc abnf::cst)))
       (cst-list-list-conc-matchp abnf::cstss
                                  "%i\"e\" [ sign ] digit-sequence")))
 :rule-classes :rewrite)

Theorem: cst-exponent-part-conc-of-tree-fix-cst

(defthm cst-exponent-part-conc-of-tree-fix-cst
  (equal (cst-exponent-part-conc (abnf::tree-fix abnf::cst))
         (cst-exponent-part-conc abnf::cst)))

Theorem: cst-exponent-part-conc-tree-equiv-congruence-on-cst

(defthm cst-exponent-part-conc-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-exponent-part-conc abnf::cst)
                  (cst-exponent-part-conc cst-equiv)))
  :rule-classes :congruence)

Function: cst-binary-exponent-part-conc

(defun cst-binary-exponent-part-conc (abnf::cst)
  (declare (xargs :guard (abnf::treep abnf::cst)))
  (declare
       (xargs :guard (cst-matchp abnf::cst "binary-exponent-part")))
  (let ((__function__ 'cst-binary-exponent-part-conc))
    (declare (ignorable __function__))
    (abnf::tree-nonleaf->branches abnf::cst)))

Theorem: tree-list-listp-of-cst-binary-exponent-part-conc

(defthm tree-list-listp-of-cst-binary-exponent-part-conc
  (b* ((abnf::cstss (cst-binary-exponent-part-conc abnf::cst)))
    (abnf::tree-list-listp abnf::cstss))
  :rule-classes :rewrite)

Theorem: cst-binary-exponent-part-conc-match

(defthm cst-binary-exponent-part-conc-match
 (implies
     (cst-matchp abnf::cst "binary-exponent-part")
     (b* ((abnf::cstss (cst-binary-exponent-part-conc abnf::cst)))
       (cst-list-list-conc-matchp abnf::cstss
                                  "%i\"p\" [ sign ] digit-sequence")))
 :rule-classes :rewrite)

Theorem: cst-binary-exponent-part-conc-of-tree-fix-cst

(defthm cst-binary-exponent-part-conc-of-tree-fix-cst
  (equal (cst-binary-exponent-part-conc (abnf::tree-fix abnf::cst))
         (cst-binary-exponent-part-conc abnf::cst)))

Theorem: cst-binary-exponent-part-conc-tree-equiv-congruence-on-cst

(defthm cst-binary-exponent-part-conc-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-binary-exponent-part-conc abnf::cst)
                  (cst-binary-exponent-part-conc cst-equiv)))
  :rule-classes :congruence)

Function: cst-enumeration-constant-conc

(defun cst-enumeration-constant-conc (abnf::cst)
  (declare (xargs :guard (abnf::treep abnf::cst)))
  (declare
       (xargs :guard (cst-matchp abnf::cst "enumeration-constant")))
  (let ((__function__ 'cst-enumeration-constant-conc))
    (declare (ignorable __function__))
    (abnf::tree-nonleaf->branches abnf::cst)))

Theorem: tree-list-listp-of-cst-enumeration-constant-conc

(defthm tree-list-listp-of-cst-enumeration-constant-conc
  (b* ((abnf::cstss (cst-enumeration-constant-conc abnf::cst)))
    (abnf::tree-list-listp abnf::cstss))
  :rule-classes :rewrite)

Theorem: cst-enumeration-constant-conc-match

(defthm cst-enumeration-constant-conc-match
  (implies
       (cst-matchp abnf::cst "enumeration-constant")
       (b* ((abnf::cstss (cst-enumeration-constant-conc abnf::cst)))
         (cst-list-list-conc-matchp abnf::cstss "identifier")))
  :rule-classes :rewrite)

Theorem: cst-enumeration-constant-conc-of-tree-fix-cst

(defthm cst-enumeration-constant-conc-of-tree-fix-cst
  (equal (cst-enumeration-constant-conc (abnf::tree-fix abnf::cst))
         (cst-enumeration-constant-conc abnf::cst)))

Theorem: cst-enumeration-constant-conc-tree-equiv-congruence-on-cst

(defthm cst-enumeration-constant-conc-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-enumeration-constant-conc abnf::cst)
                  (cst-enumeration-constant-conc cst-equiv)))
  :rule-classes :congruence)

Function: cst-c-char-conc1

(defun cst-c-char-conc1 (abnf::cst)
  (declare (xargs :guard (abnf::treep abnf::cst)))
  (declare (xargs :guard (and (cst-matchp abnf::cst "c-char")
                              (equal (cst-c-char-conc? abnf::cst)
                                     1))))
  (let ((__function__ 'cst-c-char-conc1))
    (declare (ignorable __function__))
    (abnf::tree-nonleaf->branches abnf::cst)))

Theorem: tree-list-listp-of-cst-c-char-conc1

(defthm tree-list-listp-of-cst-c-char-conc1
  (b* ((abnf::cstss (cst-c-char-conc1 abnf::cst)))
    (abnf::tree-list-listp abnf::cstss))
  :rule-classes :rewrite)

Theorem: cst-c-char-conc1-match

(defthm cst-c-char-conc1-match
 (implies
     (and (cst-matchp abnf::cst "c-char")
          (equal (cst-c-char-conc? abnf::cst) 1))
     (b* ((abnf::cstss (cst-c-char-conc1 abnf::cst)))
       (cst-list-list-conc-matchp
            abnf::cstss
            "character-not-single-quote-or-backslash-or-new-line")))
 :rule-classes :rewrite)

Theorem: cst-c-char-conc1-of-tree-fix-cst

(defthm cst-c-char-conc1-of-tree-fix-cst
  (equal (cst-c-char-conc1 (abnf::tree-fix abnf::cst))
         (cst-c-char-conc1 abnf::cst)))

Theorem: cst-c-char-conc1-tree-equiv-congruence-on-cst

(defthm cst-c-char-conc1-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-c-char-conc1 abnf::cst)
                  (cst-c-char-conc1 cst-equiv)))
  :rule-classes :congruence)

Function: cst-c-char-conc2

(defun cst-c-char-conc2 (abnf::cst)
  (declare (xargs :guard (abnf::treep abnf::cst)))
  (declare (xargs :guard (and (cst-matchp abnf::cst "c-char")
                              (equal (cst-c-char-conc? abnf::cst)
                                     2))))
  (let ((__function__ 'cst-c-char-conc2))
    (declare (ignorable __function__))
    (abnf::tree-nonleaf->branches abnf::cst)))

Theorem: tree-list-listp-of-cst-c-char-conc2

(defthm tree-list-listp-of-cst-c-char-conc2
  (b* ((abnf::cstss (cst-c-char-conc2 abnf::cst)))
    (abnf::tree-list-listp abnf::cstss))
  :rule-classes :rewrite)

Theorem: cst-c-char-conc2-match

(defthm cst-c-char-conc2-match
  (implies
       (and (cst-matchp abnf::cst "c-char")
            (equal (cst-c-char-conc? abnf::cst) 2))
       (b* ((abnf::cstss (cst-c-char-conc2 abnf::cst)))
         (cst-list-list-conc-matchp abnf::cstss "escape-sequence")))
  :rule-classes :rewrite)

Theorem: cst-c-char-conc2-of-tree-fix-cst

(defthm cst-c-char-conc2-of-tree-fix-cst
  (equal (cst-c-char-conc2 (abnf::tree-fix abnf::cst))
         (cst-c-char-conc2 abnf::cst)))

Theorem: cst-c-char-conc2-tree-equiv-congruence-on-cst

(defthm cst-c-char-conc2-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-c-char-conc2 abnf::cst)
                  (cst-c-char-conc2 cst-equiv)))
  :rule-classes :congruence)

Function: cst-escape-sequence-conc1

(defun cst-escape-sequence-conc1 (abnf::cst)
 (declare (xargs :guard (abnf::treep abnf::cst)))
 (declare
     (xargs :guard (and (cst-matchp abnf::cst "escape-sequence")
                        (equal (cst-escape-sequence-conc? abnf::cst)
                               1))))
 (let ((__function__ 'cst-escape-sequence-conc1))
   (declare (ignorable __function__))
   (abnf::tree-nonleaf->branches abnf::cst)))

Theorem: tree-list-listp-of-cst-escape-sequence-conc1

(defthm tree-list-listp-of-cst-escape-sequence-conc1
  (b* ((abnf::cstss (cst-escape-sequence-conc1 abnf::cst)))
    (abnf::tree-list-listp abnf::cstss))
  :rule-classes :rewrite)

Theorem: cst-escape-sequence-conc1-match

(defthm cst-escape-sequence-conc1-match
  (implies (and (cst-matchp abnf::cst "escape-sequence")
                (equal (cst-escape-sequence-conc? abnf::cst)
                       1))
           (b* ((abnf::cstss (cst-escape-sequence-conc1 abnf::cst)))
             (cst-list-list-conc-matchp
                  abnf::cstss "simple-escape-sequence")))
  :rule-classes :rewrite)

Theorem: cst-escape-sequence-conc1-of-tree-fix-cst

(defthm cst-escape-sequence-conc1-of-tree-fix-cst
  (equal (cst-escape-sequence-conc1 (abnf::tree-fix abnf::cst))
         (cst-escape-sequence-conc1 abnf::cst)))

Theorem: cst-escape-sequence-conc1-tree-equiv-congruence-on-cst

(defthm cst-escape-sequence-conc1-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-escape-sequence-conc1 abnf::cst)
                  (cst-escape-sequence-conc1 cst-equiv)))
  :rule-classes :congruence)

Function: cst-escape-sequence-conc2

(defun cst-escape-sequence-conc2 (abnf::cst)
 (declare (xargs :guard (abnf::treep abnf::cst)))
 (declare
     (xargs :guard (and (cst-matchp abnf::cst "escape-sequence")
                        (equal (cst-escape-sequence-conc? abnf::cst)
                               2))))
 (let ((__function__ 'cst-escape-sequence-conc2))
   (declare (ignorable __function__))
   (abnf::tree-nonleaf->branches abnf::cst)))

Theorem: tree-list-listp-of-cst-escape-sequence-conc2

(defthm tree-list-listp-of-cst-escape-sequence-conc2
  (b* ((abnf::cstss (cst-escape-sequence-conc2 abnf::cst)))
    (abnf::tree-list-listp abnf::cstss))
  :rule-classes :rewrite)

Theorem: cst-escape-sequence-conc2-match

(defthm cst-escape-sequence-conc2-match
 (implies
  (and (cst-matchp abnf::cst "escape-sequence")
       (equal (cst-escape-sequence-conc? abnf::cst)
              2))
  (b* ((abnf::cstss (cst-escape-sequence-conc2 abnf::cst)))
   (cst-list-list-conc-matchp abnf::cstss "octal-escape-sequence")))
 :rule-classes :rewrite)

Theorem: cst-escape-sequence-conc2-of-tree-fix-cst

(defthm cst-escape-sequence-conc2-of-tree-fix-cst
  (equal (cst-escape-sequence-conc2 (abnf::tree-fix abnf::cst))
         (cst-escape-sequence-conc2 abnf::cst)))

Theorem: cst-escape-sequence-conc2-tree-equiv-congruence-on-cst

(defthm cst-escape-sequence-conc2-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-escape-sequence-conc2 abnf::cst)
                  (cst-escape-sequence-conc2 cst-equiv)))
  :rule-classes :congruence)

Function: cst-escape-sequence-conc3

(defun cst-escape-sequence-conc3 (abnf::cst)
 (declare (xargs :guard (abnf::treep abnf::cst)))
 (declare
     (xargs :guard (and (cst-matchp abnf::cst "escape-sequence")
                        (equal (cst-escape-sequence-conc? abnf::cst)
                               3))))
 (let ((__function__ 'cst-escape-sequence-conc3))
   (declare (ignorable __function__))
   (abnf::tree-nonleaf->branches abnf::cst)))

Theorem: tree-list-listp-of-cst-escape-sequence-conc3

(defthm tree-list-listp-of-cst-escape-sequence-conc3
  (b* ((abnf::cstss (cst-escape-sequence-conc3 abnf::cst)))
    (abnf::tree-list-listp abnf::cstss))
  :rule-classes :rewrite)

Theorem: cst-escape-sequence-conc3-match

(defthm cst-escape-sequence-conc3-match
  (implies
       (and (cst-matchp abnf::cst "escape-sequence")
            (equal (cst-escape-sequence-conc? abnf::cst)
                   3))
       (b* ((abnf::cstss (cst-escape-sequence-conc3 abnf::cst)))
         (cst-list-list-conc-matchp abnf::cstss
                                    "hexadecimal-escape-sequence")))
  :rule-classes :rewrite)

Theorem: cst-escape-sequence-conc3-of-tree-fix-cst

(defthm cst-escape-sequence-conc3-of-tree-fix-cst
  (equal (cst-escape-sequence-conc3 (abnf::tree-fix abnf::cst))
         (cst-escape-sequence-conc3 abnf::cst)))

Theorem: cst-escape-sequence-conc3-tree-equiv-congruence-on-cst

(defthm cst-escape-sequence-conc3-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-escape-sequence-conc3 abnf::cst)
                  (cst-escape-sequence-conc3 cst-equiv)))
  :rule-classes :congruence)

Function: cst-escape-sequence-conc4

(defun cst-escape-sequence-conc4 (abnf::cst)
 (declare (xargs :guard (abnf::treep abnf::cst)))
 (declare
     (xargs :guard (and (cst-matchp abnf::cst "escape-sequence")
                        (equal (cst-escape-sequence-conc? abnf::cst)
                               4))))
 (let ((__function__ 'cst-escape-sequence-conc4))
   (declare (ignorable __function__))
   (abnf::tree-nonleaf->branches abnf::cst)))

Theorem: tree-list-listp-of-cst-escape-sequence-conc4

(defthm tree-list-listp-of-cst-escape-sequence-conc4
  (b* ((abnf::cstss (cst-escape-sequence-conc4 abnf::cst)))
    (abnf::tree-list-listp abnf::cstss))
  :rule-classes :rewrite)

Theorem: cst-escape-sequence-conc4-match

(defthm cst-escape-sequence-conc4-match
 (implies (and (cst-matchp abnf::cst "escape-sequence")
               (equal (cst-escape-sequence-conc? abnf::cst)
                      4))
          (b* ((abnf::cstss (cst-escape-sequence-conc4 abnf::cst)))
            (cst-list-list-conc-matchp abnf::cstss
                                       "universal-character-name")))
 :rule-classes :rewrite)

Theorem: cst-escape-sequence-conc4-of-tree-fix-cst

(defthm cst-escape-sequence-conc4-of-tree-fix-cst
  (equal (cst-escape-sequence-conc4 (abnf::tree-fix abnf::cst))
         (cst-escape-sequence-conc4 abnf::cst)))

Theorem: cst-escape-sequence-conc4-tree-equiv-congruence-on-cst

(defthm cst-escape-sequence-conc4-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-escape-sequence-conc4 abnf::cst)
                  (cst-escape-sequence-conc4 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
    "[ encoding-prefix ] double-quote [ s-char-sequence ] 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-s-char-conc1

(defun cst-s-char-conc1 (abnf::cst)
  (declare (xargs :guard (abnf::treep abnf::cst)))
  (declare (xargs :guard (and (cst-matchp abnf::cst "s-char")
                              (equal (cst-s-char-conc? abnf::cst)
                                     1))))
  (let ((__function__ 'cst-s-char-conc1))
    (declare (ignorable __function__))
    (abnf::tree-nonleaf->branches abnf::cst)))

Theorem: tree-list-listp-of-cst-s-char-conc1

(defthm tree-list-listp-of-cst-s-char-conc1
  (b* ((abnf::cstss (cst-s-char-conc1 abnf::cst)))
    (abnf::tree-list-listp abnf::cstss))
  :rule-classes :rewrite)

Theorem: cst-s-char-conc1-match

(defthm cst-s-char-conc1-match
 (implies
     (and (cst-matchp abnf::cst "s-char")
          (equal (cst-s-char-conc? abnf::cst) 1))
     (b* ((abnf::cstss (cst-s-char-conc1 abnf::cst)))
       (cst-list-list-conc-matchp
            abnf::cstss
            "character-not-double-quote-or-backslash-or-new-line")))
 :rule-classes :rewrite)

Theorem: cst-s-char-conc1-of-tree-fix-cst

(defthm cst-s-char-conc1-of-tree-fix-cst
  (equal (cst-s-char-conc1 (abnf::tree-fix abnf::cst))
         (cst-s-char-conc1 abnf::cst)))

Theorem: cst-s-char-conc1-tree-equiv-congruence-on-cst

(defthm cst-s-char-conc1-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-s-char-conc1 abnf::cst)
                  (cst-s-char-conc1 cst-equiv)))
  :rule-classes :congruence)

Function: cst-s-char-conc2

(defun cst-s-char-conc2 (abnf::cst)
  (declare (xargs :guard (abnf::treep abnf::cst)))
  (declare (xargs :guard (and (cst-matchp abnf::cst "s-char")
                              (equal (cst-s-char-conc? abnf::cst)
                                     2))))
  (let ((__function__ 'cst-s-char-conc2))
    (declare (ignorable __function__))
    (abnf::tree-nonleaf->branches abnf::cst)))

Theorem: tree-list-listp-of-cst-s-char-conc2

(defthm tree-list-listp-of-cst-s-char-conc2
  (b* ((abnf::cstss (cst-s-char-conc2 abnf::cst)))
    (abnf::tree-list-listp abnf::cstss))
  :rule-classes :rewrite)

Theorem: cst-s-char-conc2-match

(defthm cst-s-char-conc2-match
  (implies
       (and (cst-matchp abnf::cst "s-char")
            (equal (cst-s-char-conc? abnf::cst) 2))
       (b* ((abnf::cstss (cst-s-char-conc2 abnf::cst)))
         (cst-list-list-conc-matchp abnf::cstss "escape-sequence")))
  :rule-classes :rewrite)

Theorem: cst-s-char-conc2-of-tree-fix-cst

(defthm cst-s-char-conc2-of-tree-fix-cst
  (equal (cst-s-char-conc2 (abnf::tree-fix abnf::cst))
         (cst-s-char-conc2 abnf::cst)))

Theorem: cst-s-char-conc2-tree-equiv-congruence-on-cst

(defthm cst-s-char-conc2-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-s-char-conc2 abnf::cst)
                  (cst-s-char-conc2 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 "control-line")))
 :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-lexeme-conc4

(defun cst-lexeme-conc4 (abnf::cst)
  (declare (xargs :guard (abnf::treep abnf::cst)))
  (declare (xargs :guard (and (cst-matchp abnf::cst "lexeme")
                              (equal (cst-lexeme-conc? abnf::cst)
                                     4))))
  (let ((__function__ 'cst-lexeme-conc4))
    (declare (ignorable __function__))
    (abnf::tree-nonleaf->branches abnf::cst)))

Theorem: tree-list-listp-of-cst-lexeme-conc4

(defthm tree-list-listp-of-cst-lexeme-conc4
  (b* ((abnf::cstss (cst-lexeme-conc4 abnf::cst)))
    (abnf::tree-list-listp abnf::cstss))
  :rule-classes :rewrite)

Theorem: cst-lexeme-conc4-match

(defthm cst-lexeme-conc4-match
  (implies (and (cst-matchp abnf::cst "lexeme")
                (equal (cst-lexeme-conc? abnf::cst) 4))
           (b* ((abnf::cstss (cst-lexeme-conc4 abnf::cst)))
             (cst-list-list-conc-matchp abnf::cstss "white-space")))
  :rule-classes :rewrite)

Theorem: cst-lexeme-conc4-of-tree-fix-cst

(defthm cst-lexeme-conc4-of-tree-fix-cst
  (equal (cst-lexeme-conc4 (abnf::tree-fix abnf::cst))
         (cst-lexeme-conc4 abnf::cst)))

Theorem: cst-lexeme-conc4-tree-equiv-congruence-on-cst

(defthm cst-lexeme-conc4-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-lexeme-conc4 abnf::cst)
                  (cst-lexeme-conc4 cst-equiv)))
  :rule-classes :congruence)

Function: cst-types-compatible-call-conc

(defun cst-types-compatible-call-conc (abnf::cst)
 (declare (xargs :guard (abnf::treep abnf::cst)))
 (declare
      (xargs :guard (cst-matchp abnf::cst "types-compatible-call")))
 (let ((__function__ 'cst-types-compatible-call-conc))
   (declare (ignorable __function__))
   (abnf::tree-nonleaf->branches abnf::cst)))

Theorem: tree-list-listp-of-cst-types-compatible-call-conc

(defthm tree-list-listp-of-cst-types-compatible-call-conc
  (b* ((abnf::cstss (cst-types-compatible-call-conc abnf::cst)))
    (abnf::tree-list-listp abnf::cstss))
  :rule-classes :rewrite)

Theorem: cst-types-compatible-call-conc-match

(defthm cst-types-compatible-call-conc-match
 (implies
  (cst-matchp abnf::cst "types-compatible-call")
  (b* ((abnf::cstss (cst-types-compatible-call-conc abnf::cst)))
   (cst-list-list-conc-matchp
    abnf::cstss
    "%s\"__builtin_types_compatible_p\" \"(\" type-name \",\" type-name \")\"")))
 :rule-classes :rewrite)

Theorem: cst-types-compatible-call-conc-of-tree-fix-cst

(defthm cst-types-compatible-call-conc-of-tree-fix-cst
  (equal (cst-types-compatible-call-conc (abnf::tree-fix abnf::cst))
         (cst-types-compatible-call-conc abnf::cst)))

Theorem: cst-types-compatible-call-conc-tree-equiv-congruence-on-cst

(defthm cst-types-compatible-call-conc-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-types-compatible-call-conc abnf::cst)
                  (cst-types-compatible-call-conc cst-equiv)))
  :rule-classes :congruence)

Function: cst-offsetof-call-conc

(defun cst-offsetof-call-conc (abnf::cst)
  (declare (xargs :guard (abnf::treep abnf::cst)))
  (declare (xargs :guard (cst-matchp abnf::cst "offsetof-call")))
  (let ((__function__ 'cst-offsetof-call-conc))
    (declare (ignorable __function__))
    (abnf::tree-nonleaf->branches abnf::cst)))

Theorem: tree-list-listp-of-cst-offsetof-call-conc

(defthm tree-list-listp-of-cst-offsetof-call-conc
  (b* ((abnf::cstss (cst-offsetof-call-conc abnf::cst)))
    (abnf::tree-list-listp abnf::cstss))
  :rule-classes :rewrite)

Theorem: cst-offsetof-call-conc-match

(defthm cst-offsetof-call-conc-match
 (implies
  (cst-matchp abnf::cst "offsetof-call")
  (b* ((abnf::cstss (cst-offsetof-call-conc abnf::cst)))
   (cst-list-list-conc-matchp
    abnf::cstss
    "%s\"__builtin_offsetof\" \"(\" type-name \",\" offsetof-member-designator \")\"")))
 :rule-classes :rewrite)

Theorem: cst-offsetof-call-conc-of-tree-fix-cst

(defthm cst-offsetof-call-conc-of-tree-fix-cst
  (equal (cst-offsetof-call-conc (abnf::tree-fix abnf::cst))
         (cst-offsetof-call-conc abnf::cst)))

Theorem: cst-offsetof-call-conc-tree-equiv-congruence-on-cst

(defthm cst-offsetof-call-conc-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-offsetof-call-conc abnf::cst)
                  (cst-offsetof-call-conc cst-equiv)))
  :rule-classes :congruence)

Function: cst-va-arg-call-conc

(defun cst-va-arg-call-conc (abnf::cst)
  (declare (xargs :guard (abnf::treep abnf::cst)))
  (declare (xargs :guard (cst-matchp abnf::cst "va-arg-call")))
  (let ((__function__ 'cst-va-arg-call-conc))
    (declare (ignorable __function__))
    (abnf::tree-nonleaf->branches abnf::cst)))

Theorem: tree-list-listp-of-cst-va-arg-call-conc

(defthm tree-list-listp-of-cst-va-arg-call-conc
  (b* ((abnf::cstss (cst-va-arg-call-conc abnf::cst)))
    (abnf::tree-list-listp abnf::cstss))
  :rule-classes :rewrite)

Theorem: cst-va-arg-call-conc-match

(defthm cst-va-arg-call-conc-match
 (implies
  (cst-matchp abnf::cst "va-arg-call")
  (b* ((abnf::cstss (cst-va-arg-call-conc abnf::cst)))
   (cst-list-list-conc-matchp
    abnf::cstss
    "%s\"__builtin_va_arg\" \"(\" assignment-expression \",\" type-name \")\"")))
 :rule-classes :rewrite)

Theorem: cst-va-arg-call-conc-of-tree-fix-cst

(defthm cst-va-arg-call-conc-of-tree-fix-cst
  (equal (cst-va-arg-call-conc (abnf::tree-fix abnf::cst))
         (cst-va-arg-call-conc abnf::cst)))

Theorem: cst-va-arg-call-conc-tree-equiv-congruence-on-cst

(defthm cst-va-arg-call-conc-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-va-arg-call-conc abnf::cst)
                  (cst-va-arg-call-conc cst-equiv)))
  :rule-classes :congruence)

Function: cst-generic-selection-conc

(defun cst-generic-selection-conc (abnf::cst)
 (declare (xargs :guard (abnf::treep abnf::cst)))
 (declare (xargs :guard (cst-matchp abnf::cst "generic-selection")))
 (let ((__function__ 'cst-generic-selection-conc))
   (declare (ignorable __function__))
   (abnf::tree-nonleaf->branches abnf::cst)))

Theorem: tree-list-listp-of-cst-generic-selection-conc

(defthm tree-list-listp-of-cst-generic-selection-conc
  (b* ((abnf::cstss (cst-generic-selection-conc abnf::cst)))
    (abnf::tree-list-listp abnf::cstss))
  :rule-classes :rewrite)

Theorem: cst-generic-selection-conc-match

(defthm cst-generic-selection-conc-match
 (implies
  (cst-matchp abnf::cst "generic-selection")
  (b* ((abnf::cstss (cst-generic-selection-conc abnf::cst)))
   (cst-list-list-conc-matchp
    abnf::cstss
    "%s\"_Generic\" \"(\" assignment-expression \",\" generic-assoc-list \")\"")))
 :rule-classes :rewrite)

Theorem: cst-generic-selection-conc-of-tree-fix-cst

(defthm cst-generic-selection-conc-of-tree-fix-cst
  (equal (cst-generic-selection-conc (abnf::tree-fix abnf::cst))
         (cst-generic-selection-conc abnf::cst)))

Theorem: cst-generic-selection-conc-tree-equiv-congruence-on-cst

(defthm cst-generic-selection-conc-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-generic-selection-conc abnf::cst)
                  (cst-generic-selection-conc cst-equiv)))
  :rule-classes :congruence)

Function: cst-constant-expression-conc

(defun cst-constant-expression-conc (abnf::cst)
  (declare (xargs :guard (abnf::treep abnf::cst)))
  (declare
       (xargs :guard (cst-matchp abnf::cst "constant-expression")))
  (let ((__function__ 'cst-constant-expression-conc))
    (declare (ignorable __function__))
    (abnf::tree-nonleaf->branches abnf::cst)))

Theorem: tree-list-listp-of-cst-constant-expression-conc

(defthm tree-list-listp-of-cst-constant-expression-conc
  (b* ((abnf::cstss (cst-constant-expression-conc abnf::cst)))
    (abnf::tree-list-listp abnf::cstss))
  :rule-classes :rewrite)

Theorem: cst-constant-expression-conc-match

(defthm cst-constant-expression-conc-match
  (implies
       (cst-matchp abnf::cst "constant-expression")
       (b* ((abnf::cstss (cst-constant-expression-conc abnf::cst)))
         (cst-list-list-conc-matchp
              abnf::cstss "conditional-expression")))
  :rule-classes :rewrite)

Theorem: cst-constant-expression-conc-of-tree-fix-cst

(defthm cst-constant-expression-conc-of-tree-fix-cst
  (equal (cst-constant-expression-conc (abnf::tree-fix abnf::cst))
         (cst-constant-expression-conc abnf::cst)))

Theorem: cst-constant-expression-conc-tree-equiv-congruence-on-cst

(defthm cst-constant-expression-conc-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-constant-expression-conc abnf::cst)
                  (cst-constant-expression-conc cst-equiv)))
  :rule-classes :congruence)

Function: cst-attribute-name-conc1

(defun cst-attribute-name-conc1 (abnf::cst)
 (declare (xargs :guard (abnf::treep abnf::cst)))
 (declare
      (xargs :guard (and (cst-matchp abnf::cst "attribute-name")
                         (equal (cst-attribute-name-conc? abnf::cst)
                                1))))
 (let ((__function__ 'cst-attribute-name-conc1))
   (declare (ignorable __function__))
   (abnf::tree-nonleaf->branches abnf::cst)))

Theorem: tree-list-listp-of-cst-attribute-name-conc1

(defthm tree-list-listp-of-cst-attribute-name-conc1
  (b* ((abnf::cstss (cst-attribute-name-conc1 abnf::cst)))
    (abnf::tree-list-listp abnf::cstss))
  :rule-classes :rewrite)

Theorem: cst-attribute-name-conc1-match

(defthm cst-attribute-name-conc1-match
  (implies (and (cst-matchp abnf::cst "attribute-name")
                (equal (cst-attribute-name-conc? abnf::cst)
                       1))
           (b* ((abnf::cstss (cst-attribute-name-conc1 abnf::cst)))
             (cst-list-list-conc-matchp abnf::cstss "identifier")))
  :rule-classes :rewrite)

Theorem: cst-attribute-name-conc1-of-tree-fix-cst

(defthm cst-attribute-name-conc1-of-tree-fix-cst
  (equal (cst-attribute-name-conc1 (abnf::tree-fix abnf::cst))
         (cst-attribute-name-conc1 abnf::cst)))

Theorem: cst-attribute-name-conc1-tree-equiv-congruence-on-cst

(defthm cst-attribute-name-conc1-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-attribute-name-conc1 abnf::cst)
                  (cst-attribute-name-conc1 cst-equiv)))
  :rule-classes :congruence)

Function: cst-attribute-name-conc2

(defun cst-attribute-name-conc2 (abnf::cst)
 (declare (xargs :guard (abnf::treep abnf::cst)))
 (declare
      (xargs :guard (and (cst-matchp abnf::cst "attribute-name")
                         (equal (cst-attribute-name-conc? abnf::cst)
                                2))))
 (let ((__function__ 'cst-attribute-name-conc2))
   (declare (ignorable __function__))
   (abnf::tree-nonleaf->branches abnf::cst)))

Theorem: tree-list-listp-of-cst-attribute-name-conc2

(defthm tree-list-listp-of-cst-attribute-name-conc2
  (b* ((abnf::cstss (cst-attribute-name-conc2 abnf::cst)))
    (abnf::tree-list-listp abnf::cstss))
  :rule-classes :rewrite)

Theorem: cst-attribute-name-conc2-match

(defthm cst-attribute-name-conc2-match
  (implies (and (cst-matchp abnf::cst "attribute-name")
                (equal (cst-attribute-name-conc? abnf::cst)
                       2))
           (b* ((abnf::cstss (cst-attribute-name-conc2 abnf::cst)))
             (cst-list-list-conc-matchp abnf::cstss "keyword")))
  :rule-classes :rewrite)

Theorem: cst-attribute-name-conc2-of-tree-fix-cst

(defthm cst-attribute-name-conc2-of-tree-fix-cst
  (equal (cst-attribute-name-conc2 (abnf::tree-fix abnf::cst))
         (cst-attribute-name-conc2 abnf::cst)))

Theorem: cst-attribute-name-conc2-tree-equiv-congruence-on-cst

(defthm cst-attribute-name-conc2-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-attribute-name-conc2 abnf::cst)
                  (cst-attribute-name-conc2 cst-equiv)))
  :rule-classes :congruence)

Function: cst-attribute-parameters-conc

(defun cst-attribute-parameters-conc (abnf::cst)
  (declare (xargs :guard (abnf::treep abnf::cst)))
  (declare
       (xargs :guard (cst-matchp abnf::cst "attribute-parameters")))
  (let ((__function__ 'cst-attribute-parameters-conc))
    (declare (ignorable __function__))
    (abnf::tree-nonleaf->branches abnf::cst)))

Theorem: tree-list-listp-of-cst-attribute-parameters-conc

(defthm tree-list-listp-of-cst-attribute-parameters-conc
  (b* ((abnf::cstss (cst-attribute-parameters-conc abnf::cst)))
    (abnf::tree-list-listp abnf::cstss))
  :rule-classes :rewrite)

Theorem: cst-attribute-parameters-conc-match

(defthm cst-attribute-parameters-conc-match
 (implies
  (cst-matchp abnf::cst "attribute-parameters")
  (b* ((abnf::cstss (cst-attribute-parameters-conc abnf::cst)))
   (cst-list-list-conc-matchp
    abnf::cstss
    "\"(\" [ assignment-expression *( \",\" assignment-expression ) ] \")\"")))
 :rule-classes :rewrite)

Theorem: cst-attribute-parameters-conc-of-tree-fix-cst

(defthm cst-attribute-parameters-conc-of-tree-fix-cst
  (equal (cst-attribute-parameters-conc (abnf::tree-fix abnf::cst))
         (cst-attribute-parameters-conc abnf::cst)))

Theorem: cst-attribute-parameters-conc-tree-equiv-congruence-on-cst

(defthm cst-attribute-parameters-conc-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-attribute-parameters-conc abnf::cst)
                  (cst-attribute-parameters-conc cst-equiv)))
  :rule-classes :congruence)

Function: cst-attribute-conc

(defun cst-attribute-conc (abnf::cst)
  (declare (xargs :guard (abnf::treep abnf::cst)))
  (declare (xargs :guard (cst-matchp abnf::cst "attribute")))
  (let ((__function__ 'cst-attribute-conc))
    (declare (ignorable __function__))
    (abnf::tree-nonleaf->branches abnf::cst)))

Theorem: tree-list-listp-of-cst-attribute-conc

(defthm tree-list-listp-of-cst-attribute-conc
  (b* ((abnf::cstss (cst-attribute-conc abnf::cst)))
    (abnf::tree-list-listp abnf::cstss))
  :rule-classes :rewrite)

Theorem: cst-attribute-conc-match

(defthm cst-attribute-conc-match
  (implies (cst-matchp abnf::cst "attribute")
           (b* ((abnf::cstss (cst-attribute-conc abnf::cst)))
             (cst-list-list-conc-matchp
                  abnf::cstss
                  "attribute-name [ attribute-parameters ]")))
  :rule-classes :rewrite)

Theorem: cst-attribute-conc-of-tree-fix-cst

(defthm cst-attribute-conc-of-tree-fix-cst
  (equal (cst-attribute-conc (abnf::tree-fix abnf::cst))
         (cst-attribute-conc abnf::cst)))

Theorem: cst-attribute-conc-tree-equiv-congruence-on-cst

(defthm cst-attribute-conc-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-attribute-conc abnf::cst)
                  (cst-attribute-conc cst-equiv)))
  :rule-classes :congruence)

Function: cst-attribute-list-conc

(defun cst-attribute-list-conc (abnf::cst)
  (declare (xargs :guard (abnf::treep abnf::cst)))
  (declare (xargs :guard (cst-matchp abnf::cst "attribute-list")))
  (let ((__function__ 'cst-attribute-list-conc))
    (declare (ignorable __function__))
    (abnf::tree-nonleaf->branches abnf::cst)))

Theorem: tree-list-listp-of-cst-attribute-list-conc

(defthm tree-list-listp-of-cst-attribute-list-conc
  (b* ((abnf::cstss (cst-attribute-list-conc abnf::cst)))
    (abnf::tree-list-listp abnf::cstss))
  :rule-classes :rewrite)

Theorem: cst-attribute-list-conc-match

(defthm cst-attribute-list-conc-match
 (implies
      (cst-matchp abnf::cst "attribute-list")
      (b* ((abnf::cstss (cst-attribute-list-conc abnf::cst)))
        (cst-list-list-conc-matchp abnf::cstss
                                   "attribute *( \",\" attribute )")))
 :rule-classes :rewrite)

Theorem: cst-attribute-list-conc-of-tree-fix-cst

(defthm cst-attribute-list-conc-of-tree-fix-cst
  (equal (cst-attribute-list-conc (abnf::tree-fix abnf::cst))
         (cst-attribute-list-conc abnf::cst)))

Theorem: cst-attribute-list-conc-tree-equiv-congruence-on-cst

(defthm cst-attribute-list-conc-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-attribute-list-conc abnf::cst)
                  (cst-attribute-list-conc cst-equiv)))
  :rule-classes :congruence)

Function: cst-attribute-specifier-conc

(defun cst-attribute-specifier-conc (abnf::cst)
  (declare (xargs :guard (abnf::treep abnf::cst)))
  (declare
       (xargs :guard (cst-matchp abnf::cst "attribute-specifier")))
  (let ((__function__ 'cst-attribute-specifier-conc))
    (declare (ignorable __function__))
    (abnf::tree-nonleaf->branches abnf::cst)))

Theorem: tree-list-listp-of-cst-attribute-specifier-conc

(defthm tree-list-listp-of-cst-attribute-specifier-conc
  (b* ((abnf::cstss (cst-attribute-specifier-conc abnf::cst)))
    (abnf::tree-list-listp abnf::cstss))
  :rule-classes :rewrite)

Theorem: cst-attribute-specifier-conc-match

(defthm cst-attribute-specifier-conc-match
 (implies
    (cst-matchp abnf::cst "attribute-specifier")
    (b* ((abnf::cstss (cst-attribute-specifier-conc abnf::cst)))
      (cst-list-list-conc-matchp
           abnf::cstss
           "attribute-keyword \"(\" \"(\" [ attribute-list ] \")\" \")\"")))
 :rule-classes :rewrite)

Theorem: cst-attribute-specifier-conc-of-tree-fix-cst

(defthm cst-attribute-specifier-conc-of-tree-fix-cst
  (equal (cst-attribute-specifier-conc (abnf::tree-fix abnf::cst))
         (cst-attribute-specifier-conc abnf::cst)))

Theorem: cst-attribute-specifier-conc-tree-equiv-congruence-on-cst

(defthm cst-attribute-specifier-conc-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-attribute-specifier-conc abnf::cst)
                  (cst-attribute-specifier-conc cst-equiv)))
  :rule-classes :congruence)

Function: cst-asm-name-specifier-conc

(defun cst-asm-name-specifier-conc (abnf::cst)
  (declare (xargs :guard (abnf::treep abnf::cst)))
  (declare
       (xargs :guard (cst-matchp abnf::cst "asm-name-specifier")))
  (let ((__function__ 'cst-asm-name-specifier-conc))
    (declare (ignorable __function__))
    (abnf::tree-nonleaf->branches abnf::cst)))

Theorem: tree-list-listp-of-cst-asm-name-specifier-conc

(defthm tree-list-listp-of-cst-asm-name-specifier-conc
  (b* ((abnf::cstss (cst-asm-name-specifier-conc abnf::cst)))
    (abnf::tree-list-listp abnf::cstss))
  :rule-classes :rewrite)

Theorem: cst-asm-name-specifier-conc-match

(defthm cst-asm-name-specifier-conc-match
  (implies
       (cst-matchp abnf::cst "asm-name-specifier")
       (b* ((abnf::cstss (cst-asm-name-specifier-conc abnf::cst)))
         (cst-list-list-conc-matchp
              abnf::cstss
              "asm-keyword \"(\" 1*string-literal \")\"")))
  :rule-classes :rewrite)

Theorem: cst-asm-name-specifier-conc-of-tree-fix-cst

(defthm cst-asm-name-specifier-conc-of-tree-fix-cst
  (equal (cst-asm-name-specifier-conc (abnf::tree-fix abnf::cst))
         (cst-asm-name-specifier-conc abnf::cst)))

Theorem: cst-asm-name-specifier-conc-tree-equiv-congruence-on-cst

(defthm cst-asm-name-specifier-conc-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-asm-name-specifier-conc abnf::cst)
                  (cst-asm-name-specifier-conc cst-equiv)))
  :rule-classes :congruence)

Function: cst-asm-statement-conc

(defun cst-asm-statement-conc (abnf::cst)
  (declare (xargs :guard (abnf::treep abnf::cst)))
  (declare (xargs :guard (cst-matchp abnf::cst "asm-statement")))
  (let ((__function__ 'cst-asm-statement-conc))
    (declare (ignorable __function__))
    (abnf::tree-nonleaf->branches abnf::cst)))

Theorem: tree-list-listp-of-cst-asm-statement-conc

(defthm tree-list-listp-of-cst-asm-statement-conc
  (b* ((abnf::cstss (cst-asm-statement-conc abnf::cst)))
    (abnf::tree-list-listp abnf::cstss))
  :rule-classes :rewrite)

Theorem: cst-asm-statement-conc-match

(defthm cst-asm-statement-conc-match
 (implies
  (cst-matchp abnf::cst "asm-statement")
  (b* ((abnf::cstss (cst-asm-statement-conc abnf::cst)))
   (cst-list-list-conc-matchp
    abnf::cstss
    "asm-keyword *asm-qualifier \"(\" 1*string-literal [ \":\" asm-output-operands [ \":\" asm-input-operands [ \":\" asm-clobbers [ \":\" asm-goto-labels ] ] ] ] \")\" \";\"")))
 :rule-classes :rewrite)

Theorem: cst-asm-statement-conc-of-tree-fix-cst

(defthm cst-asm-statement-conc-of-tree-fix-cst
  (equal (cst-asm-statement-conc (abnf::tree-fix abnf::cst))
         (cst-asm-statement-conc abnf::cst)))

Theorem: cst-asm-statement-conc-tree-equiv-congruence-on-cst

(defthm cst-asm-statement-conc-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-asm-statement-conc abnf::cst)
                  (cst-asm-statement-conc cst-equiv)))
  :rule-classes :congruence)

Function: cst-asm-output-operands-conc

(defun cst-asm-output-operands-conc (abnf::cst)
  (declare (xargs :guard (abnf::treep abnf::cst)))
  (declare
       (xargs :guard (cst-matchp abnf::cst "asm-output-operands")))
  (let ((__function__ 'cst-asm-output-operands-conc))
    (declare (ignorable __function__))
    (abnf::tree-nonleaf->branches abnf::cst)))

Theorem: tree-list-listp-of-cst-asm-output-operands-conc

(defthm tree-list-listp-of-cst-asm-output-operands-conc
  (b* ((abnf::cstss (cst-asm-output-operands-conc abnf::cst)))
    (abnf::tree-list-listp abnf::cstss))
  :rule-classes :rewrite)

Theorem: cst-asm-output-operands-conc-match

(defthm cst-asm-output-operands-conc-match
 (implies
      (cst-matchp abnf::cst "asm-output-operands")
      (b* ((abnf::cstss (cst-asm-output-operands-conc abnf::cst)))
        (cst-list-list-conc-matchp
             abnf::cstss
             "[ asm-output-operand *( \",\" asm-output-operand ) ]")))
 :rule-classes :rewrite)

Theorem: cst-asm-output-operands-conc-of-tree-fix-cst

(defthm cst-asm-output-operands-conc-of-tree-fix-cst
  (equal (cst-asm-output-operands-conc (abnf::tree-fix abnf::cst))
         (cst-asm-output-operands-conc abnf::cst)))

Theorem: cst-asm-output-operands-conc-tree-equiv-congruence-on-cst

(defthm cst-asm-output-operands-conc-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-asm-output-operands-conc abnf::cst)
                  (cst-asm-output-operands-conc cst-equiv)))
  :rule-classes :congruence)

Function: cst-asm-output-operand-conc

(defun cst-asm-output-operand-conc (abnf::cst)
  (declare (xargs :guard (abnf::treep abnf::cst)))
  (declare
       (xargs :guard (cst-matchp abnf::cst "asm-output-operand")))
  (let ((__function__ 'cst-asm-output-operand-conc))
    (declare (ignorable __function__))
    (abnf::tree-nonleaf->branches abnf::cst)))

Theorem: tree-list-listp-of-cst-asm-output-operand-conc

(defthm tree-list-listp-of-cst-asm-output-operand-conc
  (b* ((abnf::cstss (cst-asm-output-operand-conc abnf::cst)))
    (abnf::tree-list-listp abnf::cstss))
  :rule-classes :rewrite)

Theorem: cst-asm-output-operand-conc-match

(defthm cst-asm-output-operand-conc-match
 (implies
  (cst-matchp abnf::cst "asm-output-operand")
  (b* ((abnf::cstss (cst-asm-output-operand-conc abnf::cst)))
   (cst-list-list-conc-matchp
     abnf::cstss
     "[ \"[\" identifier \"]\" ] 1*string-literal \"(\" expression \")\"")))
 :rule-classes :rewrite)

Theorem: cst-asm-output-operand-conc-of-tree-fix-cst

(defthm cst-asm-output-operand-conc-of-tree-fix-cst
  (equal (cst-asm-output-operand-conc (abnf::tree-fix abnf::cst))
         (cst-asm-output-operand-conc abnf::cst)))

Theorem: cst-asm-output-operand-conc-tree-equiv-congruence-on-cst

(defthm cst-asm-output-operand-conc-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-asm-output-operand-conc abnf::cst)
                  (cst-asm-output-operand-conc cst-equiv)))
  :rule-classes :congruence)

Function: cst-asm-input-operands-conc

(defun cst-asm-input-operands-conc (abnf::cst)
  (declare (xargs :guard (abnf::treep abnf::cst)))
  (declare
       (xargs :guard (cst-matchp abnf::cst "asm-input-operands")))
  (let ((__function__ 'cst-asm-input-operands-conc))
    (declare (ignorable __function__))
    (abnf::tree-nonleaf->branches abnf::cst)))

Theorem: tree-list-listp-of-cst-asm-input-operands-conc

(defthm tree-list-listp-of-cst-asm-input-operands-conc
  (b* ((abnf::cstss (cst-asm-input-operands-conc abnf::cst)))
    (abnf::tree-list-listp abnf::cstss))
  :rule-classes :rewrite)

Theorem: cst-asm-input-operands-conc-match

(defthm cst-asm-input-operands-conc-match
  (implies
       (cst-matchp abnf::cst "asm-input-operands")
       (b* ((abnf::cstss (cst-asm-input-operands-conc abnf::cst)))
         (cst-list-list-conc-matchp
              abnf::cstss
              "[ asm-input-operand *( \",\" asm-input-operand ) ]")))
  :rule-classes :rewrite)

Theorem: cst-asm-input-operands-conc-of-tree-fix-cst

(defthm cst-asm-input-operands-conc-of-tree-fix-cst
  (equal (cst-asm-input-operands-conc (abnf::tree-fix abnf::cst))
         (cst-asm-input-operands-conc abnf::cst)))

Theorem: cst-asm-input-operands-conc-tree-equiv-congruence-on-cst

(defthm cst-asm-input-operands-conc-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-asm-input-operands-conc abnf::cst)
                  (cst-asm-input-operands-conc cst-equiv)))
  :rule-classes :congruence)

Function: cst-asm-input-operand-conc

(defun cst-asm-input-operand-conc (abnf::cst)
 (declare (xargs :guard (abnf::treep abnf::cst)))
 (declare (xargs :guard (cst-matchp abnf::cst "asm-input-operand")))
 (let ((__function__ 'cst-asm-input-operand-conc))
   (declare (ignorable __function__))
   (abnf::tree-nonleaf->branches abnf::cst)))

Theorem: tree-list-listp-of-cst-asm-input-operand-conc

(defthm tree-list-listp-of-cst-asm-input-operand-conc
  (b* ((abnf::cstss (cst-asm-input-operand-conc abnf::cst)))
    (abnf::tree-list-listp abnf::cstss))
  :rule-classes :rewrite)

Theorem: cst-asm-input-operand-conc-match

(defthm cst-asm-input-operand-conc-match
 (implies
  (cst-matchp abnf::cst "asm-input-operand")
  (b* ((abnf::cstss (cst-asm-input-operand-conc abnf::cst)))
   (cst-list-list-conc-matchp
     abnf::cstss
     "[ \"[\" identifier \"]\" ] 1*string-literal \"(\" expression \")\"")))
 :rule-classes :rewrite)

Theorem: cst-asm-input-operand-conc-of-tree-fix-cst

(defthm cst-asm-input-operand-conc-of-tree-fix-cst
  (equal (cst-asm-input-operand-conc (abnf::tree-fix abnf::cst))
         (cst-asm-input-operand-conc abnf::cst)))

Theorem: cst-asm-input-operand-conc-tree-equiv-congruence-on-cst

(defthm cst-asm-input-operand-conc-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-asm-input-operand-conc abnf::cst)
                  (cst-asm-input-operand-conc cst-equiv)))
  :rule-classes :congruence)

Function: cst-asm-clobbers-conc

(defun cst-asm-clobbers-conc (abnf::cst)
  (declare (xargs :guard (abnf::treep abnf::cst)))
  (declare (xargs :guard (cst-matchp abnf::cst "asm-clobbers")))
  (let ((__function__ 'cst-asm-clobbers-conc))
    (declare (ignorable __function__))
    (abnf::tree-nonleaf->branches abnf::cst)))

Theorem: tree-list-listp-of-cst-asm-clobbers-conc

(defthm tree-list-listp-of-cst-asm-clobbers-conc
  (b* ((abnf::cstss (cst-asm-clobbers-conc abnf::cst)))
    (abnf::tree-list-listp abnf::cstss))
  :rule-classes :rewrite)

Theorem: cst-asm-clobbers-conc-match

(defthm cst-asm-clobbers-conc-match
  (implies (cst-matchp abnf::cst "asm-clobbers")
           (b* ((abnf::cstss (cst-asm-clobbers-conc abnf::cst)))
             (cst-list-list-conc-matchp
                  abnf::cstss
                  "[ asm-clobber *( \",\" asm-clobber ) ]")))
  :rule-classes :rewrite)

Theorem: cst-asm-clobbers-conc-of-tree-fix-cst

(defthm cst-asm-clobbers-conc-of-tree-fix-cst
  (equal (cst-asm-clobbers-conc (abnf::tree-fix abnf::cst))
         (cst-asm-clobbers-conc abnf::cst)))

Theorem: cst-asm-clobbers-conc-tree-equiv-congruence-on-cst

(defthm cst-asm-clobbers-conc-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-asm-clobbers-conc abnf::cst)
                  (cst-asm-clobbers-conc cst-equiv)))
  :rule-classes :congruence)

Function: cst-asm-clobber-conc

(defun cst-asm-clobber-conc (abnf::cst)
  (declare (xargs :guard (abnf::treep abnf::cst)))
  (declare (xargs :guard (cst-matchp abnf::cst "asm-clobber")))
  (let ((__function__ 'cst-asm-clobber-conc))
    (declare (ignorable __function__))
    (abnf::tree-nonleaf->branches abnf::cst)))

Theorem: tree-list-listp-of-cst-asm-clobber-conc

(defthm tree-list-listp-of-cst-asm-clobber-conc
  (b* ((abnf::cstss (cst-asm-clobber-conc abnf::cst)))
    (abnf::tree-list-listp abnf::cstss))
  :rule-classes :rewrite)

Theorem: cst-asm-clobber-conc-match

(defthm cst-asm-clobber-conc-match
 (implies
      (cst-matchp abnf::cst "asm-clobber")
      (b* ((abnf::cstss (cst-asm-clobber-conc abnf::cst)))
        (cst-list-list-conc-matchp abnf::cstss "1*string-literal")))
 :rule-classes :rewrite)

Theorem: cst-asm-clobber-conc-of-tree-fix-cst

(defthm cst-asm-clobber-conc-of-tree-fix-cst
  (equal (cst-asm-clobber-conc (abnf::tree-fix abnf::cst))
         (cst-asm-clobber-conc abnf::cst)))

Theorem: cst-asm-clobber-conc-tree-equiv-congruence-on-cst

(defthm cst-asm-clobber-conc-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-asm-clobber-conc abnf::cst)
                  (cst-asm-clobber-conc cst-equiv)))
  :rule-classes :congruence)

Function: cst-asm-goto-labels-conc

(defun cst-asm-goto-labels-conc (abnf::cst)
  (declare (xargs :guard (abnf::treep abnf::cst)))
  (declare (xargs :guard (cst-matchp abnf::cst "asm-goto-labels")))
  (let ((__function__ 'cst-asm-goto-labels-conc))
    (declare (ignorable __function__))
    (abnf::tree-nonleaf->branches abnf::cst)))

Theorem: tree-list-listp-of-cst-asm-goto-labels-conc

(defthm tree-list-listp-of-cst-asm-goto-labels-conc
  (b* ((abnf::cstss (cst-asm-goto-labels-conc abnf::cst)))
    (abnf::tree-list-listp abnf::cstss))
  :rule-classes :rewrite)

Theorem: cst-asm-goto-labels-conc-match

(defthm cst-asm-goto-labels-conc-match
  (implies (cst-matchp abnf::cst "asm-goto-labels")
           (b* ((abnf::cstss (cst-asm-goto-labels-conc abnf::cst)))
             (cst-list-list-conc-matchp
                  abnf::cstss
                  "[ identifier *( \",\" identifier ) ]")))
  :rule-classes :rewrite)

Theorem: cst-asm-goto-labels-conc-of-tree-fix-cst

(defthm cst-asm-goto-labels-conc-of-tree-fix-cst
  (equal (cst-asm-goto-labels-conc (abnf::tree-fix abnf::cst))
         (cst-asm-goto-labels-conc abnf::cst)))

Theorem: cst-asm-goto-labels-conc-tree-equiv-congruence-on-cst

(defthm cst-asm-goto-labels-conc-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-asm-goto-labels-conc abnf::cst)
                  (cst-asm-goto-labels-conc cst-equiv)))
  :rule-classes :congruence)

Function: cst-atomic-type-specifier-conc

(defun cst-atomic-type-specifier-conc (abnf::cst)
 (declare (xargs :guard (abnf::treep abnf::cst)))
 (declare
      (xargs :guard (cst-matchp abnf::cst "atomic-type-specifier")))
 (let ((__function__ 'cst-atomic-type-specifier-conc))
   (declare (ignorable __function__))
   (abnf::tree-nonleaf->branches abnf::cst)))

Theorem: tree-list-listp-of-cst-atomic-type-specifier-conc

(defthm tree-list-listp-of-cst-atomic-type-specifier-conc
  (b* ((abnf::cstss (cst-atomic-type-specifier-conc abnf::cst)))
    (abnf::tree-list-listp abnf::cstss))
  :rule-classes :rewrite)

Theorem: cst-atomic-type-specifier-conc-match

(defthm cst-atomic-type-specifier-conc-match
 (implies
     (cst-matchp abnf::cst "atomic-type-specifier")
     (b* ((abnf::cstss (cst-atomic-type-specifier-conc abnf::cst)))
       (cst-list-list-conc-matchp abnf::cstss
                                  "%s\"_Atomic\" \"(\" type-name \")\"")))
 :rule-classes :rewrite)

Theorem: cst-atomic-type-specifier-conc-of-tree-fix-cst

(defthm cst-atomic-type-specifier-conc-of-tree-fix-cst
  (equal (cst-atomic-type-specifier-conc (abnf::tree-fix abnf::cst))
         (cst-atomic-type-specifier-conc abnf::cst)))

Theorem: cst-atomic-type-specifier-conc-tree-equiv-congruence-on-cst

(defthm cst-atomic-type-specifier-conc-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-atomic-type-specifier-conc abnf::cst)
                  (cst-atomic-type-specifier-conc cst-equiv)))
  :rule-classes :congruence)

Function: cst-declarator-conc

(defun cst-declarator-conc (abnf::cst)
  (declare (xargs :guard (abnf::treep abnf::cst)))
  (declare (xargs :guard (cst-matchp abnf::cst "declarator")))
  (let ((__function__ 'cst-declarator-conc))
    (declare (ignorable __function__))
    (abnf::tree-nonleaf->branches abnf::cst)))

Theorem: tree-list-listp-of-cst-declarator-conc

(defthm tree-list-listp-of-cst-declarator-conc
  (b* ((abnf::cstss (cst-declarator-conc abnf::cst)))
    (abnf::tree-list-listp abnf::cstss))
  :rule-classes :rewrite)

Theorem: cst-declarator-conc-match

(defthm cst-declarator-conc-match
 (implies
     (cst-matchp abnf::cst "declarator")
     (b* ((abnf::cstss (cst-declarator-conc abnf::cst)))
       (cst-list-list-conc-matchp abnf::cstss
                                  "[ pointer ] direct-declarator")))
 :rule-classes :rewrite)

Theorem: cst-declarator-conc-of-tree-fix-cst

(defthm cst-declarator-conc-of-tree-fix-cst
  (equal (cst-declarator-conc (abnf::tree-fix abnf::cst))
         (cst-declarator-conc abnf::cst)))

Theorem: cst-declarator-conc-tree-equiv-congruence-on-cst

(defthm cst-declarator-conc-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-declarator-conc abnf::cst)
                  (cst-declarator-conc cst-equiv)))
  :rule-classes :congruence)

Function: cst-type-qualifier-or-attribute-specifier-conc1

(defun cst-type-qualifier-or-attribute-specifier-conc1 (abnf::cst)
 (declare (xargs :guard (abnf::treep abnf::cst)))
 (declare
  (xargs
   :guard
   (and
    (cst-matchp abnf::cst
                "type-qualifier-or-attribute-specifier")
    (equal
         (cst-type-qualifier-or-attribute-specifier-conc? abnf::cst)
         1))))
 (let
  ((__function__ 'cst-type-qualifier-or-attribute-specifier-conc1))
  (declare (ignorable __function__))
  (abnf::tree-nonleaf->branches abnf::cst)))

Theorem: tree-list-listp-of-cst-type-qualifier-or-attribute-specifier-conc1

(defthm
 tree-list-listp-of-cst-type-qualifier-or-attribute-specifier-conc1
 (b*
  ((abnf::cstss
       (cst-type-qualifier-or-attribute-specifier-conc1 abnf::cst)))
  (abnf::tree-list-listp abnf::cstss))
 :rule-classes :rewrite)

Theorem: cst-type-qualifier-or-attribute-specifier-conc1-match

(defthm cst-type-qualifier-or-attribute-specifier-conc1-match
 (implies
  (and
    (cst-matchp abnf::cst
                "type-qualifier-or-attribute-specifier")
    (equal
         (cst-type-qualifier-or-attribute-specifier-conc? abnf::cst)
         1))
  (b*
   ((abnf::cstss
       (cst-type-qualifier-or-attribute-specifier-conc1 abnf::cst)))
   (cst-list-list-conc-matchp abnf::cstss "type-qualifier")))
 :rule-classes :rewrite)

Theorem: cst-type-qualifier-or-attribute-specifier-conc1-of-tree-fix-cst

(defthm
    cst-type-qualifier-or-attribute-specifier-conc1-of-tree-fix-cst
  (equal
       (cst-type-qualifier-or-attribute-specifier-conc1
            (abnf::tree-fix abnf::cst))
       (cst-type-qualifier-or-attribute-specifier-conc1 abnf::cst)))

Theorem: cst-type-qualifier-or-attribute-specifier-conc1-tree-equiv-congruence-on-cst

(defthm
 cst-type-qualifier-or-attribute-specifier-conc1-tree-equiv-congruence-on-cst
 (implies
  (abnf::tree-equiv abnf::cst cst-equiv)
  (equal
       (cst-type-qualifier-or-attribute-specifier-conc1 abnf::cst)
       (cst-type-qualifier-or-attribute-specifier-conc1 cst-equiv)))
 :rule-classes :congruence)

Function: cst-type-qualifier-or-attribute-specifier-conc2

(defun cst-type-qualifier-or-attribute-specifier-conc2 (abnf::cst)
 (declare (xargs :guard (abnf::treep abnf::cst)))
 (declare
  (xargs
   :guard
   (and
    (cst-matchp abnf::cst
                "type-qualifier-or-attribute-specifier")
    (equal
         (cst-type-qualifier-or-attribute-specifier-conc? abnf::cst)
         2))))
 (let
  ((__function__ 'cst-type-qualifier-or-attribute-specifier-conc2))
  (declare (ignorable __function__))
  (abnf::tree-nonleaf->branches abnf::cst)))

Theorem: tree-list-listp-of-cst-type-qualifier-or-attribute-specifier-conc2

(defthm
 tree-list-listp-of-cst-type-qualifier-or-attribute-specifier-conc2
 (b*
  ((abnf::cstss
       (cst-type-qualifier-or-attribute-specifier-conc2 abnf::cst)))
  (abnf::tree-list-listp abnf::cstss))
 :rule-classes :rewrite)

Theorem: cst-type-qualifier-or-attribute-specifier-conc2-match

(defthm cst-type-qualifier-or-attribute-specifier-conc2-match
 (implies
  (and
    (cst-matchp abnf::cst
                "type-qualifier-or-attribute-specifier")
    (equal
         (cst-type-qualifier-or-attribute-specifier-conc? abnf::cst)
         2))
  (b*
   ((abnf::cstss
       (cst-type-qualifier-or-attribute-specifier-conc2 abnf::cst)))
   (cst-list-list-conc-matchp abnf::cstss "attribute-specifier")))
 :rule-classes :rewrite)

Theorem: cst-type-qualifier-or-attribute-specifier-conc2-of-tree-fix-cst

(defthm
    cst-type-qualifier-or-attribute-specifier-conc2-of-tree-fix-cst
  (equal
       (cst-type-qualifier-or-attribute-specifier-conc2
            (abnf::tree-fix abnf::cst))
       (cst-type-qualifier-or-attribute-specifier-conc2 abnf::cst)))

Theorem: cst-type-qualifier-or-attribute-specifier-conc2-tree-equiv-congruence-on-cst

(defthm
 cst-type-qualifier-or-attribute-specifier-conc2-tree-equiv-congruence-on-cst
 (implies
  (abnf::tree-equiv abnf::cst cst-equiv)
  (equal
       (cst-type-qualifier-or-attribute-specifier-conc2 abnf::cst)
       (cst-type-qualifier-or-attribute-specifier-conc2 cst-equiv)))
 :rule-classes :congruence)

Function: cst-type-name-conc

(defun cst-type-name-conc (abnf::cst)
  (declare (xargs :guard (abnf::treep abnf::cst)))
  (declare (xargs :guard (cst-matchp abnf::cst "type-name")))
  (let ((__function__ 'cst-type-name-conc))
    (declare (ignorable __function__))
    (abnf::tree-nonleaf->branches abnf::cst)))

Theorem: tree-list-listp-of-cst-type-name-conc

(defthm tree-list-listp-of-cst-type-name-conc
  (b* ((abnf::cstss (cst-type-name-conc abnf::cst)))
    (abnf::tree-list-listp abnf::cstss))
  :rule-classes :rewrite)

Theorem: cst-type-name-conc-match

(defthm cst-type-name-conc-match
  (implies
       (cst-matchp abnf::cst "type-name")
       (b* ((abnf::cstss (cst-type-name-conc abnf::cst)))
         (cst-list-list-conc-matchp
              abnf::cstss
              "specifier-qualifier-list [ abstract-declarator ]")))
  :rule-classes :rewrite)

Theorem: cst-type-name-conc-of-tree-fix-cst

(defthm cst-type-name-conc-of-tree-fix-cst
  (equal (cst-type-name-conc (abnf::tree-fix abnf::cst))
         (cst-type-name-conc abnf::cst)))

Theorem: cst-type-name-conc-tree-equiv-congruence-on-cst

(defthm cst-type-name-conc-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-type-name-conc abnf::cst)
                  (cst-type-name-conc cst-equiv)))
  :rule-classes :congruence)

Function: cst-typedef-name-conc

(defun cst-typedef-name-conc (abnf::cst)
  (declare (xargs :guard (abnf::treep abnf::cst)))
  (declare (xargs :guard (cst-matchp abnf::cst "typedef-name")))
  (let ((__function__ 'cst-typedef-name-conc))
    (declare (ignorable __function__))
    (abnf::tree-nonleaf->branches abnf::cst)))

Theorem: tree-list-listp-of-cst-typedef-name-conc

(defthm tree-list-listp-of-cst-typedef-name-conc
  (b* ((abnf::cstss (cst-typedef-name-conc abnf::cst)))
    (abnf::tree-list-listp abnf::cstss))
  :rule-classes :rewrite)

Theorem: cst-typedef-name-conc-match

(defthm cst-typedef-name-conc-match
  (implies (cst-matchp abnf::cst "typedef-name")
           (b* ((abnf::cstss (cst-typedef-name-conc abnf::cst)))
             (cst-list-list-conc-matchp abnf::cstss "identifier")))
  :rule-classes :rewrite)

Theorem: cst-typedef-name-conc-of-tree-fix-cst

(defthm cst-typedef-name-conc-of-tree-fix-cst
  (equal (cst-typedef-name-conc (abnf::tree-fix abnf::cst))
         (cst-typedef-name-conc abnf::cst)))

Theorem: cst-typedef-name-conc-tree-equiv-congruence-on-cst

(defthm cst-typedef-name-conc-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-typedef-name-conc abnf::cst)
                  (cst-typedef-name-conc cst-equiv)))
  :rule-classes :congruence)

Function: cst-designation-conc

(defun cst-designation-conc (abnf::cst)
  (declare (xargs :guard (abnf::treep abnf::cst)))
  (declare (xargs :guard (cst-matchp abnf::cst "designation")))
  (let ((__function__ 'cst-designation-conc))
    (declare (ignorable __function__))
    (abnf::tree-nonleaf->branches abnf::cst)))

Theorem: tree-list-listp-of-cst-designation-conc

(defthm tree-list-listp-of-cst-designation-conc
  (b* ((abnf::cstss (cst-designation-conc abnf::cst)))
    (abnf::tree-list-listp abnf::cstss))
  :rule-classes :rewrite)

Theorem: cst-designation-conc-match

(defthm cst-designation-conc-match
 (implies
   (cst-matchp abnf::cst "designation")
   (b* ((abnf::cstss (cst-designation-conc abnf::cst)))
     (cst-list-list-conc-matchp abnf::cstss "designator-list \"=\"")))
 :rule-classes :rewrite)

Theorem: cst-designation-conc-of-tree-fix-cst

(defthm cst-designation-conc-of-tree-fix-cst
  (equal (cst-designation-conc (abnf::tree-fix abnf::cst))
         (cst-designation-conc abnf::cst)))

Theorem: cst-designation-conc-tree-equiv-congruence-on-cst

(defthm cst-designation-conc-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-designation-conc abnf::cst)
                  (cst-designation-conc cst-equiv)))
  :rule-classes :congruence)

Function: cst-static-assert-declaration-conc

(defun cst-static-assert-declaration-conc (abnf::cst)
 (declare (xargs :guard (abnf::treep abnf::cst)))
 (declare
  (xargs :guard (cst-matchp abnf::cst "static-assert-declaration")))
 (let ((__function__ 'cst-static-assert-declaration-conc))
   (declare (ignorable __function__))
   (abnf::tree-nonleaf->branches abnf::cst)))

Theorem: tree-list-listp-of-cst-static-assert-declaration-conc

(defthm tree-list-listp-of-cst-static-assert-declaration-conc
  (b* ((abnf::cstss (cst-static-assert-declaration-conc abnf::cst)))
    (abnf::tree-list-listp abnf::cstss))
  :rule-classes :rewrite)

Theorem: cst-static-assert-declaration-conc-match

(defthm cst-static-assert-declaration-conc-match
 (implies
  (cst-matchp abnf::cst "static-assert-declaration")
  (b* ((abnf::cstss (cst-static-assert-declaration-conc abnf::cst)))
   (cst-list-list-conc-matchp
    abnf::cstss
    "%s\"_Static_assert\" \"(\" constant-expression \",\" 1*string-literal \")\" \";\"")))
 :rule-classes :rewrite)

Theorem: cst-static-assert-declaration-conc-of-tree-fix-cst

(defthm cst-static-assert-declaration-conc-of-tree-fix-cst
 (equal
     (cst-static-assert-declaration-conc (abnf::tree-fix abnf::cst))
     (cst-static-assert-declaration-conc abnf::cst)))

Theorem: cst-static-assert-declaration-conc-tree-equiv-congruence-on-cst

(defthm
    cst-static-assert-declaration-conc-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-static-assert-declaration-conc abnf::cst)
                  (cst-static-assert-declaration-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 "labeled-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 "compound-statement")))
 :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 "expression-statement")))
 :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 "selection-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 "iteration-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 "jump-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 "asm-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-label-declaration-conc

(defun cst-label-declaration-conc (abnf::cst)
 (declare (xargs :guard (abnf::treep abnf::cst)))
 (declare (xargs :guard (cst-matchp abnf::cst "label-declaration")))
 (let ((__function__ 'cst-label-declaration-conc))
   (declare (ignorable __function__))
   (abnf::tree-nonleaf->branches abnf::cst)))

Theorem: tree-list-listp-of-cst-label-declaration-conc

(defthm tree-list-listp-of-cst-label-declaration-conc
  (b* ((abnf::cstss (cst-label-declaration-conc abnf::cst)))
    (abnf::tree-list-listp abnf::cstss))
  :rule-classes :rewrite)

Theorem: cst-label-declaration-conc-match

(defthm cst-label-declaration-conc-match
  (implies
       (cst-matchp abnf::cst "label-declaration")
       (b* ((abnf::cstss (cst-label-declaration-conc abnf::cst)))
         (cst-list-list-conc-matchp
              abnf::cstss
              "%s\"__label__\" identifier *( \",\" identifier ) \";\"")))
  :rule-classes :rewrite)

Theorem: cst-label-declaration-conc-of-tree-fix-cst

(defthm cst-label-declaration-conc-of-tree-fix-cst
  (equal (cst-label-declaration-conc (abnf::tree-fix abnf::cst))
         (cst-label-declaration-conc abnf::cst)))

Theorem: cst-label-declaration-conc-tree-equiv-congruence-on-cst

(defthm cst-label-declaration-conc-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-label-declaration-conc abnf::cst)
                  (cst-label-declaration-conc cst-equiv)))
  :rule-classes :congruence)

Function: cst-compound-statement-conc

(defun cst-compound-statement-conc (abnf::cst)
  (declare (xargs :guard (abnf::treep abnf::cst)))
  (declare
       (xargs :guard (cst-matchp abnf::cst "compound-statement")))
  (let ((__function__ 'cst-compound-statement-conc))
    (declare (ignorable __function__))
    (abnf::tree-nonleaf->branches abnf::cst)))

Theorem: tree-list-listp-of-cst-compound-statement-conc

(defthm tree-list-listp-of-cst-compound-statement-conc
  (b* ((abnf::cstss (cst-compound-statement-conc abnf::cst)))
    (abnf::tree-list-listp abnf::cstss))
  :rule-classes :rewrite)

Theorem: cst-compound-statement-conc-match

(defthm cst-compound-statement-conc-match
  (implies
       (cst-matchp abnf::cst "compound-statement")
       (b* ((abnf::cstss (cst-compound-statement-conc abnf::cst)))
         (cst-list-list-conc-matchp
              abnf::cstss
              "\"{\" *label-declaration [ block-item-list ] \"}\"")))
  :rule-classes :rewrite)

Theorem: cst-compound-statement-conc-of-tree-fix-cst

(defthm cst-compound-statement-conc-of-tree-fix-cst
  (equal (cst-compound-statement-conc (abnf::tree-fix abnf::cst))
         (cst-compound-statement-conc abnf::cst)))

Theorem: cst-compound-statement-conc-tree-equiv-congruence-on-cst

(defthm cst-compound-statement-conc-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-compound-statement-conc abnf::cst)
                  (cst-compound-statement-conc cst-equiv)))
  :rule-classes :congruence)

Function: cst-block-item-conc1

(defun cst-block-item-conc1 (abnf::cst)
 (declare (xargs :guard (abnf::treep abnf::cst)))
 (declare (xargs :guard (and (cst-matchp abnf::cst "block-item")
                             (equal (cst-block-item-conc? abnf::cst)
                                    1))))
 (let ((__function__ 'cst-block-item-conc1))
   (declare (ignorable __function__))
   (abnf::tree-nonleaf->branches abnf::cst)))

Theorem: tree-list-listp-of-cst-block-item-conc1

(defthm tree-list-listp-of-cst-block-item-conc1
  (b* ((abnf::cstss (cst-block-item-conc1 abnf::cst)))
    (abnf::tree-list-listp abnf::cstss))
  :rule-classes :rewrite)

Theorem: cst-block-item-conc1-match

(defthm cst-block-item-conc1-match
  (implies (and (cst-matchp abnf::cst "block-item")
                (equal (cst-block-item-conc? abnf::cst)
                       1))
           (b* ((abnf::cstss (cst-block-item-conc1 abnf::cst)))
             (cst-list-list-conc-matchp abnf::cstss "declaration")))
  :rule-classes :rewrite)

Theorem: cst-block-item-conc1-of-tree-fix-cst

(defthm cst-block-item-conc1-of-tree-fix-cst
  (equal (cst-block-item-conc1 (abnf::tree-fix abnf::cst))
         (cst-block-item-conc1 abnf::cst)))

Theorem: cst-block-item-conc1-tree-equiv-congruence-on-cst

(defthm cst-block-item-conc1-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-block-item-conc1 abnf::cst)
                  (cst-block-item-conc1 cst-equiv)))
  :rule-classes :congruence)

Function: cst-block-item-conc2

(defun cst-block-item-conc2 (abnf::cst)
 (declare (xargs :guard (abnf::treep abnf::cst)))
 (declare (xargs :guard (and (cst-matchp abnf::cst "block-item")
                             (equal (cst-block-item-conc? abnf::cst)
                                    2))))
 (let ((__function__ 'cst-block-item-conc2))
   (declare (ignorable __function__))
   (abnf::tree-nonleaf->branches abnf::cst)))

Theorem: tree-list-listp-of-cst-block-item-conc2

(defthm tree-list-listp-of-cst-block-item-conc2
  (b* ((abnf::cstss (cst-block-item-conc2 abnf::cst)))
    (abnf::tree-list-listp abnf::cstss))
  :rule-classes :rewrite)

Theorem: cst-block-item-conc2-match

(defthm cst-block-item-conc2-match
  (implies (and (cst-matchp abnf::cst "block-item")
                (equal (cst-block-item-conc? abnf::cst)
                       2))
           (b* ((abnf::cstss (cst-block-item-conc2 abnf::cst)))
             (cst-list-list-conc-matchp abnf::cstss "statement")))
  :rule-classes :rewrite)

Theorem: cst-block-item-conc2-of-tree-fix-cst

(defthm cst-block-item-conc2-of-tree-fix-cst
  (equal (cst-block-item-conc2 (abnf::tree-fix abnf::cst))
         (cst-block-item-conc2 abnf::cst)))

Theorem: cst-block-item-conc2-tree-equiv-congruence-on-cst

(defthm cst-block-item-conc2-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-block-item-conc2 abnf::cst)
                  (cst-block-item-conc2 cst-equiv)))
  :rule-classes :congruence)

Function: cst-expression-statement-conc

(defun cst-expression-statement-conc (abnf::cst)
  (declare (xargs :guard (abnf::treep abnf::cst)))
  (declare
       (xargs :guard (cst-matchp abnf::cst "expression-statement")))
  (let ((__function__ 'cst-expression-statement-conc))
    (declare (ignorable __function__))
    (abnf::tree-nonleaf->branches abnf::cst)))

Theorem: tree-list-listp-of-cst-expression-statement-conc

(defthm tree-list-listp-of-cst-expression-statement-conc
  (b* ((abnf::cstss (cst-expression-statement-conc abnf::cst)))
    (abnf::tree-list-listp abnf::cstss))
  :rule-classes :rewrite)

Theorem: cst-expression-statement-conc-match

(defthm cst-expression-statement-conc-match
 (implies
    (cst-matchp abnf::cst "expression-statement")
    (b* ((abnf::cstss (cst-expression-statement-conc abnf::cst)))
      (cst-list-list-conc-matchp abnf::cstss "[ expression ] \";\"")))
 :rule-classes :rewrite)

Theorem: cst-expression-statement-conc-of-tree-fix-cst

(defthm cst-expression-statement-conc-of-tree-fix-cst
  (equal (cst-expression-statement-conc (abnf::tree-fix abnf::cst))
         (cst-expression-statement-conc abnf::cst)))

Theorem: cst-expression-statement-conc-tree-equiv-congruence-on-cst

(defthm cst-expression-statement-conc-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-expression-statement-conc abnf::cst)
                  (cst-expression-statement-conc cst-equiv)))
  :rule-classes :congruence)

Function: cst-translation-unit-conc

(defun cst-translation-unit-conc (abnf::cst)
  (declare (xargs :guard (abnf::treep abnf::cst)))
  (declare (xargs :guard (cst-matchp abnf::cst "translation-unit")))
  (let ((__function__ 'cst-translation-unit-conc))
    (declare (ignorable __function__))
    (abnf::tree-nonleaf->branches abnf::cst)))

Theorem: tree-list-listp-of-cst-translation-unit-conc

(defthm tree-list-listp-of-cst-translation-unit-conc
  (b* ((abnf::cstss (cst-translation-unit-conc abnf::cst)))
    (abnf::tree-list-listp abnf::cstss))
  :rule-classes :rewrite)

Theorem: cst-translation-unit-conc-match

(defthm cst-translation-unit-conc-match
 (implies
  (cst-matchp abnf::cst "translation-unit")
  (b* ((abnf::cstss (cst-translation-unit-conc abnf::cst)))
   (cst-list-list-conc-matchp abnf::cstss "*external-declaration")))
 :rule-classes :rewrite)

Theorem: cst-translation-unit-conc-of-tree-fix-cst

(defthm cst-translation-unit-conc-of-tree-fix-cst
  (equal (cst-translation-unit-conc (abnf::tree-fix abnf::cst))
         (cst-translation-unit-conc abnf::cst)))

Theorem: cst-translation-unit-conc-tree-equiv-congruence-on-cst

(defthm cst-translation-unit-conc-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-translation-unit-conc abnf::cst)
                  (cst-translation-unit-conc cst-equiv)))
  :rule-classes :congruence)

Function: cst-function-definition-conc

(defun cst-function-definition-conc (abnf::cst)
  (declare (xargs :guard (abnf::treep abnf::cst)))
  (declare
       (xargs :guard (cst-matchp abnf::cst "function-definition")))
  (let ((__function__ 'cst-function-definition-conc))
    (declare (ignorable __function__))
    (abnf::tree-nonleaf->branches abnf::cst)))

Theorem: tree-list-listp-of-cst-function-definition-conc

(defthm tree-list-listp-of-cst-function-definition-conc
  (b* ((abnf::cstss (cst-function-definition-conc abnf::cst)))
    (abnf::tree-list-listp abnf::cstss))
  :rule-classes :rewrite)

Theorem: cst-function-definition-conc-match

(defthm cst-function-definition-conc-match
 (implies
  (cst-matchp abnf::cst "function-definition")
  (b* ((abnf::cstss (cst-function-definition-conc abnf::cst)))
   (cst-list-list-conc-matchp
    abnf::cstss
    "[ %s\"__extension__\" ] declaration-specifiers declarator [ asm-name-specifier ] *attribute-specifier [ declaration-list ] compound-statement")))
 :rule-classes :rewrite)

Theorem: cst-function-definition-conc-of-tree-fix-cst

(defthm cst-function-definition-conc-of-tree-fix-cst
  (equal (cst-function-definition-conc (abnf::tree-fix abnf::cst))
         (cst-function-definition-conc abnf::cst)))

Theorem: cst-function-definition-conc-tree-equiv-congruence-on-cst

(defthm cst-function-definition-conc-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-function-definition-conc abnf::cst)
                  (cst-function-definition-conc cst-equiv)))
  :rule-classes :congruence)

Function: cst-preprocessing-file-conc

(defun cst-preprocessing-file-conc (abnf::cst)
  (declare (xargs :guard (abnf::treep abnf::cst)))
  (declare
       (xargs :guard (cst-matchp abnf::cst "preprocessing-file")))
  (let ((__function__ 'cst-preprocessing-file-conc))
    (declare (ignorable __function__))
    (abnf::tree-nonleaf->branches abnf::cst)))

Theorem: tree-list-listp-of-cst-preprocessing-file-conc

(defthm tree-list-listp-of-cst-preprocessing-file-conc
  (b* ((abnf::cstss (cst-preprocessing-file-conc abnf::cst)))
    (abnf::tree-list-listp abnf::cstss))
  :rule-classes :rewrite)

Theorem: cst-preprocessing-file-conc-match

(defthm cst-preprocessing-file-conc-match
  (implies
       (cst-matchp abnf::cst "preprocessing-file")
       (b* ((abnf::cstss (cst-preprocessing-file-conc abnf::cst)))
         (cst-list-list-conc-matchp abnf::cstss "[ group ]")))
  :rule-classes :rewrite)

Theorem: cst-preprocessing-file-conc-of-tree-fix-cst

(defthm cst-preprocessing-file-conc-of-tree-fix-cst
  (equal (cst-preprocessing-file-conc (abnf::tree-fix abnf::cst))
         (cst-preprocessing-file-conc abnf::cst)))

Theorem: cst-preprocessing-file-conc-tree-equiv-congruence-on-cst

(defthm cst-preprocessing-file-conc-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-preprocessing-file-conc abnf::cst)
                  (cst-preprocessing-file-conc cst-equiv)))
  :rule-classes :congruence)

Function: cst-if-section-conc

(defun cst-if-section-conc (abnf::cst)
  (declare (xargs :guard (abnf::treep abnf::cst)))
  (declare (xargs :guard (cst-matchp abnf::cst "if-section")))
  (let ((__function__ 'cst-if-section-conc))
    (declare (ignorable __function__))
    (abnf::tree-nonleaf->branches abnf::cst)))

Theorem: tree-list-listp-of-cst-if-section-conc

(defthm tree-list-listp-of-cst-if-section-conc
  (b* ((abnf::cstss (cst-if-section-conc abnf::cst)))
    (abnf::tree-list-listp abnf::cstss))
  :rule-classes :rewrite)

Theorem: cst-if-section-conc-match

(defthm cst-if-section-conc-match
 (implies
      (cst-matchp abnf::cst "if-section")
      (b* ((abnf::cstss (cst-if-section-conc abnf::cst)))
        (cst-list-list-conc-matchp
             abnf::cstss
             "if-group [ elif-groups ] [ else-group ] endif-line")))
 :rule-classes :rewrite)

Theorem: cst-if-section-conc-of-tree-fix-cst

(defthm cst-if-section-conc-of-tree-fix-cst
  (equal (cst-if-section-conc (abnf::tree-fix abnf::cst))
         (cst-if-section-conc abnf::cst)))

Theorem: cst-if-section-conc-tree-equiv-congruence-on-cst

(defthm cst-if-section-conc-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-if-section-conc abnf::cst)
                  (cst-if-section-conc cst-equiv)))
  :rule-classes :congruence)

Function: cst-elif-group-conc

(defun cst-elif-group-conc (abnf::cst)
  (declare (xargs :guard (abnf::treep abnf::cst)))
  (declare (xargs :guard (cst-matchp abnf::cst "elif-group")))
  (let ((__function__ 'cst-elif-group-conc))
    (declare (ignorable __function__))
    (abnf::tree-nonleaf->branches abnf::cst)))

Theorem: tree-list-listp-of-cst-elif-group-conc

(defthm tree-list-listp-of-cst-elif-group-conc
  (b* ((abnf::cstss (cst-elif-group-conc abnf::cst)))
    (abnf::tree-list-listp abnf::cstss))
  :rule-classes :rewrite)

Theorem: cst-elif-group-conc-match

(defthm cst-elif-group-conc-match
 (implies
     (cst-matchp abnf::cst "elif-group")
     (b* ((abnf::cstss (cst-elif-group-conc abnf::cst)))
       (cst-list-list-conc-matchp
            abnf::cstss
            "\"#\" %s\"elif\" constant-expression new-line [ group ]")))
 :rule-classes :rewrite)

Theorem: cst-elif-group-conc-of-tree-fix-cst

(defthm cst-elif-group-conc-of-tree-fix-cst
  (equal (cst-elif-group-conc (abnf::tree-fix abnf::cst))
         (cst-elif-group-conc abnf::cst)))

Theorem: cst-elif-group-conc-tree-equiv-congruence-on-cst

(defthm cst-elif-group-conc-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-elif-group-conc abnf::cst)
                  (cst-elif-group-conc cst-equiv)))
  :rule-classes :congruence)

Function: cst-else-group-conc

(defun cst-else-group-conc (abnf::cst)
  (declare (xargs :guard (abnf::treep abnf::cst)))
  (declare (xargs :guard (cst-matchp abnf::cst "else-group")))
  (let ((__function__ 'cst-else-group-conc))
    (declare (ignorable __function__))
    (abnf::tree-nonleaf->branches abnf::cst)))

Theorem: tree-list-listp-of-cst-else-group-conc

(defthm tree-list-listp-of-cst-else-group-conc
  (b* ((abnf::cstss (cst-else-group-conc abnf::cst)))
    (abnf::tree-list-listp abnf::cstss))
  :rule-classes :rewrite)

Theorem: cst-else-group-conc-match

(defthm cst-else-group-conc-match
 (implies
   (cst-matchp abnf::cst "else-group")
   (b* ((abnf::cstss (cst-else-group-conc abnf::cst)))
     (cst-list-list-conc-matchp abnf::cstss
                                "\"#\" %s\"else\" new-line [ group ]")))
 :rule-classes :rewrite)

Theorem: cst-else-group-conc-of-tree-fix-cst

(defthm cst-else-group-conc-of-tree-fix-cst
  (equal (cst-else-group-conc (abnf::tree-fix abnf::cst))
         (cst-else-group-conc abnf::cst)))

Theorem: cst-else-group-conc-tree-equiv-congruence-on-cst

(defthm cst-else-group-conc-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-else-group-conc abnf::cst)
                  (cst-else-group-conc cst-equiv)))
  :rule-classes :congruence)

Function: cst-endif-line-conc

(defun cst-endif-line-conc (abnf::cst)
  (declare (xargs :guard (abnf::treep abnf::cst)))
  (declare (xargs :guard (cst-matchp abnf::cst "endif-line")))
  (let ((__function__ 'cst-endif-line-conc))
    (declare (ignorable __function__))
    (abnf::tree-nonleaf->branches abnf::cst)))

Theorem: tree-list-listp-of-cst-endif-line-conc

(defthm tree-list-listp-of-cst-endif-line-conc
  (b* ((abnf::cstss (cst-endif-line-conc abnf::cst)))
    (abnf::tree-list-listp abnf::cstss))
  :rule-classes :rewrite)

Theorem: cst-endif-line-conc-match

(defthm cst-endif-line-conc-match
  (implies (cst-matchp abnf::cst "endif-line")
           (b* ((abnf::cstss (cst-endif-line-conc abnf::cst)))
             (cst-list-list-conc-matchp
                  abnf::cstss "\"#\" %s\"endif\" new-line")))
  :rule-classes :rewrite)

Theorem: cst-endif-line-conc-of-tree-fix-cst

(defthm cst-endif-line-conc-of-tree-fix-cst
  (equal (cst-endif-line-conc (abnf::tree-fix abnf::cst))
         (cst-endif-line-conc abnf::cst)))

Theorem: cst-endif-line-conc-tree-equiv-congruence-on-cst

(defthm cst-endif-line-conc-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-endif-line-conc abnf::cst)
                  (cst-endif-line-conc cst-equiv)))
  :rule-classes :congruence)

Function: cst-text-line-conc

(defun cst-text-line-conc (abnf::cst)
  (declare (xargs :guard (abnf::treep abnf::cst)))
  (declare (xargs :guard (cst-matchp abnf::cst "text-line")))
  (let ((__function__ 'cst-text-line-conc))
    (declare (ignorable __function__))
    (abnf::tree-nonleaf->branches abnf::cst)))

Theorem: tree-list-listp-of-cst-text-line-conc

(defthm tree-list-listp-of-cst-text-line-conc
  (b* ((abnf::cstss (cst-text-line-conc abnf::cst)))
    (abnf::tree-list-listp abnf::cstss))
  :rule-classes :rewrite)

Theorem: cst-text-line-conc-match

(defthm cst-text-line-conc-match
  (implies (cst-matchp abnf::cst "text-line")
           (b* ((abnf::cstss (cst-text-line-conc abnf::cst)))
             (cst-list-list-conc-matchp
                  abnf::cstss "[ pp-tokens ] new-line")))
  :rule-classes :rewrite)

Theorem: cst-text-line-conc-of-tree-fix-cst

(defthm cst-text-line-conc-of-tree-fix-cst
  (equal (cst-text-line-conc (abnf::tree-fix abnf::cst))
         (cst-text-line-conc abnf::cst)))

Theorem: cst-text-line-conc-tree-equiv-congruence-on-cst

(defthm cst-text-line-conc-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-text-line-conc abnf::cst)
                  (cst-text-line-conc cst-equiv)))
  :rule-classes :congruence)

Function: cst-non-directive-conc

(defun cst-non-directive-conc (abnf::cst)
  (declare (xargs :guard (abnf::treep abnf::cst)))
  (declare (xargs :guard (cst-matchp abnf::cst "non-directive")))
  (let ((__function__ 'cst-non-directive-conc))
    (declare (ignorable __function__))
    (abnf::tree-nonleaf->branches abnf::cst)))

Theorem: tree-list-listp-of-cst-non-directive-conc

(defthm tree-list-listp-of-cst-non-directive-conc
  (b* ((abnf::cstss (cst-non-directive-conc abnf::cst)))
    (abnf::tree-list-listp abnf::cstss))
  :rule-classes :rewrite)

Theorem: cst-non-directive-conc-match

(defthm cst-non-directive-conc-match
 (implies
    (cst-matchp abnf::cst "non-directive")
    (b* ((abnf::cstss (cst-non-directive-conc abnf::cst)))
      (cst-list-list-conc-matchp abnf::cstss "pp-tokens new-line")))
 :rule-classes :rewrite)

Theorem: cst-non-directive-conc-of-tree-fix-cst

(defthm cst-non-directive-conc-of-tree-fix-cst
  (equal (cst-non-directive-conc (abnf::tree-fix abnf::cst))
         (cst-non-directive-conc abnf::cst)))

Theorem: cst-non-directive-conc-tree-equiv-congruence-on-cst

(defthm cst-non-directive-conc-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-non-directive-conc abnf::cst)
                  (cst-non-directive-conc cst-equiv)))
  :rule-classes :congruence)

Function: cst-lparen-conc

(defun cst-lparen-conc (abnf::cst)
  (declare (xargs :guard (abnf::treep abnf::cst)))
  (declare (xargs :guard (cst-matchp abnf::cst "lparen")))
  (let ((__function__ 'cst-lparen-conc))
    (declare (ignorable __function__))
    (abnf::tree-nonleaf->branches abnf::cst)))

Theorem: tree-list-listp-of-cst-lparen-conc

(defthm tree-list-listp-of-cst-lparen-conc
  (b* ((abnf::cstss (cst-lparen-conc abnf::cst)))
    (abnf::tree-list-listp abnf::cstss))
  :rule-classes :rewrite)

Theorem: cst-lparen-conc-match

(defthm cst-lparen-conc-match
  (implies (cst-matchp abnf::cst "lparen")
           (b* ((abnf::cstss (cst-lparen-conc abnf::cst)))
             (cst-list-list-conc-matchp abnf::cstss "\"(\"")))
  :rule-classes :rewrite)

Theorem: cst-lparen-conc-of-tree-fix-cst

(defthm cst-lparen-conc-of-tree-fix-cst
  (equal (cst-lparen-conc (abnf::tree-fix abnf::cst))
         (cst-lparen-conc abnf::cst)))

Theorem: cst-lparen-conc-tree-equiv-congruence-on-cst

(defthm cst-lparen-conc-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-lparen-conc abnf::cst)
                  (cst-lparen-conc cst-equiv)))
  :rule-classes :congruence)

Function: cst-replacement-list-conc

(defun cst-replacement-list-conc (abnf::cst)
  (declare (xargs :guard (abnf::treep abnf::cst)))
  (declare (xargs :guard (cst-matchp abnf::cst "replacement-list")))
  (let ((__function__ 'cst-replacement-list-conc))
    (declare (ignorable __function__))
    (abnf::tree-nonleaf->branches abnf::cst)))

Theorem: tree-list-listp-of-cst-replacement-list-conc

(defthm tree-list-listp-of-cst-replacement-list-conc
  (b* ((abnf::cstss (cst-replacement-list-conc abnf::cst)))
    (abnf::tree-list-listp abnf::cstss))
  :rule-classes :rewrite)

Theorem: cst-replacement-list-conc-match

(defthm cst-replacement-list-conc-match
  (implies
       (cst-matchp abnf::cst "replacement-list")
       (b* ((abnf::cstss (cst-replacement-list-conc abnf::cst)))
         (cst-list-list-conc-matchp abnf::cstss "[ pp-tokens ]")))
  :rule-classes :rewrite)

Theorem: cst-replacement-list-conc-of-tree-fix-cst

(defthm cst-replacement-list-conc-of-tree-fix-cst
  (equal (cst-replacement-list-conc (abnf::tree-fix abnf::cst))
         (cst-replacement-list-conc abnf::cst)))

Theorem: cst-replacement-list-conc-tree-equiv-congruence-on-cst

(defthm cst-replacement-list-conc-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-replacement-list-conc abnf::cst)
                  (cst-replacement-list-conc cst-equiv)))
  :rule-classes :congruence)

Function: cst-uppercase-letter-conc-rep

(defun cst-uppercase-letter-conc-rep (abnf::cst)
  (declare (xargs :guard (abnf::treep abnf::cst)))
  (declare (xargs :guard (cst-matchp abnf::cst "uppercase-letter")))
  (let ((__function__ 'cst-uppercase-letter-conc-rep))
    (declare (ignorable __function__))
    (abnf::tree-list-fix
         (nth 0
              (cst-uppercase-letter-conc abnf::cst)))))

Theorem: tree-listp-of-cst-uppercase-letter-conc-rep

(defthm tree-listp-of-cst-uppercase-letter-conc-rep
  (b* ((abnf::csts (cst-uppercase-letter-conc-rep abnf::cst)))
    (abnf::tree-listp abnf::csts))
  :rule-classes :rewrite)

Theorem: cst-uppercase-letter-conc-rep-match

(defthm cst-uppercase-letter-conc-rep-match
  (implies
       (cst-matchp abnf::cst "uppercase-letter")
       (b* ((abnf::csts (cst-uppercase-letter-conc-rep abnf::cst)))
         (cst-list-rep-matchp abnf::csts "%x41-5A")))
  :rule-classes :rewrite)

Theorem: cst-uppercase-letter-conc-rep-of-tree-fix-cst

(defthm cst-uppercase-letter-conc-rep-of-tree-fix-cst
  (equal (cst-uppercase-letter-conc-rep (abnf::tree-fix abnf::cst))
         (cst-uppercase-letter-conc-rep abnf::cst)))

Theorem: cst-uppercase-letter-conc-rep-tree-equiv-congruence-on-cst

(defthm cst-uppercase-letter-conc-rep-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-uppercase-letter-conc-rep abnf::cst)
                  (cst-uppercase-letter-conc-rep cst-equiv)))
  :rule-classes :congruence)

Function: cst-lowercase-letter-conc-rep

(defun cst-lowercase-letter-conc-rep (abnf::cst)
  (declare (xargs :guard (abnf::treep abnf::cst)))
  (declare (xargs :guard (cst-matchp abnf::cst "lowercase-letter")))
  (let ((__function__ 'cst-lowercase-letter-conc-rep))
    (declare (ignorable __function__))
    (abnf::tree-list-fix
         (nth 0
              (cst-lowercase-letter-conc abnf::cst)))))

Theorem: tree-listp-of-cst-lowercase-letter-conc-rep

(defthm tree-listp-of-cst-lowercase-letter-conc-rep
  (b* ((abnf::csts (cst-lowercase-letter-conc-rep abnf::cst)))
    (abnf::tree-listp abnf::csts))
  :rule-classes :rewrite)

Theorem: cst-lowercase-letter-conc-rep-match

(defthm cst-lowercase-letter-conc-rep-match
  (implies
       (cst-matchp abnf::cst "lowercase-letter")
       (b* ((abnf::csts (cst-lowercase-letter-conc-rep abnf::cst)))
         (cst-list-rep-matchp abnf::csts "%x61-7A")))
  :rule-classes :rewrite)

Theorem: cst-lowercase-letter-conc-rep-of-tree-fix-cst

(defthm cst-lowercase-letter-conc-rep-of-tree-fix-cst
  (equal (cst-lowercase-letter-conc-rep (abnf::tree-fix abnf::cst))
         (cst-lowercase-letter-conc-rep abnf::cst)))

Theorem: cst-lowercase-letter-conc-rep-tree-equiv-congruence-on-cst

(defthm cst-lowercase-letter-conc-rep-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-lowercase-letter-conc-rep abnf::cst)
                  (cst-lowercase-letter-conc-rep cst-equiv)))
  :rule-classes :congruence)

Function: cst-letter-conc1-rep

(defun cst-letter-conc1-rep (abnf::cst)
  (declare (xargs :guard (abnf::treep abnf::cst)))
  (declare (xargs :guard (and (cst-matchp abnf::cst "letter")
                              (equal (cst-letter-conc? abnf::cst)
                                     1))))
  (let ((__function__ 'cst-letter-conc1-rep))
    (declare (ignorable __function__))
    (abnf::tree-list-fix (nth 0 (cst-letter-conc1 abnf::cst)))))

Theorem: tree-listp-of-cst-letter-conc1-rep

(defthm tree-listp-of-cst-letter-conc1-rep
  (b* ((abnf::csts (cst-letter-conc1-rep abnf::cst)))
    (abnf::tree-listp abnf::csts))
  :rule-classes :rewrite)

Theorem: cst-letter-conc1-rep-match

(defthm cst-letter-conc1-rep-match
  (implies (and (cst-matchp abnf::cst "letter")
                (equal (cst-letter-conc? abnf::cst) 1))
           (b* ((abnf::csts (cst-letter-conc1-rep abnf::cst)))
             (cst-list-rep-matchp abnf::csts "uppercase-letter")))
  :rule-classes :rewrite)

Theorem: cst-letter-conc1-rep-of-tree-fix-cst

(defthm cst-letter-conc1-rep-of-tree-fix-cst
  (equal (cst-letter-conc1-rep (abnf::tree-fix abnf::cst))
         (cst-letter-conc1-rep abnf::cst)))

Theorem: cst-letter-conc1-rep-tree-equiv-congruence-on-cst

(defthm cst-letter-conc1-rep-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-letter-conc1-rep abnf::cst)
                  (cst-letter-conc1-rep cst-equiv)))
  :rule-classes :congruence)

Function: cst-letter-conc2-rep

(defun cst-letter-conc2-rep (abnf::cst)
  (declare (xargs :guard (abnf::treep abnf::cst)))
  (declare (xargs :guard (and (cst-matchp abnf::cst "letter")
                              (equal (cst-letter-conc? abnf::cst)
                                     2))))
  (let ((__function__ 'cst-letter-conc2-rep))
    (declare (ignorable __function__))
    (abnf::tree-list-fix (nth 0 (cst-letter-conc2 abnf::cst)))))

Theorem: tree-listp-of-cst-letter-conc2-rep

(defthm tree-listp-of-cst-letter-conc2-rep
  (b* ((abnf::csts (cst-letter-conc2-rep abnf::cst)))
    (abnf::tree-listp abnf::csts))
  :rule-classes :rewrite)

Theorem: cst-letter-conc2-rep-match

(defthm cst-letter-conc2-rep-match
  (implies (and (cst-matchp abnf::cst "letter")
                (equal (cst-letter-conc? abnf::cst) 2))
           (b* ((abnf::csts (cst-letter-conc2-rep abnf::cst)))
             (cst-list-rep-matchp abnf::csts "lowercase-letter")))
  :rule-classes :rewrite)

Theorem: cst-letter-conc2-rep-of-tree-fix-cst

(defthm cst-letter-conc2-rep-of-tree-fix-cst
  (equal (cst-letter-conc2-rep (abnf::tree-fix abnf::cst))
         (cst-letter-conc2-rep abnf::cst)))

Theorem: cst-letter-conc2-rep-tree-equiv-congruence-on-cst

(defthm cst-letter-conc2-rep-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-letter-conc2-rep abnf::cst)
                  (cst-letter-conc2-rep cst-equiv)))
  :rule-classes :congruence)

Function: cst-digit-conc-rep

(defun cst-digit-conc-rep (abnf::cst)
  (declare (xargs :guard (abnf::treep abnf::cst)))
  (declare (xargs :guard (cst-matchp abnf::cst "digit")))
  (let ((__function__ 'cst-digit-conc-rep))
    (declare (ignorable __function__))
    (abnf::tree-list-fix (nth 0 (cst-digit-conc abnf::cst)))))

Theorem: tree-listp-of-cst-digit-conc-rep

(defthm tree-listp-of-cst-digit-conc-rep
  (b* ((abnf::csts (cst-digit-conc-rep abnf::cst)))
    (abnf::tree-listp abnf::csts))
  :rule-classes :rewrite)

Theorem: cst-digit-conc-rep-match

(defthm cst-digit-conc-rep-match
  (implies (cst-matchp abnf::cst "digit")
           (b* ((abnf::csts (cst-digit-conc-rep abnf::cst)))
             (cst-list-rep-matchp abnf::csts "%x30-39")))
  :rule-classes :rewrite)

Theorem: cst-digit-conc-rep-of-tree-fix-cst

(defthm cst-digit-conc-rep-of-tree-fix-cst
  (equal (cst-digit-conc-rep (abnf::tree-fix abnf::cst))
         (cst-digit-conc-rep abnf::cst)))

Theorem: cst-digit-conc-rep-tree-equiv-congruence-on-cst

(defthm cst-digit-conc-rep-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-digit-conc-rep abnf::cst)
                  (cst-digit-conc-rep cst-equiv)))
  :rule-classes :congruence)

Function: cst-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-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-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-vertical-tab-conc-rep

(defun cst-vertical-tab-conc-rep (abnf::cst)
 (declare (xargs :guard (abnf::treep abnf::cst)))
 (declare (xargs :guard (cst-matchp abnf::cst "vertical-tab")))
 (let ((__function__ 'cst-vertical-tab-conc-rep))
   (declare (ignorable __function__))
   (abnf::tree-list-fix (nth 0 (cst-vertical-tab-conc abnf::cst)))))

Theorem: tree-listp-of-cst-vertical-tab-conc-rep

(defthm tree-listp-of-cst-vertical-tab-conc-rep
  (b* ((abnf::csts (cst-vertical-tab-conc-rep abnf::cst)))
    (abnf::tree-listp abnf::csts))
  :rule-classes :rewrite)

Theorem: cst-vertical-tab-conc-rep-match

(defthm cst-vertical-tab-conc-rep-match
  (implies (cst-matchp abnf::cst "vertical-tab")
           (b* ((abnf::csts (cst-vertical-tab-conc-rep abnf::cst)))
             (cst-list-rep-matchp abnf::csts "%xB")))
  :rule-classes :rewrite)

Theorem: cst-vertical-tab-conc-rep-of-tree-fix-cst

(defthm cst-vertical-tab-conc-rep-of-tree-fix-cst
  (equal (cst-vertical-tab-conc-rep (abnf::tree-fix abnf::cst))
         (cst-vertical-tab-conc-rep abnf::cst)))

Theorem: cst-vertical-tab-conc-rep-tree-equiv-congruence-on-cst

(defthm cst-vertical-tab-conc-rep-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-vertical-tab-conc-rep abnf::cst)
                  (cst-vertical-tab-conc-rep cst-equiv)))
  :rule-classes :congruence)

Function: cst-form-feed-conc-rep

(defun cst-form-feed-conc-rep (abnf::cst)
  (declare (xargs :guard (abnf::treep abnf::cst)))
  (declare (xargs :guard (cst-matchp abnf::cst "form-feed")))
  (let ((__function__ 'cst-form-feed-conc-rep))
    (declare (ignorable __function__))
    (abnf::tree-list-fix (nth 0 (cst-form-feed-conc abnf::cst)))))

Theorem: tree-listp-of-cst-form-feed-conc-rep

(defthm tree-listp-of-cst-form-feed-conc-rep
  (b* ((abnf::csts (cst-form-feed-conc-rep abnf::cst)))
    (abnf::tree-listp abnf::csts))
  :rule-classes :rewrite)

Theorem: cst-form-feed-conc-rep-match

(defthm cst-form-feed-conc-rep-match
  (implies (cst-matchp abnf::cst "form-feed")
           (b* ((abnf::csts (cst-form-feed-conc-rep abnf::cst)))
             (cst-list-rep-matchp abnf::csts "%xC")))
  :rule-classes :rewrite)

Theorem: cst-form-feed-conc-rep-of-tree-fix-cst

(defthm cst-form-feed-conc-rep-of-tree-fix-cst
  (equal (cst-form-feed-conc-rep (abnf::tree-fix abnf::cst))
         (cst-form-feed-conc-rep abnf::cst)))

Theorem: cst-form-feed-conc-rep-tree-equiv-congruence-on-cst

(defthm cst-form-feed-conc-rep-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-form-feed-conc-rep abnf::cst)
                  (cst-form-feed-conc-rep cst-equiv)))
  :rule-classes :congruence)

Function: cst-control-character-conc1-rep

(defun cst-control-character-conc1-rep (abnf::cst)
 (declare (xargs :guard (abnf::treep abnf::cst)))
 (declare
   (xargs :guard (and (cst-matchp abnf::cst "control-character")
                      (equal (cst-control-character-conc? abnf::cst)
                             1))))
 (let ((__function__ 'cst-control-character-conc1-rep))
   (declare (ignorable __function__))
   (abnf::tree-list-fix
        (nth 0
             (cst-control-character-conc1 abnf::cst)))))

Theorem: tree-listp-of-cst-control-character-conc1-rep

(defthm tree-listp-of-cst-control-character-conc1-rep
  (b* ((abnf::csts (cst-control-character-conc1-rep abnf::cst)))
    (abnf::tree-listp abnf::csts))
  :rule-classes :rewrite)

Theorem: cst-control-character-conc1-rep-match

(defthm cst-control-character-conc1-rep-match
 (implies
      (and (cst-matchp abnf::cst "control-character")
           (equal (cst-control-character-conc? abnf::cst)
                  1))
      (b* ((abnf::csts (cst-control-character-conc1-rep abnf::cst)))
        (cst-list-rep-matchp abnf::csts "horizontal-tab")))
 :rule-classes :rewrite)

Theorem: cst-control-character-conc1-rep-of-tree-fix-cst

(defthm cst-control-character-conc1-rep-of-tree-fix-cst
 (equal (cst-control-character-conc1-rep (abnf::tree-fix abnf::cst))
        (cst-control-character-conc1-rep abnf::cst)))

Theorem: cst-control-character-conc1-rep-tree-equiv-congruence-on-cst

(defthm cst-control-character-conc1-rep-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-control-character-conc1-rep abnf::cst)
                  (cst-control-character-conc1-rep cst-equiv)))
  :rule-classes :congruence)

Function: cst-control-character-conc2-rep

(defun cst-control-character-conc2-rep (abnf::cst)
 (declare (xargs :guard (abnf::treep abnf::cst)))
 (declare
   (xargs :guard (and (cst-matchp abnf::cst "control-character")
                      (equal (cst-control-character-conc? abnf::cst)
                             2))))
 (let ((__function__ 'cst-control-character-conc2-rep))
   (declare (ignorable __function__))
   (abnf::tree-list-fix
        (nth 0
             (cst-control-character-conc2 abnf::cst)))))

Theorem: tree-listp-of-cst-control-character-conc2-rep

(defthm tree-listp-of-cst-control-character-conc2-rep
  (b* ((abnf::csts (cst-control-character-conc2-rep abnf::cst)))
    (abnf::tree-listp abnf::csts))
  :rule-classes :rewrite)

Theorem: cst-control-character-conc2-rep-match

(defthm cst-control-character-conc2-rep-match
 (implies
      (and (cst-matchp abnf::cst "control-character")
           (equal (cst-control-character-conc? abnf::cst)
                  2))
      (b* ((abnf::csts (cst-control-character-conc2-rep abnf::cst)))
        (cst-list-rep-matchp abnf::csts "vertical-tab")))
 :rule-classes :rewrite)

Theorem: cst-control-character-conc2-rep-of-tree-fix-cst

(defthm cst-control-character-conc2-rep-of-tree-fix-cst
 (equal (cst-control-character-conc2-rep (abnf::tree-fix abnf::cst))
        (cst-control-character-conc2-rep abnf::cst)))

Theorem: cst-control-character-conc2-rep-tree-equiv-congruence-on-cst

(defthm cst-control-character-conc2-rep-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-control-character-conc2-rep abnf::cst)
                  (cst-control-character-conc2-rep cst-equiv)))
  :rule-classes :congruence)

Function: cst-control-character-conc3-rep

(defun cst-control-character-conc3-rep (abnf::cst)
 (declare (xargs :guard (abnf::treep abnf::cst)))
 (declare
   (xargs :guard (and (cst-matchp abnf::cst "control-character")
                      (equal (cst-control-character-conc? abnf::cst)
                             3))))
 (let ((__function__ 'cst-control-character-conc3-rep))
   (declare (ignorable __function__))
   (abnf::tree-list-fix
        (nth 0
             (cst-control-character-conc3 abnf::cst)))))

Theorem: tree-listp-of-cst-control-character-conc3-rep

(defthm tree-listp-of-cst-control-character-conc3-rep
  (b* ((abnf::csts (cst-control-character-conc3-rep abnf::cst)))
    (abnf::tree-listp abnf::csts))
  :rule-classes :rewrite)

Theorem: cst-control-character-conc3-rep-match

(defthm cst-control-character-conc3-rep-match
 (implies
      (and (cst-matchp abnf::cst "control-character")
           (equal (cst-control-character-conc? abnf::cst)
                  3))
      (b* ((abnf::csts (cst-control-character-conc3-rep abnf::cst)))
        (cst-list-rep-matchp abnf::csts "form-feed")))
 :rule-classes :rewrite)

Theorem: cst-control-character-conc3-rep-of-tree-fix-cst

(defthm cst-control-character-conc3-rep-of-tree-fix-cst
 (equal (cst-control-character-conc3-rep (abnf::tree-fix abnf::cst))
        (cst-control-character-conc3-rep abnf::cst)))

Theorem: cst-control-character-conc3-rep-tree-equiv-congruence-on-cst

(defthm cst-control-character-conc3-rep-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-control-character-conc3-rep abnf::cst)
                  (cst-control-character-conc3-rep cst-equiv)))
  :rule-classes :congruence)

Function: cst-basic-character-conc1-rep

(defun cst-basic-character-conc1-rep (abnf::cst)
 (declare (xargs :guard (abnf::treep abnf::cst)))
 (declare
     (xargs :guard (and (cst-matchp abnf::cst "basic-character")
                        (equal (cst-basic-character-conc? abnf::cst)
                               1))))
 (let ((__function__ 'cst-basic-character-conc1-rep))
   (declare (ignorable __function__))
   (abnf::tree-list-fix
        (nth 0
             (cst-basic-character-conc1 abnf::cst)))))

Theorem: tree-listp-of-cst-basic-character-conc1-rep

(defthm tree-listp-of-cst-basic-character-conc1-rep
  (b* ((abnf::csts (cst-basic-character-conc1-rep abnf::cst)))
    (abnf::tree-listp abnf::csts))
  :rule-classes :rewrite)

Theorem: cst-basic-character-conc1-rep-match

(defthm cst-basic-character-conc1-rep-match
  (implies
       (and (cst-matchp abnf::cst "basic-character")
            (equal (cst-basic-character-conc? abnf::cst)
                   1))
       (b* ((abnf::csts (cst-basic-character-conc1-rep abnf::cst)))
         (cst-list-rep-matchp abnf::csts "letter")))
  :rule-classes :rewrite)

Theorem: cst-basic-character-conc1-rep-of-tree-fix-cst

(defthm cst-basic-character-conc1-rep-of-tree-fix-cst
  (equal (cst-basic-character-conc1-rep (abnf::tree-fix abnf::cst))
         (cst-basic-character-conc1-rep abnf::cst)))

Theorem: cst-basic-character-conc1-rep-tree-equiv-congruence-on-cst

(defthm cst-basic-character-conc1-rep-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-basic-character-conc1-rep abnf::cst)
                  (cst-basic-character-conc1-rep cst-equiv)))
  :rule-classes :congruence)

Function: cst-basic-character-conc2-rep

(defun cst-basic-character-conc2-rep (abnf::cst)
 (declare (xargs :guard (abnf::treep abnf::cst)))
 (declare
     (xargs :guard (and (cst-matchp abnf::cst "basic-character")
                        (equal (cst-basic-character-conc? abnf::cst)
                               2))))
 (let ((__function__ 'cst-basic-character-conc2-rep))
   (declare (ignorable __function__))
   (abnf::tree-list-fix
        (nth 0
             (cst-basic-character-conc2 abnf::cst)))))

Theorem: tree-listp-of-cst-basic-character-conc2-rep

(defthm tree-listp-of-cst-basic-character-conc2-rep
  (b* ((abnf::csts (cst-basic-character-conc2-rep abnf::cst)))
    (abnf::tree-listp abnf::csts))
  :rule-classes :rewrite)

Theorem: cst-basic-character-conc2-rep-match

(defthm cst-basic-character-conc2-rep-match
  (implies
       (and (cst-matchp abnf::cst "basic-character")
            (equal (cst-basic-character-conc? abnf::cst)
                   2))
       (b* ((abnf::csts (cst-basic-character-conc2-rep abnf::cst)))
         (cst-list-rep-matchp abnf::csts "digit")))
  :rule-classes :rewrite)

Theorem: cst-basic-character-conc2-rep-of-tree-fix-cst

(defthm cst-basic-character-conc2-rep-of-tree-fix-cst
  (equal (cst-basic-character-conc2-rep (abnf::tree-fix abnf::cst))
         (cst-basic-character-conc2-rep abnf::cst)))

Theorem: cst-basic-character-conc2-rep-tree-equiv-congruence-on-cst

(defthm cst-basic-character-conc2-rep-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-basic-character-conc2-rep abnf::cst)
                  (cst-basic-character-conc2-rep cst-equiv)))
  :rule-classes :congruence)

Function: cst-basic-character-conc3-rep

(defun cst-basic-character-conc3-rep (abnf::cst)
 (declare (xargs :guard (abnf::treep abnf::cst)))
 (declare
     (xargs :guard (and (cst-matchp abnf::cst "basic-character")
                        (equal (cst-basic-character-conc? abnf::cst)
                               3))))
 (let ((__function__ 'cst-basic-character-conc3-rep))
   (declare (ignorable __function__))
   (abnf::tree-list-fix
        (nth 0
             (cst-basic-character-conc3 abnf::cst)))))

Theorem: tree-listp-of-cst-basic-character-conc3-rep

(defthm tree-listp-of-cst-basic-character-conc3-rep
  (b* ((abnf::csts (cst-basic-character-conc3-rep abnf::cst)))
    (abnf::tree-listp abnf::csts))
  :rule-classes :rewrite)

Theorem: cst-basic-character-conc3-rep-match

(defthm cst-basic-character-conc3-rep-match
  (implies
       (and (cst-matchp abnf::cst "basic-character")
            (equal (cst-basic-character-conc? abnf::cst)
                   3))
       (b* ((abnf::csts (cst-basic-character-conc3-rep abnf::cst)))
         (cst-list-rep-matchp abnf::csts "graphic-character")))
  :rule-classes :rewrite)

Theorem: cst-basic-character-conc3-rep-of-tree-fix-cst

(defthm cst-basic-character-conc3-rep-of-tree-fix-cst
  (equal (cst-basic-character-conc3-rep (abnf::tree-fix abnf::cst))
         (cst-basic-character-conc3-rep abnf::cst)))

Theorem: cst-basic-character-conc3-rep-tree-equiv-congruence-on-cst

(defthm cst-basic-character-conc3-rep-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-basic-character-conc3-rep abnf::cst)
                  (cst-basic-character-conc3-rep cst-equiv)))
  :rule-classes :congruence)

Function: cst-basic-character-conc4-rep

(defun cst-basic-character-conc4-rep (abnf::cst)
 (declare (xargs :guard (abnf::treep abnf::cst)))
 (declare
     (xargs :guard (and (cst-matchp abnf::cst "basic-character")
                        (equal (cst-basic-character-conc? abnf::cst)
                               4))))
 (let ((__function__ 'cst-basic-character-conc4-rep))
   (declare (ignorable __function__))
   (abnf::tree-list-fix
        (nth 0
             (cst-basic-character-conc4 abnf::cst)))))

Theorem: tree-listp-of-cst-basic-character-conc4-rep

(defthm tree-listp-of-cst-basic-character-conc4-rep
  (b* ((abnf::csts (cst-basic-character-conc4-rep abnf::cst)))
    (abnf::tree-listp abnf::csts))
  :rule-classes :rewrite)

Theorem: cst-basic-character-conc4-rep-match

(defthm cst-basic-character-conc4-rep-match
  (implies
       (and (cst-matchp abnf::cst "basic-character")
            (equal (cst-basic-character-conc? abnf::cst)
                   4))
       (b* ((abnf::csts (cst-basic-character-conc4-rep abnf::cst)))
         (cst-list-rep-matchp abnf::csts "space")))
  :rule-classes :rewrite)

Theorem: cst-basic-character-conc4-rep-of-tree-fix-cst

(defthm cst-basic-character-conc4-rep-of-tree-fix-cst
  (equal (cst-basic-character-conc4-rep (abnf::tree-fix abnf::cst))
         (cst-basic-character-conc4-rep abnf::cst)))

Theorem: cst-basic-character-conc4-rep-tree-equiv-congruence-on-cst

(defthm cst-basic-character-conc4-rep-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-basic-character-conc4-rep abnf::cst)
                  (cst-basic-character-conc4-rep cst-equiv)))
  :rule-classes :congruence)

Function: cst-basic-character-conc5-rep

(defun cst-basic-character-conc5-rep (abnf::cst)
 (declare (xargs :guard (abnf::treep abnf::cst)))
 (declare
     (xargs :guard (and (cst-matchp abnf::cst "basic-character")
                        (equal (cst-basic-character-conc? abnf::cst)
                               5))))
 (let ((__function__ 'cst-basic-character-conc5-rep))
   (declare (ignorable __function__))
   (abnf::tree-list-fix
        (nth 0
             (cst-basic-character-conc5 abnf::cst)))))

Theorem: tree-listp-of-cst-basic-character-conc5-rep

(defthm tree-listp-of-cst-basic-character-conc5-rep
  (b* ((abnf::csts (cst-basic-character-conc5-rep abnf::cst)))
    (abnf::tree-listp abnf::csts))
  :rule-classes :rewrite)

Theorem: cst-basic-character-conc5-rep-match

(defthm cst-basic-character-conc5-rep-match
  (implies
       (and (cst-matchp abnf::cst "basic-character")
            (equal (cst-basic-character-conc? abnf::cst)
                   5))
       (b* ((abnf::csts (cst-basic-character-conc5-rep abnf::cst)))
         (cst-list-rep-matchp abnf::csts "control-character")))
  :rule-classes :rewrite)

Theorem: cst-basic-character-conc5-rep-of-tree-fix-cst

(defthm cst-basic-character-conc5-rep-of-tree-fix-cst
  (equal (cst-basic-character-conc5-rep (abnf::tree-fix abnf::cst))
         (cst-basic-character-conc5-rep abnf::cst)))

Theorem: cst-basic-character-conc5-rep-tree-equiv-congruence-on-cst

(defthm cst-basic-character-conc5-rep-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-basic-character-conc5-rep abnf::cst)
                  (cst-basic-character-conc5-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-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 "basic-character")))
  :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 "extended-character")))
  :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-basic-character-not-star-conc1-rep

(defun cst-basic-character-not-star-conc1-rep (abnf::cst)
 (declare (xargs :guard (abnf::treep abnf::cst)))
 (declare
  (xargs
   :guard (and (cst-matchp abnf::cst "basic-character-not-star")
               (equal (cst-basic-character-not-star-conc? abnf::cst)
                      1))))
 (let ((__function__ 'cst-basic-character-not-star-conc1-rep))
   (declare (ignorable __function__))
   (abnf::tree-list-fix
        (nth 0
             (cst-basic-character-not-star-conc1 abnf::cst)))))

Theorem: tree-listp-of-cst-basic-character-not-star-conc1-rep

(defthm tree-listp-of-cst-basic-character-not-star-conc1-rep
  (b*
   ((abnf::csts (cst-basic-character-not-star-conc1-rep abnf::cst)))
   (abnf::tree-listp abnf::csts))
  :rule-classes :rewrite)

Theorem: cst-basic-character-not-star-conc1-rep-match

(defthm cst-basic-character-not-star-conc1-rep-match
 (implies
  (and (cst-matchp abnf::cst "basic-character-not-star")
       (equal (cst-basic-character-not-star-conc? abnf::cst)
              1))
  (b*
   ((abnf::csts (cst-basic-character-not-star-conc1-rep abnf::cst)))
   (cst-list-rep-matchp abnf::csts "letter")))
 :rule-classes :rewrite)

Theorem: cst-basic-character-not-star-conc1-rep-of-tree-fix-cst

(defthm cst-basic-character-not-star-conc1-rep-of-tree-fix-cst
  (equal (cst-basic-character-not-star-conc1-rep
              (abnf::tree-fix abnf::cst))
         (cst-basic-character-not-star-conc1-rep abnf::cst)))

Theorem: cst-basic-character-not-star-conc1-rep-tree-equiv-congruence-on-cst

(defthm
 cst-basic-character-not-star-conc1-rep-tree-equiv-congruence-on-cst
 (implies
      (abnf::tree-equiv abnf::cst cst-equiv)
      (equal (cst-basic-character-not-star-conc1-rep abnf::cst)
             (cst-basic-character-not-star-conc1-rep cst-equiv)))
 :rule-classes :congruence)

Function: cst-basic-character-not-star-conc2-rep

(defun cst-basic-character-not-star-conc2-rep (abnf::cst)
 (declare (xargs :guard (abnf::treep abnf::cst)))
 (declare
  (xargs
   :guard (and (cst-matchp abnf::cst "basic-character-not-star")
               (equal (cst-basic-character-not-star-conc? abnf::cst)
                      2))))
 (let ((__function__ 'cst-basic-character-not-star-conc2-rep))
   (declare (ignorable __function__))
   (abnf::tree-list-fix
        (nth 0
             (cst-basic-character-not-star-conc2 abnf::cst)))))

Theorem: tree-listp-of-cst-basic-character-not-star-conc2-rep

(defthm tree-listp-of-cst-basic-character-not-star-conc2-rep
  (b*
   ((abnf::csts (cst-basic-character-not-star-conc2-rep abnf::cst)))
   (abnf::tree-listp abnf::csts))
  :rule-classes :rewrite)

Theorem: cst-basic-character-not-star-conc2-rep-match

(defthm cst-basic-character-not-star-conc2-rep-match
 (implies
  (and (cst-matchp abnf::cst "basic-character-not-star")
       (equal (cst-basic-character-not-star-conc? abnf::cst)
              2))
  (b*
   ((abnf::csts (cst-basic-character-not-star-conc2-rep abnf::cst)))
   (cst-list-rep-matchp abnf::csts "digit")))
 :rule-classes :rewrite)

Theorem: cst-basic-character-not-star-conc2-rep-of-tree-fix-cst

(defthm cst-basic-character-not-star-conc2-rep-of-tree-fix-cst
  (equal (cst-basic-character-not-star-conc2-rep
              (abnf::tree-fix abnf::cst))
         (cst-basic-character-not-star-conc2-rep abnf::cst)))

Theorem: cst-basic-character-not-star-conc2-rep-tree-equiv-congruence-on-cst

(defthm
 cst-basic-character-not-star-conc2-rep-tree-equiv-congruence-on-cst
 (implies
      (abnf::tree-equiv abnf::cst cst-equiv)
      (equal (cst-basic-character-not-star-conc2-rep abnf::cst)
             (cst-basic-character-not-star-conc2-rep cst-equiv)))
 :rule-classes :congruence)

Function: cst-basic-character-not-star-conc3-rep

(defun cst-basic-character-not-star-conc3-rep (abnf::cst)
 (declare (xargs :guard (abnf::treep abnf::cst)))
 (declare
  (xargs
   :guard (and (cst-matchp abnf::cst "basic-character-not-star")
               (equal (cst-basic-character-not-star-conc? abnf::cst)
                      3))))
 (let ((__function__ 'cst-basic-character-not-star-conc3-rep))
   (declare (ignorable __function__))
   (abnf::tree-list-fix
        (nth 0
             (cst-basic-character-not-star-conc3 abnf::cst)))))

Theorem: tree-listp-of-cst-basic-character-not-star-conc3-rep

(defthm tree-listp-of-cst-basic-character-not-star-conc3-rep
  (b*
   ((abnf::csts (cst-basic-character-not-star-conc3-rep abnf::cst)))
   (abnf::tree-listp abnf::csts))
  :rule-classes :rewrite)

Theorem: cst-basic-character-not-star-conc3-rep-match

(defthm cst-basic-character-not-star-conc3-rep-match
 (implies
  (and (cst-matchp abnf::cst "basic-character-not-star")
       (equal (cst-basic-character-not-star-conc? abnf::cst)
              3))
  (b*
   ((abnf::csts (cst-basic-character-not-star-conc3-rep abnf::cst)))
   (cst-list-rep-matchp abnf::csts
                        "graphic-character-not-star")))
 :rule-classes :rewrite)

Theorem: cst-basic-character-not-star-conc3-rep-of-tree-fix-cst

(defthm cst-basic-character-not-star-conc3-rep-of-tree-fix-cst
  (equal (cst-basic-character-not-star-conc3-rep
              (abnf::tree-fix abnf::cst))
         (cst-basic-character-not-star-conc3-rep abnf::cst)))

Theorem: cst-basic-character-not-star-conc3-rep-tree-equiv-congruence-on-cst

(defthm
 cst-basic-character-not-star-conc3-rep-tree-equiv-congruence-on-cst
 (implies
      (abnf::tree-equiv abnf::cst cst-equiv)
      (equal (cst-basic-character-not-star-conc3-rep abnf::cst)
             (cst-basic-character-not-star-conc3-rep cst-equiv)))
 :rule-classes :congruence)

Function: cst-basic-character-not-star-conc4-rep

(defun cst-basic-character-not-star-conc4-rep (abnf::cst)
 (declare (xargs :guard (abnf::treep abnf::cst)))
 (declare
  (xargs
   :guard (and (cst-matchp abnf::cst "basic-character-not-star")
               (equal (cst-basic-character-not-star-conc? abnf::cst)
                      4))))
 (let ((__function__ 'cst-basic-character-not-star-conc4-rep))
   (declare (ignorable __function__))
   (abnf::tree-list-fix
        (nth 0
             (cst-basic-character-not-star-conc4 abnf::cst)))))

Theorem: tree-listp-of-cst-basic-character-not-star-conc4-rep

(defthm tree-listp-of-cst-basic-character-not-star-conc4-rep
  (b*
   ((abnf::csts (cst-basic-character-not-star-conc4-rep abnf::cst)))
   (abnf::tree-listp abnf::csts))
  :rule-classes :rewrite)

Theorem: cst-basic-character-not-star-conc4-rep-match

(defthm cst-basic-character-not-star-conc4-rep-match
 (implies
  (and (cst-matchp abnf::cst "basic-character-not-star")
       (equal (cst-basic-character-not-star-conc? abnf::cst)
              4))
  (b*
   ((abnf::csts (cst-basic-character-not-star-conc4-rep abnf::cst)))
   (cst-list-rep-matchp abnf::csts "space")))
 :rule-classes :rewrite)

Theorem: cst-basic-character-not-star-conc4-rep-of-tree-fix-cst

(defthm cst-basic-character-not-star-conc4-rep-of-tree-fix-cst
  (equal (cst-basic-character-not-star-conc4-rep
              (abnf::tree-fix abnf::cst))
         (cst-basic-character-not-star-conc4-rep abnf::cst)))

Theorem: cst-basic-character-not-star-conc4-rep-tree-equiv-congruence-on-cst

(defthm
 cst-basic-character-not-star-conc4-rep-tree-equiv-congruence-on-cst
 (implies
      (abnf::tree-equiv abnf::cst cst-equiv)
      (equal (cst-basic-character-not-star-conc4-rep abnf::cst)
             (cst-basic-character-not-star-conc4-rep cst-equiv)))
 :rule-classes :congruence)

Function: cst-basic-character-not-star-conc5-rep

(defun cst-basic-character-not-star-conc5-rep (abnf::cst)
 (declare (xargs :guard (abnf::treep abnf::cst)))
 (declare
  (xargs
   :guard (and (cst-matchp abnf::cst "basic-character-not-star")
               (equal (cst-basic-character-not-star-conc? abnf::cst)
                      5))))
 (let ((__function__ 'cst-basic-character-not-star-conc5-rep))
   (declare (ignorable __function__))
   (abnf::tree-list-fix
        (nth 0
             (cst-basic-character-not-star-conc5 abnf::cst)))))

Theorem: tree-listp-of-cst-basic-character-not-star-conc5-rep

(defthm tree-listp-of-cst-basic-character-not-star-conc5-rep
  (b*
   ((abnf::csts (cst-basic-character-not-star-conc5-rep abnf::cst)))
   (abnf::tree-listp abnf::csts))
  :rule-classes :rewrite)

Theorem: cst-basic-character-not-star-conc5-rep-match

(defthm cst-basic-character-not-star-conc5-rep-match
 (implies
  (and (cst-matchp abnf::cst "basic-character-not-star")
       (equal (cst-basic-character-not-star-conc? abnf::cst)
              5))
  (b*
   ((abnf::csts (cst-basic-character-not-star-conc5-rep abnf::cst)))
   (cst-list-rep-matchp abnf::csts "control-character")))
 :rule-classes :rewrite)

Theorem: cst-basic-character-not-star-conc5-rep-of-tree-fix-cst

(defthm cst-basic-character-not-star-conc5-rep-of-tree-fix-cst
  (equal (cst-basic-character-not-star-conc5-rep
              (abnf::tree-fix abnf::cst))
         (cst-basic-character-not-star-conc5-rep abnf::cst)))

Theorem: cst-basic-character-not-star-conc5-rep-tree-equiv-congruence-on-cst

(defthm
 cst-basic-character-not-star-conc5-rep-tree-equiv-congruence-on-cst
 (implies
      (abnf::tree-equiv abnf::cst cst-equiv)
      (equal (cst-basic-character-not-star-conc5-rep abnf::cst)
             (cst-basic-character-not-star-conc5-rep cst-equiv)))
 :rule-classes :congruence)

Function: cst-basic-character-not-greater-than-conc1-rep

(defun cst-basic-character-not-greater-than-conc1-rep (abnf::cst)
 (declare (xargs :guard (abnf::treep abnf::cst)))
 (declare
  (xargs
   :guard
   (and
       (cst-matchp abnf::cst
                   "basic-character-not-greater-than")
       (equal (cst-basic-character-not-greater-than-conc? abnf::cst)
              1))))
 (let
   ((__function__ 'cst-basic-character-not-greater-than-conc1-rep))
  (declare (ignorable __function__))
  (abnf::tree-list-fix
     (nth 0
          (cst-basic-character-not-greater-than-conc1 abnf::cst)))))

Theorem: tree-listp-of-cst-basic-character-not-greater-than-conc1-rep

(defthm tree-listp-of-cst-basic-character-not-greater-than-conc1-rep
 (b*
  ((abnf::csts
        (cst-basic-character-not-greater-than-conc1-rep abnf::cst)))
  (abnf::tree-listp abnf::csts))
 :rule-classes :rewrite)

Theorem: cst-basic-character-not-greater-than-conc1-rep-match

(defthm cst-basic-character-not-greater-than-conc1-rep-match
 (implies
  (and (cst-matchp abnf::cst
                   "basic-character-not-greater-than")
       (equal (cst-basic-character-not-greater-than-conc? abnf::cst)
              1))
  (b*
   ((abnf::csts
        (cst-basic-character-not-greater-than-conc1-rep abnf::cst)))
   (cst-list-rep-matchp abnf::csts "letter")))
 :rule-classes :rewrite)

Theorem: cst-basic-character-not-greater-than-conc1-rep-of-tree-fix-cst

(defthm
     cst-basic-character-not-greater-than-conc1-rep-of-tree-fix-cst
 (equal (cst-basic-character-not-greater-than-conc1-rep
             (abnf::tree-fix abnf::cst))
        (cst-basic-character-not-greater-than-conc1-rep abnf::cst)))

Theorem: cst-basic-character-not-greater-than-conc1-rep-tree-equiv-congruence-on-cst

(defthm
 cst-basic-character-not-greater-than-conc1-rep-tree-equiv-congruence-on-cst
 (implies
   (abnf::tree-equiv abnf::cst cst-equiv)
   (equal
        (cst-basic-character-not-greater-than-conc1-rep abnf::cst)
        (cst-basic-character-not-greater-than-conc1-rep cst-equiv)))
 :rule-classes :congruence)

Function: cst-basic-character-not-greater-than-conc2-rep

(defun cst-basic-character-not-greater-than-conc2-rep (abnf::cst)
 (declare (xargs :guard (abnf::treep abnf::cst)))
 (declare
  (xargs
   :guard
   (and
       (cst-matchp abnf::cst
                   "basic-character-not-greater-than")
       (equal (cst-basic-character-not-greater-than-conc? abnf::cst)
              2))))
 (let
   ((__function__ 'cst-basic-character-not-greater-than-conc2-rep))
  (declare (ignorable __function__))
  (abnf::tree-list-fix
     (nth 0
          (cst-basic-character-not-greater-than-conc2 abnf::cst)))))

Theorem: tree-listp-of-cst-basic-character-not-greater-than-conc2-rep

(defthm tree-listp-of-cst-basic-character-not-greater-than-conc2-rep
 (b*
  ((abnf::csts
        (cst-basic-character-not-greater-than-conc2-rep abnf::cst)))
  (abnf::tree-listp abnf::csts))
 :rule-classes :rewrite)

Theorem: cst-basic-character-not-greater-than-conc2-rep-match

(defthm cst-basic-character-not-greater-than-conc2-rep-match
 (implies
  (and (cst-matchp abnf::cst
                   "basic-character-not-greater-than")
       (equal (cst-basic-character-not-greater-than-conc? abnf::cst)
              2))
  (b*
   ((abnf::csts
        (cst-basic-character-not-greater-than-conc2-rep abnf::cst)))
   (cst-list-rep-matchp abnf::csts "digit")))
 :rule-classes :rewrite)

Theorem: cst-basic-character-not-greater-than-conc2-rep-of-tree-fix-cst

(defthm
     cst-basic-character-not-greater-than-conc2-rep-of-tree-fix-cst
 (equal (cst-basic-character-not-greater-than-conc2-rep
             (abnf::tree-fix abnf::cst))
        (cst-basic-character-not-greater-than-conc2-rep abnf::cst)))

Theorem: cst-basic-character-not-greater-than-conc2-rep-tree-equiv-congruence-on-cst

(defthm
 cst-basic-character-not-greater-than-conc2-rep-tree-equiv-congruence-on-cst
 (implies
   (abnf::tree-equiv abnf::cst cst-equiv)
   (equal
        (cst-basic-character-not-greater-than-conc2-rep abnf::cst)
        (cst-basic-character-not-greater-than-conc2-rep cst-equiv)))
 :rule-classes :congruence)

Function: cst-basic-character-not-greater-than-conc3-rep

(defun cst-basic-character-not-greater-than-conc3-rep (abnf::cst)
 (declare (xargs :guard (abnf::treep abnf::cst)))
 (declare
  (xargs
   :guard
   (and
       (cst-matchp abnf::cst
                   "basic-character-not-greater-than")
       (equal (cst-basic-character-not-greater-than-conc? abnf::cst)
              3))))
 (let
   ((__function__ 'cst-basic-character-not-greater-than-conc3-rep))
  (declare (ignorable __function__))
  (abnf::tree-list-fix
     (nth 0
          (cst-basic-character-not-greater-than-conc3 abnf::cst)))))

Theorem: tree-listp-of-cst-basic-character-not-greater-than-conc3-rep

(defthm tree-listp-of-cst-basic-character-not-greater-than-conc3-rep
 (b*
  ((abnf::csts
        (cst-basic-character-not-greater-than-conc3-rep abnf::cst)))
  (abnf::tree-listp abnf::csts))
 :rule-classes :rewrite)

Theorem: cst-basic-character-not-greater-than-conc3-rep-match

(defthm cst-basic-character-not-greater-than-conc3-rep-match
 (implies
  (and (cst-matchp abnf::cst
                   "basic-character-not-greater-than")
       (equal (cst-basic-character-not-greater-than-conc? abnf::cst)
              3))
  (b*
   ((abnf::csts
        (cst-basic-character-not-greater-than-conc3-rep abnf::cst)))
   (cst-list-rep-matchp abnf::csts
                        "graphic-character-not-greater-than")))
 :rule-classes :rewrite)

Theorem: cst-basic-character-not-greater-than-conc3-rep-of-tree-fix-cst

(defthm
     cst-basic-character-not-greater-than-conc3-rep-of-tree-fix-cst
 (equal (cst-basic-character-not-greater-than-conc3-rep
             (abnf::tree-fix abnf::cst))
        (cst-basic-character-not-greater-than-conc3-rep abnf::cst)))

Theorem: cst-basic-character-not-greater-than-conc3-rep-tree-equiv-congruence-on-cst

(defthm
 cst-basic-character-not-greater-than-conc3-rep-tree-equiv-congruence-on-cst
 (implies
   (abnf::tree-equiv abnf::cst cst-equiv)
   (equal
        (cst-basic-character-not-greater-than-conc3-rep abnf::cst)
        (cst-basic-character-not-greater-than-conc3-rep cst-equiv)))
 :rule-classes :congruence)

Function: cst-basic-character-not-greater-than-conc4-rep

(defun cst-basic-character-not-greater-than-conc4-rep (abnf::cst)
 (declare (xargs :guard (abnf::treep abnf::cst)))
 (declare
  (xargs
   :guard
   (and
       (cst-matchp abnf::cst
                   "basic-character-not-greater-than")
       (equal (cst-basic-character-not-greater-than-conc? abnf::cst)
              4))))
 (let
   ((__function__ 'cst-basic-character-not-greater-than-conc4-rep))
  (declare (ignorable __function__))
  (abnf::tree-list-fix
     (nth 0
          (cst-basic-character-not-greater-than-conc4 abnf::cst)))))

Theorem: tree-listp-of-cst-basic-character-not-greater-than-conc4-rep

(defthm tree-listp-of-cst-basic-character-not-greater-than-conc4-rep
 (b*
  ((abnf::csts
        (cst-basic-character-not-greater-than-conc4-rep abnf::cst)))
  (abnf::tree-listp abnf::csts))
 :rule-classes :rewrite)

Theorem: cst-basic-character-not-greater-than-conc4-rep-match

(defthm cst-basic-character-not-greater-than-conc4-rep-match
 (implies
  (and (cst-matchp abnf::cst
                   "basic-character-not-greater-than")
       (equal (cst-basic-character-not-greater-than-conc? abnf::cst)
              4))
  (b*
   ((abnf::csts
        (cst-basic-character-not-greater-than-conc4-rep abnf::cst)))
   (cst-list-rep-matchp abnf::csts "space")))
 :rule-classes :rewrite)

Theorem: cst-basic-character-not-greater-than-conc4-rep-of-tree-fix-cst

(defthm
     cst-basic-character-not-greater-than-conc4-rep-of-tree-fix-cst
 (equal (cst-basic-character-not-greater-than-conc4-rep
             (abnf::tree-fix abnf::cst))
        (cst-basic-character-not-greater-than-conc4-rep abnf::cst)))

Theorem: cst-basic-character-not-greater-than-conc4-rep-tree-equiv-congruence-on-cst

(defthm
 cst-basic-character-not-greater-than-conc4-rep-tree-equiv-congruence-on-cst
 (implies
   (abnf::tree-equiv abnf::cst cst-equiv)
   (equal
        (cst-basic-character-not-greater-than-conc4-rep abnf::cst)
        (cst-basic-character-not-greater-than-conc4-rep cst-equiv)))
 :rule-classes :congruence)

Function: cst-basic-character-not-greater-than-conc5-rep

(defun cst-basic-character-not-greater-than-conc5-rep (abnf::cst)
 (declare (xargs :guard (abnf::treep abnf::cst)))
 (declare
  (xargs
   :guard
   (and
       (cst-matchp abnf::cst
                   "basic-character-not-greater-than")
       (equal (cst-basic-character-not-greater-than-conc? abnf::cst)
              5))))
 (let
   ((__function__ 'cst-basic-character-not-greater-than-conc5-rep))
  (declare (ignorable __function__))
  (abnf::tree-list-fix
     (nth 0
          (cst-basic-character-not-greater-than-conc5 abnf::cst)))))

Theorem: tree-listp-of-cst-basic-character-not-greater-than-conc5-rep

(defthm tree-listp-of-cst-basic-character-not-greater-than-conc5-rep
 (b*
  ((abnf::csts
        (cst-basic-character-not-greater-than-conc5-rep abnf::cst)))
  (abnf::tree-listp abnf::csts))
 :rule-classes :rewrite)

Theorem: cst-basic-character-not-greater-than-conc5-rep-match

(defthm cst-basic-character-not-greater-than-conc5-rep-match
 (implies
  (and (cst-matchp abnf::cst
                   "basic-character-not-greater-than")
       (equal (cst-basic-character-not-greater-than-conc? abnf::cst)
              5))
  (b*
   ((abnf::csts
        (cst-basic-character-not-greater-than-conc5-rep abnf::cst)))
   (cst-list-rep-matchp abnf::csts "control-character")))
 :rule-classes :rewrite)

Theorem: cst-basic-character-not-greater-than-conc5-rep-of-tree-fix-cst

(defthm
     cst-basic-character-not-greater-than-conc5-rep-of-tree-fix-cst
 (equal (cst-basic-character-not-greater-than-conc5-rep
             (abnf::tree-fix abnf::cst))
        (cst-basic-character-not-greater-than-conc5-rep abnf::cst)))

Theorem: cst-basic-character-not-greater-than-conc5-rep-tree-equiv-congruence-on-cst

(defthm
 cst-basic-character-not-greater-than-conc5-rep-tree-equiv-congruence-on-cst
 (implies
   (abnf::tree-equiv abnf::cst cst-equiv)
   (equal
        (cst-basic-character-not-greater-than-conc5-rep abnf::cst)
        (cst-basic-character-not-greater-than-conc5-rep cst-equiv)))
 :rule-classes :congruence)

Function: cst-basic-character-not-double-quote-conc1-rep

(defun cst-basic-character-not-double-quote-conc1-rep (abnf::cst)
 (declare (xargs :guard (abnf::treep abnf::cst)))
 (declare
  (xargs
   :guard
   (and
       (cst-matchp abnf::cst
                   "basic-character-not-double-quote")
       (equal (cst-basic-character-not-double-quote-conc? abnf::cst)
              1))))
 (let
   ((__function__ 'cst-basic-character-not-double-quote-conc1-rep))
  (declare (ignorable __function__))
  (abnf::tree-list-fix
     (nth 0
          (cst-basic-character-not-double-quote-conc1 abnf::cst)))))

Theorem: tree-listp-of-cst-basic-character-not-double-quote-conc1-rep

(defthm tree-listp-of-cst-basic-character-not-double-quote-conc1-rep
 (b*
  ((abnf::csts
        (cst-basic-character-not-double-quote-conc1-rep abnf::cst)))
  (abnf::tree-listp abnf::csts))
 :rule-classes :rewrite)

Theorem: cst-basic-character-not-double-quote-conc1-rep-match

(defthm cst-basic-character-not-double-quote-conc1-rep-match
 (implies
  (and (cst-matchp abnf::cst
                   "basic-character-not-double-quote")
       (equal (cst-basic-character-not-double-quote-conc? abnf::cst)
              1))
  (b*
   ((abnf::csts
        (cst-basic-character-not-double-quote-conc1-rep abnf::cst)))
   (cst-list-rep-matchp abnf::csts "letter")))
 :rule-classes :rewrite)

Theorem: cst-basic-character-not-double-quote-conc1-rep-of-tree-fix-cst

(defthm
     cst-basic-character-not-double-quote-conc1-rep-of-tree-fix-cst
 (equal (cst-basic-character-not-double-quote-conc1-rep
             (abnf::tree-fix abnf::cst))
        (cst-basic-character-not-double-quote-conc1-rep abnf::cst)))

Theorem: cst-basic-character-not-double-quote-conc1-rep-tree-equiv-congruence-on-cst

(defthm
 cst-basic-character-not-double-quote-conc1-rep-tree-equiv-congruence-on-cst
 (implies
   (abnf::tree-equiv abnf::cst cst-equiv)
   (equal
        (cst-basic-character-not-double-quote-conc1-rep abnf::cst)
        (cst-basic-character-not-double-quote-conc1-rep cst-equiv)))
 :rule-classes :congruence)

Function: cst-basic-character-not-double-quote-conc2-rep

(defun cst-basic-character-not-double-quote-conc2-rep (abnf::cst)
 (declare (xargs :guard (abnf::treep abnf::cst)))
 (declare
  (xargs
   :guard
   (and
       (cst-matchp abnf::cst
                   "basic-character-not-double-quote")
       (equal (cst-basic-character-not-double-quote-conc? abnf::cst)
              2))))
 (let
   ((__function__ 'cst-basic-character-not-double-quote-conc2-rep))
  (declare (ignorable __function__))
  (abnf::tree-list-fix
     (nth 0
          (cst-basic-character-not-double-quote-conc2 abnf::cst)))))

Theorem: tree-listp-of-cst-basic-character-not-double-quote-conc2-rep

(defthm tree-listp-of-cst-basic-character-not-double-quote-conc2-rep
 (b*
  ((abnf::csts
        (cst-basic-character-not-double-quote-conc2-rep abnf::cst)))
  (abnf::tree-listp abnf::csts))
 :rule-classes :rewrite)

Theorem: cst-basic-character-not-double-quote-conc2-rep-match

(defthm cst-basic-character-not-double-quote-conc2-rep-match
 (implies
  (and (cst-matchp abnf::cst
                   "basic-character-not-double-quote")
       (equal (cst-basic-character-not-double-quote-conc? abnf::cst)
              2))
  (b*
   ((abnf::csts
        (cst-basic-character-not-double-quote-conc2-rep abnf::cst)))
   (cst-list-rep-matchp abnf::csts "digit")))
 :rule-classes :rewrite)

Theorem: cst-basic-character-not-double-quote-conc2-rep-of-tree-fix-cst

(defthm
     cst-basic-character-not-double-quote-conc2-rep-of-tree-fix-cst
 (equal (cst-basic-character-not-double-quote-conc2-rep
             (abnf::tree-fix abnf::cst))
        (cst-basic-character-not-double-quote-conc2-rep abnf::cst)))

Theorem: cst-basic-character-not-double-quote-conc2-rep-tree-equiv-congruence-on-cst

(defthm
 cst-basic-character-not-double-quote-conc2-rep-tree-equiv-congruence-on-cst
 (implies
   (abnf::tree-equiv abnf::cst cst-equiv)
   (equal
        (cst-basic-character-not-double-quote-conc2-rep abnf::cst)
        (cst-basic-character-not-double-quote-conc2-rep cst-equiv)))
 :rule-classes :congruence)

Function: cst-basic-character-not-double-quote-conc3-rep

(defun cst-basic-character-not-double-quote-conc3-rep (abnf::cst)
 (declare (xargs :guard (abnf::treep abnf::cst)))
 (declare
  (xargs
   :guard
   (and
       (cst-matchp abnf::cst
                   "basic-character-not-double-quote")
       (equal (cst-basic-character-not-double-quote-conc? abnf::cst)
              3))))
 (let
   ((__function__ 'cst-basic-character-not-double-quote-conc3-rep))
  (declare (ignorable __function__))
  (abnf::tree-list-fix
     (nth 0
          (cst-basic-character-not-double-quote-conc3 abnf::cst)))))

Theorem: tree-listp-of-cst-basic-character-not-double-quote-conc3-rep

(defthm tree-listp-of-cst-basic-character-not-double-quote-conc3-rep
 (b*
  ((abnf::csts
        (cst-basic-character-not-double-quote-conc3-rep abnf::cst)))
  (abnf::tree-listp abnf::csts))
 :rule-classes :rewrite)

Theorem: cst-basic-character-not-double-quote-conc3-rep-match

(defthm cst-basic-character-not-double-quote-conc3-rep-match
 (implies
  (and (cst-matchp abnf::cst
                   "basic-character-not-double-quote")
       (equal (cst-basic-character-not-double-quote-conc? abnf::cst)
              3))
  (b*
   ((abnf::csts
        (cst-basic-character-not-double-quote-conc3-rep abnf::cst)))
   (cst-list-rep-matchp abnf::csts
                        "graphic-character-not-double-quote")))
 :rule-classes :rewrite)

Theorem: cst-basic-character-not-double-quote-conc3-rep-of-tree-fix-cst

(defthm
     cst-basic-character-not-double-quote-conc3-rep-of-tree-fix-cst
 (equal (cst-basic-character-not-double-quote-conc3-rep
             (abnf::tree-fix abnf::cst))
        (cst-basic-character-not-double-quote-conc3-rep abnf::cst)))

Theorem: cst-basic-character-not-double-quote-conc3-rep-tree-equiv-congruence-on-cst

(defthm
 cst-basic-character-not-double-quote-conc3-rep-tree-equiv-congruence-on-cst
 (implies
   (abnf::tree-equiv abnf::cst cst-equiv)
   (equal
        (cst-basic-character-not-double-quote-conc3-rep abnf::cst)
        (cst-basic-character-not-double-quote-conc3-rep cst-equiv)))
 :rule-classes :congruence)

Function: cst-basic-character-not-double-quote-conc4-rep

(defun cst-basic-character-not-double-quote-conc4-rep (abnf::cst)
 (declare (xargs :guard (abnf::treep abnf::cst)))
 (declare
  (xargs
   :guard
   (and
       (cst-matchp abnf::cst
                   "basic-character-not-double-quote")
       (equal (cst-basic-character-not-double-quote-conc? abnf::cst)
              4))))
 (let
   ((__function__ 'cst-basic-character-not-double-quote-conc4-rep))
  (declare (ignorable __function__))
  (abnf::tree-list-fix
     (nth 0
          (cst-basic-character-not-double-quote-conc4 abnf::cst)))))

Theorem: tree-listp-of-cst-basic-character-not-double-quote-conc4-rep

(defthm tree-listp-of-cst-basic-character-not-double-quote-conc4-rep
 (b*
  ((abnf::csts
        (cst-basic-character-not-double-quote-conc4-rep abnf::cst)))
  (abnf::tree-listp abnf::csts))
 :rule-classes :rewrite)

Theorem: cst-basic-character-not-double-quote-conc4-rep-match

(defthm cst-basic-character-not-double-quote-conc4-rep-match
 (implies
  (and (cst-matchp abnf::cst
                   "basic-character-not-double-quote")
       (equal (cst-basic-character-not-double-quote-conc? abnf::cst)
              4))
  (b*
   ((abnf::csts
        (cst-basic-character-not-double-quote-conc4-rep abnf::cst)))
   (cst-list-rep-matchp abnf::csts "space")))
 :rule-classes :rewrite)

Theorem: cst-basic-character-not-double-quote-conc4-rep-of-tree-fix-cst

(defthm
     cst-basic-character-not-double-quote-conc4-rep-of-tree-fix-cst
 (equal (cst-basic-character-not-double-quote-conc4-rep
             (abnf::tree-fix abnf::cst))
        (cst-basic-character-not-double-quote-conc4-rep abnf::cst)))

Theorem: cst-basic-character-not-double-quote-conc4-rep-tree-equiv-congruence-on-cst

(defthm
 cst-basic-character-not-double-quote-conc4-rep-tree-equiv-congruence-on-cst
 (implies
   (abnf::tree-equiv abnf::cst cst-equiv)
   (equal
        (cst-basic-character-not-double-quote-conc4-rep abnf::cst)
        (cst-basic-character-not-double-quote-conc4-rep cst-equiv)))
 :rule-classes :congruence)

Function: cst-basic-character-not-double-quote-conc5-rep

(defun cst-basic-character-not-double-quote-conc5-rep (abnf::cst)
 (declare (xargs :guard (abnf::treep abnf::cst)))
 (declare
  (xargs
   :guard
   (and
       (cst-matchp abnf::cst
                   "basic-character-not-double-quote")
       (equal (cst-basic-character-not-double-quote-conc? abnf::cst)
              5))))
 (let
   ((__function__ 'cst-basic-character-not-double-quote-conc5-rep))
  (declare (ignorable __function__))
  (abnf::tree-list-fix
     (nth 0
          (cst-basic-character-not-double-quote-conc5 abnf::cst)))))

Theorem: tree-listp-of-cst-basic-character-not-double-quote-conc5-rep

(defthm tree-listp-of-cst-basic-character-not-double-quote-conc5-rep
 (b*
  ((abnf::csts
        (cst-basic-character-not-double-quote-conc5-rep abnf::cst)))
  (abnf::tree-listp abnf::csts))
 :rule-classes :rewrite)

Theorem: cst-basic-character-not-double-quote-conc5-rep-match

(defthm cst-basic-character-not-double-quote-conc5-rep-match
 (implies
  (and (cst-matchp abnf::cst
                   "basic-character-not-double-quote")
       (equal (cst-basic-character-not-double-quote-conc? abnf::cst)
              5))
  (b*
   ((abnf::csts
        (cst-basic-character-not-double-quote-conc5-rep abnf::cst)))
   (cst-list-rep-matchp abnf::csts "control-character")))
 :rule-classes :rewrite)

Theorem: cst-basic-character-not-double-quote-conc5-rep-of-tree-fix-cst

(defthm
     cst-basic-character-not-double-quote-conc5-rep-of-tree-fix-cst
 (equal (cst-basic-character-not-double-quote-conc5-rep
             (abnf::tree-fix abnf::cst))
        (cst-basic-character-not-double-quote-conc5-rep abnf::cst)))

Theorem: cst-basic-character-not-double-quote-conc5-rep-tree-equiv-congruence-on-cst

(defthm
 cst-basic-character-not-double-quote-conc5-rep-tree-equiv-congruence-on-cst
 (implies
   (abnf::tree-equiv abnf::cst cst-equiv)
   (equal
        (cst-basic-character-not-double-quote-conc5-rep abnf::cst)
        (cst-basic-character-not-double-quote-conc5-rep cst-equiv)))
 :rule-classes :congruence)

Function: cst-basic-character-not-star-or-slash-conc1-rep

(defun cst-basic-character-not-star-or-slash-conc1-rep (abnf::cst)
 (declare (xargs :guard (abnf::treep abnf::cst)))
 (declare
  (xargs
   :guard
   (and
      (cst-matchp abnf::cst
                  "basic-character-not-star-or-slash")
      (equal (cst-basic-character-not-star-or-slash-conc? abnf::cst)
             1))))
 (let
  ((__function__ 'cst-basic-character-not-star-or-slash-conc1-rep))
  (declare (ignorable __function__))
  (abnf::tree-list-fix
    (nth 0
         (cst-basic-character-not-star-or-slash-conc1 abnf::cst)))))

Theorem: tree-listp-of-cst-basic-character-not-star-or-slash-conc1-rep

(defthm
      tree-listp-of-cst-basic-character-not-star-or-slash-conc1-rep
 (b*
  ((abnf::csts
       (cst-basic-character-not-star-or-slash-conc1-rep abnf::cst)))
  (abnf::tree-listp abnf::csts))
 :rule-classes :rewrite)

Theorem: cst-basic-character-not-star-or-slash-conc1-rep-match

(defthm cst-basic-character-not-star-or-slash-conc1-rep-match
 (implies
  (and
      (cst-matchp abnf::cst
                  "basic-character-not-star-or-slash")
      (equal (cst-basic-character-not-star-or-slash-conc? abnf::cst)
             1))
  (b*
   ((abnf::csts
       (cst-basic-character-not-star-or-slash-conc1-rep abnf::cst)))
   (cst-list-rep-matchp abnf::csts "letter")))
 :rule-classes :rewrite)

Theorem: cst-basic-character-not-star-or-slash-conc1-rep-of-tree-fix-cst

(defthm
    cst-basic-character-not-star-or-slash-conc1-rep-of-tree-fix-cst
  (equal
       (cst-basic-character-not-star-or-slash-conc1-rep
            (abnf::tree-fix abnf::cst))
       (cst-basic-character-not-star-or-slash-conc1-rep abnf::cst)))

Theorem: cst-basic-character-not-star-or-slash-conc1-rep-tree-equiv-congruence-on-cst

(defthm
 cst-basic-character-not-star-or-slash-conc1-rep-tree-equiv-congruence-on-cst
 (implies
  (abnf::tree-equiv abnf::cst cst-equiv)
  (equal
       (cst-basic-character-not-star-or-slash-conc1-rep abnf::cst)
       (cst-basic-character-not-star-or-slash-conc1-rep cst-equiv)))
 :rule-classes :congruence)

Function: cst-basic-character-not-star-or-slash-conc2-rep

(defun cst-basic-character-not-star-or-slash-conc2-rep (abnf::cst)
 (declare (xargs :guard (abnf::treep abnf::cst)))
 (declare
  (xargs
   :guard
   (and
      (cst-matchp abnf::cst
                  "basic-character-not-star-or-slash")
      (equal (cst-basic-character-not-star-or-slash-conc? abnf::cst)
             2))))
 (let
  ((__function__ 'cst-basic-character-not-star-or-slash-conc2-rep))
  (declare (ignorable __function__))
  (abnf::tree-list-fix
    (nth 0
         (cst-basic-character-not-star-or-slash-conc2 abnf::cst)))))

Theorem: tree-listp-of-cst-basic-character-not-star-or-slash-conc2-rep

(defthm
      tree-listp-of-cst-basic-character-not-star-or-slash-conc2-rep
 (b*
  ((abnf::csts
       (cst-basic-character-not-star-or-slash-conc2-rep abnf::cst)))
  (abnf::tree-listp abnf::csts))
 :rule-classes :rewrite)

Theorem: cst-basic-character-not-star-or-slash-conc2-rep-match

(defthm cst-basic-character-not-star-or-slash-conc2-rep-match
 (implies
  (and
      (cst-matchp abnf::cst
                  "basic-character-not-star-or-slash")
      (equal (cst-basic-character-not-star-or-slash-conc? abnf::cst)
             2))
  (b*
   ((abnf::csts
       (cst-basic-character-not-star-or-slash-conc2-rep abnf::cst)))
   (cst-list-rep-matchp abnf::csts "digit")))
 :rule-classes :rewrite)

Theorem: cst-basic-character-not-star-or-slash-conc2-rep-of-tree-fix-cst

(defthm
    cst-basic-character-not-star-or-slash-conc2-rep-of-tree-fix-cst
  (equal
       (cst-basic-character-not-star-or-slash-conc2-rep
            (abnf::tree-fix abnf::cst))
       (cst-basic-character-not-star-or-slash-conc2-rep abnf::cst)))

Theorem: cst-basic-character-not-star-or-slash-conc2-rep-tree-equiv-congruence-on-cst

(defthm
 cst-basic-character-not-star-or-slash-conc2-rep-tree-equiv-congruence-on-cst
 (implies
  (abnf::tree-equiv abnf::cst cst-equiv)
  (equal
       (cst-basic-character-not-star-or-slash-conc2-rep abnf::cst)
       (cst-basic-character-not-star-or-slash-conc2-rep cst-equiv)))
 :rule-classes :congruence)

Function: cst-basic-character-not-star-or-slash-conc3-rep

(defun cst-basic-character-not-star-or-slash-conc3-rep (abnf::cst)
 (declare (xargs :guard (abnf::treep abnf::cst)))
 (declare
  (xargs
   :guard
   (and
      (cst-matchp abnf::cst
                  "basic-character-not-star-or-slash")
      (equal (cst-basic-character-not-star-or-slash-conc? abnf::cst)
             3))))
 (let
  ((__function__ 'cst-basic-character-not-star-or-slash-conc3-rep))
  (declare (ignorable __function__))
  (abnf::tree-list-fix
    (nth 0
         (cst-basic-character-not-star-or-slash-conc3 abnf::cst)))))

Theorem: tree-listp-of-cst-basic-character-not-star-or-slash-conc3-rep

(defthm
      tree-listp-of-cst-basic-character-not-star-or-slash-conc3-rep
 (b*
  ((abnf::csts
       (cst-basic-character-not-star-or-slash-conc3-rep abnf::cst)))
  (abnf::tree-listp abnf::csts))
 :rule-classes :rewrite)

Theorem: cst-basic-character-not-star-or-slash-conc3-rep-match

(defthm cst-basic-character-not-star-or-slash-conc3-rep-match
 (implies
  (and
      (cst-matchp abnf::cst
                  "basic-character-not-star-or-slash")
      (equal (cst-basic-character-not-star-or-slash-conc? abnf::cst)
             3))
  (b*
   ((abnf::csts
       (cst-basic-character-not-star-or-slash-conc3-rep abnf::cst)))
   (cst-list-rep-matchp abnf::csts
                        "graphic-character-not-star-or-slash")))
 :rule-classes :rewrite)

Theorem: cst-basic-character-not-star-or-slash-conc3-rep-of-tree-fix-cst

(defthm
    cst-basic-character-not-star-or-slash-conc3-rep-of-tree-fix-cst
  (equal
       (cst-basic-character-not-star-or-slash-conc3-rep
            (abnf::tree-fix abnf::cst))
       (cst-basic-character-not-star-or-slash-conc3-rep abnf::cst)))

Theorem: cst-basic-character-not-star-or-slash-conc3-rep-tree-equiv-congruence-on-cst

(defthm
 cst-basic-character-not-star-or-slash-conc3-rep-tree-equiv-congruence-on-cst
 (implies
  (abnf::tree-equiv abnf::cst cst-equiv)
  (equal
       (cst-basic-character-not-star-or-slash-conc3-rep abnf::cst)
       (cst-basic-character-not-star-or-slash-conc3-rep cst-equiv)))
 :rule-classes :congruence)

Function: cst-basic-character-not-star-or-slash-conc4-rep

(defun cst-basic-character-not-star-or-slash-conc4-rep (abnf::cst)
 (declare (xargs :guard (abnf::treep abnf::cst)))
 (declare
  (xargs
   :guard
   (and
      (cst-matchp abnf::cst
                  "basic-character-not-star-or-slash")
      (equal (cst-basic-character-not-star-or-slash-conc? abnf::cst)
             4))))
 (let
  ((__function__ 'cst-basic-character-not-star-or-slash-conc4-rep))
  (declare (ignorable __function__))
  (abnf::tree-list-fix
    (nth 0
         (cst-basic-character-not-star-or-slash-conc4 abnf::cst)))))

Theorem: tree-listp-of-cst-basic-character-not-star-or-slash-conc4-rep

(defthm
      tree-listp-of-cst-basic-character-not-star-or-slash-conc4-rep
 (b*
  ((abnf::csts
       (cst-basic-character-not-star-or-slash-conc4-rep abnf::cst)))
  (abnf::tree-listp abnf::csts))
 :rule-classes :rewrite)

Theorem: cst-basic-character-not-star-or-slash-conc4-rep-match

(defthm cst-basic-character-not-star-or-slash-conc4-rep-match
 (implies
  (and
      (cst-matchp abnf::cst
                  "basic-character-not-star-or-slash")
      (equal (cst-basic-character-not-star-or-slash-conc? abnf::cst)
             4))
  (b*
   ((abnf::csts
       (cst-basic-character-not-star-or-slash-conc4-rep abnf::cst)))
   (cst-list-rep-matchp abnf::csts "space")))
 :rule-classes :rewrite)

Theorem: cst-basic-character-not-star-or-slash-conc4-rep-of-tree-fix-cst

(defthm
    cst-basic-character-not-star-or-slash-conc4-rep-of-tree-fix-cst
  (equal
       (cst-basic-character-not-star-or-slash-conc4-rep
            (abnf::tree-fix abnf::cst))
       (cst-basic-character-not-star-or-slash-conc4-rep abnf::cst)))

Theorem: cst-basic-character-not-star-or-slash-conc4-rep-tree-equiv-congruence-on-cst

(defthm
 cst-basic-character-not-star-or-slash-conc4-rep-tree-equiv-congruence-on-cst
 (implies
  (abnf::tree-equiv abnf::cst cst-equiv)
  (equal
       (cst-basic-character-not-star-or-slash-conc4-rep abnf::cst)
       (cst-basic-character-not-star-or-slash-conc4-rep cst-equiv)))
 :rule-classes :congruence)

Function: cst-basic-character-not-star-or-slash-conc5-rep

(defun cst-basic-character-not-star-or-slash-conc5-rep (abnf::cst)
 (declare (xargs :guard (abnf::treep abnf::cst)))
 (declare
  (xargs
   :guard
   (and
      (cst-matchp abnf::cst
                  "basic-character-not-star-or-slash")
      (equal (cst-basic-character-not-star-or-slash-conc? abnf::cst)
             5))))
 (let
  ((__function__ 'cst-basic-character-not-star-or-slash-conc5-rep))
  (declare (ignorable __function__))
  (abnf::tree-list-fix
    (nth 0
         (cst-basic-character-not-star-or-slash-conc5 abnf::cst)))))

Theorem: tree-listp-of-cst-basic-character-not-star-or-slash-conc5-rep

(defthm
      tree-listp-of-cst-basic-character-not-star-or-slash-conc5-rep
 (b*
  ((abnf::csts
       (cst-basic-character-not-star-or-slash-conc5-rep abnf::cst)))
  (abnf::tree-listp abnf::csts))
 :rule-classes :rewrite)

Theorem: cst-basic-character-not-star-or-slash-conc5-rep-match

(defthm cst-basic-character-not-star-or-slash-conc5-rep-match
 (implies
  (and
      (cst-matchp abnf::cst
                  "basic-character-not-star-or-slash")
      (equal (cst-basic-character-not-star-or-slash-conc? abnf::cst)
             5))
  (b*
   ((abnf::csts
       (cst-basic-character-not-star-or-slash-conc5-rep abnf::cst)))
   (cst-list-rep-matchp abnf::csts "control-character")))
 :rule-classes :rewrite)

Theorem: cst-basic-character-not-star-or-slash-conc5-rep-of-tree-fix-cst

(defthm
    cst-basic-character-not-star-or-slash-conc5-rep-of-tree-fix-cst
  (equal
       (cst-basic-character-not-star-or-slash-conc5-rep
            (abnf::tree-fix abnf::cst))
       (cst-basic-character-not-star-or-slash-conc5-rep abnf::cst)))

Theorem: cst-basic-character-not-star-or-slash-conc5-rep-tree-equiv-congruence-on-cst

(defthm
 cst-basic-character-not-star-or-slash-conc5-rep-tree-equiv-congruence-on-cst
 (implies
  (abnf::tree-equiv abnf::cst cst-equiv)
  (equal
       (cst-basic-character-not-star-or-slash-conc5-rep abnf::cst)
       (cst-basic-character-not-star-or-slash-conc5-rep cst-equiv)))
 :rule-classes :congruence)

Function: cst-basic-character-not-single-quote-or-backslash-conc1-rep

(defun cst-basic-character-not-single-quote-or-backslash-conc1-rep
       (abnf::cst)
 (declare (xargs :guard (abnf::treep abnf::cst)))
 (declare
  (xargs
   :guard
   (and (cst-matchp abnf::cst
                    "basic-character-not-single-quote-or-backslash")
        (equal (cst-basic-character-not-single-quote-or-backslash-conc?
                    abnf::cst)
               1))))
 (let
  ((__function__
      'cst-basic-character-not-single-quote-or-backslash-conc1-rep))
  (declare (ignorable __function__))
  (abnf::tree-list-fix (nth 0
                            (cst-basic-character-not-single-quote-or-backslash-conc1
                                 abnf::cst)))))

Theorem: tree-listp-of-cst-basic-character-not-single-quote-or-backslash-conc1-rep

(defthm
 tree-listp-of-cst-basic-character-not-single-quote-or-backslash-conc1-rep
 (b* ((abnf::csts (cst-basic-character-not-single-quote-or-backslash-conc1-rep
                       abnf::cst)))
   (abnf::tree-listp abnf::csts))
 :rule-classes :rewrite)

Theorem: cst-basic-character-not-single-quote-or-backslash-conc1-rep-match

(defthm
  cst-basic-character-not-single-quote-or-backslash-conc1-rep-match
 (implies
   (and (cst-matchp abnf::cst
                    "basic-character-not-single-quote-or-backslash")
        (equal (cst-basic-character-not-single-quote-or-backslash-conc?
                    abnf::cst)
               1))
   (b* ((abnf::csts (cst-basic-character-not-single-quote-or-backslash-conc1-rep
                         abnf::cst)))
     (cst-list-rep-matchp abnf::csts "letter")))
 :rule-classes :rewrite)

Theorem: cst-basic-character-not-single-quote-or-backslash-conc1-rep-of-tree-fix-cst

(defthm
 cst-basic-character-not-single-quote-or-backslash-conc1-rep-of-tree-fix-cst
 (equal (cst-basic-character-not-single-quote-or-backslash-conc1-rep
             (abnf::tree-fix abnf::cst))
        (cst-basic-character-not-single-quote-or-backslash-conc1-rep
             abnf::cst)))

Theorem: cst-basic-character-not-single-quote-or-backslash-conc1-rep-tree-equiv-congruence-on-cst

(defthm
 cst-basic-character-not-single-quote-or-backslash-conc1-rep-tree-equiv-congruence-on-cst
 (implies (abnf::tree-equiv abnf::cst cst-equiv)
          (equal (cst-basic-character-not-single-quote-or-backslash-conc1-rep
                      abnf::cst)
                 (cst-basic-character-not-single-quote-or-backslash-conc1-rep
                      cst-equiv)))
 :rule-classes :congruence)

Function: cst-basic-character-not-single-quote-or-backslash-conc2-rep

(defun cst-basic-character-not-single-quote-or-backslash-conc2-rep
       (abnf::cst)
 (declare (xargs :guard (abnf::treep abnf::cst)))
 (declare
  (xargs
   :guard
   (and (cst-matchp abnf::cst
                    "basic-character-not-single-quote-or-backslash")
        (equal (cst-basic-character-not-single-quote-or-backslash-conc?
                    abnf::cst)
               2))))
 (let
  ((__function__
      'cst-basic-character-not-single-quote-or-backslash-conc2-rep))
  (declare (ignorable __function__))
  (abnf::tree-list-fix (nth 0
                            (cst-basic-character-not-single-quote-or-backslash-conc2
                                 abnf::cst)))))

Theorem: tree-listp-of-cst-basic-character-not-single-quote-or-backslash-conc2-rep

(defthm
 tree-listp-of-cst-basic-character-not-single-quote-or-backslash-conc2-rep
 (b* ((abnf::csts (cst-basic-character-not-single-quote-or-backslash-conc2-rep
                       abnf::cst)))
   (abnf::tree-listp abnf::csts))
 :rule-classes :rewrite)

Theorem: cst-basic-character-not-single-quote-or-backslash-conc2-rep-match

(defthm
  cst-basic-character-not-single-quote-or-backslash-conc2-rep-match
 (implies
   (and (cst-matchp abnf::cst
                    "basic-character-not-single-quote-or-backslash")
        (equal (cst-basic-character-not-single-quote-or-backslash-conc?
                    abnf::cst)
               2))
   (b* ((abnf::csts (cst-basic-character-not-single-quote-or-backslash-conc2-rep
                         abnf::cst)))
     (cst-list-rep-matchp abnf::csts "digit")))
 :rule-classes :rewrite)

Theorem: cst-basic-character-not-single-quote-or-backslash-conc2-rep-of-tree-fix-cst

(defthm
 cst-basic-character-not-single-quote-or-backslash-conc2-rep-of-tree-fix-cst
 (equal (cst-basic-character-not-single-quote-or-backslash-conc2-rep
             (abnf::tree-fix abnf::cst))
        (cst-basic-character-not-single-quote-or-backslash-conc2-rep
             abnf::cst)))

Theorem: cst-basic-character-not-single-quote-or-backslash-conc2-rep-tree-equiv-congruence-on-cst

(defthm
 cst-basic-character-not-single-quote-or-backslash-conc2-rep-tree-equiv-congruence-on-cst
 (implies (abnf::tree-equiv abnf::cst cst-equiv)
          (equal (cst-basic-character-not-single-quote-or-backslash-conc2-rep
                      abnf::cst)
                 (cst-basic-character-not-single-quote-or-backslash-conc2-rep
                      cst-equiv)))
 :rule-classes :congruence)

Function: cst-basic-character-not-single-quote-or-backslash-conc3-rep

(defun cst-basic-character-not-single-quote-or-backslash-conc3-rep
       (abnf::cst)
 (declare (xargs :guard (abnf::treep abnf::cst)))
 (declare
  (xargs
   :guard
   (and (cst-matchp abnf::cst
                    "basic-character-not-single-quote-or-backslash")
        (equal (cst-basic-character-not-single-quote-or-backslash-conc?
                    abnf::cst)
               3))))
 (let
  ((__function__
      'cst-basic-character-not-single-quote-or-backslash-conc3-rep))
  (declare (ignorable __function__))
  (abnf::tree-list-fix (nth 0
                            (cst-basic-character-not-single-quote-or-backslash-conc3
                                 abnf::cst)))))

Theorem: tree-listp-of-cst-basic-character-not-single-quote-or-backslash-conc3-rep

(defthm
 tree-listp-of-cst-basic-character-not-single-quote-or-backslash-conc3-rep
 (b* ((abnf::csts (cst-basic-character-not-single-quote-or-backslash-conc3-rep
                       abnf::cst)))
   (abnf::tree-listp abnf::csts))
 :rule-classes :rewrite)

Theorem: cst-basic-character-not-single-quote-or-backslash-conc3-rep-match

(defthm
  cst-basic-character-not-single-quote-or-backslash-conc3-rep-match
 (implies
   (and (cst-matchp abnf::cst
                    "basic-character-not-single-quote-or-backslash")
        (equal (cst-basic-character-not-single-quote-or-backslash-conc?
                    abnf::cst)
               3))
   (b* ((abnf::csts (cst-basic-character-not-single-quote-or-backslash-conc3-rep
                         abnf::cst)))
     (cst-list-rep-matchp
          abnf::csts
          "graphic-character-not-single-quote-or-backslash")))
 :rule-classes :rewrite)

Theorem: cst-basic-character-not-single-quote-or-backslash-conc3-rep-of-tree-fix-cst

(defthm
 cst-basic-character-not-single-quote-or-backslash-conc3-rep-of-tree-fix-cst
 (equal (cst-basic-character-not-single-quote-or-backslash-conc3-rep
             (abnf::tree-fix abnf::cst))
        (cst-basic-character-not-single-quote-or-backslash-conc3-rep
             abnf::cst)))

Theorem: cst-basic-character-not-single-quote-or-backslash-conc3-rep-tree-equiv-congruence-on-cst

(defthm
 cst-basic-character-not-single-quote-or-backslash-conc3-rep-tree-equiv-congruence-on-cst
 (implies (abnf::tree-equiv abnf::cst cst-equiv)
          (equal (cst-basic-character-not-single-quote-or-backslash-conc3-rep
                      abnf::cst)
                 (cst-basic-character-not-single-quote-or-backslash-conc3-rep
                      cst-equiv)))
 :rule-classes :congruence)

Function: cst-basic-character-not-single-quote-or-backslash-conc4-rep

(defun cst-basic-character-not-single-quote-or-backslash-conc4-rep
       (abnf::cst)
 (declare (xargs :guard (abnf::treep abnf::cst)))
 (declare
  (xargs
   :guard
   (and (cst-matchp abnf::cst
                    "basic-character-not-single-quote-or-backslash")
        (equal (cst-basic-character-not-single-quote-or-backslash-conc?
                    abnf::cst)
               4))))
 (let
  ((__function__
      'cst-basic-character-not-single-quote-or-backslash-conc4-rep))
  (declare (ignorable __function__))
  (abnf::tree-list-fix (nth 0
                            (cst-basic-character-not-single-quote-or-backslash-conc4
                                 abnf::cst)))))

Theorem: tree-listp-of-cst-basic-character-not-single-quote-or-backslash-conc4-rep

(defthm
 tree-listp-of-cst-basic-character-not-single-quote-or-backslash-conc4-rep
 (b* ((abnf::csts (cst-basic-character-not-single-quote-or-backslash-conc4-rep
                       abnf::cst)))
   (abnf::tree-listp abnf::csts))
 :rule-classes :rewrite)

Theorem: cst-basic-character-not-single-quote-or-backslash-conc4-rep-match

(defthm
  cst-basic-character-not-single-quote-or-backslash-conc4-rep-match
 (implies
   (and (cst-matchp abnf::cst
                    "basic-character-not-single-quote-or-backslash")
        (equal (cst-basic-character-not-single-quote-or-backslash-conc?
                    abnf::cst)
               4))
   (b* ((abnf::csts (cst-basic-character-not-single-quote-or-backslash-conc4-rep
                         abnf::cst)))
     (cst-list-rep-matchp abnf::csts "space")))
 :rule-classes :rewrite)

Theorem: cst-basic-character-not-single-quote-or-backslash-conc4-rep-of-tree-fix-cst

(defthm
 cst-basic-character-not-single-quote-or-backslash-conc4-rep-of-tree-fix-cst
 (equal (cst-basic-character-not-single-quote-or-backslash-conc4-rep
             (abnf::tree-fix abnf::cst))
        (cst-basic-character-not-single-quote-or-backslash-conc4-rep
             abnf::cst)))

Theorem: cst-basic-character-not-single-quote-or-backslash-conc4-rep-tree-equiv-congruence-on-cst

(defthm
 cst-basic-character-not-single-quote-or-backslash-conc4-rep-tree-equiv-congruence-on-cst
 (implies (abnf::tree-equiv abnf::cst cst-equiv)
          (equal (cst-basic-character-not-single-quote-or-backslash-conc4-rep
                      abnf::cst)
                 (cst-basic-character-not-single-quote-or-backslash-conc4-rep
                      cst-equiv)))
 :rule-classes :congruence)

Function: cst-basic-character-not-single-quote-or-backslash-conc5-rep

(defun cst-basic-character-not-single-quote-or-backslash-conc5-rep
       (abnf::cst)
 (declare (xargs :guard (abnf::treep abnf::cst)))
 (declare
  (xargs
   :guard
   (and (cst-matchp abnf::cst
                    "basic-character-not-single-quote-or-backslash")
        (equal (cst-basic-character-not-single-quote-or-backslash-conc?
                    abnf::cst)
               5))))
 (let
  ((__function__
      'cst-basic-character-not-single-quote-or-backslash-conc5-rep))
  (declare (ignorable __function__))
  (abnf::tree-list-fix (nth 0
                            (cst-basic-character-not-single-quote-or-backslash-conc5
                                 abnf::cst)))))

Theorem: tree-listp-of-cst-basic-character-not-single-quote-or-backslash-conc5-rep

(defthm
 tree-listp-of-cst-basic-character-not-single-quote-or-backslash-conc5-rep
 (b* ((abnf::csts (cst-basic-character-not-single-quote-or-backslash-conc5-rep
                       abnf::cst)))
   (abnf::tree-listp abnf::csts))
 :rule-classes :rewrite)

Theorem: cst-basic-character-not-single-quote-or-backslash-conc5-rep-match

(defthm
  cst-basic-character-not-single-quote-or-backslash-conc5-rep-match
 (implies
   (and (cst-matchp abnf::cst
                    "basic-character-not-single-quote-or-backslash")
        (equal (cst-basic-character-not-single-quote-or-backslash-conc?
                    abnf::cst)
               5))
   (b* ((abnf::csts (cst-basic-character-not-single-quote-or-backslash-conc5-rep
                         abnf::cst)))
     (cst-list-rep-matchp abnf::csts "control-character")))
 :rule-classes :rewrite)

Theorem: cst-basic-character-not-single-quote-or-backslash-conc5-rep-of-tree-fix-cst

(defthm
 cst-basic-character-not-single-quote-or-backslash-conc5-rep-of-tree-fix-cst
 (equal (cst-basic-character-not-single-quote-or-backslash-conc5-rep
             (abnf::tree-fix abnf::cst))
        (cst-basic-character-not-single-quote-or-backslash-conc5-rep
             abnf::cst)))

Theorem: cst-basic-character-not-single-quote-or-backslash-conc5-rep-tree-equiv-congruence-on-cst

(defthm
 cst-basic-character-not-single-quote-or-backslash-conc5-rep-tree-equiv-congruence-on-cst
 (implies (abnf::tree-equiv abnf::cst cst-equiv)
          (equal (cst-basic-character-not-single-quote-or-backslash-conc5-rep
                      abnf::cst)
                 (cst-basic-character-not-single-quote-or-backslash-conc5-rep
                      cst-equiv)))
 :rule-classes :congruence)

Function: cst-basic-character-not-double-quote-or-backslash-conc1-rep

(defun cst-basic-character-not-double-quote-or-backslash-conc1-rep
       (abnf::cst)
 (declare (xargs :guard (abnf::treep abnf::cst)))
 (declare
  (xargs
   :guard
   (and (cst-matchp abnf::cst
                    "basic-character-not-double-quote-or-backslash")
        (equal (cst-basic-character-not-double-quote-or-backslash-conc?
                    abnf::cst)
               1))))
 (let
  ((__function__
      'cst-basic-character-not-double-quote-or-backslash-conc1-rep))
  (declare (ignorable __function__))
  (abnf::tree-list-fix (nth 0
                            (cst-basic-character-not-double-quote-or-backslash-conc1
                                 abnf::cst)))))

Theorem: tree-listp-of-cst-basic-character-not-double-quote-or-backslash-conc1-rep

(defthm
 tree-listp-of-cst-basic-character-not-double-quote-or-backslash-conc1-rep
 (b* ((abnf::csts (cst-basic-character-not-double-quote-or-backslash-conc1-rep
                       abnf::cst)))
   (abnf::tree-listp abnf::csts))
 :rule-classes :rewrite)

Theorem: cst-basic-character-not-double-quote-or-backslash-conc1-rep-match

(defthm
  cst-basic-character-not-double-quote-or-backslash-conc1-rep-match
 (implies
   (and (cst-matchp abnf::cst
                    "basic-character-not-double-quote-or-backslash")
        (equal (cst-basic-character-not-double-quote-or-backslash-conc?
                    abnf::cst)
               1))
   (b* ((abnf::csts (cst-basic-character-not-double-quote-or-backslash-conc1-rep
                         abnf::cst)))
     (cst-list-rep-matchp abnf::csts "letter")))
 :rule-classes :rewrite)

Theorem: cst-basic-character-not-double-quote-or-backslash-conc1-rep-of-tree-fix-cst

(defthm
 cst-basic-character-not-double-quote-or-backslash-conc1-rep-of-tree-fix-cst
 (equal (cst-basic-character-not-double-quote-or-backslash-conc1-rep
             (abnf::tree-fix abnf::cst))
        (cst-basic-character-not-double-quote-or-backslash-conc1-rep
             abnf::cst)))

Theorem: cst-basic-character-not-double-quote-or-backslash-conc1-rep-tree-equiv-congruence-on-cst

(defthm
 cst-basic-character-not-double-quote-or-backslash-conc1-rep-tree-equiv-congruence-on-cst
 (implies (abnf::tree-equiv abnf::cst cst-equiv)
          (equal (cst-basic-character-not-double-quote-or-backslash-conc1-rep
                      abnf::cst)
                 (cst-basic-character-not-double-quote-or-backslash-conc1-rep
                      cst-equiv)))
 :rule-classes :congruence)

Function: cst-basic-character-not-double-quote-or-backslash-conc2-rep

(defun cst-basic-character-not-double-quote-or-backslash-conc2-rep
       (abnf::cst)
 (declare (xargs :guard (abnf::treep abnf::cst)))
 (declare
  (xargs
   :guard
   (and (cst-matchp abnf::cst
                    "basic-character-not-double-quote-or-backslash")
        (equal (cst-basic-character-not-double-quote-or-backslash-conc?
                    abnf::cst)
               2))))
 (let
  ((__function__
      'cst-basic-character-not-double-quote-or-backslash-conc2-rep))
  (declare (ignorable __function__))
  (abnf::tree-list-fix (nth 0
                            (cst-basic-character-not-double-quote-or-backslash-conc2
                                 abnf::cst)))))

Theorem: tree-listp-of-cst-basic-character-not-double-quote-or-backslash-conc2-rep

(defthm
 tree-listp-of-cst-basic-character-not-double-quote-or-backslash-conc2-rep
 (b* ((abnf::csts (cst-basic-character-not-double-quote-or-backslash-conc2-rep
                       abnf::cst)))
   (abnf::tree-listp abnf::csts))
 :rule-classes :rewrite)

Theorem: cst-basic-character-not-double-quote-or-backslash-conc2-rep-match

(defthm
  cst-basic-character-not-double-quote-or-backslash-conc2-rep-match
 (implies
   (and (cst-matchp abnf::cst
                    "basic-character-not-double-quote-or-backslash")
        (equal (cst-basic-character-not-double-quote-or-backslash-conc?
                    abnf::cst)
               2))
   (b* ((abnf::csts (cst-basic-character-not-double-quote-or-backslash-conc2-rep
                         abnf::cst)))
     (cst-list-rep-matchp abnf::csts "digit")))
 :rule-classes :rewrite)

Theorem: cst-basic-character-not-double-quote-or-backslash-conc2-rep-of-tree-fix-cst

(defthm
 cst-basic-character-not-double-quote-or-backslash-conc2-rep-of-tree-fix-cst
 (equal (cst-basic-character-not-double-quote-or-backslash-conc2-rep
             (abnf::tree-fix abnf::cst))
        (cst-basic-character-not-double-quote-or-backslash-conc2-rep
             abnf::cst)))

Theorem: cst-basic-character-not-double-quote-or-backslash-conc2-rep-tree-equiv-congruence-on-cst

(defthm
 cst-basic-character-not-double-quote-or-backslash-conc2-rep-tree-equiv-congruence-on-cst
 (implies (abnf::tree-equiv abnf::cst cst-equiv)
          (equal (cst-basic-character-not-double-quote-or-backslash-conc2-rep
                      abnf::cst)
                 (cst-basic-character-not-double-quote-or-backslash-conc2-rep
                      cst-equiv)))
 :rule-classes :congruence)

Function: cst-basic-character-not-double-quote-or-backslash-conc3-rep

(defun cst-basic-character-not-double-quote-or-backslash-conc3-rep
       (abnf::cst)
 (declare (xargs :guard (abnf::treep abnf::cst)))
 (declare
  (xargs
   :guard
   (and (cst-matchp abnf::cst
                    "basic-character-not-double-quote-or-backslash")
        (equal (cst-basic-character-not-double-quote-or-backslash-conc?
                    abnf::cst)
               3))))
 (let
  ((__function__
      'cst-basic-character-not-double-quote-or-backslash-conc3-rep))
  (declare (ignorable __function__))
  (abnf::tree-list-fix (nth 0
                            (cst-basic-character-not-double-quote-or-backslash-conc3
                                 abnf::cst)))))

Theorem: tree-listp-of-cst-basic-character-not-double-quote-or-backslash-conc3-rep

(defthm
 tree-listp-of-cst-basic-character-not-double-quote-or-backslash-conc3-rep
 (b* ((abnf::csts (cst-basic-character-not-double-quote-or-backslash-conc3-rep
                       abnf::cst)))
   (abnf::tree-listp abnf::csts))
 :rule-classes :rewrite)

Theorem: cst-basic-character-not-double-quote-or-backslash-conc3-rep-match

(defthm
  cst-basic-character-not-double-quote-or-backslash-conc3-rep-match
 (implies
   (and (cst-matchp abnf::cst
                    "basic-character-not-double-quote-or-backslash")
        (equal (cst-basic-character-not-double-quote-or-backslash-conc?
                    abnf::cst)
               3))
   (b* ((abnf::csts (cst-basic-character-not-double-quote-or-backslash-conc3-rep
                         abnf::cst)))
     (cst-list-rep-matchp
          abnf::csts
          "graphic-character-not-double-quote-or-backslash")))
 :rule-classes :rewrite)

Theorem: cst-basic-character-not-double-quote-or-backslash-conc3-rep-of-tree-fix-cst

(defthm
 cst-basic-character-not-double-quote-or-backslash-conc3-rep-of-tree-fix-cst
 (equal (cst-basic-character-not-double-quote-or-backslash-conc3-rep
             (abnf::tree-fix abnf::cst))
        (cst-basic-character-not-double-quote-or-backslash-conc3-rep
             abnf::cst)))

Theorem: cst-basic-character-not-double-quote-or-backslash-conc3-rep-tree-equiv-congruence-on-cst

(defthm
 cst-basic-character-not-double-quote-or-backslash-conc3-rep-tree-equiv-congruence-on-cst
 (implies (abnf::tree-equiv abnf::cst cst-equiv)
          (equal (cst-basic-character-not-double-quote-or-backslash-conc3-rep
                      abnf::cst)
                 (cst-basic-character-not-double-quote-or-backslash-conc3-rep
                      cst-equiv)))
 :rule-classes :congruence)

Function: cst-basic-character-not-double-quote-or-backslash-conc4-rep

(defun cst-basic-character-not-double-quote-or-backslash-conc4-rep
       (abnf::cst)
 (declare (xargs :guard (abnf::treep abnf::cst)))
 (declare
  (xargs
   :guard
   (and (cst-matchp abnf::cst
                    "basic-character-not-double-quote-or-backslash")
        (equal (cst-basic-character-not-double-quote-or-backslash-conc?
                    abnf::cst)
               4))))
 (let
  ((__function__
      'cst-basic-character-not-double-quote-or-backslash-conc4-rep))
  (declare (ignorable __function__))
  (abnf::tree-list-fix (nth 0
                            (cst-basic-character-not-double-quote-or-backslash-conc4
                                 abnf::cst)))))

Theorem: tree-listp-of-cst-basic-character-not-double-quote-or-backslash-conc4-rep

(defthm
 tree-listp-of-cst-basic-character-not-double-quote-or-backslash-conc4-rep
 (b* ((abnf::csts (cst-basic-character-not-double-quote-or-backslash-conc4-rep
                       abnf::cst)))
   (abnf::tree-listp abnf::csts))
 :rule-classes :rewrite)

Theorem: cst-basic-character-not-double-quote-or-backslash-conc4-rep-match

(defthm
  cst-basic-character-not-double-quote-or-backslash-conc4-rep-match
 (implies
   (and (cst-matchp abnf::cst
                    "basic-character-not-double-quote-or-backslash")
        (equal (cst-basic-character-not-double-quote-or-backslash-conc?
                    abnf::cst)
               4))
   (b* ((abnf::csts (cst-basic-character-not-double-quote-or-backslash-conc4-rep
                         abnf::cst)))
     (cst-list-rep-matchp abnf::csts "space")))
 :rule-classes :rewrite)

Theorem: cst-basic-character-not-double-quote-or-backslash-conc4-rep-of-tree-fix-cst

(defthm
 cst-basic-character-not-double-quote-or-backslash-conc4-rep-of-tree-fix-cst
 (equal (cst-basic-character-not-double-quote-or-backslash-conc4-rep
             (abnf::tree-fix abnf::cst))
        (cst-basic-character-not-double-quote-or-backslash-conc4-rep
             abnf::cst)))

Theorem: cst-basic-character-not-double-quote-or-backslash-conc4-rep-tree-equiv-congruence-on-cst

(defthm
 cst-basic-character-not-double-quote-or-backslash-conc4-rep-tree-equiv-congruence-on-cst
 (implies (abnf::tree-equiv abnf::cst cst-equiv)
          (equal (cst-basic-character-not-double-quote-or-backslash-conc4-rep
                      abnf::cst)
                 (cst-basic-character-not-double-quote-or-backslash-conc4-rep
                      cst-equiv)))
 :rule-classes :congruence)

Function: cst-basic-character-not-double-quote-or-backslash-conc5-rep

(defun cst-basic-character-not-double-quote-or-backslash-conc5-rep
       (abnf::cst)
 (declare (xargs :guard (abnf::treep abnf::cst)))
 (declare
  (xargs
   :guard
   (and (cst-matchp abnf::cst
                    "basic-character-not-double-quote-or-backslash")
        (equal (cst-basic-character-not-double-quote-or-backslash-conc?
                    abnf::cst)
               5))))
 (let
  ((__function__
      'cst-basic-character-not-double-quote-or-backslash-conc5-rep))
  (declare (ignorable __function__))
  (abnf::tree-list-fix (nth 0
                            (cst-basic-character-not-double-quote-or-backslash-conc5
                                 abnf::cst)))))

Theorem: tree-listp-of-cst-basic-character-not-double-quote-or-backslash-conc5-rep

(defthm
 tree-listp-of-cst-basic-character-not-double-quote-or-backslash-conc5-rep
 (b* ((abnf::csts (cst-basic-character-not-double-quote-or-backslash-conc5-rep
                       abnf::cst)))
   (abnf::tree-listp abnf::csts))
 :rule-classes :rewrite)

Theorem: cst-basic-character-not-double-quote-or-backslash-conc5-rep-match

(defthm
  cst-basic-character-not-double-quote-or-backslash-conc5-rep-match
 (implies
   (and (cst-matchp abnf::cst
                    "basic-character-not-double-quote-or-backslash")
        (equal (cst-basic-character-not-double-quote-or-backslash-conc?
                    abnf::cst)
               5))
   (b* ((abnf::csts (cst-basic-character-not-double-quote-or-backslash-conc5-rep
                         abnf::cst)))
     (cst-list-rep-matchp abnf::csts "control-character")))
 :rule-classes :rewrite)

Theorem: cst-basic-character-not-double-quote-or-backslash-conc5-rep-of-tree-fix-cst

(defthm
 cst-basic-character-not-double-quote-or-backslash-conc5-rep-of-tree-fix-cst
 (equal (cst-basic-character-not-double-quote-or-backslash-conc5-rep
             (abnf::tree-fix abnf::cst))
        (cst-basic-character-not-double-quote-or-backslash-conc5-rep
             abnf::cst)))

Theorem: cst-basic-character-not-double-quote-or-backslash-conc5-rep-tree-equiv-congruence-on-cst

(defthm
 cst-basic-character-not-double-quote-or-backslash-conc5-rep-tree-equiv-congruence-on-cst
 (implies (abnf::tree-equiv abnf::cst cst-equiv)
          (equal (cst-basic-character-not-double-quote-or-backslash-conc5-rep
                      abnf::cst)
                 (cst-basic-character-not-double-quote-or-backslash-conc5-rep
                      cst-equiv)))
 :rule-classes :congruence)

Function: cst-character-not-new-line-conc1-rep

(defun cst-character-not-new-line-conc1-rep (abnf::cst)
 (declare (xargs :guard (abnf::treep abnf::cst)))
 (declare
  (xargs
     :guard (and (cst-matchp abnf::cst "character-not-new-line")
                 (equal (cst-character-not-new-line-conc? abnf::cst)
                        1))))
 (let ((__function__ 'cst-character-not-new-line-conc1-rep))
   (declare (ignorable __function__))
   (abnf::tree-list-fix
        (nth 0
             (cst-character-not-new-line-conc1 abnf::cst)))))

Theorem: tree-listp-of-cst-character-not-new-line-conc1-rep

(defthm tree-listp-of-cst-character-not-new-line-conc1-rep
 (b* ((abnf::csts (cst-character-not-new-line-conc1-rep abnf::cst)))
   (abnf::tree-listp abnf::csts))
 :rule-classes :rewrite)

Theorem: cst-character-not-new-line-conc1-rep-match

(defthm cst-character-not-new-line-conc1-rep-match
 (implies
   (and (cst-matchp abnf::cst "character-not-new-line")
        (equal (cst-character-not-new-line-conc? abnf::cst)
               1))
   (b*
     ((abnf::csts (cst-character-not-new-line-conc1-rep abnf::cst)))
     (cst-list-rep-matchp abnf::csts "basic-character")))
 :rule-classes :rewrite)

Theorem: cst-character-not-new-line-conc1-rep-of-tree-fix-cst

(defthm cst-character-not-new-line-conc1-rep-of-tree-fix-cst
 (equal
   (cst-character-not-new-line-conc1-rep (abnf::tree-fix abnf::cst))
   (cst-character-not-new-line-conc1-rep abnf::cst)))

Theorem: cst-character-not-new-line-conc1-rep-tree-equiv-congruence-on-cst

(defthm
  cst-character-not-new-line-conc1-rep-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-character-not-new-line-conc1-rep abnf::cst)
                  (cst-character-not-new-line-conc1-rep cst-equiv)))
  :rule-classes :congruence)

Function: cst-character-not-new-line-conc2-rep

(defun cst-character-not-new-line-conc2-rep (abnf::cst)
 (declare (xargs :guard (abnf::treep abnf::cst)))
 (declare
  (xargs
     :guard (and (cst-matchp abnf::cst "character-not-new-line")
                 (equal (cst-character-not-new-line-conc? abnf::cst)
                        2))))
 (let ((__function__ 'cst-character-not-new-line-conc2-rep))
   (declare (ignorable __function__))
   (abnf::tree-list-fix
        (nth 0
             (cst-character-not-new-line-conc2 abnf::cst)))))

Theorem: tree-listp-of-cst-character-not-new-line-conc2-rep

(defthm tree-listp-of-cst-character-not-new-line-conc2-rep
 (b* ((abnf::csts (cst-character-not-new-line-conc2-rep abnf::cst)))
   (abnf::tree-listp abnf::csts))
 :rule-classes :rewrite)

Theorem: cst-character-not-new-line-conc2-rep-match

(defthm cst-character-not-new-line-conc2-rep-match
 (implies
   (and (cst-matchp abnf::cst "character-not-new-line")
        (equal (cst-character-not-new-line-conc? abnf::cst)
               2))
   (b*
     ((abnf::csts (cst-character-not-new-line-conc2-rep abnf::cst)))
     (cst-list-rep-matchp abnf::csts
                          "extended-character-not-new-line")))
 :rule-classes :rewrite)

Theorem: cst-character-not-new-line-conc2-rep-of-tree-fix-cst

(defthm cst-character-not-new-line-conc2-rep-of-tree-fix-cst
 (equal
   (cst-character-not-new-line-conc2-rep (abnf::tree-fix abnf::cst))
   (cst-character-not-new-line-conc2-rep abnf::cst)))

Theorem: cst-character-not-new-line-conc2-rep-tree-equiv-congruence-on-cst

(defthm
  cst-character-not-new-line-conc2-rep-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-character-not-new-line-conc2-rep abnf::cst)
                  (cst-character-not-new-line-conc2-rep cst-equiv)))
  :rule-classes :congruence)

Function: cst-character-not-star-conc1-rep

(defun cst-character-not-star-conc1-rep (abnf::cst)
 (declare (xargs :guard (abnf::treep abnf::cst)))
 (declare
  (xargs :guard (and (cst-matchp abnf::cst "character-not-star")
                     (equal (cst-character-not-star-conc? abnf::cst)
                            1))))
 (let ((__function__ 'cst-character-not-star-conc1-rep))
   (declare (ignorable __function__))
   (abnf::tree-list-fix
        (nth 0
             (cst-character-not-star-conc1 abnf::cst)))))

Theorem: tree-listp-of-cst-character-not-star-conc1-rep

(defthm tree-listp-of-cst-character-not-star-conc1-rep
  (b* ((abnf::csts (cst-character-not-star-conc1-rep abnf::cst)))
    (abnf::tree-listp abnf::csts))
  :rule-classes :rewrite)

Theorem: cst-character-not-star-conc1-rep-match

(defthm cst-character-not-star-conc1-rep-match
 (implies
     (and (cst-matchp abnf::cst "character-not-star")
          (equal (cst-character-not-star-conc? abnf::cst)
                 1))
     (b* ((abnf::csts (cst-character-not-star-conc1-rep abnf::cst)))
       (cst-list-rep-matchp abnf::csts "basic-character-not-star")))
 :rule-classes :rewrite)

Theorem: cst-character-not-star-conc1-rep-of-tree-fix-cst

(defthm cst-character-not-star-conc1-rep-of-tree-fix-cst
  (equal
       (cst-character-not-star-conc1-rep (abnf::tree-fix abnf::cst))
       (cst-character-not-star-conc1-rep abnf::cst)))

Theorem: cst-character-not-star-conc1-rep-tree-equiv-congruence-on-cst

(defthm
      cst-character-not-star-conc1-rep-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-character-not-star-conc1-rep abnf::cst)
                  (cst-character-not-star-conc1-rep cst-equiv)))
  :rule-classes :congruence)

Function: cst-character-not-star-conc2-rep

(defun cst-character-not-star-conc2-rep (abnf::cst)
 (declare (xargs :guard (abnf::treep abnf::cst)))
 (declare
  (xargs :guard (and (cst-matchp abnf::cst "character-not-star")
                     (equal (cst-character-not-star-conc? abnf::cst)
                            2))))
 (let ((__function__ 'cst-character-not-star-conc2-rep))
   (declare (ignorable __function__))
   (abnf::tree-list-fix
        (nth 0
             (cst-character-not-star-conc2 abnf::cst)))))

Theorem: tree-listp-of-cst-character-not-star-conc2-rep

(defthm tree-listp-of-cst-character-not-star-conc2-rep
  (b* ((abnf::csts (cst-character-not-star-conc2-rep abnf::cst)))
    (abnf::tree-listp abnf::csts))
  :rule-classes :rewrite)

Theorem: cst-character-not-star-conc2-rep-match

(defthm cst-character-not-star-conc2-rep-match
 (implies
     (and (cst-matchp abnf::cst "character-not-star")
          (equal (cst-character-not-star-conc? abnf::cst)
                 2))
     (b* ((abnf::csts (cst-character-not-star-conc2-rep abnf::cst)))
       (cst-list-rep-matchp abnf::csts "extended-character")))
 :rule-classes :rewrite)

Theorem: cst-character-not-star-conc2-rep-of-tree-fix-cst

(defthm cst-character-not-star-conc2-rep-of-tree-fix-cst
  (equal
       (cst-character-not-star-conc2-rep (abnf::tree-fix abnf::cst))
       (cst-character-not-star-conc2-rep abnf::cst)))

Theorem: cst-character-not-star-conc2-rep-tree-equiv-congruence-on-cst

(defthm
      cst-character-not-star-conc2-rep-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-character-not-star-conc2-rep abnf::cst)
                  (cst-character-not-star-conc2-rep cst-equiv)))
  :rule-classes :congruence)

Function: cst-character-not-star-or-slash-conc1-rep

(defun cst-character-not-star-or-slash-conc1-rep (abnf::cst)
 (declare (xargs :guard (abnf::treep abnf::cst)))
 (declare
  (xargs
       :guard
       (and (cst-matchp abnf::cst "character-not-star-or-slash")
            (equal (cst-character-not-star-or-slash-conc? abnf::cst)
                   1))))
 (let ((__function__ 'cst-character-not-star-or-slash-conc1-rep))
   (declare (ignorable __function__))
   (abnf::tree-list-fix
        (nth 0
             (cst-character-not-star-or-slash-conc1 abnf::cst)))))

Theorem: tree-listp-of-cst-character-not-star-or-slash-conc1-rep

(defthm tree-listp-of-cst-character-not-star-or-slash-conc1-rep
  (b* ((abnf::csts
            (cst-character-not-star-or-slash-conc1-rep abnf::cst)))
    (abnf::tree-listp abnf::csts))
  :rule-classes :rewrite)

Theorem: cst-character-not-star-or-slash-conc1-rep-match

(defthm cst-character-not-star-or-slash-conc1-rep-match
 (implies
   (and (cst-matchp abnf::cst "character-not-star-or-slash")
        (equal (cst-character-not-star-or-slash-conc? abnf::cst)
               1))
   (b* ((abnf::csts
             (cst-character-not-star-or-slash-conc1-rep abnf::cst)))
     (cst-list-rep-matchp abnf::csts
                          "basic-character-not-star-or-slash")))
 :rule-classes :rewrite)

Theorem: cst-character-not-star-or-slash-conc1-rep-of-tree-fix-cst

(defthm cst-character-not-star-or-slash-conc1-rep-of-tree-fix-cst
  (equal (cst-character-not-star-or-slash-conc1-rep
              (abnf::tree-fix abnf::cst))
         (cst-character-not-star-or-slash-conc1-rep abnf::cst)))

Theorem: cst-character-not-star-or-slash-conc1-rep-tree-equiv-congruence-on-cst

(defthm
 cst-character-not-star-or-slash-conc1-rep-tree-equiv-congruence-on-cst
 (implies
      (abnf::tree-equiv abnf::cst cst-equiv)
      (equal (cst-character-not-star-or-slash-conc1-rep abnf::cst)
             (cst-character-not-star-or-slash-conc1-rep cst-equiv)))
 :rule-classes :congruence)

Function: cst-character-not-star-or-slash-conc2-rep

(defun cst-character-not-star-or-slash-conc2-rep (abnf::cst)
 (declare (xargs :guard (abnf::treep abnf::cst)))
 (declare
  (xargs
       :guard
       (and (cst-matchp abnf::cst "character-not-star-or-slash")
            (equal (cst-character-not-star-or-slash-conc? abnf::cst)
                   2))))
 (let ((__function__ 'cst-character-not-star-or-slash-conc2-rep))
   (declare (ignorable __function__))
   (abnf::tree-list-fix
        (nth 0
             (cst-character-not-star-or-slash-conc2 abnf::cst)))))

Theorem: tree-listp-of-cst-character-not-star-or-slash-conc2-rep

(defthm tree-listp-of-cst-character-not-star-or-slash-conc2-rep
  (b* ((abnf::csts
            (cst-character-not-star-or-slash-conc2-rep abnf::cst)))
    (abnf::tree-listp abnf::csts))
  :rule-classes :rewrite)

Theorem: cst-character-not-star-or-slash-conc2-rep-match

(defthm cst-character-not-star-or-slash-conc2-rep-match
 (implies
   (and (cst-matchp abnf::cst "character-not-star-or-slash")
        (equal (cst-character-not-star-or-slash-conc? abnf::cst)
               2))
   (b* ((abnf::csts
             (cst-character-not-star-or-slash-conc2-rep abnf::cst)))
     (cst-list-rep-matchp abnf::csts "extended-character")))
 :rule-classes :rewrite)

Theorem: cst-character-not-star-or-slash-conc2-rep-of-tree-fix-cst

(defthm cst-character-not-star-or-slash-conc2-rep-of-tree-fix-cst
  (equal (cst-character-not-star-or-slash-conc2-rep
              (abnf::tree-fix abnf::cst))
         (cst-character-not-star-or-slash-conc2-rep abnf::cst)))

Theorem: cst-character-not-star-or-slash-conc2-rep-tree-equiv-congruence-on-cst

(defthm
 cst-character-not-star-or-slash-conc2-rep-tree-equiv-congruence-on-cst
 (implies
      (abnf::tree-equiv abnf::cst cst-equiv)
      (equal (cst-character-not-star-or-slash-conc2-rep abnf::cst)
             (cst-character-not-star-or-slash-conc2-rep cst-equiv)))
 :rule-classes :congruence)

Function: cst-character-not-greater-than-or-new-line-conc1-rep

(defun cst-character-not-greater-than-or-new-line-conc1-rep
       (abnf::cst)
 (declare (xargs :guard (abnf::treep abnf::cst)))
 (declare
  (xargs
   :guard
   (and
    (cst-matchp abnf::cst
                "character-not-greater-than-or-new-line")
    (equal
        (cst-character-not-greater-than-or-new-line-conc? abnf::cst)
        1))))
 (let ((__function__
            'cst-character-not-greater-than-or-new-line-conc1-rep))
  (declare (ignorable __function__))
  (abnf::tree-list-fix
   (nth
    0
    (cst-character-not-greater-than-or-new-line-conc1 abnf::cst)))))

Theorem: tree-listp-of-cst-character-not-greater-than-or-new-line-conc1-rep

(defthm
 tree-listp-of-cst-character-not-greater-than-or-new-line-conc1-rep
 (b* ((abnf::csts (cst-character-not-greater-than-or-new-line-conc1-rep
                       abnf::cst)))
   (abnf::tree-listp abnf::csts))
 :rule-classes :rewrite)

Theorem: cst-character-not-greater-than-or-new-line-conc1-rep-match

(defthm cst-character-not-greater-than-or-new-line-conc1-rep-match
 (implies
  (and
   (cst-matchp abnf::cst
               "character-not-greater-than-or-new-line")
   (equal
        (cst-character-not-greater-than-or-new-line-conc? abnf::cst)
        1))
  (b* ((abnf::csts (cst-character-not-greater-than-or-new-line-conc1-rep
                        abnf::cst)))
    (cst-list-rep-matchp abnf::csts
                         "basic-character-not-greater-than")))
 :rule-classes :rewrite)

Theorem: cst-character-not-greater-than-or-new-line-conc1-rep-of-tree-fix-cst

(defthm
 cst-character-not-greater-than-or-new-line-conc1-rep-of-tree-fix-cst
 (equal
  (cst-character-not-greater-than-or-new-line-conc1-rep
       (abnf::tree-fix abnf::cst))
  (cst-character-not-greater-than-or-new-line-conc1-rep abnf::cst)))

Theorem: cst-character-not-greater-than-or-new-line-conc1-rep-tree-equiv-congruence-on-cst

(defthm
 cst-character-not-greater-than-or-new-line-conc1-rep-tree-equiv-congruence-on-cst
 (implies
  (abnf::tree-equiv abnf::cst cst-equiv)
  (equal
    (cst-character-not-greater-than-or-new-line-conc1-rep abnf::cst)
    (cst-character-not-greater-than-or-new-line-conc1-rep
         cst-equiv)))
 :rule-classes :congruence)

Function: cst-character-not-greater-than-or-new-line-conc2-rep

(defun cst-character-not-greater-than-or-new-line-conc2-rep
       (abnf::cst)
 (declare (xargs :guard (abnf::treep abnf::cst)))
 (declare
  (xargs
   :guard
   (and
    (cst-matchp abnf::cst
                "character-not-greater-than-or-new-line")
    (equal
        (cst-character-not-greater-than-or-new-line-conc? abnf::cst)
        2))))
 (let ((__function__
            'cst-character-not-greater-than-or-new-line-conc2-rep))
  (declare (ignorable __function__))
  (abnf::tree-list-fix
   (nth
    0
    (cst-character-not-greater-than-or-new-line-conc2 abnf::cst)))))

Theorem: tree-listp-of-cst-character-not-greater-than-or-new-line-conc2-rep

(defthm
 tree-listp-of-cst-character-not-greater-than-or-new-line-conc2-rep
 (b* ((abnf::csts (cst-character-not-greater-than-or-new-line-conc2-rep
                       abnf::cst)))
   (abnf::tree-listp abnf::csts))
 :rule-classes :rewrite)

Theorem: cst-character-not-greater-than-or-new-line-conc2-rep-match

(defthm cst-character-not-greater-than-or-new-line-conc2-rep-match
 (implies
  (and
   (cst-matchp abnf::cst
               "character-not-greater-than-or-new-line")
   (equal
        (cst-character-not-greater-than-or-new-line-conc? abnf::cst)
        2))
  (b* ((abnf::csts (cst-character-not-greater-than-or-new-line-conc2-rep
                        abnf::cst)))
    (cst-list-rep-matchp abnf::csts
                         "extended-character-not-new-line")))
 :rule-classes :rewrite)

Theorem: cst-character-not-greater-than-or-new-line-conc2-rep-of-tree-fix-cst

(defthm
 cst-character-not-greater-than-or-new-line-conc2-rep-of-tree-fix-cst
 (equal
  (cst-character-not-greater-than-or-new-line-conc2-rep
       (abnf::tree-fix abnf::cst))
  (cst-character-not-greater-than-or-new-line-conc2-rep abnf::cst)))

Theorem: cst-character-not-greater-than-or-new-line-conc2-rep-tree-equiv-congruence-on-cst

(defthm
 cst-character-not-greater-than-or-new-line-conc2-rep-tree-equiv-congruence-on-cst
 (implies
  (abnf::tree-equiv abnf::cst cst-equiv)
  (equal
    (cst-character-not-greater-than-or-new-line-conc2-rep abnf::cst)
    (cst-character-not-greater-than-or-new-line-conc2-rep
         cst-equiv)))
 :rule-classes :congruence)

Function: cst-character-not-double-quote-or-new-line-conc1-rep

(defun cst-character-not-double-quote-or-new-line-conc1-rep
       (abnf::cst)
 (declare (xargs :guard (abnf::treep abnf::cst)))
 (declare
  (xargs
   :guard
   (and
    (cst-matchp abnf::cst
                "character-not-double-quote-or-new-line")
    (equal
        (cst-character-not-double-quote-or-new-line-conc? abnf::cst)
        1))))
 (let ((__function__
            'cst-character-not-double-quote-or-new-line-conc1-rep))
  (declare (ignorable __function__))
  (abnf::tree-list-fix
   (nth
    0
    (cst-character-not-double-quote-or-new-line-conc1 abnf::cst)))))

Theorem: tree-listp-of-cst-character-not-double-quote-or-new-line-conc1-rep

(defthm
 tree-listp-of-cst-character-not-double-quote-or-new-line-conc1-rep
 (b* ((abnf::csts (cst-character-not-double-quote-or-new-line-conc1-rep
                       abnf::cst)))
   (abnf::tree-listp abnf::csts))
 :rule-classes :rewrite)

Theorem: cst-character-not-double-quote-or-new-line-conc1-rep-match

(defthm cst-character-not-double-quote-or-new-line-conc1-rep-match
 (implies
  (and
   (cst-matchp abnf::cst
               "character-not-double-quote-or-new-line")
   (equal
        (cst-character-not-double-quote-or-new-line-conc? abnf::cst)
        1))
  (b* ((abnf::csts (cst-character-not-double-quote-or-new-line-conc1-rep
                        abnf::cst)))
    (cst-list-rep-matchp abnf::csts
                         "basic-character-not-double-quote")))
 :rule-classes :rewrite)

Theorem: cst-character-not-double-quote-or-new-line-conc1-rep-of-tree-fix-cst

(defthm
 cst-character-not-double-quote-or-new-line-conc1-rep-of-tree-fix-cst
 (equal
  (cst-character-not-double-quote-or-new-line-conc1-rep
       (abnf::tree-fix abnf::cst))
  (cst-character-not-double-quote-or-new-line-conc1-rep abnf::cst)))

Theorem: cst-character-not-double-quote-or-new-line-conc1-rep-tree-equiv-congruence-on-cst

(defthm
 cst-character-not-double-quote-or-new-line-conc1-rep-tree-equiv-congruence-on-cst
 (implies
  (abnf::tree-equiv abnf::cst cst-equiv)
  (equal
    (cst-character-not-double-quote-or-new-line-conc1-rep abnf::cst)
    (cst-character-not-double-quote-or-new-line-conc1-rep
         cst-equiv)))
 :rule-classes :congruence)

Function: cst-character-not-double-quote-or-new-line-conc2-rep

(defun cst-character-not-double-quote-or-new-line-conc2-rep
       (abnf::cst)
 (declare (xargs :guard (abnf::treep abnf::cst)))
 (declare
  (xargs
   :guard
   (and
    (cst-matchp abnf::cst
                "character-not-double-quote-or-new-line")
    (equal
        (cst-character-not-double-quote-or-new-line-conc? abnf::cst)
        2))))
 (let ((__function__
            'cst-character-not-double-quote-or-new-line-conc2-rep))
  (declare (ignorable __function__))
  (abnf::tree-list-fix
   (nth
    0
    (cst-character-not-double-quote-or-new-line-conc2 abnf::cst)))))

Theorem: tree-listp-of-cst-character-not-double-quote-or-new-line-conc2-rep

(defthm
 tree-listp-of-cst-character-not-double-quote-or-new-line-conc2-rep
 (b* ((abnf::csts (cst-character-not-double-quote-or-new-line-conc2-rep
                       abnf::cst)))
   (abnf::tree-listp abnf::csts))
 :rule-classes :rewrite)

Theorem: cst-character-not-double-quote-or-new-line-conc2-rep-match

(defthm cst-character-not-double-quote-or-new-line-conc2-rep-match
 (implies
  (and
   (cst-matchp abnf::cst
               "character-not-double-quote-or-new-line")
   (equal
        (cst-character-not-double-quote-or-new-line-conc? abnf::cst)
        2))
  (b* ((abnf::csts (cst-character-not-double-quote-or-new-line-conc2-rep
                        abnf::cst)))
    (cst-list-rep-matchp abnf::csts
                         "extended-character-not-new-line")))
 :rule-classes :rewrite)

Theorem: cst-character-not-double-quote-or-new-line-conc2-rep-of-tree-fix-cst

(defthm
 cst-character-not-double-quote-or-new-line-conc2-rep-of-tree-fix-cst
 (equal
  (cst-character-not-double-quote-or-new-line-conc2-rep
       (abnf::tree-fix abnf::cst))
  (cst-character-not-double-quote-or-new-line-conc2-rep abnf::cst)))

Theorem: cst-character-not-double-quote-or-new-line-conc2-rep-tree-equiv-congruence-on-cst

(defthm
 cst-character-not-double-quote-or-new-line-conc2-rep-tree-equiv-congruence-on-cst
 (implies
  (abnf::tree-equiv abnf::cst cst-equiv)
  (equal
    (cst-character-not-double-quote-or-new-line-conc2-rep abnf::cst)
    (cst-character-not-double-quote-or-new-line-conc2-rep
         cst-equiv)))
 :rule-classes :congruence)

Function: cst-character-not-single-quote-or-backslash-or-new-line-conc1-rep

(defun
  cst-character-not-single-quote-or-backslash-or-new-line-conc1-rep
  (abnf::cst)
 (declare (xargs :guard (abnf::treep abnf::cst)))
 (declare
  (xargs
    :guard
    (and (cst-matchp
              abnf::cst
              "character-not-single-quote-or-backslash-or-new-line")
         (equal (cst-character-not-single-quote-or-backslash-or-new-line-conc?
                     abnf::cst)
                1))))
 (let
  ((__function__
    'cst-character-not-single-quote-or-backslash-or-new-line-conc1-rep))
  (declare (ignorable __function__))
  (abnf::tree-list-fix (nth 0
                            (cst-character-not-single-quote-or-backslash-or-new-line-conc1
                                 abnf::cst)))))

Theorem: tree-listp-of-cst-character-not-single-quote-or-backslash-or-new-line-conc1-rep

(defthm
 tree-listp-of-cst-character-not-single-quote-or-backslash-or-new-line-conc1-rep
 (b* ((abnf::csts (cst-character-not-single-quote-or-backslash-or-new-line-conc1-rep
                       abnf::cst)))
   (abnf::tree-listp abnf::csts))
 :rule-classes :rewrite)

Theorem: cst-character-not-single-quote-or-backslash-or-new-line-conc1-rep-match

(defthm
 cst-character-not-single-quote-or-backslash-or-new-line-conc1-rep-match
 (implies
    (and (cst-matchp
              abnf::cst
              "character-not-single-quote-or-backslash-or-new-line")
         (equal (cst-character-not-single-quote-or-backslash-or-new-line-conc?
                     abnf::cst)
                1))
    (b* ((abnf::csts (cst-character-not-single-quote-or-backslash-or-new-line-conc1-rep
                          abnf::cst)))
      (cst-list-rep-matchp
           abnf::csts
           "basic-character-not-single-quote-or-backslash")))
 :rule-classes :rewrite)

Theorem: cst-character-not-single-quote-or-backslash-or-new-line-conc1-rep-of-tree-fix-cst

(defthm
 cst-character-not-single-quote-or-backslash-or-new-line-conc1-rep-of-tree-fix-cst
 (equal (cst-character-not-single-quote-or-backslash-or-new-line-conc1-rep
             (abnf::tree-fix abnf::cst))
        (cst-character-not-single-quote-or-backslash-or-new-line-conc1-rep
             abnf::cst)))

Theorem: cst-character-not-single-quote-or-backslash-or-new-line-conc1-rep-tree-equiv-congruence-on-cst

(defthm
 cst-character-not-single-quote-or-backslash-or-new-line-conc1-rep-tree-equiv-congruence-on-cst
 (implies (abnf::tree-equiv abnf::cst cst-equiv)
          (equal (cst-character-not-single-quote-or-backslash-or-new-line-conc1-rep
                      abnf::cst)
                 (cst-character-not-single-quote-or-backslash-or-new-line-conc1-rep
                      cst-equiv)))
 :rule-classes :congruence)

Function: cst-character-not-single-quote-or-backslash-or-new-line-conc2-rep

(defun
  cst-character-not-single-quote-or-backslash-or-new-line-conc2-rep
  (abnf::cst)
 (declare (xargs :guard (abnf::treep abnf::cst)))
 (declare
  (xargs
    :guard
    (and (cst-matchp
              abnf::cst
              "character-not-single-quote-or-backslash-or-new-line")
         (equal (cst-character-not-single-quote-or-backslash-or-new-line-conc?
                     abnf::cst)
                2))))
 (let
  ((__function__
    'cst-character-not-single-quote-or-backslash-or-new-line-conc2-rep))
  (declare (ignorable __function__))
  (abnf::tree-list-fix (nth 0
                            (cst-character-not-single-quote-or-backslash-or-new-line-conc2
                                 abnf::cst)))))

Theorem: tree-listp-of-cst-character-not-single-quote-or-backslash-or-new-line-conc2-rep

(defthm
 tree-listp-of-cst-character-not-single-quote-or-backslash-or-new-line-conc2-rep
 (b* ((abnf::csts (cst-character-not-single-quote-or-backslash-or-new-line-conc2-rep
                       abnf::cst)))
   (abnf::tree-listp abnf::csts))
 :rule-classes :rewrite)

Theorem: cst-character-not-single-quote-or-backslash-or-new-line-conc2-rep-match

(defthm
 cst-character-not-single-quote-or-backslash-or-new-line-conc2-rep-match
 (implies
    (and (cst-matchp
              abnf::cst
              "character-not-single-quote-or-backslash-or-new-line")
         (equal (cst-character-not-single-quote-or-backslash-or-new-line-conc?
                     abnf::cst)
                2))
    (b* ((abnf::csts (cst-character-not-single-quote-or-backslash-or-new-line-conc2-rep
                          abnf::cst)))
      (cst-list-rep-matchp abnf::csts
                           "extended-character-not-new-line")))
 :rule-classes :rewrite)

Theorem: cst-character-not-single-quote-or-backslash-or-new-line-conc2-rep-of-tree-fix-cst

(defthm
 cst-character-not-single-quote-or-backslash-or-new-line-conc2-rep-of-tree-fix-cst
 (equal (cst-character-not-single-quote-or-backslash-or-new-line-conc2-rep
             (abnf::tree-fix abnf::cst))
        (cst-character-not-single-quote-or-backslash-or-new-line-conc2-rep
             abnf::cst)))

Theorem: cst-character-not-single-quote-or-backslash-or-new-line-conc2-rep-tree-equiv-congruence-on-cst

(defthm
 cst-character-not-single-quote-or-backslash-or-new-line-conc2-rep-tree-equiv-congruence-on-cst
 (implies (abnf::tree-equiv abnf::cst cst-equiv)
          (equal (cst-character-not-single-quote-or-backslash-or-new-line-conc2-rep
                      abnf::cst)
                 (cst-character-not-single-quote-or-backslash-or-new-line-conc2-rep
                      cst-equiv)))
 :rule-classes :congruence)

Function: cst-character-not-double-quote-or-backslash-or-new-line-conc1-rep

(defun
  cst-character-not-double-quote-or-backslash-or-new-line-conc1-rep
  (abnf::cst)
 (declare (xargs :guard (abnf::treep abnf::cst)))
 (declare
  (xargs
    :guard
    (and (cst-matchp
              abnf::cst
              "character-not-double-quote-or-backslash-or-new-line")
         (equal (cst-character-not-double-quote-or-backslash-or-new-line-conc?
                     abnf::cst)
                1))))
 (let
  ((__function__
    'cst-character-not-double-quote-or-backslash-or-new-line-conc1-rep))
  (declare (ignorable __function__))
  (abnf::tree-list-fix (nth 0
                            (cst-character-not-double-quote-or-backslash-or-new-line-conc1
                                 abnf::cst)))))

Theorem: tree-listp-of-cst-character-not-double-quote-or-backslash-or-new-line-conc1-rep

(defthm
 tree-listp-of-cst-character-not-double-quote-or-backslash-or-new-line-conc1-rep
 (b* ((abnf::csts (cst-character-not-double-quote-or-backslash-or-new-line-conc1-rep
                       abnf::cst)))
   (abnf::tree-listp abnf::csts))
 :rule-classes :rewrite)

Theorem: cst-character-not-double-quote-or-backslash-or-new-line-conc1-rep-match

(defthm
 cst-character-not-double-quote-or-backslash-or-new-line-conc1-rep-match
 (implies
    (and (cst-matchp
              abnf::cst
              "character-not-double-quote-or-backslash-or-new-line")
         (equal (cst-character-not-double-quote-or-backslash-or-new-line-conc?
                     abnf::cst)
                1))
    (b* ((abnf::csts (cst-character-not-double-quote-or-backslash-or-new-line-conc1-rep
                          abnf::cst)))
      (cst-list-rep-matchp
           abnf::csts
           "basic-character-not-double-quote-or-backslash")))
 :rule-classes :rewrite)

Theorem: cst-character-not-double-quote-or-backslash-or-new-line-conc1-rep-of-tree-fix-cst

(defthm
 cst-character-not-double-quote-or-backslash-or-new-line-conc1-rep-of-tree-fix-cst
 (equal (cst-character-not-double-quote-or-backslash-or-new-line-conc1-rep
             (abnf::tree-fix abnf::cst))
        (cst-character-not-double-quote-or-backslash-or-new-line-conc1-rep
             abnf::cst)))

Theorem: cst-character-not-double-quote-or-backslash-or-new-line-conc1-rep-tree-equiv-congruence-on-cst

(defthm
 cst-character-not-double-quote-or-backslash-or-new-line-conc1-rep-tree-equiv-congruence-on-cst
 (implies (abnf::tree-equiv abnf::cst cst-equiv)
          (equal (cst-character-not-double-quote-or-backslash-or-new-line-conc1-rep
                      abnf::cst)
                 (cst-character-not-double-quote-or-backslash-or-new-line-conc1-rep
                      cst-equiv)))
 :rule-classes :congruence)

Function: cst-character-not-double-quote-or-backslash-or-new-line-conc2-rep

(defun
  cst-character-not-double-quote-or-backslash-or-new-line-conc2-rep
  (abnf::cst)
 (declare (xargs :guard (abnf::treep abnf::cst)))
 (declare
  (xargs
    :guard
    (and (cst-matchp
              abnf::cst
              "character-not-double-quote-or-backslash-or-new-line")
         (equal (cst-character-not-double-quote-or-backslash-or-new-line-conc?
                     abnf::cst)
                2))))
 (let
  ((__function__
    'cst-character-not-double-quote-or-backslash-or-new-line-conc2-rep))
  (declare (ignorable __function__))
  (abnf::tree-list-fix (nth 0
                            (cst-character-not-double-quote-or-backslash-or-new-line-conc2
                                 abnf::cst)))))

Theorem: tree-listp-of-cst-character-not-double-quote-or-backslash-or-new-line-conc2-rep

(defthm
 tree-listp-of-cst-character-not-double-quote-or-backslash-or-new-line-conc2-rep
 (b* ((abnf::csts (cst-character-not-double-quote-or-backslash-or-new-line-conc2-rep
                       abnf::cst)))
   (abnf::tree-listp abnf::csts))
 :rule-classes :rewrite)

Theorem: cst-character-not-double-quote-or-backslash-or-new-line-conc2-rep-match

(defthm
 cst-character-not-double-quote-or-backslash-or-new-line-conc2-rep-match
 (implies
    (and (cst-matchp
              abnf::cst
              "character-not-double-quote-or-backslash-or-new-line")
         (equal (cst-character-not-double-quote-or-backslash-or-new-line-conc?
                     abnf::cst)
                2))
    (b* ((abnf::csts (cst-character-not-double-quote-or-backslash-or-new-line-conc2-rep
                          abnf::cst)))
      (cst-list-rep-matchp abnf::csts
                           "extended-character-not-new-line")))
 :rule-classes :rewrite)

Theorem: cst-character-not-double-quote-or-backslash-or-new-line-conc2-rep-of-tree-fix-cst

(defthm
 cst-character-not-double-quote-or-backslash-or-new-line-conc2-rep-of-tree-fix-cst
 (equal (cst-character-not-double-quote-or-backslash-or-new-line-conc2-rep
             (abnf::tree-fix abnf::cst))
        (cst-character-not-double-quote-or-backslash-or-new-line-conc2-rep
             abnf::cst)))

Theorem: cst-character-not-double-quote-or-backslash-or-new-line-conc2-rep-tree-equiv-congruence-on-cst

(defthm
 cst-character-not-double-quote-or-backslash-or-new-line-conc2-rep-tree-equiv-congruence-on-cst
 (implies (abnf::tree-equiv abnf::cst cst-equiv)
          (equal (cst-character-not-double-quote-or-backslash-or-new-line-conc2-rep
                      abnf::cst)
                 (cst-character-not-double-quote-or-backslash-or-new-line-conc2-rep
                      cst-equiv)))
 :rule-classes :congruence)

Function: cst-white-space-conc1-rep

(defun cst-white-space-conc1-rep (abnf::cst)
 (declare (xargs :guard (abnf::treep abnf::cst)))
 (declare
      (xargs :guard (and (cst-matchp abnf::cst "white-space")
                         (equal (cst-white-space-conc? abnf::cst)
                                1))))
 (let ((__function__ 'cst-white-space-conc1-rep))
   (declare (ignorable __function__))
   (abnf::tree-list-fix (nth 0 (cst-white-space-conc1 abnf::cst)))))

Theorem: tree-listp-of-cst-white-space-conc1-rep

(defthm tree-listp-of-cst-white-space-conc1-rep
  (b* ((abnf::csts (cst-white-space-conc1-rep abnf::cst)))
    (abnf::tree-listp abnf::csts))
  :rule-classes :rewrite)

Theorem: cst-white-space-conc1-rep-match

(defthm cst-white-space-conc1-rep-match
  (implies (and (cst-matchp abnf::cst "white-space")
                (equal (cst-white-space-conc? abnf::cst)
                       1))
           (b* ((abnf::csts (cst-white-space-conc1-rep abnf::cst)))
             (cst-list-rep-matchp abnf::csts "space")))
  :rule-classes :rewrite)

Theorem: cst-white-space-conc1-rep-of-tree-fix-cst

(defthm cst-white-space-conc1-rep-of-tree-fix-cst
  (equal (cst-white-space-conc1-rep (abnf::tree-fix abnf::cst))
         (cst-white-space-conc1-rep abnf::cst)))

Theorem: cst-white-space-conc1-rep-tree-equiv-congruence-on-cst

(defthm cst-white-space-conc1-rep-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-white-space-conc1-rep abnf::cst)
                  (cst-white-space-conc1-rep cst-equiv)))
  :rule-classes :congruence)

Function: cst-white-space-conc2-rep

(defun cst-white-space-conc2-rep (abnf::cst)
 (declare (xargs :guard (abnf::treep abnf::cst)))
 (declare
      (xargs :guard (and (cst-matchp abnf::cst "white-space")
                         (equal (cst-white-space-conc? abnf::cst)
                                2))))
 (let ((__function__ 'cst-white-space-conc2-rep))
   (declare (ignorable __function__))
   (abnf::tree-list-fix (nth 0 (cst-white-space-conc2 abnf::cst)))))

Theorem: tree-listp-of-cst-white-space-conc2-rep

(defthm tree-listp-of-cst-white-space-conc2-rep
  (b* ((abnf::csts (cst-white-space-conc2-rep abnf::cst)))
    (abnf::tree-listp abnf::csts))
  :rule-classes :rewrite)

Theorem: cst-white-space-conc2-rep-match

(defthm cst-white-space-conc2-rep-match
  (implies (and (cst-matchp abnf::cst "white-space")
                (equal (cst-white-space-conc? abnf::cst)
                       2))
           (b* ((abnf::csts (cst-white-space-conc2-rep abnf::cst)))
             (cst-list-rep-matchp abnf::csts "horizontal-tab")))
  :rule-classes :rewrite)

Theorem: cst-white-space-conc2-rep-of-tree-fix-cst

(defthm cst-white-space-conc2-rep-of-tree-fix-cst
  (equal (cst-white-space-conc2-rep (abnf::tree-fix abnf::cst))
         (cst-white-space-conc2-rep abnf::cst)))

Theorem: cst-white-space-conc2-rep-tree-equiv-congruence-on-cst

(defthm cst-white-space-conc2-rep-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-white-space-conc2-rep abnf::cst)
                  (cst-white-space-conc2-rep cst-equiv)))
  :rule-classes :congruence)

Function: cst-white-space-conc3-rep

(defun cst-white-space-conc3-rep (abnf::cst)
 (declare (xargs :guard (abnf::treep abnf::cst)))
 (declare
      (xargs :guard (and (cst-matchp abnf::cst "white-space")
                         (equal (cst-white-space-conc? abnf::cst)
                                3))))
 (let ((__function__ 'cst-white-space-conc3-rep))
   (declare (ignorable __function__))
   (abnf::tree-list-fix (nth 0 (cst-white-space-conc3 abnf::cst)))))

Theorem: tree-listp-of-cst-white-space-conc3-rep

(defthm tree-listp-of-cst-white-space-conc3-rep
  (b* ((abnf::csts (cst-white-space-conc3-rep abnf::cst)))
    (abnf::tree-listp abnf::csts))
  :rule-classes :rewrite)

Theorem: cst-white-space-conc3-rep-match

(defthm cst-white-space-conc3-rep-match
  (implies (and (cst-matchp abnf::cst "white-space")
                (equal (cst-white-space-conc? abnf::cst)
                       3))
           (b* ((abnf::csts (cst-white-space-conc3-rep abnf::cst)))
             (cst-list-rep-matchp abnf::csts "vertical-tab")))
  :rule-classes :rewrite)

Theorem: cst-white-space-conc3-rep-of-tree-fix-cst

(defthm cst-white-space-conc3-rep-of-tree-fix-cst
  (equal (cst-white-space-conc3-rep (abnf::tree-fix abnf::cst))
         (cst-white-space-conc3-rep abnf::cst)))

Theorem: cst-white-space-conc3-rep-tree-equiv-congruence-on-cst

(defthm cst-white-space-conc3-rep-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-white-space-conc3-rep abnf::cst)
                  (cst-white-space-conc3-rep cst-equiv)))
  :rule-classes :congruence)

Function: cst-white-space-conc4-rep

(defun cst-white-space-conc4-rep (abnf::cst)
 (declare (xargs :guard (abnf::treep abnf::cst)))
 (declare
      (xargs :guard (and (cst-matchp abnf::cst "white-space")
                         (equal (cst-white-space-conc? abnf::cst)
                                4))))
 (let ((__function__ 'cst-white-space-conc4-rep))
   (declare (ignorable __function__))
   (abnf::tree-list-fix (nth 0 (cst-white-space-conc4 abnf::cst)))))

Theorem: tree-listp-of-cst-white-space-conc4-rep

(defthm tree-listp-of-cst-white-space-conc4-rep
  (b* ((abnf::csts (cst-white-space-conc4-rep abnf::cst)))
    (abnf::tree-listp abnf::csts))
  :rule-classes :rewrite)

Theorem: cst-white-space-conc4-rep-match

(defthm cst-white-space-conc4-rep-match
  (implies (and (cst-matchp abnf::cst "white-space")
                (equal (cst-white-space-conc? abnf::cst)
                       4))
           (b* ((abnf::csts (cst-white-space-conc4-rep abnf::cst)))
             (cst-list-rep-matchp abnf::csts "form-feed")))
  :rule-classes :rewrite)

Theorem: cst-white-space-conc4-rep-of-tree-fix-cst

(defthm cst-white-space-conc4-rep-of-tree-fix-cst
  (equal (cst-white-space-conc4-rep (abnf::tree-fix abnf::cst))
         (cst-white-space-conc4-rep abnf::cst)))

Theorem: cst-white-space-conc4-rep-tree-equiv-congruence-on-cst

(defthm cst-white-space-conc4-rep-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-white-space-conc4-rep abnf::cst)
                  (cst-white-space-conc4-rep cst-equiv)))
  :rule-classes :congruence)

Function: cst-white-space-conc5-rep

(defun cst-white-space-conc5-rep (abnf::cst)
 (declare (xargs :guard (abnf::treep abnf::cst)))
 (declare
      (xargs :guard (and (cst-matchp abnf::cst "white-space")
                         (equal (cst-white-space-conc? abnf::cst)
                                5))))
 (let ((__function__ 'cst-white-space-conc5-rep))
   (declare (ignorable __function__))
   (abnf::tree-list-fix (nth 0 (cst-white-space-conc5 abnf::cst)))))

Theorem: tree-listp-of-cst-white-space-conc5-rep

(defthm tree-listp-of-cst-white-space-conc5-rep
  (b* ((abnf::csts (cst-white-space-conc5-rep abnf::cst)))
    (abnf::tree-listp abnf::csts))
  :rule-classes :rewrite)

Theorem: cst-white-space-conc5-rep-match

(defthm cst-white-space-conc5-rep-match
  (implies (and (cst-matchp abnf::cst "white-space")
                (equal (cst-white-space-conc? abnf::cst)
                       5))
           (b* ((abnf::csts (cst-white-space-conc5-rep abnf::cst)))
             (cst-list-rep-matchp abnf::csts "new-line")))
  :rule-classes :rewrite)

Theorem: cst-white-space-conc5-rep-of-tree-fix-cst

(defthm cst-white-space-conc5-rep-of-tree-fix-cst
  (equal (cst-white-space-conc5-rep (abnf::tree-fix abnf::cst))
         (cst-white-space-conc5-rep abnf::cst)))

Theorem: cst-white-space-conc5-rep-tree-equiv-congruence-on-cst

(defthm cst-white-space-conc5-rep-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-white-space-conc5-rep abnf::cst)
                  (cst-white-space-conc5-rep cst-equiv)))
  :rule-classes :congruence)

Function: cst-h-char-conc-rep

(defun cst-h-char-conc-rep (abnf::cst)
  (declare (xargs :guard (abnf::treep abnf::cst)))
  (declare (xargs :guard (cst-matchp abnf::cst "h-char")))
  (let ((__function__ 'cst-h-char-conc-rep))
    (declare (ignorable __function__))
    (abnf::tree-list-fix (nth 0 (cst-h-char-conc abnf::cst)))))

Theorem: tree-listp-of-cst-h-char-conc-rep

(defthm tree-listp-of-cst-h-char-conc-rep
  (b* ((abnf::csts (cst-h-char-conc-rep abnf::cst)))
    (abnf::tree-listp abnf::csts))
  :rule-classes :rewrite)

Theorem: cst-h-char-conc-rep-match

(defthm cst-h-char-conc-rep-match
 (implies
  (cst-matchp abnf::cst "h-char")
  (b* ((abnf::csts (cst-h-char-conc-rep abnf::cst)))
    (cst-list-rep-matchp abnf::csts
                         "character-not-greater-than-or-new-line")))
 :rule-classes :rewrite)

Theorem: cst-h-char-conc-rep-of-tree-fix-cst

(defthm cst-h-char-conc-rep-of-tree-fix-cst
  (equal (cst-h-char-conc-rep (abnf::tree-fix abnf::cst))
         (cst-h-char-conc-rep abnf::cst)))

Theorem: cst-h-char-conc-rep-tree-equiv-congruence-on-cst

(defthm cst-h-char-conc-rep-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-h-char-conc-rep abnf::cst)
                  (cst-h-char-conc-rep cst-equiv)))
  :rule-classes :congruence)

Function: cst-q-char-conc-rep

(defun cst-q-char-conc-rep (abnf::cst)
  (declare (xargs :guard (abnf::treep abnf::cst)))
  (declare (xargs :guard (cst-matchp abnf::cst "q-char")))
  (let ((__function__ 'cst-q-char-conc-rep))
    (declare (ignorable __function__))
    (abnf::tree-list-fix (nth 0 (cst-q-char-conc abnf::cst)))))

Theorem: tree-listp-of-cst-q-char-conc-rep

(defthm tree-listp-of-cst-q-char-conc-rep
  (b* ((abnf::csts (cst-q-char-conc-rep abnf::cst)))
    (abnf::tree-listp abnf::csts))
  :rule-classes :rewrite)

Theorem: cst-q-char-conc-rep-match

(defthm cst-q-char-conc-rep-match
 (implies
  (cst-matchp abnf::cst "q-char")
  (b* ((abnf::csts (cst-q-char-conc-rep abnf::cst)))
    (cst-list-rep-matchp abnf::csts
                         "character-not-double-quote-or-new-line")))
 :rule-classes :rewrite)

Theorem: cst-q-char-conc-rep-of-tree-fix-cst

(defthm cst-q-char-conc-rep-of-tree-fix-cst
  (equal (cst-q-char-conc-rep (abnf::tree-fix abnf::cst))
         (cst-q-char-conc-rep abnf::cst)))

Theorem: cst-q-char-conc-rep-tree-equiv-congruence-on-cst

(defthm cst-q-char-conc-rep-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-q-char-conc-rep abnf::cst)
                  (cst-q-char-conc-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-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 "constant")))
  :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 "string-literal")))
  :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 "punctuator")))
  :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-preprocessing-token-conc1-rep

(defun cst-preprocessing-token-conc1-rep (abnf::cst)
 (declare (xargs :guard (abnf::treep abnf::cst)))
 (declare
   (xargs
        :guard (and (cst-matchp abnf::cst "preprocessing-token")
                    (equal (cst-preprocessing-token-conc? abnf::cst)
                           1))))
 (let ((__function__ 'cst-preprocessing-token-conc1-rep))
   (declare (ignorable __function__))
   (abnf::tree-list-fix
        (nth 0
             (cst-preprocessing-token-conc1 abnf::cst)))))

Theorem: tree-listp-of-cst-preprocessing-token-conc1-rep

(defthm tree-listp-of-cst-preprocessing-token-conc1-rep
  (b* ((abnf::csts (cst-preprocessing-token-conc1-rep abnf::cst)))
    (abnf::tree-listp abnf::csts))
  :rule-classes :rewrite)

Theorem: cst-preprocessing-token-conc1-rep-match

(defthm cst-preprocessing-token-conc1-rep-match
 (implies
    (and (cst-matchp abnf::cst "preprocessing-token")
         (equal (cst-preprocessing-token-conc? abnf::cst)
                1))
    (b* ((abnf::csts (cst-preprocessing-token-conc1-rep abnf::cst)))
      (cst-list-rep-matchp abnf::csts "header-name")))
 :rule-classes :rewrite)

Theorem: cst-preprocessing-token-conc1-rep-of-tree-fix-cst

(defthm cst-preprocessing-token-conc1-rep-of-tree-fix-cst
 (equal
      (cst-preprocessing-token-conc1-rep (abnf::tree-fix abnf::cst))
      (cst-preprocessing-token-conc1-rep abnf::cst)))

Theorem: cst-preprocessing-token-conc1-rep-tree-equiv-congruence-on-cst

(defthm
     cst-preprocessing-token-conc1-rep-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-preprocessing-token-conc1-rep abnf::cst)
                  (cst-preprocessing-token-conc1-rep cst-equiv)))
  :rule-classes :congruence)

Function: cst-preprocessing-token-conc2-rep

(defun cst-preprocessing-token-conc2-rep (abnf::cst)
 (declare (xargs :guard (abnf::treep abnf::cst)))
 (declare
   (xargs
        :guard (and (cst-matchp abnf::cst "preprocessing-token")
                    (equal (cst-preprocessing-token-conc? abnf::cst)
                           2))))
 (let ((__function__ 'cst-preprocessing-token-conc2-rep))
   (declare (ignorable __function__))
   (abnf::tree-list-fix
        (nth 0
             (cst-preprocessing-token-conc2 abnf::cst)))))

Theorem: tree-listp-of-cst-preprocessing-token-conc2-rep

(defthm tree-listp-of-cst-preprocessing-token-conc2-rep
  (b* ((abnf::csts (cst-preprocessing-token-conc2-rep abnf::cst)))
    (abnf::tree-listp abnf::csts))
  :rule-classes :rewrite)

Theorem: cst-preprocessing-token-conc2-rep-match

(defthm cst-preprocessing-token-conc2-rep-match
 (implies
    (and (cst-matchp abnf::cst "preprocessing-token")
         (equal (cst-preprocessing-token-conc? abnf::cst)
                2))
    (b* ((abnf::csts (cst-preprocessing-token-conc2-rep abnf::cst)))
      (cst-list-rep-matchp abnf::csts "identifier")))
 :rule-classes :rewrite)

Theorem: cst-preprocessing-token-conc2-rep-of-tree-fix-cst

(defthm cst-preprocessing-token-conc2-rep-of-tree-fix-cst
 (equal
      (cst-preprocessing-token-conc2-rep (abnf::tree-fix abnf::cst))
      (cst-preprocessing-token-conc2-rep abnf::cst)))

Theorem: cst-preprocessing-token-conc2-rep-tree-equiv-congruence-on-cst

(defthm
     cst-preprocessing-token-conc2-rep-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-preprocessing-token-conc2-rep abnf::cst)
                  (cst-preprocessing-token-conc2-rep cst-equiv)))
  :rule-classes :congruence)

Function: cst-preprocessing-token-conc3-rep

(defun cst-preprocessing-token-conc3-rep (abnf::cst)
 (declare (xargs :guard (abnf::treep abnf::cst)))
 (declare
   (xargs
        :guard (and (cst-matchp abnf::cst "preprocessing-token")
                    (equal (cst-preprocessing-token-conc? abnf::cst)
                           3))))
 (let ((__function__ 'cst-preprocessing-token-conc3-rep))
   (declare (ignorable __function__))
   (abnf::tree-list-fix
        (nth 0
             (cst-preprocessing-token-conc3 abnf::cst)))))

Theorem: tree-listp-of-cst-preprocessing-token-conc3-rep

(defthm tree-listp-of-cst-preprocessing-token-conc3-rep
  (b* ((abnf::csts (cst-preprocessing-token-conc3-rep abnf::cst)))
    (abnf::tree-listp abnf::csts))
  :rule-classes :rewrite)

Theorem: cst-preprocessing-token-conc3-rep-match

(defthm cst-preprocessing-token-conc3-rep-match
 (implies
    (and (cst-matchp abnf::cst "preprocessing-token")
         (equal (cst-preprocessing-token-conc? abnf::cst)
                3))
    (b* ((abnf::csts (cst-preprocessing-token-conc3-rep abnf::cst)))
      (cst-list-rep-matchp abnf::csts "pp-number")))
 :rule-classes :rewrite)

Theorem: cst-preprocessing-token-conc3-rep-of-tree-fix-cst

(defthm cst-preprocessing-token-conc3-rep-of-tree-fix-cst
 (equal
      (cst-preprocessing-token-conc3-rep (abnf::tree-fix abnf::cst))
      (cst-preprocessing-token-conc3-rep abnf::cst)))

Theorem: cst-preprocessing-token-conc3-rep-tree-equiv-congruence-on-cst

(defthm
     cst-preprocessing-token-conc3-rep-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-preprocessing-token-conc3-rep abnf::cst)
                  (cst-preprocessing-token-conc3-rep cst-equiv)))
  :rule-classes :congruence)

Function: cst-preprocessing-token-conc4-rep

(defun cst-preprocessing-token-conc4-rep (abnf::cst)
 (declare (xargs :guard (abnf::treep abnf::cst)))
 (declare
   (xargs
        :guard (and (cst-matchp abnf::cst "preprocessing-token")
                    (equal (cst-preprocessing-token-conc? abnf::cst)
                           4))))
 (let ((__function__ 'cst-preprocessing-token-conc4-rep))
   (declare (ignorable __function__))
   (abnf::tree-list-fix
        (nth 0
             (cst-preprocessing-token-conc4 abnf::cst)))))

Theorem: tree-listp-of-cst-preprocessing-token-conc4-rep

(defthm tree-listp-of-cst-preprocessing-token-conc4-rep
  (b* ((abnf::csts (cst-preprocessing-token-conc4-rep abnf::cst)))
    (abnf::tree-listp abnf::csts))
  :rule-classes :rewrite)

Theorem: cst-preprocessing-token-conc4-rep-match

(defthm cst-preprocessing-token-conc4-rep-match
 (implies
    (and (cst-matchp abnf::cst "preprocessing-token")
         (equal (cst-preprocessing-token-conc? abnf::cst)
                4))
    (b* ((abnf::csts (cst-preprocessing-token-conc4-rep abnf::cst)))
      (cst-list-rep-matchp abnf::csts "character-constant")))
 :rule-classes :rewrite)

Theorem: cst-preprocessing-token-conc4-rep-of-tree-fix-cst

(defthm cst-preprocessing-token-conc4-rep-of-tree-fix-cst
 (equal
      (cst-preprocessing-token-conc4-rep (abnf::tree-fix abnf::cst))
      (cst-preprocessing-token-conc4-rep abnf::cst)))

Theorem: cst-preprocessing-token-conc4-rep-tree-equiv-congruence-on-cst

(defthm
     cst-preprocessing-token-conc4-rep-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-preprocessing-token-conc4-rep abnf::cst)
                  (cst-preprocessing-token-conc4-rep cst-equiv)))
  :rule-classes :congruence)

Function: cst-preprocessing-token-conc5-rep

(defun cst-preprocessing-token-conc5-rep (abnf::cst)
 (declare (xargs :guard (abnf::treep abnf::cst)))
 (declare
   (xargs
        :guard (and (cst-matchp abnf::cst "preprocessing-token")
                    (equal (cst-preprocessing-token-conc? abnf::cst)
                           5))))
 (let ((__function__ 'cst-preprocessing-token-conc5-rep))
   (declare (ignorable __function__))
   (abnf::tree-list-fix
        (nth 0
             (cst-preprocessing-token-conc5 abnf::cst)))))

Theorem: tree-listp-of-cst-preprocessing-token-conc5-rep

(defthm tree-listp-of-cst-preprocessing-token-conc5-rep
  (b* ((abnf::csts (cst-preprocessing-token-conc5-rep abnf::cst)))
    (abnf::tree-listp abnf::csts))
  :rule-classes :rewrite)

Theorem: cst-preprocessing-token-conc5-rep-match

(defthm cst-preprocessing-token-conc5-rep-match
 (implies
    (and (cst-matchp abnf::cst "preprocessing-token")
         (equal (cst-preprocessing-token-conc? abnf::cst)
                5))
    (b* ((abnf::csts (cst-preprocessing-token-conc5-rep abnf::cst)))
      (cst-list-rep-matchp abnf::csts "string-literal")))
 :rule-classes :rewrite)

Theorem: cst-preprocessing-token-conc5-rep-of-tree-fix-cst

(defthm cst-preprocessing-token-conc5-rep-of-tree-fix-cst
 (equal
      (cst-preprocessing-token-conc5-rep (abnf::tree-fix abnf::cst))
      (cst-preprocessing-token-conc5-rep abnf::cst)))

Theorem: cst-preprocessing-token-conc5-rep-tree-equiv-congruence-on-cst

(defthm
     cst-preprocessing-token-conc5-rep-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-preprocessing-token-conc5-rep abnf::cst)
                  (cst-preprocessing-token-conc5-rep cst-equiv)))
  :rule-classes :congruence)

Function: cst-preprocessing-token-conc6-rep

(defun cst-preprocessing-token-conc6-rep (abnf::cst)
 (declare (xargs :guard (abnf::treep abnf::cst)))
 (declare
   (xargs
        :guard (and (cst-matchp abnf::cst "preprocessing-token")
                    (equal (cst-preprocessing-token-conc? abnf::cst)
                           6))))
 (let ((__function__ 'cst-preprocessing-token-conc6-rep))
   (declare (ignorable __function__))
   (abnf::tree-list-fix
        (nth 0
             (cst-preprocessing-token-conc6 abnf::cst)))))

Theorem: tree-listp-of-cst-preprocessing-token-conc6-rep

(defthm tree-listp-of-cst-preprocessing-token-conc6-rep
  (b* ((abnf::csts (cst-preprocessing-token-conc6-rep abnf::cst)))
    (abnf::tree-listp abnf::csts))
  :rule-classes :rewrite)

Theorem: cst-preprocessing-token-conc6-rep-match

(defthm cst-preprocessing-token-conc6-rep-match
 (implies
    (and (cst-matchp abnf::cst "preprocessing-token")
         (equal (cst-preprocessing-token-conc? abnf::cst)
                6))
    (b* ((abnf::csts (cst-preprocessing-token-conc6-rep abnf::cst)))
      (cst-list-rep-matchp abnf::csts "punctuator")))
 :rule-classes :rewrite)

Theorem: cst-preprocessing-token-conc6-rep-of-tree-fix-cst

(defthm cst-preprocessing-token-conc6-rep-of-tree-fix-cst
 (equal
      (cst-preprocessing-token-conc6-rep (abnf::tree-fix abnf::cst))
      (cst-preprocessing-token-conc6-rep abnf::cst)))

Theorem: cst-preprocessing-token-conc6-rep-tree-equiv-congruence-on-cst

(defthm
     cst-preprocessing-token-conc6-rep-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-preprocessing-token-conc6-rep abnf::cst)
                  (cst-preprocessing-token-conc6-rep cst-equiv)))
  :rule-classes :congruence)

Function: cst-preprocessing-token-conc7-rep

(defun cst-preprocessing-token-conc7-rep (abnf::cst)
 (declare (xargs :guard (abnf::treep abnf::cst)))
 (declare
   (xargs
        :guard (and (cst-matchp abnf::cst "preprocessing-token")
                    (equal (cst-preprocessing-token-conc? abnf::cst)
                           7))))
 (let ((__function__ 'cst-preprocessing-token-conc7-rep))
   (declare (ignorable __function__))
   (abnf::tree-list-fix
        (nth 0
             (cst-preprocessing-token-conc7 abnf::cst)))))

Theorem: tree-listp-of-cst-preprocessing-token-conc7-rep

(defthm tree-listp-of-cst-preprocessing-token-conc7-rep
  (b* ((abnf::csts (cst-preprocessing-token-conc7-rep abnf::cst)))
    (abnf::tree-listp abnf::csts))
  :rule-classes :rewrite)

Theorem: cst-preprocessing-token-conc7-rep-match

(defthm cst-preprocessing-token-conc7-rep-match
 (implies
    (and (cst-matchp abnf::cst "preprocessing-token")
         (equal (cst-preprocessing-token-conc? abnf::cst)
                7))
    (b* ((abnf::csts (cst-preprocessing-token-conc7-rep abnf::cst)))
      (cst-list-rep-matchp abnf::csts "character")))
 :rule-classes :rewrite)

Theorem: cst-preprocessing-token-conc7-rep-of-tree-fix-cst

(defthm cst-preprocessing-token-conc7-rep-of-tree-fix-cst
 (equal
      (cst-preprocessing-token-conc7-rep (abnf::tree-fix abnf::cst))
      (cst-preprocessing-token-conc7-rep abnf::cst)))

Theorem: cst-preprocessing-token-conc7-rep-tree-equiv-congruence-on-cst

(defthm
     cst-preprocessing-token-conc7-rep-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-preprocessing-token-conc7-rep abnf::cst)
                  (cst-preprocessing-token-conc7-rep cst-equiv)))
  :rule-classes :congruence)

Function: cst-identifier-nondigit-conc-rep

(defun cst-identifier-nondigit-conc-rep (abnf::cst)
  (declare (xargs :guard (abnf::treep abnf::cst)))
  (declare
       (xargs :guard (cst-matchp abnf::cst "identifier-nondigit")))
  (let ((__function__ 'cst-identifier-nondigit-conc-rep))
    (declare (ignorable __function__))
    (abnf::tree-list-fix
         (nth 0
              (cst-identifier-nondigit-conc abnf::cst)))))

Theorem: tree-listp-of-cst-identifier-nondigit-conc-rep

(defthm tree-listp-of-cst-identifier-nondigit-conc-rep
  (b* ((abnf::csts (cst-identifier-nondigit-conc-rep abnf::cst)))
    (abnf::tree-listp abnf::csts))
  :rule-classes :rewrite)

Theorem: cst-identifier-nondigit-conc-rep-match

(defthm cst-identifier-nondigit-conc-rep-match
 (implies
     (cst-matchp abnf::cst "identifier-nondigit")
     (b* ((abnf::csts (cst-identifier-nondigit-conc-rep abnf::cst)))
       (cst-list-rep-matchp abnf::csts "nondigit")))
 :rule-classes :rewrite)

Theorem: cst-identifier-nondigit-conc-rep-of-tree-fix-cst

(defthm cst-identifier-nondigit-conc-rep-of-tree-fix-cst
  (equal
       (cst-identifier-nondigit-conc-rep (abnf::tree-fix abnf::cst))
       (cst-identifier-nondigit-conc-rep abnf::cst)))

Theorem: cst-identifier-nondigit-conc-rep-tree-equiv-congruence-on-cst

(defthm
      cst-identifier-nondigit-conc-rep-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-identifier-nondigit-conc-rep abnf::cst)
                  (cst-identifier-nondigit-conc-rep cst-equiv)))
  :rule-classes :congruence)

Function: cst-constant-conc1-rep

(defun cst-constant-conc1-rep (abnf::cst)
  (declare (xargs :guard (abnf::treep abnf::cst)))
  (declare (xargs :guard (and (cst-matchp abnf::cst "constant")
                              (equal (cst-constant-conc? abnf::cst)
                                     1))))
  (let ((__function__ 'cst-constant-conc1-rep))
    (declare (ignorable __function__))
    (abnf::tree-list-fix (nth 0 (cst-constant-conc1 abnf::cst)))))

Theorem: tree-listp-of-cst-constant-conc1-rep

(defthm tree-listp-of-cst-constant-conc1-rep
  (b* ((abnf::csts (cst-constant-conc1-rep abnf::cst)))
    (abnf::tree-listp abnf::csts))
  :rule-classes :rewrite)

Theorem: cst-constant-conc1-rep-match

(defthm cst-constant-conc1-rep-match
  (implies (and (cst-matchp abnf::cst "constant")
                (equal (cst-constant-conc? abnf::cst)
                       1))
           (b* ((abnf::csts (cst-constant-conc1-rep abnf::cst)))
             (cst-list-rep-matchp abnf::csts "integer-constant")))
  :rule-classes :rewrite)

Theorem: cst-constant-conc1-rep-of-tree-fix-cst

(defthm cst-constant-conc1-rep-of-tree-fix-cst
  (equal (cst-constant-conc1-rep (abnf::tree-fix abnf::cst))
         (cst-constant-conc1-rep abnf::cst)))

Theorem: cst-constant-conc1-rep-tree-equiv-congruence-on-cst

(defthm cst-constant-conc1-rep-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-constant-conc1-rep abnf::cst)
                  (cst-constant-conc1-rep cst-equiv)))
  :rule-classes :congruence)

Function: cst-constant-conc2-rep

(defun cst-constant-conc2-rep (abnf::cst)
  (declare (xargs :guard (abnf::treep abnf::cst)))
  (declare (xargs :guard (and (cst-matchp abnf::cst "constant")
                              (equal (cst-constant-conc? abnf::cst)
                                     2))))
  (let ((__function__ 'cst-constant-conc2-rep))
    (declare (ignorable __function__))
    (abnf::tree-list-fix (nth 0 (cst-constant-conc2 abnf::cst)))))

Theorem: tree-listp-of-cst-constant-conc2-rep

(defthm tree-listp-of-cst-constant-conc2-rep
  (b* ((abnf::csts (cst-constant-conc2-rep abnf::cst)))
    (abnf::tree-listp abnf::csts))
  :rule-classes :rewrite)

Theorem: cst-constant-conc2-rep-match

(defthm cst-constant-conc2-rep-match
  (implies (and (cst-matchp abnf::cst "constant")
                (equal (cst-constant-conc? abnf::cst)
                       2))
           (b* ((abnf::csts (cst-constant-conc2-rep abnf::cst)))
             (cst-list-rep-matchp abnf::csts "floating-constant")))
  :rule-classes :rewrite)

Theorem: cst-constant-conc2-rep-of-tree-fix-cst

(defthm cst-constant-conc2-rep-of-tree-fix-cst
  (equal (cst-constant-conc2-rep (abnf::tree-fix abnf::cst))
         (cst-constant-conc2-rep abnf::cst)))

Theorem: cst-constant-conc2-rep-tree-equiv-congruence-on-cst

(defthm cst-constant-conc2-rep-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-constant-conc2-rep abnf::cst)
                  (cst-constant-conc2-rep cst-equiv)))
  :rule-classes :congruence)

Function: cst-constant-conc3-rep

(defun cst-constant-conc3-rep (abnf::cst)
  (declare (xargs :guard (abnf::treep abnf::cst)))
  (declare (xargs :guard (and (cst-matchp abnf::cst "constant")
                              (equal (cst-constant-conc? abnf::cst)
                                     3))))
  (let ((__function__ 'cst-constant-conc3-rep))
    (declare (ignorable __function__))
    (abnf::tree-list-fix (nth 0 (cst-constant-conc3 abnf::cst)))))

Theorem: tree-listp-of-cst-constant-conc3-rep

(defthm tree-listp-of-cst-constant-conc3-rep
  (b* ((abnf::csts (cst-constant-conc3-rep abnf::cst)))
    (abnf::tree-listp abnf::csts))
  :rule-classes :rewrite)

Theorem: cst-constant-conc3-rep-match

(defthm cst-constant-conc3-rep-match
  (implies
       (and (cst-matchp abnf::cst "constant")
            (equal (cst-constant-conc? abnf::cst)
                   3))
       (b* ((abnf::csts (cst-constant-conc3-rep abnf::cst)))
         (cst-list-rep-matchp abnf::csts "enumeration-constant")))
  :rule-classes :rewrite)

Theorem: cst-constant-conc3-rep-of-tree-fix-cst

(defthm cst-constant-conc3-rep-of-tree-fix-cst
  (equal (cst-constant-conc3-rep (abnf::tree-fix abnf::cst))
         (cst-constant-conc3-rep abnf::cst)))

Theorem: cst-constant-conc3-rep-tree-equiv-congruence-on-cst

(defthm cst-constant-conc3-rep-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-constant-conc3-rep abnf::cst)
                  (cst-constant-conc3-rep cst-equiv)))
  :rule-classes :congruence)

Function: cst-constant-conc4-rep

(defun cst-constant-conc4-rep (abnf::cst)
  (declare (xargs :guard (abnf::treep abnf::cst)))
  (declare (xargs :guard (and (cst-matchp abnf::cst "constant")
                              (equal (cst-constant-conc? abnf::cst)
                                     4))))
  (let ((__function__ 'cst-constant-conc4-rep))
    (declare (ignorable __function__))
    (abnf::tree-list-fix (nth 0 (cst-constant-conc4 abnf::cst)))))

Theorem: tree-listp-of-cst-constant-conc4-rep

(defthm tree-listp-of-cst-constant-conc4-rep
  (b* ((abnf::csts (cst-constant-conc4-rep abnf::cst)))
    (abnf::tree-listp abnf::csts))
  :rule-classes :rewrite)

Theorem: cst-constant-conc4-rep-match

(defthm cst-constant-conc4-rep-match
  (implies (and (cst-matchp abnf::cst "constant")
                (equal (cst-constant-conc? abnf::cst)
                       4))
           (b* ((abnf::csts (cst-constant-conc4-rep abnf::cst)))
             (cst-list-rep-matchp abnf::csts "character-constant")))
  :rule-classes :rewrite)

Theorem: cst-constant-conc4-rep-of-tree-fix-cst

(defthm cst-constant-conc4-rep-of-tree-fix-cst
  (equal (cst-constant-conc4-rep (abnf::tree-fix abnf::cst))
         (cst-constant-conc4-rep abnf::cst)))

Theorem: cst-constant-conc4-rep-tree-equiv-congruence-on-cst

(defthm cst-constant-conc4-rep-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-constant-conc4-rep abnf::cst)
                  (cst-constant-conc4-rep cst-equiv)))
  :rule-classes :congruence)

Function: cst-hexadecimal-prefix-conc-rep

(defun cst-hexadecimal-prefix-conc-rep (abnf::cst)
  (declare (xargs :guard (abnf::treep abnf::cst)))
  (declare
       (xargs :guard (cst-matchp abnf::cst "hexadecimal-prefix")))
  (let ((__function__ 'cst-hexadecimal-prefix-conc-rep))
    (declare (ignorable __function__))
    (abnf::tree-list-fix
         (nth 0
              (cst-hexadecimal-prefix-conc abnf::cst)))))

Theorem: tree-listp-of-cst-hexadecimal-prefix-conc-rep

(defthm tree-listp-of-cst-hexadecimal-prefix-conc-rep
  (b* ((abnf::csts (cst-hexadecimal-prefix-conc-rep abnf::cst)))
    (abnf::tree-listp abnf::csts))
  :rule-classes :rewrite)

Theorem: cst-hexadecimal-prefix-conc-rep-match

(defthm cst-hexadecimal-prefix-conc-rep-match
 (implies
      (cst-matchp abnf::cst "hexadecimal-prefix")
      (b* ((abnf::csts (cst-hexadecimal-prefix-conc-rep abnf::cst)))
        (cst-list-rep-matchp abnf::csts "%i\"0x\"")))
 :rule-classes :rewrite)

Theorem: cst-hexadecimal-prefix-conc-rep-of-tree-fix-cst

(defthm cst-hexadecimal-prefix-conc-rep-of-tree-fix-cst
 (equal (cst-hexadecimal-prefix-conc-rep (abnf::tree-fix abnf::cst))
        (cst-hexadecimal-prefix-conc-rep abnf::cst)))

Theorem: cst-hexadecimal-prefix-conc-rep-tree-equiv-congruence-on-cst

(defthm cst-hexadecimal-prefix-conc-rep-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-hexadecimal-prefix-conc-rep abnf::cst)
                  (cst-hexadecimal-prefix-conc-rep cst-equiv)))
  :rule-classes :congruence)

Function: cst-nonzero-digit-conc-rep

(defun cst-nonzero-digit-conc-rep (abnf::cst)
 (declare (xargs :guard (abnf::treep abnf::cst)))
 (declare (xargs :guard (cst-matchp abnf::cst "nonzero-digit")))
 (let ((__function__ 'cst-nonzero-digit-conc-rep))
  (declare (ignorable __function__))
  (abnf::tree-list-fix (nth 0 (cst-nonzero-digit-conc abnf::cst)))))

Theorem: tree-listp-of-cst-nonzero-digit-conc-rep

(defthm tree-listp-of-cst-nonzero-digit-conc-rep
  (b* ((abnf::csts (cst-nonzero-digit-conc-rep abnf::cst)))
    (abnf::tree-listp abnf::csts))
  :rule-classes :rewrite)

Theorem: cst-nonzero-digit-conc-rep-match

(defthm cst-nonzero-digit-conc-rep-match
  (implies (cst-matchp abnf::cst "nonzero-digit")
           (b* ((abnf::csts (cst-nonzero-digit-conc-rep abnf::cst)))
             (cst-list-rep-matchp abnf::csts "%x31-39")))
  :rule-classes :rewrite)

Theorem: cst-nonzero-digit-conc-rep-of-tree-fix-cst

(defthm cst-nonzero-digit-conc-rep-of-tree-fix-cst
  (equal (cst-nonzero-digit-conc-rep (abnf::tree-fix abnf::cst))
         (cst-nonzero-digit-conc-rep abnf::cst)))

Theorem: cst-nonzero-digit-conc-rep-tree-equiv-congruence-on-cst

(defthm cst-nonzero-digit-conc-rep-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-nonzero-digit-conc-rep abnf::cst)
                  (cst-nonzero-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-unsigned-suffix-conc-rep

(defun cst-unsigned-suffix-conc-rep (abnf::cst)
 (declare (xargs :guard (abnf::treep abnf::cst)))
 (declare (xargs :guard (cst-matchp abnf::cst "unsigned-suffix")))
 (let ((__function__ 'cst-unsigned-suffix-conc-rep))
  (declare (ignorable __function__))
  (abnf::tree-list-fix (nth 0
                            (cst-unsigned-suffix-conc abnf::cst)))))

Theorem: tree-listp-of-cst-unsigned-suffix-conc-rep

(defthm tree-listp-of-cst-unsigned-suffix-conc-rep
  (b* ((abnf::csts (cst-unsigned-suffix-conc-rep abnf::cst)))
    (abnf::tree-listp abnf::csts))
  :rule-classes :rewrite)

Theorem: cst-unsigned-suffix-conc-rep-match

(defthm cst-unsigned-suffix-conc-rep-match
  (implies
       (cst-matchp abnf::cst "unsigned-suffix")
       (b* ((abnf::csts (cst-unsigned-suffix-conc-rep abnf::cst)))
         (cst-list-rep-matchp abnf::csts "%i\"u\"")))
  :rule-classes :rewrite)

Theorem: cst-unsigned-suffix-conc-rep-of-tree-fix-cst

(defthm cst-unsigned-suffix-conc-rep-of-tree-fix-cst
  (equal (cst-unsigned-suffix-conc-rep (abnf::tree-fix abnf::cst))
         (cst-unsigned-suffix-conc-rep abnf::cst)))

Theorem: cst-unsigned-suffix-conc-rep-tree-equiv-congruence-on-cst

(defthm cst-unsigned-suffix-conc-rep-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-unsigned-suffix-conc-rep abnf::cst)
                  (cst-unsigned-suffix-conc-rep cst-equiv)))
  :rule-classes :congruence)

Function: cst-long-suffix-conc-rep

(defun cst-long-suffix-conc-rep (abnf::cst)
  (declare (xargs :guard (abnf::treep abnf::cst)))
  (declare (xargs :guard (cst-matchp abnf::cst "long-suffix")))
  (let ((__function__ 'cst-long-suffix-conc-rep))
    (declare (ignorable __function__))
    (abnf::tree-list-fix (nth 0 (cst-long-suffix-conc abnf::cst)))))

Theorem: tree-listp-of-cst-long-suffix-conc-rep

(defthm tree-listp-of-cst-long-suffix-conc-rep
  (b* ((abnf::csts (cst-long-suffix-conc-rep abnf::cst)))
    (abnf::tree-listp abnf::csts))
  :rule-classes :rewrite)

Theorem: cst-long-suffix-conc-rep-match

(defthm cst-long-suffix-conc-rep-match
  (implies (cst-matchp abnf::cst "long-suffix")
           (b* ((abnf::csts (cst-long-suffix-conc-rep abnf::cst)))
             (cst-list-rep-matchp abnf::csts "%i\"l\"")))
  :rule-classes :rewrite)

Theorem: cst-long-suffix-conc-rep-of-tree-fix-cst

(defthm cst-long-suffix-conc-rep-of-tree-fix-cst
  (equal (cst-long-suffix-conc-rep (abnf::tree-fix abnf::cst))
         (cst-long-suffix-conc-rep abnf::cst)))

Theorem: cst-long-suffix-conc-rep-tree-equiv-congruence-on-cst

(defthm cst-long-suffix-conc-rep-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-long-suffix-conc-rep abnf::cst)
                  (cst-long-suffix-conc-rep cst-equiv)))
  :rule-classes :congruence)

Function: cst-floating-constant-conc1-rep

(defun cst-floating-constant-conc1-rep (abnf::cst)
 (declare (xargs :guard (abnf::treep abnf::cst)))
 (declare
   (xargs :guard (and (cst-matchp abnf::cst "floating-constant")
                      (equal (cst-floating-constant-conc? abnf::cst)
                             1))))
 (let ((__function__ 'cst-floating-constant-conc1-rep))
   (declare (ignorable __function__))
   (abnf::tree-list-fix
        (nth 0
             (cst-floating-constant-conc1 abnf::cst)))))

Theorem: tree-listp-of-cst-floating-constant-conc1-rep

(defthm tree-listp-of-cst-floating-constant-conc1-rep
  (b* ((abnf::csts (cst-floating-constant-conc1-rep abnf::cst)))
    (abnf::tree-listp abnf::csts))
  :rule-classes :rewrite)

Theorem: cst-floating-constant-conc1-rep-match

(defthm cst-floating-constant-conc1-rep-match
 (implies
      (and (cst-matchp abnf::cst "floating-constant")
           (equal (cst-floating-constant-conc? abnf::cst)
                  1))
      (b* ((abnf::csts (cst-floating-constant-conc1-rep abnf::cst)))
        (cst-list-rep-matchp abnf::csts
                             "decimal-floating-constant")))
 :rule-classes :rewrite)

Theorem: cst-floating-constant-conc1-rep-of-tree-fix-cst

(defthm cst-floating-constant-conc1-rep-of-tree-fix-cst
 (equal (cst-floating-constant-conc1-rep (abnf::tree-fix abnf::cst))
        (cst-floating-constant-conc1-rep abnf::cst)))

Theorem: cst-floating-constant-conc1-rep-tree-equiv-congruence-on-cst

(defthm cst-floating-constant-conc1-rep-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-floating-constant-conc1-rep abnf::cst)
                  (cst-floating-constant-conc1-rep cst-equiv)))
  :rule-classes :congruence)

Function: cst-floating-constant-conc2-rep

(defun cst-floating-constant-conc2-rep (abnf::cst)
 (declare (xargs :guard (abnf::treep abnf::cst)))
 (declare
   (xargs :guard (and (cst-matchp abnf::cst "floating-constant")
                      (equal (cst-floating-constant-conc? abnf::cst)
                             2))))
 (let ((__function__ 'cst-floating-constant-conc2-rep))
   (declare (ignorable __function__))
   (abnf::tree-list-fix
        (nth 0
             (cst-floating-constant-conc2 abnf::cst)))))

Theorem: tree-listp-of-cst-floating-constant-conc2-rep

(defthm tree-listp-of-cst-floating-constant-conc2-rep
  (b* ((abnf::csts (cst-floating-constant-conc2-rep abnf::cst)))
    (abnf::tree-listp abnf::csts))
  :rule-classes :rewrite)

Theorem: cst-floating-constant-conc2-rep-match

(defthm cst-floating-constant-conc2-rep-match
 (implies
      (and (cst-matchp abnf::cst "floating-constant")
           (equal (cst-floating-constant-conc? abnf::cst)
                  2))
      (b* ((abnf::csts (cst-floating-constant-conc2-rep abnf::cst)))
        (cst-list-rep-matchp abnf::csts
                             "hexadecimal-floating-constant")))
 :rule-classes :rewrite)

Theorem: cst-floating-constant-conc2-rep-of-tree-fix-cst

(defthm cst-floating-constant-conc2-rep-of-tree-fix-cst
 (equal (cst-floating-constant-conc2-rep (abnf::tree-fix abnf::cst))
        (cst-floating-constant-conc2-rep abnf::cst)))

Theorem: cst-floating-constant-conc2-rep-tree-equiv-congruence-on-cst

(defthm cst-floating-constant-conc2-rep-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-floating-constant-conc2-rep abnf::cst)
                  (cst-floating-constant-conc2-rep cst-equiv)))
  :rule-classes :congruence)

Function: cst-enumeration-constant-conc-rep

(defun cst-enumeration-constant-conc-rep (abnf::cst)
  (declare (xargs :guard (abnf::treep abnf::cst)))
  (declare
       (xargs :guard (cst-matchp abnf::cst "enumeration-constant")))
  (let ((__function__ 'cst-enumeration-constant-conc-rep))
    (declare (ignorable __function__))
    (abnf::tree-list-fix
         (nth 0
              (cst-enumeration-constant-conc abnf::cst)))))

Theorem: tree-listp-of-cst-enumeration-constant-conc-rep

(defthm tree-listp-of-cst-enumeration-constant-conc-rep
  (b* ((abnf::csts (cst-enumeration-constant-conc-rep abnf::cst)))
    (abnf::tree-listp abnf::csts))
  :rule-classes :rewrite)

Theorem: cst-enumeration-constant-conc-rep-match

(defthm cst-enumeration-constant-conc-rep-match
 (implies
    (cst-matchp abnf::cst "enumeration-constant")
    (b* ((abnf::csts (cst-enumeration-constant-conc-rep abnf::cst)))
      (cst-list-rep-matchp abnf::csts "identifier")))
 :rule-classes :rewrite)

Theorem: cst-enumeration-constant-conc-rep-of-tree-fix-cst

(defthm cst-enumeration-constant-conc-rep-of-tree-fix-cst
 (equal
      (cst-enumeration-constant-conc-rep (abnf::tree-fix abnf::cst))
      (cst-enumeration-constant-conc-rep abnf::cst)))

Theorem: cst-enumeration-constant-conc-rep-tree-equiv-congruence-on-cst

(defthm
     cst-enumeration-constant-conc-rep-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-enumeration-constant-conc-rep abnf::cst)
                  (cst-enumeration-constant-conc-rep cst-equiv)))
  :rule-classes :congruence)

Function: cst-c-char-conc1-rep

(defun cst-c-char-conc1-rep (abnf::cst)
  (declare (xargs :guard (abnf::treep abnf::cst)))
  (declare (xargs :guard (and (cst-matchp abnf::cst "c-char")
                              (equal (cst-c-char-conc? abnf::cst)
                                     1))))
  (let ((__function__ 'cst-c-char-conc1-rep))
    (declare (ignorable __function__))
    (abnf::tree-list-fix (nth 0 (cst-c-char-conc1 abnf::cst)))))

Theorem: tree-listp-of-cst-c-char-conc1-rep

(defthm tree-listp-of-cst-c-char-conc1-rep
  (b* ((abnf::csts (cst-c-char-conc1-rep abnf::cst)))
    (abnf::tree-listp abnf::csts))
  :rule-classes :rewrite)

Theorem: cst-c-char-conc1-rep-match

(defthm cst-c-char-conc1-rep-match
 (implies
     (and (cst-matchp abnf::cst "c-char")
          (equal (cst-c-char-conc? abnf::cst) 1))
     (b* ((abnf::csts (cst-c-char-conc1-rep abnf::cst)))
       (cst-list-rep-matchp
            abnf::csts
            "character-not-single-quote-or-backslash-or-new-line")))
 :rule-classes :rewrite)

Theorem: cst-c-char-conc1-rep-of-tree-fix-cst

(defthm cst-c-char-conc1-rep-of-tree-fix-cst
  (equal (cst-c-char-conc1-rep (abnf::tree-fix abnf::cst))
         (cst-c-char-conc1-rep abnf::cst)))

Theorem: cst-c-char-conc1-rep-tree-equiv-congruence-on-cst

(defthm cst-c-char-conc1-rep-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-c-char-conc1-rep abnf::cst)
                  (cst-c-char-conc1-rep cst-equiv)))
  :rule-classes :congruence)

Function: cst-c-char-conc2-rep

(defun cst-c-char-conc2-rep (abnf::cst)
  (declare (xargs :guard (abnf::treep abnf::cst)))
  (declare (xargs :guard (and (cst-matchp abnf::cst "c-char")
                              (equal (cst-c-char-conc? abnf::cst)
                                     2))))
  (let ((__function__ 'cst-c-char-conc2-rep))
    (declare (ignorable __function__))
    (abnf::tree-list-fix (nth 0 (cst-c-char-conc2 abnf::cst)))))

Theorem: tree-listp-of-cst-c-char-conc2-rep

(defthm tree-listp-of-cst-c-char-conc2-rep
  (b* ((abnf::csts (cst-c-char-conc2-rep abnf::cst)))
    (abnf::tree-listp abnf::csts))
  :rule-classes :rewrite)

Theorem: cst-c-char-conc2-rep-match

(defthm cst-c-char-conc2-rep-match
  (implies (and (cst-matchp abnf::cst "c-char")
                (equal (cst-c-char-conc? abnf::cst) 2))
           (b* ((abnf::csts (cst-c-char-conc2-rep abnf::cst)))
             (cst-list-rep-matchp abnf::csts "escape-sequence")))
  :rule-classes :rewrite)

Theorem: cst-c-char-conc2-rep-of-tree-fix-cst

(defthm cst-c-char-conc2-rep-of-tree-fix-cst
  (equal (cst-c-char-conc2-rep (abnf::tree-fix abnf::cst))
         (cst-c-char-conc2-rep abnf::cst)))

Theorem: cst-c-char-conc2-rep-tree-equiv-congruence-on-cst

(defthm cst-c-char-conc2-rep-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-c-char-conc2-rep abnf::cst)
                  (cst-c-char-conc2-rep cst-equiv)))
  :rule-classes :congruence)

Function: cst-escape-sequence-conc1-rep

(defun cst-escape-sequence-conc1-rep (abnf::cst)
 (declare (xargs :guard (abnf::treep abnf::cst)))
 (declare
     (xargs :guard (and (cst-matchp abnf::cst "escape-sequence")
                        (equal (cst-escape-sequence-conc? abnf::cst)
                               1))))
 (let ((__function__ 'cst-escape-sequence-conc1-rep))
   (declare (ignorable __function__))
   (abnf::tree-list-fix
        (nth 0
             (cst-escape-sequence-conc1 abnf::cst)))))

Theorem: tree-listp-of-cst-escape-sequence-conc1-rep

(defthm tree-listp-of-cst-escape-sequence-conc1-rep
  (b* ((abnf::csts (cst-escape-sequence-conc1-rep abnf::cst)))
    (abnf::tree-listp abnf::csts))
  :rule-classes :rewrite)

Theorem: cst-escape-sequence-conc1-rep-match

(defthm cst-escape-sequence-conc1-rep-match
  (implies
       (and (cst-matchp abnf::cst "escape-sequence")
            (equal (cst-escape-sequence-conc? abnf::cst)
                   1))
       (b* ((abnf::csts (cst-escape-sequence-conc1-rep abnf::cst)))
         (cst-list-rep-matchp abnf::csts "simple-escape-sequence")))
  :rule-classes :rewrite)

Theorem: cst-escape-sequence-conc1-rep-of-tree-fix-cst

(defthm cst-escape-sequence-conc1-rep-of-tree-fix-cst
  (equal (cst-escape-sequence-conc1-rep (abnf::tree-fix abnf::cst))
         (cst-escape-sequence-conc1-rep abnf::cst)))

Theorem: cst-escape-sequence-conc1-rep-tree-equiv-congruence-on-cst

(defthm cst-escape-sequence-conc1-rep-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-escape-sequence-conc1-rep abnf::cst)
                  (cst-escape-sequence-conc1-rep cst-equiv)))
  :rule-classes :congruence)

Function: cst-escape-sequence-conc2-rep

(defun cst-escape-sequence-conc2-rep (abnf::cst)
 (declare (xargs :guard (abnf::treep abnf::cst)))
 (declare
     (xargs :guard (and (cst-matchp abnf::cst "escape-sequence")
                        (equal (cst-escape-sequence-conc? abnf::cst)
                               2))))
 (let ((__function__ 'cst-escape-sequence-conc2-rep))
   (declare (ignorable __function__))
   (abnf::tree-list-fix
        (nth 0
             (cst-escape-sequence-conc2 abnf::cst)))))

Theorem: tree-listp-of-cst-escape-sequence-conc2-rep

(defthm tree-listp-of-cst-escape-sequence-conc2-rep
  (b* ((abnf::csts (cst-escape-sequence-conc2-rep abnf::cst)))
    (abnf::tree-listp abnf::csts))
  :rule-classes :rewrite)

Theorem: cst-escape-sequence-conc2-rep-match

(defthm cst-escape-sequence-conc2-rep-match
  (implies
       (and (cst-matchp abnf::cst "escape-sequence")
            (equal (cst-escape-sequence-conc? abnf::cst)
                   2))
       (b* ((abnf::csts (cst-escape-sequence-conc2-rep abnf::cst)))
         (cst-list-rep-matchp abnf::csts "octal-escape-sequence")))
  :rule-classes :rewrite)

Theorem: cst-escape-sequence-conc2-rep-of-tree-fix-cst

(defthm cst-escape-sequence-conc2-rep-of-tree-fix-cst
  (equal (cst-escape-sequence-conc2-rep (abnf::tree-fix abnf::cst))
         (cst-escape-sequence-conc2-rep abnf::cst)))

Theorem: cst-escape-sequence-conc2-rep-tree-equiv-congruence-on-cst

(defthm cst-escape-sequence-conc2-rep-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-escape-sequence-conc2-rep abnf::cst)
                  (cst-escape-sequence-conc2-rep cst-equiv)))
  :rule-classes :congruence)

Function: cst-escape-sequence-conc3-rep

(defun cst-escape-sequence-conc3-rep (abnf::cst)
 (declare (xargs :guard (abnf::treep abnf::cst)))
 (declare
     (xargs :guard (and (cst-matchp abnf::cst "escape-sequence")
                        (equal (cst-escape-sequence-conc? abnf::cst)
                               3))))
 (let ((__function__ 'cst-escape-sequence-conc3-rep))
   (declare (ignorable __function__))
   (abnf::tree-list-fix
        (nth 0
             (cst-escape-sequence-conc3 abnf::cst)))))

Theorem: tree-listp-of-cst-escape-sequence-conc3-rep

(defthm tree-listp-of-cst-escape-sequence-conc3-rep
  (b* ((abnf::csts (cst-escape-sequence-conc3-rep abnf::cst)))
    (abnf::tree-listp abnf::csts))
  :rule-classes :rewrite)

Theorem: cst-escape-sequence-conc3-rep-match

(defthm cst-escape-sequence-conc3-rep-match
  (implies
       (and (cst-matchp abnf::cst "escape-sequence")
            (equal (cst-escape-sequence-conc? abnf::cst)
                   3))
       (b* ((abnf::csts (cst-escape-sequence-conc3-rep abnf::cst)))
         (cst-list-rep-matchp abnf::csts
                              "hexadecimal-escape-sequence")))
  :rule-classes :rewrite)

Theorem: cst-escape-sequence-conc3-rep-of-tree-fix-cst

(defthm cst-escape-sequence-conc3-rep-of-tree-fix-cst
  (equal (cst-escape-sequence-conc3-rep (abnf::tree-fix abnf::cst))
         (cst-escape-sequence-conc3-rep abnf::cst)))

Theorem: cst-escape-sequence-conc3-rep-tree-equiv-congruence-on-cst

(defthm cst-escape-sequence-conc3-rep-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-escape-sequence-conc3-rep abnf::cst)
                  (cst-escape-sequence-conc3-rep cst-equiv)))
  :rule-classes :congruence)

Function: cst-escape-sequence-conc4-rep

(defun cst-escape-sequence-conc4-rep (abnf::cst)
 (declare (xargs :guard (abnf::treep abnf::cst)))
 (declare
     (xargs :guard (and (cst-matchp abnf::cst "escape-sequence")
                        (equal (cst-escape-sequence-conc? abnf::cst)
                               4))))
 (let ((__function__ 'cst-escape-sequence-conc4-rep))
   (declare (ignorable __function__))
   (abnf::tree-list-fix
        (nth 0
             (cst-escape-sequence-conc4 abnf::cst)))))

Theorem: tree-listp-of-cst-escape-sequence-conc4-rep

(defthm tree-listp-of-cst-escape-sequence-conc4-rep
  (b* ((abnf::csts (cst-escape-sequence-conc4-rep abnf::cst)))
    (abnf::tree-listp abnf::csts))
  :rule-classes :rewrite)

Theorem: cst-escape-sequence-conc4-rep-match

(defthm cst-escape-sequence-conc4-rep-match
 (implies
     (and (cst-matchp abnf::cst "escape-sequence")
          (equal (cst-escape-sequence-conc? abnf::cst)
                 4))
     (b* ((abnf::csts (cst-escape-sequence-conc4-rep abnf::cst)))
       (cst-list-rep-matchp abnf::csts "universal-character-name")))
 :rule-classes :rewrite)

Theorem: cst-escape-sequence-conc4-rep-of-tree-fix-cst

(defthm cst-escape-sequence-conc4-rep-of-tree-fix-cst
  (equal (cst-escape-sequence-conc4-rep (abnf::tree-fix abnf::cst))
         (cst-escape-sequence-conc4-rep abnf::cst)))

Theorem: cst-escape-sequence-conc4-rep-tree-equiv-congruence-on-cst

(defthm cst-escape-sequence-conc4-rep-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-escape-sequence-conc4-rep abnf::cst)
                  (cst-escape-sequence-conc4-rep cst-equiv)))
  :rule-classes :congruence)

Function: cst-s-char-conc1-rep

(defun cst-s-char-conc1-rep (abnf::cst)
  (declare (xargs :guard (abnf::treep abnf::cst)))
  (declare (xargs :guard (and (cst-matchp abnf::cst "s-char")
                              (equal (cst-s-char-conc? abnf::cst)
                                     1))))
  (let ((__function__ 'cst-s-char-conc1-rep))
    (declare (ignorable __function__))
    (abnf::tree-list-fix (nth 0 (cst-s-char-conc1 abnf::cst)))))

Theorem: tree-listp-of-cst-s-char-conc1-rep

(defthm tree-listp-of-cst-s-char-conc1-rep
  (b* ((abnf::csts (cst-s-char-conc1-rep abnf::cst)))
    (abnf::tree-listp abnf::csts))
  :rule-classes :rewrite)

Theorem: cst-s-char-conc1-rep-match

(defthm cst-s-char-conc1-rep-match
 (implies
     (and (cst-matchp abnf::cst "s-char")
          (equal (cst-s-char-conc? abnf::cst) 1))
     (b* ((abnf::csts (cst-s-char-conc1-rep abnf::cst)))
       (cst-list-rep-matchp
            abnf::csts
            "character-not-double-quote-or-backslash-or-new-line")))
 :rule-classes :rewrite)

Theorem: cst-s-char-conc1-rep-of-tree-fix-cst

(defthm cst-s-char-conc1-rep-of-tree-fix-cst
  (equal (cst-s-char-conc1-rep (abnf::tree-fix abnf::cst))
         (cst-s-char-conc1-rep abnf::cst)))

Theorem: cst-s-char-conc1-rep-tree-equiv-congruence-on-cst

(defthm cst-s-char-conc1-rep-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-s-char-conc1-rep abnf::cst)
                  (cst-s-char-conc1-rep cst-equiv)))
  :rule-classes :congruence)

Function: cst-s-char-conc2-rep

(defun cst-s-char-conc2-rep (abnf::cst)
  (declare (xargs :guard (abnf::treep abnf::cst)))
  (declare (xargs :guard (and (cst-matchp abnf::cst "s-char")
                              (equal (cst-s-char-conc? abnf::cst)
                                     2))))
  (let ((__function__ 'cst-s-char-conc2-rep))
    (declare (ignorable __function__))
    (abnf::tree-list-fix (nth 0 (cst-s-char-conc2 abnf::cst)))))

Theorem: tree-listp-of-cst-s-char-conc2-rep

(defthm tree-listp-of-cst-s-char-conc2-rep
  (b* ((abnf::csts (cst-s-char-conc2-rep abnf::cst)))
    (abnf::tree-listp abnf::csts))
  :rule-classes :rewrite)

Theorem: cst-s-char-conc2-rep-match

(defthm cst-s-char-conc2-rep-match
  (implies (and (cst-matchp abnf::cst "s-char")
                (equal (cst-s-char-conc? abnf::cst) 2))
           (b* ((abnf::csts (cst-s-char-conc2-rep abnf::cst)))
             (cst-list-rep-matchp abnf::csts "escape-sequence")))
  :rule-classes :rewrite)

Theorem: cst-s-char-conc2-rep-of-tree-fix-cst

(defthm cst-s-char-conc2-rep-of-tree-fix-cst
  (equal (cst-s-char-conc2-rep (abnf::tree-fix abnf::cst))
         (cst-s-char-conc2-rep abnf::cst)))

Theorem: cst-s-char-conc2-rep-tree-equiv-congruence-on-cst

(defthm cst-s-char-conc2-rep-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-s-char-conc2-rep abnf::cst)
                  (cst-s-char-conc2-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 "control-line")))
  :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-lexeme-conc4-rep

(defun cst-lexeme-conc4-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)
                                     4))))
  (let ((__function__ 'cst-lexeme-conc4-rep))
    (declare (ignorable __function__))
    (abnf::tree-list-fix (nth 0 (cst-lexeme-conc4 abnf::cst)))))

Theorem: tree-listp-of-cst-lexeme-conc4-rep

(defthm tree-listp-of-cst-lexeme-conc4-rep
  (b* ((abnf::csts (cst-lexeme-conc4-rep abnf::cst)))
    (abnf::tree-listp abnf::csts))
  :rule-classes :rewrite)

Theorem: cst-lexeme-conc4-rep-match

(defthm cst-lexeme-conc4-rep-match
  (implies (and (cst-matchp abnf::cst "lexeme")
                (equal (cst-lexeme-conc? abnf::cst) 4))
           (b* ((abnf::csts (cst-lexeme-conc4-rep abnf::cst)))
             (cst-list-rep-matchp abnf::csts "white-space")))
  :rule-classes :rewrite)

Theorem: cst-lexeme-conc4-rep-of-tree-fix-cst

(defthm cst-lexeme-conc4-rep-of-tree-fix-cst
  (equal (cst-lexeme-conc4-rep (abnf::tree-fix abnf::cst))
         (cst-lexeme-conc4-rep abnf::cst)))

Theorem: cst-lexeme-conc4-rep-tree-equiv-congruence-on-cst

(defthm cst-lexeme-conc4-rep-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-lexeme-conc4-rep abnf::cst)
                  (cst-lexeme-conc4-rep cst-equiv)))
  :rule-classes :congruence)

Function: cst-constant-expression-conc-rep

(defun cst-constant-expression-conc-rep (abnf::cst)
  (declare (xargs :guard (abnf::treep abnf::cst)))
  (declare
       (xargs :guard (cst-matchp abnf::cst "constant-expression")))
  (let ((__function__ 'cst-constant-expression-conc-rep))
    (declare (ignorable __function__))
    (abnf::tree-list-fix
         (nth 0
              (cst-constant-expression-conc abnf::cst)))))

Theorem: tree-listp-of-cst-constant-expression-conc-rep

(defthm tree-listp-of-cst-constant-expression-conc-rep
  (b* ((abnf::csts (cst-constant-expression-conc-rep abnf::cst)))
    (abnf::tree-listp abnf::csts))
  :rule-classes :rewrite)

Theorem: cst-constant-expression-conc-rep-match

(defthm cst-constant-expression-conc-rep-match
 (implies
     (cst-matchp abnf::cst "constant-expression")
     (b* ((abnf::csts (cst-constant-expression-conc-rep abnf::cst)))
       (cst-list-rep-matchp abnf::csts "conditional-expression")))
 :rule-classes :rewrite)

Theorem: cst-constant-expression-conc-rep-of-tree-fix-cst

(defthm cst-constant-expression-conc-rep-of-tree-fix-cst
  (equal
       (cst-constant-expression-conc-rep (abnf::tree-fix abnf::cst))
       (cst-constant-expression-conc-rep abnf::cst)))

Theorem: cst-constant-expression-conc-rep-tree-equiv-congruence-on-cst

(defthm
      cst-constant-expression-conc-rep-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-constant-expression-conc-rep abnf::cst)
                  (cst-constant-expression-conc-rep cst-equiv)))
  :rule-classes :congruence)

Function: cst-attribute-name-conc1-rep

(defun cst-attribute-name-conc1-rep (abnf::cst)
 (declare (xargs :guard (abnf::treep abnf::cst)))
 (declare
      (xargs :guard (and (cst-matchp abnf::cst "attribute-name")
                         (equal (cst-attribute-name-conc? abnf::cst)
                                1))))
 (let ((__function__ 'cst-attribute-name-conc1-rep))
  (declare (ignorable __function__))
  (abnf::tree-list-fix (nth 0
                            (cst-attribute-name-conc1 abnf::cst)))))

Theorem: tree-listp-of-cst-attribute-name-conc1-rep

(defthm tree-listp-of-cst-attribute-name-conc1-rep
  (b* ((abnf::csts (cst-attribute-name-conc1-rep abnf::cst)))
    (abnf::tree-listp abnf::csts))
  :rule-classes :rewrite)

Theorem: cst-attribute-name-conc1-rep-match

(defthm cst-attribute-name-conc1-rep-match
  (implies
       (and (cst-matchp abnf::cst "attribute-name")
            (equal (cst-attribute-name-conc? abnf::cst)
                   1))
       (b* ((abnf::csts (cst-attribute-name-conc1-rep abnf::cst)))
         (cst-list-rep-matchp abnf::csts "identifier")))
  :rule-classes :rewrite)

Theorem: cst-attribute-name-conc1-rep-of-tree-fix-cst

(defthm cst-attribute-name-conc1-rep-of-tree-fix-cst
  (equal (cst-attribute-name-conc1-rep (abnf::tree-fix abnf::cst))
         (cst-attribute-name-conc1-rep abnf::cst)))

Theorem: cst-attribute-name-conc1-rep-tree-equiv-congruence-on-cst

(defthm cst-attribute-name-conc1-rep-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-attribute-name-conc1-rep abnf::cst)
                  (cst-attribute-name-conc1-rep cst-equiv)))
  :rule-classes :congruence)

Function: cst-attribute-name-conc2-rep

(defun cst-attribute-name-conc2-rep (abnf::cst)
 (declare (xargs :guard (abnf::treep abnf::cst)))
 (declare
      (xargs :guard (and (cst-matchp abnf::cst "attribute-name")
                         (equal (cst-attribute-name-conc? abnf::cst)
                                2))))
 (let ((__function__ 'cst-attribute-name-conc2-rep))
  (declare (ignorable __function__))
  (abnf::tree-list-fix (nth 0
                            (cst-attribute-name-conc2 abnf::cst)))))

Theorem: tree-listp-of-cst-attribute-name-conc2-rep

(defthm tree-listp-of-cst-attribute-name-conc2-rep
  (b* ((abnf::csts (cst-attribute-name-conc2-rep abnf::cst)))
    (abnf::tree-listp abnf::csts))
  :rule-classes :rewrite)

Theorem: cst-attribute-name-conc2-rep-match

(defthm cst-attribute-name-conc2-rep-match
  (implies
       (and (cst-matchp abnf::cst "attribute-name")
            (equal (cst-attribute-name-conc? abnf::cst)
                   2))
       (b* ((abnf::csts (cst-attribute-name-conc2-rep abnf::cst)))
         (cst-list-rep-matchp abnf::csts "keyword")))
  :rule-classes :rewrite)

Theorem: cst-attribute-name-conc2-rep-of-tree-fix-cst

(defthm cst-attribute-name-conc2-rep-of-tree-fix-cst
  (equal (cst-attribute-name-conc2-rep (abnf::tree-fix abnf::cst))
         (cst-attribute-name-conc2-rep abnf::cst)))

Theorem: cst-attribute-name-conc2-rep-tree-equiv-congruence-on-cst

(defthm cst-attribute-name-conc2-rep-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-attribute-name-conc2-rep abnf::cst)
                  (cst-attribute-name-conc2-rep cst-equiv)))
  :rule-classes :congruence)

Function: cst-asm-output-operands-conc-rep

(defun cst-asm-output-operands-conc-rep (abnf::cst)
  (declare (xargs :guard (abnf::treep abnf::cst)))
  (declare
       (xargs :guard (cst-matchp abnf::cst "asm-output-operands")))
  (let ((__function__ 'cst-asm-output-operands-conc-rep))
    (declare (ignorable __function__))
    (abnf::tree-list-fix
         (nth 0
              (cst-asm-output-operands-conc abnf::cst)))))

Theorem: tree-listp-of-cst-asm-output-operands-conc-rep

(defthm tree-listp-of-cst-asm-output-operands-conc-rep
  (b* ((abnf::csts (cst-asm-output-operands-conc-rep abnf::cst)))
    (abnf::tree-listp abnf::csts))
  :rule-classes :rewrite)

Theorem: cst-asm-output-operands-conc-rep-match

(defthm cst-asm-output-operands-conc-rep-match
 (implies
     (cst-matchp abnf::cst "asm-output-operands")
     (b* ((abnf::csts (cst-asm-output-operands-conc-rep abnf::cst)))
       (cst-list-rep-matchp
            abnf::csts
            "[ asm-output-operand *( \",\" asm-output-operand ) ]")))
 :rule-classes :rewrite)

Theorem: cst-asm-output-operands-conc-rep-of-tree-fix-cst

(defthm cst-asm-output-operands-conc-rep-of-tree-fix-cst
  (equal
       (cst-asm-output-operands-conc-rep (abnf::tree-fix abnf::cst))
       (cst-asm-output-operands-conc-rep abnf::cst)))

Theorem: cst-asm-output-operands-conc-rep-tree-equiv-congruence-on-cst

(defthm
      cst-asm-output-operands-conc-rep-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-asm-output-operands-conc-rep abnf::cst)
                  (cst-asm-output-operands-conc-rep cst-equiv)))
  :rule-classes :congruence)

Function: cst-asm-input-operands-conc-rep

(defun cst-asm-input-operands-conc-rep (abnf::cst)
  (declare (xargs :guard (abnf::treep abnf::cst)))
  (declare
       (xargs :guard (cst-matchp abnf::cst "asm-input-operands")))
  (let ((__function__ 'cst-asm-input-operands-conc-rep))
    (declare (ignorable __function__))
    (abnf::tree-list-fix
         (nth 0
              (cst-asm-input-operands-conc abnf::cst)))))

Theorem: tree-listp-of-cst-asm-input-operands-conc-rep

(defthm tree-listp-of-cst-asm-input-operands-conc-rep
  (b* ((abnf::csts (cst-asm-input-operands-conc-rep abnf::cst)))
    (abnf::tree-listp abnf::csts))
  :rule-classes :rewrite)

Theorem: cst-asm-input-operands-conc-rep-match

(defthm cst-asm-input-operands-conc-rep-match
 (implies
      (cst-matchp abnf::cst "asm-input-operands")
      (b* ((abnf::csts (cst-asm-input-operands-conc-rep abnf::cst)))
        (cst-list-rep-matchp
             abnf::csts
             "[ asm-input-operand *( \",\" asm-input-operand ) ]")))
 :rule-classes :rewrite)

Theorem: cst-asm-input-operands-conc-rep-of-tree-fix-cst

(defthm cst-asm-input-operands-conc-rep-of-tree-fix-cst
 (equal (cst-asm-input-operands-conc-rep (abnf::tree-fix abnf::cst))
        (cst-asm-input-operands-conc-rep abnf::cst)))

Theorem: cst-asm-input-operands-conc-rep-tree-equiv-congruence-on-cst

(defthm cst-asm-input-operands-conc-rep-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-asm-input-operands-conc-rep abnf::cst)
                  (cst-asm-input-operands-conc-rep cst-equiv)))
  :rule-classes :congruence)

Function: cst-asm-clobbers-conc-rep

(defun cst-asm-clobbers-conc-rep (abnf::cst)
 (declare (xargs :guard (abnf::treep abnf::cst)))
 (declare (xargs :guard (cst-matchp abnf::cst "asm-clobbers")))
 (let ((__function__ 'cst-asm-clobbers-conc-rep))
   (declare (ignorable __function__))
   (abnf::tree-list-fix (nth 0 (cst-asm-clobbers-conc abnf::cst)))))

Theorem: tree-listp-of-cst-asm-clobbers-conc-rep

(defthm tree-listp-of-cst-asm-clobbers-conc-rep
  (b* ((abnf::csts (cst-asm-clobbers-conc-rep abnf::cst)))
    (abnf::tree-listp abnf::csts))
  :rule-classes :rewrite)

Theorem: cst-asm-clobbers-conc-rep-match

(defthm cst-asm-clobbers-conc-rep-match
 (implies
    (cst-matchp abnf::cst "asm-clobbers")
    (b* ((abnf::csts (cst-asm-clobbers-conc-rep abnf::cst)))
      (cst-list-rep-matchp abnf::csts
                           "[ asm-clobber *( \",\" asm-clobber ) ]")))
 :rule-classes :rewrite)

Theorem: cst-asm-clobbers-conc-rep-of-tree-fix-cst

(defthm cst-asm-clobbers-conc-rep-of-tree-fix-cst
  (equal (cst-asm-clobbers-conc-rep (abnf::tree-fix abnf::cst))
         (cst-asm-clobbers-conc-rep abnf::cst)))

Theorem: cst-asm-clobbers-conc-rep-tree-equiv-congruence-on-cst

(defthm cst-asm-clobbers-conc-rep-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-asm-clobbers-conc-rep abnf::cst)
                  (cst-asm-clobbers-conc-rep cst-equiv)))
  :rule-classes :congruence)

Function: cst-asm-goto-labels-conc-rep

(defun cst-asm-goto-labels-conc-rep (abnf::cst)
 (declare (xargs :guard (abnf::treep abnf::cst)))
 (declare (xargs :guard (cst-matchp abnf::cst "asm-goto-labels")))
 (let ((__function__ 'cst-asm-goto-labels-conc-rep))
  (declare (ignorable __function__))
  (abnf::tree-list-fix (nth 0
                            (cst-asm-goto-labels-conc abnf::cst)))))

Theorem: tree-listp-of-cst-asm-goto-labels-conc-rep

(defthm tree-listp-of-cst-asm-goto-labels-conc-rep
  (b* ((abnf::csts (cst-asm-goto-labels-conc-rep abnf::cst)))
    (abnf::tree-listp abnf::csts))
  :rule-classes :rewrite)

Theorem: cst-asm-goto-labels-conc-rep-match

(defthm cst-asm-goto-labels-conc-rep-match
 (implies
      (cst-matchp abnf::cst "asm-goto-labels")
      (b* ((abnf::csts (cst-asm-goto-labels-conc-rep abnf::cst)))
        (cst-list-rep-matchp abnf::csts
                             "[ identifier *( \",\" identifier ) ]")))
 :rule-classes :rewrite)

Theorem: cst-asm-goto-labels-conc-rep-of-tree-fix-cst

(defthm cst-asm-goto-labels-conc-rep-of-tree-fix-cst
  (equal (cst-asm-goto-labels-conc-rep (abnf::tree-fix abnf::cst))
         (cst-asm-goto-labels-conc-rep abnf::cst)))

Theorem: cst-asm-goto-labels-conc-rep-tree-equiv-congruence-on-cst

(defthm cst-asm-goto-labels-conc-rep-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-asm-goto-labels-conc-rep abnf::cst)
                  (cst-asm-goto-labels-conc-rep cst-equiv)))
  :rule-classes :congruence)

Function: cst-type-qualifier-or-attribute-specifier-conc1-rep

(defun cst-type-qualifier-or-attribute-specifier-conc1-rep
       (abnf::cst)
 (declare (xargs :guard (abnf::treep abnf::cst)))
 (declare
  (xargs
   :guard
   (and
    (cst-matchp abnf::cst
                "type-qualifier-or-attribute-specifier")
    (equal
         (cst-type-qualifier-or-attribute-specifier-conc? abnf::cst)
         1))))
 (let ((__function__
            'cst-type-qualifier-or-attribute-specifier-conc1-rep))
  (declare (ignorable __function__))
  (abnf::tree-list-fix
   (nth
     0
     (cst-type-qualifier-or-attribute-specifier-conc1 abnf::cst)))))

Theorem: tree-listp-of-cst-type-qualifier-or-attribute-specifier-conc1-rep

(defthm
  tree-listp-of-cst-type-qualifier-or-attribute-specifier-conc1-rep
  (b* ((abnf::csts (cst-type-qualifier-or-attribute-specifier-conc1-rep
                        abnf::cst)))
    (abnf::tree-listp abnf::csts))
  :rule-classes :rewrite)

Theorem: cst-type-qualifier-or-attribute-specifier-conc1-rep-match

(defthm cst-type-qualifier-or-attribute-specifier-conc1-rep-match
 (implies
  (and
    (cst-matchp abnf::cst
                "type-qualifier-or-attribute-specifier")
    (equal
         (cst-type-qualifier-or-attribute-specifier-conc? abnf::cst)
         1))
  (b* ((abnf::csts (cst-type-qualifier-or-attribute-specifier-conc1-rep
                        abnf::cst)))
    (cst-list-rep-matchp abnf::csts "type-qualifier")))
 :rule-classes :rewrite)

Theorem: cst-type-qualifier-or-attribute-specifier-conc1-rep-of-tree-fix-cst

(defthm
 cst-type-qualifier-or-attribute-specifier-conc1-rep-of-tree-fix-cst
 (equal
   (cst-type-qualifier-or-attribute-specifier-conc1-rep
        (abnf::tree-fix abnf::cst))
   (cst-type-qualifier-or-attribute-specifier-conc1-rep abnf::cst)))

Theorem: cst-type-qualifier-or-attribute-specifier-conc1-rep-tree-equiv-congruence-on-cst

(defthm
 cst-type-qualifier-or-attribute-specifier-conc1-rep-tree-equiv-congruence-on-cst
 (implies
  (abnf::tree-equiv abnf::cst cst-equiv)
  (equal
   (cst-type-qualifier-or-attribute-specifier-conc1-rep abnf::cst)
   (cst-type-qualifier-or-attribute-specifier-conc1-rep cst-equiv)))
 :rule-classes :congruence)

Function: cst-type-qualifier-or-attribute-specifier-conc2-rep

(defun cst-type-qualifier-or-attribute-specifier-conc2-rep
       (abnf::cst)
 (declare (xargs :guard (abnf::treep abnf::cst)))
 (declare
  (xargs
   :guard
   (and
    (cst-matchp abnf::cst
                "type-qualifier-or-attribute-specifier")
    (equal
         (cst-type-qualifier-or-attribute-specifier-conc? abnf::cst)
         2))))
 (let ((__function__
            'cst-type-qualifier-or-attribute-specifier-conc2-rep))
  (declare (ignorable __function__))
  (abnf::tree-list-fix
   (nth
     0
     (cst-type-qualifier-or-attribute-specifier-conc2 abnf::cst)))))

Theorem: tree-listp-of-cst-type-qualifier-or-attribute-specifier-conc2-rep

(defthm
  tree-listp-of-cst-type-qualifier-or-attribute-specifier-conc2-rep
  (b* ((abnf::csts (cst-type-qualifier-or-attribute-specifier-conc2-rep
                        abnf::cst)))
    (abnf::tree-listp abnf::csts))
  :rule-classes :rewrite)

Theorem: cst-type-qualifier-or-attribute-specifier-conc2-rep-match

(defthm cst-type-qualifier-or-attribute-specifier-conc2-rep-match
 (implies
  (and
    (cst-matchp abnf::cst
                "type-qualifier-or-attribute-specifier")
    (equal
         (cst-type-qualifier-or-attribute-specifier-conc? abnf::cst)
         2))
  (b* ((abnf::csts (cst-type-qualifier-or-attribute-specifier-conc2-rep
                        abnf::cst)))
    (cst-list-rep-matchp abnf::csts "attribute-specifier")))
 :rule-classes :rewrite)

Theorem: cst-type-qualifier-or-attribute-specifier-conc2-rep-of-tree-fix-cst

(defthm
 cst-type-qualifier-or-attribute-specifier-conc2-rep-of-tree-fix-cst
 (equal
   (cst-type-qualifier-or-attribute-specifier-conc2-rep
        (abnf::tree-fix abnf::cst))
   (cst-type-qualifier-or-attribute-specifier-conc2-rep abnf::cst)))

Theorem: cst-type-qualifier-or-attribute-specifier-conc2-rep-tree-equiv-congruence-on-cst

(defthm
 cst-type-qualifier-or-attribute-specifier-conc2-rep-tree-equiv-congruence-on-cst
 (implies
  (abnf::tree-equiv abnf::cst cst-equiv)
  (equal
   (cst-type-qualifier-or-attribute-specifier-conc2-rep abnf::cst)
   (cst-type-qualifier-or-attribute-specifier-conc2-rep cst-equiv)))
 :rule-classes :congruence)

Function: cst-typedef-name-conc-rep

(defun cst-typedef-name-conc-rep (abnf::cst)
 (declare (xargs :guard (abnf::treep abnf::cst)))
 (declare (xargs :guard (cst-matchp abnf::cst "typedef-name")))
 (let ((__function__ 'cst-typedef-name-conc-rep))
   (declare (ignorable __function__))
   (abnf::tree-list-fix (nth 0 (cst-typedef-name-conc abnf::cst)))))

Theorem: tree-listp-of-cst-typedef-name-conc-rep

(defthm tree-listp-of-cst-typedef-name-conc-rep
  (b* ((abnf::csts (cst-typedef-name-conc-rep abnf::cst)))
    (abnf::tree-listp abnf::csts))
  :rule-classes :rewrite)

Theorem: cst-typedef-name-conc-rep-match

(defthm cst-typedef-name-conc-rep-match
  (implies (cst-matchp abnf::cst "typedef-name")
           (b* ((abnf::csts (cst-typedef-name-conc-rep abnf::cst)))
             (cst-list-rep-matchp abnf::csts "identifier")))
  :rule-classes :rewrite)

Theorem: cst-typedef-name-conc-rep-of-tree-fix-cst

(defthm cst-typedef-name-conc-rep-of-tree-fix-cst
  (equal (cst-typedef-name-conc-rep (abnf::tree-fix abnf::cst))
         (cst-typedef-name-conc-rep abnf::cst)))

Theorem: cst-typedef-name-conc-rep-tree-equiv-congruence-on-cst

(defthm cst-typedef-name-conc-rep-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-typedef-name-conc-rep abnf::cst)
                  (cst-typedef-name-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 "labeled-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 "compound-statement")))
  :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 "expression-statement")))
  :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 "selection-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 "iteration-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 "jump-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 "asm-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-block-item-conc1-rep

(defun cst-block-item-conc1-rep (abnf::cst)
 (declare (xargs :guard (abnf::treep abnf::cst)))
 (declare (xargs :guard (and (cst-matchp abnf::cst "block-item")
                             (equal (cst-block-item-conc? abnf::cst)
                                    1))))
 (let ((__function__ 'cst-block-item-conc1-rep))
   (declare (ignorable __function__))
   (abnf::tree-list-fix (nth 0 (cst-block-item-conc1 abnf::cst)))))

Theorem: tree-listp-of-cst-block-item-conc1-rep

(defthm tree-listp-of-cst-block-item-conc1-rep
  (b* ((abnf::csts (cst-block-item-conc1-rep abnf::cst)))
    (abnf::tree-listp abnf::csts))
  :rule-classes :rewrite)

Theorem: cst-block-item-conc1-rep-match

(defthm cst-block-item-conc1-rep-match
  (implies (and (cst-matchp abnf::cst "block-item")
                (equal (cst-block-item-conc? abnf::cst)
                       1))
           (b* ((abnf::csts (cst-block-item-conc1-rep abnf::cst)))
             (cst-list-rep-matchp abnf::csts "declaration")))
  :rule-classes :rewrite)

Theorem: cst-block-item-conc1-rep-of-tree-fix-cst

(defthm cst-block-item-conc1-rep-of-tree-fix-cst
  (equal (cst-block-item-conc1-rep (abnf::tree-fix abnf::cst))
         (cst-block-item-conc1-rep abnf::cst)))

Theorem: cst-block-item-conc1-rep-tree-equiv-congruence-on-cst

(defthm cst-block-item-conc1-rep-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-block-item-conc1-rep abnf::cst)
                  (cst-block-item-conc1-rep cst-equiv)))
  :rule-classes :congruence)

Function: cst-block-item-conc2-rep

(defun cst-block-item-conc2-rep (abnf::cst)
 (declare (xargs :guard (abnf::treep abnf::cst)))
 (declare (xargs :guard (and (cst-matchp abnf::cst "block-item")
                             (equal (cst-block-item-conc? abnf::cst)
                                    2))))
 (let ((__function__ 'cst-block-item-conc2-rep))
   (declare (ignorable __function__))
   (abnf::tree-list-fix (nth 0 (cst-block-item-conc2 abnf::cst)))))

Theorem: tree-listp-of-cst-block-item-conc2-rep

(defthm tree-listp-of-cst-block-item-conc2-rep
  (b* ((abnf::csts (cst-block-item-conc2-rep abnf::cst)))
    (abnf::tree-listp abnf::csts))
  :rule-classes :rewrite)

Theorem: cst-block-item-conc2-rep-match

(defthm cst-block-item-conc2-rep-match
  (implies (and (cst-matchp abnf::cst "block-item")
                (equal (cst-block-item-conc? abnf::cst)
                       2))
           (b* ((abnf::csts (cst-block-item-conc2-rep abnf::cst)))
             (cst-list-rep-matchp abnf::csts "statement")))
  :rule-classes :rewrite)

Theorem: cst-block-item-conc2-rep-of-tree-fix-cst

(defthm cst-block-item-conc2-rep-of-tree-fix-cst
  (equal (cst-block-item-conc2-rep (abnf::tree-fix abnf::cst))
         (cst-block-item-conc2-rep abnf::cst)))

Theorem: cst-block-item-conc2-rep-tree-equiv-congruence-on-cst

(defthm cst-block-item-conc2-rep-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-block-item-conc2-rep abnf::cst)
                  (cst-block-item-conc2-rep cst-equiv)))
  :rule-classes :congruence)

Function: cst-preprocessing-file-conc-rep

(defun cst-preprocessing-file-conc-rep (abnf::cst)
  (declare (xargs :guard (abnf::treep abnf::cst)))
  (declare
       (xargs :guard (cst-matchp abnf::cst "preprocessing-file")))
  (let ((__function__ 'cst-preprocessing-file-conc-rep))
    (declare (ignorable __function__))
    (abnf::tree-list-fix
         (nth 0
              (cst-preprocessing-file-conc abnf::cst)))))

Theorem: tree-listp-of-cst-preprocessing-file-conc-rep

(defthm tree-listp-of-cst-preprocessing-file-conc-rep
  (b* ((abnf::csts (cst-preprocessing-file-conc-rep abnf::cst)))
    (abnf::tree-listp abnf::csts))
  :rule-classes :rewrite)

Theorem: cst-preprocessing-file-conc-rep-match

(defthm cst-preprocessing-file-conc-rep-match
 (implies
      (cst-matchp abnf::cst "preprocessing-file")
      (b* ((abnf::csts (cst-preprocessing-file-conc-rep abnf::cst)))
        (cst-list-rep-matchp abnf::csts "[ group ]")))
 :rule-classes :rewrite)

Theorem: cst-preprocessing-file-conc-rep-of-tree-fix-cst

(defthm cst-preprocessing-file-conc-rep-of-tree-fix-cst
 (equal (cst-preprocessing-file-conc-rep (abnf::tree-fix abnf::cst))
        (cst-preprocessing-file-conc-rep abnf::cst)))

Theorem: cst-preprocessing-file-conc-rep-tree-equiv-congruence-on-cst

(defthm cst-preprocessing-file-conc-rep-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-preprocessing-file-conc-rep abnf::cst)
                  (cst-preprocessing-file-conc-rep cst-equiv)))
  :rule-classes :congruence)

Function: cst-lparen-conc-rep

(defun cst-lparen-conc-rep (abnf::cst)
  (declare (xargs :guard (abnf::treep abnf::cst)))
  (declare (xargs :guard (cst-matchp abnf::cst "lparen")))
  (let ((__function__ 'cst-lparen-conc-rep))
    (declare (ignorable __function__))
    (abnf::tree-list-fix (nth 0 (cst-lparen-conc abnf::cst)))))

Theorem: tree-listp-of-cst-lparen-conc-rep

(defthm tree-listp-of-cst-lparen-conc-rep
  (b* ((abnf::csts (cst-lparen-conc-rep abnf::cst)))
    (abnf::tree-listp abnf::csts))
  :rule-classes :rewrite)

Theorem: cst-lparen-conc-rep-match

(defthm cst-lparen-conc-rep-match
  (implies (cst-matchp abnf::cst "lparen")
           (b* ((abnf::csts (cst-lparen-conc-rep abnf::cst)))
             (cst-list-rep-matchp abnf::csts "\"(\"")))
  :rule-classes :rewrite)

Theorem: cst-lparen-conc-rep-of-tree-fix-cst

(defthm cst-lparen-conc-rep-of-tree-fix-cst
  (equal (cst-lparen-conc-rep (abnf::tree-fix abnf::cst))
         (cst-lparen-conc-rep abnf::cst)))

Theorem: cst-lparen-conc-rep-tree-equiv-congruence-on-cst

(defthm cst-lparen-conc-rep-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-lparen-conc-rep abnf::cst)
                  (cst-lparen-conc-rep cst-equiv)))
  :rule-classes :congruence)

Function: cst-replacement-list-conc-rep

(defun cst-replacement-list-conc-rep (abnf::cst)
  (declare (xargs :guard (abnf::treep abnf::cst)))
  (declare (xargs :guard (cst-matchp abnf::cst "replacement-list")))
  (let ((__function__ 'cst-replacement-list-conc-rep))
    (declare (ignorable __function__))
    (abnf::tree-list-fix
         (nth 0
              (cst-replacement-list-conc abnf::cst)))))

Theorem: tree-listp-of-cst-replacement-list-conc-rep

(defthm tree-listp-of-cst-replacement-list-conc-rep
  (b* ((abnf::csts (cst-replacement-list-conc-rep abnf::cst)))
    (abnf::tree-listp abnf::csts))
  :rule-classes :rewrite)

Theorem: cst-replacement-list-conc-rep-match

(defthm cst-replacement-list-conc-rep-match
  (implies
       (cst-matchp abnf::cst "replacement-list")
       (b* ((abnf::csts (cst-replacement-list-conc-rep abnf::cst)))
         (cst-list-rep-matchp abnf::csts "[ pp-tokens ]")))
  :rule-classes :rewrite)

Theorem: cst-replacement-list-conc-rep-of-tree-fix-cst

(defthm cst-replacement-list-conc-rep-of-tree-fix-cst
  (equal (cst-replacement-list-conc-rep (abnf::tree-fix abnf::cst))
         (cst-replacement-list-conc-rep abnf::cst)))

Theorem: cst-replacement-list-conc-rep-tree-equiv-congruence-on-cst

(defthm cst-replacement-list-conc-rep-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-replacement-list-conc-rep abnf::cst)
                  (cst-replacement-list-conc-rep cst-equiv)))
  :rule-classes :congruence)

Function: cst-uppercase-letter-conc-rep-elem

(defun cst-uppercase-letter-conc-rep-elem (abnf::cst)
 (declare (xargs :guard (abnf::treep abnf::cst)))
 (declare (xargs :guard (cst-matchp abnf::cst "uppercase-letter")))
 (let ((__function__ 'cst-uppercase-letter-conc-rep-elem))
  (declare (ignorable __function__))
  (abnf::tree-fix (nth 0
                       (cst-uppercase-letter-conc-rep abnf::cst)))))

Theorem: treep-of-cst-uppercase-letter-conc-rep-elem

(defthm treep-of-cst-uppercase-letter-conc-rep-elem
  (b* ((abnf::cst1 (cst-uppercase-letter-conc-rep-elem abnf::cst)))
    (abnf::treep abnf::cst1))
  :rule-classes :rewrite)

Theorem: cst-uppercase-letter-conc-rep-elem-match

(defthm cst-uppercase-letter-conc-rep-elem-match
 (implies
   (cst-matchp abnf::cst "uppercase-letter")
   (b* ((abnf::cst1 (cst-uppercase-letter-conc-rep-elem abnf::cst)))
     (cst-matchp abnf::cst1 "%x41-5A")))
 :rule-classes :rewrite)

Theorem: cst-uppercase-letter-conc-rep-elem-of-tree-fix-cst

(defthm cst-uppercase-letter-conc-rep-elem-of-tree-fix-cst
 (equal
     (cst-uppercase-letter-conc-rep-elem (abnf::tree-fix abnf::cst))
     (cst-uppercase-letter-conc-rep-elem abnf::cst)))

Theorem: cst-uppercase-letter-conc-rep-elem-tree-equiv-congruence-on-cst

(defthm
    cst-uppercase-letter-conc-rep-elem-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-uppercase-letter-conc-rep-elem abnf::cst)
                  (cst-uppercase-letter-conc-rep-elem cst-equiv)))
  :rule-classes :congruence)

Function: cst-lowercase-letter-conc-rep-elem

(defun cst-lowercase-letter-conc-rep-elem (abnf::cst)
 (declare (xargs :guard (abnf::treep abnf::cst)))
 (declare (xargs :guard (cst-matchp abnf::cst "lowercase-letter")))
 (let ((__function__ 'cst-lowercase-letter-conc-rep-elem))
  (declare (ignorable __function__))
  (abnf::tree-fix (nth 0
                       (cst-lowercase-letter-conc-rep abnf::cst)))))

Theorem: treep-of-cst-lowercase-letter-conc-rep-elem

(defthm treep-of-cst-lowercase-letter-conc-rep-elem
  (b* ((abnf::cst1 (cst-lowercase-letter-conc-rep-elem abnf::cst)))
    (abnf::treep abnf::cst1))
  :rule-classes :rewrite)

Theorem: cst-lowercase-letter-conc-rep-elem-match

(defthm cst-lowercase-letter-conc-rep-elem-match
 (implies
   (cst-matchp abnf::cst "lowercase-letter")
   (b* ((abnf::cst1 (cst-lowercase-letter-conc-rep-elem abnf::cst)))
     (cst-matchp abnf::cst1 "%x61-7A")))
 :rule-classes :rewrite)

Theorem: cst-lowercase-letter-conc-rep-elem-of-tree-fix-cst

(defthm cst-lowercase-letter-conc-rep-elem-of-tree-fix-cst
 (equal
     (cst-lowercase-letter-conc-rep-elem (abnf::tree-fix abnf::cst))
     (cst-lowercase-letter-conc-rep-elem abnf::cst)))

Theorem: cst-lowercase-letter-conc-rep-elem-tree-equiv-congruence-on-cst

(defthm
    cst-lowercase-letter-conc-rep-elem-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-lowercase-letter-conc-rep-elem abnf::cst)
                  (cst-lowercase-letter-conc-rep-elem cst-equiv)))
  :rule-classes :congruence)

Function: cst-letter-conc1-rep-elem

(defun cst-letter-conc1-rep-elem (abnf::cst)
  (declare (xargs :guard (abnf::treep abnf::cst)))
  (declare (xargs :guard (and (cst-matchp abnf::cst "letter")
                              (equal (cst-letter-conc? abnf::cst)
                                     1))))
  (let ((__function__ 'cst-letter-conc1-rep-elem))
    (declare (ignorable __function__))
    (abnf::tree-fix (nth 0 (cst-letter-conc1-rep abnf::cst)))))

Theorem: treep-of-cst-letter-conc1-rep-elem

(defthm treep-of-cst-letter-conc1-rep-elem
  (b* ((abnf::cst1 (cst-letter-conc1-rep-elem abnf::cst)))
    (abnf::treep abnf::cst1))
  :rule-classes :rewrite)

Theorem: cst-letter-conc1-rep-elem-match

(defthm cst-letter-conc1-rep-elem-match
  (implies (and (cst-matchp abnf::cst "letter")
                (equal (cst-letter-conc? abnf::cst) 1))
           (b* ((abnf::cst1 (cst-letter-conc1-rep-elem abnf::cst)))
             (cst-matchp abnf::cst1 "uppercase-letter")))
  :rule-classes :rewrite)

Theorem: cst-letter-conc1-rep-elem-of-tree-fix-cst

(defthm cst-letter-conc1-rep-elem-of-tree-fix-cst
  (equal (cst-letter-conc1-rep-elem (abnf::tree-fix abnf::cst))
         (cst-letter-conc1-rep-elem abnf::cst)))

Theorem: cst-letter-conc1-rep-elem-tree-equiv-congruence-on-cst

(defthm cst-letter-conc1-rep-elem-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-letter-conc1-rep-elem abnf::cst)
                  (cst-letter-conc1-rep-elem cst-equiv)))
  :rule-classes :congruence)

Function: cst-letter-conc2-rep-elem

(defun cst-letter-conc2-rep-elem (abnf::cst)
  (declare (xargs :guard (abnf::treep abnf::cst)))
  (declare (xargs :guard (and (cst-matchp abnf::cst "letter")
                              (equal (cst-letter-conc? abnf::cst)
                                     2))))
  (let ((__function__ 'cst-letter-conc2-rep-elem))
    (declare (ignorable __function__))
    (abnf::tree-fix (nth 0 (cst-letter-conc2-rep abnf::cst)))))

Theorem: treep-of-cst-letter-conc2-rep-elem

(defthm treep-of-cst-letter-conc2-rep-elem
  (b* ((abnf::cst1 (cst-letter-conc2-rep-elem abnf::cst)))
    (abnf::treep abnf::cst1))
  :rule-classes :rewrite)

Theorem: cst-letter-conc2-rep-elem-match

(defthm cst-letter-conc2-rep-elem-match
  (implies (and (cst-matchp abnf::cst "letter")
                (equal (cst-letter-conc? abnf::cst) 2))
           (b* ((abnf::cst1 (cst-letter-conc2-rep-elem abnf::cst)))
             (cst-matchp abnf::cst1 "lowercase-letter")))
  :rule-classes :rewrite)

Theorem: cst-letter-conc2-rep-elem-of-tree-fix-cst

(defthm cst-letter-conc2-rep-elem-of-tree-fix-cst
  (equal (cst-letter-conc2-rep-elem (abnf::tree-fix abnf::cst))
         (cst-letter-conc2-rep-elem abnf::cst)))

Theorem: cst-letter-conc2-rep-elem-tree-equiv-congruence-on-cst

(defthm cst-letter-conc2-rep-elem-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-letter-conc2-rep-elem abnf::cst)
                  (cst-letter-conc2-rep-elem cst-equiv)))
  :rule-classes :congruence)

Function: cst-digit-conc-rep-elem

(defun cst-digit-conc-rep-elem (abnf::cst)
  (declare (xargs :guard (abnf::treep abnf::cst)))
  (declare (xargs :guard (cst-matchp abnf::cst "digit")))
  (let ((__function__ 'cst-digit-conc-rep-elem))
    (declare (ignorable __function__))
    (abnf::tree-fix (nth 0 (cst-digit-conc-rep abnf::cst)))))

Theorem: treep-of-cst-digit-conc-rep-elem

(defthm treep-of-cst-digit-conc-rep-elem
  (b* ((abnf::cst1 (cst-digit-conc-rep-elem abnf::cst)))
    (abnf::treep abnf::cst1))
  :rule-classes :rewrite)

Theorem: cst-digit-conc-rep-elem-match

(defthm cst-digit-conc-rep-elem-match
  (implies (cst-matchp abnf::cst "digit")
           (b* ((abnf::cst1 (cst-digit-conc-rep-elem abnf::cst)))
             (cst-matchp abnf::cst1 "%x30-39")))
  :rule-classes :rewrite)

Theorem: cst-digit-conc-rep-elem-of-tree-fix-cst

(defthm cst-digit-conc-rep-elem-of-tree-fix-cst
  (equal (cst-digit-conc-rep-elem (abnf::tree-fix abnf::cst))
         (cst-digit-conc-rep-elem abnf::cst)))

Theorem: cst-digit-conc-rep-elem-tree-equiv-congruence-on-cst

(defthm cst-digit-conc-rep-elem-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-digit-conc-rep-elem abnf::cst)
                  (cst-digit-conc-rep-elem cst-equiv)))
  :rule-classes :congruence)

Function: cst-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-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-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-vertical-tab-conc-rep-elem

(defun cst-vertical-tab-conc-rep-elem (abnf::cst)
  (declare (xargs :guard (abnf::treep abnf::cst)))
  (declare (xargs :guard (cst-matchp abnf::cst "vertical-tab")))
  (let ((__function__ 'cst-vertical-tab-conc-rep-elem))
    (declare (ignorable __function__))
    (abnf::tree-fix (nth 0
                         (cst-vertical-tab-conc-rep abnf::cst)))))

Theorem: treep-of-cst-vertical-tab-conc-rep-elem

(defthm treep-of-cst-vertical-tab-conc-rep-elem
  (b* ((abnf::cst1 (cst-vertical-tab-conc-rep-elem abnf::cst)))
    (abnf::treep abnf::cst1))
  :rule-classes :rewrite)

Theorem: cst-vertical-tab-conc-rep-elem-match

(defthm cst-vertical-tab-conc-rep-elem-match
  (implies
       (cst-matchp abnf::cst "vertical-tab")
       (b* ((abnf::cst1 (cst-vertical-tab-conc-rep-elem abnf::cst)))
         (cst-matchp abnf::cst1 "%xB")))
  :rule-classes :rewrite)

Theorem: cst-vertical-tab-conc-rep-elem-of-tree-fix-cst

(defthm cst-vertical-tab-conc-rep-elem-of-tree-fix-cst
  (equal (cst-vertical-tab-conc-rep-elem (abnf::tree-fix abnf::cst))
         (cst-vertical-tab-conc-rep-elem abnf::cst)))

Theorem: cst-vertical-tab-conc-rep-elem-tree-equiv-congruence-on-cst

(defthm cst-vertical-tab-conc-rep-elem-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-vertical-tab-conc-rep-elem abnf::cst)
                  (cst-vertical-tab-conc-rep-elem cst-equiv)))
  :rule-classes :congruence)

Function: cst-form-feed-conc-rep-elem

(defun cst-form-feed-conc-rep-elem (abnf::cst)
  (declare (xargs :guard (abnf::treep abnf::cst)))
  (declare (xargs :guard (cst-matchp abnf::cst "form-feed")))
  (let ((__function__ 'cst-form-feed-conc-rep-elem))
    (declare (ignorable __function__))
    (abnf::tree-fix (nth 0 (cst-form-feed-conc-rep abnf::cst)))))

Theorem: treep-of-cst-form-feed-conc-rep-elem

(defthm treep-of-cst-form-feed-conc-rep-elem
  (b* ((abnf::cst1 (cst-form-feed-conc-rep-elem abnf::cst)))
    (abnf::treep abnf::cst1))
  :rule-classes :rewrite)

Theorem: cst-form-feed-conc-rep-elem-match

(defthm cst-form-feed-conc-rep-elem-match
 (implies (cst-matchp abnf::cst "form-feed")
          (b* ((abnf::cst1 (cst-form-feed-conc-rep-elem abnf::cst)))
            (cst-matchp abnf::cst1 "%xC")))
 :rule-classes :rewrite)

Theorem: cst-form-feed-conc-rep-elem-of-tree-fix-cst

(defthm cst-form-feed-conc-rep-elem-of-tree-fix-cst
  (equal (cst-form-feed-conc-rep-elem (abnf::tree-fix abnf::cst))
         (cst-form-feed-conc-rep-elem abnf::cst)))

Theorem: cst-form-feed-conc-rep-elem-tree-equiv-congruence-on-cst

(defthm cst-form-feed-conc-rep-elem-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-form-feed-conc-rep-elem abnf::cst)
                  (cst-form-feed-conc-rep-elem cst-equiv)))
  :rule-classes :congruence)

Function: cst-control-character-conc1-rep-elem

(defun cst-control-character-conc1-rep-elem (abnf::cst)
 (declare (xargs :guard (abnf::treep abnf::cst)))
 (declare
   (xargs :guard (and (cst-matchp abnf::cst "control-character")
                      (equal (cst-control-character-conc? abnf::cst)
                             1))))
 (let ((__function__ 'cst-control-character-conc1-rep-elem))
   (declare (ignorable __function__))
   (abnf::tree-fix
        (nth 0
             (cst-control-character-conc1-rep abnf::cst)))))

Theorem: treep-of-cst-control-character-conc1-rep-elem

(defthm treep-of-cst-control-character-conc1-rep-elem
 (b* ((abnf::cst1 (cst-control-character-conc1-rep-elem abnf::cst)))
   (abnf::treep abnf::cst1))
 :rule-classes :rewrite)

Theorem: cst-control-character-conc1-rep-elem-match

(defthm cst-control-character-conc1-rep-elem-match
 (implies
   (and (cst-matchp abnf::cst "control-character")
        (equal (cst-control-character-conc? abnf::cst)
               1))
   (b*
     ((abnf::cst1 (cst-control-character-conc1-rep-elem abnf::cst)))
     (cst-matchp abnf::cst1 "horizontal-tab")))
 :rule-classes :rewrite)

Theorem: cst-control-character-conc1-rep-elem-of-tree-fix-cst

(defthm cst-control-character-conc1-rep-elem-of-tree-fix-cst
 (equal
   (cst-control-character-conc1-rep-elem (abnf::tree-fix abnf::cst))
   (cst-control-character-conc1-rep-elem abnf::cst)))

Theorem: cst-control-character-conc1-rep-elem-tree-equiv-congruence-on-cst

(defthm
  cst-control-character-conc1-rep-elem-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-control-character-conc1-rep-elem abnf::cst)
                  (cst-control-character-conc1-rep-elem cst-equiv)))
  :rule-classes :congruence)

Function: cst-control-character-conc2-rep-elem

(defun cst-control-character-conc2-rep-elem (abnf::cst)
 (declare (xargs :guard (abnf::treep abnf::cst)))
 (declare
   (xargs :guard (and (cst-matchp abnf::cst "control-character")
                      (equal (cst-control-character-conc? abnf::cst)
                             2))))
 (let ((__function__ 'cst-control-character-conc2-rep-elem))
   (declare (ignorable __function__))
   (abnf::tree-fix
        (nth 0
             (cst-control-character-conc2-rep abnf::cst)))))

Theorem: treep-of-cst-control-character-conc2-rep-elem

(defthm treep-of-cst-control-character-conc2-rep-elem
 (b* ((abnf::cst1 (cst-control-character-conc2-rep-elem abnf::cst)))
   (abnf::treep abnf::cst1))
 :rule-classes :rewrite)

Theorem: cst-control-character-conc2-rep-elem-match

(defthm cst-control-character-conc2-rep-elem-match
 (implies
   (and (cst-matchp abnf::cst "control-character")
        (equal (cst-control-character-conc? abnf::cst)
               2))
   (b*
     ((abnf::cst1 (cst-control-character-conc2-rep-elem abnf::cst)))
     (cst-matchp abnf::cst1 "vertical-tab")))
 :rule-classes :rewrite)

Theorem: cst-control-character-conc2-rep-elem-of-tree-fix-cst

(defthm cst-control-character-conc2-rep-elem-of-tree-fix-cst
 (equal
   (cst-control-character-conc2-rep-elem (abnf::tree-fix abnf::cst))
   (cst-control-character-conc2-rep-elem abnf::cst)))

Theorem: cst-control-character-conc2-rep-elem-tree-equiv-congruence-on-cst

(defthm
  cst-control-character-conc2-rep-elem-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-control-character-conc2-rep-elem abnf::cst)
                  (cst-control-character-conc2-rep-elem cst-equiv)))
  :rule-classes :congruence)

Function: cst-control-character-conc3-rep-elem

(defun cst-control-character-conc3-rep-elem (abnf::cst)
 (declare (xargs :guard (abnf::treep abnf::cst)))
 (declare
   (xargs :guard (and (cst-matchp abnf::cst "control-character")
                      (equal (cst-control-character-conc? abnf::cst)
                             3))))
 (let ((__function__ 'cst-control-character-conc3-rep-elem))
   (declare (ignorable __function__))
   (abnf::tree-fix
        (nth 0
             (cst-control-character-conc3-rep abnf::cst)))))

Theorem: treep-of-cst-control-character-conc3-rep-elem

(defthm treep-of-cst-control-character-conc3-rep-elem
 (b* ((abnf::cst1 (cst-control-character-conc3-rep-elem abnf::cst)))
   (abnf::treep abnf::cst1))
 :rule-classes :rewrite)

Theorem: cst-control-character-conc3-rep-elem-match

(defthm cst-control-character-conc3-rep-elem-match
 (implies
   (and (cst-matchp abnf::cst "control-character")
        (equal (cst-control-character-conc? abnf::cst)
               3))
   (b*
     ((abnf::cst1 (cst-control-character-conc3-rep-elem abnf::cst)))
     (cst-matchp abnf::cst1 "form-feed")))
 :rule-classes :rewrite)

Theorem: cst-control-character-conc3-rep-elem-of-tree-fix-cst

(defthm cst-control-character-conc3-rep-elem-of-tree-fix-cst
 (equal
   (cst-control-character-conc3-rep-elem (abnf::tree-fix abnf::cst))
   (cst-control-character-conc3-rep-elem abnf::cst)))

Theorem: cst-control-character-conc3-rep-elem-tree-equiv-congruence-on-cst

(defthm
  cst-control-character-conc3-rep-elem-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-control-character-conc3-rep-elem abnf::cst)
                  (cst-control-character-conc3-rep-elem cst-equiv)))
  :rule-classes :congruence)

Function: cst-basic-character-conc1-rep-elem

(defun cst-basic-character-conc1-rep-elem (abnf::cst)
 (declare (xargs :guard (abnf::treep abnf::cst)))
 (declare
     (xargs :guard (and (cst-matchp abnf::cst "basic-character")
                        (equal (cst-basic-character-conc? abnf::cst)
                               1))))
 (let ((__function__ 'cst-basic-character-conc1-rep-elem))
  (declare (ignorable __function__))
  (abnf::tree-fix (nth 0
                       (cst-basic-character-conc1-rep abnf::cst)))))

Theorem: treep-of-cst-basic-character-conc1-rep-elem

(defthm treep-of-cst-basic-character-conc1-rep-elem
  (b* ((abnf::cst1 (cst-basic-character-conc1-rep-elem abnf::cst)))
    (abnf::treep abnf::cst1))
  :rule-classes :rewrite)

Theorem: cst-basic-character-conc1-rep-elem-match

(defthm cst-basic-character-conc1-rep-elem-match
 (implies
   (and (cst-matchp abnf::cst "basic-character")
        (equal (cst-basic-character-conc? abnf::cst)
               1))
   (b* ((abnf::cst1 (cst-basic-character-conc1-rep-elem abnf::cst)))
     (cst-matchp abnf::cst1 "letter")))
 :rule-classes :rewrite)

Theorem: cst-basic-character-conc1-rep-elem-of-tree-fix-cst

(defthm cst-basic-character-conc1-rep-elem-of-tree-fix-cst
 (equal
     (cst-basic-character-conc1-rep-elem (abnf::tree-fix abnf::cst))
     (cst-basic-character-conc1-rep-elem abnf::cst)))

Theorem: cst-basic-character-conc1-rep-elem-tree-equiv-congruence-on-cst

(defthm
    cst-basic-character-conc1-rep-elem-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-basic-character-conc1-rep-elem abnf::cst)
                  (cst-basic-character-conc1-rep-elem cst-equiv)))
  :rule-classes :congruence)

Function: cst-basic-character-conc2-rep-elem

(defun cst-basic-character-conc2-rep-elem (abnf::cst)
 (declare (xargs :guard (abnf::treep abnf::cst)))
 (declare
     (xargs :guard (and (cst-matchp abnf::cst "basic-character")
                        (equal (cst-basic-character-conc? abnf::cst)
                               2))))
 (let ((__function__ 'cst-basic-character-conc2-rep-elem))
  (declare (ignorable __function__))
  (abnf::tree-fix (nth 0
                       (cst-basic-character-conc2-rep abnf::cst)))))

Theorem: treep-of-cst-basic-character-conc2-rep-elem

(defthm treep-of-cst-basic-character-conc2-rep-elem
  (b* ((abnf::cst1 (cst-basic-character-conc2-rep-elem abnf::cst)))
    (abnf::treep abnf::cst1))
  :rule-classes :rewrite)

Theorem: cst-basic-character-conc2-rep-elem-match

(defthm cst-basic-character-conc2-rep-elem-match
 (implies
   (and (cst-matchp abnf::cst "basic-character")
        (equal (cst-basic-character-conc? abnf::cst)
               2))
   (b* ((abnf::cst1 (cst-basic-character-conc2-rep-elem abnf::cst)))
     (cst-matchp abnf::cst1 "digit")))
 :rule-classes :rewrite)

Theorem: cst-basic-character-conc2-rep-elem-of-tree-fix-cst

(defthm cst-basic-character-conc2-rep-elem-of-tree-fix-cst
 (equal
     (cst-basic-character-conc2-rep-elem (abnf::tree-fix abnf::cst))
     (cst-basic-character-conc2-rep-elem abnf::cst)))

Theorem: cst-basic-character-conc2-rep-elem-tree-equiv-congruence-on-cst

(defthm
    cst-basic-character-conc2-rep-elem-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-basic-character-conc2-rep-elem abnf::cst)
                  (cst-basic-character-conc2-rep-elem cst-equiv)))
  :rule-classes :congruence)

Function: cst-basic-character-conc3-rep-elem

(defun cst-basic-character-conc3-rep-elem (abnf::cst)
 (declare (xargs :guard (abnf::treep abnf::cst)))
 (declare
     (xargs :guard (and (cst-matchp abnf::cst "basic-character")
                        (equal (cst-basic-character-conc? abnf::cst)
                               3))))
 (let ((__function__ 'cst-basic-character-conc3-rep-elem))
  (declare (ignorable __function__))
  (abnf::tree-fix (nth 0
                       (cst-basic-character-conc3-rep abnf::cst)))))

Theorem: treep-of-cst-basic-character-conc3-rep-elem

(defthm treep-of-cst-basic-character-conc3-rep-elem
  (b* ((abnf::cst1 (cst-basic-character-conc3-rep-elem abnf::cst)))
    (abnf::treep abnf::cst1))
  :rule-classes :rewrite)

Theorem: cst-basic-character-conc3-rep-elem-match

(defthm cst-basic-character-conc3-rep-elem-match
 (implies
   (and (cst-matchp abnf::cst "basic-character")
        (equal (cst-basic-character-conc? abnf::cst)
               3))
   (b* ((abnf::cst1 (cst-basic-character-conc3-rep-elem abnf::cst)))
     (cst-matchp abnf::cst1 "graphic-character")))
 :rule-classes :rewrite)

Theorem: cst-basic-character-conc3-rep-elem-of-tree-fix-cst

(defthm cst-basic-character-conc3-rep-elem-of-tree-fix-cst
 (equal
     (cst-basic-character-conc3-rep-elem (abnf::tree-fix abnf::cst))
     (cst-basic-character-conc3-rep-elem abnf::cst)))

Theorem: cst-basic-character-conc3-rep-elem-tree-equiv-congruence-on-cst

(defthm
    cst-basic-character-conc3-rep-elem-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-basic-character-conc3-rep-elem abnf::cst)
                  (cst-basic-character-conc3-rep-elem cst-equiv)))
  :rule-classes :congruence)

Function: cst-basic-character-conc4-rep-elem

(defun cst-basic-character-conc4-rep-elem (abnf::cst)
 (declare (xargs :guard (abnf::treep abnf::cst)))
 (declare
     (xargs :guard (and (cst-matchp abnf::cst "basic-character")
                        (equal (cst-basic-character-conc? abnf::cst)
                               4))))
 (let ((__function__ 'cst-basic-character-conc4-rep-elem))
  (declare (ignorable __function__))
  (abnf::tree-fix (nth 0
                       (cst-basic-character-conc4-rep abnf::cst)))))

Theorem: treep-of-cst-basic-character-conc4-rep-elem

(defthm treep-of-cst-basic-character-conc4-rep-elem
  (b* ((abnf::cst1 (cst-basic-character-conc4-rep-elem abnf::cst)))
    (abnf::treep abnf::cst1))
  :rule-classes :rewrite)

Theorem: cst-basic-character-conc4-rep-elem-match

(defthm cst-basic-character-conc4-rep-elem-match
 (implies
   (and (cst-matchp abnf::cst "basic-character")
        (equal (cst-basic-character-conc? abnf::cst)
               4))
   (b* ((abnf::cst1 (cst-basic-character-conc4-rep-elem abnf::cst)))
     (cst-matchp abnf::cst1 "space")))
 :rule-classes :rewrite)

Theorem: cst-basic-character-conc4-rep-elem-of-tree-fix-cst

(defthm cst-basic-character-conc4-rep-elem-of-tree-fix-cst
 (equal
     (cst-basic-character-conc4-rep-elem (abnf::tree-fix abnf::cst))
     (cst-basic-character-conc4-rep-elem abnf::cst)))

Theorem: cst-basic-character-conc4-rep-elem-tree-equiv-congruence-on-cst

(defthm
    cst-basic-character-conc4-rep-elem-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-basic-character-conc4-rep-elem abnf::cst)
                  (cst-basic-character-conc4-rep-elem cst-equiv)))
  :rule-classes :congruence)

Function: cst-basic-character-conc5-rep-elem

(defun cst-basic-character-conc5-rep-elem (abnf::cst)
 (declare (xargs :guard (abnf::treep abnf::cst)))
 (declare
     (xargs :guard (and (cst-matchp abnf::cst "basic-character")
                        (equal (cst-basic-character-conc? abnf::cst)
                               5))))
 (let ((__function__ 'cst-basic-character-conc5-rep-elem))
  (declare (ignorable __function__))
  (abnf::tree-fix (nth 0
                       (cst-basic-character-conc5-rep abnf::cst)))))

Theorem: treep-of-cst-basic-character-conc5-rep-elem

(defthm treep-of-cst-basic-character-conc5-rep-elem
  (b* ((abnf::cst1 (cst-basic-character-conc5-rep-elem abnf::cst)))
    (abnf::treep abnf::cst1))
  :rule-classes :rewrite)

Theorem: cst-basic-character-conc5-rep-elem-match

(defthm cst-basic-character-conc5-rep-elem-match
 (implies
   (and (cst-matchp abnf::cst "basic-character")
        (equal (cst-basic-character-conc? abnf::cst)
               5))
   (b* ((abnf::cst1 (cst-basic-character-conc5-rep-elem abnf::cst)))
     (cst-matchp abnf::cst1 "control-character")))
 :rule-classes :rewrite)

Theorem: cst-basic-character-conc5-rep-elem-of-tree-fix-cst

(defthm cst-basic-character-conc5-rep-elem-of-tree-fix-cst
 (equal
     (cst-basic-character-conc5-rep-elem (abnf::tree-fix abnf::cst))
     (cst-basic-character-conc5-rep-elem abnf::cst)))

Theorem: cst-basic-character-conc5-rep-elem-tree-equiv-congruence-on-cst

(defthm
    cst-basic-character-conc5-rep-elem-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-basic-character-conc5-rep-elem abnf::cst)
                  (cst-basic-character-conc5-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-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 "basic-character")))
  :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 "extended-character")))
  :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-basic-character-not-star-conc1-rep-elem

(defun cst-basic-character-not-star-conc1-rep-elem (abnf::cst)
 (declare (xargs :guard (abnf::treep abnf::cst)))
 (declare
  (xargs
   :guard (and (cst-matchp abnf::cst "basic-character-not-star")
               (equal (cst-basic-character-not-star-conc? abnf::cst)
                      1))))
 (let ((__function__ 'cst-basic-character-not-star-conc1-rep-elem))
   (declare (ignorable __function__))
   (abnf::tree-fix
        (nth 0
             (cst-basic-character-not-star-conc1-rep abnf::cst)))))

Theorem: treep-of-cst-basic-character-not-star-conc1-rep-elem

(defthm treep-of-cst-basic-character-not-star-conc1-rep-elem
 (b* ((abnf::cst1
           (cst-basic-character-not-star-conc1-rep-elem abnf::cst)))
   (abnf::treep abnf::cst1))
 :rule-classes :rewrite)

Theorem: cst-basic-character-not-star-conc1-rep-elem-match

(defthm cst-basic-character-not-star-conc1-rep-elem-match
 (implies
   (and (cst-matchp abnf::cst "basic-character-not-star")
        (equal (cst-basic-character-not-star-conc? abnf::cst)
               1))
   (b*
     ((abnf::cst1
           (cst-basic-character-not-star-conc1-rep-elem abnf::cst)))
     (cst-matchp abnf::cst1 "letter")))
 :rule-classes :rewrite)

Theorem: cst-basic-character-not-star-conc1-rep-elem-of-tree-fix-cst

(defthm cst-basic-character-not-star-conc1-rep-elem-of-tree-fix-cst
  (equal (cst-basic-character-not-star-conc1-rep-elem
              (abnf::tree-fix abnf::cst))
         (cst-basic-character-not-star-conc1-rep-elem abnf::cst)))

Theorem: cst-basic-character-not-star-conc1-rep-elem-tree-equiv-congruence-on-cst

(defthm
 cst-basic-character-not-star-conc1-rep-elem-tree-equiv-congruence-on-cst
 (implies
    (abnf::tree-equiv abnf::cst cst-equiv)
    (equal (cst-basic-character-not-star-conc1-rep-elem abnf::cst)
           (cst-basic-character-not-star-conc1-rep-elem cst-equiv)))
 :rule-classes :congruence)

Function: cst-basic-character-not-star-conc2-rep-elem

(defun cst-basic-character-not-star-conc2-rep-elem (abnf::cst)
 (declare (xargs :guard (abnf::treep abnf::cst)))
 (declare
  (xargs
   :guard (and (cst-matchp abnf::cst "basic-character-not-star")
               (equal (cst-basic-character-not-star-conc? abnf::cst)
                      2))))
 (let ((__function__ 'cst-basic-character-not-star-conc2-rep-elem))
   (declare (ignorable __function__))
   (abnf::tree-fix
        (nth 0
             (cst-basic-character-not-star-conc2-rep abnf::cst)))))

Theorem: treep-of-cst-basic-character-not-star-conc2-rep-elem

(defthm treep-of-cst-basic-character-not-star-conc2-rep-elem
 (b* ((abnf::cst1
           (cst-basic-character-not-star-conc2-rep-elem abnf::cst)))
   (abnf::treep abnf::cst1))
 :rule-classes :rewrite)

Theorem: cst-basic-character-not-star-conc2-rep-elem-match

(defthm cst-basic-character-not-star-conc2-rep-elem-match
 (implies
   (and (cst-matchp abnf::cst "basic-character-not-star")
        (equal (cst-basic-character-not-star-conc? abnf::cst)
               2))
   (b*
     ((abnf::cst1
           (cst-basic-character-not-star-conc2-rep-elem abnf::cst)))
     (cst-matchp abnf::cst1 "digit")))
 :rule-classes :rewrite)

Theorem: cst-basic-character-not-star-conc2-rep-elem-of-tree-fix-cst

(defthm cst-basic-character-not-star-conc2-rep-elem-of-tree-fix-cst
  (equal (cst-basic-character-not-star-conc2-rep-elem
              (abnf::tree-fix abnf::cst))
         (cst-basic-character-not-star-conc2-rep-elem abnf::cst)))

Theorem: cst-basic-character-not-star-conc2-rep-elem-tree-equiv-congruence-on-cst

(defthm
 cst-basic-character-not-star-conc2-rep-elem-tree-equiv-congruence-on-cst
 (implies
    (abnf::tree-equiv abnf::cst cst-equiv)
    (equal (cst-basic-character-not-star-conc2-rep-elem abnf::cst)
           (cst-basic-character-not-star-conc2-rep-elem cst-equiv)))
 :rule-classes :congruence)

Function: cst-basic-character-not-star-conc3-rep-elem

(defun cst-basic-character-not-star-conc3-rep-elem (abnf::cst)
 (declare (xargs :guard (abnf::treep abnf::cst)))
 (declare
  (xargs
   :guard (and (cst-matchp abnf::cst "basic-character-not-star")
               (equal (cst-basic-character-not-star-conc? abnf::cst)
                      3))))
 (let ((__function__ 'cst-basic-character-not-star-conc3-rep-elem))
   (declare (ignorable __function__))
   (abnf::tree-fix
        (nth 0
             (cst-basic-character-not-star-conc3-rep abnf::cst)))))

Theorem: treep-of-cst-basic-character-not-star-conc3-rep-elem

(defthm treep-of-cst-basic-character-not-star-conc3-rep-elem
 (b* ((abnf::cst1
           (cst-basic-character-not-star-conc3-rep-elem abnf::cst)))
   (abnf::treep abnf::cst1))
 :rule-classes :rewrite)

Theorem: cst-basic-character-not-star-conc3-rep-elem-match

(defthm cst-basic-character-not-star-conc3-rep-elem-match
 (implies
   (and (cst-matchp abnf::cst "basic-character-not-star")
        (equal (cst-basic-character-not-star-conc? abnf::cst)
               3))
   (b*
     ((abnf::cst1
           (cst-basic-character-not-star-conc3-rep-elem abnf::cst)))
     (cst-matchp abnf::cst1
                 "graphic-character-not-star")))
 :rule-classes :rewrite)

Theorem: cst-basic-character-not-star-conc3-rep-elem-of-tree-fix-cst

(defthm cst-basic-character-not-star-conc3-rep-elem-of-tree-fix-cst
  (equal (cst-basic-character-not-star-conc3-rep-elem
              (abnf::tree-fix abnf::cst))
         (cst-basic-character-not-star-conc3-rep-elem abnf::cst)))

Theorem: cst-basic-character-not-star-conc3-rep-elem-tree-equiv-congruence-on-cst

(defthm
 cst-basic-character-not-star-conc3-rep-elem-tree-equiv-congruence-on-cst
 (implies
    (abnf::tree-equiv abnf::cst cst-equiv)
    (equal (cst-basic-character-not-star-conc3-rep-elem abnf::cst)
           (cst-basic-character-not-star-conc3-rep-elem cst-equiv)))
 :rule-classes :congruence)

Function: cst-basic-character-not-star-conc4-rep-elem

(defun cst-basic-character-not-star-conc4-rep-elem (abnf::cst)
 (declare (xargs :guard (abnf::treep abnf::cst)))
 (declare
  (xargs
   :guard (and (cst-matchp abnf::cst "basic-character-not-star")
               (equal (cst-basic-character-not-star-conc? abnf::cst)
                      4))))
 (let ((__function__ 'cst-basic-character-not-star-conc4-rep-elem))
   (declare (ignorable __function__))
   (abnf::tree-fix
        (nth 0
             (cst-basic-character-not-star-conc4-rep abnf::cst)))))

Theorem: treep-of-cst-basic-character-not-star-conc4-rep-elem

(defthm treep-of-cst-basic-character-not-star-conc4-rep-elem
 (b* ((abnf::cst1
           (cst-basic-character-not-star-conc4-rep-elem abnf::cst)))
   (abnf::treep abnf::cst1))
 :rule-classes :rewrite)

Theorem: cst-basic-character-not-star-conc4-rep-elem-match

(defthm cst-basic-character-not-star-conc4-rep-elem-match
 (implies
   (and (cst-matchp abnf::cst "basic-character-not-star")
        (equal (cst-basic-character-not-star-conc? abnf::cst)
               4))
   (b*
     ((abnf::cst1
           (cst-basic-character-not-star-conc4-rep-elem abnf::cst)))
     (cst-matchp abnf::cst1 "space")))
 :rule-classes :rewrite)

Theorem: cst-basic-character-not-star-conc4-rep-elem-of-tree-fix-cst

(defthm cst-basic-character-not-star-conc4-rep-elem-of-tree-fix-cst
  (equal (cst-basic-character-not-star-conc4-rep-elem
              (abnf::tree-fix abnf::cst))
         (cst-basic-character-not-star-conc4-rep-elem abnf::cst)))

Theorem: cst-basic-character-not-star-conc4-rep-elem-tree-equiv-congruence-on-cst

(defthm
 cst-basic-character-not-star-conc4-rep-elem-tree-equiv-congruence-on-cst
 (implies
    (abnf::tree-equiv abnf::cst cst-equiv)
    (equal (cst-basic-character-not-star-conc4-rep-elem abnf::cst)
           (cst-basic-character-not-star-conc4-rep-elem cst-equiv)))
 :rule-classes :congruence)

Function: cst-basic-character-not-star-conc5-rep-elem

(defun cst-basic-character-not-star-conc5-rep-elem (abnf::cst)
 (declare (xargs :guard (abnf::treep abnf::cst)))
 (declare
  (xargs
   :guard (and (cst-matchp abnf::cst "basic-character-not-star")
               (equal (cst-basic-character-not-star-conc? abnf::cst)
                      5))))
 (let ((__function__ 'cst-basic-character-not-star-conc5-rep-elem))
   (declare (ignorable __function__))
   (abnf::tree-fix
        (nth 0
             (cst-basic-character-not-star-conc5-rep abnf::cst)))))

Theorem: treep-of-cst-basic-character-not-star-conc5-rep-elem

(defthm treep-of-cst-basic-character-not-star-conc5-rep-elem
 (b* ((abnf::cst1
           (cst-basic-character-not-star-conc5-rep-elem abnf::cst)))
   (abnf::treep abnf::cst1))
 :rule-classes :rewrite)

Theorem: cst-basic-character-not-star-conc5-rep-elem-match

(defthm cst-basic-character-not-star-conc5-rep-elem-match
 (implies
   (and (cst-matchp abnf::cst "basic-character-not-star")
        (equal (cst-basic-character-not-star-conc? abnf::cst)
               5))
   (b*
     ((abnf::cst1
           (cst-basic-character-not-star-conc5-rep-elem abnf::cst)))
     (cst-matchp abnf::cst1 "control-character")))
 :rule-classes :rewrite)

Theorem: cst-basic-character-not-star-conc5-rep-elem-of-tree-fix-cst

(defthm cst-basic-character-not-star-conc5-rep-elem-of-tree-fix-cst
  (equal (cst-basic-character-not-star-conc5-rep-elem
              (abnf::tree-fix abnf::cst))
         (cst-basic-character-not-star-conc5-rep-elem abnf::cst)))

Theorem: cst-basic-character-not-star-conc5-rep-elem-tree-equiv-congruence-on-cst

(defthm
 cst-basic-character-not-star-conc5-rep-elem-tree-equiv-congruence-on-cst
 (implies
    (abnf::tree-equiv abnf::cst cst-equiv)
    (equal (cst-basic-character-not-star-conc5-rep-elem abnf::cst)
           (cst-basic-character-not-star-conc5-rep-elem cst-equiv)))
 :rule-classes :congruence)

Function: cst-basic-character-not-greater-than-conc1-rep-elem

(defun cst-basic-character-not-greater-than-conc1-rep-elem
       (abnf::cst)
 (declare (xargs :guard (abnf::treep abnf::cst)))
 (declare
  (xargs
   :guard
   (and
       (cst-matchp abnf::cst
                   "basic-character-not-greater-than")
       (equal (cst-basic-character-not-greater-than-conc? abnf::cst)
              1))))
 (let ((__function__
            'cst-basic-character-not-greater-than-conc1-rep-elem))
  (declare (ignorable __function__))
  (abnf::tree-fix
   (nth
      0
      (cst-basic-character-not-greater-than-conc1-rep abnf::cst)))))

Theorem: treep-of-cst-basic-character-not-greater-than-conc1-rep-elem

(defthm treep-of-cst-basic-character-not-greater-than-conc1-rep-elem
  (b* ((abnf::cst1 (cst-basic-character-not-greater-than-conc1-rep-elem
                        abnf::cst)))
    (abnf::treep abnf::cst1))
  :rule-classes :rewrite)

Theorem: cst-basic-character-not-greater-than-conc1-rep-elem-match

(defthm cst-basic-character-not-greater-than-conc1-rep-elem-match
 (implies
  (and (cst-matchp abnf::cst
                   "basic-character-not-greater-than")
       (equal (cst-basic-character-not-greater-than-conc? abnf::cst)
              1))
  (b* ((abnf::cst1 (cst-basic-character-not-greater-than-conc1-rep-elem
                        abnf::cst)))
    (cst-matchp abnf::cst1 "letter")))
 :rule-classes :rewrite)

Theorem: cst-basic-character-not-greater-than-conc1-rep-elem-of-tree-fix-cst

(defthm
 cst-basic-character-not-greater-than-conc1-rep-elem-of-tree-fix-cst
 (equal
   (cst-basic-character-not-greater-than-conc1-rep-elem
        (abnf::tree-fix abnf::cst))
   (cst-basic-character-not-greater-than-conc1-rep-elem abnf::cst)))

Theorem: cst-basic-character-not-greater-than-conc1-rep-elem-tree-equiv-congruence-on-cst

(defthm
 cst-basic-character-not-greater-than-conc1-rep-elem-tree-equiv-congruence-on-cst
 (implies
  (abnf::tree-equiv abnf::cst cst-equiv)
  (equal
   (cst-basic-character-not-greater-than-conc1-rep-elem abnf::cst)
   (cst-basic-character-not-greater-than-conc1-rep-elem cst-equiv)))
 :rule-classes :congruence)

Function: cst-basic-character-not-greater-than-conc2-rep-elem

(defun cst-basic-character-not-greater-than-conc2-rep-elem
       (abnf::cst)
 (declare (xargs :guard (abnf::treep abnf::cst)))
 (declare
  (xargs
   :guard
   (and
       (cst-matchp abnf::cst
                   "basic-character-not-greater-than")
       (equal (cst-basic-character-not-greater-than-conc? abnf::cst)
              2))))
 (let ((__function__
            'cst-basic-character-not-greater-than-conc2-rep-elem))
  (declare (ignorable __function__))
  (abnf::tree-fix
   (nth
      0
      (cst-basic-character-not-greater-than-conc2-rep abnf::cst)))))

Theorem: treep-of-cst-basic-character-not-greater-than-conc2-rep-elem

(defthm treep-of-cst-basic-character-not-greater-than-conc2-rep-elem
  (b* ((abnf::cst1 (cst-basic-character-not-greater-than-conc2-rep-elem
                        abnf::cst)))
    (abnf::treep abnf::cst1))
  :rule-classes :rewrite)

Theorem: cst-basic-character-not-greater-than-conc2-rep-elem-match

(defthm cst-basic-character-not-greater-than-conc2-rep-elem-match
 (implies
  (and (cst-matchp abnf::cst
                   "basic-character-not-greater-than")
       (equal (cst-basic-character-not-greater-than-conc? abnf::cst)
              2))
  (b* ((abnf::cst1 (cst-basic-character-not-greater-than-conc2-rep-elem
                        abnf::cst)))
    (cst-matchp abnf::cst1 "digit")))
 :rule-classes :rewrite)

Theorem: cst-basic-character-not-greater-than-conc2-rep-elem-of-tree-fix-cst

(defthm
 cst-basic-character-not-greater-than-conc2-rep-elem-of-tree-fix-cst
 (equal
   (cst-basic-character-not-greater-than-conc2-rep-elem
        (abnf::tree-fix abnf::cst))
   (cst-basic-character-not-greater-than-conc2-rep-elem abnf::cst)))

Theorem: cst-basic-character-not-greater-than-conc2-rep-elem-tree-equiv-congruence-on-cst

(defthm
 cst-basic-character-not-greater-than-conc2-rep-elem-tree-equiv-congruence-on-cst
 (implies
  (abnf::tree-equiv abnf::cst cst-equiv)
  (equal
   (cst-basic-character-not-greater-than-conc2-rep-elem abnf::cst)
   (cst-basic-character-not-greater-than-conc2-rep-elem cst-equiv)))
 :rule-classes :congruence)

Function: cst-basic-character-not-greater-than-conc3-rep-elem

(defun cst-basic-character-not-greater-than-conc3-rep-elem
       (abnf::cst)
 (declare (xargs :guard (abnf::treep abnf::cst)))
 (declare
  (xargs
   :guard
   (and
       (cst-matchp abnf::cst
                   "basic-character-not-greater-than")
       (equal (cst-basic-character-not-greater-than-conc? abnf::cst)
              3))))
 (let ((__function__
            'cst-basic-character-not-greater-than-conc3-rep-elem))
  (declare (ignorable __function__))
  (abnf::tree-fix
   (nth
      0
      (cst-basic-character-not-greater-than-conc3-rep abnf::cst)))))

Theorem: treep-of-cst-basic-character-not-greater-than-conc3-rep-elem

(defthm treep-of-cst-basic-character-not-greater-than-conc3-rep-elem
  (b* ((abnf::cst1 (cst-basic-character-not-greater-than-conc3-rep-elem
                        abnf::cst)))
    (abnf::treep abnf::cst1))
  :rule-classes :rewrite)

Theorem: cst-basic-character-not-greater-than-conc3-rep-elem-match

(defthm cst-basic-character-not-greater-than-conc3-rep-elem-match
 (implies
  (and (cst-matchp abnf::cst
                   "basic-character-not-greater-than")
       (equal (cst-basic-character-not-greater-than-conc? abnf::cst)
              3))
  (b* ((abnf::cst1 (cst-basic-character-not-greater-than-conc3-rep-elem
                        abnf::cst)))
    (cst-matchp abnf::cst1
                "graphic-character-not-greater-than")))
 :rule-classes :rewrite)

Theorem: cst-basic-character-not-greater-than-conc3-rep-elem-of-tree-fix-cst

(defthm
 cst-basic-character-not-greater-than-conc3-rep-elem-of-tree-fix-cst
 (equal
   (cst-basic-character-not-greater-than-conc3-rep-elem
        (abnf::tree-fix abnf::cst))
   (cst-basic-character-not-greater-than-conc3-rep-elem abnf::cst)))

Theorem: cst-basic-character-not-greater-than-conc3-rep-elem-tree-equiv-congruence-on-cst

(defthm
 cst-basic-character-not-greater-than-conc3-rep-elem-tree-equiv-congruence-on-cst
 (implies
  (abnf::tree-equiv abnf::cst cst-equiv)
  (equal
   (cst-basic-character-not-greater-than-conc3-rep-elem abnf::cst)
   (cst-basic-character-not-greater-than-conc3-rep-elem cst-equiv)))
 :rule-classes :congruence)

Function: cst-basic-character-not-greater-than-conc4-rep-elem

(defun cst-basic-character-not-greater-than-conc4-rep-elem
       (abnf::cst)
 (declare (xargs :guard (abnf::treep abnf::cst)))
 (declare
  (xargs
   :guard
   (and
       (cst-matchp abnf::cst
                   "basic-character-not-greater-than")
       (equal (cst-basic-character-not-greater-than-conc? abnf::cst)
              4))))
 (let ((__function__
            'cst-basic-character-not-greater-than-conc4-rep-elem))
  (declare (ignorable __function__))
  (abnf::tree-fix
   (nth
      0
      (cst-basic-character-not-greater-than-conc4-rep abnf::cst)))))

Theorem: treep-of-cst-basic-character-not-greater-than-conc4-rep-elem

(defthm treep-of-cst-basic-character-not-greater-than-conc4-rep-elem
  (b* ((abnf::cst1 (cst-basic-character-not-greater-than-conc4-rep-elem
                        abnf::cst)))
    (abnf::treep abnf::cst1))
  :rule-classes :rewrite)

Theorem: cst-basic-character-not-greater-than-conc4-rep-elem-match

(defthm cst-basic-character-not-greater-than-conc4-rep-elem-match
 (implies
  (and (cst-matchp abnf::cst
                   "basic-character-not-greater-than")
       (equal (cst-basic-character-not-greater-than-conc? abnf::cst)
              4))
  (b* ((abnf::cst1 (cst-basic-character-not-greater-than-conc4-rep-elem
                        abnf::cst)))
    (cst-matchp abnf::cst1 "space")))
 :rule-classes :rewrite)

Theorem: cst-basic-character-not-greater-than-conc4-rep-elem-of-tree-fix-cst

(defthm
 cst-basic-character-not-greater-than-conc4-rep-elem-of-tree-fix-cst
 (equal
   (cst-basic-character-not-greater-than-conc4-rep-elem
        (abnf::tree-fix abnf::cst))
   (cst-basic-character-not-greater-than-conc4-rep-elem abnf::cst)))

Theorem: cst-basic-character-not-greater-than-conc4-rep-elem-tree-equiv-congruence-on-cst

(defthm
 cst-basic-character-not-greater-than-conc4-rep-elem-tree-equiv-congruence-on-cst
 (implies
  (abnf::tree-equiv abnf::cst cst-equiv)
  (equal
   (cst-basic-character-not-greater-than-conc4-rep-elem abnf::cst)
   (cst-basic-character-not-greater-than-conc4-rep-elem cst-equiv)))
 :rule-classes :congruence)

Function: cst-basic-character-not-greater-than-conc5-rep-elem

(defun cst-basic-character-not-greater-than-conc5-rep-elem
       (abnf::cst)
 (declare (xargs :guard (abnf::treep abnf::cst)))
 (declare
  (xargs
   :guard
   (and
       (cst-matchp abnf::cst
                   "basic-character-not-greater-than")
       (equal (cst-basic-character-not-greater-than-conc? abnf::cst)
              5))))
 (let ((__function__
            'cst-basic-character-not-greater-than-conc5-rep-elem))
  (declare (ignorable __function__))
  (abnf::tree-fix
   (nth
      0
      (cst-basic-character-not-greater-than-conc5-rep abnf::cst)))))

Theorem: treep-of-cst-basic-character-not-greater-than-conc5-rep-elem

(defthm treep-of-cst-basic-character-not-greater-than-conc5-rep-elem
  (b* ((abnf::cst1 (cst-basic-character-not-greater-than-conc5-rep-elem
                        abnf::cst)))
    (abnf::treep abnf::cst1))
  :rule-classes :rewrite)

Theorem: cst-basic-character-not-greater-than-conc5-rep-elem-match

(defthm cst-basic-character-not-greater-than-conc5-rep-elem-match
 (implies
  (and (cst-matchp abnf::cst
                   "basic-character-not-greater-than")
       (equal (cst-basic-character-not-greater-than-conc? abnf::cst)
              5))
  (b* ((abnf::cst1 (cst-basic-character-not-greater-than-conc5-rep-elem
                        abnf::cst)))
    (cst-matchp abnf::cst1 "control-character")))
 :rule-classes :rewrite)

Theorem: cst-basic-character-not-greater-than-conc5-rep-elem-of-tree-fix-cst

(defthm
 cst-basic-character-not-greater-than-conc5-rep-elem-of-tree-fix-cst
 (equal
   (cst-basic-character-not-greater-than-conc5-rep-elem
        (abnf::tree-fix abnf::cst))
   (cst-basic-character-not-greater-than-conc5-rep-elem abnf::cst)))

Theorem: cst-basic-character-not-greater-than-conc5-rep-elem-tree-equiv-congruence-on-cst

(defthm
 cst-basic-character-not-greater-than-conc5-rep-elem-tree-equiv-congruence-on-cst
 (implies
  (abnf::tree-equiv abnf::cst cst-equiv)
  (equal
   (cst-basic-character-not-greater-than-conc5-rep-elem abnf::cst)
   (cst-basic-character-not-greater-than-conc5-rep-elem cst-equiv)))
 :rule-classes :congruence)

Function: cst-basic-character-not-double-quote-conc1-rep-elem

(defun cst-basic-character-not-double-quote-conc1-rep-elem
       (abnf::cst)
 (declare (xargs :guard (abnf::treep abnf::cst)))
 (declare
  (xargs
   :guard
   (and
       (cst-matchp abnf::cst
                   "basic-character-not-double-quote")
       (equal (cst-basic-character-not-double-quote-conc? abnf::cst)
              1))))
 (let ((__function__
            'cst-basic-character-not-double-quote-conc1-rep-elem))
  (declare (ignorable __function__))
  (abnf::tree-fix
   (nth
      0
      (cst-basic-character-not-double-quote-conc1-rep abnf::cst)))))

Theorem: treep-of-cst-basic-character-not-double-quote-conc1-rep-elem

(defthm treep-of-cst-basic-character-not-double-quote-conc1-rep-elem
  (b* ((abnf::cst1 (cst-basic-character-not-double-quote-conc1-rep-elem
                        abnf::cst)))
    (abnf::treep abnf::cst1))
  :rule-classes :rewrite)

Theorem: cst-basic-character-not-double-quote-conc1-rep-elem-match

(defthm cst-basic-character-not-double-quote-conc1-rep-elem-match
 (implies
  (and (cst-matchp abnf::cst
                   "basic-character-not-double-quote")
       (equal (cst-basic-character-not-double-quote-conc? abnf::cst)
              1))
  (b* ((abnf::cst1 (cst-basic-character-not-double-quote-conc1-rep-elem
                        abnf::cst)))
    (cst-matchp abnf::cst1 "letter")))
 :rule-classes :rewrite)

Theorem: cst-basic-character-not-double-quote-conc1-rep-elem-of-tree-fix-cst

(defthm
 cst-basic-character-not-double-quote-conc1-rep-elem-of-tree-fix-cst
 (equal
   (cst-basic-character-not-double-quote-conc1-rep-elem
        (abnf::tree-fix abnf::cst))
   (cst-basic-character-not-double-quote-conc1-rep-elem abnf::cst)))

Theorem: cst-basic-character-not-double-quote-conc1-rep-elem-tree-equiv-congruence-on-cst

(defthm
 cst-basic-character-not-double-quote-conc1-rep-elem-tree-equiv-congruence-on-cst
 (implies
  (abnf::tree-equiv abnf::cst cst-equiv)
  (equal
   (cst-basic-character-not-double-quote-conc1-rep-elem abnf::cst)
   (cst-basic-character-not-double-quote-conc1-rep-elem cst-equiv)))
 :rule-classes :congruence)

Function: cst-basic-character-not-double-quote-conc2-rep-elem

(defun cst-basic-character-not-double-quote-conc2-rep-elem
       (abnf::cst)
 (declare (xargs :guard (abnf::treep abnf::cst)))
 (declare
  (xargs
   :guard
   (and
       (cst-matchp abnf::cst
                   "basic-character-not-double-quote")
       (equal (cst-basic-character-not-double-quote-conc? abnf::cst)
              2))))
 (let ((__function__
            'cst-basic-character-not-double-quote-conc2-rep-elem))
  (declare (ignorable __function__))
  (abnf::tree-fix
   (nth
      0
      (cst-basic-character-not-double-quote-conc2-rep abnf::cst)))))

Theorem: treep-of-cst-basic-character-not-double-quote-conc2-rep-elem

(defthm treep-of-cst-basic-character-not-double-quote-conc2-rep-elem
  (b* ((abnf::cst1 (cst-basic-character-not-double-quote-conc2-rep-elem
                        abnf::cst)))
    (abnf::treep abnf::cst1))
  :rule-classes :rewrite)

Theorem: cst-basic-character-not-double-quote-conc2-rep-elem-match

(defthm cst-basic-character-not-double-quote-conc2-rep-elem-match
 (implies
  (and (cst-matchp abnf::cst
                   "basic-character-not-double-quote")
       (equal (cst-basic-character-not-double-quote-conc? abnf::cst)
              2))
  (b* ((abnf::cst1 (cst-basic-character-not-double-quote-conc2-rep-elem
                        abnf::cst)))
    (cst-matchp abnf::cst1 "digit")))
 :rule-classes :rewrite)

Theorem: cst-basic-character-not-double-quote-conc2-rep-elem-of-tree-fix-cst

(defthm
 cst-basic-character-not-double-quote-conc2-rep-elem-of-tree-fix-cst
 (equal
   (cst-basic-character-not-double-quote-conc2-rep-elem
        (abnf::tree-fix abnf::cst))
   (cst-basic-character-not-double-quote-conc2-rep-elem abnf::cst)))

Theorem: cst-basic-character-not-double-quote-conc2-rep-elem-tree-equiv-congruence-on-cst

(defthm
 cst-basic-character-not-double-quote-conc2-rep-elem-tree-equiv-congruence-on-cst
 (implies
  (abnf::tree-equiv abnf::cst cst-equiv)
  (equal
   (cst-basic-character-not-double-quote-conc2-rep-elem abnf::cst)
   (cst-basic-character-not-double-quote-conc2-rep-elem cst-equiv)))
 :rule-classes :congruence)

Function: cst-basic-character-not-double-quote-conc3-rep-elem

(defun cst-basic-character-not-double-quote-conc3-rep-elem
       (abnf::cst)
 (declare (xargs :guard (abnf::treep abnf::cst)))
 (declare
  (xargs
   :guard
   (and
       (cst-matchp abnf::cst
                   "basic-character-not-double-quote")
       (equal (cst-basic-character-not-double-quote-conc? abnf::cst)
              3))))
 (let ((__function__
            'cst-basic-character-not-double-quote-conc3-rep-elem))
  (declare (ignorable __function__))
  (abnf::tree-fix
   (nth
      0
      (cst-basic-character-not-double-quote-conc3-rep abnf::cst)))))

Theorem: treep-of-cst-basic-character-not-double-quote-conc3-rep-elem

(defthm treep-of-cst-basic-character-not-double-quote-conc3-rep-elem
  (b* ((abnf::cst1 (cst-basic-character-not-double-quote-conc3-rep-elem
                        abnf::cst)))
    (abnf::treep abnf::cst1))
  :rule-classes :rewrite)

Theorem: cst-basic-character-not-double-quote-conc3-rep-elem-match

(defthm cst-basic-character-not-double-quote-conc3-rep-elem-match
 (implies
  (and (cst-matchp abnf::cst
                   "basic-character-not-double-quote")
       (equal (cst-basic-character-not-double-quote-conc? abnf::cst)
              3))
  (b* ((abnf::cst1 (cst-basic-character-not-double-quote-conc3-rep-elem
                        abnf::cst)))
    (cst-matchp abnf::cst1
                "graphic-character-not-double-quote")))
 :rule-classes :rewrite)

Theorem: cst-basic-character-not-double-quote-conc3-rep-elem-of-tree-fix-cst

(defthm
 cst-basic-character-not-double-quote-conc3-rep-elem-of-tree-fix-cst
 (equal
   (cst-basic-character-not-double-quote-conc3-rep-elem
        (abnf::tree-fix abnf::cst))
   (cst-basic-character-not-double-quote-conc3-rep-elem abnf::cst)))

Theorem: cst-basic-character-not-double-quote-conc3-rep-elem-tree-equiv-congruence-on-cst

(defthm
 cst-basic-character-not-double-quote-conc3-rep-elem-tree-equiv-congruence-on-cst
 (implies
  (abnf::tree-equiv abnf::cst cst-equiv)
  (equal
   (cst-basic-character-not-double-quote-conc3-rep-elem abnf::cst)
   (cst-basic-character-not-double-quote-conc3-rep-elem cst-equiv)))
 :rule-classes :congruence)

Function: cst-basic-character-not-double-quote-conc4-rep-elem

(defun cst-basic-character-not-double-quote-conc4-rep-elem
       (abnf::cst)
 (declare (xargs :guard (abnf::treep abnf::cst)))
 (declare
  (xargs
   :guard
   (and
       (cst-matchp abnf::cst
                   "basic-character-not-double-quote")
       (equal (cst-basic-character-not-double-quote-conc? abnf::cst)
              4))))
 (let ((__function__
            'cst-basic-character-not-double-quote-conc4-rep-elem))
  (declare (ignorable __function__))
  (abnf::tree-fix
   (nth
      0
      (cst-basic-character-not-double-quote-conc4-rep abnf::cst)))))

Theorem: treep-of-cst-basic-character-not-double-quote-conc4-rep-elem

(defthm treep-of-cst-basic-character-not-double-quote-conc4-rep-elem
  (b* ((abnf::cst1 (cst-basic-character-not-double-quote-conc4-rep-elem
                        abnf::cst)))
    (abnf::treep abnf::cst1))
  :rule-classes :rewrite)

Theorem: cst-basic-character-not-double-quote-conc4-rep-elem-match

(defthm cst-basic-character-not-double-quote-conc4-rep-elem-match
 (implies
  (and (cst-matchp abnf::cst
                   "basic-character-not-double-quote")
       (equal (cst-basic-character-not-double-quote-conc? abnf::cst)
              4))
  (b* ((abnf::cst1 (cst-basic-character-not-double-quote-conc4-rep-elem
                        abnf::cst)))
    (cst-matchp abnf::cst1 "space")))
 :rule-classes :rewrite)

Theorem: cst-basic-character-not-double-quote-conc4-rep-elem-of-tree-fix-cst

(defthm
 cst-basic-character-not-double-quote-conc4-rep-elem-of-tree-fix-cst
 (equal
   (cst-basic-character-not-double-quote-conc4-rep-elem
        (abnf::tree-fix abnf::cst))
   (cst-basic-character-not-double-quote-conc4-rep-elem abnf::cst)))

Theorem: cst-basic-character-not-double-quote-conc4-rep-elem-tree-equiv-congruence-on-cst

(defthm
 cst-basic-character-not-double-quote-conc4-rep-elem-tree-equiv-congruence-on-cst
 (implies
  (abnf::tree-equiv abnf::cst cst-equiv)
  (equal
   (cst-basic-character-not-double-quote-conc4-rep-elem abnf::cst)
   (cst-basic-character-not-double-quote-conc4-rep-elem cst-equiv)))
 :rule-classes :congruence)

Function: cst-basic-character-not-double-quote-conc5-rep-elem

(defun cst-basic-character-not-double-quote-conc5-rep-elem
       (abnf::cst)
 (declare (xargs :guard (abnf::treep abnf::cst)))
 (declare
  (xargs
   :guard
   (and
       (cst-matchp abnf::cst
                   "basic-character-not-double-quote")
       (equal (cst-basic-character-not-double-quote-conc? abnf::cst)
              5))))
 (let ((__function__
            'cst-basic-character-not-double-quote-conc5-rep-elem))
  (declare (ignorable __function__))
  (abnf::tree-fix
   (nth
      0
      (cst-basic-character-not-double-quote-conc5-rep abnf::cst)))))

Theorem: treep-of-cst-basic-character-not-double-quote-conc5-rep-elem

(defthm treep-of-cst-basic-character-not-double-quote-conc5-rep-elem
  (b* ((abnf::cst1 (cst-basic-character-not-double-quote-conc5-rep-elem
                        abnf::cst)))
    (abnf::treep abnf::cst1))
  :rule-classes :rewrite)

Theorem: cst-basic-character-not-double-quote-conc5-rep-elem-match

(defthm cst-basic-character-not-double-quote-conc5-rep-elem-match
 (implies
  (and (cst-matchp abnf::cst
                   "basic-character-not-double-quote")
       (equal (cst-basic-character-not-double-quote-conc? abnf::cst)
              5))
  (b* ((abnf::cst1 (cst-basic-character-not-double-quote-conc5-rep-elem
                        abnf::cst)))
    (cst-matchp abnf::cst1 "control-character")))
 :rule-classes :rewrite)

Theorem: cst-basic-character-not-double-quote-conc5-rep-elem-of-tree-fix-cst

(defthm
 cst-basic-character-not-double-quote-conc5-rep-elem-of-tree-fix-cst
 (equal
   (cst-basic-character-not-double-quote-conc5-rep-elem
        (abnf::tree-fix abnf::cst))
   (cst-basic-character-not-double-quote-conc5-rep-elem abnf::cst)))

Theorem: cst-basic-character-not-double-quote-conc5-rep-elem-tree-equiv-congruence-on-cst

(defthm
 cst-basic-character-not-double-quote-conc5-rep-elem-tree-equiv-congruence-on-cst
 (implies
  (abnf::tree-equiv abnf::cst cst-equiv)
  (equal
   (cst-basic-character-not-double-quote-conc5-rep-elem abnf::cst)
   (cst-basic-character-not-double-quote-conc5-rep-elem cst-equiv)))
 :rule-classes :congruence)

Function: cst-basic-character-not-star-or-slash-conc1-rep-elem

(defun cst-basic-character-not-star-or-slash-conc1-rep-elem
       (abnf::cst)
 (declare (xargs :guard (abnf::treep abnf::cst)))
 (declare
  (xargs
   :guard
   (and
      (cst-matchp abnf::cst
                  "basic-character-not-star-or-slash")
      (equal (cst-basic-character-not-star-or-slash-conc? abnf::cst)
             1))))
 (let ((__function__
            'cst-basic-character-not-star-or-slash-conc1-rep-elem))
  (declare (ignorable __function__))
  (abnf::tree-fix
   (nth
     0
     (cst-basic-character-not-star-or-slash-conc1-rep abnf::cst)))))

Theorem: treep-of-cst-basic-character-not-star-or-slash-conc1-rep-elem

(defthm
      treep-of-cst-basic-character-not-star-or-slash-conc1-rep-elem
  (b* ((abnf::cst1 (cst-basic-character-not-star-or-slash-conc1-rep-elem
                        abnf::cst)))
    (abnf::treep abnf::cst1))
  :rule-classes :rewrite)

Theorem: cst-basic-character-not-star-or-slash-conc1-rep-elem-match

(defthm cst-basic-character-not-star-or-slash-conc1-rep-elem-match
 (implies
  (and
      (cst-matchp abnf::cst
                  "basic-character-not-star-or-slash")
      (equal (cst-basic-character-not-star-or-slash-conc? abnf::cst)
             1))
  (b* ((abnf::cst1 (cst-basic-character-not-star-or-slash-conc1-rep-elem
                        abnf::cst)))
    (cst-matchp abnf::cst1 "letter")))
 :rule-classes :rewrite)

Theorem: cst-basic-character-not-star-or-slash-conc1-rep-elem-of-tree-fix-cst

(defthm
 cst-basic-character-not-star-or-slash-conc1-rep-elem-of-tree-fix-cst
 (equal
  (cst-basic-character-not-star-or-slash-conc1-rep-elem
       (abnf::tree-fix abnf::cst))
  (cst-basic-character-not-star-or-slash-conc1-rep-elem abnf::cst)))

Theorem: cst-basic-character-not-star-or-slash-conc1-rep-elem-tree-equiv-congruence-on-cst

(defthm
 cst-basic-character-not-star-or-slash-conc1-rep-elem-tree-equiv-congruence-on-cst
 (implies
  (abnf::tree-equiv abnf::cst cst-equiv)
  (equal
    (cst-basic-character-not-star-or-slash-conc1-rep-elem abnf::cst)
    (cst-basic-character-not-star-or-slash-conc1-rep-elem
         cst-equiv)))
 :rule-classes :congruence)

Function: cst-basic-character-not-star-or-slash-conc2-rep-elem

(defun cst-basic-character-not-star-or-slash-conc2-rep-elem
       (abnf::cst)
 (declare (xargs :guard (abnf::treep abnf::cst)))
 (declare
  (xargs
   :guard
   (and
      (cst-matchp abnf::cst
                  "basic-character-not-star-or-slash")
      (equal (cst-basic-character-not-star-or-slash-conc? abnf::cst)
             2))))
 (let ((__function__
            'cst-basic-character-not-star-or-slash-conc2-rep-elem))
  (declare (ignorable __function__))
  (abnf::tree-fix
   (nth
     0
     (cst-basic-character-not-star-or-slash-conc2-rep abnf::cst)))))

Theorem: treep-of-cst-basic-character-not-star-or-slash-conc2-rep-elem

(defthm
      treep-of-cst-basic-character-not-star-or-slash-conc2-rep-elem
  (b* ((abnf::cst1 (cst-basic-character-not-star-or-slash-conc2-rep-elem
                        abnf::cst)))
    (abnf::treep abnf::cst1))
  :rule-classes :rewrite)

Theorem: cst-basic-character-not-star-or-slash-conc2-rep-elem-match

(defthm cst-basic-character-not-star-or-slash-conc2-rep-elem-match
 (implies
  (and
      (cst-matchp abnf::cst
                  "basic-character-not-star-or-slash")
      (equal (cst-basic-character-not-star-or-slash-conc? abnf::cst)
             2))
  (b* ((abnf::cst1 (cst-basic-character-not-star-or-slash-conc2-rep-elem
                        abnf::cst)))
    (cst-matchp abnf::cst1 "digit")))
 :rule-classes :rewrite)

Theorem: cst-basic-character-not-star-or-slash-conc2-rep-elem-of-tree-fix-cst

(defthm
 cst-basic-character-not-star-or-slash-conc2-rep-elem-of-tree-fix-cst
 (equal
  (cst-basic-character-not-star-or-slash-conc2-rep-elem
       (abnf::tree-fix abnf::cst))
  (cst-basic-character-not-star-or-slash-conc2-rep-elem abnf::cst)))

Theorem: cst-basic-character-not-star-or-slash-conc2-rep-elem-tree-equiv-congruence-on-cst

(defthm
 cst-basic-character-not-star-or-slash-conc2-rep-elem-tree-equiv-congruence-on-cst
 (implies
  (abnf::tree-equiv abnf::cst cst-equiv)
  (equal
    (cst-basic-character-not-star-or-slash-conc2-rep-elem abnf::cst)
    (cst-basic-character-not-star-or-slash-conc2-rep-elem
         cst-equiv)))
 :rule-classes :congruence)

Function: cst-basic-character-not-star-or-slash-conc3-rep-elem

(defun cst-basic-character-not-star-or-slash-conc3-rep-elem
       (abnf::cst)
 (declare (xargs :guard (abnf::treep abnf::cst)))
 (declare
  (xargs
   :guard
   (and
      (cst-matchp abnf::cst
                  "basic-character-not-star-or-slash")
      (equal (cst-basic-character-not-star-or-slash-conc? abnf::cst)
             3))))
 (let ((__function__
            'cst-basic-character-not-star-or-slash-conc3-rep-elem))
  (declare (ignorable __function__))
  (abnf::tree-fix
   (nth
     0
     (cst-basic-character-not-star-or-slash-conc3-rep abnf::cst)))))

Theorem: treep-of-cst-basic-character-not-star-or-slash-conc3-rep-elem

(defthm
      treep-of-cst-basic-character-not-star-or-slash-conc3-rep-elem
  (b* ((abnf::cst1 (cst-basic-character-not-star-or-slash-conc3-rep-elem
                        abnf::cst)))
    (abnf::treep abnf::cst1))
  :rule-classes :rewrite)

Theorem: cst-basic-character-not-star-or-slash-conc3-rep-elem-match

(defthm cst-basic-character-not-star-or-slash-conc3-rep-elem-match
 (implies
  (and
      (cst-matchp abnf::cst
                  "basic-character-not-star-or-slash")
      (equal (cst-basic-character-not-star-or-slash-conc? abnf::cst)
             3))
  (b* ((abnf::cst1 (cst-basic-character-not-star-or-slash-conc3-rep-elem
                        abnf::cst)))
    (cst-matchp abnf::cst1
                "graphic-character-not-star-or-slash")))
 :rule-classes :rewrite)

Theorem: cst-basic-character-not-star-or-slash-conc3-rep-elem-of-tree-fix-cst

(defthm
 cst-basic-character-not-star-or-slash-conc3-rep-elem-of-tree-fix-cst
 (equal
  (cst-basic-character-not-star-or-slash-conc3-rep-elem
       (abnf::tree-fix abnf::cst))
  (cst-basic-character-not-star-or-slash-conc3-rep-elem abnf::cst)))

Theorem: cst-basic-character-not-star-or-slash-conc3-rep-elem-tree-equiv-congruence-on-cst

(defthm
 cst-basic-character-not-star-or-slash-conc3-rep-elem-tree-equiv-congruence-on-cst
 (implies
  (abnf::tree-equiv abnf::cst cst-equiv)
  (equal
    (cst-basic-character-not-star-or-slash-conc3-rep-elem abnf::cst)
    (cst-basic-character-not-star-or-slash-conc3-rep-elem
         cst-equiv)))
 :rule-classes :congruence)

Function: cst-basic-character-not-star-or-slash-conc4-rep-elem

(defun cst-basic-character-not-star-or-slash-conc4-rep-elem
       (abnf::cst)
 (declare (xargs :guard (abnf::treep abnf::cst)))
 (declare
  (xargs
   :guard
   (and
      (cst-matchp abnf::cst
                  "basic-character-not-star-or-slash")
      (equal (cst-basic-character-not-star-or-slash-conc? abnf::cst)
             4))))
 (let ((__function__
            'cst-basic-character-not-star-or-slash-conc4-rep-elem))
  (declare (ignorable __function__))
  (abnf::tree-fix
   (nth
     0
     (cst-basic-character-not-star-or-slash-conc4-rep abnf::cst)))))

Theorem: treep-of-cst-basic-character-not-star-or-slash-conc4-rep-elem

(defthm
      treep-of-cst-basic-character-not-star-or-slash-conc4-rep-elem
  (b* ((abnf::cst1 (cst-basic-character-not-star-or-slash-conc4-rep-elem
                        abnf::cst)))
    (abnf::treep abnf::cst1))
  :rule-classes :rewrite)

Theorem: cst-basic-character-not-star-or-slash-conc4-rep-elem-match

(defthm cst-basic-character-not-star-or-slash-conc4-rep-elem-match
 (implies
  (and
      (cst-matchp abnf::cst
                  "basic-character-not-star-or-slash")
      (equal (cst-basic-character-not-star-or-slash-conc? abnf::cst)
             4))
  (b* ((abnf::cst1 (cst-basic-character-not-star-or-slash-conc4-rep-elem
                        abnf::cst)))
    (cst-matchp abnf::cst1 "space")))
 :rule-classes :rewrite)

Theorem: cst-basic-character-not-star-or-slash-conc4-rep-elem-of-tree-fix-cst

(defthm
 cst-basic-character-not-star-or-slash-conc4-rep-elem-of-tree-fix-cst
 (equal
  (cst-basic-character-not-star-or-slash-conc4-rep-elem
       (abnf::tree-fix abnf::cst))
  (cst-basic-character-not-star-or-slash-conc4-rep-elem abnf::cst)))

Theorem: cst-basic-character-not-star-or-slash-conc4-rep-elem-tree-equiv-congruence-on-cst

(defthm
 cst-basic-character-not-star-or-slash-conc4-rep-elem-tree-equiv-congruence-on-cst
 (implies
  (abnf::tree-equiv abnf::cst cst-equiv)
  (equal
    (cst-basic-character-not-star-or-slash-conc4-rep-elem abnf::cst)
    (cst-basic-character-not-star-or-slash-conc4-rep-elem
         cst-equiv)))
 :rule-classes :congruence)

Function: cst-basic-character-not-star-or-slash-conc5-rep-elem

(defun cst-basic-character-not-star-or-slash-conc5-rep-elem
       (abnf::cst)
 (declare (xargs :guard (abnf::treep abnf::cst)))
 (declare
  (xargs
   :guard
   (and
      (cst-matchp abnf::cst
                  "basic-character-not-star-or-slash")
      (equal (cst-basic-character-not-star-or-slash-conc? abnf::cst)
             5))))
 (let ((__function__
            'cst-basic-character-not-star-or-slash-conc5-rep-elem))
  (declare (ignorable __function__))
  (abnf::tree-fix
   (nth
     0
     (cst-basic-character-not-star-or-slash-conc5-rep abnf::cst)))))

Theorem: treep-of-cst-basic-character-not-star-or-slash-conc5-rep-elem

(defthm
      treep-of-cst-basic-character-not-star-or-slash-conc5-rep-elem
  (b* ((abnf::cst1 (cst-basic-character-not-star-or-slash-conc5-rep-elem
                        abnf::cst)))
    (abnf::treep abnf::cst1))
  :rule-classes :rewrite)

Theorem: cst-basic-character-not-star-or-slash-conc5-rep-elem-match

(defthm cst-basic-character-not-star-or-slash-conc5-rep-elem-match
 (implies
  (and
      (cst-matchp abnf::cst
                  "basic-character-not-star-or-slash")
      (equal (cst-basic-character-not-star-or-slash-conc? abnf::cst)
             5))
  (b* ((abnf::cst1 (cst-basic-character-not-star-or-slash-conc5-rep-elem
                        abnf::cst)))
    (cst-matchp abnf::cst1 "control-character")))
 :rule-classes :rewrite)

Theorem: cst-basic-character-not-star-or-slash-conc5-rep-elem-of-tree-fix-cst

(defthm
 cst-basic-character-not-star-or-slash-conc5-rep-elem-of-tree-fix-cst
 (equal
  (cst-basic-character-not-star-or-slash-conc5-rep-elem
       (abnf::tree-fix abnf::cst))
  (cst-basic-character-not-star-or-slash-conc5-rep-elem abnf::cst)))

Theorem: cst-basic-character-not-star-or-slash-conc5-rep-elem-tree-equiv-congruence-on-cst

(defthm
 cst-basic-character-not-star-or-slash-conc5-rep-elem-tree-equiv-congruence-on-cst
 (implies
  (abnf::tree-equiv abnf::cst cst-equiv)
  (equal
    (cst-basic-character-not-star-or-slash-conc5-rep-elem abnf::cst)
    (cst-basic-character-not-star-or-slash-conc5-rep-elem
         cst-equiv)))
 :rule-classes :congruence)

Function: cst-basic-character-not-single-quote-or-backslash-conc1-rep-elem

(defun
   cst-basic-character-not-single-quote-or-backslash-conc1-rep-elem
   (abnf::cst)
 (declare (xargs :guard (abnf::treep abnf::cst)))
 (declare
  (xargs
   :guard
   (and (cst-matchp abnf::cst
                    "basic-character-not-single-quote-or-backslash")
        (equal (cst-basic-character-not-single-quote-or-backslash-conc?
                    abnf::cst)
               1))))
 (let
  ((__function__
    'cst-basic-character-not-single-quote-or-backslash-conc1-rep-elem))
  (declare (ignorable __function__))
  (abnf::tree-fix (nth 0
                       (cst-basic-character-not-single-quote-or-backslash-conc1-rep
                            abnf::cst)))))

Theorem: treep-of-cst-basic-character-not-single-quote-or-backslash-conc1-rep-elem

(defthm
 treep-of-cst-basic-character-not-single-quote-or-backslash-conc1-rep-elem
 (b* ((abnf::cst1 (cst-basic-character-not-single-quote-or-backslash-conc1-rep-elem
                       abnf::cst)))
   (abnf::treep abnf::cst1))
 :rule-classes :rewrite)

Theorem: cst-basic-character-not-single-quote-or-backslash-conc1-rep-elem-match

(defthm
 cst-basic-character-not-single-quote-or-backslash-conc1-rep-elem-match
 (implies
   (and (cst-matchp abnf::cst
                    "basic-character-not-single-quote-or-backslash")
        (equal (cst-basic-character-not-single-quote-or-backslash-conc?
                    abnf::cst)
               1))
   (b* ((abnf::cst1 (cst-basic-character-not-single-quote-or-backslash-conc1-rep-elem
                         abnf::cst)))
     (cst-matchp abnf::cst1 "letter")))
 :rule-classes :rewrite)

Theorem: cst-basic-character-not-single-quote-or-backslash-conc1-rep-elem-of-tree-fix-cst

(defthm
 cst-basic-character-not-single-quote-or-backslash-conc1-rep-elem-of-tree-fix-cst
 (equal (cst-basic-character-not-single-quote-or-backslash-conc1-rep-elem
             (abnf::tree-fix abnf::cst))
        (cst-basic-character-not-single-quote-or-backslash-conc1-rep-elem
             abnf::cst)))

Theorem: cst-basic-character-not-single-quote-or-backslash-conc1-rep-elem-tree-equiv-congruence-on-cst

(defthm
 cst-basic-character-not-single-quote-or-backslash-conc1-rep-elem-tree-equiv-congruence-on-cst
 (implies (abnf::tree-equiv abnf::cst cst-equiv)
          (equal (cst-basic-character-not-single-quote-or-backslash-conc1-rep-elem
                      abnf::cst)
                 (cst-basic-character-not-single-quote-or-backslash-conc1-rep-elem
                      cst-equiv)))
 :rule-classes :congruence)

Function: cst-basic-character-not-single-quote-or-backslash-conc2-rep-elem

(defun
   cst-basic-character-not-single-quote-or-backslash-conc2-rep-elem
   (abnf::cst)
 (declare (xargs :guard (abnf::treep abnf::cst)))
 (declare
  (xargs
   :guard
   (and (cst-matchp abnf::cst
                    "basic-character-not-single-quote-or-backslash")
        (equal (cst-basic-character-not-single-quote-or-backslash-conc?
                    abnf::cst)
               2))))
 (let
  ((__function__
    'cst-basic-character-not-single-quote-or-backslash-conc2-rep-elem))
  (declare (ignorable __function__))
  (abnf::tree-fix (nth 0
                       (cst-basic-character-not-single-quote-or-backslash-conc2-rep
                            abnf::cst)))))

Theorem: treep-of-cst-basic-character-not-single-quote-or-backslash-conc2-rep-elem

(defthm
 treep-of-cst-basic-character-not-single-quote-or-backslash-conc2-rep-elem
 (b* ((abnf::cst1 (cst-basic-character-not-single-quote-or-backslash-conc2-rep-elem
                       abnf::cst)))
   (abnf::treep abnf::cst1))
 :rule-classes :rewrite)

Theorem: cst-basic-character-not-single-quote-or-backslash-conc2-rep-elem-match

(defthm
 cst-basic-character-not-single-quote-or-backslash-conc2-rep-elem-match
 (implies
   (and (cst-matchp abnf::cst
                    "basic-character-not-single-quote-or-backslash")
        (equal (cst-basic-character-not-single-quote-or-backslash-conc?
                    abnf::cst)
               2))
   (b* ((abnf::cst1 (cst-basic-character-not-single-quote-or-backslash-conc2-rep-elem
                         abnf::cst)))
     (cst-matchp abnf::cst1 "digit")))
 :rule-classes :rewrite)

Theorem: cst-basic-character-not-single-quote-or-backslash-conc2-rep-elem-of-tree-fix-cst

(defthm
 cst-basic-character-not-single-quote-or-backslash-conc2-rep-elem-of-tree-fix-cst
 (equal (cst-basic-character-not-single-quote-or-backslash-conc2-rep-elem
             (abnf::tree-fix abnf::cst))
        (cst-basic-character-not-single-quote-or-backslash-conc2-rep-elem
             abnf::cst)))

Theorem: cst-basic-character-not-single-quote-or-backslash-conc2-rep-elem-tree-equiv-congruence-on-cst

(defthm
 cst-basic-character-not-single-quote-or-backslash-conc2-rep-elem-tree-equiv-congruence-on-cst
 (implies (abnf::tree-equiv abnf::cst cst-equiv)
          (equal (cst-basic-character-not-single-quote-or-backslash-conc2-rep-elem
                      abnf::cst)
                 (cst-basic-character-not-single-quote-or-backslash-conc2-rep-elem
                      cst-equiv)))
 :rule-classes :congruence)

Function: cst-basic-character-not-single-quote-or-backslash-conc3-rep-elem

(defun
   cst-basic-character-not-single-quote-or-backslash-conc3-rep-elem
   (abnf::cst)
 (declare (xargs :guard (abnf::treep abnf::cst)))
 (declare
  (xargs
   :guard
   (and (cst-matchp abnf::cst
                    "basic-character-not-single-quote-or-backslash")
        (equal (cst-basic-character-not-single-quote-or-backslash-conc?
                    abnf::cst)
               3))))
 (let
  ((__function__
    'cst-basic-character-not-single-quote-or-backslash-conc3-rep-elem))
  (declare (ignorable __function__))
  (abnf::tree-fix (nth 0
                       (cst-basic-character-not-single-quote-or-backslash-conc3-rep
                            abnf::cst)))))

Theorem: treep-of-cst-basic-character-not-single-quote-or-backslash-conc3-rep-elem

(defthm
 treep-of-cst-basic-character-not-single-quote-or-backslash-conc3-rep-elem
 (b* ((abnf::cst1 (cst-basic-character-not-single-quote-or-backslash-conc3-rep-elem
                       abnf::cst)))
   (abnf::treep abnf::cst1))
 :rule-classes :rewrite)

Theorem: cst-basic-character-not-single-quote-or-backslash-conc3-rep-elem-match

(defthm
 cst-basic-character-not-single-quote-or-backslash-conc3-rep-elem-match
 (implies
  (and (cst-matchp abnf::cst
                   "basic-character-not-single-quote-or-backslash")
       (equal (cst-basic-character-not-single-quote-or-backslash-conc?
                   abnf::cst)
              3))
  (b* ((abnf::cst1 (cst-basic-character-not-single-quote-or-backslash-conc3-rep-elem
                        abnf::cst)))
    (cst-matchp abnf::cst1
                "graphic-character-not-single-quote-or-backslash")))
 :rule-classes :rewrite)

Theorem: cst-basic-character-not-single-quote-or-backslash-conc3-rep-elem-of-tree-fix-cst

(defthm
 cst-basic-character-not-single-quote-or-backslash-conc3-rep-elem-of-tree-fix-cst
 (equal (cst-basic-character-not-single-quote-or-backslash-conc3-rep-elem
             (abnf::tree-fix abnf::cst))
        (cst-basic-character-not-single-quote-or-backslash-conc3-rep-elem
             abnf::cst)))

Theorem: cst-basic-character-not-single-quote-or-backslash-conc3-rep-elem-tree-equiv-congruence-on-cst

(defthm
 cst-basic-character-not-single-quote-or-backslash-conc3-rep-elem-tree-equiv-congruence-on-cst
 (implies (abnf::tree-equiv abnf::cst cst-equiv)
          (equal (cst-basic-character-not-single-quote-or-backslash-conc3-rep-elem
                      abnf::cst)
                 (cst-basic-character-not-single-quote-or-backslash-conc3-rep-elem
                      cst-equiv)))
 :rule-classes :congruence)

Function: cst-basic-character-not-single-quote-or-backslash-conc4-rep-elem

(defun
   cst-basic-character-not-single-quote-or-backslash-conc4-rep-elem
   (abnf::cst)
 (declare (xargs :guard (abnf::treep abnf::cst)))
 (declare
  (xargs
   :guard
   (and (cst-matchp abnf::cst
                    "basic-character-not-single-quote-or-backslash")
        (equal (cst-basic-character-not-single-quote-or-backslash-conc?
                    abnf::cst)
               4))))
 (let
  ((__function__
    'cst-basic-character-not-single-quote-or-backslash-conc4-rep-elem))
  (declare (ignorable __function__))
  (abnf::tree-fix (nth 0
                       (cst-basic-character-not-single-quote-or-backslash-conc4-rep
                            abnf::cst)))))

Theorem: treep-of-cst-basic-character-not-single-quote-or-backslash-conc4-rep-elem

(defthm
 treep-of-cst-basic-character-not-single-quote-or-backslash-conc4-rep-elem
 (b* ((abnf::cst1 (cst-basic-character-not-single-quote-or-backslash-conc4-rep-elem
                       abnf::cst)))
   (abnf::treep abnf::cst1))
 :rule-classes :rewrite)

Theorem: cst-basic-character-not-single-quote-or-backslash-conc4-rep-elem-match

(defthm
 cst-basic-character-not-single-quote-or-backslash-conc4-rep-elem-match
 (implies
   (and (cst-matchp abnf::cst
                    "basic-character-not-single-quote-or-backslash")
        (equal (cst-basic-character-not-single-quote-or-backslash-conc?
                    abnf::cst)
               4))
   (b* ((abnf::cst1 (cst-basic-character-not-single-quote-or-backslash-conc4-rep-elem
                         abnf::cst)))
     (cst-matchp abnf::cst1 "space")))
 :rule-classes :rewrite)

Theorem: cst-basic-character-not-single-quote-or-backslash-conc4-rep-elem-of-tree-fix-cst

(defthm
 cst-basic-character-not-single-quote-or-backslash-conc4-rep-elem-of-tree-fix-cst
 (equal (cst-basic-character-not-single-quote-or-backslash-conc4-rep-elem
             (abnf::tree-fix abnf::cst))
        (cst-basic-character-not-single-quote-or-backslash-conc4-rep-elem
             abnf::cst)))

Theorem: cst-basic-character-not-single-quote-or-backslash-conc4-rep-elem-tree-equiv-congruence-on-cst

(defthm
 cst-basic-character-not-single-quote-or-backslash-conc4-rep-elem-tree-equiv-congruence-on-cst
 (implies (abnf::tree-equiv abnf::cst cst-equiv)
          (equal (cst-basic-character-not-single-quote-or-backslash-conc4-rep-elem
                      abnf::cst)
                 (cst-basic-character-not-single-quote-or-backslash-conc4-rep-elem
                      cst-equiv)))
 :rule-classes :congruence)

Function: cst-basic-character-not-single-quote-or-backslash-conc5-rep-elem

(defun
   cst-basic-character-not-single-quote-or-backslash-conc5-rep-elem
   (abnf::cst)
 (declare (xargs :guard (abnf::treep abnf::cst)))
 (declare
  (xargs
   :guard
   (and (cst-matchp abnf::cst
                    "basic-character-not-single-quote-or-backslash")
        (equal (cst-basic-character-not-single-quote-or-backslash-conc?
                    abnf::cst)
               5))))
 (let
  ((__function__
    'cst-basic-character-not-single-quote-or-backslash-conc5-rep-elem))
  (declare (ignorable __function__))
  (abnf::tree-fix (nth 0
                       (cst-basic-character-not-single-quote-or-backslash-conc5-rep
                            abnf::cst)))))

Theorem: treep-of-cst-basic-character-not-single-quote-or-backslash-conc5-rep-elem

(defthm
 treep-of-cst-basic-character-not-single-quote-or-backslash-conc5-rep-elem
 (b* ((abnf::cst1 (cst-basic-character-not-single-quote-or-backslash-conc5-rep-elem
                       abnf::cst)))
   (abnf::treep abnf::cst1))
 :rule-classes :rewrite)

Theorem: cst-basic-character-not-single-quote-or-backslash-conc5-rep-elem-match

(defthm
 cst-basic-character-not-single-quote-or-backslash-conc5-rep-elem-match
 (implies
   (and (cst-matchp abnf::cst
                    "basic-character-not-single-quote-or-backslash")
        (equal (cst-basic-character-not-single-quote-or-backslash-conc?
                    abnf::cst)
               5))
   (b* ((abnf::cst1 (cst-basic-character-not-single-quote-or-backslash-conc5-rep-elem
                         abnf::cst)))
     (cst-matchp abnf::cst1 "control-character")))
 :rule-classes :rewrite)

Theorem: cst-basic-character-not-single-quote-or-backslash-conc5-rep-elem-of-tree-fix-cst

(defthm
 cst-basic-character-not-single-quote-or-backslash-conc5-rep-elem-of-tree-fix-cst
 (equal (cst-basic-character-not-single-quote-or-backslash-conc5-rep-elem
             (abnf::tree-fix abnf::cst))
        (cst-basic-character-not-single-quote-or-backslash-conc5-rep-elem
             abnf::cst)))

Theorem: cst-basic-character-not-single-quote-or-backslash-conc5-rep-elem-tree-equiv-congruence-on-cst

(defthm
 cst-basic-character-not-single-quote-or-backslash-conc5-rep-elem-tree-equiv-congruence-on-cst
 (implies (abnf::tree-equiv abnf::cst cst-equiv)
          (equal (cst-basic-character-not-single-quote-or-backslash-conc5-rep-elem
                      abnf::cst)
                 (cst-basic-character-not-single-quote-or-backslash-conc5-rep-elem
                      cst-equiv)))
 :rule-classes :congruence)

Function: cst-basic-character-not-double-quote-or-backslash-conc1-rep-elem

(defun
   cst-basic-character-not-double-quote-or-backslash-conc1-rep-elem
   (abnf::cst)
 (declare (xargs :guard (abnf::treep abnf::cst)))
 (declare
  (xargs
   :guard
   (and (cst-matchp abnf::cst
                    "basic-character-not-double-quote-or-backslash")
        (equal (cst-basic-character-not-double-quote-or-backslash-conc?
                    abnf::cst)
               1))))
 (let
  ((__function__
    'cst-basic-character-not-double-quote-or-backslash-conc1-rep-elem))
  (declare (ignorable __function__))
  (abnf::tree-fix (nth 0
                       (cst-basic-character-not-double-quote-or-backslash-conc1-rep
                            abnf::cst)))))

Theorem: treep-of-cst-basic-character-not-double-quote-or-backslash-conc1-rep-elem

(defthm
 treep-of-cst-basic-character-not-double-quote-or-backslash-conc1-rep-elem
 (b* ((abnf::cst1 (cst-basic-character-not-double-quote-or-backslash-conc1-rep-elem
                       abnf::cst)))
   (abnf::treep abnf::cst1))
 :rule-classes :rewrite)

Theorem: cst-basic-character-not-double-quote-or-backslash-conc1-rep-elem-match

(defthm
 cst-basic-character-not-double-quote-or-backslash-conc1-rep-elem-match
 (implies
   (and (cst-matchp abnf::cst
                    "basic-character-not-double-quote-or-backslash")
        (equal (cst-basic-character-not-double-quote-or-backslash-conc?
                    abnf::cst)
               1))
   (b* ((abnf::cst1 (cst-basic-character-not-double-quote-or-backslash-conc1-rep-elem
                         abnf::cst)))
     (cst-matchp abnf::cst1 "letter")))
 :rule-classes :rewrite)

Theorem: cst-basic-character-not-double-quote-or-backslash-conc1-rep-elem-of-tree-fix-cst

(defthm
 cst-basic-character-not-double-quote-or-backslash-conc1-rep-elem-of-tree-fix-cst
 (equal (cst-basic-character-not-double-quote-or-backslash-conc1-rep-elem
             (abnf::tree-fix abnf::cst))
        (cst-basic-character-not-double-quote-or-backslash-conc1-rep-elem
             abnf::cst)))

Theorem: cst-basic-character-not-double-quote-or-backslash-conc1-rep-elem-tree-equiv-congruence-on-cst

(defthm
 cst-basic-character-not-double-quote-or-backslash-conc1-rep-elem-tree-equiv-congruence-on-cst
 (implies (abnf::tree-equiv abnf::cst cst-equiv)
          (equal (cst-basic-character-not-double-quote-or-backslash-conc1-rep-elem
                      abnf::cst)
                 (cst-basic-character-not-double-quote-or-backslash-conc1-rep-elem
                      cst-equiv)))
 :rule-classes :congruence)

Function: cst-basic-character-not-double-quote-or-backslash-conc2-rep-elem

(defun
   cst-basic-character-not-double-quote-or-backslash-conc2-rep-elem
   (abnf::cst)
 (declare (xargs :guard (abnf::treep abnf::cst)))
 (declare
  (xargs
   :guard
   (and (cst-matchp abnf::cst
                    "basic-character-not-double-quote-or-backslash")
        (equal (cst-basic-character-not-double-quote-or-backslash-conc?
                    abnf::cst)
               2))))
 (let
  ((__function__
    'cst-basic-character-not-double-quote-or-backslash-conc2-rep-elem))
  (declare (ignorable __function__))
  (abnf::tree-fix (nth 0
                       (cst-basic-character-not-double-quote-or-backslash-conc2-rep
                            abnf::cst)))))

Theorem: treep-of-cst-basic-character-not-double-quote-or-backslash-conc2-rep-elem

(defthm
 treep-of-cst-basic-character-not-double-quote-or-backslash-conc2-rep-elem
 (b* ((abnf::cst1 (cst-basic-character-not-double-quote-or-backslash-conc2-rep-elem
                       abnf::cst)))
   (abnf::treep abnf::cst1))
 :rule-classes :rewrite)

Theorem: cst-basic-character-not-double-quote-or-backslash-conc2-rep-elem-match

(defthm
 cst-basic-character-not-double-quote-or-backslash-conc2-rep-elem-match
 (implies
   (and (cst-matchp abnf::cst
                    "basic-character-not-double-quote-or-backslash")
        (equal (cst-basic-character-not-double-quote-or-backslash-conc?
                    abnf::cst)
               2))
   (b* ((abnf::cst1 (cst-basic-character-not-double-quote-or-backslash-conc2-rep-elem
                         abnf::cst)))
     (cst-matchp abnf::cst1 "digit")))
 :rule-classes :rewrite)

Theorem: cst-basic-character-not-double-quote-or-backslash-conc2-rep-elem-of-tree-fix-cst

(defthm
 cst-basic-character-not-double-quote-or-backslash-conc2-rep-elem-of-tree-fix-cst
 (equal (cst-basic-character-not-double-quote-or-backslash-conc2-rep-elem
             (abnf::tree-fix abnf::cst))
        (cst-basic-character-not-double-quote-or-backslash-conc2-rep-elem
             abnf::cst)))

Theorem: cst-basic-character-not-double-quote-or-backslash-conc2-rep-elem-tree-equiv-congruence-on-cst

(defthm
 cst-basic-character-not-double-quote-or-backslash-conc2-rep-elem-tree-equiv-congruence-on-cst
 (implies (abnf::tree-equiv abnf::cst cst-equiv)
          (equal (cst-basic-character-not-double-quote-or-backslash-conc2-rep-elem
                      abnf::cst)
                 (cst-basic-character-not-double-quote-or-backslash-conc2-rep-elem
                      cst-equiv)))
 :rule-classes :congruence)

Function: cst-basic-character-not-double-quote-or-backslash-conc3-rep-elem

(defun
   cst-basic-character-not-double-quote-or-backslash-conc3-rep-elem
   (abnf::cst)
 (declare (xargs :guard (abnf::treep abnf::cst)))
 (declare
  (xargs
   :guard
   (and (cst-matchp abnf::cst
                    "basic-character-not-double-quote-or-backslash")
        (equal (cst-basic-character-not-double-quote-or-backslash-conc?
                    abnf::cst)
               3))))
 (let
  ((__function__
    'cst-basic-character-not-double-quote-or-backslash-conc3-rep-elem))
  (declare (ignorable __function__))
  (abnf::tree-fix (nth 0
                       (cst-basic-character-not-double-quote-or-backslash-conc3-rep
                            abnf::cst)))))

Theorem: treep-of-cst-basic-character-not-double-quote-or-backslash-conc3-rep-elem

(defthm
 treep-of-cst-basic-character-not-double-quote-or-backslash-conc3-rep-elem
 (b* ((abnf::cst1 (cst-basic-character-not-double-quote-or-backslash-conc3-rep-elem
                       abnf::cst)))
   (abnf::treep abnf::cst1))
 :rule-classes :rewrite)

Theorem: cst-basic-character-not-double-quote-or-backslash-conc3-rep-elem-match

(defthm
 cst-basic-character-not-double-quote-or-backslash-conc3-rep-elem-match
 (implies
  (and (cst-matchp abnf::cst
                   "basic-character-not-double-quote-or-backslash")
       (equal (cst-basic-character-not-double-quote-or-backslash-conc?
                   abnf::cst)
              3))
  (b* ((abnf::cst1 (cst-basic-character-not-double-quote-or-backslash-conc3-rep-elem
                        abnf::cst)))
    (cst-matchp abnf::cst1
                "graphic-character-not-double-quote-or-backslash")))
 :rule-classes :rewrite)

Theorem: cst-basic-character-not-double-quote-or-backslash-conc3-rep-elem-of-tree-fix-cst

(defthm
 cst-basic-character-not-double-quote-or-backslash-conc3-rep-elem-of-tree-fix-cst
 (equal (cst-basic-character-not-double-quote-or-backslash-conc3-rep-elem
             (abnf::tree-fix abnf::cst))
        (cst-basic-character-not-double-quote-or-backslash-conc3-rep-elem
             abnf::cst)))

Theorem: cst-basic-character-not-double-quote-or-backslash-conc3-rep-elem-tree-equiv-congruence-on-cst

(defthm
 cst-basic-character-not-double-quote-or-backslash-conc3-rep-elem-tree-equiv-congruence-on-cst
 (implies (abnf::tree-equiv abnf::cst cst-equiv)
          (equal (cst-basic-character-not-double-quote-or-backslash-conc3-rep-elem
                      abnf::cst)
                 (cst-basic-character-not-double-quote-or-backslash-conc3-rep-elem
                      cst-equiv)))
 :rule-classes :congruence)

Function: cst-basic-character-not-double-quote-or-backslash-conc4-rep-elem

(defun
   cst-basic-character-not-double-quote-or-backslash-conc4-rep-elem
   (abnf::cst)
 (declare (xargs :guard (abnf::treep abnf::cst)))
 (declare
  (xargs
   :guard
   (and (cst-matchp abnf::cst
                    "basic-character-not-double-quote-or-backslash")
        (equal (cst-basic-character-not-double-quote-or-backslash-conc?
                    abnf::cst)
               4))))
 (let
  ((__function__
    'cst-basic-character-not-double-quote-or-backslash-conc4-rep-elem))
  (declare (ignorable __function__))
  (abnf::tree-fix (nth 0
                       (cst-basic-character-not-double-quote-or-backslash-conc4-rep
                            abnf::cst)))))

Theorem: treep-of-cst-basic-character-not-double-quote-or-backslash-conc4-rep-elem

(defthm
 treep-of-cst-basic-character-not-double-quote-or-backslash-conc4-rep-elem
 (b* ((abnf::cst1 (cst-basic-character-not-double-quote-or-backslash-conc4-rep-elem
                       abnf::cst)))
   (abnf::treep abnf::cst1))
 :rule-classes :rewrite)

Theorem: cst-basic-character-not-double-quote-or-backslash-conc4-rep-elem-match

(defthm
 cst-basic-character-not-double-quote-or-backslash-conc4-rep-elem-match
 (implies
   (and (cst-matchp abnf::cst
                    "basic-character-not-double-quote-or-backslash")
        (equal (cst-basic-character-not-double-quote-or-backslash-conc?
                    abnf::cst)
               4))
   (b* ((abnf::cst1 (cst-basic-character-not-double-quote-or-backslash-conc4-rep-elem
                         abnf::cst)))
     (cst-matchp abnf::cst1 "space")))
 :rule-classes :rewrite)

Theorem: cst-basic-character-not-double-quote-or-backslash-conc4-rep-elem-of-tree-fix-cst

(defthm
 cst-basic-character-not-double-quote-or-backslash-conc4-rep-elem-of-tree-fix-cst
 (equal (cst-basic-character-not-double-quote-or-backslash-conc4-rep-elem
             (abnf::tree-fix abnf::cst))
        (cst-basic-character-not-double-quote-or-backslash-conc4-rep-elem
             abnf::cst)))

Theorem: cst-basic-character-not-double-quote-or-backslash-conc4-rep-elem-tree-equiv-congruence-on-cst

(defthm
 cst-basic-character-not-double-quote-or-backslash-conc4-rep-elem-tree-equiv-congruence-on-cst
 (implies (abnf::tree-equiv abnf::cst cst-equiv)
          (equal (cst-basic-character-not-double-quote-or-backslash-conc4-rep-elem
                      abnf::cst)
                 (cst-basic-character-not-double-quote-or-backslash-conc4-rep-elem
                      cst-equiv)))
 :rule-classes :congruence)

Function: cst-basic-character-not-double-quote-or-backslash-conc5-rep-elem

(defun
   cst-basic-character-not-double-quote-or-backslash-conc5-rep-elem
   (abnf::cst)
 (declare (xargs :guard (abnf::treep abnf::cst)))
 (declare
  (xargs
   :guard
   (and (cst-matchp abnf::cst
                    "basic-character-not-double-quote-or-backslash")
        (equal (cst-basic-character-not-double-quote-or-backslash-conc?
                    abnf::cst)
               5))))
 (let
  ((__function__
    'cst-basic-character-not-double-quote-or-backslash-conc5-rep-elem))
  (declare (ignorable __function__))
  (abnf::tree-fix (nth 0
                       (cst-basic-character-not-double-quote-or-backslash-conc5-rep
                            abnf::cst)))))

Theorem: treep-of-cst-basic-character-not-double-quote-or-backslash-conc5-rep-elem

(defthm
 treep-of-cst-basic-character-not-double-quote-or-backslash-conc5-rep-elem
 (b* ((abnf::cst1 (cst-basic-character-not-double-quote-or-backslash-conc5-rep-elem
                       abnf::cst)))
   (abnf::treep abnf::cst1))
 :rule-classes :rewrite)

Theorem: cst-basic-character-not-double-quote-or-backslash-conc5-rep-elem-match

(defthm
 cst-basic-character-not-double-quote-or-backslash-conc5-rep-elem-match
 (implies
   (and (cst-matchp abnf::cst
                    "basic-character-not-double-quote-or-backslash")
        (equal (cst-basic-character-not-double-quote-or-backslash-conc?
                    abnf::cst)
               5))
   (b* ((abnf::cst1 (cst-basic-character-not-double-quote-or-backslash-conc5-rep-elem
                         abnf::cst)))
     (cst-matchp abnf::cst1 "control-character")))
 :rule-classes :rewrite)

Theorem: cst-basic-character-not-double-quote-or-backslash-conc5-rep-elem-of-tree-fix-cst

(defthm
 cst-basic-character-not-double-quote-or-backslash-conc5-rep-elem-of-tree-fix-cst
 (equal (cst-basic-character-not-double-quote-or-backslash-conc5-rep-elem
             (abnf::tree-fix abnf::cst))
        (cst-basic-character-not-double-quote-or-backslash-conc5-rep-elem
             abnf::cst)))

Theorem: cst-basic-character-not-double-quote-or-backslash-conc5-rep-elem-tree-equiv-congruence-on-cst

(defthm
 cst-basic-character-not-double-quote-or-backslash-conc5-rep-elem-tree-equiv-congruence-on-cst
 (implies (abnf::tree-equiv abnf::cst cst-equiv)
          (equal (cst-basic-character-not-double-quote-or-backslash-conc5-rep-elem
                      abnf::cst)
                 (cst-basic-character-not-double-quote-or-backslash-conc5-rep-elem
                      cst-equiv)))
 :rule-classes :congruence)

Function: cst-character-not-new-line-conc1-rep-elem

(defun cst-character-not-new-line-conc1-rep-elem (abnf::cst)
 (declare (xargs :guard (abnf::treep abnf::cst)))
 (declare
  (xargs
     :guard (and (cst-matchp abnf::cst "character-not-new-line")
                 (equal (cst-character-not-new-line-conc? abnf::cst)
                        1))))
 (let ((__function__ 'cst-character-not-new-line-conc1-rep-elem))
   (declare (ignorable __function__))
   (abnf::tree-fix
        (nth 0
             (cst-character-not-new-line-conc1-rep abnf::cst)))))

Theorem: treep-of-cst-character-not-new-line-conc1-rep-elem

(defthm treep-of-cst-character-not-new-line-conc1-rep-elem
  (b* ((abnf::cst1
            (cst-character-not-new-line-conc1-rep-elem abnf::cst)))
    (abnf::treep abnf::cst1))
  :rule-classes :rewrite)

Theorem: cst-character-not-new-line-conc1-rep-elem-match

(defthm cst-character-not-new-line-conc1-rep-elem-match
 (implies
   (and (cst-matchp abnf::cst "character-not-new-line")
        (equal (cst-character-not-new-line-conc? abnf::cst)
               1))
   (b* ((abnf::cst1
             (cst-character-not-new-line-conc1-rep-elem abnf::cst)))
     (cst-matchp abnf::cst1 "basic-character")))
 :rule-classes :rewrite)

Theorem: cst-character-not-new-line-conc1-rep-elem-of-tree-fix-cst

(defthm cst-character-not-new-line-conc1-rep-elem-of-tree-fix-cst
  (equal (cst-character-not-new-line-conc1-rep-elem
              (abnf::tree-fix abnf::cst))
         (cst-character-not-new-line-conc1-rep-elem abnf::cst)))

Theorem: cst-character-not-new-line-conc1-rep-elem-tree-equiv-congruence-on-cst

(defthm
 cst-character-not-new-line-conc1-rep-elem-tree-equiv-congruence-on-cst
 (implies
      (abnf::tree-equiv abnf::cst cst-equiv)
      (equal (cst-character-not-new-line-conc1-rep-elem abnf::cst)
             (cst-character-not-new-line-conc1-rep-elem cst-equiv)))
 :rule-classes :congruence)

Function: cst-character-not-new-line-conc2-rep-elem

(defun cst-character-not-new-line-conc2-rep-elem (abnf::cst)
 (declare (xargs :guard (abnf::treep abnf::cst)))
 (declare
  (xargs
     :guard (and (cst-matchp abnf::cst "character-not-new-line")
                 (equal (cst-character-not-new-line-conc? abnf::cst)
                        2))))
 (let ((__function__ 'cst-character-not-new-line-conc2-rep-elem))
   (declare (ignorable __function__))
   (abnf::tree-fix
        (nth 0
             (cst-character-not-new-line-conc2-rep abnf::cst)))))

Theorem: treep-of-cst-character-not-new-line-conc2-rep-elem

(defthm treep-of-cst-character-not-new-line-conc2-rep-elem
  (b* ((abnf::cst1
            (cst-character-not-new-line-conc2-rep-elem abnf::cst)))
    (abnf::treep abnf::cst1))
  :rule-classes :rewrite)

Theorem: cst-character-not-new-line-conc2-rep-elem-match

(defthm cst-character-not-new-line-conc2-rep-elem-match
 (implies
   (and (cst-matchp abnf::cst "character-not-new-line")
        (equal (cst-character-not-new-line-conc? abnf::cst)
               2))
   (b* ((abnf::cst1
             (cst-character-not-new-line-conc2-rep-elem abnf::cst)))
     (cst-matchp abnf::cst1
                 "extended-character-not-new-line")))
 :rule-classes :rewrite)

Theorem: cst-character-not-new-line-conc2-rep-elem-of-tree-fix-cst

(defthm cst-character-not-new-line-conc2-rep-elem-of-tree-fix-cst
  (equal (cst-character-not-new-line-conc2-rep-elem
              (abnf::tree-fix abnf::cst))
         (cst-character-not-new-line-conc2-rep-elem abnf::cst)))

Theorem: cst-character-not-new-line-conc2-rep-elem-tree-equiv-congruence-on-cst

(defthm
 cst-character-not-new-line-conc2-rep-elem-tree-equiv-congruence-on-cst
 (implies
      (abnf::tree-equiv abnf::cst cst-equiv)
      (equal (cst-character-not-new-line-conc2-rep-elem abnf::cst)
             (cst-character-not-new-line-conc2-rep-elem cst-equiv)))
 :rule-classes :congruence)

Function: cst-character-not-star-conc1-rep-elem

(defun cst-character-not-star-conc1-rep-elem (abnf::cst)
 (declare (xargs :guard (abnf::treep abnf::cst)))
 (declare
  (xargs :guard (and (cst-matchp abnf::cst "character-not-star")
                     (equal (cst-character-not-star-conc? abnf::cst)
                            1))))
 (let ((__function__ 'cst-character-not-star-conc1-rep-elem))
   (declare (ignorable __function__))
   (abnf::tree-fix
        (nth 0
             (cst-character-not-star-conc1-rep abnf::cst)))))

Theorem: treep-of-cst-character-not-star-conc1-rep-elem

(defthm treep-of-cst-character-not-star-conc1-rep-elem
  (b*
    ((abnf::cst1 (cst-character-not-star-conc1-rep-elem abnf::cst)))
    (abnf::treep abnf::cst1))
  :rule-classes :rewrite)

Theorem: cst-character-not-star-conc1-rep-elem-match

(defthm cst-character-not-star-conc1-rep-elem-match
 (implies
   (and (cst-matchp abnf::cst "character-not-star")
        (equal (cst-character-not-star-conc? abnf::cst)
               1))
   (b*
    ((abnf::cst1 (cst-character-not-star-conc1-rep-elem abnf::cst)))
    (cst-matchp abnf::cst1 "basic-character-not-star")))
 :rule-classes :rewrite)

Theorem: cst-character-not-star-conc1-rep-elem-of-tree-fix-cst

(defthm cst-character-not-star-conc1-rep-elem-of-tree-fix-cst
 (equal
  (cst-character-not-star-conc1-rep-elem (abnf::tree-fix abnf::cst))
  (cst-character-not-star-conc1-rep-elem abnf::cst)))

Theorem: cst-character-not-star-conc1-rep-elem-tree-equiv-congruence-on-cst

(defthm
 cst-character-not-star-conc1-rep-elem-tree-equiv-congruence-on-cst
 (implies (abnf::tree-equiv abnf::cst cst-equiv)
          (equal (cst-character-not-star-conc1-rep-elem abnf::cst)
                 (cst-character-not-star-conc1-rep-elem cst-equiv)))
 :rule-classes :congruence)

Function: cst-character-not-star-conc2-rep-elem

(defun cst-character-not-star-conc2-rep-elem (abnf::cst)
 (declare (xargs :guard (abnf::treep abnf::cst)))
 (declare
  (xargs :guard (and (cst-matchp abnf::cst "character-not-star")
                     (equal (cst-character-not-star-conc? abnf::cst)
                            2))))
 (let ((__function__ 'cst-character-not-star-conc2-rep-elem))
   (declare (ignorable __function__))
   (abnf::tree-fix
        (nth 0
             (cst-character-not-star-conc2-rep abnf::cst)))))

Theorem: treep-of-cst-character-not-star-conc2-rep-elem

(defthm treep-of-cst-character-not-star-conc2-rep-elem
  (b*
    ((abnf::cst1 (cst-character-not-star-conc2-rep-elem abnf::cst)))
    (abnf::treep abnf::cst1))
  :rule-classes :rewrite)

Theorem: cst-character-not-star-conc2-rep-elem-match

(defthm cst-character-not-star-conc2-rep-elem-match
 (implies
   (and (cst-matchp abnf::cst "character-not-star")
        (equal (cst-character-not-star-conc? abnf::cst)
               2))
   (b*
    ((abnf::cst1 (cst-character-not-star-conc2-rep-elem abnf::cst)))
    (cst-matchp abnf::cst1 "extended-character")))
 :rule-classes :rewrite)

Theorem: cst-character-not-star-conc2-rep-elem-of-tree-fix-cst

(defthm cst-character-not-star-conc2-rep-elem-of-tree-fix-cst
 (equal
  (cst-character-not-star-conc2-rep-elem (abnf::tree-fix abnf::cst))
  (cst-character-not-star-conc2-rep-elem abnf::cst)))

Theorem: cst-character-not-star-conc2-rep-elem-tree-equiv-congruence-on-cst

(defthm
 cst-character-not-star-conc2-rep-elem-tree-equiv-congruence-on-cst
 (implies (abnf::tree-equiv abnf::cst cst-equiv)
          (equal (cst-character-not-star-conc2-rep-elem abnf::cst)
                 (cst-character-not-star-conc2-rep-elem cst-equiv)))
 :rule-classes :congruence)

Function: cst-character-not-star-or-slash-conc1-rep-elem

(defun cst-character-not-star-or-slash-conc1-rep-elem (abnf::cst)
 (declare (xargs :guard (abnf::treep abnf::cst)))
 (declare
  (xargs
       :guard
       (and (cst-matchp abnf::cst "character-not-star-or-slash")
            (equal (cst-character-not-star-or-slash-conc? abnf::cst)
                   1))))
 (let
   ((__function__ 'cst-character-not-star-or-slash-conc1-rep-elem))
  (declare (ignorable __function__))
  (abnf::tree-fix
      (nth 0
           (cst-character-not-star-or-slash-conc1-rep abnf::cst)))))

Theorem: treep-of-cst-character-not-star-or-slash-conc1-rep-elem

(defthm treep-of-cst-character-not-star-or-slash-conc1-rep-elem
 (b*
  ((abnf::cst1
        (cst-character-not-star-or-slash-conc1-rep-elem abnf::cst)))
  (abnf::treep abnf::cst1))
 :rule-classes :rewrite)

Theorem: cst-character-not-star-or-slash-conc1-rep-elem-match

(defthm cst-character-not-star-or-slash-conc1-rep-elem-match
 (implies
  (and (cst-matchp abnf::cst "character-not-star-or-slash")
       (equal (cst-character-not-star-or-slash-conc? abnf::cst)
              1))
  (b*
   ((abnf::cst1
        (cst-character-not-star-or-slash-conc1-rep-elem abnf::cst)))
   (cst-matchp abnf::cst1
               "basic-character-not-star-or-slash")))
 :rule-classes :rewrite)

Theorem: cst-character-not-star-or-slash-conc1-rep-elem-of-tree-fix-cst

(defthm
     cst-character-not-star-or-slash-conc1-rep-elem-of-tree-fix-cst
 (equal (cst-character-not-star-or-slash-conc1-rep-elem
             (abnf::tree-fix abnf::cst))
        (cst-character-not-star-or-slash-conc1-rep-elem abnf::cst)))

Theorem: cst-character-not-star-or-slash-conc1-rep-elem-tree-equiv-congruence-on-cst

(defthm
 cst-character-not-star-or-slash-conc1-rep-elem-tree-equiv-congruence-on-cst
 (implies
   (abnf::tree-equiv abnf::cst cst-equiv)
   (equal
        (cst-character-not-star-or-slash-conc1-rep-elem abnf::cst)
        (cst-character-not-star-or-slash-conc1-rep-elem cst-equiv)))
 :rule-classes :congruence)

Function: cst-character-not-star-or-slash-conc2-rep-elem

(defun cst-character-not-star-or-slash-conc2-rep-elem (abnf::cst)
 (declare (xargs :guard (abnf::treep abnf::cst)))
 (declare
  (xargs
       :guard
       (and (cst-matchp abnf::cst "character-not-star-or-slash")
            (equal (cst-character-not-star-or-slash-conc? abnf::cst)
                   2))))
 (let
   ((__function__ 'cst-character-not-star-or-slash-conc2-rep-elem))
  (declare (ignorable __function__))
  (abnf::tree-fix
      (nth 0
           (cst-character-not-star-or-slash-conc2-rep abnf::cst)))))

Theorem: treep-of-cst-character-not-star-or-slash-conc2-rep-elem

(defthm treep-of-cst-character-not-star-or-slash-conc2-rep-elem
 (b*
  ((abnf::cst1
        (cst-character-not-star-or-slash-conc2-rep-elem abnf::cst)))
  (abnf::treep abnf::cst1))
 :rule-classes :rewrite)

Theorem: cst-character-not-star-or-slash-conc2-rep-elem-match

(defthm cst-character-not-star-or-slash-conc2-rep-elem-match
 (implies
  (and (cst-matchp abnf::cst "character-not-star-or-slash")
       (equal (cst-character-not-star-or-slash-conc? abnf::cst)
              2))
  (b*
   ((abnf::cst1
        (cst-character-not-star-or-slash-conc2-rep-elem abnf::cst)))
   (cst-matchp abnf::cst1 "extended-character")))
 :rule-classes :rewrite)

Theorem: cst-character-not-star-or-slash-conc2-rep-elem-of-tree-fix-cst

(defthm
     cst-character-not-star-or-slash-conc2-rep-elem-of-tree-fix-cst
 (equal (cst-character-not-star-or-slash-conc2-rep-elem
             (abnf::tree-fix abnf::cst))
        (cst-character-not-star-or-slash-conc2-rep-elem abnf::cst)))

Theorem: cst-character-not-star-or-slash-conc2-rep-elem-tree-equiv-congruence-on-cst

(defthm
 cst-character-not-star-or-slash-conc2-rep-elem-tree-equiv-congruence-on-cst
 (implies
   (abnf::tree-equiv abnf::cst cst-equiv)
   (equal
        (cst-character-not-star-or-slash-conc2-rep-elem abnf::cst)
        (cst-character-not-star-or-slash-conc2-rep-elem cst-equiv)))
 :rule-classes :congruence)

Function: cst-character-not-greater-than-or-new-line-conc1-rep-elem

(defun cst-character-not-greater-than-or-new-line-conc1-rep-elem
       (abnf::cst)
 (declare (xargs :guard (abnf::treep abnf::cst)))
 (declare
  (xargs
   :guard
   (and
    (cst-matchp abnf::cst
                "character-not-greater-than-or-new-line")
    (equal
        (cst-character-not-greater-than-or-new-line-conc? abnf::cst)
        1))))
 (let
  ((__function__
        'cst-character-not-greater-than-or-new-line-conc1-rep-elem))
  (declare (ignorable __function__))
  (abnf::tree-fix (nth 0
                       (cst-character-not-greater-than-or-new-line-conc1-rep
                            abnf::cst)))))

Theorem: treep-of-cst-character-not-greater-than-or-new-line-conc1-rep-elem

(defthm
 treep-of-cst-character-not-greater-than-or-new-line-conc1-rep-elem
 (b* ((abnf::cst1 (cst-character-not-greater-than-or-new-line-conc1-rep-elem
                       abnf::cst)))
   (abnf::treep abnf::cst1))
 :rule-classes :rewrite)

Theorem: cst-character-not-greater-than-or-new-line-conc1-rep-elem-match

(defthm
    cst-character-not-greater-than-or-new-line-conc1-rep-elem-match
 (implies
  (and
   (cst-matchp abnf::cst
               "character-not-greater-than-or-new-line")
   (equal
        (cst-character-not-greater-than-or-new-line-conc? abnf::cst)
        1))
  (b* ((abnf::cst1 (cst-character-not-greater-than-or-new-line-conc1-rep-elem
                        abnf::cst)))
    (cst-matchp abnf::cst1
                "basic-character-not-greater-than")))
 :rule-classes :rewrite)

Theorem: cst-character-not-greater-than-or-new-line-conc1-rep-elem-of-tree-fix-cst

(defthm
 cst-character-not-greater-than-or-new-line-conc1-rep-elem-of-tree-fix-cst
 (equal (cst-character-not-greater-than-or-new-line-conc1-rep-elem
             (abnf::tree-fix abnf::cst))
        (cst-character-not-greater-than-or-new-line-conc1-rep-elem
             abnf::cst)))

Theorem: cst-character-not-greater-than-or-new-line-conc1-rep-elem-tree-equiv-congruence-on-cst

(defthm
 cst-character-not-greater-than-or-new-line-conc1-rep-elem-tree-equiv-congruence-on-cst
 (implies (abnf::tree-equiv abnf::cst cst-equiv)
          (equal (cst-character-not-greater-than-or-new-line-conc1-rep-elem
                      abnf::cst)
                 (cst-character-not-greater-than-or-new-line-conc1-rep-elem
                      cst-equiv)))
 :rule-classes :congruence)

Function: cst-character-not-greater-than-or-new-line-conc2-rep-elem

(defun cst-character-not-greater-than-or-new-line-conc2-rep-elem
       (abnf::cst)
 (declare (xargs :guard (abnf::treep abnf::cst)))
 (declare
  (xargs
   :guard
   (and
    (cst-matchp abnf::cst
                "character-not-greater-than-or-new-line")
    (equal
        (cst-character-not-greater-than-or-new-line-conc? abnf::cst)
        2))))
 (let
  ((__function__
        'cst-character-not-greater-than-or-new-line-conc2-rep-elem))
  (declare (ignorable __function__))
  (abnf::tree-fix (nth 0
                       (cst-character-not-greater-than-or-new-line-conc2-rep
                            abnf::cst)))))

Theorem: treep-of-cst-character-not-greater-than-or-new-line-conc2-rep-elem

(defthm
 treep-of-cst-character-not-greater-than-or-new-line-conc2-rep-elem
 (b* ((abnf::cst1 (cst-character-not-greater-than-or-new-line-conc2-rep-elem
                       abnf::cst)))
   (abnf::treep abnf::cst1))
 :rule-classes :rewrite)

Theorem: cst-character-not-greater-than-or-new-line-conc2-rep-elem-match

(defthm
    cst-character-not-greater-than-or-new-line-conc2-rep-elem-match
 (implies
  (and
   (cst-matchp abnf::cst
               "character-not-greater-than-or-new-line")
   (equal
        (cst-character-not-greater-than-or-new-line-conc? abnf::cst)
        2))
  (b* ((abnf::cst1 (cst-character-not-greater-than-or-new-line-conc2-rep-elem
                        abnf::cst)))
    (cst-matchp abnf::cst1
                "extended-character-not-new-line")))
 :rule-classes :rewrite)

Theorem: cst-character-not-greater-than-or-new-line-conc2-rep-elem-of-tree-fix-cst

(defthm
 cst-character-not-greater-than-or-new-line-conc2-rep-elem-of-tree-fix-cst
 (equal (cst-character-not-greater-than-or-new-line-conc2-rep-elem
             (abnf::tree-fix abnf::cst))
        (cst-character-not-greater-than-or-new-line-conc2-rep-elem
             abnf::cst)))

Theorem: cst-character-not-greater-than-or-new-line-conc2-rep-elem-tree-equiv-congruence-on-cst

(defthm
 cst-character-not-greater-than-or-new-line-conc2-rep-elem-tree-equiv-congruence-on-cst
 (implies (abnf::tree-equiv abnf::cst cst-equiv)
          (equal (cst-character-not-greater-than-or-new-line-conc2-rep-elem
                      abnf::cst)
                 (cst-character-not-greater-than-or-new-line-conc2-rep-elem
                      cst-equiv)))
 :rule-classes :congruence)

Function: cst-character-not-double-quote-or-new-line-conc1-rep-elem

(defun cst-character-not-double-quote-or-new-line-conc1-rep-elem
       (abnf::cst)
 (declare (xargs :guard (abnf::treep abnf::cst)))
 (declare
  (xargs
   :guard
   (and
    (cst-matchp abnf::cst
                "character-not-double-quote-or-new-line")
    (equal
        (cst-character-not-double-quote-or-new-line-conc? abnf::cst)
        1))))
 (let
  ((__function__
        'cst-character-not-double-quote-or-new-line-conc1-rep-elem))
  (declare (ignorable __function__))
  (abnf::tree-fix (nth 0
                       (cst-character-not-double-quote-or-new-line-conc1-rep
                            abnf::cst)))))

Theorem: treep-of-cst-character-not-double-quote-or-new-line-conc1-rep-elem

(defthm
 treep-of-cst-character-not-double-quote-or-new-line-conc1-rep-elem
 (b* ((abnf::cst1 (cst-character-not-double-quote-or-new-line-conc1-rep-elem
                       abnf::cst)))
   (abnf::treep abnf::cst1))
 :rule-classes :rewrite)

Theorem: cst-character-not-double-quote-or-new-line-conc1-rep-elem-match

(defthm
    cst-character-not-double-quote-or-new-line-conc1-rep-elem-match
 (implies
  (and
   (cst-matchp abnf::cst
               "character-not-double-quote-or-new-line")
   (equal
        (cst-character-not-double-quote-or-new-line-conc? abnf::cst)
        1))
  (b* ((abnf::cst1 (cst-character-not-double-quote-or-new-line-conc1-rep-elem
                        abnf::cst)))
    (cst-matchp abnf::cst1
                "basic-character-not-double-quote")))
 :rule-classes :rewrite)

Theorem: cst-character-not-double-quote-or-new-line-conc1-rep-elem-of-tree-fix-cst

(defthm
 cst-character-not-double-quote-or-new-line-conc1-rep-elem-of-tree-fix-cst
 (equal (cst-character-not-double-quote-or-new-line-conc1-rep-elem
             (abnf::tree-fix abnf::cst))
        (cst-character-not-double-quote-or-new-line-conc1-rep-elem
             abnf::cst)))

Theorem: cst-character-not-double-quote-or-new-line-conc1-rep-elem-tree-equiv-congruence-on-cst

(defthm
 cst-character-not-double-quote-or-new-line-conc1-rep-elem-tree-equiv-congruence-on-cst
 (implies (abnf::tree-equiv abnf::cst cst-equiv)
          (equal (cst-character-not-double-quote-or-new-line-conc1-rep-elem
                      abnf::cst)
                 (cst-character-not-double-quote-or-new-line-conc1-rep-elem
                      cst-equiv)))
 :rule-classes :congruence)

Function: cst-character-not-double-quote-or-new-line-conc2-rep-elem

(defun cst-character-not-double-quote-or-new-line-conc2-rep-elem
       (abnf::cst)
 (declare (xargs :guard (abnf::treep abnf::cst)))
 (declare
  (xargs
   :guard
   (and
    (cst-matchp abnf::cst
                "character-not-double-quote-or-new-line")
    (equal
        (cst-character-not-double-quote-or-new-line-conc? abnf::cst)
        2))))
 (let
  ((__function__
        'cst-character-not-double-quote-or-new-line-conc2-rep-elem))
  (declare (ignorable __function__))
  (abnf::tree-fix (nth 0
                       (cst-character-not-double-quote-or-new-line-conc2-rep
                            abnf::cst)))))

Theorem: treep-of-cst-character-not-double-quote-or-new-line-conc2-rep-elem

(defthm
 treep-of-cst-character-not-double-quote-or-new-line-conc2-rep-elem
 (b* ((abnf::cst1 (cst-character-not-double-quote-or-new-line-conc2-rep-elem
                       abnf::cst)))
   (abnf::treep abnf::cst1))
 :rule-classes :rewrite)

Theorem: cst-character-not-double-quote-or-new-line-conc2-rep-elem-match

(defthm
    cst-character-not-double-quote-or-new-line-conc2-rep-elem-match
 (implies
  (and
   (cst-matchp abnf::cst
               "character-not-double-quote-or-new-line")
   (equal
        (cst-character-not-double-quote-or-new-line-conc? abnf::cst)
        2))
  (b* ((abnf::cst1 (cst-character-not-double-quote-or-new-line-conc2-rep-elem
                        abnf::cst)))
    (cst-matchp abnf::cst1
                "extended-character-not-new-line")))
 :rule-classes :rewrite)

Theorem: cst-character-not-double-quote-or-new-line-conc2-rep-elem-of-tree-fix-cst

(defthm
 cst-character-not-double-quote-or-new-line-conc2-rep-elem-of-tree-fix-cst
 (equal (cst-character-not-double-quote-or-new-line-conc2-rep-elem
             (abnf::tree-fix abnf::cst))
        (cst-character-not-double-quote-or-new-line-conc2-rep-elem
             abnf::cst)))

Theorem: cst-character-not-double-quote-or-new-line-conc2-rep-elem-tree-equiv-congruence-on-cst

(defthm
 cst-character-not-double-quote-or-new-line-conc2-rep-elem-tree-equiv-congruence-on-cst
 (implies (abnf::tree-equiv abnf::cst cst-equiv)
          (equal (cst-character-not-double-quote-or-new-line-conc2-rep-elem
                      abnf::cst)
                 (cst-character-not-double-quote-or-new-line-conc2-rep-elem
                      cst-equiv)))
 :rule-classes :congruence)

Function: cst-character-not-single-quote-or-backslash-or-new-line-conc1-rep-elem

(defun
 cst-character-not-single-quote-or-backslash-or-new-line-conc1-rep-elem
 (abnf::cst)
 (declare (xargs :guard (abnf::treep abnf::cst)))
 (declare
  (xargs
    :guard
    (and (cst-matchp
              abnf::cst
              "character-not-single-quote-or-backslash-or-new-line")
         (equal (cst-character-not-single-quote-or-backslash-or-new-line-conc?
                     abnf::cst)
                1))))
 (let
  ((__function__
    'cst-character-not-single-quote-or-backslash-or-new-line-conc1-rep-elem))
  (declare (ignorable __function__))
  (abnf::tree-fix (nth 0
                       (cst-character-not-single-quote-or-backslash-or-new-line-conc1-rep
                            abnf::cst)))))

Theorem: treep-of-cst-character-not-single-quote-or-backslash-or-new-line-conc1-rep-elem

(defthm
 treep-of-cst-character-not-single-quote-or-backslash-or-new-line-conc1-rep-elem
 (b* ((abnf::cst1 (cst-character-not-single-quote-or-backslash-or-new-line-conc1-rep-elem
                       abnf::cst)))
   (abnf::treep abnf::cst1))
 :rule-classes :rewrite)

Theorem: cst-character-not-single-quote-or-backslash-or-new-line-conc1-rep-elem-match

(defthm
 cst-character-not-single-quote-or-backslash-or-new-line-conc1-rep-elem-match
 (implies
    (and (cst-matchp
              abnf::cst
              "character-not-single-quote-or-backslash-or-new-line")
         (equal (cst-character-not-single-quote-or-backslash-or-new-line-conc?
                     abnf::cst)
                1))
    (b* ((abnf::cst1 (cst-character-not-single-quote-or-backslash-or-new-line-conc1-rep-elem
                          abnf::cst)))
      (cst-matchp abnf::cst1
                  "basic-character-not-single-quote-or-backslash")))
 :rule-classes :rewrite)

Theorem: cst-character-not-single-quote-or-backslash-or-new-line-conc1-rep-elem-of-tree-fix-cst

(defthm
 cst-character-not-single-quote-or-backslash-or-new-line-conc1-rep-elem-of-tree-fix-cst
 (equal (cst-character-not-single-quote-or-backslash-or-new-line-conc1-rep-elem
             (abnf::tree-fix abnf::cst))
        (cst-character-not-single-quote-or-backslash-or-new-line-conc1-rep-elem
             abnf::cst)))

Theorem: cst-character-not-single-quote-or-backslash-or-new-line-conc1-rep-elem-tree-equiv-congruence-on-cst

(defthm
 cst-character-not-single-quote-or-backslash-or-new-line-conc1-rep-elem-tree-equiv-congruence-on-cst
 (implies (abnf::tree-equiv abnf::cst cst-equiv)
          (equal (cst-character-not-single-quote-or-backslash-or-new-line-conc1-rep-elem
                      abnf::cst)
                 (cst-character-not-single-quote-or-backslash-or-new-line-conc1-rep-elem
                      cst-equiv)))
 :rule-classes :congruence)

Function: cst-character-not-single-quote-or-backslash-or-new-line-conc2-rep-elem

(defun
 cst-character-not-single-quote-or-backslash-or-new-line-conc2-rep-elem
 (abnf::cst)
 (declare (xargs :guard (abnf::treep abnf::cst)))
 (declare
  (xargs
    :guard
    (and (cst-matchp
              abnf::cst
              "character-not-single-quote-or-backslash-or-new-line")
         (equal (cst-character-not-single-quote-or-backslash-or-new-line-conc?
                     abnf::cst)
                2))))
 (let
  ((__function__
    'cst-character-not-single-quote-or-backslash-or-new-line-conc2-rep-elem))
  (declare (ignorable __function__))
  (abnf::tree-fix (nth 0
                       (cst-character-not-single-quote-or-backslash-or-new-line-conc2-rep
                            abnf::cst)))))

Theorem: treep-of-cst-character-not-single-quote-or-backslash-or-new-line-conc2-rep-elem

(defthm
 treep-of-cst-character-not-single-quote-or-backslash-or-new-line-conc2-rep-elem
 (b* ((abnf::cst1 (cst-character-not-single-quote-or-backslash-or-new-line-conc2-rep-elem
                       abnf::cst)))
   (abnf::treep abnf::cst1))
 :rule-classes :rewrite)

Theorem: cst-character-not-single-quote-or-backslash-or-new-line-conc2-rep-elem-match

(defthm
 cst-character-not-single-quote-or-backslash-or-new-line-conc2-rep-elem-match
 (implies
    (and (cst-matchp
              abnf::cst
              "character-not-single-quote-or-backslash-or-new-line")
         (equal (cst-character-not-single-quote-or-backslash-or-new-line-conc?
                     abnf::cst)
                2))
    (b* ((abnf::cst1 (cst-character-not-single-quote-or-backslash-or-new-line-conc2-rep-elem
                          abnf::cst)))
      (cst-matchp abnf::cst1
                  "extended-character-not-new-line")))
 :rule-classes :rewrite)

Theorem: cst-character-not-single-quote-or-backslash-or-new-line-conc2-rep-elem-of-tree-fix-cst

(defthm
 cst-character-not-single-quote-or-backslash-or-new-line-conc2-rep-elem-of-tree-fix-cst
 (equal (cst-character-not-single-quote-or-backslash-or-new-line-conc2-rep-elem
             (abnf::tree-fix abnf::cst))
        (cst-character-not-single-quote-or-backslash-or-new-line-conc2-rep-elem
             abnf::cst)))

Theorem: cst-character-not-single-quote-or-backslash-or-new-line-conc2-rep-elem-tree-equiv-congruence-on-cst

(defthm
 cst-character-not-single-quote-or-backslash-or-new-line-conc2-rep-elem-tree-equiv-congruence-on-cst
 (implies (abnf::tree-equiv abnf::cst cst-equiv)
          (equal (cst-character-not-single-quote-or-backslash-or-new-line-conc2-rep-elem
                      abnf::cst)
                 (cst-character-not-single-quote-or-backslash-or-new-line-conc2-rep-elem
                      cst-equiv)))
 :rule-classes :congruence)

Function: cst-character-not-double-quote-or-backslash-or-new-line-conc1-rep-elem

(defun
 cst-character-not-double-quote-or-backslash-or-new-line-conc1-rep-elem
 (abnf::cst)
 (declare (xargs :guard (abnf::treep abnf::cst)))
 (declare
  (xargs
    :guard
    (and (cst-matchp
              abnf::cst
              "character-not-double-quote-or-backslash-or-new-line")
         (equal (cst-character-not-double-quote-or-backslash-or-new-line-conc?
                     abnf::cst)
                1))))
 (let
  ((__function__
    'cst-character-not-double-quote-or-backslash-or-new-line-conc1-rep-elem))
  (declare (ignorable __function__))
  (abnf::tree-fix (nth 0
                       (cst-character-not-double-quote-or-backslash-or-new-line-conc1-rep
                            abnf::cst)))))

Theorem: treep-of-cst-character-not-double-quote-or-backslash-or-new-line-conc1-rep-elem

(defthm
 treep-of-cst-character-not-double-quote-or-backslash-or-new-line-conc1-rep-elem
 (b* ((abnf::cst1 (cst-character-not-double-quote-or-backslash-or-new-line-conc1-rep-elem
                       abnf::cst)))
   (abnf::treep abnf::cst1))
 :rule-classes :rewrite)

Theorem: cst-character-not-double-quote-or-backslash-or-new-line-conc1-rep-elem-match

(defthm
 cst-character-not-double-quote-or-backslash-or-new-line-conc1-rep-elem-match
 (implies
    (and (cst-matchp
              abnf::cst
              "character-not-double-quote-or-backslash-or-new-line")
         (equal (cst-character-not-double-quote-or-backslash-or-new-line-conc?
                     abnf::cst)
                1))
    (b* ((abnf::cst1 (cst-character-not-double-quote-or-backslash-or-new-line-conc1-rep-elem
                          abnf::cst)))
      (cst-matchp abnf::cst1
                  "basic-character-not-double-quote-or-backslash")))
 :rule-classes :rewrite)

Theorem: cst-character-not-double-quote-or-backslash-or-new-line-conc1-rep-elem-of-tree-fix-cst

(defthm
 cst-character-not-double-quote-or-backslash-or-new-line-conc1-rep-elem-of-tree-fix-cst
 (equal (cst-character-not-double-quote-or-backslash-or-new-line-conc1-rep-elem
             (abnf::tree-fix abnf::cst))
        (cst-character-not-double-quote-or-backslash-or-new-line-conc1-rep-elem
             abnf::cst)))

Theorem: cst-character-not-double-quote-or-backslash-or-new-line-conc1-rep-elem-tree-equiv-congruence-on-cst

(defthm
 cst-character-not-double-quote-or-backslash-or-new-line-conc1-rep-elem-tree-equiv-congruence-on-cst
 (implies (abnf::tree-equiv abnf::cst cst-equiv)
          (equal (cst-character-not-double-quote-or-backslash-or-new-line-conc1-rep-elem
                      abnf::cst)
                 (cst-character-not-double-quote-or-backslash-or-new-line-conc1-rep-elem
                      cst-equiv)))
 :rule-classes :congruence)

Function: cst-character-not-double-quote-or-backslash-or-new-line-conc2-rep-elem

(defun
 cst-character-not-double-quote-or-backslash-or-new-line-conc2-rep-elem
 (abnf::cst)
 (declare (xargs :guard (abnf::treep abnf::cst)))
 (declare
  (xargs
    :guard
    (and (cst-matchp
              abnf::cst
              "character-not-double-quote-or-backslash-or-new-line")
         (equal (cst-character-not-double-quote-or-backslash-or-new-line-conc?
                     abnf::cst)
                2))))
 (let
  ((__function__
    'cst-character-not-double-quote-or-backslash-or-new-line-conc2-rep-elem))
  (declare (ignorable __function__))
  (abnf::tree-fix (nth 0
                       (cst-character-not-double-quote-or-backslash-or-new-line-conc2-rep
                            abnf::cst)))))

Theorem: treep-of-cst-character-not-double-quote-or-backslash-or-new-line-conc2-rep-elem

(defthm
 treep-of-cst-character-not-double-quote-or-backslash-or-new-line-conc2-rep-elem
 (b* ((abnf::cst1 (cst-character-not-double-quote-or-backslash-or-new-line-conc2-rep-elem
                       abnf::cst)))
   (abnf::treep abnf::cst1))
 :rule-classes :rewrite)

Theorem: cst-character-not-double-quote-or-backslash-or-new-line-conc2-rep-elem-match

(defthm
 cst-character-not-double-quote-or-backslash-or-new-line-conc2-rep-elem-match
 (implies
    (and (cst-matchp
              abnf::cst
              "character-not-double-quote-or-backslash-or-new-line")
         (equal (cst-character-not-double-quote-or-backslash-or-new-line-conc?
                     abnf::cst)
                2))
    (b* ((abnf::cst1 (cst-character-not-double-quote-or-backslash-or-new-line-conc2-rep-elem
                          abnf::cst)))
      (cst-matchp abnf::cst1
                  "extended-character-not-new-line")))
 :rule-classes :rewrite)

Theorem: cst-character-not-double-quote-or-backslash-or-new-line-conc2-rep-elem-of-tree-fix-cst

(defthm
 cst-character-not-double-quote-or-backslash-or-new-line-conc2-rep-elem-of-tree-fix-cst
 (equal (cst-character-not-double-quote-or-backslash-or-new-line-conc2-rep-elem
             (abnf::tree-fix abnf::cst))
        (cst-character-not-double-quote-or-backslash-or-new-line-conc2-rep-elem
             abnf::cst)))

Theorem: cst-character-not-double-quote-or-backslash-or-new-line-conc2-rep-elem-tree-equiv-congruence-on-cst

(defthm
 cst-character-not-double-quote-or-backslash-or-new-line-conc2-rep-elem-tree-equiv-congruence-on-cst
 (implies (abnf::tree-equiv abnf::cst cst-equiv)
          (equal (cst-character-not-double-quote-or-backslash-or-new-line-conc2-rep-elem
                      abnf::cst)
                 (cst-character-not-double-quote-or-backslash-or-new-line-conc2-rep-elem
                      cst-equiv)))
 :rule-classes :congruence)

Function: cst-white-space-conc1-rep-elem

(defun cst-white-space-conc1-rep-elem (abnf::cst)
  (declare (xargs :guard (abnf::treep abnf::cst)))
  (declare
       (xargs :guard (and (cst-matchp abnf::cst "white-space")
                          (equal (cst-white-space-conc? abnf::cst)
                                 1))))
  (let ((__function__ 'cst-white-space-conc1-rep-elem))
    (declare (ignorable __function__))
    (abnf::tree-fix (nth 0
                         (cst-white-space-conc1-rep abnf::cst)))))

Theorem: treep-of-cst-white-space-conc1-rep-elem

(defthm treep-of-cst-white-space-conc1-rep-elem
  (b* ((abnf::cst1 (cst-white-space-conc1-rep-elem abnf::cst)))
    (abnf::treep abnf::cst1))
  :rule-classes :rewrite)

Theorem: cst-white-space-conc1-rep-elem-match

(defthm cst-white-space-conc1-rep-elem-match
  (implies
       (and (cst-matchp abnf::cst "white-space")
            (equal (cst-white-space-conc? abnf::cst)
                   1))
       (b* ((abnf::cst1 (cst-white-space-conc1-rep-elem abnf::cst)))
         (cst-matchp abnf::cst1 "space")))
  :rule-classes :rewrite)

Theorem: cst-white-space-conc1-rep-elem-of-tree-fix-cst

(defthm cst-white-space-conc1-rep-elem-of-tree-fix-cst
  (equal (cst-white-space-conc1-rep-elem (abnf::tree-fix abnf::cst))
         (cst-white-space-conc1-rep-elem abnf::cst)))

Theorem: cst-white-space-conc1-rep-elem-tree-equiv-congruence-on-cst

(defthm cst-white-space-conc1-rep-elem-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-white-space-conc1-rep-elem abnf::cst)
                  (cst-white-space-conc1-rep-elem cst-equiv)))
  :rule-classes :congruence)

Function: cst-white-space-conc2-rep-elem

(defun cst-white-space-conc2-rep-elem (abnf::cst)
  (declare (xargs :guard (abnf::treep abnf::cst)))
  (declare
       (xargs :guard (and (cst-matchp abnf::cst "white-space")
                          (equal (cst-white-space-conc? abnf::cst)
                                 2))))
  (let ((__function__ 'cst-white-space-conc2-rep-elem))
    (declare (ignorable __function__))
    (abnf::tree-fix (nth 0
                         (cst-white-space-conc2-rep abnf::cst)))))

Theorem: treep-of-cst-white-space-conc2-rep-elem

(defthm treep-of-cst-white-space-conc2-rep-elem
  (b* ((abnf::cst1 (cst-white-space-conc2-rep-elem abnf::cst)))
    (abnf::treep abnf::cst1))
  :rule-classes :rewrite)

Theorem: cst-white-space-conc2-rep-elem-match

(defthm cst-white-space-conc2-rep-elem-match
  (implies
       (and (cst-matchp abnf::cst "white-space")
            (equal (cst-white-space-conc? abnf::cst)
                   2))
       (b* ((abnf::cst1 (cst-white-space-conc2-rep-elem abnf::cst)))
         (cst-matchp abnf::cst1 "horizontal-tab")))
  :rule-classes :rewrite)

Theorem: cst-white-space-conc2-rep-elem-of-tree-fix-cst

(defthm cst-white-space-conc2-rep-elem-of-tree-fix-cst
  (equal (cst-white-space-conc2-rep-elem (abnf::tree-fix abnf::cst))
         (cst-white-space-conc2-rep-elem abnf::cst)))

Theorem: cst-white-space-conc2-rep-elem-tree-equiv-congruence-on-cst

(defthm cst-white-space-conc2-rep-elem-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-white-space-conc2-rep-elem abnf::cst)
                  (cst-white-space-conc2-rep-elem cst-equiv)))
  :rule-classes :congruence)

Function: cst-white-space-conc3-rep-elem

(defun cst-white-space-conc3-rep-elem (abnf::cst)
  (declare (xargs :guard (abnf::treep abnf::cst)))
  (declare
       (xargs :guard (and (cst-matchp abnf::cst "white-space")
                          (equal (cst-white-space-conc? abnf::cst)
                                 3))))
  (let ((__function__ 'cst-white-space-conc3-rep-elem))
    (declare (ignorable __function__))
    (abnf::tree-fix (nth 0
                         (cst-white-space-conc3-rep abnf::cst)))))

Theorem: treep-of-cst-white-space-conc3-rep-elem

(defthm treep-of-cst-white-space-conc3-rep-elem
  (b* ((abnf::cst1 (cst-white-space-conc3-rep-elem abnf::cst)))
    (abnf::treep abnf::cst1))
  :rule-classes :rewrite)

Theorem: cst-white-space-conc3-rep-elem-match

(defthm cst-white-space-conc3-rep-elem-match
  (implies
       (and (cst-matchp abnf::cst "white-space")
            (equal (cst-white-space-conc? abnf::cst)
                   3))
       (b* ((abnf::cst1 (cst-white-space-conc3-rep-elem abnf::cst)))
         (cst-matchp abnf::cst1 "vertical-tab")))
  :rule-classes :rewrite)

Theorem: cst-white-space-conc3-rep-elem-of-tree-fix-cst

(defthm cst-white-space-conc3-rep-elem-of-tree-fix-cst
  (equal (cst-white-space-conc3-rep-elem (abnf::tree-fix abnf::cst))
         (cst-white-space-conc3-rep-elem abnf::cst)))

Theorem: cst-white-space-conc3-rep-elem-tree-equiv-congruence-on-cst

(defthm cst-white-space-conc3-rep-elem-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-white-space-conc3-rep-elem abnf::cst)
                  (cst-white-space-conc3-rep-elem cst-equiv)))
  :rule-classes :congruence)

Function: cst-white-space-conc4-rep-elem

(defun cst-white-space-conc4-rep-elem (abnf::cst)
  (declare (xargs :guard (abnf::treep abnf::cst)))
  (declare
       (xargs :guard (and (cst-matchp abnf::cst "white-space")
                          (equal (cst-white-space-conc? abnf::cst)
                                 4))))
  (let ((__function__ 'cst-white-space-conc4-rep-elem))
    (declare (ignorable __function__))
    (abnf::tree-fix (nth 0
                         (cst-white-space-conc4-rep abnf::cst)))))

Theorem: treep-of-cst-white-space-conc4-rep-elem

(defthm treep-of-cst-white-space-conc4-rep-elem
  (b* ((abnf::cst1 (cst-white-space-conc4-rep-elem abnf::cst)))
    (abnf::treep abnf::cst1))
  :rule-classes :rewrite)

Theorem: cst-white-space-conc4-rep-elem-match

(defthm cst-white-space-conc4-rep-elem-match
  (implies
       (and (cst-matchp abnf::cst "white-space")
            (equal (cst-white-space-conc? abnf::cst)
                   4))
       (b* ((abnf::cst1 (cst-white-space-conc4-rep-elem abnf::cst)))
         (cst-matchp abnf::cst1 "form-feed")))
  :rule-classes :rewrite)

Theorem: cst-white-space-conc4-rep-elem-of-tree-fix-cst

(defthm cst-white-space-conc4-rep-elem-of-tree-fix-cst
  (equal (cst-white-space-conc4-rep-elem (abnf::tree-fix abnf::cst))
         (cst-white-space-conc4-rep-elem abnf::cst)))

Theorem: cst-white-space-conc4-rep-elem-tree-equiv-congruence-on-cst

(defthm cst-white-space-conc4-rep-elem-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-white-space-conc4-rep-elem abnf::cst)
                  (cst-white-space-conc4-rep-elem cst-equiv)))
  :rule-classes :congruence)

Function: cst-white-space-conc5-rep-elem

(defun cst-white-space-conc5-rep-elem (abnf::cst)
  (declare (xargs :guard (abnf::treep abnf::cst)))
  (declare
       (xargs :guard (and (cst-matchp abnf::cst "white-space")
                          (equal (cst-white-space-conc? abnf::cst)
                                 5))))
  (let ((__function__ 'cst-white-space-conc5-rep-elem))
    (declare (ignorable __function__))
    (abnf::tree-fix (nth 0
                         (cst-white-space-conc5-rep abnf::cst)))))

Theorem: treep-of-cst-white-space-conc5-rep-elem

(defthm treep-of-cst-white-space-conc5-rep-elem
  (b* ((abnf::cst1 (cst-white-space-conc5-rep-elem abnf::cst)))
    (abnf::treep abnf::cst1))
  :rule-classes :rewrite)

Theorem: cst-white-space-conc5-rep-elem-match

(defthm cst-white-space-conc5-rep-elem-match
  (implies
       (and (cst-matchp abnf::cst "white-space")
            (equal (cst-white-space-conc? abnf::cst)
                   5))
       (b* ((abnf::cst1 (cst-white-space-conc5-rep-elem abnf::cst)))
         (cst-matchp abnf::cst1 "new-line")))
  :rule-classes :rewrite)

Theorem: cst-white-space-conc5-rep-elem-of-tree-fix-cst

(defthm cst-white-space-conc5-rep-elem-of-tree-fix-cst
  (equal (cst-white-space-conc5-rep-elem (abnf::tree-fix abnf::cst))
         (cst-white-space-conc5-rep-elem abnf::cst)))

Theorem: cst-white-space-conc5-rep-elem-tree-equiv-congruence-on-cst

(defthm cst-white-space-conc5-rep-elem-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-white-space-conc5-rep-elem abnf::cst)
                  (cst-white-space-conc5-rep-elem cst-equiv)))
  :rule-classes :congruence)

Function: cst-h-char-conc-rep-elem

(defun cst-h-char-conc-rep-elem (abnf::cst)
  (declare (xargs :guard (abnf::treep abnf::cst)))
  (declare (xargs :guard (cst-matchp abnf::cst "h-char")))
  (let ((__function__ 'cst-h-char-conc-rep-elem))
    (declare (ignorable __function__))
    (abnf::tree-fix (nth 0 (cst-h-char-conc-rep abnf::cst)))))

Theorem: treep-of-cst-h-char-conc-rep-elem

(defthm treep-of-cst-h-char-conc-rep-elem
  (b* ((abnf::cst1 (cst-h-char-conc-rep-elem abnf::cst)))
    (abnf::treep abnf::cst1))
  :rule-classes :rewrite)

Theorem: cst-h-char-conc-rep-elem-match

(defthm cst-h-char-conc-rep-elem-match
  (implies (cst-matchp abnf::cst "h-char")
           (b* ((abnf::cst1 (cst-h-char-conc-rep-elem abnf::cst)))
             (cst-matchp abnf::cst1
                         "character-not-greater-than-or-new-line")))
  :rule-classes :rewrite)

Theorem: cst-h-char-conc-rep-elem-of-tree-fix-cst

(defthm cst-h-char-conc-rep-elem-of-tree-fix-cst
  (equal (cst-h-char-conc-rep-elem (abnf::tree-fix abnf::cst))
         (cst-h-char-conc-rep-elem abnf::cst)))

Theorem: cst-h-char-conc-rep-elem-tree-equiv-congruence-on-cst

(defthm cst-h-char-conc-rep-elem-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-h-char-conc-rep-elem abnf::cst)
                  (cst-h-char-conc-rep-elem cst-equiv)))
  :rule-classes :congruence)

Function: cst-q-char-conc-rep-elem

(defun cst-q-char-conc-rep-elem (abnf::cst)
  (declare (xargs :guard (abnf::treep abnf::cst)))
  (declare (xargs :guard (cst-matchp abnf::cst "q-char")))
  (let ((__function__ 'cst-q-char-conc-rep-elem))
    (declare (ignorable __function__))
    (abnf::tree-fix (nth 0 (cst-q-char-conc-rep abnf::cst)))))

Theorem: treep-of-cst-q-char-conc-rep-elem

(defthm treep-of-cst-q-char-conc-rep-elem
  (b* ((abnf::cst1 (cst-q-char-conc-rep-elem abnf::cst)))
    (abnf::treep abnf::cst1))
  :rule-classes :rewrite)

Theorem: cst-q-char-conc-rep-elem-match

(defthm cst-q-char-conc-rep-elem-match
  (implies (cst-matchp abnf::cst "q-char")
           (b* ((abnf::cst1 (cst-q-char-conc-rep-elem abnf::cst)))
             (cst-matchp abnf::cst1
                         "character-not-double-quote-or-new-line")))
  :rule-classes :rewrite)

Theorem: cst-q-char-conc-rep-elem-of-tree-fix-cst

(defthm cst-q-char-conc-rep-elem-of-tree-fix-cst
  (equal (cst-q-char-conc-rep-elem (abnf::tree-fix abnf::cst))
         (cst-q-char-conc-rep-elem abnf::cst)))

Theorem: cst-q-char-conc-rep-elem-tree-equiv-congruence-on-cst

(defthm cst-q-char-conc-rep-elem-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-q-char-conc-rep-elem abnf::cst)
                  (cst-q-char-conc-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-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 "constant")))
  :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 "string-literal")))
  :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 "punctuator")))
  :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-preprocessing-token-conc1-rep-elem

(defun cst-preprocessing-token-conc1-rep-elem (abnf::cst)
 (declare (xargs :guard (abnf::treep abnf::cst)))
 (declare
   (xargs
        :guard (and (cst-matchp abnf::cst "preprocessing-token")
                    (equal (cst-preprocessing-token-conc? abnf::cst)
                           1))))
 (let ((__function__ 'cst-preprocessing-token-conc1-rep-elem))
   (declare (ignorable __function__))
   (abnf::tree-fix
        (nth 0
             (cst-preprocessing-token-conc1-rep abnf::cst)))))

Theorem: treep-of-cst-preprocessing-token-conc1-rep-elem

(defthm treep-of-cst-preprocessing-token-conc1-rep-elem
  (b*
   ((abnf::cst1 (cst-preprocessing-token-conc1-rep-elem abnf::cst)))
   (abnf::treep abnf::cst1))
  :rule-classes :rewrite)

Theorem: cst-preprocessing-token-conc1-rep-elem-match

(defthm cst-preprocessing-token-conc1-rep-elem-match
 (implies
  (and (cst-matchp abnf::cst "preprocessing-token")
       (equal (cst-preprocessing-token-conc? abnf::cst)
              1))
  (b*
   ((abnf::cst1 (cst-preprocessing-token-conc1-rep-elem abnf::cst)))
   (cst-matchp abnf::cst1 "header-name")))
 :rule-classes :rewrite)

Theorem: cst-preprocessing-token-conc1-rep-elem-of-tree-fix-cst

(defthm cst-preprocessing-token-conc1-rep-elem-of-tree-fix-cst
  (equal (cst-preprocessing-token-conc1-rep-elem
              (abnf::tree-fix abnf::cst))
         (cst-preprocessing-token-conc1-rep-elem abnf::cst)))

Theorem: cst-preprocessing-token-conc1-rep-elem-tree-equiv-congruence-on-cst

(defthm
 cst-preprocessing-token-conc1-rep-elem-tree-equiv-congruence-on-cst
 (implies
      (abnf::tree-equiv abnf::cst cst-equiv)
      (equal (cst-preprocessing-token-conc1-rep-elem abnf::cst)
             (cst-preprocessing-token-conc1-rep-elem cst-equiv)))
 :rule-classes :congruence)

Function: cst-preprocessing-token-conc2-rep-elem

(defun cst-preprocessing-token-conc2-rep-elem (abnf::cst)
 (declare (xargs :guard (abnf::treep abnf::cst)))
 (declare
   (xargs
        :guard (and (cst-matchp abnf::cst "preprocessing-token")
                    (equal (cst-preprocessing-token-conc? abnf::cst)
                           2))))
 (let ((__function__ 'cst-preprocessing-token-conc2-rep-elem))
   (declare (ignorable __function__))
   (abnf::tree-fix
        (nth 0
             (cst-preprocessing-token-conc2-rep abnf::cst)))))

Theorem: treep-of-cst-preprocessing-token-conc2-rep-elem

(defthm treep-of-cst-preprocessing-token-conc2-rep-elem
  (b*
   ((abnf::cst1 (cst-preprocessing-token-conc2-rep-elem abnf::cst)))
   (abnf::treep abnf::cst1))
  :rule-classes :rewrite)

Theorem: cst-preprocessing-token-conc2-rep-elem-match

(defthm cst-preprocessing-token-conc2-rep-elem-match
 (implies
  (and (cst-matchp abnf::cst "preprocessing-token")
       (equal (cst-preprocessing-token-conc? abnf::cst)
              2))
  (b*
   ((abnf::cst1 (cst-preprocessing-token-conc2-rep-elem abnf::cst)))
   (cst-matchp abnf::cst1 "identifier")))
 :rule-classes :rewrite)

Theorem: cst-preprocessing-token-conc2-rep-elem-of-tree-fix-cst

(defthm cst-preprocessing-token-conc2-rep-elem-of-tree-fix-cst
  (equal (cst-preprocessing-token-conc2-rep-elem
              (abnf::tree-fix abnf::cst))
         (cst-preprocessing-token-conc2-rep-elem abnf::cst)))

Theorem: cst-preprocessing-token-conc2-rep-elem-tree-equiv-congruence-on-cst

(defthm
 cst-preprocessing-token-conc2-rep-elem-tree-equiv-congruence-on-cst
 (implies
      (abnf::tree-equiv abnf::cst cst-equiv)
      (equal (cst-preprocessing-token-conc2-rep-elem abnf::cst)
             (cst-preprocessing-token-conc2-rep-elem cst-equiv)))
 :rule-classes :congruence)

Function: cst-preprocessing-token-conc3-rep-elem

(defun cst-preprocessing-token-conc3-rep-elem (abnf::cst)
 (declare (xargs :guard (abnf::treep abnf::cst)))
 (declare
   (xargs
        :guard (and (cst-matchp abnf::cst "preprocessing-token")
                    (equal (cst-preprocessing-token-conc? abnf::cst)
                           3))))
 (let ((__function__ 'cst-preprocessing-token-conc3-rep-elem))
   (declare (ignorable __function__))
   (abnf::tree-fix
        (nth 0
             (cst-preprocessing-token-conc3-rep abnf::cst)))))

Theorem: treep-of-cst-preprocessing-token-conc3-rep-elem

(defthm treep-of-cst-preprocessing-token-conc3-rep-elem
  (b*
   ((abnf::cst1 (cst-preprocessing-token-conc3-rep-elem abnf::cst)))
   (abnf::treep abnf::cst1))
  :rule-classes :rewrite)

Theorem: cst-preprocessing-token-conc3-rep-elem-match

(defthm cst-preprocessing-token-conc3-rep-elem-match
 (implies
  (and (cst-matchp abnf::cst "preprocessing-token")
       (equal (cst-preprocessing-token-conc? abnf::cst)
              3))
  (b*
   ((abnf::cst1 (cst-preprocessing-token-conc3-rep-elem abnf::cst)))
   (cst-matchp abnf::cst1 "pp-number")))
 :rule-classes :rewrite)

Theorem: cst-preprocessing-token-conc3-rep-elem-of-tree-fix-cst

(defthm cst-preprocessing-token-conc3-rep-elem-of-tree-fix-cst
  (equal (cst-preprocessing-token-conc3-rep-elem
              (abnf::tree-fix abnf::cst))
         (cst-preprocessing-token-conc3-rep-elem abnf::cst)))

Theorem: cst-preprocessing-token-conc3-rep-elem-tree-equiv-congruence-on-cst

(defthm
 cst-preprocessing-token-conc3-rep-elem-tree-equiv-congruence-on-cst
 (implies
      (abnf::tree-equiv abnf::cst cst-equiv)
      (equal (cst-preprocessing-token-conc3-rep-elem abnf::cst)
             (cst-preprocessing-token-conc3-rep-elem cst-equiv)))
 :rule-classes :congruence)

Function: cst-preprocessing-token-conc4-rep-elem

(defun cst-preprocessing-token-conc4-rep-elem (abnf::cst)
 (declare (xargs :guard (abnf::treep abnf::cst)))
 (declare
   (xargs
        :guard (and (cst-matchp abnf::cst "preprocessing-token")
                    (equal (cst-preprocessing-token-conc? abnf::cst)
                           4))))
 (let ((__function__ 'cst-preprocessing-token-conc4-rep-elem))
   (declare (ignorable __function__))
   (abnf::tree-fix
        (nth 0
             (cst-preprocessing-token-conc4-rep abnf::cst)))))

Theorem: treep-of-cst-preprocessing-token-conc4-rep-elem

(defthm treep-of-cst-preprocessing-token-conc4-rep-elem
  (b*
   ((abnf::cst1 (cst-preprocessing-token-conc4-rep-elem abnf::cst)))
   (abnf::treep abnf::cst1))
  :rule-classes :rewrite)

Theorem: cst-preprocessing-token-conc4-rep-elem-match

(defthm cst-preprocessing-token-conc4-rep-elem-match
 (implies
  (and (cst-matchp abnf::cst "preprocessing-token")
       (equal (cst-preprocessing-token-conc? abnf::cst)
              4))
  (b*
   ((abnf::cst1 (cst-preprocessing-token-conc4-rep-elem abnf::cst)))
   (cst-matchp abnf::cst1 "character-constant")))
 :rule-classes :rewrite)

Theorem: cst-preprocessing-token-conc4-rep-elem-of-tree-fix-cst

(defthm cst-preprocessing-token-conc4-rep-elem-of-tree-fix-cst
  (equal (cst-preprocessing-token-conc4-rep-elem
              (abnf::tree-fix abnf::cst))
         (cst-preprocessing-token-conc4-rep-elem abnf::cst)))

Theorem: cst-preprocessing-token-conc4-rep-elem-tree-equiv-congruence-on-cst

(defthm
 cst-preprocessing-token-conc4-rep-elem-tree-equiv-congruence-on-cst
 (implies
      (abnf::tree-equiv abnf::cst cst-equiv)
      (equal (cst-preprocessing-token-conc4-rep-elem abnf::cst)
             (cst-preprocessing-token-conc4-rep-elem cst-equiv)))
 :rule-classes :congruence)

Function: cst-preprocessing-token-conc5-rep-elem

(defun cst-preprocessing-token-conc5-rep-elem (abnf::cst)
 (declare (xargs :guard (abnf::treep abnf::cst)))
 (declare
   (xargs
        :guard (and (cst-matchp abnf::cst "preprocessing-token")
                    (equal (cst-preprocessing-token-conc? abnf::cst)
                           5))))
 (let ((__function__ 'cst-preprocessing-token-conc5-rep-elem))
   (declare (ignorable __function__))
   (abnf::tree-fix
        (nth 0
             (cst-preprocessing-token-conc5-rep abnf::cst)))))

Theorem: treep-of-cst-preprocessing-token-conc5-rep-elem

(defthm treep-of-cst-preprocessing-token-conc5-rep-elem
  (b*
   ((abnf::cst1 (cst-preprocessing-token-conc5-rep-elem abnf::cst)))
   (abnf::treep abnf::cst1))
  :rule-classes :rewrite)

Theorem: cst-preprocessing-token-conc5-rep-elem-match

(defthm cst-preprocessing-token-conc5-rep-elem-match
 (implies
  (and (cst-matchp abnf::cst "preprocessing-token")
       (equal (cst-preprocessing-token-conc? abnf::cst)
              5))
  (b*
   ((abnf::cst1 (cst-preprocessing-token-conc5-rep-elem abnf::cst)))
   (cst-matchp abnf::cst1 "string-literal")))
 :rule-classes :rewrite)

Theorem: cst-preprocessing-token-conc5-rep-elem-of-tree-fix-cst

(defthm cst-preprocessing-token-conc5-rep-elem-of-tree-fix-cst
  (equal (cst-preprocessing-token-conc5-rep-elem
              (abnf::tree-fix abnf::cst))
         (cst-preprocessing-token-conc5-rep-elem abnf::cst)))

Theorem: cst-preprocessing-token-conc5-rep-elem-tree-equiv-congruence-on-cst

(defthm
 cst-preprocessing-token-conc5-rep-elem-tree-equiv-congruence-on-cst
 (implies
      (abnf::tree-equiv abnf::cst cst-equiv)
      (equal (cst-preprocessing-token-conc5-rep-elem abnf::cst)
             (cst-preprocessing-token-conc5-rep-elem cst-equiv)))
 :rule-classes :congruence)

Function: cst-preprocessing-token-conc6-rep-elem

(defun cst-preprocessing-token-conc6-rep-elem (abnf::cst)
 (declare (xargs :guard (abnf::treep abnf::cst)))
 (declare
   (xargs
        :guard (and (cst-matchp abnf::cst "preprocessing-token")
                    (equal (cst-preprocessing-token-conc? abnf::cst)
                           6))))
 (let ((__function__ 'cst-preprocessing-token-conc6-rep-elem))
   (declare (ignorable __function__))
   (abnf::tree-fix
        (nth 0
             (cst-preprocessing-token-conc6-rep abnf::cst)))))

Theorem: treep-of-cst-preprocessing-token-conc6-rep-elem

(defthm treep-of-cst-preprocessing-token-conc6-rep-elem
  (b*
   ((abnf::cst1 (cst-preprocessing-token-conc6-rep-elem abnf::cst)))
   (abnf::treep abnf::cst1))
  :rule-classes :rewrite)

Theorem: cst-preprocessing-token-conc6-rep-elem-match

(defthm cst-preprocessing-token-conc6-rep-elem-match
 (implies
  (and (cst-matchp abnf::cst "preprocessing-token")
       (equal (cst-preprocessing-token-conc? abnf::cst)
              6))
  (b*
   ((abnf::cst1 (cst-preprocessing-token-conc6-rep-elem abnf::cst)))
   (cst-matchp abnf::cst1 "punctuator")))
 :rule-classes :rewrite)

Theorem: cst-preprocessing-token-conc6-rep-elem-of-tree-fix-cst

(defthm cst-preprocessing-token-conc6-rep-elem-of-tree-fix-cst
  (equal (cst-preprocessing-token-conc6-rep-elem
              (abnf::tree-fix abnf::cst))
         (cst-preprocessing-token-conc6-rep-elem abnf::cst)))

Theorem: cst-preprocessing-token-conc6-rep-elem-tree-equiv-congruence-on-cst

(defthm
 cst-preprocessing-token-conc6-rep-elem-tree-equiv-congruence-on-cst
 (implies
      (abnf::tree-equiv abnf::cst cst-equiv)
      (equal (cst-preprocessing-token-conc6-rep-elem abnf::cst)
             (cst-preprocessing-token-conc6-rep-elem cst-equiv)))
 :rule-classes :congruence)

Function: cst-preprocessing-token-conc7-rep-elem

(defun cst-preprocessing-token-conc7-rep-elem (abnf::cst)
 (declare (xargs :guard (abnf::treep abnf::cst)))
 (declare
   (xargs
        :guard (and (cst-matchp abnf::cst "preprocessing-token")
                    (equal (cst-preprocessing-token-conc? abnf::cst)
                           7))))
 (let ((__function__ 'cst-preprocessing-token-conc7-rep-elem))
   (declare (ignorable __function__))
   (abnf::tree-fix
        (nth 0
             (cst-preprocessing-token-conc7-rep abnf::cst)))))

Theorem: treep-of-cst-preprocessing-token-conc7-rep-elem

(defthm treep-of-cst-preprocessing-token-conc7-rep-elem
  (b*
   ((abnf::cst1 (cst-preprocessing-token-conc7-rep-elem abnf::cst)))
   (abnf::treep abnf::cst1))
  :rule-classes :rewrite)

Theorem: cst-preprocessing-token-conc7-rep-elem-match

(defthm cst-preprocessing-token-conc7-rep-elem-match
 (implies
  (and (cst-matchp abnf::cst "preprocessing-token")
       (equal (cst-preprocessing-token-conc? abnf::cst)
              7))
  (b*
   ((abnf::cst1 (cst-preprocessing-token-conc7-rep-elem abnf::cst)))
   (cst-matchp abnf::cst1 "character")))
 :rule-classes :rewrite)

Theorem: cst-preprocessing-token-conc7-rep-elem-of-tree-fix-cst

(defthm cst-preprocessing-token-conc7-rep-elem-of-tree-fix-cst
  (equal (cst-preprocessing-token-conc7-rep-elem
              (abnf::tree-fix abnf::cst))
         (cst-preprocessing-token-conc7-rep-elem abnf::cst)))

Theorem: cst-preprocessing-token-conc7-rep-elem-tree-equiv-congruence-on-cst

(defthm
 cst-preprocessing-token-conc7-rep-elem-tree-equiv-congruence-on-cst
 (implies
      (abnf::tree-equiv abnf::cst cst-equiv)
      (equal (cst-preprocessing-token-conc7-rep-elem abnf::cst)
             (cst-preprocessing-token-conc7-rep-elem cst-equiv)))
 :rule-classes :congruence)

Function: cst-identifier-nondigit-conc-rep-elem

(defun cst-identifier-nondigit-conc-rep-elem (abnf::cst)
  (declare (xargs :guard (abnf::treep abnf::cst)))
  (declare
       (xargs :guard (cst-matchp abnf::cst "identifier-nondigit")))
  (let ((__function__ 'cst-identifier-nondigit-conc-rep-elem))
    (declare (ignorable __function__))
    (abnf::tree-fix
         (nth 0
              (cst-identifier-nondigit-conc-rep abnf::cst)))))

Theorem: treep-of-cst-identifier-nondigit-conc-rep-elem

(defthm treep-of-cst-identifier-nondigit-conc-rep-elem
  (b*
    ((abnf::cst1 (cst-identifier-nondigit-conc-rep-elem abnf::cst)))
    (abnf::treep abnf::cst1))
  :rule-classes :rewrite)

Theorem: cst-identifier-nondigit-conc-rep-elem-match

(defthm cst-identifier-nondigit-conc-rep-elem-match
 (implies
   (cst-matchp abnf::cst "identifier-nondigit")
   (b*
    ((abnf::cst1 (cst-identifier-nondigit-conc-rep-elem abnf::cst)))
    (cst-matchp abnf::cst1 "nondigit")))
 :rule-classes :rewrite)

Theorem: cst-identifier-nondigit-conc-rep-elem-of-tree-fix-cst

(defthm cst-identifier-nondigit-conc-rep-elem-of-tree-fix-cst
 (equal
  (cst-identifier-nondigit-conc-rep-elem (abnf::tree-fix abnf::cst))
  (cst-identifier-nondigit-conc-rep-elem abnf::cst)))

Theorem: cst-identifier-nondigit-conc-rep-elem-tree-equiv-congruence-on-cst

(defthm
 cst-identifier-nondigit-conc-rep-elem-tree-equiv-congruence-on-cst
 (implies (abnf::tree-equiv abnf::cst cst-equiv)
          (equal (cst-identifier-nondigit-conc-rep-elem abnf::cst)
                 (cst-identifier-nondigit-conc-rep-elem cst-equiv)))
 :rule-classes :congruence)

Function: cst-constant-conc1-rep-elem

(defun cst-constant-conc1-rep-elem (abnf::cst)
  (declare (xargs :guard (abnf::treep abnf::cst)))
  (declare (xargs :guard (and (cst-matchp abnf::cst "constant")
                              (equal (cst-constant-conc? abnf::cst)
                                     1))))
  (let ((__function__ 'cst-constant-conc1-rep-elem))
    (declare (ignorable __function__))
    (abnf::tree-fix (nth 0 (cst-constant-conc1-rep abnf::cst)))))

Theorem: treep-of-cst-constant-conc1-rep-elem

(defthm treep-of-cst-constant-conc1-rep-elem
  (b* ((abnf::cst1 (cst-constant-conc1-rep-elem abnf::cst)))
    (abnf::treep abnf::cst1))
  :rule-classes :rewrite)

Theorem: cst-constant-conc1-rep-elem-match

(defthm cst-constant-conc1-rep-elem-match
 (implies (and (cst-matchp abnf::cst "constant")
               (equal (cst-constant-conc? abnf::cst)
                      1))
          (b* ((abnf::cst1 (cst-constant-conc1-rep-elem abnf::cst)))
            (cst-matchp abnf::cst1 "integer-constant")))
 :rule-classes :rewrite)

Theorem: cst-constant-conc1-rep-elem-of-tree-fix-cst

(defthm cst-constant-conc1-rep-elem-of-tree-fix-cst
  (equal (cst-constant-conc1-rep-elem (abnf::tree-fix abnf::cst))
         (cst-constant-conc1-rep-elem abnf::cst)))

Theorem: cst-constant-conc1-rep-elem-tree-equiv-congruence-on-cst

(defthm cst-constant-conc1-rep-elem-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-constant-conc1-rep-elem abnf::cst)
                  (cst-constant-conc1-rep-elem cst-equiv)))
  :rule-classes :congruence)

Function: cst-constant-conc2-rep-elem

(defun cst-constant-conc2-rep-elem (abnf::cst)
  (declare (xargs :guard (abnf::treep abnf::cst)))
  (declare (xargs :guard (and (cst-matchp abnf::cst "constant")
                              (equal (cst-constant-conc? abnf::cst)
                                     2))))
  (let ((__function__ 'cst-constant-conc2-rep-elem))
    (declare (ignorable __function__))
    (abnf::tree-fix (nth 0 (cst-constant-conc2-rep abnf::cst)))))

Theorem: treep-of-cst-constant-conc2-rep-elem

(defthm treep-of-cst-constant-conc2-rep-elem
  (b* ((abnf::cst1 (cst-constant-conc2-rep-elem abnf::cst)))
    (abnf::treep abnf::cst1))
  :rule-classes :rewrite)

Theorem: cst-constant-conc2-rep-elem-match

(defthm cst-constant-conc2-rep-elem-match
 (implies (and (cst-matchp abnf::cst "constant")
               (equal (cst-constant-conc? abnf::cst)
                      2))
          (b* ((abnf::cst1 (cst-constant-conc2-rep-elem abnf::cst)))
            (cst-matchp abnf::cst1 "floating-constant")))
 :rule-classes :rewrite)

Theorem: cst-constant-conc2-rep-elem-of-tree-fix-cst

(defthm cst-constant-conc2-rep-elem-of-tree-fix-cst
  (equal (cst-constant-conc2-rep-elem (abnf::tree-fix abnf::cst))
         (cst-constant-conc2-rep-elem abnf::cst)))

Theorem: cst-constant-conc2-rep-elem-tree-equiv-congruence-on-cst

(defthm cst-constant-conc2-rep-elem-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-constant-conc2-rep-elem abnf::cst)
                  (cst-constant-conc2-rep-elem cst-equiv)))
  :rule-classes :congruence)

Function: cst-constant-conc3-rep-elem

(defun cst-constant-conc3-rep-elem (abnf::cst)
  (declare (xargs :guard (abnf::treep abnf::cst)))
  (declare (xargs :guard (and (cst-matchp abnf::cst "constant")
                              (equal (cst-constant-conc? abnf::cst)
                                     3))))
  (let ((__function__ 'cst-constant-conc3-rep-elem))
    (declare (ignorable __function__))
    (abnf::tree-fix (nth 0 (cst-constant-conc3-rep abnf::cst)))))

Theorem: treep-of-cst-constant-conc3-rep-elem

(defthm treep-of-cst-constant-conc3-rep-elem
  (b* ((abnf::cst1 (cst-constant-conc3-rep-elem abnf::cst)))
    (abnf::treep abnf::cst1))
  :rule-classes :rewrite)

Theorem: cst-constant-conc3-rep-elem-match

(defthm cst-constant-conc3-rep-elem-match
 (implies (and (cst-matchp abnf::cst "constant")
               (equal (cst-constant-conc? abnf::cst)
                      3))
          (b* ((abnf::cst1 (cst-constant-conc3-rep-elem abnf::cst)))
            (cst-matchp abnf::cst1 "enumeration-constant")))
 :rule-classes :rewrite)

Theorem: cst-constant-conc3-rep-elem-of-tree-fix-cst

(defthm cst-constant-conc3-rep-elem-of-tree-fix-cst
  (equal (cst-constant-conc3-rep-elem (abnf::tree-fix abnf::cst))
         (cst-constant-conc3-rep-elem abnf::cst)))

Theorem: cst-constant-conc3-rep-elem-tree-equiv-congruence-on-cst

(defthm cst-constant-conc3-rep-elem-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-constant-conc3-rep-elem abnf::cst)
                  (cst-constant-conc3-rep-elem cst-equiv)))
  :rule-classes :congruence)

Function: cst-constant-conc4-rep-elem

(defun cst-constant-conc4-rep-elem (abnf::cst)
  (declare (xargs :guard (abnf::treep abnf::cst)))
  (declare (xargs :guard (and (cst-matchp abnf::cst "constant")
                              (equal (cst-constant-conc? abnf::cst)
                                     4))))
  (let ((__function__ 'cst-constant-conc4-rep-elem))
    (declare (ignorable __function__))
    (abnf::tree-fix (nth 0 (cst-constant-conc4-rep abnf::cst)))))

Theorem: treep-of-cst-constant-conc4-rep-elem

(defthm treep-of-cst-constant-conc4-rep-elem
  (b* ((abnf::cst1 (cst-constant-conc4-rep-elem abnf::cst)))
    (abnf::treep abnf::cst1))
  :rule-classes :rewrite)

Theorem: cst-constant-conc4-rep-elem-match

(defthm cst-constant-conc4-rep-elem-match
 (implies (and (cst-matchp abnf::cst "constant")
               (equal (cst-constant-conc? abnf::cst)
                      4))
          (b* ((abnf::cst1 (cst-constant-conc4-rep-elem abnf::cst)))
            (cst-matchp abnf::cst1 "character-constant")))
 :rule-classes :rewrite)

Theorem: cst-constant-conc4-rep-elem-of-tree-fix-cst

(defthm cst-constant-conc4-rep-elem-of-tree-fix-cst
  (equal (cst-constant-conc4-rep-elem (abnf::tree-fix abnf::cst))
         (cst-constant-conc4-rep-elem abnf::cst)))

Theorem: cst-constant-conc4-rep-elem-tree-equiv-congruence-on-cst

(defthm cst-constant-conc4-rep-elem-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-constant-conc4-rep-elem abnf::cst)
                  (cst-constant-conc4-rep-elem cst-equiv)))
  :rule-classes :congruence)

Function: cst-hexadecimal-prefix-conc-rep-elem

(defun cst-hexadecimal-prefix-conc-rep-elem (abnf::cst)
  (declare (xargs :guard (abnf::treep abnf::cst)))
  (declare
       (xargs :guard (cst-matchp abnf::cst "hexadecimal-prefix")))
  (let ((__function__ 'cst-hexadecimal-prefix-conc-rep-elem))
    (declare (ignorable __function__))
    (abnf::tree-fix
         (nth 0
              (cst-hexadecimal-prefix-conc-rep abnf::cst)))))

Theorem: treep-of-cst-hexadecimal-prefix-conc-rep-elem

(defthm treep-of-cst-hexadecimal-prefix-conc-rep-elem
 (b* ((abnf::cst1 (cst-hexadecimal-prefix-conc-rep-elem abnf::cst)))
   (abnf::treep abnf::cst1))
 :rule-classes :rewrite)

Theorem: cst-hexadecimal-prefix-conc-rep-elem-match

(defthm cst-hexadecimal-prefix-conc-rep-elem-match
 (implies
   (cst-matchp abnf::cst "hexadecimal-prefix")
   (b*
     ((abnf::cst1 (cst-hexadecimal-prefix-conc-rep-elem abnf::cst)))
     (cst-matchp abnf::cst1 "%i\"0x\"")))
 :rule-classes :rewrite)

Theorem: cst-hexadecimal-prefix-conc-rep-elem-of-tree-fix-cst

(defthm cst-hexadecimal-prefix-conc-rep-elem-of-tree-fix-cst
 (equal
   (cst-hexadecimal-prefix-conc-rep-elem (abnf::tree-fix abnf::cst))
   (cst-hexadecimal-prefix-conc-rep-elem abnf::cst)))

Theorem: cst-hexadecimal-prefix-conc-rep-elem-tree-equiv-congruence-on-cst

(defthm
  cst-hexadecimal-prefix-conc-rep-elem-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-hexadecimal-prefix-conc-rep-elem abnf::cst)
                  (cst-hexadecimal-prefix-conc-rep-elem cst-equiv)))
  :rule-classes :congruence)

Function: cst-nonzero-digit-conc-rep-elem

(defun cst-nonzero-digit-conc-rep-elem (abnf::cst)
  (declare (xargs :guard (abnf::treep abnf::cst)))
  (declare (xargs :guard (cst-matchp abnf::cst "nonzero-digit")))
  (let ((__function__ 'cst-nonzero-digit-conc-rep-elem))
    (declare (ignorable __function__))
    (abnf::tree-fix (nth 0
                         (cst-nonzero-digit-conc-rep abnf::cst)))))

Theorem: treep-of-cst-nonzero-digit-conc-rep-elem

(defthm treep-of-cst-nonzero-digit-conc-rep-elem
  (b* ((abnf::cst1 (cst-nonzero-digit-conc-rep-elem abnf::cst)))
    (abnf::treep abnf::cst1))
  :rule-classes :rewrite)

Theorem: cst-nonzero-digit-conc-rep-elem-match

(defthm cst-nonzero-digit-conc-rep-elem-match
 (implies
      (cst-matchp abnf::cst "nonzero-digit")
      (b* ((abnf::cst1 (cst-nonzero-digit-conc-rep-elem abnf::cst)))
        (cst-matchp abnf::cst1 "%x31-39")))
 :rule-classes :rewrite)

Theorem: cst-nonzero-digit-conc-rep-elem-of-tree-fix-cst

(defthm cst-nonzero-digit-conc-rep-elem-of-tree-fix-cst
 (equal (cst-nonzero-digit-conc-rep-elem (abnf::tree-fix abnf::cst))
        (cst-nonzero-digit-conc-rep-elem abnf::cst)))

Theorem: cst-nonzero-digit-conc-rep-elem-tree-equiv-congruence-on-cst

(defthm cst-nonzero-digit-conc-rep-elem-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-nonzero-digit-conc-rep-elem abnf::cst)
                  (cst-nonzero-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-unsigned-suffix-conc-rep-elem

(defun cst-unsigned-suffix-conc-rep-elem (abnf::cst)
 (declare (xargs :guard (abnf::treep abnf::cst)))
 (declare (xargs :guard (cst-matchp abnf::cst "unsigned-suffix")))
 (let ((__function__ 'cst-unsigned-suffix-conc-rep-elem))
   (declare (ignorable __function__))
   (abnf::tree-fix (nth 0
                        (cst-unsigned-suffix-conc-rep abnf::cst)))))

Theorem: treep-of-cst-unsigned-suffix-conc-rep-elem

(defthm treep-of-cst-unsigned-suffix-conc-rep-elem
  (b* ((abnf::cst1 (cst-unsigned-suffix-conc-rep-elem abnf::cst)))
    (abnf::treep abnf::cst1))
  :rule-classes :rewrite)

Theorem: cst-unsigned-suffix-conc-rep-elem-match

(defthm cst-unsigned-suffix-conc-rep-elem-match
 (implies
    (cst-matchp abnf::cst "unsigned-suffix")
    (b* ((abnf::cst1 (cst-unsigned-suffix-conc-rep-elem abnf::cst)))
      (cst-matchp abnf::cst1 "%i\"u\"")))
 :rule-classes :rewrite)

Theorem: cst-unsigned-suffix-conc-rep-elem-of-tree-fix-cst

(defthm cst-unsigned-suffix-conc-rep-elem-of-tree-fix-cst
 (equal
      (cst-unsigned-suffix-conc-rep-elem (abnf::tree-fix abnf::cst))
      (cst-unsigned-suffix-conc-rep-elem abnf::cst)))

Theorem: cst-unsigned-suffix-conc-rep-elem-tree-equiv-congruence-on-cst

(defthm
     cst-unsigned-suffix-conc-rep-elem-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-unsigned-suffix-conc-rep-elem abnf::cst)
                  (cst-unsigned-suffix-conc-rep-elem cst-equiv)))
  :rule-classes :congruence)

Function: cst-long-suffix-conc-rep-elem

(defun cst-long-suffix-conc-rep-elem (abnf::cst)
  (declare (xargs :guard (abnf::treep abnf::cst)))
  (declare (xargs :guard (cst-matchp abnf::cst "long-suffix")))
  (let ((__function__ 'cst-long-suffix-conc-rep-elem))
    (declare (ignorable __function__))
    (abnf::tree-fix (nth 0
                         (cst-long-suffix-conc-rep abnf::cst)))))

Theorem: treep-of-cst-long-suffix-conc-rep-elem

(defthm treep-of-cst-long-suffix-conc-rep-elem
  (b* ((abnf::cst1 (cst-long-suffix-conc-rep-elem abnf::cst)))
    (abnf::treep abnf::cst1))
  :rule-classes :rewrite)

Theorem: cst-long-suffix-conc-rep-elem-match

(defthm cst-long-suffix-conc-rep-elem-match
  (implies
       (cst-matchp abnf::cst "long-suffix")
       (b* ((abnf::cst1 (cst-long-suffix-conc-rep-elem abnf::cst)))
         (cst-matchp abnf::cst1 "%i\"l\"")))
  :rule-classes :rewrite)

Theorem: cst-long-suffix-conc-rep-elem-of-tree-fix-cst

(defthm cst-long-suffix-conc-rep-elem-of-tree-fix-cst
  (equal (cst-long-suffix-conc-rep-elem (abnf::tree-fix abnf::cst))
         (cst-long-suffix-conc-rep-elem abnf::cst)))

Theorem: cst-long-suffix-conc-rep-elem-tree-equiv-congruence-on-cst

(defthm cst-long-suffix-conc-rep-elem-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-long-suffix-conc-rep-elem abnf::cst)
                  (cst-long-suffix-conc-rep-elem cst-equiv)))
  :rule-classes :congruence)

Function: cst-floating-constant-conc1-rep-elem

(defun cst-floating-constant-conc1-rep-elem (abnf::cst)
 (declare (xargs :guard (abnf::treep abnf::cst)))
 (declare
   (xargs :guard (and (cst-matchp abnf::cst "floating-constant")
                      (equal (cst-floating-constant-conc? abnf::cst)
                             1))))
 (let ((__function__ 'cst-floating-constant-conc1-rep-elem))
   (declare (ignorable __function__))
   (abnf::tree-fix
        (nth 0
             (cst-floating-constant-conc1-rep abnf::cst)))))

Theorem: treep-of-cst-floating-constant-conc1-rep-elem

(defthm treep-of-cst-floating-constant-conc1-rep-elem
 (b* ((abnf::cst1 (cst-floating-constant-conc1-rep-elem abnf::cst)))
   (abnf::treep abnf::cst1))
 :rule-classes :rewrite)

Theorem: cst-floating-constant-conc1-rep-elem-match

(defthm cst-floating-constant-conc1-rep-elem-match
 (implies
   (and (cst-matchp abnf::cst "floating-constant")
        (equal (cst-floating-constant-conc? abnf::cst)
               1))
   (b*
     ((abnf::cst1 (cst-floating-constant-conc1-rep-elem abnf::cst)))
     (cst-matchp abnf::cst1
                 "decimal-floating-constant")))
 :rule-classes :rewrite)

Theorem: cst-floating-constant-conc1-rep-elem-of-tree-fix-cst

(defthm cst-floating-constant-conc1-rep-elem-of-tree-fix-cst
 (equal
   (cst-floating-constant-conc1-rep-elem (abnf::tree-fix abnf::cst))
   (cst-floating-constant-conc1-rep-elem abnf::cst)))

Theorem: cst-floating-constant-conc1-rep-elem-tree-equiv-congruence-on-cst

(defthm
  cst-floating-constant-conc1-rep-elem-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-floating-constant-conc1-rep-elem abnf::cst)
                  (cst-floating-constant-conc1-rep-elem cst-equiv)))
  :rule-classes :congruence)

Function: cst-floating-constant-conc2-rep-elem

(defun cst-floating-constant-conc2-rep-elem (abnf::cst)
 (declare (xargs :guard (abnf::treep abnf::cst)))
 (declare
   (xargs :guard (and (cst-matchp abnf::cst "floating-constant")
                      (equal (cst-floating-constant-conc? abnf::cst)
                             2))))
 (let ((__function__ 'cst-floating-constant-conc2-rep-elem))
   (declare (ignorable __function__))
   (abnf::tree-fix
        (nth 0
             (cst-floating-constant-conc2-rep abnf::cst)))))

Theorem: treep-of-cst-floating-constant-conc2-rep-elem

(defthm treep-of-cst-floating-constant-conc2-rep-elem
 (b* ((abnf::cst1 (cst-floating-constant-conc2-rep-elem abnf::cst)))
   (abnf::treep abnf::cst1))
 :rule-classes :rewrite)

Theorem: cst-floating-constant-conc2-rep-elem-match

(defthm cst-floating-constant-conc2-rep-elem-match
 (implies
   (and (cst-matchp abnf::cst "floating-constant")
        (equal (cst-floating-constant-conc? abnf::cst)
               2))
   (b*
     ((abnf::cst1 (cst-floating-constant-conc2-rep-elem abnf::cst)))
     (cst-matchp abnf::cst1
                 "hexadecimal-floating-constant")))
 :rule-classes :rewrite)

Theorem: cst-floating-constant-conc2-rep-elem-of-tree-fix-cst

(defthm cst-floating-constant-conc2-rep-elem-of-tree-fix-cst
 (equal
   (cst-floating-constant-conc2-rep-elem (abnf::tree-fix abnf::cst))
   (cst-floating-constant-conc2-rep-elem abnf::cst)))

Theorem: cst-floating-constant-conc2-rep-elem-tree-equiv-congruence-on-cst

(defthm
  cst-floating-constant-conc2-rep-elem-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-floating-constant-conc2-rep-elem abnf::cst)
                  (cst-floating-constant-conc2-rep-elem cst-equiv)))
  :rule-classes :congruence)

Function: cst-enumeration-constant-conc-rep-elem

(defun cst-enumeration-constant-conc-rep-elem (abnf::cst)
  (declare (xargs :guard (abnf::treep abnf::cst)))
  (declare
       (xargs :guard (cst-matchp abnf::cst "enumeration-constant")))
  (let ((__function__ 'cst-enumeration-constant-conc-rep-elem))
    (declare (ignorable __function__))
    (abnf::tree-fix
         (nth 0
              (cst-enumeration-constant-conc-rep abnf::cst)))))

Theorem: treep-of-cst-enumeration-constant-conc-rep-elem

(defthm treep-of-cst-enumeration-constant-conc-rep-elem
  (b*
   ((abnf::cst1 (cst-enumeration-constant-conc-rep-elem abnf::cst)))
   (abnf::treep abnf::cst1))
  :rule-classes :rewrite)

Theorem: cst-enumeration-constant-conc-rep-elem-match

(defthm cst-enumeration-constant-conc-rep-elem-match
 (implies
  (cst-matchp abnf::cst "enumeration-constant")
  (b*
   ((abnf::cst1 (cst-enumeration-constant-conc-rep-elem abnf::cst)))
   (cst-matchp abnf::cst1 "identifier")))
 :rule-classes :rewrite)

Theorem: cst-enumeration-constant-conc-rep-elem-of-tree-fix-cst

(defthm cst-enumeration-constant-conc-rep-elem-of-tree-fix-cst
  (equal (cst-enumeration-constant-conc-rep-elem
              (abnf::tree-fix abnf::cst))
         (cst-enumeration-constant-conc-rep-elem abnf::cst)))

Theorem: cst-enumeration-constant-conc-rep-elem-tree-equiv-congruence-on-cst

(defthm
 cst-enumeration-constant-conc-rep-elem-tree-equiv-congruence-on-cst
 (implies
      (abnf::tree-equiv abnf::cst cst-equiv)
      (equal (cst-enumeration-constant-conc-rep-elem abnf::cst)
             (cst-enumeration-constant-conc-rep-elem cst-equiv)))
 :rule-classes :congruence)

Function: cst-c-char-conc1-rep-elem

(defun cst-c-char-conc1-rep-elem (abnf::cst)
  (declare (xargs :guard (abnf::treep abnf::cst)))
  (declare (xargs :guard (and (cst-matchp abnf::cst "c-char")
                              (equal (cst-c-char-conc? abnf::cst)
                                     1))))
  (let ((__function__ 'cst-c-char-conc1-rep-elem))
    (declare (ignorable __function__))
    (abnf::tree-fix (nth 0 (cst-c-char-conc1-rep abnf::cst)))))

Theorem: treep-of-cst-c-char-conc1-rep-elem

(defthm treep-of-cst-c-char-conc1-rep-elem
  (b* ((abnf::cst1 (cst-c-char-conc1-rep-elem abnf::cst)))
    (abnf::treep abnf::cst1))
  :rule-classes :rewrite)

Theorem: cst-c-char-conc1-rep-elem-match

(defthm cst-c-char-conc1-rep-elem-match
 (implies
     (and (cst-matchp abnf::cst "c-char")
          (equal (cst-c-char-conc? abnf::cst) 1))
     (b* ((abnf::cst1 (cst-c-char-conc1-rep-elem abnf::cst)))
       (cst-matchp
            abnf::cst1
            "character-not-single-quote-or-backslash-or-new-line")))
 :rule-classes :rewrite)

Theorem: cst-c-char-conc1-rep-elem-of-tree-fix-cst

(defthm cst-c-char-conc1-rep-elem-of-tree-fix-cst
  (equal (cst-c-char-conc1-rep-elem (abnf::tree-fix abnf::cst))
         (cst-c-char-conc1-rep-elem abnf::cst)))

Theorem: cst-c-char-conc1-rep-elem-tree-equiv-congruence-on-cst

(defthm cst-c-char-conc1-rep-elem-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-c-char-conc1-rep-elem abnf::cst)
                  (cst-c-char-conc1-rep-elem cst-equiv)))
  :rule-classes :congruence)

Function: cst-c-char-conc2-rep-elem

(defun cst-c-char-conc2-rep-elem (abnf::cst)
  (declare (xargs :guard (abnf::treep abnf::cst)))
  (declare (xargs :guard (and (cst-matchp abnf::cst "c-char")
                              (equal (cst-c-char-conc? abnf::cst)
                                     2))))
  (let ((__function__ 'cst-c-char-conc2-rep-elem))
    (declare (ignorable __function__))
    (abnf::tree-fix (nth 0 (cst-c-char-conc2-rep abnf::cst)))))

Theorem: treep-of-cst-c-char-conc2-rep-elem

(defthm treep-of-cst-c-char-conc2-rep-elem
  (b* ((abnf::cst1 (cst-c-char-conc2-rep-elem abnf::cst)))
    (abnf::treep abnf::cst1))
  :rule-classes :rewrite)

Theorem: cst-c-char-conc2-rep-elem-match

(defthm cst-c-char-conc2-rep-elem-match
  (implies (and (cst-matchp abnf::cst "c-char")
                (equal (cst-c-char-conc? abnf::cst) 2))
           (b* ((abnf::cst1 (cst-c-char-conc2-rep-elem abnf::cst)))
             (cst-matchp abnf::cst1 "escape-sequence")))
  :rule-classes :rewrite)

Theorem: cst-c-char-conc2-rep-elem-of-tree-fix-cst

(defthm cst-c-char-conc2-rep-elem-of-tree-fix-cst
  (equal (cst-c-char-conc2-rep-elem (abnf::tree-fix abnf::cst))
         (cst-c-char-conc2-rep-elem abnf::cst)))

Theorem: cst-c-char-conc2-rep-elem-tree-equiv-congruence-on-cst

(defthm cst-c-char-conc2-rep-elem-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-c-char-conc2-rep-elem abnf::cst)
                  (cst-c-char-conc2-rep-elem cst-equiv)))
  :rule-classes :congruence)

Function: cst-escape-sequence-conc1-rep-elem

(defun cst-escape-sequence-conc1-rep-elem (abnf::cst)
 (declare (xargs :guard (abnf::treep abnf::cst)))
 (declare
     (xargs :guard (and (cst-matchp abnf::cst "escape-sequence")
                        (equal (cst-escape-sequence-conc? abnf::cst)
                               1))))
 (let ((__function__ 'cst-escape-sequence-conc1-rep-elem))
  (declare (ignorable __function__))
  (abnf::tree-fix (nth 0
                       (cst-escape-sequence-conc1-rep abnf::cst)))))

Theorem: treep-of-cst-escape-sequence-conc1-rep-elem

(defthm treep-of-cst-escape-sequence-conc1-rep-elem
  (b* ((abnf::cst1 (cst-escape-sequence-conc1-rep-elem abnf::cst)))
    (abnf::treep abnf::cst1))
  :rule-classes :rewrite)

Theorem: cst-escape-sequence-conc1-rep-elem-match

(defthm cst-escape-sequence-conc1-rep-elem-match
 (implies
   (and (cst-matchp abnf::cst "escape-sequence")
        (equal (cst-escape-sequence-conc? abnf::cst)
               1))
   (b* ((abnf::cst1 (cst-escape-sequence-conc1-rep-elem abnf::cst)))
     (cst-matchp abnf::cst1 "simple-escape-sequence")))
 :rule-classes :rewrite)

Theorem: cst-escape-sequence-conc1-rep-elem-of-tree-fix-cst

(defthm cst-escape-sequence-conc1-rep-elem-of-tree-fix-cst
 (equal
     (cst-escape-sequence-conc1-rep-elem (abnf::tree-fix abnf::cst))
     (cst-escape-sequence-conc1-rep-elem abnf::cst)))

Theorem: cst-escape-sequence-conc1-rep-elem-tree-equiv-congruence-on-cst

(defthm
    cst-escape-sequence-conc1-rep-elem-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-escape-sequence-conc1-rep-elem abnf::cst)
                  (cst-escape-sequence-conc1-rep-elem cst-equiv)))
  :rule-classes :congruence)

Function: cst-escape-sequence-conc2-rep-elem

(defun cst-escape-sequence-conc2-rep-elem (abnf::cst)
 (declare (xargs :guard (abnf::treep abnf::cst)))
 (declare
     (xargs :guard (and (cst-matchp abnf::cst "escape-sequence")
                        (equal (cst-escape-sequence-conc? abnf::cst)
                               2))))
 (let ((__function__ 'cst-escape-sequence-conc2-rep-elem))
  (declare (ignorable __function__))
  (abnf::tree-fix (nth 0
                       (cst-escape-sequence-conc2-rep abnf::cst)))))

Theorem: treep-of-cst-escape-sequence-conc2-rep-elem

(defthm treep-of-cst-escape-sequence-conc2-rep-elem
  (b* ((abnf::cst1 (cst-escape-sequence-conc2-rep-elem abnf::cst)))
    (abnf::treep abnf::cst1))
  :rule-classes :rewrite)

Theorem: cst-escape-sequence-conc2-rep-elem-match

(defthm cst-escape-sequence-conc2-rep-elem-match
 (implies
   (and (cst-matchp abnf::cst "escape-sequence")
        (equal (cst-escape-sequence-conc? abnf::cst)
               2))
   (b* ((abnf::cst1 (cst-escape-sequence-conc2-rep-elem abnf::cst)))
     (cst-matchp abnf::cst1 "octal-escape-sequence")))
 :rule-classes :rewrite)

Theorem: cst-escape-sequence-conc2-rep-elem-of-tree-fix-cst

(defthm cst-escape-sequence-conc2-rep-elem-of-tree-fix-cst
 (equal
     (cst-escape-sequence-conc2-rep-elem (abnf::tree-fix abnf::cst))
     (cst-escape-sequence-conc2-rep-elem abnf::cst)))

Theorem: cst-escape-sequence-conc2-rep-elem-tree-equiv-congruence-on-cst

(defthm
    cst-escape-sequence-conc2-rep-elem-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-escape-sequence-conc2-rep-elem abnf::cst)
                  (cst-escape-sequence-conc2-rep-elem cst-equiv)))
  :rule-classes :congruence)

Function: cst-escape-sequence-conc3-rep-elem

(defun cst-escape-sequence-conc3-rep-elem (abnf::cst)
 (declare (xargs :guard (abnf::treep abnf::cst)))
 (declare
     (xargs :guard (and (cst-matchp abnf::cst "escape-sequence")
                        (equal (cst-escape-sequence-conc? abnf::cst)
                               3))))
 (let ((__function__ 'cst-escape-sequence-conc3-rep-elem))
  (declare (ignorable __function__))
  (abnf::tree-fix (nth 0
                       (cst-escape-sequence-conc3-rep abnf::cst)))))

Theorem: treep-of-cst-escape-sequence-conc3-rep-elem

(defthm treep-of-cst-escape-sequence-conc3-rep-elem
  (b* ((abnf::cst1 (cst-escape-sequence-conc3-rep-elem abnf::cst)))
    (abnf::treep abnf::cst1))
  :rule-classes :rewrite)

Theorem: cst-escape-sequence-conc3-rep-elem-match

(defthm cst-escape-sequence-conc3-rep-elem-match
 (implies
   (and (cst-matchp abnf::cst "escape-sequence")
        (equal (cst-escape-sequence-conc? abnf::cst)
               3))
   (b* ((abnf::cst1 (cst-escape-sequence-conc3-rep-elem abnf::cst)))
     (cst-matchp abnf::cst1
                 "hexadecimal-escape-sequence")))
 :rule-classes :rewrite)

Theorem: cst-escape-sequence-conc3-rep-elem-of-tree-fix-cst

(defthm cst-escape-sequence-conc3-rep-elem-of-tree-fix-cst
 (equal
     (cst-escape-sequence-conc3-rep-elem (abnf::tree-fix abnf::cst))
     (cst-escape-sequence-conc3-rep-elem abnf::cst)))

Theorem: cst-escape-sequence-conc3-rep-elem-tree-equiv-congruence-on-cst

(defthm
    cst-escape-sequence-conc3-rep-elem-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-escape-sequence-conc3-rep-elem abnf::cst)
                  (cst-escape-sequence-conc3-rep-elem cst-equiv)))
  :rule-classes :congruence)

Function: cst-escape-sequence-conc4-rep-elem

(defun cst-escape-sequence-conc4-rep-elem (abnf::cst)
 (declare (xargs :guard (abnf::treep abnf::cst)))
 (declare
     (xargs :guard (and (cst-matchp abnf::cst "escape-sequence")
                        (equal (cst-escape-sequence-conc? abnf::cst)
                               4))))
 (let ((__function__ 'cst-escape-sequence-conc4-rep-elem))
  (declare (ignorable __function__))
  (abnf::tree-fix (nth 0
                       (cst-escape-sequence-conc4-rep abnf::cst)))))

Theorem: treep-of-cst-escape-sequence-conc4-rep-elem

(defthm treep-of-cst-escape-sequence-conc4-rep-elem
  (b* ((abnf::cst1 (cst-escape-sequence-conc4-rep-elem abnf::cst)))
    (abnf::treep abnf::cst1))
  :rule-classes :rewrite)

Theorem: cst-escape-sequence-conc4-rep-elem-match

(defthm cst-escape-sequence-conc4-rep-elem-match
 (implies
   (and (cst-matchp abnf::cst "escape-sequence")
        (equal (cst-escape-sequence-conc? abnf::cst)
               4))
   (b* ((abnf::cst1 (cst-escape-sequence-conc4-rep-elem abnf::cst)))
     (cst-matchp abnf::cst1 "universal-character-name")))
 :rule-classes :rewrite)

Theorem: cst-escape-sequence-conc4-rep-elem-of-tree-fix-cst

(defthm cst-escape-sequence-conc4-rep-elem-of-tree-fix-cst
 (equal
     (cst-escape-sequence-conc4-rep-elem (abnf::tree-fix abnf::cst))
     (cst-escape-sequence-conc4-rep-elem abnf::cst)))

Theorem: cst-escape-sequence-conc4-rep-elem-tree-equiv-congruence-on-cst

(defthm
    cst-escape-sequence-conc4-rep-elem-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-escape-sequence-conc4-rep-elem abnf::cst)
                  (cst-escape-sequence-conc4-rep-elem cst-equiv)))
  :rule-classes :congruence)

Function: cst-s-char-conc1-rep-elem

(defun cst-s-char-conc1-rep-elem (abnf::cst)
  (declare (xargs :guard (abnf::treep abnf::cst)))
  (declare (xargs :guard (and (cst-matchp abnf::cst "s-char")
                              (equal (cst-s-char-conc? abnf::cst)
                                     1))))
  (let ((__function__ 'cst-s-char-conc1-rep-elem))
    (declare (ignorable __function__))
    (abnf::tree-fix (nth 0 (cst-s-char-conc1-rep abnf::cst)))))

Theorem: treep-of-cst-s-char-conc1-rep-elem

(defthm treep-of-cst-s-char-conc1-rep-elem
  (b* ((abnf::cst1 (cst-s-char-conc1-rep-elem abnf::cst)))
    (abnf::treep abnf::cst1))
  :rule-classes :rewrite)

Theorem: cst-s-char-conc1-rep-elem-match

(defthm cst-s-char-conc1-rep-elem-match
 (implies
     (and (cst-matchp abnf::cst "s-char")
          (equal (cst-s-char-conc? abnf::cst) 1))
     (b* ((abnf::cst1 (cst-s-char-conc1-rep-elem abnf::cst)))
       (cst-matchp
            abnf::cst1
            "character-not-double-quote-or-backslash-or-new-line")))
 :rule-classes :rewrite)

Theorem: cst-s-char-conc1-rep-elem-of-tree-fix-cst

(defthm cst-s-char-conc1-rep-elem-of-tree-fix-cst
  (equal (cst-s-char-conc1-rep-elem (abnf::tree-fix abnf::cst))
         (cst-s-char-conc1-rep-elem abnf::cst)))

Theorem: cst-s-char-conc1-rep-elem-tree-equiv-congruence-on-cst

(defthm cst-s-char-conc1-rep-elem-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-s-char-conc1-rep-elem abnf::cst)
                  (cst-s-char-conc1-rep-elem cst-equiv)))
  :rule-classes :congruence)

Function: cst-s-char-conc2-rep-elem

(defun cst-s-char-conc2-rep-elem (abnf::cst)
  (declare (xargs :guard (abnf::treep abnf::cst)))
  (declare (xargs :guard (and (cst-matchp abnf::cst "s-char")
                              (equal (cst-s-char-conc? abnf::cst)
                                     2))))
  (let ((__function__ 'cst-s-char-conc2-rep-elem))
    (declare (ignorable __function__))
    (abnf::tree-fix (nth 0 (cst-s-char-conc2-rep abnf::cst)))))

Theorem: treep-of-cst-s-char-conc2-rep-elem

(defthm treep-of-cst-s-char-conc2-rep-elem
  (b* ((abnf::cst1 (cst-s-char-conc2-rep-elem abnf::cst)))
    (abnf::treep abnf::cst1))
  :rule-classes :rewrite)

Theorem: cst-s-char-conc2-rep-elem-match

(defthm cst-s-char-conc2-rep-elem-match
  (implies (and (cst-matchp abnf::cst "s-char")
                (equal (cst-s-char-conc? abnf::cst) 2))
           (b* ((abnf::cst1 (cst-s-char-conc2-rep-elem abnf::cst)))
             (cst-matchp abnf::cst1 "escape-sequence")))
  :rule-classes :rewrite)

Theorem: cst-s-char-conc2-rep-elem-of-tree-fix-cst

(defthm cst-s-char-conc2-rep-elem-of-tree-fix-cst
  (equal (cst-s-char-conc2-rep-elem (abnf::tree-fix abnf::cst))
         (cst-s-char-conc2-rep-elem abnf::cst)))

Theorem: cst-s-char-conc2-rep-elem-tree-equiv-congruence-on-cst

(defthm cst-s-char-conc2-rep-elem-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-s-char-conc2-rep-elem abnf::cst)
                  (cst-s-char-conc2-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 "control-line")))
  :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-lexeme-conc4-rep-elem

(defun cst-lexeme-conc4-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)
                                     4))))
  (let ((__function__ 'cst-lexeme-conc4-rep-elem))
    (declare (ignorable __function__))
    (abnf::tree-fix (nth 0 (cst-lexeme-conc4-rep abnf::cst)))))

Theorem: treep-of-cst-lexeme-conc4-rep-elem

(defthm treep-of-cst-lexeme-conc4-rep-elem
  (b* ((abnf::cst1 (cst-lexeme-conc4-rep-elem abnf::cst)))
    (abnf::treep abnf::cst1))
  :rule-classes :rewrite)

Theorem: cst-lexeme-conc4-rep-elem-match

(defthm cst-lexeme-conc4-rep-elem-match
  (implies (and (cst-matchp abnf::cst "lexeme")
                (equal (cst-lexeme-conc? abnf::cst) 4))
           (b* ((abnf::cst1 (cst-lexeme-conc4-rep-elem abnf::cst)))
             (cst-matchp abnf::cst1 "white-space")))
  :rule-classes :rewrite)

Theorem: cst-lexeme-conc4-rep-elem-of-tree-fix-cst

(defthm cst-lexeme-conc4-rep-elem-of-tree-fix-cst
  (equal (cst-lexeme-conc4-rep-elem (abnf::tree-fix abnf::cst))
         (cst-lexeme-conc4-rep-elem abnf::cst)))

Theorem: cst-lexeme-conc4-rep-elem-tree-equiv-congruence-on-cst

(defthm cst-lexeme-conc4-rep-elem-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-lexeme-conc4-rep-elem abnf::cst)
                  (cst-lexeme-conc4-rep-elem cst-equiv)))
  :rule-classes :congruence)

Function: cst-constant-expression-conc-rep-elem

(defun cst-constant-expression-conc-rep-elem (abnf::cst)
  (declare (xargs :guard (abnf::treep abnf::cst)))
  (declare
       (xargs :guard (cst-matchp abnf::cst "constant-expression")))
  (let ((__function__ 'cst-constant-expression-conc-rep-elem))
    (declare (ignorable __function__))
    (abnf::tree-fix
         (nth 0
              (cst-constant-expression-conc-rep abnf::cst)))))

Theorem: treep-of-cst-constant-expression-conc-rep-elem

(defthm treep-of-cst-constant-expression-conc-rep-elem
  (b*
    ((abnf::cst1 (cst-constant-expression-conc-rep-elem abnf::cst)))
    (abnf::treep abnf::cst1))
  :rule-classes :rewrite)

Theorem: cst-constant-expression-conc-rep-elem-match

(defthm cst-constant-expression-conc-rep-elem-match
 (implies
   (cst-matchp abnf::cst "constant-expression")
   (b*
    ((abnf::cst1 (cst-constant-expression-conc-rep-elem abnf::cst)))
    (cst-matchp abnf::cst1 "conditional-expression")))
 :rule-classes :rewrite)

Theorem: cst-constant-expression-conc-rep-elem-of-tree-fix-cst

(defthm cst-constant-expression-conc-rep-elem-of-tree-fix-cst
 (equal
  (cst-constant-expression-conc-rep-elem (abnf::tree-fix abnf::cst))
  (cst-constant-expression-conc-rep-elem abnf::cst)))

Theorem: cst-constant-expression-conc-rep-elem-tree-equiv-congruence-on-cst

(defthm
 cst-constant-expression-conc-rep-elem-tree-equiv-congruence-on-cst
 (implies (abnf::tree-equiv abnf::cst cst-equiv)
          (equal (cst-constant-expression-conc-rep-elem abnf::cst)
                 (cst-constant-expression-conc-rep-elem cst-equiv)))
 :rule-classes :congruence)

Function: cst-attribute-name-conc1-rep-elem

(defun cst-attribute-name-conc1-rep-elem (abnf::cst)
 (declare (xargs :guard (abnf::treep abnf::cst)))
 (declare
      (xargs :guard (and (cst-matchp abnf::cst "attribute-name")
                         (equal (cst-attribute-name-conc? abnf::cst)
                                1))))
 (let ((__function__ 'cst-attribute-name-conc1-rep-elem))
   (declare (ignorable __function__))
   (abnf::tree-fix (nth 0
                        (cst-attribute-name-conc1-rep abnf::cst)))))

Theorem: treep-of-cst-attribute-name-conc1-rep-elem

(defthm treep-of-cst-attribute-name-conc1-rep-elem
  (b* ((abnf::cst1 (cst-attribute-name-conc1-rep-elem abnf::cst)))
    (abnf::treep abnf::cst1))
  :rule-classes :rewrite)

Theorem: cst-attribute-name-conc1-rep-elem-match

(defthm cst-attribute-name-conc1-rep-elem-match
 (implies
    (and (cst-matchp abnf::cst "attribute-name")
         (equal (cst-attribute-name-conc? abnf::cst)
                1))
    (b* ((abnf::cst1 (cst-attribute-name-conc1-rep-elem abnf::cst)))
      (cst-matchp abnf::cst1 "identifier")))
 :rule-classes :rewrite)

Theorem: cst-attribute-name-conc1-rep-elem-of-tree-fix-cst

(defthm cst-attribute-name-conc1-rep-elem-of-tree-fix-cst
 (equal
      (cst-attribute-name-conc1-rep-elem (abnf::tree-fix abnf::cst))
      (cst-attribute-name-conc1-rep-elem abnf::cst)))

Theorem: cst-attribute-name-conc1-rep-elem-tree-equiv-congruence-on-cst

(defthm
     cst-attribute-name-conc1-rep-elem-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-attribute-name-conc1-rep-elem abnf::cst)
                  (cst-attribute-name-conc1-rep-elem cst-equiv)))
  :rule-classes :congruence)

Function: cst-attribute-name-conc2-rep-elem

(defun cst-attribute-name-conc2-rep-elem (abnf::cst)
 (declare (xargs :guard (abnf::treep abnf::cst)))
 (declare
      (xargs :guard (and (cst-matchp abnf::cst "attribute-name")
                         (equal (cst-attribute-name-conc? abnf::cst)
                                2))))
 (let ((__function__ 'cst-attribute-name-conc2-rep-elem))
   (declare (ignorable __function__))
   (abnf::tree-fix (nth 0
                        (cst-attribute-name-conc2-rep abnf::cst)))))

Theorem: treep-of-cst-attribute-name-conc2-rep-elem

(defthm treep-of-cst-attribute-name-conc2-rep-elem
  (b* ((abnf::cst1 (cst-attribute-name-conc2-rep-elem abnf::cst)))
    (abnf::treep abnf::cst1))
  :rule-classes :rewrite)

Theorem: cst-attribute-name-conc2-rep-elem-match

(defthm cst-attribute-name-conc2-rep-elem-match
 (implies
    (and (cst-matchp abnf::cst "attribute-name")
         (equal (cst-attribute-name-conc? abnf::cst)
                2))
    (b* ((abnf::cst1 (cst-attribute-name-conc2-rep-elem abnf::cst)))
      (cst-matchp abnf::cst1 "keyword")))
 :rule-classes :rewrite)

Theorem: cst-attribute-name-conc2-rep-elem-of-tree-fix-cst

(defthm cst-attribute-name-conc2-rep-elem-of-tree-fix-cst
 (equal
      (cst-attribute-name-conc2-rep-elem (abnf::tree-fix abnf::cst))
      (cst-attribute-name-conc2-rep-elem abnf::cst)))

Theorem: cst-attribute-name-conc2-rep-elem-tree-equiv-congruence-on-cst

(defthm
     cst-attribute-name-conc2-rep-elem-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-attribute-name-conc2-rep-elem abnf::cst)
                  (cst-attribute-name-conc2-rep-elem cst-equiv)))
  :rule-classes :congruence)

Function: cst-asm-output-operands-conc-rep-elem

(defun cst-asm-output-operands-conc-rep-elem (abnf::cst)
  (declare (xargs :guard (abnf::treep abnf::cst)))
  (declare
       (xargs :guard (cst-matchp abnf::cst "asm-output-operands")))
  (let ((__function__ 'cst-asm-output-operands-conc-rep-elem))
    (declare (ignorable __function__))
    (abnf::tree-fix
         (nth 0
              (cst-asm-output-operands-conc-rep abnf::cst)))))

Theorem: treep-of-cst-asm-output-operands-conc-rep-elem

(defthm treep-of-cst-asm-output-operands-conc-rep-elem
  (b*
    ((abnf::cst1 (cst-asm-output-operands-conc-rep-elem abnf::cst)))
    (abnf::treep abnf::cst1))
  :rule-classes :rewrite)

Theorem: cst-asm-output-operands-conc-rep-elem-match

(defthm cst-asm-output-operands-conc-rep-elem-match
 (implies
   (cst-matchp abnf::cst "asm-output-operands")
   (b*
    ((abnf::cst1 (cst-asm-output-operands-conc-rep-elem abnf::cst)))
    (cst-matchp
         abnf::cst1
         "[ asm-output-operand *( \",\" asm-output-operand ) ]")))
 :rule-classes :rewrite)

Theorem: cst-asm-output-operands-conc-rep-elem-of-tree-fix-cst

(defthm cst-asm-output-operands-conc-rep-elem-of-tree-fix-cst
 (equal
  (cst-asm-output-operands-conc-rep-elem (abnf::tree-fix abnf::cst))
  (cst-asm-output-operands-conc-rep-elem abnf::cst)))

Theorem: cst-asm-output-operands-conc-rep-elem-tree-equiv-congruence-on-cst

(defthm
 cst-asm-output-operands-conc-rep-elem-tree-equiv-congruence-on-cst
 (implies (abnf::tree-equiv abnf::cst cst-equiv)
          (equal (cst-asm-output-operands-conc-rep-elem abnf::cst)
                 (cst-asm-output-operands-conc-rep-elem cst-equiv)))
 :rule-classes :congruence)

Function: cst-asm-input-operands-conc-rep-elem

(defun cst-asm-input-operands-conc-rep-elem (abnf::cst)
  (declare (xargs :guard (abnf::treep abnf::cst)))
  (declare
       (xargs :guard (cst-matchp abnf::cst "asm-input-operands")))
  (let ((__function__ 'cst-asm-input-operands-conc-rep-elem))
    (declare (ignorable __function__))
    (abnf::tree-fix
         (nth 0
              (cst-asm-input-operands-conc-rep abnf::cst)))))

Theorem: treep-of-cst-asm-input-operands-conc-rep-elem

(defthm treep-of-cst-asm-input-operands-conc-rep-elem
 (b* ((abnf::cst1 (cst-asm-input-operands-conc-rep-elem abnf::cst)))
   (abnf::treep abnf::cst1))
 :rule-classes :rewrite)

Theorem: cst-asm-input-operands-conc-rep-elem-match

(defthm cst-asm-input-operands-conc-rep-elem-match
 (implies
  (cst-matchp abnf::cst "asm-input-operands")
  (b*
    ((abnf::cst1 (cst-asm-input-operands-conc-rep-elem abnf::cst)))
   (cst-matchp abnf::cst1
               "[ asm-input-operand *( \",\" asm-input-operand ) ]")))
 :rule-classes :rewrite)

Theorem: cst-asm-input-operands-conc-rep-elem-of-tree-fix-cst

(defthm cst-asm-input-operands-conc-rep-elem-of-tree-fix-cst
 (equal
   (cst-asm-input-operands-conc-rep-elem (abnf::tree-fix abnf::cst))
   (cst-asm-input-operands-conc-rep-elem abnf::cst)))

Theorem: cst-asm-input-operands-conc-rep-elem-tree-equiv-congruence-on-cst

(defthm
  cst-asm-input-operands-conc-rep-elem-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-asm-input-operands-conc-rep-elem abnf::cst)
                  (cst-asm-input-operands-conc-rep-elem cst-equiv)))
  :rule-classes :congruence)

Function: cst-asm-clobbers-conc-rep-elem

(defun cst-asm-clobbers-conc-rep-elem (abnf::cst)
  (declare (xargs :guard (abnf::treep abnf::cst)))
  (declare (xargs :guard (cst-matchp abnf::cst "asm-clobbers")))
  (let ((__function__ 'cst-asm-clobbers-conc-rep-elem))
    (declare (ignorable __function__))
    (abnf::tree-fix (nth 0
                         (cst-asm-clobbers-conc-rep abnf::cst)))))

Theorem: treep-of-cst-asm-clobbers-conc-rep-elem

(defthm treep-of-cst-asm-clobbers-conc-rep-elem
  (b* ((abnf::cst1 (cst-asm-clobbers-conc-rep-elem abnf::cst)))
    (abnf::treep abnf::cst1))
  :rule-classes :rewrite)

Theorem: cst-asm-clobbers-conc-rep-elem-match

(defthm cst-asm-clobbers-conc-rep-elem-match
  (implies
       (cst-matchp abnf::cst "asm-clobbers")
       (b* ((abnf::cst1 (cst-asm-clobbers-conc-rep-elem abnf::cst)))
         (cst-matchp abnf::cst1
                     "[ asm-clobber *( \",\" asm-clobber ) ]")))
  :rule-classes :rewrite)

Theorem: cst-asm-clobbers-conc-rep-elem-of-tree-fix-cst

(defthm cst-asm-clobbers-conc-rep-elem-of-tree-fix-cst
  (equal (cst-asm-clobbers-conc-rep-elem (abnf::tree-fix abnf::cst))
         (cst-asm-clobbers-conc-rep-elem abnf::cst)))

Theorem: cst-asm-clobbers-conc-rep-elem-tree-equiv-congruence-on-cst

(defthm cst-asm-clobbers-conc-rep-elem-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-asm-clobbers-conc-rep-elem abnf::cst)
                  (cst-asm-clobbers-conc-rep-elem cst-equiv)))
  :rule-classes :congruence)

Function: cst-asm-goto-labels-conc-rep-elem

(defun cst-asm-goto-labels-conc-rep-elem (abnf::cst)
 (declare (xargs :guard (abnf::treep abnf::cst)))
 (declare (xargs :guard (cst-matchp abnf::cst "asm-goto-labels")))
 (let ((__function__ 'cst-asm-goto-labels-conc-rep-elem))
   (declare (ignorable __function__))
   (abnf::tree-fix (nth 0
                        (cst-asm-goto-labels-conc-rep abnf::cst)))))

Theorem: treep-of-cst-asm-goto-labels-conc-rep-elem

(defthm treep-of-cst-asm-goto-labels-conc-rep-elem
  (b* ((abnf::cst1 (cst-asm-goto-labels-conc-rep-elem abnf::cst)))
    (abnf::treep abnf::cst1))
  :rule-classes :rewrite)

Theorem: cst-asm-goto-labels-conc-rep-elem-match

(defthm cst-asm-goto-labels-conc-rep-elem-match
 (implies
    (cst-matchp abnf::cst "asm-goto-labels")
    (b* ((abnf::cst1 (cst-asm-goto-labels-conc-rep-elem abnf::cst)))
      (cst-matchp abnf::cst1
                  "[ identifier *( \",\" identifier ) ]")))
 :rule-classes :rewrite)

Theorem: cst-asm-goto-labels-conc-rep-elem-of-tree-fix-cst

(defthm cst-asm-goto-labels-conc-rep-elem-of-tree-fix-cst
 (equal
      (cst-asm-goto-labels-conc-rep-elem (abnf::tree-fix abnf::cst))
      (cst-asm-goto-labels-conc-rep-elem abnf::cst)))

Theorem: cst-asm-goto-labels-conc-rep-elem-tree-equiv-congruence-on-cst

(defthm
     cst-asm-goto-labels-conc-rep-elem-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-asm-goto-labels-conc-rep-elem abnf::cst)
                  (cst-asm-goto-labels-conc-rep-elem cst-equiv)))
  :rule-classes :congruence)

Function: cst-type-qualifier-or-attribute-specifier-conc1-rep-elem

(defun cst-type-qualifier-or-attribute-specifier-conc1-rep-elem
       (abnf::cst)
 (declare (xargs :guard (abnf::treep abnf::cst)))
 (declare
  (xargs
   :guard
   (and
    (cst-matchp abnf::cst
                "type-qualifier-or-attribute-specifier")
    (equal
         (cst-type-qualifier-or-attribute-specifier-conc? abnf::cst)
         1))))
 (let
  ((__function__
        'cst-type-qualifier-or-attribute-specifier-conc1-rep-elem))
  (declare (ignorable __function__))
  (abnf::tree-fix (nth 0
                       (cst-type-qualifier-or-attribute-specifier-conc1-rep
                            abnf::cst)))))

Theorem: treep-of-cst-type-qualifier-or-attribute-specifier-conc1-rep-elem

(defthm
  treep-of-cst-type-qualifier-or-attribute-specifier-conc1-rep-elem
  (b* ((abnf::cst1 (cst-type-qualifier-or-attribute-specifier-conc1-rep-elem
                        abnf::cst)))
    (abnf::treep abnf::cst1))
  :rule-classes :rewrite)

Theorem: cst-type-qualifier-or-attribute-specifier-conc1-rep-elem-match

(defthm
     cst-type-qualifier-or-attribute-specifier-conc1-rep-elem-match
 (implies
  (and
    (cst-matchp abnf::cst
                "type-qualifier-or-attribute-specifier")
    (equal
         (cst-type-qualifier-or-attribute-specifier-conc? abnf::cst)
         1))
  (b* ((abnf::cst1 (cst-type-qualifier-or-attribute-specifier-conc1-rep-elem
                        abnf::cst)))
    (cst-matchp abnf::cst1 "type-qualifier")))
 :rule-classes :rewrite)

Theorem: cst-type-qualifier-or-attribute-specifier-conc1-rep-elem-of-tree-fix-cst

(defthm
 cst-type-qualifier-or-attribute-specifier-conc1-rep-elem-of-tree-fix-cst
 (equal (cst-type-qualifier-or-attribute-specifier-conc1-rep-elem
             (abnf::tree-fix abnf::cst))
        (cst-type-qualifier-or-attribute-specifier-conc1-rep-elem
             abnf::cst)))

Theorem: cst-type-qualifier-or-attribute-specifier-conc1-rep-elem-tree-equiv-congruence-on-cst

(defthm
 cst-type-qualifier-or-attribute-specifier-conc1-rep-elem-tree-equiv-congruence-on-cst
 (implies (abnf::tree-equiv abnf::cst cst-equiv)
          (equal (cst-type-qualifier-or-attribute-specifier-conc1-rep-elem
                      abnf::cst)
                 (cst-type-qualifier-or-attribute-specifier-conc1-rep-elem
                      cst-equiv)))
 :rule-classes :congruence)

Function: cst-type-qualifier-or-attribute-specifier-conc2-rep-elem

(defun cst-type-qualifier-or-attribute-specifier-conc2-rep-elem
       (abnf::cst)
 (declare (xargs :guard (abnf::treep abnf::cst)))
 (declare
  (xargs
   :guard
   (and
    (cst-matchp abnf::cst
                "type-qualifier-or-attribute-specifier")
    (equal
         (cst-type-qualifier-or-attribute-specifier-conc? abnf::cst)
         2))))
 (let
  ((__function__
        'cst-type-qualifier-or-attribute-specifier-conc2-rep-elem))
  (declare (ignorable __function__))
  (abnf::tree-fix (nth 0
                       (cst-type-qualifier-or-attribute-specifier-conc2-rep
                            abnf::cst)))))

Theorem: treep-of-cst-type-qualifier-or-attribute-specifier-conc2-rep-elem

(defthm
  treep-of-cst-type-qualifier-or-attribute-specifier-conc2-rep-elem
  (b* ((abnf::cst1 (cst-type-qualifier-or-attribute-specifier-conc2-rep-elem
                        abnf::cst)))
    (abnf::treep abnf::cst1))
  :rule-classes :rewrite)

Theorem: cst-type-qualifier-or-attribute-specifier-conc2-rep-elem-match

(defthm
     cst-type-qualifier-or-attribute-specifier-conc2-rep-elem-match
 (implies
  (and
    (cst-matchp abnf::cst
                "type-qualifier-or-attribute-specifier")
    (equal
         (cst-type-qualifier-or-attribute-specifier-conc? abnf::cst)
         2))
  (b* ((abnf::cst1 (cst-type-qualifier-or-attribute-specifier-conc2-rep-elem
                        abnf::cst)))
    (cst-matchp abnf::cst1 "attribute-specifier")))
 :rule-classes :rewrite)

Theorem: cst-type-qualifier-or-attribute-specifier-conc2-rep-elem-of-tree-fix-cst

(defthm
 cst-type-qualifier-or-attribute-specifier-conc2-rep-elem-of-tree-fix-cst
 (equal (cst-type-qualifier-or-attribute-specifier-conc2-rep-elem
             (abnf::tree-fix abnf::cst))
        (cst-type-qualifier-or-attribute-specifier-conc2-rep-elem
             abnf::cst)))

Theorem: cst-type-qualifier-or-attribute-specifier-conc2-rep-elem-tree-equiv-congruence-on-cst

(defthm
 cst-type-qualifier-or-attribute-specifier-conc2-rep-elem-tree-equiv-congruence-on-cst
 (implies (abnf::tree-equiv abnf::cst cst-equiv)
          (equal (cst-type-qualifier-or-attribute-specifier-conc2-rep-elem
                      abnf::cst)
                 (cst-type-qualifier-or-attribute-specifier-conc2-rep-elem
                      cst-equiv)))
 :rule-classes :congruence)

Function: cst-typedef-name-conc-rep-elem

(defun cst-typedef-name-conc-rep-elem (abnf::cst)
  (declare (xargs :guard (abnf::treep abnf::cst)))
  (declare (xargs :guard (cst-matchp abnf::cst "typedef-name")))
  (let ((__function__ 'cst-typedef-name-conc-rep-elem))
    (declare (ignorable __function__))
    (abnf::tree-fix (nth 0
                         (cst-typedef-name-conc-rep abnf::cst)))))

Theorem: treep-of-cst-typedef-name-conc-rep-elem

(defthm treep-of-cst-typedef-name-conc-rep-elem
  (b* ((abnf::cst1 (cst-typedef-name-conc-rep-elem abnf::cst)))
    (abnf::treep abnf::cst1))
  :rule-classes :rewrite)

Theorem: cst-typedef-name-conc-rep-elem-match

(defthm cst-typedef-name-conc-rep-elem-match
  (implies
       (cst-matchp abnf::cst "typedef-name")
       (b* ((abnf::cst1 (cst-typedef-name-conc-rep-elem abnf::cst)))
         (cst-matchp abnf::cst1 "identifier")))
  :rule-classes :rewrite)

Theorem: cst-typedef-name-conc-rep-elem-of-tree-fix-cst

(defthm cst-typedef-name-conc-rep-elem-of-tree-fix-cst
  (equal (cst-typedef-name-conc-rep-elem (abnf::tree-fix abnf::cst))
         (cst-typedef-name-conc-rep-elem abnf::cst)))

Theorem: cst-typedef-name-conc-rep-elem-tree-equiv-congruence-on-cst

(defthm cst-typedef-name-conc-rep-elem-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-typedef-name-conc-rep-elem abnf::cst)
                  (cst-typedef-name-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 "labeled-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 "compound-statement")))
  :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 "expression-statement")))
  :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 "selection-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 "iteration-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 "jump-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 "asm-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-block-item-conc1-rep-elem

(defun cst-block-item-conc1-rep-elem (abnf::cst)
 (declare (xargs :guard (abnf::treep abnf::cst)))
 (declare (xargs :guard (and (cst-matchp abnf::cst "block-item")
                             (equal (cst-block-item-conc? abnf::cst)
                                    1))))
 (let ((__function__ 'cst-block-item-conc1-rep-elem))
   (declare (ignorable __function__))
   (abnf::tree-fix (nth 0
                        (cst-block-item-conc1-rep abnf::cst)))))

Theorem: treep-of-cst-block-item-conc1-rep-elem

(defthm treep-of-cst-block-item-conc1-rep-elem
  (b* ((abnf::cst1 (cst-block-item-conc1-rep-elem abnf::cst)))
    (abnf::treep abnf::cst1))
  :rule-classes :rewrite)

Theorem: cst-block-item-conc1-rep-elem-match

(defthm cst-block-item-conc1-rep-elem-match
  (implies
       (and (cst-matchp abnf::cst "block-item")
            (equal (cst-block-item-conc? abnf::cst)
                   1))
       (b* ((abnf::cst1 (cst-block-item-conc1-rep-elem abnf::cst)))
         (cst-matchp abnf::cst1 "declaration")))
  :rule-classes :rewrite)

Theorem: cst-block-item-conc1-rep-elem-of-tree-fix-cst

(defthm cst-block-item-conc1-rep-elem-of-tree-fix-cst
  (equal (cst-block-item-conc1-rep-elem (abnf::tree-fix abnf::cst))
         (cst-block-item-conc1-rep-elem abnf::cst)))

Theorem: cst-block-item-conc1-rep-elem-tree-equiv-congruence-on-cst

(defthm cst-block-item-conc1-rep-elem-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-block-item-conc1-rep-elem abnf::cst)
                  (cst-block-item-conc1-rep-elem cst-equiv)))
  :rule-classes :congruence)

Function: cst-block-item-conc2-rep-elem

(defun cst-block-item-conc2-rep-elem (abnf::cst)
 (declare (xargs :guard (abnf::treep abnf::cst)))
 (declare (xargs :guard (and (cst-matchp abnf::cst "block-item")
                             (equal (cst-block-item-conc? abnf::cst)
                                    2))))
 (let ((__function__ 'cst-block-item-conc2-rep-elem))
   (declare (ignorable __function__))
   (abnf::tree-fix (nth 0
                        (cst-block-item-conc2-rep abnf::cst)))))

Theorem: treep-of-cst-block-item-conc2-rep-elem

(defthm treep-of-cst-block-item-conc2-rep-elem
  (b* ((abnf::cst1 (cst-block-item-conc2-rep-elem abnf::cst)))
    (abnf::treep abnf::cst1))
  :rule-classes :rewrite)

Theorem: cst-block-item-conc2-rep-elem-match

(defthm cst-block-item-conc2-rep-elem-match
  (implies
       (and (cst-matchp abnf::cst "block-item")
            (equal (cst-block-item-conc? abnf::cst)
                   2))
       (b* ((abnf::cst1 (cst-block-item-conc2-rep-elem abnf::cst)))
         (cst-matchp abnf::cst1 "statement")))
  :rule-classes :rewrite)

Theorem: cst-block-item-conc2-rep-elem-of-tree-fix-cst

(defthm cst-block-item-conc2-rep-elem-of-tree-fix-cst
  (equal (cst-block-item-conc2-rep-elem (abnf::tree-fix abnf::cst))
         (cst-block-item-conc2-rep-elem abnf::cst)))

Theorem: cst-block-item-conc2-rep-elem-tree-equiv-congruence-on-cst

(defthm cst-block-item-conc2-rep-elem-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-block-item-conc2-rep-elem abnf::cst)
                  (cst-block-item-conc2-rep-elem cst-equiv)))
  :rule-classes :congruence)

Function: cst-preprocessing-file-conc-rep-elem

(defun cst-preprocessing-file-conc-rep-elem (abnf::cst)
  (declare (xargs :guard (abnf::treep abnf::cst)))
  (declare
       (xargs :guard (cst-matchp abnf::cst "preprocessing-file")))
  (let ((__function__ 'cst-preprocessing-file-conc-rep-elem))
    (declare (ignorable __function__))
    (abnf::tree-fix
         (nth 0
              (cst-preprocessing-file-conc-rep abnf::cst)))))

Theorem: treep-of-cst-preprocessing-file-conc-rep-elem

(defthm treep-of-cst-preprocessing-file-conc-rep-elem
 (b* ((abnf::cst1 (cst-preprocessing-file-conc-rep-elem abnf::cst)))
   (abnf::treep abnf::cst1))
 :rule-classes :rewrite)

Theorem: cst-preprocessing-file-conc-rep-elem-match

(defthm cst-preprocessing-file-conc-rep-elem-match
 (implies
   (cst-matchp abnf::cst "preprocessing-file")
   (b*
     ((abnf::cst1 (cst-preprocessing-file-conc-rep-elem abnf::cst)))
     (cst-matchp abnf::cst1 "[ group ]")))
 :rule-classes :rewrite)

Theorem: cst-preprocessing-file-conc-rep-elem-of-tree-fix-cst

(defthm cst-preprocessing-file-conc-rep-elem-of-tree-fix-cst
 (equal
   (cst-preprocessing-file-conc-rep-elem (abnf::tree-fix abnf::cst))
   (cst-preprocessing-file-conc-rep-elem abnf::cst)))

Theorem: cst-preprocessing-file-conc-rep-elem-tree-equiv-congruence-on-cst

(defthm
  cst-preprocessing-file-conc-rep-elem-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-preprocessing-file-conc-rep-elem abnf::cst)
                  (cst-preprocessing-file-conc-rep-elem cst-equiv)))
  :rule-classes :congruence)

Function: cst-lparen-conc-rep-elem

(defun cst-lparen-conc-rep-elem (abnf::cst)
  (declare (xargs :guard (abnf::treep abnf::cst)))
  (declare (xargs :guard (cst-matchp abnf::cst "lparen")))
  (let ((__function__ 'cst-lparen-conc-rep-elem))
    (declare (ignorable __function__))
    (abnf::tree-fix (nth 0 (cst-lparen-conc-rep abnf::cst)))))

Theorem: treep-of-cst-lparen-conc-rep-elem

(defthm treep-of-cst-lparen-conc-rep-elem
  (b* ((abnf::cst1 (cst-lparen-conc-rep-elem abnf::cst)))
    (abnf::treep abnf::cst1))
  :rule-classes :rewrite)

Theorem: cst-lparen-conc-rep-elem-match

(defthm cst-lparen-conc-rep-elem-match
  (implies (cst-matchp abnf::cst "lparen")
           (b* ((abnf::cst1 (cst-lparen-conc-rep-elem abnf::cst)))
             (cst-matchp abnf::cst1 "\"(\"")))
  :rule-classes :rewrite)

Theorem: cst-lparen-conc-rep-elem-of-tree-fix-cst

(defthm cst-lparen-conc-rep-elem-of-tree-fix-cst
  (equal (cst-lparen-conc-rep-elem (abnf::tree-fix abnf::cst))
         (cst-lparen-conc-rep-elem abnf::cst)))

Theorem: cst-lparen-conc-rep-elem-tree-equiv-congruence-on-cst

(defthm cst-lparen-conc-rep-elem-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-lparen-conc-rep-elem abnf::cst)
                  (cst-lparen-conc-rep-elem cst-equiv)))
  :rule-classes :congruence)

Function: cst-replacement-list-conc-rep-elem

(defun cst-replacement-list-conc-rep-elem (abnf::cst)
 (declare (xargs :guard (abnf::treep abnf::cst)))
 (declare (xargs :guard (cst-matchp abnf::cst "replacement-list")))
 (let ((__function__ 'cst-replacement-list-conc-rep-elem))
  (declare (ignorable __function__))
  (abnf::tree-fix (nth 0
                       (cst-replacement-list-conc-rep abnf::cst)))))

Theorem: treep-of-cst-replacement-list-conc-rep-elem

(defthm treep-of-cst-replacement-list-conc-rep-elem
  (b* ((abnf::cst1 (cst-replacement-list-conc-rep-elem abnf::cst)))
    (abnf::treep abnf::cst1))
  :rule-classes :rewrite)

Theorem: cst-replacement-list-conc-rep-elem-match

(defthm cst-replacement-list-conc-rep-elem-match
 (implies
   (cst-matchp abnf::cst "replacement-list")
   (b* ((abnf::cst1 (cst-replacement-list-conc-rep-elem abnf::cst)))
     (cst-matchp abnf::cst1 "[ pp-tokens ]")))
 :rule-classes :rewrite)

Theorem: cst-replacement-list-conc-rep-elem-of-tree-fix-cst

(defthm cst-replacement-list-conc-rep-elem-of-tree-fix-cst
 (equal
     (cst-replacement-list-conc-rep-elem (abnf::tree-fix abnf::cst))
     (cst-replacement-list-conc-rep-elem abnf::cst)))

Theorem: cst-replacement-list-conc-rep-elem-tree-equiv-congruence-on-cst

(defthm
    cst-replacement-list-conc-rep-elem-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-replacement-list-conc-rep-elem abnf::cst)
                  (cst-replacement-list-conc-rep-elem cst-equiv)))
  :rule-classes :congruence)

*grammar*-tree-operations

Definitions and Theorems

grammar-tree-operations