		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-%x0-9-nat

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

Theorem: natp-of-cst-%x0-9-nat

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

Theorem: cst-%x0-9-nat-of-tree-fix-cst

(defthm cst-%x0-9-nat-of-tree-fix-cst
  (equal (cst-%x0-9-nat (abnf::tree-fix abnf::cst))
         (cst-%x0-9-nat abnf::cst)))

Theorem: cst-%x0-9-nat-tree-equiv-congruence-on-cst

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

Function: cst-%x0-7f-nat

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

Theorem: natp-of-cst-%x0-7f-nat

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

Theorem: cst-%x0-7f-nat-of-tree-fix-cst

(defthm cst-%x0-7f-nat-of-tree-fix-cst
  (equal (cst-%x0-7f-nat (abnf::tree-fix abnf::cst))
         (cst-%x0-7f-nat abnf::cst)))

Theorem: cst-%x0-7f-nat-tree-equiv-congruence-on-cst

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

Function: cst-%xb-21-nat

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

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

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

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

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

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

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

Function: cst-%xb-29-nat

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

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

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

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

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

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

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

Function: cst-%xb-7f-nat

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

Theorem: natp-of-cst-%xb-7f-nat

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

Theorem: cst-%xb-7f-nat-of-tree-fix-cst

(defthm cst-%xb-7f-nat-of-tree-fix-cst
  (equal (cst-%xb-7f-nat (abnf::tree-fix abnf::cst))
         (cst-%xb-7f-nat abnf::cst)))

Theorem: cst-%xb-7f-nat-tree-equiv-congruence-on-cst

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

Function: cst-%x23-7f-nat

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

Theorem: natp-of-cst-%x23-7f-nat

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

Theorem: cst-%x23-7f-nat-of-tree-fix-cst

(defthm cst-%x23-7f-nat-of-tree-fix-cst
  (equal (cst-%x23-7f-nat (abnf::tree-fix abnf::cst))
         (cst-%x23-7f-nat abnf::cst)))

Theorem: cst-%x23-7f-nat-tree-equiv-congruence-on-cst

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

Function: cst-%x2b-2e-nat

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

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

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

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

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

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

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

Function: cst-%x2b-7e-nat

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

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

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

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

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

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

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

Function: cst-%x30-31-nat

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

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

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

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

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

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

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

Function: cst-%x30-37-nat

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

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

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

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

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

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

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

Function: cst-%x30-39-nat

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

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

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

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

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

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

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

Function: cst-%x30-7e-nat

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

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

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

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

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

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

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

Function: cst-%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-%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-%x61-7a-nat

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

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

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

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

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

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

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

Function: cst-%x80-2029-nat

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

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

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

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

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

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

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

Function: cst-%x202f-2065-nat

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

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

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

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

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

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

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

Function: cst-%x206a-d7ff-nat

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

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

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

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

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

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

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

Function: cst-%xe000-10ffff-nat

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

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

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

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

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

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

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

Theorem: cst-%x0-9-nat-bounds

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

Theorem: cst-%x0-7f-nat-bounds

(defthm cst-%x0-7f-nat-bounds
  (implies (cst-matchp abnf::cst "%x0-7F")
           (and (<= 0 (cst-%x0-7f-nat abnf::cst))
                (<= (cst-%x0-7f-nat abnf::cst) 127)))
  :rule-classes :linear)

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

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

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

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

Theorem: cst-%xb-7f-nat-bounds

(defthm cst-%xb-7f-nat-bounds
  (implies (cst-matchp abnf::cst "%xB-7F")
           (and (<= 11 (cst-%xb-7f-nat abnf::cst))
                (<= (cst-%xb-7f-nat abnf::cst) 127)))
  :rule-classes :linear)

Theorem: cst-%x23-7f-nat-bounds

(defthm cst-%x23-7f-nat-bounds
  (implies (cst-matchp abnf::cst "%x23-7F")
           (and (<= 35 (cst-%x23-7f-nat abnf::cst))
                (<= (cst-%x23-7f-nat abnf::cst) 127)))
  :rule-classes :linear)

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

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

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

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

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

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

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

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

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

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

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

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

Theorem: cst-%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-%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-%x61-7a-nat-bounds

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

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

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

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

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

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

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

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

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

Theorem: cst-"!"-leafterm

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

Theorem: cst-"!="-leafterm

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

Theorem: cst-"%"-leafterm

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

Theorem: cst-"%="-leafterm

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

Theorem: cst-"&"-leafterm

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

Theorem: cst-"&&"-leafterm

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

Theorem: cst-"&&="-leafterm

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

Theorem: cst-"&="-leafterm

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

Theorem: cst-"("-leafterm

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

Theorem: cst-")"-leafterm

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

Theorem: cst-"*"-leafterm

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

Theorem: cst-"**"-leafterm

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

Theorem: cst-"**="-leafterm

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

Theorem: cst-"*="-leafterm

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

Theorem: cst-"+"-leafterm

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

Theorem: cst-"+="-leafterm

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

Theorem: cst-","-leafterm

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

Theorem: cst-"-"-leafterm

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

Theorem: cst-"-="-leafterm

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

Theorem: cst-"->"-leafterm

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

Theorem: cst-"."-leafterm

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

Theorem: cst-".."-leafterm

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

Theorem: cst-"/"-leafterm

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

Theorem: cst-"/*"-leafterm

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

Theorem: cst-"//"-leafterm

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

Theorem: cst-"/="-leafterm

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

Theorem: cst-"0"-leafterm

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

Theorem: cst-":"-leafterm

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

Theorem: cst-"::"-leafterm

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

Theorem: cst-";"-leafterm

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

Theorem: cst-"<"-leafterm

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

Theorem: cst-"<<"-leafterm

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

Theorem: cst-"<<="-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-%s"0b"-leafterm

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

Theorem: cst-%s"0o"-leafterm

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

Theorem: cst-%s"0x"-leafterm

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

Theorem: cst-%s"fn"-leafterm

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

Theorem: cst-%s"future"-leafterm

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

Theorem: cst-%s"address"-leafterm

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

Theorem: cst-%s"aleo"-leafterm

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

Theorem: cst-%s"aleo1"-leafterm

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

Theorem: cst-%s"as"-leafterm

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

Theorem: cst-%s"assert"-leafterm

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

Theorem: cst-%s"assert_eq"-leafterm

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

Theorem: cst-%s"assert_neq"-leafterm

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

Theorem: cst-%s"async"-leafterm

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

Theorem: cst-%s"block"-leafterm

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

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

Theorem: cst-%s"const"-leafterm

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

Theorem: cst-%s"constant"-leafterm

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

Theorem: cst-%s"else"-leafterm

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

Theorem: cst-%s"false"-leafterm

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

Theorem: cst-%s"field"-leafterm

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

Theorem: cst-%s"for"-leafterm

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

Theorem: cst-%s"function"-leafterm

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

Theorem: cst-%s"group"-leafterm

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

Theorem: cst-%s"height"-leafterm

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

Theorem: cst-%s"i128"-leafterm

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

Theorem: cst-%s"i16"-leafterm

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

Theorem: cst-%s"i32"-leafterm

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

Theorem: cst-%s"i64"-leafterm

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

Theorem: cst-%s"i8"-leafterm

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

Theorem: cst-%s"id"-leafterm

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

Theorem: cst-%s"if"-leafterm

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

Theorem: cst-%s"import"-leafterm

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

Theorem: cst-%s"in"-leafterm

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

Theorem: cst-%s"inline"-leafterm

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

Theorem: cst-%s"let"-leafterm

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

Theorem: cst-%s"mapping"-leafterm

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

Theorem: cst-%s"network"-leafterm

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

Theorem: cst-%s"private"-leafterm

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

Theorem: cst-%s"program"-leafterm

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

Theorem: cst-%s"public"-leafterm

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

Theorem: cst-%s"record"-leafterm

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

Theorem: cst-%s"return"-leafterm

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

Theorem: cst-%s"scalar"-leafterm

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

Theorem: cst-%s"self"-leafterm

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

Theorem: cst-%s"signature"-leafterm

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

Theorem: cst-%s"signer"-leafterm

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

Theorem: cst-%s"string"-leafterm

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

Theorem: cst-%s"struct"-leafterm

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

Theorem: cst-%s"transition"-leafterm

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

Theorem: cst-%s"true"-leafterm

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

Theorem: cst-%s"u128"-leafterm

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

Theorem: cst-%s"u16"-leafterm

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

Theorem: cst-%s"u32"-leafterm

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

Theorem: cst-%s"u64"-leafterm

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

Theorem: cst-%s"u8"-leafterm

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

Theorem: cst-ascii-nonleaf

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

Theorem: cst-safe-nonascii-nonleaf

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

Theorem: cst-character-nonleaf

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

Theorem: cst-line-terminator-nonleaf

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

Theorem: cst-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-whitespace-nonleaf

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

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

Theorem: cst-comment-nonleaf

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

Theorem: cst-block-comment-nonleaf

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

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

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

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

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

Theorem: cst-not-star-or-line-feed-nonleaf

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

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

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

Theorem: cst-line-comment-nonleaf

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

Theorem: cst-not-line-feed-nonleaf

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

Theorem: cst-keyword-nonleaf

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

Theorem: cst-uppercase-letter-nonleaf

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

Theorem: cst-lowercase-letter-nonleaf

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

Theorem: cst-letter-nonleaf

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

Theorem: cst-binary-digit-nonleaf

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

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

Theorem: cst-nonzero-decimal-digit-nonleaf

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

Theorem: cst-hexadecimal-digit-nonleaf

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

Theorem: cst-identifier-nonleaf

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

Theorem: cst-binary-numeral-nonleaf

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

Theorem: cst-octal-numeral-nonleaf

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

Theorem: cst-decimal-numeral-nonleaf

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

Theorem: cst-hexadecimal-numeral-nonleaf

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

Theorem: cst-numeral-nonleaf

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

Theorem: cst-tuple-index-nonleaf

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

Theorem: cst-unsigned-literal-nonleaf

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

Theorem: cst-signed-literal-nonleaf

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

Theorem: cst-integer-literal-nonleaf

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

Theorem: cst-field-literal-nonleaf

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

Theorem: cst-group-literal-nonleaf

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

Theorem: cst-scalar-literal-nonleaf

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

Theorem: cst-numeric-literal-nonleaf

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

Theorem: cst-boolean-literal-nonleaf

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

Theorem: cst-explicit-address-literal-nonleaf

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

Theorem: cst-string-literal-nonleaf

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

Theorem: cst-double-quote-nonleaf

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

Theorem: cst-string-character-nonleaf

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

Theorem: cst-not-double-quote-or-line-feed-nonleaf

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

Theorem: cst-atomic-literal-nonleaf

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

Theorem: cst-annotation-nonleaf

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

Theorem: cst-symbol-nonleaf

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

Theorem: cst-token-nonleaf

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

Theorem: cst-lexeme-nonleaf

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

Theorem: cst-program-id-nonleaf

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

Theorem: cst-network-nonleaf

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

Theorem: cst-locator-nonleaf

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

Theorem: cst-unsigned-type-nonleaf

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

Theorem: cst-signed-type-nonleaf

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

Theorem: cst-integer-type-nonleaf

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

Theorem: cst-field-type-nonleaf

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

Theorem: cst-group-type-nonleaf

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

Theorem: cst-scalar-type-nonleaf

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

Theorem: cst-arithmetic-type-nonleaf

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

Theorem: cst-boolean-type-nonleaf

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

Theorem: cst-address-type-nonleaf

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

Theorem: cst-signature-type-nonleaf

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

Theorem: cst-string-type-nonleaf

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

Theorem: cst-named-primitive-type-nonleaf

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

Theorem: cst-unit-type-nonleaf

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

Theorem: cst-primitive-type-nonleaf

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

Theorem: cst-untyped-future-type-nonleaf

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

Theorem: cst-typed-future-type-nonleaf

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

Theorem: cst-future-type-nonleaf

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

Theorem: cst-tuple-type-nonleaf

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

Theorem: cst-array-type-nonleaf

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

Theorem: cst-type-nonleaf

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

Theorem: cst-named-type-nonleaf

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

Theorem: cst-program-address-literal-nonleaf

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

Theorem: cst-literal-nonleaf

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

Theorem: cst-address-literal-nonleaf

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

Theorem: cst-primary-expression-nonleaf

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

Theorem: cst-variable-nonleaf

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

Theorem: cst-associated-constant-nonleaf

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

Theorem: cst-free-function-call-nonleaf

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

Theorem: cst-associated-function-call-nonleaf

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

Theorem: cst-function-arguments-nonleaf

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

Theorem: cst-unit-expression-nonleaf

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

Theorem: cst-tuple-expression-nonleaf

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

Theorem: cst-array-expression-nonleaf

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

Theorem: cst-struct-expression-nonleaf

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

Theorem: cst-struct-component-initializer-nonleaf

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

Theorem: cst-self-expression-nonleaf

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

Theorem: cst-block-expression-nonleaf

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

Theorem: cst-network-expression-nonleaf

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

Theorem: cst-postfix-expression-nonleaf

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

Theorem: cst-tuple-component-expression-nonleaf

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

Theorem: cst-array-component-expression-nonleaf

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

Theorem: cst-struct-component-expression-nonleaf

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

Theorem: cst-method-call-nonleaf

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

Theorem: cst-unary-expression-nonleaf

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

Theorem: cst-cast-expression-nonleaf

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

Theorem: cst-exponential-expression-nonleaf

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

Theorem: cst-multiplicative-expression-nonleaf

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

Theorem: cst-additive-expression-nonleaf

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

Theorem: cst-shift-expression-nonleaf

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

Theorem: cst-conjunctive-expression-nonleaf

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

Theorem: cst-inclusive-disjunctive-expression-nonleaf

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

Theorem: cst-exclusive-disjunctive-expression-nonleaf

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

Theorem: cst-ordering-expression-nonleaf

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

Theorem: cst-equality-expression-nonleaf

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

Theorem: cst-conditional-conjunctive-expression-nonleaf

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

Theorem: cst-conditional-disjunctive-expression-nonleaf

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

Theorem: cst-binary-expression-nonleaf

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

Theorem: cst-conditional-ternary-expression-nonleaf

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

Theorem: cst-expression-nonleaf

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

Theorem: cst-statement-nonleaf

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

Theorem: cst-expression-statement-nonleaf

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

Theorem: cst-block-nonleaf

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

Theorem: cst-return-statement-nonleaf

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

Theorem: cst-variable-declaration-nonleaf

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

Theorem: cst-constant-declaration-nonleaf

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

Theorem: cst-identifier-or-identifiers-nonleaf

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

Theorem: cst-branch-nonleaf

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

Theorem: cst-conditional-statement-nonleaf

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

Theorem: cst-loop-statement-nonleaf

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

Theorem: cst-assignment-operator-nonleaf

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

Theorem: cst-assignment-statement-nonleaf

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

Theorem: cst-assert-statement-nonleaf

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

Theorem: cst-function-declaration-nonleaf

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

Theorem: cst-function-kind-nonleaf

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

Theorem: cst-function-inputs-nonleaf

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

Theorem: cst-function-input-nonleaf

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

Theorem: cst-function-outputs-nonleaf

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

Theorem: cst-function-output-nonleaf

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

Theorem: cst-struct-declaration-nonleaf

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

Theorem: cst-struct-component-declarations-nonleaf

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

Theorem: cst-struct-component-declaration-nonleaf

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

Theorem: cst-record-declaration-nonleaf

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

Theorem: cst-mapping-declaration-nonleaf

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

Theorem: cst-program-item-nonleaf

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

Theorem: cst-program-declaration-nonleaf

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

Theorem: cst-import-declaration-nonleaf

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

Theorem: cst-file-nonleaf

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

Theorem: cst-ascii-rulename

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

Theorem: cst-safe-nonascii-rulename

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

Theorem: cst-character-rulename

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

Theorem: cst-line-terminator-rulename

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

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

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

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

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

Theorem: cst-block-comment-rulename

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

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

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

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

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

Theorem: cst-not-star-or-line-feed-rulename

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

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

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

Theorem: cst-line-comment-rulename

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

Theorem: cst-not-line-feed-rulename

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

Theorem: cst-keyword-rulename

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

Theorem: cst-uppercase-letter-rulename

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

Theorem: cst-lowercase-letter-rulename

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

Theorem: cst-letter-rulename

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

Theorem: cst-binary-digit-rulename

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

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

Theorem: cst-nonzero-decimal-digit-rulename

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

Theorem: cst-hexadecimal-digit-rulename

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

Theorem: cst-identifier-rulename

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

Theorem: cst-binary-numeral-rulename

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

Theorem: cst-octal-numeral-rulename

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

Theorem: cst-decimal-numeral-rulename

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

Theorem: cst-hexadecimal-numeral-rulename

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

Theorem: cst-numeral-rulename

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

Theorem: cst-tuple-index-rulename

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

Theorem: cst-unsigned-literal-rulename

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

Theorem: cst-signed-literal-rulename

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

Theorem: cst-integer-literal-rulename

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

Theorem: cst-field-literal-rulename

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

Theorem: cst-group-literal-rulename

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

Theorem: cst-scalar-literal-rulename

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

Theorem: cst-numeric-literal-rulename

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

Theorem: cst-boolean-literal-rulename

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

Theorem: cst-explicit-address-literal-rulename

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

Theorem: cst-string-literal-rulename

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

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

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

Theorem: cst-not-double-quote-or-line-feed-rulename

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

Theorem: cst-atomic-literal-rulename

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

Theorem: cst-annotation-rulename

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

Theorem: cst-symbol-rulename

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

Theorem: cst-token-rulename

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

Theorem: cst-lexeme-rulename

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

Theorem: cst-program-id-rulename

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

Theorem: cst-network-rulename

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

Theorem: cst-locator-rulename

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

Theorem: cst-unsigned-type-rulename

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

Theorem: cst-signed-type-rulename

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

Theorem: cst-integer-type-rulename

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

Theorem: cst-field-type-rulename

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

Theorem: cst-group-type-rulename

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

Theorem: cst-scalar-type-rulename

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

Theorem: cst-arithmetic-type-rulename

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

Theorem: cst-boolean-type-rulename

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

Theorem: cst-address-type-rulename

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

Theorem: cst-signature-type-rulename

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

Theorem: cst-string-type-rulename

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

Theorem: cst-named-primitive-type-rulename

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

Theorem: cst-unit-type-rulename

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

Theorem: cst-primitive-type-rulename

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

Theorem: cst-untyped-future-type-rulename

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

Theorem: cst-typed-future-type-rulename

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

Theorem: cst-future-type-rulename

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

Theorem: cst-tuple-type-rulename

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

Theorem: cst-array-type-rulename

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

Theorem: cst-type-rulename

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

Theorem: cst-named-type-rulename

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

Theorem: cst-program-address-literal-rulename

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

Theorem: cst-literal-rulename

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

Theorem: cst-address-literal-rulename

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

Theorem: cst-primary-expression-rulename

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

Theorem: cst-variable-rulename

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

Theorem: cst-associated-constant-rulename

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

Theorem: cst-free-function-call-rulename

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

Theorem: cst-associated-function-call-rulename

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

Theorem: cst-function-arguments-rulename

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

Theorem: cst-unit-expression-rulename

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

Theorem: cst-tuple-expression-rulename

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

Theorem: cst-array-expression-rulename

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

Theorem: cst-struct-expression-rulename

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

Theorem: cst-struct-component-initializer-rulename

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

Theorem: cst-self-expression-rulename

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

Theorem: cst-block-expression-rulename

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

Theorem: cst-network-expression-rulename

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

Theorem: cst-postfix-expression-rulename

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

Theorem: cst-tuple-component-expression-rulename

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

Theorem: cst-array-component-expression-rulename

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

Theorem: cst-struct-component-expression-rulename

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

Theorem: cst-method-call-rulename

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

Theorem: cst-unary-expression-rulename

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

Theorem: cst-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-exponential-expression-rulename

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

Theorem: cst-multiplicative-expression-rulename

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

Theorem: cst-additive-expression-rulename

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

Theorem: cst-shift-expression-rulename

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

Theorem: cst-conjunctive-expression-rulename

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

Theorem: cst-inclusive-disjunctive-expression-rulename

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

Theorem: cst-exclusive-disjunctive-expression-rulename

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

Theorem: cst-ordering-expression-rulename

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

Theorem: cst-equality-expression-rulename

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

Theorem: cst-conditional-conjunctive-expression-rulename

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

Theorem: cst-conditional-disjunctive-expression-rulename

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

Theorem: cst-binary-expression-rulename

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

Theorem: cst-conditional-ternary-expression-rulename

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

Theorem: cst-expression-rulename

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

Theorem: cst-statement-rulename

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

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

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

Theorem: cst-return-statement-rulename

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

Theorem: cst-variable-declaration-rulename

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

Theorem: cst-constant-declaration-rulename

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

Theorem: cst-identifier-or-identifiers-rulename

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

Theorem: cst-branch-rulename

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

Theorem: cst-conditional-statement-rulename

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

Theorem: cst-loop-statement-rulename

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

Theorem: cst-assignment-operator-rulename

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

Theorem: cst-assignment-statement-rulename

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

Theorem: cst-assert-statement-rulename

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

Theorem: cst-function-declaration-rulename

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

Theorem: cst-function-kind-rulename

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

Theorem: cst-function-inputs-rulename

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

Theorem: cst-function-input-rulename

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

Theorem: cst-function-outputs-rulename

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

Theorem: cst-function-output-rulename

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

Theorem: cst-struct-declaration-rulename

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

Theorem: cst-struct-component-declarations-rulename

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

Theorem: cst-struct-component-declaration-rulename

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

Theorem: cst-record-declaration-rulename

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

Theorem: cst-mapping-declaration-rulename

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

Theorem: cst-program-item-rulename

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

Theorem: cst-program-declaration-rulename

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

Theorem: cst-import-declaration-rulename

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

Theorem: cst-file-rulename

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

Theorem: cst-ascii-branches-match-alt

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

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

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

Theorem: cst-character-branches-match-alt

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

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

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

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-whitespace-branches-match-alt

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

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-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-comment-branches-match-alt

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

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

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

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

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

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

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

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

(defthm cst-not-star-or-line-feed-branches-match-alt
  (implies (cst-matchp abnf::cst "not-star-or-line-feed")
           (cst-list-list-alt-matchp
                (abnf::tree-nonleaf->branches abnf::cst)
                "%x0-9 / %xB-29 / %x2B-7E / safe-nonascii")))

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

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

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

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

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

(defthm cst-not-line-feed-branches-match-alt
 (implies
  (cst-matchp abnf::cst "not-line-feed")
  (cst-list-list-alt-matchp (abnf::tree-nonleaf->branches abnf::cst)
                            "%x0-9 / %xB-7F / safe-nonascii")))

Theorem: cst-keyword-branches-match-alt

(defthm cst-keyword-branches-match-alt
 (implies
  (cst-matchp abnf::cst "keyword")
  (cst-list-list-alt-matchp
   (abnf::tree-nonleaf->branches abnf::cst)
   "%s\"address\" / %s\"aleo\" / %s\"as\" / %s\"assert\" / %s\"assert_eq\" / %s\"assert_neq\" / %s\"async\" / %s\"block\" / %s\"bool\" / %s\"const\" / %s\"constant\" / %s\"else\" / %s\"field\" / %s\"Fn\" / %s\"for\" / %s\"function\" / %s\"Future\" / %s\"group\" / %s\"i8\" / %s\"i16\" / %s\"i32\" / %s\"i64\" / %s\"i128\" / %s\"if\" / %s\"import\" / %s\"in\" / %s\"inline\" / %s\"let\" / %s\"mapping\" / %s\"network\" / %s\"private\" / %s\"program\" / %s\"public\" / %s\"record\" / %s\"return\" / %s\"scalar\" / %s\"self\" / %s\"signature\" / %s\"string\" / %s\"struct\" / %s\"transition\" / %s\"u8\" / %s\"u16\" / %s\"u32\" / %s\"u64\" / %s\"u128\"")))

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

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

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

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

Theorem: cst-letter-branches-match-alt

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

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

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

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

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

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

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

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

(defthm cst-hexadecimal-digit-branches-match-alt
 (implies
  (cst-matchp abnf::cst "hexadecimal-digit")
  (cst-list-list-alt-matchp (abnf::tree-nonleaf->branches abnf::cst)
                            "decimal-digit / %x41-46")))

Theorem: cst-identifier-branches-match-alt

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

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

(defthm cst-binary-numeral-branches-match-alt
 (implies
  (cst-matchp abnf::cst "binary-numeral")
  (cst-list-list-alt-matchp (abnf::tree-nonleaf->branches abnf::cst)
                            "%s\"0b\" 1*( binary-digit *\"_\" )")))

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

(defthm cst-octal-numeral-branches-match-alt
 (implies
  (cst-matchp abnf::cst "octal-numeral")
  (cst-list-list-alt-matchp (abnf::tree-nonleaf->branches abnf::cst)
                            "%s\"0o\" 1*( octal-digit *\"_\" )")))

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

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

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

(defthm cst-hexadecimal-numeral-branches-match-alt
 (implies
  (cst-matchp abnf::cst "hexadecimal-numeral")
  (cst-list-list-alt-matchp (abnf::tree-nonleaf->branches abnf::cst)
                            "%s\"0x\" 1*( hexadecimal-digit *\"_\" )")))

Theorem: cst-numeral-branches-match-alt

(defthm cst-numeral-branches-match-alt
 (implies
  (cst-matchp abnf::cst "numeral")
  (cst-list-list-alt-matchp
   (abnf::tree-nonleaf->branches abnf::cst)
   "binary-numeral / octal-numeral / decimal-numeral / hexadecimal-numeral")))

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

(defthm cst-tuple-index-branches-match-alt
  (implies (cst-matchp abnf::cst "tuple-index")
           (cst-list-list-alt-matchp
                (abnf::tree-nonleaf->branches abnf::cst)
                "\"0\" / nonzero-decimal-digit *( decimal-digit )")))

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

(defthm cst-explicit-address-literal-branches-match-alt
 (implies (cst-matchp abnf::cst "explicit-address-literal")
          (cst-list-list-alt-matchp
               (abnf::tree-nonleaf->branches abnf::cst)
               "%s\"aleo1\" 58( lowercase-letter / decimal-digit )")))

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

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

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

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

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

(defthm cst-not-double-quote-or-line-feed-branches-match-alt
  (implies (cst-matchp abnf::cst
                       "not-double-quote-or-line-feed")
           (cst-list-list-alt-matchp
                (abnf::tree-nonleaf->branches abnf::cst)
                "%x0-9 / %xB-21 / %x23-7F / safe-nonascii")))

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

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

Theorem: cst-annotation-branches-match-alt

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

Theorem: cst-symbol-branches-match-alt

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

Theorem: cst-token-branches-match-alt

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

Theorem: cst-lexeme-branches-match-alt

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

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

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

Theorem: cst-network-branches-match-alt

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

Theorem: cst-locator-branches-match-alt

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

Theorem: cst-untyped-future-type-branches-match-alt

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

Theorem: cst-typed-future-type-branches-match-alt

(defthm cst-typed-future-type-branches-match-alt
 (implies
  (cst-matchp abnf::cst "typed-future-type")
  (cst-list-list-alt-matchp
   (abnf::tree-nonleaf->branches abnf::cst)
   "%s\"Future\" \"<\" %s\"Fn\" \"(\" [ type 1*( \",\" type ) [ \",\" ] ] \")\" \">\"")))

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

(defthm cst-future-type-branches-match-alt
  (implies (cst-matchp abnf::cst "future-type")
           (cst-list-list-alt-matchp
                (abnf::tree-nonleaf->branches abnf::cst)
                "untyped-future-type / typed-future-type")))

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

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

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

(defthm cst-array-type-branches-match-alt
 (implies
  (cst-matchp abnf::cst "array-type")
  (cst-list-list-alt-matchp (abnf::tree-nonleaf->branches abnf::cst)
                            "\"[\" type \";\" decimal-numeral \"]\"")))

Theorem: cst-type-branches-match-alt

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

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

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

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

(defthm cst-program-address-literal-branches-match-alt
 (implies
  (cst-matchp abnf::cst "program-address-literal")
  (cst-list-list-alt-matchp (abnf::tree-nonleaf->branches abnf::cst)
                            "program-id")))

Theorem: cst-literal-branches-match-alt

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

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

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

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

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

Theorem: cst-variable-branches-match-alt

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

(defthm cst-self-expression-branches-match-alt
 (implies
  (cst-matchp abnf::cst "self-expression")
  (cst-list-list-alt-matchp
   (abnf::tree-nonleaf->branches abnf::cst)
   "%s\"self\" \".\" %s\"address\" / %s\"self\" \".\" %s\"caller\" / %s\"self\" \".\" %s\"signer\"")))

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

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

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

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

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

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

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

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

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

(defthm cst-array-component-expression-branches-match-alt
  (implies (cst-matchp abnf::cst "array-component-expression")
           (cst-list-list-alt-matchp
                (abnf::tree-nonleaf->branches abnf::cst)
                "postfix-expression \"[\" expression \"]\"")))

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

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

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

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

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

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

Theorem: cst-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 / unary-expression %s\"as\" named-primitive-type")))

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

Theorem: cst-expression-branches-match-alt

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

Theorem: cst-statement-branches-match-alt

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

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-block-branches-match-alt

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

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

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

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

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

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

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

Theorem: cst-identifier-or-identifiers-branches-match-alt

(defthm cst-identifier-or-identifiers-branches-match-alt
 (implies
  (cst-matchp abnf::cst "identifier-or-identifiers")
  (cst-list-list-alt-matchp
   (abnf::tree-nonleaf->branches abnf::cst)
   "identifier / \"(\" identifier 1*( \",\" identifier ) [ \",\" ] \")\"")))

Theorem: cst-branch-branches-match-alt

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

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

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

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

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

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

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

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

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

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

(defthm cst-assert-statement-branches-match-alt
 (implies
  (cst-matchp abnf::cst "assert-statement")
  (cst-list-list-alt-matchp
   (abnf::tree-nonleaf->branches abnf::cst)
   "%s\"assert\" \"(\" expression \")\" \";\" / %s\"assert_eq\" \"(\" expression \",\" expression \")\" \";\" / %s\"assert_neq\" \"(\" expression \",\" expression \")\" \";\"")))

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

(defthm cst-function-declaration-branches-match-alt
 (implies
  (cst-matchp abnf::cst "function-declaration")
  (cst-list-list-alt-matchp
   (abnf::tree-nonleaf->branches abnf::cst)
   "*annotation [ %s\"async\" ] function-kind identifier \"(\" [ function-inputs ] \")\" [ \"->\" function-outputs ] ( block / \";\" )")))

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

(defthm cst-function-kind-branches-match-alt
  (implies (cst-matchp abnf::cst "function-kind")
           (cst-list-list-alt-matchp
                (abnf::tree-nonleaf->branches abnf::cst)
                "%s\"function\" / %s\"transition\" / %s\"inline\"")))

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

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

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

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

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

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

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

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

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

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

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

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

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

(defthm cst-struct-component-declaration-branches-match-alt
 (implies
  (cst-matchp abnf::cst
              "struct-component-declaration")
  (cst-list-list-alt-matchp
   (abnf::tree-nonleaf->branches abnf::cst)
   "[ %s\"public\" / %s\"private\" / %s\"constant\" ] identifier \":\" type")))

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

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

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

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

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

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

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

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

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

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

Theorem: cst-file-branches-match-alt

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

Theorem: cst-ascii-concs

(defthm cst-ascii-concs
  (implies (cst-list-list-alt-matchp abnf::cstss "%x0-7F")
           (or (cst-list-list-conc-matchp abnf::cstss "%x0-7F"))))

Theorem: cst-safe-nonascii-concs

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

Theorem: cst-character-concs

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

Theorem: cst-line-terminator-concs

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

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-whitespace-concs

(defthm cst-whitespace-concs
 (implies
  (cst-list-list-alt-matchp
   abnf::cstss
   "space / horizontal-tab / form-feed / line-terminator / carriage-return")
  (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 "form-feed")
      (cst-list-list-conc-matchp abnf::cstss "line-terminator")
      (cst-list-list-conc-matchp abnf::cstss "carriage-return"))))

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-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-comment-concs

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

Theorem: cst-block-comment-concs

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

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

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

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

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

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

(defthm cst-not-star-or-line-feed-concs
 (implies
      (cst-list-list-alt-matchp
           abnf::cstss
           "%x0-9 / %xB-29 / %x2B-7E / safe-nonascii")
      (or (cst-list-list-conc-matchp abnf::cstss "%x0-9")
          (cst-list-list-conc-matchp abnf::cstss "%xB-29")
          (cst-list-list-conc-matchp abnf::cstss "%x2B-7E")
          (cst-list-list-conc-matchp abnf::cstss "safe-nonascii"))))

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

(defthm cst-not-star-or-slash-or-line-feed-concs
 (implies
      (cst-list-list-alt-matchp
           abnf::cstss
           "%x0-9 / %xB-29 / %x2B-2E / %x30-7E / safe-nonascii")
      (or (cst-list-list-conc-matchp abnf::cstss "%x0-9")
          (cst-list-list-conc-matchp abnf::cstss "%xB-29")
          (cst-list-list-conc-matchp abnf::cstss "%x2B-2E")
          (cst-list-list-conc-matchp abnf::cstss "%x30-7E")
          (cst-list-list-conc-matchp abnf::cstss "safe-nonascii"))))

Theorem: cst-line-comment-concs

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

Theorem: cst-not-line-feed-concs

(defthm cst-not-line-feed-concs
 (implies
      (cst-list-list-alt-matchp abnf::cstss
                                "%x0-9 / %xB-7F / safe-nonascii")
      (or (cst-list-list-conc-matchp abnf::cstss "%x0-9")
          (cst-list-list-conc-matchp abnf::cstss "%xB-7F")
          (cst-list-list-conc-matchp abnf::cstss "safe-nonascii"))))

Theorem: cst-keyword-concs

(defthm cst-keyword-concs
 (implies
  (cst-list-list-alt-matchp
   abnf::cstss
   "%s\"address\" / %s\"aleo\" / %s\"as\" / %s\"assert\" / %s\"assert_eq\" / %s\"assert_neq\" / %s\"async\" / %s\"block\" / %s\"bool\" / %s\"const\" / %s\"constant\" / %s\"else\" / %s\"field\" / %s\"Fn\" / %s\"for\" / %s\"function\" / %s\"Future\" / %s\"group\" / %s\"i8\" / %s\"i16\" / %s\"i32\" / %s\"i64\" / %s\"i128\" / %s\"if\" / %s\"import\" / %s\"in\" / %s\"inline\" / %s\"let\" / %s\"mapping\" / %s\"network\" / %s\"private\" / %s\"program\" / %s\"public\" / %s\"record\" / %s\"return\" / %s\"scalar\" / %s\"self\" / %s\"signature\" / %s\"string\" / %s\"struct\" / %s\"transition\" / %s\"u8\" / %s\"u16\" / %s\"u32\" / %s\"u64\" / %s\"u128\"")
  (or (cst-list-list-conc-matchp abnf::cstss "%s\"address\"")
      (cst-list-list-conc-matchp abnf::cstss "%s\"aleo\"")
      (cst-list-list-conc-matchp abnf::cstss "%s\"as\"")
      (cst-list-list-conc-matchp abnf::cstss "%s\"assert\"")
      (cst-list-list-conc-matchp abnf::cstss "%s\"assert_eq\"")
      (cst-list-list-conc-matchp abnf::cstss "%s\"assert_neq\"")
      (cst-list-list-conc-matchp abnf::cstss "%s\"async\"")
      (cst-list-list-conc-matchp abnf::cstss "%s\"block\"")
      (cst-list-list-conc-matchp abnf::cstss "%s\"bool\"")
      (cst-list-list-conc-matchp abnf::cstss "%s\"const\"")
      (cst-list-list-conc-matchp abnf::cstss "%s\"constant\"")
      (cst-list-list-conc-matchp abnf::cstss "%s\"else\"")
      (cst-list-list-conc-matchp abnf::cstss "%s\"field\"")
      (cst-list-list-conc-matchp abnf::cstss "%s\"Fn\"")
      (cst-list-list-conc-matchp abnf::cstss "%s\"for\"")
      (cst-list-list-conc-matchp abnf::cstss "%s\"function\"")
      (cst-list-list-conc-matchp abnf::cstss "%s\"Future\"")
      (cst-list-list-conc-matchp abnf::cstss "%s\"group\"")
      (cst-list-list-conc-matchp abnf::cstss "%s\"i8\"")
      (cst-list-list-conc-matchp abnf::cstss "%s\"i16\"")
      (cst-list-list-conc-matchp abnf::cstss "%s\"i32\"")
      (cst-list-list-conc-matchp abnf::cstss "%s\"i64\"")
      (cst-list-list-conc-matchp abnf::cstss "%s\"i128\"")
      (cst-list-list-conc-matchp abnf::cstss "%s\"if\"")
      (cst-list-list-conc-matchp abnf::cstss "%s\"import\"")
      (cst-list-list-conc-matchp abnf::cstss "%s\"in\"")
      (cst-list-list-conc-matchp abnf::cstss "%s\"inline\"")
      (cst-list-list-conc-matchp abnf::cstss "%s\"let\"")
      (cst-list-list-conc-matchp abnf::cstss "%s\"mapping\"")
      (cst-list-list-conc-matchp abnf::cstss "%s\"network\"")
      (cst-list-list-conc-matchp abnf::cstss "%s\"private\"")
      (cst-list-list-conc-matchp abnf::cstss "%s\"program\"")
      (cst-list-list-conc-matchp abnf::cstss "%s\"public\"")
      (cst-list-list-conc-matchp abnf::cstss "%s\"record\"")
      (cst-list-list-conc-matchp abnf::cstss "%s\"return\"")
      (cst-list-list-conc-matchp abnf::cstss "%s\"scalar\"")
      (cst-list-list-conc-matchp abnf::cstss "%s\"self\"")
      (cst-list-list-conc-matchp abnf::cstss "%s\"signature\"")
      (cst-list-list-conc-matchp abnf::cstss "%s\"string\"")
      (cst-list-list-conc-matchp abnf::cstss "%s\"struct\"")
      (cst-list-list-conc-matchp abnf::cstss "%s\"transition\"")
      (cst-list-list-conc-matchp abnf::cstss "%s\"u8\"")
      (cst-list-list-conc-matchp abnf::cstss "%s\"u16\"")
      (cst-list-list-conc-matchp abnf::cstss "%s\"u32\"")
      (cst-list-list-conc-matchp abnf::cstss "%s\"u64\"")
      (cst-list-list-conc-matchp abnf::cstss "%s\"u128\""))))

Theorem: cst-uppercase-letter-concs

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

Theorem: cst-lowercase-letter-concs

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

Theorem: cst-letter-concs

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

Theorem: cst-binary-digit-concs

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

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

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

Theorem: cst-nonzero-decimal-digit-concs

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

Theorem: cst-hexadecimal-digit-concs

(defthm cst-hexadecimal-digit-concs
 (implies
    (cst-list-list-alt-matchp abnf::cstss "decimal-digit / %x41-46")
    (or (cst-list-list-conc-matchp abnf::cstss "decimal-digit")
        (cst-list-list-conc-matchp abnf::cstss "%x41-46"))))

Theorem: cst-identifier-concs

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

Theorem: cst-binary-numeral-concs

(defthm cst-binary-numeral-concs
 (implies
  (cst-list-list-alt-matchp abnf::cstss
                            "%s\"0b\" 1*( binary-digit *\"_\" )")
  (or
     (cst-list-list-conc-matchp abnf::cstss
                                "%s\"0b\" 1*( binary-digit *\"_\" )"))))

Theorem: cst-octal-numeral-concs

(defthm cst-octal-numeral-concs
 (implies
  (cst-list-list-alt-matchp abnf::cstss
                            "%s\"0o\" 1*( octal-digit *\"_\" )")
  (or (cst-list-list-conc-matchp abnf::cstss
                                 "%s\"0o\" 1*( octal-digit *\"_\" )"))))

Theorem: cst-decimal-numeral-concs

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

Theorem: cst-hexadecimal-numeral-concs

(defthm cst-hexadecimal-numeral-concs
 (implies
    (cst-list-list-alt-matchp abnf::cstss
                              "%s\"0x\" 1*( hexadecimal-digit *\"_\" )")
    (or (cst-list-list-conc-matchp
             abnf::cstss
             "%s\"0x\" 1*( hexadecimal-digit *\"_\" )"))))

Theorem: cst-numeral-concs

(defthm cst-numeral-concs
 (implies
  (cst-list-list-alt-matchp
   abnf::cstss
   "binary-numeral / octal-numeral / decimal-numeral / hexadecimal-numeral")
  (or
    (cst-list-list-conc-matchp abnf::cstss "binary-numeral")
    (cst-list-list-conc-matchp abnf::cstss "octal-numeral")
    (cst-list-list-conc-matchp abnf::cstss "decimal-numeral")
    (cst-list-list-conc-matchp abnf::cstss "hexadecimal-numeral"))))

Theorem: cst-tuple-index-concs

(defthm cst-tuple-index-concs
  (implies (cst-list-list-alt-matchp
                abnf::cstss
                "\"0\" / nonzero-decimal-digit *( decimal-digit )")
           (or (cst-list-list-conc-matchp abnf::cstss "\"0\"")
               (cst-list-list-conc-matchp
                    abnf::cstss
                    "nonzero-decimal-digit *( decimal-digit )"))))

Theorem: cst-unsigned-literal-concs

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

Theorem: cst-signed-literal-concs

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

Theorem: cst-integer-literal-concs

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

Theorem: cst-field-literal-concs

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

Theorem: cst-group-literal-concs

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

Theorem: cst-scalar-literal-concs

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

Theorem: cst-numeric-literal-concs

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

Theorem: cst-boolean-literal-concs

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

Theorem: cst-explicit-address-literal-concs

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

Theorem: cst-string-literal-concs

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

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-string-character-concs

(defthm cst-string-character-concs
 (implies
    (cst-list-list-alt-matchp
         abnf::cstss
         "not-double-quote-or-line-feed / line-terminator")
    (or (cst-list-list-conc-matchp abnf::cstss
                                   "not-double-quote-or-line-feed")
        (cst-list-list-conc-matchp abnf::cstss "line-terminator"))))

Theorem: cst-not-double-quote-or-line-feed-concs

(defthm cst-not-double-quote-or-line-feed-concs
 (implies
      (cst-list-list-alt-matchp
           abnf::cstss
           "%x0-9 / %xB-21 / %x23-7F / safe-nonascii")
      (or (cst-list-list-conc-matchp abnf::cstss "%x0-9")
          (cst-list-list-conc-matchp abnf::cstss "%xB-21")
          (cst-list-list-conc-matchp abnf::cstss "%x23-7F")
          (cst-list-list-conc-matchp abnf::cstss "safe-nonascii"))))

Theorem: cst-atomic-literal-concs

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

Theorem: cst-annotation-concs

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

Theorem: cst-symbol-concs

(defthm cst-symbol-concs
 (implies
  (cst-list-list-alt-matchp
   abnf::cstss
   "\"!\" / \"&&\" / \"||\" / \"==\" / \"!=\" / \"<\" / \"<=\" / \">\" / \">=\" / \"&\" / \"|\" / \"^\" / \"<<\" / \">>\" / \"+\" / \"-\" / \"*\" / \"/\" / \"%\" / \"**\" / \"=\" / \"+=\" / \"-=\" / \"*=\" / \"/=\" / \"%=\" / \"**=\" / \"<<=\" / \">>=\" / \"&=\" / \"|=\" / \"^=\" / \"&&=\" / \"||=\" / \"(\" / \")\" / \"[\" / \"]\" / \"{\" / \"}\" / \",\" / \".\" / \"..\" / \";\" / \":\" / \"::\" / \"?\" / \"->\" / \"=>\"")
  (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 "\"=>\""))))

Theorem: cst-token-concs

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

Theorem: cst-lexeme-concs

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

Theorem: cst-program-id-concs

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

Theorem: cst-network-concs

(defthm cst-network-concs
  (implies (cst-list-list-alt-matchp abnf::cstss "%s\"aleo\"")
           (or (cst-list-list-conc-matchp abnf::cstss "%s\"aleo\""))))

Theorem: cst-locator-concs

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

Theorem: cst-unsigned-type-concs

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

Theorem: cst-signed-type-concs

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

Theorem: cst-integer-type-concs

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

Theorem: cst-field-type-concs

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

Theorem: cst-group-type-concs

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

Theorem: cst-scalar-type-concs

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

Theorem: cst-arithmetic-type-concs

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

Theorem: cst-boolean-type-concs

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

Theorem: cst-address-type-concs

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

Theorem: cst-signature-type-concs

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

Theorem: cst-string-type-concs

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

Theorem: cst-named-primitive-type-concs

(defthm cst-named-primitive-type-concs
 (implies
  (cst-list-list-alt-matchp
   abnf::cstss
   "boolean-type / arithmetic-type / address-type / signature-type / string-type")
  (or (cst-list-list-conc-matchp abnf::cstss "boolean-type")
      (cst-list-list-conc-matchp abnf::cstss "arithmetic-type")
      (cst-list-list-conc-matchp abnf::cstss "address-type")
      (cst-list-list-conc-matchp abnf::cstss "signature-type")
      (cst-list-list-conc-matchp abnf::cstss "string-type"))))

Theorem: cst-unit-type-concs

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

Theorem: cst-primitive-type-concs

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

Theorem: cst-untyped-future-type-concs

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

Theorem: cst-typed-future-type-concs

(defthm cst-typed-future-type-concs
 (implies
  (cst-list-list-alt-matchp
   abnf::cstss
   "%s\"Future\" \"<\" %s\"Fn\" \"(\" [ type 1*( \",\" type ) [ \",\" ] ] \")\" \">\"")
  (or
   (cst-list-list-conc-matchp
    abnf::cstss
    "%s\"Future\" \"<\" %s\"Fn\" \"(\" [ type 1*( \",\" type ) [ \",\" ] ] \")\" \">\""))))

Theorem: cst-future-type-concs

(defthm cst-future-type-concs
 (implies
  (cst-list-list-alt-matchp
       abnf::cstss
       "untyped-future-type / typed-future-type")
  (or (cst-list-list-conc-matchp abnf::cstss "untyped-future-type")
      (cst-list-list-conc-matchp abnf::cstss "typed-future-type"))))

Theorem: cst-tuple-type-concs

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

Theorem: cst-array-type-concs

(defthm cst-array-type-concs
 (implies
  (cst-list-list-alt-matchp abnf::cstss
                            "\"[\" type \";\" decimal-numeral \"]\"")
  (or
   (cst-list-list-conc-matchp abnf::cstss
                              "\"[\" type \";\" decimal-numeral \"]\""))))

Theorem: cst-type-concs

(defthm cst-type-concs
 (implies
      (cst-list-list-alt-matchp
           abnf::cstss
           "primitive-type / future-type / tuple-type / array-type")
      (or (cst-list-list-conc-matchp abnf::cstss "primitive-type")
          (cst-list-list-conc-matchp abnf::cstss "future-type")
          (cst-list-list-conc-matchp abnf::cstss "tuple-type")
          (cst-list-list-conc-matchp abnf::cstss "array-type"))))

Theorem: cst-named-type-concs

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

Theorem: cst-program-address-literal-concs

(defthm cst-program-address-literal-concs
  (implies
       (cst-list-list-alt-matchp abnf::cstss "program-id")
       (or (cst-list-list-conc-matchp abnf::cstss "program-id"))))

Theorem: cst-literal-concs

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

Theorem: cst-address-literal-concs

(defthm cst-address-literal-concs
  (implies
       (cst-list-list-alt-matchp
            abnf::cstss
            "explicit-address-literal / program-address-literal")
       (or (cst-list-list-conc-matchp
                abnf::cstss "explicit-address-literal")
           (cst-list-list-conc-matchp abnf::cstss
                                      "program-address-literal"))))

Theorem: cst-primary-expression-concs

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

Theorem: cst-variable-concs

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

Theorem: cst-associated-constant-concs

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

Theorem: cst-free-function-call-concs

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

Theorem: cst-associated-function-call-concs

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

Theorem: cst-function-arguments-concs

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

Theorem: cst-unit-expression-concs

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

Theorem: cst-tuple-expression-concs

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

Theorem: cst-array-expression-concs

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

Theorem: cst-struct-expression-concs

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

Theorem: cst-struct-component-initializer-concs

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

Theorem: cst-self-expression-concs

(defthm cst-self-expression-concs
 (implies
  (cst-list-list-alt-matchp
   abnf::cstss
   "%s\"self\" \".\" %s\"address\" / %s\"self\" \".\" %s\"caller\" / %s\"self\" \".\" %s\"signer\"")
  (or
   (cst-list-list-conc-matchp
        abnf::cstss "%s\"self\" \".\" %s\"address\"")
   (cst-list-list-conc-matchp abnf::cstss "%s\"self\" \".\" %s\"caller\"")
   (cst-list-list-conc-matchp abnf::cstss
                              "%s\"self\" \".\" %s\"signer\""))))

Theorem: cst-block-expression-concs

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

Theorem: cst-network-expression-concs

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

Theorem: cst-postfix-expression-concs

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

Theorem: cst-tuple-component-expression-concs

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

Theorem: cst-array-component-expression-concs

(defthm cst-array-component-expression-concs
 (implies
  (cst-list-list-alt-matchp abnf::cstss
                            "postfix-expression \"[\" expression \"]\"")
  (or (cst-list-list-conc-matchp
           abnf::cstss
           "postfix-expression \"[\" expression \"]\""))))

Theorem: cst-struct-component-expression-concs

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

Theorem: cst-method-call-concs

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

Theorem: cst-unary-expression-concs

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

Theorem: cst-cast-expression-concs

(defthm cst-cast-expression-concs
 (implies
  (cst-list-list-alt-matchp
   abnf::cstss
   "unary-expression / unary-expression %s\"as\" named-primitive-type")
  (or (cst-list-list-conc-matchp abnf::cstss "unary-expression")
      (cst-list-list-conc-matchp
           abnf::cstss
           "unary-expression %s\"as\" named-primitive-type"))))

Theorem: cst-exponential-expression-concs

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

Theorem: cst-multiplicative-expression-concs

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

Theorem: cst-additive-expression-concs

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

Theorem: cst-shift-expression-concs

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

Theorem: cst-conjunctive-expression-concs

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

Theorem: cst-inclusive-disjunctive-expression-concs

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

Theorem: cst-exclusive-disjunctive-expression-concs

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

Theorem: cst-ordering-expression-concs

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

Theorem: cst-equality-expression-concs

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

Theorem: cst-conditional-conjunctive-expression-concs

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

Theorem: cst-conditional-disjunctive-expression-concs

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

Theorem: cst-binary-expression-concs

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

Theorem: cst-conditional-ternary-expression-concs

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

Theorem: cst-expression-concs

(defthm cst-expression-concs
 (implies
  (cst-list-list-alt-matchp abnf::cstss
                            "conditional-ternary-expression")
  (or
     (cst-list-list-conc-matchp abnf::cstss
                                "conditional-ternary-expression"))))

Theorem: cst-statement-concs

(defthm cst-statement-concs
 (implies
  (cst-list-list-alt-matchp
   abnf::cstss
   "expression-statement / return-statement / variable-declaration / constant-declaration / conditional-statement / loop-statement / assignment-statement / block")
  (or
     (cst-list-list-conc-matchp abnf::cstss "expression-statement")
     (cst-list-list-conc-matchp abnf::cstss "return-statement")
     (cst-list-list-conc-matchp abnf::cstss "variable-declaration")
     (cst-list-list-conc-matchp abnf::cstss "constant-declaration")
     (cst-list-list-conc-matchp abnf::cstss "conditional-statement")
     (cst-list-list-conc-matchp abnf::cstss "loop-statement")
     (cst-list-list-conc-matchp abnf::cstss "assignment-statement")
     (cst-list-list-conc-matchp abnf::cstss "block"))))

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-block-concs

(defthm cst-block-concs
 (implies
  (cst-list-list-alt-matchp abnf::cstss "\"{\" *statement \"}\"")
  (or
     (cst-list-list-conc-matchp abnf::cstss "\"{\" *statement \"}\""))))

Theorem: cst-return-statement-concs

(defthm cst-return-statement-concs
 (implies
  (cst-list-list-alt-matchp abnf::cstss
                            "%s\"return\" [ expression ] \";\"")
  (or (cst-list-list-conc-matchp abnf::cstss
                                 "%s\"return\" [ expression ] \";\""))))

Theorem: cst-variable-declaration-concs

(defthm cst-variable-declaration-concs
 (implies
  (cst-list-list-alt-matchp
   abnf::cstss
   "%s\"let\" identifier-or-identifiers [ \":\" type ] \"=\" expression \";\"")
  (or
   (cst-list-list-conc-matchp
    abnf::cstss
    "%s\"let\" identifier-or-identifiers [ \":\" type ] \"=\" expression \";\""))))

Theorem: cst-constant-declaration-concs

(defthm cst-constant-declaration-concs
 (implies
     (cst-list-list-alt-matchp
          abnf::cstss
          "%s\"const\" identifier \":\" type \"=\" expression \";\"")
     (or (cst-list-list-conc-matchp
              abnf::cstss
              "%s\"const\" identifier \":\" type \"=\" expression \";\""))))

Theorem: cst-identifier-or-identifiers-concs

(defthm cst-identifier-or-identifiers-concs
 (implies
  (cst-list-list-alt-matchp
     abnf::cstss
     "identifier / \"(\" identifier 1*( \",\" identifier ) [ \",\" ] \")\"")
  (or (cst-list-list-conc-matchp abnf::cstss "identifier")
      (cst-list-list-conc-matchp
           abnf::cstss
           "\"(\" identifier 1*( \",\" identifier ) [ \",\" ] \")\""))))

Theorem: cst-branch-concs

(defthm cst-branch-concs
 (implies (cst-list-list-alt-matchp
               abnf::cstss
               "%s\"if\" conditional-ternary-expression block")
          (or (cst-list-list-conc-matchp
                   abnf::cstss
                   "%s\"if\" conditional-ternary-expression block"))))

Theorem: cst-conditional-statement-concs

(defthm cst-conditional-statement-concs
 (implies
  (cst-list-list-alt-matchp
   abnf::cstss
   "branch / branch %s\"else\" block / branch %s\"else\" conditional-statement")
  (or
     (cst-list-list-conc-matchp abnf::cstss "branch")
     (cst-list-list-conc-matchp abnf::cstss "branch %s\"else\" block")
     (cst-list-list-conc-matchp
          abnf::cstss
          "branch %s\"else\" conditional-statement"))))

Theorem: cst-loop-statement-concs

(defthm cst-loop-statement-concs
 (implies
  (cst-list-list-alt-matchp
   abnf::cstss
   "%s\"for\" identifier [ \":\" type ] %s\"in\" expression \"..\" expression block")
  (or
   (cst-list-list-conc-matchp
    abnf::cstss
    "%s\"for\" identifier [ \":\" type ] %s\"in\" expression \"..\" expression block"))))

Theorem: cst-assignment-operator-concs

(defthm cst-assignment-operator-concs
 (implies
  (cst-list-list-alt-matchp
   abnf::cstss
   "\"=\" / \"+=\" / \"-=\" / \"*=\" / \"/=\" / \"%=\" / \"**=\" / \"<<=\" / \">>=\" / \"&=\" / \"|=\" / \"^=\" / \"&&=\" / \"||=\"")
  (or (cst-list-list-conc-matchp abnf::cstss "\"=\"")
      (cst-list-list-conc-matchp abnf::cstss "\"+=\"")
      (cst-list-list-conc-matchp abnf::cstss "\"-=\"")
      (cst-list-list-conc-matchp abnf::cstss "\"*=\"")
      (cst-list-list-conc-matchp abnf::cstss "\"/=\"")
      (cst-list-list-conc-matchp abnf::cstss "\"%=\"")
      (cst-list-list-conc-matchp abnf::cstss "\"**=\"")
      (cst-list-list-conc-matchp abnf::cstss "\"<<=\"")
      (cst-list-list-conc-matchp abnf::cstss "\">>=\"")
      (cst-list-list-conc-matchp abnf::cstss "\"&=\"")
      (cst-list-list-conc-matchp abnf::cstss "\"|=\"")
      (cst-list-list-conc-matchp abnf::cstss "\"^=\"")
      (cst-list-list-conc-matchp abnf::cstss "\"&&=\"")
      (cst-list-list-conc-matchp abnf::cstss "\"||=\""))))

Theorem: cst-assignment-statement-concs

(defthm cst-assignment-statement-concs
  (implies
       (cst-list-list-alt-matchp
            abnf::cstss
            "expression assignment-operator expression \";\"")
       (or (cst-list-list-conc-matchp
                abnf::cstss
                "expression assignment-operator expression \";\""))))

Theorem: cst-assert-statement-concs

(defthm cst-assert-statement-concs
 (implies
  (cst-list-list-alt-matchp
   abnf::cstss
   "%s\"assert\" \"(\" expression \")\" \";\" / %s\"assert_eq\" \"(\" expression \",\" expression \")\" \";\" / %s\"assert_neq\" \"(\" expression \",\" expression \")\" \";\"")
  (or
     (cst-list-list-conc-matchp abnf::cstss
                                "%s\"assert\" \"(\" expression \")\" \";\"")
     (cst-list-list-conc-matchp
          abnf::cstss
          "%s\"assert_eq\" \"(\" expression \",\" expression \")\" \";\"")
     (cst-list-list-conc-matchp
          abnf::cstss
          "%s\"assert_neq\" \"(\" expression \",\" expression \")\" \";\""))))

Theorem: cst-function-declaration-concs

(defthm cst-function-declaration-concs
 (implies
  (cst-list-list-alt-matchp
   abnf::cstss
   "*annotation [ %s\"async\" ] function-kind identifier \"(\" [ function-inputs ] \")\" [ \"->\" function-outputs ] ( block / \";\" )")
  (or
   (cst-list-list-conc-matchp
    abnf::cstss
    "*annotation [ %s\"async\" ] function-kind identifier \"(\" [ function-inputs ] \")\" [ \"->\" function-outputs ] ( block / \";\" )"))))

Theorem: cst-function-kind-concs

(defthm cst-function-kind-concs
  (implies
       (cst-list-list-alt-matchp
            abnf::cstss
            "%s\"function\" / %s\"transition\" / %s\"inline\"")
       (or (cst-list-list-conc-matchp abnf::cstss "%s\"function\"")
           (cst-list-list-conc-matchp abnf::cstss "%s\"transition\"")
           (cst-list-list-conc-matchp abnf::cstss "%s\"inline\""))))

Theorem: cst-function-inputs-concs

(defthm cst-function-inputs-concs
  (implies
       (cst-list-list-alt-matchp
            abnf::cstss
            "function-input *( \",\" function-input ) [ \",\" ]")
       (or (cst-list-list-conc-matchp
                abnf::cstss
                "function-input *( \",\" function-input ) [ \",\" ]"))))

Theorem: cst-function-input-concs

(defthm cst-function-input-concs
 (implies
  (cst-list-list-alt-matchp
   abnf::cstss
   "[ %s\"public\" / %s\"private\" / %s\"constant\" ] identifier \":\" type")
  (or
   (cst-list-list-conc-matchp
    abnf::cstss
    "[ %s\"public\" / %s\"private\" / %s\"constant\" ] identifier \":\" type"))))

Theorem: cst-function-outputs-concs

(defthm cst-function-outputs-concs
 (implies
  (cst-list-list-alt-matchp
   abnf::cstss
   "function-output / \"(\" [ function-output *( \",\" function-output ) [ \",\" ] ] \")\"")
  (or
   (cst-list-list-conc-matchp abnf::cstss "function-output")
   (cst-list-list-conc-matchp
    abnf::cstss
    "\"(\" [ function-output *( \",\" function-output ) [ \",\" ] ] \")\""))))

Theorem: cst-function-output-concs

(defthm cst-function-output-concs
 (implies
     (cst-list-list-alt-matchp
          abnf::cstss
          "[ %s\"public\" / %s\"private\" / %s\"constant\" ] type")
     (or (cst-list-list-conc-matchp
              abnf::cstss
              "[ %s\"public\" / %s\"private\" / %s\"constant\" ] type"))))

Theorem: cst-struct-declaration-concs

(defthm cst-struct-declaration-concs
 (implies
  (cst-list-list-alt-matchp
      abnf::cstss
      "%s\"struct\" identifier \"{\" struct-component-declarations \"}\"")
  (or
   (cst-list-list-conc-matchp
    abnf::cstss
    "%s\"struct\" identifier \"{\" struct-component-declarations \"}\""))))

Theorem: cst-struct-component-declarations-concs

(defthm cst-struct-component-declarations-concs
 (implies
  (cst-list-list-alt-matchp
   abnf::cstss
   "struct-component-declaration *( \",\" struct-component-declaration ) [ \",\" ]")
  (or
   (cst-list-list-conc-matchp
    abnf::cstss
    "struct-component-declaration *( \",\" struct-component-declaration ) [ \",\" ]"))))

Theorem: cst-struct-component-declaration-concs

(defthm cst-struct-component-declaration-concs
 (implies
  (cst-list-list-alt-matchp
   abnf::cstss
   "[ %s\"public\" / %s\"private\" / %s\"constant\" ] identifier \":\" type")
  (or
   (cst-list-list-conc-matchp
    abnf::cstss
    "[ %s\"public\" / %s\"private\" / %s\"constant\" ] identifier \":\" type"))))

Theorem: cst-record-declaration-concs

(defthm cst-record-declaration-concs
 (implies
  (cst-list-list-alt-matchp
      abnf::cstss
      "%s\"record\" identifier \"{\" struct-component-declarations \"}\"")
  (or
   (cst-list-list-conc-matchp
    abnf::cstss
    "%s\"record\" identifier \"{\" struct-component-declarations \"}\""))))

Theorem: cst-mapping-declaration-concs

(defthm cst-mapping-declaration-concs
  (implies
       (cst-list-list-alt-matchp
            abnf::cstss
            "%s\"mapping\" identifier \":\" type \"=>\" type \";\"")
       (or (cst-list-list-conc-matchp
                abnf::cstss
                "%s\"mapping\" identifier \":\" type \"=>\" type \";\""))))

Theorem: cst-program-item-concs

(defthm cst-program-item-concs
 (implies
  (cst-list-list-alt-matchp
   abnf::cstss
   "function-declaration / struct-declaration / record-declaration / mapping-declaration / constant-declaration")
  (or
   (cst-list-list-conc-matchp abnf::cstss "function-declaration")
   (cst-list-list-conc-matchp abnf::cstss "struct-declaration")
   (cst-list-list-conc-matchp abnf::cstss "record-declaration")
   (cst-list-list-conc-matchp abnf::cstss "mapping-declaration")
   (cst-list-list-conc-matchp abnf::cstss "constant-declaration"))))

Theorem: cst-program-declaration-concs

(defthm cst-program-declaration-concs
  (implies
       (cst-list-list-alt-matchp
            abnf::cstss
            "%s\"program\" program-id \"{\" *program-item \"}\"")
       (or (cst-list-list-conc-matchp
                abnf::cstss
                "%s\"program\" program-id \"{\" *program-item \"}\""))))

Theorem: cst-import-declaration-concs

(defthm cst-import-declaration-concs
 (implies
  (cst-list-list-alt-matchp abnf::cstss "%s\"import\" program-id \";\"")
  (or (cst-list-list-conc-matchp abnf::cstss
                                 "%s\"import\" program-id \";\""))))

Theorem: cst-file-concs

(defthm cst-file-concs
  (implies (cst-list-list-alt-matchp
                abnf::cstss
                "*import-declaration program-declaration")
           (or (cst-list-list-conc-matchp
                    abnf::cstss
                    "*import-declaration program-declaration"))))

Theorem: cst-ascii-conc-matching

(defthm cst-ascii-conc-matching
  (implies (cst-list-list-conc-matchp abnf::cstss "%x0-7F")
           (and (equal (len abnf::cstss) 1)
                (cst-list-rep-matchp (nth 0 abnf::cstss)
                                     "%x0-7F"))))

Theorem: cst-safe-nonascii-conc1-matching

(defthm cst-safe-nonascii-conc1-matching
  (implies (cst-list-list-conc-matchp abnf::cstss "%x80-2029")
           (and (equal (len abnf::cstss) 1)
                (cst-list-rep-matchp (nth 0 abnf::cstss)
                                     "%x80-2029"))))

Theorem: cst-safe-nonascii-conc2-matching

(defthm cst-safe-nonascii-conc2-matching
  (implies (cst-list-list-conc-matchp abnf::cstss "%x202F-2065")
           (and (equal (len abnf::cstss) 1)
                (cst-list-rep-matchp (nth 0 abnf::cstss)
                                     "%x202F-2065"))))

Theorem: cst-safe-nonascii-conc3-matching

(defthm cst-safe-nonascii-conc3-matching
  (implies (cst-list-list-conc-matchp abnf::cstss "%x206A-D7FF")
           (and (equal (len abnf::cstss) 1)
                (cst-list-rep-matchp (nth 0 abnf::cstss)
                                     "%x206A-D7FF"))))

Theorem: cst-safe-nonascii-conc4-matching

(defthm cst-safe-nonascii-conc4-matching
  (implies (cst-list-list-conc-matchp abnf::cstss "%xE000-10FFFF")
           (and (equal (len abnf::cstss) 1)
                (cst-list-rep-matchp (nth 0 abnf::cstss)
                                     "%xE000-10FFFF"))))

Theorem: cst-character-conc1-matching

(defthm cst-character-conc1-matching
  (implies (cst-list-list-conc-matchp abnf::cstss "ascii")
           (and (equal (len abnf::cstss) 1)
                (cst-list-rep-matchp (nth 0 abnf::cstss)
                                     "ascii"))))

Theorem: cst-character-conc2-matching

(defthm cst-character-conc2-matching
  (implies (cst-list-list-conc-matchp abnf::cstss "safe-nonascii")
           (and (equal (len abnf::cstss) 1)
                (cst-list-rep-matchp (nth 0 abnf::cstss)
                                     "safe-nonascii"))))

Theorem: cst-line-terminator-conc1-matching

(defthm cst-line-terminator-conc1-matching
  (implies (cst-list-list-conc-matchp abnf::cstss "line-feed")
           (and (equal (len abnf::cstss) 1)
                (cst-list-rep-matchp (nth 0 abnf::cstss)
                                     "line-feed"))))

Theorem: cst-line-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-whitespace-conc1-matching

(defthm cst-whitespace-conc1-matching
  (implies (cst-list-list-conc-matchp abnf::cstss "space")
           (and (equal (len abnf::cstss) 1)
                (cst-list-rep-matchp (nth 0 abnf::cstss)
                                     "space"))))

Theorem: cst-whitespace-conc2-matching

(defthm cst-whitespace-conc2-matching
  (implies (cst-list-list-conc-matchp abnf::cstss "horizontal-tab")
           (and (equal (len abnf::cstss) 1)
                (cst-list-rep-matchp (nth 0 abnf::cstss)
                                     "horizontal-tab"))))

Theorem: cst-whitespace-conc3-matching

(defthm cst-whitespace-conc3-matching
  (implies (cst-list-list-conc-matchp abnf::cstss "form-feed")
           (and (equal (len abnf::cstss) 1)
                (cst-list-rep-matchp (nth 0 abnf::cstss)
                                     "form-feed"))))

Theorem: cst-whitespace-conc4-matching

(defthm cst-whitespace-conc4-matching
  (implies (cst-list-list-conc-matchp abnf::cstss "line-terminator")
           (and (equal (len abnf::cstss) 1)
                (cst-list-rep-matchp (nth 0 abnf::cstss)
                                     "line-terminator"))))

Theorem: cst-whitespace-conc5-matching

(defthm cst-whitespace-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-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-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-comment-conc1-matching

(defthm cst-comment-conc1-matching
  (implies (cst-list-list-conc-matchp abnf::cstss "block-comment")
           (and (equal (len abnf::cstss) 1)
                (cst-list-rep-matchp (nth 0 abnf::cstss)
                                     "block-comment"))))

Theorem: cst-comment-conc2-matching

(defthm cst-comment-conc2-matching
  (implies (cst-list-list-conc-matchp abnf::cstss "line-comment")
           (and (equal (len abnf::cstss) 1)
                (cst-list-rep-matchp (nth 0 abnf::cstss)
                                     "line-comment"))))

Theorem: cst-rest-of-block-comment-after-star-conc1-matching

(defthm cst-rest-of-block-comment-after-star-conc1-matching
  (implies (cst-list-list-conc-matchp abnf::cstss "\"/\"")
           (and (equal (len abnf::cstss) 1)
                (cst-list-rep-matchp (nth 0 abnf::cstss)
                                     "\"/\""))))

Theorem: cst-not-star-or-line-feed-conc1-matching

(defthm cst-not-star-or-line-feed-conc1-matching
  (implies (cst-list-list-conc-matchp abnf::cstss "%x0-9")
           (and (equal (len abnf::cstss) 1)
                (cst-list-rep-matchp (nth 0 abnf::cstss)
                                     "%x0-9"))))

Theorem: cst-not-star-or-line-feed-conc2-matching

(defthm cst-not-star-or-line-feed-conc2-matching
  (implies (cst-list-list-conc-matchp abnf::cstss "%xB-29")
           (and (equal (len abnf::cstss) 1)
                (cst-list-rep-matchp (nth 0 abnf::cstss)
                                     "%xB-29"))))

Theorem: cst-not-star-or-line-feed-conc3-matching

(defthm cst-not-star-or-line-feed-conc3-matching
  (implies (cst-list-list-conc-matchp abnf::cstss "%x2B-7E")
           (and (equal (len abnf::cstss) 1)
                (cst-list-rep-matchp (nth 0 abnf::cstss)
                                     "%x2B-7E"))))

Theorem: cst-not-star-or-line-feed-conc4-matching

(defthm cst-not-star-or-line-feed-conc4-matching
  (implies (cst-list-list-conc-matchp abnf::cstss "safe-nonascii")
           (and (equal (len abnf::cstss) 1)
                (cst-list-rep-matchp (nth 0 abnf::cstss)
                                     "safe-nonascii"))))

Theorem: cst-not-star-or-slash-or-line-feed-conc1-matching

(defthm cst-not-star-or-slash-or-line-feed-conc1-matching
  (implies (cst-list-list-conc-matchp abnf::cstss "%x0-9")
           (and (equal (len abnf::cstss) 1)
                (cst-list-rep-matchp (nth 0 abnf::cstss)
                                     "%x0-9"))))

Theorem: cst-not-star-or-slash-or-line-feed-conc2-matching

(defthm cst-not-star-or-slash-or-line-feed-conc2-matching
  (implies (cst-list-list-conc-matchp abnf::cstss "%xB-29")
           (and (equal (len abnf::cstss) 1)
                (cst-list-rep-matchp (nth 0 abnf::cstss)
                                     "%xB-29"))))

Theorem: cst-not-star-or-slash-or-line-feed-conc3-matching

(defthm cst-not-star-or-slash-or-line-feed-conc3-matching
  (implies (cst-list-list-conc-matchp abnf::cstss "%x2B-2E")
           (and (equal (len abnf::cstss) 1)
                (cst-list-rep-matchp (nth 0 abnf::cstss)
                                     "%x2B-2E"))))

Theorem: cst-not-star-or-slash-or-line-feed-conc4-matching

(defthm cst-not-star-or-slash-or-line-feed-conc4-matching
  (implies (cst-list-list-conc-matchp abnf::cstss "%x30-7E")
           (and (equal (len abnf::cstss) 1)
                (cst-list-rep-matchp (nth 0 abnf::cstss)
                                     "%x30-7E"))))

Theorem: cst-not-star-or-slash-or-line-feed-conc5-matching

(defthm cst-not-star-or-slash-or-line-feed-conc5-matching
  (implies (cst-list-list-conc-matchp abnf::cstss "safe-nonascii")
           (and (equal (len abnf::cstss) 1)
                (cst-list-rep-matchp (nth 0 abnf::cstss)
                                     "safe-nonascii"))))

Theorem: cst-not-line-feed-conc1-matching

(defthm cst-not-line-feed-conc1-matching
  (implies (cst-list-list-conc-matchp abnf::cstss "%x0-9")
           (and (equal (len abnf::cstss) 1)
                (cst-list-rep-matchp (nth 0 abnf::cstss)
                                     "%x0-9"))))

Theorem: cst-not-line-feed-conc2-matching

(defthm cst-not-line-feed-conc2-matching
  (implies (cst-list-list-conc-matchp abnf::cstss "%xB-7F")
           (and (equal (len abnf::cstss) 1)
                (cst-list-rep-matchp (nth 0 abnf::cstss)
                                     "%xB-7F"))))

Theorem: cst-not-line-feed-conc3-matching

(defthm cst-not-line-feed-conc3-matching
  (implies (cst-list-list-conc-matchp abnf::cstss "safe-nonascii")
           (and (equal (len abnf::cstss) 1)
                (cst-list-rep-matchp (nth 0 abnf::cstss)
                                     "safe-nonascii"))))

Theorem: cst-keyword-conc1-matching

(defthm cst-keyword-conc1-matching
  (implies (cst-list-list-conc-matchp abnf::cstss "%s\"address\"")
           (and (equal (len abnf::cstss) 1)
                (cst-list-rep-matchp (nth 0 abnf::cstss)
                                     "%s\"address\""))))

Theorem: cst-keyword-conc2-matching

(defthm cst-keyword-conc2-matching
  (implies (cst-list-list-conc-matchp abnf::cstss "%s\"aleo\"")
           (and (equal (len abnf::cstss) 1)
                (cst-list-rep-matchp (nth 0 abnf::cstss)
                                     "%s\"aleo\""))))

Theorem: cst-keyword-conc3-matching

(defthm cst-keyword-conc3-matching
  (implies (cst-list-list-conc-matchp abnf::cstss "%s\"as\"")
           (and (equal (len abnf::cstss) 1)
                (cst-list-rep-matchp (nth 0 abnf::cstss)
                                     "%s\"as\""))))

Theorem: cst-keyword-conc4-matching

(defthm cst-keyword-conc4-matching
  (implies (cst-list-list-conc-matchp abnf::cstss "%s\"assert\"")
           (and (equal (len abnf::cstss) 1)
                (cst-list-rep-matchp (nth 0 abnf::cstss)
                                     "%s\"assert\""))))

Theorem: cst-keyword-conc5-matching

(defthm cst-keyword-conc5-matching
  (implies (cst-list-list-conc-matchp abnf::cstss "%s\"assert_eq\"")
           (and (equal (len abnf::cstss) 1)
                (cst-list-rep-matchp (nth 0 abnf::cstss)
                                     "%s\"assert_eq\""))))

Theorem: cst-keyword-conc6-matching

(defthm cst-keyword-conc6-matching
  (implies (cst-list-list-conc-matchp abnf::cstss "%s\"assert_neq\"")
           (and (equal (len abnf::cstss) 1)
                (cst-list-rep-matchp (nth 0 abnf::cstss)
                                     "%s\"assert_neq\""))))

Theorem: cst-keyword-conc7-matching

(defthm cst-keyword-conc7-matching
  (implies (cst-list-list-conc-matchp abnf::cstss "%s\"async\"")
           (and (equal (len abnf::cstss) 1)
                (cst-list-rep-matchp (nth 0 abnf::cstss)
                                     "%s\"async\""))))

Theorem: cst-keyword-conc8-matching

(defthm cst-keyword-conc8-matching
  (implies (cst-list-list-conc-matchp abnf::cstss "%s\"block\"")
           (and (equal (len abnf::cstss) 1)
                (cst-list-rep-matchp (nth 0 abnf::cstss)
                                     "%s\"block\""))))

Theorem: cst-keyword-conc9-matching

(defthm cst-keyword-conc9-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-conc10-matching

(defthm cst-keyword-conc10-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-conc11-matching

(defthm cst-keyword-conc11-matching
  (implies (cst-list-list-conc-matchp abnf::cstss "%s\"constant\"")
           (and (equal (len abnf::cstss) 1)
                (cst-list-rep-matchp (nth 0 abnf::cstss)
                                     "%s\"constant\""))))

Theorem: cst-keyword-conc12-matching

(defthm cst-keyword-conc12-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-conc13-matching

(defthm cst-keyword-conc13-matching
  (implies (cst-list-list-conc-matchp abnf::cstss "%s\"field\"")
           (and (equal (len abnf::cstss) 1)
                (cst-list-rep-matchp (nth 0 abnf::cstss)
                                     "%s\"field\""))))

Theorem: cst-keyword-conc14-matching

(defthm cst-keyword-conc14-matching
  (implies (cst-list-list-conc-matchp abnf::cstss "%s\"Fn\"")
           (and (equal (len abnf::cstss) 1)
                (cst-list-rep-matchp (nth 0 abnf::cstss)
                                     "%s\"Fn\""))))

Theorem: cst-keyword-conc15-matching

(defthm cst-keyword-conc15-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-conc16-matching

(defthm cst-keyword-conc16-matching
  (implies (cst-list-list-conc-matchp abnf::cstss "%s\"function\"")
           (and (equal (len abnf::cstss) 1)
                (cst-list-rep-matchp (nth 0 abnf::cstss)
                                     "%s\"function\""))))

Theorem: cst-keyword-conc17-matching

(defthm cst-keyword-conc17-matching
  (implies (cst-list-list-conc-matchp abnf::cstss "%s\"Future\"")
           (and (equal (len abnf::cstss) 1)
                (cst-list-rep-matchp (nth 0 abnf::cstss)
                                     "%s\"Future\""))))

Theorem: cst-keyword-conc18-matching

(defthm cst-keyword-conc18-matching
  (implies (cst-list-list-conc-matchp abnf::cstss "%s\"group\"")
           (and (equal (len abnf::cstss) 1)
                (cst-list-rep-matchp (nth 0 abnf::cstss)
                                     "%s\"group\""))))

Theorem: cst-keyword-conc19-matching

(defthm cst-keyword-conc19-matching
  (implies (cst-list-list-conc-matchp abnf::cstss "%s\"i8\"")
           (and (equal (len abnf::cstss) 1)
                (cst-list-rep-matchp (nth 0 abnf::cstss)
                                     "%s\"i8\""))))

Theorem: cst-keyword-conc20-matching

(defthm cst-keyword-conc20-matching
  (implies (cst-list-list-conc-matchp abnf::cstss "%s\"i16\"")
           (and (equal (len abnf::cstss) 1)
                (cst-list-rep-matchp (nth 0 abnf::cstss)
                                     "%s\"i16\""))))

Theorem: cst-keyword-conc21-matching

(defthm cst-keyword-conc21-matching
  (implies (cst-list-list-conc-matchp abnf::cstss "%s\"i32\"")
           (and (equal (len abnf::cstss) 1)
                (cst-list-rep-matchp (nth 0 abnf::cstss)
                                     "%s\"i32\""))))

Theorem: cst-keyword-conc22-matching

(defthm cst-keyword-conc22-matching
  (implies (cst-list-list-conc-matchp abnf::cstss "%s\"i64\"")
           (and (equal (len abnf::cstss) 1)
                (cst-list-rep-matchp (nth 0 abnf::cstss)
                                     "%s\"i64\""))))

Theorem: cst-keyword-conc23-matching

(defthm cst-keyword-conc23-matching
  (implies (cst-list-list-conc-matchp abnf::cstss "%s\"i128\"")
           (and (equal (len abnf::cstss) 1)
                (cst-list-rep-matchp (nth 0 abnf::cstss)
                                     "%s\"i128\""))))

Theorem: cst-keyword-conc24-matching

(defthm cst-keyword-conc24-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-conc25-matching

(defthm cst-keyword-conc25-matching
  (implies (cst-list-list-conc-matchp abnf::cstss "%s\"import\"")
           (and (equal (len abnf::cstss) 1)
                (cst-list-rep-matchp (nth 0 abnf::cstss)
                                     "%s\"import\""))))

Theorem: cst-keyword-conc26-matching

(defthm cst-keyword-conc26-matching
  (implies (cst-list-list-conc-matchp abnf::cstss "%s\"in\"")
           (and (equal (len abnf::cstss) 1)
                (cst-list-rep-matchp (nth 0 abnf::cstss)
                                     "%s\"in\""))))

Theorem: cst-keyword-conc27-matching

(defthm cst-keyword-conc27-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-conc28-matching

(defthm cst-keyword-conc28-matching
  (implies (cst-list-list-conc-matchp abnf::cstss "%s\"let\"")
           (and (equal (len abnf::cstss) 1)
                (cst-list-rep-matchp (nth 0 abnf::cstss)
                                     "%s\"let\""))))

Theorem: cst-keyword-conc29-matching

(defthm cst-keyword-conc29-matching
  (implies (cst-list-list-conc-matchp abnf::cstss "%s\"mapping\"")
           (and (equal (len abnf::cstss) 1)
                (cst-list-rep-matchp (nth 0 abnf::cstss)
                                     "%s\"mapping\""))))

Theorem: cst-keyword-conc30-matching

(defthm cst-keyword-conc30-matching
  (implies (cst-list-list-conc-matchp abnf::cstss "%s\"network\"")
           (and (equal (len abnf::cstss) 1)
                (cst-list-rep-matchp (nth 0 abnf::cstss)
                                     "%s\"network\""))))

Theorem: cst-keyword-conc31-matching

(defthm cst-keyword-conc31-matching
  (implies (cst-list-list-conc-matchp abnf::cstss "%s\"private\"")
           (and (equal (len abnf::cstss) 1)
                (cst-list-rep-matchp (nth 0 abnf::cstss)
                                     "%s\"private\""))))

Theorem: cst-keyword-conc32-matching

(defthm cst-keyword-conc32-matching
  (implies (cst-list-list-conc-matchp abnf::cstss "%s\"program\"")
           (and (equal (len abnf::cstss) 1)
                (cst-list-rep-matchp (nth 0 abnf::cstss)
                                     "%s\"program\""))))

Theorem: cst-keyword-conc33-matching

(defthm cst-keyword-conc33-matching
  (implies (cst-list-list-conc-matchp abnf::cstss "%s\"public\"")
           (and (equal (len abnf::cstss) 1)
                (cst-list-rep-matchp (nth 0 abnf::cstss)
                                     "%s\"public\""))))

Theorem: cst-keyword-conc34-matching

(defthm cst-keyword-conc34-matching
  (implies (cst-list-list-conc-matchp abnf::cstss "%s\"record\"")
           (and (equal (len abnf::cstss) 1)
                (cst-list-rep-matchp (nth 0 abnf::cstss)
                                     "%s\"record\""))))

Theorem: cst-keyword-conc35-matching

(defthm cst-keyword-conc35-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-conc36-matching

(defthm cst-keyword-conc36-matching
  (implies (cst-list-list-conc-matchp abnf::cstss "%s\"scalar\"")
           (and (equal (len abnf::cstss) 1)
                (cst-list-rep-matchp (nth 0 abnf::cstss)
                                     "%s\"scalar\""))))

Theorem: cst-keyword-conc37-matching

(defthm cst-keyword-conc37-matching
  (implies (cst-list-list-conc-matchp abnf::cstss "%s\"self\"")
           (and (equal (len abnf::cstss) 1)
                (cst-list-rep-matchp (nth 0 abnf::cstss)
                                     "%s\"self\""))))

Theorem: cst-keyword-conc38-matching

(defthm cst-keyword-conc38-matching
  (implies (cst-list-list-conc-matchp abnf::cstss "%s\"signature\"")
           (and (equal (len abnf::cstss) 1)
                (cst-list-rep-matchp (nth 0 abnf::cstss)
                                     "%s\"signature\""))))

Theorem: cst-keyword-conc39-matching

(defthm cst-keyword-conc39-matching
  (implies (cst-list-list-conc-matchp abnf::cstss "%s\"string\"")
           (and (equal (len abnf::cstss) 1)
                (cst-list-rep-matchp (nth 0 abnf::cstss)
                                     "%s\"string\""))))

Theorem: cst-keyword-conc40-matching

(defthm cst-keyword-conc40-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-conc41-matching

(defthm cst-keyword-conc41-matching
  (implies (cst-list-list-conc-matchp abnf::cstss "%s\"transition\"")
           (and (equal (len abnf::cstss) 1)
                (cst-list-rep-matchp (nth 0 abnf::cstss)
                                     "%s\"transition\""))))

Theorem: cst-keyword-conc42-matching

(defthm cst-keyword-conc42-matching
  (implies (cst-list-list-conc-matchp abnf::cstss "%s\"u8\"")
           (and (equal (len abnf::cstss) 1)
                (cst-list-rep-matchp (nth 0 abnf::cstss)
                                     "%s\"u8\""))))

Theorem: cst-keyword-conc43-matching

(defthm cst-keyword-conc43-matching
  (implies (cst-list-list-conc-matchp abnf::cstss "%s\"u16\"")
           (and (equal (len abnf::cstss) 1)
                (cst-list-rep-matchp (nth 0 abnf::cstss)
                                     "%s\"u16\""))))

Theorem: cst-keyword-conc44-matching

(defthm cst-keyword-conc44-matching
  (implies (cst-list-list-conc-matchp abnf::cstss "%s\"u32\"")
           (and (equal (len abnf::cstss) 1)
                (cst-list-rep-matchp (nth 0 abnf::cstss)
                                     "%s\"u32\""))))

Theorem: cst-keyword-conc45-matching

(defthm cst-keyword-conc45-matching
  (implies (cst-list-list-conc-matchp abnf::cstss "%s\"u64\"")
           (and (equal (len abnf::cstss) 1)
                (cst-list-rep-matchp (nth 0 abnf::cstss)
                                     "%s\"u64\""))))

Theorem: cst-keyword-conc46-matching

(defthm cst-keyword-conc46-matching
  (implies (cst-list-list-conc-matchp abnf::cstss "%s\"u128\"")
           (and (equal (len abnf::cstss) 1)
                (cst-list-rep-matchp (nth 0 abnf::cstss)
                                     "%s\"u128\""))))

Theorem: cst-uppercase-letter-conc-matching

(defthm cst-uppercase-letter-conc-matching
  (implies (cst-list-list-conc-matchp abnf::cstss "%x41-5A")
           (and (equal (len abnf::cstss) 1)
                (cst-list-rep-matchp (nth 0 abnf::cstss)
                                     "%x41-5A"))))

Theorem: cst-lowercase-letter-conc-matching

(defthm cst-lowercase-letter-conc-matching
  (implies (cst-list-list-conc-matchp abnf::cstss "%x61-7A")
           (and (equal (len abnf::cstss) 1)
                (cst-list-rep-matchp (nth 0 abnf::cstss)
                                     "%x61-7A"))))

Theorem: cst-letter-conc1-matching

(defthm cst-letter-conc1-matching
 (implies (cst-list-list-conc-matchp abnf::cstss "uppercase-letter")
          (and (equal (len abnf::cstss) 1)
               (cst-list-rep-matchp (nth 0 abnf::cstss)
                                    "uppercase-letter"))))

Theorem: cst-letter-conc2-matching

(defthm cst-letter-conc2-matching
 (implies (cst-list-list-conc-matchp abnf::cstss "lowercase-letter")
          (and (equal (len abnf::cstss) 1)
               (cst-list-rep-matchp (nth 0 abnf::cstss)
                                    "lowercase-letter"))))

Theorem: cst-binary-digit-conc-matching

(defthm cst-binary-digit-conc-matching
  (implies (cst-list-list-conc-matchp abnf::cstss "%x30-31")
           (and (equal (len abnf::cstss) 1)
                (cst-list-rep-matchp (nth 0 abnf::cstss)
                                     "%x30-31"))))

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-decimal-digit-conc-matching

(defthm cst-decimal-digit-conc-matching
  (implies (cst-list-list-conc-matchp abnf::cstss "%x30-39")
           (and (equal (len abnf::cstss) 1)
                (cst-list-rep-matchp (nth 0 abnf::cstss)
                                     "%x30-39"))))

Theorem: cst-nonzero-decimal-digit-conc-matching

(defthm cst-nonzero-decimal-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-hexadecimal-digit-conc1-matching

(defthm cst-hexadecimal-digit-conc1-matching
  (implies (cst-list-list-conc-matchp abnf::cstss "decimal-digit")
           (and (equal (len abnf::cstss) 1)
                (cst-list-rep-matchp (nth 0 abnf::cstss)
                                     "decimal-digit"))))

Theorem: cst-hexadecimal-digit-conc2-matching

(defthm cst-hexadecimal-digit-conc2-matching
  (implies (cst-list-list-conc-matchp abnf::cstss "%x41-46")
           (and (equal (len abnf::cstss) 1)
                (cst-list-rep-matchp (nth 0 abnf::cstss)
                                     "%x41-46"))))

Theorem: cst-decimal-numeral-conc-matching

(defthm cst-decimal-numeral-conc-matching
 (implies
  (cst-list-list-conc-matchp abnf::cstss "1*( decimal-digit *\"_\" )")
  (and (equal (len abnf::cstss) 1)
       (cst-list-rep-matchp (nth 0 abnf::cstss)
                            "1*( decimal-digit *\"_\" )"))))

Theorem: cst-numeral-conc1-matching

(defthm cst-numeral-conc1-matching
  (implies (cst-list-list-conc-matchp abnf::cstss "binary-numeral")
           (and (equal (len abnf::cstss) 1)
                (cst-list-rep-matchp (nth 0 abnf::cstss)
                                     "binary-numeral"))))

Theorem: cst-numeral-conc2-matching

(defthm cst-numeral-conc2-matching
  (implies (cst-list-list-conc-matchp abnf::cstss "octal-numeral")
           (and (equal (len abnf::cstss) 1)
                (cst-list-rep-matchp (nth 0 abnf::cstss)
                                     "octal-numeral"))))

Theorem: cst-numeral-conc3-matching

(defthm cst-numeral-conc3-matching
  (implies (cst-list-list-conc-matchp abnf::cstss "decimal-numeral")
           (and (equal (len abnf::cstss) 1)
                (cst-list-rep-matchp (nth 0 abnf::cstss)
                                     "decimal-numeral"))))

Theorem: cst-numeral-conc4-matching

(defthm cst-numeral-conc4-matching
  (implies
       (cst-list-list-conc-matchp abnf::cstss "hexadecimal-numeral")
       (and (equal (len abnf::cstss) 1)
            (cst-list-rep-matchp (nth 0 abnf::cstss)
                                 "hexadecimal-numeral"))))

Theorem: cst-tuple-index-conc1-matching

(defthm cst-tuple-index-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-integer-literal-conc1-matching

(defthm cst-integer-literal-conc1-matching
 (implies (cst-list-list-conc-matchp abnf::cstss "unsigned-literal")
          (and (equal (len abnf::cstss) 1)
               (cst-list-rep-matchp (nth 0 abnf::cstss)
                                    "unsigned-literal"))))

Theorem: cst-integer-literal-conc2-matching

(defthm cst-integer-literal-conc2-matching
  (implies (cst-list-list-conc-matchp abnf::cstss "signed-literal")
           (and (equal (len abnf::cstss) 1)
                (cst-list-rep-matchp (nth 0 abnf::cstss)
                                     "signed-literal"))))

Theorem: cst-numeric-literal-conc1-matching

(defthm cst-numeric-literal-conc1-matching
  (implies (cst-list-list-conc-matchp abnf::cstss "integer-literal")
           (and (equal (len abnf::cstss) 1)
                (cst-list-rep-matchp (nth 0 abnf::cstss)
                                     "integer-literal"))))

Theorem: cst-numeric-literal-conc2-matching

(defthm cst-numeric-literal-conc2-matching
  (implies (cst-list-list-conc-matchp abnf::cstss "field-literal")
           (and (equal (len abnf::cstss) 1)
                (cst-list-rep-matchp (nth 0 abnf::cstss)
                                     "field-literal"))))

Theorem: cst-numeric-literal-conc3-matching

(defthm cst-numeric-literal-conc3-matching
  (implies (cst-list-list-conc-matchp abnf::cstss "group-literal")
           (and (equal (len abnf::cstss) 1)
                (cst-list-rep-matchp (nth 0 abnf::cstss)
                                     "group-literal"))))

Theorem: cst-numeric-literal-conc4-matching

(defthm cst-numeric-literal-conc4-matching
  (implies (cst-list-list-conc-matchp abnf::cstss "scalar-literal")
           (and (equal (len abnf::cstss) 1)
                (cst-list-rep-matchp (nth 0 abnf::cstss)
                                     "scalar-literal"))))

Theorem: cst-boolean-literal-conc1-matching

(defthm cst-boolean-literal-conc1-matching
  (implies (cst-list-list-conc-matchp abnf::cstss "%s\"true\"")
           (and (equal (len abnf::cstss) 1)
                (cst-list-rep-matchp (nth 0 abnf::cstss)
                                     "%s\"true\""))))

Theorem: cst-boolean-literal-conc2-matching

(defthm cst-boolean-literal-conc2-matching
  (implies (cst-list-list-conc-matchp abnf::cstss "%s\"false\"")
           (and (equal (len abnf::cstss) 1)
                (cst-list-rep-matchp (nth 0 abnf::cstss)
                                     "%s\"false\""))))

Theorem: cst-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-string-character-conc1-matching

(defthm cst-string-character-conc1-matching
  (implies
       (cst-list-list-conc-matchp abnf::cstss
                                  "not-double-quote-or-line-feed")
       (and (equal (len abnf::cstss) 1)
            (cst-list-rep-matchp (nth 0 abnf::cstss)
                                 "not-double-quote-or-line-feed"))))

Theorem: cst-string-character-conc2-matching

(defthm cst-string-character-conc2-matching
  (implies (cst-list-list-conc-matchp abnf::cstss "line-terminator")
           (and (equal (len abnf::cstss) 1)
                (cst-list-rep-matchp (nth 0 abnf::cstss)
                                     "line-terminator"))))

Theorem: cst-not-double-quote-or-line-feed-conc1-matching

(defthm cst-not-double-quote-or-line-feed-conc1-matching
  (implies (cst-list-list-conc-matchp abnf::cstss "%x0-9")
           (and (equal (len abnf::cstss) 1)
                (cst-list-rep-matchp (nth 0 abnf::cstss)
                                     "%x0-9"))))

Theorem: cst-not-double-quote-or-line-feed-conc2-matching

(defthm cst-not-double-quote-or-line-feed-conc2-matching
  (implies (cst-list-list-conc-matchp abnf::cstss "%xB-21")
           (and (equal (len abnf::cstss) 1)
                (cst-list-rep-matchp (nth 0 abnf::cstss)
                                     "%xB-21"))))

Theorem: cst-not-double-quote-or-line-feed-conc3-matching

(defthm cst-not-double-quote-or-line-feed-conc3-matching
  (implies (cst-list-list-conc-matchp abnf::cstss "%x23-7F")
           (and (equal (len abnf::cstss) 1)
                (cst-list-rep-matchp (nth 0 abnf::cstss)
                                     "%x23-7F"))))

Theorem: cst-not-double-quote-or-line-feed-conc4-matching

(defthm cst-not-double-quote-or-line-feed-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-atomic-literal-conc1-matching

(defthm cst-atomic-literal-conc1-matching
  (implies (cst-list-list-conc-matchp abnf::cstss "numeric-literal")
           (and (equal (len abnf::cstss) 1)
                (cst-list-rep-matchp (nth 0 abnf::cstss)
                                     "numeric-literal"))))

Theorem: cst-atomic-literal-conc2-matching

(defthm cst-atomic-literal-conc2-matching
  (implies (cst-list-list-conc-matchp abnf::cstss "boolean-literal")
           (and (equal (len abnf::cstss) 1)
                (cst-list-rep-matchp (nth 0 abnf::cstss)
                                     "boolean-literal"))))

Theorem: cst-atomic-literal-conc3-matching

(defthm cst-atomic-literal-conc3-matching
 (implies
  (cst-list-list-conc-matchp abnf::cstss "explicit-address-literal")
  (and (equal (len abnf::cstss) 1)
       (cst-list-rep-matchp (nth 0 abnf::cstss)
                            "explicit-address-literal"))))

Theorem: cst-atomic-literal-conc4-matching

(defthm cst-atomic-literal-conc4-matching
  (implies (cst-list-list-conc-matchp abnf::cstss "string-literal")
           (and (equal (len abnf::cstss) 1)
                (cst-list-rep-matchp (nth 0 abnf::cstss)
                                     "string-literal"))))

Theorem: cst-symbol-conc1-matching

(defthm cst-symbol-conc1-matching
  (implies (cst-list-list-conc-matchp abnf::cstss "\"!\"")
           (and (equal (len abnf::cstss) 1)
                (cst-list-rep-matchp (nth 0 abnf::cstss)
                                     "\"!\""))))

Theorem: cst-symbol-conc2-matching

(defthm cst-symbol-conc2-matching
  (implies (cst-list-list-conc-matchp abnf::cstss "\"&&\"")
           (and (equal (len abnf::cstss) 1)
                (cst-list-rep-matchp (nth 0 abnf::cstss)
                                     "\"&&\""))))

Theorem: cst-symbol-conc3-matching

(defthm cst-symbol-conc3-matching
  (implies (cst-list-list-conc-matchp abnf::cstss "\"||\"")
           (and (equal (len abnf::cstss) 1)
                (cst-list-rep-matchp (nth 0 abnf::cstss)
                                     "\"||\""))))

Theorem: cst-symbol-conc4-matching

(defthm cst-symbol-conc4-matching
  (implies (cst-list-list-conc-matchp abnf::cstss "\"==\"")
           (and (equal (len abnf::cstss) 1)
                (cst-list-rep-matchp (nth 0 abnf::cstss)
                                     "\"==\""))))

Theorem: cst-symbol-conc5-matching

(defthm cst-symbol-conc5-matching
  (implies (cst-list-list-conc-matchp abnf::cstss "\"!=\"")
           (and (equal (len abnf::cstss) 1)
                (cst-list-rep-matchp (nth 0 abnf::cstss)
                                     "\"!=\""))))

Theorem: cst-symbol-conc6-matching

(defthm cst-symbol-conc6-matching
  (implies (cst-list-list-conc-matchp abnf::cstss "\"<\"")
           (and (equal (len abnf::cstss) 1)
                (cst-list-rep-matchp (nth 0 abnf::cstss)
                                     "\"<\""))))

Theorem: cst-symbol-conc7-matching

(defthm cst-symbol-conc7-matching
  (implies (cst-list-list-conc-matchp abnf::cstss "\"<=\"")
           (and (equal (len abnf::cstss) 1)
                (cst-list-rep-matchp (nth 0 abnf::cstss)
                                     "\"<=\""))))

Theorem: cst-symbol-conc8-matching

(defthm cst-symbol-conc8-matching
  (implies (cst-list-list-conc-matchp abnf::cstss "\">\"")
           (and (equal (len abnf::cstss) 1)
                (cst-list-rep-matchp (nth 0 abnf::cstss)
                                     "\">\""))))

Theorem: cst-symbol-conc9-matching

(defthm cst-symbol-conc9-matching
  (implies (cst-list-list-conc-matchp abnf::cstss "\">=\"")
           (and (equal (len abnf::cstss) 1)
                (cst-list-rep-matchp (nth 0 abnf::cstss)
                                     "\">=\""))))

Theorem: cst-symbol-conc10-matching

(defthm cst-symbol-conc10-matching
  (implies (cst-list-list-conc-matchp abnf::cstss "\"&\"")
           (and (equal (len abnf::cstss) 1)
                (cst-list-rep-matchp (nth 0 abnf::cstss)
                                     "\"&\""))))

Theorem: cst-symbol-conc11-matching

(defthm cst-symbol-conc11-matching
  (implies (cst-list-list-conc-matchp abnf::cstss "\"|\"")
           (and (equal (len abnf::cstss) 1)
                (cst-list-rep-matchp (nth 0 abnf::cstss)
                                     "\"|\""))))

Theorem: cst-symbol-conc12-matching

(defthm cst-symbol-conc12-matching
  (implies (cst-list-list-conc-matchp abnf::cstss "\"^\"")
           (and (equal (len abnf::cstss) 1)
                (cst-list-rep-matchp (nth 0 abnf::cstss)
                                     "\"^\""))))

Theorem: cst-symbol-conc13-matching

(defthm cst-symbol-conc13-matching
  (implies (cst-list-list-conc-matchp abnf::cstss "\"<<\"")
           (and (equal (len abnf::cstss) 1)
                (cst-list-rep-matchp (nth 0 abnf::cstss)
                                     "\"<<\""))))

Theorem: cst-symbol-conc14-matching

(defthm cst-symbol-conc14-matching
  (implies (cst-list-list-conc-matchp abnf::cstss "\">>\"")
           (and (equal (len abnf::cstss) 1)
                (cst-list-rep-matchp (nth 0 abnf::cstss)
                                     "\">>\""))))

Theorem: cst-symbol-conc15-matching

(defthm cst-symbol-conc15-matching
  (implies (cst-list-list-conc-matchp abnf::cstss "\"+\"")
           (and (equal (len abnf::cstss) 1)
                (cst-list-rep-matchp (nth 0 abnf::cstss)
                                     "\"+\""))))

Theorem: cst-symbol-conc16-matching

(defthm cst-symbol-conc16-matching
  (implies (cst-list-list-conc-matchp abnf::cstss "\"-\"")
           (and (equal (len abnf::cstss) 1)
                (cst-list-rep-matchp (nth 0 abnf::cstss)
                                     "\"-\""))))

Theorem: cst-symbol-conc17-matching

(defthm cst-symbol-conc17-matching
  (implies (cst-list-list-conc-matchp abnf::cstss "\"*\"")
           (and (equal (len abnf::cstss) 1)
                (cst-list-rep-matchp (nth 0 abnf::cstss)
                                     "\"*\""))))

Theorem: cst-symbol-conc18-matching

(defthm cst-symbol-conc18-matching
  (implies (cst-list-list-conc-matchp abnf::cstss "\"/\"")
           (and (equal (len abnf::cstss) 1)
                (cst-list-rep-matchp (nth 0 abnf::cstss)
                                     "\"/\""))))

Theorem: cst-symbol-conc19-matching

(defthm cst-symbol-conc19-matching
  (implies (cst-list-list-conc-matchp abnf::cstss "\"%\"")
           (and (equal (len abnf::cstss) 1)
                (cst-list-rep-matchp (nth 0 abnf::cstss)
                                     "\"%\""))))

Theorem: cst-symbol-conc20-matching

(defthm cst-symbol-conc20-matching
  (implies (cst-list-list-conc-matchp abnf::cstss "\"**\"")
           (and (equal (len abnf::cstss) 1)
                (cst-list-rep-matchp (nth 0 abnf::cstss)
                                     "\"**\""))))

Theorem: cst-symbol-conc21-matching

(defthm cst-symbol-conc21-matching
  (implies (cst-list-list-conc-matchp abnf::cstss "\"=\"")
           (and (equal (len abnf::cstss) 1)
                (cst-list-rep-matchp (nth 0 abnf::cstss)
                                     "\"=\""))))

Theorem: cst-symbol-conc22-matching

(defthm cst-symbol-conc22-matching
  (implies (cst-list-list-conc-matchp abnf::cstss "\"+=\"")
           (and (equal (len abnf::cstss) 1)
                (cst-list-rep-matchp (nth 0 abnf::cstss)
                                     "\"+=\""))))

Theorem: cst-symbol-conc23-matching

(defthm cst-symbol-conc23-matching
  (implies (cst-list-list-conc-matchp abnf::cstss "\"-=\"")
           (and (equal (len abnf::cstss) 1)
                (cst-list-rep-matchp (nth 0 abnf::cstss)
                                     "\"-=\""))))

Theorem: cst-symbol-conc24-matching

(defthm cst-symbol-conc24-matching
  (implies (cst-list-list-conc-matchp abnf::cstss "\"*=\"")
           (and (equal (len abnf::cstss) 1)
                (cst-list-rep-matchp (nth 0 abnf::cstss)
                                     "\"*=\""))))

Theorem: cst-symbol-conc25-matching

(defthm cst-symbol-conc25-matching
  (implies (cst-list-list-conc-matchp abnf::cstss "\"/=\"")
           (and (equal (len abnf::cstss) 1)
                (cst-list-rep-matchp (nth 0 abnf::cstss)
                                     "\"/=\""))))

Theorem: cst-symbol-conc26-matching

(defthm cst-symbol-conc26-matching
  (implies (cst-list-list-conc-matchp abnf::cstss "\"%=\"")
           (and (equal (len abnf::cstss) 1)
                (cst-list-rep-matchp (nth 0 abnf::cstss)
                                     "\"%=\""))))

Theorem: cst-symbol-conc27-matching

(defthm cst-symbol-conc27-matching
  (implies (cst-list-list-conc-matchp abnf::cstss "\"**=\"")
           (and (equal (len abnf::cstss) 1)
                (cst-list-rep-matchp (nth 0 abnf::cstss)
                                     "\"**=\""))))

Theorem: cst-symbol-conc28-matching

(defthm cst-symbol-conc28-matching
  (implies (cst-list-list-conc-matchp abnf::cstss "\"<<=\"")
           (and (equal (len abnf::cstss) 1)
                (cst-list-rep-matchp (nth 0 abnf::cstss)
                                     "\"<<=\""))))

Theorem: cst-symbol-conc29-matching

(defthm cst-symbol-conc29-matching
  (implies (cst-list-list-conc-matchp abnf::cstss "\">>=\"")
           (and (equal (len abnf::cstss) 1)
                (cst-list-rep-matchp (nth 0 abnf::cstss)
                                     "\">>=\""))))

Theorem: cst-symbol-conc30-matching

(defthm cst-symbol-conc30-matching
  (implies (cst-list-list-conc-matchp abnf::cstss "\"&=\"")
           (and (equal (len abnf::cstss) 1)
                (cst-list-rep-matchp (nth 0 abnf::cstss)
                                     "\"&=\""))))

Theorem: cst-symbol-conc31-matching

(defthm cst-symbol-conc31-matching
  (implies (cst-list-list-conc-matchp abnf::cstss "\"|=\"")
           (and (equal (len abnf::cstss) 1)
                (cst-list-rep-matchp (nth 0 abnf::cstss)
                                     "\"|=\""))))

Theorem: cst-symbol-conc32-matching

(defthm cst-symbol-conc32-matching
  (implies (cst-list-list-conc-matchp abnf::cstss "\"^=\"")
           (and (equal (len abnf::cstss) 1)
                (cst-list-rep-matchp (nth 0 abnf::cstss)
                                     "\"^=\""))))

Theorem: cst-symbol-conc33-matching

(defthm cst-symbol-conc33-matching
  (implies (cst-list-list-conc-matchp abnf::cstss "\"&&=\"")
           (and (equal (len abnf::cstss) 1)
                (cst-list-rep-matchp (nth 0 abnf::cstss)
                                     "\"&&=\""))))

Theorem: cst-symbol-conc34-matching

(defthm cst-symbol-conc34-matching
  (implies (cst-list-list-conc-matchp abnf::cstss "\"||=\"")
           (and (equal (len abnf::cstss) 1)
                (cst-list-rep-matchp (nth 0 abnf::cstss)
                                     "\"||=\""))))

Theorem: cst-symbol-conc35-matching

(defthm cst-symbol-conc35-matching
  (implies (cst-list-list-conc-matchp abnf::cstss "\"(\"")
           (and (equal (len abnf::cstss) 1)
                (cst-list-rep-matchp (nth 0 abnf::cstss)
                                     "\"(\""))))

Theorem: cst-symbol-conc36-matching

(defthm cst-symbol-conc36-matching
  (implies (cst-list-list-conc-matchp abnf::cstss "\")\"")
           (and (equal (len abnf::cstss) 1)
                (cst-list-rep-matchp (nth 0 abnf::cstss)
                                     "\")\""))))

Theorem: cst-symbol-conc37-matching

(defthm cst-symbol-conc37-matching
  (implies (cst-list-list-conc-matchp abnf::cstss "\"[\"")
           (and (equal (len abnf::cstss) 1)
                (cst-list-rep-matchp (nth 0 abnf::cstss)
                                     "\"[\""))))

Theorem: cst-symbol-conc38-matching

(defthm cst-symbol-conc38-matching
  (implies (cst-list-list-conc-matchp abnf::cstss "\"]\"")
           (and (equal (len abnf::cstss) 1)
                (cst-list-rep-matchp (nth 0 abnf::cstss)
                                     "\"]\""))))

Theorem: cst-symbol-conc39-matching

(defthm cst-symbol-conc39-matching
  (implies (cst-list-list-conc-matchp abnf::cstss "\"{\"")
           (and (equal (len abnf::cstss) 1)
                (cst-list-rep-matchp (nth 0 abnf::cstss)
                                     "\"{\""))))

Theorem: cst-symbol-conc40-matching

(defthm cst-symbol-conc40-matching
  (implies (cst-list-list-conc-matchp abnf::cstss "\"}\"")
           (and (equal (len abnf::cstss) 1)
                (cst-list-rep-matchp (nth 0 abnf::cstss)
                                     "\"}\""))))

Theorem: cst-symbol-conc41-matching

(defthm cst-symbol-conc41-matching
  (implies (cst-list-list-conc-matchp abnf::cstss "\",\"")
           (and (equal (len abnf::cstss) 1)
                (cst-list-rep-matchp (nth 0 abnf::cstss)
                                     "\",\""))))

Theorem: cst-symbol-conc42-matching

(defthm cst-symbol-conc42-matching
  (implies (cst-list-list-conc-matchp abnf::cstss "\".\"")
           (and (equal (len abnf::cstss) 1)
                (cst-list-rep-matchp (nth 0 abnf::cstss)
                                     "\".\""))))

Theorem: cst-symbol-conc43-matching

(defthm cst-symbol-conc43-matching
  (implies (cst-list-list-conc-matchp abnf::cstss "\"..\"")
           (and (equal (len abnf::cstss) 1)
                (cst-list-rep-matchp (nth 0 abnf::cstss)
                                     "\"..\""))))

Theorem: cst-symbol-conc44-matching

(defthm cst-symbol-conc44-matching
  (implies (cst-list-list-conc-matchp abnf::cstss "\";\"")
           (and (equal (len abnf::cstss) 1)
                (cst-list-rep-matchp (nth 0 abnf::cstss)
                                     "\";\""))))

Theorem: cst-symbol-conc45-matching

(defthm cst-symbol-conc45-matching
  (implies (cst-list-list-conc-matchp abnf::cstss "\":\"")
           (and (equal (len abnf::cstss) 1)
                (cst-list-rep-matchp (nth 0 abnf::cstss)
                                     "\":\""))))

Theorem: cst-symbol-conc46-matching

(defthm cst-symbol-conc46-matching
  (implies (cst-list-list-conc-matchp abnf::cstss "\"::\"")
           (and (equal (len abnf::cstss) 1)
                (cst-list-rep-matchp (nth 0 abnf::cstss)
                                     "\"::\""))))

Theorem: cst-symbol-conc47-matching

(defthm cst-symbol-conc47-matching
  (implies (cst-list-list-conc-matchp abnf::cstss "\"?\"")
           (and (equal (len abnf::cstss) 1)
                (cst-list-rep-matchp (nth 0 abnf::cstss)
                                     "\"?\""))))

Theorem: cst-symbol-conc48-matching

(defthm cst-symbol-conc48-matching
  (implies (cst-list-list-conc-matchp abnf::cstss "\"->\"")
           (and (equal (len abnf::cstss) 1)
                (cst-list-rep-matchp (nth 0 abnf::cstss)
                                     "\"->\""))))

Theorem: cst-symbol-conc49-matching

(defthm cst-symbol-conc49-matching
  (implies (cst-list-list-conc-matchp abnf::cstss "\"=>\"")
           (and (equal (len abnf::cstss) 1)
                (cst-list-rep-matchp (nth 0 abnf::cstss)
                                     "\"=>\""))))

Theorem: cst-token-conc1-matching

(defthm cst-token-conc1-matching
  (implies (cst-list-list-conc-matchp abnf::cstss "keyword")
           (and (equal (len abnf::cstss) 1)
                (cst-list-rep-matchp (nth 0 abnf::cstss)
                                     "keyword"))))

Theorem: cst-token-conc2-matching

(defthm cst-token-conc2-matching
  (implies (cst-list-list-conc-matchp abnf::cstss "identifier")
           (and (equal (len abnf::cstss) 1)
                (cst-list-rep-matchp (nth 0 abnf::cstss)
                                     "identifier"))))

Theorem: cst-token-conc3-matching

(defthm cst-token-conc3-matching
  (implies (cst-list-list-conc-matchp abnf::cstss "atomic-literal")
           (and (equal (len abnf::cstss) 1)
                (cst-list-rep-matchp (nth 0 abnf::cstss)
                                     "atomic-literal"))))

Theorem: cst-token-conc4-matching

(defthm cst-token-conc4-matching
  (implies (cst-list-list-conc-matchp abnf::cstss "decimal-numeral")
           (and (equal (len abnf::cstss) 1)
                (cst-list-rep-matchp (nth 0 abnf::cstss)
                                     "decimal-numeral"))))

Theorem: cst-token-conc5-matching

(defthm cst-token-conc5-matching
  (implies (cst-list-list-conc-matchp abnf::cstss "annotation")
           (and (equal (len abnf::cstss) 1)
                (cst-list-rep-matchp (nth 0 abnf::cstss)
                                     "annotation"))))

Theorem: cst-token-conc6-matching

(defthm cst-token-conc6-matching
  (implies (cst-list-list-conc-matchp abnf::cstss "symbol")
           (and (equal (len abnf::cstss) 1)
                (cst-list-rep-matchp (nth 0 abnf::cstss)
                                     "symbol"))))

Theorem: cst-lexeme-conc1-matching

(defthm cst-lexeme-conc1-matching
  (implies (cst-list-list-conc-matchp abnf::cstss "token")
           (and (equal (len abnf::cstss) 1)
                (cst-list-rep-matchp (nth 0 abnf::cstss)
                                     "token"))))

Theorem: cst-lexeme-conc2-matching

(defthm cst-lexeme-conc2-matching
  (implies (cst-list-list-conc-matchp abnf::cstss "comment")
           (and (equal (len abnf::cstss) 1)
                (cst-list-rep-matchp (nth 0 abnf::cstss)
                                     "comment"))))

Theorem: cst-lexeme-conc3-matching

(defthm cst-lexeme-conc3-matching
  (implies (cst-list-list-conc-matchp abnf::cstss "whitespace")
           (and (equal (len abnf::cstss) 1)
                (cst-list-rep-matchp (nth 0 abnf::cstss)
                                     "whitespace"))))

Theorem: cst-network-conc-matching

(defthm cst-network-conc-matching
  (implies (cst-list-list-conc-matchp abnf::cstss "%s\"aleo\"")
           (and (equal (len abnf::cstss) 1)
                (cst-list-rep-matchp (nth 0 abnf::cstss)
                                     "%s\"aleo\""))))

Theorem: cst-unsigned-type-conc1-matching

(defthm cst-unsigned-type-conc1-matching
  (implies (cst-list-list-conc-matchp abnf::cstss "%s\"u8\"")
           (and (equal (len abnf::cstss) 1)
                (cst-list-rep-matchp (nth 0 abnf::cstss)
                                     "%s\"u8\""))))

Theorem: cst-unsigned-type-conc2-matching

(defthm cst-unsigned-type-conc2-matching
  (implies (cst-list-list-conc-matchp abnf::cstss "%s\"u16\"")
           (and (equal (len abnf::cstss) 1)
                (cst-list-rep-matchp (nth 0 abnf::cstss)
                                     "%s\"u16\""))))

Theorem: cst-unsigned-type-conc3-matching

(defthm cst-unsigned-type-conc3-matching
  (implies (cst-list-list-conc-matchp abnf::cstss "%s\"u32\"")
           (and (equal (len abnf::cstss) 1)
                (cst-list-rep-matchp (nth 0 abnf::cstss)
                                     "%s\"u32\""))))

Theorem: cst-unsigned-type-conc4-matching

(defthm cst-unsigned-type-conc4-matching
  (implies (cst-list-list-conc-matchp abnf::cstss "%s\"u64\"")
           (and (equal (len abnf::cstss) 1)
                (cst-list-rep-matchp (nth 0 abnf::cstss)
                                     "%s\"u64\""))))

Theorem: cst-unsigned-type-conc5-matching

(defthm cst-unsigned-type-conc5-matching
  (implies (cst-list-list-conc-matchp abnf::cstss "%s\"u128\"")
           (and (equal (len abnf::cstss) 1)
                (cst-list-rep-matchp (nth 0 abnf::cstss)
                                     "%s\"u128\""))))

Theorem: cst-signed-type-conc1-matching

(defthm cst-signed-type-conc1-matching
  (implies (cst-list-list-conc-matchp abnf::cstss "%s\"i8\"")
           (and (equal (len abnf::cstss) 1)
                (cst-list-rep-matchp (nth 0 abnf::cstss)
                                     "%s\"i8\""))))

Theorem: cst-signed-type-conc2-matching

(defthm cst-signed-type-conc2-matching
  (implies (cst-list-list-conc-matchp abnf::cstss "%s\"i16\"")
           (and (equal (len abnf::cstss) 1)
                (cst-list-rep-matchp (nth 0 abnf::cstss)
                                     "%s\"i16\""))))

Theorem: cst-signed-type-conc3-matching

(defthm cst-signed-type-conc3-matching
  (implies (cst-list-list-conc-matchp abnf::cstss "%s\"i32\"")
           (and (equal (len abnf::cstss) 1)
                (cst-list-rep-matchp (nth 0 abnf::cstss)
                                     "%s\"i32\""))))

Theorem: cst-signed-type-conc4-matching

(defthm cst-signed-type-conc4-matching
  (implies (cst-list-list-conc-matchp abnf::cstss "%s\"i64\"")
           (and (equal (len abnf::cstss) 1)
                (cst-list-rep-matchp (nth 0 abnf::cstss)
                                     "%s\"i64\""))))

Theorem: cst-signed-type-conc5-matching

(defthm cst-signed-type-conc5-matching
  (implies (cst-list-list-conc-matchp abnf::cstss "%s\"i128\"")
           (and (equal (len abnf::cstss) 1)
                (cst-list-rep-matchp (nth 0 abnf::cstss)
                                     "%s\"i128\""))))

Theorem: cst-integer-type-conc1-matching

(defthm cst-integer-type-conc1-matching
  (implies (cst-list-list-conc-matchp abnf::cstss "unsigned-type")
           (and (equal (len abnf::cstss) 1)
                (cst-list-rep-matchp (nth 0 abnf::cstss)
                                     "unsigned-type"))))

Theorem: cst-integer-type-conc2-matching

(defthm cst-integer-type-conc2-matching
  (implies (cst-list-list-conc-matchp abnf::cstss "signed-type")
           (and (equal (len abnf::cstss) 1)
                (cst-list-rep-matchp (nth 0 abnf::cstss)
                                     "signed-type"))))

Theorem: cst-field-type-conc-matching

(defthm cst-field-type-conc-matching
  (implies (cst-list-list-conc-matchp abnf::cstss "%s\"field\"")
           (and (equal (len abnf::cstss) 1)
                (cst-list-rep-matchp (nth 0 abnf::cstss)
                                     "%s\"field\""))))

Theorem: cst-group-type-conc-matching

(defthm cst-group-type-conc-matching
  (implies (cst-list-list-conc-matchp abnf::cstss "%s\"group\"")
           (and (equal (len abnf::cstss) 1)
                (cst-list-rep-matchp (nth 0 abnf::cstss)
                                     "%s\"group\""))))

Theorem: cst-scalar-type-conc-matching

(defthm cst-scalar-type-conc-matching
  (implies (cst-list-list-conc-matchp abnf::cstss "%s\"scalar\"")
           (and (equal (len abnf::cstss) 1)
                (cst-list-rep-matchp (nth 0 abnf::cstss)
                                     "%s\"scalar\""))))

Theorem: cst-arithmetic-type-conc1-matching

(defthm cst-arithmetic-type-conc1-matching
  (implies (cst-list-list-conc-matchp abnf::cstss "integer-type")
           (and (equal (len abnf::cstss) 1)
                (cst-list-rep-matchp (nth 0 abnf::cstss)
                                     "integer-type"))))

Theorem: cst-arithmetic-type-conc2-matching

(defthm cst-arithmetic-type-conc2-matching
  (implies (cst-list-list-conc-matchp abnf::cstss "field-type")
           (and (equal (len abnf::cstss) 1)
                (cst-list-rep-matchp (nth 0 abnf::cstss)
                                     "field-type"))))

Theorem: cst-arithmetic-type-conc3-matching

(defthm cst-arithmetic-type-conc3-matching
  (implies (cst-list-list-conc-matchp abnf::cstss "group-type")
           (and (equal (len abnf::cstss) 1)
                (cst-list-rep-matchp (nth 0 abnf::cstss)
                                     "group-type"))))

Theorem: cst-arithmetic-type-conc4-matching

(defthm cst-arithmetic-type-conc4-matching
  (implies (cst-list-list-conc-matchp abnf::cstss "scalar-type")
           (and (equal (len abnf::cstss) 1)
                (cst-list-rep-matchp (nth 0 abnf::cstss)
                                     "scalar-type"))))

Theorem: cst-boolean-type-conc-matching

(defthm cst-boolean-type-conc-matching
  (implies (cst-list-list-conc-matchp abnf::cstss "%s\"bool\"")
           (and (equal (len abnf::cstss) 1)
                (cst-list-rep-matchp (nth 0 abnf::cstss)
                                     "%s\"bool\""))))

Theorem: cst-address-type-conc-matching

(defthm cst-address-type-conc-matching
  (implies (cst-list-list-conc-matchp abnf::cstss "%s\"address\"")
           (and (equal (len abnf::cstss) 1)
                (cst-list-rep-matchp (nth 0 abnf::cstss)
                                     "%s\"address\""))))

Theorem: cst-signature-type-conc-matching

(defthm cst-signature-type-conc-matching
  (implies (cst-list-list-conc-matchp abnf::cstss "%s\"signature\"")
           (and (equal (len abnf::cstss) 1)
                (cst-list-rep-matchp (nth 0 abnf::cstss)
                                     "%s\"signature\""))))

Theorem: cst-string-type-conc-matching

(defthm cst-string-type-conc-matching
  (implies (cst-list-list-conc-matchp abnf::cstss "%s\"string\"")
           (and (equal (len abnf::cstss) 1)
                (cst-list-rep-matchp (nth 0 abnf::cstss)
                                     "%s\"string\""))))

Theorem: cst-named-primitive-type-conc1-matching

(defthm cst-named-primitive-type-conc1-matching
  (implies (cst-list-list-conc-matchp abnf::cstss "boolean-type")
           (and (equal (len abnf::cstss) 1)
                (cst-list-rep-matchp (nth 0 abnf::cstss)
                                     "boolean-type"))))

Theorem: cst-named-primitive-type-conc2-matching

(defthm cst-named-primitive-type-conc2-matching
  (implies (cst-list-list-conc-matchp abnf::cstss "arithmetic-type")
           (and (equal (len abnf::cstss) 1)
                (cst-list-rep-matchp (nth 0 abnf::cstss)
                                     "arithmetic-type"))))

Theorem: cst-named-primitive-type-conc3-matching

(defthm cst-named-primitive-type-conc3-matching
  (implies (cst-list-list-conc-matchp abnf::cstss "address-type")
           (and (equal (len abnf::cstss) 1)
                (cst-list-rep-matchp (nth 0 abnf::cstss)
                                     "address-type"))))

Theorem: cst-named-primitive-type-conc4-matching

(defthm cst-named-primitive-type-conc4-matching
  (implies (cst-list-list-conc-matchp abnf::cstss "signature-type")
           (and (equal (len abnf::cstss) 1)
                (cst-list-rep-matchp (nth 0 abnf::cstss)
                                     "signature-type"))))

Theorem: cst-named-primitive-type-conc5-matching

(defthm cst-named-primitive-type-conc5-matching
  (implies (cst-list-list-conc-matchp abnf::cstss "string-type")
           (and (equal (len abnf::cstss) 1)
                (cst-list-rep-matchp (nth 0 abnf::cstss)
                                     "string-type"))))

Theorem: cst-primitive-type-conc1-matching

(defthm cst-primitive-type-conc1-matching
 (implies
      (cst-list-list-conc-matchp abnf::cstss "named-primitive-type")
      (and (equal (len abnf::cstss) 1)
           (cst-list-rep-matchp (nth 0 abnf::cstss)
                                "named-primitive-type"))))

Theorem: cst-primitive-type-conc2-matching

(defthm cst-primitive-type-conc2-matching
  (implies (cst-list-list-conc-matchp abnf::cstss "unit-type")
           (and (equal (len abnf::cstss) 1)
                (cst-list-rep-matchp (nth 0 abnf::cstss)
                                     "unit-type"))))

Theorem: cst-untyped-future-type-conc-matching

(defthm cst-untyped-future-type-conc-matching
  (implies (cst-list-list-conc-matchp abnf::cstss "%s\"Future\"")
           (and (equal (len abnf::cstss) 1)
                (cst-list-rep-matchp (nth 0 abnf::cstss)
                                     "%s\"Future\""))))

Theorem: cst-future-type-conc1-matching

(defthm cst-future-type-conc1-matching
  (implies
       (cst-list-list-conc-matchp abnf::cstss "untyped-future-type")
       (and (equal (len abnf::cstss) 1)
            (cst-list-rep-matchp (nth 0 abnf::cstss)
                                 "untyped-future-type"))))

Theorem: cst-future-type-conc2-matching

(defthm cst-future-type-conc2-matching
  (implies
       (cst-list-list-conc-matchp abnf::cstss "typed-future-type")
       (and (equal (len abnf::cstss) 1)
            (cst-list-rep-matchp (nth 0 abnf::cstss)
                                 "typed-future-type"))))

Theorem: cst-type-conc1-matching

(defthm cst-type-conc1-matching
  (implies (cst-list-list-conc-matchp abnf::cstss "primitive-type")
           (and (equal (len abnf::cstss) 1)
                (cst-list-rep-matchp (nth 0 abnf::cstss)
                                     "primitive-type"))))

Theorem: cst-type-conc2-matching

(defthm cst-type-conc2-matching
  (implies (cst-list-list-conc-matchp abnf::cstss "future-type")
           (and (equal (len abnf::cstss) 1)
                (cst-list-rep-matchp (nth 0 abnf::cstss)
                                     "future-type"))))

Theorem: cst-type-conc3-matching

(defthm cst-type-conc3-matching
  (implies (cst-list-list-conc-matchp abnf::cstss "tuple-type")
           (and (equal (len abnf::cstss) 1)
                (cst-list-rep-matchp (nth 0 abnf::cstss)
                                     "tuple-type"))))

Theorem: cst-type-conc4-matching

(defthm cst-type-conc4-matching
  (implies (cst-list-list-conc-matchp abnf::cstss "array-type")
           (and (equal (len abnf::cstss) 1)
                (cst-list-rep-matchp (nth 0 abnf::cstss)
                                     "array-type"))))

Theorem: cst-named-type-conc1-matching

(defthm cst-named-type-conc1-matching
 (implies
      (cst-list-list-conc-matchp abnf::cstss "named-primitive-type")
      (and (equal (len abnf::cstss) 1)
           (cst-list-rep-matchp (nth 0 abnf::cstss)
                                "named-primitive-type"))))

Theorem: cst-named-type-conc2-matching

(defthm cst-named-type-conc2-matching
  (implies
       (cst-list-list-conc-matchp abnf::cstss "untyped-future-type")
       (and (equal (len abnf::cstss) 1)
            (cst-list-rep-matchp (nth 0 abnf::cstss)
                                 "untyped-future-type"))))

Theorem: cst-named-type-conc3-matching

(defthm cst-named-type-conc3-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-program-address-literal-conc-matching

(defthm cst-program-address-literal-conc-matching
  (implies (cst-list-list-conc-matchp abnf::cstss "program-id")
           (and (equal (len abnf::cstss) 1)
                (cst-list-rep-matchp (nth 0 abnf::cstss)
                                     "program-id"))))

Theorem: cst-literal-conc1-matching

(defthm cst-literal-conc1-matching
  (implies (cst-list-list-conc-matchp abnf::cstss "atomic-literal")
           (and (equal (len abnf::cstss) 1)
                (cst-list-rep-matchp (nth 0 abnf::cstss)
                                     "atomic-literal"))))

Theorem: cst-literal-conc2-matching

(defthm cst-literal-conc2-matching
 (implies
   (cst-list-list-conc-matchp abnf::cstss "program-address-literal")
   (and (equal (len abnf::cstss) 1)
        (cst-list-rep-matchp (nth 0 abnf::cstss)
                             "program-address-literal"))))

Theorem: cst-address-literal-conc1-matching

(defthm cst-address-literal-conc1-matching
 (implies
  (cst-list-list-conc-matchp abnf::cstss "explicit-address-literal")
  (and (equal (len abnf::cstss) 1)
       (cst-list-rep-matchp (nth 0 abnf::cstss)
                            "explicit-address-literal"))))

Theorem: cst-address-literal-conc2-matching

(defthm cst-address-literal-conc2-matching
 (implies
   (cst-list-list-conc-matchp abnf::cstss "program-address-literal")
   (and (equal (len abnf::cstss) 1)
        (cst-list-rep-matchp (nth 0 abnf::cstss)
                             "program-address-literal"))))

Theorem: cst-primary-expression-conc1-matching

(defthm cst-primary-expression-conc1-matching
  (implies (cst-list-list-conc-matchp abnf::cstss "literal")
           (and (equal (len abnf::cstss) 1)
                (cst-list-rep-matchp (nth 0 abnf::cstss)
                                     "literal"))))

Theorem: cst-primary-expression-conc2-matching

(defthm cst-primary-expression-conc2-matching
  (implies (cst-list-list-conc-matchp abnf::cstss "variable")
           (and (equal (len abnf::cstss) 1)
                (cst-list-rep-matchp (nth 0 abnf::cstss)
                                     "variable"))))

Theorem: cst-primary-expression-conc3-matching

(defthm cst-primary-expression-conc3-matching
  (implies (cst-list-list-conc-matchp abnf::cstss "locator")
           (and (equal (len abnf::cstss) 1)
                (cst-list-rep-matchp (nth 0 abnf::cstss)
                                     "locator"))))

Theorem: cst-primary-expression-conc4-matching

(defthm cst-primary-expression-conc4-matching
  (implies
       (cst-list-list-conc-matchp abnf::cstss "associated-constant")
       (and (equal (len abnf::cstss) 1)
            (cst-list-rep-matchp (nth 0 abnf::cstss)
                                 "associated-constant"))))

Theorem: cst-primary-expression-conc6-matching

(defthm cst-primary-expression-conc6-matching
  (implies
       (cst-list-list-conc-matchp abnf::cstss "free-function-call")
       (and (equal (len abnf::cstss) 1)
            (cst-list-rep-matchp (nth 0 abnf::cstss)
                                 "free-function-call"))))

Theorem: cst-primary-expression-conc7-matching

(defthm cst-primary-expression-conc7-matching
 (implies
  (cst-list-list-conc-matchp abnf::cstss "associated-function-call")
  (and (equal (len abnf::cstss) 1)
       (cst-list-rep-matchp (nth 0 abnf::cstss)
                            "associated-function-call"))))

Theorem: cst-primary-expression-conc8-matching

(defthm cst-primary-expression-conc8-matching
  (implies (cst-list-list-conc-matchp abnf::cstss "unit-expression")
           (and (equal (len abnf::cstss) 1)
                (cst-list-rep-matchp (nth 0 abnf::cstss)
                                     "unit-expression"))))

Theorem: cst-primary-expression-conc9-matching

(defthm cst-primary-expression-conc9-matching
 (implies (cst-list-list-conc-matchp abnf::cstss "tuple-expression")
          (and (equal (len abnf::cstss) 1)
               (cst-list-rep-matchp (nth 0 abnf::cstss)
                                    "tuple-expression"))))

Theorem: cst-primary-expression-conc10-matching

(defthm cst-primary-expression-conc10-matching
 (implies (cst-list-list-conc-matchp abnf::cstss "array-expression")
          (and (equal (len abnf::cstss) 1)
               (cst-list-rep-matchp (nth 0 abnf::cstss)
                                    "array-expression"))))

Theorem: cst-primary-expression-conc11-matching

(defthm cst-primary-expression-conc11-matching
  (implies
       (cst-list-list-conc-matchp abnf::cstss "struct-expression")
       (and (equal (len abnf::cstss) 1)
            (cst-list-rep-matchp (nth 0 abnf::cstss)
                                 "struct-expression"))))

Theorem: cst-primary-expression-conc12-matching

(defthm cst-primary-expression-conc12-matching
  (implies (cst-list-list-conc-matchp abnf::cstss "self-expression")
           (and (equal (len abnf::cstss) 1)
                (cst-list-rep-matchp (nth 0 abnf::cstss)
                                     "self-expression"))))

Theorem: cst-primary-expression-conc13-matching

(defthm cst-primary-expression-conc13-matching
 (implies (cst-list-list-conc-matchp abnf::cstss "block-expression")
          (and (equal (len abnf::cstss) 1)
               (cst-list-rep-matchp (nth 0 abnf::cstss)
                                    "block-expression"))))

Theorem: cst-primary-expression-conc14-matching

(defthm cst-primary-expression-conc14-matching
  (implies
       (cst-list-list-conc-matchp abnf::cstss "network-expression")
       (and (equal (len abnf::cstss) 1)
            (cst-list-rep-matchp (nth 0 abnf::cstss)
                                 "network-expression"))))

Theorem: cst-variable-conc-matching

(defthm cst-variable-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-postfix-expression-conc1-matching

(defthm cst-postfix-expression-conc1-matching
  (implies
       (cst-list-list-conc-matchp abnf::cstss "primary-expression")
       (and (equal (len abnf::cstss) 1)
            (cst-list-rep-matchp (nth 0 abnf::cstss)
                                 "primary-expression"))))

Theorem: cst-postfix-expression-conc2-matching

(defthm cst-postfix-expression-conc2-matching
 (implies (cst-list-list-conc-matchp abnf::cstss
                                     "tuple-component-expression")
          (and (equal (len abnf::cstss) 1)
               (cst-list-rep-matchp (nth 0 abnf::cstss)
                                    "tuple-component-expression"))))

Theorem: cst-postfix-expression-conc3-matching

(defthm cst-postfix-expression-conc3-matching
 (implies (cst-list-list-conc-matchp abnf::cstss
                                     "array-component-expression")
          (and (equal (len abnf::cstss) 1)
               (cst-list-rep-matchp (nth 0 abnf::cstss)
                                    "array-component-expression"))))

Theorem: cst-postfix-expression-conc4-matching

(defthm cst-postfix-expression-conc4-matching
  (implies
       (cst-list-list-conc-matchp abnf::cstss
                                  "struct-component-expression")
       (and (equal (len abnf::cstss) 1)
            (cst-list-rep-matchp (nth 0 abnf::cstss)
                                 "struct-component-expression"))))

Theorem: cst-postfix-expression-conc5-matching

(defthm cst-postfix-expression-conc5-matching
  (implies (cst-list-list-conc-matchp abnf::cstss "method-call")
           (and (equal (len abnf::cstss) 1)
                (cst-list-rep-matchp (nth 0 abnf::cstss)
                                     "method-call"))))

Theorem: cst-unary-expression-conc1-matching

(defthm cst-unary-expression-conc1-matching
  (implies
       (cst-list-list-conc-matchp abnf::cstss "postfix-expression")
       (and (equal (len abnf::cstss) 1)
            (cst-list-rep-matchp (nth 0 abnf::cstss)
                                 "postfix-expression"))))

Theorem: cst-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-exponential-expression-conc1-matching

(defthm cst-exponential-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-multiplicative-expression-conc1-matching

(defthm cst-multiplicative-expression-conc1-matching
 (implies
    (cst-list-list-conc-matchp abnf::cstss "exponential-expression")
    (and (equal (len abnf::cstss) 1)
         (cst-list-rep-matchp (nth 0 abnf::cstss)
                              "exponential-expression"))))

Theorem: cst-additive-expression-conc1-matching

(defthm cst-additive-expression-conc1-matching
  (implies (cst-list-list-conc-matchp
                abnf::cstss "multiplicative-expression")
           (and (equal (len abnf::cstss) 1)
                (cst-list-rep-matchp (nth 0 abnf::cstss)
                                     "multiplicative-expression"))))

Theorem: cst-shift-expression-conc1-matching

(defthm cst-shift-expression-conc1-matching
  (implies
       (cst-list-list-conc-matchp abnf::cstss "additive-expression")
       (and (equal (len abnf::cstss) 1)
            (cst-list-rep-matchp (nth 0 abnf::cstss)
                                 "additive-expression"))))

Theorem: cst-conjunctive-expression-conc1-matching

(defthm cst-conjunctive-expression-conc1-matching
 (implies (cst-list-list-conc-matchp abnf::cstss "shift-expression")
          (and (equal (len abnf::cstss) 1)
               (cst-list-rep-matchp (nth 0 abnf::cstss)
                                    "shift-expression"))))

Theorem: cst-inclusive-disjunctive-expression-conc1-matching

(defthm cst-inclusive-disjunctive-expression-conc1-matching
 (implies
    (cst-list-list-conc-matchp abnf::cstss "conjunctive-expression")
    (and (equal (len abnf::cstss) 1)
         (cst-list-rep-matchp (nth 0 abnf::cstss)
                              "conjunctive-expression"))))

Theorem: cst-exclusive-disjunctive-expression-conc1-matching

(defthm cst-exclusive-disjunctive-expression-conc1-matching
 (implies
    (cst-list-list-conc-matchp abnf::cstss
                               "inclusive-disjunctive-expression")
    (and (equal (len abnf::cstss) 1)
         (cst-list-rep-matchp (nth 0 abnf::cstss)
                              "inclusive-disjunctive-expression"))))

Theorem: cst-ordering-expression-conc1-matching

(defthm cst-ordering-expression-conc1-matching
 (implies
    (cst-list-list-conc-matchp abnf::cstss
                               "exclusive-disjunctive-expression")
    (and (equal (len abnf::cstss) 1)
         (cst-list-rep-matchp (nth 0 abnf::cstss)
                              "exclusive-disjunctive-expression"))))

Theorem: cst-equality-expression-conc1-matching

(defthm cst-equality-expression-conc1-matching
  (implies
       (cst-list-list-conc-matchp abnf::cstss "ordering-expression")
       (and (equal (len abnf::cstss) 1)
            (cst-list-rep-matchp (nth 0 abnf::cstss)
                                 "ordering-expression"))))

Theorem: cst-conditional-conjunctive-expression-conc1-matching

(defthm cst-conditional-conjunctive-expression-conc1-matching
  (implies
       (cst-list-list-conc-matchp abnf::cstss "equality-expression")
       (and (equal (len abnf::cstss) 1)
            (cst-list-rep-matchp (nth 0 abnf::cstss)
                                 "equality-expression"))))

Theorem: cst-conditional-disjunctive-expression-conc1-matching

(defthm cst-conditional-disjunctive-expression-conc1-matching
 (implies
  (cst-list-list-conc-matchp abnf::cstss
                             "conditional-conjunctive-expression")
  (and (equal (len abnf::cstss) 1)
       (cst-list-rep-matchp (nth 0 abnf::cstss)
                            "conditional-conjunctive-expression"))))

Theorem: cst-binary-expression-conc-matching

(defthm cst-binary-expression-conc-matching
 (implies
  (cst-list-list-conc-matchp abnf::cstss
                             "conditional-disjunctive-expression")
  (and (equal (len abnf::cstss) 1)
       (cst-list-rep-matchp (nth 0 abnf::cstss)
                            "conditional-disjunctive-expression"))))

Theorem: cst-conditional-ternary-expression-conc1-matching

(defthm cst-conditional-ternary-expression-conc1-matching
  (implies
       (cst-list-list-conc-matchp abnf::cstss "binary-expression")
       (and (equal (len abnf::cstss) 1)
            (cst-list-rep-matchp (nth 0 abnf::cstss)
                                 "binary-expression"))))

Theorem: cst-expression-conc-matching

(defthm cst-expression-conc-matching
 (implies
      (cst-list-list-conc-matchp abnf::cstss
                                 "conditional-ternary-expression")
      (and (equal (len abnf::cstss) 1)
           (cst-list-rep-matchp (nth 0 abnf::cstss)
                                "conditional-ternary-expression"))))

Theorem: cst-statement-conc1-matching

(defthm cst-statement-conc1-matching
 (implies
      (cst-list-list-conc-matchp abnf::cstss "expression-statement")
      (and (equal (len abnf::cstss) 1)
           (cst-list-rep-matchp (nth 0 abnf::cstss)
                                "expression-statement"))))

Theorem: cst-statement-conc2-matching

(defthm cst-statement-conc2-matching
 (implies (cst-list-list-conc-matchp abnf::cstss "return-statement")
          (and (equal (len abnf::cstss) 1)
               (cst-list-rep-matchp (nth 0 abnf::cstss)
                                    "return-statement"))))

Theorem: cst-statement-conc3-matching

(defthm cst-statement-conc3-matching
 (implies
      (cst-list-list-conc-matchp abnf::cstss "variable-declaration")
      (and (equal (len abnf::cstss) 1)
           (cst-list-rep-matchp (nth 0 abnf::cstss)
                                "variable-declaration"))))

Theorem: cst-statement-conc4-matching

(defthm cst-statement-conc4-matching
 (implies
      (cst-list-list-conc-matchp abnf::cstss "constant-declaration")
      (and (equal (len abnf::cstss) 1)
           (cst-list-rep-matchp (nth 0 abnf::cstss)
                                "constant-declaration"))))

Theorem: cst-statement-conc5-matching

(defthm cst-statement-conc5-matching
 (implies
     (cst-list-list-conc-matchp abnf::cstss "conditional-statement")
     (and (equal (len abnf::cstss) 1)
          (cst-list-rep-matchp (nth 0 abnf::cstss)
                               "conditional-statement"))))

Theorem: cst-statement-conc6-matching

(defthm cst-statement-conc6-matching
  (implies (cst-list-list-conc-matchp abnf::cstss "loop-statement")
           (and (equal (len abnf::cstss) 1)
                (cst-list-rep-matchp (nth 0 abnf::cstss)
                                     "loop-statement"))))

Theorem: cst-statement-conc7-matching

(defthm cst-statement-conc7-matching
 (implies
      (cst-list-list-conc-matchp abnf::cstss "assignment-statement")
      (and (equal (len abnf::cstss) 1)
           (cst-list-rep-matchp (nth 0 abnf::cstss)
                                "assignment-statement"))))

Theorem: cst-statement-conc8-matching

(defthm cst-statement-conc8-matching
  (implies (cst-list-list-conc-matchp abnf::cstss "block")
           (and (equal (len abnf::cstss) 1)
                (cst-list-rep-matchp (nth 0 abnf::cstss)
                                     "block"))))

Theorem: cst-identifier-or-identifiers-conc1-matching

(defthm cst-identifier-or-identifiers-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-conditional-statement-conc1-matching

(defthm cst-conditional-statement-conc1-matching
  (implies (cst-list-list-conc-matchp abnf::cstss "branch")
           (and (equal (len abnf::cstss) 1)
                (cst-list-rep-matchp (nth 0 abnf::cstss)
                                     "branch"))))

Theorem: cst-assignment-operator-conc1-matching

(defthm cst-assignment-operator-conc1-matching
  (implies (cst-list-list-conc-matchp abnf::cstss "\"=\"")
           (and (equal (len abnf::cstss) 1)
                (cst-list-rep-matchp (nth 0 abnf::cstss)
                                     "\"=\""))))

Theorem: cst-assignment-operator-conc2-matching

(defthm cst-assignment-operator-conc2-matching
  (implies (cst-list-list-conc-matchp abnf::cstss "\"+=\"")
           (and (equal (len abnf::cstss) 1)
                (cst-list-rep-matchp (nth 0 abnf::cstss)
                                     "\"+=\""))))

Theorem: cst-assignment-operator-conc3-matching

(defthm cst-assignment-operator-conc3-matching
  (implies (cst-list-list-conc-matchp abnf::cstss "\"-=\"")
           (and (equal (len abnf::cstss) 1)
                (cst-list-rep-matchp (nth 0 abnf::cstss)
                                     "\"-=\""))))

Theorem: cst-assignment-operator-conc4-matching

(defthm cst-assignment-operator-conc4-matching
  (implies (cst-list-list-conc-matchp abnf::cstss "\"*=\"")
           (and (equal (len abnf::cstss) 1)
                (cst-list-rep-matchp (nth 0 abnf::cstss)
                                     "\"*=\""))))

Theorem: cst-assignment-operator-conc5-matching

(defthm cst-assignment-operator-conc5-matching
  (implies (cst-list-list-conc-matchp abnf::cstss "\"/=\"")
           (and (equal (len abnf::cstss) 1)
                (cst-list-rep-matchp (nth 0 abnf::cstss)
                                     "\"/=\""))))

Theorem: cst-assignment-operator-conc6-matching

(defthm cst-assignment-operator-conc6-matching
  (implies (cst-list-list-conc-matchp abnf::cstss "\"%=\"")
           (and (equal (len abnf::cstss) 1)
                (cst-list-rep-matchp (nth 0 abnf::cstss)
                                     "\"%=\""))))

Theorem: cst-assignment-operator-conc7-matching

(defthm cst-assignment-operator-conc7-matching
  (implies (cst-list-list-conc-matchp abnf::cstss "\"**=\"")
           (and (equal (len abnf::cstss) 1)
                (cst-list-rep-matchp (nth 0 abnf::cstss)
                                     "\"**=\""))))

Theorem: cst-assignment-operator-conc8-matching

(defthm cst-assignment-operator-conc8-matching
  (implies (cst-list-list-conc-matchp abnf::cstss "\"<<=\"")
           (and (equal (len abnf::cstss) 1)
                (cst-list-rep-matchp (nth 0 abnf::cstss)
                                     "\"<<=\""))))

Theorem: cst-assignment-operator-conc9-matching

(defthm cst-assignment-operator-conc9-matching
  (implies (cst-list-list-conc-matchp abnf::cstss "\">>=\"")
           (and (equal (len abnf::cstss) 1)
                (cst-list-rep-matchp (nth 0 abnf::cstss)
                                     "\">>=\""))))

Theorem: cst-assignment-operator-conc10-matching

(defthm cst-assignment-operator-conc10-matching
  (implies (cst-list-list-conc-matchp abnf::cstss "\"&=\"")
           (and (equal (len abnf::cstss) 1)
                (cst-list-rep-matchp (nth 0 abnf::cstss)
                                     "\"&=\""))))

Theorem: cst-assignment-operator-conc11-matching

(defthm cst-assignment-operator-conc11-matching
  (implies (cst-list-list-conc-matchp abnf::cstss "\"|=\"")
           (and (equal (len abnf::cstss) 1)
                (cst-list-rep-matchp (nth 0 abnf::cstss)
                                     "\"|=\""))))

Theorem: cst-assignment-operator-conc12-matching

(defthm cst-assignment-operator-conc12-matching
  (implies (cst-list-list-conc-matchp abnf::cstss "\"^=\"")
           (and (equal (len abnf::cstss) 1)
                (cst-list-rep-matchp (nth 0 abnf::cstss)
                                     "\"^=\""))))

Theorem: cst-assignment-operator-conc13-matching

(defthm cst-assignment-operator-conc13-matching
  (implies (cst-list-list-conc-matchp abnf::cstss "\"&&=\"")
           (and (equal (len abnf::cstss) 1)
                (cst-list-rep-matchp (nth 0 abnf::cstss)
                                     "\"&&=\""))))

Theorem: cst-assignment-operator-conc14-matching

(defthm cst-assignment-operator-conc14-matching
  (implies (cst-list-list-conc-matchp abnf::cstss "\"||=\"")
           (and (equal (len abnf::cstss) 1)
                (cst-list-rep-matchp (nth 0 abnf::cstss)
                                     "\"||=\""))))

Theorem: cst-function-kind-conc1-matching

(defthm cst-function-kind-conc1-matching
  (implies (cst-list-list-conc-matchp abnf::cstss "%s\"function\"")
           (and (equal (len abnf::cstss) 1)
                (cst-list-rep-matchp (nth 0 abnf::cstss)
                                     "%s\"function\""))))

Theorem: cst-function-kind-conc2-matching

(defthm cst-function-kind-conc2-matching
  (implies (cst-list-list-conc-matchp abnf::cstss "%s\"transition\"")
           (and (equal (len abnf::cstss) 1)
                (cst-list-rep-matchp (nth 0 abnf::cstss)
                                     "%s\"transition\""))))

Theorem: cst-function-kind-conc3-matching

(defthm cst-function-kind-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-function-outputs-conc1-matching

(defthm cst-function-outputs-conc1-matching
  (implies (cst-list-list-conc-matchp abnf::cstss "function-output")
           (and (equal (len abnf::cstss) 1)
                (cst-list-rep-matchp (nth 0 abnf::cstss)
                                     "function-output"))))

Theorem: cst-program-item-conc1-matching

(defthm cst-program-item-conc1-matching
 (implies
      (cst-list-list-conc-matchp abnf::cstss "function-declaration")
      (and (equal (len abnf::cstss) 1)
           (cst-list-rep-matchp (nth 0 abnf::cstss)
                                "function-declaration"))))

Theorem: cst-program-item-conc2-matching

(defthm cst-program-item-conc2-matching
  (implies
       (cst-list-list-conc-matchp abnf::cstss "struct-declaration")
       (and (equal (len abnf::cstss) 1)
            (cst-list-rep-matchp (nth 0 abnf::cstss)
                                 "struct-declaration"))))

Theorem: cst-program-item-conc3-matching

(defthm cst-program-item-conc3-matching
  (implies
       (cst-list-list-conc-matchp abnf::cstss "record-declaration")
       (and (equal (len abnf::cstss) 1)
            (cst-list-rep-matchp (nth 0 abnf::cstss)
                                 "record-declaration"))))

Theorem: cst-program-item-conc4-matching

(defthm cst-program-item-conc4-matching
  (implies
       (cst-list-list-conc-matchp abnf::cstss "mapping-declaration")
       (and (equal (len abnf::cstss) 1)
            (cst-list-rep-matchp (nth 0 abnf::cstss)
                                 "mapping-declaration"))))

Theorem: cst-program-item-conc5-matching

(defthm cst-program-item-conc5-matching
 (implies
      (cst-list-list-conc-matchp abnf::cstss "constant-declaration")
      (and (equal (len abnf::cstss) 1)
           (cst-list-rep-matchp (nth 0 abnf::cstss)
                                "constant-declaration"))))

Theorem: cst-ascii-conc-rep-matching

(defthm cst-ascii-conc-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "%x0-7F")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "%x0-7F"))))

Theorem: cst-safe-nonascii-conc1-rep-matching

(defthm cst-safe-nonascii-conc1-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "%x80-2029")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "%x80-2029"))))

Theorem: cst-safe-nonascii-conc2-rep-matching

(defthm cst-safe-nonascii-conc2-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "%x202F-2065")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "%x202F-2065"))))

Theorem: cst-safe-nonascii-conc3-rep-matching

(defthm cst-safe-nonascii-conc3-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "%x206A-D7FF")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "%x206A-D7FF"))))

Theorem: cst-safe-nonascii-conc4-rep-matching

(defthm cst-safe-nonascii-conc4-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "%xE000-10FFFF")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "%xE000-10FFFF"))))

Theorem: cst-character-conc1-rep-matching

(defthm cst-character-conc1-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "ascii")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "ascii"))))

Theorem: cst-character-conc2-rep-matching

(defthm cst-character-conc2-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "safe-nonascii")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "safe-nonascii"))))

Theorem: cst-line-terminator-conc1-rep-matching

(defthm cst-line-terminator-conc1-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "line-feed")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "line-feed"))))

Theorem: cst-line-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-whitespace-conc1-rep-matching

(defthm cst-whitespace-conc1-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "space")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "space"))))

Theorem: cst-whitespace-conc2-rep-matching

(defthm cst-whitespace-conc2-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "horizontal-tab")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "horizontal-tab"))))

Theorem: cst-whitespace-conc3-rep-matching

(defthm cst-whitespace-conc3-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "form-feed")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "form-feed"))))

Theorem: cst-whitespace-conc4-rep-matching

(defthm cst-whitespace-conc4-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "line-terminator")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "line-terminator"))))

Theorem: cst-whitespace-conc5-rep-matching

(defthm cst-whitespace-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-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-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-comment-conc1-rep-matching

(defthm cst-comment-conc1-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "block-comment")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "block-comment"))))

Theorem: cst-comment-conc2-rep-matching

(defthm cst-comment-conc2-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "line-comment")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "line-comment"))))

Theorem: cst-rest-of-block-comment-after-star-conc1-rep-matching

(defthm cst-rest-of-block-comment-after-star-conc1-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "\"/\"")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts) "\"/\""))))

Theorem: cst-not-star-or-line-feed-conc1-rep-matching

(defthm cst-not-star-or-line-feed-conc1-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "%x0-9")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "%x0-9"))))

Theorem: cst-not-star-or-line-feed-conc2-rep-matching

(defthm cst-not-star-or-line-feed-conc2-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "%xB-29")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "%xB-29"))))

Theorem: cst-not-star-or-line-feed-conc3-rep-matching

(defthm cst-not-star-or-line-feed-conc3-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "%x2B-7E")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "%x2B-7E"))))

Theorem: cst-not-star-or-line-feed-conc4-rep-matching

(defthm cst-not-star-or-line-feed-conc4-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "safe-nonascii")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "safe-nonascii"))))

Theorem: cst-not-star-or-slash-or-line-feed-conc1-rep-matching

(defthm cst-not-star-or-slash-or-line-feed-conc1-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "%x0-9")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "%x0-9"))))

Theorem: cst-not-star-or-slash-or-line-feed-conc2-rep-matching

(defthm cst-not-star-or-slash-or-line-feed-conc2-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "%xB-29")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "%xB-29"))))

Theorem: cst-not-star-or-slash-or-line-feed-conc3-rep-matching

(defthm cst-not-star-or-slash-or-line-feed-conc3-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "%x2B-2E")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "%x2B-2E"))))

Theorem: cst-not-star-or-slash-or-line-feed-conc4-rep-matching

(defthm cst-not-star-or-slash-or-line-feed-conc4-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "%x30-7E")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "%x30-7E"))))

Theorem: cst-not-star-or-slash-or-line-feed-conc5-rep-matching

(defthm cst-not-star-or-slash-or-line-feed-conc5-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "safe-nonascii")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "safe-nonascii"))))

Theorem: cst-not-line-feed-conc1-rep-matching

(defthm cst-not-line-feed-conc1-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "%x0-9")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "%x0-9"))))

Theorem: cst-not-line-feed-conc2-rep-matching

(defthm cst-not-line-feed-conc2-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "%xB-7F")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "%xB-7F"))))

Theorem: cst-not-line-feed-conc3-rep-matching

(defthm cst-not-line-feed-conc3-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "safe-nonascii")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "safe-nonascii"))))

Theorem: cst-keyword-conc1-rep-matching

(defthm cst-keyword-conc1-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "%s\"address\"")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "%s\"address\""))))

Theorem: cst-keyword-conc2-rep-matching

(defthm cst-keyword-conc2-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "%s\"aleo\"")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "%s\"aleo\""))))

Theorem: cst-keyword-conc3-rep-matching

(defthm cst-keyword-conc3-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "%s\"as\"")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "%s\"as\""))))

Theorem: cst-keyword-conc4-rep-matching

(defthm cst-keyword-conc4-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "%s\"assert\"")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "%s\"assert\""))))

Theorem: cst-keyword-conc5-rep-matching

(defthm cst-keyword-conc5-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "%s\"assert_eq\"")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "%s\"assert_eq\""))))

Theorem: cst-keyword-conc6-rep-matching

(defthm cst-keyword-conc6-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "%s\"assert_neq\"")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "%s\"assert_neq\""))))

Theorem: cst-keyword-conc7-rep-matching

(defthm cst-keyword-conc7-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "%s\"async\"")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "%s\"async\""))))

Theorem: cst-keyword-conc8-rep-matching

(defthm cst-keyword-conc8-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "%s\"block\"")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "%s\"block\""))))

Theorem: cst-keyword-conc9-rep-matching

(defthm cst-keyword-conc9-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-conc10-rep-matching

(defthm cst-keyword-conc10-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-conc11-rep-matching

(defthm cst-keyword-conc11-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "%s\"constant\"")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "%s\"constant\""))))

Theorem: cst-keyword-conc12-rep-matching

(defthm cst-keyword-conc12-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-conc13-rep-matching

(defthm cst-keyword-conc13-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "%s\"field\"")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "%s\"field\""))))

Theorem: cst-keyword-conc14-rep-matching

(defthm cst-keyword-conc14-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "%s\"Fn\"")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "%s\"Fn\""))))

Theorem: cst-keyword-conc15-rep-matching

(defthm cst-keyword-conc15-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-conc16-rep-matching

(defthm cst-keyword-conc16-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "%s\"function\"")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "%s\"function\""))))

Theorem: cst-keyword-conc17-rep-matching

(defthm cst-keyword-conc17-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "%s\"Future\"")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "%s\"Future\""))))

Theorem: cst-keyword-conc18-rep-matching

(defthm cst-keyword-conc18-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "%s\"group\"")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "%s\"group\""))))

Theorem: cst-keyword-conc19-rep-matching

(defthm cst-keyword-conc19-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "%s\"i8\"")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "%s\"i8\""))))

Theorem: cst-keyword-conc20-rep-matching

(defthm cst-keyword-conc20-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "%s\"i16\"")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "%s\"i16\""))))

Theorem: cst-keyword-conc21-rep-matching

(defthm cst-keyword-conc21-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "%s\"i32\"")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "%s\"i32\""))))

Theorem: cst-keyword-conc22-rep-matching

(defthm cst-keyword-conc22-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "%s\"i64\"")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "%s\"i64\""))))

Theorem: cst-keyword-conc23-rep-matching

(defthm cst-keyword-conc23-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "%s\"i128\"")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "%s\"i128\""))))

Theorem: cst-keyword-conc24-rep-matching

(defthm cst-keyword-conc24-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-conc25-rep-matching

(defthm cst-keyword-conc25-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "%s\"import\"")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "%s\"import\""))))

Theorem: cst-keyword-conc26-rep-matching

(defthm cst-keyword-conc26-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "%s\"in\"")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "%s\"in\""))))

Theorem: cst-keyword-conc27-rep-matching

(defthm cst-keyword-conc27-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-conc28-rep-matching

(defthm cst-keyword-conc28-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "%s\"let\"")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "%s\"let\""))))

Theorem: cst-keyword-conc29-rep-matching

(defthm cst-keyword-conc29-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "%s\"mapping\"")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "%s\"mapping\""))))

Theorem: cst-keyword-conc30-rep-matching

(defthm cst-keyword-conc30-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "%s\"network\"")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "%s\"network\""))))

Theorem: cst-keyword-conc31-rep-matching

(defthm cst-keyword-conc31-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "%s\"private\"")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "%s\"private\""))))

Theorem: cst-keyword-conc32-rep-matching

(defthm cst-keyword-conc32-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "%s\"program\"")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "%s\"program\""))))

Theorem: cst-keyword-conc33-rep-matching

(defthm cst-keyword-conc33-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "%s\"public\"")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "%s\"public\""))))

Theorem: cst-keyword-conc34-rep-matching

(defthm cst-keyword-conc34-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "%s\"record\"")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "%s\"record\""))))

Theorem: cst-keyword-conc35-rep-matching

(defthm cst-keyword-conc35-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-conc36-rep-matching

(defthm cst-keyword-conc36-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "%s\"scalar\"")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "%s\"scalar\""))))

Theorem: cst-keyword-conc37-rep-matching

(defthm cst-keyword-conc37-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "%s\"self\"")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "%s\"self\""))))

Theorem: cst-keyword-conc38-rep-matching

(defthm cst-keyword-conc38-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "%s\"signature\"")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "%s\"signature\""))))

Theorem: cst-keyword-conc39-rep-matching

(defthm cst-keyword-conc39-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "%s\"string\"")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "%s\"string\""))))

Theorem: cst-keyword-conc40-rep-matching

(defthm cst-keyword-conc40-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-conc41-rep-matching

(defthm cst-keyword-conc41-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "%s\"transition\"")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "%s\"transition\""))))

Theorem: cst-keyword-conc42-rep-matching

(defthm cst-keyword-conc42-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "%s\"u8\"")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "%s\"u8\""))))

Theorem: cst-keyword-conc43-rep-matching

(defthm cst-keyword-conc43-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "%s\"u16\"")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "%s\"u16\""))))

Theorem: cst-keyword-conc44-rep-matching

(defthm cst-keyword-conc44-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "%s\"u32\"")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "%s\"u32\""))))

Theorem: cst-keyword-conc45-rep-matching

(defthm cst-keyword-conc45-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "%s\"u64\"")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "%s\"u64\""))))

Theorem: cst-keyword-conc46-rep-matching

(defthm cst-keyword-conc46-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "%s\"u128\"")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "%s\"u128\""))))

Theorem: cst-uppercase-letter-conc-rep-matching

(defthm cst-uppercase-letter-conc-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "%x41-5A")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "%x41-5A"))))

Theorem: cst-lowercase-letter-conc-rep-matching

(defthm cst-lowercase-letter-conc-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "%x61-7A")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "%x61-7A"))))

Theorem: cst-letter-conc1-rep-matching

(defthm cst-letter-conc1-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "uppercase-letter")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "uppercase-letter"))))

Theorem: cst-letter-conc2-rep-matching

(defthm cst-letter-conc2-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "lowercase-letter")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "lowercase-letter"))))

Theorem: cst-binary-digit-conc-rep-matching

(defthm cst-binary-digit-conc-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "%x30-31")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "%x30-31"))))

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-decimal-digit-conc-rep-matching

(defthm cst-decimal-digit-conc-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "%x30-39")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "%x30-39"))))

Theorem: cst-nonzero-decimal-digit-conc-rep-matching

(defthm cst-nonzero-decimal-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-hexadecimal-digit-conc1-rep-matching

(defthm cst-hexadecimal-digit-conc1-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "decimal-digit")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "decimal-digit"))))

Theorem: cst-hexadecimal-digit-conc2-rep-matching

(defthm cst-hexadecimal-digit-conc2-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "%x41-46")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "%x41-46"))))

Theorem: cst-numeral-conc1-rep-matching

(defthm cst-numeral-conc1-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "binary-numeral")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "binary-numeral"))))

Theorem: cst-numeral-conc2-rep-matching

(defthm cst-numeral-conc2-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "octal-numeral")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "octal-numeral"))))

Theorem: cst-numeral-conc3-rep-matching

(defthm cst-numeral-conc3-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "decimal-numeral")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "decimal-numeral"))))

Theorem: cst-numeral-conc4-rep-matching

(defthm cst-numeral-conc4-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "hexadecimal-numeral")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "hexadecimal-numeral"))))

Theorem: cst-tuple-index-conc1-rep-matching

(defthm cst-tuple-index-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-integer-literal-conc1-rep-matching

(defthm cst-integer-literal-conc1-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "unsigned-literal")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "unsigned-literal"))))

Theorem: cst-integer-literal-conc2-rep-matching

(defthm cst-integer-literal-conc2-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "signed-literal")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "signed-literal"))))

Theorem: cst-numeric-literal-conc1-rep-matching

(defthm cst-numeric-literal-conc1-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "integer-literal")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "integer-literal"))))

Theorem: cst-numeric-literal-conc2-rep-matching

(defthm cst-numeric-literal-conc2-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "field-literal")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "field-literal"))))

Theorem: cst-numeric-literal-conc3-rep-matching

(defthm cst-numeric-literal-conc3-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "group-literal")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "group-literal"))))

Theorem: cst-numeric-literal-conc4-rep-matching

(defthm cst-numeric-literal-conc4-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "scalar-literal")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "scalar-literal"))))

Theorem: cst-boolean-literal-conc1-rep-matching

(defthm cst-boolean-literal-conc1-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "%s\"true\"")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "%s\"true\""))))

Theorem: cst-boolean-literal-conc2-rep-matching

(defthm cst-boolean-literal-conc2-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "%s\"false\"")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "%s\"false\""))))

Theorem: cst-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-string-character-conc1-rep-matching

(defthm cst-string-character-conc1-rep-matching
  (implies (cst-list-rep-matchp abnf::csts
                                "not-double-quote-or-line-feed")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "not-double-quote-or-line-feed"))))

Theorem: cst-string-character-conc2-rep-matching

(defthm cst-string-character-conc2-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "line-terminator")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "line-terminator"))))

Theorem: cst-not-double-quote-or-line-feed-conc1-rep-matching

(defthm cst-not-double-quote-or-line-feed-conc1-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "%x0-9")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "%x0-9"))))

Theorem: cst-not-double-quote-or-line-feed-conc2-rep-matching

(defthm cst-not-double-quote-or-line-feed-conc2-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "%xB-21")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "%xB-21"))))

Theorem: cst-not-double-quote-or-line-feed-conc3-rep-matching

(defthm cst-not-double-quote-or-line-feed-conc3-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "%x23-7F")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "%x23-7F"))))

Theorem: cst-not-double-quote-or-line-feed-conc4-rep-matching

(defthm cst-not-double-quote-or-line-feed-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-atomic-literal-conc1-rep-matching

(defthm cst-atomic-literal-conc1-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "numeric-literal")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "numeric-literal"))))

Theorem: cst-atomic-literal-conc2-rep-matching

(defthm cst-atomic-literal-conc2-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "boolean-literal")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "boolean-literal"))))

Theorem: cst-atomic-literal-conc3-rep-matching

(defthm cst-atomic-literal-conc3-rep-matching
  (implies
       (cst-list-rep-matchp abnf::csts "explicit-address-literal")
       (and (equal (len abnf::csts) 1)
            (cst-matchp (nth 0 abnf::csts)
                        "explicit-address-literal"))))

Theorem: cst-atomic-literal-conc4-rep-matching

(defthm cst-atomic-literal-conc4-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "string-literal")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "string-literal"))))

Theorem: cst-symbol-conc1-rep-matching

(defthm cst-symbol-conc1-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "\"!\"")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts) "\"!\""))))

Theorem: cst-symbol-conc2-rep-matching

(defthm cst-symbol-conc2-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "\"&&\"")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "\"&&\""))))

Theorem: cst-symbol-conc3-rep-matching

(defthm cst-symbol-conc3-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "\"||\"")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "\"||\""))))

Theorem: cst-symbol-conc4-rep-matching

(defthm cst-symbol-conc4-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "\"==\"")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "\"==\""))))

Theorem: cst-symbol-conc5-rep-matching

(defthm cst-symbol-conc5-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "\"!=\"")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "\"!=\""))))

Theorem: cst-symbol-conc6-rep-matching

(defthm cst-symbol-conc6-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "\"<\"")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts) "\"<\""))))

Theorem: cst-symbol-conc7-rep-matching

(defthm cst-symbol-conc7-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "\"<=\"")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "\"<=\""))))

Theorem: cst-symbol-conc8-rep-matching

(defthm cst-symbol-conc8-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "\">\"")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts) "\">\""))))

Theorem: cst-symbol-conc9-rep-matching

(defthm cst-symbol-conc9-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "\">=\"")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "\">=\""))))

Theorem: cst-symbol-conc10-rep-matching

(defthm cst-symbol-conc10-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "\"&\"")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts) "\"&\""))))

Theorem: cst-symbol-conc11-rep-matching

(defthm cst-symbol-conc11-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "\"|\"")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts) "\"|\""))))

Theorem: cst-symbol-conc12-rep-matching

(defthm cst-symbol-conc12-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "\"^\"")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts) "\"^\""))))

Theorem: cst-symbol-conc13-rep-matching

(defthm cst-symbol-conc13-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "\"<<\"")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "\"<<\""))))

Theorem: cst-symbol-conc14-rep-matching

(defthm cst-symbol-conc14-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "\">>\"")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "\">>\""))))

Theorem: cst-symbol-conc15-rep-matching

(defthm cst-symbol-conc15-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "\"+\"")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts) "\"+\""))))

Theorem: cst-symbol-conc16-rep-matching

(defthm cst-symbol-conc16-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "\"-\"")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts) "\"-\""))))

Theorem: cst-symbol-conc17-rep-matching

(defthm cst-symbol-conc17-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "\"*\"")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts) "\"*\""))))

Theorem: cst-symbol-conc18-rep-matching

(defthm cst-symbol-conc18-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "\"/\"")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts) "\"/\""))))

Theorem: cst-symbol-conc19-rep-matching

(defthm cst-symbol-conc19-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "\"%\"")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts) "\"%\""))))

Theorem: cst-symbol-conc20-rep-matching

(defthm cst-symbol-conc20-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "\"**\"")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "\"**\""))))

Theorem: cst-symbol-conc21-rep-matching

(defthm cst-symbol-conc21-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "\"=\"")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts) "\"=\""))))

Theorem: cst-symbol-conc22-rep-matching

(defthm cst-symbol-conc22-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "\"+=\"")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "\"+=\""))))

Theorem: cst-symbol-conc23-rep-matching

(defthm cst-symbol-conc23-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "\"-=\"")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "\"-=\""))))

Theorem: cst-symbol-conc24-rep-matching

(defthm cst-symbol-conc24-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "\"*=\"")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "\"*=\""))))

Theorem: cst-symbol-conc25-rep-matching

(defthm cst-symbol-conc25-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "\"/=\"")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "\"/=\""))))

Theorem: cst-symbol-conc26-rep-matching

(defthm cst-symbol-conc26-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "\"%=\"")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "\"%=\""))))

Theorem: cst-symbol-conc27-rep-matching

(defthm cst-symbol-conc27-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "\"**=\"")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "\"**=\""))))

Theorem: cst-symbol-conc28-rep-matching

(defthm cst-symbol-conc28-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "\"<<=\"")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "\"<<=\""))))

Theorem: cst-symbol-conc29-rep-matching

(defthm cst-symbol-conc29-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "\">>=\"")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "\">>=\""))))

Theorem: cst-symbol-conc30-rep-matching

(defthm cst-symbol-conc30-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "\"&=\"")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "\"&=\""))))

Theorem: cst-symbol-conc31-rep-matching

(defthm cst-symbol-conc31-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "\"|=\"")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "\"|=\""))))

Theorem: cst-symbol-conc32-rep-matching

(defthm cst-symbol-conc32-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "\"^=\"")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "\"^=\""))))

Theorem: cst-symbol-conc33-rep-matching

(defthm cst-symbol-conc33-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "\"&&=\"")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "\"&&=\""))))

Theorem: cst-symbol-conc34-rep-matching

(defthm cst-symbol-conc34-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "\"||=\"")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "\"||=\""))))

Theorem: cst-symbol-conc35-rep-matching

(defthm cst-symbol-conc35-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "\"(\"")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts) "\"(\""))))

Theorem: cst-symbol-conc36-rep-matching

(defthm cst-symbol-conc36-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "\")\"")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts) "\")\""))))

Theorem: cst-symbol-conc37-rep-matching

(defthm cst-symbol-conc37-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "\"[\"")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts) "\"[\""))))

Theorem: cst-symbol-conc38-rep-matching

(defthm cst-symbol-conc38-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "\"]\"")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts) "\"]\""))))

Theorem: cst-symbol-conc39-rep-matching

(defthm cst-symbol-conc39-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "\"{\"")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts) "\"{\""))))

Theorem: cst-symbol-conc40-rep-matching

(defthm cst-symbol-conc40-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "\"}\"")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts) "\"}\""))))

Theorem: cst-symbol-conc41-rep-matching

(defthm cst-symbol-conc41-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "\",\"")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts) "\",\""))))

Theorem: cst-symbol-conc42-rep-matching

(defthm cst-symbol-conc42-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "\".\"")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts) "\".\""))))

Theorem: cst-symbol-conc43-rep-matching

(defthm cst-symbol-conc43-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "\"..\"")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "\"..\""))))

Theorem: cst-symbol-conc44-rep-matching

(defthm cst-symbol-conc44-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "\";\"")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts) "\";\""))))

Theorem: cst-symbol-conc45-rep-matching

(defthm cst-symbol-conc45-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "\":\"")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts) "\":\""))))

Theorem: cst-symbol-conc46-rep-matching

(defthm cst-symbol-conc46-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "\"::\"")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "\"::\""))))

Theorem: cst-symbol-conc47-rep-matching

(defthm cst-symbol-conc47-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "\"?\"")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts) "\"?\""))))

Theorem: cst-symbol-conc48-rep-matching

(defthm cst-symbol-conc48-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "\"->\"")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "\"->\""))))

Theorem: cst-symbol-conc49-rep-matching

(defthm cst-symbol-conc49-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "\"=>\"")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "\"=>\""))))

Theorem: cst-token-conc1-rep-matching

(defthm cst-token-conc1-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "keyword")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "keyword"))))

Theorem: cst-token-conc2-rep-matching

(defthm cst-token-conc2-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "identifier")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "identifier"))))

Theorem: cst-token-conc3-rep-matching

(defthm cst-token-conc3-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "atomic-literal")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "atomic-literal"))))

Theorem: cst-token-conc4-rep-matching

(defthm cst-token-conc4-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "decimal-numeral")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "decimal-numeral"))))

Theorem: cst-token-conc5-rep-matching

(defthm cst-token-conc5-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "annotation")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "annotation"))))

Theorem: cst-token-conc6-rep-matching

(defthm cst-token-conc6-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "symbol")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "symbol"))))

Theorem: cst-lexeme-conc1-rep-matching

(defthm cst-lexeme-conc1-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "token")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "token"))))

Theorem: cst-lexeme-conc2-rep-matching

(defthm cst-lexeme-conc2-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "comment")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "comment"))))

Theorem: cst-lexeme-conc3-rep-matching

(defthm cst-lexeme-conc3-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "whitespace")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "whitespace"))))

Theorem: cst-network-conc-rep-matching

(defthm cst-network-conc-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "%s\"aleo\"")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "%s\"aleo\""))))

Theorem: cst-unsigned-type-conc1-rep-matching

(defthm cst-unsigned-type-conc1-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "%s\"u8\"")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "%s\"u8\""))))

Theorem: cst-unsigned-type-conc2-rep-matching

(defthm cst-unsigned-type-conc2-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "%s\"u16\"")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "%s\"u16\""))))

Theorem: cst-unsigned-type-conc3-rep-matching

(defthm cst-unsigned-type-conc3-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "%s\"u32\"")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "%s\"u32\""))))

Theorem: cst-unsigned-type-conc4-rep-matching

(defthm cst-unsigned-type-conc4-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "%s\"u64\"")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "%s\"u64\""))))

Theorem: cst-unsigned-type-conc5-rep-matching

(defthm cst-unsigned-type-conc5-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "%s\"u128\"")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "%s\"u128\""))))

Theorem: cst-signed-type-conc1-rep-matching

(defthm cst-signed-type-conc1-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "%s\"i8\"")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "%s\"i8\""))))

Theorem: cst-signed-type-conc2-rep-matching

(defthm cst-signed-type-conc2-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "%s\"i16\"")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "%s\"i16\""))))

Theorem: cst-signed-type-conc3-rep-matching

(defthm cst-signed-type-conc3-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "%s\"i32\"")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "%s\"i32\""))))

Theorem: cst-signed-type-conc4-rep-matching

(defthm cst-signed-type-conc4-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "%s\"i64\"")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "%s\"i64\""))))

Theorem: cst-signed-type-conc5-rep-matching

(defthm cst-signed-type-conc5-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "%s\"i128\"")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "%s\"i128\""))))

Theorem: cst-integer-type-conc1-rep-matching

(defthm cst-integer-type-conc1-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "unsigned-type")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "unsigned-type"))))

Theorem: cst-integer-type-conc2-rep-matching

(defthm cst-integer-type-conc2-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "signed-type")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "signed-type"))))

Theorem: cst-field-type-conc-rep-matching

(defthm cst-field-type-conc-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "%s\"field\"")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "%s\"field\""))))

Theorem: cst-group-type-conc-rep-matching

(defthm cst-group-type-conc-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "%s\"group\"")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "%s\"group\""))))

Theorem: cst-scalar-type-conc-rep-matching

(defthm cst-scalar-type-conc-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "%s\"scalar\"")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "%s\"scalar\""))))

Theorem: cst-arithmetic-type-conc1-rep-matching

(defthm cst-arithmetic-type-conc1-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "integer-type")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "integer-type"))))

Theorem: cst-arithmetic-type-conc2-rep-matching

(defthm cst-arithmetic-type-conc2-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "field-type")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "field-type"))))

Theorem: cst-arithmetic-type-conc3-rep-matching

(defthm cst-arithmetic-type-conc3-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "group-type")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "group-type"))))

Theorem: cst-arithmetic-type-conc4-rep-matching

(defthm cst-arithmetic-type-conc4-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "scalar-type")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "scalar-type"))))

Theorem: cst-boolean-type-conc-rep-matching

(defthm cst-boolean-type-conc-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "%s\"bool\"")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "%s\"bool\""))))

Theorem: cst-address-type-conc-rep-matching

(defthm cst-address-type-conc-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "%s\"address\"")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "%s\"address\""))))

Theorem: cst-signature-type-conc-rep-matching

(defthm cst-signature-type-conc-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "%s\"signature\"")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "%s\"signature\""))))

Theorem: cst-string-type-conc-rep-matching

(defthm cst-string-type-conc-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "%s\"string\"")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "%s\"string\""))))

Theorem: cst-named-primitive-type-conc1-rep-matching

(defthm cst-named-primitive-type-conc1-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "boolean-type")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "boolean-type"))))

Theorem: cst-named-primitive-type-conc2-rep-matching

(defthm cst-named-primitive-type-conc2-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "arithmetic-type")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "arithmetic-type"))))

Theorem: cst-named-primitive-type-conc3-rep-matching

(defthm cst-named-primitive-type-conc3-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "address-type")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "address-type"))))

Theorem: cst-named-primitive-type-conc4-rep-matching

(defthm cst-named-primitive-type-conc4-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "signature-type")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "signature-type"))))

Theorem: cst-named-primitive-type-conc5-rep-matching

(defthm cst-named-primitive-type-conc5-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "string-type")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "string-type"))))

Theorem: cst-primitive-type-conc1-rep-matching

(defthm cst-primitive-type-conc1-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "named-primitive-type")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "named-primitive-type"))))

Theorem: cst-primitive-type-conc2-rep-matching

(defthm cst-primitive-type-conc2-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "unit-type")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "unit-type"))))

Theorem: cst-untyped-future-type-conc-rep-matching

(defthm cst-untyped-future-type-conc-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "%s\"Future\"")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "%s\"Future\""))))

Theorem: cst-future-type-conc1-rep-matching

(defthm cst-future-type-conc1-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "untyped-future-type")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "untyped-future-type"))))

Theorem: cst-future-type-conc2-rep-matching

(defthm cst-future-type-conc2-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "typed-future-type")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "typed-future-type"))))

Theorem: cst-type-conc1-rep-matching

(defthm cst-type-conc1-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "primitive-type")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "primitive-type"))))

Theorem: cst-type-conc2-rep-matching

(defthm cst-type-conc2-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "future-type")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "future-type"))))

Theorem: cst-type-conc3-rep-matching

(defthm cst-type-conc3-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "tuple-type")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "tuple-type"))))

Theorem: cst-type-conc4-rep-matching

(defthm cst-type-conc4-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "array-type")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "array-type"))))

Theorem: cst-named-type-conc1-rep-matching

(defthm cst-named-type-conc1-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "named-primitive-type")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "named-primitive-type"))))

Theorem: cst-named-type-conc2-rep-matching

(defthm cst-named-type-conc2-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "untyped-future-type")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "untyped-future-type"))))

Theorem: cst-named-type-conc3-rep-matching

(defthm cst-named-type-conc3-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-program-address-literal-conc-rep-matching

(defthm cst-program-address-literal-conc-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "program-id")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "program-id"))))

Theorem: cst-literal-conc1-rep-matching

(defthm cst-literal-conc1-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "atomic-literal")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "atomic-literal"))))

Theorem: cst-literal-conc2-rep-matching

(defthm cst-literal-conc2-rep-matching
 (implies (cst-list-rep-matchp abnf::csts "program-address-literal")
          (and (equal (len abnf::csts) 1)
               (cst-matchp (nth 0 abnf::csts)
                           "program-address-literal"))))

Theorem: cst-address-literal-conc1-rep-matching

(defthm cst-address-literal-conc1-rep-matching
  (implies
       (cst-list-rep-matchp abnf::csts "explicit-address-literal")
       (and (equal (len abnf::csts) 1)
            (cst-matchp (nth 0 abnf::csts)
                        "explicit-address-literal"))))

Theorem: cst-address-literal-conc2-rep-matching

(defthm cst-address-literal-conc2-rep-matching
 (implies (cst-list-rep-matchp abnf::csts "program-address-literal")
          (and (equal (len abnf::csts) 1)
               (cst-matchp (nth 0 abnf::csts)
                           "program-address-literal"))))

Theorem: cst-primary-expression-conc1-rep-matching

(defthm cst-primary-expression-conc1-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "literal")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "literal"))))

Theorem: cst-primary-expression-conc2-rep-matching

(defthm cst-primary-expression-conc2-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "variable")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "variable"))))

Theorem: cst-primary-expression-conc3-rep-matching

(defthm cst-primary-expression-conc3-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "locator")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "locator"))))

Theorem: cst-primary-expression-conc4-rep-matching

(defthm cst-primary-expression-conc4-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "associated-constant")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "associated-constant"))))

Theorem: cst-primary-expression-conc6-rep-matching

(defthm cst-primary-expression-conc6-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "free-function-call")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "free-function-call"))))

Theorem: cst-primary-expression-conc7-rep-matching

(defthm cst-primary-expression-conc7-rep-matching
  (implies
       (cst-list-rep-matchp abnf::csts "associated-function-call")
       (and (equal (len abnf::csts) 1)
            (cst-matchp (nth 0 abnf::csts)
                        "associated-function-call"))))

Theorem: cst-primary-expression-conc8-rep-matching

(defthm cst-primary-expression-conc8-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "unit-expression")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "unit-expression"))))

Theorem: cst-primary-expression-conc9-rep-matching

(defthm cst-primary-expression-conc9-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "tuple-expression")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "tuple-expression"))))

Theorem: cst-primary-expression-conc10-rep-matching

(defthm cst-primary-expression-conc10-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "array-expression")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "array-expression"))))

Theorem: cst-primary-expression-conc11-rep-matching

(defthm cst-primary-expression-conc11-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "struct-expression")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "struct-expression"))))

Theorem: cst-primary-expression-conc12-rep-matching

(defthm cst-primary-expression-conc12-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "self-expression")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "self-expression"))))

Theorem: cst-primary-expression-conc13-rep-matching

(defthm cst-primary-expression-conc13-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "block-expression")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "block-expression"))))

Theorem: cst-primary-expression-conc14-rep-matching

(defthm cst-primary-expression-conc14-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "network-expression")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "network-expression"))))

Theorem: cst-variable-conc-rep-matching

(defthm cst-variable-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-postfix-expression-conc1-rep-matching

(defthm cst-postfix-expression-conc1-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "primary-expression")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "primary-expression"))))

Theorem: cst-postfix-expression-conc2-rep-matching

(defthm cst-postfix-expression-conc2-rep-matching
  (implies
       (cst-list-rep-matchp abnf::csts "tuple-component-expression")
       (and (equal (len abnf::csts) 1)
            (cst-matchp (nth 0 abnf::csts)
                        "tuple-component-expression"))))

Theorem: cst-postfix-expression-conc3-rep-matching

(defthm cst-postfix-expression-conc3-rep-matching
  (implies
       (cst-list-rep-matchp abnf::csts "array-component-expression")
       (and (equal (len abnf::csts) 1)
            (cst-matchp (nth 0 abnf::csts)
                        "array-component-expression"))))

Theorem: cst-postfix-expression-conc4-rep-matching

(defthm cst-postfix-expression-conc4-rep-matching
  (implies (cst-list-rep-matchp abnf::csts
                                "struct-component-expression")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "struct-component-expression"))))

Theorem: cst-postfix-expression-conc5-rep-matching

(defthm cst-postfix-expression-conc5-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "method-call")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "method-call"))))

Theorem: cst-unary-expression-conc1-rep-matching

(defthm cst-unary-expression-conc1-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "postfix-expression")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "postfix-expression"))))

Theorem: cst-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-exponential-expression-conc1-rep-matching

(defthm cst-exponential-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-multiplicative-expression-conc1-rep-matching

(defthm cst-multiplicative-expression-conc1-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "exponential-expression")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "exponential-expression"))))

Theorem: cst-additive-expression-conc1-rep-matching

(defthm cst-additive-expression-conc1-rep-matching
  (implies
       (cst-list-rep-matchp abnf::csts "multiplicative-expression")
       (and (equal (len abnf::csts) 1)
            (cst-matchp (nth 0 abnf::csts)
                        "multiplicative-expression"))))

Theorem: cst-shift-expression-conc1-rep-matching

(defthm cst-shift-expression-conc1-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "additive-expression")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "additive-expression"))))

Theorem: cst-conjunctive-expression-conc1-rep-matching

(defthm cst-conjunctive-expression-conc1-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "shift-expression")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "shift-expression"))))

Theorem: cst-inclusive-disjunctive-expression-conc1-rep-matching

(defthm cst-inclusive-disjunctive-expression-conc1-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "conjunctive-expression")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "conjunctive-expression"))))

Theorem: cst-exclusive-disjunctive-expression-conc1-rep-matching

(defthm cst-exclusive-disjunctive-expression-conc1-rep-matching
  (implies (cst-list-rep-matchp abnf::csts
                                "inclusive-disjunctive-expression")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "inclusive-disjunctive-expression"))))

Theorem: cst-ordering-expression-conc1-rep-matching

(defthm cst-ordering-expression-conc1-rep-matching
  (implies (cst-list-rep-matchp abnf::csts
                                "exclusive-disjunctive-expression")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "exclusive-disjunctive-expression"))))

Theorem: cst-equality-expression-conc1-rep-matching

(defthm cst-equality-expression-conc1-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "ordering-expression")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "ordering-expression"))))

Theorem: cst-conditional-conjunctive-expression-conc1-rep-matching

(defthm cst-conditional-conjunctive-expression-conc1-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "equality-expression")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "equality-expression"))))

Theorem: cst-conditional-disjunctive-expression-conc1-rep-matching

(defthm cst-conditional-disjunctive-expression-conc1-rep-matching
 (implies (cst-list-rep-matchp abnf::csts
                               "conditional-conjunctive-expression")
          (and (equal (len abnf::csts) 1)
               (cst-matchp (nth 0 abnf::csts)
                           "conditional-conjunctive-expression"))))

Theorem: cst-binary-expression-conc-rep-matching

(defthm cst-binary-expression-conc-rep-matching
 (implies (cst-list-rep-matchp abnf::csts
                               "conditional-disjunctive-expression")
          (and (equal (len abnf::csts) 1)
               (cst-matchp (nth 0 abnf::csts)
                           "conditional-disjunctive-expression"))))

Theorem: cst-conditional-ternary-expression-conc1-rep-matching

(defthm cst-conditional-ternary-expression-conc1-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "binary-expression")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "binary-expression"))))

Theorem: cst-expression-conc-rep-matching

(defthm cst-expression-conc-rep-matching
  (implies (cst-list-rep-matchp abnf::csts
                                "conditional-ternary-expression")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "conditional-ternary-expression"))))

Theorem: cst-statement-conc1-rep-matching

(defthm cst-statement-conc1-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "expression-statement")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "expression-statement"))))

Theorem: cst-statement-conc2-rep-matching

(defthm cst-statement-conc2-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "return-statement")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "return-statement"))))

Theorem: cst-statement-conc3-rep-matching

(defthm cst-statement-conc3-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "variable-declaration")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "variable-declaration"))))

Theorem: cst-statement-conc4-rep-matching

(defthm cst-statement-conc4-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "constant-declaration")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "constant-declaration"))))

Theorem: cst-statement-conc5-rep-matching

(defthm cst-statement-conc5-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "conditional-statement")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "conditional-statement"))))

Theorem: cst-statement-conc6-rep-matching

(defthm cst-statement-conc6-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "loop-statement")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "loop-statement"))))

Theorem: cst-statement-conc7-rep-matching

(defthm cst-statement-conc7-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "assignment-statement")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "assignment-statement"))))

Theorem: cst-statement-conc8-rep-matching

(defthm cst-statement-conc8-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "block")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "block"))))

Theorem: cst-identifier-or-identifiers-conc1-rep-matching

(defthm cst-identifier-or-identifiers-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-conditional-statement-conc1-rep-matching

(defthm cst-conditional-statement-conc1-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "branch")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "branch"))))

Theorem: cst-assignment-operator-conc1-rep-matching

(defthm cst-assignment-operator-conc1-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "\"=\"")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts) "\"=\""))))

Theorem: cst-assignment-operator-conc2-rep-matching

(defthm cst-assignment-operator-conc2-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "\"+=\"")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "\"+=\""))))

Theorem: cst-assignment-operator-conc3-rep-matching

(defthm cst-assignment-operator-conc3-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "\"-=\"")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "\"-=\""))))

Theorem: cst-assignment-operator-conc4-rep-matching

(defthm cst-assignment-operator-conc4-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "\"*=\"")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "\"*=\""))))

Theorem: cst-assignment-operator-conc5-rep-matching

(defthm cst-assignment-operator-conc5-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "\"/=\"")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "\"/=\""))))

Theorem: cst-assignment-operator-conc6-rep-matching

(defthm cst-assignment-operator-conc6-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "\"%=\"")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "\"%=\""))))

Theorem: cst-assignment-operator-conc7-rep-matching

(defthm cst-assignment-operator-conc7-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "\"**=\"")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "\"**=\""))))

Theorem: cst-assignment-operator-conc8-rep-matching

(defthm cst-assignment-operator-conc8-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "\"<<=\"")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "\"<<=\""))))

Theorem: cst-assignment-operator-conc9-rep-matching

(defthm cst-assignment-operator-conc9-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "\">>=\"")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "\">>=\""))))

Theorem: cst-assignment-operator-conc10-rep-matching

(defthm cst-assignment-operator-conc10-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "\"&=\"")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "\"&=\""))))

Theorem: cst-assignment-operator-conc11-rep-matching

(defthm cst-assignment-operator-conc11-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "\"|=\"")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "\"|=\""))))

Theorem: cst-assignment-operator-conc12-rep-matching

(defthm cst-assignment-operator-conc12-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "\"^=\"")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "\"^=\""))))

Theorem: cst-assignment-operator-conc13-rep-matching

(defthm cst-assignment-operator-conc13-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "\"&&=\"")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "\"&&=\""))))

Theorem: cst-assignment-operator-conc14-rep-matching

(defthm cst-assignment-operator-conc14-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "\"||=\"")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "\"||=\""))))

Theorem: cst-function-kind-conc1-rep-matching

(defthm cst-function-kind-conc1-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "%s\"function\"")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "%s\"function\""))))

Theorem: cst-function-kind-conc2-rep-matching

(defthm cst-function-kind-conc2-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "%s\"transition\"")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "%s\"transition\""))))

Theorem: cst-function-kind-conc3-rep-matching

(defthm cst-function-kind-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-function-outputs-conc1-rep-matching

(defthm cst-function-outputs-conc1-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "function-output")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "function-output"))))

Theorem: cst-program-item-conc1-rep-matching

(defthm cst-program-item-conc1-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "function-declaration")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "function-declaration"))))

Theorem: cst-program-item-conc2-rep-matching

(defthm cst-program-item-conc2-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "struct-declaration")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "struct-declaration"))))

Theorem: cst-program-item-conc3-rep-matching

(defthm cst-program-item-conc3-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "record-declaration")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "record-declaration"))))

Theorem: cst-program-item-conc4-rep-matching

(defthm cst-program-item-conc4-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "mapping-declaration")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "mapping-declaration"))))

Theorem: cst-program-item-conc5-rep-matching

(defthm cst-program-item-conc5-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "constant-declaration")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "constant-declaration"))))

Theorem: cst-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)
          "ascii")
     (equal
          (abnf::tree-nonleaf->rulename?
               (nth 0
                    (nth 0
                         (abnf::tree-nonleaf->branches abnf::cst))))
          (abnf::rulename "ascii")))
   (iff
     (cst-list-list-conc-matchp
          (abnf::tree-nonleaf->branches abnf::cst)
          "safe-nonascii")
     (equal
          (abnf::tree-nonleaf->rulename?
               (nth 0
                    (nth 0
                         (abnf::tree-nonleaf->branches abnf::cst))))
          (abnf::rulename "safe-nonascii"))))))

Theorem: cst-whitespace-conc-equivs

(defthm cst-whitespace-conc-equivs
 (implies
  (cst-matchp abnf::cst "whitespace")
  (and
   (iff
     (cst-list-list-conc-matchp
          (abnf::tree-nonleaf->branches abnf::cst)
          "space")
     (equal
          (abnf::tree-nonleaf->rulename?
               (nth 0
                    (nth 0
                         (abnf::tree-nonleaf->branches abnf::cst))))
          (abnf::rulename "space")))
   (iff
     (cst-list-list-conc-matchp
          (abnf::tree-nonleaf->branches abnf::cst)
          "horizontal-tab")
     (equal
          (abnf::tree-nonleaf->rulename?
               (nth 0
                    (nth 0
                         (abnf::tree-nonleaf->branches abnf::cst))))
          (abnf::rulename "horizontal-tab")))
   (iff
     (cst-list-list-conc-matchp
          (abnf::tree-nonleaf->branches abnf::cst)
          "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)
          "line-terminator")
     (equal
          (abnf::tree-nonleaf->rulename?
               (nth 0
                    (nth 0
                         (abnf::tree-nonleaf->branches abnf::cst))))
          (abnf::rulename "line-terminator")))
   (iff
     (cst-list-list-conc-matchp
          (abnf::tree-nonleaf->branches abnf::cst)
          "carriage-return")
     (equal
          (abnf::tree-nonleaf->rulename?
               (nth 0
                    (nth 0
                         (abnf::tree-nonleaf->branches abnf::cst))))
          (abnf::rulename "carriage-return"))))))

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-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-numeral-conc-equivs

(defthm cst-numeral-conc-equivs
 (implies
  (cst-matchp abnf::cst "numeral")
  (and
   (iff
     (cst-list-list-conc-matchp
          (abnf::tree-nonleaf->branches abnf::cst)
          "binary-numeral")
     (equal
          (abnf::tree-nonleaf->rulename?
               (nth 0
                    (nth 0
                         (abnf::tree-nonleaf->branches abnf::cst))))
          (abnf::rulename "binary-numeral")))
   (iff
     (cst-list-list-conc-matchp
          (abnf::tree-nonleaf->branches abnf::cst)
          "octal-numeral")
     (equal
          (abnf::tree-nonleaf->rulename?
               (nth 0
                    (nth 0
                         (abnf::tree-nonleaf->branches abnf::cst))))
          (abnf::rulename "octal-numeral")))
   (iff
     (cst-list-list-conc-matchp
          (abnf::tree-nonleaf->branches abnf::cst)
          "decimal-numeral")
     (equal
          (abnf::tree-nonleaf->rulename?
               (nth 0
                    (nth 0
                         (abnf::tree-nonleaf->branches abnf::cst))))
          (abnf::rulename "decimal-numeral")))
   (iff
     (cst-list-list-conc-matchp
          (abnf::tree-nonleaf->branches abnf::cst)
          "hexadecimal-numeral")
     (equal
          (abnf::tree-nonleaf->rulename?
               (nth 0
                    (nth 0
                         (abnf::tree-nonleaf->branches abnf::cst))))
          (abnf::rulename "hexadecimal-numeral"))))))

Theorem: cst-integer-literal-conc-equivs

(defthm cst-integer-literal-conc-equivs
 (implies
  (cst-matchp abnf::cst "integer-literal")
  (and
   (iff
     (cst-list-list-conc-matchp
          (abnf::tree-nonleaf->branches abnf::cst)
          "unsigned-literal")
     (equal
          (abnf::tree-nonleaf->rulename?
               (nth 0
                    (nth 0
                         (abnf::tree-nonleaf->branches abnf::cst))))
          (abnf::rulename "unsigned-literal")))
   (iff
     (cst-list-list-conc-matchp
          (abnf::tree-nonleaf->branches abnf::cst)
          "signed-literal")
     (equal
          (abnf::tree-nonleaf->rulename?
               (nth 0
                    (nth 0
                         (abnf::tree-nonleaf->branches abnf::cst))))
          (abnf::rulename "signed-literal"))))))

Theorem: cst-numeric-literal-conc-equivs

(defthm cst-numeric-literal-conc-equivs
 (implies
  (cst-matchp abnf::cst "numeric-literal")
  (and
   (iff
     (cst-list-list-conc-matchp
          (abnf::tree-nonleaf->branches abnf::cst)
          "integer-literal")
     (equal
          (abnf::tree-nonleaf->rulename?
               (nth 0
                    (nth 0
                         (abnf::tree-nonleaf->branches abnf::cst))))
          (abnf::rulename "integer-literal")))
   (iff
     (cst-list-list-conc-matchp
          (abnf::tree-nonleaf->branches abnf::cst)
          "field-literal")
     (equal
          (abnf::tree-nonleaf->rulename?
               (nth 0
                    (nth 0
                         (abnf::tree-nonleaf->branches abnf::cst))))
          (abnf::rulename "field-literal")))
   (iff
     (cst-list-list-conc-matchp
          (abnf::tree-nonleaf->branches abnf::cst)
          "group-literal")
     (equal
          (abnf::tree-nonleaf->rulename?
               (nth 0
                    (nth 0
                         (abnf::tree-nonleaf->branches abnf::cst))))
          (abnf::rulename "group-literal")))
   (iff
     (cst-list-list-conc-matchp
          (abnf::tree-nonleaf->branches abnf::cst)
          "scalar-literal")
     (equal
          (abnf::tree-nonleaf->rulename?
               (nth 0
                    (nth 0
                         (abnf::tree-nonleaf->branches abnf::cst))))
          (abnf::rulename "scalar-literal"))))))

Theorem: cst-string-character-conc-equivs

(defthm cst-string-character-conc-equivs
 (implies
  (cst-matchp abnf::cst "string-character")
  (and
   (iff
     (cst-list-list-conc-matchp
          (abnf::tree-nonleaf->branches abnf::cst)
          "not-double-quote-or-line-feed")
     (equal
          (abnf::tree-nonleaf->rulename?
               (nth 0
                    (nth 0
                         (abnf::tree-nonleaf->branches abnf::cst))))
          (abnf::rulename "not-double-quote-or-line-feed")))
   (iff
     (cst-list-list-conc-matchp
          (abnf::tree-nonleaf->branches abnf::cst)
          "line-terminator")
     (equal
          (abnf::tree-nonleaf->rulename?
               (nth 0
                    (nth 0
                         (abnf::tree-nonleaf->branches abnf::cst))))
          (abnf::rulename "line-terminator"))))))

Theorem: cst-atomic-literal-conc-equivs

(defthm cst-atomic-literal-conc-equivs
 (implies
  (cst-matchp abnf::cst "atomic-literal")
  (and
   (iff
     (cst-list-list-conc-matchp
          (abnf::tree-nonleaf->branches abnf::cst)
          "numeric-literal")
     (equal
          (abnf::tree-nonleaf->rulename?
               (nth 0
                    (nth 0
                         (abnf::tree-nonleaf->branches abnf::cst))))
          (abnf::rulename "numeric-literal")))
   (iff
     (cst-list-list-conc-matchp
          (abnf::tree-nonleaf->branches abnf::cst)
          "boolean-literal")
     (equal
          (abnf::tree-nonleaf->rulename?
               (nth 0
                    (nth 0
                         (abnf::tree-nonleaf->branches abnf::cst))))
          (abnf::rulename "boolean-literal")))
   (iff
     (cst-list-list-conc-matchp
          (abnf::tree-nonleaf->branches abnf::cst)
          "explicit-address-literal")
     (equal
          (abnf::tree-nonleaf->rulename?
               (nth 0
                    (nth 0
                         (abnf::tree-nonleaf->branches abnf::cst))))
          (abnf::rulename "explicit-address-literal")))
   (iff
     (cst-list-list-conc-matchp
          (abnf::tree-nonleaf->branches abnf::cst)
          "string-literal")
     (equal
          (abnf::tree-nonleaf->rulename?
               (nth 0
                    (nth 0
                         (abnf::tree-nonleaf->branches abnf::cst))))
          (abnf::rulename "string-literal"))))))

Theorem: cst-token-conc-equivs

(defthm cst-token-conc-equivs
 (implies
  (cst-matchp abnf::cst "token")
  (and
   (iff
     (cst-list-list-conc-matchp
          (abnf::tree-nonleaf->branches abnf::cst)
          "keyword")
     (equal
          (abnf::tree-nonleaf->rulename?
               (nth 0
                    (nth 0
                         (abnf::tree-nonleaf->branches abnf::cst))))
          (abnf::rulename "keyword")))
   (iff
     (cst-list-list-conc-matchp
          (abnf::tree-nonleaf->branches abnf::cst)
          "identifier")
     (equal
          (abnf::tree-nonleaf->rulename?
               (nth 0
                    (nth 0
                         (abnf::tree-nonleaf->branches abnf::cst))))
          (abnf::rulename "identifier")))
   (iff
     (cst-list-list-conc-matchp
          (abnf::tree-nonleaf->branches abnf::cst)
          "atomic-literal")
     (equal
          (abnf::tree-nonleaf->rulename?
               (nth 0
                    (nth 0
                         (abnf::tree-nonleaf->branches abnf::cst))))
          (abnf::rulename "atomic-literal")))
   (iff
     (cst-list-list-conc-matchp
          (abnf::tree-nonleaf->branches abnf::cst)
          "decimal-numeral")
     (equal
          (abnf::tree-nonleaf->rulename?
               (nth 0
                    (nth 0
                         (abnf::tree-nonleaf->branches abnf::cst))))
          (abnf::rulename "decimal-numeral")))
   (iff
     (cst-list-list-conc-matchp
          (abnf::tree-nonleaf->branches abnf::cst)
          "annotation")
     (equal
          (abnf::tree-nonleaf->rulename?
               (nth 0
                    (nth 0
                         (abnf::tree-nonleaf->branches abnf::cst))))
          (abnf::rulename "annotation")))
   (iff
     (cst-list-list-conc-matchp
          (abnf::tree-nonleaf->branches abnf::cst)
          "symbol")
     (equal
          (abnf::tree-nonleaf->rulename?
               (nth 0
                    (nth 0
                         (abnf::tree-nonleaf->branches abnf::cst))))
          (abnf::rulename "symbol"))))))

Theorem: cst-lexeme-conc-equivs

(defthm cst-lexeme-conc-equivs
 (implies
  (cst-matchp abnf::cst "lexeme")
  (and
   (iff
     (cst-list-list-conc-matchp
          (abnf::tree-nonleaf->branches abnf::cst)
          "token")
     (equal
          (abnf::tree-nonleaf->rulename?
               (nth 0
                    (nth 0
                         (abnf::tree-nonleaf->branches abnf::cst))))
          (abnf::rulename "token")))
   (iff
     (cst-list-list-conc-matchp
          (abnf::tree-nonleaf->branches abnf::cst)
          "comment")
     (equal
          (abnf::tree-nonleaf->rulename?
               (nth 0
                    (nth 0
                         (abnf::tree-nonleaf->branches abnf::cst))))
          (abnf::rulename "comment")))
   (iff
     (cst-list-list-conc-matchp
          (abnf::tree-nonleaf->branches abnf::cst)
          "whitespace")
     (equal
          (abnf::tree-nonleaf->rulename?
               (nth 0
                    (nth 0
                         (abnf::tree-nonleaf->branches abnf::cst))))
          (abnf::rulename "whitespace"))))))

Theorem: cst-integer-type-conc-equivs

(defthm cst-integer-type-conc-equivs
 (implies
  (cst-matchp abnf::cst "integer-type")
  (and
   (iff
     (cst-list-list-conc-matchp
          (abnf::tree-nonleaf->branches abnf::cst)
          "unsigned-type")
     (equal
          (abnf::tree-nonleaf->rulename?
               (nth 0
                    (nth 0
                         (abnf::tree-nonleaf->branches abnf::cst))))
          (abnf::rulename "unsigned-type")))
   (iff
     (cst-list-list-conc-matchp
          (abnf::tree-nonleaf->branches abnf::cst)
          "signed-type")
     (equal
          (abnf::tree-nonleaf->rulename?
               (nth 0
                    (nth 0
                         (abnf::tree-nonleaf->branches abnf::cst))))
          (abnf::rulename "signed-type"))))))

Theorem: cst-arithmetic-type-conc-equivs

(defthm cst-arithmetic-type-conc-equivs
 (implies
  (cst-matchp abnf::cst "arithmetic-type")
  (and
   (iff
     (cst-list-list-conc-matchp
          (abnf::tree-nonleaf->branches abnf::cst)
          "integer-type")
     (equal
          (abnf::tree-nonleaf->rulename?
               (nth 0
                    (nth 0
                         (abnf::tree-nonleaf->branches abnf::cst))))
          (abnf::rulename "integer-type")))
   (iff
     (cst-list-list-conc-matchp
          (abnf::tree-nonleaf->branches abnf::cst)
          "field-type")
     (equal
          (abnf::tree-nonleaf->rulename?
               (nth 0
                    (nth 0
                         (abnf::tree-nonleaf->branches abnf::cst))))
          (abnf::rulename "field-type")))
   (iff
     (cst-list-list-conc-matchp
          (abnf::tree-nonleaf->branches abnf::cst)
          "group-type")
     (equal
          (abnf::tree-nonleaf->rulename?
               (nth 0
                    (nth 0
                         (abnf::tree-nonleaf->branches abnf::cst))))
          (abnf::rulename "group-type")))
   (iff
     (cst-list-list-conc-matchp
          (abnf::tree-nonleaf->branches abnf::cst)
          "scalar-type")
     (equal
          (abnf::tree-nonleaf->rulename?
               (nth 0
                    (nth 0
                         (abnf::tree-nonleaf->branches abnf::cst))))
          (abnf::rulename "scalar-type"))))))

Theorem: cst-named-primitive-type-conc-equivs

(defthm cst-named-primitive-type-conc-equivs
 (implies
  (cst-matchp abnf::cst "named-primitive-type")
  (and
   (iff
     (cst-list-list-conc-matchp
          (abnf::tree-nonleaf->branches abnf::cst)
          "boolean-type")
     (equal
          (abnf::tree-nonleaf->rulename?
               (nth 0
                    (nth 0
                         (abnf::tree-nonleaf->branches abnf::cst))))
          (abnf::rulename "boolean-type")))
   (iff
     (cst-list-list-conc-matchp
          (abnf::tree-nonleaf->branches abnf::cst)
          "arithmetic-type")
     (equal
          (abnf::tree-nonleaf->rulename?
               (nth 0
                    (nth 0
                         (abnf::tree-nonleaf->branches abnf::cst))))
          (abnf::rulename "arithmetic-type")))
   (iff
     (cst-list-list-conc-matchp
          (abnf::tree-nonleaf->branches abnf::cst)
          "address-type")
     (equal
          (abnf::tree-nonleaf->rulename?
               (nth 0
                    (nth 0
                         (abnf::tree-nonleaf->branches abnf::cst))))
          (abnf::rulename "address-type")))
   (iff
     (cst-list-list-conc-matchp
          (abnf::tree-nonleaf->branches abnf::cst)
          "signature-type")
     (equal
          (abnf::tree-nonleaf->rulename?
               (nth 0
                    (nth 0
                         (abnf::tree-nonleaf->branches abnf::cst))))
          (abnf::rulename "signature-type")))
   (iff
     (cst-list-list-conc-matchp
          (abnf::tree-nonleaf->branches abnf::cst)
          "string-type")
     (equal
          (abnf::tree-nonleaf->rulename?
               (nth 0
                    (nth 0
                         (abnf::tree-nonleaf->branches abnf::cst))))
          (abnf::rulename "string-type"))))))

Theorem: cst-primitive-type-conc-equivs

(defthm cst-primitive-type-conc-equivs
 (implies
  (cst-matchp abnf::cst "primitive-type")
  (and
   (iff
     (cst-list-list-conc-matchp
          (abnf::tree-nonleaf->branches abnf::cst)
          "named-primitive-type")
     (equal
          (abnf::tree-nonleaf->rulename?
               (nth 0
                    (nth 0
                         (abnf::tree-nonleaf->branches abnf::cst))))
          (abnf::rulename "named-primitive-type")))
   (iff
     (cst-list-list-conc-matchp
          (abnf::tree-nonleaf->branches abnf::cst)
          "unit-type")
     (equal
          (abnf::tree-nonleaf->rulename?
               (nth 0
                    (nth 0
                         (abnf::tree-nonleaf->branches abnf::cst))))
          (abnf::rulename "unit-type"))))))

Theorem: cst-future-type-conc-equivs

(defthm cst-future-type-conc-equivs
 (implies
  (cst-matchp abnf::cst "future-type")
  (and
   (iff
     (cst-list-list-conc-matchp
          (abnf::tree-nonleaf->branches abnf::cst)
          "untyped-future-type")
     (equal
          (abnf::tree-nonleaf->rulename?
               (nth 0
                    (nth 0
                         (abnf::tree-nonleaf->branches abnf::cst))))
          (abnf::rulename "untyped-future-type")))
   (iff
     (cst-list-list-conc-matchp
          (abnf::tree-nonleaf->branches abnf::cst)
          "typed-future-type")
     (equal
          (abnf::tree-nonleaf->rulename?
               (nth 0
                    (nth 0
                         (abnf::tree-nonleaf->branches abnf::cst))))
          (abnf::rulename "typed-future-type"))))))

Theorem: cst-type-conc-equivs

(defthm cst-type-conc-equivs
 (implies
  (cst-matchp abnf::cst "type")
  (and
   (iff
     (cst-list-list-conc-matchp
          (abnf::tree-nonleaf->branches abnf::cst)
          "primitive-type")
     (equal
          (abnf::tree-nonleaf->rulename?
               (nth 0
                    (nth 0
                         (abnf::tree-nonleaf->branches abnf::cst))))
          (abnf::rulename "primitive-type")))
   (iff
     (cst-list-list-conc-matchp
          (abnf::tree-nonleaf->branches abnf::cst)
          "future-type")
     (equal
          (abnf::tree-nonleaf->rulename?
               (nth 0
                    (nth 0
                         (abnf::tree-nonleaf->branches abnf::cst))))
          (abnf::rulename "future-type")))
   (iff
     (cst-list-list-conc-matchp
          (abnf::tree-nonleaf->branches abnf::cst)
          "tuple-type")
     (equal
          (abnf::tree-nonleaf->rulename?
               (nth 0
                    (nth 0
                         (abnf::tree-nonleaf->branches abnf::cst))))
          (abnf::rulename "tuple-type")))
   (iff
     (cst-list-list-conc-matchp
          (abnf::tree-nonleaf->branches abnf::cst)
          "array-type")
     (equal
          (abnf::tree-nonleaf->rulename?
               (nth 0
                    (nth 0
                         (abnf::tree-nonleaf->branches abnf::cst))))
          (abnf::rulename "array-type"))))))

Theorem: cst-named-type-conc-equivs

(defthm cst-named-type-conc-equivs
 (implies
  (cst-matchp abnf::cst "named-type")
  (and
   (iff
     (cst-list-list-conc-matchp
          (abnf::tree-nonleaf->branches abnf::cst)
          "named-primitive-type")
     (equal
          (abnf::tree-nonleaf->rulename?
               (nth 0
                    (nth 0
                         (abnf::tree-nonleaf->branches abnf::cst))))
          (abnf::rulename "named-primitive-type")))
   (iff
     (cst-list-list-conc-matchp
          (abnf::tree-nonleaf->branches abnf::cst)
          "untyped-future-type")
     (equal
          (abnf::tree-nonleaf->rulename?
               (nth 0
                    (nth 0
                         (abnf::tree-nonleaf->branches abnf::cst))))
          (abnf::rulename "untyped-future-type")))
   (iff
     (cst-list-list-conc-matchp
          (abnf::tree-nonleaf->branches abnf::cst)
          "identifier")
     (equal
          (abnf::tree-nonleaf->rulename?
               (nth 0
                    (nth 0
                         (abnf::tree-nonleaf->branches abnf::cst))))
          (abnf::rulename "identifier"))))))

Theorem: cst-literal-conc-equivs

(defthm cst-literal-conc-equivs
 (implies
  (cst-matchp abnf::cst "literal")
  (and
   (iff
     (cst-list-list-conc-matchp
          (abnf::tree-nonleaf->branches abnf::cst)
          "atomic-literal")
     (equal
          (abnf::tree-nonleaf->rulename?
               (nth 0
                    (nth 0
                         (abnf::tree-nonleaf->branches abnf::cst))))
          (abnf::rulename "atomic-literal")))
   (iff
     (cst-list-list-conc-matchp
          (abnf::tree-nonleaf->branches abnf::cst)
          "program-address-literal")
     (equal
          (abnf::tree-nonleaf->rulename?
               (nth 0
                    (nth 0
                         (abnf::tree-nonleaf->branches abnf::cst))))
          (abnf::rulename "program-address-literal"))))))

Theorem: cst-address-literal-conc-equivs

(defthm cst-address-literal-conc-equivs
 (implies
  (cst-matchp abnf::cst "address-literal")
  (and
   (iff
     (cst-list-list-conc-matchp
          (abnf::tree-nonleaf->branches abnf::cst)
          "explicit-address-literal")
     (equal
          (abnf::tree-nonleaf->rulename?
               (nth 0
                    (nth 0
                         (abnf::tree-nonleaf->branches abnf::cst))))
          (abnf::rulename "explicit-address-literal")))
   (iff
     (cst-list-list-conc-matchp
          (abnf::tree-nonleaf->branches abnf::cst)
          "program-address-literal")
     (equal
          (abnf::tree-nonleaf->rulename?
               (nth 0
                    (nth 0
                         (abnf::tree-nonleaf->branches abnf::cst))))
          (abnf::rulename "program-address-literal"))))))

Theorem: cst-postfix-expression-conc-equivs

(defthm cst-postfix-expression-conc-equivs
 (implies
  (cst-matchp abnf::cst "postfix-expression")
  (and
   (iff
     (cst-list-list-conc-matchp
          (abnf::tree-nonleaf->branches abnf::cst)
          "primary-expression")
     (equal
          (abnf::tree-nonleaf->rulename?
               (nth 0
                    (nth 0
                         (abnf::tree-nonleaf->branches abnf::cst))))
          (abnf::rulename "primary-expression")))
   (iff
     (cst-list-list-conc-matchp
          (abnf::tree-nonleaf->branches abnf::cst)
          "tuple-component-expression")
     (equal
          (abnf::tree-nonleaf->rulename?
               (nth 0
                    (nth 0
                         (abnf::tree-nonleaf->branches abnf::cst))))
          (abnf::rulename "tuple-component-expression")))
   (iff
     (cst-list-list-conc-matchp
          (abnf::tree-nonleaf->branches abnf::cst)
          "array-component-expression")
     (equal
          (abnf::tree-nonleaf->rulename?
               (nth 0
                    (nth 0
                         (abnf::tree-nonleaf->branches abnf::cst))))
          (abnf::rulename "array-component-expression")))
   (iff
     (cst-list-list-conc-matchp
          (abnf::tree-nonleaf->branches abnf::cst)
          "struct-component-expression")
     (equal
          (abnf::tree-nonleaf->rulename?
               (nth 0
                    (nth 0
                         (abnf::tree-nonleaf->branches abnf::cst))))
          (abnf::rulename "struct-component-expression")))
   (iff
     (cst-list-list-conc-matchp
          (abnf::tree-nonleaf->branches abnf::cst)
          "method-call")
     (equal
          (abnf::tree-nonleaf->rulename?
               (nth 0
                    (nth 0
                         (abnf::tree-nonleaf->branches abnf::cst))))
          (abnf::rulename "method-call"))))))

Theorem: cst-statement-conc-equivs

(defthm cst-statement-conc-equivs
 (implies
  (cst-matchp abnf::cst "statement")
  (and
   (iff
     (cst-list-list-conc-matchp
          (abnf::tree-nonleaf->branches abnf::cst)
          "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)
          "return-statement")
     (equal
          (abnf::tree-nonleaf->rulename?
               (nth 0
                    (nth 0
                         (abnf::tree-nonleaf->branches abnf::cst))))
          (abnf::rulename "return-statement")))
   (iff
     (cst-list-list-conc-matchp
          (abnf::tree-nonleaf->branches abnf::cst)
          "variable-declaration")
     (equal
          (abnf::tree-nonleaf->rulename?
               (nth 0
                    (nth 0
                         (abnf::tree-nonleaf->branches abnf::cst))))
          (abnf::rulename "variable-declaration")))
   (iff
     (cst-list-list-conc-matchp
          (abnf::tree-nonleaf->branches abnf::cst)
          "constant-declaration")
     (equal
          (abnf::tree-nonleaf->rulename?
               (nth 0
                    (nth 0
                         (abnf::tree-nonleaf->branches abnf::cst))))
          (abnf::rulename "constant-declaration")))
   (iff
     (cst-list-list-conc-matchp
          (abnf::tree-nonleaf->branches abnf::cst)
          "conditional-statement")
     (equal
          (abnf::tree-nonleaf->rulename?
               (nth 0
                    (nth 0
                         (abnf::tree-nonleaf->branches abnf::cst))))
          (abnf::rulename "conditional-statement")))
   (iff
     (cst-list-list-conc-matchp
          (abnf::tree-nonleaf->branches abnf::cst)
          "loop-statement")
     (equal
          (abnf::tree-nonleaf->rulename?
               (nth 0
                    (nth 0
                         (abnf::tree-nonleaf->branches abnf::cst))))
          (abnf::rulename "loop-statement")))
   (iff
     (cst-list-list-conc-matchp
          (abnf::tree-nonleaf->branches abnf::cst)
          "assignment-statement")
     (equal
          (abnf::tree-nonleaf->rulename?
               (nth 0
                    (nth 0
                         (abnf::tree-nonleaf->branches abnf::cst))))
          (abnf::rulename "assignment-statement")))
   (iff
     (cst-list-list-conc-matchp
          (abnf::tree-nonleaf->branches abnf::cst)
          "block")
     (equal
          (abnf::tree-nonleaf->rulename?
               (nth 0
                    (nth 0
                         (abnf::tree-nonleaf->branches abnf::cst))))
          (abnf::rulename "block"))))))

Theorem: cst-program-item-conc-equivs

(defthm cst-program-item-conc-equivs
 (implies
  (cst-matchp abnf::cst "program-item")
  (and
   (iff
     (cst-list-list-conc-matchp
          (abnf::tree-nonleaf->branches abnf::cst)
          "function-declaration")
     (equal
          (abnf::tree-nonleaf->rulename?
               (nth 0
                    (nth 0
                         (abnf::tree-nonleaf->branches abnf::cst))))
          (abnf::rulename "function-declaration")))
   (iff
     (cst-list-list-conc-matchp
          (abnf::tree-nonleaf->branches abnf::cst)
          "struct-declaration")
     (equal
          (abnf::tree-nonleaf->rulename?
               (nth 0
                    (nth 0
                         (abnf::tree-nonleaf->branches abnf::cst))))
          (abnf::rulename "struct-declaration")))
   (iff
     (cst-list-list-conc-matchp
          (abnf::tree-nonleaf->branches abnf::cst)
          "record-declaration")
     (equal
          (abnf::tree-nonleaf->rulename?
               (nth 0
                    (nth 0
                         (abnf::tree-nonleaf->branches abnf::cst))))
          (abnf::rulename "record-declaration")))
   (iff
     (cst-list-list-conc-matchp
          (abnf::tree-nonleaf->branches abnf::cst)
          "mapping-declaration")
     (equal
          (abnf::tree-nonleaf->rulename?
               (nth 0
                    (nth 0
                         (abnf::tree-nonleaf->branches abnf::cst))))
          (abnf::rulename "mapping-declaration")))
   (iff
     (cst-list-list-conc-matchp
          (abnf::tree-nonleaf->branches abnf::cst)
          "constant-declaration")
     (equal
          (abnf::tree-nonleaf->rulename?
               (nth 0
                    (nth 0
                         (abnf::tree-nonleaf->branches abnf::cst))))
          (abnf::rulename "constant-declaration"))))))

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 "ascii"))
     1)
    ((equal
          (abnf::tree-nonleaf->rulename?
               (nth 0
                    (nth 0
                         (abnf::tree-nonleaf->branches abnf::cst))))
          (abnf::rulename "safe-nonascii"))
     2)
    (t (prog2$ (impossible) 1)))))

Theorem: posp-of-cst-character-conc?

(defthm posp-of-cst-character-conc?
  (b* ((number (cst-character-conc? abnf::cst)))
    (posp number))
  :rule-classes :rewrite)

Theorem: cst-character-conc?-possibilities

(defthm cst-character-conc?-possibilities
  (b* ((number (cst-character-conc? abnf::cst)))
    (or (equal number 1) (equal number 2)))
  :rule-classes
  ((:forward-chaining
        :trigger-terms ((cst-character-conc? abnf::cst)))))

Theorem: cst-character-conc?-of-tree-fix-cst

(defthm cst-character-conc?-of-tree-fix-cst
  (equal (cst-character-conc? (abnf::tree-fix abnf::cst))
         (cst-character-conc? abnf::cst)))

Theorem: cst-character-conc?-tree-equiv-congruence-on-cst

(defthm cst-character-conc?-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-character-conc? abnf::cst)
                  (cst-character-conc? cst-equiv)))
  :rule-classes :congruence)

Theorem: cst-character-conc?-1-iff-match-conc

(defthm cst-character-conc?-1-iff-match-conc
  (implies (cst-matchp abnf::cst "character")
           (iff (equal (cst-character-conc? abnf::cst)
                       1)
                (cst-list-list-conc-matchp
                     (abnf::tree-nonleaf->branches abnf::cst)
                     "ascii"))))

Theorem: cst-character-conc?-2-iff-match-conc

(defthm cst-character-conc?-2-iff-match-conc
  (implies (cst-matchp abnf::cst "character")
           (iff (equal (cst-character-conc? abnf::cst)
                       2)
                (cst-list-list-conc-matchp
                     (abnf::tree-nonleaf->branches abnf::cst)
                     "safe-nonascii"))))

Function: cst-whitespace-conc?

(defun cst-whitespace-conc? (abnf::cst)
 (declare (xargs :guard (abnf::treep abnf::cst)))
 (declare (xargs :guard (cst-matchp abnf::cst "whitespace")))
 (let ((__function__ 'cst-whitespace-conc?))
  (declare (ignorable __function__))
  (cond
    ((equal
          (abnf::tree-nonleaf->rulename?
               (nth 0
                    (nth 0
                         (abnf::tree-nonleaf->branches abnf::cst))))
          (abnf::rulename "space"))
     1)
    ((equal
          (abnf::tree-nonleaf->rulename?
               (nth 0
                    (nth 0
                         (abnf::tree-nonleaf->branches abnf::cst))))
          (abnf::rulename "horizontal-tab"))
     2)
    ((equal
          (abnf::tree-nonleaf->rulename?
               (nth 0
                    (nth 0
                         (abnf::tree-nonleaf->branches abnf::cst))))
          (abnf::rulename "form-feed"))
     3)
    ((equal
          (abnf::tree-nonleaf->rulename?
               (nth 0
                    (nth 0
                         (abnf::tree-nonleaf->branches abnf::cst))))
          (abnf::rulename "line-terminator"))
     4)
    ((equal
          (abnf::tree-nonleaf->rulename?
               (nth 0
                    (nth 0
                         (abnf::tree-nonleaf->branches abnf::cst))))
          (abnf::rulename "carriage-return"))
     5)
    (t (prog2$ (impossible) 1)))))

Theorem: posp-of-cst-whitespace-conc?

(defthm posp-of-cst-whitespace-conc?
  (b* ((number (cst-whitespace-conc? abnf::cst)))
    (posp number))
  :rule-classes :rewrite)

Theorem: cst-whitespace-conc?-possibilities

(defthm cst-whitespace-conc?-possibilities
  (b* ((number (cst-whitespace-conc? abnf::cst)))
    (or (equal number 1)
        (equal number 2)
        (equal number 3)
        (equal number 4)
        (equal number 5)))
  :rule-classes
  ((:forward-chaining
        :trigger-terms ((cst-whitespace-conc? abnf::cst)))))

Theorem: cst-whitespace-conc?-of-tree-fix-cst

(defthm cst-whitespace-conc?-of-tree-fix-cst
  (equal (cst-whitespace-conc? (abnf::tree-fix abnf::cst))
         (cst-whitespace-conc? abnf::cst)))

Theorem: cst-whitespace-conc?-tree-equiv-congruence-on-cst

(defthm cst-whitespace-conc?-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-whitespace-conc? abnf::cst)
                  (cst-whitespace-conc? cst-equiv)))
  :rule-classes :congruence)

Theorem: cst-whitespace-conc?-1-iff-match-conc

(defthm cst-whitespace-conc?-1-iff-match-conc
  (implies (cst-matchp abnf::cst "whitespace")
           (iff (equal (cst-whitespace-conc? abnf::cst)
                       1)
                (cst-list-list-conc-matchp
                     (abnf::tree-nonleaf->branches abnf::cst)
                     "space"))))

Theorem: cst-whitespace-conc?-2-iff-match-conc

(defthm cst-whitespace-conc?-2-iff-match-conc
  (implies (cst-matchp abnf::cst "whitespace")
           (iff (equal (cst-whitespace-conc? abnf::cst)
                       2)
                (cst-list-list-conc-matchp
                     (abnf::tree-nonleaf->branches abnf::cst)
                     "horizontal-tab"))))

Theorem: cst-whitespace-conc?-3-iff-match-conc

(defthm cst-whitespace-conc?-3-iff-match-conc
  (implies (cst-matchp abnf::cst "whitespace")
           (iff (equal (cst-whitespace-conc? abnf::cst)
                       3)
                (cst-list-list-conc-matchp
                     (abnf::tree-nonleaf->branches abnf::cst)
                     "form-feed"))))

Theorem: cst-whitespace-conc?-4-iff-match-conc

(defthm cst-whitespace-conc?-4-iff-match-conc
  (implies (cst-matchp abnf::cst "whitespace")
           (iff (equal (cst-whitespace-conc? abnf::cst)
                       4)
                (cst-list-list-conc-matchp
                     (abnf::tree-nonleaf->branches abnf::cst)
                     "line-terminator"))))

Theorem: cst-whitespace-conc?-5-iff-match-conc

(defthm cst-whitespace-conc?-5-iff-match-conc
  (implies (cst-matchp abnf::cst "whitespace")
           (iff (equal (cst-whitespace-conc? abnf::cst)
                       5)
                (cst-list-list-conc-matchp
                     (abnf::tree-nonleaf->branches abnf::cst)
                     "carriage-return"))))

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-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-numeral-conc?

(defun cst-numeral-conc? (abnf::cst)
 (declare (xargs :guard (abnf::treep abnf::cst)))
 (declare (xargs :guard (cst-matchp abnf::cst "numeral")))
 (let ((__function__ 'cst-numeral-conc?))
  (declare (ignorable __function__))
  (cond
    ((equal
          (abnf::tree-nonleaf->rulename?
               (nth 0
                    (nth 0
                         (abnf::tree-nonleaf->branches abnf::cst))))
          (abnf::rulename "binary-numeral"))
     1)
    ((equal
          (abnf::tree-nonleaf->rulename?
               (nth 0
                    (nth 0
                         (abnf::tree-nonleaf->branches abnf::cst))))
          (abnf::rulename "octal-numeral"))
     2)
    ((equal
          (abnf::tree-nonleaf->rulename?
               (nth 0
                    (nth 0
                         (abnf::tree-nonleaf->branches abnf::cst))))
          (abnf::rulename "decimal-numeral"))
     3)
    ((equal
          (abnf::tree-nonleaf->rulename?
               (nth 0
                    (nth 0
                         (abnf::tree-nonleaf->branches abnf::cst))))
          (abnf::rulename "hexadecimal-numeral"))
     4)
    (t (prog2$ (impossible) 1)))))

Theorem: posp-of-cst-numeral-conc?

(defthm posp-of-cst-numeral-conc?
  (b* ((number (cst-numeral-conc? abnf::cst)))
    (posp number))
  :rule-classes :rewrite)

Theorem: cst-numeral-conc?-possibilities

(defthm cst-numeral-conc?-possibilities
  (b* ((number (cst-numeral-conc? abnf::cst)))
    (or (equal number 1)
        (equal number 2)
        (equal number 3)
        (equal number 4)))
  :rule-classes
  ((:forward-chaining
        :trigger-terms ((cst-numeral-conc? abnf::cst)))))

Theorem: cst-numeral-conc?-of-tree-fix-cst

(defthm cst-numeral-conc?-of-tree-fix-cst
  (equal (cst-numeral-conc? (abnf::tree-fix abnf::cst))
         (cst-numeral-conc? abnf::cst)))

Theorem: cst-numeral-conc?-tree-equiv-congruence-on-cst

(defthm cst-numeral-conc?-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-numeral-conc? abnf::cst)
                  (cst-numeral-conc? cst-equiv)))
  :rule-classes :congruence)

Theorem: cst-numeral-conc?-1-iff-match-conc

(defthm cst-numeral-conc?-1-iff-match-conc
  (implies (cst-matchp abnf::cst "numeral")
           (iff (equal (cst-numeral-conc? abnf::cst) 1)
                (cst-list-list-conc-matchp
                     (abnf::tree-nonleaf->branches abnf::cst)
                     "binary-numeral"))))

Theorem: cst-numeral-conc?-2-iff-match-conc

(defthm cst-numeral-conc?-2-iff-match-conc
  (implies (cst-matchp abnf::cst "numeral")
           (iff (equal (cst-numeral-conc? abnf::cst) 2)
                (cst-list-list-conc-matchp
                     (abnf::tree-nonleaf->branches abnf::cst)
                     "octal-numeral"))))

Theorem: cst-numeral-conc?-3-iff-match-conc

(defthm cst-numeral-conc?-3-iff-match-conc
  (implies (cst-matchp abnf::cst "numeral")
           (iff (equal (cst-numeral-conc? abnf::cst) 3)
                (cst-list-list-conc-matchp
                     (abnf::tree-nonleaf->branches abnf::cst)
                     "decimal-numeral"))))

Theorem: cst-numeral-conc?-4-iff-match-conc

(defthm cst-numeral-conc?-4-iff-match-conc
  (implies (cst-matchp abnf::cst "numeral")
           (iff (equal (cst-numeral-conc? abnf::cst) 4)
                (cst-list-list-conc-matchp
                     (abnf::tree-nonleaf->branches abnf::cst)
                     "hexadecimal-numeral"))))

Function: cst-integer-literal-conc?

(defun cst-integer-literal-conc? (abnf::cst)
 (declare (xargs :guard (abnf::treep abnf::cst)))
 (declare (xargs :guard (cst-matchp abnf::cst "integer-literal")))
 (let ((__function__ 'cst-integer-literal-conc?))
  (declare (ignorable __function__))
  (cond
    ((equal
          (abnf::tree-nonleaf->rulename?
               (nth 0
                    (nth 0
                         (abnf::tree-nonleaf->branches abnf::cst))))
          (abnf::rulename "unsigned-literal"))
     1)
    ((equal
          (abnf::tree-nonleaf->rulename?
               (nth 0
                    (nth 0
                         (abnf::tree-nonleaf->branches abnf::cst))))
          (abnf::rulename "signed-literal"))
     2)
    (t (prog2$ (impossible) 1)))))

Theorem: posp-of-cst-integer-literal-conc?

(defthm posp-of-cst-integer-literal-conc?
  (b* ((number (cst-integer-literal-conc? abnf::cst)))
    (posp number))
  :rule-classes :rewrite)

Theorem: cst-integer-literal-conc?-possibilities

(defthm cst-integer-literal-conc?-possibilities
  (b* ((number (cst-integer-literal-conc? abnf::cst)))
    (or (equal number 1) (equal number 2)))
  :rule-classes
  ((:forward-chaining
        :trigger-terms ((cst-integer-literal-conc? abnf::cst)))))

Theorem: cst-integer-literal-conc?-of-tree-fix-cst

(defthm cst-integer-literal-conc?-of-tree-fix-cst
  (equal (cst-integer-literal-conc? (abnf::tree-fix abnf::cst))
         (cst-integer-literal-conc? abnf::cst)))

Theorem: cst-integer-literal-conc?-tree-equiv-congruence-on-cst

(defthm cst-integer-literal-conc?-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-integer-literal-conc? abnf::cst)
                  (cst-integer-literal-conc? cst-equiv)))
  :rule-classes :congruence)

Theorem: cst-integer-literal-conc?-1-iff-match-conc

(defthm cst-integer-literal-conc?-1-iff-match-conc
  (implies (cst-matchp abnf::cst "integer-literal")
           (iff (equal (cst-integer-literal-conc? abnf::cst)
                       1)
                (cst-list-list-conc-matchp
                     (abnf::tree-nonleaf->branches abnf::cst)
                     "unsigned-literal"))))

Theorem: cst-integer-literal-conc?-2-iff-match-conc

(defthm cst-integer-literal-conc?-2-iff-match-conc
  (implies (cst-matchp abnf::cst "integer-literal")
           (iff (equal (cst-integer-literal-conc? abnf::cst)
                       2)
                (cst-list-list-conc-matchp
                     (abnf::tree-nonleaf->branches abnf::cst)
                     "signed-literal"))))

Function: cst-numeric-literal-conc?

(defun cst-numeric-literal-conc? (abnf::cst)
 (declare (xargs :guard (abnf::treep abnf::cst)))
 (declare (xargs :guard (cst-matchp abnf::cst "numeric-literal")))
 (let ((__function__ 'cst-numeric-literal-conc?))
  (declare (ignorable __function__))
  (cond
    ((equal
          (abnf::tree-nonleaf->rulename?
               (nth 0
                    (nth 0
                         (abnf::tree-nonleaf->branches abnf::cst))))
          (abnf::rulename "integer-literal"))
     1)
    ((equal
          (abnf::tree-nonleaf->rulename?
               (nth 0
                    (nth 0
                         (abnf::tree-nonleaf->branches abnf::cst))))
          (abnf::rulename "field-literal"))
     2)
    ((equal
          (abnf::tree-nonleaf->rulename?
               (nth 0
                    (nth 0
                         (abnf::tree-nonleaf->branches abnf::cst))))
          (abnf::rulename "group-literal"))
     3)
    ((equal
          (abnf::tree-nonleaf->rulename?
               (nth 0
                    (nth 0
                         (abnf::tree-nonleaf->branches abnf::cst))))
          (abnf::rulename "scalar-literal"))
     4)
    (t (prog2$ (impossible) 1)))))

Theorem: posp-of-cst-numeric-literal-conc?

(defthm posp-of-cst-numeric-literal-conc?
  (b* ((number (cst-numeric-literal-conc? abnf::cst)))
    (posp number))
  :rule-classes :rewrite)

Theorem: cst-numeric-literal-conc?-possibilities

(defthm cst-numeric-literal-conc?-possibilities
  (b* ((number (cst-numeric-literal-conc? abnf::cst)))
    (or (equal number 1)
        (equal number 2)
        (equal number 3)
        (equal number 4)))
  :rule-classes
  ((:forward-chaining
        :trigger-terms ((cst-numeric-literal-conc? abnf::cst)))))

Theorem: cst-numeric-literal-conc?-of-tree-fix-cst

(defthm cst-numeric-literal-conc?-of-tree-fix-cst
  (equal (cst-numeric-literal-conc? (abnf::tree-fix abnf::cst))
         (cst-numeric-literal-conc? abnf::cst)))

Theorem: cst-numeric-literal-conc?-tree-equiv-congruence-on-cst

(defthm cst-numeric-literal-conc?-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-numeric-literal-conc? abnf::cst)
                  (cst-numeric-literal-conc? cst-equiv)))
  :rule-classes :congruence)

Theorem: cst-numeric-literal-conc?-1-iff-match-conc

(defthm cst-numeric-literal-conc?-1-iff-match-conc
  (implies (cst-matchp abnf::cst "numeric-literal")
           (iff (equal (cst-numeric-literal-conc? abnf::cst)
                       1)
                (cst-list-list-conc-matchp
                     (abnf::tree-nonleaf->branches abnf::cst)
                     "integer-literal"))))

Theorem: cst-numeric-literal-conc?-2-iff-match-conc

(defthm cst-numeric-literal-conc?-2-iff-match-conc
  (implies (cst-matchp abnf::cst "numeric-literal")
           (iff (equal (cst-numeric-literal-conc? abnf::cst)
                       2)
                (cst-list-list-conc-matchp
                     (abnf::tree-nonleaf->branches abnf::cst)
                     "field-literal"))))

Theorem: cst-numeric-literal-conc?-3-iff-match-conc

(defthm cst-numeric-literal-conc?-3-iff-match-conc
  (implies (cst-matchp abnf::cst "numeric-literal")
           (iff (equal (cst-numeric-literal-conc? abnf::cst)
                       3)
                (cst-list-list-conc-matchp
                     (abnf::tree-nonleaf->branches abnf::cst)
                     "group-literal"))))

Theorem: cst-numeric-literal-conc?-4-iff-match-conc

(defthm cst-numeric-literal-conc?-4-iff-match-conc
  (implies (cst-matchp abnf::cst "numeric-literal")
           (iff (equal (cst-numeric-literal-conc? abnf::cst)
                       4)
                (cst-list-list-conc-matchp
                     (abnf::tree-nonleaf->branches abnf::cst)
                     "scalar-literal"))))

Function: cst-string-character-conc?

(defun cst-string-character-conc? (abnf::cst)
 (declare (xargs :guard (abnf::treep abnf::cst)))
 (declare (xargs :guard (cst-matchp abnf::cst "string-character")))
 (let ((__function__ 'cst-string-character-conc?))
  (declare (ignorable __function__))
  (cond
    ((equal
          (abnf::tree-nonleaf->rulename?
               (nth 0
                    (nth 0
                         (abnf::tree-nonleaf->branches abnf::cst))))
          (abnf::rulename "not-double-quote-or-line-feed"))
     1)
    ((equal
          (abnf::tree-nonleaf->rulename?
               (nth 0
                    (nth 0
                         (abnf::tree-nonleaf->branches abnf::cst))))
          (abnf::rulename "line-terminator"))
     2)
    (t (prog2$ (impossible) 1)))))

Theorem: posp-of-cst-string-character-conc?

(defthm posp-of-cst-string-character-conc?
  (b* ((number (cst-string-character-conc? abnf::cst)))
    (posp number))
  :rule-classes :rewrite)

Theorem: cst-string-character-conc?-possibilities

(defthm cst-string-character-conc?-possibilities
  (b* ((number (cst-string-character-conc? abnf::cst)))
    (or (equal number 1) (equal number 2)))
  :rule-classes
  ((:forward-chaining
        :trigger-terms ((cst-string-character-conc? abnf::cst)))))

Theorem: cst-string-character-conc?-of-tree-fix-cst

(defthm cst-string-character-conc?-of-tree-fix-cst
  (equal (cst-string-character-conc? (abnf::tree-fix abnf::cst))
         (cst-string-character-conc? abnf::cst)))

Theorem: cst-string-character-conc?-tree-equiv-congruence-on-cst

(defthm cst-string-character-conc?-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-string-character-conc? abnf::cst)
                  (cst-string-character-conc? cst-equiv)))
  :rule-classes :congruence)

Theorem: cst-string-character-conc?-1-iff-match-conc

(defthm cst-string-character-conc?-1-iff-match-conc
  (implies (cst-matchp abnf::cst "string-character")
           (iff (equal (cst-string-character-conc? abnf::cst)
                       1)
                (cst-list-list-conc-matchp
                     (abnf::tree-nonleaf->branches abnf::cst)
                     "not-double-quote-or-line-feed"))))

Theorem: cst-string-character-conc?-2-iff-match-conc

(defthm cst-string-character-conc?-2-iff-match-conc
  (implies (cst-matchp abnf::cst "string-character")
           (iff (equal (cst-string-character-conc? abnf::cst)
                       2)
                (cst-list-list-conc-matchp
                     (abnf::tree-nonleaf->branches abnf::cst)
                     "line-terminator"))))

Function: cst-atomic-literal-conc?

(defun cst-atomic-literal-conc? (abnf::cst)
 (declare (xargs :guard (abnf::treep abnf::cst)))
 (declare (xargs :guard (cst-matchp abnf::cst "atomic-literal")))
 (let ((__function__ 'cst-atomic-literal-conc?))
  (declare (ignorable __function__))
  (cond
    ((equal
          (abnf::tree-nonleaf->rulename?
               (nth 0
                    (nth 0
                         (abnf::tree-nonleaf->branches abnf::cst))))
          (abnf::rulename "numeric-literal"))
     1)
    ((equal
          (abnf::tree-nonleaf->rulename?
               (nth 0
                    (nth 0
                         (abnf::tree-nonleaf->branches abnf::cst))))
          (abnf::rulename "boolean-literal"))
     2)
    ((equal
          (abnf::tree-nonleaf->rulename?
               (nth 0
                    (nth 0
                         (abnf::tree-nonleaf->branches abnf::cst))))
          (abnf::rulename "explicit-address-literal"))
     3)
    ((equal
          (abnf::tree-nonleaf->rulename?
               (nth 0
                    (nth 0
                         (abnf::tree-nonleaf->branches abnf::cst))))
          (abnf::rulename "string-literal"))
     4)
    (t (prog2$ (impossible) 1)))))

Theorem: posp-of-cst-atomic-literal-conc?

(defthm posp-of-cst-atomic-literal-conc?
  (b* ((number (cst-atomic-literal-conc? abnf::cst)))
    (posp number))
  :rule-classes :rewrite)

Theorem: cst-atomic-literal-conc?-possibilities

(defthm cst-atomic-literal-conc?-possibilities
  (b* ((number (cst-atomic-literal-conc? abnf::cst)))
    (or (equal number 1)
        (equal number 2)
        (equal number 3)
        (equal number 4)))
  :rule-classes
  ((:forward-chaining
        :trigger-terms ((cst-atomic-literal-conc? abnf::cst)))))

Theorem: cst-atomic-literal-conc?-of-tree-fix-cst

(defthm cst-atomic-literal-conc?-of-tree-fix-cst
  (equal (cst-atomic-literal-conc? (abnf::tree-fix abnf::cst))
         (cst-atomic-literal-conc? abnf::cst)))

Theorem: cst-atomic-literal-conc?-tree-equiv-congruence-on-cst

(defthm cst-atomic-literal-conc?-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-atomic-literal-conc? abnf::cst)
                  (cst-atomic-literal-conc? cst-equiv)))
  :rule-classes :congruence)

Theorem: cst-atomic-literal-conc?-1-iff-match-conc

(defthm cst-atomic-literal-conc?-1-iff-match-conc
  (implies (cst-matchp abnf::cst "atomic-literal")
           (iff (equal (cst-atomic-literal-conc? abnf::cst)
                       1)
                (cst-list-list-conc-matchp
                     (abnf::tree-nonleaf->branches abnf::cst)
                     "numeric-literal"))))

Theorem: cst-atomic-literal-conc?-2-iff-match-conc

(defthm cst-atomic-literal-conc?-2-iff-match-conc
  (implies (cst-matchp abnf::cst "atomic-literal")
           (iff (equal (cst-atomic-literal-conc? abnf::cst)
                       2)
                (cst-list-list-conc-matchp
                     (abnf::tree-nonleaf->branches abnf::cst)
                     "boolean-literal"))))

Theorem: cst-atomic-literal-conc?-3-iff-match-conc

(defthm cst-atomic-literal-conc?-3-iff-match-conc
  (implies (cst-matchp abnf::cst "atomic-literal")
           (iff (equal (cst-atomic-literal-conc? abnf::cst)
                       3)
                (cst-list-list-conc-matchp
                     (abnf::tree-nonleaf->branches abnf::cst)
                     "explicit-address-literal"))))

Theorem: cst-atomic-literal-conc?-4-iff-match-conc

(defthm cst-atomic-literal-conc?-4-iff-match-conc
  (implies (cst-matchp abnf::cst "atomic-literal")
           (iff (equal (cst-atomic-literal-conc? abnf::cst)
                       4)
                (cst-list-list-conc-matchp
                     (abnf::tree-nonleaf->branches abnf::cst)
                     "string-literal"))))

Function: cst-token-conc?

(defun cst-token-conc? (abnf::cst)
 (declare (xargs :guard (abnf::treep abnf::cst)))
 (declare (xargs :guard (cst-matchp abnf::cst "token")))
 (let ((__function__ 'cst-token-conc?))
  (declare (ignorable __function__))
  (cond
    ((equal
          (abnf::tree-nonleaf->rulename?
               (nth 0
                    (nth 0
                         (abnf::tree-nonleaf->branches abnf::cst))))
          (abnf::rulename "keyword"))
     1)
    ((equal
          (abnf::tree-nonleaf->rulename?
               (nth 0
                    (nth 0
                         (abnf::tree-nonleaf->branches abnf::cst))))
          (abnf::rulename "identifier"))
     2)
    ((equal
          (abnf::tree-nonleaf->rulename?
               (nth 0
                    (nth 0
                         (abnf::tree-nonleaf->branches abnf::cst))))
          (abnf::rulename "atomic-literal"))
     3)
    ((equal
          (abnf::tree-nonleaf->rulename?
               (nth 0
                    (nth 0
                         (abnf::tree-nonleaf->branches abnf::cst))))
          (abnf::rulename "decimal-numeral"))
     4)
    ((equal
          (abnf::tree-nonleaf->rulename?
               (nth 0
                    (nth 0
                         (abnf::tree-nonleaf->branches abnf::cst))))
          (abnf::rulename "annotation"))
     5)
    ((equal
          (abnf::tree-nonleaf->rulename?
               (nth 0
                    (nth 0
                         (abnf::tree-nonleaf->branches abnf::cst))))
          (abnf::rulename "symbol"))
     6)
    (t (prog2$ (impossible) 1)))))

Theorem: posp-of-cst-token-conc?

(defthm posp-of-cst-token-conc?
  (b* ((number (cst-token-conc? abnf::cst)))
    (posp number))
  :rule-classes :rewrite)

Theorem: cst-token-conc?-possibilities

(defthm cst-token-conc?-possibilities
 (b* ((number (cst-token-conc? abnf::cst)))
   (or (equal number 1)
       (equal number 2)
       (equal number 3)
       (equal number 4)
       (equal number 5)
       (equal number 6)))
 :rule-classes
 ((:forward-chaining :trigger-terms ((cst-token-conc? abnf::cst)))))

Theorem: cst-token-conc?-of-tree-fix-cst

(defthm cst-token-conc?-of-tree-fix-cst
  (equal (cst-token-conc? (abnf::tree-fix abnf::cst))
         (cst-token-conc? abnf::cst)))

Theorem: cst-token-conc?-tree-equiv-congruence-on-cst

(defthm cst-token-conc?-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-token-conc? abnf::cst)
                  (cst-token-conc? cst-equiv)))
  :rule-classes :congruence)

Theorem: cst-token-conc?-1-iff-match-conc

(defthm cst-token-conc?-1-iff-match-conc
  (implies (cst-matchp abnf::cst "token")
           (iff (equal (cst-token-conc? abnf::cst) 1)
                (cst-list-list-conc-matchp
                     (abnf::tree-nonleaf->branches abnf::cst)
                     "keyword"))))

Theorem: cst-token-conc?-2-iff-match-conc

(defthm cst-token-conc?-2-iff-match-conc
  (implies (cst-matchp abnf::cst "token")
           (iff (equal (cst-token-conc? abnf::cst) 2)
                (cst-list-list-conc-matchp
                     (abnf::tree-nonleaf->branches abnf::cst)
                     "identifier"))))

Theorem: cst-token-conc?-3-iff-match-conc

(defthm cst-token-conc?-3-iff-match-conc
  (implies (cst-matchp abnf::cst "token")
           (iff (equal (cst-token-conc? abnf::cst) 3)
                (cst-list-list-conc-matchp
                     (abnf::tree-nonleaf->branches abnf::cst)
                     "atomic-literal"))))

Theorem: cst-token-conc?-4-iff-match-conc

(defthm cst-token-conc?-4-iff-match-conc
  (implies (cst-matchp abnf::cst "token")
           (iff (equal (cst-token-conc? abnf::cst) 4)
                (cst-list-list-conc-matchp
                     (abnf::tree-nonleaf->branches abnf::cst)
                     "decimal-numeral"))))

Theorem: cst-token-conc?-5-iff-match-conc

(defthm cst-token-conc?-5-iff-match-conc
  (implies (cst-matchp abnf::cst "token")
           (iff (equal (cst-token-conc? abnf::cst) 5)
                (cst-list-list-conc-matchp
                     (abnf::tree-nonleaf->branches abnf::cst)
                     "annotation"))))

Theorem: cst-token-conc?-6-iff-match-conc

(defthm cst-token-conc?-6-iff-match-conc
  (implies (cst-matchp abnf::cst "token")
           (iff (equal (cst-token-conc? abnf::cst) 6)
                (cst-list-list-conc-matchp
                     (abnf::tree-nonleaf->branches abnf::cst)
                     "symbol"))))

Function: cst-lexeme-conc?

(defun cst-lexeme-conc? (abnf::cst)
 (declare (xargs :guard (abnf::treep abnf::cst)))
 (declare (xargs :guard (cst-matchp abnf::cst "lexeme")))
 (let ((__function__ 'cst-lexeme-conc?))
  (declare (ignorable __function__))
  (cond
    ((equal
          (abnf::tree-nonleaf->rulename?
               (nth 0
                    (nth 0
                         (abnf::tree-nonleaf->branches abnf::cst))))
          (abnf::rulename "token"))
     1)
    ((equal
          (abnf::tree-nonleaf->rulename?
               (nth 0
                    (nth 0
                         (abnf::tree-nonleaf->branches abnf::cst))))
          (abnf::rulename "comment"))
     2)
    ((equal
          (abnf::tree-nonleaf->rulename?
               (nth 0
                    (nth 0
                         (abnf::tree-nonleaf->branches abnf::cst))))
          (abnf::rulename "whitespace"))
     3)
    (t (prog2$ (impossible) 1)))))

Theorem: posp-of-cst-lexeme-conc?

(defthm posp-of-cst-lexeme-conc?
  (b* ((number (cst-lexeme-conc? abnf::cst)))
    (posp number))
  :rule-classes :rewrite)

Theorem: cst-lexeme-conc?-possibilities

(defthm cst-lexeme-conc?-possibilities
  (b* ((number (cst-lexeme-conc? abnf::cst)))
    (or (equal number 1)
        (equal number 2)
        (equal number 3)))
  :rule-classes
  ((:forward-chaining
        :trigger-terms ((cst-lexeme-conc? abnf::cst)))))

Theorem: cst-lexeme-conc?-of-tree-fix-cst

(defthm cst-lexeme-conc?-of-tree-fix-cst
  (equal (cst-lexeme-conc? (abnf::tree-fix abnf::cst))
         (cst-lexeme-conc? abnf::cst)))

Theorem: cst-lexeme-conc?-tree-equiv-congruence-on-cst

(defthm cst-lexeme-conc?-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-lexeme-conc? abnf::cst)
                  (cst-lexeme-conc? cst-equiv)))
  :rule-classes :congruence)

Theorem: cst-lexeme-conc?-1-iff-match-conc

(defthm cst-lexeme-conc?-1-iff-match-conc
  (implies (cst-matchp abnf::cst "lexeme")
           (iff (equal (cst-lexeme-conc? abnf::cst) 1)
                (cst-list-list-conc-matchp
                     (abnf::tree-nonleaf->branches abnf::cst)
                     "token"))))

Theorem: cst-lexeme-conc?-2-iff-match-conc

(defthm cst-lexeme-conc?-2-iff-match-conc
  (implies (cst-matchp abnf::cst "lexeme")
           (iff (equal (cst-lexeme-conc? abnf::cst) 2)
                (cst-list-list-conc-matchp
                     (abnf::tree-nonleaf->branches abnf::cst)
                     "comment"))))

Theorem: cst-lexeme-conc?-3-iff-match-conc

(defthm cst-lexeme-conc?-3-iff-match-conc
  (implies (cst-matchp abnf::cst "lexeme")
           (iff (equal (cst-lexeme-conc? abnf::cst) 3)
                (cst-list-list-conc-matchp
                     (abnf::tree-nonleaf->branches abnf::cst)
                     "whitespace"))))

Function: cst-integer-type-conc?

(defun cst-integer-type-conc? (abnf::cst)
 (declare (xargs :guard (abnf::treep abnf::cst)))
 (declare (xargs :guard (cst-matchp abnf::cst "integer-type")))
 (let ((__function__ 'cst-integer-type-conc?))
  (declare (ignorable __function__))
  (cond
    ((equal
          (abnf::tree-nonleaf->rulename?
               (nth 0
                    (nth 0
                         (abnf::tree-nonleaf->branches abnf::cst))))
          (abnf::rulename "unsigned-type"))
     1)
    ((equal
          (abnf::tree-nonleaf->rulename?
               (nth 0
                    (nth 0
                         (abnf::tree-nonleaf->branches abnf::cst))))
          (abnf::rulename "signed-type"))
     2)
    (t (prog2$ (impossible) 1)))))

Theorem: posp-of-cst-integer-type-conc?

(defthm posp-of-cst-integer-type-conc?
  (b* ((number (cst-integer-type-conc? abnf::cst)))
    (posp number))
  :rule-classes :rewrite)

Theorem: cst-integer-type-conc?-possibilities

(defthm cst-integer-type-conc?-possibilities
  (b* ((number (cst-integer-type-conc? abnf::cst)))
    (or (equal number 1) (equal number 2)))
  :rule-classes
  ((:forward-chaining
        :trigger-terms ((cst-integer-type-conc? abnf::cst)))))

Theorem: cst-integer-type-conc?-of-tree-fix-cst

(defthm cst-integer-type-conc?-of-tree-fix-cst
  (equal (cst-integer-type-conc? (abnf::tree-fix abnf::cst))
         (cst-integer-type-conc? abnf::cst)))

Theorem: cst-integer-type-conc?-tree-equiv-congruence-on-cst

(defthm cst-integer-type-conc?-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-integer-type-conc? abnf::cst)
                  (cst-integer-type-conc? cst-equiv)))
  :rule-classes :congruence)

Theorem: cst-integer-type-conc?-1-iff-match-conc

(defthm cst-integer-type-conc?-1-iff-match-conc
  (implies (cst-matchp abnf::cst "integer-type")
           (iff (equal (cst-integer-type-conc? abnf::cst)
                       1)
                (cst-list-list-conc-matchp
                     (abnf::tree-nonleaf->branches abnf::cst)
                     "unsigned-type"))))

Theorem: cst-integer-type-conc?-2-iff-match-conc

(defthm cst-integer-type-conc?-2-iff-match-conc
  (implies (cst-matchp abnf::cst "integer-type")
           (iff (equal (cst-integer-type-conc? abnf::cst)
                       2)
                (cst-list-list-conc-matchp
                     (abnf::tree-nonleaf->branches abnf::cst)
                     "signed-type"))))

Function: cst-arithmetic-type-conc?

(defun cst-arithmetic-type-conc? (abnf::cst)
 (declare (xargs :guard (abnf::treep abnf::cst)))
 (declare (xargs :guard (cst-matchp abnf::cst "arithmetic-type")))
 (let ((__function__ 'cst-arithmetic-type-conc?))
  (declare (ignorable __function__))
  (cond
    ((equal
          (abnf::tree-nonleaf->rulename?
               (nth 0
                    (nth 0
                         (abnf::tree-nonleaf->branches abnf::cst))))
          (abnf::rulename "integer-type"))
     1)
    ((equal
          (abnf::tree-nonleaf->rulename?
               (nth 0
                    (nth 0
                         (abnf::tree-nonleaf->branches abnf::cst))))
          (abnf::rulename "field-type"))
     2)
    ((equal
          (abnf::tree-nonleaf->rulename?
               (nth 0
                    (nth 0
                         (abnf::tree-nonleaf->branches abnf::cst))))
          (abnf::rulename "group-type"))
     3)
    ((equal
          (abnf::tree-nonleaf->rulename?
               (nth 0
                    (nth 0
                         (abnf::tree-nonleaf->branches abnf::cst))))
          (abnf::rulename "scalar-type"))
     4)
    (t (prog2$ (impossible) 1)))))

Theorem: posp-of-cst-arithmetic-type-conc?

(defthm posp-of-cst-arithmetic-type-conc?
  (b* ((number (cst-arithmetic-type-conc? abnf::cst)))
    (posp number))
  :rule-classes :rewrite)

Theorem: cst-arithmetic-type-conc?-possibilities

(defthm cst-arithmetic-type-conc?-possibilities
  (b* ((number (cst-arithmetic-type-conc? abnf::cst)))
    (or (equal number 1)
        (equal number 2)
        (equal number 3)
        (equal number 4)))
  :rule-classes
  ((:forward-chaining
        :trigger-terms ((cst-arithmetic-type-conc? abnf::cst)))))

Theorem: cst-arithmetic-type-conc?-of-tree-fix-cst

(defthm cst-arithmetic-type-conc?-of-tree-fix-cst
  (equal (cst-arithmetic-type-conc? (abnf::tree-fix abnf::cst))
         (cst-arithmetic-type-conc? abnf::cst)))

Theorem: cst-arithmetic-type-conc?-tree-equiv-congruence-on-cst

(defthm cst-arithmetic-type-conc?-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-arithmetic-type-conc? abnf::cst)
                  (cst-arithmetic-type-conc? cst-equiv)))
  :rule-classes :congruence)

Theorem: cst-arithmetic-type-conc?-1-iff-match-conc

(defthm cst-arithmetic-type-conc?-1-iff-match-conc
  (implies (cst-matchp abnf::cst "arithmetic-type")
           (iff (equal (cst-arithmetic-type-conc? abnf::cst)
                       1)
                (cst-list-list-conc-matchp
                     (abnf::tree-nonleaf->branches abnf::cst)
                     "integer-type"))))

Theorem: cst-arithmetic-type-conc?-2-iff-match-conc

(defthm cst-arithmetic-type-conc?-2-iff-match-conc
  (implies (cst-matchp abnf::cst "arithmetic-type")
           (iff (equal (cst-arithmetic-type-conc? abnf::cst)
                       2)
                (cst-list-list-conc-matchp
                     (abnf::tree-nonleaf->branches abnf::cst)
                     "field-type"))))

Theorem: cst-arithmetic-type-conc?-3-iff-match-conc

(defthm cst-arithmetic-type-conc?-3-iff-match-conc
  (implies (cst-matchp abnf::cst "arithmetic-type")
           (iff (equal (cst-arithmetic-type-conc? abnf::cst)
                       3)
                (cst-list-list-conc-matchp
                     (abnf::tree-nonleaf->branches abnf::cst)
                     "group-type"))))

Theorem: cst-arithmetic-type-conc?-4-iff-match-conc

(defthm cst-arithmetic-type-conc?-4-iff-match-conc
  (implies (cst-matchp abnf::cst "arithmetic-type")
           (iff (equal (cst-arithmetic-type-conc? abnf::cst)
                       4)
                (cst-list-list-conc-matchp
                     (abnf::tree-nonleaf->branches abnf::cst)
                     "scalar-type"))))

Function: cst-named-primitive-type-conc?

(defun cst-named-primitive-type-conc? (abnf::cst)
 (declare (xargs :guard (abnf::treep abnf::cst)))
 (declare
      (xargs :guard (cst-matchp abnf::cst "named-primitive-type")))
 (let ((__function__ 'cst-named-primitive-type-conc?))
  (declare (ignorable __function__))
  (cond
    ((equal
          (abnf::tree-nonleaf->rulename?
               (nth 0
                    (nth 0
                         (abnf::tree-nonleaf->branches abnf::cst))))
          (abnf::rulename "boolean-type"))
     1)
    ((equal
          (abnf::tree-nonleaf->rulename?
               (nth 0
                    (nth 0
                         (abnf::tree-nonleaf->branches abnf::cst))))
          (abnf::rulename "arithmetic-type"))
     2)
    ((equal
          (abnf::tree-nonleaf->rulename?
               (nth 0
                    (nth 0
                         (abnf::tree-nonleaf->branches abnf::cst))))
          (abnf::rulename "address-type"))
     3)
    ((equal
          (abnf::tree-nonleaf->rulename?
               (nth 0
                    (nth 0
                         (abnf::tree-nonleaf->branches abnf::cst))))
          (abnf::rulename "signature-type"))
     4)
    ((equal
          (abnf::tree-nonleaf->rulename?
               (nth 0
                    (nth 0
                         (abnf::tree-nonleaf->branches abnf::cst))))
          (abnf::rulename "string-type"))
     5)
    (t (prog2$ (impossible) 1)))))

Theorem: posp-of-cst-named-primitive-type-conc?

(defthm posp-of-cst-named-primitive-type-conc?
  (b* ((number (cst-named-primitive-type-conc? abnf::cst)))
    (posp number))
  :rule-classes :rewrite)

Theorem: cst-named-primitive-type-conc?-possibilities

(defthm cst-named-primitive-type-conc?-possibilities
 (b* ((number (cst-named-primitive-type-conc? abnf::cst)))
   (or (equal number 1)
       (equal number 2)
       (equal number 3)
       (equal number 4)
       (equal number 5)))
 :rule-classes
 ((:forward-chaining
      :trigger-terms ((cst-named-primitive-type-conc? abnf::cst)))))

Theorem: cst-named-primitive-type-conc?-of-tree-fix-cst

(defthm cst-named-primitive-type-conc?-of-tree-fix-cst
  (equal (cst-named-primitive-type-conc? (abnf::tree-fix abnf::cst))
         (cst-named-primitive-type-conc? abnf::cst)))

Theorem: cst-named-primitive-type-conc?-tree-equiv-congruence-on-cst

(defthm cst-named-primitive-type-conc?-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-named-primitive-type-conc? abnf::cst)
                  (cst-named-primitive-type-conc? cst-equiv)))
  :rule-classes :congruence)

Theorem: cst-named-primitive-type-conc?-1-iff-match-conc

(defthm cst-named-primitive-type-conc?-1-iff-match-conc
  (implies (cst-matchp abnf::cst "named-primitive-type")
           (iff (equal (cst-named-primitive-type-conc? abnf::cst)
                       1)
                (cst-list-list-conc-matchp
                     (abnf::tree-nonleaf->branches abnf::cst)
                     "boolean-type"))))

Theorem: cst-named-primitive-type-conc?-2-iff-match-conc

(defthm cst-named-primitive-type-conc?-2-iff-match-conc
  (implies (cst-matchp abnf::cst "named-primitive-type")
           (iff (equal (cst-named-primitive-type-conc? abnf::cst)
                       2)
                (cst-list-list-conc-matchp
                     (abnf::tree-nonleaf->branches abnf::cst)
                     "arithmetic-type"))))

Theorem: cst-named-primitive-type-conc?-3-iff-match-conc

(defthm cst-named-primitive-type-conc?-3-iff-match-conc
  (implies (cst-matchp abnf::cst "named-primitive-type")
           (iff (equal (cst-named-primitive-type-conc? abnf::cst)
                       3)
                (cst-list-list-conc-matchp
                     (abnf::tree-nonleaf->branches abnf::cst)
                     "address-type"))))

Theorem: cst-named-primitive-type-conc?-4-iff-match-conc

(defthm cst-named-primitive-type-conc?-4-iff-match-conc
  (implies (cst-matchp abnf::cst "named-primitive-type")
           (iff (equal (cst-named-primitive-type-conc? abnf::cst)
                       4)
                (cst-list-list-conc-matchp
                     (abnf::tree-nonleaf->branches abnf::cst)
                     "signature-type"))))

Theorem: cst-named-primitive-type-conc?-5-iff-match-conc

(defthm cst-named-primitive-type-conc?-5-iff-match-conc
  (implies (cst-matchp abnf::cst "named-primitive-type")
           (iff (equal (cst-named-primitive-type-conc? abnf::cst)
                       5)
                (cst-list-list-conc-matchp
                     (abnf::tree-nonleaf->branches abnf::cst)
                     "string-type"))))

Function: cst-primitive-type-conc?

(defun cst-primitive-type-conc? (abnf::cst)
 (declare (xargs :guard (abnf::treep abnf::cst)))
 (declare (xargs :guard (cst-matchp abnf::cst "primitive-type")))
 (let ((__function__ 'cst-primitive-type-conc?))
  (declare (ignorable __function__))
  (cond
    ((equal
          (abnf::tree-nonleaf->rulename?
               (nth 0
                    (nth 0
                         (abnf::tree-nonleaf->branches abnf::cst))))
          (abnf::rulename "named-primitive-type"))
     1)
    ((equal
          (abnf::tree-nonleaf->rulename?
               (nth 0
                    (nth 0
                         (abnf::tree-nonleaf->branches abnf::cst))))
          (abnf::rulename "unit-type"))
     2)
    (t (prog2$ (impossible) 1)))))

Theorem: posp-of-cst-primitive-type-conc?

(defthm posp-of-cst-primitive-type-conc?
  (b* ((number (cst-primitive-type-conc? abnf::cst)))
    (posp number))
  :rule-classes :rewrite)

Theorem: cst-primitive-type-conc?-possibilities

(defthm cst-primitive-type-conc?-possibilities
  (b* ((number (cst-primitive-type-conc? abnf::cst)))
    (or (equal number 1) (equal number 2)))
  :rule-classes
  ((:forward-chaining
        :trigger-terms ((cst-primitive-type-conc? abnf::cst)))))

Theorem: cst-primitive-type-conc?-of-tree-fix-cst

(defthm cst-primitive-type-conc?-of-tree-fix-cst
  (equal (cst-primitive-type-conc? (abnf::tree-fix abnf::cst))
         (cst-primitive-type-conc? abnf::cst)))

Theorem: cst-primitive-type-conc?-tree-equiv-congruence-on-cst

(defthm cst-primitive-type-conc?-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-primitive-type-conc? abnf::cst)
                  (cst-primitive-type-conc? cst-equiv)))
  :rule-classes :congruence)

Theorem: cst-primitive-type-conc?-1-iff-match-conc

(defthm cst-primitive-type-conc?-1-iff-match-conc
  (implies (cst-matchp abnf::cst "primitive-type")
           (iff (equal (cst-primitive-type-conc? abnf::cst)
                       1)
                (cst-list-list-conc-matchp
                     (abnf::tree-nonleaf->branches abnf::cst)
                     "named-primitive-type"))))

Theorem: cst-primitive-type-conc?-2-iff-match-conc

(defthm cst-primitive-type-conc?-2-iff-match-conc
  (implies (cst-matchp abnf::cst "primitive-type")
           (iff (equal (cst-primitive-type-conc? abnf::cst)
                       2)
                (cst-list-list-conc-matchp
                     (abnf::tree-nonleaf->branches abnf::cst)
                     "unit-type"))))

Function: cst-future-type-conc?

(defun cst-future-type-conc? (abnf::cst)
 (declare (xargs :guard (abnf::treep abnf::cst)))
 (declare (xargs :guard (cst-matchp abnf::cst "future-type")))
 (let ((__function__ 'cst-future-type-conc?))
  (declare (ignorable __function__))
  (cond
    ((equal
          (abnf::tree-nonleaf->rulename?
               (nth 0
                    (nth 0
                         (abnf::tree-nonleaf->branches abnf::cst))))
          (abnf::rulename "untyped-future-type"))
     1)
    ((equal
          (abnf::tree-nonleaf->rulename?
               (nth 0
                    (nth 0
                         (abnf::tree-nonleaf->branches abnf::cst))))
          (abnf::rulename "typed-future-type"))
     2)
    (t (prog2$ (impossible) 1)))))

Theorem: posp-of-cst-future-type-conc?

(defthm posp-of-cst-future-type-conc?
  (b* ((number (cst-future-type-conc? abnf::cst)))
    (posp number))
  :rule-classes :rewrite)

Theorem: cst-future-type-conc?-possibilities

(defthm cst-future-type-conc?-possibilities
  (b* ((number (cst-future-type-conc? abnf::cst)))
    (or (equal number 1) (equal number 2)))
  :rule-classes
  ((:forward-chaining
        :trigger-terms ((cst-future-type-conc? abnf::cst)))))

Theorem: cst-future-type-conc?-of-tree-fix-cst

(defthm cst-future-type-conc?-of-tree-fix-cst
  (equal (cst-future-type-conc? (abnf::tree-fix abnf::cst))
         (cst-future-type-conc? abnf::cst)))

Theorem: cst-future-type-conc?-tree-equiv-congruence-on-cst

(defthm cst-future-type-conc?-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-future-type-conc? abnf::cst)
                  (cst-future-type-conc? cst-equiv)))
  :rule-classes :congruence)

Theorem: cst-future-type-conc?-1-iff-match-conc

(defthm cst-future-type-conc?-1-iff-match-conc
  (implies (cst-matchp abnf::cst "future-type")
           (iff (equal (cst-future-type-conc? abnf::cst)
                       1)
                (cst-list-list-conc-matchp
                     (abnf::tree-nonleaf->branches abnf::cst)
                     "untyped-future-type"))))

Theorem: cst-future-type-conc?-2-iff-match-conc

(defthm cst-future-type-conc?-2-iff-match-conc
  (implies (cst-matchp abnf::cst "future-type")
           (iff (equal (cst-future-type-conc? abnf::cst)
                       2)
                (cst-list-list-conc-matchp
                     (abnf::tree-nonleaf->branches abnf::cst)
                     "typed-future-type"))))

Function: cst-type-conc?

(defun cst-type-conc? (abnf::cst)
 (declare (xargs :guard (abnf::treep abnf::cst)))
 (declare (xargs :guard (cst-matchp abnf::cst "type")))
 (let ((__function__ 'cst-type-conc?))
  (declare (ignorable __function__))
  (cond
    ((equal
          (abnf::tree-nonleaf->rulename?
               (nth 0
                    (nth 0
                         (abnf::tree-nonleaf->branches abnf::cst))))
          (abnf::rulename "primitive-type"))
     1)
    ((equal
          (abnf::tree-nonleaf->rulename?
               (nth 0
                    (nth 0
                         (abnf::tree-nonleaf->branches abnf::cst))))
          (abnf::rulename "future-type"))
     2)
    ((equal
          (abnf::tree-nonleaf->rulename?
               (nth 0
                    (nth 0
                         (abnf::tree-nonleaf->branches abnf::cst))))
          (abnf::rulename "tuple-type"))
     3)
    ((equal
          (abnf::tree-nonleaf->rulename?
               (nth 0
                    (nth 0
                         (abnf::tree-nonleaf->branches abnf::cst))))
          (abnf::rulename "array-type"))
     4)
    (t (prog2$ (impossible) 1)))))

Theorem: posp-of-cst-type-conc?

(defthm posp-of-cst-type-conc?
  (b* ((number (cst-type-conc? abnf::cst)))
    (posp number))
  :rule-classes :rewrite)

Theorem: cst-type-conc?-possibilities

(defthm cst-type-conc?-possibilities
  (b* ((number (cst-type-conc? abnf::cst)))
    (or (equal number 1)
        (equal number 2)
        (equal number 3)
        (equal number 4)))
  :rule-classes
  ((:forward-chaining :trigger-terms ((cst-type-conc? abnf::cst)))))

Theorem: cst-type-conc?-of-tree-fix-cst

(defthm cst-type-conc?-of-tree-fix-cst
  (equal (cst-type-conc? (abnf::tree-fix abnf::cst))
         (cst-type-conc? abnf::cst)))

Theorem: cst-type-conc?-tree-equiv-congruence-on-cst

(defthm cst-type-conc?-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-type-conc? abnf::cst)
                  (cst-type-conc? cst-equiv)))
  :rule-classes :congruence)

Theorem: cst-type-conc?-1-iff-match-conc

(defthm cst-type-conc?-1-iff-match-conc
  (implies (cst-matchp abnf::cst "type")
           (iff (equal (cst-type-conc? abnf::cst) 1)
                (cst-list-list-conc-matchp
                     (abnf::tree-nonleaf->branches abnf::cst)
                     "primitive-type"))))

Theorem: cst-type-conc?-2-iff-match-conc

(defthm cst-type-conc?-2-iff-match-conc
  (implies (cst-matchp abnf::cst "type")
           (iff (equal (cst-type-conc? abnf::cst) 2)
                (cst-list-list-conc-matchp
                     (abnf::tree-nonleaf->branches abnf::cst)
                     "future-type"))))

Theorem: cst-type-conc?-3-iff-match-conc

(defthm cst-type-conc?-3-iff-match-conc
  (implies (cst-matchp abnf::cst "type")
           (iff (equal (cst-type-conc? abnf::cst) 3)
                (cst-list-list-conc-matchp
                     (abnf::tree-nonleaf->branches abnf::cst)
                     "tuple-type"))))

Theorem: cst-type-conc?-4-iff-match-conc

(defthm cst-type-conc?-4-iff-match-conc
  (implies (cst-matchp abnf::cst "type")
           (iff (equal (cst-type-conc? abnf::cst) 4)
                (cst-list-list-conc-matchp
                     (abnf::tree-nonleaf->branches abnf::cst)
                     "array-type"))))

Function: cst-named-type-conc?

(defun cst-named-type-conc? (abnf::cst)
 (declare (xargs :guard (abnf::treep abnf::cst)))
 (declare (xargs :guard (cst-matchp abnf::cst "named-type")))
 (let ((__function__ 'cst-named-type-conc?))
  (declare (ignorable __function__))
  (cond
    ((equal
          (abnf::tree-nonleaf->rulename?
               (nth 0
                    (nth 0
                         (abnf::tree-nonleaf->branches abnf::cst))))
          (abnf::rulename "named-primitive-type"))
     1)
    ((equal
          (abnf::tree-nonleaf->rulename?
               (nth 0
                    (nth 0
                         (abnf::tree-nonleaf->branches abnf::cst))))
          (abnf::rulename "untyped-future-type"))
     2)
    ((equal
          (abnf::tree-nonleaf->rulename?
               (nth 0
                    (nth 0
                         (abnf::tree-nonleaf->branches abnf::cst))))
          (abnf::rulename "identifier"))
     3)
    (t (prog2$ (impossible) 1)))))

Theorem: posp-of-cst-named-type-conc?

(defthm posp-of-cst-named-type-conc?
  (b* ((number (cst-named-type-conc? abnf::cst)))
    (posp number))
  :rule-classes :rewrite)

Theorem: cst-named-type-conc?-possibilities

(defthm cst-named-type-conc?-possibilities
  (b* ((number (cst-named-type-conc? abnf::cst)))
    (or (equal number 1)
        (equal number 2)
        (equal number 3)))
  :rule-classes
  ((:forward-chaining
        :trigger-terms ((cst-named-type-conc? abnf::cst)))))

Theorem: cst-named-type-conc?-of-tree-fix-cst

(defthm cst-named-type-conc?-of-tree-fix-cst
  (equal (cst-named-type-conc? (abnf::tree-fix abnf::cst))
         (cst-named-type-conc? abnf::cst)))

Theorem: cst-named-type-conc?-tree-equiv-congruence-on-cst

(defthm cst-named-type-conc?-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-named-type-conc? abnf::cst)
                  (cst-named-type-conc? cst-equiv)))
  :rule-classes :congruence)

Theorem: cst-named-type-conc?-1-iff-match-conc

(defthm cst-named-type-conc?-1-iff-match-conc
  (implies (cst-matchp abnf::cst "named-type")
           (iff (equal (cst-named-type-conc? abnf::cst)
                       1)
                (cst-list-list-conc-matchp
                     (abnf::tree-nonleaf->branches abnf::cst)
                     "named-primitive-type"))))

Theorem: cst-named-type-conc?-2-iff-match-conc

(defthm cst-named-type-conc?-2-iff-match-conc
  (implies (cst-matchp abnf::cst "named-type")
           (iff (equal (cst-named-type-conc? abnf::cst)
                       2)
                (cst-list-list-conc-matchp
                     (abnf::tree-nonleaf->branches abnf::cst)
                     "untyped-future-type"))))

Theorem: cst-named-type-conc?-3-iff-match-conc

(defthm cst-named-type-conc?-3-iff-match-conc
  (implies (cst-matchp abnf::cst "named-type")
           (iff (equal (cst-named-type-conc? abnf::cst)
                       3)
                (cst-list-list-conc-matchp
                     (abnf::tree-nonleaf->branches abnf::cst)
                     "identifier"))))

Function: cst-literal-conc?

(defun cst-literal-conc? (abnf::cst)
 (declare (xargs :guard (abnf::treep abnf::cst)))
 (declare (xargs :guard (cst-matchp abnf::cst "literal")))
 (let ((__function__ 'cst-literal-conc?))
  (declare (ignorable __function__))
  (cond
    ((equal
          (abnf::tree-nonleaf->rulename?
               (nth 0
                    (nth 0
                         (abnf::tree-nonleaf->branches abnf::cst))))
          (abnf::rulename "atomic-literal"))
     1)
    ((equal
          (abnf::tree-nonleaf->rulename?
               (nth 0
                    (nth 0
                         (abnf::tree-nonleaf->branches abnf::cst))))
          (abnf::rulename "program-address-literal"))
     2)
    (t (prog2$ (impossible) 1)))))

Theorem: posp-of-cst-literal-conc?

(defthm posp-of-cst-literal-conc?
  (b* ((number (cst-literal-conc? abnf::cst)))
    (posp number))
  :rule-classes :rewrite)

Theorem: cst-literal-conc?-possibilities

(defthm cst-literal-conc?-possibilities
  (b* ((number (cst-literal-conc? abnf::cst)))
    (or (equal number 1) (equal number 2)))
  :rule-classes
  ((:forward-chaining
        :trigger-terms ((cst-literal-conc? abnf::cst)))))

Theorem: cst-literal-conc?-of-tree-fix-cst

(defthm cst-literal-conc?-of-tree-fix-cst
  (equal (cst-literal-conc? (abnf::tree-fix abnf::cst))
         (cst-literal-conc? abnf::cst)))

Theorem: cst-literal-conc?-tree-equiv-congruence-on-cst

(defthm cst-literal-conc?-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-literal-conc? abnf::cst)
                  (cst-literal-conc? cst-equiv)))
  :rule-classes :congruence)

Theorem: cst-literal-conc?-1-iff-match-conc

(defthm cst-literal-conc?-1-iff-match-conc
  (implies (cst-matchp abnf::cst "literal")
           (iff (equal (cst-literal-conc? abnf::cst) 1)
                (cst-list-list-conc-matchp
                     (abnf::tree-nonleaf->branches abnf::cst)
                     "atomic-literal"))))

Theorem: cst-literal-conc?-2-iff-match-conc

(defthm cst-literal-conc?-2-iff-match-conc
  (implies (cst-matchp abnf::cst "literal")
           (iff (equal (cst-literal-conc? abnf::cst) 2)
                (cst-list-list-conc-matchp
                     (abnf::tree-nonleaf->branches abnf::cst)
                     "program-address-literal"))))

Function: cst-address-literal-conc?

(defun cst-address-literal-conc? (abnf::cst)
 (declare (xargs :guard (abnf::treep abnf::cst)))
 (declare (xargs :guard (cst-matchp abnf::cst "address-literal")))
 (let ((__function__ 'cst-address-literal-conc?))
  (declare (ignorable __function__))
  (cond
    ((equal
          (abnf::tree-nonleaf->rulename?
               (nth 0
                    (nth 0
                         (abnf::tree-nonleaf->branches abnf::cst))))
          (abnf::rulename "explicit-address-literal"))
     1)
    ((equal
          (abnf::tree-nonleaf->rulename?
               (nth 0
                    (nth 0
                         (abnf::tree-nonleaf->branches abnf::cst))))
          (abnf::rulename "program-address-literal"))
     2)
    (t (prog2$ (impossible) 1)))))

Theorem: posp-of-cst-address-literal-conc?

(defthm posp-of-cst-address-literal-conc?
  (b* ((number (cst-address-literal-conc? abnf::cst)))
    (posp number))
  :rule-classes :rewrite)

Theorem: cst-address-literal-conc?-possibilities

(defthm cst-address-literal-conc?-possibilities
  (b* ((number (cst-address-literal-conc? abnf::cst)))
    (or (equal number 1) (equal number 2)))
  :rule-classes
  ((:forward-chaining
        :trigger-terms ((cst-address-literal-conc? abnf::cst)))))

Theorem: cst-address-literal-conc?-of-tree-fix-cst

(defthm cst-address-literal-conc?-of-tree-fix-cst
  (equal (cst-address-literal-conc? (abnf::tree-fix abnf::cst))
         (cst-address-literal-conc? abnf::cst)))

Theorem: cst-address-literal-conc?-tree-equiv-congruence-on-cst

(defthm cst-address-literal-conc?-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-address-literal-conc? abnf::cst)
                  (cst-address-literal-conc? cst-equiv)))
  :rule-classes :congruence)

Theorem: cst-address-literal-conc?-1-iff-match-conc

(defthm cst-address-literal-conc?-1-iff-match-conc
  (implies (cst-matchp abnf::cst "address-literal")
           (iff (equal (cst-address-literal-conc? abnf::cst)
                       1)
                (cst-list-list-conc-matchp
                     (abnf::tree-nonleaf->branches abnf::cst)
                     "explicit-address-literal"))))

Theorem: cst-address-literal-conc?-2-iff-match-conc

(defthm cst-address-literal-conc?-2-iff-match-conc
  (implies (cst-matchp abnf::cst "address-literal")
           (iff (equal (cst-address-literal-conc? abnf::cst)
                       2)
                (cst-list-list-conc-matchp
                     (abnf::tree-nonleaf->branches abnf::cst)
                     "program-address-literal"))))

Function: cst-postfix-expression-conc?

(defun cst-postfix-expression-conc? (abnf::cst)
 (declare (xargs :guard (abnf::treep abnf::cst)))
 (declare
      (xargs :guard (cst-matchp abnf::cst "postfix-expression")))
 (let ((__function__ 'cst-postfix-expression-conc?))
  (declare (ignorable __function__))
  (cond
    ((equal
          (abnf::tree-nonleaf->rulename?
               (nth 0
                    (nth 0
                         (abnf::tree-nonleaf->branches abnf::cst))))
          (abnf::rulename "primary-expression"))
     1)
    ((equal
          (abnf::tree-nonleaf->rulename?
               (nth 0
                    (nth 0
                         (abnf::tree-nonleaf->branches abnf::cst))))
          (abnf::rulename "tuple-component-expression"))
     2)
    ((equal
          (abnf::tree-nonleaf->rulename?
               (nth 0
                    (nth 0
                         (abnf::tree-nonleaf->branches abnf::cst))))
          (abnf::rulename "array-component-expression"))
     3)
    ((equal
          (abnf::tree-nonleaf->rulename?
               (nth 0
                    (nth 0
                         (abnf::tree-nonleaf->branches abnf::cst))))
          (abnf::rulename "struct-component-expression"))
     4)
    ((equal
          (abnf::tree-nonleaf->rulename?
               (nth 0
                    (nth 0
                         (abnf::tree-nonleaf->branches abnf::cst))))
          (abnf::rulename "method-call"))
     5)
    (t (prog2$ (impossible) 1)))))

Theorem: posp-of-cst-postfix-expression-conc?

(defthm posp-of-cst-postfix-expression-conc?
  (b* ((number (cst-postfix-expression-conc? abnf::cst)))
    (posp number))
  :rule-classes :rewrite)

Theorem: cst-postfix-expression-conc?-possibilities

(defthm cst-postfix-expression-conc?-possibilities
  (b* ((number (cst-postfix-expression-conc? abnf::cst)))
    (or (equal number 1)
        (equal number 2)
        (equal number 3)
        (equal number 4)
        (equal number 5)))
  :rule-classes
  ((:forward-chaining
        :trigger-terms ((cst-postfix-expression-conc? abnf::cst)))))

Theorem: cst-postfix-expression-conc?-of-tree-fix-cst

(defthm cst-postfix-expression-conc?-of-tree-fix-cst
  (equal (cst-postfix-expression-conc? (abnf::tree-fix abnf::cst))
         (cst-postfix-expression-conc? abnf::cst)))

Theorem: cst-postfix-expression-conc?-tree-equiv-congruence-on-cst

(defthm cst-postfix-expression-conc?-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-postfix-expression-conc? abnf::cst)
                  (cst-postfix-expression-conc? cst-equiv)))
  :rule-classes :congruence)

Theorem: cst-postfix-expression-conc?-1-iff-match-conc

(defthm cst-postfix-expression-conc?-1-iff-match-conc
  (implies (cst-matchp abnf::cst "postfix-expression")
           (iff (equal (cst-postfix-expression-conc? abnf::cst)
                       1)
                (cst-list-list-conc-matchp
                     (abnf::tree-nonleaf->branches abnf::cst)
                     "primary-expression"))))

Theorem: cst-postfix-expression-conc?-2-iff-match-conc

(defthm cst-postfix-expression-conc?-2-iff-match-conc
  (implies (cst-matchp abnf::cst "postfix-expression")
           (iff (equal (cst-postfix-expression-conc? abnf::cst)
                       2)
                (cst-list-list-conc-matchp
                     (abnf::tree-nonleaf->branches abnf::cst)
                     "tuple-component-expression"))))

Theorem: cst-postfix-expression-conc?-3-iff-match-conc

(defthm cst-postfix-expression-conc?-3-iff-match-conc
  (implies (cst-matchp abnf::cst "postfix-expression")
           (iff (equal (cst-postfix-expression-conc? abnf::cst)
                       3)
                (cst-list-list-conc-matchp
                     (abnf::tree-nonleaf->branches abnf::cst)
                     "array-component-expression"))))

Theorem: cst-postfix-expression-conc?-4-iff-match-conc

(defthm cst-postfix-expression-conc?-4-iff-match-conc
  (implies (cst-matchp abnf::cst "postfix-expression")
           (iff (equal (cst-postfix-expression-conc? abnf::cst)
                       4)
                (cst-list-list-conc-matchp
                     (abnf::tree-nonleaf->branches abnf::cst)
                     "struct-component-expression"))))

Theorem: cst-postfix-expression-conc?-5-iff-match-conc

(defthm cst-postfix-expression-conc?-5-iff-match-conc
  (implies (cst-matchp abnf::cst "postfix-expression")
           (iff (equal (cst-postfix-expression-conc? abnf::cst)
                       5)
                (cst-list-list-conc-matchp
                     (abnf::tree-nonleaf->branches abnf::cst)
                     "method-call"))))

Function: cst-statement-conc?

(defun cst-statement-conc? (abnf::cst)
 (declare (xargs :guard (abnf::treep abnf::cst)))
 (declare (xargs :guard (cst-matchp abnf::cst "statement")))
 (let ((__function__ 'cst-statement-conc?))
  (declare (ignorable __function__))
  (cond
    ((equal
          (abnf::tree-nonleaf->rulename?
               (nth 0
                    (nth 0
                         (abnf::tree-nonleaf->branches abnf::cst))))
          (abnf::rulename "expression-statement"))
     1)
    ((equal
          (abnf::tree-nonleaf->rulename?
               (nth 0
                    (nth 0
                         (abnf::tree-nonleaf->branches abnf::cst))))
          (abnf::rulename "return-statement"))
     2)
    ((equal
          (abnf::tree-nonleaf->rulename?
               (nth 0
                    (nth 0
                         (abnf::tree-nonleaf->branches abnf::cst))))
          (abnf::rulename "variable-declaration"))
     3)
    ((equal
          (abnf::tree-nonleaf->rulename?
               (nth 0
                    (nth 0
                         (abnf::tree-nonleaf->branches abnf::cst))))
          (abnf::rulename "constant-declaration"))
     4)
    ((equal
          (abnf::tree-nonleaf->rulename?
               (nth 0
                    (nth 0
                         (abnf::tree-nonleaf->branches abnf::cst))))
          (abnf::rulename "conditional-statement"))
     5)
    ((equal
          (abnf::tree-nonleaf->rulename?
               (nth 0
                    (nth 0
                         (abnf::tree-nonleaf->branches abnf::cst))))
          (abnf::rulename "loop-statement"))
     6)
    ((equal
          (abnf::tree-nonleaf->rulename?
               (nth 0
                    (nth 0
                         (abnf::tree-nonleaf->branches abnf::cst))))
          (abnf::rulename "assignment-statement"))
     7)
    ((equal
          (abnf::tree-nonleaf->rulename?
               (nth 0
                    (nth 0
                         (abnf::tree-nonleaf->branches abnf::cst))))
          (abnf::rulename "block"))
     8)
    (t (prog2$ (impossible) 1)))))

Theorem: posp-of-cst-statement-conc?

(defthm posp-of-cst-statement-conc?
  (b* ((number (cst-statement-conc? abnf::cst)))
    (posp number))
  :rule-classes :rewrite)

Theorem: cst-statement-conc?-possibilities

(defthm cst-statement-conc?-possibilities
  (b* ((number (cst-statement-conc? abnf::cst)))
    (or (equal number 1)
        (equal number 2)
        (equal number 3)
        (equal number 4)
        (equal number 5)
        (equal number 6)
        (equal number 7)
        (equal number 8)))
  :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)
                     "expression-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)
                     "return-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)
                     "variable-declaration"))))

Theorem: cst-statement-conc?-4-iff-match-conc

(defthm cst-statement-conc?-4-iff-match-conc
  (implies (cst-matchp abnf::cst "statement")
           (iff (equal (cst-statement-conc? abnf::cst)
                       4)
                (cst-list-list-conc-matchp
                     (abnf::tree-nonleaf->branches abnf::cst)
                     "constant-declaration"))))

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)
                     "conditional-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)
                     "loop-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)
                     "assignment-statement"))))

Theorem: cst-statement-conc?-8-iff-match-conc

(defthm cst-statement-conc?-8-iff-match-conc
  (implies (cst-matchp abnf::cst "statement")
           (iff (equal (cst-statement-conc? abnf::cst)
                       8)
                (cst-list-list-conc-matchp
                     (abnf::tree-nonleaf->branches abnf::cst)
                     "block"))))

Function: cst-program-item-conc?

(defun cst-program-item-conc? (abnf::cst)
 (declare (xargs :guard (abnf::treep abnf::cst)))
 (declare (xargs :guard (cst-matchp abnf::cst "program-item")))
 (let ((__function__ 'cst-program-item-conc?))
  (declare (ignorable __function__))
  (cond
    ((equal
          (abnf::tree-nonleaf->rulename?
               (nth 0
                    (nth 0
                         (abnf::tree-nonleaf->branches abnf::cst))))
          (abnf::rulename "function-declaration"))
     1)
    ((equal
          (abnf::tree-nonleaf->rulename?
               (nth 0
                    (nth 0
                         (abnf::tree-nonleaf->branches abnf::cst))))
          (abnf::rulename "struct-declaration"))
     2)
    ((equal
          (abnf::tree-nonleaf->rulename?
               (nth 0
                    (nth 0
                         (abnf::tree-nonleaf->branches abnf::cst))))
          (abnf::rulename "record-declaration"))
     3)
    ((equal
          (abnf::tree-nonleaf->rulename?
               (nth 0
                    (nth 0
                         (abnf::tree-nonleaf->branches abnf::cst))))
          (abnf::rulename "mapping-declaration"))
     4)
    ((equal
          (abnf::tree-nonleaf->rulename?
               (nth 0
                    (nth 0
                         (abnf::tree-nonleaf->branches abnf::cst))))
          (abnf::rulename "constant-declaration"))
     5)
    (t (prog2$ (impossible) 1)))))

Theorem: posp-of-cst-program-item-conc?

(defthm posp-of-cst-program-item-conc?
  (b* ((number (cst-program-item-conc? abnf::cst)))
    (posp number))
  :rule-classes :rewrite)

Theorem: cst-program-item-conc?-possibilities

(defthm cst-program-item-conc?-possibilities
  (b* ((number (cst-program-item-conc? abnf::cst)))
    (or (equal number 1)
        (equal number 2)
        (equal number 3)
        (equal number 4)
        (equal number 5)))
  :rule-classes
  ((:forward-chaining
        :trigger-terms ((cst-program-item-conc? abnf::cst)))))

Theorem: cst-program-item-conc?-of-tree-fix-cst

(defthm cst-program-item-conc?-of-tree-fix-cst
  (equal (cst-program-item-conc? (abnf::tree-fix abnf::cst))
         (cst-program-item-conc? abnf::cst)))

Theorem: cst-program-item-conc?-tree-equiv-congruence-on-cst

(defthm cst-program-item-conc?-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-program-item-conc? abnf::cst)
                  (cst-program-item-conc? cst-equiv)))
  :rule-classes :congruence)

Theorem: cst-program-item-conc?-1-iff-match-conc

(defthm cst-program-item-conc?-1-iff-match-conc
  (implies (cst-matchp abnf::cst "program-item")
           (iff (equal (cst-program-item-conc? abnf::cst)
                       1)
                (cst-list-list-conc-matchp
                     (abnf::tree-nonleaf->branches abnf::cst)
                     "function-declaration"))))

Theorem: cst-program-item-conc?-2-iff-match-conc

(defthm cst-program-item-conc?-2-iff-match-conc
  (implies (cst-matchp abnf::cst "program-item")
           (iff (equal (cst-program-item-conc? abnf::cst)
                       2)
                (cst-list-list-conc-matchp
                     (abnf::tree-nonleaf->branches abnf::cst)
                     "struct-declaration"))))

Theorem: cst-program-item-conc?-3-iff-match-conc

(defthm cst-program-item-conc?-3-iff-match-conc
  (implies (cst-matchp abnf::cst "program-item")
           (iff (equal (cst-program-item-conc? abnf::cst)
                       3)
                (cst-list-list-conc-matchp
                     (abnf::tree-nonleaf->branches abnf::cst)
                     "record-declaration"))))

Theorem: cst-program-item-conc?-4-iff-match-conc

(defthm cst-program-item-conc?-4-iff-match-conc
  (implies (cst-matchp abnf::cst "program-item")
           (iff (equal (cst-program-item-conc? abnf::cst)
                       4)
                (cst-list-list-conc-matchp
                     (abnf::tree-nonleaf->branches abnf::cst)
                     "mapping-declaration"))))

Theorem: cst-program-item-conc?-5-iff-match-conc

(defthm cst-program-item-conc?-5-iff-match-conc
  (implies (cst-matchp abnf::cst "program-item")
           (iff (equal (cst-program-item-conc? abnf::cst)
                       5)
                (cst-list-list-conc-matchp
                     (abnf::tree-nonleaf->branches abnf::cst)
                     "constant-declaration"))))

Function: cst-ascii-conc

(defun cst-ascii-conc (abnf::cst)
  (declare (xargs :guard (abnf::treep abnf::cst)))
  (declare (xargs :guard (cst-matchp abnf::cst "ascii")))
  (let ((__function__ 'cst-ascii-conc))
    (declare (ignorable __function__))
    (abnf::tree-nonleaf->branches abnf::cst)))

Theorem: tree-list-listp-of-cst-ascii-conc

(defthm tree-list-listp-of-cst-ascii-conc
  (b* ((abnf::cstss (cst-ascii-conc abnf::cst)))
    (abnf::tree-list-listp abnf::cstss))
  :rule-classes :rewrite)

Theorem: cst-ascii-conc-match

(defthm cst-ascii-conc-match
  (implies (cst-matchp abnf::cst "ascii")
           (b* ((abnf::cstss (cst-ascii-conc abnf::cst)))
             (cst-list-list-conc-matchp abnf::cstss "%x0-7F")))
  :rule-classes :rewrite)

Theorem: cst-ascii-conc-of-tree-fix-cst

(defthm cst-ascii-conc-of-tree-fix-cst
  (equal (cst-ascii-conc (abnf::tree-fix abnf::cst))
         (cst-ascii-conc abnf::cst)))

Theorem: cst-ascii-conc-tree-equiv-congruence-on-cst

(defthm cst-ascii-conc-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-ascii-conc abnf::cst)
                  (cst-ascii-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 "ascii")))
  :rule-classes :rewrite)

Theorem: cst-character-conc1-of-tree-fix-cst

(defthm cst-character-conc1-of-tree-fix-cst
  (equal (cst-character-conc1 (abnf::tree-fix abnf::cst))
         (cst-character-conc1 abnf::cst)))

Theorem: cst-character-conc1-tree-equiv-congruence-on-cst

(defthm cst-character-conc1-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-character-conc1 abnf::cst)
                  (cst-character-conc1 cst-equiv)))
  :rule-classes :congruence)

Function: cst-character-conc2

(defun cst-character-conc2 (abnf::cst)
  (declare (xargs :guard (abnf::treep abnf::cst)))
  (declare (xargs :guard (and (cst-matchp abnf::cst "character")
                              (equal (cst-character-conc? abnf::cst)
                                     2))))
  (let ((__function__ 'cst-character-conc2))
    (declare (ignorable __function__))
    (abnf::tree-nonleaf->branches abnf::cst)))

Theorem: tree-list-listp-of-cst-character-conc2

(defthm tree-list-listp-of-cst-character-conc2
  (b* ((abnf::cstss (cst-character-conc2 abnf::cst)))
    (abnf::tree-list-listp abnf::cstss))
  :rule-classes :rewrite)

Theorem: cst-character-conc2-match

(defthm cst-character-conc2-match
  (implies
       (and (cst-matchp abnf::cst "character")
            (equal (cst-character-conc? abnf::cst)
                   2))
       (b* ((abnf::cstss (cst-character-conc2 abnf::cst)))
         (cst-list-list-conc-matchp abnf::cstss "safe-nonascii")))
  :rule-classes :rewrite)

Theorem: cst-character-conc2-of-tree-fix-cst

(defthm cst-character-conc2-of-tree-fix-cst
  (equal (cst-character-conc2 (abnf::tree-fix abnf::cst))
         (cst-character-conc2 abnf::cst)))

Theorem: cst-character-conc2-tree-equiv-congruence-on-cst

(defthm cst-character-conc2-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-character-conc2 abnf::cst)
                  (cst-character-conc2 cst-equiv)))
  :rule-classes :congruence)

Function: cst-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-whitespace-conc1

(defun cst-whitespace-conc1 (abnf::cst)
 (declare (xargs :guard (abnf::treep abnf::cst)))
 (declare (xargs :guard (and (cst-matchp abnf::cst "whitespace")
                             (equal (cst-whitespace-conc? abnf::cst)
                                    1))))
 (let ((__function__ 'cst-whitespace-conc1))
   (declare (ignorable __function__))
   (abnf::tree-nonleaf->branches abnf::cst)))

Theorem: tree-list-listp-of-cst-whitespace-conc1

(defthm tree-list-listp-of-cst-whitespace-conc1
  (b* ((abnf::cstss (cst-whitespace-conc1 abnf::cst)))
    (abnf::tree-list-listp abnf::cstss))
  :rule-classes :rewrite)

Theorem: cst-whitespace-conc1-match

(defthm cst-whitespace-conc1-match
  (implies (and (cst-matchp abnf::cst "whitespace")
                (equal (cst-whitespace-conc? abnf::cst)
                       1))
           (b* ((abnf::cstss (cst-whitespace-conc1 abnf::cst)))
             (cst-list-list-conc-matchp abnf::cstss "space")))
  :rule-classes :rewrite)

Theorem: cst-whitespace-conc1-of-tree-fix-cst

(defthm cst-whitespace-conc1-of-tree-fix-cst
  (equal (cst-whitespace-conc1 (abnf::tree-fix abnf::cst))
         (cst-whitespace-conc1 abnf::cst)))

Theorem: cst-whitespace-conc1-tree-equiv-congruence-on-cst

(defthm cst-whitespace-conc1-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-whitespace-conc1 abnf::cst)
                  (cst-whitespace-conc1 cst-equiv)))
  :rule-classes :congruence)

Function: cst-whitespace-conc2

(defun cst-whitespace-conc2 (abnf::cst)
 (declare (xargs :guard (abnf::treep abnf::cst)))
 (declare (xargs :guard (and (cst-matchp abnf::cst "whitespace")
                             (equal (cst-whitespace-conc? abnf::cst)
                                    2))))
 (let ((__function__ 'cst-whitespace-conc2))
   (declare (ignorable __function__))
   (abnf::tree-nonleaf->branches abnf::cst)))

Theorem: tree-list-listp-of-cst-whitespace-conc2

(defthm tree-list-listp-of-cst-whitespace-conc2
  (b* ((abnf::cstss (cst-whitespace-conc2 abnf::cst)))
    (abnf::tree-list-listp abnf::cstss))
  :rule-classes :rewrite)

Theorem: cst-whitespace-conc2-match

(defthm cst-whitespace-conc2-match
  (implies
       (and (cst-matchp abnf::cst "whitespace")
            (equal (cst-whitespace-conc? abnf::cst)
                   2))
       (b* ((abnf::cstss (cst-whitespace-conc2 abnf::cst)))
         (cst-list-list-conc-matchp abnf::cstss "horizontal-tab")))
  :rule-classes :rewrite)

Theorem: cst-whitespace-conc2-of-tree-fix-cst

(defthm cst-whitespace-conc2-of-tree-fix-cst
  (equal (cst-whitespace-conc2 (abnf::tree-fix abnf::cst))
         (cst-whitespace-conc2 abnf::cst)))

Theorem: cst-whitespace-conc2-tree-equiv-congruence-on-cst

(defthm cst-whitespace-conc2-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-whitespace-conc2 abnf::cst)
                  (cst-whitespace-conc2 cst-equiv)))
  :rule-classes :congruence)

Function: cst-whitespace-conc3

(defun cst-whitespace-conc3 (abnf::cst)
 (declare (xargs :guard (abnf::treep abnf::cst)))
 (declare (xargs :guard (and (cst-matchp abnf::cst "whitespace")
                             (equal (cst-whitespace-conc? abnf::cst)
                                    3))))
 (let ((__function__ 'cst-whitespace-conc3))
   (declare (ignorable __function__))
   (abnf::tree-nonleaf->branches abnf::cst)))

Theorem: tree-list-listp-of-cst-whitespace-conc3

(defthm tree-list-listp-of-cst-whitespace-conc3
  (b* ((abnf::cstss (cst-whitespace-conc3 abnf::cst)))
    (abnf::tree-list-listp abnf::cstss))
  :rule-classes :rewrite)

Theorem: cst-whitespace-conc3-match

(defthm cst-whitespace-conc3-match
  (implies (and (cst-matchp abnf::cst "whitespace")
                (equal (cst-whitespace-conc? abnf::cst)
                       3))
           (b* ((abnf::cstss (cst-whitespace-conc3 abnf::cst)))
             (cst-list-list-conc-matchp abnf::cstss "form-feed")))
  :rule-classes :rewrite)

Theorem: cst-whitespace-conc3-of-tree-fix-cst

(defthm cst-whitespace-conc3-of-tree-fix-cst
  (equal (cst-whitespace-conc3 (abnf::tree-fix abnf::cst))
         (cst-whitespace-conc3 abnf::cst)))

Theorem: cst-whitespace-conc3-tree-equiv-congruence-on-cst

(defthm cst-whitespace-conc3-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-whitespace-conc3 abnf::cst)
                  (cst-whitespace-conc3 cst-equiv)))
  :rule-classes :congruence)

Function: cst-whitespace-conc4

(defun cst-whitespace-conc4 (abnf::cst)
 (declare (xargs :guard (abnf::treep abnf::cst)))
 (declare (xargs :guard (and (cst-matchp abnf::cst "whitespace")
                             (equal (cst-whitespace-conc? abnf::cst)
                                    4))))
 (let ((__function__ 'cst-whitespace-conc4))
   (declare (ignorable __function__))
   (abnf::tree-nonleaf->branches abnf::cst)))

Theorem: tree-list-listp-of-cst-whitespace-conc4

(defthm tree-list-listp-of-cst-whitespace-conc4
  (b* ((abnf::cstss (cst-whitespace-conc4 abnf::cst)))
    (abnf::tree-list-listp abnf::cstss))
  :rule-classes :rewrite)

Theorem: cst-whitespace-conc4-match

(defthm cst-whitespace-conc4-match
  (implies
       (and (cst-matchp abnf::cst "whitespace")
            (equal (cst-whitespace-conc? abnf::cst)
                   4))
       (b* ((abnf::cstss (cst-whitespace-conc4 abnf::cst)))
         (cst-list-list-conc-matchp abnf::cstss "line-terminator")))
  :rule-classes :rewrite)

Theorem: cst-whitespace-conc4-of-tree-fix-cst

(defthm cst-whitespace-conc4-of-tree-fix-cst
  (equal (cst-whitespace-conc4 (abnf::tree-fix abnf::cst))
         (cst-whitespace-conc4 abnf::cst)))

Theorem: cst-whitespace-conc4-tree-equiv-congruence-on-cst

(defthm cst-whitespace-conc4-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-whitespace-conc4 abnf::cst)
                  (cst-whitespace-conc4 cst-equiv)))
  :rule-classes :congruence)

Function: cst-whitespace-conc5

(defun cst-whitespace-conc5 (abnf::cst)
 (declare (xargs :guard (abnf::treep abnf::cst)))
 (declare (xargs :guard (and (cst-matchp abnf::cst "whitespace")
                             (equal (cst-whitespace-conc? abnf::cst)
                                    5))))
 (let ((__function__ 'cst-whitespace-conc5))
   (declare (ignorable __function__))
   (abnf::tree-nonleaf->branches abnf::cst)))

Theorem: tree-list-listp-of-cst-whitespace-conc5

(defthm tree-list-listp-of-cst-whitespace-conc5
  (b* ((abnf::cstss (cst-whitespace-conc5 abnf::cst)))
    (abnf::tree-list-listp abnf::cstss))
  :rule-classes :rewrite)

Theorem: cst-whitespace-conc5-match

(defthm cst-whitespace-conc5-match
  (implies
       (and (cst-matchp abnf::cst "whitespace")
            (equal (cst-whitespace-conc? abnf::cst)
                   5))
       (b* ((abnf::cstss (cst-whitespace-conc5 abnf::cst)))
         (cst-list-list-conc-matchp abnf::cstss "carriage-return")))
  :rule-classes :rewrite)

Theorem: cst-whitespace-conc5-of-tree-fix-cst

(defthm cst-whitespace-conc5-of-tree-fix-cst
  (equal (cst-whitespace-conc5 (abnf::tree-fix abnf::cst))
         (cst-whitespace-conc5 abnf::cst)))

Theorem: cst-whitespace-conc5-tree-equiv-congruence-on-cst

(defthm cst-whitespace-conc5-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-whitespace-conc5 abnf::cst)
                  (cst-whitespace-conc5 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-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-comment-conc1

(defun cst-comment-conc1 (abnf::cst)
  (declare (xargs :guard (abnf::treep abnf::cst)))
  (declare (xargs :guard (and (cst-matchp abnf::cst "comment")
                              (equal (cst-comment-conc? abnf::cst)
                                     1))))
  (let ((__function__ 'cst-comment-conc1))
    (declare (ignorable __function__))
    (abnf::tree-nonleaf->branches abnf::cst)))

Theorem: tree-list-listp-of-cst-comment-conc1

(defthm tree-list-listp-of-cst-comment-conc1
  (b* ((abnf::cstss (cst-comment-conc1 abnf::cst)))
    (abnf::tree-list-listp abnf::cstss))
  :rule-classes :rewrite)

Theorem: cst-comment-conc1-match

(defthm cst-comment-conc1-match
  (implies
       (and (cst-matchp abnf::cst "comment")
            (equal (cst-comment-conc? abnf::cst) 1))
       (b* ((abnf::cstss (cst-comment-conc1 abnf::cst)))
         (cst-list-list-conc-matchp abnf::cstss "block-comment")))
  :rule-classes :rewrite)

Theorem: cst-comment-conc1-of-tree-fix-cst

(defthm cst-comment-conc1-of-tree-fix-cst
  (equal (cst-comment-conc1 (abnf::tree-fix abnf::cst))
         (cst-comment-conc1 abnf::cst)))

Theorem: cst-comment-conc1-tree-equiv-congruence-on-cst

(defthm cst-comment-conc1-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-comment-conc1 abnf::cst)
                  (cst-comment-conc1 cst-equiv)))
  :rule-classes :congruence)

Function: cst-comment-conc2

(defun cst-comment-conc2 (abnf::cst)
  (declare (xargs :guard (abnf::treep abnf::cst)))
  (declare (xargs :guard (and (cst-matchp abnf::cst "comment")
                              (equal (cst-comment-conc? abnf::cst)
                                     2))))
  (let ((__function__ 'cst-comment-conc2))
    (declare (ignorable __function__))
    (abnf::tree-nonleaf->branches abnf::cst)))

Theorem: tree-list-listp-of-cst-comment-conc2

(defthm tree-list-listp-of-cst-comment-conc2
  (b* ((abnf::cstss (cst-comment-conc2 abnf::cst)))
    (abnf::tree-list-listp abnf::cstss))
  :rule-classes :rewrite)

Theorem: cst-comment-conc2-match

(defthm cst-comment-conc2-match
 (implies (and (cst-matchp abnf::cst "comment")
               (equal (cst-comment-conc? abnf::cst) 2))
          (b* ((abnf::cstss (cst-comment-conc2 abnf::cst)))
            (cst-list-list-conc-matchp abnf::cstss "line-comment")))
 :rule-classes :rewrite)

Theorem: cst-comment-conc2-of-tree-fix-cst

(defthm cst-comment-conc2-of-tree-fix-cst
  (equal (cst-comment-conc2 (abnf::tree-fix abnf::cst))
         (cst-comment-conc2 abnf::cst)))

Theorem: cst-comment-conc2-tree-equiv-congruence-on-cst

(defthm cst-comment-conc2-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-comment-conc2 abnf::cst)
                  (cst-comment-conc2 cst-equiv)))
  :rule-classes :congruence)

Function: cst-block-comment-conc

(defun cst-block-comment-conc (abnf::cst)
  (declare (xargs :guard (abnf::treep abnf::cst)))
  (declare (xargs :guard (cst-matchp abnf::cst "block-comment")))
  (let ((__function__ 'cst-block-comment-conc))
    (declare (ignorable __function__))
    (abnf::tree-nonleaf->branches abnf::cst)))

Theorem: tree-list-listp-of-cst-block-comment-conc

(defthm tree-list-listp-of-cst-block-comment-conc
  (b* ((abnf::cstss (cst-block-comment-conc abnf::cst)))
    (abnf::tree-list-listp abnf::cstss))
  :rule-classes :rewrite)

Theorem: cst-block-comment-conc-match

(defthm cst-block-comment-conc-match
  (implies
       (cst-matchp abnf::cst "block-comment")
       (b* ((abnf::cstss (cst-block-comment-conc abnf::cst)))
         (cst-list-list-conc-matchp abnf::cstss
                                    "\"/*\" rest-of-block-comment")))
  :rule-classes :rewrite)

Theorem: cst-block-comment-conc-of-tree-fix-cst

(defthm cst-block-comment-conc-of-tree-fix-cst
  (equal (cst-block-comment-conc (abnf::tree-fix abnf::cst))
         (cst-block-comment-conc abnf::cst)))

Theorem: cst-block-comment-conc-tree-equiv-congruence-on-cst

(defthm cst-block-comment-conc-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-block-comment-conc abnf::cst)
                  (cst-block-comment-conc cst-equiv)))
  :rule-classes :congruence)

Function: cst-line-comment-conc

(defun cst-line-comment-conc (abnf::cst)
  (declare (xargs :guard (abnf::treep abnf::cst)))
  (declare (xargs :guard (cst-matchp abnf::cst "line-comment")))
  (let ((__function__ 'cst-line-comment-conc))
    (declare (ignorable __function__))
    (abnf::tree-nonleaf->branches abnf::cst)))

Theorem: tree-list-listp-of-cst-line-comment-conc

(defthm tree-list-listp-of-cst-line-comment-conc
  (b* ((abnf::cstss (cst-line-comment-conc abnf::cst)))
    (abnf::tree-list-listp abnf::cstss))
  :rule-classes :rewrite)

Theorem: cst-line-comment-conc-match

(defthm cst-line-comment-conc-match
  (implies (cst-matchp abnf::cst "line-comment")
           (b* ((abnf::cstss (cst-line-comment-conc abnf::cst)))
             (cst-list-list-conc-matchp
                  abnf::cstss
                  "\"//\" *not-line-feed line-terminator")))
  :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-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-binary-digit-conc

(defun cst-binary-digit-conc (abnf::cst)
  (declare (xargs :guard (abnf::treep abnf::cst)))
  (declare (xargs :guard (cst-matchp abnf::cst "binary-digit")))
  (let ((__function__ 'cst-binary-digit-conc))
    (declare (ignorable __function__))
    (abnf::tree-nonleaf->branches abnf::cst)))

Theorem: tree-list-listp-of-cst-binary-digit-conc

(defthm tree-list-listp-of-cst-binary-digit-conc
  (b* ((abnf::cstss (cst-binary-digit-conc abnf::cst)))
    (abnf::tree-list-listp abnf::cstss))
  :rule-classes :rewrite)

Theorem: cst-binary-digit-conc-match

(defthm cst-binary-digit-conc-match
  (implies (cst-matchp abnf::cst "binary-digit")
           (b* ((abnf::cstss (cst-binary-digit-conc abnf::cst)))
             (cst-list-list-conc-matchp abnf::cstss "%x30-31")))
  :rule-classes :rewrite)

Theorem: cst-binary-digit-conc-of-tree-fix-cst

(defthm cst-binary-digit-conc-of-tree-fix-cst
  (equal (cst-binary-digit-conc (abnf::tree-fix abnf::cst))
         (cst-binary-digit-conc abnf::cst)))

Theorem: cst-binary-digit-conc-tree-equiv-congruence-on-cst

(defthm cst-binary-digit-conc-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-binary-digit-conc abnf::cst)
                  (cst-binary-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-decimal-digit-conc

(defun cst-decimal-digit-conc (abnf::cst)
  (declare (xargs :guard (abnf::treep abnf::cst)))
  (declare (xargs :guard (cst-matchp abnf::cst "decimal-digit")))
  (let ((__function__ 'cst-decimal-digit-conc))
    (declare (ignorable __function__))
    (abnf::tree-nonleaf->branches abnf::cst)))

Theorem: tree-list-listp-of-cst-decimal-digit-conc

(defthm tree-list-listp-of-cst-decimal-digit-conc
  (b* ((abnf::cstss (cst-decimal-digit-conc abnf::cst)))
    (abnf::tree-list-listp abnf::cstss))
  :rule-classes :rewrite)

Theorem: cst-decimal-digit-conc-match

(defthm cst-decimal-digit-conc-match
  (implies (cst-matchp abnf::cst "decimal-digit")
           (b* ((abnf::cstss (cst-decimal-digit-conc abnf::cst)))
             (cst-list-list-conc-matchp abnf::cstss "%x30-39")))
  :rule-classes :rewrite)

Theorem: cst-decimal-digit-conc-of-tree-fix-cst

(defthm cst-decimal-digit-conc-of-tree-fix-cst
  (equal (cst-decimal-digit-conc (abnf::tree-fix abnf::cst))
         (cst-decimal-digit-conc abnf::cst)))

Theorem: cst-decimal-digit-conc-tree-equiv-congruence-on-cst

(defthm cst-decimal-digit-conc-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-decimal-digit-conc abnf::cst)
                  (cst-decimal-digit-conc cst-equiv)))
  :rule-classes :congruence)

Function: cst-nonzero-decimal-digit-conc

(defun cst-nonzero-decimal-digit-conc (abnf::cst)
 (declare (xargs :guard (abnf::treep abnf::cst)))
 (declare
      (xargs :guard (cst-matchp abnf::cst "nonzero-decimal-digit")))
 (let ((__function__ 'cst-nonzero-decimal-digit-conc))
   (declare (ignorable __function__))
   (abnf::tree-nonleaf->branches abnf::cst)))

Theorem: tree-list-listp-of-cst-nonzero-decimal-digit-conc

(defthm tree-list-listp-of-cst-nonzero-decimal-digit-conc
  (b* ((abnf::cstss (cst-nonzero-decimal-digit-conc abnf::cst)))
    (abnf::tree-list-listp abnf::cstss))
  :rule-classes :rewrite)

Theorem: cst-nonzero-decimal-digit-conc-match

(defthm cst-nonzero-decimal-digit-conc-match
 (implies
      (cst-matchp abnf::cst "nonzero-decimal-digit")
      (b* ((abnf::cstss (cst-nonzero-decimal-digit-conc abnf::cst)))
        (cst-list-list-conc-matchp abnf::cstss "%x31-39")))
 :rule-classes :rewrite)

Theorem: cst-nonzero-decimal-digit-conc-of-tree-fix-cst

(defthm cst-nonzero-decimal-digit-conc-of-tree-fix-cst
  (equal (cst-nonzero-decimal-digit-conc (abnf::tree-fix abnf::cst))
         (cst-nonzero-decimal-digit-conc abnf::cst)))

Theorem: cst-nonzero-decimal-digit-conc-tree-equiv-congruence-on-cst

(defthm cst-nonzero-decimal-digit-conc-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-nonzero-decimal-digit-conc abnf::cst)
                  (cst-nonzero-decimal-digit-conc cst-equiv)))
  :rule-classes :congruence)

Function: cst-identifier-conc

(defun cst-identifier-conc (abnf::cst)
  (declare (xargs :guard (abnf::treep abnf::cst)))
  (declare (xargs :guard (cst-matchp abnf::cst "identifier")))
  (let ((__function__ 'cst-identifier-conc))
    (declare (ignorable __function__))
    (abnf::tree-nonleaf->branches abnf::cst)))

Theorem: tree-list-listp-of-cst-identifier-conc

(defthm tree-list-listp-of-cst-identifier-conc
  (b* ((abnf::cstss (cst-identifier-conc abnf::cst)))
    (abnf::tree-list-listp abnf::cstss))
  :rule-classes :rewrite)

Theorem: cst-identifier-conc-match

(defthm cst-identifier-conc-match
  (implies (cst-matchp abnf::cst "identifier")
           (b* ((abnf::cstss (cst-identifier-conc abnf::cst)))
             (cst-list-list-conc-matchp
                  abnf::cstss
                  "letter *( letter / decimal-digit / \"_\" )")))
  :rule-classes :rewrite)

Theorem: cst-identifier-conc-of-tree-fix-cst

(defthm cst-identifier-conc-of-tree-fix-cst
  (equal (cst-identifier-conc (abnf::tree-fix abnf::cst))
         (cst-identifier-conc abnf::cst)))

Theorem: cst-identifier-conc-tree-equiv-congruence-on-cst

(defthm cst-identifier-conc-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-identifier-conc abnf::cst)
                  (cst-identifier-conc cst-equiv)))
  :rule-classes :congruence)

Function: cst-binary-numeral-conc

(defun cst-binary-numeral-conc (abnf::cst)
  (declare (xargs :guard (abnf::treep abnf::cst)))
  (declare (xargs :guard (cst-matchp abnf::cst "binary-numeral")))
  (let ((__function__ 'cst-binary-numeral-conc))
    (declare (ignorable __function__))
    (abnf::tree-nonleaf->branches abnf::cst)))

Theorem: tree-list-listp-of-cst-binary-numeral-conc

(defthm tree-list-listp-of-cst-binary-numeral-conc
  (b* ((abnf::cstss (cst-binary-numeral-conc abnf::cst)))
    (abnf::tree-list-listp abnf::cstss))
  :rule-classes :rewrite)

Theorem: cst-binary-numeral-conc-match

(defthm cst-binary-numeral-conc-match
 (implies
    (cst-matchp abnf::cst "binary-numeral")
    (b* ((abnf::cstss (cst-binary-numeral-conc abnf::cst)))
      (cst-list-list-conc-matchp abnf::cstss
                                 "%s\"0b\" 1*( binary-digit *\"_\" )")))
 :rule-classes :rewrite)

Theorem: cst-binary-numeral-conc-of-tree-fix-cst

(defthm cst-binary-numeral-conc-of-tree-fix-cst
  (equal (cst-binary-numeral-conc (abnf::tree-fix abnf::cst))
         (cst-binary-numeral-conc abnf::cst)))

Theorem: cst-binary-numeral-conc-tree-equiv-congruence-on-cst

(defthm cst-binary-numeral-conc-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-binary-numeral-conc abnf::cst)
                  (cst-binary-numeral-conc cst-equiv)))
  :rule-classes :congruence)

Function: cst-octal-numeral-conc

(defun cst-octal-numeral-conc (abnf::cst)
  (declare (xargs :guard (abnf::treep abnf::cst)))
  (declare (xargs :guard (cst-matchp abnf::cst "octal-numeral")))
  (let ((__function__ 'cst-octal-numeral-conc))
    (declare (ignorable __function__))
    (abnf::tree-nonleaf->branches abnf::cst)))

Theorem: tree-list-listp-of-cst-octal-numeral-conc

(defthm tree-list-listp-of-cst-octal-numeral-conc
  (b* ((abnf::cstss (cst-octal-numeral-conc abnf::cst)))
    (abnf::tree-list-listp abnf::cstss))
  :rule-classes :rewrite)

Theorem: cst-octal-numeral-conc-match

(defthm cst-octal-numeral-conc-match
 (implies
     (cst-matchp abnf::cst "octal-numeral")
     (b* ((abnf::cstss (cst-octal-numeral-conc abnf::cst)))
       (cst-list-list-conc-matchp abnf::cstss
                                  "%s\"0o\" 1*( octal-digit *\"_\" )")))
 :rule-classes :rewrite)

Theorem: cst-octal-numeral-conc-of-tree-fix-cst

(defthm cst-octal-numeral-conc-of-tree-fix-cst
  (equal (cst-octal-numeral-conc (abnf::tree-fix abnf::cst))
         (cst-octal-numeral-conc abnf::cst)))

Theorem: cst-octal-numeral-conc-tree-equiv-congruence-on-cst

(defthm cst-octal-numeral-conc-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-octal-numeral-conc abnf::cst)
                  (cst-octal-numeral-conc cst-equiv)))
  :rule-classes :congruence)

Function: cst-decimal-numeral-conc

(defun cst-decimal-numeral-conc (abnf::cst)
  (declare (xargs :guard (abnf::treep abnf::cst)))
  (declare (xargs :guard (cst-matchp abnf::cst "decimal-numeral")))
  (let ((__function__ 'cst-decimal-numeral-conc))
    (declare (ignorable __function__))
    (abnf::tree-nonleaf->branches abnf::cst)))

Theorem: tree-list-listp-of-cst-decimal-numeral-conc

(defthm tree-list-listp-of-cst-decimal-numeral-conc
  (b* ((abnf::cstss (cst-decimal-numeral-conc abnf::cst)))
    (abnf::tree-list-listp abnf::cstss))
  :rule-classes :rewrite)

Theorem: cst-decimal-numeral-conc-match

(defthm cst-decimal-numeral-conc-match
 (implies (cst-matchp abnf::cst "decimal-numeral")
          (b* ((abnf::cstss (cst-decimal-numeral-conc abnf::cst)))
            (cst-list-list-conc-matchp abnf::cstss
                                       "1*( decimal-digit *\"_\" )")))
 :rule-classes :rewrite)

Theorem: cst-decimal-numeral-conc-of-tree-fix-cst

(defthm cst-decimal-numeral-conc-of-tree-fix-cst
  (equal (cst-decimal-numeral-conc (abnf::tree-fix abnf::cst))
         (cst-decimal-numeral-conc abnf::cst)))

Theorem: cst-decimal-numeral-conc-tree-equiv-congruence-on-cst

(defthm cst-decimal-numeral-conc-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-decimal-numeral-conc abnf::cst)
                  (cst-decimal-numeral-conc cst-equiv)))
  :rule-classes :congruence)

Function: cst-hexadecimal-numeral-conc

(defun cst-hexadecimal-numeral-conc (abnf::cst)
  (declare (xargs :guard (abnf::treep abnf::cst)))
  (declare
       (xargs :guard (cst-matchp abnf::cst "hexadecimal-numeral")))
  (let ((__function__ 'cst-hexadecimal-numeral-conc))
    (declare (ignorable __function__))
    (abnf::tree-nonleaf->branches abnf::cst)))

Theorem: tree-list-listp-of-cst-hexadecimal-numeral-conc

(defthm tree-list-listp-of-cst-hexadecimal-numeral-conc
  (b* ((abnf::cstss (cst-hexadecimal-numeral-conc abnf::cst)))
    (abnf::tree-list-listp abnf::cstss))
  :rule-classes :rewrite)

Theorem: cst-hexadecimal-numeral-conc-match

(defthm cst-hexadecimal-numeral-conc-match
  (implies
       (cst-matchp abnf::cst "hexadecimal-numeral")
       (b* ((abnf::cstss (cst-hexadecimal-numeral-conc abnf::cst)))
         (cst-list-list-conc-matchp
              abnf::cstss
              "%s\"0x\" 1*( hexadecimal-digit *\"_\" )")))
  :rule-classes :rewrite)

Theorem: cst-hexadecimal-numeral-conc-of-tree-fix-cst

(defthm cst-hexadecimal-numeral-conc-of-tree-fix-cst
  (equal (cst-hexadecimal-numeral-conc (abnf::tree-fix abnf::cst))
         (cst-hexadecimal-numeral-conc abnf::cst)))

Theorem: cst-hexadecimal-numeral-conc-tree-equiv-congruence-on-cst

(defthm cst-hexadecimal-numeral-conc-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-hexadecimal-numeral-conc abnf::cst)
                  (cst-hexadecimal-numeral-conc cst-equiv)))
  :rule-classes :congruence)

Function: cst-numeral-conc1

(defun cst-numeral-conc1 (abnf::cst)
  (declare (xargs :guard (abnf::treep abnf::cst)))
  (declare (xargs :guard (and (cst-matchp abnf::cst "numeral")
                              (equal (cst-numeral-conc? abnf::cst)
                                     1))))
  (let ((__function__ 'cst-numeral-conc1))
    (declare (ignorable __function__))
    (abnf::tree-nonleaf->branches abnf::cst)))

Theorem: tree-list-listp-of-cst-numeral-conc1

(defthm tree-list-listp-of-cst-numeral-conc1
  (b* ((abnf::cstss (cst-numeral-conc1 abnf::cst)))
    (abnf::tree-list-listp abnf::cstss))
  :rule-classes :rewrite)

Theorem: cst-numeral-conc1-match

(defthm cst-numeral-conc1-match
  (implies
       (and (cst-matchp abnf::cst "numeral")
            (equal (cst-numeral-conc? abnf::cst) 1))
       (b* ((abnf::cstss (cst-numeral-conc1 abnf::cst)))
         (cst-list-list-conc-matchp abnf::cstss "binary-numeral")))
  :rule-classes :rewrite)

Theorem: cst-numeral-conc1-of-tree-fix-cst

(defthm cst-numeral-conc1-of-tree-fix-cst
  (equal (cst-numeral-conc1 (abnf::tree-fix abnf::cst))
         (cst-numeral-conc1 abnf::cst)))

Theorem: cst-numeral-conc1-tree-equiv-congruence-on-cst

(defthm cst-numeral-conc1-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-numeral-conc1 abnf::cst)
                  (cst-numeral-conc1 cst-equiv)))
  :rule-classes :congruence)

Function: cst-numeral-conc2

(defun cst-numeral-conc2 (abnf::cst)
  (declare (xargs :guard (abnf::treep abnf::cst)))
  (declare (xargs :guard (and (cst-matchp abnf::cst "numeral")
                              (equal (cst-numeral-conc? abnf::cst)
                                     2))))
  (let ((__function__ 'cst-numeral-conc2))
    (declare (ignorable __function__))
    (abnf::tree-nonleaf->branches abnf::cst)))

Theorem: tree-list-listp-of-cst-numeral-conc2

(defthm tree-list-listp-of-cst-numeral-conc2
  (b* ((abnf::cstss (cst-numeral-conc2 abnf::cst)))
    (abnf::tree-list-listp abnf::cstss))
  :rule-classes :rewrite)

Theorem: cst-numeral-conc2-match

(defthm cst-numeral-conc2-match
  (implies
       (and (cst-matchp abnf::cst "numeral")
            (equal (cst-numeral-conc? abnf::cst) 2))
       (b* ((abnf::cstss (cst-numeral-conc2 abnf::cst)))
         (cst-list-list-conc-matchp abnf::cstss "octal-numeral")))
  :rule-classes :rewrite)

Theorem: cst-numeral-conc2-of-tree-fix-cst

(defthm cst-numeral-conc2-of-tree-fix-cst
  (equal (cst-numeral-conc2 (abnf::tree-fix abnf::cst))
         (cst-numeral-conc2 abnf::cst)))

Theorem: cst-numeral-conc2-tree-equiv-congruence-on-cst

(defthm cst-numeral-conc2-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-numeral-conc2 abnf::cst)
                  (cst-numeral-conc2 cst-equiv)))
  :rule-classes :congruence)

Function: cst-numeral-conc3

(defun cst-numeral-conc3 (abnf::cst)
  (declare (xargs :guard (abnf::treep abnf::cst)))
  (declare (xargs :guard (and (cst-matchp abnf::cst "numeral")
                              (equal (cst-numeral-conc? abnf::cst)
                                     3))))
  (let ((__function__ 'cst-numeral-conc3))
    (declare (ignorable __function__))
    (abnf::tree-nonleaf->branches abnf::cst)))

Theorem: tree-list-listp-of-cst-numeral-conc3

(defthm tree-list-listp-of-cst-numeral-conc3
  (b* ((abnf::cstss (cst-numeral-conc3 abnf::cst)))
    (abnf::tree-list-listp abnf::cstss))
  :rule-classes :rewrite)

Theorem: cst-numeral-conc3-match

(defthm cst-numeral-conc3-match
  (implies
       (and (cst-matchp abnf::cst "numeral")
            (equal (cst-numeral-conc? abnf::cst) 3))
       (b* ((abnf::cstss (cst-numeral-conc3 abnf::cst)))
         (cst-list-list-conc-matchp abnf::cstss "decimal-numeral")))
  :rule-classes :rewrite)

Theorem: cst-numeral-conc3-of-tree-fix-cst

(defthm cst-numeral-conc3-of-tree-fix-cst
  (equal (cst-numeral-conc3 (abnf::tree-fix abnf::cst))
         (cst-numeral-conc3 abnf::cst)))

Theorem: cst-numeral-conc3-tree-equiv-congruence-on-cst

(defthm cst-numeral-conc3-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-numeral-conc3 abnf::cst)
                  (cst-numeral-conc3 cst-equiv)))
  :rule-classes :congruence)

Function: cst-numeral-conc4

(defun cst-numeral-conc4 (abnf::cst)
  (declare (xargs :guard (abnf::treep abnf::cst)))
  (declare (xargs :guard (and (cst-matchp abnf::cst "numeral")
                              (equal (cst-numeral-conc? abnf::cst)
                                     4))))
  (let ((__function__ 'cst-numeral-conc4))
    (declare (ignorable __function__))
    (abnf::tree-nonleaf->branches abnf::cst)))

Theorem: tree-list-listp-of-cst-numeral-conc4

(defthm tree-list-listp-of-cst-numeral-conc4
  (b* ((abnf::cstss (cst-numeral-conc4 abnf::cst)))
    (abnf::tree-list-listp abnf::cstss))
  :rule-classes :rewrite)

Theorem: cst-numeral-conc4-match

(defthm cst-numeral-conc4-match
 (implies
   (and (cst-matchp abnf::cst "numeral")
        (equal (cst-numeral-conc? abnf::cst) 4))
   (b* ((abnf::cstss (cst-numeral-conc4 abnf::cst)))
     (cst-list-list-conc-matchp abnf::cstss "hexadecimal-numeral")))
 :rule-classes :rewrite)

Theorem: cst-numeral-conc4-of-tree-fix-cst

(defthm cst-numeral-conc4-of-tree-fix-cst
  (equal (cst-numeral-conc4 (abnf::tree-fix abnf::cst))
         (cst-numeral-conc4 abnf::cst)))

Theorem: cst-numeral-conc4-tree-equiv-congruence-on-cst

(defthm cst-numeral-conc4-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-numeral-conc4 abnf::cst)
                  (cst-numeral-conc4 cst-equiv)))
  :rule-classes :congruence)

Function: cst-unsigned-literal-conc

(defun cst-unsigned-literal-conc (abnf::cst)
  (declare (xargs :guard (abnf::treep abnf::cst)))
  (declare (xargs :guard (cst-matchp abnf::cst "unsigned-literal")))
  (let ((__function__ 'cst-unsigned-literal-conc))
    (declare (ignorable __function__))
    (abnf::tree-nonleaf->branches abnf::cst)))

Theorem: tree-list-listp-of-cst-unsigned-literal-conc

(defthm tree-list-listp-of-cst-unsigned-literal-conc
  (b* ((abnf::cstss (cst-unsigned-literal-conc abnf::cst)))
    (abnf::tree-list-listp abnf::cstss))
  :rule-classes :rewrite)

Theorem: cst-unsigned-literal-conc-match

(defthm cst-unsigned-literal-conc-match
 (implies
  (cst-matchp abnf::cst "unsigned-literal")
  (b* ((abnf::cstss (cst-unsigned-literal-conc abnf::cst)))
   (cst-list-list-conc-matchp
    abnf::cstss
    "numeral ( %s\"u8\" / %s\"u16\" / %s\"u32\" / %s\"u64\" / %s\"u128\" )")))
 :rule-classes :rewrite)

Theorem: cst-unsigned-literal-conc-of-tree-fix-cst

(defthm cst-unsigned-literal-conc-of-tree-fix-cst
  (equal (cst-unsigned-literal-conc (abnf::tree-fix abnf::cst))
         (cst-unsigned-literal-conc abnf::cst)))

Theorem: cst-unsigned-literal-conc-tree-equiv-congruence-on-cst

(defthm cst-unsigned-literal-conc-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-unsigned-literal-conc abnf::cst)
                  (cst-unsigned-literal-conc cst-equiv)))
  :rule-classes :congruence)

Function: cst-signed-literal-conc

(defun cst-signed-literal-conc (abnf::cst)
  (declare (xargs :guard (abnf::treep abnf::cst)))
  (declare (xargs :guard (cst-matchp abnf::cst "signed-literal")))
  (let ((__function__ 'cst-signed-literal-conc))
    (declare (ignorable __function__))
    (abnf::tree-nonleaf->branches abnf::cst)))

Theorem: tree-list-listp-of-cst-signed-literal-conc

(defthm tree-list-listp-of-cst-signed-literal-conc
  (b* ((abnf::cstss (cst-signed-literal-conc abnf::cst)))
    (abnf::tree-list-listp abnf::cstss))
  :rule-classes :rewrite)

Theorem: cst-signed-literal-conc-match

(defthm cst-signed-literal-conc-match
 (implies
  (cst-matchp abnf::cst "signed-literal")
  (b* ((abnf::cstss (cst-signed-literal-conc abnf::cst)))
   (cst-list-list-conc-matchp
    abnf::cstss
    "numeral ( %s\"i8\" / %s\"i16\" / %s\"i32\" / %s\"i64\" / %s\"i128\" )")))
 :rule-classes :rewrite)

Theorem: cst-signed-literal-conc-of-tree-fix-cst

(defthm cst-signed-literal-conc-of-tree-fix-cst
  (equal (cst-signed-literal-conc (abnf::tree-fix abnf::cst))
         (cst-signed-literal-conc abnf::cst)))

Theorem: cst-signed-literal-conc-tree-equiv-congruence-on-cst

(defthm cst-signed-literal-conc-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-signed-literal-conc abnf::cst)
                  (cst-signed-literal-conc cst-equiv)))
  :rule-classes :congruence)

Function: cst-integer-literal-conc1

(defun cst-integer-literal-conc1 (abnf::cst)
 (declare (xargs :guard (abnf::treep abnf::cst)))
 (declare
     (xargs :guard (and (cst-matchp abnf::cst "integer-literal")
                        (equal (cst-integer-literal-conc? abnf::cst)
                               1))))
 (let ((__function__ 'cst-integer-literal-conc1))
   (declare (ignorable __function__))
   (abnf::tree-nonleaf->branches abnf::cst)))

Theorem: tree-list-listp-of-cst-integer-literal-conc1

(defthm tree-list-listp-of-cst-integer-literal-conc1
  (b* ((abnf::cstss (cst-integer-literal-conc1 abnf::cst)))
    (abnf::tree-list-listp abnf::cstss))
  :rule-classes :rewrite)

Theorem: cst-integer-literal-conc1-match

(defthm cst-integer-literal-conc1-match
 (implies
      (and (cst-matchp abnf::cst "integer-literal")
           (equal (cst-integer-literal-conc? abnf::cst)
                  1))
      (b* ((abnf::cstss (cst-integer-literal-conc1 abnf::cst)))
        (cst-list-list-conc-matchp abnf::cstss "unsigned-literal")))
 :rule-classes :rewrite)

Theorem: cst-integer-literal-conc1-of-tree-fix-cst

(defthm cst-integer-literal-conc1-of-tree-fix-cst
  (equal (cst-integer-literal-conc1 (abnf::tree-fix abnf::cst))
         (cst-integer-literal-conc1 abnf::cst)))

Theorem: cst-integer-literal-conc1-tree-equiv-congruence-on-cst

(defthm cst-integer-literal-conc1-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-integer-literal-conc1 abnf::cst)
                  (cst-integer-literal-conc1 cst-equiv)))
  :rule-classes :congruence)

Function: cst-integer-literal-conc2

(defun cst-integer-literal-conc2 (abnf::cst)
 (declare (xargs :guard (abnf::treep abnf::cst)))
 (declare
     (xargs :guard (and (cst-matchp abnf::cst "integer-literal")
                        (equal (cst-integer-literal-conc? abnf::cst)
                               2))))
 (let ((__function__ 'cst-integer-literal-conc2))
   (declare (ignorable __function__))
   (abnf::tree-nonleaf->branches abnf::cst)))

Theorem: tree-list-listp-of-cst-integer-literal-conc2

(defthm tree-list-listp-of-cst-integer-literal-conc2
  (b* ((abnf::cstss (cst-integer-literal-conc2 abnf::cst)))
    (abnf::tree-list-listp abnf::cstss))
  :rule-classes :rewrite)

Theorem: cst-integer-literal-conc2-match

(defthm cst-integer-literal-conc2-match
  (implies
       (and (cst-matchp abnf::cst "integer-literal")
            (equal (cst-integer-literal-conc? abnf::cst)
                   2))
       (b* ((abnf::cstss (cst-integer-literal-conc2 abnf::cst)))
         (cst-list-list-conc-matchp abnf::cstss "signed-literal")))
  :rule-classes :rewrite)

Theorem: cst-integer-literal-conc2-of-tree-fix-cst

(defthm cst-integer-literal-conc2-of-tree-fix-cst
  (equal (cst-integer-literal-conc2 (abnf::tree-fix abnf::cst))
         (cst-integer-literal-conc2 abnf::cst)))

Theorem: cst-integer-literal-conc2-tree-equiv-congruence-on-cst

(defthm cst-integer-literal-conc2-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-integer-literal-conc2 abnf::cst)
                  (cst-integer-literal-conc2 cst-equiv)))
  :rule-classes :congruence)

Function: cst-field-literal-conc

(defun cst-field-literal-conc (abnf::cst)
  (declare (xargs :guard (abnf::treep abnf::cst)))
  (declare (xargs :guard (cst-matchp abnf::cst "field-literal")))
  (let ((__function__ 'cst-field-literal-conc))
    (declare (ignorable __function__))
    (abnf::tree-nonleaf->branches abnf::cst)))

Theorem: tree-list-listp-of-cst-field-literal-conc

(defthm tree-list-listp-of-cst-field-literal-conc
  (b* ((abnf::cstss (cst-field-literal-conc abnf::cst)))
    (abnf::tree-list-listp abnf::cstss))
  :rule-classes :rewrite)

Theorem: cst-field-literal-conc-match

(defthm cst-field-literal-conc-match
  (implies
       (cst-matchp abnf::cst "field-literal")
       (b* ((abnf::cstss (cst-field-literal-conc abnf::cst)))
         (cst-list-list-conc-matchp abnf::cstss
                                    "decimal-numeral %s\"field\"")))
  :rule-classes :rewrite)

Theorem: cst-field-literal-conc-of-tree-fix-cst

(defthm cst-field-literal-conc-of-tree-fix-cst
  (equal (cst-field-literal-conc (abnf::tree-fix abnf::cst))
         (cst-field-literal-conc abnf::cst)))

Theorem: cst-field-literal-conc-tree-equiv-congruence-on-cst

(defthm cst-field-literal-conc-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-field-literal-conc abnf::cst)
                  (cst-field-literal-conc cst-equiv)))
  :rule-classes :congruence)

Function: cst-group-literal-conc

(defun cst-group-literal-conc (abnf::cst)
  (declare (xargs :guard (abnf::treep abnf::cst)))
  (declare (xargs :guard (cst-matchp abnf::cst "group-literal")))
  (let ((__function__ 'cst-group-literal-conc))
    (declare (ignorable __function__))
    (abnf::tree-nonleaf->branches abnf::cst)))

Theorem: tree-list-listp-of-cst-group-literal-conc

(defthm tree-list-listp-of-cst-group-literal-conc
  (b* ((abnf::cstss (cst-group-literal-conc abnf::cst)))
    (abnf::tree-list-listp abnf::cstss))
  :rule-classes :rewrite)

Theorem: cst-group-literal-conc-match

(defthm cst-group-literal-conc-match
  (implies
       (cst-matchp abnf::cst "group-literal")
       (b* ((abnf::cstss (cst-group-literal-conc abnf::cst)))
         (cst-list-list-conc-matchp abnf::cstss
                                    "decimal-numeral %s\"group\"")))
  :rule-classes :rewrite)

Theorem: cst-group-literal-conc-of-tree-fix-cst

(defthm cst-group-literal-conc-of-tree-fix-cst
  (equal (cst-group-literal-conc (abnf::tree-fix abnf::cst))
         (cst-group-literal-conc abnf::cst)))

Theorem: cst-group-literal-conc-tree-equiv-congruence-on-cst

(defthm cst-group-literal-conc-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-group-literal-conc abnf::cst)
                  (cst-group-literal-conc cst-equiv)))
  :rule-classes :congruence)

Function: cst-scalar-literal-conc

(defun cst-scalar-literal-conc (abnf::cst)
  (declare (xargs :guard (abnf::treep abnf::cst)))
  (declare (xargs :guard (cst-matchp abnf::cst "scalar-literal")))
  (let ((__function__ 'cst-scalar-literal-conc))
    (declare (ignorable __function__))
    (abnf::tree-nonleaf->branches abnf::cst)))

Theorem: tree-list-listp-of-cst-scalar-literal-conc

(defthm tree-list-listp-of-cst-scalar-literal-conc
  (b* ((abnf::cstss (cst-scalar-literal-conc abnf::cst)))
    (abnf::tree-list-listp abnf::cstss))
  :rule-classes :rewrite)

Theorem: cst-scalar-literal-conc-match

(defthm cst-scalar-literal-conc-match
  (implies
       (cst-matchp abnf::cst "scalar-literal")
       (b* ((abnf::cstss (cst-scalar-literal-conc abnf::cst)))
         (cst-list-list-conc-matchp abnf::cstss
                                    "decimal-numeral %s\"scalar\"")))
  :rule-classes :rewrite)

Theorem: cst-scalar-literal-conc-of-tree-fix-cst

(defthm cst-scalar-literal-conc-of-tree-fix-cst
  (equal (cst-scalar-literal-conc (abnf::tree-fix abnf::cst))
         (cst-scalar-literal-conc abnf::cst)))

Theorem: cst-scalar-literal-conc-tree-equiv-congruence-on-cst

(defthm cst-scalar-literal-conc-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-scalar-literal-conc abnf::cst)
                  (cst-scalar-literal-conc cst-equiv)))
  :rule-classes :congruence)

Function: cst-numeric-literal-conc1

(defun cst-numeric-literal-conc1 (abnf::cst)
 (declare (xargs :guard (abnf::treep abnf::cst)))
 (declare
     (xargs :guard (and (cst-matchp abnf::cst "numeric-literal")
                        (equal (cst-numeric-literal-conc? abnf::cst)
                               1))))
 (let ((__function__ 'cst-numeric-literal-conc1))
   (declare (ignorable __function__))
   (abnf::tree-nonleaf->branches abnf::cst)))

Theorem: tree-list-listp-of-cst-numeric-literal-conc1

(defthm tree-list-listp-of-cst-numeric-literal-conc1
  (b* ((abnf::cstss (cst-numeric-literal-conc1 abnf::cst)))
    (abnf::tree-list-listp abnf::cstss))
  :rule-classes :rewrite)

Theorem: cst-numeric-literal-conc1-match

(defthm cst-numeric-literal-conc1-match
  (implies
       (and (cst-matchp abnf::cst "numeric-literal")
            (equal (cst-numeric-literal-conc? abnf::cst)
                   1))
       (b* ((abnf::cstss (cst-numeric-literal-conc1 abnf::cst)))
         (cst-list-list-conc-matchp abnf::cstss "integer-literal")))
  :rule-classes :rewrite)

Theorem: cst-numeric-literal-conc1-of-tree-fix-cst

(defthm cst-numeric-literal-conc1-of-tree-fix-cst
  (equal (cst-numeric-literal-conc1 (abnf::tree-fix abnf::cst))
         (cst-numeric-literal-conc1 abnf::cst)))

Theorem: cst-numeric-literal-conc1-tree-equiv-congruence-on-cst

(defthm cst-numeric-literal-conc1-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-numeric-literal-conc1 abnf::cst)
                  (cst-numeric-literal-conc1 cst-equiv)))
  :rule-classes :congruence)

Function: cst-numeric-literal-conc2

(defun cst-numeric-literal-conc2 (abnf::cst)
 (declare (xargs :guard (abnf::treep abnf::cst)))
 (declare
     (xargs :guard (and (cst-matchp abnf::cst "numeric-literal")
                        (equal (cst-numeric-literal-conc? abnf::cst)
                               2))))
 (let ((__function__ 'cst-numeric-literal-conc2))
   (declare (ignorable __function__))
   (abnf::tree-nonleaf->branches abnf::cst)))

Theorem: tree-list-listp-of-cst-numeric-literal-conc2

(defthm tree-list-listp-of-cst-numeric-literal-conc2
  (b* ((abnf::cstss (cst-numeric-literal-conc2 abnf::cst)))
    (abnf::tree-list-listp abnf::cstss))
  :rule-classes :rewrite)

Theorem: cst-numeric-literal-conc2-match

(defthm cst-numeric-literal-conc2-match
  (implies
       (and (cst-matchp abnf::cst "numeric-literal")
            (equal (cst-numeric-literal-conc? abnf::cst)
                   2))
       (b* ((abnf::cstss (cst-numeric-literal-conc2 abnf::cst)))
         (cst-list-list-conc-matchp abnf::cstss "field-literal")))
  :rule-classes :rewrite)

Theorem: cst-numeric-literal-conc2-of-tree-fix-cst

(defthm cst-numeric-literal-conc2-of-tree-fix-cst
  (equal (cst-numeric-literal-conc2 (abnf::tree-fix abnf::cst))
         (cst-numeric-literal-conc2 abnf::cst)))

Theorem: cst-numeric-literal-conc2-tree-equiv-congruence-on-cst

(defthm cst-numeric-literal-conc2-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-numeric-literal-conc2 abnf::cst)
                  (cst-numeric-literal-conc2 cst-equiv)))
  :rule-classes :congruence)

Function: cst-numeric-literal-conc3

(defun cst-numeric-literal-conc3 (abnf::cst)
 (declare (xargs :guard (abnf::treep abnf::cst)))
 (declare
     (xargs :guard (and (cst-matchp abnf::cst "numeric-literal")
                        (equal (cst-numeric-literal-conc? abnf::cst)
                               3))))
 (let ((__function__ 'cst-numeric-literal-conc3))
   (declare (ignorable __function__))
   (abnf::tree-nonleaf->branches abnf::cst)))

Theorem: tree-list-listp-of-cst-numeric-literal-conc3

(defthm tree-list-listp-of-cst-numeric-literal-conc3
  (b* ((abnf::cstss (cst-numeric-literal-conc3 abnf::cst)))
    (abnf::tree-list-listp abnf::cstss))
  :rule-classes :rewrite)

Theorem: cst-numeric-literal-conc3-match

(defthm cst-numeric-literal-conc3-match
  (implies
       (and (cst-matchp abnf::cst "numeric-literal")
            (equal (cst-numeric-literal-conc? abnf::cst)
                   3))
       (b* ((abnf::cstss (cst-numeric-literal-conc3 abnf::cst)))
         (cst-list-list-conc-matchp abnf::cstss "group-literal")))
  :rule-classes :rewrite)

Theorem: cst-numeric-literal-conc3-of-tree-fix-cst

(defthm cst-numeric-literal-conc3-of-tree-fix-cst
  (equal (cst-numeric-literal-conc3 (abnf::tree-fix abnf::cst))
         (cst-numeric-literal-conc3 abnf::cst)))

Theorem: cst-numeric-literal-conc3-tree-equiv-congruence-on-cst

(defthm cst-numeric-literal-conc3-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-numeric-literal-conc3 abnf::cst)
                  (cst-numeric-literal-conc3 cst-equiv)))
  :rule-classes :congruence)

Function: cst-numeric-literal-conc4

(defun cst-numeric-literal-conc4 (abnf::cst)
 (declare (xargs :guard (abnf::treep abnf::cst)))
 (declare
     (xargs :guard (and (cst-matchp abnf::cst "numeric-literal")
                        (equal (cst-numeric-literal-conc? abnf::cst)
                               4))))
 (let ((__function__ 'cst-numeric-literal-conc4))
   (declare (ignorable __function__))
   (abnf::tree-nonleaf->branches abnf::cst)))

Theorem: tree-list-listp-of-cst-numeric-literal-conc4

(defthm tree-list-listp-of-cst-numeric-literal-conc4
  (b* ((abnf::cstss (cst-numeric-literal-conc4 abnf::cst)))
    (abnf::tree-list-listp abnf::cstss))
  :rule-classes :rewrite)

Theorem: cst-numeric-literal-conc4-match

(defthm cst-numeric-literal-conc4-match
  (implies
       (and (cst-matchp abnf::cst "numeric-literal")
            (equal (cst-numeric-literal-conc? abnf::cst)
                   4))
       (b* ((abnf::cstss (cst-numeric-literal-conc4 abnf::cst)))
         (cst-list-list-conc-matchp abnf::cstss "scalar-literal")))
  :rule-classes :rewrite)

Theorem: cst-numeric-literal-conc4-of-tree-fix-cst

(defthm cst-numeric-literal-conc4-of-tree-fix-cst
  (equal (cst-numeric-literal-conc4 (abnf::tree-fix abnf::cst))
         (cst-numeric-literal-conc4 abnf::cst)))

Theorem: cst-numeric-literal-conc4-tree-equiv-congruence-on-cst

(defthm cst-numeric-literal-conc4-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-numeric-literal-conc4 abnf::cst)
                  (cst-numeric-literal-conc4 cst-equiv)))
  :rule-classes :congruence)

Function: cst-explicit-address-literal-conc

(defun cst-explicit-address-literal-conc (abnf::cst)
 (declare (xargs :guard (abnf::treep abnf::cst)))
 (declare
   (xargs :guard (cst-matchp abnf::cst "explicit-address-literal")))
 (let ((__function__ 'cst-explicit-address-literal-conc))
   (declare (ignorable __function__))
   (abnf::tree-nonleaf->branches abnf::cst)))

Theorem: tree-list-listp-of-cst-explicit-address-literal-conc

(defthm tree-list-listp-of-cst-explicit-address-literal-conc
  (b* ((abnf::cstss (cst-explicit-address-literal-conc abnf::cst)))
    (abnf::tree-list-listp abnf::cstss))
  :rule-classes :rewrite)

Theorem: cst-explicit-address-literal-conc-match

(defthm cst-explicit-address-literal-conc-match
 (implies
   (cst-matchp abnf::cst "explicit-address-literal")
   (b* ((abnf::cstss (cst-explicit-address-literal-conc abnf::cst)))
     (cst-list-list-conc-matchp
          abnf::cstss
          "%s\"aleo1\" 58( lowercase-letter / decimal-digit )")))
 :rule-classes :rewrite)

Theorem: cst-explicit-address-literal-conc-of-tree-fix-cst

(defthm cst-explicit-address-literal-conc-of-tree-fix-cst
 (equal
      (cst-explicit-address-literal-conc (abnf::tree-fix abnf::cst))
      (cst-explicit-address-literal-conc abnf::cst)))

Theorem: cst-explicit-address-literal-conc-tree-equiv-congruence-on-cst

(defthm
     cst-explicit-address-literal-conc-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-explicit-address-literal-conc abnf::cst)
                  (cst-explicit-address-literal-conc cst-equiv)))
  :rule-classes :congruence)

Function: cst-string-literal-conc

(defun cst-string-literal-conc (abnf::cst)
  (declare (xargs :guard (abnf::treep abnf::cst)))
  (declare (xargs :guard (cst-matchp abnf::cst "string-literal")))
  (let ((__function__ 'cst-string-literal-conc))
    (declare (ignorable __function__))
    (abnf::tree-nonleaf->branches abnf::cst)))

Theorem: tree-list-listp-of-cst-string-literal-conc

(defthm tree-list-listp-of-cst-string-literal-conc
  (b* ((abnf::cstss (cst-string-literal-conc abnf::cst)))
    (abnf::tree-list-listp abnf::cstss))
  :rule-classes :rewrite)

Theorem: cst-string-literal-conc-match

(defthm cst-string-literal-conc-match
  (implies (cst-matchp abnf::cst "string-literal")
           (b* ((abnf::cstss (cst-string-literal-conc abnf::cst)))
             (cst-list-list-conc-matchp
                  abnf::cstss
                  "double-quote *string-character 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-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-string-character-conc1

(defun cst-string-character-conc1 (abnf::cst)
 (declare (xargs :guard (abnf::treep abnf::cst)))
 (declare
    (xargs :guard (and (cst-matchp abnf::cst "string-character")
                       (equal (cst-string-character-conc? abnf::cst)
                              1))))
 (let ((__function__ 'cst-string-character-conc1))
   (declare (ignorable __function__))
   (abnf::tree-nonleaf->branches abnf::cst)))

Theorem: tree-list-listp-of-cst-string-character-conc1

(defthm tree-list-listp-of-cst-string-character-conc1
  (b* ((abnf::cstss (cst-string-character-conc1 abnf::cst)))
    (abnf::tree-list-listp abnf::cstss))
  :rule-classes :rewrite)

Theorem: cst-string-character-conc1-match

(defthm cst-string-character-conc1-match
 (implies
     (and (cst-matchp abnf::cst "string-character")
          (equal (cst-string-character-conc? abnf::cst)
                 1))
     (b* ((abnf::cstss (cst-string-character-conc1 abnf::cst)))
       (cst-list-list-conc-matchp abnf::cstss
                                  "not-double-quote-or-line-feed")))
 :rule-classes :rewrite)

Theorem: cst-string-character-conc1-of-tree-fix-cst

(defthm cst-string-character-conc1-of-tree-fix-cst
  (equal (cst-string-character-conc1 (abnf::tree-fix abnf::cst))
         (cst-string-character-conc1 abnf::cst)))

Theorem: cst-string-character-conc1-tree-equiv-congruence-on-cst

(defthm cst-string-character-conc1-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-string-character-conc1 abnf::cst)
                  (cst-string-character-conc1 cst-equiv)))
  :rule-classes :congruence)

Function: cst-string-character-conc2

(defun cst-string-character-conc2 (abnf::cst)
 (declare (xargs :guard (abnf::treep abnf::cst)))
 (declare
    (xargs :guard (and (cst-matchp abnf::cst "string-character")
                       (equal (cst-string-character-conc? abnf::cst)
                              2))))
 (let ((__function__ 'cst-string-character-conc2))
   (declare (ignorable __function__))
   (abnf::tree-nonleaf->branches abnf::cst)))

Theorem: tree-list-listp-of-cst-string-character-conc2

(defthm tree-list-listp-of-cst-string-character-conc2
  (b* ((abnf::cstss (cst-string-character-conc2 abnf::cst)))
    (abnf::tree-list-listp abnf::cstss))
  :rule-classes :rewrite)

Theorem: cst-string-character-conc2-match

(defthm cst-string-character-conc2-match
  (implies
       (and (cst-matchp abnf::cst "string-character")
            (equal (cst-string-character-conc? abnf::cst)
                   2))
       (b* ((abnf::cstss (cst-string-character-conc2 abnf::cst)))
         (cst-list-list-conc-matchp abnf::cstss "line-terminator")))
  :rule-classes :rewrite)

Theorem: cst-string-character-conc2-of-tree-fix-cst

(defthm cst-string-character-conc2-of-tree-fix-cst
  (equal (cst-string-character-conc2 (abnf::tree-fix abnf::cst))
         (cst-string-character-conc2 abnf::cst)))

Theorem: cst-string-character-conc2-tree-equiv-congruence-on-cst

(defthm cst-string-character-conc2-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-string-character-conc2 abnf::cst)
                  (cst-string-character-conc2 cst-equiv)))
  :rule-classes :congruence)

Function: cst-atomic-literal-conc1

(defun cst-atomic-literal-conc1 (abnf::cst)
 (declare (xargs :guard (abnf::treep abnf::cst)))
 (declare
      (xargs :guard (and (cst-matchp abnf::cst "atomic-literal")
                         (equal (cst-atomic-literal-conc? abnf::cst)
                                1))))
 (let ((__function__ 'cst-atomic-literal-conc1))
   (declare (ignorable __function__))
   (abnf::tree-nonleaf->branches abnf::cst)))

Theorem: tree-list-listp-of-cst-atomic-literal-conc1

(defthm tree-list-listp-of-cst-atomic-literal-conc1
  (b* ((abnf::cstss (cst-atomic-literal-conc1 abnf::cst)))
    (abnf::tree-list-listp abnf::cstss))
  :rule-classes :rewrite)

Theorem: cst-atomic-literal-conc1-match

(defthm cst-atomic-literal-conc1-match
  (implies
       (and (cst-matchp abnf::cst "atomic-literal")
            (equal (cst-atomic-literal-conc? abnf::cst)
                   1))
       (b* ((abnf::cstss (cst-atomic-literal-conc1 abnf::cst)))
         (cst-list-list-conc-matchp abnf::cstss "numeric-literal")))
  :rule-classes :rewrite)

Theorem: cst-atomic-literal-conc1-of-tree-fix-cst

(defthm cst-atomic-literal-conc1-of-tree-fix-cst
  (equal (cst-atomic-literal-conc1 (abnf::tree-fix abnf::cst))
         (cst-atomic-literal-conc1 abnf::cst)))

Theorem: cst-atomic-literal-conc1-tree-equiv-congruence-on-cst

(defthm cst-atomic-literal-conc1-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-atomic-literal-conc1 abnf::cst)
                  (cst-atomic-literal-conc1 cst-equiv)))
  :rule-classes :congruence)

Function: cst-atomic-literal-conc2

(defun cst-atomic-literal-conc2 (abnf::cst)
 (declare (xargs :guard (abnf::treep abnf::cst)))
 (declare
      (xargs :guard (and (cst-matchp abnf::cst "atomic-literal")
                         (equal (cst-atomic-literal-conc? abnf::cst)
                                2))))
 (let ((__function__ 'cst-atomic-literal-conc2))
   (declare (ignorable __function__))
   (abnf::tree-nonleaf->branches abnf::cst)))

Theorem: tree-list-listp-of-cst-atomic-literal-conc2

(defthm tree-list-listp-of-cst-atomic-literal-conc2
  (b* ((abnf::cstss (cst-atomic-literal-conc2 abnf::cst)))
    (abnf::tree-list-listp abnf::cstss))
  :rule-classes :rewrite)

Theorem: cst-atomic-literal-conc2-match

(defthm cst-atomic-literal-conc2-match
  (implies
       (and (cst-matchp abnf::cst "atomic-literal")
            (equal (cst-atomic-literal-conc? abnf::cst)
                   2))
       (b* ((abnf::cstss (cst-atomic-literal-conc2 abnf::cst)))
         (cst-list-list-conc-matchp abnf::cstss "boolean-literal")))
  :rule-classes :rewrite)

Theorem: cst-atomic-literal-conc2-of-tree-fix-cst

(defthm cst-atomic-literal-conc2-of-tree-fix-cst
  (equal (cst-atomic-literal-conc2 (abnf::tree-fix abnf::cst))
         (cst-atomic-literal-conc2 abnf::cst)))

Theorem: cst-atomic-literal-conc2-tree-equiv-congruence-on-cst

(defthm cst-atomic-literal-conc2-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-atomic-literal-conc2 abnf::cst)
                  (cst-atomic-literal-conc2 cst-equiv)))
  :rule-classes :congruence)

Function: cst-atomic-literal-conc3

(defun cst-atomic-literal-conc3 (abnf::cst)
 (declare (xargs :guard (abnf::treep abnf::cst)))
 (declare
      (xargs :guard (and (cst-matchp abnf::cst "atomic-literal")
                         (equal (cst-atomic-literal-conc? abnf::cst)
                                3))))
 (let ((__function__ 'cst-atomic-literal-conc3))
   (declare (ignorable __function__))
   (abnf::tree-nonleaf->branches abnf::cst)))

Theorem: tree-list-listp-of-cst-atomic-literal-conc3

(defthm tree-list-listp-of-cst-atomic-literal-conc3
  (b* ((abnf::cstss (cst-atomic-literal-conc3 abnf::cst)))
    (abnf::tree-list-listp abnf::cstss))
  :rule-classes :rewrite)

Theorem: cst-atomic-literal-conc3-match

(defthm cst-atomic-literal-conc3-match
 (implies (and (cst-matchp abnf::cst "atomic-literal")
               (equal (cst-atomic-literal-conc? abnf::cst)
                      3))
          (b* ((abnf::cstss (cst-atomic-literal-conc3 abnf::cst)))
            (cst-list-list-conc-matchp abnf::cstss
                                       "explicit-address-literal")))
 :rule-classes :rewrite)

Theorem: cst-atomic-literal-conc3-of-tree-fix-cst

(defthm cst-atomic-literal-conc3-of-tree-fix-cst
  (equal (cst-atomic-literal-conc3 (abnf::tree-fix abnf::cst))
         (cst-atomic-literal-conc3 abnf::cst)))

Theorem: cst-atomic-literal-conc3-tree-equiv-congruence-on-cst

(defthm cst-atomic-literal-conc3-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-atomic-literal-conc3 abnf::cst)
                  (cst-atomic-literal-conc3 cst-equiv)))
  :rule-classes :congruence)

Function: cst-atomic-literal-conc4

(defun cst-atomic-literal-conc4 (abnf::cst)
 (declare (xargs :guard (abnf::treep abnf::cst)))
 (declare
      (xargs :guard (and (cst-matchp abnf::cst "atomic-literal")
                         (equal (cst-atomic-literal-conc? abnf::cst)
                                4))))
 (let ((__function__ 'cst-atomic-literal-conc4))
   (declare (ignorable __function__))
   (abnf::tree-nonleaf->branches abnf::cst)))

Theorem: tree-list-listp-of-cst-atomic-literal-conc4

(defthm tree-list-listp-of-cst-atomic-literal-conc4
  (b* ((abnf::cstss (cst-atomic-literal-conc4 abnf::cst)))
    (abnf::tree-list-listp abnf::cstss))
  :rule-classes :rewrite)

Theorem: cst-atomic-literal-conc4-match

(defthm cst-atomic-literal-conc4-match
  (implies
       (and (cst-matchp abnf::cst "atomic-literal")
            (equal (cst-atomic-literal-conc? abnf::cst)
                   4))
       (b* ((abnf::cstss (cst-atomic-literal-conc4 abnf::cst)))
         (cst-list-list-conc-matchp abnf::cstss "string-literal")))
  :rule-classes :rewrite)

Theorem: cst-atomic-literal-conc4-of-tree-fix-cst

(defthm cst-atomic-literal-conc4-of-tree-fix-cst
  (equal (cst-atomic-literal-conc4 (abnf::tree-fix abnf::cst))
         (cst-atomic-literal-conc4 abnf::cst)))

Theorem: cst-atomic-literal-conc4-tree-equiv-congruence-on-cst

(defthm cst-atomic-literal-conc4-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-atomic-literal-conc4 abnf::cst)
                  (cst-atomic-literal-conc4 cst-equiv)))
  :rule-classes :congruence)

Function: cst-annotation-conc

(defun cst-annotation-conc (abnf::cst)
  (declare (xargs :guard (abnf::treep abnf::cst)))
  (declare (xargs :guard (cst-matchp abnf::cst "annotation")))
  (let ((__function__ 'cst-annotation-conc))
    (declare (ignorable __function__))
    (abnf::tree-nonleaf->branches abnf::cst)))

Theorem: tree-list-listp-of-cst-annotation-conc

(defthm tree-list-listp-of-cst-annotation-conc
  (b* ((abnf::cstss (cst-annotation-conc abnf::cst)))
    (abnf::tree-list-listp abnf::cstss))
  :rule-classes :rewrite)

Theorem: cst-annotation-conc-match

(defthm cst-annotation-conc-match
  (implies
       (cst-matchp abnf::cst "annotation")
       (b* ((abnf::cstss (cst-annotation-conc abnf::cst)))
         (cst-list-list-conc-matchp abnf::cstss "\"@\" identifier")))
  :rule-classes :rewrite)

Theorem: cst-annotation-conc-of-tree-fix-cst

(defthm cst-annotation-conc-of-tree-fix-cst
  (equal (cst-annotation-conc (abnf::tree-fix abnf::cst))
         (cst-annotation-conc abnf::cst)))

Theorem: cst-annotation-conc-tree-equiv-congruence-on-cst

(defthm cst-annotation-conc-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-annotation-conc abnf::cst)
                  (cst-annotation-conc cst-equiv)))
  :rule-classes :congruence)

Function: cst-token-conc1

(defun cst-token-conc1 (abnf::cst)
  (declare (xargs :guard (abnf::treep abnf::cst)))
  (declare
       (xargs :guard (and (cst-matchp abnf::cst "token")
                          (equal (cst-token-conc? abnf::cst) 1))))
  (let ((__function__ 'cst-token-conc1))
    (declare (ignorable __function__))
    (abnf::tree-nonleaf->branches abnf::cst)))

Theorem: tree-list-listp-of-cst-token-conc1

(defthm tree-list-listp-of-cst-token-conc1
  (b* ((abnf::cstss (cst-token-conc1 abnf::cst)))
    (abnf::tree-list-listp abnf::cstss))
  :rule-classes :rewrite)

Theorem: cst-token-conc1-match

(defthm cst-token-conc1-match
  (implies (and (cst-matchp abnf::cst "token")
                (equal (cst-token-conc? abnf::cst) 1))
           (b* ((abnf::cstss (cst-token-conc1 abnf::cst)))
             (cst-list-list-conc-matchp abnf::cstss "keyword")))
  :rule-classes :rewrite)

Theorem: cst-token-conc1-of-tree-fix-cst

(defthm cst-token-conc1-of-tree-fix-cst
  (equal (cst-token-conc1 (abnf::tree-fix abnf::cst))
         (cst-token-conc1 abnf::cst)))

Theorem: cst-token-conc1-tree-equiv-congruence-on-cst

(defthm cst-token-conc1-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-token-conc1 abnf::cst)
                  (cst-token-conc1 cst-equiv)))
  :rule-classes :congruence)

Function: cst-token-conc2

(defun cst-token-conc2 (abnf::cst)
  (declare (xargs :guard (abnf::treep abnf::cst)))
  (declare
       (xargs :guard (and (cst-matchp abnf::cst "token")
                          (equal (cst-token-conc? abnf::cst) 2))))
  (let ((__function__ 'cst-token-conc2))
    (declare (ignorable __function__))
    (abnf::tree-nonleaf->branches abnf::cst)))

Theorem: tree-list-listp-of-cst-token-conc2

(defthm tree-list-listp-of-cst-token-conc2
  (b* ((abnf::cstss (cst-token-conc2 abnf::cst)))
    (abnf::tree-list-listp abnf::cstss))
  :rule-classes :rewrite)

Theorem: cst-token-conc2-match

(defthm cst-token-conc2-match
  (implies (and (cst-matchp abnf::cst "token")
                (equal (cst-token-conc? abnf::cst) 2))
           (b* ((abnf::cstss (cst-token-conc2 abnf::cst)))
             (cst-list-list-conc-matchp abnf::cstss "identifier")))
  :rule-classes :rewrite)

Theorem: cst-token-conc2-of-tree-fix-cst

(defthm cst-token-conc2-of-tree-fix-cst
  (equal (cst-token-conc2 (abnf::tree-fix abnf::cst))
         (cst-token-conc2 abnf::cst)))

Theorem: cst-token-conc2-tree-equiv-congruence-on-cst

(defthm cst-token-conc2-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-token-conc2 abnf::cst)
                  (cst-token-conc2 cst-equiv)))
  :rule-classes :congruence)

Function: cst-token-conc3

(defun cst-token-conc3 (abnf::cst)
  (declare (xargs :guard (abnf::treep abnf::cst)))
  (declare
       (xargs :guard (and (cst-matchp abnf::cst "token")
                          (equal (cst-token-conc? abnf::cst) 3))))
  (let ((__function__ 'cst-token-conc3))
    (declare (ignorable __function__))
    (abnf::tree-nonleaf->branches abnf::cst)))

Theorem: tree-list-listp-of-cst-token-conc3

(defthm tree-list-listp-of-cst-token-conc3
  (b* ((abnf::cstss (cst-token-conc3 abnf::cst)))
    (abnf::tree-list-listp abnf::cstss))
  :rule-classes :rewrite)

Theorem: cst-token-conc3-match

(defthm cst-token-conc3-match
  (implies
       (and (cst-matchp abnf::cst "token")
            (equal (cst-token-conc? abnf::cst) 3))
       (b* ((abnf::cstss (cst-token-conc3 abnf::cst)))
         (cst-list-list-conc-matchp abnf::cstss "atomic-literal")))
  :rule-classes :rewrite)

Theorem: cst-token-conc3-of-tree-fix-cst

(defthm cst-token-conc3-of-tree-fix-cst
  (equal (cst-token-conc3 (abnf::tree-fix abnf::cst))
         (cst-token-conc3 abnf::cst)))

Theorem: cst-token-conc3-tree-equiv-congruence-on-cst

(defthm cst-token-conc3-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-token-conc3 abnf::cst)
                  (cst-token-conc3 cst-equiv)))
  :rule-classes :congruence)

Function: cst-token-conc4

(defun cst-token-conc4 (abnf::cst)
  (declare (xargs :guard (abnf::treep abnf::cst)))
  (declare
       (xargs :guard (and (cst-matchp abnf::cst "token")
                          (equal (cst-token-conc? abnf::cst) 4))))
  (let ((__function__ 'cst-token-conc4))
    (declare (ignorable __function__))
    (abnf::tree-nonleaf->branches abnf::cst)))

Theorem: tree-list-listp-of-cst-token-conc4

(defthm tree-list-listp-of-cst-token-conc4
  (b* ((abnf::cstss (cst-token-conc4 abnf::cst)))
    (abnf::tree-list-listp abnf::cstss))
  :rule-classes :rewrite)

Theorem: cst-token-conc4-match

(defthm cst-token-conc4-match
  (implies
       (and (cst-matchp abnf::cst "token")
            (equal (cst-token-conc? abnf::cst) 4))
       (b* ((abnf::cstss (cst-token-conc4 abnf::cst)))
         (cst-list-list-conc-matchp abnf::cstss "decimal-numeral")))
  :rule-classes :rewrite)

Theorem: cst-token-conc4-of-tree-fix-cst

(defthm cst-token-conc4-of-tree-fix-cst
  (equal (cst-token-conc4 (abnf::tree-fix abnf::cst))
         (cst-token-conc4 abnf::cst)))

Theorem: cst-token-conc4-tree-equiv-congruence-on-cst

(defthm cst-token-conc4-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-token-conc4 abnf::cst)
                  (cst-token-conc4 cst-equiv)))
  :rule-classes :congruence)

Function: cst-token-conc5

(defun cst-token-conc5 (abnf::cst)
  (declare (xargs :guard (abnf::treep abnf::cst)))
  (declare
       (xargs :guard (and (cst-matchp abnf::cst "token")
                          (equal (cst-token-conc? abnf::cst) 5))))
  (let ((__function__ 'cst-token-conc5))
    (declare (ignorable __function__))
    (abnf::tree-nonleaf->branches abnf::cst)))

Theorem: tree-list-listp-of-cst-token-conc5

(defthm tree-list-listp-of-cst-token-conc5
  (b* ((abnf::cstss (cst-token-conc5 abnf::cst)))
    (abnf::tree-list-listp abnf::cstss))
  :rule-classes :rewrite)

Theorem: cst-token-conc5-match

(defthm cst-token-conc5-match
  (implies (and (cst-matchp abnf::cst "token")
                (equal (cst-token-conc? abnf::cst) 5))
           (b* ((abnf::cstss (cst-token-conc5 abnf::cst)))
             (cst-list-list-conc-matchp abnf::cstss "annotation")))
  :rule-classes :rewrite)

Theorem: cst-token-conc5-of-tree-fix-cst

(defthm cst-token-conc5-of-tree-fix-cst
  (equal (cst-token-conc5 (abnf::tree-fix abnf::cst))
         (cst-token-conc5 abnf::cst)))

Theorem: cst-token-conc5-tree-equiv-congruence-on-cst

(defthm cst-token-conc5-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-token-conc5 abnf::cst)
                  (cst-token-conc5 cst-equiv)))
  :rule-classes :congruence)

Function: cst-token-conc6

(defun cst-token-conc6 (abnf::cst)
  (declare (xargs :guard (abnf::treep abnf::cst)))
  (declare
       (xargs :guard (and (cst-matchp abnf::cst "token")
                          (equal (cst-token-conc? abnf::cst) 6))))
  (let ((__function__ 'cst-token-conc6))
    (declare (ignorable __function__))
    (abnf::tree-nonleaf->branches abnf::cst)))

Theorem: tree-list-listp-of-cst-token-conc6

(defthm tree-list-listp-of-cst-token-conc6
  (b* ((abnf::cstss (cst-token-conc6 abnf::cst)))
    (abnf::tree-list-listp abnf::cstss))
  :rule-classes :rewrite)

Theorem: cst-token-conc6-match

(defthm cst-token-conc6-match
  (implies (and (cst-matchp abnf::cst "token")
                (equal (cst-token-conc? abnf::cst) 6))
           (b* ((abnf::cstss (cst-token-conc6 abnf::cst)))
             (cst-list-list-conc-matchp abnf::cstss "symbol")))
  :rule-classes :rewrite)

Theorem: cst-token-conc6-of-tree-fix-cst

(defthm cst-token-conc6-of-tree-fix-cst
  (equal (cst-token-conc6 (abnf::tree-fix abnf::cst))
         (cst-token-conc6 abnf::cst)))

Theorem: cst-token-conc6-tree-equiv-congruence-on-cst

(defthm cst-token-conc6-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-token-conc6 abnf::cst)
                  (cst-token-conc6 cst-equiv)))
  :rule-classes :congruence)

Function: cst-lexeme-conc1

(defun cst-lexeme-conc1 (abnf::cst)
  (declare (xargs :guard (abnf::treep abnf::cst)))
  (declare (xargs :guard (and (cst-matchp abnf::cst "lexeme")
                              (equal (cst-lexeme-conc? abnf::cst)
                                     1))))
  (let ((__function__ 'cst-lexeme-conc1))
    (declare (ignorable __function__))
    (abnf::tree-nonleaf->branches abnf::cst)))

Theorem: tree-list-listp-of-cst-lexeme-conc1

(defthm tree-list-listp-of-cst-lexeme-conc1
  (b* ((abnf::cstss (cst-lexeme-conc1 abnf::cst)))
    (abnf::tree-list-listp abnf::cstss))
  :rule-classes :rewrite)

Theorem: cst-lexeme-conc1-match

(defthm cst-lexeme-conc1-match
  (implies (and (cst-matchp abnf::cst "lexeme")
                (equal (cst-lexeme-conc? abnf::cst) 1))
           (b* ((abnf::cstss (cst-lexeme-conc1 abnf::cst)))
             (cst-list-list-conc-matchp abnf::cstss "token")))
  :rule-classes :rewrite)

Theorem: cst-lexeme-conc1-of-tree-fix-cst

(defthm cst-lexeme-conc1-of-tree-fix-cst
  (equal (cst-lexeme-conc1 (abnf::tree-fix abnf::cst))
         (cst-lexeme-conc1 abnf::cst)))

Theorem: cst-lexeme-conc1-tree-equiv-congruence-on-cst

(defthm cst-lexeme-conc1-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-lexeme-conc1 abnf::cst)
                  (cst-lexeme-conc1 cst-equiv)))
  :rule-classes :congruence)

Function: cst-lexeme-conc2

(defun cst-lexeme-conc2 (abnf::cst)
  (declare (xargs :guard (abnf::treep abnf::cst)))
  (declare (xargs :guard (and (cst-matchp abnf::cst "lexeme")
                              (equal (cst-lexeme-conc? abnf::cst)
                                     2))))
  (let ((__function__ 'cst-lexeme-conc2))
    (declare (ignorable __function__))
    (abnf::tree-nonleaf->branches abnf::cst)))

Theorem: tree-list-listp-of-cst-lexeme-conc2

(defthm tree-list-listp-of-cst-lexeme-conc2
  (b* ((abnf::cstss (cst-lexeme-conc2 abnf::cst)))
    (abnf::tree-list-listp abnf::cstss))
  :rule-classes :rewrite)

Theorem: cst-lexeme-conc2-match

(defthm cst-lexeme-conc2-match
  (implies (and (cst-matchp abnf::cst "lexeme")
                (equal (cst-lexeme-conc? abnf::cst) 2))
           (b* ((abnf::cstss (cst-lexeme-conc2 abnf::cst)))
             (cst-list-list-conc-matchp abnf::cstss "comment")))
  :rule-classes :rewrite)

Theorem: cst-lexeme-conc2-of-tree-fix-cst

(defthm cst-lexeme-conc2-of-tree-fix-cst
  (equal (cst-lexeme-conc2 (abnf::tree-fix abnf::cst))
         (cst-lexeme-conc2 abnf::cst)))

Theorem: cst-lexeme-conc2-tree-equiv-congruence-on-cst

(defthm cst-lexeme-conc2-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-lexeme-conc2 abnf::cst)
                  (cst-lexeme-conc2 cst-equiv)))
  :rule-classes :congruence)

Function: cst-lexeme-conc3

(defun cst-lexeme-conc3 (abnf::cst)
  (declare (xargs :guard (abnf::treep abnf::cst)))
  (declare (xargs :guard (and (cst-matchp abnf::cst "lexeme")
                              (equal (cst-lexeme-conc? abnf::cst)
                                     3))))
  (let ((__function__ 'cst-lexeme-conc3))
    (declare (ignorable __function__))
    (abnf::tree-nonleaf->branches abnf::cst)))

Theorem: tree-list-listp-of-cst-lexeme-conc3

(defthm tree-list-listp-of-cst-lexeme-conc3
  (b* ((abnf::cstss (cst-lexeme-conc3 abnf::cst)))
    (abnf::tree-list-listp abnf::cstss))
  :rule-classes :rewrite)

Theorem: cst-lexeme-conc3-match

(defthm cst-lexeme-conc3-match
  (implies (and (cst-matchp abnf::cst "lexeme")
                (equal (cst-lexeme-conc? abnf::cst) 3))
           (b* ((abnf::cstss (cst-lexeme-conc3 abnf::cst)))
             (cst-list-list-conc-matchp abnf::cstss "whitespace")))
  :rule-classes :rewrite)

Theorem: cst-lexeme-conc3-of-tree-fix-cst

(defthm cst-lexeme-conc3-of-tree-fix-cst
  (equal (cst-lexeme-conc3 (abnf::tree-fix abnf::cst))
         (cst-lexeme-conc3 abnf::cst)))

Theorem: cst-lexeme-conc3-tree-equiv-congruence-on-cst

(defthm cst-lexeme-conc3-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-lexeme-conc3 abnf::cst)
                  (cst-lexeme-conc3 cst-equiv)))
  :rule-classes :congruence)

Function: cst-program-id-conc

(defun cst-program-id-conc (abnf::cst)
  (declare (xargs :guard (abnf::treep abnf::cst)))
  (declare (xargs :guard (cst-matchp abnf::cst "program-id")))
  (let ((__function__ 'cst-program-id-conc))
    (declare (ignorable __function__))
    (abnf::tree-nonleaf->branches abnf::cst)))

Theorem: tree-list-listp-of-cst-program-id-conc

(defthm tree-list-listp-of-cst-program-id-conc
  (b* ((abnf::cstss (cst-program-id-conc abnf::cst)))
    (abnf::tree-list-listp abnf::cstss))
  :rule-classes :rewrite)

Theorem: cst-program-id-conc-match

(defthm cst-program-id-conc-match
  (implies (cst-matchp abnf::cst "program-id")
           (b* ((abnf::cstss (cst-program-id-conc abnf::cst)))
             (cst-list-list-conc-matchp
                  abnf::cstss "identifier \".\" network")))
  :rule-classes :rewrite)

Theorem: cst-program-id-conc-of-tree-fix-cst

(defthm cst-program-id-conc-of-tree-fix-cst
  (equal (cst-program-id-conc (abnf::tree-fix abnf::cst))
         (cst-program-id-conc abnf::cst)))

Theorem: cst-program-id-conc-tree-equiv-congruence-on-cst

(defthm cst-program-id-conc-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-program-id-conc abnf::cst)
                  (cst-program-id-conc cst-equiv)))
  :rule-classes :congruence)

Function: cst-network-conc

(defun cst-network-conc (abnf::cst)
  (declare (xargs :guard (abnf::treep abnf::cst)))
  (declare (xargs :guard (cst-matchp abnf::cst "network")))
  (let ((__function__ 'cst-network-conc))
    (declare (ignorable __function__))
    (abnf::tree-nonleaf->branches abnf::cst)))

Theorem: tree-list-listp-of-cst-network-conc

(defthm tree-list-listp-of-cst-network-conc
  (b* ((abnf::cstss (cst-network-conc abnf::cst)))
    (abnf::tree-list-listp abnf::cstss))
  :rule-classes :rewrite)

Theorem: cst-network-conc-match

(defthm cst-network-conc-match
  (implies (cst-matchp abnf::cst "network")
           (b* ((abnf::cstss (cst-network-conc abnf::cst)))
             (cst-list-list-conc-matchp abnf::cstss "%s\"aleo\"")))
  :rule-classes :rewrite)

Theorem: cst-network-conc-of-tree-fix-cst

(defthm cst-network-conc-of-tree-fix-cst
  (equal (cst-network-conc (abnf::tree-fix abnf::cst))
         (cst-network-conc abnf::cst)))

Theorem: cst-network-conc-tree-equiv-congruence-on-cst

(defthm cst-network-conc-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-network-conc abnf::cst)
                  (cst-network-conc cst-equiv)))
  :rule-classes :congruence)

Function: cst-locator-conc

(defun cst-locator-conc (abnf::cst)
  (declare (xargs :guard (abnf::treep abnf::cst)))
  (declare (xargs :guard (cst-matchp abnf::cst "locator")))
  (let ((__function__ 'cst-locator-conc))
    (declare (ignorable __function__))
    (abnf::tree-nonleaf->branches abnf::cst)))

Theorem: tree-list-listp-of-cst-locator-conc

(defthm tree-list-listp-of-cst-locator-conc
  (b* ((abnf::cstss (cst-locator-conc abnf::cst)))
    (abnf::tree-list-listp abnf::cstss))
  :rule-classes :rewrite)

Theorem: cst-locator-conc-match

(defthm cst-locator-conc-match
  (implies
       (cst-matchp abnf::cst "locator")
       (b* ((abnf::cstss (cst-locator-conc abnf::cst)))
         (cst-list-list-conc-matchp abnf::cstss
                                    "program-id \"/\" identifier")))
  :rule-classes :rewrite)

Theorem: cst-locator-conc-of-tree-fix-cst

(defthm cst-locator-conc-of-tree-fix-cst
  (equal (cst-locator-conc (abnf::tree-fix abnf::cst))
         (cst-locator-conc abnf::cst)))

Theorem: cst-locator-conc-tree-equiv-congruence-on-cst

(defthm cst-locator-conc-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-locator-conc abnf::cst)
                  (cst-locator-conc cst-equiv)))
  :rule-classes :congruence)

Function: cst-integer-type-conc1

(defun cst-integer-type-conc1 (abnf::cst)
  (declare (xargs :guard (abnf::treep abnf::cst)))
  (declare
       (xargs :guard (and (cst-matchp abnf::cst "integer-type")
                          (equal (cst-integer-type-conc? abnf::cst)
                                 1))))
  (let ((__function__ 'cst-integer-type-conc1))
    (declare (ignorable __function__))
    (abnf::tree-nonleaf->branches abnf::cst)))

Theorem: tree-list-listp-of-cst-integer-type-conc1

(defthm tree-list-listp-of-cst-integer-type-conc1
  (b* ((abnf::cstss (cst-integer-type-conc1 abnf::cst)))
    (abnf::tree-list-listp abnf::cstss))
  :rule-classes :rewrite)

Theorem: cst-integer-type-conc1-match

(defthm cst-integer-type-conc1-match
  (implies
       (and (cst-matchp abnf::cst "integer-type")
            (equal (cst-integer-type-conc? abnf::cst)
                   1))
       (b* ((abnf::cstss (cst-integer-type-conc1 abnf::cst)))
         (cst-list-list-conc-matchp abnf::cstss "unsigned-type")))
  :rule-classes :rewrite)

Theorem: cst-integer-type-conc1-of-tree-fix-cst

(defthm cst-integer-type-conc1-of-tree-fix-cst
  (equal (cst-integer-type-conc1 (abnf::tree-fix abnf::cst))
         (cst-integer-type-conc1 abnf::cst)))

Theorem: cst-integer-type-conc1-tree-equiv-congruence-on-cst

(defthm cst-integer-type-conc1-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-integer-type-conc1 abnf::cst)
                  (cst-integer-type-conc1 cst-equiv)))
  :rule-classes :congruence)

Function: cst-integer-type-conc2

(defun cst-integer-type-conc2 (abnf::cst)
  (declare (xargs :guard (abnf::treep abnf::cst)))
  (declare
       (xargs :guard (and (cst-matchp abnf::cst "integer-type")
                          (equal (cst-integer-type-conc? abnf::cst)
                                 2))))
  (let ((__function__ 'cst-integer-type-conc2))
    (declare (ignorable __function__))
    (abnf::tree-nonleaf->branches abnf::cst)))

Theorem: tree-list-listp-of-cst-integer-type-conc2

(defthm tree-list-listp-of-cst-integer-type-conc2
  (b* ((abnf::cstss (cst-integer-type-conc2 abnf::cst)))
    (abnf::tree-list-listp abnf::cstss))
  :rule-classes :rewrite)

Theorem: cst-integer-type-conc2-match

(defthm cst-integer-type-conc2-match
  (implies (and (cst-matchp abnf::cst "integer-type")
                (equal (cst-integer-type-conc? abnf::cst)
                       2))
           (b* ((abnf::cstss (cst-integer-type-conc2 abnf::cst)))
             (cst-list-list-conc-matchp abnf::cstss "signed-type")))
  :rule-classes :rewrite)

Theorem: cst-integer-type-conc2-of-tree-fix-cst

(defthm cst-integer-type-conc2-of-tree-fix-cst
  (equal (cst-integer-type-conc2 (abnf::tree-fix abnf::cst))
         (cst-integer-type-conc2 abnf::cst)))

Theorem: cst-integer-type-conc2-tree-equiv-congruence-on-cst

(defthm cst-integer-type-conc2-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-integer-type-conc2 abnf::cst)
                  (cst-integer-type-conc2 cst-equiv)))
  :rule-classes :congruence)

Function: cst-field-type-conc

(defun cst-field-type-conc (abnf::cst)
  (declare (xargs :guard (abnf::treep abnf::cst)))
  (declare (xargs :guard (cst-matchp abnf::cst "field-type")))
  (let ((__function__ 'cst-field-type-conc))
    (declare (ignorable __function__))
    (abnf::tree-nonleaf->branches abnf::cst)))

Theorem: tree-list-listp-of-cst-field-type-conc

(defthm tree-list-listp-of-cst-field-type-conc
  (b* ((abnf::cstss (cst-field-type-conc abnf::cst)))
    (abnf::tree-list-listp abnf::cstss))
  :rule-classes :rewrite)

Theorem: cst-field-type-conc-match

(defthm cst-field-type-conc-match
  (implies (cst-matchp abnf::cst "field-type")
           (b* ((abnf::cstss (cst-field-type-conc abnf::cst)))
             (cst-list-list-conc-matchp abnf::cstss "%s\"field\"")))
  :rule-classes :rewrite)

Theorem: cst-field-type-conc-of-tree-fix-cst

(defthm cst-field-type-conc-of-tree-fix-cst
  (equal (cst-field-type-conc (abnf::tree-fix abnf::cst))
         (cst-field-type-conc abnf::cst)))

Theorem: cst-field-type-conc-tree-equiv-congruence-on-cst

(defthm cst-field-type-conc-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-field-type-conc abnf::cst)
                  (cst-field-type-conc cst-equiv)))
  :rule-classes :congruence)

Function: cst-group-type-conc

(defun cst-group-type-conc (abnf::cst)
  (declare (xargs :guard (abnf::treep abnf::cst)))
  (declare (xargs :guard (cst-matchp abnf::cst "group-type")))
  (let ((__function__ 'cst-group-type-conc))
    (declare (ignorable __function__))
    (abnf::tree-nonleaf->branches abnf::cst)))

Theorem: tree-list-listp-of-cst-group-type-conc

(defthm tree-list-listp-of-cst-group-type-conc
  (b* ((abnf::cstss (cst-group-type-conc abnf::cst)))
    (abnf::tree-list-listp abnf::cstss))
  :rule-classes :rewrite)

Theorem: cst-group-type-conc-match

(defthm cst-group-type-conc-match
  (implies (cst-matchp abnf::cst "group-type")
           (b* ((abnf::cstss (cst-group-type-conc abnf::cst)))
             (cst-list-list-conc-matchp abnf::cstss "%s\"group\"")))
  :rule-classes :rewrite)

Theorem: cst-group-type-conc-of-tree-fix-cst

(defthm cst-group-type-conc-of-tree-fix-cst
  (equal (cst-group-type-conc (abnf::tree-fix abnf::cst))
         (cst-group-type-conc abnf::cst)))

Theorem: cst-group-type-conc-tree-equiv-congruence-on-cst

(defthm cst-group-type-conc-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-group-type-conc abnf::cst)
                  (cst-group-type-conc cst-equiv)))
  :rule-classes :congruence)

Function: cst-scalar-type-conc

(defun cst-scalar-type-conc (abnf::cst)
  (declare (xargs :guard (abnf::treep abnf::cst)))
  (declare (xargs :guard (cst-matchp abnf::cst "scalar-type")))
  (let ((__function__ 'cst-scalar-type-conc))
    (declare (ignorable __function__))
    (abnf::tree-nonleaf->branches abnf::cst)))

Theorem: tree-list-listp-of-cst-scalar-type-conc

(defthm tree-list-listp-of-cst-scalar-type-conc
  (b* ((abnf::cstss (cst-scalar-type-conc abnf::cst)))
    (abnf::tree-list-listp abnf::cstss))
  :rule-classes :rewrite)

Theorem: cst-scalar-type-conc-match

(defthm cst-scalar-type-conc-match
  (implies (cst-matchp abnf::cst "scalar-type")
           (b* ((abnf::cstss (cst-scalar-type-conc abnf::cst)))
             (cst-list-list-conc-matchp abnf::cstss "%s\"scalar\"")))
  :rule-classes :rewrite)

Theorem: cst-scalar-type-conc-of-tree-fix-cst

(defthm cst-scalar-type-conc-of-tree-fix-cst
  (equal (cst-scalar-type-conc (abnf::tree-fix abnf::cst))
         (cst-scalar-type-conc abnf::cst)))

Theorem: cst-scalar-type-conc-tree-equiv-congruence-on-cst

(defthm cst-scalar-type-conc-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-scalar-type-conc abnf::cst)
                  (cst-scalar-type-conc cst-equiv)))
  :rule-classes :congruence)

Function: cst-arithmetic-type-conc1

(defun cst-arithmetic-type-conc1 (abnf::cst)
 (declare (xargs :guard (abnf::treep abnf::cst)))
 (declare
     (xargs :guard (and (cst-matchp abnf::cst "arithmetic-type")
                        (equal (cst-arithmetic-type-conc? abnf::cst)
                               1))))
 (let ((__function__ 'cst-arithmetic-type-conc1))
   (declare (ignorable __function__))
   (abnf::tree-nonleaf->branches abnf::cst)))

Theorem: tree-list-listp-of-cst-arithmetic-type-conc1

(defthm tree-list-listp-of-cst-arithmetic-type-conc1
  (b* ((abnf::cstss (cst-arithmetic-type-conc1 abnf::cst)))
    (abnf::tree-list-listp abnf::cstss))
  :rule-classes :rewrite)

Theorem: cst-arithmetic-type-conc1-match

(defthm cst-arithmetic-type-conc1-match
 (implies (and (cst-matchp abnf::cst "arithmetic-type")
               (equal (cst-arithmetic-type-conc? abnf::cst)
                      1))
          (b* ((abnf::cstss (cst-arithmetic-type-conc1 abnf::cst)))
            (cst-list-list-conc-matchp abnf::cstss "integer-type")))
 :rule-classes :rewrite)

Theorem: cst-arithmetic-type-conc1-of-tree-fix-cst

(defthm cst-arithmetic-type-conc1-of-tree-fix-cst
  (equal (cst-arithmetic-type-conc1 (abnf::tree-fix abnf::cst))
         (cst-arithmetic-type-conc1 abnf::cst)))

Theorem: cst-arithmetic-type-conc1-tree-equiv-congruence-on-cst

(defthm cst-arithmetic-type-conc1-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-arithmetic-type-conc1 abnf::cst)
                  (cst-arithmetic-type-conc1 cst-equiv)))
  :rule-classes :congruence)

Function: cst-arithmetic-type-conc2

(defun cst-arithmetic-type-conc2 (abnf::cst)
 (declare (xargs :guard (abnf::treep abnf::cst)))
 (declare
     (xargs :guard (and (cst-matchp abnf::cst "arithmetic-type")
                        (equal (cst-arithmetic-type-conc? abnf::cst)
                               2))))
 (let ((__function__ 'cst-arithmetic-type-conc2))
   (declare (ignorable __function__))
   (abnf::tree-nonleaf->branches abnf::cst)))

Theorem: tree-list-listp-of-cst-arithmetic-type-conc2

(defthm tree-list-listp-of-cst-arithmetic-type-conc2
  (b* ((abnf::cstss (cst-arithmetic-type-conc2 abnf::cst)))
    (abnf::tree-list-listp abnf::cstss))
  :rule-classes :rewrite)

Theorem: cst-arithmetic-type-conc2-match

(defthm cst-arithmetic-type-conc2-match
  (implies (and (cst-matchp abnf::cst "arithmetic-type")
                (equal (cst-arithmetic-type-conc? abnf::cst)
                       2))
           (b* ((abnf::cstss (cst-arithmetic-type-conc2 abnf::cst)))
             (cst-list-list-conc-matchp abnf::cstss "field-type")))
  :rule-classes :rewrite)

Theorem: cst-arithmetic-type-conc2-of-tree-fix-cst

(defthm cst-arithmetic-type-conc2-of-tree-fix-cst
  (equal (cst-arithmetic-type-conc2 (abnf::tree-fix abnf::cst))
         (cst-arithmetic-type-conc2 abnf::cst)))

Theorem: cst-arithmetic-type-conc2-tree-equiv-congruence-on-cst

(defthm cst-arithmetic-type-conc2-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-arithmetic-type-conc2 abnf::cst)
                  (cst-arithmetic-type-conc2 cst-equiv)))
  :rule-classes :congruence)

Function: cst-arithmetic-type-conc3

(defun cst-arithmetic-type-conc3 (abnf::cst)
 (declare (xargs :guard (abnf::treep abnf::cst)))
 (declare
     (xargs :guard (and (cst-matchp abnf::cst "arithmetic-type")
                        (equal (cst-arithmetic-type-conc? abnf::cst)
                               3))))
 (let ((__function__ 'cst-arithmetic-type-conc3))
   (declare (ignorable __function__))
   (abnf::tree-nonleaf->branches abnf::cst)))

Theorem: tree-list-listp-of-cst-arithmetic-type-conc3

(defthm tree-list-listp-of-cst-arithmetic-type-conc3
  (b* ((abnf::cstss (cst-arithmetic-type-conc3 abnf::cst)))
    (abnf::tree-list-listp abnf::cstss))
  :rule-classes :rewrite)

Theorem: cst-arithmetic-type-conc3-match

(defthm cst-arithmetic-type-conc3-match
  (implies (and (cst-matchp abnf::cst "arithmetic-type")
                (equal (cst-arithmetic-type-conc? abnf::cst)
                       3))
           (b* ((abnf::cstss (cst-arithmetic-type-conc3 abnf::cst)))
             (cst-list-list-conc-matchp abnf::cstss "group-type")))
  :rule-classes :rewrite)

Theorem: cst-arithmetic-type-conc3-of-tree-fix-cst

(defthm cst-arithmetic-type-conc3-of-tree-fix-cst
  (equal (cst-arithmetic-type-conc3 (abnf::tree-fix abnf::cst))
         (cst-arithmetic-type-conc3 abnf::cst)))

Theorem: cst-arithmetic-type-conc3-tree-equiv-congruence-on-cst

(defthm cst-arithmetic-type-conc3-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-arithmetic-type-conc3 abnf::cst)
                  (cst-arithmetic-type-conc3 cst-equiv)))
  :rule-classes :congruence)

Function: cst-arithmetic-type-conc4

(defun cst-arithmetic-type-conc4 (abnf::cst)
 (declare (xargs :guard (abnf::treep abnf::cst)))
 (declare
     (xargs :guard (and (cst-matchp abnf::cst "arithmetic-type")
                        (equal (cst-arithmetic-type-conc? abnf::cst)
                               4))))
 (let ((__function__ 'cst-arithmetic-type-conc4))
   (declare (ignorable __function__))
   (abnf::tree-nonleaf->branches abnf::cst)))

Theorem: tree-list-listp-of-cst-arithmetic-type-conc4

(defthm tree-list-listp-of-cst-arithmetic-type-conc4
  (b* ((abnf::cstss (cst-arithmetic-type-conc4 abnf::cst)))
    (abnf::tree-list-listp abnf::cstss))
  :rule-classes :rewrite)

Theorem: cst-arithmetic-type-conc4-match

(defthm cst-arithmetic-type-conc4-match
  (implies (and (cst-matchp abnf::cst "arithmetic-type")
                (equal (cst-arithmetic-type-conc? abnf::cst)
                       4))
           (b* ((abnf::cstss (cst-arithmetic-type-conc4 abnf::cst)))
             (cst-list-list-conc-matchp abnf::cstss "scalar-type")))
  :rule-classes :rewrite)

Theorem: cst-arithmetic-type-conc4-of-tree-fix-cst

(defthm cst-arithmetic-type-conc4-of-tree-fix-cst
  (equal (cst-arithmetic-type-conc4 (abnf::tree-fix abnf::cst))
         (cst-arithmetic-type-conc4 abnf::cst)))

Theorem: cst-arithmetic-type-conc4-tree-equiv-congruence-on-cst

(defthm cst-arithmetic-type-conc4-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-arithmetic-type-conc4 abnf::cst)
                  (cst-arithmetic-type-conc4 cst-equiv)))
  :rule-classes :congruence)

Function: cst-boolean-type-conc

(defun cst-boolean-type-conc (abnf::cst)
  (declare (xargs :guard (abnf::treep abnf::cst)))
  (declare (xargs :guard (cst-matchp abnf::cst "boolean-type")))
  (let ((__function__ 'cst-boolean-type-conc))
    (declare (ignorable __function__))
    (abnf::tree-nonleaf->branches abnf::cst)))

Theorem: tree-list-listp-of-cst-boolean-type-conc

(defthm tree-list-listp-of-cst-boolean-type-conc
  (b* ((abnf::cstss (cst-boolean-type-conc abnf::cst)))
    (abnf::tree-list-listp abnf::cstss))
  :rule-classes :rewrite)

Theorem: cst-boolean-type-conc-match

(defthm cst-boolean-type-conc-match
  (implies (cst-matchp abnf::cst "boolean-type")
           (b* ((abnf::cstss (cst-boolean-type-conc abnf::cst)))
             (cst-list-list-conc-matchp abnf::cstss "%s\"bool\"")))
  :rule-classes :rewrite)

Theorem: cst-boolean-type-conc-of-tree-fix-cst

(defthm cst-boolean-type-conc-of-tree-fix-cst
  (equal (cst-boolean-type-conc (abnf::tree-fix abnf::cst))
         (cst-boolean-type-conc abnf::cst)))

Theorem: cst-boolean-type-conc-tree-equiv-congruence-on-cst

(defthm cst-boolean-type-conc-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-boolean-type-conc abnf::cst)
                  (cst-boolean-type-conc cst-equiv)))
  :rule-classes :congruence)

Function: cst-address-type-conc

(defun cst-address-type-conc (abnf::cst)
  (declare (xargs :guard (abnf::treep abnf::cst)))
  (declare (xargs :guard (cst-matchp abnf::cst "address-type")))
  (let ((__function__ 'cst-address-type-conc))
    (declare (ignorable __function__))
    (abnf::tree-nonleaf->branches abnf::cst)))

Theorem: tree-list-listp-of-cst-address-type-conc

(defthm tree-list-listp-of-cst-address-type-conc
  (b* ((abnf::cstss (cst-address-type-conc abnf::cst)))
    (abnf::tree-list-listp abnf::cstss))
  :rule-classes :rewrite)

Theorem: cst-address-type-conc-match

(defthm cst-address-type-conc-match
  (implies (cst-matchp abnf::cst "address-type")
           (b* ((abnf::cstss (cst-address-type-conc abnf::cst)))
             (cst-list-list-conc-matchp abnf::cstss "%s\"address\"")))
  :rule-classes :rewrite)

Theorem: cst-address-type-conc-of-tree-fix-cst

(defthm cst-address-type-conc-of-tree-fix-cst
  (equal (cst-address-type-conc (abnf::tree-fix abnf::cst))
         (cst-address-type-conc abnf::cst)))

Theorem: cst-address-type-conc-tree-equiv-congruence-on-cst

(defthm cst-address-type-conc-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-address-type-conc abnf::cst)
                  (cst-address-type-conc cst-equiv)))
  :rule-classes :congruence)

Function: cst-signature-type-conc

(defun cst-signature-type-conc (abnf::cst)
  (declare (xargs :guard (abnf::treep abnf::cst)))
  (declare (xargs :guard (cst-matchp abnf::cst "signature-type")))
  (let ((__function__ 'cst-signature-type-conc))
    (declare (ignorable __function__))
    (abnf::tree-nonleaf->branches abnf::cst)))

Theorem: tree-list-listp-of-cst-signature-type-conc

(defthm tree-list-listp-of-cst-signature-type-conc
  (b* ((abnf::cstss (cst-signature-type-conc abnf::cst)))
    (abnf::tree-list-listp abnf::cstss))
  :rule-classes :rewrite)

Theorem: cst-signature-type-conc-match

(defthm cst-signature-type-conc-match
  (implies
       (cst-matchp abnf::cst "signature-type")
       (b* ((abnf::cstss (cst-signature-type-conc abnf::cst)))
         (cst-list-list-conc-matchp abnf::cstss "%s\"signature\"")))
  :rule-classes :rewrite)

Theorem: cst-signature-type-conc-of-tree-fix-cst

(defthm cst-signature-type-conc-of-tree-fix-cst
  (equal (cst-signature-type-conc (abnf::tree-fix abnf::cst))
         (cst-signature-type-conc abnf::cst)))

Theorem: cst-signature-type-conc-tree-equiv-congruence-on-cst

(defthm cst-signature-type-conc-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-signature-type-conc abnf::cst)
                  (cst-signature-type-conc cst-equiv)))
  :rule-classes :congruence)

Function: cst-string-type-conc

(defun cst-string-type-conc (abnf::cst)
  (declare (xargs :guard (abnf::treep abnf::cst)))
  (declare (xargs :guard (cst-matchp abnf::cst "string-type")))
  (let ((__function__ 'cst-string-type-conc))
    (declare (ignorable __function__))
    (abnf::tree-nonleaf->branches abnf::cst)))

Theorem: tree-list-listp-of-cst-string-type-conc

(defthm tree-list-listp-of-cst-string-type-conc
  (b* ((abnf::cstss (cst-string-type-conc abnf::cst)))
    (abnf::tree-list-listp abnf::cstss))
  :rule-classes :rewrite)

Theorem: cst-string-type-conc-match

(defthm cst-string-type-conc-match
  (implies (cst-matchp abnf::cst "string-type")
           (b* ((abnf::cstss (cst-string-type-conc abnf::cst)))
             (cst-list-list-conc-matchp abnf::cstss "%s\"string\"")))
  :rule-classes :rewrite)

Theorem: cst-string-type-conc-of-tree-fix-cst

(defthm cst-string-type-conc-of-tree-fix-cst
  (equal (cst-string-type-conc (abnf::tree-fix abnf::cst))
         (cst-string-type-conc abnf::cst)))

Theorem: cst-string-type-conc-tree-equiv-congruence-on-cst

(defthm cst-string-type-conc-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-string-type-conc abnf::cst)
                  (cst-string-type-conc cst-equiv)))
  :rule-classes :congruence)

Function: cst-named-primitive-type-conc1

(defun cst-named-primitive-type-conc1 (abnf::cst)
 (declare (xargs :guard (abnf::treep abnf::cst)))
 (declare
  (xargs
       :guard (and (cst-matchp abnf::cst "named-primitive-type")
                   (equal (cst-named-primitive-type-conc? abnf::cst)
                          1))))
 (let ((__function__ 'cst-named-primitive-type-conc1))
   (declare (ignorable __function__))
   (abnf::tree-nonleaf->branches abnf::cst)))

Theorem: tree-list-listp-of-cst-named-primitive-type-conc1

(defthm tree-list-listp-of-cst-named-primitive-type-conc1
  (b* ((abnf::cstss (cst-named-primitive-type-conc1 abnf::cst)))
    (abnf::tree-list-listp abnf::cstss))
  :rule-classes :rewrite)

Theorem: cst-named-primitive-type-conc1-match

(defthm cst-named-primitive-type-conc1-match
 (implies
      (and (cst-matchp abnf::cst "named-primitive-type")
           (equal (cst-named-primitive-type-conc? abnf::cst)
                  1))
      (b* ((abnf::cstss (cst-named-primitive-type-conc1 abnf::cst)))
        (cst-list-list-conc-matchp abnf::cstss "boolean-type")))
 :rule-classes :rewrite)

Theorem: cst-named-primitive-type-conc1-of-tree-fix-cst

(defthm cst-named-primitive-type-conc1-of-tree-fix-cst
  (equal (cst-named-primitive-type-conc1 (abnf::tree-fix abnf::cst))
         (cst-named-primitive-type-conc1 abnf::cst)))

Theorem: cst-named-primitive-type-conc1-tree-equiv-congruence-on-cst

(defthm cst-named-primitive-type-conc1-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-named-primitive-type-conc1 abnf::cst)
                  (cst-named-primitive-type-conc1 cst-equiv)))
  :rule-classes :congruence)

Function: cst-named-primitive-type-conc2

(defun cst-named-primitive-type-conc2 (abnf::cst)
 (declare (xargs :guard (abnf::treep abnf::cst)))
 (declare
  (xargs
       :guard (and (cst-matchp abnf::cst "named-primitive-type")
                   (equal (cst-named-primitive-type-conc? abnf::cst)
                          2))))
 (let ((__function__ 'cst-named-primitive-type-conc2))
   (declare (ignorable __function__))
   (abnf::tree-nonleaf->branches abnf::cst)))

Theorem: tree-list-listp-of-cst-named-primitive-type-conc2

(defthm tree-list-listp-of-cst-named-primitive-type-conc2
  (b* ((abnf::cstss (cst-named-primitive-type-conc2 abnf::cst)))
    (abnf::tree-list-listp abnf::cstss))
  :rule-classes :rewrite)

Theorem: cst-named-primitive-type-conc2-match

(defthm cst-named-primitive-type-conc2-match
 (implies
      (and (cst-matchp abnf::cst "named-primitive-type")
           (equal (cst-named-primitive-type-conc? abnf::cst)
                  2))
      (b* ((abnf::cstss (cst-named-primitive-type-conc2 abnf::cst)))
        (cst-list-list-conc-matchp abnf::cstss "arithmetic-type")))
 :rule-classes :rewrite)

Theorem: cst-named-primitive-type-conc2-of-tree-fix-cst

(defthm cst-named-primitive-type-conc2-of-tree-fix-cst
  (equal (cst-named-primitive-type-conc2 (abnf::tree-fix abnf::cst))
         (cst-named-primitive-type-conc2 abnf::cst)))

Theorem: cst-named-primitive-type-conc2-tree-equiv-congruence-on-cst

(defthm cst-named-primitive-type-conc2-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-named-primitive-type-conc2 abnf::cst)
                  (cst-named-primitive-type-conc2 cst-equiv)))
  :rule-classes :congruence)

Function: cst-named-primitive-type-conc3

(defun cst-named-primitive-type-conc3 (abnf::cst)
 (declare (xargs :guard (abnf::treep abnf::cst)))
 (declare
  (xargs
       :guard (and (cst-matchp abnf::cst "named-primitive-type")
                   (equal (cst-named-primitive-type-conc? abnf::cst)
                          3))))
 (let ((__function__ 'cst-named-primitive-type-conc3))
   (declare (ignorable __function__))
   (abnf::tree-nonleaf->branches abnf::cst)))

Theorem: tree-list-listp-of-cst-named-primitive-type-conc3

(defthm tree-list-listp-of-cst-named-primitive-type-conc3
  (b* ((abnf::cstss (cst-named-primitive-type-conc3 abnf::cst)))
    (abnf::tree-list-listp abnf::cstss))
  :rule-classes :rewrite)

Theorem: cst-named-primitive-type-conc3-match

(defthm cst-named-primitive-type-conc3-match
 (implies
      (and (cst-matchp abnf::cst "named-primitive-type")
           (equal (cst-named-primitive-type-conc? abnf::cst)
                  3))
      (b* ((abnf::cstss (cst-named-primitive-type-conc3 abnf::cst)))
        (cst-list-list-conc-matchp abnf::cstss "address-type")))
 :rule-classes :rewrite)

Theorem: cst-named-primitive-type-conc3-of-tree-fix-cst

(defthm cst-named-primitive-type-conc3-of-tree-fix-cst
  (equal (cst-named-primitive-type-conc3 (abnf::tree-fix abnf::cst))
         (cst-named-primitive-type-conc3 abnf::cst)))

Theorem: cst-named-primitive-type-conc3-tree-equiv-congruence-on-cst

(defthm cst-named-primitive-type-conc3-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-named-primitive-type-conc3 abnf::cst)
                  (cst-named-primitive-type-conc3 cst-equiv)))
  :rule-classes :congruence)

Function: cst-named-primitive-type-conc4

(defun cst-named-primitive-type-conc4 (abnf::cst)
 (declare (xargs :guard (abnf::treep abnf::cst)))
 (declare
  (xargs
       :guard (and (cst-matchp abnf::cst "named-primitive-type")
                   (equal (cst-named-primitive-type-conc? abnf::cst)
                          4))))
 (let ((__function__ 'cst-named-primitive-type-conc4))
   (declare (ignorable __function__))
   (abnf::tree-nonleaf->branches abnf::cst)))

Theorem: tree-list-listp-of-cst-named-primitive-type-conc4

(defthm tree-list-listp-of-cst-named-primitive-type-conc4
  (b* ((abnf::cstss (cst-named-primitive-type-conc4 abnf::cst)))
    (abnf::tree-list-listp abnf::cstss))
  :rule-classes :rewrite)

Theorem: cst-named-primitive-type-conc4-match

(defthm cst-named-primitive-type-conc4-match
 (implies
      (and (cst-matchp abnf::cst "named-primitive-type")
           (equal (cst-named-primitive-type-conc? abnf::cst)
                  4))
      (b* ((abnf::cstss (cst-named-primitive-type-conc4 abnf::cst)))
        (cst-list-list-conc-matchp abnf::cstss "signature-type")))
 :rule-classes :rewrite)

Theorem: cst-named-primitive-type-conc4-of-tree-fix-cst

(defthm cst-named-primitive-type-conc4-of-tree-fix-cst
  (equal (cst-named-primitive-type-conc4 (abnf::tree-fix abnf::cst))
         (cst-named-primitive-type-conc4 abnf::cst)))

Theorem: cst-named-primitive-type-conc4-tree-equiv-congruence-on-cst

(defthm cst-named-primitive-type-conc4-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-named-primitive-type-conc4 abnf::cst)
                  (cst-named-primitive-type-conc4 cst-equiv)))
  :rule-classes :congruence)

Function: cst-named-primitive-type-conc5

(defun cst-named-primitive-type-conc5 (abnf::cst)
 (declare (xargs :guard (abnf::treep abnf::cst)))
 (declare
  (xargs
       :guard (and (cst-matchp abnf::cst "named-primitive-type")
                   (equal (cst-named-primitive-type-conc? abnf::cst)
                          5))))
 (let ((__function__ 'cst-named-primitive-type-conc5))
   (declare (ignorable __function__))
   (abnf::tree-nonleaf->branches abnf::cst)))

Theorem: tree-list-listp-of-cst-named-primitive-type-conc5

(defthm tree-list-listp-of-cst-named-primitive-type-conc5
  (b* ((abnf::cstss (cst-named-primitive-type-conc5 abnf::cst)))
    (abnf::tree-list-listp abnf::cstss))
  :rule-classes :rewrite)

Theorem: cst-named-primitive-type-conc5-match

(defthm cst-named-primitive-type-conc5-match
 (implies
      (and (cst-matchp abnf::cst "named-primitive-type")
           (equal (cst-named-primitive-type-conc? abnf::cst)
                  5))
      (b* ((abnf::cstss (cst-named-primitive-type-conc5 abnf::cst)))
        (cst-list-list-conc-matchp abnf::cstss "string-type")))
 :rule-classes :rewrite)

Theorem: cst-named-primitive-type-conc5-of-tree-fix-cst

(defthm cst-named-primitive-type-conc5-of-tree-fix-cst
  (equal (cst-named-primitive-type-conc5 (abnf::tree-fix abnf::cst))
         (cst-named-primitive-type-conc5 abnf::cst)))

Theorem: cst-named-primitive-type-conc5-tree-equiv-congruence-on-cst

(defthm cst-named-primitive-type-conc5-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-named-primitive-type-conc5 abnf::cst)
                  (cst-named-primitive-type-conc5 cst-equiv)))
  :rule-classes :congruence)

Function: cst-unit-type-conc

(defun cst-unit-type-conc (abnf::cst)
  (declare (xargs :guard (abnf::treep abnf::cst)))
  (declare (xargs :guard (cst-matchp abnf::cst "unit-type")))
  (let ((__function__ 'cst-unit-type-conc))
    (declare (ignorable __function__))
    (abnf::tree-nonleaf->branches abnf::cst)))

Theorem: tree-list-listp-of-cst-unit-type-conc

(defthm tree-list-listp-of-cst-unit-type-conc
  (b* ((abnf::cstss (cst-unit-type-conc abnf::cst)))
    (abnf::tree-list-listp abnf::cstss))
  :rule-classes :rewrite)

Theorem: cst-unit-type-conc-match

(defthm cst-unit-type-conc-match
  (implies (cst-matchp abnf::cst "unit-type")
           (b* ((abnf::cstss (cst-unit-type-conc abnf::cst)))
             (cst-list-list-conc-matchp abnf::cstss "\"(\" \")\"")))
  :rule-classes :rewrite)

Theorem: cst-unit-type-conc-of-tree-fix-cst

(defthm cst-unit-type-conc-of-tree-fix-cst
  (equal (cst-unit-type-conc (abnf::tree-fix abnf::cst))
         (cst-unit-type-conc abnf::cst)))

Theorem: cst-unit-type-conc-tree-equiv-congruence-on-cst

(defthm cst-unit-type-conc-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-unit-type-conc abnf::cst)
                  (cst-unit-type-conc cst-equiv)))
  :rule-classes :congruence)

Function: cst-primitive-type-conc1

(defun cst-primitive-type-conc1 (abnf::cst)
 (declare (xargs :guard (abnf::treep abnf::cst)))
 (declare
      (xargs :guard (and (cst-matchp abnf::cst "primitive-type")
                         (equal (cst-primitive-type-conc? abnf::cst)
                                1))))
 (let ((__function__ 'cst-primitive-type-conc1))
   (declare (ignorable __function__))
   (abnf::tree-nonleaf->branches abnf::cst)))

Theorem: tree-list-listp-of-cst-primitive-type-conc1

(defthm tree-list-listp-of-cst-primitive-type-conc1
  (b* ((abnf::cstss (cst-primitive-type-conc1 abnf::cst)))
    (abnf::tree-list-listp abnf::cstss))
  :rule-classes :rewrite)

Theorem: cst-primitive-type-conc1-match

(defthm cst-primitive-type-conc1-match
 (implies
  (and (cst-matchp abnf::cst "primitive-type")
       (equal (cst-primitive-type-conc? abnf::cst)
              1))
  (b* ((abnf::cstss (cst-primitive-type-conc1 abnf::cst)))
    (cst-list-list-conc-matchp abnf::cstss "named-primitive-type")))
 :rule-classes :rewrite)

Theorem: cst-primitive-type-conc1-of-tree-fix-cst

(defthm cst-primitive-type-conc1-of-tree-fix-cst
  (equal (cst-primitive-type-conc1 (abnf::tree-fix abnf::cst))
         (cst-primitive-type-conc1 abnf::cst)))

Theorem: cst-primitive-type-conc1-tree-equiv-congruence-on-cst

(defthm cst-primitive-type-conc1-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-primitive-type-conc1 abnf::cst)
                  (cst-primitive-type-conc1 cst-equiv)))
  :rule-classes :congruence)

Function: cst-primitive-type-conc2

(defun cst-primitive-type-conc2 (abnf::cst)
 (declare (xargs :guard (abnf::treep abnf::cst)))
 (declare
      (xargs :guard (and (cst-matchp abnf::cst "primitive-type")
                         (equal (cst-primitive-type-conc? abnf::cst)
                                2))))
 (let ((__function__ 'cst-primitive-type-conc2))
   (declare (ignorable __function__))
   (abnf::tree-nonleaf->branches abnf::cst)))

Theorem: tree-list-listp-of-cst-primitive-type-conc2

(defthm tree-list-listp-of-cst-primitive-type-conc2
  (b* ((abnf::cstss (cst-primitive-type-conc2 abnf::cst)))
    (abnf::tree-list-listp abnf::cstss))
  :rule-classes :rewrite)

Theorem: cst-primitive-type-conc2-match

(defthm cst-primitive-type-conc2-match
  (implies (and (cst-matchp abnf::cst "primitive-type")
                (equal (cst-primitive-type-conc? abnf::cst)
                       2))
           (b* ((abnf::cstss (cst-primitive-type-conc2 abnf::cst)))
             (cst-list-list-conc-matchp abnf::cstss "unit-type")))
  :rule-classes :rewrite)

Theorem: cst-primitive-type-conc2-of-tree-fix-cst

(defthm cst-primitive-type-conc2-of-tree-fix-cst
  (equal (cst-primitive-type-conc2 (abnf::tree-fix abnf::cst))
         (cst-primitive-type-conc2 abnf::cst)))

Theorem: cst-primitive-type-conc2-tree-equiv-congruence-on-cst

(defthm cst-primitive-type-conc2-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-primitive-type-conc2 abnf::cst)
                  (cst-primitive-type-conc2 cst-equiv)))
  :rule-classes :congruence)

Function: cst-untyped-future-type-conc

(defun cst-untyped-future-type-conc (abnf::cst)
  (declare (xargs :guard (abnf::treep abnf::cst)))
  (declare
       (xargs :guard (cst-matchp abnf::cst "untyped-future-type")))
  (let ((__function__ 'cst-untyped-future-type-conc))
    (declare (ignorable __function__))
    (abnf::tree-nonleaf->branches abnf::cst)))

Theorem: tree-list-listp-of-cst-untyped-future-type-conc

(defthm tree-list-listp-of-cst-untyped-future-type-conc
  (b* ((abnf::cstss (cst-untyped-future-type-conc abnf::cst)))
    (abnf::tree-list-listp abnf::cstss))
  :rule-classes :rewrite)

Theorem: cst-untyped-future-type-conc-match

(defthm cst-untyped-future-type-conc-match
  (implies
       (cst-matchp abnf::cst "untyped-future-type")
       (b* ((abnf::cstss (cst-untyped-future-type-conc abnf::cst)))
         (cst-list-list-conc-matchp abnf::cstss "%s\"Future\"")))
  :rule-classes :rewrite)

Theorem: cst-untyped-future-type-conc-of-tree-fix-cst

(defthm cst-untyped-future-type-conc-of-tree-fix-cst
  (equal (cst-untyped-future-type-conc (abnf::tree-fix abnf::cst))
         (cst-untyped-future-type-conc abnf::cst)))

Theorem: cst-untyped-future-type-conc-tree-equiv-congruence-on-cst

(defthm cst-untyped-future-type-conc-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-untyped-future-type-conc abnf::cst)
                  (cst-untyped-future-type-conc cst-equiv)))
  :rule-classes :congruence)

Function: cst-typed-future-type-conc

(defun cst-typed-future-type-conc (abnf::cst)
 (declare (xargs :guard (abnf::treep abnf::cst)))
 (declare (xargs :guard (cst-matchp abnf::cst "typed-future-type")))
 (let ((__function__ 'cst-typed-future-type-conc))
   (declare (ignorable __function__))
   (abnf::tree-nonleaf->branches abnf::cst)))

Theorem: tree-list-listp-of-cst-typed-future-type-conc

(defthm tree-list-listp-of-cst-typed-future-type-conc
  (b* ((abnf::cstss (cst-typed-future-type-conc abnf::cst)))
    (abnf::tree-list-listp abnf::cstss))
  :rule-classes :rewrite)

Theorem: cst-typed-future-type-conc-match

(defthm cst-typed-future-type-conc-match
 (implies
  (cst-matchp abnf::cst "typed-future-type")
  (b* ((abnf::cstss (cst-typed-future-type-conc abnf::cst)))
   (cst-list-list-conc-matchp
    abnf::cstss
    "%s\"Future\" \"<\" %s\"Fn\" \"(\" [ type 1*( \",\" type ) [ \",\" ] ] \")\" \">\"")))
 :rule-classes :rewrite)

Theorem: cst-typed-future-type-conc-of-tree-fix-cst

(defthm cst-typed-future-type-conc-of-tree-fix-cst
  (equal (cst-typed-future-type-conc (abnf::tree-fix abnf::cst))
         (cst-typed-future-type-conc abnf::cst)))

Theorem: cst-typed-future-type-conc-tree-equiv-congruence-on-cst

(defthm cst-typed-future-type-conc-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-typed-future-type-conc abnf::cst)
                  (cst-typed-future-type-conc cst-equiv)))
  :rule-classes :congruence)

Function: cst-future-type-conc1

(defun cst-future-type-conc1 (abnf::cst)
  (declare (xargs :guard (abnf::treep abnf::cst)))
  (declare
       (xargs :guard (and (cst-matchp abnf::cst "future-type")
                          (equal (cst-future-type-conc? abnf::cst)
                                 1))))
  (let ((__function__ 'cst-future-type-conc1))
    (declare (ignorable __function__))
    (abnf::tree-nonleaf->branches abnf::cst)))

Theorem: tree-list-listp-of-cst-future-type-conc1

(defthm tree-list-listp-of-cst-future-type-conc1
  (b* ((abnf::cstss (cst-future-type-conc1 abnf::cst)))
    (abnf::tree-list-listp abnf::cstss))
  :rule-classes :rewrite)

Theorem: cst-future-type-conc1-match

(defthm cst-future-type-conc1-match
 (implies
   (and (cst-matchp abnf::cst "future-type")
        (equal (cst-future-type-conc? abnf::cst)
               1))
   (b* ((abnf::cstss (cst-future-type-conc1 abnf::cst)))
     (cst-list-list-conc-matchp abnf::cstss "untyped-future-type")))
 :rule-classes :rewrite)

Theorem: cst-future-type-conc1-of-tree-fix-cst

(defthm cst-future-type-conc1-of-tree-fix-cst
  (equal (cst-future-type-conc1 (abnf::tree-fix abnf::cst))
         (cst-future-type-conc1 abnf::cst)))

Theorem: cst-future-type-conc1-tree-equiv-congruence-on-cst

(defthm cst-future-type-conc1-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-future-type-conc1 abnf::cst)
                  (cst-future-type-conc1 cst-equiv)))
  :rule-classes :congruence)

Function: cst-future-type-conc2

(defun cst-future-type-conc2 (abnf::cst)
  (declare (xargs :guard (abnf::treep abnf::cst)))
  (declare
       (xargs :guard (and (cst-matchp abnf::cst "future-type")
                          (equal (cst-future-type-conc? abnf::cst)
                                 2))))
  (let ((__function__ 'cst-future-type-conc2))
    (declare (ignorable __function__))
    (abnf::tree-nonleaf->branches abnf::cst)))

Theorem: tree-list-listp-of-cst-future-type-conc2

(defthm tree-list-listp-of-cst-future-type-conc2
  (b* ((abnf::cstss (cst-future-type-conc2 abnf::cst)))
    (abnf::tree-list-listp abnf::cstss))
  :rule-classes :rewrite)

Theorem: cst-future-type-conc2-match

(defthm cst-future-type-conc2-match
 (implies
     (and (cst-matchp abnf::cst "future-type")
          (equal (cst-future-type-conc? abnf::cst)
                 2))
     (b* ((abnf::cstss (cst-future-type-conc2 abnf::cst)))
       (cst-list-list-conc-matchp abnf::cstss "typed-future-type")))
 :rule-classes :rewrite)

Theorem: cst-future-type-conc2-of-tree-fix-cst

(defthm cst-future-type-conc2-of-tree-fix-cst
  (equal (cst-future-type-conc2 (abnf::tree-fix abnf::cst))
         (cst-future-type-conc2 abnf::cst)))

Theorem: cst-future-type-conc2-tree-equiv-congruence-on-cst

(defthm cst-future-type-conc2-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-future-type-conc2 abnf::cst)
                  (cst-future-type-conc2 cst-equiv)))
  :rule-classes :congruence)

Function: cst-tuple-type-conc

(defun cst-tuple-type-conc (abnf::cst)
  (declare (xargs :guard (abnf::treep abnf::cst)))
  (declare (xargs :guard (cst-matchp abnf::cst "tuple-type")))
  (let ((__function__ 'cst-tuple-type-conc))
    (declare (ignorable __function__))
    (abnf::tree-nonleaf->branches abnf::cst)))

Theorem: tree-list-listp-of-cst-tuple-type-conc

(defthm tree-list-listp-of-cst-tuple-type-conc
  (b* ((abnf::cstss (cst-tuple-type-conc abnf::cst)))
    (abnf::tree-list-listp abnf::cstss))
  :rule-classes :rewrite)

Theorem: cst-tuple-type-conc-match

(defthm cst-tuple-type-conc-match
  (implies (cst-matchp abnf::cst "tuple-type")
           (b* ((abnf::cstss (cst-tuple-type-conc abnf::cst)))
             (cst-list-list-conc-matchp
                  abnf::cstss
                  "\"(\" type 1*( \",\" type ) [ \",\" ] \")\"")))
  :rule-classes :rewrite)

Theorem: cst-tuple-type-conc-of-tree-fix-cst

(defthm cst-tuple-type-conc-of-tree-fix-cst
  (equal (cst-tuple-type-conc (abnf::tree-fix abnf::cst))
         (cst-tuple-type-conc abnf::cst)))

Theorem: cst-tuple-type-conc-tree-equiv-congruence-on-cst

(defthm cst-tuple-type-conc-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-tuple-type-conc abnf::cst)
                  (cst-tuple-type-conc cst-equiv)))
  :rule-classes :congruence)

Function: cst-array-type-conc

(defun cst-array-type-conc (abnf::cst)
  (declare (xargs :guard (abnf::treep abnf::cst)))
  (declare (xargs :guard (cst-matchp abnf::cst "array-type")))
  (let ((__function__ 'cst-array-type-conc))
    (declare (ignorable __function__))
    (abnf::tree-nonleaf->branches abnf::cst)))

Theorem: tree-list-listp-of-cst-array-type-conc

(defthm tree-list-listp-of-cst-array-type-conc
  (b* ((abnf::cstss (cst-array-type-conc abnf::cst)))
    (abnf::tree-list-listp abnf::cstss))
  :rule-classes :rewrite)

Theorem: cst-array-type-conc-match

(defthm cst-array-type-conc-match
 (implies
  (cst-matchp abnf::cst "array-type")
  (b* ((abnf::cstss (cst-array-type-conc abnf::cst)))
    (cst-list-list-conc-matchp abnf::cstss
                               "\"[\" type \";\" decimal-numeral \"]\"")))
 :rule-classes :rewrite)

Theorem: cst-array-type-conc-of-tree-fix-cst

(defthm cst-array-type-conc-of-tree-fix-cst
  (equal (cst-array-type-conc (abnf::tree-fix abnf::cst))
         (cst-array-type-conc abnf::cst)))

Theorem: cst-array-type-conc-tree-equiv-congruence-on-cst

(defthm cst-array-type-conc-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-array-type-conc abnf::cst)
                  (cst-array-type-conc cst-equiv)))
  :rule-classes :congruence)

Function: cst-type-conc1

(defun cst-type-conc1 (abnf::cst)
 (declare (xargs :guard (abnf::treep abnf::cst)))
 (declare (xargs :guard (and (cst-matchp abnf::cst "type")
                             (equal (cst-type-conc? abnf::cst) 1))))
 (let ((__function__ 'cst-type-conc1))
   (declare (ignorable __function__))
   (abnf::tree-nonleaf->branches abnf::cst)))

Theorem: tree-list-listp-of-cst-type-conc1

(defthm tree-list-listp-of-cst-type-conc1
  (b* ((abnf::cstss (cst-type-conc1 abnf::cst)))
    (abnf::tree-list-listp abnf::cstss))
  :rule-classes :rewrite)

Theorem: cst-type-conc1-match

(defthm cst-type-conc1-match
  (implies
       (and (cst-matchp abnf::cst "type")
            (equal (cst-type-conc? abnf::cst) 1))
       (b* ((abnf::cstss (cst-type-conc1 abnf::cst)))
         (cst-list-list-conc-matchp abnf::cstss "primitive-type")))
  :rule-classes :rewrite)

Theorem: cst-type-conc1-of-tree-fix-cst

(defthm cst-type-conc1-of-tree-fix-cst
  (equal (cst-type-conc1 (abnf::tree-fix abnf::cst))
         (cst-type-conc1 abnf::cst)))

Theorem: cst-type-conc1-tree-equiv-congruence-on-cst

(defthm cst-type-conc1-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-type-conc1 abnf::cst)
                  (cst-type-conc1 cst-equiv)))
  :rule-classes :congruence)

Function: cst-type-conc2

(defun cst-type-conc2 (abnf::cst)
 (declare (xargs :guard (abnf::treep abnf::cst)))
 (declare (xargs :guard (and (cst-matchp abnf::cst "type")
                             (equal (cst-type-conc? abnf::cst) 2))))
 (let ((__function__ 'cst-type-conc2))
   (declare (ignorable __function__))
   (abnf::tree-nonleaf->branches abnf::cst)))

Theorem: tree-list-listp-of-cst-type-conc2

(defthm tree-list-listp-of-cst-type-conc2
  (b* ((abnf::cstss (cst-type-conc2 abnf::cst)))
    (abnf::tree-list-listp abnf::cstss))
  :rule-classes :rewrite)

Theorem: cst-type-conc2-match

(defthm cst-type-conc2-match
  (implies (and (cst-matchp abnf::cst "type")
                (equal (cst-type-conc? abnf::cst) 2))
           (b* ((abnf::cstss (cst-type-conc2 abnf::cst)))
             (cst-list-list-conc-matchp abnf::cstss "future-type")))
  :rule-classes :rewrite)

Theorem: cst-type-conc2-of-tree-fix-cst

(defthm cst-type-conc2-of-tree-fix-cst
  (equal (cst-type-conc2 (abnf::tree-fix abnf::cst))
         (cst-type-conc2 abnf::cst)))

Theorem: cst-type-conc2-tree-equiv-congruence-on-cst

(defthm cst-type-conc2-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-type-conc2 abnf::cst)
                  (cst-type-conc2 cst-equiv)))
  :rule-classes :congruence)

Function: cst-type-conc3

(defun cst-type-conc3 (abnf::cst)
 (declare (xargs :guard (abnf::treep abnf::cst)))
 (declare (xargs :guard (and (cst-matchp abnf::cst "type")
                             (equal (cst-type-conc? abnf::cst) 3))))
 (let ((__function__ 'cst-type-conc3))
   (declare (ignorable __function__))
   (abnf::tree-nonleaf->branches abnf::cst)))

Theorem: tree-list-listp-of-cst-type-conc3

(defthm tree-list-listp-of-cst-type-conc3
  (b* ((abnf::cstss (cst-type-conc3 abnf::cst)))
    (abnf::tree-list-listp abnf::cstss))
  :rule-classes :rewrite)

Theorem: cst-type-conc3-match

(defthm cst-type-conc3-match
  (implies (and (cst-matchp abnf::cst "type")
                (equal (cst-type-conc? abnf::cst) 3))
           (b* ((abnf::cstss (cst-type-conc3 abnf::cst)))
             (cst-list-list-conc-matchp abnf::cstss "tuple-type")))
  :rule-classes :rewrite)

Theorem: cst-type-conc3-of-tree-fix-cst

(defthm cst-type-conc3-of-tree-fix-cst
  (equal (cst-type-conc3 (abnf::tree-fix abnf::cst))
         (cst-type-conc3 abnf::cst)))

Theorem: cst-type-conc3-tree-equiv-congruence-on-cst

(defthm cst-type-conc3-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-type-conc3 abnf::cst)
                  (cst-type-conc3 cst-equiv)))
  :rule-classes :congruence)

Function: cst-type-conc4

(defun cst-type-conc4 (abnf::cst)
 (declare (xargs :guard (abnf::treep abnf::cst)))
 (declare (xargs :guard (and (cst-matchp abnf::cst "type")
                             (equal (cst-type-conc? abnf::cst) 4))))
 (let ((__function__ 'cst-type-conc4))
   (declare (ignorable __function__))
   (abnf::tree-nonleaf->branches abnf::cst)))

Theorem: tree-list-listp-of-cst-type-conc4

(defthm tree-list-listp-of-cst-type-conc4
  (b* ((abnf::cstss (cst-type-conc4 abnf::cst)))
    (abnf::tree-list-listp abnf::cstss))
  :rule-classes :rewrite)

Theorem: cst-type-conc4-match

(defthm cst-type-conc4-match
  (implies (and (cst-matchp abnf::cst "type")
                (equal (cst-type-conc? abnf::cst) 4))
           (b* ((abnf::cstss (cst-type-conc4 abnf::cst)))
             (cst-list-list-conc-matchp abnf::cstss "array-type")))
  :rule-classes :rewrite)

Theorem: cst-type-conc4-of-tree-fix-cst

(defthm cst-type-conc4-of-tree-fix-cst
  (equal (cst-type-conc4 (abnf::tree-fix abnf::cst))
         (cst-type-conc4 abnf::cst)))

Theorem: cst-type-conc4-tree-equiv-congruence-on-cst

(defthm cst-type-conc4-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-type-conc4 abnf::cst)
                  (cst-type-conc4 cst-equiv)))
  :rule-classes :congruence)

Function: cst-named-type-conc1

(defun cst-named-type-conc1 (abnf::cst)
 (declare (xargs :guard (abnf::treep abnf::cst)))
 (declare (xargs :guard (and (cst-matchp abnf::cst "named-type")
                             (equal (cst-named-type-conc? abnf::cst)
                                    1))))
 (let ((__function__ 'cst-named-type-conc1))
   (declare (ignorable __function__))
   (abnf::tree-nonleaf->branches abnf::cst)))

Theorem: tree-list-listp-of-cst-named-type-conc1

(defthm tree-list-listp-of-cst-named-type-conc1
  (b* ((abnf::cstss (cst-named-type-conc1 abnf::cst)))
    (abnf::tree-list-listp abnf::cstss))
  :rule-classes :rewrite)

Theorem: cst-named-type-conc1-match

(defthm cst-named-type-conc1-match
 (implies
  (and (cst-matchp abnf::cst "named-type")
       (equal (cst-named-type-conc? abnf::cst)
              1))
  (b* ((abnf::cstss (cst-named-type-conc1 abnf::cst)))
    (cst-list-list-conc-matchp abnf::cstss "named-primitive-type")))
 :rule-classes :rewrite)

Theorem: cst-named-type-conc1-of-tree-fix-cst

(defthm cst-named-type-conc1-of-tree-fix-cst
  (equal (cst-named-type-conc1 (abnf::tree-fix abnf::cst))
         (cst-named-type-conc1 abnf::cst)))

Theorem: cst-named-type-conc1-tree-equiv-congruence-on-cst

(defthm cst-named-type-conc1-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-named-type-conc1 abnf::cst)
                  (cst-named-type-conc1 cst-equiv)))
  :rule-classes :congruence)

Function: cst-named-type-conc2

(defun cst-named-type-conc2 (abnf::cst)
 (declare (xargs :guard (abnf::treep abnf::cst)))
 (declare (xargs :guard (and (cst-matchp abnf::cst "named-type")
                             (equal (cst-named-type-conc? abnf::cst)
                                    2))))
 (let ((__function__ 'cst-named-type-conc2))
   (declare (ignorable __function__))
   (abnf::tree-nonleaf->branches abnf::cst)))

Theorem: tree-list-listp-of-cst-named-type-conc2

(defthm tree-list-listp-of-cst-named-type-conc2
  (b* ((abnf::cstss (cst-named-type-conc2 abnf::cst)))
    (abnf::tree-list-listp abnf::cstss))
  :rule-classes :rewrite)

Theorem: cst-named-type-conc2-match

(defthm cst-named-type-conc2-match
 (implies
   (and (cst-matchp abnf::cst "named-type")
        (equal (cst-named-type-conc? abnf::cst)
               2))
   (b* ((abnf::cstss (cst-named-type-conc2 abnf::cst)))
     (cst-list-list-conc-matchp abnf::cstss "untyped-future-type")))
 :rule-classes :rewrite)

Theorem: cst-named-type-conc2-of-tree-fix-cst

(defthm cst-named-type-conc2-of-tree-fix-cst
  (equal (cst-named-type-conc2 (abnf::tree-fix abnf::cst))
         (cst-named-type-conc2 abnf::cst)))

Theorem: cst-named-type-conc2-tree-equiv-congruence-on-cst

(defthm cst-named-type-conc2-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-named-type-conc2 abnf::cst)
                  (cst-named-type-conc2 cst-equiv)))
  :rule-classes :congruence)

Function: cst-named-type-conc3

(defun cst-named-type-conc3 (abnf::cst)
 (declare (xargs :guard (abnf::treep abnf::cst)))
 (declare (xargs :guard (and (cst-matchp abnf::cst "named-type")
                             (equal (cst-named-type-conc? abnf::cst)
                                    3))))
 (let ((__function__ 'cst-named-type-conc3))
   (declare (ignorable __function__))
   (abnf::tree-nonleaf->branches abnf::cst)))

Theorem: tree-list-listp-of-cst-named-type-conc3

(defthm tree-list-listp-of-cst-named-type-conc3
  (b* ((abnf::cstss (cst-named-type-conc3 abnf::cst)))
    (abnf::tree-list-listp abnf::cstss))
  :rule-classes :rewrite)

Theorem: cst-named-type-conc3-match

(defthm cst-named-type-conc3-match
  (implies (and (cst-matchp abnf::cst "named-type")
                (equal (cst-named-type-conc? abnf::cst)
                       3))
           (b* ((abnf::cstss (cst-named-type-conc3 abnf::cst)))
             (cst-list-list-conc-matchp abnf::cstss "identifier")))
  :rule-classes :rewrite)

Theorem: cst-named-type-conc3-of-tree-fix-cst

(defthm cst-named-type-conc3-of-tree-fix-cst
  (equal (cst-named-type-conc3 (abnf::tree-fix abnf::cst))
         (cst-named-type-conc3 abnf::cst)))

Theorem: cst-named-type-conc3-tree-equiv-congruence-on-cst

(defthm cst-named-type-conc3-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-named-type-conc3 abnf::cst)
                  (cst-named-type-conc3 cst-equiv)))
  :rule-classes :congruence)

Function: cst-program-address-literal-conc

(defun cst-program-address-literal-conc (abnf::cst)
 (declare (xargs :guard (abnf::treep abnf::cst)))
 (declare
    (xargs :guard (cst-matchp abnf::cst "program-address-literal")))
 (let ((__function__ 'cst-program-address-literal-conc))
   (declare (ignorable __function__))
   (abnf::tree-nonleaf->branches abnf::cst)))

Theorem: tree-list-listp-of-cst-program-address-literal-conc

(defthm tree-list-listp-of-cst-program-address-literal-conc
  (b* ((abnf::cstss (cst-program-address-literal-conc abnf::cst)))
    (abnf::tree-list-listp abnf::cstss))
  :rule-classes :rewrite)

Theorem: cst-program-address-literal-conc-match

(defthm cst-program-address-literal-conc-match
 (implies
    (cst-matchp abnf::cst "program-address-literal")
    (b* ((abnf::cstss (cst-program-address-literal-conc abnf::cst)))
      (cst-list-list-conc-matchp abnf::cstss "program-id")))
 :rule-classes :rewrite)

Theorem: cst-program-address-literal-conc-of-tree-fix-cst

(defthm cst-program-address-literal-conc-of-tree-fix-cst
  (equal
       (cst-program-address-literal-conc (abnf::tree-fix abnf::cst))
       (cst-program-address-literal-conc abnf::cst)))

Theorem: cst-program-address-literal-conc-tree-equiv-congruence-on-cst

(defthm
      cst-program-address-literal-conc-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-program-address-literal-conc abnf::cst)
                  (cst-program-address-literal-conc cst-equiv)))
  :rule-classes :congruence)

Function: cst-literal-conc1

(defun cst-literal-conc1 (abnf::cst)
  (declare (xargs :guard (abnf::treep abnf::cst)))
  (declare (xargs :guard (and (cst-matchp abnf::cst "literal")
                              (equal (cst-literal-conc? abnf::cst)
                                     1))))
  (let ((__function__ 'cst-literal-conc1))
    (declare (ignorable __function__))
    (abnf::tree-nonleaf->branches abnf::cst)))

Theorem: tree-list-listp-of-cst-literal-conc1

(defthm tree-list-listp-of-cst-literal-conc1
  (b* ((abnf::cstss (cst-literal-conc1 abnf::cst)))
    (abnf::tree-list-listp abnf::cstss))
  :rule-classes :rewrite)

Theorem: cst-literal-conc1-match

(defthm cst-literal-conc1-match
  (implies
       (and (cst-matchp abnf::cst "literal")
            (equal (cst-literal-conc? abnf::cst) 1))
       (b* ((abnf::cstss (cst-literal-conc1 abnf::cst)))
         (cst-list-list-conc-matchp abnf::cstss "atomic-literal")))
  :rule-classes :rewrite)

Theorem: cst-literal-conc1-of-tree-fix-cst

(defthm cst-literal-conc1-of-tree-fix-cst
  (equal (cst-literal-conc1 (abnf::tree-fix abnf::cst))
         (cst-literal-conc1 abnf::cst)))

Theorem: cst-literal-conc1-tree-equiv-congruence-on-cst

(defthm cst-literal-conc1-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-literal-conc1 abnf::cst)
                  (cst-literal-conc1 cst-equiv)))
  :rule-classes :congruence)

Function: cst-literal-conc2

(defun cst-literal-conc2 (abnf::cst)
  (declare (xargs :guard (abnf::treep abnf::cst)))
  (declare (xargs :guard (and (cst-matchp abnf::cst "literal")
                              (equal (cst-literal-conc? abnf::cst)
                                     2))))
  (let ((__function__ 'cst-literal-conc2))
    (declare (ignorable __function__))
    (abnf::tree-nonleaf->branches abnf::cst)))

Theorem: tree-list-listp-of-cst-literal-conc2

(defthm tree-list-listp-of-cst-literal-conc2
  (b* ((abnf::cstss (cst-literal-conc2 abnf::cst)))
    (abnf::tree-list-listp abnf::cstss))
  :rule-classes :rewrite)

Theorem: cst-literal-conc2-match

(defthm cst-literal-conc2-match
  (implies (and (cst-matchp abnf::cst "literal")
                (equal (cst-literal-conc? abnf::cst) 2))
           (b* ((abnf::cstss (cst-literal-conc2 abnf::cst)))
             (cst-list-list-conc-matchp
                  abnf::cstss "program-address-literal")))
  :rule-classes :rewrite)

Theorem: cst-literal-conc2-of-tree-fix-cst

(defthm cst-literal-conc2-of-tree-fix-cst
  (equal (cst-literal-conc2 (abnf::tree-fix abnf::cst))
         (cst-literal-conc2 abnf::cst)))

Theorem: cst-literal-conc2-tree-equiv-congruence-on-cst

(defthm cst-literal-conc2-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-literal-conc2 abnf::cst)
                  (cst-literal-conc2 cst-equiv)))
  :rule-classes :congruence)

Function: cst-address-literal-conc1

(defun cst-address-literal-conc1 (abnf::cst)
 (declare (xargs :guard (abnf::treep abnf::cst)))
 (declare
     (xargs :guard (and (cst-matchp abnf::cst "address-literal")
                        (equal (cst-address-literal-conc? abnf::cst)
                               1))))
 (let ((__function__ 'cst-address-literal-conc1))
   (declare (ignorable __function__))
   (abnf::tree-nonleaf->branches abnf::cst)))

Theorem: tree-list-listp-of-cst-address-literal-conc1

(defthm tree-list-listp-of-cst-address-literal-conc1
  (b* ((abnf::cstss (cst-address-literal-conc1 abnf::cst)))
    (abnf::tree-list-listp abnf::cstss))
  :rule-classes :rewrite)

Theorem: cst-address-literal-conc1-match

(defthm cst-address-literal-conc1-match
 (implies (and (cst-matchp abnf::cst "address-literal")
               (equal (cst-address-literal-conc? abnf::cst)
                      1))
          (b* ((abnf::cstss (cst-address-literal-conc1 abnf::cst)))
            (cst-list-list-conc-matchp abnf::cstss
                                       "explicit-address-literal")))
 :rule-classes :rewrite)

Theorem: cst-address-literal-conc1-of-tree-fix-cst

(defthm cst-address-literal-conc1-of-tree-fix-cst
  (equal (cst-address-literal-conc1 (abnf::tree-fix abnf::cst))
         (cst-address-literal-conc1 abnf::cst)))

Theorem: cst-address-literal-conc1-tree-equiv-congruence-on-cst

(defthm cst-address-literal-conc1-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-address-literal-conc1 abnf::cst)
                  (cst-address-literal-conc1 cst-equiv)))
  :rule-classes :congruence)

Function: cst-address-literal-conc2

(defun cst-address-literal-conc2 (abnf::cst)
 (declare (xargs :guard (abnf::treep abnf::cst)))
 (declare
     (xargs :guard (and (cst-matchp abnf::cst "address-literal")
                        (equal (cst-address-literal-conc? abnf::cst)
                               2))))
 (let ((__function__ 'cst-address-literal-conc2))
   (declare (ignorable __function__))
   (abnf::tree-nonleaf->branches abnf::cst)))

Theorem: tree-list-listp-of-cst-address-literal-conc2

(defthm tree-list-listp-of-cst-address-literal-conc2
  (b* ((abnf::cstss (cst-address-literal-conc2 abnf::cst)))
    (abnf::tree-list-listp abnf::cstss))
  :rule-classes :rewrite)

Theorem: cst-address-literal-conc2-match

(defthm cst-address-literal-conc2-match
  (implies (and (cst-matchp abnf::cst "address-literal")
                (equal (cst-address-literal-conc? abnf::cst)
                       2))
           (b* ((abnf::cstss (cst-address-literal-conc2 abnf::cst)))
             (cst-list-list-conc-matchp
                  abnf::cstss "program-address-literal")))
  :rule-classes :rewrite)

Theorem: cst-address-literal-conc2-of-tree-fix-cst

(defthm cst-address-literal-conc2-of-tree-fix-cst
  (equal (cst-address-literal-conc2 (abnf::tree-fix abnf::cst))
         (cst-address-literal-conc2 abnf::cst)))

Theorem: cst-address-literal-conc2-tree-equiv-congruence-on-cst

(defthm cst-address-literal-conc2-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-address-literal-conc2 abnf::cst)
                  (cst-address-literal-conc2 cst-equiv)))
  :rule-classes :congruence)

Function: cst-variable-conc

(defun cst-variable-conc (abnf::cst)
  (declare (xargs :guard (abnf::treep abnf::cst)))
  (declare (xargs :guard (cst-matchp abnf::cst "variable")))
  (let ((__function__ 'cst-variable-conc))
    (declare (ignorable __function__))
    (abnf::tree-nonleaf->branches abnf::cst)))

Theorem: tree-list-listp-of-cst-variable-conc

(defthm tree-list-listp-of-cst-variable-conc
  (b* ((abnf::cstss (cst-variable-conc abnf::cst)))
    (abnf::tree-list-listp abnf::cstss))
  :rule-classes :rewrite)

Theorem: cst-variable-conc-match

(defthm cst-variable-conc-match
  (implies (cst-matchp abnf::cst "variable")
           (b* ((abnf::cstss (cst-variable-conc abnf::cst)))
             (cst-list-list-conc-matchp abnf::cstss "identifier")))
  :rule-classes :rewrite)

Theorem: cst-variable-conc-of-tree-fix-cst

(defthm cst-variable-conc-of-tree-fix-cst
  (equal (cst-variable-conc (abnf::tree-fix abnf::cst))
         (cst-variable-conc abnf::cst)))

Theorem: cst-variable-conc-tree-equiv-congruence-on-cst

(defthm cst-variable-conc-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-variable-conc abnf::cst)
                  (cst-variable-conc cst-equiv)))
  :rule-classes :congruence)

Function: cst-associated-constant-conc

(defun cst-associated-constant-conc (abnf::cst)
  (declare (xargs :guard (abnf::treep abnf::cst)))
  (declare
       (xargs :guard (cst-matchp abnf::cst "associated-constant")))
  (let ((__function__ 'cst-associated-constant-conc))
    (declare (ignorable __function__))
    (abnf::tree-nonleaf->branches abnf::cst)))

Theorem: tree-list-listp-of-cst-associated-constant-conc

(defthm tree-list-listp-of-cst-associated-constant-conc
  (b* ((abnf::cstss (cst-associated-constant-conc abnf::cst)))
    (abnf::tree-list-listp abnf::cstss))
  :rule-classes :rewrite)

Theorem: cst-associated-constant-conc-match

(defthm cst-associated-constant-conc-match
  (implies
       (cst-matchp abnf::cst "associated-constant")
       (b* ((abnf::cstss (cst-associated-constant-conc abnf::cst)))
         (cst-list-list-conc-matchp abnf::cstss
                                    "named-type \"::\" identifier")))
  :rule-classes :rewrite)

Theorem: cst-associated-constant-conc-of-tree-fix-cst

(defthm cst-associated-constant-conc-of-tree-fix-cst
  (equal (cst-associated-constant-conc (abnf::tree-fix abnf::cst))
         (cst-associated-constant-conc abnf::cst)))

Theorem: cst-associated-constant-conc-tree-equiv-congruence-on-cst

(defthm cst-associated-constant-conc-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-associated-constant-conc abnf::cst)
                  (cst-associated-constant-conc cst-equiv)))
  :rule-classes :congruence)

Function: cst-associated-function-call-conc

(defun cst-associated-function-call-conc (abnf::cst)
 (declare (xargs :guard (abnf::treep abnf::cst)))
 (declare
   (xargs :guard (cst-matchp abnf::cst "associated-function-call")))
 (let ((__function__ 'cst-associated-function-call-conc))
   (declare (ignorable __function__))
   (abnf::tree-nonleaf->branches abnf::cst)))

Theorem: tree-list-listp-of-cst-associated-function-call-conc

(defthm tree-list-listp-of-cst-associated-function-call-conc
  (b* ((abnf::cstss (cst-associated-function-call-conc abnf::cst)))
    (abnf::tree-list-listp abnf::cstss))
  :rule-classes :rewrite)

Theorem: cst-associated-function-call-conc-match

(defthm cst-associated-function-call-conc-match
 (implies
   (cst-matchp abnf::cst "associated-function-call")
   (b* ((abnf::cstss (cst-associated-function-call-conc abnf::cst)))
     (cst-list-list-conc-matchp
          abnf::cstss
          "named-type \"::\" identifier function-arguments")))
 :rule-classes :rewrite)

Theorem: cst-associated-function-call-conc-of-tree-fix-cst

(defthm cst-associated-function-call-conc-of-tree-fix-cst
 (equal
      (cst-associated-function-call-conc (abnf::tree-fix abnf::cst))
      (cst-associated-function-call-conc abnf::cst)))

Theorem: cst-associated-function-call-conc-tree-equiv-congruence-on-cst

(defthm
     cst-associated-function-call-conc-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-associated-function-call-conc abnf::cst)
                  (cst-associated-function-call-conc cst-equiv)))
  :rule-classes :congruence)

Function: cst-function-arguments-conc

(defun cst-function-arguments-conc (abnf::cst)
  (declare (xargs :guard (abnf::treep abnf::cst)))
  (declare
       (xargs :guard (cst-matchp abnf::cst "function-arguments")))
  (let ((__function__ 'cst-function-arguments-conc))
    (declare (ignorable __function__))
    (abnf::tree-nonleaf->branches abnf::cst)))

Theorem: tree-list-listp-of-cst-function-arguments-conc

(defthm tree-list-listp-of-cst-function-arguments-conc
  (b* ((abnf::cstss (cst-function-arguments-conc abnf::cst)))
    (abnf::tree-list-listp abnf::cstss))
  :rule-classes :rewrite)

Theorem: cst-function-arguments-conc-match

(defthm cst-function-arguments-conc-match
 (implies
      (cst-matchp abnf::cst "function-arguments")
      (b* ((abnf::cstss (cst-function-arguments-conc abnf::cst)))
        (cst-list-list-conc-matchp
             abnf::cstss
             "\"(\" [ expression *( \",\" expression ) [ \",\" ] ] \")\"")))
 :rule-classes :rewrite)

Theorem: cst-function-arguments-conc-of-tree-fix-cst

(defthm cst-function-arguments-conc-of-tree-fix-cst
  (equal (cst-function-arguments-conc (abnf::tree-fix abnf::cst))
         (cst-function-arguments-conc abnf::cst)))

Theorem: cst-function-arguments-conc-tree-equiv-congruence-on-cst

(defthm cst-function-arguments-conc-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-function-arguments-conc abnf::cst)
                  (cst-function-arguments-conc cst-equiv)))
  :rule-classes :congruence)

Function: cst-unit-expression-conc

(defun cst-unit-expression-conc (abnf::cst)
  (declare (xargs :guard (abnf::treep abnf::cst)))
  (declare (xargs :guard (cst-matchp abnf::cst "unit-expression")))
  (let ((__function__ 'cst-unit-expression-conc))
    (declare (ignorable __function__))
    (abnf::tree-nonleaf->branches abnf::cst)))

Theorem: tree-list-listp-of-cst-unit-expression-conc

(defthm tree-list-listp-of-cst-unit-expression-conc
  (b* ((abnf::cstss (cst-unit-expression-conc abnf::cst)))
    (abnf::tree-list-listp abnf::cstss))
  :rule-classes :rewrite)

Theorem: cst-unit-expression-conc-match

(defthm cst-unit-expression-conc-match
  (implies (cst-matchp abnf::cst "unit-expression")
           (b* ((abnf::cstss (cst-unit-expression-conc abnf::cst)))
             (cst-list-list-conc-matchp abnf::cstss "\"(\" \")\"")))
  :rule-classes :rewrite)

Theorem: cst-unit-expression-conc-of-tree-fix-cst

(defthm cst-unit-expression-conc-of-tree-fix-cst
  (equal (cst-unit-expression-conc (abnf::tree-fix abnf::cst))
         (cst-unit-expression-conc abnf::cst)))

Theorem: cst-unit-expression-conc-tree-equiv-congruence-on-cst

(defthm cst-unit-expression-conc-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-unit-expression-conc abnf::cst)
                  (cst-unit-expression-conc cst-equiv)))
  :rule-classes :congruence)

Function: cst-tuple-expression-conc

(defun cst-tuple-expression-conc (abnf::cst)
  (declare (xargs :guard (abnf::treep abnf::cst)))
  (declare (xargs :guard (cst-matchp abnf::cst "tuple-expression")))
  (let ((__function__ 'cst-tuple-expression-conc))
    (declare (ignorable __function__))
    (abnf::tree-nonleaf->branches abnf::cst)))

Theorem: tree-list-listp-of-cst-tuple-expression-conc

(defthm tree-list-listp-of-cst-tuple-expression-conc
  (b* ((abnf::cstss (cst-tuple-expression-conc abnf::cst)))
    (abnf::tree-list-listp abnf::cstss))
  :rule-classes :rewrite)

Theorem: cst-tuple-expression-conc-match

(defthm cst-tuple-expression-conc-match
  (implies
       (cst-matchp abnf::cst "tuple-expression")
       (b* ((abnf::cstss (cst-tuple-expression-conc abnf::cst)))
         (cst-list-list-conc-matchp
              abnf::cstss
              "\"(\" expression 1*( \",\" expression ) [ \",\" ] \")\"")))
  :rule-classes :rewrite)

Theorem: cst-tuple-expression-conc-of-tree-fix-cst

(defthm cst-tuple-expression-conc-of-tree-fix-cst
  (equal (cst-tuple-expression-conc (abnf::tree-fix abnf::cst))
         (cst-tuple-expression-conc abnf::cst)))

Theorem: cst-tuple-expression-conc-tree-equiv-congruence-on-cst

(defthm cst-tuple-expression-conc-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-tuple-expression-conc abnf::cst)
                  (cst-tuple-expression-conc cst-equiv)))
  :rule-classes :congruence)

Function: cst-array-expression-conc

(defun cst-array-expression-conc (abnf::cst)
  (declare (xargs :guard (abnf::treep abnf::cst)))
  (declare (xargs :guard (cst-matchp abnf::cst "array-expression")))
  (let ((__function__ 'cst-array-expression-conc))
    (declare (ignorable __function__))
    (abnf::tree-nonleaf->branches abnf::cst)))

Theorem: tree-list-listp-of-cst-array-expression-conc

(defthm tree-list-listp-of-cst-array-expression-conc
  (b* ((abnf::cstss (cst-array-expression-conc abnf::cst)))
    (abnf::tree-list-listp abnf::cstss))
  :rule-classes :rewrite)

Theorem: cst-array-expression-conc-match

(defthm cst-array-expression-conc-match
  (implies
       (cst-matchp abnf::cst "array-expression")
       (b* ((abnf::cstss (cst-array-expression-conc abnf::cst)))
         (cst-list-list-conc-matchp
              abnf::cstss
              "\"[\" expression 1*( \",\" expression ) [ \",\" ] \"]\"")))
  :rule-classes :rewrite)

Theorem: cst-array-expression-conc-of-tree-fix-cst

(defthm cst-array-expression-conc-of-tree-fix-cst
  (equal (cst-array-expression-conc (abnf::tree-fix abnf::cst))
         (cst-array-expression-conc abnf::cst)))

Theorem: cst-array-expression-conc-tree-equiv-congruence-on-cst

(defthm cst-array-expression-conc-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-array-expression-conc abnf::cst)
                  (cst-array-expression-conc cst-equiv)))
  :rule-classes :congruence)

Function: cst-struct-expression-conc

(defun cst-struct-expression-conc (abnf::cst)
 (declare (xargs :guard (abnf::treep abnf::cst)))
 (declare (xargs :guard (cst-matchp abnf::cst "struct-expression")))
 (let ((__function__ 'cst-struct-expression-conc))
   (declare (ignorable __function__))
   (abnf::tree-nonleaf->branches abnf::cst)))

Theorem: tree-list-listp-of-cst-struct-expression-conc

(defthm tree-list-listp-of-cst-struct-expression-conc
  (b* ((abnf::cstss (cst-struct-expression-conc abnf::cst)))
    (abnf::tree-list-listp abnf::cstss))
  :rule-classes :rewrite)

Theorem: cst-struct-expression-conc-match

(defthm cst-struct-expression-conc-match
 (implies
  (cst-matchp abnf::cst "struct-expression")
  (b* ((abnf::cstss (cst-struct-expression-conc abnf::cst)))
   (cst-list-list-conc-matchp
    abnf::cstss
    "identifier \"{\" struct-component-initializer *( \",\" struct-component-initializer ) [ \",\" ] \"}\"")))
 :rule-classes :rewrite)

Theorem: cst-struct-expression-conc-of-tree-fix-cst

(defthm cst-struct-expression-conc-of-tree-fix-cst
  (equal (cst-struct-expression-conc (abnf::tree-fix abnf::cst))
         (cst-struct-expression-conc abnf::cst)))

Theorem: cst-struct-expression-conc-tree-equiv-congruence-on-cst

(defthm cst-struct-expression-conc-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-struct-expression-conc abnf::cst)
                  (cst-struct-expression-conc cst-equiv)))
  :rule-classes :congruence)

Function: cst-struct-component-initializer-conc

(defun cst-struct-component-initializer-conc (abnf::cst)
  (declare (xargs :guard (abnf::treep abnf::cst)))
  (declare
       (xargs :guard (cst-matchp abnf::cst
                                 "struct-component-initializer")))
  (let ((__function__ 'cst-struct-component-initializer-conc))
    (declare (ignorable __function__))
    (abnf::tree-nonleaf->branches abnf::cst)))

Theorem: tree-list-listp-of-cst-struct-component-initializer-conc

(defthm tree-list-listp-of-cst-struct-component-initializer-conc
  (b*
   ((abnf::cstss (cst-struct-component-initializer-conc abnf::cst)))
   (abnf::tree-list-listp abnf::cstss))
  :rule-classes :rewrite)

Theorem: cst-struct-component-initializer-conc-match

(defthm cst-struct-component-initializer-conc-match
 (implies
  (cst-matchp abnf::cst
              "struct-component-initializer")
  (b*
   ((abnf::cstss (cst-struct-component-initializer-conc abnf::cst)))
   (cst-list-list-conc-matchp abnf::cstss
                              "identifier [ \":\" expression ]")))
 :rule-classes :rewrite)

Theorem: cst-struct-component-initializer-conc-of-tree-fix-cst

(defthm cst-struct-component-initializer-conc-of-tree-fix-cst
 (equal
  (cst-struct-component-initializer-conc (abnf::tree-fix abnf::cst))
  (cst-struct-component-initializer-conc abnf::cst)))

Theorem: cst-struct-component-initializer-conc-tree-equiv-congruence-on-cst

(defthm
 cst-struct-component-initializer-conc-tree-equiv-congruence-on-cst
 (implies (abnf::tree-equiv abnf::cst cst-equiv)
          (equal (cst-struct-component-initializer-conc abnf::cst)
                 (cst-struct-component-initializer-conc cst-equiv)))
 :rule-classes :congruence)

Function: cst-block-expression-conc

(defun cst-block-expression-conc (abnf::cst)
  (declare (xargs :guard (abnf::treep abnf::cst)))
  (declare (xargs :guard (cst-matchp abnf::cst "block-expression")))
  (let ((__function__ 'cst-block-expression-conc))
    (declare (ignorable __function__))
    (abnf::tree-nonleaf->branches abnf::cst)))

Theorem: tree-list-listp-of-cst-block-expression-conc

(defthm tree-list-listp-of-cst-block-expression-conc
  (b* ((abnf::cstss (cst-block-expression-conc abnf::cst)))
    (abnf::tree-list-listp abnf::cstss))
  :rule-classes :rewrite)

Theorem: cst-block-expression-conc-match

(defthm cst-block-expression-conc-match
 (implies (cst-matchp abnf::cst "block-expression")
          (b* ((abnf::cstss (cst-block-expression-conc abnf::cst)))
            (cst-list-list-conc-matchp abnf::cstss
                                       "%s\"block\" \".\" %s\"height\"")))
 :rule-classes :rewrite)

Theorem: cst-block-expression-conc-of-tree-fix-cst

(defthm cst-block-expression-conc-of-tree-fix-cst
  (equal (cst-block-expression-conc (abnf::tree-fix abnf::cst))
         (cst-block-expression-conc abnf::cst)))

Theorem: cst-block-expression-conc-tree-equiv-congruence-on-cst

(defthm cst-block-expression-conc-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-block-expression-conc abnf::cst)
                  (cst-block-expression-conc cst-equiv)))
  :rule-classes :congruence)

Function: cst-network-expression-conc

(defun cst-network-expression-conc (abnf::cst)
  (declare (xargs :guard (abnf::treep abnf::cst)))
  (declare
       (xargs :guard (cst-matchp abnf::cst "network-expression")))
  (let ((__function__ 'cst-network-expression-conc))
    (declare (ignorable __function__))
    (abnf::tree-nonleaf->branches abnf::cst)))

Theorem: tree-list-listp-of-cst-network-expression-conc

(defthm tree-list-listp-of-cst-network-expression-conc
  (b* ((abnf::cstss (cst-network-expression-conc abnf::cst)))
    (abnf::tree-list-listp abnf::cstss))
  :rule-classes :rewrite)

Theorem: cst-network-expression-conc-match

(defthm cst-network-expression-conc-match
  (implies
       (cst-matchp abnf::cst "network-expression")
       (b* ((abnf::cstss (cst-network-expression-conc abnf::cst)))
         (cst-list-list-conc-matchp
              abnf::cstss "%s\"network\" \".\" %s\"id\"")))
  :rule-classes :rewrite)

Theorem: cst-network-expression-conc-of-tree-fix-cst

(defthm cst-network-expression-conc-of-tree-fix-cst
  (equal (cst-network-expression-conc (abnf::tree-fix abnf::cst))
         (cst-network-expression-conc abnf::cst)))

Theorem: cst-network-expression-conc-tree-equiv-congruence-on-cst

(defthm cst-network-expression-conc-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-network-expression-conc abnf::cst)
                  (cst-network-expression-conc cst-equiv)))
  :rule-classes :congruence)

Function: cst-postfix-expression-conc1

(defun cst-postfix-expression-conc1 (abnf::cst)
 (declare (xargs :guard (abnf::treep abnf::cst)))
 (declare
  (xargs :guard (and (cst-matchp abnf::cst "postfix-expression")
                     (equal (cst-postfix-expression-conc? abnf::cst)
                            1))))
 (let ((__function__ 'cst-postfix-expression-conc1))
   (declare (ignorable __function__))
   (abnf::tree-nonleaf->branches abnf::cst)))

Theorem: tree-list-listp-of-cst-postfix-expression-conc1

(defthm tree-list-listp-of-cst-postfix-expression-conc1
  (b* ((abnf::cstss (cst-postfix-expression-conc1 abnf::cst)))
    (abnf::tree-list-listp abnf::cstss))
  :rule-classes :rewrite)

Theorem: cst-postfix-expression-conc1-match

(defthm cst-postfix-expression-conc1-match
 (implies
    (and (cst-matchp abnf::cst "postfix-expression")
         (equal (cst-postfix-expression-conc? abnf::cst)
                1))
    (b* ((abnf::cstss (cst-postfix-expression-conc1 abnf::cst)))
      (cst-list-list-conc-matchp abnf::cstss "primary-expression")))
 :rule-classes :rewrite)

Theorem: cst-postfix-expression-conc1-of-tree-fix-cst

(defthm cst-postfix-expression-conc1-of-tree-fix-cst
  (equal (cst-postfix-expression-conc1 (abnf::tree-fix abnf::cst))
         (cst-postfix-expression-conc1 abnf::cst)))

Theorem: cst-postfix-expression-conc1-tree-equiv-congruence-on-cst

(defthm cst-postfix-expression-conc1-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-postfix-expression-conc1 abnf::cst)
                  (cst-postfix-expression-conc1 cst-equiv)))
  :rule-classes :congruence)

Function: cst-postfix-expression-conc2

(defun cst-postfix-expression-conc2 (abnf::cst)
 (declare (xargs :guard (abnf::treep abnf::cst)))
 (declare
  (xargs :guard (and (cst-matchp abnf::cst "postfix-expression")
                     (equal (cst-postfix-expression-conc? abnf::cst)
                            2))))
 (let ((__function__ 'cst-postfix-expression-conc2))
   (declare (ignorable __function__))
   (abnf::tree-nonleaf->branches abnf::cst)))

Theorem: tree-list-listp-of-cst-postfix-expression-conc2

(defthm tree-list-listp-of-cst-postfix-expression-conc2
  (b* ((abnf::cstss (cst-postfix-expression-conc2 abnf::cst)))
    (abnf::tree-list-listp abnf::cstss))
  :rule-classes :rewrite)

Theorem: cst-postfix-expression-conc2-match

(defthm cst-postfix-expression-conc2-match
  (implies
       (and (cst-matchp abnf::cst "postfix-expression")
            (equal (cst-postfix-expression-conc? abnf::cst)
                   2))
       (b* ((abnf::cstss (cst-postfix-expression-conc2 abnf::cst)))
         (cst-list-list-conc-matchp abnf::cstss
                                    "tuple-component-expression")))
  :rule-classes :rewrite)

Theorem: cst-postfix-expression-conc2-of-tree-fix-cst

(defthm cst-postfix-expression-conc2-of-tree-fix-cst
  (equal (cst-postfix-expression-conc2 (abnf::tree-fix abnf::cst))
         (cst-postfix-expression-conc2 abnf::cst)))

Theorem: cst-postfix-expression-conc2-tree-equiv-congruence-on-cst

(defthm cst-postfix-expression-conc2-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-postfix-expression-conc2 abnf::cst)
                  (cst-postfix-expression-conc2 cst-equiv)))
  :rule-classes :congruence)

Function: cst-postfix-expression-conc3

(defun cst-postfix-expression-conc3 (abnf::cst)
 (declare (xargs :guard (abnf::treep abnf::cst)))
 (declare
  (xargs :guard (and (cst-matchp abnf::cst "postfix-expression")
                     (equal (cst-postfix-expression-conc? abnf::cst)
                            3))))
 (let ((__function__ 'cst-postfix-expression-conc3))
   (declare (ignorable __function__))
   (abnf::tree-nonleaf->branches abnf::cst)))

Theorem: tree-list-listp-of-cst-postfix-expression-conc3

(defthm tree-list-listp-of-cst-postfix-expression-conc3
  (b* ((abnf::cstss (cst-postfix-expression-conc3 abnf::cst)))
    (abnf::tree-list-listp abnf::cstss))
  :rule-classes :rewrite)

Theorem: cst-postfix-expression-conc3-match

(defthm cst-postfix-expression-conc3-match
  (implies
       (and (cst-matchp abnf::cst "postfix-expression")
            (equal (cst-postfix-expression-conc? abnf::cst)
                   3))
       (b* ((abnf::cstss (cst-postfix-expression-conc3 abnf::cst)))
         (cst-list-list-conc-matchp abnf::cstss
                                    "array-component-expression")))
  :rule-classes :rewrite)

Theorem: cst-postfix-expression-conc3-of-tree-fix-cst

(defthm cst-postfix-expression-conc3-of-tree-fix-cst
  (equal (cst-postfix-expression-conc3 (abnf::tree-fix abnf::cst))
         (cst-postfix-expression-conc3 abnf::cst)))

Theorem: cst-postfix-expression-conc3-tree-equiv-congruence-on-cst

(defthm cst-postfix-expression-conc3-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-postfix-expression-conc3 abnf::cst)
                  (cst-postfix-expression-conc3 cst-equiv)))
  :rule-classes :congruence)

Function: cst-postfix-expression-conc4

(defun cst-postfix-expression-conc4 (abnf::cst)
 (declare (xargs :guard (abnf::treep abnf::cst)))
 (declare
  (xargs :guard (and (cst-matchp abnf::cst "postfix-expression")
                     (equal (cst-postfix-expression-conc? abnf::cst)
                            4))))
 (let ((__function__ 'cst-postfix-expression-conc4))
   (declare (ignorable __function__))
   (abnf::tree-nonleaf->branches abnf::cst)))

Theorem: tree-list-listp-of-cst-postfix-expression-conc4

(defthm tree-list-listp-of-cst-postfix-expression-conc4
  (b* ((abnf::cstss (cst-postfix-expression-conc4 abnf::cst)))
    (abnf::tree-list-listp abnf::cstss))
  :rule-classes :rewrite)

Theorem: cst-postfix-expression-conc4-match

(defthm cst-postfix-expression-conc4-match
  (implies
       (and (cst-matchp abnf::cst "postfix-expression")
            (equal (cst-postfix-expression-conc? abnf::cst)
                   4))
       (b* ((abnf::cstss (cst-postfix-expression-conc4 abnf::cst)))
         (cst-list-list-conc-matchp abnf::cstss
                                    "struct-component-expression")))
  :rule-classes :rewrite)

Theorem: cst-postfix-expression-conc4-of-tree-fix-cst

(defthm cst-postfix-expression-conc4-of-tree-fix-cst
  (equal (cst-postfix-expression-conc4 (abnf::tree-fix abnf::cst))
         (cst-postfix-expression-conc4 abnf::cst)))

Theorem: cst-postfix-expression-conc4-tree-equiv-congruence-on-cst

(defthm cst-postfix-expression-conc4-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-postfix-expression-conc4 abnf::cst)
                  (cst-postfix-expression-conc4 cst-equiv)))
  :rule-classes :congruence)

Function: cst-postfix-expression-conc5

(defun cst-postfix-expression-conc5 (abnf::cst)
 (declare (xargs :guard (abnf::treep abnf::cst)))
 (declare
  (xargs :guard (and (cst-matchp abnf::cst "postfix-expression")
                     (equal (cst-postfix-expression-conc? abnf::cst)
                            5))))
 (let ((__function__ 'cst-postfix-expression-conc5))
   (declare (ignorable __function__))
   (abnf::tree-nonleaf->branches abnf::cst)))

Theorem: tree-list-listp-of-cst-postfix-expression-conc5

(defthm tree-list-listp-of-cst-postfix-expression-conc5
  (b* ((abnf::cstss (cst-postfix-expression-conc5 abnf::cst)))
    (abnf::tree-list-listp abnf::cstss))
  :rule-classes :rewrite)

Theorem: cst-postfix-expression-conc5-match

(defthm cst-postfix-expression-conc5-match
  (implies
       (and (cst-matchp abnf::cst "postfix-expression")
            (equal (cst-postfix-expression-conc? abnf::cst)
                   5))
       (b* ((abnf::cstss (cst-postfix-expression-conc5 abnf::cst)))
         (cst-list-list-conc-matchp abnf::cstss "method-call")))
  :rule-classes :rewrite)

Theorem: cst-postfix-expression-conc5-of-tree-fix-cst

(defthm cst-postfix-expression-conc5-of-tree-fix-cst
  (equal (cst-postfix-expression-conc5 (abnf::tree-fix abnf::cst))
         (cst-postfix-expression-conc5 abnf::cst)))

Theorem: cst-postfix-expression-conc5-tree-equiv-congruence-on-cst

(defthm cst-postfix-expression-conc5-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-postfix-expression-conc5 abnf::cst)
                  (cst-postfix-expression-conc5 cst-equiv)))
  :rule-classes :congruence)

Function: cst-tuple-component-expression-conc

(defun cst-tuple-component-expression-conc (abnf::cst)
  (declare (xargs :guard (abnf::treep abnf::cst)))
  (declare (xargs :guard (cst-matchp abnf::cst
                                     "tuple-component-expression")))
  (let ((__function__ 'cst-tuple-component-expression-conc))
    (declare (ignorable __function__))
    (abnf::tree-nonleaf->branches abnf::cst)))

Theorem: tree-list-listp-of-cst-tuple-component-expression-conc

(defthm tree-list-listp-of-cst-tuple-component-expression-conc
 (b* ((abnf::cstss (cst-tuple-component-expression-conc abnf::cst)))
   (abnf::tree-list-listp abnf::cstss))
 :rule-classes :rewrite)

Theorem: cst-tuple-component-expression-conc-match

(defthm cst-tuple-component-expression-conc-match
 (implies
   (cst-matchp abnf::cst "tuple-component-expression")
   (b*
     ((abnf::cstss (cst-tuple-component-expression-conc abnf::cst)))
     (cst-list-list-conc-matchp
          abnf::cstss
          "postfix-expression \".\" tuple-index")))
 :rule-classes :rewrite)

Theorem: cst-tuple-component-expression-conc-of-tree-fix-cst

(defthm cst-tuple-component-expression-conc-of-tree-fix-cst
 (equal
    (cst-tuple-component-expression-conc (abnf::tree-fix abnf::cst))
    (cst-tuple-component-expression-conc abnf::cst)))

Theorem: cst-tuple-component-expression-conc-tree-equiv-congruence-on-cst

(defthm
   cst-tuple-component-expression-conc-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-tuple-component-expression-conc abnf::cst)
                  (cst-tuple-component-expression-conc cst-equiv)))
  :rule-classes :congruence)

Function: cst-array-component-expression-conc

(defun cst-array-component-expression-conc (abnf::cst)
  (declare (xargs :guard (abnf::treep abnf::cst)))
  (declare (xargs :guard (cst-matchp abnf::cst
                                     "array-component-expression")))
  (let ((__function__ 'cst-array-component-expression-conc))
    (declare (ignorable __function__))
    (abnf::tree-nonleaf->branches abnf::cst)))

Theorem: tree-list-listp-of-cst-array-component-expression-conc

(defthm tree-list-listp-of-cst-array-component-expression-conc
 (b* ((abnf::cstss (cst-array-component-expression-conc abnf::cst)))
   (abnf::tree-list-listp abnf::cstss))
 :rule-classes :rewrite)

Theorem: cst-array-component-expression-conc-match

(defthm cst-array-component-expression-conc-match
 (implies
   (cst-matchp abnf::cst "array-component-expression")
   (b*
     ((abnf::cstss (cst-array-component-expression-conc abnf::cst)))
     (cst-list-list-conc-matchp
          abnf::cstss
          "postfix-expression \"[\" expression \"]\"")))
 :rule-classes :rewrite)

Theorem: cst-array-component-expression-conc-of-tree-fix-cst

(defthm cst-array-component-expression-conc-of-tree-fix-cst
 (equal
    (cst-array-component-expression-conc (abnf::tree-fix abnf::cst))
    (cst-array-component-expression-conc abnf::cst)))

Theorem: cst-array-component-expression-conc-tree-equiv-congruence-on-cst

(defthm
   cst-array-component-expression-conc-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-array-component-expression-conc abnf::cst)
                  (cst-array-component-expression-conc cst-equiv)))
  :rule-classes :congruence)

Function: cst-struct-component-expression-conc

(defun cst-struct-component-expression-conc (abnf::cst)
 (declare (xargs :guard (abnf::treep abnf::cst)))
 (declare (xargs :guard (cst-matchp abnf::cst
                                    "struct-component-expression")))
 (let ((__function__ 'cst-struct-component-expression-conc))
   (declare (ignorable __function__))
   (abnf::tree-nonleaf->branches abnf::cst)))

Theorem: tree-list-listp-of-cst-struct-component-expression-conc

(defthm tree-list-listp-of-cst-struct-component-expression-conc
  (b*
    ((abnf::cstss (cst-struct-component-expression-conc abnf::cst)))
    (abnf::tree-list-listp abnf::cstss))
  :rule-classes :rewrite)

Theorem: cst-struct-component-expression-conc-match

(defthm cst-struct-component-expression-conc-match
 (implies
  (cst-matchp abnf::cst "struct-component-expression")
  (b*
   ((abnf::cstss (cst-struct-component-expression-conc abnf::cst)))
   (cst-list-list-conc-matchp abnf::cstss
                              "postfix-expression \".\" identifier")))
 :rule-classes :rewrite)

Theorem: cst-struct-component-expression-conc-of-tree-fix-cst

(defthm cst-struct-component-expression-conc-of-tree-fix-cst
 (equal
   (cst-struct-component-expression-conc (abnf::tree-fix abnf::cst))
   (cst-struct-component-expression-conc abnf::cst)))

Theorem: cst-struct-component-expression-conc-tree-equiv-congruence-on-cst

(defthm
  cst-struct-component-expression-conc-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-struct-component-expression-conc abnf::cst)
                  (cst-struct-component-expression-conc cst-equiv)))
  :rule-classes :congruence)

Function: cst-method-call-conc

(defun cst-method-call-conc (abnf::cst)
  (declare (xargs :guard (abnf::treep abnf::cst)))
  (declare (xargs :guard (cst-matchp abnf::cst "method-call")))
  (let ((__function__ 'cst-method-call-conc))
    (declare (ignorable __function__))
    (abnf::tree-nonleaf->branches abnf::cst)))

Theorem: tree-list-listp-of-cst-method-call-conc

(defthm tree-list-listp-of-cst-method-call-conc
  (b* ((abnf::cstss (cst-method-call-conc abnf::cst)))
    (abnf::tree-list-listp abnf::cstss))
  :rule-classes :rewrite)

Theorem: cst-method-call-conc-match

(defthm cst-method-call-conc-match
 (implies
    (cst-matchp abnf::cst "method-call")
    (b* ((abnf::cstss (cst-method-call-conc abnf::cst)))
      (cst-list-list-conc-matchp
           abnf::cstss
           "postfix-expression \".\" identifier function-arguments")))
 :rule-classes :rewrite)

Theorem: cst-method-call-conc-of-tree-fix-cst

(defthm cst-method-call-conc-of-tree-fix-cst
  (equal (cst-method-call-conc (abnf::tree-fix abnf::cst))
         (cst-method-call-conc abnf::cst)))

Theorem: cst-method-call-conc-tree-equiv-congruence-on-cst

(defthm cst-method-call-conc-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-method-call-conc abnf::cst)
                  (cst-method-call-conc cst-equiv)))
  :rule-classes :congruence)

Function: cst-binary-expression-conc

(defun cst-binary-expression-conc (abnf::cst)
 (declare (xargs :guard (abnf::treep abnf::cst)))
 (declare (xargs :guard (cst-matchp abnf::cst "binary-expression")))
 (let ((__function__ 'cst-binary-expression-conc))
   (declare (ignorable __function__))
   (abnf::tree-nonleaf->branches abnf::cst)))

Theorem: tree-list-listp-of-cst-binary-expression-conc

(defthm tree-list-listp-of-cst-binary-expression-conc
  (b* ((abnf::cstss (cst-binary-expression-conc abnf::cst)))
    (abnf::tree-list-listp abnf::cstss))
  :rule-classes :rewrite)

Theorem: cst-binary-expression-conc-match

(defthm cst-binary-expression-conc-match
 (implies (cst-matchp abnf::cst "binary-expression")
          (b* ((abnf::cstss (cst-binary-expression-conc abnf::cst)))
            (cst-list-list-conc-matchp
                 abnf::cstss
                 "conditional-disjunctive-expression")))
 :rule-classes :rewrite)

Theorem: cst-binary-expression-conc-of-tree-fix-cst

(defthm cst-binary-expression-conc-of-tree-fix-cst
  (equal (cst-binary-expression-conc (abnf::tree-fix abnf::cst))
         (cst-binary-expression-conc abnf::cst)))

Theorem: cst-binary-expression-conc-tree-equiv-congruence-on-cst

(defthm cst-binary-expression-conc-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-binary-expression-conc abnf::cst)
                  (cst-binary-expression-conc cst-equiv)))
  :rule-classes :congruence)

Function: cst-expression-conc

(defun cst-expression-conc (abnf::cst)
  (declare (xargs :guard (abnf::treep abnf::cst)))
  (declare (xargs :guard (cst-matchp abnf::cst "expression")))
  (let ((__function__ 'cst-expression-conc))
    (declare (ignorable __function__))
    (abnf::tree-nonleaf->branches abnf::cst)))

Theorem: tree-list-listp-of-cst-expression-conc

(defthm tree-list-listp-of-cst-expression-conc
  (b* ((abnf::cstss (cst-expression-conc abnf::cst)))
    (abnf::tree-list-listp abnf::cstss))
  :rule-classes :rewrite)

Theorem: cst-expression-conc-match

(defthm cst-expression-conc-match
 (implies
    (cst-matchp abnf::cst "expression")
    (b* ((abnf::cstss (cst-expression-conc abnf::cst)))
      (cst-list-list-conc-matchp abnf::cstss
                                 "conditional-ternary-expression")))
 :rule-classes :rewrite)

Theorem: cst-expression-conc-of-tree-fix-cst

(defthm cst-expression-conc-of-tree-fix-cst
  (equal (cst-expression-conc (abnf::tree-fix abnf::cst))
         (cst-expression-conc abnf::cst)))

Theorem: cst-expression-conc-tree-equiv-congruence-on-cst

(defthm cst-expression-conc-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-expression-conc abnf::cst)
                  (cst-expression-conc cst-equiv)))
  :rule-classes :congruence)

Function: cst-statement-conc1

(defun cst-statement-conc1 (abnf::cst)
  (declare (xargs :guard (abnf::treep abnf::cst)))
  (declare (xargs :guard (and (cst-matchp abnf::cst "statement")
                              (equal (cst-statement-conc? abnf::cst)
                                     1))))
  (let ((__function__ 'cst-statement-conc1))
    (declare (ignorable __function__))
    (abnf::tree-nonleaf->branches abnf::cst)))

Theorem: tree-list-listp-of-cst-statement-conc1

(defthm tree-list-listp-of-cst-statement-conc1
  (b* ((abnf::cstss (cst-statement-conc1 abnf::cst)))
    (abnf::tree-list-listp abnf::cstss))
  :rule-classes :rewrite)

Theorem: cst-statement-conc1-match

(defthm cst-statement-conc1-match
 (implies
  (and (cst-matchp abnf::cst "statement")
       (equal (cst-statement-conc? abnf::cst)
              1))
  (b* ((abnf::cstss (cst-statement-conc1 abnf::cst)))
    (cst-list-list-conc-matchp abnf::cstss "expression-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 "return-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 "variable-declaration")))
 :rule-classes :rewrite)

Theorem: cst-statement-conc3-of-tree-fix-cst

(defthm cst-statement-conc3-of-tree-fix-cst
  (equal (cst-statement-conc3 (abnf::tree-fix abnf::cst))
         (cst-statement-conc3 abnf::cst)))

Theorem: cst-statement-conc3-tree-equiv-congruence-on-cst

(defthm cst-statement-conc3-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-statement-conc3 abnf::cst)
                  (cst-statement-conc3 cst-equiv)))
  :rule-classes :congruence)

Function: cst-statement-conc4

(defun cst-statement-conc4 (abnf::cst)
  (declare (xargs :guard (abnf::treep abnf::cst)))
  (declare (xargs :guard (and (cst-matchp abnf::cst "statement")
                              (equal (cst-statement-conc? abnf::cst)
                                     4))))
  (let ((__function__ 'cst-statement-conc4))
    (declare (ignorable __function__))
    (abnf::tree-nonleaf->branches abnf::cst)))

Theorem: tree-list-listp-of-cst-statement-conc4

(defthm tree-list-listp-of-cst-statement-conc4
  (b* ((abnf::cstss (cst-statement-conc4 abnf::cst)))
    (abnf::tree-list-listp abnf::cstss))
  :rule-classes :rewrite)

Theorem: cst-statement-conc4-match

(defthm cst-statement-conc4-match
 (implies
  (and (cst-matchp abnf::cst "statement")
       (equal (cst-statement-conc? abnf::cst)
              4))
  (b* ((abnf::cstss (cst-statement-conc4 abnf::cst)))
    (cst-list-list-conc-matchp abnf::cstss "constant-declaration")))
 :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 "conditional-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 "loop-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 "assignment-statement")))
 :rule-classes :rewrite)

Theorem: cst-statement-conc7-of-tree-fix-cst

(defthm cst-statement-conc7-of-tree-fix-cst
  (equal (cst-statement-conc7 (abnf::tree-fix abnf::cst))
         (cst-statement-conc7 abnf::cst)))

Theorem: cst-statement-conc7-tree-equiv-congruence-on-cst

(defthm cst-statement-conc7-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-statement-conc7 abnf::cst)
                  (cst-statement-conc7 cst-equiv)))
  :rule-classes :congruence)

Function: cst-statement-conc8

(defun cst-statement-conc8 (abnf::cst)
  (declare (xargs :guard (abnf::treep abnf::cst)))
  (declare (xargs :guard (and (cst-matchp abnf::cst "statement")
                              (equal (cst-statement-conc? abnf::cst)
                                     8))))
  (let ((__function__ 'cst-statement-conc8))
    (declare (ignorable __function__))
    (abnf::tree-nonleaf->branches abnf::cst)))

Theorem: tree-list-listp-of-cst-statement-conc8

(defthm tree-list-listp-of-cst-statement-conc8
  (b* ((abnf::cstss (cst-statement-conc8 abnf::cst)))
    (abnf::tree-list-listp abnf::cstss))
  :rule-classes :rewrite)

Theorem: cst-statement-conc8-match

(defthm cst-statement-conc8-match
  (implies (and (cst-matchp abnf::cst "statement")
                (equal (cst-statement-conc? abnf::cst)
                       8))
           (b* ((abnf::cstss (cst-statement-conc8 abnf::cst)))
             (cst-list-list-conc-matchp abnf::cstss "block")))
  :rule-classes :rewrite)

Theorem: cst-statement-conc8-of-tree-fix-cst

(defthm cst-statement-conc8-of-tree-fix-cst
  (equal (cst-statement-conc8 (abnf::tree-fix abnf::cst))
         (cst-statement-conc8 abnf::cst)))

Theorem: cst-statement-conc8-tree-equiv-congruence-on-cst

(defthm cst-statement-conc8-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-statement-conc8 abnf::cst)
                  (cst-statement-conc8 cst-equiv)))
  :rule-classes :congruence)

Function: cst-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-block-conc

(defun cst-block-conc (abnf::cst)
  (declare (xargs :guard (abnf::treep abnf::cst)))
  (declare (xargs :guard (cst-matchp abnf::cst "block")))
  (let ((__function__ 'cst-block-conc))
    (declare (ignorable __function__))
    (abnf::tree-nonleaf->branches abnf::cst)))

Theorem: tree-list-listp-of-cst-block-conc

(defthm tree-list-listp-of-cst-block-conc
  (b* ((abnf::cstss (cst-block-conc abnf::cst)))
    (abnf::tree-list-listp abnf::cstss))
  :rule-classes :rewrite)

Theorem: cst-block-conc-match

(defthm cst-block-conc-match
 (implies
    (cst-matchp abnf::cst "block")
    (b* ((abnf::cstss (cst-block-conc abnf::cst)))
      (cst-list-list-conc-matchp abnf::cstss "\"{\" *statement \"}\"")))
 :rule-classes :rewrite)

Theorem: cst-block-conc-of-tree-fix-cst

(defthm cst-block-conc-of-tree-fix-cst
  (equal (cst-block-conc (abnf::tree-fix abnf::cst))
         (cst-block-conc abnf::cst)))

Theorem: cst-block-conc-tree-equiv-congruence-on-cst

(defthm cst-block-conc-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-block-conc abnf::cst)
                  (cst-block-conc cst-equiv)))
  :rule-classes :congruence)

Function: cst-return-statement-conc

(defun cst-return-statement-conc (abnf::cst)
  (declare (xargs :guard (abnf::treep abnf::cst)))
  (declare (xargs :guard (cst-matchp abnf::cst "return-statement")))
  (let ((__function__ 'cst-return-statement-conc))
    (declare (ignorable __function__))
    (abnf::tree-nonleaf->branches abnf::cst)))

Theorem: tree-list-listp-of-cst-return-statement-conc

(defthm tree-list-listp-of-cst-return-statement-conc
  (b* ((abnf::cstss (cst-return-statement-conc abnf::cst)))
    (abnf::tree-list-listp abnf::cstss))
  :rule-classes :rewrite)

Theorem: cst-return-statement-conc-match

(defthm cst-return-statement-conc-match
 (implies
     (cst-matchp abnf::cst "return-statement")
     (b* ((abnf::cstss (cst-return-statement-conc abnf::cst)))
       (cst-list-list-conc-matchp abnf::cstss
                                  "%s\"return\" [ expression ] \";\"")))
 :rule-classes :rewrite)

Theorem: cst-return-statement-conc-of-tree-fix-cst

(defthm cst-return-statement-conc-of-tree-fix-cst
  (equal (cst-return-statement-conc (abnf::tree-fix abnf::cst))
         (cst-return-statement-conc abnf::cst)))

Theorem: cst-return-statement-conc-tree-equiv-congruence-on-cst

(defthm cst-return-statement-conc-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-return-statement-conc abnf::cst)
                  (cst-return-statement-conc cst-equiv)))
  :rule-classes :congruence)

Function: cst-variable-declaration-conc

(defun cst-variable-declaration-conc (abnf::cst)
  (declare (xargs :guard (abnf::treep abnf::cst)))
  (declare
       (xargs :guard (cst-matchp abnf::cst "variable-declaration")))
  (let ((__function__ 'cst-variable-declaration-conc))
    (declare (ignorable __function__))
    (abnf::tree-nonleaf->branches abnf::cst)))

Theorem: tree-list-listp-of-cst-variable-declaration-conc

(defthm tree-list-listp-of-cst-variable-declaration-conc
  (b* ((abnf::cstss (cst-variable-declaration-conc abnf::cst)))
    (abnf::tree-list-listp abnf::cstss))
  :rule-classes :rewrite)

Theorem: cst-variable-declaration-conc-match

(defthm cst-variable-declaration-conc-match
 (implies
  (cst-matchp abnf::cst "variable-declaration")
  (b* ((abnf::cstss (cst-variable-declaration-conc abnf::cst)))
   (cst-list-list-conc-matchp
    abnf::cstss
    "%s\"let\" identifier-or-identifiers [ \":\" type ] \"=\" expression \";\"")))
 :rule-classes :rewrite)

Theorem: cst-variable-declaration-conc-of-tree-fix-cst

(defthm cst-variable-declaration-conc-of-tree-fix-cst
  (equal (cst-variable-declaration-conc (abnf::tree-fix abnf::cst))
         (cst-variable-declaration-conc abnf::cst)))

Theorem: cst-variable-declaration-conc-tree-equiv-congruence-on-cst

(defthm cst-variable-declaration-conc-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-variable-declaration-conc abnf::cst)
                  (cst-variable-declaration-conc cst-equiv)))
  :rule-classes :congruence)

Function: cst-constant-declaration-conc

(defun cst-constant-declaration-conc (abnf::cst)
  (declare (xargs :guard (abnf::treep abnf::cst)))
  (declare
       (xargs :guard (cst-matchp abnf::cst "constant-declaration")))
  (let ((__function__ 'cst-constant-declaration-conc))
    (declare (ignorable __function__))
    (abnf::tree-nonleaf->branches abnf::cst)))

Theorem: tree-list-listp-of-cst-constant-declaration-conc

(defthm tree-list-listp-of-cst-constant-declaration-conc
  (b* ((abnf::cstss (cst-constant-declaration-conc abnf::cst)))
    (abnf::tree-list-listp abnf::cstss))
  :rule-classes :rewrite)

Theorem: cst-constant-declaration-conc-match

(defthm cst-constant-declaration-conc-match
  (implies
       (cst-matchp abnf::cst "constant-declaration")
       (b* ((abnf::cstss (cst-constant-declaration-conc abnf::cst)))
         (cst-list-list-conc-matchp
              abnf::cstss
              "%s\"const\" identifier \":\" type \"=\" expression \";\"")))
  :rule-classes :rewrite)

Theorem: cst-constant-declaration-conc-of-tree-fix-cst

(defthm cst-constant-declaration-conc-of-tree-fix-cst
  (equal (cst-constant-declaration-conc (abnf::tree-fix abnf::cst))
         (cst-constant-declaration-conc abnf::cst)))

Theorem: cst-constant-declaration-conc-tree-equiv-congruence-on-cst

(defthm cst-constant-declaration-conc-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-constant-declaration-conc abnf::cst)
                  (cst-constant-declaration-conc cst-equiv)))
  :rule-classes :congruence)

Function: cst-branch-conc

(defun cst-branch-conc (abnf::cst)
  (declare (xargs :guard (abnf::treep abnf::cst)))
  (declare (xargs :guard (cst-matchp abnf::cst "branch")))
  (let ((__function__ 'cst-branch-conc))
    (declare (ignorable __function__))
    (abnf::tree-nonleaf->branches abnf::cst)))

Theorem: tree-list-listp-of-cst-branch-conc

(defthm tree-list-listp-of-cst-branch-conc
  (b* ((abnf::cstss (cst-branch-conc abnf::cst)))
    (abnf::tree-list-listp abnf::cstss))
  :rule-classes :rewrite)

Theorem: cst-branch-conc-match

(defthm cst-branch-conc-match
  (implies (cst-matchp abnf::cst "branch")
           (b* ((abnf::cstss (cst-branch-conc abnf::cst)))
             (cst-list-list-conc-matchp
                  abnf::cstss
                  "%s\"if\" conditional-ternary-expression block")))
  :rule-classes :rewrite)

Theorem: cst-branch-conc-of-tree-fix-cst

(defthm cst-branch-conc-of-tree-fix-cst
  (equal (cst-branch-conc (abnf::tree-fix abnf::cst))
         (cst-branch-conc abnf::cst)))

Theorem: cst-branch-conc-tree-equiv-congruence-on-cst

(defthm cst-branch-conc-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-branch-conc abnf::cst)
                  (cst-branch-conc cst-equiv)))
  :rule-classes :congruence)

Function: cst-loop-statement-conc

(defun cst-loop-statement-conc (abnf::cst)
  (declare (xargs :guard (abnf::treep abnf::cst)))
  (declare (xargs :guard (cst-matchp abnf::cst "loop-statement")))
  (let ((__function__ 'cst-loop-statement-conc))
    (declare (ignorable __function__))
    (abnf::tree-nonleaf->branches abnf::cst)))

Theorem: tree-list-listp-of-cst-loop-statement-conc

(defthm tree-list-listp-of-cst-loop-statement-conc
  (b* ((abnf::cstss (cst-loop-statement-conc abnf::cst)))
    (abnf::tree-list-listp abnf::cstss))
  :rule-classes :rewrite)

Theorem: cst-loop-statement-conc-match

(defthm cst-loop-statement-conc-match
 (implies
  (cst-matchp abnf::cst "loop-statement")
  (b* ((abnf::cstss (cst-loop-statement-conc abnf::cst)))
   (cst-list-list-conc-matchp
    abnf::cstss
    "%s\"for\" identifier [ \":\" type ] %s\"in\" expression \"..\" expression block")))
 :rule-classes :rewrite)

Theorem: cst-loop-statement-conc-of-tree-fix-cst

(defthm cst-loop-statement-conc-of-tree-fix-cst
  (equal (cst-loop-statement-conc (abnf::tree-fix abnf::cst))
         (cst-loop-statement-conc abnf::cst)))

Theorem: cst-loop-statement-conc-tree-equiv-congruence-on-cst

(defthm cst-loop-statement-conc-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-loop-statement-conc abnf::cst)
                  (cst-loop-statement-conc cst-equiv)))
  :rule-classes :congruence)

Function: cst-assignment-statement-conc

(defun cst-assignment-statement-conc (abnf::cst)
  (declare (xargs :guard (abnf::treep abnf::cst)))
  (declare
       (xargs :guard (cst-matchp abnf::cst "assignment-statement")))
  (let ((__function__ 'cst-assignment-statement-conc))
    (declare (ignorable __function__))
    (abnf::tree-nonleaf->branches abnf::cst)))

Theorem: tree-list-listp-of-cst-assignment-statement-conc

(defthm tree-list-listp-of-cst-assignment-statement-conc
  (b* ((abnf::cstss (cst-assignment-statement-conc abnf::cst)))
    (abnf::tree-list-listp abnf::cstss))
  :rule-classes :rewrite)

Theorem: cst-assignment-statement-conc-match

(defthm cst-assignment-statement-conc-match
  (implies
       (cst-matchp abnf::cst "assignment-statement")
       (b* ((abnf::cstss (cst-assignment-statement-conc abnf::cst)))
         (cst-list-list-conc-matchp
              abnf::cstss
              "expression assignment-operator expression \";\"")))
  :rule-classes :rewrite)

Theorem: cst-assignment-statement-conc-of-tree-fix-cst

(defthm cst-assignment-statement-conc-of-tree-fix-cst
  (equal (cst-assignment-statement-conc (abnf::tree-fix abnf::cst))
         (cst-assignment-statement-conc abnf::cst)))

Theorem: cst-assignment-statement-conc-tree-equiv-congruence-on-cst

(defthm cst-assignment-statement-conc-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-assignment-statement-conc abnf::cst)
                  (cst-assignment-statement-conc cst-equiv)))
  :rule-classes :congruence)

Function: cst-function-declaration-conc

(defun cst-function-declaration-conc (abnf::cst)
  (declare (xargs :guard (abnf::treep abnf::cst)))
  (declare
       (xargs :guard (cst-matchp abnf::cst "function-declaration")))
  (let ((__function__ 'cst-function-declaration-conc))
    (declare (ignorable __function__))
    (abnf::tree-nonleaf->branches abnf::cst)))

Theorem: tree-list-listp-of-cst-function-declaration-conc

(defthm tree-list-listp-of-cst-function-declaration-conc
  (b* ((abnf::cstss (cst-function-declaration-conc abnf::cst)))
    (abnf::tree-list-listp abnf::cstss))
  :rule-classes :rewrite)

Theorem: cst-function-declaration-conc-match

(defthm cst-function-declaration-conc-match
 (implies
  (cst-matchp abnf::cst "function-declaration")
  (b* ((abnf::cstss (cst-function-declaration-conc abnf::cst)))
   (cst-list-list-conc-matchp
    abnf::cstss
    "*annotation [ %s\"async\" ] function-kind identifier \"(\" [ function-inputs ] \")\" [ \"->\" function-outputs ] ( block / \";\" )")))
 :rule-classes :rewrite)

Theorem: cst-function-declaration-conc-of-tree-fix-cst

(defthm cst-function-declaration-conc-of-tree-fix-cst
  (equal (cst-function-declaration-conc (abnf::tree-fix abnf::cst))
         (cst-function-declaration-conc abnf::cst)))

Theorem: cst-function-declaration-conc-tree-equiv-congruence-on-cst

(defthm cst-function-declaration-conc-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-function-declaration-conc abnf::cst)
                  (cst-function-declaration-conc cst-equiv)))
  :rule-classes :congruence)

Function: cst-function-inputs-conc

(defun cst-function-inputs-conc (abnf::cst)
  (declare (xargs :guard (abnf::treep abnf::cst)))
  (declare (xargs :guard (cst-matchp abnf::cst "function-inputs")))
  (let ((__function__ 'cst-function-inputs-conc))
    (declare (ignorable __function__))
    (abnf::tree-nonleaf->branches abnf::cst)))

Theorem: tree-list-listp-of-cst-function-inputs-conc

(defthm tree-list-listp-of-cst-function-inputs-conc
  (b* ((abnf::cstss (cst-function-inputs-conc abnf::cst)))
    (abnf::tree-list-listp abnf::cstss))
  :rule-classes :rewrite)

Theorem: cst-function-inputs-conc-match

(defthm cst-function-inputs-conc-match
 (implies (cst-matchp abnf::cst "function-inputs")
          (b* ((abnf::cstss (cst-function-inputs-conc abnf::cst)))
            (cst-list-list-conc-matchp
                 abnf::cstss
                 "function-input *( \",\" function-input ) [ \",\" ]")))
 :rule-classes :rewrite)

Theorem: cst-function-inputs-conc-of-tree-fix-cst

(defthm cst-function-inputs-conc-of-tree-fix-cst
  (equal (cst-function-inputs-conc (abnf::tree-fix abnf::cst))
         (cst-function-inputs-conc abnf::cst)))

Theorem: cst-function-inputs-conc-tree-equiv-congruence-on-cst

(defthm cst-function-inputs-conc-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-function-inputs-conc abnf::cst)
                  (cst-function-inputs-conc cst-equiv)))
  :rule-classes :congruence)

Function: cst-function-input-conc

(defun cst-function-input-conc (abnf::cst)
  (declare (xargs :guard (abnf::treep abnf::cst)))
  (declare (xargs :guard (cst-matchp abnf::cst "function-input")))
  (let ((__function__ 'cst-function-input-conc))
    (declare (ignorable __function__))
    (abnf::tree-nonleaf->branches abnf::cst)))

Theorem: tree-list-listp-of-cst-function-input-conc

(defthm tree-list-listp-of-cst-function-input-conc
  (b* ((abnf::cstss (cst-function-input-conc abnf::cst)))
    (abnf::tree-list-listp abnf::cstss))
  :rule-classes :rewrite)

Theorem: cst-function-input-conc-match

(defthm cst-function-input-conc-match
 (implies
  (cst-matchp abnf::cst "function-input")
  (b* ((abnf::cstss (cst-function-input-conc abnf::cst)))
   (cst-list-list-conc-matchp
    abnf::cstss
    "[ %s\"public\" / %s\"private\" / %s\"constant\" ] identifier \":\" type")))
 :rule-classes :rewrite)

Theorem: cst-function-input-conc-of-tree-fix-cst

(defthm cst-function-input-conc-of-tree-fix-cst
  (equal (cst-function-input-conc (abnf::tree-fix abnf::cst))
         (cst-function-input-conc abnf::cst)))

Theorem: cst-function-input-conc-tree-equiv-congruence-on-cst

(defthm cst-function-input-conc-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-function-input-conc abnf::cst)
                  (cst-function-input-conc cst-equiv)))
  :rule-classes :congruence)

Function: cst-function-output-conc

(defun cst-function-output-conc (abnf::cst)
  (declare (xargs :guard (abnf::treep abnf::cst)))
  (declare (xargs :guard (cst-matchp abnf::cst "function-output")))
  (let ((__function__ 'cst-function-output-conc))
    (declare (ignorable __function__))
    (abnf::tree-nonleaf->branches abnf::cst)))

Theorem: tree-list-listp-of-cst-function-output-conc

(defthm tree-list-listp-of-cst-function-output-conc
  (b* ((abnf::cstss (cst-function-output-conc abnf::cst)))
    (abnf::tree-list-listp abnf::cstss))
  :rule-classes :rewrite)

Theorem: cst-function-output-conc-match

(defthm cst-function-output-conc-match
  (implies
       (cst-matchp abnf::cst "function-output")
       (b* ((abnf::cstss (cst-function-output-conc abnf::cst)))
         (cst-list-list-conc-matchp
              abnf::cstss
              "[ %s\"public\" / %s\"private\" / %s\"constant\" ] type")))
  :rule-classes :rewrite)

Theorem: cst-function-output-conc-of-tree-fix-cst

(defthm cst-function-output-conc-of-tree-fix-cst
  (equal (cst-function-output-conc (abnf::tree-fix abnf::cst))
         (cst-function-output-conc abnf::cst)))

Theorem: cst-function-output-conc-tree-equiv-congruence-on-cst

(defthm cst-function-output-conc-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-function-output-conc abnf::cst)
                  (cst-function-output-conc cst-equiv)))
  :rule-classes :congruence)

Function: cst-struct-declaration-conc

(defun cst-struct-declaration-conc (abnf::cst)
  (declare (xargs :guard (abnf::treep abnf::cst)))
  (declare
       (xargs :guard (cst-matchp abnf::cst "struct-declaration")))
  (let ((__function__ 'cst-struct-declaration-conc))
    (declare (ignorable __function__))
    (abnf::tree-nonleaf->branches abnf::cst)))

Theorem: tree-list-listp-of-cst-struct-declaration-conc

(defthm tree-list-listp-of-cst-struct-declaration-conc
  (b* ((abnf::cstss (cst-struct-declaration-conc abnf::cst)))
    (abnf::tree-list-listp abnf::cstss))
  :rule-classes :rewrite)

Theorem: cst-struct-declaration-conc-match

(defthm cst-struct-declaration-conc-match
 (implies
  (cst-matchp abnf::cst "struct-declaration")
  (b* ((abnf::cstss (cst-struct-declaration-conc abnf::cst)))
   (cst-list-list-conc-matchp
    abnf::cstss
    "%s\"struct\" identifier \"{\" struct-component-declarations \"}\"")))
 :rule-classes :rewrite)

Theorem: cst-struct-declaration-conc-of-tree-fix-cst

(defthm cst-struct-declaration-conc-of-tree-fix-cst
  (equal (cst-struct-declaration-conc (abnf::tree-fix abnf::cst))
         (cst-struct-declaration-conc abnf::cst)))

Theorem: cst-struct-declaration-conc-tree-equiv-congruence-on-cst

(defthm cst-struct-declaration-conc-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-struct-declaration-conc abnf::cst)
                  (cst-struct-declaration-conc cst-equiv)))
  :rule-classes :congruence)

Function: cst-struct-component-declarations-conc

(defun cst-struct-component-declarations-conc (abnf::cst)
  (declare (xargs :guard (abnf::treep abnf::cst)))
  (declare
       (xargs :guard (cst-matchp abnf::cst
                                 "struct-component-declarations")))
  (let ((__function__ 'cst-struct-component-declarations-conc))
    (declare (ignorable __function__))
    (abnf::tree-nonleaf->branches abnf::cst)))

Theorem: tree-list-listp-of-cst-struct-component-declarations-conc

(defthm tree-list-listp-of-cst-struct-component-declarations-conc
 (b*
  ((abnf::cstss (cst-struct-component-declarations-conc abnf::cst)))
  (abnf::tree-list-listp abnf::cstss))
 :rule-classes :rewrite)

Theorem: cst-struct-component-declarations-conc-match

(defthm cst-struct-component-declarations-conc-match
 (implies
  (cst-matchp abnf::cst
              "struct-component-declarations")
  (b* ((abnf::cstss
            (cst-struct-component-declarations-conc abnf::cst)))
   (cst-list-list-conc-matchp
    abnf::cstss
    "struct-component-declaration *( \",\" struct-component-declaration ) [ \",\" ]")))
 :rule-classes :rewrite)

Theorem: cst-struct-component-declarations-conc-of-tree-fix-cst

(defthm cst-struct-component-declarations-conc-of-tree-fix-cst
  (equal (cst-struct-component-declarations-conc
              (abnf::tree-fix abnf::cst))
         (cst-struct-component-declarations-conc abnf::cst)))

Theorem: cst-struct-component-declarations-conc-tree-equiv-congruence-on-cst

(defthm
 cst-struct-component-declarations-conc-tree-equiv-congruence-on-cst
 (implies
      (abnf::tree-equiv abnf::cst cst-equiv)
      (equal (cst-struct-component-declarations-conc abnf::cst)
             (cst-struct-component-declarations-conc cst-equiv)))
 :rule-classes :congruence)

Function: cst-struct-component-declaration-conc

(defun cst-struct-component-declaration-conc (abnf::cst)
  (declare (xargs :guard (abnf::treep abnf::cst)))
  (declare
       (xargs :guard (cst-matchp abnf::cst
                                 "struct-component-declaration")))
  (let ((__function__ 'cst-struct-component-declaration-conc))
    (declare (ignorable __function__))
    (abnf::tree-nonleaf->branches abnf::cst)))

Theorem: tree-list-listp-of-cst-struct-component-declaration-conc

(defthm tree-list-listp-of-cst-struct-component-declaration-conc
  (b*
   ((abnf::cstss (cst-struct-component-declaration-conc abnf::cst)))
   (abnf::tree-list-listp abnf::cstss))
  :rule-classes :rewrite)

Theorem: cst-struct-component-declaration-conc-match

(defthm cst-struct-component-declaration-conc-match
 (implies
  (cst-matchp abnf::cst
              "struct-component-declaration")
  (b*
   ((abnf::cstss (cst-struct-component-declaration-conc abnf::cst)))
   (cst-list-list-conc-matchp
    abnf::cstss
    "[ %s\"public\" / %s\"private\" / %s\"constant\" ] identifier \":\" type")))
 :rule-classes :rewrite)

Theorem: cst-struct-component-declaration-conc-of-tree-fix-cst

(defthm cst-struct-component-declaration-conc-of-tree-fix-cst
 (equal
  (cst-struct-component-declaration-conc (abnf::tree-fix abnf::cst))
  (cst-struct-component-declaration-conc abnf::cst)))

Theorem: cst-struct-component-declaration-conc-tree-equiv-congruence-on-cst

(defthm
 cst-struct-component-declaration-conc-tree-equiv-congruence-on-cst
 (implies (abnf::tree-equiv abnf::cst cst-equiv)
          (equal (cst-struct-component-declaration-conc abnf::cst)
                 (cst-struct-component-declaration-conc cst-equiv)))
 :rule-classes :congruence)

Function: cst-record-declaration-conc

(defun cst-record-declaration-conc (abnf::cst)
  (declare (xargs :guard (abnf::treep abnf::cst)))
  (declare
       (xargs :guard (cst-matchp abnf::cst "record-declaration")))
  (let ((__function__ 'cst-record-declaration-conc))
    (declare (ignorable __function__))
    (abnf::tree-nonleaf->branches abnf::cst)))

Theorem: tree-list-listp-of-cst-record-declaration-conc

(defthm tree-list-listp-of-cst-record-declaration-conc
  (b* ((abnf::cstss (cst-record-declaration-conc abnf::cst)))
    (abnf::tree-list-listp abnf::cstss))
  :rule-classes :rewrite)

Theorem: cst-record-declaration-conc-match

(defthm cst-record-declaration-conc-match
 (implies
  (cst-matchp abnf::cst "record-declaration")
  (b* ((abnf::cstss (cst-record-declaration-conc abnf::cst)))
   (cst-list-list-conc-matchp
    abnf::cstss
    "%s\"record\" identifier \"{\" struct-component-declarations \"}\"")))
 :rule-classes :rewrite)

Theorem: cst-record-declaration-conc-of-tree-fix-cst

(defthm cst-record-declaration-conc-of-tree-fix-cst
  (equal (cst-record-declaration-conc (abnf::tree-fix abnf::cst))
         (cst-record-declaration-conc abnf::cst)))

Theorem: cst-record-declaration-conc-tree-equiv-congruence-on-cst

(defthm cst-record-declaration-conc-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-record-declaration-conc abnf::cst)
                  (cst-record-declaration-conc cst-equiv)))
  :rule-classes :congruence)

Function: cst-mapping-declaration-conc

(defun cst-mapping-declaration-conc (abnf::cst)
  (declare (xargs :guard (abnf::treep abnf::cst)))
  (declare
       (xargs :guard (cst-matchp abnf::cst "mapping-declaration")))
  (let ((__function__ 'cst-mapping-declaration-conc))
    (declare (ignorable __function__))
    (abnf::tree-nonleaf->branches abnf::cst)))

Theorem: tree-list-listp-of-cst-mapping-declaration-conc

(defthm tree-list-listp-of-cst-mapping-declaration-conc
  (b* ((abnf::cstss (cst-mapping-declaration-conc abnf::cst)))
    (abnf::tree-list-listp abnf::cstss))
  :rule-classes :rewrite)

Theorem: cst-mapping-declaration-conc-match

(defthm cst-mapping-declaration-conc-match
  (implies
       (cst-matchp abnf::cst "mapping-declaration")
       (b* ((abnf::cstss (cst-mapping-declaration-conc abnf::cst)))
         (cst-list-list-conc-matchp
              abnf::cstss
              "%s\"mapping\" identifier \":\" type \"=>\" type \";\"")))
  :rule-classes :rewrite)

Theorem: cst-mapping-declaration-conc-of-tree-fix-cst

(defthm cst-mapping-declaration-conc-of-tree-fix-cst
  (equal (cst-mapping-declaration-conc (abnf::tree-fix abnf::cst))
         (cst-mapping-declaration-conc abnf::cst)))

Theorem: cst-mapping-declaration-conc-tree-equiv-congruence-on-cst

(defthm cst-mapping-declaration-conc-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-mapping-declaration-conc abnf::cst)
                  (cst-mapping-declaration-conc cst-equiv)))
  :rule-classes :congruence)

Function: cst-program-item-conc1

(defun cst-program-item-conc1 (abnf::cst)
  (declare (xargs :guard (abnf::treep abnf::cst)))
  (declare
       (xargs :guard (and (cst-matchp abnf::cst "program-item")
                          (equal (cst-program-item-conc? abnf::cst)
                                 1))))
  (let ((__function__ 'cst-program-item-conc1))
    (declare (ignorable __function__))
    (abnf::tree-nonleaf->branches abnf::cst)))

Theorem: tree-list-listp-of-cst-program-item-conc1

(defthm tree-list-listp-of-cst-program-item-conc1
  (b* ((abnf::cstss (cst-program-item-conc1 abnf::cst)))
    (abnf::tree-list-listp abnf::cstss))
  :rule-classes :rewrite)

Theorem: cst-program-item-conc1-match

(defthm cst-program-item-conc1-match
 (implies
  (and (cst-matchp abnf::cst "program-item")
       (equal (cst-program-item-conc? abnf::cst)
              1))
  (b* ((abnf::cstss (cst-program-item-conc1 abnf::cst)))
    (cst-list-list-conc-matchp abnf::cstss "function-declaration")))
 :rule-classes :rewrite)

Theorem: cst-program-item-conc1-of-tree-fix-cst

(defthm cst-program-item-conc1-of-tree-fix-cst
  (equal (cst-program-item-conc1 (abnf::tree-fix abnf::cst))
         (cst-program-item-conc1 abnf::cst)))

Theorem: cst-program-item-conc1-tree-equiv-congruence-on-cst

(defthm cst-program-item-conc1-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-program-item-conc1 abnf::cst)
                  (cst-program-item-conc1 cst-equiv)))
  :rule-classes :congruence)

Function: cst-program-item-conc2

(defun cst-program-item-conc2 (abnf::cst)
  (declare (xargs :guard (abnf::treep abnf::cst)))
  (declare
       (xargs :guard (and (cst-matchp abnf::cst "program-item")
                          (equal (cst-program-item-conc? abnf::cst)
                                 2))))
  (let ((__function__ 'cst-program-item-conc2))
    (declare (ignorable __function__))
    (abnf::tree-nonleaf->branches abnf::cst)))

Theorem: tree-list-listp-of-cst-program-item-conc2

(defthm tree-list-listp-of-cst-program-item-conc2
  (b* ((abnf::cstss (cst-program-item-conc2 abnf::cst)))
    (abnf::tree-list-listp abnf::cstss))
  :rule-classes :rewrite)

Theorem: cst-program-item-conc2-match

(defthm cst-program-item-conc2-match
 (implies
    (and (cst-matchp abnf::cst "program-item")
         (equal (cst-program-item-conc? abnf::cst)
                2))
    (b* ((abnf::cstss (cst-program-item-conc2 abnf::cst)))
      (cst-list-list-conc-matchp abnf::cstss "struct-declaration")))
 :rule-classes :rewrite)

Theorem: cst-program-item-conc2-of-tree-fix-cst

(defthm cst-program-item-conc2-of-tree-fix-cst
  (equal (cst-program-item-conc2 (abnf::tree-fix abnf::cst))
         (cst-program-item-conc2 abnf::cst)))

Theorem: cst-program-item-conc2-tree-equiv-congruence-on-cst

(defthm cst-program-item-conc2-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-program-item-conc2 abnf::cst)
                  (cst-program-item-conc2 cst-equiv)))
  :rule-classes :congruence)

Function: cst-program-item-conc3

(defun cst-program-item-conc3 (abnf::cst)
  (declare (xargs :guard (abnf::treep abnf::cst)))
  (declare
       (xargs :guard (and (cst-matchp abnf::cst "program-item")
                          (equal (cst-program-item-conc? abnf::cst)
                                 3))))
  (let ((__function__ 'cst-program-item-conc3))
    (declare (ignorable __function__))
    (abnf::tree-nonleaf->branches abnf::cst)))

Theorem: tree-list-listp-of-cst-program-item-conc3

(defthm tree-list-listp-of-cst-program-item-conc3
  (b* ((abnf::cstss (cst-program-item-conc3 abnf::cst)))
    (abnf::tree-list-listp abnf::cstss))
  :rule-classes :rewrite)

Theorem: cst-program-item-conc3-match

(defthm cst-program-item-conc3-match
 (implies
    (and (cst-matchp abnf::cst "program-item")
         (equal (cst-program-item-conc? abnf::cst)
                3))
    (b* ((abnf::cstss (cst-program-item-conc3 abnf::cst)))
      (cst-list-list-conc-matchp abnf::cstss "record-declaration")))
 :rule-classes :rewrite)

Theorem: cst-program-item-conc3-of-tree-fix-cst

(defthm cst-program-item-conc3-of-tree-fix-cst
  (equal (cst-program-item-conc3 (abnf::tree-fix abnf::cst))
         (cst-program-item-conc3 abnf::cst)))

Theorem: cst-program-item-conc3-tree-equiv-congruence-on-cst

(defthm cst-program-item-conc3-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-program-item-conc3 abnf::cst)
                  (cst-program-item-conc3 cst-equiv)))
  :rule-classes :congruence)

Function: cst-program-item-conc4

(defun cst-program-item-conc4 (abnf::cst)
  (declare (xargs :guard (abnf::treep abnf::cst)))
  (declare
       (xargs :guard (and (cst-matchp abnf::cst "program-item")
                          (equal (cst-program-item-conc? abnf::cst)
                                 4))))
  (let ((__function__ 'cst-program-item-conc4))
    (declare (ignorable __function__))
    (abnf::tree-nonleaf->branches abnf::cst)))

Theorem: tree-list-listp-of-cst-program-item-conc4

(defthm tree-list-listp-of-cst-program-item-conc4
  (b* ((abnf::cstss (cst-program-item-conc4 abnf::cst)))
    (abnf::tree-list-listp abnf::cstss))
  :rule-classes :rewrite)

Theorem: cst-program-item-conc4-match

(defthm cst-program-item-conc4-match
 (implies
   (and (cst-matchp abnf::cst "program-item")
        (equal (cst-program-item-conc? abnf::cst)
               4))
   (b* ((abnf::cstss (cst-program-item-conc4 abnf::cst)))
     (cst-list-list-conc-matchp abnf::cstss "mapping-declaration")))
 :rule-classes :rewrite)

Theorem: cst-program-item-conc4-of-tree-fix-cst

(defthm cst-program-item-conc4-of-tree-fix-cst
  (equal (cst-program-item-conc4 (abnf::tree-fix abnf::cst))
         (cst-program-item-conc4 abnf::cst)))

Theorem: cst-program-item-conc4-tree-equiv-congruence-on-cst

(defthm cst-program-item-conc4-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-program-item-conc4 abnf::cst)
                  (cst-program-item-conc4 cst-equiv)))
  :rule-classes :congruence)

Function: cst-program-item-conc5

(defun cst-program-item-conc5 (abnf::cst)
  (declare (xargs :guard (abnf::treep abnf::cst)))
  (declare
       (xargs :guard (and (cst-matchp abnf::cst "program-item")
                          (equal (cst-program-item-conc? abnf::cst)
                                 5))))
  (let ((__function__ 'cst-program-item-conc5))
    (declare (ignorable __function__))
    (abnf::tree-nonleaf->branches abnf::cst)))

Theorem: tree-list-listp-of-cst-program-item-conc5

(defthm tree-list-listp-of-cst-program-item-conc5
  (b* ((abnf::cstss (cst-program-item-conc5 abnf::cst)))
    (abnf::tree-list-listp abnf::cstss))
  :rule-classes :rewrite)

Theorem: cst-program-item-conc5-match

(defthm cst-program-item-conc5-match
 (implies
  (and (cst-matchp abnf::cst "program-item")
       (equal (cst-program-item-conc? abnf::cst)
              5))
  (b* ((abnf::cstss (cst-program-item-conc5 abnf::cst)))
    (cst-list-list-conc-matchp abnf::cstss "constant-declaration")))
 :rule-classes :rewrite)

Theorem: cst-program-item-conc5-of-tree-fix-cst

(defthm cst-program-item-conc5-of-tree-fix-cst
  (equal (cst-program-item-conc5 (abnf::tree-fix abnf::cst))
         (cst-program-item-conc5 abnf::cst)))

Theorem: cst-program-item-conc5-tree-equiv-congruence-on-cst

(defthm cst-program-item-conc5-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-program-item-conc5 abnf::cst)
                  (cst-program-item-conc5 cst-equiv)))
  :rule-classes :congruence)

Function: cst-program-declaration-conc

(defun cst-program-declaration-conc (abnf::cst)
  (declare (xargs :guard (abnf::treep abnf::cst)))
  (declare
       (xargs :guard (cst-matchp abnf::cst "program-declaration")))
  (let ((__function__ 'cst-program-declaration-conc))
    (declare (ignorable __function__))
    (abnf::tree-nonleaf->branches abnf::cst)))

Theorem: tree-list-listp-of-cst-program-declaration-conc

(defthm tree-list-listp-of-cst-program-declaration-conc
  (b* ((abnf::cstss (cst-program-declaration-conc abnf::cst)))
    (abnf::tree-list-listp abnf::cstss))
  :rule-classes :rewrite)

Theorem: cst-program-declaration-conc-match

(defthm cst-program-declaration-conc-match
  (implies
       (cst-matchp abnf::cst "program-declaration")
       (b* ((abnf::cstss (cst-program-declaration-conc abnf::cst)))
         (cst-list-list-conc-matchp
              abnf::cstss
              "%s\"program\" program-id \"{\" *program-item \"}\"")))
  :rule-classes :rewrite)

Theorem: cst-program-declaration-conc-of-tree-fix-cst

(defthm cst-program-declaration-conc-of-tree-fix-cst
  (equal (cst-program-declaration-conc (abnf::tree-fix abnf::cst))
         (cst-program-declaration-conc abnf::cst)))

Theorem: cst-program-declaration-conc-tree-equiv-congruence-on-cst

(defthm cst-program-declaration-conc-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-program-declaration-conc abnf::cst)
                  (cst-program-declaration-conc cst-equiv)))
  :rule-classes :congruence)

Function: cst-import-declaration-conc

(defun cst-import-declaration-conc (abnf::cst)
  (declare (xargs :guard (abnf::treep abnf::cst)))
  (declare
       (xargs :guard (cst-matchp abnf::cst "import-declaration")))
  (let ((__function__ 'cst-import-declaration-conc))
    (declare (ignorable __function__))
    (abnf::tree-nonleaf->branches abnf::cst)))

Theorem: tree-list-listp-of-cst-import-declaration-conc

(defthm tree-list-listp-of-cst-import-declaration-conc
  (b* ((abnf::cstss (cst-import-declaration-conc abnf::cst)))
    (abnf::tree-list-listp abnf::cstss))
  :rule-classes :rewrite)

Theorem: cst-import-declaration-conc-match

(defthm cst-import-declaration-conc-match
  (implies
       (cst-matchp abnf::cst "import-declaration")
       (b* ((abnf::cstss (cst-import-declaration-conc abnf::cst)))
         (cst-list-list-conc-matchp abnf::cstss
                                    "%s\"import\" program-id \";\"")))
  :rule-classes :rewrite)

Theorem: cst-import-declaration-conc-of-tree-fix-cst

(defthm cst-import-declaration-conc-of-tree-fix-cst
  (equal (cst-import-declaration-conc (abnf::tree-fix abnf::cst))
         (cst-import-declaration-conc abnf::cst)))

Theorem: cst-import-declaration-conc-tree-equiv-congruence-on-cst

(defthm cst-import-declaration-conc-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-import-declaration-conc abnf::cst)
                  (cst-import-declaration-conc cst-equiv)))
  :rule-classes :congruence)

Function: cst-file-conc

(defun cst-file-conc (abnf::cst)
  (declare (xargs :guard (abnf::treep abnf::cst)))
  (declare (xargs :guard (cst-matchp abnf::cst "file")))
  (let ((__function__ 'cst-file-conc))
    (declare (ignorable __function__))
    (abnf::tree-nonleaf->branches abnf::cst)))

Theorem: tree-list-listp-of-cst-file-conc

(defthm tree-list-listp-of-cst-file-conc
  (b* ((abnf::cstss (cst-file-conc abnf::cst)))
    (abnf::tree-list-listp abnf::cstss))
  :rule-classes :rewrite)

Theorem: cst-file-conc-match

(defthm cst-file-conc-match
  (implies (cst-matchp abnf::cst "file")
           (b* ((abnf::cstss (cst-file-conc abnf::cst)))
             (cst-list-list-conc-matchp
                  abnf::cstss
                  "*import-declaration program-declaration")))
  :rule-classes :rewrite)

Theorem: cst-file-conc-of-tree-fix-cst

(defthm cst-file-conc-of-tree-fix-cst
  (equal (cst-file-conc (abnf::tree-fix abnf::cst))
         (cst-file-conc abnf::cst)))

Theorem: cst-file-conc-tree-equiv-congruence-on-cst

(defthm cst-file-conc-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-file-conc abnf::cst)
                  (cst-file-conc cst-equiv)))
  :rule-classes :congruence)

Function: cst-ascii-conc-rep

(defun cst-ascii-conc-rep (abnf::cst)
  (declare (xargs :guard (abnf::treep abnf::cst)))
  (declare (xargs :guard (cst-matchp abnf::cst "ascii")))
  (let ((__function__ 'cst-ascii-conc-rep))
    (declare (ignorable __function__))
    (abnf::tree-list-fix (nth 0 (cst-ascii-conc abnf::cst)))))

Theorem: tree-listp-of-cst-ascii-conc-rep

(defthm tree-listp-of-cst-ascii-conc-rep
  (b* ((abnf::csts (cst-ascii-conc-rep abnf::cst)))
    (abnf::tree-listp abnf::csts))
  :rule-classes :rewrite)

Theorem: cst-ascii-conc-rep-match

(defthm cst-ascii-conc-rep-match
  (implies (cst-matchp abnf::cst "ascii")
           (b* ((abnf::csts (cst-ascii-conc-rep abnf::cst)))
             (cst-list-rep-matchp abnf::csts "%x0-7F")))
  :rule-classes :rewrite)

Theorem: cst-ascii-conc-rep-of-tree-fix-cst

(defthm cst-ascii-conc-rep-of-tree-fix-cst
  (equal (cst-ascii-conc-rep (abnf::tree-fix abnf::cst))
         (cst-ascii-conc-rep abnf::cst)))

Theorem: cst-ascii-conc-rep-tree-equiv-congruence-on-cst

(defthm cst-ascii-conc-rep-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-ascii-conc-rep abnf::cst)
                  (cst-ascii-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 "ascii")))
  :rule-classes :rewrite)

Theorem: cst-character-conc1-rep-of-tree-fix-cst

(defthm cst-character-conc1-rep-of-tree-fix-cst
  (equal (cst-character-conc1-rep (abnf::tree-fix abnf::cst))
         (cst-character-conc1-rep abnf::cst)))

Theorem: cst-character-conc1-rep-tree-equiv-congruence-on-cst

(defthm cst-character-conc1-rep-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-character-conc1-rep abnf::cst)
                  (cst-character-conc1-rep cst-equiv)))
  :rule-classes :congruence)

Function: cst-character-conc2-rep

(defun cst-character-conc2-rep (abnf::cst)
  (declare (xargs :guard (abnf::treep abnf::cst)))
  (declare (xargs :guard (and (cst-matchp abnf::cst "character")
                              (equal (cst-character-conc? abnf::cst)
                                     2))))
  (let ((__function__ 'cst-character-conc2-rep))
    (declare (ignorable __function__))
    (abnf::tree-list-fix (nth 0 (cst-character-conc2 abnf::cst)))))

Theorem: tree-listp-of-cst-character-conc2-rep

(defthm tree-listp-of-cst-character-conc2-rep
  (b* ((abnf::csts (cst-character-conc2-rep abnf::cst)))
    (abnf::tree-listp abnf::csts))
  :rule-classes :rewrite)

Theorem: cst-character-conc2-rep-match

(defthm cst-character-conc2-rep-match
  (implies (and (cst-matchp abnf::cst "character")
                (equal (cst-character-conc? abnf::cst)
                       2))
           (b* ((abnf::csts (cst-character-conc2-rep abnf::cst)))
             (cst-list-rep-matchp abnf::csts "safe-nonascii")))
  :rule-classes :rewrite)

Theorem: cst-character-conc2-rep-of-tree-fix-cst

(defthm cst-character-conc2-rep-of-tree-fix-cst
  (equal (cst-character-conc2-rep (abnf::tree-fix abnf::cst))
         (cst-character-conc2-rep abnf::cst)))

Theorem: cst-character-conc2-rep-tree-equiv-congruence-on-cst

(defthm cst-character-conc2-rep-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-character-conc2-rep abnf::cst)
                  (cst-character-conc2-rep cst-equiv)))
  :rule-classes :congruence)

Function: cst-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-whitespace-conc1-rep

(defun cst-whitespace-conc1-rep (abnf::cst)
 (declare (xargs :guard (abnf::treep abnf::cst)))
 (declare (xargs :guard (and (cst-matchp abnf::cst "whitespace")
                             (equal (cst-whitespace-conc? abnf::cst)
                                    1))))
 (let ((__function__ 'cst-whitespace-conc1-rep))
   (declare (ignorable __function__))
   (abnf::tree-list-fix (nth 0 (cst-whitespace-conc1 abnf::cst)))))

Theorem: tree-listp-of-cst-whitespace-conc1-rep

(defthm tree-listp-of-cst-whitespace-conc1-rep
  (b* ((abnf::csts (cst-whitespace-conc1-rep abnf::cst)))
    (abnf::tree-listp abnf::csts))
  :rule-classes :rewrite)

Theorem: cst-whitespace-conc1-rep-match

(defthm cst-whitespace-conc1-rep-match
  (implies (and (cst-matchp abnf::cst "whitespace")
                (equal (cst-whitespace-conc? abnf::cst)
                       1))
           (b* ((abnf::csts (cst-whitespace-conc1-rep abnf::cst)))
             (cst-list-rep-matchp abnf::csts "space")))
  :rule-classes :rewrite)

Theorem: cst-whitespace-conc1-rep-of-tree-fix-cst

(defthm cst-whitespace-conc1-rep-of-tree-fix-cst
  (equal (cst-whitespace-conc1-rep (abnf::tree-fix abnf::cst))
         (cst-whitespace-conc1-rep abnf::cst)))

Theorem: cst-whitespace-conc1-rep-tree-equiv-congruence-on-cst

(defthm cst-whitespace-conc1-rep-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-whitespace-conc1-rep abnf::cst)
                  (cst-whitespace-conc1-rep cst-equiv)))
  :rule-classes :congruence)

Function: cst-whitespace-conc2-rep

(defun cst-whitespace-conc2-rep (abnf::cst)
 (declare (xargs :guard (abnf::treep abnf::cst)))
 (declare (xargs :guard (and (cst-matchp abnf::cst "whitespace")
                             (equal (cst-whitespace-conc? abnf::cst)
                                    2))))
 (let ((__function__ 'cst-whitespace-conc2-rep))
   (declare (ignorable __function__))
   (abnf::tree-list-fix (nth 0 (cst-whitespace-conc2 abnf::cst)))))

Theorem: tree-listp-of-cst-whitespace-conc2-rep

(defthm tree-listp-of-cst-whitespace-conc2-rep
  (b* ((abnf::csts (cst-whitespace-conc2-rep abnf::cst)))
    (abnf::tree-listp abnf::csts))
  :rule-classes :rewrite)

Theorem: cst-whitespace-conc2-rep-match

(defthm cst-whitespace-conc2-rep-match
  (implies (and (cst-matchp abnf::cst "whitespace")
                (equal (cst-whitespace-conc? abnf::cst)
                       2))
           (b* ((abnf::csts (cst-whitespace-conc2-rep abnf::cst)))
             (cst-list-rep-matchp abnf::csts "horizontal-tab")))
  :rule-classes :rewrite)

Theorem: cst-whitespace-conc2-rep-of-tree-fix-cst

(defthm cst-whitespace-conc2-rep-of-tree-fix-cst
  (equal (cst-whitespace-conc2-rep (abnf::tree-fix abnf::cst))
         (cst-whitespace-conc2-rep abnf::cst)))

Theorem: cst-whitespace-conc2-rep-tree-equiv-congruence-on-cst

(defthm cst-whitespace-conc2-rep-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-whitespace-conc2-rep abnf::cst)
                  (cst-whitespace-conc2-rep cst-equiv)))
  :rule-classes :congruence)

Function: cst-whitespace-conc3-rep

(defun cst-whitespace-conc3-rep (abnf::cst)
 (declare (xargs :guard (abnf::treep abnf::cst)))
 (declare (xargs :guard (and (cst-matchp abnf::cst "whitespace")
                             (equal (cst-whitespace-conc? abnf::cst)
                                    3))))
 (let ((__function__ 'cst-whitespace-conc3-rep))
   (declare (ignorable __function__))
   (abnf::tree-list-fix (nth 0 (cst-whitespace-conc3 abnf::cst)))))

Theorem: tree-listp-of-cst-whitespace-conc3-rep

(defthm tree-listp-of-cst-whitespace-conc3-rep
  (b* ((abnf::csts (cst-whitespace-conc3-rep abnf::cst)))
    (abnf::tree-listp abnf::csts))
  :rule-classes :rewrite)

Theorem: cst-whitespace-conc3-rep-match

(defthm cst-whitespace-conc3-rep-match
  (implies (and (cst-matchp abnf::cst "whitespace")
                (equal (cst-whitespace-conc? abnf::cst)
                       3))
           (b* ((abnf::csts (cst-whitespace-conc3-rep abnf::cst)))
             (cst-list-rep-matchp abnf::csts "form-feed")))
  :rule-classes :rewrite)

Theorem: cst-whitespace-conc3-rep-of-tree-fix-cst

(defthm cst-whitespace-conc3-rep-of-tree-fix-cst
  (equal (cst-whitespace-conc3-rep (abnf::tree-fix abnf::cst))
         (cst-whitespace-conc3-rep abnf::cst)))

Theorem: cst-whitespace-conc3-rep-tree-equiv-congruence-on-cst

(defthm cst-whitespace-conc3-rep-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-whitespace-conc3-rep abnf::cst)
                  (cst-whitespace-conc3-rep cst-equiv)))
  :rule-classes :congruence)

Function: cst-whitespace-conc4-rep

(defun cst-whitespace-conc4-rep (abnf::cst)
 (declare (xargs :guard (abnf::treep abnf::cst)))
 (declare (xargs :guard (and (cst-matchp abnf::cst "whitespace")
                             (equal (cst-whitespace-conc? abnf::cst)
                                    4))))
 (let ((__function__ 'cst-whitespace-conc4-rep))
   (declare (ignorable __function__))
   (abnf::tree-list-fix (nth 0 (cst-whitespace-conc4 abnf::cst)))))

Theorem: tree-listp-of-cst-whitespace-conc4-rep

(defthm tree-listp-of-cst-whitespace-conc4-rep
  (b* ((abnf::csts (cst-whitespace-conc4-rep abnf::cst)))
    (abnf::tree-listp abnf::csts))
  :rule-classes :rewrite)

Theorem: cst-whitespace-conc4-rep-match

(defthm cst-whitespace-conc4-rep-match
  (implies (and (cst-matchp abnf::cst "whitespace")
                (equal (cst-whitespace-conc? abnf::cst)
                       4))
           (b* ((abnf::csts (cst-whitespace-conc4-rep abnf::cst)))
             (cst-list-rep-matchp abnf::csts "line-terminator")))
  :rule-classes :rewrite)

Theorem: cst-whitespace-conc4-rep-of-tree-fix-cst

(defthm cst-whitespace-conc4-rep-of-tree-fix-cst
  (equal (cst-whitespace-conc4-rep (abnf::tree-fix abnf::cst))
         (cst-whitespace-conc4-rep abnf::cst)))

Theorem: cst-whitespace-conc4-rep-tree-equiv-congruence-on-cst

(defthm cst-whitespace-conc4-rep-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-whitespace-conc4-rep abnf::cst)
                  (cst-whitespace-conc4-rep cst-equiv)))
  :rule-classes :congruence)

Function: cst-whitespace-conc5-rep

(defun cst-whitespace-conc5-rep (abnf::cst)
 (declare (xargs :guard (abnf::treep abnf::cst)))
 (declare (xargs :guard (and (cst-matchp abnf::cst "whitespace")
                             (equal (cst-whitespace-conc? abnf::cst)
                                    5))))
 (let ((__function__ 'cst-whitespace-conc5-rep))
   (declare (ignorable __function__))
   (abnf::tree-list-fix (nth 0 (cst-whitespace-conc5 abnf::cst)))))

Theorem: tree-listp-of-cst-whitespace-conc5-rep

(defthm tree-listp-of-cst-whitespace-conc5-rep
  (b* ((abnf::csts (cst-whitespace-conc5-rep abnf::cst)))
    (abnf::tree-listp abnf::csts))
  :rule-classes :rewrite)

Theorem: cst-whitespace-conc5-rep-match

(defthm cst-whitespace-conc5-rep-match
  (implies (and (cst-matchp abnf::cst "whitespace")
                (equal (cst-whitespace-conc? abnf::cst)
                       5))
           (b* ((abnf::csts (cst-whitespace-conc5-rep abnf::cst)))
             (cst-list-rep-matchp abnf::csts "carriage-return")))
  :rule-classes :rewrite)

Theorem: cst-whitespace-conc5-rep-of-tree-fix-cst

(defthm cst-whitespace-conc5-rep-of-tree-fix-cst
  (equal (cst-whitespace-conc5-rep (abnf::tree-fix abnf::cst))
         (cst-whitespace-conc5-rep abnf::cst)))

Theorem: cst-whitespace-conc5-rep-tree-equiv-congruence-on-cst

(defthm cst-whitespace-conc5-rep-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-whitespace-conc5-rep abnf::cst)
                  (cst-whitespace-conc5-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-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-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-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-binary-digit-conc-rep

(defun cst-binary-digit-conc-rep (abnf::cst)
 (declare (xargs :guard (abnf::treep abnf::cst)))
 (declare (xargs :guard (cst-matchp abnf::cst "binary-digit")))
 (let ((__function__ 'cst-binary-digit-conc-rep))
   (declare (ignorable __function__))
   (abnf::tree-list-fix (nth 0 (cst-binary-digit-conc abnf::cst)))))

Theorem: tree-listp-of-cst-binary-digit-conc-rep

(defthm tree-listp-of-cst-binary-digit-conc-rep
  (b* ((abnf::csts (cst-binary-digit-conc-rep abnf::cst)))
    (abnf::tree-listp abnf::csts))
  :rule-classes :rewrite)

Theorem: cst-binary-digit-conc-rep-match

(defthm cst-binary-digit-conc-rep-match
  (implies (cst-matchp abnf::cst "binary-digit")
           (b* ((abnf::csts (cst-binary-digit-conc-rep abnf::cst)))
             (cst-list-rep-matchp abnf::csts "%x30-31")))
  :rule-classes :rewrite)

Theorem: cst-binary-digit-conc-rep-of-tree-fix-cst

(defthm cst-binary-digit-conc-rep-of-tree-fix-cst
  (equal (cst-binary-digit-conc-rep (abnf::tree-fix abnf::cst))
         (cst-binary-digit-conc-rep abnf::cst)))

Theorem: cst-binary-digit-conc-rep-tree-equiv-congruence-on-cst

(defthm cst-binary-digit-conc-rep-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-binary-digit-conc-rep abnf::cst)
                  (cst-binary-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-decimal-digit-conc-rep

(defun cst-decimal-digit-conc-rep (abnf::cst)
 (declare (xargs :guard (abnf::treep abnf::cst)))
 (declare (xargs :guard (cst-matchp abnf::cst "decimal-digit")))
 (let ((__function__ 'cst-decimal-digit-conc-rep))
  (declare (ignorable __function__))
  (abnf::tree-list-fix (nth 0 (cst-decimal-digit-conc abnf::cst)))))

Theorem: tree-listp-of-cst-decimal-digit-conc-rep

(defthm tree-listp-of-cst-decimal-digit-conc-rep
  (b* ((abnf::csts (cst-decimal-digit-conc-rep abnf::cst)))
    (abnf::tree-listp abnf::csts))
  :rule-classes :rewrite)

Theorem: cst-decimal-digit-conc-rep-match

(defthm cst-decimal-digit-conc-rep-match
  (implies (cst-matchp abnf::cst "decimal-digit")
           (b* ((abnf::csts (cst-decimal-digit-conc-rep abnf::cst)))
             (cst-list-rep-matchp abnf::csts "%x30-39")))
  :rule-classes :rewrite)

Theorem: cst-decimal-digit-conc-rep-of-tree-fix-cst

(defthm cst-decimal-digit-conc-rep-of-tree-fix-cst
  (equal (cst-decimal-digit-conc-rep (abnf::tree-fix abnf::cst))
         (cst-decimal-digit-conc-rep abnf::cst)))

Theorem: cst-decimal-digit-conc-rep-tree-equiv-congruence-on-cst

(defthm cst-decimal-digit-conc-rep-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-decimal-digit-conc-rep abnf::cst)
                  (cst-decimal-digit-conc-rep cst-equiv)))
  :rule-classes :congruence)

Function: cst-nonzero-decimal-digit-conc-rep

(defun cst-nonzero-decimal-digit-conc-rep (abnf::cst)
 (declare (xargs :guard (abnf::treep abnf::cst)))
 (declare
      (xargs :guard (cst-matchp abnf::cst "nonzero-decimal-digit")))
 (let ((__function__ 'cst-nonzero-decimal-digit-conc-rep))
   (declare (ignorable __function__))
   (abnf::tree-list-fix
        (nth 0
             (cst-nonzero-decimal-digit-conc abnf::cst)))))

Theorem: tree-listp-of-cst-nonzero-decimal-digit-conc-rep

(defthm tree-listp-of-cst-nonzero-decimal-digit-conc-rep
  (b* ((abnf::csts (cst-nonzero-decimal-digit-conc-rep abnf::cst)))
    (abnf::tree-listp abnf::csts))
  :rule-classes :rewrite)

Theorem: cst-nonzero-decimal-digit-conc-rep-match

(defthm cst-nonzero-decimal-digit-conc-rep-match
 (implies
   (cst-matchp abnf::cst "nonzero-decimal-digit")
   (b* ((abnf::csts (cst-nonzero-decimal-digit-conc-rep abnf::cst)))
     (cst-list-rep-matchp abnf::csts "%x31-39")))
 :rule-classes :rewrite)

Theorem: cst-nonzero-decimal-digit-conc-rep-of-tree-fix-cst

(defthm cst-nonzero-decimal-digit-conc-rep-of-tree-fix-cst
 (equal
     (cst-nonzero-decimal-digit-conc-rep (abnf::tree-fix abnf::cst))
     (cst-nonzero-decimal-digit-conc-rep abnf::cst)))

Theorem: cst-nonzero-decimal-digit-conc-rep-tree-equiv-congruence-on-cst

(defthm
    cst-nonzero-decimal-digit-conc-rep-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-nonzero-decimal-digit-conc-rep abnf::cst)
                  (cst-nonzero-decimal-digit-conc-rep cst-equiv)))
  :rule-classes :congruence)

Function: cst-numeral-conc1-rep

(defun cst-numeral-conc1-rep (abnf::cst)
  (declare (xargs :guard (abnf::treep abnf::cst)))
  (declare (xargs :guard (and (cst-matchp abnf::cst "numeral")
                              (equal (cst-numeral-conc? abnf::cst)
                                     1))))
  (let ((__function__ 'cst-numeral-conc1-rep))
    (declare (ignorable __function__))
    (abnf::tree-list-fix (nth 0 (cst-numeral-conc1 abnf::cst)))))

Theorem: tree-listp-of-cst-numeral-conc1-rep

(defthm tree-listp-of-cst-numeral-conc1-rep
  (b* ((abnf::csts (cst-numeral-conc1-rep abnf::cst)))
    (abnf::tree-listp abnf::csts))
  :rule-classes :rewrite)

Theorem: cst-numeral-conc1-rep-match

(defthm cst-numeral-conc1-rep-match
  (implies (and (cst-matchp abnf::cst "numeral")
                (equal (cst-numeral-conc? abnf::cst) 1))
           (b* ((abnf::csts (cst-numeral-conc1-rep abnf::cst)))
             (cst-list-rep-matchp abnf::csts "binary-numeral")))
  :rule-classes :rewrite)

Theorem: cst-numeral-conc1-rep-of-tree-fix-cst

(defthm cst-numeral-conc1-rep-of-tree-fix-cst
  (equal (cst-numeral-conc1-rep (abnf::tree-fix abnf::cst))
         (cst-numeral-conc1-rep abnf::cst)))

Theorem: cst-numeral-conc1-rep-tree-equiv-congruence-on-cst

(defthm cst-numeral-conc1-rep-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-numeral-conc1-rep abnf::cst)
                  (cst-numeral-conc1-rep cst-equiv)))
  :rule-classes :congruence)

Function: cst-numeral-conc2-rep

(defun cst-numeral-conc2-rep (abnf::cst)
  (declare (xargs :guard (abnf::treep abnf::cst)))
  (declare (xargs :guard (and (cst-matchp abnf::cst "numeral")
                              (equal (cst-numeral-conc? abnf::cst)
                                     2))))
  (let ((__function__ 'cst-numeral-conc2-rep))
    (declare (ignorable __function__))
    (abnf::tree-list-fix (nth 0 (cst-numeral-conc2 abnf::cst)))))

Theorem: tree-listp-of-cst-numeral-conc2-rep

(defthm tree-listp-of-cst-numeral-conc2-rep
  (b* ((abnf::csts (cst-numeral-conc2-rep abnf::cst)))
    (abnf::tree-listp abnf::csts))
  :rule-classes :rewrite)

Theorem: cst-numeral-conc2-rep-match

(defthm cst-numeral-conc2-rep-match
  (implies (and (cst-matchp abnf::cst "numeral")
                (equal (cst-numeral-conc? abnf::cst) 2))
           (b* ((abnf::csts (cst-numeral-conc2-rep abnf::cst)))
             (cst-list-rep-matchp abnf::csts "octal-numeral")))
  :rule-classes :rewrite)

Theorem: cst-numeral-conc2-rep-of-tree-fix-cst

(defthm cst-numeral-conc2-rep-of-tree-fix-cst
  (equal (cst-numeral-conc2-rep (abnf::tree-fix abnf::cst))
         (cst-numeral-conc2-rep abnf::cst)))

Theorem: cst-numeral-conc2-rep-tree-equiv-congruence-on-cst

(defthm cst-numeral-conc2-rep-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-numeral-conc2-rep abnf::cst)
                  (cst-numeral-conc2-rep cst-equiv)))
  :rule-classes :congruence)

Function: cst-numeral-conc3-rep

(defun cst-numeral-conc3-rep (abnf::cst)
  (declare (xargs :guard (abnf::treep abnf::cst)))
  (declare (xargs :guard (and (cst-matchp abnf::cst "numeral")
                              (equal (cst-numeral-conc? abnf::cst)
                                     3))))
  (let ((__function__ 'cst-numeral-conc3-rep))
    (declare (ignorable __function__))
    (abnf::tree-list-fix (nth 0 (cst-numeral-conc3 abnf::cst)))))

Theorem: tree-listp-of-cst-numeral-conc3-rep

(defthm tree-listp-of-cst-numeral-conc3-rep
  (b* ((abnf::csts (cst-numeral-conc3-rep abnf::cst)))
    (abnf::tree-listp abnf::csts))
  :rule-classes :rewrite)

Theorem: cst-numeral-conc3-rep-match

(defthm cst-numeral-conc3-rep-match
  (implies (and (cst-matchp abnf::cst "numeral")
                (equal (cst-numeral-conc? abnf::cst) 3))
           (b* ((abnf::csts (cst-numeral-conc3-rep abnf::cst)))
             (cst-list-rep-matchp abnf::csts "decimal-numeral")))
  :rule-classes :rewrite)

Theorem: cst-numeral-conc3-rep-of-tree-fix-cst

(defthm cst-numeral-conc3-rep-of-tree-fix-cst
  (equal (cst-numeral-conc3-rep (abnf::tree-fix abnf::cst))
         (cst-numeral-conc3-rep abnf::cst)))

Theorem: cst-numeral-conc3-rep-tree-equiv-congruence-on-cst

(defthm cst-numeral-conc3-rep-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-numeral-conc3-rep abnf::cst)
                  (cst-numeral-conc3-rep cst-equiv)))
  :rule-classes :congruence)

Function: cst-numeral-conc4-rep

(defun cst-numeral-conc4-rep (abnf::cst)
  (declare (xargs :guard (abnf::treep abnf::cst)))
  (declare (xargs :guard (and (cst-matchp abnf::cst "numeral")
                              (equal (cst-numeral-conc? abnf::cst)
                                     4))))
  (let ((__function__ 'cst-numeral-conc4-rep))
    (declare (ignorable __function__))
    (abnf::tree-list-fix (nth 0 (cst-numeral-conc4 abnf::cst)))))

Theorem: tree-listp-of-cst-numeral-conc4-rep

(defthm tree-listp-of-cst-numeral-conc4-rep
  (b* ((abnf::csts (cst-numeral-conc4-rep abnf::cst)))
    (abnf::tree-listp abnf::csts))
  :rule-classes :rewrite)

Theorem: cst-numeral-conc4-rep-match

(defthm cst-numeral-conc4-rep-match
 (implies (and (cst-matchp abnf::cst "numeral")
               (equal (cst-numeral-conc? abnf::cst) 4))
          (b* ((abnf::csts (cst-numeral-conc4-rep abnf::cst)))
            (cst-list-rep-matchp abnf::csts "hexadecimal-numeral")))
 :rule-classes :rewrite)

Theorem: cst-numeral-conc4-rep-of-tree-fix-cst

(defthm cst-numeral-conc4-rep-of-tree-fix-cst
  (equal (cst-numeral-conc4-rep (abnf::tree-fix abnf::cst))
         (cst-numeral-conc4-rep abnf::cst)))

Theorem: cst-numeral-conc4-rep-tree-equiv-congruence-on-cst

(defthm cst-numeral-conc4-rep-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-numeral-conc4-rep abnf::cst)
                  (cst-numeral-conc4-rep cst-equiv)))
  :rule-classes :congruence)

Function: cst-integer-literal-conc1-rep

(defun cst-integer-literal-conc1-rep (abnf::cst)
 (declare (xargs :guard (abnf::treep abnf::cst)))
 (declare
     (xargs :guard (and (cst-matchp abnf::cst "integer-literal")
                        (equal (cst-integer-literal-conc? abnf::cst)
                               1))))
 (let ((__function__ 'cst-integer-literal-conc1-rep))
   (declare (ignorable __function__))
   (abnf::tree-list-fix
        (nth 0
             (cst-integer-literal-conc1 abnf::cst)))))

Theorem: tree-listp-of-cst-integer-literal-conc1-rep

(defthm tree-listp-of-cst-integer-literal-conc1-rep
  (b* ((abnf::csts (cst-integer-literal-conc1-rep abnf::cst)))
    (abnf::tree-listp abnf::csts))
  :rule-classes :rewrite)

Theorem: cst-integer-literal-conc1-rep-match

(defthm cst-integer-literal-conc1-rep-match
  (implies
       (and (cst-matchp abnf::cst "integer-literal")
            (equal (cst-integer-literal-conc? abnf::cst)
                   1))
       (b* ((abnf::csts (cst-integer-literal-conc1-rep abnf::cst)))
         (cst-list-rep-matchp abnf::csts "unsigned-literal")))
  :rule-classes :rewrite)

Theorem: cst-integer-literal-conc1-rep-of-tree-fix-cst

(defthm cst-integer-literal-conc1-rep-of-tree-fix-cst
  (equal (cst-integer-literal-conc1-rep (abnf::tree-fix abnf::cst))
         (cst-integer-literal-conc1-rep abnf::cst)))

Theorem: cst-integer-literal-conc1-rep-tree-equiv-congruence-on-cst

(defthm cst-integer-literal-conc1-rep-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-integer-literal-conc1-rep abnf::cst)
                  (cst-integer-literal-conc1-rep cst-equiv)))
  :rule-classes :congruence)

Function: cst-integer-literal-conc2-rep

(defun cst-integer-literal-conc2-rep (abnf::cst)
 (declare (xargs :guard (abnf::treep abnf::cst)))
 (declare
     (xargs :guard (and (cst-matchp abnf::cst "integer-literal")
                        (equal (cst-integer-literal-conc? abnf::cst)
                               2))))
 (let ((__function__ 'cst-integer-literal-conc2-rep))
   (declare (ignorable __function__))
   (abnf::tree-list-fix
        (nth 0
             (cst-integer-literal-conc2 abnf::cst)))))

Theorem: tree-listp-of-cst-integer-literal-conc2-rep

(defthm tree-listp-of-cst-integer-literal-conc2-rep
  (b* ((abnf::csts (cst-integer-literal-conc2-rep abnf::cst)))
    (abnf::tree-listp abnf::csts))
  :rule-classes :rewrite)

Theorem: cst-integer-literal-conc2-rep-match

(defthm cst-integer-literal-conc2-rep-match
  (implies
       (and (cst-matchp abnf::cst "integer-literal")
            (equal (cst-integer-literal-conc? abnf::cst)
                   2))
       (b* ((abnf::csts (cst-integer-literal-conc2-rep abnf::cst)))
         (cst-list-rep-matchp abnf::csts "signed-literal")))
  :rule-classes :rewrite)

Theorem: cst-integer-literal-conc2-rep-of-tree-fix-cst

(defthm cst-integer-literal-conc2-rep-of-tree-fix-cst
  (equal (cst-integer-literal-conc2-rep (abnf::tree-fix abnf::cst))
         (cst-integer-literal-conc2-rep abnf::cst)))

Theorem: cst-integer-literal-conc2-rep-tree-equiv-congruence-on-cst

(defthm cst-integer-literal-conc2-rep-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-integer-literal-conc2-rep abnf::cst)
                  (cst-integer-literal-conc2-rep cst-equiv)))
  :rule-classes :congruence)

Function: cst-numeric-literal-conc1-rep

(defun cst-numeric-literal-conc1-rep (abnf::cst)
 (declare (xargs :guard (abnf::treep abnf::cst)))
 (declare
     (xargs :guard (and (cst-matchp abnf::cst "numeric-literal")
                        (equal (cst-numeric-literal-conc? abnf::cst)
                               1))))
 (let ((__function__ 'cst-numeric-literal-conc1-rep))
   (declare (ignorable __function__))
   (abnf::tree-list-fix
        (nth 0
             (cst-numeric-literal-conc1 abnf::cst)))))

Theorem: tree-listp-of-cst-numeric-literal-conc1-rep

(defthm tree-listp-of-cst-numeric-literal-conc1-rep
  (b* ((abnf::csts (cst-numeric-literal-conc1-rep abnf::cst)))
    (abnf::tree-listp abnf::csts))
  :rule-classes :rewrite)

Theorem: cst-numeric-literal-conc1-rep-match

(defthm cst-numeric-literal-conc1-rep-match
  (implies
       (and (cst-matchp abnf::cst "numeric-literal")
            (equal (cst-numeric-literal-conc? abnf::cst)
                   1))
       (b* ((abnf::csts (cst-numeric-literal-conc1-rep abnf::cst)))
         (cst-list-rep-matchp abnf::csts "integer-literal")))
  :rule-classes :rewrite)

Theorem: cst-numeric-literal-conc1-rep-of-tree-fix-cst

(defthm cst-numeric-literal-conc1-rep-of-tree-fix-cst
  (equal (cst-numeric-literal-conc1-rep (abnf::tree-fix abnf::cst))
         (cst-numeric-literal-conc1-rep abnf::cst)))

Theorem: cst-numeric-literal-conc1-rep-tree-equiv-congruence-on-cst

(defthm cst-numeric-literal-conc1-rep-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-numeric-literal-conc1-rep abnf::cst)
                  (cst-numeric-literal-conc1-rep cst-equiv)))
  :rule-classes :congruence)

Function: cst-numeric-literal-conc2-rep

(defun cst-numeric-literal-conc2-rep (abnf::cst)
 (declare (xargs :guard (abnf::treep abnf::cst)))
 (declare
     (xargs :guard (and (cst-matchp abnf::cst "numeric-literal")
                        (equal (cst-numeric-literal-conc? abnf::cst)
                               2))))
 (let ((__function__ 'cst-numeric-literal-conc2-rep))
   (declare (ignorable __function__))
   (abnf::tree-list-fix
        (nth 0
             (cst-numeric-literal-conc2 abnf::cst)))))

Theorem: tree-listp-of-cst-numeric-literal-conc2-rep

(defthm tree-listp-of-cst-numeric-literal-conc2-rep
  (b* ((abnf::csts (cst-numeric-literal-conc2-rep abnf::cst)))
    (abnf::tree-listp abnf::csts))
  :rule-classes :rewrite)

Theorem: cst-numeric-literal-conc2-rep-match

(defthm cst-numeric-literal-conc2-rep-match
  (implies
       (and (cst-matchp abnf::cst "numeric-literal")
            (equal (cst-numeric-literal-conc? abnf::cst)
                   2))
       (b* ((abnf::csts (cst-numeric-literal-conc2-rep abnf::cst)))
         (cst-list-rep-matchp abnf::csts "field-literal")))
  :rule-classes :rewrite)

Theorem: cst-numeric-literal-conc2-rep-of-tree-fix-cst

(defthm cst-numeric-literal-conc2-rep-of-tree-fix-cst
  (equal (cst-numeric-literal-conc2-rep (abnf::tree-fix abnf::cst))
         (cst-numeric-literal-conc2-rep abnf::cst)))

Theorem: cst-numeric-literal-conc2-rep-tree-equiv-congruence-on-cst

(defthm cst-numeric-literal-conc2-rep-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-numeric-literal-conc2-rep abnf::cst)
                  (cst-numeric-literal-conc2-rep cst-equiv)))
  :rule-classes :congruence)

Function: cst-numeric-literal-conc3-rep

(defun cst-numeric-literal-conc3-rep (abnf::cst)
 (declare (xargs :guard (abnf::treep abnf::cst)))
 (declare
     (xargs :guard (and (cst-matchp abnf::cst "numeric-literal")
                        (equal (cst-numeric-literal-conc? abnf::cst)
                               3))))
 (let ((__function__ 'cst-numeric-literal-conc3-rep))
   (declare (ignorable __function__))
   (abnf::tree-list-fix
        (nth 0
             (cst-numeric-literal-conc3 abnf::cst)))))

Theorem: tree-listp-of-cst-numeric-literal-conc3-rep

(defthm tree-listp-of-cst-numeric-literal-conc3-rep
  (b* ((abnf::csts (cst-numeric-literal-conc3-rep abnf::cst)))
    (abnf::tree-listp abnf::csts))
  :rule-classes :rewrite)

Theorem: cst-numeric-literal-conc3-rep-match

(defthm cst-numeric-literal-conc3-rep-match
  (implies
       (and (cst-matchp abnf::cst "numeric-literal")
            (equal (cst-numeric-literal-conc? abnf::cst)
                   3))
       (b* ((abnf::csts (cst-numeric-literal-conc3-rep abnf::cst)))
         (cst-list-rep-matchp abnf::csts "group-literal")))
  :rule-classes :rewrite)

Theorem: cst-numeric-literal-conc3-rep-of-tree-fix-cst

(defthm cst-numeric-literal-conc3-rep-of-tree-fix-cst
  (equal (cst-numeric-literal-conc3-rep (abnf::tree-fix abnf::cst))
         (cst-numeric-literal-conc3-rep abnf::cst)))

Theorem: cst-numeric-literal-conc3-rep-tree-equiv-congruence-on-cst

(defthm cst-numeric-literal-conc3-rep-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-numeric-literal-conc3-rep abnf::cst)
                  (cst-numeric-literal-conc3-rep cst-equiv)))
  :rule-classes :congruence)

Function: cst-numeric-literal-conc4-rep

(defun cst-numeric-literal-conc4-rep (abnf::cst)
 (declare (xargs :guard (abnf::treep abnf::cst)))
 (declare
     (xargs :guard (and (cst-matchp abnf::cst "numeric-literal")
                        (equal (cst-numeric-literal-conc? abnf::cst)
                               4))))
 (let ((__function__ 'cst-numeric-literal-conc4-rep))
   (declare (ignorable __function__))
   (abnf::tree-list-fix
        (nth 0
             (cst-numeric-literal-conc4 abnf::cst)))))

Theorem: tree-listp-of-cst-numeric-literal-conc4-rep

(defthm tree-listp-of-cst-numeric-literal-conc4-rep
  (b* ((abnf::csts (cst-numeric-literal-conc4-rep abnf::cst)))
    (abnf::tree-listp abnf::csts))
  :rule-classes :rewrite)

Theorem: cst-numeric-literal-conc4-rep-match

(defthm cst-numeric-literal-conc4-rep-match
  (implies
       (and (cst-matchp abnf::cst "numeric-literal")
            (equal (cst-numeric-literal-conc? abnf::cst)
                   4))
       (b* ((abnf::csts (cst-numeric-literal-conc4-rep abnf::cst)))
         (cst-list-rep-matchp abnf::csts "scalar-literal")))
  :rule-classes :rewrite)

Theorem: cst-numeric-literal-conc4-rep-of-tree-fix-cst

(defthm cst-numeric-literal-conc4-rep-of-tree-fix-cst
  (equal (cst-numeric-literal-conc4-rep (abnf::tree-fix abnf::cst))
         (cst-numeric-literal-conc4-rep abnf::cst)))

Theorem: cst-numeric-literal-conc4-rep-tree-equiv-congruence-on-cst

(defthm cst-numeric-literal-conc4-rep-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-numeric-literal-conc4-rep abnf::cst)
                  (cst-numeric-literal-conc4-rep cst-equiv)))
  :rule-classes :congruence)

Function: cst-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-string-character-conc1-rep

(defun cst-string-character-conc1-rep (abnf::cst)
 (declare (xargs :guard (abnf::treep abnf::cst)))
 (declare
    (xargs :guard (and (cst-matchp abnf::cst "string-character")
                       (equal (cst-string-character-conc? abnf::cst)
                              1))))
 (let ((__function__ 'cst-string-character-conc1-rep))
   (declare (ignorable __function__))
   (abnf::tree-list-fix
        (nth 0
             (cst-string-character-conc1 abnf::cst)))))

Theorem: tree-listp-of-cst-string-character-conc1-rep

(defthm tree-listp-of-cst-string-character-conc1-rep
  (b* ((abnf::csts (cst-string-character-conc1-rep abnf::cst)))
    (abnf::tree-listp abnf::csts))
  :rule-classes :rewrite)

Theorem: cst-string-character-conc1-rep-match

(defthm cst-string-character-conc1-rep-match
  (implies
       (and (cst-matchp abnf::cst "string-character")
            (equal (cst-string-character-conc? abnf::cst)
                   1))
       (b* ((abnf::csts (cst-string-character-conc1-rep abnf::cst)))
         (cst-list-rep-matchp abnf::csts
                              "not-double-quote-or-line-feed")))
  :rule-classes :rewrite)

Theorem: cst-string-character-conc1-rep-of-tree-fix-cst

(defthm cst-string-character-conc1-rep-of-tree-fix-cst
  (equal (cst-string-character-conc1-rep (abnf::tree-fix abnf::cst))
         (cst-string-character-conc1-rep abnf::cst)))

Theorem: cst-string-character-conc1-rep-tree-equiv-congruence-on-cst

(defthm cst-string-character-conc1-rep-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-string-character-conc1-rep abnf::cst)
                  (cst-string-character-conc1-rep cst-equiv)))
  :rule-classes :congruence)

Function: cst-string-character-conc2-rep

(defun cst-string-character-conc2-rep (abnf::cst)
 (declare (xargs :guard (abnf::treep abnf::cst)))
 (declare
    (xargs :guard (and (cst-matchp abnf::cst "string-character")
                       (equal (cst-string-character-conc? abnf::cst)
                              2))))
 (let ((__function__ 'cst-string-character-conc2-rep))
   (declare (ignorable __function__))
   (abnf::tree-list-fix
        (nth 0
             (cst-string-character-conc2 abnf::cst)))))

Theorem: tree-listp-of-cst-string-character-conc2-rep

(defthm tree-listp-of-cst-string-character-conc2-rep
  (b* ((abnf::csts (cst-string-character-conc2-rep abnf::cst)))
    (abnf::tree-listp abnf::csts))
  :rule-classes :rewrite)

Theorem: cst-string-character-conc2-rep-match

(defthm cst-string-character-conc2-rep-match
  (implies
       (and (cst-matchp abnf::cst "string-character")
            (equal (cst-string-character-conc? abnf::cst)
                   2))
       (b* ((abnf::csts (cst-string-character-conc2-rep abnf::cst)))
         (cst-list-rep-matchp abnf::csts "line-terminator")))
  :rule-classes :rewrite)

Theorem: cst-string-character-conc2-rep-of-tree-fix-cst

(defthm cst-string-character-conc2-rep-of-tree-fix-cst
  (equal (cst-string-character-conc2-rep (abnf::tree-fix abnf::cst))
         (cst-string-character-conc2-rep abnf::cst)))

Theorem: cst-string-character-conc2-rep-tree-equiv-congruence-on-cst

(defthm cst-string-character-conc2-rep-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-string-character-conc2-rep abnf::cst)
                  (cst-string-character-conc2-rep cst-equiv)))
  :rule-classes :congruence)

Function: cst-atomic-literal-conc1-rep

(defun cst-atomic-literal-conc1-rep (abnf::cst)
 (declare (xargs :guard (abnf::treep abnf::cst)))
 (declare
      (xargs :guard (and (cst-matchp abnf::cst "atomic-literal")
                         (equal (cst-atomic-literal-conc? abnf::cst)
                                1))))
 (let ((__function__ 'cst-atomic-literal-conc1-rep))
  (declare (ignorable __function__))
  (abnf::tree-list-fix (nth 0
                            (cst-atomic-literal-conc1 abnf::cst)))))

Theorem: tree-listp-of-cst-atomic-literal-conc1-rep

(defthm tree-listp-of-cst-atomic-literal-conc1-rep
  (b* ((abnf::csts (cst-atomic-literal-conc1-rep abnf::cst)))
    (abnf::tree-listp abnf::csts))
  :rule-classes :rewrite)

Theorem: cst-atomic-literal-conc1-rep-match

(defthm cst-atomic-literal-conc1-rep-match
  (implies
       (and (cst-matchp abnf::cst "atomic-literal")
            (equal (cst-atomic-literal-conc? abnf::cst)
                   1))
       (b* ((abnf::csts (cst-atomic-literal-conc1-rep abnf::cst)))
         (cst-list-rep-matchp abnf::csts "numeric-literal")))
  :rule-classes :rewrite)

Theorem: cst-atomic-literal-conc1-rep-of-tree-fix-cst

(defthm cst-atomic-literal-conc1-rep-of-tree-fix-cst
  (equal (cst-atomic-literal-conc1-rep (abnf::tree-fix abnf::cst))
         (cst-atomic-literal-conc1-rep abnf::cst)))

Theorem: cst-atomic-literal-conc1-rep-tree-equiv-congruence-on-cst

(defthm cst-atomic-literal-conc1-rep-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-atomic-literal-conc1-rep abnf::cst)
                  (cst-atomic-literal-conc1-rep cst-equiv)))
  :rule-classes :congruence)

Function: cst-atomic-literal-conc2-rep

(defun cst-atomic-literal-conc2-rep (abnf::cst)
 (declare (xargs :guard (abnf::treep abnf::cst)))
 (declare
      (xargs :guard (and (cst-matchp abnf::cst "atomic-literal")
                         (equal (cst-atomic-literal-conc? abnf::cst)
                                2))))
 (let ((__function__ 'cst-atomic-literal-conc2-rep))
  (declare (ignorable __function__))
  (abnf::tree-list-fix (nth 0
                            (cst-atomic-literal-conc2 abnf::cst)))))

Theorem: tree-listp-of-cst-atomic-literal-conc2-rep

(defthm tree-listp-of-cst-atomic-literal-conc2-rep
  (b* ((abnf::csts (cst-atomic-literal-conc2-rep abnf::cst)))
    (abnf::tree-listp abnf::csts))
  :rule-classes :rewrite)

Theorem: cst-atomic-literal-conc2-rep-match

(defthm cst-atomic-literal-conc2-rep-match
  (implies
       (and (cst-matchp abnf::cst "atomic-literal")
            (equal (cst-atomic-literal-conc? abnf::cst)
                   2))
       (b* ((abnf::csts (cst-atomic-literal-conc2-rep abnf::cst)))
         (cst-list-rep-matchp abnf::csts "boolean-literal")))
  :rule-classes :rewrite)

Theorem: cst-atomic-literal-conc2-rep-of-tree-fix-cst

(defthm cst-atomic-literal-conc2-rep-of-tree-fix-cst
  (equal (cst-atomic-literal-conc2-rep (abnf::tree-fix abnf::cst))
         (cst-atomic-literal-conc2-rep abnf::cst)))

Theorem: cst-atomic-literal-conc2-rep-tree-equiv-congruence-on-cst

(defthm cst-atomic-literal-conc2-rep-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-atomic-literal-conc2-rep abnf::cst)
                  (cst-atomic-literal-conc2-rep cst-equiv)))
  :rule-classes :congruence)

Function: cst-atomic-literal-conc3-rep

(defun cst-atomic-literal-conc3-rep (abnf::cst)
 (declare (xargs :guard (abnf::treep abnf::cst)))
 (declare
      (xargs :guard (and (cst-matchp abnf::cst "atomic-literal")
                         (equal (cst-atomic-literal-conc? abnf::cst)
                                3))))
 (let ((__function__ 'cst-atomic-literal-conc3-rep))
  (declare (ignorable __function__))
  (abnf::tree-list-fix (nth 0
                            (cst-atomic-literal-conc3 abnf::cst)))))

Theorem: tree-listp-of-cst-atomic-literal-conc3-rep

(defthm tree-listp-of-cst-atomic-literal-conc3-rep
  (b* ((abnf::csts (cst-atomic-literal-conc3-rep abnf::cst)))
    (abnf::tree-listp abnf::csts))
  :rule-classes :rewrite)

Theorem: cst-atomic-literal-conc3-rep-match

(defthm cst-atomic-literal-conc3-rep-match
 (implies
     (and (cst-matchp abnf::cst "atomic-literal")
          (equal (cst-atomic-literal-conc? abnf::cst)
                 3))
     (b* ((abnf::csts (cst-atomic-literal-conc3-rep abnf::cst)))
       (cst-list-rep-matchp abnf::csts "explicit-address-literal")))
 :rule-classes :rewrite)

Theorem: cst-atomic-literal-conc3-rep-of-tree-fix-cst

(defthm cst-atomic-literal-conc3-rep-of-tree-fix-cst
  (equal (cst-atomic-literal-conc3-rep (abnf::tree-fix abnf::cst))
         (cst-atomic-literal-conc3-rep abnf::cst)))

Theorem: cst-atomic-literal-conc3-rep-tree-equiv-congruence-on-cst

(defthm cst-atomic-literal-conc3-rep-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-atomic-literal-conc3-rep abnf::cst)
                  (cst-atomic-literal-conc3-rep cst-equiv)))
  :rule-classes :congruence)

Function: cst-atomic-literal-conc4-rep

(defun cst-atomic-literal-conc4-rep (abnf::cst)
 (declare (xargs :guard (abnf::treep abnf::cst)))
 (declare
      (xargs :guard (and (cst-matchp abnf::cst "atomic-literal")
                         (equal (cst-atomic-literal-conc? abnf::cst)
                                4))))
 (let ((__function__ 'cst-atomic-literal-conc4-rep))
  (declare (ignorable __function__))
  (abnf::tree-list-fix (nth 0
                            (cst-atomic-literal-conc4 abnf::cst)))))

Theorem: tree-listp-of-cst-atomic-literal-conc4-rep

(defthm tree-listp-of-cst-atomic-literal-conc4-rep
  (b* ((abnf::csts (cst-atomic-literal-conc4-rep abnf::cst)))
    (abnf::tree-listp abnf::csts))
  :rule-classes :rewrite)

Theorem: cst-atomic-literal-conc4-rep-match

(defthm cst-atomic-literal-conc4-rep-match
  (implies
       (and (cst-matchp abnf::cst "atomic-literal")
            (equal (cst-atomic-literal-conc? abnf::cst)
                   4))
       (b* ((abnf::csts (cst-atomic-literal-conc4-rep abnf::cst)))
         (cst-list-rep-matchp abnf::csts "string-literal")))
  :rule-classes :rewrite)

Theorem: cst-atomic-literal-conc4-rep-of-tree-fix-cst

(defthm cst-atomic-literal-conc4-rep-of-tree-fix-cst
  (equal (cst-atomic-literal-conc4-rep (abnf::tree-fix abnf::cst))
         (cst-atomic-literal-conc4-rep abnf::cst)))

Theorem: cst-atomic-literal-conc4-rep-tree-equiv-congruence-on-cst

(defthm cst-atomic-literal-conc4-rep-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-atomic-literal-conc4-rep abnf::cst)
                  (cst-atomic-literal-conc4-rep cst-equiv)))
  :rule-classes :congruence)

Function: cst-token-conc1-rep

(defun cst-token-conc1-rep (abnf::cst)
  (declare (xargs :guard (abnf::treep abnf::cst)))
  (declare
       (xargs :guard (and (cst-matchp abnf::cst "token")
                          (equal (cst-token-conc? abnf::cst) 1))))
  (let ((__function__ 'cst-token-conc1-rep))
    (declare (ignorable __function__))
    (abnf::tree-list-fix (nth 0 (cst-token-conc1 abnf::cst)))))

Theorem: tree-listp-of-cst-token-conc1-rep

(defthm tree-listp-of-cst-token-conc1-rep
  (b* ((abnf::csts (cst-token-conc1-rep abnf::cst)))
    (abnf::tree-listp abnf::csts))
  :rule-classes :rewrite)

Theorem: cst-token-conc1-rep-match

(defthm cst-token-conc1-rep-match
  (implies (and (cst-matchp abnf::cst "token")
                (equal (cst-token-conc? abnf::cst) 1))
           (b* ((abnf::csts (cst-token-conc1-rep abnf::cst)))
             (cst-list-rep-matchp abnf::csts "keyword")))
  :rule-classes :rewrite)

Theorem: cst-token-conc1-rep-of-tree-fix-cst

(defthm cst-token-conc1-rep-of-tree-fix-cst
  (equal (cst-token-conc1-rep (abnf::tree-fix abnf::cst))
         (cst-token-conc1-rep abnf::cst)))

Theorem: cst-token-conc1-rep-tree-equiv-congruence-on-cst

(defthm cst-token-conc1-rep-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-token-conc1-rep abnf::cst)
                  (cst-token-conc1-rep cst-equiv)))
  :rule-classes :congruence)

Function: cst-token-conc2-rep

(defun cst-token-conc2-rep (abnf::cst)
  (declare (xargs :guard (abnf::treep abnf::cst)))
  (declare
       (xargs :guard (and (cst-matchp abnf::cst "token")
                          (equal (cst-token-conc? abnf::cst) 2))))
  (let ((__function__ 'cst-token-conc2-rep))
    (declare (ignorable __function__))
    (abnf::tree-list-fix (nth 0 (cst-token-conc2 abnf::cst)))))

Theorem: tree-listp-of-cst-token-conc2-rep

(defthm tree-listp-of-cst-token-conc2-rep
  (b* ((abnf::csts (cst-token-conc2-rep abnf::cst)))
    (abnf::tree-listp abnf::csts))
  :rule-classes :rewrite)

Theorem: cst-token-conc2-rep-match

(defthm cst-token-conc2-rep-match
  (implies (and (cst-matchp abnf::cst "token")
                (equal (cst-token-conc? abnf::cst) 2))
           (b* ((abnf::csts (cst-token-conc2-rep abnf::cst)))
             (cst-list-rep-matchp abnf::csts "identifier")))
  :rule-classes :rewrite)

Theorem: cst-token-conc2-rep-of-tree-fix-cst

(defthm cst-token-conc2-rep-of-tree-fix-cst
  (equal (cst-token-conc2-rep (abnf::tree-fix abnf::cst))
         (cst-token-conc2-rep abnf::cst)))

Theorem: cst-token-conc2-rep-tree-equiv-congruence-on-cst

(defthm cst-token-conc2-rep-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-token-conc2-rep abnf::cst)
                  (cst-token-conc2-rep cst-equiv)))
  :rule-classes :congruence)

Function: cst-token-conc3-rep

(defun cst-token-conc3-rep (abnf::cst)
  (declare (xargs :guard (abnf::treep abnf::cst)))
  (declare
       (xargs :guard (and (cst-matchp abnf::cst "token")
                          (equal (cst-token-conc? abnf::cst) 3))))
  (let ((__function__ 'cst-token-conc3-rep))
    (declare (ignorable __function__))
    (abnf::tree-list-fix (nth 0 (cst-token-conc3 abnf::cst)))))

Theorem: tree-listp-of-cst-token-conc3-rep

(defthm tree-listp-of-cst-token-conc3-rep
  (b* ((abnf::csts (cst-token-conc3-rep abnf::cst)))
    (abnf::tree-listp abnf::csts))
  :rule-classes :rewrite)

Theorem: cst-token-conc3-rep-match

(defthm cst-token-conc3-rep-match
  (implies (and (cst-matchp abnf::cst "token")
                (equal (cst-token-conc? abnf::cst) 3))
           (b* ((abnf::csts (cst-token-conc3-rep abnf::cst)))
             (cst-list-rep-matchp abnf::csts "atomic-literal")))
  :rule-classes :rewrite)

Theorem: cst-token-conc3-rep-of-tree-fix-cst

(defthm cst-token-conc3-rep-of-tree-fix-cst
  (equal (cst-token-conc3-rep (abnf::tree-fix abnf::cst))
         (cst-token-conc3-rep abnf::cst)))

Theorem: cst-token-conc3-rep-tree-equiv-congruence-on-cst

(defthm cst-token-conc3-rep-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-token-conc3-rep abnf::cst)
                  (cst-token-conc3-rep cst-equiv)))
  :rule-classes :congruence)

Function: cst-token-conc4-rep

(defun cst-token-conc4-rep (abnf::cst)
  (declare (xargs :guard (abnf::treep abnf::cst)))
  (declare
       (xargs :guard (and (cst-matchp abnf::cst "token")
                          (equal (cst-token-conc? abnf::cst) 4))))
  (let ((__function__ 'cst-token-conc4-rep))
    (declare (ignorable __function__))
    (abnf::tree-list-fix (nth 0 (cst-token-conc4 abnf::cst)))))

Theorem: tree-listp-of-cst-token-conc4-rep

(defthm tree-listp-of-cst-token-conc4-rep
  (b* ((abnf::csts (cst-token-conc4-rep abnf::cst)))
    (abnf::tree-listp abnf::csts))
  :rule-classes :rewrite)

Theorem: cst-token-conc4-rep-match

(defthm cst-token-conc4-rep-match
  (implies (and (cst-matchp abnf::cst "token")
                (equal (cst-token-conc? abnf::cst) 4))
           (b* ((abnf::csts (cst-token-conc4-rep abnf::cst)))
             (cst-list-rep-matchp abnf::csts "decimal-numeral")))
  :rule-classes :rewrite)

Theorem: cst-token-conc4-rep-of-tree-fix-cst

(defthm cst-token-conc4-rep-of-tree-fix-cst
  (equal (cst-token-conc4-rep (abnf::tree-fix abnf::cst))
         (cst-token-conc4-rep abnf::cst)))

Theorem: cst-token-conc4-rep-tree-equiv-congruence-on-cst

(defthm cst-token-conc4-rep-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-token-conc4-rep abnf::cst)
                  (cst-token-conc4-rep cst-equiv)))
  :rule-classes :congruence)

Function: cst-token-conc5-rep

(defun cst-token-conc5-rep (abnf::cst)
  (declare (xargs :guard (abnf::treep abnf::cst)))
  (declare
       (xargs :guard (and (cst-matchp abnf::cst "token")
                          (equal (cst-token-conc? abnf::cst) 5))))
  (let ((__function__ 'cst-token-conc5-rep))
    (declare (ignorable __function__))
    (abnf::tree-list-fix (nth 0 (cst-token-conc5 abnf::cst)))))

Theorem: tree-listp-of-cst-token-conc5-rep

(defthm tree-listp-of-cst-token-conc5-rep
  (b* ((abnf::csts (cst-token-conc5-rep abnf::cst)))
    (abnf::tree-listp abnf::csts))
  :rule-classes :rewrite)

Theorem: cst-token-conc5-rep-match

(defthm cst-token-conc5-rep-match
  (implies (and (cst-matchp abnf::cst "token")
                (equal (cst-token-conc? abnf::cst) 5))
           (b* ((abnf::csts (cst-token-conc5-rep abnf::cst)))
             (cst-list-rep-matchp abnf::csts "annotation")))
  :rule-classes :rewrite)

Theorem: cst-token-conc5-rep-of-tree-fix-cst

(defthm cst-token-conc5-rep-of-tree-fix-cst
  (equal (cst-token-conc5-rep (abnf::tree-fix abnf::cst))
         (cst-token-conc5-rep abnf::cst)))

Theorem: cst-token-conc5-rep-tree-equiv-congruence-on-cst

(defthm cst-token-conc5-rep-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-token-conc5-rep abnf::cst)
                  (cst-token-conc5-rep cst-equiv)))
  :rule-classes :congruence)

Function: cst-token-conc6-rep

(defun cst-token-conc6-rep (abnf::cst)
  (declare (xargs :guard (abnf::treep abnf::cst)))
  (declare
       (xargs :guard (and (cst-matchp abnf::cst "token")
                          (equal (cst-token-conc? abnf::cst) 6))))
  (let ((__function__ 'cst-token-conc6-rep))
    (declare (ignorable __function__))
    (abnf::tree-list-fix (nth 0 (cst-token-conc6 abnf::cst)))))

Theorem: tree-listp-of-cst-token-conc6-rep

(defthm tree-listp-of-cst-token-conc6-rep
  (b* ((abnf::csts (cst-token-conc6-rep abnf::cst)))
    (abnf::tree-listp abnf::csts))
  :rule-classes :rewrite)

Theorem: cst-token-conc6-rep-match

(defthm cst-token-conc6-rep-match
  (implies (and (cst-matchp abnf::cst "token")
                (equal (cst-token-conc? abnf::cst) 6))
           (b* ((abnf::csts (cst-token-conc6-rep abnf::cst)))
             (cst-list-rep-matchp abnf::csts "symbol")))
  :rule-classes :rewrite)

Theorem: cst-token-conc6-rep-of-tree-fix-cst

(defthm cst-token-conc6-rep-of-tree-fix-cst
  (equal (cst-token-conc6-rep (abnf::tree-fix abnf::cst))
         (cst-token-conc6-rep abnf::cst)))

Theorem: cst-token-conc6-rep-tree-equiv-congruence-on-cst

(defthm cst-token-conc6-rep-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-token-conc6-rep abnf::cst)
                  (cst-token-conc6-rep cst-equiv)))
  :rule-classes :congruence)

Function: cst-lexeme-conc1-rep

(defun cst-lexeme-conc1-rep (abnf::cst)
  (declare (xargs :guard (abnf::treep abnf::cst)))
  (declare (xargs :guard (and (cst-matchp abnf::cst "lexeme")
                              (equal (cst-lexeme-conc? abnf::cst)
                                     1))))
  (let ((__function__ 'cst-lexeme-conc1-rep))
    (declare (ignorable __function__))
    (abnf::tree-list-fix (nth 0 (cst-lexeme-conc1 abnf::cst)))))

Theorem: tree-listp-of-cst-lexeme-conc1-rep

(defthm tree-listp-of-cst-lexeme-conc1-rep
  (b* ((abnf::csts (cst-lexeme-conc1-rep abnf::cst)))
    (abnf::tree-listp abnf::csts))
  :rule-classes :rewrite)

Theorem: cst-lexeme-conc1-rep-match

(defthm cst-lexeme-conc1-rep-match
  (implies (and (cst-matchp abnf::cst "lexeme")
                (equal (cst-lexeme-conc? abnf::cst) 1))
           (b* ((abnf::csts (cst-lexeme-conc1-rep abnf::cst)))
             (cst-list-rep-matchp abnf::csts "token")))
  :rule-classes :rewrite)

Theorem: cst-lexeme-conc1-rep-of-tree-fix-cst

(defthm cst-lexeme-conc1-rep-of-tree-fix-cst
  (equal (cst-lexeme-conc1-rep (abnf::tree-fix abnf::cst))
         (cst-lexeme-conc1-rep abnf::cst)))

Theorem: cst-lexeme-conc1-rep-tree-equiv-congruence-on-cst

(defthm cst-lexeme-conc1-rep-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-lexeme-conc1-rep abnf::cst)
                  (cst-lexeme-conc1-rep cst-equiv)))
  :rule-classes :congruence)

Function: cst-lexeme-conc2-rep

(defun cst-lexeme-conc2-rep (abnf::cst)
  (declare (xargs :guard (abnf::treep abnf::cst)))
  (declare (xargs :guard (and (cst-matchp abnf::cst "lexeme")
                              (equal (cst-lexeme-conc? abnf::cst)
                                     2))))
  (let ((__function__ 'cst-lexeme-conc2-rep))
    (declare (ignorable __function__))
    (abnf::tree-list-fix (nth 0 (cst-lexeme-conc2 abnf::cst)))))

Theorem: tree-listp-of-cst-lexeme-conc2-rep

(defthm tree-listp-of-cst-lexeme-conc2-rep
  (b* ((abnf::csts (cst-lexeme-conc2-rep abnf::cst)))
    (abnf::tree-listp abnf::csts))
  :rule-classes :rewrite)

Theorem: cst-lexeme-conc2-rep-match

(defthm cst-lexeme-conc2-rep-match
  (implies (and (cst-matchp abnf::cst "lexeme")
                (equal (cst-lexeme-conc? abnf::cst) 2))
           (b* ((abnf::csts (cst-lexeme-conc2-rep abnf::cst)))
             (cst-list-rep-matchp abnf::csts "comment")))
  :rule-classes :rewrite)

Theorem: cst-lexeme-conc2-rep-of-tree-fix-cst

(defthm cst-lexeme-conc2-rep-of-tree-fix-cst
  (equal (cst-lexeme-conc2-rep (abnf::tree-fix abnf::cst))
         (cst-lexeme-conc2-rep abnf::cst)))

Theorem: cst-lexeme-conc2-rep-tree-equiv-congruence-on-cst

(defthm cst-lexeme-conc2-rep-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-lexeme-conc2-rep abnf::cst)
                  (cst-lexeme-conc2-rep cst-equiv)))
  :rule-classes :congruence)

Function: cst-lexeme-conc3-rep

(defun cst-lexeme-conc3-rep (abnf::cst)
  (declare (xargs :guard (abnf::treep abnf::cst)))
  (declare (xargs :guard (and (cst-matchp abnf::cst "lexeme")
                              (equal (cst-lexeme-conc? abnf::cst)
                                     3))))
  (let ((__function__ 'cst-lexeme-conc3-rep))
    (declare (ignorable __function__))
    (abnf::tree-list-fix (nth 0 (cst-lexeme-conc3 abnf::cst)))))

Theorem: tree-listp-of-cst-lexeme-conc3-rep

(defthm tree-listp-of-cst-lexeme-conc3-rep
  (b* ((abnf::csts (cst-lexeme-conc3-rep abnf::cst)))
    (abnf::tree-listp abnf::csts))
  :rule-classes :rewrite)

Theorem: cst-lexeme-conc3-rep-match

(defthm cst-lexeme-conc3-rep-match
  (implies (and (cst-matchp abnf::cst "lexeme")
                (equal (cst-lexeme-conc? abnf::cst) 3))
           (b* ((abnf::csts (cst-lexeme-conc3-rep abnf::cst)))
             (cst-list-rep-matchp abnf::csts "whitespace")))
  :rule-classes :rewrite)

Theorem: cst-lexeme-conc3-rep-of-tree-fix-cst

(defthm cst-lexeme-conc3-rep-of-tree-fix-cst
  (equal (cst-lexeme-conc3-rep (abnf::tree-fix abnf::cst))
         (cst-lexeme-conc3-rep abnf::cst)))

Theorem: cst-lexeme-conc3-rep-tree-equiv-congruence-on-cst

(defthm cst-lexeme-conc3-rep-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-lexeme-conc3-rep abnf::cst)
                  (cst-lexeme-conc3-rep cst-equiv)))
  :rule-classes :congruence)

Function: cst-network-conc-rep

(defun cst-network-conc-rep (abnf::cst)
  (declare (xargs :guard (abnf::treep abnf::cst)))
  (declare (xargs :guard (cst-matchp abnf::cst "network")))
  (let ((__function__ 'cst-network-conc-rep))
    (declare (ignorable __function__))
    (abnf::tree-list-fix (nth 0 (cst-network-conc abnf::cst)))))

Theorem: tree-listp-of-cst-network-conc-rep

(defthm tree-listp-of-cst-network-conc-rep
  (b* ((abnf::csts (cst-network-conc-rep abnf::cst)))
    (abnf::tree-listp abnf::csts))
  :rule-classes :rewrite)

Theorem: cst-network-conc-rep-match

(defthm cst-network-conc-rep-match
  (implies (cst-matchp abnf::cst "network")
           (b* ((abnf::csts (cst-network-conc-rep abnf::cst)))
             (cst-list-rep-matchp abnf::csts "%s\"aleo\"")))
  :rule-classes :rewrite)

Theorem: cst-network-conc-rep-of-tree-fix-cst

(defthm cst-network-conc-rep-of-tree-fix-cst
  (equal (cst-network-conc-rep (abnf::tree-fix abnf::cst))
         (cst-network-conc-rep abnf::cst)))

Theorem: cst-network-conc-rep-tree-equiv-congruence-on-cst

(defthm cst-network-conc-rep-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-network-conc-rep abnf::cst)
                  (cst-network-conc-rep cst-equiv)))
  :rule-classes :congruence)

Function: cst-integer-type-conc1-rep

(defun cst-integer-type-conc1-rep (abnf::cst)
 (declare (xargs :guard (abnf::treep abnf::cst)))
 (declare
      (xargs :guard (and (cst-matchp abnf::cst "integer-type")
                         (equal (cst-integer-type-conc? abnf::cst)
                                1))))
 (let ((__function__ 'cst-integer-type-conc1-rep))
  (declare (ignorable __function__))
  (abnf::tree-list-fix (nth 0 (cst-integer-type-conc1 abnf::cst)))))

Theorem: tree-listp-of-cst-integer-type-conc1-rep

(defthm tree-listp-of-cst-integer-type-conc1-rep
  (b* ((abnf::csts (cst-integer-type-conc1-rep abnf::cst)))
    (abnf::tree-listp abnf::csts))
  :rule-classes :rewrite)

Theorem: cst-integer-type-conc1-rep-match

(defthm cst-integer-type-conc1-rep-match
  (implies (and (cst-matchp abnf::cst "integer-type")
                (equal (cst-integer-type-conc? abnf::cst)
                       1))
           (b* ((abnf::csts (cst-integer-type-conc1-rep abnf::cst)))
             (cst-list-rep-matchp abnf::csts "unsigned-type")))
  :rule-classes :rewrite)

Theorem: cst-integer-type-conc1-rep-of-tree-fix-cst

(defthm cst-integer-type-conc1-rep-of-tree-fix-cst
  (equal (cst-integer-type-conc1-rep (abnf::tree-fix abnf::cst))
         (cst-integer-type-conc1-rep abnf::cst)))

Theorem: cst-integer-type-conc1-rep-tree-equiv-congruence-on-cst

(defthm cst-integer-type-conc1-rep-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-integer-type-conc1-rep abnf::cst)
                  (cst-integer-type-conc1-rep cst-equiv)))
  :rule-classes :congruence)

Function: cst-integer-type-conc2-rep

(defun cst-integer-type-conc2-rep (abnf::cst)
 (declare (xargs :guard (abnf::treep abnf::cst)))
 (declare
      (xargs :guard (and (cst-matchp abnf::cst "integer-type")
                         (equal (cst-integer-type-conc? abnf::cst)
                                2))))
 (let ((__function__ 'cst-integer-type-conc2-rep))
  (declare (ignorable __function__))
  (abnf::tree-list-fix (nth 0 (cst-integer-type-conc2 abnf::cst)))))

Theorem: tree-listp-of-cst-integer-type-conc2-rep

(defthm tree-listp-of-cst-integer-type-conc2-rep
  (b* ((abnf::csts (cst-integer-type-conc2-rep abnf::cst)))
    (abnf::tree-listp abnf::csts))
  :rule-classes :rewrite)

Theorem: cst-integer-type-conc2-rep-match

(defthm cst-integer-type-conc2-rep-match
  (implies (and (cst-matchp abnf::cst "integer-type")
                (equal (cst-integer-type-conc? abnf::cst)
                       2))
           (b* ((abnf::csts (cst-integer-type-conc2-rep abnf::cst)))
             (cst-list-rep-matchp abnf::csts "signed-type")))
  :rule-classes :rewrite)

Theorem: cst-integer-type-conc2-rep-of-tree-fix-cst

(defthm cst-integer-type-conc2-rep-of-tree-fix-cst
  (equal (cst-integer-type-conc2-rep (abnf::tree-fix abnf::cst))
         (cst-integer-type-conc2-rep abnf::cst)))

Theorem: cst-integer-type-conc2-rep-tree-equiv-congruence-on-cst

(defthm cst-integer-type-conc2-rep-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-integer-type-conc2-rep abnf::cst)
                  (cst-integer-type-conc2-rep cst-equiv)))
  :rule-classes :congruence)

Function: cst-field-type-conc-rep

(defun cst-field-type-conc-rep (abnf::cst)
  (declare (xargs :guard (abnf::treep abnf::cst)))
  (declare (xargs :guard (cst-matchp abnf::cst "field-type")))
  (let ((__function__ 'cst-field-type-conc-rep))
    (declare (ignorable __function__))
    (abnf::tree-list-fix (nth 0 (cst-field-type-conc abnf::cst)))))

Theorem: tree-listp-of-cst-field-type-conc-rep

(defthm tree-listp-of-cst-field-type-conc-rep
  (b* ((abnf::csts (cst-field-type-conc-rep abnf::cst)))
    (abnf::tree-listp abnf::csts))
  :rule-classes :rewrite)

Theorem: cst-field-type-conc-rep-match

(defthm cst-field-type-conc-rep-match
  (implies (cst-matchp abnf::cst "field-type")
           (b* ((abnf::csts (cst-field-type-conc-rep abnf::cst)))
             (cst-list-rep-matchp abnf::csts "%s\"field\"")))
  :rule-classes :rewrite)

Theorem: cst-field-type-conc-rep-of-tree-fix-cst

(defthm cst-field-type-conc-rep-of-tree-fix-cst
  (equal (cst-field-type-conc-rep (abnf::tree-fix abnf::cst))
         (cst-field-type-conc-rep abnf::cst)))

Theorem: cst-field-type-conc-rep-tree-equiv-congruence-on-cst

(defthm cst-field-type-conc-rep-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-field-type-conc-rep abnf::cst)
                  (cst-field-type-conc-rep cst-equiv)))
  :rule-classes :congruence)

Function: cst-group-type-conc-rep

(defun cst-group-type-conc-rep (abnf::cst)
  (declare (xargs :guard (abnf::treep abnf::cst)))
  (declare (xargs :guard (cst-matchp abnf::cst "group-type")))
  (let ((__function__ 'cst-group-type-conc-rep))
    (declare (ignorable __function__))
    (abnf::tree-list-fix (nth 0 (cst-group-type-conc abnf::cst)))))

Theorem: tree-listp-of-cst-group-type-conc-rep

(defthm tree-listp-of-cst-group-type-conc-rep
  (b* ((abnf::csts (cst-group-type-conc-rep abnf::cst)))
    (abnf::tree-listp abnf::csts))
  :rule-classes :rewrite)

Theorem: cst-group-type-conc-rep-match

(defthm cst-group-type-conc-rep-match
  (implies (cst-matchp abnf::cst "group-type")
           (b* ((abnf::csts (cst-group-type-conc-rep abnf::cst)))
             (cst-list-rep-matchp abnf::csts "%s\"group\"")))
  :rule-classes :rewrite)

Theorem: cst-group-type-conc-rep-of-tree-fix-cst

(defthm cst-group-type-conc-rep-of-tree-fix-cst
  (equal (cst-group-type-conc-rep (abnf::tree-fix abnf::cst))
         (cst-group-type-conc-rep abnf::cst)))

Theorem: cst-group-type-conc-rep-tree-equiv-congruence-on-cst

(defthm cst-group-type-conc-rep-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-group-type-conc-rep abnf::cst)
                  (cst-group-type-conc-rep cst-equiv)))
  :rule-classes :congruence)

Function: cst-scalar-type-conc-rep

(defun cst-scalar-type-conc-rep (abnf::cst)
  (declare (xargs :guard (abnf::treep abnf::cst)))
  (declare (xargs :guard (cst-matchp abnf::cst "scalar-type")))
  (let ((__function__ 'cst-scalar-type-conc-rep))
    (declare (ignorable __function__))
    (abnf::tree-list-fix (nth 0 (cst-scalar-type-conc abnf::cst)))))

Theorem: tree-listp-of-cst-scalar-type-conc-rep

(defthm tree-listp-of-cst-scalar-type-conc-rep
  (b* ((abnf::csts (cst-scalar-type-conc-rep abnf::cst)))
    (abnf::tree-listp abnf::csts))
  :rule-classes :rewrite)

Theorem: cst-scalar-type-conc-rep-match

(defthm cst-scalar-type-conc-rep-match
  (implies (cst-matchp abnf::cst "scalar-type")
           (b* ((abnf::csts (cst-scalar-type-conc-rep abnf::cst)))
             (cst-list-rep-matchp abnf::csts "%s\"scalar\"")))
  :rule-classes :rewrite)

Theorem: cst-scalar-type-conc-rep-of-tree-fix-cst

(defthm cst-scalar-type-conc-rep-of-tree-fix-cst
  (equal (cst-scalar-type-conc-rep (abnf::tree-fix abnf::cst))
         (cst-scalar-type-conc-rep abnf::cst)))

Theorem: cst-scalar-type-conc-rep-tree-equiv-congruence-on-cst

(defthm cst-scalar-type-conc-rep-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-scalar-type-conc-rep abnf::cst)
                  (cst-scalar-type-conc-rep cst-equiv)))
  :rule-classes :congruence)

Function: cst-arithmetic-type-conc1-rep

(defun cst-arithmetic-type-conc1-rep (abnf::cst)
 (declare (xargs :guard (abnf::treep abnf::cst)))
 (declare
     (xargs :guard (and (cst-matchp abnf::cst "arithmetic-type")
                        (equal (cst-arithmetic-type-conc? abnf::cst)
                               1))))
 (let ((__function__ 'cst-arithmetic-type-conc1-rep))
   (declare (ignorable __function__))
   (abnf::tree-list-fix
        (nth 0
             (cst-arithmetic-type-conc1 abnf::cst)))))

Theorem: tree-listp-of-cst-arithmetic-type-conc1-rep

(defthm tree-listp-of-cst-arithmetic-type-conc1-rep
  (b* ((abnf::csts (cst-arithmetic-type-conc1-rep abnf::cst)))
    (abnf::tree-listp abnf::csts))
  :rule-classes :rewrite)

Theorem: cst-arithmetic-type-conc1-rep-match

(defthm cst-arithmetic-type-conc1-rep-match
  (implies
       (and (cst-matchp abnf::cst "arithmetic-type")
            (equal (cst-arithmetic-type-conc? abnf::cst)
                   1))
       (b* ((abnf::csts (cst-arithmetic-type-conc1-rep abnf::cst)))
         (cst-list-rep-matchp abnf::csts "integer-type")))
  :rule-classes :rewrite)

Theorem: cst-arithmetic-type-conc1-rep-of-tree-fix-cst

(defthm cst-arithmetic-type-conc1-rep-of-tree-fix-cst
  (equal (cst-arithmetic-type-conc1-rep (abnf::tree-fix abnf::cst))
         (cst-arithmetic-type-conc1-rep abnf::cst)))

Theorem: cst-arithmetic-type-conc1-rep-tree-equiv-congruence-on-cst

(defthm cst-arithmetic-type-conc1-rep-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-arithmetic-type-conc1-rep abnf::cst)
                  (cst-arithmetic-type-conc1-rep cst-equiv)))
  :rule-classes :congruence)

Function: cst-arithmetic-type-conc2-rep

(defun cst-arithmetic-type-conc2-rep (abnf::cst)
 (declare (xargs :guard (abnf::treep abnf::cst)))
 (declare
     (xargs :guard (and (cst-matchp abnf::cst "arithmetic-type")
                        (equal (cst-arithmetic-type-conc? abnf::cst)
                               2))))
 (let ((__function__ 'cst-arithmetic-type-conc2-rep))
   (declare (ignorable __function__))
   (abnf::tree-list-fix
        (nth 0
             (cst-arithmetic-type-conc2 abnf::cst)))))

Theorem: tree-listp-of-cst-arithmetic-type-conc2-rep

(defthm tree-listp-of-cst-arithmetic-type-conc2-rep
  (b* ((abnf::csts (cst-arithmetic-type-conc2-rep abnf::cst)))
    (abnf::tree-listp abnf::csts))
  :rule-classes :rewrite)

Theorem: cst-arithmetic-type-conc2-rep-match

(defthm cst-arithmetic-type-conc2-rep-match
  (implies
       (and (cst-matchp abnf::cst "arithmetic-type")
            (equal (cst-arithmetic-type-conc? abnf::cst)
                   2))
       (b* ((abnf::csts (cst-arithmetic-type-conc2-rep abnf::cst)))
         (cst-list-rep-matchp abnf::csts "field-type")))
  :rule-classes :rewrite)

Theorem: cst-arithmetic-type-conc2-rep-of-tree-fix-cst

(defthm cst-arithmetic-type-conc2-rep-of-tree-fix-cst
  (equal (cst-arithmetic-type-conc2-rep (abnf::tree-fix abnf::cst))
         (cst-arithmetic-type-conc2-rep abnf::cst)))

Theorem: cst-arithmetic-type-conc2-rep-tree-equiv-congruence-on-cst

(defthm cst-arithmetic-type-conc2-rep-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-arithmetic-type-conc2-rep abnf::cst)
                  (cst-arithmetic-type-conc2-rep cst-equiv)))
  :rule-classes :congruence)

Function: cst-arithmetic-type-conc3-rep

(defun cst-arithmetic-type-conc3-rep (abnf::cst)
 (declare (xargs :guard (abnf::treep abnf::cst)))
 (declare
     (xargs :guard (and (cst-matchp abnf::cst "arithmetic-type")
                        (equal (cst-arithmetic-type-conc? abnf::cst)
                               3))))
 (let ((__function__ 'cst-arithmetic-type-conc3-rep))
   (declare (ignorable __function__))
   (abnf::tree-list-fix
        (nth 0
             (cst-arithmetic-type-conc3 abnf::cst)))))

Theorem: tree-listp-of-cst-arithmetic-type-conc3-rep

(defthm tree-listp-of-cst-arithmetic-type-conc3-rep
  (b* ((abnf::csts (cst-arithmetic-type-conc3-rep abnf::cst)))
    (abnf::tree-listp abnf::csts))
  :rule-classes :rewrite)

Theorem: cst-arithmetic-type-conc3-rep-match

(defthm cst-arithmetic-type-conc3-rep-match
  (implies
       (and (cst-matchp abnf::cst "arithmetic-type")
            (equal (cst-arithmetic-type-conc? abnf::cst)
                   3))
       (b* ((abnf::csts (cst-arithmetic-type-conc3-rep abnf::cst)))
         (cst-list-rep-matchp abnf::csts "group-type")))
  :rule-classes :rewrite)

Theorem: cst-arithmetic-type-conc3-rep-of-tree-fix-cst

(defthm cst-arithmetic-type-conc3-rep-of-tree-fix-cst
  (equal (cst-arithmetic-type-conc3-rep (abnf::tree-fix abnf::cst))
         (cst-arithmetic-type-conc3-rep abnf::cst)))

Theorem: cst-arithmetic-type-conc3-rep-tree-equiv-congruence-on-cst

(defthm cst-arithmetic-type-conc3-rep-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-arithmetic-type-conc3-rep abnf::cst)
                  (cst-arithmetic-type-conc3-rep cst-equiv)))
  :rule-classes :congruence)

Function: cst-arithmetic-type-conc4-rep

(defun cst-arithmetic-type-conc4-rep (abnf::cst)
 (declare (xargs :guard (abnf::treep abnf::cst)))
 (declare
     (xargs :guard (and (cst-matchp abnf::cst "arithmetic-type")
                        (equal (cst-arithmetic-type-conc? abnf::cst)
                               4))))
 (let ((__function__ 'cst-arithmetic-type-conc4-rep))
   (declare (ignorable __function__))
   (abnf::tree-list-fix
        (nth 0
             (cst-arithmetic-type-conc4 abnf::cst)))))

Theorem: tree-listp-of-cst-arithmetic-type-conc4-rep

(defthm tree-listp-of-cst-arithmetic-type-conc4-rep
  (b* ((abnf::csts (cst-arithmetic-type-conc4-rep abnf::cst)))
    (abnf::tree-listp abnf::csts))
  :rule-classes :rewrite)

Theorem: cst-arithmetic-type-conc4-rep-match

(defthm cst-arithmetic-type-conc4-rep-match
  (implies
       (and (cst-matchp abnf::cst "arithmetic-type")
            (equal (cst-arithmetic-type-conc? abnf::cst)
                   4))
       (b* ((abnf::csts (cst-arithmetic-type-conc4-rep abnf::cst)))
         (cst-list-rep-matchp abnf::csts "scalar-type")))
  :rule-classes :rewrite)

Theorem: cst-arithmetic-type-conc4-rep-of-tree-fix-cst

(defthm cst-arithmetic-type-conc4-rep-of-tree-fix-cst
  (equal (cst-arithmetic-type-conc4-rep (abnf::tree-fix abnf::cst))
         (cst-arithmetic-type-conc4-rep abnf::cst)))

Theorem: cst-arithmetic-type-conc4-rep-tree-equiv-congruence-on-cst

(defthm cst-arithmetic-type-conc4-rep-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-arithmetic-type-conc4-rep abnf::cst)
                  (cst-arithmetic-type-conc4-rep cst-equiv)))
  :rule-classes :congruence)

Function: cst-boolean-type-conc-rep

(defun cst-boolean-type-conc-rep (abnf::cst)
 (declare (xargs :guard (abnf::treep abnf::cst)))
 (declare (xargs :guard (cst-matchp abnf::cst "boolean-type")))
 (let ((__function__ 'cst-boolean-type-conc-rep))
   (declare (ignorable __function__))
   (abnf::tree-list-fix (nth 0 (cst-boolean-type-conc abnf::cst)))))

Theorem: tree-listp-of-cst-boolean-type-conc-rep

(defthm tree-listp-of-cst-boolean-type-conc-rep
  (b* ((abnf::csts (cst-boolean-type-conc-rep abnf::cst)))
    (abnf::tree-listp abnf::csts))
  :rule-classes :rewrite)

Theorem: cst-boolean-type-conc-rep-match

(defthm cst-boolean-type-conc-rep-match
  (implies (cst-matchp abnf::cst "boolean-type")
           (b* ((abnf::csts (cst-boolean-type-conc-rep abnf::cst)))
             (cst-list-rep-matchp abnf::csts "%s\"bool\"")))
  :rule-classes :rewrite)

Theorem: cst-boolean-type-conc-rep-of-tree-fix-cst

(defthm cst-boolean-type-conc-rep-of-tree-fix-cst
  (equal (cst-boolean-type-conc-rep (abnf::tree-fix abnf::cst))
         (cst-boolean-type-conc-rep abnf::cst)))

Theorem: cst-boolean-type-conc-rep-tree-equiv-congruence-on-cst

(defthm cst-boolean-type-conc-rep-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-boolean-type-conc-rep abnf::cst)
                  (cst-boolean-type-conc-rep cst-equiv)))
  :rule-classes :congruence)

Function: cst-address-type-conc-rep

(defun cst-address-type-conc-rep (abnf::cst)
 (declare (xargs :guard (abnf::treep abnf::cst)))
 (declare (xargs :guard (cst-matchp abnf::cst "address-type")))
 (let ((__function__ 'cst-address-type-conc-rep))
   (declare (ignorable __function__))
   (abnf::tree-list-fix (nth 0 (cst-address-type-conc abnf::cst)))))

Theorem: tree-listp-of-cst-address-type-conc-rep

(defthm tree-listp-of-cst-address-type-conc-rep
  (b* ((abnf::csts (cst-address-type-conc-rep abnf::cst)))
    (abnf::tree-listp abnf::csts))
  :rule-classes :rewrite)

Theorem: cst-address-type-conc-rep-match

(defthm cst-address-type-conc-rep-match
  (implies (cst-matchp abnf::cst "address-type")
           (b* ((abnf::csts (cst-address-type-conc-rep abnf::cst)))
             (cst-list-rep-matchp abnf::csts "%s\"address\"")))
  :rule-classes :rewrite)

Theorem: cst-address-type-conc-rep-of-tree-fix-cst

(defthm cst-address-type-conc-rep-of-tree-fix-cst
  (equal (cst-address-type-conc-rep (abnf::tree-fix abnf::cst))
         (cst-address-type-conc-rep abnf::cst)))

Theorem: cst-address-type-conc-rep-tree-equiv-congruence-on-cst

(defthm cst-address-type-conc-rep-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-address-type-conc-rep abnf::cst)
                  (cst-address-type-conc-rep cst-equiv)))
  :rule-classes :congruence)

Function: cst-signature-type-conc-rep

(defun cst-signature-type-conc-rep (abnf::cst)
 (declare (xargs :guard (abnf::treep abnf::cst)))
 (declare (xargs :guard (cst-matchp abnf::cst "signature-type")))
 (let ((__function__ 'cst-signature-type-conc-rep))
   (declare (ignorable __function__))
   (abnf::tree-list-fix (nth 0
                             (cst-signature-type-conc abnf::cst)))))

Theorem: tree-listp-of-cst-signature-type-conc-rep

(defthm tree-listp-of-cst-signature-type-conc-rep
  (b* ((abnf::csts (cst-signature-type-conc-rep abnf::cst)))
    (abnf::tree-listp abnf::csts))
  :rule-classes :rewrite)

Theorem: cst-signature-type-conc-rep-match

(defthm cst-signature-type-conc-rep-match
 (implies (cst-matchp abnf::cst "signature-type")
          (b* ((abnf::csts (cst-signature-type-conc-rep abnf::cst)))
            (cst-list-rep-matchp abnf::csts "%s\"signature\"")))
 :rule-classes :rewrite)

Theorem: cst-signature-type-conc-rep-of-tree-fix-cst

(defthm cst-signature-type-conc-rep-of-tree-fix-cst
  (equal (cst-signature-type-conc-rep (abnf::tree-fix abnf::cst))
         (cst-signature-type-conc-rep abnf::cst)))

Theorem: cst-signature-type-conc-rep-tree-equiv-congruence-on-cst

(defthm cst-signature-type-conc-rep-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-signature-type-conc-rep abnf::cst)
                  (cst-signature-type-conc-rep cst-equiv)))
  :rule-classes :congruence)

Function: cst-string-type-conc-rep

(defun cst-string-type-conc-rep (abnf::cst)
  (declare (xargs :guard (abnf::treep abnf::cst)))
  (declare (xargs :guard (cst-matchp abnf::cst "string-type")))
  (let ((__function__ 'cst-string-type-conc-rep))
    (declare (ignorable __function__))
    (abnf::tree-list-fix (nth 0 (cst-string-type-conc abnf::cst)))))

Theorem: tree-listp-of-cst-string-type-conc-rep

(defthm tree-listp-of-cst-string-type-conc-rep
  (b* ((abnf::csts (cst-string-type-conc-rep abnf::cst)))
    (abnf::tree-listp abnf::csts))
  :rule-classes :rewrite)

Theorem: cst-string-type-conc-rep-match

(defthm cst-string-type-conc-rep-match
  (implies (cst-matchp abnf::cst "string-type")
           (b* ((abnf::csts (cst-string-type-conc-rep abnf::cst)))
             (cst-list-rep-matchp abnf::csts "%s\"string\"")))
  :rule-classes :rewrite)

Theorem: cst-string-type-conc-rep-of-tree-fix-cst

(defthm cst-string-type-conc-rep-of-tree-fix-cst
  (equal (cst-string-type-conc-rep (abnf::tree-fix abnf::cst))
         (cst-string-type-conc-rep abnf::cst)))

Theorem: cst-string-type-conc-rep-tree-equiv-congruence-on-cst

(defthm cst-string-type-conc-rep-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-string-type-conc-rep abnf::cst)
                  (cst-string-type-conc-rep cst-equiv)))
  :rule-classes :congruence)

Function: cst-named-primitive-type-conc1-rep

(defun cst-named-primitive-type-conc1-rep (abnf::cst)
 (declare (xargs :guard (abnf::treep abnf::cst)))
 (declare
  (xargs
       :guard (and (cst-matchp abnf::cst "named-primitive-type")
                   (equal (cst-named-primitive-type-conc? abnf::cst)
                          1))))
 (let ((__function__ 'cst-named-primitive-type-conc1-rep))
   (declare (ignorable __function__))
   (abnf::tree-list-fix
        (nth 0
             (cst-named-primitive-type-conc1 abnf::cst)))))

Theorem: tree-listp-of-cst-named-primitive-type-conc1-rep

(defthm tree-listp-of-cst-named-primitive-type-conc1-rep
  (b* ((abnf::csts (cst-named-primitive-type-conc1-rep abnf::cst)))
    (abnf::tree-listp abnf::csts))
  :rule-classes :rewrite)

Theorem: cst-named-primitive-type-conc1-rep-match

(defthm cst-named-primitive-type-conc1-rep-match
 (implies
   (and (cst-matchp abnf::cst "named-primitive-type")
        (equal (cst-named-primitive-type-conc? abnf::cst)
               1))
   (b* ((abnf::csts (cst-named-primitive-type-conc1-rep abnf::cst)))
     (cst-list-rep-matchp abnf::csts "boolean-type")))
 :rule-classes :rewrite)

Theorem: cst-named-primitive-type-conc1-rep-of-tree-fix-cst

(defthm cst-named-primitive-type-conc1-rep-of-tree-fix-cst
 (equal
     (cst-named-primitive-type-conc1-rep (abnf::tree-fix abnf::cst))
     (cst-named-primitive-type-conc1-rep abnf::cst)))

Theorem: cst-named-primitive-type-conc1-rep-tree-equiv-congruence-on-cst

(defthm
    cst-named-primitive-type-conc1-rep-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-named-primitive-type-conc1-rep abnf::cst)
                  (cst-named-primitive-type-conc1-rep cst-equiv)))
  :rule-classes :congruence)

Function: cst-named-primitive-type-conc2-rep

(defun cst-named-primitive-type-conc2-rep (abnf::cst)
 (declare (xargs :guard (abnf::treep abnf::cst)))
 (declare
  (xargs
       :guard (and (cst-matchp abnf::cst "named-primitive-type")
                   (equal (cst-named-primitive-type-conc? abnf::cst)
                          2))))
 (let ((__function__ 'cst-named-primitive-type-conc2-rep))
   (declare (ignorable __function__))
   (abnf::tree-list-fix
        (nth 0
             (cst-named-primitive-type-conc2 abnf::cst)))))

Theorem: tree-listp-of-cst-named-primitive-type-conc2-rep

(defthm tree-listp-of-cst-named-primitive-type-conc2-rep
  (b* ((abnf::csts (cst-named-primitive-type-conc2-rep abnf::cst)))
    (abnf::tree-listp abnf::csts))
  :rule-classes :rewrite)

Theorem: cst-named-primitive-type-conc2-rep-match

(defthm cst-named-primitive-type-conc2-rep-match
 (implies
   (and (cst-matchp abnf::cst "named-primitive-type")
        (equal (cst-named-primitive-type-conc? abnf::cst)
               2))
   (b* ((abnf::csts (cst-named-primitive-type-conc2-rep abnf::cst)))
     (cst-list-rep-matchp abnf::csts "arithmetic-type")))
 :rule-classes :rewrite)

Theorem: cst-named-primitive-type-conc2-rep-of-tree-fix-cst

(defthm cst-named-primitive-type-conc2-rep-of-tree-fix-cst
 (equal
     (cst-named-primitive-type-conc2-rep (abnf::tree-fix abnf::cst))
     (cst-named-primitive-type-conc2-rep abnf::cst)))

Theorem: cst-named-primitive-type-conc2-rep-tree-equiv-congruence-on-cst

(defthm
    cst-named-primitive-type-conc2-rep-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-named-primitive-type-conc2-rep abnf::cst)
                  (cst-named-primitive-type-conc2-rep cst-equiv)))
  :rule-classes :congruence)

Function: cst-named-primitive-type-conc3-rep

(defun cst-named-primitive-type-conc3-rep (abnf::cst)
 (declare (xargs :guard (abnf::treep abnf::cst)))
 (declare
  (xargs
       :guard (and (cst-matchp abnf::cst "named-primitive-type")
                   (equal (cst-named-primitive-type-conc? abnf::cst)
                          3))))
 (let ((__function__ 'cst-named-primitive-type-conc3-rep))
   (declare (ignorable __function__))
   (abnf::tree-list-fix
        (nth 0
             (cst-named-primitive-type-conc3 abnf::cst)))))

Theorem: tree-listp-of-cst-named-primitive-type-conc3-rep

(defthm tree-listp-of-cst-named-primitive-type-conc3-rep
  (b* ((abnf::csts (cst-named-primitive-type-conc3-rep abnf::cst)))
    (abnf::tree-listp abnf::csts))
  :rule-classes :rewrite)

Theorem: cst-named-primitive-type-conc3-rep-match

(defthm cst-named-primitive-type-conc3-rep-match
 (implies
   (and (cst-matchp abnf::cst "named-primitive-type")
        (equal (cst-named-primitive-type-conc? abnf::cst)
               3))
   (b* ((abnf::csts (cst-named-primitive-type-conc3-rep abnf::cst)))
     (cst-list-rep-matchp abnf::csts "address-type")))
 :rule-classes :rewrite)

Theorem: cst-named-primitive-type-conc3-rep-of-tree-fix-cst

(defthm cst-named-primitive-type-conc3-rep-of-tree-fix-cst
 (equal
     (cst-named-primitive-type-conc3-rep (abnf::tree-fix abnf::cst))
     (cst-named-primitive-type-conc3-rep abnf::cst)))

Theorem: cst-named-primitive-type-conc3-rep-tree-equiv-congruence-on-cst

(defthm
    cst-named-primitive-type-conc3-rep-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-named-primitive-type-conc3-rep abnf::cst)
                  (cst-named-primitive-type-conc3-rep cst-equiv)))
  :rule-classes :congruence)

Function: cst-named-primitive-type-conc4-rep

(defun cst-named-primitive-type-conc4-rep (abnf::cst)
 (declare (xargs :guard (abnf::treep abnf::cst)))
 (declare
  (xargs
       :guard (and (cst-matchp abnf::cst "named-primitive-type")
                   (equal (cst-named-primitive-type-conc? abnf::cst)
                          4))))
 (let ((__function__ 'cst-named-primitive-type-conc4-rep))
   (declare (ignorable __function__))
   (abnf::tree-list-fix
        (nth 0
             (cst-named-primitive-type-conc4 abnf::cst)))))

Theorem: tree-listp-of-cst-named-primitive-type-conc4-rep

(defthm tree-listp-of-cst-named-primitive-type-conc4-rep
  (b* ((abnf::csts (cst-named-primitive-type-conc4-rep abnf::cst)))
    (abnf::tree-listp abnf::csts))
  :rule-classes :rewrite)

Theorem: cst-named-primitive-type-conc4-rep-match

(defthm cst-named-primitive-type-conc4-rep-match
 (implies
   (and (cst-matchp abnf::cst "named-primitive-type")
        (equal (cst-named-primitive-type-conc? abnf::cst)
               4))
   (b* ((abnf::csts (cst-named-primitive-type-conc4-rep abnf::cst)))
     (cst-list-rep-matchp abnf::csts "signature-type")))
 :rule-classes :rewrite)

Theorem: cst-named-primitive-type-conc4-rep-of-tree-fix-cst

(defthm cst-named-primitive-type-conc4-rep-of-tree-fix-cst
 (equal
     (cst-named-primitive-type-conc4-rep (abnf::tree-fix abnf::cst))
     (cst-named-primitive-type-conc4-rep abnf::cst)))

Theorem: cst-named-primitive-type-conc4-rep-tree-equiv-congruence-on-cst

(defthm
    cst-named-primitive-type-conc4-rep-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-named-primitive-type-conc4-rep abnf::cst)
                  (cst-named-primitive-type-conc4-rep cst-equiv)))
  :rule-classes :congruence)

Function: cst-named-primitive-type-conc5-rep

(defun cst-named-primitive-type-conc5-rep (abnf::cst)
 (declare (xargs :guard (abnf::treep abnf::cst)))
 (declare
  (xargs
       :guard (and (cst-matchp abnf::cst "named-primitive-type")
                   (equal (cst-named-primitive-type-conc? abnf::cst)
                          5))))
 (let ((__function__ 'cst-named-primitive-type-conc5-rep))
   (declare (ignorable __function__))
   (abnf::tree-list-fix
        (nth 0
             (cst-named-primitive-type-conc5 abnf::cst)))))

Theorem: tree-listp-of-cst-named-primitive-type-conc5-rep

(defthm tree-listp-of-cst-named-primitive-type-conc5-rep
  (b* ((abnf::csts (cst-named-primitive-type-conc5-rep abnf::cst)))
    (abnf::tree-listp abnf::csts))
  :rule-classes :rewrite)

Theorem: cst-named-primitive-type-conc5-rep-match

(defthm cst-named-primitive-type-conc5-rep-match
 (implies
   (and (cst-matchp abnf::cst "named-primitive-type")
        (equal (cst-named-primitive-type-conc? abnf::cst)
               5))
   (b* ((abnf::csts (cst-named-primitive-type-conc5-rep abnf::cst)))
     (cst-list-rep-matchp abnf::csts "string-type")))
 :rule-classes :rewrite)

Theorem: cst-named-primitive-type-conc5-rep-of-tree-fix-cst

(defthm cst-named-primitive-type-conc5-rep-of-tree-fix-cst
 (equal
     (cst-named-primitive-type-conc5-rep (abnf::tree-fix abnf::cst))
     (cst-named-primitive-type-conc5-rep abnf::cst)))

Theorem: cst-named-primitive-type-conc5-rep-tree-equiv-congruence-on-cst

(defthm
    cst-named-primitive-type-conc5-rep-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-named-primitive-type-conc5-rep abnf::cst)
                  (cst-named-primitive-type-conc5-rep cst-equiv)))
  :rule-classes :congruence)

Function: cst-primitive-type-conc1-rep

(defun cst-primitive-type-conc1-rep (abnf::cst)
 (declare (xargs :guard (abnf::treep abnf::cst)))
 (declare
      (xargs :guard (and (cst-matchp abnf::cst "primitive-type")
                         (equal (cst-primitive-type-conc? abnf::cst)
                                1))))
 (let ((__function__ 'cst-primitive-type-conc1-rep))
  (declare (ignorable __function__))
  (abnf::tree-list-fix (nth 0
                            (cst-primitive-type-conc1 abnf::cst)))))

Theorem: tree-listp-of-cst-primitive-type-conc1-rep

(defthm tree-listp-of-cst-primitive-type-conc1-rep
  (b* ((abnf::csts (cst-primitive-type-conc1-rep abnf::cst)))
    (abnf::tree-listp abnf::csts))
  :rule-classes :rewrite)

Theorem: cst-primitive-type-conc1-rep-match

(defthm cst-primitive-type-conc1-rep-match
  (implies
       (and (cst-matchp abnf::cst "primitive-type")
            (equal (cst-primitive-type-conc? abnf::cst)
                   1))
       (b* ((abnf::csts (cst-primitive-type-conc1-rep abnf::cst)))
         (cst-list-rep-matchp abnf::csts "named-primitive-type")))
  :rule-classes :rewrite)

Theorem: cst-primitive-type-conc1-rep-of-tree-fix-cst

(defthm cst-primitive-type-conc1-rep-of-tree-fix-cst
  (equal (cst-primitive-type-conc1-rep (abnf::tree-fix abnf::cst))
         (cst-primitive-type-conc1-rep abnf::cst)))

Theorem: cst-primitive-type-conc1-rep-tree-equiv-congruence-on-cst

(defthm cst-primitive-type-conc1-rep-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-primitive-type-conc1-rep abnf::cst)
                  (cst-primitive-type-conc1-rep cst-equiv)))
  :rule-classes :congruence)

Function: cst-primitive-type-conc2-rep

(defun cst-primitive-type-conc2-rep (abnf::cst)
 (declare (xargs :guard (abnf::treep abnf::cst)))
 (declare
      (xargs :guard (and (cst-matchp abnf::cst "primitive-type")
                         (equal (cst-primitive-type-conc? abnf::cst)
                                2))))
 (let ((__function__ 'cst-primitive-type-conc2-rep))
  (declare (ignorable __function__))
  (abnf::tree-list-fix (nth 0
                            (cst-primitive-type-conc2 abnf::cst)))))

Theorem: tree-listp-of-cst-primitive-type-conc2-rep

(defthm tree-listp-of-cst-primitive-type-conc2-rep
  (b* ((abnf::csts (cst-primitive-type-conc2-rep abnf::cst)))
    (abnf::tree-listp abnf::csts))
  :rule-classes :rewrite)

Theorem: cst-primitive-type-conc2-rep-match

(defthm cst-primitive-type-conc2-rep-match
  (implies
       (and (cst-matchp abnf::cst "primitive-type")
            (equal (cst-primitive-type-conc? abnf::cst)
                   2))
       (b* ((abnf::csts (cst-primitive-type-conc2-rep abnf::cst)))
         (cst-list-rep-matchp abnf::csts "unit-type")))
  :rule-classes :rewrite)

Theorem: cst-primitive-type-conc2-rep-of-tree-fix-cst

(defthm cst-primitive-type-conc2-rep-of-tree-fix-cst
  (equal (cst-primitive-type-conc2-rep (abnf::tree-fix abnf::cst))
         (cst-primitive-type-conc2-rep abnf::cst)))

Theorem: cst-primitive-type-conc2-rep-tree-equiv-congruence-on-cst

(defthm cst-primitive-type-conc2-rep-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-primitive-type-conc2-rep abnf::cst)
                  (cst-primitive-type-conc2-rep cst-equiv)))
  :rule-classes :congruence)

Function: cst-untyped-future-type-conc-rep

(defun cst-untyped-future-type-conc-rep (abnf::cst)
  (declare (xargs :guard (abnf::treep abnf::cst)))
  (declare
       (xargs :guard (cst-matchp abnf::cst "untyped-future-type")))
  (let ((__function__ 'cst-untyped-future-type-conc-rep))
    (declare (ignorable __function__))
    (abnf::tree-list-fix
         (nth 0
              (cst-untyped-future-type-conc abnf::cst)))))

Theorem: tree-listp-of-cst-untyped-future-type-conc-rep

(defthm tree-listp-of-cst-untyped-future-type-conc-rep
  (b* ((abnf::csts (cst-untyped-future-type-conc-rep abnf::cst)))
    (abnf::tree-listp abnf::csts))
  :rule-classes :rewrite)

Theorem: cst-untyped-future-type-conc-rep-match

(defthm cst-untyped-future-type-conc-rep-match
 (implies
     (cst-matchp abnf::cst "untyped-future-type")
     (b* ((abnf::csts (cst-untyped-future-type-conc-rep abnf::cst)))
       (cst-list-rep-matchp abnf::csts "%s\"Future\"")))
 :rule-classes :rewrite)

Theorem: cst-untyped-future-type-conc-rep-of-tree-fix-cst

(defthm cst-untyped-future-type-conc-rep-of-tree-fix-cst
  (equal
       (cst-untyped-future-type-conc-rep (abnf::tree-fix abnf::cst))
       (cst-untyped-future-type-conc-rep abnf::cst)))

Theorem: cst-untyped-future-type-conc-rep-tree-equiv-congruence-on-cst

(defthm
      cst-untyped-future-type-conc-rep-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-untyped-future-type-conc-rep abnf::cst)
                  (cst-untyped-future-type-conc-rep cst-equiv)))
  :rule-classes :congruence)

Function: cst-future-type-conc1-rep

(defun cst-future-type-conc1-rep (abnf::cst)
 (declare (xargs :guard (abnf::treep abnf::cst)))
 (declare
      (xargs :guard (and (cst-matchp abnf::cst "future-type")
                         (equal (cst-future-type-conc? abnf::cst)
                                1))))
 (let ((__function__ 'cst-future-type-conc1-rep))
   (declare (ignorable __function__))
   (abnf::tree-list-fix (nth 0 (cst-future-type-conc1 abnf::cst)))))

Theorem: tree-listp-of-cst-future-type-conc1-rep

(defthm tree-listp-of-cst-future-type-conc1-rep
  (b* ((abnf::csts (cst-future-type-conc1-rep abnf::cst)))
    (abnf::tree-listp abnf::csts))
  :rule-classes :rewrite)

Theorem: cst-future-type-conc1-rep-match

(defthm cst-future-type-conc1-rep-match
 (implies (and (cst-matchp abnf::cst "future-type")
               (equal (cst-future-type-conc? abnf::cst)
                      1))
          (b* ((abnf::csts (cst-future-type-conc1-rep abnf::cst)))
            (cst-list-rep-matchp abnf::csts "untyped-future-type")))
 :rule-classes :rewrite)

Theorem: cst-future-type-conc1-rep-of-tree-fix-cst

(defthm cst-future-type-conc1-rep-of-tree-fix-cst
  (equal (cst-future-type-conc1-rep (abnf::tree-fix abnf::cst))
         (cst-future-type-conc1-rep abnf::cst)))

Theorem: cst-future-type-conc1-rep-tree-equiv-congruence-on-cst

(defthm cst-future-type-conc1-rep-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-future-type-conc1-rep abnf::cst)
                  (cst-future-type-conc1-rep cst-equiv)))
  :rule-classes :congruence)

Function: cst-future-type-conc2-rep

(defun cst-future-type-conc2-rep (abnf::cst)
 (declare (xargs :guard (abnf::treep abnf::cst)))
 (declare
      (xargs :guard (and (cst-matchp abnf::cst "future-type")
                         (equal (cst-future-type-conc? abnf::cst)
                                2))))
 (let ((__function__ 'cst-future-type-conc2-rep))
   (declare (ignorable __function__))
   (abnf::tree-list-fix (nth 0 (cst-future-type-conc2 abnf::cst)))))

Theorem: tree-listp-of-cst-future-type-conc2-rep

(defthm tree-listp-of-cst-future-type-conc2-rep
  (b* ((abnf::csts (cst-future-type-conc2-rep abnf::cst)))
    (abnf::tree-listp abnf::csts))
  :rule-classes :rewrite)

Theorem: cst-future-type-conc2-rep-match

(defthm cst-future-type-conc2-rep-match
  (implies (and (cst-matchp abnf::cst "future-type")
                (equal (cst-future-type-conc? abnf::cst)
                       2))
           (b* ((abnf::csts (cst-future-type-conc2-rep abnf::cst)))
             (cst-list-rep-matchp abnf::csts "typed-future-type")))
  :rule-classes :rewrite)

Theorem: cst-future-type-conc2-rep-of-tree-fix-cst

(defthm cst-future-type-conc2-rep-of-tree-fix-cst
  (equal (cst-future-type-conc2-rep (abnf::tree-fix abnf::cst))
         (cst-future-type-conc2-rep abnf::cst)))

Theorem: cst-future-type-conc2-rep-tree-equiv-congruence-on-cst

(defthm cst-future-type-conc2-rep-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-future-type-conc2-rep abnf::cst)
                  (cst-future-type-conc2-rep cst-equiv)))
  :rule-classes :congruence)

Function: cst-type-conc1-rep

(defun cst-type-conc1-rep (abnf::cst)
 (declare (xargs :guard (abnf::treep abnf::cst)))
 (declare (xargs :guard (and (cst-matchp abnf::cst "type")
                             (equal (cst-type-conc? abnf::cst) 1))))
 (let ((__function__ 'cst-type-conc1-rep))
   (declare (ignorable __function__))
   (abnf::tree-list-fix (nth 0 (cst-type-conc1 abnf::cst)))))

Theorem: tree-listp-of-cst-type-conc1-rep

(defthm tree-listp-of-cst-type-conc1-rep
  (b* ((abnf::csts (cst-type-conc1-rep abnf::cst)))
    (abnf::tree-listp abnf::csts))
  :rule-classes :rewrite)

Theorem: cst-type-conc1-rep-match

(defthm cst-type-conc1-rep-match
  (implies (and (cst-matchp abnf::cst "type")
                (equal (cst-type-conc? abnf::cst) 1))
           (b* ((abnf::csts (cst-type-conc1-rep abnf::cst)))
             (cst-list-rep-matchp abnf::csts "primitive-type")))
  :rule-classes :rewrite)

Theorem: cst-type-conc1-rep-of-tree-fix-cst

(defthm cst-type-conc1-rep-of-tree-fix-cst
  (equal (cst-type-conc1-rep (abnf::tree-fix abnf::cst))
         (cst-type-conc1-rep abnf::cst)))

Theorem: cst-type-conc1-rep-tree-equiv-congruence-on-cst

(defthm cst-type-conc1-rep-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-type-conc1-rep abnf::cst)
                  (cst-type-conc1-rep cst-equiv)))
  :rule-classes :congruence)

Function: cst-type-conc2-rep

(defun cst-type-conc2-rep (abnf::cst)
 (declare (xargs :guard (abnf::treep abnf::cst)))
 (declare (xargs :guard (and (cst-matchp abnf::cst "type")
                             (equal (cst-type-conc? abnf::cst) 2))))
 (let ((__function__ 'cst-type-conc2-rep))
   (declare (ignorable __function__))
   (abnf::tree-list-fix (nth 0 (cst-type-conc2 abnf::cst)))))

Theorem: tree-listp-of-cst-type-conc2-rep

(defthm tree-listp-of-cst-type-conc2-rep
  (b* ((abnf::csts (cst-type-conc2-rep abnf::cst)))
    (abnf::tree-listp abnf::csts))
  :rule-classes :rewrite)

Theorem: cst-type-conc2-rep-match

(defthm cst-type-conc2-rep-match
  (implies (and (cst-matchp abnf::cst "type")
                (equal (cst-type-conc? abnf::cst) 2))
           (b* ((abnf::csts (cst-type-conc2-rep abnf::cst)))
             (cst-list-rep-matchp abnf::csts "future-type")))
  :rule-classes :rewrite)

Theorem: cst-type-conc2-rep-of-tree-fix-cst

(defthm cst-type-conc2-rep-of-tree-fix-cst
  (equal (cst-type-conc2-rep (abnf::tree-fix abnf::cst))
         (cst-type-conc2-rep abnf::cst)))

Theorem: cst-type-conc2-rep-tree-equiv-congruence-on-cst

(defthm cst-type-conc2-rep-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-type-conc2-rep abnf::cst)
                  (cst-type-conc2-rep cst-equiv)))
  :rule-classes :congruence)

Function: cst-type-conc3-rep

(defun cst-type-conc3-rep (abnf::cst)
 (declare (xargs :guard (abnf::treep abnf::cst)))
 (declare (xargs :guard (and (cst-matchp abnf::cst "type")
                             (equal (cst-type-conc? abnf::cst) 3))))
 (let ((__function__ 'cst-type-conc3-rep))
   (declare (ignorable __function__))
   (abnf::tree-list-fix (nth 0 (cst-type-conc3 abnf::cst)))))

Theorem: tree-listp-of-cst-type-conc3-rep

(defthm tree-listp-of-cst-type-conc3-rep
  (b* ((abnf::csts (cst-type-conc3-rep abnf::cst)))
    (abnf::tree-listp abnf::csts))
  :rule-classes :rewrite)

Theorem: cst-type-conc3-rep-match

(defthm cst-type-conc3-rep-match
  (implies (and (cst-matchp abnf::cst "type")
                (equal (cst-type-conc? abnf::cst) 3))
           (b* ((abnf::csts (cst-type-conc3-rep abnf::cst)))
             (cst-list-rep-matchp abnf::csts "tuple-type")))
  :rule-classes :rewrite)

Theorem: cst-type-conc3-rep-of-tree-fix-cst

(defthm cst-type-conc3-rep-of-tree-fix-cst
  (equal (cst-type-conc3-rep (abnf::tree-fix abnf::cst))
         (cst-type-conc3-rep abnf::cst)))

Theorem: cst-type-conc3-rep-tree-equiv-congruence-on-cst

(defthm cst-type-conc3-rep-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-type-conc3-rep abnf::cst)
                  (cst-type-conc3-rep cst-equiv)))
  :rule-classes :congruence)

Function: cst-type-conc4-rep

(defun cst-type-conc4-rep (abnf::cst)
 (declare (xargs :guard (abnf::treep abnf::cst)))
 (declare (xargs :guard (and (cst-matchp abnf::cst "type")
                             (equal (cst-type-conc? abnf::cst) 4))))
 (let ((__function__ 'cst-type-conc4-rep))
   (declare (ignorable __function__))
   (abnf::tree-list-fix (nth 0 (cst-type-conc4 abnf::cst)))))

Theorem: tree-listp-of-cst-type-conc4-rep

(defthm tree-listp-of-cst-type-conc4-rep
  (b* ((abnf::csts (cst-type-conc4-rep abnf::cst)))
    (abnf::tree-listp abnf::csts))
  :rule-classes :rewrite)

Theorem: cst-type-conc4-rep-match

(defthm cst-type-conc4-rep-match
  (implies (and (cst-matchp abnf::cst "type")
                (equal (cst-type-conc? abnf::cst) 4))
           (b* ((abnf::csts (cst-type-conc4-rep abnf::cst)))
             (cst-list-rep-matchp abnf::csts "array-type")))
  :rule-classes :rewrite)

Theorem: cst-type-conc4-rep-of-tree-fix-cst

(defthm cst-type-conc4-rep-of-tree-fix-cst
  (equal (cst-type-conc4-rep (abnf::tree-fix abnf::cst))
         (cst-type-conc4-rep abnf::cst)))

Theorem: cst-type-conc4-rep-tree-equiv-congruence-on-cst

(defthm cst-type-conc4-rep-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-type-conc4-rep abnf::cst)
                  (cst-type-conc4-rep cst-equiv)))
  :rule-classes :congruence)

Function: cst-named-type-conc1-rep

(defun cst-named-type-conc1-rep (abnf::cst)
 (declare (xargs :guard (abnf::treep abnf::cst)))
 (declare (xargs :guard (and (cst-matchp abnf::cst "named-type")
                             (equal (cst-named-type-conc? abnf::cst)
                                    1))))
 (let ((__function__ 'cst-named-type-conc1-rep))
   (declare (ignorable __function__))
   (abnf::tree-list-fix (nth 0 (cst-named-type-conc1 abnf::cst)))))

Theorem: tree-listp-of-cst-named-type-conc1-rep

(defthm tree-listp-of-cst-named-type-conc1-rep
  (b* ((abnf::csts (cst-named-type-conc1-rep abnf::cst)))
    (abnf::tree-listp abnf::csts))
  :rule-classes :rewrite)

Theorem: cst-named-type-conc1-rep-match

(defthm cst-named-type-conc1-rep-match
  (implies
       (and (cst-matchp abnf::cst "named-type")
            (equal (cst-named-type-conc? abnf::cst)
                   1))
       (b* ((abnf::csts (cst-named-type-conc1-rep abnf::cst)))
         (cst-list-rep-matchp abnf::csts "named-primitive-type")))
  :rule-classes :rewrite)

Theorem: cst-named-type-conc1-rep-of-tree-fix-cst

(defthm cst-named-type-conc1-rep-of-tree-fix-cst
  (equal (cst-named-type-conc1-rep (abnf::tree-fix abnf::cst))
         (cst-named-type-conc1-rep abnf::cst)))

Theorem: cst-named-type-conc1-rep-tree-equiv-congruence-on-cst

(defthm cst-named-type-conc1-rep-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-named-type-conc1-rep abnf::cst)
                  (cst-named-type-conc1-rep cst-equiv)))
  :rule-classes :congruence)

Function: cst-named-type-conc2-rep

(defun cst-named-type-conc2-rep (abnf::cst)
 (declare (xargs :guard (abnf::treep abnf::cst)))
 (declare (xargs :guard (and (cst-matchp abnf::cst "named-type")
                             (equal (cst-named-type-conc? abnf::cst)
                                    2))))
 (let ((__function__ 'cst-named-type-conc2-rep))
   (declare (ignorable __function__))
   (abnf::tree-list-fix (nth 0 (cst-named-type-conc2 abnf::cst)))))

Theorem: tree-listp-of-cst-named-type-conc2-rep

(defthm tree-listp-of-cst-named-type-conc2-rep
  (b* ((abnf::csts (cst-named-type-conc2-rep abnf::cst)))
    (abnf::tree-listp abnf::csts))
  :rule-classes :rewrite)

Theorem: cst-named-type-conc2-rep-match

(defthm cst-named-type-conc2-rep-match
 (implies (and (cst-matchp abnf::cst "named-type")
               (equal (cst-named-type-conc? abnf::cst)
                      2))
          (b* ((abnf::csts (cst-named-type-conc2-rep abnf::cst)))
            (cst-list-rep-matchp abnf::csts "untyped-future-type")))
 :rule-classes :rewrite)

Theorem: cst-named-type-conc2-rep-of-tree-fix-cst

(defthm cst-named-type-conc2-rep-of-tree-fix-cst
  (equal (cst-named-type-conc2-rep (abnf::tree-fix abnf::cst))
         (cst-named-type-conc2-rep abnf::cst)))

Theorem: cst-named-type-conc2-rep-tree-equiv-congruence-on-cst

(defthm cst-named-type-conc2-rep-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-named-type-conc2-rep abnf::cst)
                  (cst-named-type-conc2-rep cst-equiv)))
  :rule-classes :congruence)

Function: cst-named-type-conc3-rep

(defun cst-named-type-conc3-rep (abnf::cst)
 (declare (xargs :guard (abnf::treep abnf::cst)))
 (declare (xargs :guard (and (cst-matchp abnf::cst "named-type")
                             (equal (cst-named-type-conc? abnf::cst)
                                    3))))
 (let ((__function__ 'cst-named-type-conc3-rep))
   (declare (ignorable __function__))
   (abnf::tree-list-fix (nth 0 (cst-named-type-conc3 abnf::cst)))))

Theorem: tree-listp-of-cst-named-type-conc3-rep

(defthm tree-listp-of-cst-named-type-conc3-rep
  (b* ((abnf::csts (cst-named-type-conc3-rep abnf::cst)))
    (abnf::tree-listp abnf::csts))
  :rule-classes :rewrite)

Theorem: cst-named-type-conc3-rep-match

(defthm cst-named-type-conc3-rep-match
  (implies (and (cst-matchp abnf::cst "named-type")
                (equal (cst-named-type-conc? abnf::cst)
                       3))
           (b* ((abnf::csts (cst-named-type-conc3-rep abnf::cst)))
             (cst-list-rep-matchp abnf::csts "identifier")))
  :rule-classes :rewrite)

Theorem: cst-named-type-conc3-rep-of-tree-fix-cst

(defthm cst-named-type-conc3-rep-of-tree-fix-cst
  (equal (cst-named-type-conc3-rep (abnf::tree-fix abnf::cst))
         (cst-named-type-conc3-rep abnf::cst)))

Theorem: cst-named-type-conc3-rep-tree-equiv-congruence-on-cst

(defthm cst-named-type-conc3-rep-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-named-type-conc3-rep abnf::cst)
                  (cst-named-type-conc3-rep cst-equiv)))
  :rule-classes :congruence)

Function: cst-program-address-literal-conc-rep

(defun cst-program-address-literal-conc-rep (abnf::cst)
 (declare (xargs :guard (abnf::treep abnf::cst)))
 (declare
    (xargs :guard (cst-matchp abnf::cst "program-address-literal")))
 (let ((__function__ 'cst-program-address-literal-conc-rep))
   (declare (ignorable __function__))
   (abnf::tree-list-fix
        (nth 0
             (cst-program-address-literal-conc abnf::cst)))))

Theorem: tree-listp-of-cst-program-address-literal-conc-rep

(defthm tree-listp-of-cst-program-address-literal-conc-rep
 (b* ((abnf::csts (cst-program-address-literal-conc-rep abnf::cst)))
   (abnf::tree-listp abnf::csts))
 :rule-classes :rewrite)

Theorem: cst-program-address-literal-conc-rep-match

(defthm cst-program-address-literal-conc-rep-match
 (implies
   (cst-matchp abnf::cst "program-address-literal")
   (b*
     ((abnf::csts (cst-program-address-literal-conc-rep abnf::cst)))
     (cst-list-rep-matchp abnf::csts "program-id")))
 :rule-classes :rewrite)

Theorem: cst-program-address-literal-conc-rep-of-tree-fix-cst

(defthm cst-program-address-literal-conc-rep-of-tree-fix-cst
 (equal
   (cst-program-address-literal-conc-rep (abnf::tree-fix abnf::cst))
   (cst-program-address-literal-conc-rep abnf::cst)))

Theorem: cst-program-address-literal-conc-rep-tree-equiv-congruence-on-cst

(defthm
  cst-program-address-literal-conc-rep-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-program-address-literal-conc-rep abnf::cst)
                  (cst-program-address-literal-conc-rep cst-equiv)))
  :rule-classes :congruence)

Function: cst-literal-conc1-rep

(defun cst-literal-conc1-rep (abnf::cst)
  (declare (xargs :guard (abnf::treep abnf::cst)))
  (declare (xargs :guard (and (cst-matchp abnf::cst "literal")
                              (equal (cst-literal-conc? abnf::cst)
                                     1))))
  (let ((__function__ 'cst-literal-conc1-rep))
    (declare (ignorable __function__))
    (abnf::tree-list-fix (nth 0 (cst-literal-conc1 abnf::cst)))))

Theorem: tree-listp-of-cst-literal-conc1-rep

(defthm tree-listp-of-cst-literal-conc1-rep
  (b* ((abnf::csts (cst-literal-conc1-rep abnf::cst)))
    (abnf::tree-listp abnf::csts))
  :rule-classes :rewrite)

Theorem: cst-literal-conc1-rep-match

(defthm cst-literal-conc1-rep-match
  (implies (and (cst-matchp abnf::cst "literal")
                (equal (cst-literal-conc? abnf::cst) 1))
           (b* ((abnf::csts (cst-literal-conc1-rep abnf::cst)))
             (cst-list-rep-matchp abnf::csts "atomic-literal")))
  :rule-classes :rewrite)

Theorem: cst-literal-conc1-rep-of-tree-fix-cst

(defthm cst-literal-conc1-rep-of-tree-fix-cst
  (equal (cst-literal-conc1-rep (abnf::tree-fix abnf::cst))
         (cst-literal-conc1-rep abnf::cst)))

Theorem: cst-literal-conc1-rep-tree-equiv-congruence-on-cst

(defthm cst-literal-conc1-rep-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-literal-conc1-rep abnf::cst)
                  (cst-literal-conc1-rep cst-equiv)))
  :rule-classes :congruence)

Function: cst-literal-conc2-rep

(defun cst-literal-conc2-rep (abnf::cst)
  (declare (xargs :guard (abnf::treep abnf::cst)))
  (declare (xargs :guard (and (cst-matchp abnf::cst "literal")
                              (equal (cst-literal-conc? abnf::cst)
                                     2))))
  (let ((__function__ 'cst-literal-conc2-rep))
    (declare (ignorable __function__))
    (abnf::tree-list-fix (nth 0 (cst-literal-conc2 abnf::cst)))))

Theorem: tree-listp-of-cst-literal-conc2-rep

(defthm tree-listp-of-cst-literal-conc2-rep
  (b* ((abnf::csts (cst-literal-conc2-rep abnf::cst)))
    (abnf::tree-listp abnf::csts))
  :rule-classes :rewrite)

Theorem: cst-literal-conc2-rep-match

(defthm cst-literal-conc2-rep-match
 (implies
      (and (cst-matchp abnf::cst "literal")
           (equal (cst-literal-conc? abnf::cst) 2))
      (b* ((abnf::csts (cst-literal-conc2-rep abnf::cst)))
        (cst-list-rep-matchp abnf::csts "program-address-literal")))
 :rule-classes :rewrite)

Theorem: cst-literal-conc2-rep-of-tree-fix-cst

(defthm cst-literal-conc2-rep-of-tree-fix-cst
  (equal (cst-literal-conc2-rep (abnf::tree-fix abnf::cst))
         (cst-literal-conc2-rep abnf::cst)))

Theorem: cst-literal-conc2-rep-tree-equiv-congruence-on-cst

(defthm cst-literal-conc2-rep-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-literal-conc2-rep abnf::cst)
                  (cst-literal-conc2-rep cst-equiv)))
  :rule-classes :congruence)

Function: cst-address-literal-conc1-rep

(defun cst-address-literal-conc1-rep (abnf::cst)
 (declare (xargs :guard (abnf::treep abnf::cst)))
 (declare
     (xargs :guard (and (cst-matchp abnf::cst "address-literal")
                        (equal (cst-address-literal-conc? abnf::cst)
                               1))))
 (let ((__function__ 'cst-address-literal-conc1-rep))
   (declare (ignorable __function__))
   (abnf::tree-list-fix
        (nth 0
             (cst-address-literal-conc1 abnf::cst)))))

Theorem: tree-listp-of-cst-address-literal-conc1-rep

(defthm tree-listp-of-cst-address-literal-conc1-rep
  (b* ((abnf::csts (cst-address-literal-conc1-rep abnf::cst)))
    (abnf::tree-listp abnf::csts))
  :rule-classes :rewrite)

Theorem: cst-address-literal-conc1-rep-match

(defthm cst-address-literal-conc1-rep-match
 (implies
     (and (cst-matchp abnf::cst "address-literal")
          (equal (cst-address-literal-conc? abnf::cst)
                 1))
     (b* ((abnf::csts (cst-address-literal-conc1-rep abnf::cst)))
       (cst-list-rep-matchp abnf::csts "explicit-address-literal")))
 :rule-classes :rewrite)

Theorem: cst-address-literal-conc1-rep-of-tree-fix-cst

(defthm cst-address-literal-conc1-rep-of-tree-fix-cst
  (equal (cst-address-literal-conc1-rep (abnf::tree-fix abnf::cst))
         (cst-address-literal-conc1-rep abnf::cst)))

Theorem: cst-address-literal-conc1-rep-tree-equiv-congruence-on-cst

(defthm cst-address-literal-conc1-rep-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-address-literal-conc1-rep abnf::cst)
                  (cst-address-literal-conc1-rep cst-equiv)))
  :rule-classes :congruence)

Function: cst-address-literal-conc2-rep

(defun cst-address-literal-conc2-rep (abnf::cst)
 (declare (xargs :guard (abnf::treep abnf::cst)))
 (declare
     (xargs :guard (and (cst-matchp abnf::cst "address-literal")
                        (equal (cst-address-literal-conc? abnf::cst)
                               2))))
 (let ((__function__ 'cst-address-literal-conc2-rep))
   (declare (ignorable __function__))
   (abnf::tree-list-fix
        (nth 0
             (cst-address-literal-conc2 abnf::cst)))))

Theorem: tree-listp-of-cst-address-literal-conc2-rep

(defthm tree-listp-of-cst-address-literal-conc2-rep
  (b* ((abnf::csts (cst-address-literal-conc2-rep abnf::cst)))
    (abnf::tree-listp abnf::csts))
  :rule-classes :rewrite)

Theorem: cst-address-literal-conc2-rep-match

(defthm cst-address-literal-conc2-rep-match
 (implies
      (and (cst-matchp abnf::cst "address-literal")
           (equal (cst-address-literal-conc? abnf::cst)
                  2))
      (b* ((abnf::csts (cst-address-literal-conc2-rep abnf::cst)))
        (cst-list-rep-matchp abnf::csts "program-address-literal")))
 :rule-classes :rewrite)

Theorem: cst-address-literal-conc2-rep-of-tree-fix-cst

(defthm cst-address-literal-conc2-rep-of-tree-fix-cst
  (equal (cst-address-literal-conc2-rep (abnf::tree-fix abnf::cst))
         (cst-address-literal-conc2-rep abnf::cst)))

Theorem: cst-address-literal-conc2-rep-tree-equiv-congruence-on-cst

(defthm cst-address-literal-conc2-rep-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-address-literal-conc2-rep abnf::cst)
                  (cst-address-literal-conc2-rep cst-equiv)))
  :rule-classes :congruence)

Function: cst-variable-conc-rep

(defun cst-variable-conc-rep (abnf::cst)
  (declare (xargs :guard (abnf::treep abnf::cst)))
  (declare (xargs :guard (cst-matchp abnf::cst "variable")))
  (let ((__function__ 'cst-variable-conc-rep))
    (declare (ignorable __function__))
    (abnf::tree-list-fix (nth 0 (cst-variable-conc abnf::cst)))))

Theorem: tree-listp-of-cst-variable-conc-rep

(defthm tree-listp-of-cst-variable-conc-rep
  (b* ((abnf::csts (cst-variable-conc-rep abnf::cst)))
    (abnf::tree-listp abnf::csts))
  :rule-classes :rewrite)

Theorem: cst-variable-conc-rep-match

(defthm cst-variable-conc-rep-match
  (implies (cst-matchp abnf::cst "variable")
           (b* ((abnf::csts (cst-variable-conc-rep abnf::cst)))
             (cst-list-rep-matchp abnf::csts "identifier")))
  :rule-classes :rewrite)

Theorem: cst-variable-conc-rep-of-tree-fix-cst

(defthm cst-variable-conc-rep-of-tree-fix-cst
  (equal (cst-variable-conc-rep (abnf::tree-fix abnf::cst))
         (cst-variable-conc-rep abnf::cst)))

Theorem: cst-variable-conc-rep-tree-equiv-congruence-on-cst

(defthm cst-variable-conc-rep-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-variable-conc-rep abnf::cst)
                  (cst-variable-conc-rep cst-equiv)))
  :rule-classes :congruence)

Function: cst-postfix-expression-conc1-rep

(defun cst-postfix-expression-conc1-rep (abnf::cst)
 (declare (xargs :guard (abnf::treep abnf::cst)))
 (declare
  (xargs :guard (and (cst-matchp abnf::cst "postfix-expression")
                     (equal (cst-postfix-expression-conc? abnf::cst)
                            1))))
 (let ((__function__ 'cst-postfix-expression-conc1-rep))
   (declare (ignorable __function__))
   (abnf::tree-list-fix
        (nth 0
             (cst-postfix-expression-conc1 abnf::cst)))))

Theorem: tree-listp-of-cst-postfix-expression-conc1-rep

(defthm tree-listp-of-cst-postfix-expression-conc1-rep
  (b* ((abnf::csts (cst-postfix-expression-conc1-rep abnf::cst)))
    (abnf::tree-listp abnf::csts))
  :rule-classes :rewrite)

Theorem: cst-postfix-expression-conc1-rep-match

(defthm cst-postfix-expression-conc1-rep-match
 (implies
     (and (cst-matchp abnf::cst "postfix-expression")
          (equal (cst-postfix-expression-conc? abnf::cst)
                 1))
     (b* ((abnf::csts (cst-postfix-expression-conc1-rep abnf::cst)))
       (cst-list-rep-matchp abnf::csts "primary-expression")))
 :rule-classes :rewrite)

Theorem: cst-postfix-expression-conc1-rep-of-tree-fix-cst

(defthm cst-postfix-expression-conc1-rep-of-tree-fix-cst
  (equal
       (cst-postfix-expression-conc1-rep (abnf::tree-fix abnf::cst))
       (cst-postfix-expression-conc1-rep abnf::cst)))

Theorem: cst-postfix-expression-conc1-rep-tree-equiv-congruence-on-cst

(defthm
      cst-postfix-expression-conc1-rep-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-postfix-expression-conc1-rep abnf::cst)
                  (cst-postfix-expression-conc1-rep cst-equiv)))
  :rule-classes :congruence)

Function: cst-postfix-expression-conc2-rep

(defun cst-postfix-expression-conc2-rep (abnf::cst)
 (declare (xargs :guard (abnf::treep abnf::cst)))
 (declare
  (xargs :guard (and (cst-matchp abnf::cst "postfix-expression")
                     (equal (cst-postfix-expression-conc? abnf::cst)
                            2))))
 (let ((__function__ 'cst-postfix-expression-conc2-rep))
   (declare (ignorable __function__))
   (abnf::tree-list-fix
        (nth 0
             (cst-postfix-expression-conc2 abnf::cst)))))

Theorem: tree-listp-of-cst-postfix-expression-conc2-rep

(defthm tree-listp-of-cst-postfix-expression-conc2-rep
  (b* ((abnf::csts (cst-postfix-expression-conc2-rep abnf::cst)))
    (abnf::tree-listp abnf::csts))
  :rule-classes :rewrite)

Theorem: cst-postfix-expression-conc2-rep-match

(defthm cst-postfix-expression-conc2-rep-match
 (implies
     (and (cst-matchp abnf::cst "postfix-expression")
          (equal (cst-postfix-expression-conc? abnf::cst)
                 2))
     (b* ((abnf::csts (cst-postfix-expression-conc2-rep abnf::cst)))
       (cst-list-rep-matchp abnf::csts
                            "tuple-component-expression")))
 :rule-classes :rewrite)

Theorem: cst-postfix-expression-conc2-rep-of-tree-fix-cst

(defthm cst-postfix-expression-conc2-rep-of-tree-fix-cst
  (equal
       (cst-postfix-expression-conc2-rep (abnf::tree-fix abnf::cst))
       (cst-postfix-expression-conc2-rep abnf::cst)))

Theorem: cst-postfix-expression-conc2-rep-tree-equiv-congruence-on-cst

(defthm
      cst-postfix-expression-conc2-rep-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-postfix-expression-conc2-rep abnf::cst)
                  (cst-postfix-expression-conc2-rep cst-equiv)))
  :rule-classes :congruence)

Function: cst-postfix-expression-conc3-rep

(defun cst-postfix-expression-conc3-rep (abnf::cst)
 (declare (xargs :guard (abnf::treep abnf::cst)))
 (declare
  (xargs :guard (and (cst-matchp abnf::cst "postfix-expression")
                     (equal (cst-postfix-expression-conc? abnf::cst)
                            3))))
 (let ((__function__ 'cst-postfix-expression-conc3-rep))
   (declare (ignorable __function__))
   (abnf::tree-list-fix
        (nth 0
             (cst-postfix-expression-conc3 abnf::cst)))))

Theorem: tree-listp-of-cst-postfix-expression-conc3-rep

(defthm tree-listp-of-cst-postfix-expression-conc3-rep
  (b* ((abnf::csts (cst-postfix-expression-conc3-rep abnf::cst)))
    (abnf::tree-listp abnf::csts))
  :rule-classes :rewrite)

Theorem: cst-postfix-expression-conc3-rep-match

(defthm cst-postfix-expression-conc3-rep-match
 (implies
     (and (cst-matchp abnf::cst "postfix-expression")
          (equal (cst-postfix-expression-conc? abnf::cst)
                 3))
     (b* ((abnf::csts (cst-postfix-expression-conc3-rep abnf::cst)))
       (cst-list-rep-matchp abnf::csts
                            "array-component-expression")))
 :rule-classes :rewrite)

Theorem: cst-postfix-expression-conc3-rep-of-tree-fix-cst

(defthm cst-postfix-expression-conc3-rep-of-tree-fix-cst
  (equal
       (cst-postfix-expression-conc3-rep (abnf::tree-fix abnf::cst))
       (cst-postfix-expression-conc3-rep abnf::cst)))

Theorem: cst-postfix-expression-conc3-rep-tree-equiv-congruence-on-cst

(defthm
      cst-postfix-expression-conc3-rep-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-postfix-expression-conc3-rep abnf::cst)
                  (cst-postfix-expression-conc3-rep cst-equiv)))
  :rule-classes :congruence)

Function: cst-postfix-expression-conc4-rep

(defun cst-postfix-expression-conc4-rep (abnf::cst)
 (declare (xargs :guard (abnf::treep abnf::cst)))
 (declare
  (xargs :guard (and (cst-matchp abnf::cst "postfix-expression")
                     (equal (cst-postfix-expression-conc? abnf::cst)
                            4))))
 (let ((__function__ 'cst-postfix-expression-conc4-rep))
   (declare (ignorable __function__))
   (abnf::tree-list-fix
        (nth 0
             (cst-postfix-expression-conc4 abnf::cst)))))

Theorem: tree-listp-of-cst-postfix-expression-conc4-rep

(defthm tree-listp-of-cst-postfix-expression-conc4-rep
  (b* ((abnf::csts (cst-postfix-expression-conc4-rep abnf::cst)))
    (abnf::tree-listp abnf::csts))
  :rule-classes :rewrite)

Theorem: cst-postfix-expression-conc4-rep-match

(defthm cst-postfix-expression-conc4-rep-match
 (implies
     (and (cst-matchp abnf::cst "postfix-expression")
          (equal (cst-postfix-expression-conc? abnf::cst)
                 4))
     (b* ((abnf::csts (cst-postfix-expression-conc4-rep abnf::cst)))
       (cst-list-rep-matchp abnf::csts
                            "struct-component-expression")))
 :rule-classes :rewrite)

Theorem: cst-postfix-expression-conc4-rep-of-tree-fix-cst

(defthm cst-postfix-expression-conc4-rep-of-tree-fix-cst
  (equal
       (cst-postfix-expression-conc4-rep (abnf::tree-fix abnf::cst))
       (cst-postfix-expression-conc4-rep abnf::cst)))

Theorem: cst-postfix-expression-conc4-rep-tree-equiv-congruence-on-cst

(defthm
      cst-postfix-expression-conc4-rep-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-postfix-expression-conc4-rep abnf::cst)
                  (cst-postfix-expression-conc4-rep cst-equiv)))
  :rule-classes :congruence)

Function: cst-postfix-expression-conc5-rep

(defun cst-postfix-expression-conc5-rep (abnf::cst)
 (declare (xargs :guard (abnf::treep abnf::cst)))
 (declare
  (xargs :guard (and (cst-matchp abnf::cst "postfix-expression")
                     (equal (cst-postfix-expression-conc? abnf::cst)
                            5))))
 (let ((__function__ 'cst-postfix-expression-conc5-rep))
   (declare (ignorable __function__))
   (abnf::tree-list-fix
        (nth 0
             (cst-postfix-expression-conc5 abnf::cst)))))

Theorem: tree-listp-of-cst-postfix-expression-conc5-rep

(defthm tree-listp-of-cst-postfix-expression-conc5-rep
  (b* ((abnf::csts (cst-postfix-expression-conc5-rep abnf::cst)))
    (abnf::tree-listp abnf::csts))
  :rule-classes :rewrite)

Theorem: cst-postfix-expression-conc5-rep-match

(defthm cst-postfix-expression-conc5-rep-match
 (implies
     (and (cst-matchp abnf::cst "postfix-expression")
          (equal (cst-postfix-expression-conc? abnf::cst)
                 5))
     (b* ((abnf::csts (cst-postfix-expression-conc5-rep abnf::cst)))
       (cst-list-rep-matchp abnf::csts "method-call")))
 :rule-classes :rewrite)

Theorem: cst-postfix-expression-conc5-rep-of-tree-fix-cst

(defthm cst-postfix-expression-conc5-rep-of-tree-fix-cst
  (equal
       (cst-postfix-expression-conc5-rep (abnf::tree-fix abnf::cst))
       (cst-postfix-expression-conc5-rep abnf::cst)))

Theorem: cst-postfix-expression-conc5-rep-tree-equiv-congruence-on-cst

(defthm
      cst-postfix-expression-conc5-rep-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-postfix-expression-conc5-rep abnf::cst)
                  (cst-postfix-expression-conc5-rep cst-equiv)))
  :rule-classes :congruence)

Function: cst-binary-expression-conc-rep

(defun cst-binary-expression-conc-rep (abnf::cst)
 (declare (xargs :guard (abnf::treep abnf::cst)))
 (declare (xargs :guard (cst-matchp abnf::cst "binary-expression")))
 (let ((__function__ 'cst-binary-expression-conc-rep))
   (declare (ignorable __function__))
   (abnf::tree-list-fix
        (nth 0
             (cst-binary-expression-conc abnf::cst)))))

Theorem: tree-listp-of-cst-binary-expression-conc-rep

(defthm tree-listp-of-cst-binary-expression-conc-rep
  (b* ((abnf::csts (cst-binary-expression-conc-rep abnf::cst)))
    (abnf::tree-listp abnf::csts))
  :rule-classes :rewrite)

Theorem: cst-binary-expression-conc-rep-match

(defthm cst-binary-expression-conc-rep-match
 (implies
      (cst-matchp abnf::cst "binary-expression")
      (b* ((abnf::csts (cst-binary-expression-conc-rep abnf::cst)))
        (cst-list-rep-matchp abnf::csts
                             "conditional-disjunctive-expression")))
 :rule-classes :rewrite)

Theorem: cst-binary-expression-conc-rep-of-tree-fix-cst

(defthm cst-binary-expression-conc-rep-of-tree-fix-cst
  (equal (cst-binary-expression-conc-rep (abnf::tree-fix abnf::cst))
         (cst-binary-expression-conc-rep abnf::cst)))

Theorem: cst-binary-expression-conc-rep-tree-equiv-congruence-on-cst

(defthm cst-binary-expression-conc-rep-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-binary-expression-conc-rep abnf::cst)
                  (cst-binary-expression-conc-rep cst-equiv)))
  :rule-classes :congruence)

Function: cst-expression-conc-rep

(defun cst-expression-conc-rep (abnf::cst)
  (declare (xargs :guard (abnf::treep abnf::cst)))
  (declare (xargs :guard (cst-matchp abnf::cst "expression")))
  (let ((__function__ 'cst-expression-conc-rep))
    (declare (ignorable __function__))
    (abnf::tree-list-fix (nth 0 (cst-expression-conc abnf::cst)))))

Theorem: tree-listp-of-cst-expression-conc-rep

(defthm tree-listp-of-cst-expression-conc-rep
  (b* ((abnf::csts (cst-expression-conc-rep abnf::cst)))
    (abnf::tree-listp abnf::csts))
  :rule-classes :rewrite)

Theorem: cst-expression-conc-rep-match

(defthm cst-expression-conc-rep-match
 (implies (cst-matchp abnf::cst "expression")
          (b* ((abnf::csts (cst-expression-conc-rep abnf::cst)))
            (cst-list-rep-matchp abnf::csts
                                 "conditional-ternary-expression")))
 :rule-classes :rewrite)

Theorem: cst-expression-conc-rep-of-tree-fix-cst

(defthm cst-expression-conc-rep-of-tree-fix-cst
  (equal (cst-expression-conc-rep (abnf::tree-fix abnf::cst))
         (cst-expression-conc-rep abnf::cst)))

Theorem: cst-expression-conc-rep-tree-equiv-congruence-on-cst

(defthm cst-expression-conc-rep-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-expression-conc-rep abnf::cst)
                  (cst-expression-conc-rep cst-equiv)))
  :rule-classes :congruence)

Function: cst-statement-conc1-rep

(defun cst-statement-conc1-rep (abnf::cst)
  (declare (xargs :guard (abnf::treep abnf::cst)))
  (declare (xargs :guard (and (cst-matchp abnf::cst "statement")
                              (equal (cst-statement-conc? abnf::cst)
                                     1))))
  (let ((__function__ 'cst-statement-conc1-rep))
    (declare (ignorable __function__))
    (abnf::tree-list-fix (nth 0 (cst-statement-conc1 abnf::cst)))))

Theorem: tree-listp-of-cst-statement-conc1-rep

(defthm tree-listp-of-cst-statement-conc1-rep
  (b* ((abnf::csts (cst-statement-conc1-rep abnf::cst)))
    (abnf::tree-listp abnf::csts))
  :rule-classes :rewrite)

Theorem: cst-statement-conc1-rep-match

(defthm cst-statement-conc1-rep-match
  (implies
       (and (cst-matchp abnf::cst "statement")
            (equal (cst-statement-conc? abnf::cst)
                   1))
       (b* ((abnf::csts (cst-statement-conc1-rep abnf::cst)))
         (cst-list-rep-matchp abnf::csts "expression-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 "return-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 "variable-declaration")))
  :rule-classes :rewrite)

Theorem: cst-statement-conc3-rep-of-tree-fix-cst

(defthm cst-statement-conc3-rep-of-tree-fix-cst
  (equal (cst-statement-conc3-rep (abnf::tree-fix abnf::cst))
         (cst-statement-conc3-rep abnf::cst)))

Theorem: cst-statement-conc3-rep-tree-equiv-congruence-on-cst

(defthm cst-statement-conc3-rep-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-statement-conc3-rep abnf::cst)
                  (cst-statement-conc3-rep cst-equiv)))
  :rule-classes :congruence)

Function: cst-statement-conc4-rep

(defun cst-statement-conc4-rep (abnf::cst)
  (declare (xargs :guard (abnf::treep abnf::cst)))
  (declare (xargs :guard (and (cst-matchp abnf::cst "statement")
                              (equal (cst-statement-conc? abnf::cst)
                                     4))))
  (let ((__function__ 'cst-statement-conc4-rep))
    (declare (ignorable __function__))
    (abnf::tree-list-fix (nth 0 (cst-statement-conc4 abnf::cst)))))

Theorem: tree-listp-of-cst-statement-conc4-rep

(defthm tree-listp-of-cst-statement-conc4-rep
  (b* ((abnf::csts (cst-statement-conc4-rep abnf::cst)))
    (abnf::tree-listp abnf::csts))
  :rule-classes :rewrite)

Theorem: cst-statement-conc4-rep-match

(defthm cst-statement-conc4-rep-match
  (implies
       (and (cst-matchp abnf::cst "statement")
            (equal (cst-statement-conc? abnf::cst)
                   4))
       (b* ((abnf::csts (cst-statement-conc4-rep abnf::cst)))
         (cst-list-rep-matchp abnf::csts "constant-declaration")))
  :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 "conditional-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 "loop-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 "assignment-statement")))
  :rule-classes :rewrite)

Theorem: cst-statement-conc7-rep-of-tree-fix-cst

(defthm cst-statement-conc7-rep-of-tree-fix-cst
  (equal (cst-statement-conc7-rep (abnf::tree-fix abnf::cst))
         (cst-statement-conc7-rep abnf::cst)))

Theorem: cst-statement-conc7-rep-tree-equiv-congruence-on-cst

(defthm cst-statement-conc7-rep-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-statement-conc7-rep abnf::cst)
                  (cst-statement-conc7-rep cst-equiv)))
  :rule-classes :congruence)

Function: cst-statement-conc8-rep

(defun cst-statement-conc8-rep (abnf::cst)
  (declare (xargs :guard (abnf::treep abnf::cst)))
  (declare (xargs :guard (and (cst-matchp abnf::cst "statement")
                              (equal (cst-statement-conc? abnf::cst)
                                     8))))
  (let ((__function__ 'cst-statement-conc8-rep))
    (declare (ignorable __function__))
    (abnf::tree-list-fix (nth 0 (cst-statement-conc8 abnf::cst)))))

Theorem: tree-listp-of-cst-statement-conc8-rep

(defthm tree-listp-of-cst-statement-conc8-rep
  (b* ((abnf::csts (cst-statement-conc8-rep abnf::cst)))
    (abnf::tree-listp abnf::csts))
  :rule-classes :rewrite)

Theorem: cst-statement-conc8-rep-match

(defthm cst-statement-conc8-rep-match
  (implies (and (cst-matchp abnf::cst "statement")
                (equal (cst-statement-conc? abnf::cst)
                       8))
           (b* ((abnf::csts (cst-statement-conc8-rep abnf::cst)))
             (cst-list-rep-matchp abnf::csts "block")))
  :rule-classes :rewrite)

Theorem: cst-statement-conc8-rep-of-tree-fix-cst

(defthm cst-statement-conc8-rep-of-tree-fix-cst
  (equal (cst-statement-conc8-rep (abnf::tree-fix abnf::cst))
         (cst-statement-conc8-rep abnf::cst)))

Theorem: cst-statement-conc8-rep-tree-equiv-congruence-on-cst

(defthm cst-statement-conc8-rep-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-statement-conc8-rep abnf::cst)
                  (cst-statement-conc8-rep cst-equiv)))
  :rule-classes :congruence)

Function: cst-program-item-conc1-rep

(defun cst-program-item-conc1-rep (abnf::cst)
 (declare (xargs :guard (abnf::treep abnf::cst)))
 (declare
      (xargs :guard (and (cst-matchp abnf::cst "program-item")
                         (equal (cst-program-item-conc? abnf::cst)
                                1))))
 (let ((__function__ 'cst-program-item-conc1-rep))
  (declare (ignorable __function__))
  (abnf::tree-list-fix (nth 0 (cst-program-item-conc1 abnf::cst)))))

Theorem: tree-listp-of-cst-program-item-conc1-rep

(defthm tree-listp-of-cst-program-item-conc1-rep
  (b* ((abnf::csts (cst-program-item-conc1-rep abnf::cst)))
    (abnf::tree-listp abnf::csts))
  :rule-classes :rewrite)

Theorem: cst-program-item-conc1-rep-match

(defthm cst-program-item-conc1-rep-match
  (implies
       (and (cst-matchp abnf::cst "program-item")
            (equal (cst-program-item-conc? abnf::cst)
                   1))
       (b* ((abnf::csts (cst-program-item-conc1-rep abnf::cst)))
         (cst-list-rep-matchp abnf::csts "function-declaration")))
  :rule-classes :rewrite)

Theorem: cst-program-item-conc1-rep-of-tree-fix-cst

(defthm cst-program-item-conc1-rep-of-tree-fix-cst
  (equal (cst-program-item-conc1-rep (abnf::tree-fix abnf::cst))
         (cst-program-item-conc1-rep abnf::cst)))

Theorem: cst-program-item-conc1-rep-tree-equiv-congruence-on-cst

(defthm cst-program-item-conc1-rep-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-program-item-conc1-rep abnf::cst)
                  (cst-program-item-conc1-rep cst-equiv)))
  :rule-classes :congruence)

Function: cst-program-item-conc2-rep

(defun cst-program-item-conc2-rep (abnf::cst)
 (declare (xargs :guard (abnf::treep abnf::cst)))
 (declare
      (xargs :guard (and (cst-matchp abnf::cst "program-item")
                         (equal (cst-program-item-conc? abnf::cst)
                                2))))
 (let ((__function__ 'cst-program-item-conc2-rep))
  (declare (ignorable __function__))
  (abnf::tree-list-fix (nth 0 (cst-program-item-conc2 abnf::cst)))))

Theorem: tree-listp-of-cst-program-item-conc2-rep

(defthm tree-listp-of-cst-program-item-conc2-rep
  (b* ((abnf::csts (cst-program-item-conc2-rep abnf::cst)))
    (abnf::tree-listp abnf::csts))
  :rule-classes :rewrite)

Theorem: cst-program-item-conc2-rep-match

(defthm cst-program-item-conc2-rep-match
  (implies (and (cst-matchp abnf::cst "program-item")
                (equal (cst-program-item-conc? abnf::cst)
                       2))
           (b* ((abnf::csts (cst-program-item-conc2-rep abnf::cst)))
             (cst-list-rep-matchp abnf::csts "struct-declaration")))
  :rule-classes :rewrite)

Theorem: cst-program-item-conc2-rep-of-tree-fix-cst

(defthm cst-program-item-conc2-rep-of-tree-fix-cst
  (equal (cst-program-item-conc2-rep (abnf::tree-fix abnf::cst))
         (cst-program-item-conc2-rep abnf::cst)))

Theorem: cst-program-item-conc2-rep-tree-equiv-congruence-on-cst

(defthm cst-program-item-conc2-rep-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-program-item-conc2-rep abnf::cst)
                  (cst-program-item-conc2-rep cst-equiv)))
  :rule-classes :congruence)

Function: cst-program-item-conc3-rep

(defun cst-program-item-conc3-rep (abnf::cst)
 (declare (xargs :guard (abnf::treep abnf::cst)))
 (declare
      (xargs :guard (and (cst-matchp abnf::cst "program-item")
                         (equal (cst-program-item-conc? abnf::cst)
                                3))))
 (let ((__function__ 'cst-program-item-conc3-rep))
  (declare (ignorable __function__))
  (abnf::tree-list-fix (nth 0 (cst-program-item-conc3 abnf::cst)))))

Theorem: tree-listp-of-cst-program-item-conc3-rep

(defthm tree-listp-of-cst-program-item-conc3-rep
  (b* ((abnf::csts (cst-program-item-conc3-rep abnf::cst)))
    (abnf::tree-listp abnf::csts))
  :rule-classes :rewrite)

Theorem: cst-program-item-conc3-rep-match

(defthm cst-program-item-conc3-rep-match
  (implies (and (cst-matchp abnf::cst "program-item")
                (equal (cst-program-item-conc? abnf::cst)
                       3))
           (b* ((abnf::csts (cst-program-item-conc3-rep abnf::cst)))
             (cst-list-rep-matchp abnf::csts "record-declaration")))
  :rule-classes :rewrite)

Theorem: cst-program-item-conc3-rep-of-tree-fix-cst

(defthm cst-program-item-conc3-rep-of-tree-fix-cst
  (equal (cst-program-item-conc3-rep (abnf::tree-fix abnf::cst))
         (cst-program-item-conc3-rep abnf::cst)))

Theorem: cst-program-item-conc3-rep-tree-equiv-congruence-on-cst

(defthm cst-program-item-conc3-rep-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-program-item-conc3-rep abnf::cst)
                  (cst-program-item-conc3-rep cst-equiv)))
  :rule-classes :congruence)

Function: cst-program-item-conc4-rep

(defun cst-program-item-conc4-rep (abnf::cst)
 (declare (xargs :guard (abnf::treep abnf::cst)))
 (declare
      (xargs :guard (and (cst-matchp abnf::cst "program-item")
                         (equal (cst-program-item-conc? abnf::cst)
                                4))))
 (let ((__function__ 'cst-program-item-conc4-rep))
  (declare (ignorable __function__))
  (abnf::tree-list-fix (nth 0 (cst-program-item-conc4 abnf::cst)))))

Theorem: tree-listp-of-cst-program-item-conc4-rep

(defthm tree-listp-of-cst-program-item-conc4-rep
  (b* ((abnf::csts (cst-program-item-conc4-rep abnf::cst)))
    (abnf::tree-listp abnf::csts))
  :rule-classes :rewrite)

Theorem: cst-program-item-conc4-rep-match

(defthm cst-program-item-conc4-rep-match
 (implies (and (cst-matchp abnf::cst "program-item")
               (equal (cst-program-item-conc? abnf::cst)
                      4))
          (b* ((abnf::csts (cst-program-item-conc4-rep abnf::cst)))
            (cst-list-rep-matchp abnf::csts "mapping-declaration")))
 :rule-classes :rewrite)

Theorem: cst-program-item-conc4-rep-of-tree-fix-cst

(defthm cst-program-item-conc4-rep-of-tree-fix-cst
  (equal (cst-program-item-conc4-rep (abnf::tree-fix abnf::cst))
         (cst-program-item-conc4-rep abnf::cst)))

Theorem: cst-program-item-conc4-rep-tree-equiv-congruence-on-cst

(defthm cst-program-item-conc4-rep-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-program-item-conc4-rep abnf::cst)
                  (cst-program-item-conc4-rep cst-equiv)))
  :rule-classes :congruence)

Function: cst-program-item-conc5-rep

(defun cst-program-item-conc5-rep (abnf::cst)
 (declare (xargs :guard (abnf::treep abnf::cst)))
 (declare
      (xargs :guard (and (cst-matchp abnf::cst "program-item")
                         (equal (cst-program-item-conc? abnf::cst)
                                5))))
 (let ((__function__ 'cst-program-item-conc5-rep))
  (declare (ignorable __function__))
  (abnf::tree-list-fix (nth 0 (cst-program-item-conc5 abnf::cst)))))

Theorem: tree-listp-of-cst-program-item-conc5-rep

(defthm tree-listp-of-cst-program-item-conc5-rep
  (b* ((abnf::csts (cst-program-item-conc5-rep abnf::cst)))
    (abnf::tree-listp abnf::csts))
  :rule-classes :rewrite)

Theorem: cst-program-item-conc5-rep-match

(defthm cst-program-item-conc5-rep-match
  (implies
       (and (cst-matchp abnf::cst "program-item")
            (equal (cst-program-item-conc? abnf::cst)
                   5))
       (b* ((abnf::csts (cst-program-item-conc5-rep abnf::cst)))
         (cst-list-rep-matchp abnf::csts "constant-declaration")))
  :rule-classes :rewrite)

Theorem: cst-program-item-conc5-rep-of-tree-fix-cst

(defthm cst-program-item-conc5-rep-of-tree-fix-cst
  (equal (cst-program-item-conc5-rep (abnf::tree-fix abnf::cst))
         (cst-program-item-conc5-rep abnf::cst)))

Theorem: cst-program-item-conc5-rep-tree-equiv-congruence-on-cst

(defthm cst-program-item-conc5-rep-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-program-item-conc5-rep abnf::cst)
                  (cst-program-item-conc5-rep cst-equiv)))
  :rule-classes :congruence)

Function: cst-ascii-conc-rep-elem

(defun cst-ascii-conc-rep-elem (abnf::cst)
  (declare (xargs :guard (abnf::treep abnf::cst)))
  (declare (xargs :guard (cst-matchp abnf::cst "ascii")))
  (let ((__function__ 'cst-ascii-conc-rep-elem))
    (declare (ignorable __function__))
    (abnf::tree-fix (nth 0 (cst-ascii-conc-rep abnf::cst)))))

Theorem: treep-of-cst-ascii-conc-rep-elem

(defthm treep-of-cst-ascii-conc-rep-elem
  (b* ((abnf::cst1 (cst-ascii-conc-rep-elem abnf::cst)))
    (abnf::treep abnf::cst1))
  :rule-classes :rewrite)

Theorem: cst-ascii-conc-rep-elem-match

(defthm cst-ascii-conc-rep-elem-match
  (implies (cst-matchp abnf::cst "ascii")
           (b* ((abnf::cst1 (cst-ascii-conc-rep-elem abnf::cst)))
             (cst-matchp abnf::cst1 "%x0-7F")))
  :rule-classes :rewrite)

Theorem: cst-ascii-conc-rep-elem-of-tree-fix-cst

(defthm cst-ascii-conc-rep-elem-of-tree-fix-cst
  (equal (cst-ascii-conc-rep-elem (abnf::tree-fix abnf::cst))
         (cst-ascii-conc-rep-elem abnf::cst)))

Theorem: cst-ascii-conc-rep-elem-tree-equiv-congruence-on-cst

(defthm cst-ascii-conc-rep-elem-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-ascii-conc-rep-elem abnf::cst)
                  (cst-ascii-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 "ascii")))
  :rule-classes :rewrite)

Theorem: cst-character-conc1-rep-elem-of-tree-fix-cst

(defthm cst-character-conc1-rep-elem-of-tree-fix-cst
  (equal (cst-character-conc1-rep-elem (abnf::tree-fix abnf::cst))
         (cst-character-conc1-rep-elem abnf::cst)))

Theorem: cst-character-conc1-rep-elem-tree-equiv-congruence-on-cst

(defthm cst-character-conc1-rep-elem-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-character-conc1-rep-elem abnf::cst)
                  (cst-character-conc1-rep-elem cst-equiv)))
  :rule-classes :congruence)

Function: cst-character-conc2-rep-elem

(defun cst-character-conc2-rep-elem (abnf::cst)
  (declare (xargs :guard (abnf::treep abnf::cst)))
  (declare (xargs :guard (and (cst-matchp abnf::cst "character")
                              (equal (cst-character-conc? abnf::cst)
                                     2))))
  (let ((__function__ 'cst-character-conc2-rep-elem))
    (declare (ignorable __function__))
    (abnf::tree-fix (nth 0
                         (cst-character-conc2-rep abnf::cst)))))

Theorem: treep-of-cst-character-conc2-rep-elem

(defthm treep-of-cst-character-conc2-rep-elem
  (b* ((abnf::cst1 (cst-character-conc2-rep-elem abnf::cst)))
    (abnf::treep abnf::cst1))
  :rule-classes :rewrite)

Theorem: cst-character-conc2-rep-elem-match

(defthm cst-character-conc2-rep-elem-match
  (implies
       (and (cst-matchp abnf::cst "character")
            (equal (cst-character-conc? abnf::cst)
                   2))
       (b* ((abnf::cst1 (cst-character-conc2-rep-elem abnf::cst)))
         (cst-matchp abnf::cst1 "safe-nonascii")))
  :rule-classes :rewrite)

Theorem: cst-character-conc2-rep-elem-of-tree-fix-cst

(defthm cst-character-conc2-rep-elem-of-tree-fix-cst
  (equal (cst-character-conc2-rep-elem (abnf::tree-fix abnf::cst))
         (cst-character-conc2-rep-elem abnf::cst)))

Theorem: cst-character-conc2-rep-elem-tree-equiv-congruence-on-cst

(defthm cst-character-conc2-rep-elem-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-character-conc2-rep-elem abnf::cst)
                  (cst-character-conc2-rep-elem cst-equiv)))
  :rule-classes :congruence)

Function: cst-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-whitespace-conc1-rep-elem

(defun cst-whitespace-conc1-rep-elem (abnf::cst)
 (declare (xargs :guard (abnf::treep abnf::cst)))
 (declare (xargs :guard (and (cst-matchp abnf::cst "whitespace")
                             (equal (cst-whitespace-conc? abnf::cst)
                                    1))))
 (let ((__function__ 'cst-whitespace-conc1-rep-elem))
   (declare (ignorable __function__))
   (abnf::tree-fix (nth 0
                        (cst-whitespace-conc1-rep abnf::cst)))))

Theorem: treep-of-cst-whitespace-conc1-rep-elem

(defthm treep-of-cst-whitespace-conc1-rep-elem
  (b* ((abnf::cst1 (cst-whitespace-conc1-rep-elem abnf::cst)))
    (abnf::treep abnf::cst1))
  :rule-classes :rewrite)

Theorem: cst-whitespace-conc1-rep-elem-match

(defthm cst-whitespace-conc1-rep-elem-match
  (implies
       (and (cst-matchp abnf::cst "whitespace")
            (equal (cst-whitespace-conc? abnf::cst)
                   1))
       (b* ((abnf::cst1 (cst-whitespace-conc1-rep-elem abnf::cst)))
         (cst-matchp abnf::cst1 "space")))
  :rule-classes :rewrite)

Theorem: cst-whitespace-conc1-rep-elem-of-tree-fix-cst

(defthm cst-whitespace-conc1-rep-elem-of-tree-fix-cst
  (equal (cst-whitespace-conc1-rep-elem (abnf::tree-fix abnf::cst))
         (cst-whitespace-conc1-rep-elem abnf::cst)))

Theorem: cst-whitespace-conc1-rep-elem-tree-equiv-congruence-on-cst

(defthm cst-whitespace-conc1-rep-elem-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-whitespace-conc1-rep-elem abnf::cst)
                  (cst-whitespace-conc1-rep-elem cst-equiv)))
  :rule-classes :congruence)

Function: cst-whitespace-conc2-rep-elem

(defun cst-whitespace-conc2-rep-elem (abnf::cst)
 (declare (xargs :guard (abnf::treep abnf::cst)))
 (declare (xargs :guard (and (cst-matchp abnf::cst "whitespace")
                             (equal (cst-whitespace-conc? abnf::cst)
                                    2))))
 (let ((__function__ 'cst-whitespace-conc2-rep-elem))
   (declare (ignorable __function__))
   (abnf::tree-fix (nth 0
                        (cst-whitespace-conc2-rep abnf::cst)))))

Theorem: treep-of-cst-whitespace-conc2-rep-elem

(defthm treep-of-cst-whitespace-conc2-rep-elem
  (b* ((abnf::cst1 (cst-whitespace-conc2-rep-elem abnf::cst)))
    (abnf::treep abnf::cst1))
  :rule-classes :rewrite)

Theorem: cst-whitespace-conc2-rep-elem-match

(defthm cst-whitespace-conc2-rep-elem-match
  (implies
       (and (cst-matchp abnf::cst "whitespace")
            (equal (cst-whitespace-conc? abnf::cst)
                   2))
       (b* ((abnf::cst1 (cst-whitespace-conc2-rep-elem abnf::cst)))
         (cst-matchp abnf::cst1 "horizontal-tab")))
  :rule-classes :rewrite)

Theorem: cst-whitespace-conc2-rep-elem-of-tree-fix-cst

(defthm cst-whitespace-conc2-rep-elem-of-tree-fix-cst
  (equal (cst-whitespace-conc2-rep-elem (abnf::tree-fix abnf::cst))
         (cst-whitespace-conc2-rep-elem abnf::cst)))

Theorem: cst-whitespace-conc2-rep-elem-tree-equiv-congruence-on-cst

(defthm cst-whitespace-conc2-rep-elem-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-whitespace-conc2-rep-elem abnf::cst)
                  (cst-whitespace-conc2-rep-elem cst-equiv)))
  :rule-classes :congruence)

Function: cst-whitespace-conc3-rep-elem

(defun cst-whitespace-conc3-rep-elem (abnf::cst)
 (declare (xargs :guard (abnf::treep abnf::cst)))
 (declare (xargs :guard (and (cst-matchp abnf::cst "whitespace")
                             (equal (cst-whitespace-conc? abnf::cst)
                                    3))))
 (let ((__function__ 'cst-whitespace-conc3-rep-elem))
   (declare (ignorable __function__))
   (abnf::tree-fix (nth 0
                        (cst-whitespace-conc3-rep abnf::cst)))))

Theorem: treep-of-cst-whitespace-conc3-rep-elem

(defthm treep-of-cst-whitespace-conc3-rep-elem
  (b* ((abnf::cst1 (cst-whitespace-conc3-rep-elem abnf::cst)))
    (abnf::treep abnf::cst1))
  :rule-classes :rewrite)

Theorem: cst-whitespace-conc3-rep-elem-match

(defthm cst-whitespace-conc3-rep-elem-match
  (implies
       (and (cst-matchp abnf::cst "whitespace")
            (equal (cst-whitespace-conc? abnf::cst)
                   3))
       (b* ((abnf::cst1 (cst-whitespace-conc3-rep-elem abnf::cst)))
         (cst-matchp abnf::cst1 "form-feed")))
  :rule-classes :rewrite)

Theorem: cst-whitespace-conc3-rep-elem-of-tree-fix-cst

(defthm cst-whitespace-conc3-rep-elem-of-tree-fix-cst
  (equal (cst-whitespace-conc3-rep-elem (abnf::tree-fix abnf::cst))
         (cst-whitespace-conc3-rep-elem abnf::cst)))

Theorem: cst-whitespace-conc3-rep-elem-tree-equiv-congruence-on-cst

(defthm cst-whitespace-conc3-rep-elem-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-whitespace-conc3-rep-elem abnf::cst)
                  (cst-whitespace-conc3-rep-elem cst-equiv)))
  :rule-classes :congruence)

Function: cst-whitespace-conc4-rep-elem

(defun cst-whitespace-conc4-rep-elem (abnf::cst)
 (declare (xargs :guard (abnf::treep abnf::cst)))
 (declare (xargs :guard (and (cst-matchp abnf::cst "whitespace")
                             (equal (cst-whitespace-conc? abnf::cst)
                                    4))))
 (let ((__function__ 'cst-whitespace-conc4-rep-elem))
   (declare (ignorable __function__))
   (abnf::tree-fix (nth 0
                        (cst-whitespace-conc4-rep abnf::cst)))))

Theorem: treep-of-cst-whitespace-conc4-rep-elem

(defthm treep-of-cst-whitespace-conc4-rep-elem
  (b* ((abnf::cst1 (cst-whitespace-conc4-rep-elem abnf::cst)))
    (abnf::treep abnf::cst1))
  :rule-classes :rewrite)

Theorem: cst-whitespace-conc4-rep-elem-match

(defthm cst-whitespace-conc4-rep-elem-match
  (implies
       (and (cst-matchp abnf::cst "whitespace")
            (equal (cst-whitespace-conc? abnf::cst)
                   4))
       (b* ((abnf::cst1 (cst-whitespace-conc4-rep-elem abnf::cst)))
         (cst-matchp abnf::cst1 "line-terminator")))
  :rule-classes :rewrite)

Theorem: cst-whitespace-conc4-rep-elem-of-tree-fix-cst

(defthm cst-whitespace-conc4-rep-elem-of-tree-fix-cst
  (equal (cst-whitespace-conc4-rep-elem (abnf::tree-fix abnf::cst))
         (cst-whitespace-conc4-rep-elem abnf::cst)))

Theorem: cst-whitespace-conc4-rep-elem-tree-equiv-congruence-on-cst

(defthm cst-whitespace-conc4-rep-elem-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-whitespace-conc4-rep-elem abnf::cst)
                  (cst-whitespace-conc4-rep-elem cst-equiv)))
  :rule-classes :congruence)

Function: cst-whitespace-conc5-rep-elem

(defun cst-whitespace-conc5-rep-elem (abnf::cst)
 (declare (xargs :guard (abnf::treep abnf::cst)))
 (declare (xargs :guard (and (cst-matchp abnf::cst "whitespace")
                             (equal (cst-whitespace-conc? abnf::cst)
                                    5))))
 (let ((__function__ 'cst-whitespace-conc5-rep-elem))
   (declare (ignorable __function__))
   (abnf::tree-fix (nth 0
                        (cst-whitespace-conc5-rep abnf::cst)))))

Theorem: treep-of-cst-whitespace-conc5-rep-elem

(defthm treep-of-cst-whitespace-conc5-rep-elem
  (b* ((abnf::cst1 (cst-whitespace-conc5-rep-elem abnf::cst)))
    (abnf::treep abnf::cst1))
  :rule-classes :rewrite)

Theorem: cst-whitespace-conc5-rep-elem-match

(defthm cst-whitespace-conc5-rep-elem-match
  (implies
       (and (cst-matchp abnf::cst "whitespace")
            (equal (cst-whitespace-conc? abnf::cst)
                   5))
       (b* ((abnf::cst1 (cst-whitespace-conc5-rep-elem abnf::cst)))
         (cst-matchp abnf::cst1 "carriage-return")))
  :rule-classes :rewrite)

Theorem: cst-whitespace-conc5-rep-elem-of-tree-fix-cst

(defthm cst-whitespace-conc5-rep-elem-of-tree-fix-cst
  (equal (cst-whitespace-conc5-rep-elem (abnf::tree-fix abnf::cst))
         (cst-whitespace-conc5-rep-elem abnf::cst)))

Theorem: cst-whitespace-conc5-rep-elem-tree-equiv-congruence-on-cst

(defthm cst-whitespace-conc5-rep-elem-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-whitespace-conc5-rep-elem abnf::cst)
                  (cst-whitespace-conc5-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-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-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-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-binary-digit-conc-rep-elem

(defun cst-binary-digit-conc-rep-elem (abnf::cst)
  (declare (xargs :guard (abnf::treep abnf::cst)))
  (declare (xargs :guard (cst-matchp abnf::cst "binary-digit")))
  (let ((__function__ 'cst-binary-digit-conc-rep-elem))
    (declare (ignorable __function__))
    (abnf::tree-fix (nth 0
                         (cst-binary-digit-conc-rep abnf::cst)))))

Theorem: treep-of-cst-binary-digit-conc-rep-elem

(defthm treep-of-cst-binary-digit-conc-rep-elem
  (b* ((abnf::cst1 (cst-binary-digit-conc-rep-elem abnf::cst)))
    (abnf::treep abnf::cst1))
  :rule-classes :rewrite)

Theorem: cst-binary-digit-conc-rep-elem-match

(defthm cst-binary-digit-conc-rep-elem-match
  (implies
       (cst-matchp abnf::cst "binary-digit")
       (b* ((abnf::cst1 (cst-binary-digit-conc-rep-elem abnf::cst)))
         (cst-matchp abnf::cst1 "%x30-31")))
  :rule-classes :rewrite)

Theorem: cst-binary-digit-conc-rep-elem-of-tree-fix-cst

(defthm cst-binary-digit-conc-rep-elem-of-tree-fix-cst
  (equal (cst-binary-digit-conc-rep-elem (abnf::tree-fix abnf::cst))
         (cst-binary-digit-conc-rep-elem abnf::cst)))

Theorem: cst-binary-digit-conc-rep-elem-tree-equiv-congruence-on-cst

(defthm cst-binary-digit-conc-rep-elem-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-binary-digit-conc-rep-elem abnf::cst)
                  (cst-binary-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-decimal-digit-conc-rep-elem

(defun cst-decimal-digit-conc-rep-elem (abnf::cst)
  (declare (xargs :guard (abnf::treep abnf::cst)))
  (declare (xargs :guard (cst-matchp abnf::cst "decimal-digit")))
  (let ((__function__ 'cst-decimal-digit-conc-rep-elem))
    (declare (ignorable __function__))
    (abnf::tree-fix (nth 0
                         (cst-decimal-digit-conc-rep abnf::cst)))))

Theorem: treep-of-cst-decimal-digit-conc-rep-elem

(defthm treep-of-cst-decimal-digit-conc-rep-elem
  (b* ((abnf::cst1 (cst-decimal-digit-conc-rep-elem abnf::cst)))
    (abnf::treep abnf::cst1))
  :rule-classes :rewrite)

Theorem: cst-decimal-digit-conc-rep-elem-match

(defthm cst-decimal-digit-conc-rep-elem-match
 (implies
      (cst-matchp abnf::cst "decimal-digit")
      (b* ((abnf::cst1 (cst-decimal-digit-conc-rep-elem abnf::cst)))
        (cst-matchp abnf::cst1 "%x30-39")))
 :rule-classes :rewrite)

Theorem: cst-decimal-digit-conc-rep-elem-of-tree-fix-cst

(defthm cst-decimal-digit-conc-rep-elem-of-tree-fix-cst
 (equal (cst-decimal-digit-conc-rep-elem (abnf::tree-fix abnf::cst))
        (cst-decimal-digit-conc-rep-elem abnf::cst)))

Theorem: cst-decimal-digit-conc-rep-elem-tree-equiv-congruence-on-cst

(defthm cst-decimal-digit-conc-rep-elem-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-decimal-digit-conc-rep-elem abnf::cst)
                  (cst-decimal-digit-conc-rep-elem cst-equiv)))
  :rule-classes :congruence)

Function: cst-nonzero-decimal-digit-conc-rep-elem

(defun cst-nonzero-decimal-digit-conc-rep-elem (abnf::cst)
 (declare (xargs :guard (abnf::treep abnf::cst)))
 (declare
      (xargs :guard (cst-matchp abnf::cst "nonzero-decimal-digit")))
 (let ((__function__ 'cst-nonzero-decimal-digit-conc-rep-elem))
   (declare (ignorable __function__))
   (abnf::tree-fix
        (nth 0
             (cst-nonzero-decimal-digit-conc-rep abnf::cst)))))

Theorem: treep-of-cst-nonzero-decimal-digit-conc-rep-elem

(defthm treep-of-cst-nonzero-decimal-digit-conc-rep-elem
 (b*
  ((abnf::cst1 (cst-nonzero-decimal-digit-conc-rep-elem abnf::cst)))
  (abnf::treep abnf::cst1))
 :rule-classes :rewrite)

Theorem: cst-nonzero-decimal-digit-conc-rep-elem-match

(defthm cst-nonzero-decimal-digit-conc-rep-elem-match
 (implies
     (cst-matchp abnf::cst "nonzero-decimal-digit")
     (b* ((abnf::cst1
               (cst-nonzero-decimal-digit-conc-rep-elem abnf::cst)))
       (cst-matchp abnf::cst1 "%x31-39")))
 :rule-classes :rewrite)

Theorem: cst-nonzero-decimal-digit-conc-rep-elem-of-tree-fix-cst

(defthm cst-nonzero-decimal-digit-conc-rep-elem-of-tree-fix-cst
  (equal (cst-nonzero-decimal-digit-conc-rep-elem
              (abnf::tree-fix abnf::cst))
         (cst-nonzero-decimal-digit-conc-rep-elem abnf::cst)))

Theorem: cst-nonzero-decimal-digit-conc-rep-elem-tree-equiv-congruence-on-cst

(defthm
 cst-nonzero-decimal-digit-conc-rep-elem-tree-equiv-congruence-on-cst
 (implies
      (abnf::tree-equiv abnf::cst cst-equiv)
      (equal (cst-nonzero-decimal-digit-conc-rep-elem abnf::cst)
             (cst-nonzero-decimal-digit-conc-rep-elem cst-equiv)))
 :rule-classes :congruence)

Function: cst-numeral-conc1-rep-elem

(defun cst-numeral-conc1-rep-elem (abnf::cst)
  (declare (xargs :guard (abnf::treep abnf::cst)))
  (declare (xargs :guard (and (cst-matchp abnf::cst "numeral")
                              (equal (cst-numeral-conc? abnf::cst)
                                     1))))
  (let ((__function__ 'cst-numeral-conc1-rep-elem))
    (declare (ignorable __function__))
    (abnf::tree-fix (nth 0 (cst-numeral-conc1-rep abnf::cst)))))

Theorem: treep-of-cst-numeral-conc1-rep-elem

(defthm treep-of-cst-numeral-conc1-rep-elem
  (b* ((abnf::cst1 (cst-numeral-conc1-rep-elem abnf::cst)))
    (abnf::treep abnf::cst1))
  :rule-classes :rewrite)

Theorem: cst-numeral-conc1-rep-elem-match

(defthm cst-numeral-conc1-rep-elem-match
  (implies (and (cst-matchp abnf::cst "numeral")
                (equal (cst-numeral-conc? abnf::cst) 1))
           (b* ((abnf::cst1 (cst-numeral-conc1-rep-elem abnf::cst)))
             (cst-matchp abnf::cst1 "binary-numeral")))
  :rule-classes :rewrite)

Theorem: cst-numeral-conc1-rep-elem-of-tree-fix-cst

(defthm cst-numeral-conc1-rep-elem-of-tree-fix-cst
  (equal (cst-numeral-conc1-rep-elem (abnf::tree-fix abnf::cst))
         (cst-numeral-conc1-rep-elem abnf::cst)))

Theorem: cst-numeral-conc1-rep-elem-tree-equiv-congruence-on-cst

(defthm cst-numeral-conc1-rep-elem-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-numeral-conc1-rep-elem abnf::cst)
                  (cst-numeral-conc1-rep-elem cst-equiv)))
  :rule-classes :congruence)

Function: cst-numeral-conc2-rep-elem

(defun cst-numeral-conc2-rep-elem (abnf::cst)
  (declare (xargs :guard (abnf::treep abnf::cst)))
  (declare (xargs :guard (and (cst-matchp abnf::cst "numeral")
                              (equal (cst-numeral-conc? abnf::cst)
                                     2))))
  (let ((__function__ 'cst-numeral-conc2-rep-elem))
    (declare (ignorable __function__))
    (abnf::tree-fix (nth 0 (cst-numeral-conc2-rep abnf::cst)))))

Theorem: treep-of-cst-numeral-conc2-rep-elem

(defthm treep-of-cst-numeral-conc2-rep-elem
  (b* ((abnf::cst1 (cst-numeral-conc2-rep-elem abnf::cst)))
    (abnf::treep abnf::cst1))
  :rule-classes :rewrite)

Theorem: cst-numeral-conc2-rep-elem-match

(defthm cst-numeral-conc2-rep-elem-match
  (implies (and (cst-matchp abnf::cst "numeral")
                (equal (cst-numeral-conc? abnf::cst) 2))
           (b* ((abnf::cst1 (cst-numeral-conc2-rep-elem abnf::cst)))
             (cst-matchp abnf::cst1 "octal-numeral")))
  :rule-classes :rewrite)

Theorem: cst-numeral-conc2-rep-elem-of-tree-fix-cst

(defthm cst-numeral-conc2-rep-elem-of-tree-fix-cst
  (equal (cst-numeral-conc2-rep-elem (abnf::tree-fix abnf::cst))
         (cst-numeral-conc2-rep-elem abnf::cst)))

Theorem: cst-numeral-conc2-rep-elem-tree-equiv-congruence-on-cst

(defthm cst-numeral-conc2-rep-elem-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-numeral-conc2-rep-elem abnf::cst)
                  (cst-numeral-conc2-rep-elem cst-equiv)))
  :rule-classes :congruence)

Function: cst-numeral-conc3-rep-elem

(defun cst-numeral-conc3-rep-elem (abnf::cst)
  (declare (xargs :guard (abnf::treep abnf::cst)))
  (declare (xargs :guard (and (cst-matchp abnf::cst "numeral")
                              (equal (cst-numeral-conc? abnf::cst)
                                     3))))
  (let ((__function__ 'cst-numeral-conc3-rep-elem))
    (declare (ignorable __function__))
    (abnf::tree-fix (nth 0 (cst-numeral-conc3-rep abnf::cst)))))

Theorem: treep-of-cst-numeral-conc3-rep-elem

(defthm treep-of-cst-numeral-conc3-rep-elem
  (b* ((abnf::cst1 (cst-numeral-conc3-rep-elem abnf::cst)))
    (abnf::treep abnf::cst1))
  :rule-classes :rewrite)

Theorem: cst-numeral-conc3-rep-elem-match

(defthm cst-numeral-conc3-rep-elem-match
  (implies (and (cst-matchp abnf::cst "numeral")
                (equal (cst-numeral-conc? abnf::cst) 3))
           (b* ((abnf::cst1 (cst-numeral-conc3-rep-elem abnf::cst)))
             (cst-matchp abnf::cst1 "decimal-numeral")))
  :rule-classes :rewrite)

Theorem: cst-numeral-conc3-rep-elem-of-tree-fix-cst

(defthm cst-numeral-conc3-rep-elem-of-tree-fix-cst
  (equal (cst-numeral-conc3-rep-elem (abnf::tree-fix abnf::cst))
         (cst-numeral-conc3-rep-elem abnf::cst)))

Theorem: cst-numeral-conc3-rep-elem-tree-equiv-congruence-on-cst

(defthm cst-numeral-conc3-rep-elem-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-numeral-conc3-rep-elem abnf::cst)
                  (cst-numeral-conc3-rep-elem cst-equiv)))
  :rule-classes :congruence)

Function: cst-numeral-conc4-rep-elem

(defun cst-numeral-conc4-rep-elem (abnf::cst)
  (declare (xargs :guard (abnf::treep abnf::cst)))
  (declare (xargs :guard (and (cst-matchp abnf::cst "numeral")
                              (equal (cst-numeral-conc? abnf::cst)
                                     4))))
  (let ((__function__ 'cst-numeral-conc4-rep-elem))
    (declare (ignorable __function__))
    (abnf::tree-fix (nth 0 (cst-numeral-conc4-rep abnf::cst)))))

Theorem: treep-of-cst-numeral-conc4-rep-elem

(defthm treep-of-cst-numeral-conc4-rep-elem
  (b* ((abnf::cst1 (cst-numeral-conc4-rep-elem abnf::cst)))
    (abnf::treep abnf::cst1))
  :rule-classes :rewrite)

Theorem: cst-numeral-conc4-rep-elem-match

(defthm cst-numeral-conc4-rep-elem-match
  (implies (and (cst-matchp abnf::cst "numeral")
                (equal (cst-numeral-conc? abnf::cst) 4))
           (b* ((abnf::cst1 (cst-numeral-conc4-rep-elem abnf::cst)))
             (cst-matchp abnf::cst1 "hexadecimal-numeral")))
  :rule-classes :rewrite)

Theorem: cst-numeral-conc4-rep-elem-of-tree-fix-cst

(defthm cst-numeral-conc4-rep-elem-of-tree-fix-cst
  (equal (cst-numeral-conc4-rep-elem (abnf::tree-fix abnf::cst))
         (cst-numeral-conc4-rep-elem abnf::cst)))

Theorem: cst-numeral-conc4-rep-elem-tree-equiv-congruence-on-cst

(defthm cst-numeral-conc4-rep-elem-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-numeral-conc4-rep-elem abnf::cst)
                  (cst-numeral-conc4-rep-elem cst-equiv)))
  :rule-classes :congruence)

Function: cst-integer-literal-conc1-rep-elem

(defun cst-integer-literal-conc1-rep-elem (abnf::cst)
 (declare (xargs :guard (abnf::treep abnf::cst)))
 (declare
     (xargs :guard (and (cst-matchp abnf::cst "integer-literal")
                        (equal (cst-integer-literal-conc? abnf::cst)
                               1))))
 (let ((__function__ 'cst-integer-literal-conc1-rep-elem))
  (declare (ignorable __function__))
  (abnf::tree-fix (nth 0
                       (cst-integer-literal-conc1-rep abnf::cst)))))

Theorem: treep-of-cst-integer-literal-conc1-rep-elem

(defthm treep-of-cst-integer-literal-conc1-rep-elem
  (b* ((abnf::cst1 (cst-integer-literal-conc1-rep-elem abnf::cst)))
    (abnf::treep abnf::cst1))
  :rule-classes :rewrite)

Theorem: cst-integer-literal-conc1-rep-elem-match

(defthm cst-integer-literal-conc1-rep-elem-match
 (implies
   (and (cst-matchp abnf::cst "integer-literal")
        (equal (cst-integer-literal-conc? abnf::cst)
               1))
   (b* ((abnf::cst1 (cst-integer-literal-conc1-rep-elem abnf::cst)))
     (cst-matchp abnf::cst1 "unsigned-literal")))
 :rule-classes :rewrite)

Theorem: cst-integer-literal-conc1-rep-elem-of-tree-fix-cst

(defthm cst-integer-literal-conc1-rep-elem-of-tree-fix-cst
 (equal
     (cst-integer-literal-conc1-rep-elem (abnf::tree-fix abnf::cst))
     (cst-integer-literal-conc1-rep-elem abnf::cst)))

Theorem: cst-integer-literal-conc1-rep-elem-tree-equiv-congruence-on-cst

(defthm
    cst-integer-literal-conc1-rep-elem-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-integer-literal-conc1-rep-elem abnf::cst)
                  (cst-integer-literal-conc1-rep-elem cst-equiv)))
  :rule-classes :congruence)

Function: cst-integer-literal-conc2-rep-elem

(defun cst-integer-literal-conc2-rep-elem (abnf::cst)
 (declare (xargs :guard (abnf::treep abnf::cst)))
 (declare
     (xargs :guard (and (cst-matchp abnf::cst "integer-literal")
                        (equal (cst-integer-literal-conc? abnf::cst)
                               2))))
 (let ((__function__ 'cst-integer-literal-conc2-rep-elem))
  (declare (ignorable __function__))
  (abnf::tree-fix (nth 0
                       (cst-integer-literal-conc2-rep abnf::cst)))))

Theorem: treep-of-cst-integer-literal-conc2-rep-elem

(defthm treep-of-cst-integer-literal-conc2-rep-elem
  (b* ((abnf::cst1 (cst-integer-literal-conc2-rep-elem abnf::cst)))
    (abnf::treep abnf::cst1))
  :rule-classes :rewrite)

Theorem: cst-integer-literal-conc2-rep-elem-match

(defthm cst-integer-literal-conc2-rep-elem-match
 (implies
   (and (cst-matchp abnf::cst "integer-literal")
        (equal (cst-integer-literal-conc? abnf::cst)
               2))
   (b* ((abnf::cst1 (cst-integer-literal-conc2-rep-elem abnf::cst)))
     (cst-matchp abnf::cst1 "signed-literal")))
 :rule-classes :rewrite)

Theorem: cst-integer-literal-conc2-rep-elem-of-tree-fix-cst

(defthm cst-integer-literal-conc2-rep-elem-of-tree-fix-cst
 (equal
     (cst-integer-literal-conc2-rep-elem (abnf::tree-fix abnf::cst))
     (cst-integer-literal-conc2-rep-elem abnf::cst)))

Theorem: cst-integer-literal-conc2-rep-elem-tree-equiv-congruence-on-cst

(defthm
    cst-integer-literal-conc2-rep-elem-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-integer-literal-conc2-rep-elem abnf::cst)
                  (cst-integer-literal-conc2-rep-elem cst-equiv)))
  :rule-classes :congruence)

Function: cst-numeric-literal-conc1-rep-elem

(defun cst-numeric-literal-conc1-rep-elem (abnf::cst)
 (declare (xargs :guard (abnf::treep abnf::cst)))
 (declare
     (xargs :guard (and (cst-matchp abnf::cst "numeric-literal")
                        (equal (cst-numeric-literal-conc? abnf::cst)
                               1))))
 (let ((__function__ 'cst-numeric-literal-conc1-rep-elem))
  (declare (ignorable __function__))
  (abnf::tree-fix (nth 0
                       (cst-numeric-literal-conc1-rep abnf::cst)))))

Theorem: treep-of-cst-numeric-literal-conc1-rep-elem

(defthm treep-of-cst-numeric-literal-conc1-rep-elem
  (b* ((abnf::cst1 (cst-numeric-literal-conc1-rep-elem abnf::cst)))
    (abnf::treep abnf::cst1))
  :rule-classes :rewrite)

Theorem: cst-numeric-literal-conc1-rep-elem-match

(defthm cst-numeric-literal-conc1-rep-elem-match
 (implies
   (and (cst-matchp abnf::cst "numeric-literal")
        (equal (cst-numeric-literal-conc? abnf::cst)
               1))
   (b* ((abnf::cst1 (cst-numeric-literal-conc1-rep-elem abnf::cst)))
     (cst-matchp abnf::cst1 "integer-literal")))
 :rule-classes :rewrite)

Theorem: cst-numeric-literal-conc1-rep-elem-of-tree-fix-cst

(defthm cst-numeric-literal-conc1-rep-elem-of-tree-fix-cst
 (equal
     (cst-numeric-literal-conc1-rep-elem (abnf::tree-fix abnf::cst))
     (cst-numeric-literal-conc1-rep-elem abnf::cst)))

Theorem: cst-numeric-literal-conc1-rep-elem-tree-equiv-congruence-on-cst

(defthm
    cst-numeric-literal-conc1-rep-elem-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-numeric-literal-conc1-rep-elem abnf::cst)
                  (cst-numeric-literal-conc1-rep-elem cst-equiv)))
  :rule-classes :congruence)

Function: cst-numeric-literal-conc2-rep-elem

(defun cst-numeric-literal-conc2-rep-elem (abnf::cst)
 (declare (xargs :guard (abnf::treep abnf::cst)))
 (declare
     (xargs :guard (and (cst-matchp abnf::cst "numeric-literal")
                        (equal (cst-numeric-literal-conc? abnf::cst)
                               2))))
 (let ((__function__ 'cst-numeric-literal-conc2-rep-elem))
  (declare (ignorable __function__))
  (abnf::tree-fix (nth 0
                       (cst-numeric-literal-conc2-rep abnf::cst)))))

Theorem: treep-of-cst-numeric-literal-conc2-rep-elem

(defthm treep-of-cst-numeric-literal-conc2-rep-elem
  (b* ((abnf::cst1 (cst-numeric-literal-conc2-rep-elem abnf::cst)))
    (abnf::treep abnf::cst1))
  :rule-classes :rewrite)

Theorem: cst-numeric-literal-conc2-rep-elem-match

(defthm cst-numeric-literal-conc2-rep-elem-match
 (implies
   (and (cst-matchp abnf::cst "numeric-literal")
        (equal (cst-numeric-literal-conc? abnf::cst)
               2))
   (b* ((abnf::cst1 (cst-numeric-literal-conc2-rep-elem abnf::cst)))
     (cst-matchp abnf::cst1 "field-literal")))
 :rule-classes :rewrite)

Theorem: cst-numeric-literal-conc2-rep-elem-of-tree-fix-cst

(defthm cst-numeric-literal-conc2-rep-elem-of-tree-fix-cst
 (equal
     (cst-numeric-literal-conc2-rep-elem (abnf::tree-fix abnf::cst))
     (cst-numeric-literal-conc2-rep-elem abnf::cst)))

Theorem: cst-numeric-literal-conc2-rep-elem-tree-equiv-congruence-on-cst

(defthm
    cst-numeric-literal-conc2-rep-elem-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-numeric-literal-conc2-rep-elem abnf::cst)
                  (cst-numeric-literal-conc2-rep-elem cst-equiv)))
  :rule-classes :congruence)

Function: cst-numeric-literal-conc3-rep-elem

(defun cst-numeric-literal-conc3-rep-elem (abnf::cst)
 (declare (xargs :guard (abnf::treep abnf::cst)))
 (declare
     (xargs :guard (and (cst-matchp abnf::cst "numeric-literal")
                        (equal (cst-numeric-literal-conc? abnf::cst)
                               3))))
 (let ((__function__ 'cst-numeric-literal-conc3-rep-elem))
  (declare (ignorable __function__))
  (abnf::tree-fix (nth 0
                       (cst-numeric-literal-conc3-rep abnf::cst)))))

Theorem: treep-of-cst-numeric-literal-conc3-rep-elem

(defthm treep-of-cst-numeric-literal-conc3-rep-elem
  (b* ((abnf::cst1 (cst-numeric-literal-conc3-rep-elem abnf::cst)))
    (abnf::treep abnf::cst1))
  :rule-classes :rewrite)

Theorem: cst-numeric-literal-conc3-rep-elem-match

(defthm cst-numeric-literal-conc3-rep-elem-match
 (implies
   (and (cst-matchp abnf::cst "numeric-literal")
        (equal (cst-numeric-literal-conc? abnf::cst)
               3))
   (b* ((abnf::cst1 (cst-numeric-literal-conc3-rep-elem abnf::cst)))
     (cst-matchp abnf::cst1 "group-literal")))
 :rule-classes :rewrite)

Theorem: cst-numeric-literal-conc3-rep-elem-of-tree-fix-cst

(defthm cst-numeric-literal-conc3-rep-elem-of-tree-fix-cst
 (equal
     (cst-numeric-literal-conc3-rep-elem (abnf::tree-fix abnf::cst))
     (cst-numeric-literal-conc3-rep-elem abnf::cst)))

Theorem: cst-numeric-literal-conc3-rep-elem-tree-equiv-congruence-on-cst

(defthm
    cst-numeric-literal-conc3-rep-elem-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-numeric-literal-conc3-rep-elem abnf::cst)
                  (cst-numeric-literal-conc3-rep-elem cst-equiv)))
  :rule-classes :congruence)

Function: cst-numeric-literal-conc4-rep-elem

(defun cst-numeric-literal-conc4-rep-elem (abnf::cst)
 (declare (xargs :guard (abnf::treep abnf::cst)))
 (declare
     (xargs :guard (and (cst-matchp abnf::cst "numeric-literal")
                        (equal (cst-numeric-literal-conc? abnf::cst)
                               4))))
 (let ((__function__ 'cst-numeric-literal-conc4-rep-elem))
  (declare (ignorable __function__))
  (abnf::tree-fix (nth 0
                       (cst-numeric-literal-conc4-rep abnf::cst)))))

Theorem: treep-of-cst-numeric-literal-conc4-rep-elem

(defthm treep-of-cst-numeric-literal-conc4-rep-elem
  (b* ((abnf::cst1 (cst-numeric-literal-conc4-rep-elem abnf::cst)))
    (abnf::treep abnf::cst1))
  :rule-classes :rewrite)

Theorem: cst-numeric-literal-conc4-rep-elem-match

(defthm cst-numeric-literal-conc4-rep-elem-match
 (implies
   (and (cst-matchp abnf::cst "numeric-literal")
        (equal (cst-numeric-literal-conc? abnf::cst)
               4))
   (b* ((abnf::cst1 (cst-numeric-literal-conc4-rep-elem abnf::cst)))
     (cst-matchp abnf::cst1 "scalar-literal")))
 :rule-classes :rewrite)

Theorem: cst-numeric-literal-conc4-rep-elem-of-tree-fix-cst

(defthm cst-numeric-literal-conc4-rep-elem-of-tree-fix-cst
 (equal
     (cst-numeric-literal-conc4-rep-elem (abnf::tree-fix abnf::cst))
     (cst-numeric-literal-conc4-rep-elem abnf::cst)))

Theorem: cst-numeric-literal-conc4-rep-elem-tree-equiv-congruence-on-cst

(defthm
    cst-numeric-literal-conc4-rep-elem-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-numeric-literal-conc4-rep-elem abnf::cst)
                  (cst-numeric-literal-conc4-rep-elem cst-equiv)))
  :rule-classes :congruence)

Function: cst-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-string-character-conc1-rep-elem

(defun cst-string-character-conc1-rep-elem (abnf::cst)
 (declare (xargs :guard (abnf::treep abnf::cst)))
 (declare
    (xargs :guard (and (cst-matchp abnf::cst "string-character")
                       (equal (cst-string-character-conc? abnf::cst)
                              1))))
 (let ((__function__ 'cst-string-character-conc1-rep-elem))
   (declare (ignorable __function__))
   (abnf::tree-fix
        (nth 0
             (cst-string-character-conc1-rep abnf::cst)))))

Theorem: treep-of-cst-string-character-conc1-rep-elem

(defthm treep-of-cst-string-character-conc1-rep-elem
  (b* ((abnf::cst1 (cst-string-character-conc1-rep-elem abnf::cst)))
    (abnf::treep abnf::cst1))
  :rule-classes :rewrite)

Theorem: cst-string-character-conc1-rep-elem-match

(defthm cst-string-character-conc1-rep-elem-match
 (implies
  (and (cst-matchp abnf::cst "string-character")
       (equal (cst-string-character-conc? abnf::cst)
              1))
  (b* ((abnf::cst1 (cst-string-character-conc1-rep-elem abnf::cst)))
    (cst-matchp abnf::cst1
                "not-double-quote-or-line-feed")))
 :rule-classes :rewrite)

Theorem: cst-string-character-conc1-rep-elem-of-tree-fix-cst

(defthm cst-string-character-conc1-rep-elem-of-tree-fix-cst
 (equal
    (cst-string-character-conc1-rep-elem (abnf::tree-fix abnf::cst))
    (cst-string-character-conc1-rep-elem abnf::cst)))

Theorem: cst-string-character-conc1-rep-elem-tree-equiv-congruence-on-cst

(defthm
   cst-string-character-conc1-rep-elem-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-string-character-conc1-rep-elem abnf::cst)
                  (cst-string-character-conc1-rep-elem cst-equiv)))
  :rule-classes :congruence)

Function: cst-string-character-conc2-rep-elem

(defun cst-string-character-conc2-rep-elem (abnf::cst)
 (declare (xargs :guard (abnf::treep abnf::cst)))
 (declare
    (xargs :guard (and (cst-matchp abnf::cst "string-character")
                       (equal (cst-string-character-conc? abnf::cst)
                              2))))
 (let ((__function__ 'cst-string-character-conc2-rep-elem))
   (declare (ignorable __function__))
   (abnf::tree-fix
        (nth 0
             (cst-string-character-conc2-rep abnf::cst)))))

Theorem: treep-of-cst-string-character-conc2-rep-elem

(defthm treep-of-cst-string-character-conc2-rep-elem
  (b* ((abnf::cst1 (cst-string-character-conc2-rep-elem abnf::cst)))
    (abnf::treep abnf::cst1))
  :rule-classes :rewrite)

Theorem: cst-string-character-conc2-rep-elem-match

(defthm cst-string-character-conc2-rep-elem-match
 (implies
  (and (cst-matchp abnf::cst "string-character")
       (equal (cst-string-character-conc? abnf::cst)
              2))
  (b* ((abnf::cst1 (cst-string-character-conc2-rep-elem abnf::cst)))
    (cst-matchp abnf::cst1 "line-terminator")))
 :rule-classes :rewrite)

Theorem: cst-string-character-conc2-rep-elem-of-tree-fix-cst

(defthm cst-string-character-conc2-rep-elem-of-tree-fix-cst
 (equal
    (cst-string-character-conc2-rep-elem (abnf::tree-fix abnf::cst))
    (cst-string-character-conc2-rep-elem abnf::cst)))

Theorem: cst-string-character-conc2-rep-elem-tree-equiv-congruence-on-cst

(defthm
   cst-string-character-conc2-rep-elem-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-string-character-conc2-rep-elem abnf::cst)
                  (cst-string-character-conc2-rep-elem cst-equiv)))
  :rule-classes :congruence)

Function: cst-atomic-literal-conc1-rep-elem

(defun cst-atomic-literal-conc1-rep-elem (abnf::cst)
 (declare (xargs :guard (abnf::treep abnf::cst)))
 (declare
      (xargs :guard (and (cst-matchp abnf::cst "atomic-literal")
                         (equal (cst-atomic-literal-conc? abnf::cst)
                                1))))
 (let ((__function__ 'cst-atomic-literal-conc1-rep-elem))
   (declare (ignorable __function__))
   (abnf::tree-fix (nth 0
                        (cst-atomic-literal-conc1-rep abnf::cst)))))

Theorem: treep-of-cst-atomic-literal-conc1-rep-elem

(defthm treep-of-cst-atomic-literal-conc1-rep-elem
  (b* ((abnf::cst1 (cst-atomic-literal-conc1-rep-elem abnf::cst)))
    (abnf::treep abnf::cst1))
  :rule-classes :rewrite)

Theorem: cst-atomic-literal-conc1-rep-elem-match

(defthm cst-atomic-literal-conc1-rep-elem-match
 (implies
    (and (cst-matchp abnf::cst "atomic-literal")
         (equal (cst-atomic-literal-conc? abnf::cst)
                1))
    (b* ((abnf::cst1 (cst-atomic-literal-conc1-rep-elem abnf::cst)))
      (cst-matchp abnf::cst1 "numeric-literal")))
 :rule-classes :rewrite)

Theorem: cst-atomic-literal-conc1-rep-elem-of-tree-fix-cst

(defthm cst-atomic-literal-conc1-rep-elem-of-tree-fix-cst
 (equal
      (cst-atomic-literal-conc1-rep-elem (abnf::tree-fix abnf::cst))
      (cst-atomic-literal-conc1-rep-elem abnf::cst)))

Theorem: cst-atomic-literal-conc1-rep-elem-tree-equiv-congruence-on-cst

(defthm
     cst-atomic-literal-conc1-rep-elem-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-atomic-literal-conc1-rep-elem abnf::cst)
                  (cst-atomic-literal-conc1-rep-elem cst-equiv)))
  :rule-classes :congruence)

Function: cst-atomic-literal-conc2-rep-elem

(defun cst-atomic-literal-conc2-rep-elem (abnf::cst)
 (declare (xargs :guard (abnf::treep abnf::cst)))
 (declare
      (xargs :guard (and (cst-matchp abnf::cst "atomic-literal")
                         (equal (cst-atomic-literal-conc? abnf::cst)
                                2))))
 (let ((__function__ 'cst-atomic-literal-conc2-rep-elem))
   (declare (ignorable __function__))
   (abnf::tree-fix (nth 0
                        (cst-atomic-literal-conc2-rep abnf::cst)))))

Theorem: treep-of-cst-atomic-literal-conc2-rep-elem

(defthm treep-of-cst-atomic-literal-conc2-rep-elem
  (b* ((abnf::cst1 (cst-atomic-literal-conc2-rep-elem abnf::cst)))
    (abnf::treep abnf::cst1))
  :rule-classes :rewrite)

Theorem: cst-atomic-literal-conc2-rep-elem-match

(defthm cst-atomic-literal-conc2-rep-elem-match
 (implies
    (and (cst-matchp abnf::cst "atomic-literal")
         (equal (cst-atomic-literal-conc? abnf::cst)
                2))
    (b* ((abnf::cst1 (cst-atomic-literal-conc2-rep-elem abnf::cst)))
      (cst-matchp abnf::cst1 "boolean-literal")))
 :rule-classes :rewrite)

Theorem: cst-atomic-literal-conc2-rep-elem-of-tree-fix-cst

(defthm cst-atomic-literal-conc2-rep-elem-of-tree-fix-cst
 (equal
      (cst-atomic-literal-conc2-rep-elem (abnf::tree-fix abnf::cst))
      (cst-atomic-literal-conc2-rep-elem abnf::cst)))

Theorem: cst-atomic-literal-conc2-rep-elem-tree-equiv-congruence-on-cst

(defthm
     cst-atomic-literal-conc2-rep-elem-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-atomic-literal-conc2-rep-elem abnf::cst)
                  (cst-atomic-literal-conc2-rep-elem cst-equiv)))
  :rule-classes :congruence)

Function: cst-atomic-literal-conc3-rep-elem

(defun cst-atomic-literal-conc3-rep-elem (abnf::cst)
 (declare (xargs :guard (abnf::treep abnf::cst)))
 (declare
      (xargs :guard (and (cst-matchp abnf::cst "atomic-literal")
                         (equal (cst-atomic-literal-conc? abnf::cst)
                                3))))
 (let ((__function__ 'cst-atomic-literal-conc3-rep-elem))
   (declare (ignorable __function__))
   (abnf::tree-fix (nth 0
                        (cst-atomic-literal-conc3-rep abnf::cst)))))

Theorem: treep-of-cst-atomic-literal-conc3-rep-elem

(defthm treep-of-cst-atomic-literal-conc3-rep-elem
  (b* ((abnf::cst1 (cst-atomic-literal-conc3-rep-elem abnf::cst)))
    (abnf::treep abnf::cst1))
  :rule-classes :rewrite)

Theorem: cst-atomic-literal-conc3-rep-elem-match

(defthm cst-atomic-literal-conc3-rep-elem-match
 (implies
    (and (cst-matchp abnf::cst "atomic-literal")
         (equal (cst-atomic-literal-conc? abnf::cst)
                3))
    (b* ((abnf::cst1 (cst-atomic-literal-conc3-rep-elem abnf::cst)))
      (cst-matchp abnf::cst1 "explicit-address-literal")))
 :rule-classes :rewrite)

Theorem: cst-atomic-literal-conc3-rep-elem-of-tree-fix-cst

(defthm cst-atomic-literal-conc3-rep-elem-of-tree-fix-cst
 (equal
      (cst-atomic-literal-conc3-rep-elem (abnf::tree-fix abnf::cst))
      (cst-atomic-literal-conc3-rep-elem abnf::cst)))

Theorem: cst-atomic-literal-conc3-rep-elem-tree-equiv-congruence-on-cst

(defthm
     cst-atomic-literal-conc3-rep-elem-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-atomic-literal-conc3-rep-elem abnf::cst)
                  (cst-atomic-literal-conc3-rep-elem cst-equiv)))
  :rule-classes :congruence)

Function: cst-atomic-literal-conc4-rep-elem

(defun cst-atomic-literal-conc4-rep-elem (abnf::cst)
 (declare (xargs :guard (abnf::treep abnf::cst)))
 (declare
      (xargs :guard (and (cst-matchp abnf::cst "atomic-literal")
                         (equal (cst-atomic-literal-conc? abnf::cst)
                                4))))
 (let ((__function__ 'cst-atomic-literal-conc4-rep-elem))
   (declare (ignorable __function__))
   (abnf::tree-fix (nth 0
                        (cst-atomic-literal-conc4-rep abnf::cst)))))

Theorem: treep-of-cst-atomic-literal-conc4-rep-elem

(defthm treep-of-cst-atomic-literal-conc4-rep-elem
  (b* ((abnf::cst1 (cst-atomic-literal-conc4-rep-elem abnf::cst)))
    (abnf::treep abnf::cst1))
  :rule-classes :rewrite)

Theorem: cst-atomic-literal-conc4-rep-elem-match

(defthm cst-atomic-literal-conc4-rep-elem-match
 (implies
    (and (cst-matchp abnf::cst "atomic-literal")
         (equal (cst-atomic-literal-conc? abnf::cst)
                4))
    (b* ((abnf::cst1 (cst-atomic-literal-conc4-rep-elem abnf::cst)))
      (cst-matchp abnf::cst1 "string-literal")))
 :rule-classes :rewrite)

Theorem: cst-atomic-literal-conc4-rep-elem-of-tree-fix-cst

(defthm cst-atomic-literal-conc4-rep-elem-of-tree-fix-cst
 (equal
      (cst-atomic-literal-conc4-rep-elem (abnf::tree-fix abnf::cst))
      (cst-atomic-literal-conc4-rep-elem abnf::cst)))

Theorem: cst-atomic-literal-conc4-rep-elem-tree-equiv-congruence-on-cst

(defthm
     cst-atomic-literal-conc4-rep-elem-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-atomic-literal-conc4-rep-elem abnf::cst)
                  (cst-atomic-literal-conc4-rep-elem cst-equiv)))
  :rule-classes :congruence)

Function: cst-token-conc1-rep-elem

(defun cst-token-conc1-rep-elem (abnf::cst)
  (declare (xargs :guard (abnf::treep abnf::cst)))
  (declare
       (xargs :guard (and (cst-matchp abnf::cst "token")
                          (equal (cst-token-conc? abnf::cst) 1))))
  (let ((__function__ 'cst-token-conc1-rep-elem))
    (declare (ignorable __function__))
    (abnf::tree-fix (nth 0 (cst-token-conc1-rep abnf::cst)))))

Theorem: treep-of-cst-token-conc1-rep-elem

(defthm treep-of-cst-token-conc1-rep-elem
  (b* ((abnf::cst1 (cst-token-conc1-rep-elem abnf::cst)))
    (abnf::treep abnf::cst1))
  :rule-classes :rewrite)

Theorem: cst-token-conc1-rep-elem-match

(defthm cst-token-conc1-rep-elem-match
  (implies (and (cst-matchp abnf::cst "token")
                (equal (cst-token-conc? abnf::cst) 1))
           (b* ((abnf::cst1 (cst-token-conc1-rep-elem abnf::cst)))
             (cst-matchp abnf::cst1 "keyword")))
  :rule-classes :rewrite)

Theorem: cst-token-conc1-rep-elem-of-tree-fix-cst

(defthm cst-token-conc1-rep-elem-of-tree-fix-cst
  (equal (cst-token-conc1-rep-elem (abnf::tree-fix abnf::cst))
         (cst-token-conc1-rep-elem abnf::cst)))

Theorem: cst-token-conc1-rep-elem-tree-equiv-congruence-on-cst

(defthm cst-token-conc1-rep-elem-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-token-conc1-rep-elem abnf::cst)
                  (cst-token-conc1-rep-elem cst-equiv)))
  :rule-classes :congruence)

Function: cst-token-conc2-rep-elem

(defun cst-token-conc2-rep-elem (abnf::cst)
  (declare (xargs :guard (abnf::treep abnf::cst)))
  (declare
       (xargs :guard (and (cst-matchp abnf::cst "token")
                          (equal (cst-token-conc? abnf::cst) 2))))
  (let ((__function__ 'cst-token-conc2-rep-elem))
    (declare (ignorable __function__))
    (abnf::tree-fix (nth 0 (cst-token-conc2-rep abnf::cst)))))

Theorem: treep-of-cst-token-conc2-rep-elem

(defthm treep-of-cst-token-conc2-rep-elem
  (b* ((abnf::cst1 (cst-token-conc2-rep-elem abnf::cst)))
    (abnf::treep abnf::cst1))
  :rule-classes :rewrite)

Theorem: cst-token-conc2-rep-elem-match

(defthm cst-token-conc2-rep-elem-match
  (implies (and (cst-matchp abnf::cst "token")
                (equal (cst-token-conc? abnf::cst) 2))
           (b* ((abnf::cst1 (cst-token-conc2-rep-elem abnf::cst)))
             (cst-matchp abnf::cst1 "identifier")))
  :rule-classes :rewrite)

Theorem: cst-token-conc2-rep-elem-of-tree-fix-cst

(defthm cst-token-conc2-rep-elem-of-tree-fix-cst
  (equal (cst-token-conc2-rep-elem (abnf::tree-fix abnf::cst))
         (cst-token-conc2-rep-elem abnf::cst)))

Theorem: cst-token-conc2-rep-elem-tree-equiv-congruence-on-cst

(defthm cst-token-conc2-rep-elem-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-token-conc2-rep-elem abnf::cst)
                  (cst-token-conc2-rep-elem cst-equiv)))
  :rule-classes :congruence)

Function: cst-token-conc3-rep-elem

(defun cst-token-conc3-rep-elem (abnf::cst)
  (declare (xargs :guard (abnf::treep abnf::cst)))
  (declare
       (xargs :guard (and (cst-matchp abnf::cst "token")
                          (equal (cst-token-conc? abnf::cst) 3))))
  (let ((__function__ 'cst-token-conc3-rep-elem))
    (declare (ignorable __function__))
    (abnf::tree-fix (nth 0 (cst-token-conc3-rep abnf::cst)))))

Theorem: treep-of-cst-token-conc3-rep-elem

(defthm treep-of-cst-token-conc3-rep-elem
  (b* ((abnf::cst1 (cst-token-conc3-rep-elem abnf::cst)))
    (abnf::treep abnf::cst1))
  :rule-classes :rewrite)

Theorem: cst-token-conc3-rep-elem-match

(defthm cst-token-conc3-rep-elem-match
  (implies (and (cst-matchp abnf::cst "token")
                (equal (cst-token-conc? abnf::cst) 3))
           (b* ((abnf::cst1 (cst-token-conc3-rep-elem abnf::cst)))
             (cst-matchp abnf::cst1 "atomic-literal")))
  :rule-classes :rewrite)

Theorem: cst-token-conc3-rep-elem-of-tree-fix-cst

(defthm cst-token-conc3-rep-elem-of-tree-fix-cst
  (equal (cst-token-conc3-rep-elem (abnf::tree-fix abnf::cst))
         (cst-token-conc3-rep-elem abnf::cst)))

Theorem: cst-token-conc3-rep-elem-tree-equiv-congruence-on-cst

(defthm cst-token-conc3-rep-elem-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-token-conc3-rep-elem abnf::cst)
                  (cst-token-conc3-rep-elem cst-equiv)))
  :rule-classes :congruence)

Function: cst-token-conc4-rep-elem

(defun cst-token-conc4-rep-elem (abnf::cst)
  (declare (xargs :guard (abnf::treep abnf::cst)))
  (declare
       (xargs :guard (and (cst-matchp abnf::cst "token")
                          (equal (cst-token-conc? abnf::cst) 4))))
  (let ((__function__ 'cst-token-conc4-rep-elem))
    (declare (ignorable __function__))
    (abnf::tree-fix (nth 0 (cst-token-conc4-rep abnf::cst)))))

Theorem: treep-of-cst-token-conc4-rep-elem

(defthm treep-of-cst-token-conc4-rep-elem
  (b* ((abnf::cst1 (cst-token-conc4-rep-elem abnf::cst)))
    (abnf::treep abnf::cst1))
  :rule-classes :rewrite)

Theorem: cst-token-conc4-rep-elem-match

(defthm cst-token-conc4-rep-elem-match
  (implies (and (cst-matchp abnf::cst "token")
                (equal (cst-token-conc? abnf::cst) 4))
           (b* ((abnf::cst1 (cst-token-conc4-rep-elem abnf::cst)))
             (cst-matchp abnf::cst1 "decimal-numeral")))
  :rule-classes :rewrite)

Theorem: cst-token-conc4-rep-elem-of-tree-fix-cst

(defthm cst-token-conc4-rep-elem-of-tree-fix-cst
  (equal (cst-token-conc4-rep-elem (abnf::tree-fix abnf::cst))
         (cst-token-conc4-rep-elem abnf::cst)))

Theorem: cst-token-conc4-rep-elem-tree-equiv-congruence-on-cst

(defthm cst-token-conc4-rep-elem-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-token-conc4-rep-elem abnf::cst)
                  (cst-token-conc4-rep-elem cst-equiv)))
  :rule-classes :congruence)

Function: cst-token-conc5-rep-elem

(defun cst-token-conc5-rep-elem (abnf::cst)
  (declare (xargs :guard (abnf::treep abnf::cst)))
  (declare
       (xargs :guard (and (cst-matchp abnf::cst "token")
                          (equal (cst-token-conc? abnf::cst) 5))))
  (let ((__function__ 'cst-token-conc5-rep-elem))
    (declare (ignorable __function__))
    (abnf::tree-fix (nth 0 (cst-token-conc5-rep abnf::cst)))))

Theorem: treep-of-cst-token-conc5-rep-elem

(defthm treep-of-cst-token-conc5-rep-elem
  (b* ((abnf::cst1 (cst-token-conc5-rep-elem abnf::cst)))
    (abnf::treep abnf::cst1))
  :rule-classes :rewrite)

Theorem: cst-token-conc5-rep-elem-match

(defthm cst-token-conc5-rep-elem-match
  (implies (and (cst-matchp abnf::cst "token")
                (equal (cst-token-conc? abnf::cst) 5))
           (b* ((abnf::cst1 (cst-token-conc5-rep-elem abnf::cst)))
             (cst-matchp abnf::cst1 "annotation")))
  :rule-classes :rewrite)

Theorem: cst-token-conc5-rep-elem-of-tree-fix-cst

(defthm cst-token-conc5-rep-elem-of-tree-fix-cst
  (equal (cst-token-conc5-rep-elem (abnf::tree-fix abnf::cst))
         (cst-token-conc5-rep-elem abnf::cst)))

Theorem: cst-token-conc5-rep-elem-tree-equiv-congruence-on-cst

(defthm cst-token-conc5-rep-elem-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-token-conc5-rep-elem abnf::cst)
                  (cst-token-conc5-rep-elem cst-equiv)))
  :rule-classes :congruence)

Function: cst-token-conc6-rep-elem

(defun cst-token-conc6-rep-elem (abnf::cst)
  (declare (xargs :guard (abnf::treep abnf::cst)))
  (declare
       (xargs :guard (and (cst-matchp abnf::cst "token")
                          (equal (cst-token-conc? abnf::cst) 6))))
  (let ((__function__ 'cst-token-conc6-rep-elem))
    (declare (ignorable __function__))
    (abnf::tree-fix (nth 0 (cst-token-conc6-rep abnf::cst)))))

Theorem: treep-of-cst-token-conc6-rep-elem

(defthm treep-of-cst-token-conc6-rep-elem
  (b* ((abnf::cst1 (cst-token-conc6-rep-elem abnf::cst)))
    (abnf::treep abnf::cst1))
  :rule-classes :rewrite)

Theorem: cst-token-conc6-rep-elem-match

(defthm cst-token-conc6-rep-elem-match
  (implies (and (cst-matchp abnf::cst "token")
                (equal (cst-token-conc? abnf::cst) 6))
           (b* ((abnf::cst1 (cst-token-conc6-rep-elem abnf::cst)))
             (cst-matchp abnf::cst1 "symbol")))
  :rule-classes :rewrite)

Theorem: cst-token-conc6-rep-elem-of-tree-fix-cst

(defthm cst-token-conc6-rep-elem-of-tree-fix-cst
  (equal (cst-token-conc6-rep-elem (abnf::tree-fix abnf::cst))
         (cst-token-conc6-rep-elem abnf::cst)))

Theorem: cst-token-conc6-rep-elem-tree-equiv-congruence-on-cst

(defthm cst-token-conc6-rep-elem-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-token-conc6-rep-elem abnf::cst)
                  (cst-token-conc6-rep-elem cst-equiv)))
  :rule-classes :congruence)

Function: cst-lexeme-conc1-rep-elem

(defun cst-lexeme-conc1-rep-elem (abnf::cst)
  (declare (xargs :guard (abnf::treep abnf::cst)))
  (declare (xargs :guard (and (cst-matchp abnf::cst "lexeme")
                              (equal (cst-lexeme-conc? abnf::cst)
                                     1))))
  (let ((__function__ 'cst-lexeme-conc1-rep-elem))
    (declare (ignorable __function__))
    (abnf::tree-fix (nth 0 (cst-lexeme-conc1-rep abnf::cst)))))

Theorem: treep-of-cst-lexeme-conc1-rep-elem

(defthm treep-of-cst-lexeme-conc1-rep-elem
  (b* ((abnf::cst1 (cst-lexeme-conc1-rep-elem abnf::cst)))
    (abnf::treep abnf::cst1))
  :rule-classes :rewrite)

Theorem: cst-lexeme-conc1-rep-elem-match

(defthm cst-lexeme-conc1-rep-elem-match
  (implies (and (cst-matchp abnf::cst "lexeme")
                (equal (cst-lexeme-conc? abnf::cst) 1))
           (b* ((abnf::cst1 (cst-lexeme-conc1-rep-elem abnf::cst)))
             (cst-matchp abnf::cst1 "token")))
  :rule-classes :rewrite)

Theorem: cst-lexeme-conc1-rep-elem-of-tree-fix-cst

(defthm cst-lexeme-conc1-rep-elem-of-tree-fix-cst
  (equal (cst-lexeme-conc1-rep-elem (abnf::tree-fix abnf::cst))
         (cst-lexeme-conc1-rep-elem abnf::cst)))

Theorem: cst-lexeme-conc1-rep-elem-tree-equiv-congruence-on-cst

(defthm cst-lexeme-conc1-rep-elem-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-lexeme-conc1-rep-elem abnf::cst)
                  (cst-lexeme-conc1-rep-elem cst-equiv)))
  :rule-classes :congruence)

Function: cst-lexeme-conc2-rep-elem

(defun cst-lexeme-conc2-rep-elem (abnf::cst)
  (declare (xargs :guard (abnf::treep abnf::cst)))
  (declare (xargs :guard (and (cst-matchp abnf::cst "lexeme")
                              (equal (cst-lexeme-conc? abnf::cst)
                                     2))))
  (let ((__function__ 'cst-lexeme-conc2-rep-elem))
    (declare (ignorable __function__))
    (abnf::tree-fix (nth 0 (cst-lexeme-conc2-rep abnf::cst)))))

Theorem: treep-of-cst-lexeme-conc2-rep-elem

(defthm treep-of-cst-lexeme-conc2-rep-elem
  (b* ((abnf::cst1 (cst-lexeme-conc2-rep-elem abnf::cst)))
    (abnf::treep abnf::cst1))
  :rule-classes :rewrite)

Theorem: cst-lexeme-conc2-rep-elem-match

(defthm cst-lexeme-conc2-rep-elem-match
  (implies (and (cst-matchp abnf::cst "lexeme")
                (equal (cst-lexeme-conc? abnf::cst) 2))
           (b* ((abnf::cst1 (cst-lexeme-conc2-rep-elem abnf::cst)))
             (cst-matchp abnf::cst1 "comment")))
  :rule-classes :rewrite)

Theorem: cst-lexeme-conc2-rep-elem-of-tree-fix-cst

(defthm cst-lexeme-conc2-rep-elem-of-tree-fix-cst
  (equal (cst-lexeme-conc2-rep-elem (abnf::tree-fix abnf::cst))
         (cst-lexeme-conc2-rep-elem abnf::cst)))

Theorem: cst-lexeme-conc2-rep-elem-tree-equiv-congruence-on-cst

(defthm cst-lexeme-conc2-rep-elem-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-lexeme-conc2-rep-elem abnf::cst)
                  (cst-lexeme-conc2-rep-elem cst-equiv)))
  :rule-classes :congruence)

Function: cst-lexeme-conc3-rep-elem

(defun cst-lexeme-conc3-rep-elem (abnf::cst)
  (declare (xargs :guard (abnf::treep abnf::cst)))
  (declare (xargs :guard (and (cst-matchp abnf::cst "lexeme")
                              (equal (cst-lexeme-conc? abnf::cst)
                                     3))))
  (let ((__function__ 'cst-lexeme-conc3-rep-elem))
    (declare (ignorable __function__))
    (abnf::tree-fix (nth 0 (cst-lexeme-conc3-rep abnf::cst)))))

Theorem: treep-of-cst-lexeme-conc3-rep-elem

(defthm treep-of-cst-lexeme-conc3-rep-elem
  (b* ((abnf::cst1 (cst-lexeme-conc3-rep-elem abnf::cst)))
    (abnf::treep abnf::cst1))
  :rule-classes :rewrite)

Theorem: cst-lexeme-conc3-rep-elem-match

(defthm cst-lexeme-conc3-rep-elem-match
  (implies (and (cst-matchp abnf::cst "lexeme")
                (equal (cst-lexeme-conc? abnf::cst) 3))
           (b* ((abnf::cst1 (cst-lexeme-conc3-rep-elem abnf::cst)))
             (cst-matchp abnf::cst1 "whitespace")))
  :rule-classes :rewrite)

Theorem: cst-lexeme-conc3-rep-elem-of-tree-fix-cst

(defthm cst-lexeme-conc3-rep-elem-of-tree-fix-cst
  (equal (cst-lexeme-conc3-rep-elem (abnf::tree-fix abnf::cst))
         (cst-lexeme-conc3-rep-elem abnf::cst)))

Theorem: cst-lexeme-conc3-rep-elem-tree-equiv-congruence-on-cst

(defthm cst-lexeme-conc3-rep-elem-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-lexeme-conc3-rep-elem abnf::cst)
                  (cst-lexeme-conc3-rep-elem cst-equiv)))
  :rule-classes :congruence)

Function: cst-network-conc-rep-elem

(defun cst-network-conc-rep-elem (abnf::cst)
  (declare (xargs :guard (abnf::treep abnf::cst)))
  (declare (xargs :guard (cst-matchp abnf::cst "network")))
  (let ((__function__ 'cst-network-conc-rep-elem))
    (declare (ignorable __function__))
    (abnf::tree-fix (nth 0 (cst-network-conc-rep abnf::cst)))))

Theorem: treep-of-cst-network-conc-rep-elem

(defthm treep-of-cst-network-conc-rep-elem
  (b* ((abnf::cst1 (cst-network-conc-rep-elem abnf::cst)))
    (abnf::treep abnf::cst1))
  :rule-classes :rewrite)

Theorem: cst-network-conc-rep-elem-match

(defthm cst-network-conc-rep-elem-match
  (implies (cst-matchp abnf::cst "network")
           (b* ((abnf::cst1 (cst-network-conc-rep-elem abnf::cst)))
             (cst-matchp abnf::cst1 "%s\"aleo\"")))
  :rule-classes :rewrite)

Theorem: cst-network-conc-rep-elem-of-tree-fix-cst

(defthm cst-network-conc-rep-elem-of-tree-fix-cst
  (equal (cst-network-conc-rep-elem (abnf::tree-fix abnf::cst))
         (cst-network-conc-rep-elem abnf::cst)))

Theorem: cst-network-conc-rep-elem-tree-equiv-congruence-on-cst

(defthm cst-network-conc-rep-elem-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-network-conc-rep-elem abnf::cst)
                  (cst-network-conc-rep-elem cst-equiv)))
  :rule-classes :congruence)

Function: cst-integer-type-conc1-rep-elem

(defun cst-integer-type-conc1-rep-elem (abnf::cst)
  (declare (xargs :guard (abnf::treep abnf::cst)))
  (declare
       (xargs :guard (and (cst-matchp abnf::cst "integer-type")
                          (equal (cst-integer-type-conc? abnf::cst)
                                 1))))
  (let ((__function__ 'cst-integer-type-conc1-rep-elem))
    (declare (ignorable __function__))
    (abnf::tree-fix (nth 0
                         (cst-integer-type-conc1-rep abnf::cst)))))

Theorem: treep-of-cst-integer-type-conc1-rep-elem

(defthm treep-of-cst-integer-type-conc1-rep-elem
  (b* ((abnf::cst1 (cst-integer-type-conc1-rep-elem abnf::cst)))
    (abnf::treep abnf::cst1))
  :rule-classes :rewrite)

Theorem: cst-integer-type-conc1-rep-elem-match

(defthm cst-integer-type-conc1-rep-elem-match
 (implies
      (and (cst-matchp abnf::cst "integer-type")
           (equal (cst-integer-type-conc? abnf::cst)
                  1))
      (b* ((abnf::cst1 (cst-integer-type-conc1-rep-elem abnf::cst)))
        (cst-matchp abnf::cst1 "unsigned-type")))
 :rule-classes :rewrite)

Theorem: cst-integer-type-conc1-rep-elem-of-tree-fix-cst

(defthm cst-integer-type-conc1-rep-elem-of-tree-fix-cst
 (equal (cst-integer-type-conc1-rep-elem (abnf::tree-fix abnf::cst))
        (cst-integer-type-conc1-rep-elem abnf::cst)))

Theorem: cst-integer-type-conc1-rep-elem-tree-equiv-congruence-on-cst

(defthm cst-integer-type-conc1-rep-elem-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-integer-type-conc1-rep-elem abnf::cst)
                  (cst-integer-type-conc1-rep-elem cst-equiv)))
  :rule-classes :congruence)

Function: cst-integer-type-conc2-rep-elem

(defun cst-integer-type-conc2-rep-elem (abnf::cst)
  (declare (xargs :guard (abnf::treep abnf::cst)))
  (declare
       (xargs :guard (and (cst-matchp abnf::cst "integer-type")
                          (equal (cst-integer-type-conc? abnf::cst)
                                 2))))
  (let ((__function__ 'cst-integer-type-conc2-rep-elem))
    (declare (ignorable __function__))
    (abnf::tree-fix (nth 0
                         (cst-integer-type-conc2-rep abnf::cst)))))

Theorem: treep-of-cst-integer-type-conc2-rep-elem

(defthm treep-of-cst-integer-type-conc2-rep-elem
  (b* ((abnf::cst1 (cst-integer-type-conc2-rep-elem abnf::cst)))
    (abnf::treep abnf::cst1))
  :rule-classes :rewrite)

Theorem: cst-integer-type-conc2-rep-elem-match

(defthm cst-integer-type-conc2-rep-elem-match
 (implies
      (and (cst-matchp abnf::cst "integer-type")
           (equal (cst-integer-type-conc? abnf::cst)
                  2))
      (b* ((abnf::cst1 (cst-integer-type-conc2-rep-elem abnf::cst)))
        (cst-matchp abnf::cst1 "signed-type")))
 :rule-classes :rewrite)

Theorem: cst-integer-type-conc2-rep-elem-of-tree-fix-cst

(defthm cst-integer-type-conc2-rep-elem-of-tree-fix-cst
 (equal (cst-integer-type-conc2-rep-elem (abnf::tree-fix abnf::cst))
        (cst-integer-type-conc2-rep-elem abnf::cst)))

Theorem: cst-integer-type-conc2-rep-elem-tree-equiv-congruence-on-cst

(defthm cst-integer-type-conc2-rep-elem-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-integer-type-conc2-rep-elem abnf::cst)
                  (cst-integer-type-conc2-rep-elem cst-equiv)))
  :rule-classes :congruence)

Function: cst-field-type-conc-rep-elem

(defun cst-field-type-conc-rep-elem (abnf::cst)
  (declare (xargs :guard (abnf::treep abnf::cst)))
  (declare (xargs :guard (cst-matchp abnf::cst "field-type")))
  (let ((__function__ 'cst-field-type-conc-rep-elem))
    (declare (ignorable __function__))
    (abnf::tree-fix (nth 0
                         (cst-field-type-conc-rep abnf::cst)))))

Theorem: treep-of-cst-field-type-conc-rep-elem

(defthm treep-of-cst-field-type-conc-rep-elem
  (b* ((abnf::cst1 (cst-field-type-conc-rep-elem abnf::cst)))
    (abnf::treep abnf::cst1))
  :rule-classes :rewrite)

Theorem: cst-field-type-conc-rep-elem-match

(defthm cst-field-type-conc-rep-elem-match
  (implies
       (cst-matchp abnf::cst "field-type")
       (b* ((abnf::cst1 (cst-field-type-conc-rep-elem abnf::cst)))
         (cst-matchp abnf::cst1 "%s\"field\"")))
  :rule-classes :rewrite)

Theorem: cst-field-type-conc-rep-elem-of-tree-fix-cst

(defthm cst-field-type-conc-rep-elem-of-tree-fix-cst
  (equal (cst-field-type-conc-rep-elem (abnf::tree-fix abnf::cst))
         (cst-field-type-conc-rep-elem abnf::cst)))

Theorem: cst-field-type-conc-rep-elem-tree-equiv-congruence-on-cst

(defthm cst-field-type-conc-rep-elem-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-field-type-conc-rep-elem abnf::cst)
                  (cst-field-type-conc-rep-elem cst-equiv)))
  :rule-classes :congruence)

Function: cst-group-type-conc-rep-elem

(defun cst-group-type-conc-rep-elem (abnf::cst)
  (declare (xargs :guard (abnf::treep abnf::cst)))
  (declare (xargs :guard (cst-matchp abnf::cst "group-type")))
  (let ((__function__ 'cst-group-type-conc-rep-elem))
    (declare (ignorable __function__))
    (abnf::tree-fix (nth 0
                         (cst-group-type-conc-rep abnf::cst)))))

Theorem: treep-of-cst-group-type-conc-rep-elem

(defthm treep-of-cst-group-type-conc-rep-elem
  (b* ((abnf::cst1 (cst-group-type-conc-rep-elem abnf::cst)))
    (abnf::treep abnf::cst1))
  :rule-classes :rewrite)

Theorem: cst-group-type-conc-rep-elem-match

(defthm cst-group-type-conc-rep-elem-match
  (implies
       (cst-matchp abnf::cst "group-type")
       (b* ((abnf::cst1 (cst-group-type-conc-rep-elem abnf::cst)))
         (cst-matchp abnf::cst1 "%s\"group\"")))
  :rule-classes :rewrite)

Theorem: cst-group-type-conc-rep-elem-of-tree-fix-cst

(defthm cst-group-type-conc-rep-elem-of-tree-fix-cst
  (equal (cst-group-type-conc-rep-elem (abnf::tree-fix abnf::cst))
         (cst-group-type-conc-rep-elem abnf::cst)))

Theorem: cst-group-type-conc-rep-elem-tree-equiv-congruence-on-cst

(defthm cst-group-type-conc-rep-elem-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-group-type-conc-rep-elem abnf::cst)
                  (cst-group-type-conc-rep-elem cst-equiv)))
  :rule-classes :congruence)

Function: cst-scalar-type-conc-rep-elem

(defun cst-scalar-type-conc-rep-elem (abnf::cst)
  (declare (xargs :guard (abnf::treep abnf::cst)))
  (declare (xargs :guard (cst-matchp abnf::cst "scalar-type")))
  (let ((__function__ 'cst-scalar-type-conc-rep-elem))
    (declare (ignorable __function__))
    (abnf::tree-fix (nth 0
                         (cst-scalar-type-conc-rep abnf::cst)))))

Theorem: treep-of-cst-scalar-type-conc-rep-elem

(defthm treep-of-cst-scalar-type-conc-rep-elem
  (b* ((abnf::cst1 (cst-scalar-type-conc-rep-elem abnf::cst)))
    (abnf::treep abnf::cst1))
  :rule-classes :rewrite)

Theorem: cst-scalar-type-conc-rep-elem-match

(defthm cst-scalar-type-conc-rep-elem-match
  (implies
       (cst-matchp abnf::cst "scalar-type")
       (b* ((abnf::cst1 (cst-scalar-type-conc-rep-elem abnf::cst)))
         (cst-matchp abnf::cst1 "%s\"scalar\"")))
  :rule-classes :rewrite)

Theorem: cst-scalar-type-conc-rep-elem-of-tree-fix-cst

(defthm cst-scalar-type-conc-rep-elem-of-tree-fix-cst
  (equal (cst-scalar-type-conc-rep-elem (abnf::tree-fix abnf::cst))
         (cst-scalar-type-conc-rep-elem abnf::cst)))

Theorem: cst-scalar-type-conc-rep-elem-tree-equiv-congruence-on-cst

(defthm cst-scalar-type-conc-rep-elem-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-scalar-type-conc-rep-elem abnf::cst)
                  (cst-scalar-type-conc-rep-elem cst-equiv)))
  :rule-classes :congruence)

Function: cst-arithmetic-type-conc1-rep-elem

(defun cst-arithmetic-type-conc1-rep-elem (abnf::cst)
 (declare (xargs :guard (abnf::treep abnf::cst)))
 (declare
     (xargs :guard (and (cst-matchp abnf::cst "arithmetic-type")
                        (equal (cst-arithmetic-type-conc? abnf::cst)
                               1))))
 (let ((__function__ 'cst-arithmetic-type-conc1-rep-elem))
  (declare (ignorable __function__))
  (abnf::tree-fix (nth 0
                       (cst-arithmetic-type-conc1-rep abnf::cst)))))

Theorem: treep-of-cst-arithmetic-type-conc1-rep-elem

(defthm treep-of-cst-arithmetic-type-conc1-rep-elem
  (b* ((abnf::cst1 (cst-arithmetic-type-conc1-rep-elem abnf::cst)))
    (abnf::treep abnf::cst1))
  :rule-classes :rewrite)

Theorem: cst-arithmetic-type-conc1-rep-elem-match

(defthm cst-arithmetic-type-conc1-rep-elem-match
 (implies
   (and (cst-matchp abnf::cst "arithmetic-type")
        (equal (cst-arithmetic-type-conc? abnf::cst)
               1))
   (b* ((abnf::cst1 (cst-arithmetic-type-conc1-rep-elem abnf::cst)))
     (cst-matchp abnf::cst1 "integer-type")))
 :rule-classes :rewrite)

Theorem: cst-arithmetic-type-conc1-rep-elem-of-tree-fix-cst

(defthm cst-arithmetic-type-conc1-rep-elem-of-tree-fix-cst
 (equal
     (cst-arithmetic-type-conc1-rep-elem (abnf::tree-fix abnf::cst))
     (cst-arithmetic-type-conc1-rep-elem abnf::cst)))

Theorem: cst-arithmetic-type-conc1-rep-elem-tree-equiv-congruence-on-cst

(defthm
    cst-arithmetic-type-conc1-rep-elem-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-arithmetic-type-conc1-rep-elem abnf::cst)
                  (cst-arithmetic-type-conc1-rep-elem cst-equiv)))
  :rule-classes :congruence)

Function: cst-arithmetic-type-conc2-rep-elem

(defun cst-arithmetic-type-conc2-rep-elem (abnf::cst)
 (declare (xargs :guard (abnf::treep abnf::cst)))
 (declare
     (xargs :guard (and (cst-matchp abnf::cst "arithmetic-type")
                        (equal (cst-arithmetic-type-conc? abnf::cst)
                               2))))
 (let ((__function__ 'cst-arithmetic-type-conc2-rep-elem))
  (declare (ignorable __function__))
  (abnf::tree-fix (nth 0
                       (cst-arithmetic-type-conc2-rep abnf::cst)))))

Theorem: treep-of-cst-arithmetic-type-conc2-rep-elem

(defthm treep-of-cst-arithmetic-type-conc2-rep-elem
  (b* ((abnf::cst1 (cst-arithmetic-type-conc2-rep-elem abnf::cst)))
    (abnf::treep abnf::cst1))
  :rule-classes :rewrite)

Theorem: cst-arithmetic-type-conc2-rep-elem-match

(defthm cst-arithmetic-type-conc2-rep-elem-match
 (implies
   (and (cst-matchp abnf::cst "arithmetic-type")
        (equal (cst-arithmetic-type-conc? abnf::cst)
               2))
   (b* ((abnf::cst1 (cst-arithmetic-type-conc2-rep-elem abnf::cst)))
     (cst-matchp abnf::cst1 "field-type")))
 :rule-classes :rewrite)

Theorem: cst-arithmetic-type-conc2-rep-elem-of-tree-fix-cst

(defthm cst-arithmetic-type-conc2-rep-elem-of-tree-fix-cst
 (equal
     (cst-arithmetic-type-conc2-rep-elem (abnf::tree-fix abnf::cst))
     (cst-arithmetic-type-conc2-rep-elem abnf::cst)))

Theorem: cst-arithmetic-type-conc2-rep-elem-tree-equiv-congruence-on-cst

(defthm
    cst-arithmetic-type-conc2-rep-elem-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-arithmetic-type-conc2-rep-elem abnf::cst)
                  (cst-arithmetic-type-conc2-rep-elem cst-equiv)))
  :rule-classes :congruence)

Function: cst-arithmetic-type-conc3-rep-elem

(defun cst-arithmetic-type-conc3-rep-elem (abnf::cst)
 (declare (xargs :guard (abnf::treep abnf::cst)))
 (declare
     (xargs :guard (and (cst-matchp abnf::cst "arithmetic-type")
                        (equal (cst-arithmetic-type-conc? abnf::cst)
                               3))))
 (let ((__function__ 'cst-arithmetic-type-conc3-rep-elem))
  (declare (ignorable __function__))
  (abnf::tree-fix (nth 0
                       (cst-arithmetic-type-conc3-rep abnf::cst)))))

Theorem: treep-of-cst-arithmetic-type-conc3-rep-elem

(defthm treep-of-cst-arithmetic-type-conc3-rep-elem
  (b* ((abnf::cst1 (cst-arithmetic-type-conc3-rep-elem abnf::cst)))
    (abnf::treep abnf::cst1))
  :rule-classes :rewrite)

Theorem: cst-arithmetic-type-conc3-rep-elem-match

(defthm cst-arithmetic-type-conc3-rep-elem-match
 (implies
   (and (cst-matchp abnf::cst "arithmetic-type")
        (equal (cst-arithmetic-type-conc? abnf::cst)
               3))
   (b* ((abnf::cst1 (cst-arithmetic-type-conc3-rep-elem abnf::cst)))
     (cst-matchp abnf::cst1 "group-type")))
 :rule-classes :rewrite)

Theorem: cst-arithmetic-type-conc3-rep-elem-of-tree-fix-cst

(defthm cst-arithmetic-type-conc3-rep-elem-of-tree-fix-cst
 (equal
     (cst-arithmetic-type-conc3-rep-elem (abnf::tree-fix abnf::cst))
     (cst-arithmetic-type-conc3-rep-elem abnf::cst)))

Theorem: cst-arithmetic-type-conc3-rep-elem-tree-equiv-congruence-on-cst

(defthm
    cst-arithmetic-type-conc3-rep-elem-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-arithmetic-type-conc3-rep-elem abnf::cst)
                  (cst-arithmetic-type-conc3-rep-elem cst-equiv)))
  :rule-classes :congruence)

Function: cst-arithmetic-type-conc4-rep-elem

(defun cst-arithmetic-type-conc4-rep-elem (abnf::cst)
 (declare (xargs :guard (abnf::treep abnf::cst)))
 (declare
     (xargs :guard (and (cst-matchp abnf::cst "arithmetic-type")
                        (equal (cst-arithmetic-type-conc? abnf::cst)
                               4))))
 (let ((__function__ 'cst-arithmetic-type-conc4-rep-elem))
  (declare (ignorable __function__))
  (abnf::tree-fix (nth 0
                       (cst-arithmetic-type-conc4-rep abnf::cst)))))

Theorem: treep-of-cst-arithmetic-type-conc4-rep-elem

(defthm treep-of-cst-arithmetic-type-conc4-rep-elem
  (b* ((abnf::cst1 (cst-arithmetic-type-conc4-rep-elem abnf::cst)))
    (abnf::treep abnf::cst1))
  :rule-classes :rewrite)

Theorem: cst-arithmetic-type-conc4-rep-elem-match

(defthm cst-arithmetic-type-conc4-rep-elem-match
 (implies
   (and (cst-matchp abnf::cst "arithmetic-type")
        (equal (cst-arithmetic-type-conc? abnf::cst)
               4))
   (b* ((abnf::cst1 (cst-arithmetic-type-conc4-rep-elem abnf::cst)))
     (cst-matchp abnf::cst1 "scalar-type")))
 :rule-classes :rewrite)

Theorem: cst-arithmetic-type-conc4-rep-elem-of-tree-fix-cst

(defthm cst-arithmetic-type-conc4-rep-elem-of-tree-fix-cst
 (equal
     (cst-arithmetic-type-conc4-rep-elem (abnf::tree-fix abnf::cst))
     (cst-arithmetic-type-conc4-rep-elem abnf::cst)))

Theorem: cst-arithmetic-type-conc4-rep-elem-tree-equiv-congruence-on-cst

(defthm
    cst-arithmetic-type-conc4-rep-elem-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-arithmetic-type-conc4-rep-elem abnf::cst)
                  (cst-arithmetic-type-conc4-rep-elem cst-equiv)))
  :rule-classes :congruence)

Function: cst-boolean-type-conc-rep-elem

(defun cst-boolean-type-conc-rep-elem (abnf::cst)
  (declare (xargs :guard (abnf::treep abnf::cst)))
  (declare (xargs :guard (cst-matchp abnf::cst "boolean-type")))
  (let ((__function__ 'cst-boolean-type-conc-rep-elem))
    (declare (ignorable __function__))
    (abnf::tree-fix (nth 0
                         (cst-boolean-type-conc-rep abnf::cst)))))

Theorem: treep-of-cst-boolean-type-conc-rep-elem

(defthm treep-of-cst-boolean-type-conc-rep-elem
  (b* ((abnf::cst1 (cst-boolean-type-conc-rep-elem abnf::cst)))
    (abnf::treep abnf::cst1))
  :rule-classes :rewrite)

Theorem: cst-boolean-type-conc-rep-elem-match

(defthm cst-boolean-type-conc-rep-elem-match
  (implies
       (cst-matchp abnf::cst "boolean-type")
       (b* ((abnf::cst1 (cst-boolean-type-conc-rep-elem abnf::cst)))
         (cst-matchp abnf::cst1 "%s\"bool\"")))
  :rule-classes :rewrite)

Theorem: cst-boolean-type-conc-rep-elem-of-tree-fix-cst

(defthm cst-boolean-type-conc-rep-elem-of-tree-fix-cst
  (equal (cst-boolean-type-conc-rep-elem (abnf::tree-fix abnf::cst))
         (cst-boolean-type-conc-rep-elem abnf::cst)))

Theorem: cst-boolean-type-conc-rep-elem-tree-equiv-congruence-on-cst

(defthm cst-boolean-type-conc-rep-elem-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-boolean-type-conc-rep-elem abnf::cst)
                  (cst-boolean-type-conc-rep-elem cst-equiv)))
  :rule-classes :congruence)

Function: cst-address-type-conc-rep-elem

(defun cst-address-type-conc-rep-elem (abnf::cst)
  (declare (xargs :guard (abnf::treep abnf::cst)))
  (declare (xargs :guard (cst-matchp abnf::cst "address-type")))
  (let ((__function__ 'cst-address-type-conc-rep-elem))
    (declare (ignorable __function__))
    (abnf::tree-fix (nth 0
                         (cst-address-type-conc-rep abnf::cst)))))

Theorem: treep-of-cst-address-type-conc-rep-elem

(defthm treep-of-cst-address-type-conc-rep-elem
  (b* ((abnf::cst1 (cst-address-type-conc-rep-elem abnf::cst)))
    (abnf::treep abnf::cst1))
  :rule-classes :rewrite)

Theorem: cst-address-type-conc-rep-elem-match

(defthm cst-address-type-conc-rep-elem-match
  (implies
       (cst-matchp abnf::cst "address-type")
       (b* ((abnf::cst1 (cst-address-type-conc-rep-elem abnf::cst)))
         (cst-matchp abnf::cst1 "%s\"address\"")))
  :rule-classes :rewrite)

Theorem: cst-address-type-conc-rep-elem-of-tree-fix-cst

(defthm cst-address-type-conc-rep-elem-of-tree-fix-cst
  (equal (cst-address-type-conc-rep-elem (abnf::tree-fix abnf::cst))
         (cst-address-type-conc-rep-elem abnf::cst)))

Theorem: cst-address-type-conc-rep-elem-tree-equiv-congruence-on-cst

(defthm cst-address-type-conc-rep-elem-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-address-type-conc-rep-elem abnf::cst)
                  (cst-address-type-conc-rep-elem cst-equiv)))
  :rule-classes :congruence)

Function: cst-signature-type-conc-rep-elem

(defun cst-signature-type-conc-rep-elem (abnf::cst)
  (declare (xargs :guard (abnf::treep abnf::cst)))
  (declare (xargs :guard (cst-matchp abnf::cst "signature-type")))
  (let ((__function__ 'cst-signature-type-conc-rep-elem))
    (declare (ignorable __function__))
    (abnf::tree-fix (nth 0
                         (cst-signature-type-conc-rep abnf::cst)))))

Theorem: treep-of-cst-signature-type-conc-rep-elem

(defthm treep-of-cst-signature-type-conc-rep-elem
  (b* ((abnf::cst1 (cst-signature-type-conc-rep-elem abnf::cst)))
    (abnf::treep abnf::cst1))
  :rule-classes :rewrite)

Theorem: cst-signature-type-conc-rep-elem-match

(defthm cst-signature-type-conc-rep-elem-match
 (implies
     (cst-matchp abnf::cst "signature-type")
     (b* ((abnf::cst1 (cst-signature-type-conc-rep-elem abnf::cst)))
       (cst-matchp abnf::cst1 "%s\"signature\"")))
 :rule-classes :rewrite)

Theorem: cst-signature-type-conc-rep-elem-of-tree-fix-cst

(defthm cst-signature-type-conc-rep-elem-of-tree-fix-cst
  (equal
       (cst-signature-type-conc-rep-elem (abnf::tree-fix abnf::cst))
       (cst-signature-type-conc-rep-elem abnf::cst)))

Theorem: cst-signature-type-conc-rep-elem-tree-equiv-congruence-on-cst

(defthm
      cst-signature-type-conc-rep-elem-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-signature-type-conc-rep-elem abnf::cst)
                  (cst-signature-type-conc-rep-elem cst-equiv)))
  :rule-classes :congruence)

Function: cst-string-type-conc-rep-elem

(defun cst-string-type-conc-rep-elem (abnf::cst)
  (declare (xargs :guard (abnf::treep abnf::cst)))
  (declare (xargs :guard (cst-matchp abnf::cst "string-type")))
  (let ((__function__ 'cst-string-type-conc-rep-elem))
    (declare (ignorable __function__))
    (abnf::tree-fix (nth 0
                         (cst-string-type-conc-rep abnf::cst)))))

Theorem: treep-of-cst-string-type-conc-rep-elem

(defthm treep-of-cst-string-type-conc-rep-elem
  (b* ((abnf::cst1 (cst-string-type-conc-rep-elem abnf::cst)))
    (abnf::treep abnf::cst1))
  :rule-classes :rewrite)

Theorem: cst-string-type-conc-rep-elem-match

(defthm cst-string-type-conc-rep-elem-match
  (implies
       (cst-matchp abnf::cst "string-type")
       (b* ((abnf::cst1 (cst-string-type-conc-rep-elem abnf::cst)))
         (cst-matchp abnf::cst1 "%s\"string\"")))
  :rule-classes :rewrite)

Theorem: cst-string-type-conc-rep-elem-of-tree-fix-cst

(defthm cst-string-type-conc-rep-elem-of-tree-fix-cst
  (equal (cst-string-type-conc-rep-elem (abnf::tree-fix abnf::cst))
         (cst-string-type-conc-rep-elem abnf::cst)))

Theorem: cst-string-type-conc-rep-elem-tree-equiv-congruence-on-cst

(defthm cst-string-type-conc-rep-elem-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-string-type-conc-rep-elem abnf::cst)
                  (cst-string-type-conc-rep-elem cst-equiv)))
  :rule-classes :congruence)

Function: cst-named-primitive-type-conc1-rep-elem

(defun cst-named-primitive-type-conc1-rep-elem (abnf::cst)
 (declare (xargs :guard (abnf::treep abnf::cst)))
 (declare
  (xargs
       :guard (and (cst-matchp abnf::cst "named-primitive-type")
                   (equal (cst-named-primitive-type-conc? abnf::cst)
                          1))))
 (let ((__function__ 'cst-named-primitive-type-conc1-rep-elem))
   (declare (ignorable __function__))
   (abnf::tree-fix
        (nth 0
             (cst-named-primitive-type-conc1-rep abnf::cst)))))

Theorem: treep-of-cst-named-primitive-type-conc1-rep-elem

(defthm treep-of-cst-named-primitive-type-conc1-rep-elem
 (b*
  ((abnf::cst1 (cst-named-primitive-type-conc1-rep-elem abnf::cst)))
  (abnf::treep abnf::cst1))
 :rule-classes :rewrite)

Theorem: cst-named-primitive-type-conc1-rep-elem-match

(defthm cst-named-primitive-type-conc1-rep-elem-match
 (implies
     (and (cst-matchp abnf::cst "named-primitive-type")
          (equal (cst-named-primitive-type-conc? abnf::cst)
                 1))
     (b* ((abnf::cst1
               (cst-named-primitive-type-conc1-rep-elem abnf::cst)))
       (cst-matchp abnf::cst1 "boolean-type")))
 :rule-classes :rewrite)

Theorem: cst-named-primitive-type-conc1-rep-elem-of-tree-fix-cst

(defthm cst-named-primitive-type-conc1-rep-elem-of-tree-fix-cst
  (equal (cst-named-primitive-type-conc1-rep-elem
              (abnf::tree-fix abnf::cst))
         (cst-named-primitive-type-conc1-rep-elem abnf::cst)))

Theorem: cst-named-primitive-type-conc1-rep-elem-tree-equiv-congruence-on-cst

(defthm
 cst-named-primitive-type-conc1-rep-elem-tree-equiv-congruence-on-cst
 (implies
      (abnf::tree-equiv abnf::cst cst-equiv)
      (equal (cst-named-primitive-type-conc1-rep-elem abnf::cst)
             (cst-named-primitive-type-conc1-rep-elem cst-equiv)))
 :rule-classes :congruence)

Function: cst-named-primitive-type-conc2-rep-elem

(defun cst-named-primitive-type-conc2-rep-elem (abnf::cst)
 (declare (xargs :guard (abnf::treep abnf::cst)))
 (declare
  (xargs
       :guard (and (cst-matchp abnf::cst "named-primitive-type")
                   (equal (cst-named-primitive-type-conc? abnf::cst)
                          2))))
 (let ((__function__ 'cst-named-primitive-type-conc2-rep-elem))
   (declare (ignorable __function__))
   (abnf::tree-fix
        (nth 0
             (cst-named-primitive-type-conc2-rep abnf::cst)))))

Theorem: treep-of-cst-named-primitive-type-conc2-rep-elem

(defthm treep-of-cst-named-primitive-type-conc2-rep-elem
 (b*
  ((abnf::cst1 (cst-named-primitive-type-conc2-rep-elem abnf::cst)))
  (abnf::treep abnf::cst1))
 :rule-classes :rewrite)

Theorem: cst-named-primitive-type-conc2-rep-elem-match

(defthm cst-named-primitive-type-conc2-rep-elem-match
 (implies
     (and (cst-matchp abnf::cst "named-primitive-type")
          (equal (cst-named-primitive-type-conc? abnf::cst)
                 2))
     (b* ((abnf::cst1
               (cst-named-primitive-type-conc2-rep-elem abnf::cst)))
       (cst-matchp abnf::cst1 "arithmetic-type")))
 :rule-classes :rewrite)

Theorem: cst-named-primitive-type-conc2-rep-elem-of-tree-fix-cst

(defthm cst-named-primitive-type-conc2-rep-elem-of-tree-fix-cst
  (equal (cst-named-primitive-type-conc2-rep-elem
              (abnf::tree-fix abnf::cst))
         (cst-named-primitive-type-conc2-rep-elem abnf::cst)))

Theorem: cst-named-primitive-type-conc2-rep-elem-tree-equiv-congruence-on-cst

(defthm
 cst-named-primitive-type-conc2-rep-elem-tree-equiv-congruence-on-cst
 (implies
      (abnf::tree-equiv abnf::cst cst-equiv)
      (equal (cst-named-primitive-type-conc2-rep-elem abnf::cst)
             (cst-named-primitive-type-conc2-rep-elem cst-equiv)))
 :rule-classes :congruence)

Function: cst-named-primitive-type-conc3-rep-elem

(defun cst-named-primitive-type-conc3-rep-elem (abnf::cst)
 (declare (xargs :guard (abnf::treep abnf::cst)))
 (declare
  (xargs
       :guard (and (cst-matchp abnf::cst "named-primitive-type")
                   (equal (cst-named-primitive-type-conc? abnf::cst)
                          3))))
 (let ((__function__ 'cst-named-primitive-type-conc3-rep-elem))
   (declare (ignorable __function__))
   (abnf::tree-fix
        (nth 0
             (cst-named-primitive-type-conc3-rep abnf::cst)))))

Theorem: treep-of-cst-named-primitive-type-conc3-rep-elem

(defthm treep-of-cst-named-primitive-type-conc3-rep-elem
 (b*
  ((abnf::cst1 (cst-named-primitive-type-conc3-rep-elem abnf::cst)))
  (abnf::treep abnf::cst1))
 :rule-classes :rewrite)

Theorem: cst-named-primitive-type-conc3-rep-elem-match

(defthm cst-named-primitive-type-conc3-rep-elem-match
 (implies
     (and (cst-matchp abnf::cst "named-primitive-type")
          (equal (cst-named-primitive-type-conc? abnf::cst)
                 3))
     (b* ((abnf::cst1
               (cst-named-primitive-type-conc3-rep-elem abnf::cst)))
       (cst-matchp abnf::cst1 "address-type")))
 :rule-classes :rewrite)

Theorem: cst-named-primitive-type-conc3-rep-elem-of-tree-fix-cst

(defthm cst-named-primitive-type-conc3-rep-elem-of-tree-fix-cst
  (equal (cst-named-primitive-type-conc3-rep-elem
              (abnf::tree-fix abnf::cst))
         (cst-named-primitive-type-conc3-rep-elem abnf::cst)))

Theorem: cst-named-primitive-type-conc3-rep-elem-tree-equiv-congruence-on-cst

(defthm
 cst-named-primitive-type-conc3-rep-elem-tree-equiv-congruence-on-cst
 (implies
      (abnf::tree-equiv abnf::cst cst-equiv)
      (equal (cst-named-primitive-type-conc3-rep-elem abnf::cst)
             (cst-named-primitive-type-conc3-rep-elem cst-equiv)))
 :rule-classes :congruence)

Function: cst-named-primitive-type-conc4-rep-elem

(defun cst-named-primitive-type-conc4-rep-elem (abnf::cst)
 (declare (xargs :guard (abnf::treep abnf::cst)))
 (declare
  (xargs
       :guard (and (cst-matchp abnf::cst "named-primitive-type")
                   (equal (cst-named-primitive-type-conc? abnf::cst)
                          4))))
 (let ((__function__ 'cst-named-primitive-type-conc4-rep-elem))
   (declare (ignorable __function__))
   (abnf::tree-fix
        (nth 0
             (cst-named-primitive-type-conc4-rep abnf::cst)))))

Theorem: treep-of-cst-named-primitive-type-conc4-rep-elem

(defthm treep-of-cst-named-primitive-type-conc4-rep-elem
 (b*
  ((abnf::cst1 (cst-named-primitive-type-conc4-rep-elem abnf::cst)))
  (abnf::treep abnf::cst1))
 :rule-classes :rewrite)

Theorem: cst-named-primitive-type-conc4-rep-elem-match

(defthm cst-named-primitive-type-conc4-rep-elem-match
 (implies
     (and (cst-matchp abnf::cst "named-primitive-type")
          (equal (cst-named-primitive-type-conc? abnf::cst)
                 4))
     (b* ((abnf::cst1
               (cst-named-primitive-type-conc4-rep-elem abnf::cst)))
       (cst-matchp abnf::cst1 "signature-type")))
 :rule-classes :rewrite)

Theorem: cst-named-primitive-type-conc4-rep-elem-of-tree-fix-cst

(defthm cst-named-primitive-type-conc4-rep-elem-of-tree-fix-cst
  (equal (cst-named-primitive-type-conc4-rep-elem
              (abnf::tree-fix abnf::cst))
         (cst-named-primitive-type-conc4-rep-elem abnf::cst)))

Theorem: cst-named-primitive-type-conc4-rep-elem-tree-equiv-congruence-on-cst

(defthm
 cst-named-primitive-type-conc4-rep-elem-tree-equiv-congruence-on-cst
 (implies
      (abnf::tree-equiv abnf::cst cst-equiv)
      (equal (cst-named-primitive-type-conc4-rep-elem abnf::cst)
             (cst-named-primitive-type-conc4-rep-elem cst-equiv)))
 :rule-classes :congruence)

Function: cst-named-primitive-type-conc5-rep-elem

(defun cst-named-primitive-type-conc5-rep-elem (abnf::cst)
 (declare (xargs :guard (abnf::treep abnf::cst)))
 (declare
  (xargs
       :guard (and (cst-matchp abnf::cst "named-primitive-type")
                   (equal (cst-named-primitive-type-conc? abnf::cst)
                          5))))
 (let ((__function__ 'cst-named-primitive-type-conc5-rep-elem))
   (declare (ignorable __function__))
   (abnf::tree-fix
        (nth 0
             (cst-named-primitive-type-conc5-rep abnf::cst)))))

Theorem: treep-of-cst-named-primitive-type-conc5-rep-elem

(defthm treep-of-cst-named-primitive-type-conc5-rep-elem
 (b*
  ((abnf::cst1 (cst-named-primitive-type-conc5-rep-elem abnf::cst)))
  (abnf::treep abnf::cst1))
 :rule-classes :rewrite)

Theorem: cst-named-primitive-type-conc5-rep-elem-match

(defthm cst-named-primitive-type-conc5-rep-elem-match
 (implies
     (and (cst-matchp abnf::cst "named-primitive-type")
          (equal (cst-named-primitive-type-conc? abnf::cst)
                 5))
     (b* ((abnf::cst1
               (cst-named-primitive-type-conc5-rep-elem abnf::cst)))
       (cst-matchp abnf::cst1 "string-type")))
 :rule-classes :rewrite)

Theorem: cst-named-primitive-type-conc5-rep-elem-of-tree-fix-cst

(defthm cst-named-primitive-type-conc5-rep-elem-of-tree-fix-cst
  (equal (cst-named-primitive-type-conc5-rep-elem
              (abnf::tree-fix abnf::cst))
         (cst-named-primitive-type-conc5-rep-elem abnf::cst)))

Theorem: cst-named-primitive-type-conc5-rep-elem-tree-equiv-congruence-on-cst

(defthm
 cst-named-primitive-type-conc5-rep-elem-tree-equiv-congruence-on-cst
 (implies
      (abnf::tree-equiv abnf::cst cst-equiv)
      (equal (cst-named-primitive-type-conc5-rep-elem abnf::cst)
             (cst-named-primitive-type-conc5-rep-elem cst-equiv)))
 :rule-classes :congruence)

Function: cst-primitive-type-conc1-rep-elem

(defun cst-primitive-type-conc1-rep-elem (abnf::cst)
 (declare (xargs :guard (abnf::treep abnf::cst)))
 (declare
      (xargs :guard (and (cst-matchp abnf::cst "primitive-type")
                         (equal (cst-primitive-type-conc? abnf::cst)
                                1))))
 (let ((__function__ 'cst-primitive-type-conc1-rep-elem))
   (declare (ignorable __function__))
   (abnf::tree-fix (nth 0
                        (cst-primitive-type-conc1-rep abnf::cst)))))

Theorem: treep-of-cst-primitive-type-conc1-rep-elem

(defthm treep-of-cst-primitive-type-conc1-rep-elem
  (b* ((abnf::cst1 (cst-primitive-type-conc1-rep-elem abnf::cst)))
    (abnf::treep abnf::cst1))
  :rule-classes :rewrite)

Theorem: cst-primitive-type-conc1-rep-elem-match

(defthm cst-primitive-type-conc1-rep-elem-match
 (implies
    (and (cst-matchp abnf::cst "primitive-type")
         (equal (cst-primitive-type-conc? abnf::cst)
                1))
    (b* ((abnf::cst1 (cst-primitive-type-conc1-rep-elem abnf::cst)))
      (cst-matchp abnf::cst1 "named-primitive-type")))
 :rule-classes :rewrite)

Theorem: cst-primitive-type-conc1-rep-elem-of-tree-fix-cst

(defthm cst-primitive-type-conc1-rep-elem-of-tree-fix-cst
 (equal
      (cst-primitive-type-conc1-rep-elem (abnf::tree-fix abnf::cst))
      (cst-primitive-type-conc1-rep-elem abnf::cst)))

Theorem: cst-primitive-type-conc1-rep-elem-tree-equiv-congruence-on-cst

(defthm
     cst-primitive-type-conc1-rep-elem-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-primitive-type-conc1-rep-elem abnf::cst)
                  (cst-primitive-type-conc1-rep-elem cst-equiv)))
  :rule-classes :congruence)

Function: cst-primitive-type-conc2-rep-elem

(defun cst-primitive-type-conc2-rep-elem (abnf::cst)
 (declare (xargs :guard (abnf::treep abnf::cst)))
 (declare
      (xargs :guard (and (cst-matchp abnf::cst "primitive-type")
                         (equal (cst-primitive-type-conc? abnf::cst)
                                2))))
 (let ((__function__ 'cst-primitive-type-conc2-rep-elem))
   (declare (ignorable __function__))
   (abnf::tree-fix (nth 0
                        (cst-primitive-type-conc2-rep abnf::cst)))))

Theorem: treep-of-cst-primitive-type-conc2-rep-elem

(defthm treep-of-cst-primitive-type-conc2-rep-elem
  (b* ((abnf::cst1 (cst-primitive-type-conc2-rep-elem abnf::cst)))
    (abnf::treep abnf::cst1))
  :rule-classes :rewrite)

Theorem: cst-primitive-type-conc2-rep-elem-match

(defthm cst-primitive-type-conc2-rep-elem-match
 (implies
    (and (cst-matchp abnf::cst "primitive-type")
         (equal (cst-primitive-type-conc? abnf::cst)
                2))
    (b* ((abnf::cst1 (cst-primitive-type-conc2-rep-elem abnf::cst)))
      (cst-matchp abnf::cst1 "unit-type")))
 :rule-classes :rewrite)

Theorem: cst-primitive-type-conc2-rep-elem-of-tree-fix-cst

(defthm cst-primitive-type-conc2-rep-elem-of-tree-fix-cst
 (equal
      (cst-primitive-type-conc2-rep-elem (abnf::tree-fix abnf::cst))
      (cst-primitive-type-conc2-rep-elem abnf::cst)))

Theorem: cst-primitive-type-conc2-rep-elem-tree-equiv-congruence-on-cst

(defthm
     cst-primitive-type-conc2-rep-elem-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-primitive-type-conc2-rep-elem abnf::cst)
                  (cst-primitive-type-conc2-rep-elem cst-equiv)))
  :rule-classes :congruence)

Function: cst-untyped-future-type-conc-rep-elem

(defun cst-untyped-future-type-conc-rep-elem (abnf::cst)
  (declare (xargs :guard (abnf::treep abnf::cst)))
  (declare
       (xargs :guard (cst-matchp abnf::cst "untyped-future-type")))
  (let ((__function__ 'cst-untyped-future-type-conc-rep-elem))
    (declare (ignorable __function__))
    (abnf::tree-fix
         (nth 0
              (cst-untyped-future-type-conc-rep abnf::cst)))))

Theorem: treep-of-cst-untyped-future-type-conc-rep-elem

(defthm treep-of-cst-untyped-future-type-conc-rep-elem
  (b*
    ((abnf::cst1 (cst-untyped-future-type-conc-rep-elem abnf::cst)))
    (abnf::treep abnf::cst1))
  :rule-classes :rewrite)

Theorem: cst-untyped-future-type-conc-rep-elem-match

(defthm cst-untyped-future-type-conc-rep-elem-match
 (implies
   (cst-matchp abnf::cst "untyped-future-type")
   (b*
    ((abnf::cst1 (cst-untyped-future-type-conc-rep-elem abnf::cst)))
    (cst-matchp abnf::cst1 "%s\"Future\"")))
 :rule-classes :rewrite)

Theorem: cst-untyped-future-type-conc-rep-elem-of-tree-fix-cst

(defthm cst-untyped-future-type-conc-rep-elem-of-tree-fix-cst
 (equal
  (cst-untyped-future-type-conc-rep-elem (abnf::tree-fix abnf::cst))
  (cst-untyped-future-type-conc-rep-elem abnf::cst)))

Theorem: cst-untyped-future-type-conc-rep-elem-tree-equiv-congruence-on-cst

(defthm
 cst-untyped-future-type-conc-rep-elem-tree-equiv-congruence-on-cst
 (implies (abnf::tree-equiv abnf::cst cst-equiv)
          (equal (cst-untyped-future-type-conc-rep-elem abnf::cst)
                 (cst-untyped-future-type-conc-rep-elem cst-equiv)))
 :rule-classes :congruence)

Function: cst-future-type-conc1-rep-elem

(defun cst-future-type-conc1-rep-elem (abnf::cst)
  (declare (xargs :guard (abnf::treep abnf::cst)))
  (declare
       (xargs :guard (and (cst-matchp abnf::cst "future-type")
                          (equal (cst-future-type-conc? abnf::cst)
                                 1))))
  (let ((__function__ 'cst-future-type-conc1-rep-elem))
    (declare (ignorable __function__))
    (abnf::tree-fix (nth 0
                         (cst-future-type-conc1-rep abnf::cst)))))

Theorem: treep-of-cst-future-type-conc1-rep-elem

(defthm treep-of-cst-future-type-conc1-rep-elem
  (b* ((abnf::cst1 (cst-future-type-conc1-rep-elem abnf::cst)))
    (abnf::treep abnf::cst1))
  :rule-classes :rewrite)

Theorem: cst-future-type-conc1-rep-elem-match

(defthm cst-future-type-conc1-rep-elem-match
  (implies
       (and (cst-matchp abnf::cst "future-type")
            (equal (cst-future-type-conc? abnf::cst)
                   1))
       (b* ((abnf::cst1 (cst-future-type-conc1-rep-elem abnf::cst)))
         (cst-matchp abnf::cst1 "untyped-future-type")))
  :rule-classes :rewrite)

Theorem: cst-future-type-conc1-rep-elem-of-tree-fix-cst

(defthm cst-future-type-conc1-rep-elem-of-tree-fix-cst
  (equal (cst-future-type-conc1-rep-elem (abnf::tree-fix abnf::cst))
         (cst-future-type-conc1-rep-elem abnf::cst)))

Theorem: cst-future-type-conc1-rep-elem-tree-equiv-congruence-on-cst

(defthm cst-future-type-conc1-rep-elem-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-future-type-conc1-rep-elem abnf::cst)
                  (cst-future-type-conc1-rep-elem cst-equiv)))
  :rule-classes :congruence)

Function: cst-future-type-conc2-rep-elem

(defun cst-future-type-conc2-rep-elem (abnf::cst)
  (declare (xargs :guard (abnf::treep abnf::cst)))
  (declare
       (xargs :guard (and (cst-matchp abnf::cst "future-type")
                          (equal (cst-future-type-conc? abnf::cst)
                                 2))))
  (let ((__function__ 'cst-future-type-conc2-rep-elem))
    (declare (ignorable __function__))
    (abnf::tree-fix (nth 0
                         (cst-future-type-conc2-rep abnf::cst)))))

Theorem: treep-of-cst-future-type-conc2-rep-elem

(defthm treep-of-cst-future-type-conc2-rep-elem
  (b* ((abnf::cst1 (cst-future-type-conc2-rep-elem abnf::cst)))
    (abnf::treep abnf::cst1))
  :rule-classes :rewrite)

Theorem: cst-future-type-conc2-rep-elem-match

(defthm cst-future-type-conc2-rep-elem-match
  (implies
       (and (cst-matchp abnf::cst "future-type")
            (equal (cst-future-type-conc? abnf::cst)
                   2))
       (b* ((abnf::cst1 (cst-future-type-conc2-rep-elem abnf::cst)))
         (cst-matchp abnf::cst1 "typed-future-type")))
  :rule-classes :rewrite)

Theorem: cst-future-type-conc2-rep-elem-of-tree-fix-cst

(defthm cst-future-type-conc2-rep-elem-of-tree-fix-cst
  (equal (cst-future-type-conc2-rep-elem (abnf::tree-fix abnf::cst))
         (cst-future-type-conc2-rep-elem abnf::cst)))

Theorem: cst-future-type-conc2-rep-elem-tree-equiv-congruence-on-cst

(defthm cst-future-type-conc2-rep-elem-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-future-type-conc2-rep-elem abnf::cst)
                  (cst-future-type-conc2-rep-elem cst-equiv)))
  :rule-classes :congruence)

Function: cst-type-conc1-rep-elem

(defun cst-type-conc1-rep-elem (abnf::cst)
 (declare (xargs :guard (abnf::treep abnf::cst)))
 (declare (xargs :guard (and (cst-matchp abnf::cst "type")
                             (equal (cst-type-conc? abnf::cst) 1))))
 (let ((__function__ 'cst-type-conc1-rep-elem))
   (declare (ignorable __function__))
   (abnf::tree-fix (nth 0 (cst-type-conc1-rep abnf::cst)))))

Theorem: treep-of-cst-type-conc1-rep-elem

(defthm treep-of-cst-type-conc1-rep-elem
  (b* ((abnf::cst1 (cst-type-conc1-rep-elem abnf::cst)))
    (abnf::treep abnf::cst1))
  :rule-classes :rewrite)

Theorem: cst-type-conc1-rep-elem-match

(defthm cst-type-conc1-rep-elem-match
  (implies (and (cst-matchp abnf::cst "type")
                (equal (cst-type-conc? abnf::cst) 1))
           (b* ((abnf::cst1 (cst-type-conc1-rep-elem abnf::cst)))
             (cst-matchp abnf::cst1 "primitive-type")))
  :rule-classes :rewrite)

Theorem: cst-type-conc1-rep-elem-of-tree-fix-cst

(defthm cst-type-conc1-rep-elem-of-tree-fix-cst
  (equal (cst-type-conc1-rep-elem (abnf::tree-fix abnf::cst))
         (cst-type-conc1-rep-elem abnf::cst)))

Theorem: cst-type-conc1-rep-elem-tree-equiv-congruence-on-cst

(defthm cst-type-conc1-rep-elem-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-type-conc1-rep-elem abnf::cst)
                  (cst-type-conc1-rep-elem cst-equiv)))
  :rule-classes :congruence)

Function: cst-type-conc2-rep-elem

(defun cst-type-conc2-rep-elem (abnf::cst)
 (declare (xargs :guard (abnf::treep abnf::cst)))
 (declare (xargs :guard (and (cst-matchp abnf::cst "type")
                             (equal (cst-type-conc? abnf::cst) 2))))
 (let ((__function__ 'cst-type-conc2-rep-elem))
   (declare (ignorable __function__))
   (abnf::tree-fix (nth 0 (cst-type-conc2-rep abnf::cst)))))

Theorem: treep-of-cst-type-conc2-rep-elem

(defthm treep-of-cst-type-conc2-rep-elem
  (b* ((abnf::cst1 (cst-type-conc2-rep-elem abnf::cst)))
    (abnf::treep abnf::cst1))
  :rule-classes :rewrite)

Theorem: cst-type-conc2-rep-elem-match

(defthm cst-type-conc2-rep-elem-match
  (implies (and (cst-matchp abnf::cst "type")
                (equal (cst-type-conc? abnf::cst) 2))
           (b* ((abnf::cst1 (cst-type-conc2-rep-elem abnf::cst)))
             (cst-matchp abnf::cst1 "future-type")))
  :rule-classes :rewrite)

Theorem: cst-type-conc2-rep-elem-of-tree-fix-cst

(defthm cst-type-conc2-rep-elem-of-tree-fix-cst
  (equal (cst-type-conc2-rep-elem (abnf::tree-fix abnf::cst))
         (cst-type-conc2-rep-elem abnf::cst)))

Theorem: cst-type-conc2-rep-elem-tree-equiv-congruence-on-cst

(defthm cst-type-conc2-rep-elem-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-type-conc2-rep-elem abnf::cst)
                  (cst-type-conc2-rep-elem cst-equiv)))
  :rule-classes :congruence)

Function: cst-type-conc3-rep-elem

(defun cst-type-conc3-rep-elem (abnf::cst)
 (declare (xargs :guard (abnf::treep abnf::cst)))
 (declare (xargs :guard (and (cst-matchp abnf::cst "type")
                             (equal (cst-type-conc? abnf::cst) 3))))
 (let ((__function__ 'cst-type-conc3-rep-elem))
   (declare (ignorable __function__))
   (abnf::tree-fix (nth 0 (cst-type-conc3-rep abnf::cst)))))

Theorem: treep-of-cst-type-conc3-rep-elem

(defthm treep-of-cst-type-conc3-rep-elem
  (b* ((abnf::cst1 (cst-type-conc3-rep-elem abnf::cst)))
    (abnf::treep abnf::cst1))
  :rule-classes :rewrite)

Theorem: cst-type-conc3-rep-elem-match

(defthm cst-type-conc3-rep-elem-match
  (implies (and (cst-matchp abnf::cst "type")
                (equal (cst-type-conc? abnf::cst) 3))
           (b* ((abnf::cst1 (cst-type-conc3-rep-elem abnf::cst)))
             (cst-matchp abnf::cst1 "tuple-type")))
  :rule-classes :rewrite)

Theorem: cst-type-conc3-rep-elem-of-tree-fix-cst

(defthm cst-type-conc3-rep-elem-of-tree-fix-cst
  (equal (cst-type-conc3-rep-elem (abnf::tree-fix abnf::cst))
         (cst-type-conc3-rep-elem abnf::cst)))

Theorem: cst-type-conc3-rep-elem-tree-equiv-congruence-on-cst

(defthm cst-type-conc3-rep-elem-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-type-conc3-rep-elem abnf::cst)
                  (cst-type-conc3-rep-elem cst-equiv)))
  :rule-classes :congruence)

Function: cst-type-conc4-rep-elem

(defun cst-type-conc4-rep-elem (abnf::cst)
 (declare (xargs :guard (abnf::treep abnf::cst)))
 (declare (xargs :guard (and (cst-matchp abnf::cst "type")
                             (equal (cst-type-conc? abnf::cst) 4))))
 (let ((__function__ 'cst-type-conc4-rep-elem))
   (declare (ignorable __function__))
   (abnf::tree-fix (nth 0 (cst-type-conc4-rep abnf::cst)))))

Theorem: treep-of-cst-type-conc4-rep-elem

(defthm treep-of-cst-type-conc4-rep-elem
  (b* ((abnf::cst1 (cst-type-conc4-rep-elem abnf::cst)))
    (abnf::treep abnf::cst1))
  :rule-classes :rewrite)

Theorem: cst-type-conc4-rep-elem-match

(defthm cst-type-conc4-rep-elem-match
  (implies (and (cst-matchp abnf::cst "type")
                (equal (cst-type-conc? abnf::cst) 4))
           (b* ((abnf::cst1 (cst-type-conc4-rep-elem abnf::cst)))
             (cst-matchp abnf::cst1 "array-type")))
  :rule-classes :rewrite)

Theorem: cst-type-conc4-rep-elem-of-tree-fix-cst

(defthm cst-type-conc4-rep-elem-of-tree-fix-cst
  (equal (cst-type-conc4-rep-elem (abnf::tree-fix abnf::cst))
         (cst-type-conc4-rep-elem abnf::cst)))

Theorem: cst-type-conc4-rep-elem-tree-equiv-congruence-on-cst

(defthm cst-type-conc4-rep-elem-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-type-conc4-rep-elem abnf::cst)
                  (cst-type-conc4-rep-elem cst-equiv)))
  :rule-classes :congruence)

Function: cst-named-type-conc1-rep-elem

(defun cst-named-type-conc1-rep-elem (abnf::cst)
 (declare (xargs :guard (abnf::treep abnf::cst)))
 (declare (xargs :guard (and (cst-matchp abnf::cst "named-type")
                             (equal (cst-named-type-conc? abnf::cst)
                                    1))))
 (let ((__function__ 'cst-named-type-conc1-rep-elem))
   (declare (ignorable __function__))
   (abnf::tree-fix (nth 0
                        (cst-named-type-conc1-rep abnf::cst)))))

Theorem: treep-of-cst-named-type-conc1-rep-elem

(defthm treep-of-cst-named-type-conc1-rep-elem
  (b* ((abnf::cst1 (cst-named-type-conc1-rep-elem abnf::cst)))
    (abnf::treep abnf::cst1))
  :rule-classes :rewrite)

Theorem: cst-named-type-conc1-rep-elem-match

(defthm cst-named-type-conc1-rep-elem-match
  (implies
       (and (cst-matchp abnf::cst "named-type")
            (equal (cst-named-type-conc? abnf::cst)
                   1))
       (b* ((abnf::cst1 (cst-named-type-conc1-rep-elem abnf::cst)))
         (cst-matchp abnf::cst1 "named-primitive-type")))
  :rule-classes :rewrite)

Theorem: cst-named-type-conc1-rep-elem-of-tree-fix-cst

(defthm cst-named-type-conc1-rep-elem-of-tree-fix-cst
  (equal (cst-named-type-conc1-rep-elem (abnf::tree-fix abnf::cst))
         (cst-named-type-conc1-rep-elem abnf::cst)))

Theorem: cst-named-type-conc1-rep-elem-tree-equiv-congruence-on-cst

(defthm cst-named-type-conc1-rep-elem-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-named-type-conc1-rep-elem abnf::cst)
                  (cst-named-type-conc1-rep-elem cst-equiv)))
  :rule-classes :congruence)

Function: cst-named-type-conc2-rep-elem

(defun cst-named-type-conc2-rep-elem (abnf::cst)
 (declare (xargs :guard (abnf::treep abnf::cst)))
 (declare (xargs :guard (and (cst-matchp abnf::cst "named-type")
                             (equal (cst-named-type-conc? abnf::cst)
                                    2))))
 (let ((__function__ 'cst-named-type-conc2-rep-elem))
   (declare (ignorable __function__))
   (abnf::tree-fix (nth 0
                        (cst-named-type-conc2-rep abnf::cst)))))

Theorem: treep-of-cst-named-type-conc2-rep-elem

(defthm treep-of-cst-named-type-conc2-rep-elem
  (b* ((abnf::cst1 (cst-named-type-conc2-rep-elem abnf::cst)))
    (abnf::treep abnf::cst1))
  :rule-classes :rewrite)

Theorem: cst-named-type-conc2-rep-elem-match

(defthm cst-named-type-conc2-rep-elem-match
  (implies
       (and (cst-matchp abnf::cst "named-type")
            (equal (cst-named-type-conc? abnf::cst)
                   2))
       (b* ((abnf::cst1 (cst-named-type-conc2-rep-elem abnf::cst)))
         (cst-matchp abnf::cst1 "untyped-future-type")))
  :rule-classes :rewrite)

Theorem: cst-named-type-conc2-rep-elem-of-tree-fix-cst

(defthm cst-named-type-conc2-rep-elem-of-tree-fix-cst
  (equal (cst-named-type-conc2-rep-elem (abnf::tree-fix abnf::cst))
         (cst-named-type-conc2-rep-elem abnf::cst)))

Theorem: cst-named-type-conc2-rep-elem-tree-equiv-congruence-on-cst

(defthm cst-named-type-conc2-rep-elem-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-named-type-conc2-rep-elem abnf::cst)
                  (cst-named-type-conc2-rep-elem cst-equiv)))
  :rule-classes :congruence)

Function: cst-named-type-conc3-rep-elem

(defun cst-named-type-conc3-rep-elem (abnf::cst)
 (declare (xargs :guard (abnf::treep abnf::cst)))
 (declare (xargs :guard (and (cst-matchp abnf::cst "named-type")
                             (equal (cst-named-type-conc? abnf::cst)
                                    3))))
 (let ((__function__ 'cst-named-type-conc3-rep-elem))
   (declare (ignorable __function__))
   (abnf::tree-fix (nth 0
                        (cst-named-type-conc3-rep abnf::cst)))))

Theorem: treep-of-cst-named-type-conc3-rep-elem

(defthm treep-of-cst-named-type-conc3-rep-elem
  (b* ((abnf::cst1 (cst-named-type-conc3-rep-elem abnf::cst)))
    (abnf::treep abnf::cst1))
  :rule-classes :rewrite)

Theorem: cst-named-type-conc3-rep-elem-match

(defthm cst-named-type-conc3-rep-elem-match
  (implies
       (and (cst-matchp abnf::cst "named-type")
            (equal (cst-named-type-conc? abnf::cst)
                   3))
       (b* ((abnf::cst1 (cst-named-type-conc3-rep-elem abnf::cst)))
         (cst-matchp abnf::cst1 "identifier")))
  :rule-classes :rewrite)

Theorem: cst-named-type-conc3-rep-elem-of-tree-fix-cst

(defthm cst-named-type-conc3-rep-elem-of-tree-fix-cst
  (equal (cst-named-type-conc3-rep-elem (abnf::tree-fix abnf::cst))
         (cst-named-type-conc3-rep-elem abnf::cst)))

Theorem: cst-named-type-conc3-rep-elem-tree-equiv-congruence-on-cst

(defthm cst-named-type-conc3-rep-elem-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-named-type-conc3-rep-elem abnf::cst)
                  (cst-named-type-conc3-rep-elem cst-equiv)))
  :rule-classes :congruence)

Function: cst-program-address-literal-conc-rep-elem

(defun cst-program-address-literal-conc-rep-elem (abnf::cst)
 (declare (xargs :guard (abnf::treep abnf::cst)))
 (declare
    (xargs :guard (cst-matchp abnf::cst "program-address-literal")))
 (let ((__function__ 'cst-program-address-literal-conc-rep-elem))
   (declare (ignorable __function__))
   (abnf::tree-fix
        (nth 0
             (cst-program-address-literal-conc-rep abnf::cst)))))

Theorem: treep-of-cst-program-address-literal-conc-rep-elem

(defthm treep-of-cst-program-address-literal-conc-rep-elem
  (b* ((abnf::cst1
            (cst-program-address-literal-conc-rep-elem abnf::cst)))
    (abnf::treep abnf::cst1))
  :rule-classes :rewrite)

Theorem: cst-program-address-literal-conc-rep-elem-match

(defthm cst-program-address-literal-conc-rep-elem-match
 (implies
   (cst-matchp abnf::cst "program-address-literal")
   (b* ((abnf::cst1
             (cst-program-address-literal-conc-rep-elem abnf::cst)))
     (cst-matchp abnf::cst1 "program-id")))
 :rule-classes :rewrite)

Theorem: cst-program-address-literal-conc-rep-elem-of-tree-fix-cst

(defthm cst-program-address-literal-conc-rep-elem-of-tree-fix-cst
  (equal (cst-program-address-literal-conc-rep-elem
              (abnf::tree-fix abnf::cst))
         (cst-program-address-literal-conc-rep-elem abnf::cst)))

Theorem: cst-program-address-literal-conc-rep-elem-tree-equiv-congruence-on-cst

(defthm
 cst-program-address-literal-conc-rep-elem-tree-equiv-congruence-on-cst
 (implies
      (abnf::tree-equiv abnf::cst cst-equiv)
      (equal (cst-program-address-literal-conc-rep-elem abnf::cst)
             (cst-program-address-literal-conc-rep-elem cst-equiv)))
 :rule-classes :congruence)

Function: cst-literal-conc1-rep-elem

(defun cst-literal-conc1-rep-elem (abnf::cst)
  (declare (xargs :guard (abnf::treep abnf::cst)))
  (declare (xargs :guard (and (cst-matchp abnf::cst "literal")
                              (equal (cst-literal-conc? abnf::cst)
                                     1))))
  (let ((__function__ 'cst-literal-conc1-rep-elem))
    (declare (ignorable __function__))
    (abnf::tree-fix (nth 0 (cst-literal-conc1-rep abnf::cst)))))

Theorem: treep-of-cst-literal-conc1-rep-elem

(defthm treep-of-cst-literal-conc1-rep-elem
  (b* ((abnf::cst1 (cst-literal-conc1-rep-elem abnf::cst)))
    (abnf::treep abnf::cst1))
  :rule-classes :rewrite)

Theorem: cst-literal-conc1-rep-elem-match

(defthm cst-literal-conc1-rep-elem-match
  (implies (and (cst-matchp abnf::cst "literal")
                (equal (cst-literal-conc? abnf::cst) 1))
           (b* ((abnf::cst1 (cst-literal-conc1-rep-elem abnf::cst)))
             (cst-matchp abnf::cst1 "atomic-literal")))
  :rule-classes :rewrite)

Theorem: cst-literal-conc1-rep-elem-of-tree-fix-cst

(defthm cst-literal-conc1-rep-elem-of-tree-fix-cst
  (equal (cst-literal-conc1-rep-elem (abnf::tree-fix abnf::cst))
         (cst-literal-conc1-rep-elem abnf::cst)))

Theorem: cst-literal-conc1-rep-elem-tree-equiv-congruence-on-cst

(defthm cst-literal-conc1-rep-elem-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-literal-conc1-rep-elem abnf::cst)
                  (cst-literal-conc1-rep-elem cst-equiv)))
  :rule-classes :congruence)

Function: cst-literal-conc2-rep-elem

(defun cst-literal-conc2-rep-elem (abnf::cst)
  (declare (xargs :guard (abnf::treep abnf::cst)))
  (declare (xargs :guard (and (cst-matchp abnf::cst "literal")
                              (equal (cst-literal-conc? abnf::cst)
                                     2))))
  (let ((__function__ 'cst-literal-conc2-rep-elem))
    (declare (ignorable __function__))
    (abnf::tree-fix (nth 0 (cst-literal-conc2-rep abnf::cst)))))

Theorem: treep-of-cst-literal-conc2-rep-elem

(defthm treep-of-cst-literal-conc2-rep-elem
  (b* ((abnf::cst1 (cst-literal-conc2-rep-elem abnf::cst)))
    (abnf::treep abnf::cst1))
  :rule-classes :rewrite)

Theorem: cst-literal-conc2-rep-elem-match

(defthm cst-literal-conc2-rep-elem-match
  (implies (and (cst-matchp abnf::cst "literal")
                (equal (cst-literal-conc? abnf::cst) 2))
           (b* ((abnf::cst1 (cst-literal-conc2-rep-elem abnf::cst)))
             (cst-matchp abnf::cst1 "program-address-literal")))
  :rule-classes :rewrite)

Theorem: cst-literal-conc2-rep-elem-of-tree-fix-cst

(defthm cst-literal-conc2-rep-elem-of-tree-fix-cst
  (equal (cst-literal-conc2-rep-elem (abnf::tree-fix abnf::cst))
         (cst-literal-conc2-rep-elem abnf::cst)))

Theorem: cst-literal-conc2-rep-elem-tree-equiv-congruence-on-cst

(defthm cst-literal-conc2-rep-elem-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-literal-conc2-rep-elem abnf::cst)
                  (cst-literal-conc2-rep-elem cst-equiv)))
  :rule-classes :congruence)

Function: cst-address-literal-conc1-rep-elem

(defun cst-address-literal-conc1-rep-elem (abnf::cst)
 (declare (xargs :guard (abnf::treep abnf::cst)))
 (declare
     (xargs :guard (and (cst-matchp abnf::cst "address-literal")
                        (equal (cst-address-literal-conc? abnf::cst)
                               1))))
 (let ((__function__ 'cst-address-literal-conc1-rep-elem))
  (declare (ignorable __function__))
  (abnf::tree-fix (nth 0
                       (cst-address-literal-conc1-rep abnf::cst)))))

Theorem: treep-of-cst-address-literal-conc1-rep-elem

(defthm treep-of-cst-address-literal-conc1-rep-elem
  (b* ((abnf::cst1 (cst-address-literal-conc1-rep-elem abnf::cst)))
    (abnf::treep abnf::cst1))
  :rule-classes :rewrite)

Theorem: cst-address-literal-conc1-rep-elem-match

(defthm cst-address-literal-conc1-rep-elem-match
 (implies
   (and (cst-matchp abnf::cst "address-literal")
        (equal (cst-address-literal-conc? abnf::cst)
               1))
   (b* ((abnf::cst1 (cst-address-literal-conc1-rep-elem abnf::cst)))
     (cst-matchp abnf::cst1 "explicit-address-literal")))
 :rule-classes :rewrite)

Theorem: cst-address-literal-conc1-rep-elem-of-tree-fix-cst

(defthm cst-address-literal-conc1-rep-elem-of-tree-fix-cst
 (equal
     (cst-address-literal-conc1-rep-elem (abnf::tree-fix abnf::cst))
     (cst-address-literal-conc1-rep-elem abnf::cst)))

Theorem: cst-address-literal-conc1-rep-elem-tree-equiv-congruence-on-cst

(defthm
    cst-address-literal-conc1-rep-elem-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-address-literal-conc1-rep-elem abnf::cst)
                  (cst-address-literal-conc1-rep-elem cst-equiv)))
  :rule-classes :congruence)

Function: cst-address-literal-conc2-rep-elem

(defun cst-address-literal-conc2-rep-elem (abnf::cst)
 (declare (xargs :guard (abnf::treep abnf::cst)))
 (declare
     (xargs :guard (and (cst-matchp abnf::cst "address-literal")
                        (equal (cst-address-literal-conc? abnf::cst)
                               2))))
 (let ((__function__ 'cst-address-literal-conc2-rep-elem))
  (declare (ignorable __function__))
  (abnf::tree-fix (nth 0
                       (cst-address-literal-conc2-rep abnf::cst)))))

Theorem: treep-of-cst-address-literal-conc2-rep-elem

(defthm treep-of-cst-address-literal-conc2-rep-elem
  (b* ((abnf::cst1 (cst-address-literal-conc2-rep-elem abnf::cst)))
    (abnf::treep abnf::cst1))
  :rule-classes :rewrite)

Theorem: cst-address-literal-conc2-rep-elem-match

(defthm cst-address-literal-conc2-rep-elem-match
 (implies
   (and (cst-matchp abnf::cst "address-literal")
        (equal (cst-address-literal-conc? abnf::cst)
               2))
   (b* ((abnf::cst1 (cst-address-literal-conc2-rep-elem abnf::cst)))
     (cst-matchp abnf::cst1 "program-address-literal")))
 :rule-classes :rewrite)

Theorem: cst-address-literal-conc2-rep-elem-of-tree-fix-cst

(defthm cst-address-literal-conc2-rep-elem-of-tree-fix-cst
 (equal
     (cst-address-literal-conc2-rep-elem (abnf::tree-fix abnf::cst))
     (cst-address-literal-conc2-rep-elem abnf::cst)))

Theorem: cst-address-literal-conc2-rep-elem-tree-equiv-congruence-on-cst

(defthm
    cst-address-literal-conc2-rep-elem-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-address-literal-conc2-rep-elem abnf::cst)
                  (cst-address-literal-conc2-rep-elem cst-equiv)))
  :rule-classes :congruence)

Function: cst-variable-conc-rep-elem

(defun cst-variable-conc-rep-elem (abnf::cst)
  (declare (xargs :guard (abnf::treep abnf::cst)))
  (declare (xargs :guard (cst-matchp abnf::cst "variable")))
  (let ((__function__ 'cst-variable-conc-rep-elem))
    (declare (ignorable __function__))
    (abnf::tree-fix (nth 0 (cst-variable-conc-rep abnf::cst)))))

Theorem: treep-of-cst-variable-conc-rep-elem

(defthm treep-of-cst-variable-conc-rep-elem
  (b* ((abnf::cst1 (cst-variable-conc-rep-elem abnf::cst)))
    (abnf::treep abnf::cst1))
  :rule-classes :rewrite)

Theorem: cst-variable-conc-rep-elem-match

(defthm cst-variable-conc-rep-elem-match
  (implies (cst-matchp abnf::cst "variable")
           (b* ((abnf::cst1 (cst-variable-conc-rep-elem abnf::cst)))
             (cst-matchp abnf::cst1 "identifier")))
  :rule-classes :rewrite)

Theorem: cst-variable-conc-rep-elem-of-tree-fix-cst

(defthm cst-variable-conc-rep-elem-of-tree-fix-cst
  (equal (cst-variable-conc-rep-elem (abnf::tree-fix abnf::cst))
         (cst-variable-conc-rep-elem abnf::cst)))

Theorem: cst-variable-conc-rep-elem-tree-equiv-congruence-on-cst

(defthm cst-variable-conc-rep-elem-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-variable-conc-rep-elem abnf::cst)
                  (cst-variable-conc-rep-elem cst-equiv)))
  :rule-classes :congruence)

Function: cst-postfix-expression-conc1-rep-elem

(defun cst-postfix-expression-conc1-rep-elem (abnf::cst)
 (declare (xargs :guard (abnf::treep abnf::cst)))
 (declare
  (xargs :guard (and (cst-matchp abnf::cst "postfix-expression")
                     (equal (cst-postfix-expression-conc? abnf::cst)
                            1))))
 (let ((__function__ 'cst-postfix-expression-conc1-rep-elem))
   (declare (ignorable __function__))
   (abnf::tree-fix
        (nth 0
             (cst-postfix-expression-conc1-rep abnf::cst)))))

Theorem: treep-of-cst-postfix-expression-conc1-rep-elem

(defthm treep-of-cst-postfix-expression-conc1-rep-elem
  (b*
    ((abnf::cst1 (cst-postfix-expression-conc1-rep-elem abnf::cst)))
    (abnf::treep abnf::cst1))
  :rule-classes :rewrite)

Theorem: cst-postfix-expression-conc1-rep-elem-match

(defthm cst-postfix-expression-conc1-rep-elem-match
 (implies
   (and (cst-matchp abnf::cst "postfix-expression")
        (equal (cst-postfix-expression-conc? abnf::cst)
               1))
   (b*
    ((abnf::cst1 (cst-postfix-expression-conc1-rep-elem abnf::cst)))
    (cst-matchp abnf::cst1 "primary-expression")))
 :rule-classes :rewrite)

Theorem: cst-postfix-expression-conc1-rep-elem-of-tree-fix-cst

(defthm cst-postfix-expression-conc1-rep-elem-of-tree-fix-cst
 (equal
  (cst-postfix-expression-conc1-rep-elem (abnf::tree-fix abnf::cst))
  (cst-postfix-expression-conc1-rep-elem abnf::cst)))

Theorem: cst-postfix-expression-conc1-rep-elem-tree-equiv-congruence-on-cst

(defthm
 cst-postfix-expression-conc1-rep-elem-tree-equiv-congruence-on-cst
 (implies (abnf::tree-equiv abnf::cst cst-equiv)
          (equal (cst-postfix-expression-conc1-rep-elem abnf::cst)
                 (cst-postfix-expression-conc1-rep-elem cst-equiv)))
 :rule-classes :congruence)

Function: cst-postfix-expression-conc2-rep-elem

(defun cst-postfix-expression-conc2-rep-elem (abnf::cst)
 (declare (xargs :guard (abnf::treep abnf::cst)))
 (declare
  (xargs :guard (and (cst-matchp abnf::cst "postfix-expression")
                     (equal (cst-postfix-expression-conc? abnf::cst)
                            2))))
 (let ((__function__ 'cst-postfix-expression-conc2-rep-elem))
   (declare (ignorable __function__))
   (abnf::tree-fix
        (nth 0
             (cst-postfix-expression-conc2-rep abnf::cst)))))

Theorem: treep-of-cst-postfix-expression-conc2-rep-elem

(defthm treep-of-cst-postfix-expression-conc2-rep-elem
  (b*
    ((abnf::cst1 (cst-postfix-expression-conc2-rep-elem abnf::cst)))
    (abnf::treep abnf::cst1))
  :rule-classes :rewrite)

Theorem: cst-postfix-expression-conc2-rep-elem-match

(defthm cst-postfix-expression-conc2-rep-elem-match
 (implies
   (and (cst-matchp abnf::cst "postfix-expression")
        (equal (cst-postfix-expression-conc? abnf::cst)
               2))
   (b*
    ((abnf::cst1 (cst-postfix-expression-conc2-rep-elem abnf::cst)))
    (cst-matchp abnf::cst1
                "tuple-component-expression")))
 :rule-classes :rewrite)

Theorem: cst-postfix-expression-conc2-rep-elem-of-tree-fix-cst

(defthm cst-postfix-expression-conc2-rep-elem-of-tree-fix-cst
 (equal
  (cst-postfix-expression-conc2-rep-elem (abnf::tree-fix abnf::cst))
  (cst-postfix-expression-conc2-rep-elem abnf::cst)))

Theorem: cst-postfix-expression-conc2-rep-elem-tree-equiv-congruence-on-cst

(defthm
 cst-postfix-expression-conc2-rep-elem-tree-equiv-congruence-on-cst
 (implies (abnf::tree-equiv abnf::cst cst-equiv)
          (equal (cst-postfix-expression-conc2-rep-elem abnf::cst)
                 (cst-postfix-expression-conc2-rep-elem cst-equiv)))
 :rule-classes :congruence)

Function: cst-postfix-expression-conc3-rep-elem

(defun cst-postfix-expression-conc3-rep-elem (abnf::cst)
 (declare (xargs :guard (abnf::treep abnf::cst)))
 (declare
  (xargs :guard (and (cst-matchp abnf::cst "postfix-expression")
                     (equal (cst-postfix-expression-conc? abnf::cst)
                            3))))
 (let ((__function__ 'cst-postfix-expression-conc3-rep-elem))
   (declare (ignorable __function__))
   (abnf::tree-fix
        (nth 0
             (cst-postfix-expression-conc3-rep abnf::cst)))))

Theorem: treep-of-cst-postfix-expression-conc3-rep-elem

(defthm treep-of-cst-postfix-expression-conc3-rep-elem
  (b*
    ((abnf::cst1 (cst-postfix-expression-conc3-rep-elem abnf::cst)))
    (abnf::treep abnf::cst1))
  :rule-classes :rewrite)

Theorem: cst-postfix-expression-conc3-rep-elem-match

(defthm cst-postfix-expression-conc3-rep-elem-match
 (implies
   (and (cst-matchp abnf::cst "postfix-expression")
        (equal (cst-postfix-expression-conc? abnf::cst)
               3))
   (b*
    ((abnf::cst1 (cst-postfix-expression-conc3-rep-elem abnf::cst)))
    (cst-matchp abnf::cst1
                "array-component-expression")))
 :rule-classes :rewrite)

Theorem: cst-postfix-expression-conc3-rep-elem-of-tree-fix-cst

(defthm cst-postfix-expression-conc3-rep-elem-of-tree-fix-cst
 (equal
  (cst-postfix-expression-conc3-rep-elem (abnf::tree-fix abnf::cst))
  (cst-postfix-expression-conc3-rep-elem abnf::cst)))

Theorem: cst-postfix-expression-conc3-rep-elem-tree-equiv-congruence-on-cst

(defthm
 cst-postfix-expression-conc3-rep-elem-tree-equiv-congruence-on-cst
 (implies (abnf::tree-equiv abnf::cst cst-equiv)
          (equal (cst-postfix-expression-conc3-rep-elem abnf::cst)
                 (cst-postfix-expression-conc3-rep-elem cst-equiv)))
 :rule-classes :congruence)

Function: cst-postfix-expression-conc4-rep-elem

(defun cst-postfix-expression-conc4-rep-elem (abnf::cst)
 (declare (xargs :guard (abnf::treep abnf::cst)))
 (declare
  (xargs :guard (and (cst-matchp abnf::cst "postfix-expression")
                     (equal (cst-postfix-expression-conc? abnf::cst)
                            4))))
 (let ((__function__ 'cst-postfix-expression-conc4-rep-elem))
   (declare (ignorable __function__))
   (abnf::tree-fix
        (nth 0
             (cst-postfix-expression-conc4-rep abnf::cst)))))

Theorem: treep-of-cst-postfix-expression-conc4-rep-elem

(defthm treep-of-cst-postfix-expression-conc4-rep-elem
  (b*
    ((abnf::cst1 (cst-postfix-expression-conc4-rep-elem abnf::cst)))
    (abnf::treep abnf::cst1))
  :rule-classes :rewrite)

Theorem: cst-postfix-expression-conc4-rep-elem-match

(defthm cst-postfix-expression-conc4-rep-elem-match
 (implies
   (and (cst-matchp abnf::cst "postfix-expression")
        (equal (cst-postfix-expression-conc? abnf::cst)
               4))
   (b*
    ((abnf::cst1 (cst-postfix-expression-conc4-rep-elem abnf::cst)))
    (cst-matchp abnf::cst1
                "struct-component-expression")))
 :rule-classes :rewrite)

Theorem: cst-postfix-expression-conc4-rep-elem-of-tree-fix-cst

(defthm cst-postfix-expression-conc4-rep-elem-of-tree-fix-cst
 (equal
  (cst-postfix-expression-conc4-rep-elem (abnf::tree-fix abnf::cst))
  (cst-postfix-expression-conc4-rep-elem abnf::cst)))

Theorem: cst-postfix-expression-conc4-rep-elem-tree-equiv-congruence-on-cst

(defthm
 cst-postfix-expression-conc4-rep-elem-tree-equiv-congruence-on-cst
 (implies (abnf::tree-equiv abnf::cst cst-equiv)
          (equal (cst-postfix-expression-conc4-rep-elem abnf::cst)
                 (cst-postfix-expression-conc4-rep-elem cst-equiv)))
 :rule-classes :congruence)

Function: cst-postfix-expression-conc5-rep-elem

(defun cst-postfix-expression-conc5-rep-elem (abnf::cst)
 (declare (xargs :guard (abnf::treep abnf::cst)))
 (declare
  (xargs :guard (and (cst-matchp abnf::cst "postfix-expression")
                     (equal (cst-postfix-expression-conc? abnf::cst)
                            5))))
 (let ((__function__ 'cst-postfix-expression-conc5-rep-elem))
   (declare (ignorable __function__))
   (abnf::tree-fix
        (nth 0
             (cst-postfix-expression-conc5-rep abnf::cst)))))

Theorem: treep-of-cst-postfix-expression-conc5-rep-elem

(defthm treep-of-cst-postfix-expression-conc5-rep-elem
  (b*
    ((abnf::cst1 (cst-postfix-expression-conc5-rep-elem abnf::cst)))
    (abnf::treep abnf::cst1))
  :rule-classes :rewrite)

Theorem: cst-postfix-expression-conc5-rep-elem-match

(defthm cst-postfix-expression-conc5-rep-elem-match
 (implies
   (and (cst-matchp abnf::cst "postfix-expression")
        (equal (cst-postfix-expression-conc? abnf::cst)
               5))
   (b*
    ((abnf::cst1 (cst-postfix-expression-conc5-rep-elem abnf::cst)))
    (cst-matchp abnf::cst1 "method-call")))
 :rule-classes :rewrite)

Theorem: cst-postfix-expression-conc5-rep-elem-of-tree-fix-cst

(defthm cst-postfix-expression-conc5-rep-elem-of-tree-fix-cst
 (equal
  (cst-postfix-expression-conc5-rep-elem (abnf::tree-fix abnf::cst))
  (cst-postfix-expression-conc5-rep-elem abnf::cst)))

Theorem: cst-postfix-expression-conc5-rep-elem-tree-equiv-congruence-on-cst

(defthm
 cst-postfix-expression-conc5-rep-elem-tree-equiv-congruence-on-cst
 (implies (abnf::tree-equiv abnf::cst cst-equiv)
          (equal (cst-postfix-expression-conc5-rep-elem abnf::cst)
                 (cst-postfix-expression-conc5-rep-elem cst-equiv)))
 :rule-classes :congruence)

Function: cst-binary-expression-conc-rep-elem

(defun cst-binary-expression-conc-rep-elem (abnf::cst)
 (declare (xargs :guard (abnf::treep abnf::cst)))
 (declare (xargs :guard (cst-matchp abnf::cst "binary-expression")))
 (let ((__function__ 'cst-binary-expression-conc-rep-elem))
   (declare (ignorable __function__))
   (abnf::tree-fix
        (nth 0
             (cst-binary-expression-conc-rep abnf::cst)))))

Theorem: treep-of-cst-binary-expression-conc-rep-elem

(defthm treep-of-cst-binary-expression-conc-rep-elem
  (b* ((abnf::cst1 (cst-binary-expression-conc-rep-elem abnf::cst)))
    (abnf::treep abnf::cst1))
  :rule-classes :rewrite)

Theorem: cst-binary-expression-conc-rep-elem-match

(defthm cst-binary-expression-conc-rep-elem-match
 (implies
  (cst-matchp abnf::cst "binary-expression")
  (b* ((abnf::cst1 (cst-binary-expression-conc-rep-elem abnf::cst)))
    (cst-matchp abnf::cst1
                "conditional-disjunctive-expression")))
 :rule-classes :rewrite)

Theorem: cst-binary-expression-conc-rep-elem-of-tree-fix-cst

(defthm cst-binary-expression-conc-rep-elem-of-tree-fix-cst
 (equal
    (cst-binary-expression-conc-rep-elem (abnf::tree-fix abnf::cst))
    (cst-binary-expression-conc-rep-elem abnf::cst)))

Theorem: cst-binary-expression-conc-rep-elem-tree-equiv-congruence-on-cst

(defthm
   cst-binary-expression-conc-rep-elem-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-binary-expression-conc-rep-elem abnf::cst)
                  (cst-binary-expression-conc-rep-elem cst-equiv)))
  :rule-classes :congruence)

Function: cst-expression-conc-rep-elem

(defun cst-expression-conc-rep-elem (abnf::cst)
  (declare (xargs :guard (abnf::treep abnf::cst)))
  (declare (xargs :guard (cst-matchp abnf::cst "expression")))
  (let ((__function__ 'cst-expression-conc-rep-elem))
    (declare (ignorable __function__))
    (abnf::tree-fix (nth 0
                         (cst-expression-conc-rep abnf::cst)))))

Theorem: treep-of-cst-expression-conc-rep-elem

(defthm treep-of-cst-expression-conc-rep-elem
  (b* ((abnf::cst1 (cst-expression-conc-rep-elem abnf::cst)))
    (abnf::treep abnf::cst1))
  :rule-classes :rewrite)

Theorem: cst-expression-conc-rep-elem-match

(defthm cst-expression-conc-rep-elem-match
  (implies
       (cst-matchp abnf::cst "expression")
       (b* ((abnf::cst1 (cst-expression-conc-rep-elem abnf::cst)))
         (cst-matchp abnf::cst1
                     "conditional-ternary-expression")))
  :rule-classes :rewrite)

Theorem: cst-expression-conc-rep-elem-of-tree-fix-cst

(defthm cst-expression-conc-rep-elem-of-tree-fix-cst
  (equal (cst-expression-conc-rep-elem (abnf::tree-fix abnf::cst))
         (cst-expression-conc-rep-elem abnf::cst)))

Theorem: cst-expression-conc-rep-elem-tree-equiv-congruence-on-cst

(defthm cst-expression-conc-rep-elem-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-expression-conc-rep-elem abnf::cst)
                  (cst-expression-conc-rep-elem cst-equiv)))
  :rule-classes :congruence)

Function: cst-statement-conc1-rep-elem

(defun cst-statement-conc1-rep-elem (abnf::cst)
  (declare (xargs :guard (abnf::treep abnf::cst)))
  (declare (xargs :guard (and (cst-matchp abnf::cst "statement")
                              (equal (cst-statement-conc? abnf::cst)
                                     1))))
  (let ((__function__ 'cst-statement-conc1-rep-elem))
    (declare (ignorable __function__))
    (abnf::tree-fix (nth 0
                         (cst-statement-conc1-rep abnf::cst)))))

Theorem: treep-of-cst-statement-conc1-rep-elem

(defthm treep-of-cst-statement-conc1-rep-elem
  (b* ((abnf::cst1 (cst-statement-conc1-rep-elem abnf::cst)))
    (abnf::treep abnf::cst1))
  :rule-classes :rewrite)

Theorem: cst-statement-conc1-rep-elem-match

(defthm cst-statement-conc1-rep-elem-match
  (implies
       (and (cst-matchp abnf::cst "statement")
            (equal (cst-statement-conc? abnf::cst)
                   1))
       (b* ((abnf::cst1 (cst-statement-conc1-rep-elem abnf::cst)))
         (cst-matchp abnf::cst1 "expression-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 "return-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 "variable-declaration")))
  :rule-classes :rewrite)

Theorem: cst-statement-conc3-rep-elem-of-tree-fix-cst

(defthm cst-statement-conc3-rep-elem-of-tree-fix-cst
  (equal (cst-statement-conc3-rep-elem (abnf::tree-fix abnf::cst))
         (cst-statement-conc3-rep-elem abnf::cst)))

Theorem: cst-statement-conc3-rep-elem-tree-equiv-congruence-on-cst

(defthm cst-statement-conc3-rep-elem-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-statement-conc3-rep-elem abnf::cst)
                  (cst-statement-conc3-rep-elem cst-equiv)))
  :rule-classes :congruence)

Function: cst-statement-conc4-rep-elem

(defun cst-statement-conc4-rep-elem (abnf::cst)
  (declare (xargs :guard (abnf::treep abnf::cst)))
  (declare (xargs :guard (and (cst-matchp abnf::cst "statement")
                              (equal (cst-statement-conc? abnf::cst)
                                     4))))
  (let ((__function__ 'cst-statement-conc4-rep-elem))
    (declare (ignorable __function__))
    (abnf::tree-fix (nth 0
                         (cst-statement-conc4-rep abnf::cst)))))

Theorem: treep-of-cst-statement-conc4-rep-elem

(defthm treep-of-cst-statement-conc4-rep-elem
  (b* ((abnf::cst1 (cst-statement-conc4-rep-elem abnf::cst)))
    (abnf::treep abnf::cst1))
  :rule-classes :rewrite)

Theorem: cst-statement-conc4-rep-elem-match

(defthm cst-statement-conc4-rep-elem-match
  (implies
       (and (cst-matchp abnf::cst "statement")
            (equal (cst-statement-conc? abnf::cst)
                   4))
       (b* ((abnf::cst1 (cst-statement-conc4-rep-elem abnf::cst)))
         (cst-matchp abnf::cst1 "constant-declaration")))
  :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 "conditional-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 "loop-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 "assignment-statement")))
  :rule-classes :rewrite)

Theorem: cst-statement-conc7-rep-elem-of-tree-fix-cst

(defthm cst-statement-conc7-rep-elem-of-tree-fix-cst
  (equal (cst-statement-conc7-rep-elem (abnf::tree-fix abnf::cst))
         (cst-statement-conc7-rep-elem abnf::cst)))

Theorem: cst-statement-conc7-rep-elem-tree-equiv-congruence-on-cst

(defthm cst-statement-conc7-rep-elem-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-statement-conc7-rep-elem abnf::cst)
                  (cst-statement-conc7-rep-elem cst-equiv)))
  :rule-classes :congruence)

Function: cst-statement-conc8-rep-elem

(defun cst-statement-conc8-rep-elem (abnf::cst)
  (declare (xargs :guard (abnf::treep abnf::cst)))
  (declare (xargs :guard (and (cst-matchp abnf::cst "statement")
                              (equal (cst-statement-conc? abnf::cst)
                                     8))))
  (let ((__function__ 'cst-statement-conc8-rep-elem))
    (declare (ignorable __function__))
    (abnf::tree-fix (nth 0
                         (cst-statement-conc8-rep abnf::cst)))))

Theorem: treep-of-cst-statement-conc8-rep-elem

(defthm treep-of-cst-statement-conc8-rep-elem
  (b* ((abnf::cst1 (cst-statement-conc8-rep-elem abnf::cst)))
    (abnf::treep abnf::cst1))
  :rule-classes :rewrite)

Theorem: cst-statement-conc8-rep-elem-match

(defthm cst-statement-conc8-rep-elem-match
  (implies
       (and (cst-matchp abnf::cst "statement")
            (equal (cst-statement-conc? abnf::cst)
                   8))
       (b* ((abnf::cst1 (cst-statement-conc8-rep-elem abnf::cst)))
         (cst-matchp abnf::cst1 "block")))
  :rule-classes :rewrite)

Theorem: cst-statement-conc8-rep-elem-of-tree-fix-cst

(defthm cst-statement-conc8-rep-elem-of-tree-fix-cst
  (equal (cst-statement-conc8-rep-elem (abnf::tree-fix abnf::cst))
         (cst-statement-conc8-rep-elem abnf::cst)))

Theorem: cst-statement-conc8-rep-elem-tree-equiv-congruence-on-cst

(defthm cst-statement-conc8-rep-elem-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-statement-conc8-rep-elem abnf::cst)
                  (cst-statement-conc8-rep-elem cst-equiv)))
  :rule-classes :congruence)

Function: cst-program-item-conc1-rep-elem

(defun cst-program-item-conc1-rep-elem (abnf::cst)
  (declare (xargs :guard (abnf::treep abnf::cst)))
  (declare
       (xargs :guard (and (cst-matchp abnf::cst "program-item")
                          (equal (cst-program-item-conc? abnf::cst)
                                 1))))
  (let ((__function__ 'cst-program-item-conc1-rep-elem))
    (declare (ignorable __function__))
    (abnf::tree-fix (nth 0
                         (cst-program-item-conc1-rep abnf::cst)))))

Theorem: treep-of-cst-program-item-conc1-rep-elem

(defthm treep-of-cst-program-item-conc1-rep-elem
  (b* ((abnf::cst1 (cst-program-item-conc1-rep-elem abnf::cst)))
    (abnf::treep abnf::cst1))
  :rule-classes :rewrite)

Theorem: cst-program-item-conc1-rep-elem-match

(defthm cst-program-item-conc1-rep-elem-match
 (implies
      (and (cst-matchp abnf::cst "program-item")
           (equal (cst-program-item-conc? abnf::cst)
                  1))
      (b* ((abnf::cst1 (cst-program-item-conc1-rep-elem abnf::cst)))
        (cst-matchp abnf::cst1 "function-declaration")))
 :rule-classes :rewrite)

Theorem: cst-program-item-conc1-rep-elem-of-tree-fix-cst

(defthm cst-program-item-conc1-rep-elem-of-tree-fix-cst
 (equal (cst-program-item-conc1-rep-elem (abnf::tree-fix abnf::cst))
        (cst-program-item-conc1-rep-elem abnf::cst)))

Theorem: cst-program-item-conc1-rep-elem-tree-equiv-congruence-on-cst

(defthm cst-program-item-conc1-rep-elem-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-program-item-conc1-rep-elem abnf::cst)
                  (cst-program-item-conc1-rep-elem cst-equiv)))
  :rule-classes :congruence)

Function: cst-program-item-conc2-rep-elem

(defun cst-program-item-conc2-rep-elem (abnf::cst)
  (declare (xargs :guard (abnf::treep abnf::cst)))
  (declare
       (xargs :guard (and (cst-matchp abnf::cst "program-item")
                          (equal (cst-program-item-conc? abnf::cst)
                                 2))))
  (let ((__function__ 'cst-program-item-conc2-rep-elem))
    (declare (ignorable __function__))
    (abnf::tree-fix (nth 0
                         (cst-program-item-conc2-rep abnf::cst)))))

Theorem: treep-of-cst-program-item-conc2-rep-elem

(defthm treep-of-cst-program-item-conc2-rep-elem
  (b* ((abnf::cst1 (cst-program-item-conc2-rep-elem abnf::cst)))
    (abnf::treep abnf::cst1))
  :rule-classes :rewrite)

Theorem: cst-program-item-conc2-rep-elem-match

(defthm cst-program-item-conc2-rep-elem-match
 (implies
      (and (cst-matchp abnf::cst "program-item")
           (equal (cst-program-item-conc? abnf::cst)
                  2))
      (b* ((abnf::cst1 (cst-program-item-conc2-rep-elem abnf::cst)))
        (cst-matchp abnf::cst1 "struct-declaration")))
 :rule-classes :rewrite)

Theorem: cst-program-item-conc2-rep-elem-of-tree-fix-cst

(defthm cst-program-item-conc2-rep-elem-of-tree-fix-cst
 (equal (cst-program-item-conc2-rep-elem (abnf::tree-fix abnf::cst))
        (cst-program-item-conc2-rep-elem abnf::cst)))

Theorem: cst-program-item-conc2-rep-elem-tree-equiv-congruence-on-cst

(defthm cst-program-item-conc2-rep-elem-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-program-item-conc2-rep-elem abnf::cst)
                  (cst-program-item-conc2-rep-elem cst-equiv)))
  :rule-classes :congruence)

Function: cst-program-item-conc3-rep-elem

(defun cst-program-item-conc3-rep-elem (abnf::cst)
  (declare (xargs :guard (abnf::treep abnf::cst)))
  (declare
       (xargs :guard (and (cst-matchp abnf::cst "program-item")
                          (equal (cst-program-item-conc? abnf::cst)
                                 3))))
  (let ((__function__ 'cst-program-item-conc3-rep-elem))
    (declare (ignorable __function__))
    (abnf::tree-fix (nth 0
                         (cst-program-item-conc3-rep abnf::cst)))))

Theorem: treep-of-cst-program-item-conc3-rep-elem

(defthm treep-of-cst-program-item-conc3-rep-elem
  (b* ((abnf::cst1 (cst-program-item-conc3-rep-elem abnf::cst)))
    (abnf::treep abnf::cst1))
  :rule-classes :rewrite)

Theorem: cst-program-item-conc3-rep-elem-match

(defthm cst-program-item-conc3-rep-elem-match
 (implies
      (and (cst-matchp abnf::cst "program-item")
           (equal (cst-program-item-conc? abnf::cst)
                  3))
      (b* ((abnf::cst1 (cst-program-item-conc3-rep-elem abnf::cst)))
        (cst-matchp abnf::cst1 "record-declaration")))
 :rule-classes :rewrite)

Theorem: cst-program-item-conc3-rep-elem-of-tree-fix-cst

(defthm cst-program-item-conc3-rep-elem-of-tree-fix-cst
 (equal (cst-program-item-conc3-rep-elem (abnf::tree-fix abnf::cst))
        (cst-program-item-conc3-rep-elem abnf::cst)))

Theorem: cst-program-item-conc3-rep-elem-tree-equiv-congruence-on-cst

(defthm cst-program-item-conc3-rep-elem-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-program-item-conc3-rep-elem abnf::cst)
                  (cst-program-item-conc3-rep-elem cst-equiv)))
  :rule-classes :congruence)

Function: cst-program-item-conc4-rep-elem

(defun cst-program-item-conc4-rep-elem (abnf::cst)
  (declare (xargs :guard (abnf::treep abnf::cst)))
  (declare
       (xargs :guard (and (cst-matchp abnf::cst "program-item")
                          (equal (cst-program-item-conc? abnf::cst)
                                 4))))
  (let ((__function__ 'cst-program-item-conc4-rep-elem))
    (declare (ignorable __function__))
    (abnf::tree-fix (nth 0
                         (cst-program-item-conc4-rep abnf::cst)))))

Theorem: treep-of-cst-program-item-conc4-rep-elem

(defthm treep-of-cst-program-item-conc4-rep-elem
  (b* ((abnf::cst1 (cst-program-item-conc4-rep-elem abnf::cst)))
    (abnf::treep abnf::cst1))
  :rule-classes :rewrite)

Theorem: cst-program-item-conc4-rep-elem-match

(defthm cst-program-item-conc4-rep-elem-match
 (implies
      (and (cst-matchp abnf::cst "program-item")
           (equal (cst-program-item-conc? abnf::cst)
                  4))
      (b* ((abnf::cst1 (cst-program-item-conc4-rep-elem abnf::cst)))
        (cst-matchp abnf::cst1 "mapping-declaration")))
 :rule-classes :rewrite)

Theorem: cst-program-item-conc4-rep-elem-of-tree-fix-cst

(defthm cst-program-item-conc4-rep-elem-of-tree-fix-cst
 (equal (cst-program-item-conc4-rep-elem (abnf::tree-fix abnf::cst))
        (cst-program-item-conc4-rep-elem abnf::cst)))

Theorem: cst-program-item-conc4-rep-elem-tree-equiv-congruence-on-cst

(defthm cst-program-item-conc4-rep-elem-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-program-item-conc4-rep-elem abnf::cst)
                  (cst-program-item-conc4-rep-elem cst-equiv)))
  :rule-classes :congruence)

Function: cst-program-item-conc5-rep-elem

(defun cst-program-item-conc5-rep-elem (abnf::cst)
  (declare (xargs :guard (abnf::treep abnf::cst)))
  (declare
       (xargs :guard (and (cst-matchp abnf::cst "program-item")
                          (equal (cst-program-item-conc? abnf::cst)
                                 5))))
  (let ((__function__ 'cst-program-item-conc5-rep-elem))
    (declare (ignorable __function__))
    (abnf::tree-fix (nth 0
                         (cst-program-item-conc5-rep abnf::cst)))))

Theorem: treep-of-cst-program-item-conc5-rep-elem

(defthm treep-of-cst-program-item-conc5-rep-elem
  (b* ((abnf::cst1 (cst-program-item-conc5-rep-elem abnf::cst)))
    (abnf::treep abnf::cst1))
  :rule-classes :rewrite)

Theorem: cst-program-item-conc5-rep-elem-match

(defthm cst-program-item-conc5-rep-elem-match
 (implies
      (and (cst-matchp abnf::cst "program-item")
           (equal (cst-program-item-conc? abnf::cst)
                  5))
      (b* ((abnf::cst1 (cst-program-item-conc5-rep-elem abnf::cst)))
        (cst-matchp abnf::cst1 "constant-declaration")))
 :rule-classes :rewrite)

Theorem: cst-program-item-conc5-rep-elem-of-tree-fix-cst

(defthm cst-program-item-conc5-rep-elem-of-tree-fix-cst
 (equal (cst-program-item-conc5-rep-elem (abnf::tree-fix abnf::cst))
        (cst-program-item-conc5-rep-elem abnf::cst)))

Theorem: cst-program-item-conc5-rep-elem-tree-equiv-congruence-on-cst

(defthm cst-program-item-conc5-rep-elem-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-program-item-conc5-rep-elem abnf::cst)
                  (cst-program-item-conc5-rep-elem cst-equiv)))
  :rule-classes :congruence)

*grammar*-tree-operations

Definitions and Theorems

grammar-tree-operations