		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))))
 (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))))
  (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))))
  (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))))
  (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))))
  (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-ffff-nat

(defun cst-%x0-ffff-nat (abnf::cst)
  (declare (xargs :guard (abnf::treep abnf::cst)))
  (declare (xargs :guard (cst-matchp abnf::cst "%x0-FFFF")))
  (acl2::lnfix (nth 0
                    (abnf::tree-leafterm->get abnf::cst))))

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

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

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

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

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

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

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

(defthm cst-%x0-ffff-nat-bounds
  (implies (cst-matchp abnf::cst "%x0-FFFF")
           (and (<= 0 (cst-%x0-ffff-nat abnf::cst))
                (<= (cst-%x0-ffff-nat abnf::cst)
                    65535)))
  :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-"0"-leafterm

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

Theorem: cst-"0b"-leafterm

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

Theorem: cst-"0x"-leafterm

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

Theorem: cst-"1"-leafterm

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

Theorem: cst-"2"-leafterm

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

Theorem: cst-"3"-leafterm

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

Theorem: cst-"4"-leafterm

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

Theorem: cst-"5"-leafterm

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

Theorem: cst-"6"-leafterm

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

Theorem: cst-"7"-leafterm

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

Theorem: cst-"8"-leafterm

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

Theorem: cst-"9"-leafterm

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

Theorem: cst-":"-leafterm

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

Theorem: cst-"::"-leafterm

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

Theorem: cst-";"-leafterm

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

Theorem: cst-"<"-leafterm

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

Theorem: cst-"<<"-leafterm

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

Theorem: cst-"<<="-leafterm

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

Theorem: cst-"<="-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-"a"-leafterm

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

Theorem: cst-"b"-leafterm

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

Theorem: cst-"c"-leafterm

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

Theorem: cst-"d"-leafterm

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

Theorem: cst-"e"-leafterm

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

Theorem: cst-"f"-leafterm

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

Theorem: cst-"l"-leafterm

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

Theorem: cst-"p"-leafterm

(defthm |CST-"p"-LEAFTERM|
  (implies (cst-matchp abnf::cst "\"p\"")
           (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"\b"-leafterm

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

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

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

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

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

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

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

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

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

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

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

Theorem: cst-%s"abstract"-leafterm

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

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

Theorem: cst-%s"break"-leafterm

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

Theorem: cst-%s"byte"-leafterm

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

Theorem: cst-%s"case"-leafterm

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

Theorem: cst-%s"catch"-leafterm

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

Theorem: cst-%s"char"-leafterm

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

Theorem: cst-%s"class"-leafterm

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

Theorem: cst-%s"const"-leafterm

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

Theorem: cst-%s"continue"-leafterm

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

Theorem: cst-%s"default"-leafterm

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

Theorem: cst-%s"do"-leafterm

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

Theorem: cst-%s"double"-leafterm

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

Theorem: cst-%s"else"-leafterm

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

Theorem: cst-%s"enum"-leafterm

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

Theorem: cst-%s"exports"-leafterm

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

Theorem: cst-%s"extends"-leafterm

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

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

Theorem: cst-%s"finally"-leafterm

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

Theorem: cst-%s"float"-leafterm

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

Theorem: cst-%s"for"-leafterm

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

Theorem: cst-%s"goto"-leafterm

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

Theorem: cst-%s"if"-leafterm

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

Theorem: cst-%s"implements"-leafterm

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

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

Theorem: cst-%s"int"-leafterm

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

Theorem: cst-%s"interface"-leafterm

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

Theorem: cst-%s"long"-leafterm

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

Theorem: cst-%s"module"-leafterm

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

Theorem: cst-%s"native"-leafterm

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

Theorem: cst-%s"new"-leafterm

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

Theorem: cst-%s"non-sealed"-leafterm

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

Theorem: cst-%s"null"-leafterm

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

Theorem: cst-%s"open"-leafterm

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

Theorem: cst-%s"opens"-leafterm

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

Theorem: cst-%s"package"-leafterm

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

Theorem: cst-%s"permits"-leafterm

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

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

Theorem: cst-%s"provides"-leafterm

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

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

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

Theorem: cst-%s"short"-leafterm

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

Theorem: cst-%s"static"-leafterm

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

Theorem: cst-%s"strictfp"-leafterm

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

Theorem: cst-%s"super"-leafterm

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

Theorem: cst-%s"switch"-leafterm

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

Theorem: cst-%s"synchronized"-leafterm

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

Theorem: cst-%s"this"-leafterm

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

Theorem: cst-%s"throw"-leafterm

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

Theorem: cst-%s"throws"-leafterm

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

Theorem: cst-%s"to"-leafterm

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

Theorem: cst-%s"transient"-leafterm

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

Theorem: cst-%s"transitive"-leafterm

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

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

Theorem: cst-%s"u"-leafterm

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

Theorem: cst-%s"uses"-leafterm

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

Theorem: cst-%s"var"-leafterm

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

Theorem: cst-%s"void"-leafterm

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

Theorem: cst-%s"volatile"-leafterm

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

Theorem: cst-%s"when"-leafterm

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

Theorem: cst-%s"while"-leafterm

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

Theorem: cst-%s"with"-leafterm

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

Theorem: cst-%s"yield"-leafterm

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

Theorem: cst-unicode-input-character-nonleaf

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

Theorem: cst-unicode-escape-nonleaf

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

Theorem: cst-unicode-marker-nonleaf

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

Theorem: cst-hex-digit-nonleaf

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

Theorem: cst-raw-input-character-nonleaf

(defthm cst-raw-input-character-nonleaf
  (implies (cst-matchp abnf::cst "raw-input-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-input-character-nonleaf

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

Theorem: cst-input-nonleaf

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

Theorem: cst-input-element-nonleaf

(defthm cst-input-element-nonleaf
  (implies (cst-matchp abnf::cst "input-element")
           (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-sub-nonleaf

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

Theorem: cst-white-space-nonleaf

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

Theorem: cst-comment-nonleaf

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

Theorem: cst-traditional-comment-nonleaf

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

Theorem: cst-comment-tail-nonleaf

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

Theorem: cst-comment-tail-star-nonleaf

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

Theorem: cst-not-star-nonleaf

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

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

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

Theorem: cst-end-of-line-comment-nonleaf

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

Theorem: cst-identifier-nonleaf

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

Theorem: cst-identifier-chars-nonleaf

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

Theorem: cst-java-letter-nonleaf

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

Theorem: cst-java-letter-or-digit-nonleaf

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

Theorem: cst-type-identifier-nonleaf

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

Theorem: cst-unqualified-method-identifier-nonleaf

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

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

Theorem: cst-contextual-keyword-nonleaf

(defthm cst-contextual-keyword-nonleaf
  (implies (cst-matchp abnf::cst "contextual-keyword")
           (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-integer-literal-nonleaf

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

Theorem: cst-decimal-integer-literal-nonleaf

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

Theorem: cst-hex-integer-literal-nonleaf

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

Theorem: cst-octal-integer-literal-nonleaf

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

Theorem: cst-binary-integer-literal-nonleaf

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

Theorem: cst-integer-type-suffix-nonleaf

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

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

Theorem: cst-digits-nonleaf

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

Theorem: cst-digit-nonleaf

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

Theorem: cst-digits-and-underscores-nonleaf

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

Theorem: cst-digit-or-underscore-nonleaf

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

Theorem: cst-underscores-nonleaf

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

Theorem: cst-hex-numeral-nonleaf

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

Theorem: cst-hex-digits-nonleaf

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

Theorem: cst-hex-digits-and-underscores-nonleaf

(defthm cst-hex-digits-and-underscores-nonleaf
  (implies (cst-matchp abnf::cst "hex-digits-and-underscores")
           (equal (abnf::tree-kind abnf::cst)
                  :nonleaf)))

Theorem: cst-hex-digit-or-underscore-nonleaf

(defthm cst-hex-digit-or-underscore-nonleaf
  (implies (cst-matchp abnf::cst "hex-digit-or-underscore")
           (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-octal-digits-nonleaf

(defthm cst-octal-digits-nonleaf
  (implies (cst-matchp abnf::cst "octal-digits")
           (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-octal-digits-and-underscores-nonleaf

(defthm cst-octal-digits-and-underscores-nonleaf
  (implies (cst-matchp abnf::cst
                       "octal-digits-and-underscores")
           (equal (abnf::tree-kind abnf::cst)
                  :nonleaf)))

Theorem: cst-octal-digit-or-underscore-nonleaf

(defthm cst-octal-digit-or-underscore-nonleaf
  (implies (cst-matchp abnf::cst "octal-digit-or-underscore")
           (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-binary-digits-nonleaf

(defthm cst-binary-digits-nonleaf
  (implies (cst-matchp abnf::cst "binary-digits")
           (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-binary-digits-and-underscores-nonleaf

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

Theorem: cst-binary-digit-or-underscore-nonleaf

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

Theorem: cst-floating-point-literal-nonleaf

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

Theorem: cst-decimal-floating-point-literal-nonleaf

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

Theorem: cst-exponent-part-nonleaf

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

Theorem: cst-exponent-indicator-nonleaf

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

Theorem: cst-signed-integer-nonleaf

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

Theorem: cst-sign-nonleaf

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

Theorem: cst-float-type-suffix-nonleaf

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

Theorem: cst-hexadecimal-floating-point-literal-nonleaf

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

Theorem: cst-hex-significand-nonleaf

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

Theorem: cst-binary-exponent-nonleaf

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

Theorem: cst-binary-exponent-indicator-nonleaf

(defthm cst-binary-exponent-indicator-nonleaf
  (implies (cst-matchp abnf::cst "binary-exponent-indicator")
           (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-character-literal-nonleaf

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

Theorem: cst-single-character-nonleaf

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

Theorem: cst-string-literal-nonleaf

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

Theorem: cst-string-character-nonleaf

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

Theorem: cst-text-block-nonleaf

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

Theorem: cst-text-block-white-space-nonleaf

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

Theorem: cst-text-block-character-nonleaf

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

Theorem: cst-escape-sequence-nonleaf

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

Theorem: cst-octal-escape-nonleaf

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

Theorem: cst-zero-to-three-nonleaf

(defthm cst-zero-to-three-nonleaf
  (implies (cst-matchp abnf::cst "zero-to-three")
           (equal (abnf::tree-kind abnf::cst)
                  :nonleaf)))

Theorem: cst-null-literal-nonleaf

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

Theorem: cst-separator-nonleaf

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

Theorem: cst-operator-nonleaf

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

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

Theorem: cst-numeric-type-nonleaf

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

Theorem: cst-integral-type-nonleaf

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

Theorem: cst-floating-point-type-nonleaf

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

Theorem: cst-reference-type-nonleaf

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

Theorem: cst-class-or-interface-type-nonleaf

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

Theorem: cst-class-type-nonleaf

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

Theorem: cst-interface-type-nonleaf

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

Theorem: cst-type-variable-nonleaf

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

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

Theorem: cst-type-parameter-nonleaf

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

Theorem: cst-type-parameter-modifier-nonleaf

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

Theorem: cst-type-bound-nonleaf

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

Theorem: cst-additional-bound-nonleaf

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

Theorem: cst-type-arguments-nonleaf

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

Theorem: cst-type-argument-list-nonleaf

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

Theorem: cst-type-argument-nonleaf

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

Theorem: cst-wildcard-nonleaf

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

Theorem: cst-wildcard-bounds-nonleaf

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

Theorem: cst-module-name-nonleaf

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

Theorem: cst-package-name-nonleaf

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

Theorem: cst-type-name-nonleaf

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

Theorem: cst-package-or-type-name-nonleaf

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

Theorem: cst-expression-name-nonleaf

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

Theorem: cst-method-name-nonleaf

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

Theorem: cst-ambiguous-name-nonleaf

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

Theorem: cst-compilation-unit-nonleaf

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

Theorem: cst-ordinary-compilation-unit-nonleaf

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

Theorem: cst-compact-compilation-unit-nonleaf

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

Theorem: cst-class-member-declaration-no-method-nonleaf

(defthm cst-class-member-declaration-no-method-nonleaf
  (implies (cst-matchp abnf::cst
                       "class-member-declaration-no-method")
           (equal (abnf::tree-kind abnf::cst)
                  :nonleaf)))

Theorem: cst-modular-compilation-unit-nonleaf

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

Theorem: cst-package-declaration-nonleaf

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

Theorem: cst-package-modifier-nonleaf

(defthm cst-package-modifier-nonleaf
  (implies (cst-matchp abnf::cst "package-modifier")
           (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-single-type-import-declaration-nonleaf

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

Theorem: cst-type-import-on-demand-declaration-nonleaf

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

Theorem: cst-single-static-import-declaration-nonleaf

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

Theorem: cst-static-import-on-demand-declaration-nonleaf

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

Theorem: cst-single-module-import-declaration-nonleaf

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

Theorem: cst-top-level-class-or-interface-declaration-nonleaf

(defthm cst-top-level-class-or-interface-declaration-nonleaf
  (implies (cst-matchp abnf::cst
                       "top-level-class-or-interface-declaration")
           (equal (abnf::tree-kind abnf::cst)
                  :nonleaf)))

Theorem: cst-module-declaration-nonleaf

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

Theorem: cst-module-directive-nonleaf

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

Theorem: cst-requires-modifier-nonleaf

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

Theorem: cst-class-declaration-nonleaf

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

Theorem: cst-normal-class-declaration-nonleaf

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

Theorem: cst-class-modifier-nonleaf

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

Theorem: cst-type-parameters-nonleaf

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

Theorem: cst-type-parameter-list-nonleaf

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

Theorem: cst-class-extends-nonleaf

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

Theorem: cst-class-implements-nonleaf

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

Theorem: cst-interface-type-list-nonleaf

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

Theorem: cst-class-permits-nonleaf

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

Theorem: cst-class-body-nonleaf

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

Theorem: cst-class-body-declaration-nonleaf

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

Theorem: cst-class-member-declaration-nonleaf

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

Theorem: cst-field-declaration-nonleaf

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

Theorem: cst-variable-declarator-list-nonleaf

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

Theorem: cst-variable-declarator-nonleaf

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

Theorem: cst-variable-declarator-id-nonleaf

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

Theorem: cst-variable-initializer-nonleaf

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

Theorem: cst-unann-type-nonleaf

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

Theorem: cst-unann-primitive-type-nonleaf

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

Theorem: cst-unann-reference-type-nonleaf

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

Theorem: cst-unann-class-or-interface-type-nonleaf

(defthm cst-unann-class-or-interface-type-nonleaf
  (implies (cst-matchp abnf::cst
                       "unann-class-or-interface-type")
           (equal (abnf::tree-kind abnf::cst)
                  :nonleaf)))

Theorem: cst-unann-class-type-nonleaf

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

Theorem: cst-unann-interface-type-nonleaf

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

Theorem: cst-unann-type-variable-nonleaf

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

Theorem: cst-unann-array-type-nonleaf

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

Theorem: cst-field-modifier-nonleaf

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

Theorem: cst-method-declaration-nonleaf

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

Theorem: cst-method-header-nonleaf

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

Theorem: cst-method-declarator-nonleaf

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

Theorem: cst-receiver-parameter-nonleaf

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

Theorem: cst-formal-parameter-list-nonleaf

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

Theorem: cst-formal-parameter-nonleaf

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

Theorem: cst-variable-arity-parameter-nonleaf

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

Theorem: cst-variable-modifier-nonleaf

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

Theorem: cst-method-modifier-nonleaf

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

Theorem: cst-result-nonleaf

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

Theorem: cst-throws-nonleaf

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

Theorem: cst-exception-type-list-nonleaf

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

Theorem: cst-exception-type-nonleaf

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

Theorem: cst-method-body-nonleaf

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

Theorem: cst-instance-initializer-nonleaf

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

Theorem: cst-static-initializer-nonleaf

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

Theorem: cst-constructor-declaration-nonleaf

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

Theorem: cst-constructor-declarator-nonleaf

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

Theorem: cst-simple-type-name-nonleaf

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

Theorem: cst-constructor-modifier-nonleaf

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

Theorem: cst-constructor-body-nonleaf

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

Theorem: cst-constructor-invocation-nonleaf

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

Theorem: cst-enum-declaration-nonleaf

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

Theorem: cst-enum-body-nonleaf

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

Theorem: cst-enum-constant-list-nonleaf

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

Theorem: cst-enum-constant-nonleaf

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

Theorem: cst-enum-constant-modifier-nonleaf

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

Theorem: cst-enum-body-declarations-nonleaf

(defthm cst-enum-body-declarations-nonleaf
  (implies (cst-matchp abnf::cst "enum-body-declarations")
           (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-record-header-nonleaf

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

Theorem: cst-record-component-list-nonleaf

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

Theorem: cst-record-component-nonleaf

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

Theorem: cst-variable-arity-record-component-nonleaf

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

Theorem: cst-record-component-modifier-nonleaf

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

Theorem: cst-record-body-nonleaf

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

Theorem: cst-record-body-declaration-nonleaf

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

Theorem: cst-compact-constructor-declaration-nonleaf

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

Theorem: cst-interface-declaration-nonleaf

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

Theorem: cst-normal-interface-declaration-nonleaf

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

Theorem: cst-interface-modifier-nonleaf

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

Theorem: cst-interface-extends-nonleaf

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

Theorem: cst-interface-permits-nonleaf

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

Theorem: cst-interface-body-nonleaf

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

Theorem: cst-interface-member-declaration-nonleaf

(defthm cst-interface-member-declaration-nonleaf
  (implies (cst-matchp abnf::cst
                       "interface-member-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-constant-modifier-nonleaf

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

Theorem: cst-interface-method-declaration-nonleaf

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

Theorem: cst-interface-method-modifier-nonleaf

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

Theorem: cst-annotation-interface-declaration-nonleaf

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

Theorem: cst-annotation-interface-body-nonleaf

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

Theorem: cst-annotation-interface-member-declaration-nonleaf

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

Theorem: cst-annotation-interface-element-declaration-nonleaf

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

Theorem: cst-annotation-interface-element-modifier-nonleaf

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

Theorem: cst-default-value-nonleaf

(defthm cst-default-value-nonleaf
  (implies (cst-matchp abnf::cst "default-value")
           (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-normal-annotation-nonleaf

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

Theorem: cst-element-value-pair-list-nonleaf

(defthm cst-element-value-pair-list-nonleaf
  (implies (cst-matchp abnf::cst "element-value-pair-list")
           (equal (abnf::tree-kind abnf::cst)
                  :nonleaf)))

Theorem: cst-element-value-pair-nonleaf

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

Theorem: cst-element-value-nonleaf

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

Theorem: cst-element-value-array-initializer-nonleaf

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

Theorem: cst-element-value-list-nonleaf

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

Theorem: cst-marker-annotation-nonleaf

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

Theorem: cst-single-element-annotation-nonleaf

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

Theorem: cst-array-initializer-nonleaf

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

Theorem: cst-variable-initializer-list-nonleaf

(defthm cst-variable-initializer-list-nonleaf
  (implies (cst-matchp abnf::cst "variable-initializer-list")
           (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-block-statements-nonleaf

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

Theorem: cst-block-statement-nonleaf

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

Theorem: cst-local-class-or-interface-declaration-nonleaf

(defthm cst-local-class-or-interface-declaration-nonleaf
  (implies (cst-matchp abnf::cst
                       "local-class-or-interface-declaration")
           (equal (abnf::tree-kind abnf::cst)
                  :nonleaf)))

Theorem: cst-local-variable-declaration-nonleaf

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

Theorem: cst-local-variable-type-nonleaf

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

Theorem: cst-local-variable-declaration-statement-nonleaf

(defthm cst-local-variable-declaration-statement-nonleaf
  (implies (cst-matchp abnf::cst
                       "local-variable-declaration-statement")
           (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-statement-no-short-if-nonleaf

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

Theorem: cst-statement-without-trailing-substatement-nonleaf

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

Theorem: cst-empty-statement-nonleaf

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

Theorem: cst-labeled-statement-nonleaf

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

Theorem: cst-labeled-statement-no-short-if-nonleaf

(defthm cst-labeled-statement-no-short-if-nonleaf
  (implies (cst-matchp abnf::cst
                       "labeled-statement-no-short-if")
           (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-statement-expression-nonleaf

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

Theorem: cst-if-then-statement-nonleaf

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

Theorem: cst-if-then-else-statement-nonleaf

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

Theorem: cst-if-then-else-statement-no-short-if-nonleaf

(defthm cst-if-then-else-statement-no-short-if-nonleaf
  (implies (cst-matchp abnf::cst
                       "if-then-else-statement-no-short-if")
           (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-switch-statement-nonleaf

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

Theorem: cst-switch-block-nonleaf

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

Theorem: cst-switch-rule-nonleaf

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

Theorem: cst-switch-block-statement-group-nonleaf

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

Theorem: cst-switch-label-nonleaf

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

Theorem: cst-case-constant-nonleaf

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

Theorem: cst-case-pattern-nonleaf

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

Theorem: cst-guard-nonleaf

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

Theorem: cst-while-statement-nonleaf

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

Theorem: cst-while-statement-no-short-if-nonleaf

(defthm cst-while-statement-no-short-if-nonleaf
  (implies (cst-matchp abnf::cst "while-statement-no-short-if")
           (equal (abnf::tree-kind abnf::cst)
                  :nonleaf)))

Theorem: cst-do-statement-nonleaf

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

Theorem: cst-for-statement-nonleaf

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

Theorem: cst-for-statement-no-short-if-nonleaf

(defthm cst-for-statement-no-short-if-nonleaf
  (implies (cst-matchp abnf::cst "for-statement-no-short-if")
           (equal (abnf::tree-kind abnf::cst)
                  :nonleaf)))

Theorem: cst-basic-for-statement-nonleaf

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

Theorem: cst-basic-for-statement-no-short-if-nonleaf

(defthm cst-basic-for-statement-no-short-if-nonleaf
  (implies (cst-matchp abnf::cst
                       "basic-for-statement-no-short-if")
           (equal (abnf::tree-kind abnf::cst)
                  :nonleaf)))

Theorem: cst-for-init-nonleaf

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

Theorem: cst-for-update-nonleaf

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

Theorem: cst-statement-expression-list-nonleaf

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

Theorem: cst-enhanced-for-statement-nonleaf

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

Theorem: cst-enhanced-for-statement-no-short-if-nonleaf

(defthm cst-enhanced-for-statement-no-short-if-nonleaf
  (implies (cst-matchp abnf::cst
                       "enhanced-for-statement-no-short-if")
           (equal (abnf::tree-kind abnf::cst)
                  :nonleaf)))

Theorem: cst-break-statement-nonleaf

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

Theorem: cst-continue-statement-nonleaf

(defthm cst-continue-statement-nonleaf
  (implies (cst-matchp abnf::cst "continue-statement")
           (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-throw-statement-nonleaf

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

Theorem: cst-synchronized-statement-nonleaf

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

Theorem: cst-try-statement-nonleaf

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

Theorem: cst-catches-nonleaf

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

Theorem: cst-catch-clause-nonleaf

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

Theorem: cst-catch-formal-parameter-nonleaf

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

Theorem: cst-catch-type-nonleaf

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

Theorem: cst-finally-nonleaf

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

Theorem: cst-try-with-resources-statement-nonleaf

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

Theorem: cst-resource-specification-nonleaf

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

Theorem: cst-resource-list-nonleaf

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

Theorem: cst-resource-nonleaf

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

Theorem: cst-variable-access-nonleaf

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

Theorem: cst-yield-statement-nonleaf

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

Theorem: cst-pattern-nonleaf

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

Theorem: cst-type-pattern-nonleaf

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

Theorem: cst-record-pattern-nonleaf

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

Theorem: cst-component-pattern-list-nonleaf

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

Theorem: cst-component-pattern-nonleaf

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

Theorem: cst-match-all-pattern-nonleaf

(defthm cst-match-all-pattern-nonleaf
  (implies (cst-matchp abnf::cst "match-all-pattern")
           (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-primary-nonleaf

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

Theorem: cst-primary-no-new-array-nonleaf

(defthm cst-primary-no-new-array-nonleaf
  (implies (cst-matchp abnf::cst "primary-no-new-array")
           (equal (abnf::tree-kind abnf::cst)
                  :nonleaf)))

Theorem: cst-class-literal-nonleaf

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

Theorem: cst-class-instance-creation-expression-nonleaf

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

Theorem: cst-unqualified-class-instance-creation-expression-nonleaf

(defthm cst-unqualified-class-instance-creation-expression-nonleaf
  (implies
       (cst-matchp abnf::cst
                   "unqualified-class-instance-creation-expression")
       (equal (abnf::tree-kind abnf::cst)
              :nonleaf)))

Theorem: cst-class-or-interface-type-to-instantiate-nonleaf

(defthm cst-class-or-interface-type-to-instantiate-nonleaf
  (implies (cst-matchp abnf::cst
                       "class-or-interface-type-to-instantiate")
           (equal (abnf::tree-kind abnf::cst)
                  :nonleaf)))

Theorem: cst-type-arguments-or-diamond-nonleaf

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

Theorem: cst-array-creation-expression-nonleaf

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

Theorem: cst-array-creation-expression-without-initializer-nonleaf

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

Theorem: cst-array-creation-expression-with-initializer-nonleaf

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

Theorem: cst-dim-exprs-nonleaf

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

Theorem: cst-dim-expr-nonleaf

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

Theorem: cst-array-access-nonleaf

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

Theorem: cst-field-access-nonleaf

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

Theorem: cst-method-invocation-nonleaf

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

Theorem: cst-argument-list-nonleaf

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

Theorem: cst-method-reference-nonleaf

(defthm cst-method-reference-nonleaf
  (implies (cst-matchp abnf::cst "method-reference")
           (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-post-increment-expression-nonleaf

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

Theorem: cst-post-decrement-expression-nonleaf

(defthm cst-post-decrement-expression-nonleaf
  (implies (cst-matchp abnf::cst "post-decrement-expression")
           (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-pre-increment-expression-nonleaf

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

Theorem: cst-pre-decrement-expression-nonleaf

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

Theorem: cst-unary-expression-not-plus-minus-nonleaf

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

Theorem: cst-cast-expression-nonleaf

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

Theorem: cst-multiplicative-expression-nonleaf

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

Theorem: cst-additive-expression-nonleaf

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

Theorem: cst-shift-expression-nonleaf

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

Theorem: cst-relational-expression-nonleaf

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

Theorem: cst-instanceof-expression-nonleaf

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

Theorem: cst-equality-expression-nonleaf

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

Theorem: cst-and-expression-nonleaf

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

Theorem: cst-exclusive-or-expression-nonleaf

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

Theorem: cst-inclusive-or-expression-nonleaf

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

Theorem: cst-conditional-and-expression-nonleaf

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

Theorem: cst-conditional-or-expression-nonleaf

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

Theorem: cst-conditional-expression-nonleaf

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

Theorem: cst-assignment-expression-nonleaf

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

Theorem: cst-assignment-nonleaf

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

Theorem: cst-left-hand-side-nonleaf

(defthm cst-left-hand-side-nonleaf
  (implies (cst-matchp abnf::cst "left-hand-side")
           (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-lambda-expression-nonleaf

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

Theorem: cst-lambda-parameters-nonleaf

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

Theorem: cst-lambda-parameter-list-nonleaf

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

Theorem: cst-normal-lambda-parameter-nonleaf

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

Theorem: cst-lambda-parameter-type-nonleaf

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

Theorem: cst-concise-lambda-parameter-nonleaf

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

Theorem: cst-lambda-body-nonleaf

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

Theorem: cst-switch-expression-nonleaf

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

Theorem: cst-unicode-input-character-rulename

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

Theorem: cst-unicode-escape-rulename

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

Theorem: cst-unicode-marker-rulename

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

Theorem: cst-hex-digit-rulename

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

Theorem: cst-raw-input-character-rulename

(defthm cst-raw-input-character-rulename
  (implies (cst-matchp abnf::cst "raw-input-character")
           (equal (abnf::tree-nonleaf->rulename? abnf::cst)
                  (abnf::rulename "raw-input-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-input-character-rulename

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

Theorem: cst-input-rulename

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

Theorem: cst-input-element-rulename

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

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

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

Theorem: cst-white-space-rulename

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

Theorem: cst-comment-rulename

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

Theorem: cst-traditional-comment-rulename

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

Theorem: cst-comment-tail-rulename

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

Theorem: cst-comment-tail-star-rulename

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

Theorem: cst-not-star-rulename

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

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

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

Theorem: cst-end-of-line-comment-rulename

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

Theorem: cst-identifier-rulename

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

Theorem: cst-identifier-chars-rulename

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

Theorem: cst-java-letter-rulename

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

Theorem: cst-java-letter-or-digit-rulename

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

Theorem: cst-type-identifier-rulename

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

Theorem: cst-unqualified-method-identifier-rulename

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

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

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

Theorem: cst-contextual-keyword-rulename

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

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-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-decimal-integer-literal-rulename

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

Theorem: cst-hex-integer-literal-rulename

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

Theorem: cst-octal-integer-literal-rulename

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

Theorem: cst-binary-integer-literal-rulename

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

Theorem: cst-integer-type-suffix-rulename

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

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-non-zero-digit-rulename

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

Theorem: cst-digits-rulename

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

Theorem: cst-digit-rulename

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

Theorem: cst-digits-and-underscores-rulename

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

Theorem: cst-digit-or-underscore-rulename

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

Theorem: cst-underscores-rulename

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

Theorem: cst-hex-numeral-rulename

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

Theorem: cst-hex-digits-rulename

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

Theorem: cst-hex-digits-and-underscores-rulename

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

Theorem: cst-hex-digit-or-underscore-rulename

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

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-octal-digits-rulename

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

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-octal-digits-and-underscores-rulename

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

Theorem: cst-octal-digit-or-underscore-rulename

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

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-binary-digits-rulename

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

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-binary-digits-and-underscores-rulename

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

Theorem: cst-binary-digit-or-underscore-rulename

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

Theorem: cst-floating-point-literal-rulename

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

Theorem: cst-decimal-floating-point-literal-rulename

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

Theorem: cst-exponent-part-rulename

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

Theorem: cst-exponent-indicator-rulename

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

Theorem: cst-signed-integer-rulename

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

Theorem: cst-sign-rulename

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

Theorem: cst-float-type-suffix-rulename

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

Theorem: cst-hexadecimal-floating-point-literal-rulename

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

Theorem: cst-hex-significand-rulename

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

Theorem: cst-binary-exponent-rulename

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

Theorem: cst-binary-exponent-indicator-rulename

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

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

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

Theorem: cst-single-character-rulename

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

Theorem: cst-string-literal-rulename

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

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

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

Theorem: cst-text-block-white-space-rulename

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

Theorem: cst-text-block-character-rulename

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

Theorem: cst-escape-sequence-rulename

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

Theorem: cst-octal-escape-rulename

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

Theorem: cst-zero-to-three-rulename

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

Theorem: cst-null-literal-rulename

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

Theorem: cst-separator-rulename

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

Theorem: cst-operator-rulename

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

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

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

Theorem: cst-integral-type-rulename

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

Theorem: cst-floating-point-type-rulename

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

Theorem: cst-reference-type-rulename

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

Theorem: cst-class-or-interface-type-rulename

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

Theorem: cst-class-type-rulename

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

Theorem: cst-interface-type-rulename

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

Theorem: cst-type-variable-rulename

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

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

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

Theorem: cst-type-parameter-rulename

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

Theorem: cst-type-parameter-modifier-rulename

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

Theorem: cst-type-bound-rulename

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

Theorem: cst-additional-bound-rulename

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

Theorem: cst-type-arguments-rulename

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

Theorem: cst-type-argument-list-rulename

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

Theorem: cst-type-argument-rulename

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

Theorem: cst-wildcard-rulename

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

Theorem: cst-wildcard-bounds-rulename

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

Theorem: cst-module-name-rulename

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

Theorem: cst-package-name-rulename

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

Theorem: cst-type-name-rulename

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

Theorem: cst-package-or-type-name-rulename

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

Theorem: cst-expression-name-rulename

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

Theorem: cst-method-name-rulename

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

Theorem: cst-ambiguous-name-rulename

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

Theorem: cst-compilation-unit-rulename

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

Theorem: cst-ordinary-compilation-unit-rulename

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

Theorem: cst-compact-compilation-unit-rulename

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

Theorem: cst-class-member-declaration-no-method-rulename

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

Theorem: cst-modular-compilation-unit-rulename

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

Theorem: cst-package-declaration-rulename

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

Theorem: cst-package-modifier-rulename

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

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-single-type-import-declaration-rulename

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

Theorem: cst-type-import-on-demand-declaration-rulename

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

Theorem: cst-single-static-import-declaration-rulename

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

Theorem: cst-static-import-on-demand-declaration-rulename

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

Theorem: cst-single-module-import-declaration-rulename

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

Theorem: cst-top-level-class-or-interface-declaration-rulename

(defthm cst-top-level-class-or-interface-declaration-rulename
 (implies
  (cst-matchp abnf::cst
              "top-level-class-or-interface-declaration")
  (equal
      (abnf::tree-nonleaf->rulename? abnf::cst)
      (abnf::rulename "top-level-class-or-interface-declaration"))))

Theorem: cst-module-declaration-rulename

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

Theorem: cst-module-directive-rulename

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

Theorem: cst-requires-modifier-rulename

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

Theorem: cst-class-declaration-rulename

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

Theorem: cst-normal-class-declaration-rulename

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

Theorem: cst-class-modifier-rulename

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

Theorem: cst-type-parameters-rulename

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

Theorem: cst-type-parameter-list-rulename

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

Theorem: cst-class-extends-rulename

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

Theorem: cst-class-implements-rulename

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

Theorem: cst-interface-type-list-rulename

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

Theorem: cst-class-permits-rulename

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

Theorem: cst-class-body-rulename

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

Theorem: cst-class-body-declaration-rulename

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

Theorem: cst-class-member-declaration-rulename

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

Theorem: cst-field-declaration-rulename

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

Theorem: cst-variable-declarator-list-rulename

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

Theorem: cst-variable-declarator-rulename

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

Theorem: cst-variable-declarator-id-rulename

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

Theorem: cst-variable-initializer-rulename

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

Theorem: cst-unann-type-rulename

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

Theorem: cst-unann-primitive-type-rulename

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

Theorem: cst-unann-reference-type-rulename

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

Theorem: cst-unann-class-or-interface-type-rulename

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

Theorem: cst-unann-class-type-rulename

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

Theorem: cst-unann-interface-type-rulename

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

Theorem: cst-unann-type-variable-rulename

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

Theorem: cst-unann-array-type-rulename

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

Theorem: cst-field-modifier-rulename

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

Theorem: cst-method-declaration-rulename

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

Theorem: cst-method-header-rulename

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

Theorem: cst-method-declarator-rulename

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

Theorem: cst-receiver-parameter-rulename

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

Theorem: cst-formal-parameter-list-rulename

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

Theorem: cst-formal-parameter-rulename

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

Theorem: cst-variable-arity-parameter-rulename

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

Theorem: cst-variable-modifier-rulename

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

Theorem: cst-method-modifier-rulename

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

Theorem: cst-result-rulename

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

Theorem: cst-throws-rulename

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

Theorem: cst-exception-type-list-rulename

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

Theorem: cst-exception-type-rulename

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

Theorem: cst-method-body-rulename

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

Theorem: cst-instance-initializer-rulename

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

Theorem: cst-static-initializer-rulename

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

Theorem: cst-constructor-declaration-rulename

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

Theorem: cst-constructor-declarator-rulename

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

Theorem: cst-simple-type-name-rulename

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

Theorem: cst-constructor-modifier-rulename

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

Theorem: cst-constructor-body-rulename

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

Theorem: cst-constructor-invocation-rulename

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

Theorem: cst-enum-declaration-rulename

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

Theorem: cst-enum-body-rulename

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

Theorem: cst-enum-constant-list-rulename

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

Theorem: cst-enum-constant-rulename

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

Theorem: cst-enum-constant-modifier-rulename

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

Theorem: cst-enum-body-declarations-rulename

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

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-record-header-rulename

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

Theorem: cst-record-component-list-rulename

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

Theorem: cst-record-component-rulename

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

Theorem: cst-variable-arity-record-component-rulename

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

Theorem: cst-record-component-modifier-rulename

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

Theorem: cst-record-body-rulename

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

Theorem: cst-record-body-declaration-rulename

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

Theorem: cst-compact-constructor-declaration-rulename

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

Theorem: cst-interface-declaration-rulename

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

Theorem: cst-normal-interface-declaration-rulename

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

Theorem: cst-interface-modifier-rulename

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

Theorem: cst-interface-extends-rulename

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

Theorem: cst-interface-permits-rulename

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

Theorem: cst-interface-body-rulename

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

Theorem: cst-interface-member-declaration-rulename

(defthm cst-interface-member-declaration-rulename
  (implies (cst-matchp abnf::cst
                       "interface-member-declaration")
           (equal (abnf::tree-nonleaf->rulename? abnf::cst)
                  (abnf::rulename "interface-member-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-constant-modifier-rulename

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

Theorem: cst-interface-method-declaration-rulename

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

Theorem: cst-interface-method-modifier-rulename

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

Theorem: cst-annotation-interface-declaration-rulename

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

Theorem: cst-annotation-interface-body-rulename

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

Theorem: cst-annotation-interface-member-declaration-rulename

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

Theorem: cst-annotation-interface-element-declaration-rulename

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

Theorem: cst-annotation-interface-element-modifier-rulename

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

Theorem: cst-default-value-rulename

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

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-normal-annotation-rulename

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

Theorem: cst-element-value-pair-list-rulename

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

Theorem: cst-element-value-pair-rulename

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

Theorem: cst-element-value-rulename

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

Theorem: cst-element-value-array-initializer-rulename

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

Theorem: cst-element-value-list-rulename

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

Theorem: cst-marker-annotation-rulename

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

Theorem: cst-single-element-annotation-rulename

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

Theorem: cst-array-initializer-rulename

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

Theorem: cst-variable-initializer-list-rulename

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

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-block-statements-rulename

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

Theorem: cst-block-statement-rulename

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

Theorem: cst-local-class-or-interface-declaration-rulename

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

Theorem: cst-local-variable-declaration-rulename

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

Theorem: cst-local-variable-type-rulename

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

Theorem: cst-local-variable-declaration-statement-rulename

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

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-statement-no-short-if-rulename

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

Theorem: cst-statement-without-trailing-substatement-rulename

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

Theorem: cst-empty-statement-rulename

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

Theorem: cst-labeled-statement-rulename

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

Theorem: cst-labeled-statement-no-short-if-rulename

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

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

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

Theorem: cst-if-then-statement-rulename

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

Theorem: cst-if-then-else-statement-rulename

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

Theorem: cst-if-then-else-statement-no-short-if-rulename

(defthm cst-if-then-else-statement-no-short-if-rulename
 (implies
     (cst-matchp abnf::cst
                 "if-then-else-statement-no-short-if")
     (equal (abnf::tree-nonleaf->rulename? abnf::cst)
            (abnf::rulename "if-then-else-statement-no-short-if"))))

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

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

Theorem: cst-switch-block-rulename

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

Theorem: cst-switch-rule-rulename

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

Theorem: cst-switch-block-statement-group-rulename

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

Theorem: cst-switch-label-rulename

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

Theorem: cst-case-constant-rulename

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

Theorem: cst-case-pattern-rulename

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

Theorem: cst-guard-rulename

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

Theorem: cst-while-statement-rulename

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

Theorem: cst-while-statement-no-short-if-rulename

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

Theorem: cst-do-statement-rulename

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

Theorem: cst-for-statement-rulename

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

Theorem: cst-for-statement-no-short-if-rulename

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

Theorem: cst-basic-for-statement-rulename

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

Theorem: cst-basic-for-statement-no-short-if-rulename

(defthm cst-basic-for-statement-no-short-if-rulename
  (implies
       (cst-matchp abnf::cst
                   "basic-for-statement-no-short-if")
       (equal (abnf::tree-nonleaf->rulename? abnf::cst)
              (abnf::rulename "basic-for-statement-no-short-if"))))

Theorem: cst-for-init-rulename

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

Theorem: cst-for-update-rulename

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

Theorem: cst-statement-expression-list-rulename

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

Theorem: cst-enhanced-for-statement-rulename

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

Theorem: cst-enhanced-for-statement-no-short-if-rulename

(defthm cst-enhanced-for-statement-no-short-if-rulename
 (implies
     (cst-matchp abnf::cst
                 "enhanced-for-statement-no-short-if")
     (equal (abnf::tree-nonleaf->rulename? abnf::cst)
            (abnf::rulename "enhanced-for-statement-no-short-if"))))

Theorem: cst-break-statement-rulename

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

Theorem: cst-continue-statement-rulename

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

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

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

Theorem: cst-synchronized-statement-rulename

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

Theorem: cst-try-statement-rulename

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

Theorem: cst-catches-rulename

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

Theorem: cst-catch-clause-rulename

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

Theorem: cst-catch-formal-parameter-rulename

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

Theorem: cst-catch-type-rulename

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

Theorem: cst-finally-rulename

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

Theorem: cst-try-with-resources-statement-rulename

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

Theorem: cst-resource-specification-rulename

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

Theorem: cst-resource-list-rulename

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

Theorem: cst-resource-rulename

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

Theorem: cst-variable-access-rulename

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

Theorem: cst-yield-statement-rulename

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

Theorem: cst-pattern-rulename

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

Theorem: cst-type-pattern-rulename

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

Theorem: cst-record-pattern-rulename

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

Theorem: cst-component-pattern-list-rulename

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

Theorem: cst-component-pattern-rulename

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

Theorem: cst-match-all-pattern-rulename

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

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

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

Theorem: cst-primary-no-new-array-rulename

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

Theorem: cst-class-literal-rulename

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

Theorem: cst-class-instance-creation-expression-rulename

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

Theorem: cst-unqualified-class-instance-creation-expression-rulename

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

Theorem: cst-class-or-interface-type-to-instantiate-rulename

(defthm cst-class-or-interface-type-to-instantiate-rulename
 (implies
   (cst-matchp abnf::cst
               "class-or-interface-type-to-instantiate")
   (equal
        (abnf::tree-nonleaf->rulename? abnf::cst)
        (abnf::rulename "class-or-interface-type-to-instantiate"))))

Theorem: cst-type-arguments-or-diamond-rulename

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

Theorem: cst-array-creation-expression-rulename

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

Theorem: cst-array-creation-expression-without-initializer-rulename

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

Theorem: cst-array-creation-expression-with-initializer-rulename

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

Theorem: cst-dim-exprs-rulename

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

Theorem: cst-dim-expr-rulename

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

Theorem: cst-array-access-rulename

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

Theorem: cst-field-access-rulename

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

Theorem: cst-method-invocation-rulename

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

Theorem: cst-argument-list-rulename

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

Theorem: cst-method-reference-rulename

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

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

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

Theorem: cst-post-decrement-expression-rulename

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

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

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

Theorem: cst-pre-decrement-expression-rulename

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

Theorem: cst-unary-expression-not-plus-minus-rulename

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

Theorem: cst-cast-expression-rulename

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

Theorem: cst-multiplicative-expression-rulename

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

Theorem: cst-additive-expression-rulename

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

Theorem: cst-shift-expression-rulename

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

Theorem: cst-relational-expression-rulename

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

Theorem: cst-instanceof-expression-rulename

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

Theorem: cst-equality-expression-rulename

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

Theorem: cst-and-expression-rulename

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

Theorem: cst-exclusive-or-expression-rulename

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

Theorem: cst-inclusive-or-expression-rulename

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

Theorem: cst-conditional-and-expression-rulename

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

Theorem: cst-conditional-or-expression-rulename

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

Theorem: cst-conditional-expression-rulename

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

Theorem: cst-assignment-expression-rulename

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

Theorem: cst-assignment-rulename

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

Theorem: cst-left-hand-side-rulename

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

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

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

Theorem: cst-lambda-parameters-rulename

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

Theorem: cst-lambda-parameter-list-rulename

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

Theorem: cst-normal-lambda-parameter-rulename

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

Theorem: cst-lambda-parameter-type-rulename

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

Theorem: cst-concise-lambda-parameter-rulename

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

Theorem: cst-lambda-body-rulename

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

Theorem: cst-switch-expression-rulename

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

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

(defthm cst-unicode-input-character-branches-match-alt
  (implies (cst-matchp abnf::cst "unicode-input-character")
           (cst-list-list-alt-matchp
                (abnf::tree-nonleaf->branches abnf::cst)
                "unicode-escape / raw-input-character")))

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

(defthm cst-unicode-escape-branches-match-alt
 (implies
  (cst-matchp abnf::cst "unicode-escape")
  (cst-list-list-alt-matchp
     (abnf::tree-nonleaf->branches abnf::cst)
     "\"\\\" unicode-marker hex-digit hex-digit hex-digit hex-digit")))

Theorem: cst-unicode-marker-branches-match-alt

(defthm cst-unicode-marker-branches-match-alt
 (implies
  (cst-matchp abnf::cst "unicode-marker")
  (cst-list-list-alt-matchp (abnf::tree-nonleaf->branches abnf::cst)
                            "1*%s\"u\"")))

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

(defthm cst-hex-digit-branches-match-alt
 (implies
  (cst-matchp abnf::cst "hex-digit")
  (cst-list-list-alt-matchp
   (abnf::tree-nonleaf->branches abnf::cst)
   "\"0\" / \"1\" / \"2\" / \"3\" / \"4\" / \"5\" / \"6\" / \"7\" / \"8\" / \"9\" / \"a\" / \"b\" / \"c\" / \"d\" / \"e\" / \"f\"")))

Theorem: cst-raw-input-character-branches-match-alt

(defthm cst-raw-input-character-branches-match-alt
 (implies
  (cst-matchp abnf::cst "raw-input-character")
  (cst-list-list-alt-matchp (abnf::tree-nonleaf->branches abnf::cst)
                            "%x0-FFFF")))

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)
                            "%d10 / %d13 / %d13.10")))

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

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

Theorem: cst-input-branches-match-alt

(defthm cst-input-branches-match-alt
 (implies
  (cst-matchp abnf::cst "input")
  (cst-list-list-alt-matchp (abnf::tree-nonleaf->branches abnf::cst)
                            "*input-element [ sub ]")))

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

(defthm cst-input-element-branches-match-alt
 (implies
  (cst-matchp abnf::cst "input-element")
  (cst-list-list-alt-matchp (abnf::tree-nonleaf->branches abnf::cst)
                            "white-space / comment / token")))

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)
          "identifier / keyword / literal / separator / operator")))

Theorem: cst-sub-branches-match-alt

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

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

(defthm cst-white-space-branches-match-alt
 (implies
  (cst-matchp abnf::cst "white-space")
  (cst-list-list-alt-matchp (abnf::tree-nonleaf->branches abnf::cst)
                            "%d32 / %d9 / %d12 / line-terminator")))

Theorem: cst-comment-branches-match-alt

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

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

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

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

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

Theorem: cst-comment-tail-star-branches-match-alt

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

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

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

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

(defthm cst-not-star-not-slash-branches-match-alt
 (implies
  (cst-matchp abnf::cst "not-star-not-slash")
  (cst-list-list-alt-matchp (abnf::tree-nonleaf->branches abnf::cst)
                            "input-character / line-terminator")))

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

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

Theorem: cst-identifier-branches-match-alt

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

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

(defthm cst-identifier-chars-branches-match-alt
 (implies
  (cst-matchp abnf::cst "identifier-chars")
  (cst-list-list-alt-matchp (abnf::tree-nonleaf->branches abnf::cst)
                            "java-letter *java-letter-or-digit")))

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

(defthm cst-java-letter-branches-match-alt
 (implies
  (cst-matchp abnf::cst "java-letter")
  (cst-list-list-alt-matchp (abnf::tree-nonleaf->branches abnf::cst)
                            "raw-input-character")))

Theorem: cst-java-letter-or-digit-branches-match-alt

(defthm cst-java-letter-or-digit-branches-match-alt
 (implies
  (cst-matchp abnf::cst "java-letter-or-digit")
  (cst-list-list-alt-matchp (abnf::tree-nonleaf->branches abnf::cst)
                            "raw-input-character")))

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

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

Theorem: cst-unqualified-method-identifier-branches-match-alt

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

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)
                "reserved-keyword / contextual-keyword")))

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

(defthm cst-reserved-keyword-branches-match-alt
 (implies
  (cst-matchp abnf::cst "reserved-keyword")
  (cst-list-list-alt-matchp
   (abnf::tree-nonleaf->branches abnf::cst)
   "%s\"abstract\" / %s\"assert\" / %s\"boolean\" / %s\"break\" / %s\"byte\" / %s\"case\" / %s\"catch\" / %s\"char\" / %s\"class\" / %s\"const\" / %s\"continue\" / %s\"default\" / %s\"do\" / %s\"double\" / %s\"else\" / %s\"enum\" / %s\"extends\" / %s\"final\" / %s\"finally\" / %s\"float\" / %s\"for\" / %s\"if\" / %s\"goto\" / %s\"implements\" / %s\"import\" / %s\"instanceof\" / %s\"int\" / %s\"interface\" / %s\"long\" / %s\"native\" / %s\"new\" / %s\"package\" / %s\"private\" / %s\"protected\" / %s\"public\" / %s\"return\" / %s\"short\" / %s\"static\" / %s\"strictfp\" / %s\"super\" / %s\"switch\" / %s\"synchronized\" / %s\"this\" / %s\"throw\" / %s\"throws\" / %s\"transient\" / %s\"try\" / %s\"void\" / %s\"volatile\" / %s\"while\" / \"_\"")))

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

(defthm cst-contextual-keyword-branches-match-alt
 (implies
  (cst-matchp abnf::cst "contextual-keyword")
  (cst-list-list-alt-matchp
   (abnf::tree-nonleaf->branches abnf::cst)
   "%s\"exports\" / %s\"module\" / %s\"non-sealed\" / %s\"open\" / %s\"opens\" / %s\"permits\" / %s\"provides\" / %s\"record\" / %s\"requires\" / %s\"sealed\" / %s\"to\" / %s\"transitive\" / %s\"uses\" / %s\"var\" / %s\"when\" / %s\"with\" / %s\"yield\"")))

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)
   "integer-literal / floating-point-literal / boolean-literal / character-literal / string-literal / text-block / null-literal")))

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)
   "decimal-integer-literal / hex-integer-literal / octal-integer-literal / binary-integer-literal")))

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

(defthm cst-decimal-integer-literal-branches-match-alt
  (implies (cst-matchp abnf::cst "decimal-integer-literal")
           (cst-list-list-alt-matchp
                (abnf::tree-nonleaf->branches abnf::cst)
                "decimal-numeral [ integer-type-suffix ]")))

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

(defthm cst-hex-integer-literal-branches-match-alt
 (implies
  (cst-matchp abnf::cst "hex-integer-literal")
  (cst-list-list-alt-matchp (abnf::tree-nonleaf->branches abnf::cst)
                            "hex-numeral [ integer-type-suffix ]")))

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

(defthm cst-octal-integer-literal-branches-match-alt
  (implies (cst-matchp abnf::cst "octal-integer-literal")
           (cst-list-list-alt-matchp
                (abnf::tree-nonleaf->branches abnf::cst)
                "octal-numeral [ integer-type-suffix ]")))

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

(defthm cst-binary-integer-literal-branches-match-alt
  (implies (cst-matchp abnf::cst "binary-integer-literal")
           (cst-list-list-alt-matchp
                (abnf::tree-nonleaf->branches abnf::cst)
                "binary-numeral [ integer-type-suffix ]")))

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

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

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)
   "\"0\" / non-zero-digit [ digits ] / non-zero-digit underscores digits")))

Theorem: cst-non-zero-digit-branches-match-alt

(defthm cst-non-zero-digit-branches-match-alt
  (implies
       (cst-matchp abnf::cst "non-zero-digit")
       (cst-list-list-alt-matchp
            (abnf::tree-nonleaf->branches abnf::cst)
            "\"1\" / \"2\" / \"3\" / \"4\" / \"5\" / \"6\" / \"7\" / \"8\" / \"9\"")))

Theorem: cst-digits-branches-match-alt

(defthm cst-digits-branches-match-alt
  (implies (cst-matchp abnf::cst "digits")
           (cst-list-list-alt-matchp
                (abnf::tree-nonleaf->branches abnf::cst)
                "digit / digit [ digits-and-underscores ] digit")))

Theorem: cst-digit-branches-match-alt

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

Theorem: cst-digits-and-underscores-branches-match-alt

(defthm cst-digits-and-underscores-branches-match-alt
  (implies (cst-matchp abnf::cst "digits-and-underscores")
           (cst-list-list-alt-matchp
                (abnf::tree-nonleaf->branches abnf::cst)
                "digit-or-underscore *digit-or-underscore")))

Theorem: cst-digit-or-underscore-branches-match-alt

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

Theorem: cst-underscores-branches-match-alt

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

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

(defthm cst-hex-numeral-branches-match-alt
 (implies
  (cst-matchp abnf::cst "hex-numeral")
  (cst-list-list-alt-matchp (abnf::tree-nonleaf->branches abnf::cst)
                            "\"0x\" hex-digits")))

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

(defthm cst-hex-digits-branches-match-alt
 (implies
  (cst-matchp abnf::cst "hex-digits")
  (cst-list-list-alt-matchp
   (abnf::tree-nonleaf->branches abnf::cst)
   "hex-digit / hex-digit [ hex-digits-and-underscores ] hex-digit")))

Theorem: cst-hex-digits-and-underscores-branches-match-alt

(defthm cst-hex-digits-and-underscores-branches-match-alt
 (implies
  (cst-matchp abnf::cst "hex-digits-and-underscores")
  (cst-list-list-alt-matchp (abnf::tree-nonleaf->branches abnf::cst)
                            "1*hex-digit-or-underscore")))

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

(defthm cst-hex-digit-or-underscore-branches-match-alt
 (implies
  (cst-matchp abnf::cst "hex-digit-or-underscore")
  (cst-list-list-alt-matchp (abnf::tree-nonleaf->branches abnf::cst)
                            "hex-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)
                "\"0\" octal-digits / \"0\" underscores octal-digits")))

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

(defthm cst-octal-digits-branches-match-alt
 (implies
  (cst-matchp abnf::cst "octal-digits")
  (cst-list-list-alt-matchp
   (abnf::tree-nonleaf->branches abnf::cst)
   "octal-digit / octal-digit [ octal-digits-and-underscores ] octal-digit")))

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)
                "\"0\" / \"1\" / \"2\" / \"3\" / \"4\" / \"5\" / \"6\" / \"7\"")))

Theorem: cst-octal-digits-and-underscores-branches-match-alt

(defthm cst-octal-digits-and-underscores-branches-match-alt
 (implies
  (cst-matchp abnf::cst
              "octal-digits-and-underscores")
  (cst-list-list-alt-matchp (abnf::tree-nonleaf->branches abnf::cst)
                            "1*octal-digit-or-underscore")))

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

(defthm cst-octal-digit-or-underscore-branches-match-alt
 (implies
  (cst-matchp abnf::cst "octal-digit-or-underscore")
  (cst-list-list-alt-matchp (abnf::tree-nonleaf->branches abnf::cst)
                            "octal-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)
                            "\"0b\" binary-digits")))

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

(defthm cst-binary-digits-branches-match-alt
 (implies
  (cst-matchp abnf::cst "binary-digits")
  (cst-list-list-alt-matchp
   (abnf::tree-nonleaf->branches abnf::cst)
   "binary-digit / binary-digit [ binary-digits-and-underscores ] binary-digit")))

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)
                            "\"0\" / \"1\"")))

Theorem: cst-binary-digits-and-underscores-branches-match-alt

(defthm cst-binary-digits-and-underscores-branches-match-alt
 (implies
  (cst-matchp abnf::cst
              "binary-digits-and-underscores")
  (cst-list-list-alt-matchp (abnf::tree-nonleaf->branches abnf::cst)
                            "1*binary-digit-or-underscore")))

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

(defthm cst-binary-digit-or-underscore-branches-match-alt
 (implies
  (cst-matchp abnf::cst "binary-digit-or-underscore")
  (cst-list-list-alt-matchp (abnf::tree-nonleaf->branches abnf::cst)
                            "binary-digit / \"_\"")))

Theorem: cst-floating-point-literal-branches-match-alt

(defthm cst-floating-point-literal-branches-match-alt
 (implies
  (cst-matchp abnf::cst "floating-point-literal")
  (cst-list-list-alt-matchp
   (abnf::tree-nonleaf->branches abnf::cst)
   "decimal-floating-point-literal / hexadecimal-floating-point-literal")))

Theorem: cst-decimal-floating-point-literal-branches-match-alt

(defthm cst-decimal-floating-point-literal-branches-match-alt
 (implies
  (cst-matchp abnf::cst
              "decimal-floating-point-literal")
  (cst-list-list-alt-matchp
   (abnf::tree-nonleaf->branches abnf::cst)
   "digits \".\" [ digits ] [ exponent-part ] [ float-type-suffix ] / \".\" digits [ exponent-part ] [ float-type-suffix ] / digits exponent-part [ float-type-suffix ] / digits [ exponent-part ] float-type-suffix")))

Theorem: cst-exponent-part-branches-match-alt

(defthm cst-exponent-part-branches-match-alt
 (implies
  (cst-matchp abnf::cst "exponent-part")
  (cst-list-list-alt-matchp (abnf::tree-nonleaf->branches abnf::cst)
                            "exponent-indicator signed-integer")))

Theorem: cst-exponent-indicator-branches-match-alt

(defthm cst-exponent-indicator-branches-match-alt
 (implies
  (cst-matchp abnf::cst "exponent-indicator")
  (cst-list-list-alt-matchp (abnf::tree-nonleaf->branches abnf::cst)
                            "\"e\"")))

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

(defthm cst-signed-integer-branches-match-alt
 (implies
  (cst-matchp abnf::cst "signed-integer")
  (cst-list-list-alt-matchp (abnf::tree-nonleaf->branches abnf::cst)
                            "[ sign ] digits")))

Theorem: cst-sign-branches-match-alt

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

Theorem: cst-float-type-suffix-branches-match-alt

(defthm cst-float-type-suffix-branches-match-alt
 (implies
  (cst-matchp abnf::cst "float-type-suffix")
  (cst-list-list-alt-matchp (abnf::tree-nonleaf->branches abnf::cst)
                            "\"f\" / \"d\"")))

Theorem: cst-hexadecimal-floating-point-literal-branches-match-alt

(defthm cst-hexadecimal-floating-point-literal-branches-match-alt
 (implies
     (cst-matchp abnf::cst
                 "hexadecimal-floating-point-literal")
     (cst-list-list-alt-matchp
          (abnf::tree-nonleaf->branches abnf::cst)
          "hex-significand binary-exponent [ float-type-suffix ]")))

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

(defthm cst-hex-significand-branches-match-alt
 (implies
  (cst-matchp abnf::cst "hex-significand")
  (cst-list-list-alt-matchp
       (abnf::tree-nonleaf->branches abnf::cst)
       "hex-numeral [ \".\" ] / \"0x\" [ hex-digits ] \".\" hex-digits")))

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

(defthm cst-binary-exponent-branches-match-alt
  (implies (cst-matchp abnf::cst "binary-exponent")
           (cst-list-list-alt-matchp
                (abnf::tree-nonleaf->branches abnf::cst)
                "binary-exponent-indicator signed-integer")))

Theorem: cst-binary-exponent-indicator-branches-match-alt

(defthm cst-binary-exponent-indicator-branches-match-alt
 (implies
  (cst-matchp abnf::cst "binary-exponent-indicator")
  (cst-list-list-alt-matchp (abnf::tree-nonleaf->branches abnf::cst)
                            "\"p\"")))

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

(defthm cst-character-literal-branches-match-alt
  (implies
       (cst-matchp abnf::cst "character-literal")
       (cst-list-list-alt-matchp
            (abnf::tree-nonleaf->branches abnf::cst)
            "\"'\" single-character \"'\" / \"'\" escape-sequence \"'\"")))

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

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

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)
                            "%d34 *string-character %d34")))

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)
                            "input-character / escape-sequence")))

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

(defthm cst-text-block-branches-match-alt
 (implies
  (cst-matchp abnf::cst "text-block")
  (cst-list-list-alt-matchp
   (abnf::tree-nonleaf->branches abnf::cst)
   "%d34 %d34 %d34 *text-block-white-space line-terminator *text-block-character %d34 %d34 %d34")))

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

(defthm cst-text-block-white-space-branches-match-alt
 (implies
  (cst-matchp abnf::cst "text-block-white-space")
  (cst-list-list-alt-matchp (abnf::tree-nonleaf->branches abnf::cst)
                            "white-space")))

Theorem: cst-text-block-character-branches-match-alt

(defthm cst-text-block-character-branches-match-alt
  (implies
       (cst-matchp abnf::cst "text-block-character")
       (cst-list-list-alt-matchp
            (abnf::tree-nonleaf->branches abnf::cst)
            "input-character / escape-sequence / line-terminator")))

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

(defthm cst-escape-sequence-branches-match-alt
 (implies
  (cst-matchp abnf::cst "escape-sequence")
  (cst-list-list-alt-matchp
   (abnf::tree-nonleaf->branches abnf::cst)
   "%s\"\\b\" / %s\"\\s\" / %s\"\\t\" / %s\"\\n\" / %s\"\\f\" / %s\"\\r\" / line-terminator / \"\\\" %d34 / \"\\'\" / \"\\\\\" / octal-escape")))

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

(defthm cst-octal-escape-branches-match-alt
 (implies
  (cst-matchp abnf::cst "octal-escape")
  (cst-list-list-alt-matchp
   (abnf::tree-nonleaf->branches abnf::cst)
   "\"\\\" octal-digit / \"\\\" octal-digit octal-digit / \"\\\" zero-to-three octal-digit octal-digit")))

Theorem: cst-zero-to-three-branches-match-alt

(defthm cst-zero-to-three-branches-match-alt
 (implies
  (cst-matchp abnf::cst "zero-to-three")
  (cst-list-list-alt-matchp (abnf::tree-nonleaf->branches abnf::cst)
                            "\"0\" / \"1\" / \"2\" / \"3\"")))

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

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

Theorem: cst-separator-branches-match-alt

(defthm cst-separator-branches-match-alt
 (implies
  (cst-matchp abnf::cst "separator")
  (cst-list-list-alt-matchp
   (abnf::tree-nonleaf->branches abnf::cst)
   "\"(\" / \")\" / \"{\" / \"}\" / \"[\" / \"]\" / \";\" / \",\" / \".\" / \"...\" / \"@\" / \"::\"")))

Theorem: cst-operator-branches-match-alt

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

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 / reference-type")))

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)
            "*annotation numeric-type / *annotation %s\"boolean\"")))

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

(defthm cst-numeric-type-branches-match-alt
 (implies
  (cst-matchp abnf::cst "numeric-type")
  (cst-list-list-alt-matchp (abnf::tree-nonleaf->branches abnf::cst)
                            "integral-type / floating-point-type")))

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

(defthm cst-integral-type-branches-match-alt
 (implies
      (cst-matchp abnf::cst "integral-type")
      (cst-list-list-alt-matchp
           (abnf::tree-nonleaf->branches abnf::cst)
           "%s\"byte\" / %s\"short\" / %s\"int\" / %s\"long\" / %s\"char\"")))

Theorem: cst-floating-point-type-branches-match-alt

(defthm cst-floating-point-type-branches-match-alt
 (implies
  (cst-matchp abnf::cst "floating-point-type")
  (cst-list-list-alt-matchp (abnf::tree-nonleaf->branches abnf::cst)
                            "%s\"float\" / %s\"double\"")))

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

(defthm cst-reference-type-branches-match-alt
 (implies
      (cst-matchp abnf::cst "reference-type")
      (cst-list-list-alt-matchp
           (abnf::tree-nonleaf->branches abnf::cst)
           "class-or-interface-type / type-variable / array-type")))

Theorem: cst-class-or-interface-type-branches-match-alt

(defthm cst-class-or-interface-type-branches-match-alt
 (implies
  (cst-matchp abnf::cst "class-or-interface-type")
  (cst-list-list-alt-matchp (abnf::tree-nonleaf->branches abnf::cst)
                            "class-type / interface-type")))

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

(defthm cst-class-type-branches-match-alt
 (implies
  (cst-matchp abnf::cst "class-type")
  (cst-list-list-alt-matchp
   (abnf::tree-nonleaf->branches abnf::cst)
   "*annotation type-identifier [ type-arguments ] / package-name \".\" *annotation type-identifier [ type-arguments ] / class-or-interface-type \".\" *annotation type-identifier [ type-arguments ]")))

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

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

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

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

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)
   "primitive-type dims / class-or-interface-type dims / type-variable dims")))

Theorem: cst-dims-branches-match-alt

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

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

(defthm cst-type-parameter-branches-match-alt
 (implies
   (cst-matchp abnf::cst "type-parameter")
   (cst-list-list-alt-matchp
        (abnf::tree-nonleaf->branches abnf::cst)
        "*type-parameter-modifier type-identifier [ type-bound ]")))

Theorem: cst-type-parameter-modifier-branches-match-alt

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

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

(defthm cst-type-bound-branches-match-alt
 (implies
  (cst-matchp abnf::cst "type-bound")
  (cst-list-list-alt-matchp
   (abnf::tree-nonleaf->branches abnf::cst)
   "%s\"extends\" type-variable / %s\"extends\" class-or-interface-type *additional-bound")))

Theorem: cst-additional-bound-branches-match-alt

(defthm cst-additional-bound-branches-match-alt
 (implies
  (cst-matchp abnf::cst "additional-bound")
  (cst-list-list-alt-matchp (abnf::tree-nonleaf->branches abnf::cst)
                            "\"&\" interface-type")))

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

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

Theorem: cst-type-argument-list-branches-match-alt

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

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

(defthm cst-type-argument-branches-match-alt
 (implies
  (cst-matchp abnf::cst "type-argument")
  (cst-list-list-alt-matchp (abnf::tree-nonleaf->branches abnf::cst)
                            "reference-type / wildcard")))

Theorem: cst-wildcard-branches-match-alt

(defthm cst-wildcard-branches-match-alt
 (implies
  (cst-matchp abnf::cst "wildcard")
  (cst-list-list-alt-matchp (abnf::tree-nonleaf->branches abnf::cst)
                            "*annotation \"?\" [ wildcard-bounds ]")))

Theorem: cst-wildcard-bounds-branches-match-alt

(defthm cst-wildcard-bounds-branches-match-alt
 (implies
     (cst-matchp abnf::cst "wildcard-bounds")
     (cst-list-list-alt-matchp
          (abnf::tree-nonleaf->branches abnf::cst)
          "%s\"extends\" reference-type / %s\"super\" reference-type")))

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

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

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

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

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

(defthm cst-type-name-branches-match-alt
 (implies
  (cst-matchp abnf::cst "type-name")
  (cst-list-list-alt-matchp
     (abnf::tree-nonleaf->branches abnf::cst)
     "type-identifier / package-or-type-name \".\" type-identifier")))

Theorem: cst-package-or-type-name-branches-match-alt

(defthm cst-package-or-type-name-branches-match-alt
 (implies (cst-matchp abnf::cst "package-or-type-name")
          (cst-list-list-alt-matchp
               (abnf::tree-nonleaf->branches abnf::cst)
               "identifier / package-or-type-name \".\" identifier")))

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

(defthm cst-expression-name-branches-match-alt
  (implies (cst-matchp abnf::cst "expression-name")
           (cst-list-list-alt-matchp
                (abnf::tree-nonleaf->branches abnf::cst)
                "identifier / ambiguous-name \".\" identifier")))

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

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

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

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

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

(defthm cst-compilation-unit-branches-match-alt
 (implies
  (cst-matchp abnf::cst "compilation-unit")
  (cst-list-list-alt-matchp
   (abnf::tree-nonleaf->branches abnf::cst)
   "ordinary-compilation-unit / compact-compilation-unit / modular-compilation-unit")))

Theorem: cst-ordinary-compilation-unit-branches-match-alt

(defthm cst-ordinary-compilation-unit-branches-match-alt
 (implies
  (cst-matchp abnf::cst "ordinary-compilation-unit")
  (cst-list-list-alt-matchp
   (abnf::tree-nonleaf->branches abnf::cst)
   "[ package-declaration ] *import-declaration *top-level-class-or-interface-declaration")))

Theorem: cst-compact-compilation-unit-branches-match-alt

(defthm cst-compact-compilation-unit-branches-match-alt
 (implies
  (cst-matchp abnf::cst "compact-compilation-unit")
  (cst-list-list-alt-matchp
   (abnf::tree-nonleaf->branches abnf::cst)
   "*import-declaration *class-member-declaration-no-method *method-declaration *class-member-declaration")))

Theorem: cst-class-member-declaration-no-method-branches-match-alt

(defthm cst-class-member-declaration-no-method-branches-match-alt
 (implies
  (cst-matchp abnf::cst
              "class-member-declaration-no-method")
  (cst-list-list-alt-matchp
   (abnf::tree-nonleaf->branches abnf::cst)
   "field-declaration / class-declaration / interface-declaration / \";\"")))

Theorem: cst-modular-compilation-unit-branches-match-alt

(defthm cst-modular-compilation-unit-branches-match-alt
  (implies (cst-matchp abnf::cst "modular-compilation-unit")
           (cst-list-list-alt-matchp
                (abnf::tree-nonleaf->branches abnf::cst)
                "*import-declaration module-declaration")))

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

(defthm cst-package-declaration-branches-match-alt
 (implies
  (cst-matchp abnf::cst "package-declaration")
  (cst-list-list-alt-matchp
   (abnf::tree-nonleaf->branches abnf::cst)
   "*package-modifier %s\"package\" identifier *( \".\" identifier ) \";\"")))

Theorem: cst-package-modifier-branches-match-alt

(defthm cst-package-modifier-branches-match-alt
 (implies
  (cst-matchp abnf::cst "package-modifier")
  (cst-list-list-alt-matchp (abnf::tree-nonleaf->branches abnf::cst)
                            "annotation")))

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)
   "single-type-import-declaration / type-import-on-demand-declaration / single-static-import-declaration / static-import-on-demand-declaration / single-module-import-declaration")))

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

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

Theorem: cst-type-import-on-demand-declaration-branches-match-alt

(defthm cst-type-import-on-demand-declaration-branches-match-alt
  (implies (cst-matchp abnf::cst
                       "type-import-on-demand-declaration")
           (cst-list-list-alt-matchp
                (abnf::tree-nonleaf->branches abnf::cst)
                "%s\"import\" package-or-type-name \".\" \"*\" \";\"")))

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

(defthm cst-single-static-import-declaration-branches-match-alt
  (implies
       (cst-matchp abnf::cst
                   "single-static-import-declaration")
       (cst-list-list-alt-matchp
            (abnf::tree-nonleaf->branches abnf::cst)
            "%s\"import\" %s\"static\" type-name \".\" identifier \";\"")))

Theorem: cst-static-import-on-demand-declaration-branches-match-alt

(defthm cst-static-import-on-demand-declaration-branches-match-alt
  (implies (cst-matchp abnf::cst
                       "static-import-on-demand-declaration")
           (cst-list-list-alt-matchp
                (abnf::tree-nonleaf->branches abnf::cst)
                "%s\"import\" %s\"static\" type-name \".\" \"*\" \";\"")))

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

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

Theorem: cst-top-level-class-or-interface-declaration-branches-match-alt

(defthm
    cst-top-level-class-or-interface-declaration-branches-match-alt
  (implies (cst-matchp abnf::cst
                       "top-level-class-or-interface-declaration")
           (cst-list-list-alt-matchp
                (abnf::tree-nonleaf->branches abnf::cst)
                "class-declaration / interface-declaration / \";\"")))

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

(defthm cst-module-declaration-branches-match-alt
 (implies
  (cst-matchp abnf::cst "module-declaration")
  (cst-list-list-alt-matchp
   (abnf::tree-nonleaf->branches abnf::cst)
   "*annotation [ %s\"open\" ] %s\"module\" identifier *( \".\" identifier ) \"{\" *module-directive \"}\"")))

Theorem: cst-module-directive-branches-match-alt

(defthm cst-module-directive-branches-match-alt
 (implies
  (cst-matchp abnf::cst "module-directive")
  (cst-list-list-alt-matchp
   (abnf::tree-nonleaf->branches abnf::cst)
   "%s\"requires\" *requires-modifier module-name \";\" / %s\"exports\" package-name [ %s\"to\" module-name *( \",\" module-name ) ] \";\" / %s\"opens\" package-name [ %s\"to\" module-name *( \",\" module-name ) ] \";\" / %s\"uses\" type-name \";\" / %s\"provides\" type-name %s\"with\" type-name *( \",\" type-name ) \";\"")))

Theorem: cst-requires-modifier-branches-match-alt

(defthm cst-requires-modifier-branches-match-alt
 (implies
  (cst-matchp abnf::cst "requires-modifier")
  (cst-list-list-alt-matchp (abnf::tree-nonleaf->branches abnf::cst)
                            "%s\"transitive\" / %s\"static\"")))

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

(defthm cst-class-declaration-branches-match-alt
 (implies
  (cst-matchp abnf::cst "class-declaration")
  (cst-list-list-alt-matchp
   (abnf::tree-nonleaf->branches abnf::cst)
   "normal-class-declaration / enum-declaration / record-declaration")))

Theorem: cst-normal-class-declaration-branches-match-alt

(defthm cst-normal-class-declaration-branches-match-alt
 (implies
  (cst-matchp abnf::cst "normal-class-declaration")
  (cst-list-list-alt-matchp
   (abnf::tree-nonleaf->branches abnf::cst)
   "*class-modifier %s\"class\" type-identifier [ type-parameters ] [ class-extends ] [ class-implements ] [ class-permits ] class-body")))

Theorem: cst-class-modifier-branches-match-alt

(defthm cst-class-modifier-branches-match-alt
 (implies
  (cst-matchp abnf::cst "class-modifier")
  (cst-list-list-alt-matchp
   (abnf::tree-nonleaf->branches abnf::cst)
   "annotation / %s\"public\" / %s\"protected\" / %s\"private\" / %s\"abstract\" / %s\"static\" / %s\"final\" / %s\"sealed\" / %s\"non-sealed\" / %s\"strictfp\"")))

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

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

Theorem: cst-type-parameter-list-branches-match-alt

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

Theorem: cst-class-extends-branches-match-alt

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

Theorem: cst-class-implements-branches-match-alt

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

Theorem: cst-interface-type-list-branches-match-alt

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

Theorem: cst-class-permits-branches-match-alt

(defthm cst-class-permits-branches-match-alt
  (implies (cst-matchp abnf::cst "class-permits")
           (cst-list-list-alt-matchp
                (abnf::tree-nonleaf->branches abnf::cst)
                "%s\"permits\" type-name *( \",\" type-name )")))

Theorem: cst-class-body-branches-match-alt

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

Theorem: cst-class-body-declaration-branches-match-alt

(defthm cst-class-body-declaration-branches-match-alt
 (implies
  (cst-matchp abnf::cst "class-body-declaration")
  (cst-list-list-alt-matchp
   (abnf::tree-nonleaf->branches abnf::cst)
   "class-member-declaration / instance-initializer / static-initializer / constructor-declaration")))

Theorem: cst-class-member-declaration-branches-match-alt

(defthm cst-class-member-declaration-branches-match-alt
 (implies
  (cst-matchp abnf::cst "class-member-declaration")
  (cst-list-list-alt-matchp
   (abnf::tree-nonleaf->branches abnf::cst)
   "field-declaration / method-declaration / class-declaration / interface-declaration / \";\"")))

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

(defthm cst-field-declaration-branches-match-alt
 (implies
   (cst-matchp abnf::cst "field-declaration")
   (cst-list-list-alt-matchp
        (abnf::tree-nonleaf->branches abnf::cst)
        "*field-modifier unann-type variable-declarator-list \";\"")))

Theorem: cst-variable-declarator-list-branches-match-alt

(defthm cst-variable-declarator-list-branches-match-alt
 (implies (cst-matchp abnf::cst "variable-declarator-list")
          (cst-list-list-alt-matchp
               (abnf::tree-nonleaf->branches abnf::cst)
               "variable-declarator *( \",\" variable-declarator )")))

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

(defthm cst-variable-declarator-branches-match-alt
  (implies
       (cst-matchp abnf::cst "variable-declarator")
       (cst-list-list-alt-matchp
            (abnf::tree-nonleaf->branches abnf::cst)
            "variable-declarator-id [ \"=\" variable-initializer ]")))

Theorem: cst-variable-declarator-id-branches-match-alt

(defthm cst-variable-declarator-id-branches-match-alt
 (implies
  (cst-matchp abnf::cst "variable-declarator-id")
  (cst-list-list-alt-matchp (abnf::tree-nonleaf->branches abnf::cst)
                            "identifier [ dims ] / \"_\"")))

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

(defthm cst-variable-initializer-branches-match-alt
 (implies
  (cst-matchp abnf::cst "variable-initializer")
  (cst-list-list-alt-matchp (abnf::tree-nonleaf->branches abnf::cst)
                            "expression / array-initializer")))

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

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

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

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

Theorem: cst-unann-reference-type-branches-match-alt

(defthm cst-unann-reference-type-branches-match-alt
 (implies
  (cst-matchp abnf::cst "unann-reference-type")
  (cst-list-list-alt-matchp
   (abnf::tree-nonleaf->branches abnf::cst)
   "unann-class-or-interface-type / unann-type-variable / unann-array-type")))

Theorem: cst-unann-class-or-interface-type-branches-match-alt

(defthm cst-unann-class-or-interface-type-branches-match-alt
  (implies (cst-matchp abnf::cst
                       "unann-class-or-interface-type")
           (cst-list-list-alt-matchp
                (abnf::tree-nonleaf->branches abnf::cst)
                "unann-class-type / unann-interface-type")))

Theorem: cst-unann-class-type-branches-match-alt

(defthm cst-unann-class-type-branches-match-alt
 (implies
  (cst-matchp abnf::cst "unann-class-type")
  (cst-list-list-alt-matchp
   (abnf::tree-nonleaf->branches abnf::cst)
   "type-identifier [ type-arguments ] / package-name \".\" *annotation type-identifier [ type-arguments ] / unann-class-or-interface-type \".\" *annotation type-identifier [ type-arguments ]")))

Theorem: cst-unann-interface-type-branches-match-alt

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

Theorem: cst-unann-type-variable-branches-match-alt

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

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

(defthm cst-unann-array-type-branches-match-alt
 (implies
  (cst-matchp abnf::cst "unann-array-type")
  (cst-list-list-alt-matchp
   (abnf::tree-nonleaf->branches abnf::cst)
   "unann-primitive-type dims / unann-class-or-interface-type dims / unann-type-variable dims")))

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

(defthm cst-field-modifier-branches-match-alt
 (implies
  (cst-matchp abnf::cst "field-modifier")
  (cst-list-list-alt-matchp
   (abnf::tree-nonleaf->branches abnf::cst)
   "annotation / %s\"public\" / %s\"protected\" / %s\"private\" / %s\"static\" / %s\"final\" / %s\"transient\" / %s\"volatile\"")))

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

(defthm cst-method-declaration-branches-match-alt
  (implies (cst-matchp abnf::cst "method-declaration")
           (cst-list-list-alt-matchp
                (abnf::tree-nonleaf->branches abnf::cst)
                "*method-modifier method-header method-body")))

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

(defthm cst-method-header-branches-match-alt
 (implies
  (cst-matchp abnf::cst "method-header")
  (cst-list-list-alt-matchp
   (abnf::tree-nonleaf->branches abnf::cst)
   "result method-declarator [ throws ] / type-parameters *annotation result method-declarator [ throws ]")))

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

(defthm cst-method-declarator-branches-match-alt
 (implies
  (cst-matchp abnf::cst "method-declarator")
  (cst-list-list-alt-matchp
   (abnf::tree-nonleaf->branches abnf::cst)
   "identifier \"(\" [ receiver-parameter \",\" ] [ formal-parameter-list ] \")\" [ dims ]")))

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

(defthm cst-receiver-parameter-branches-match-alt
  (implies
       (cst-matchp abnf::cst "receiver-parameter")
       (cst-list-list-alt-matchp
            (abnf::tree-nonleaf->branches abnf::cst)
            "*annotation unann-type [ identifier \".\" ] %s\"this\"")))

Theorem: cst-formal-parameter-list-branches-match-alt

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

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

(defthm cst-formal-parameter-branches-match-alt
 (implies
  (cst-matchp abnf::cst "formal-parameter")
  (cst-list-list-alt-matchp
   (abnf::tree-nonleaf->branches abnf::cst)
   "*variable-modifier unann-type variable-declarator-id / variable-arity-parameter")))

Theorem: cst-variable-arity-parameter-branches-match-alt

(defthm cst-variable-arity-parameter-branches-match-alt
 (implies
  (cst-matchp abnf::cst "variable-arity-parameter")
  (cst-list-list-alt-matchp
     (abnf::tree-nonleaf->branches abnf::cst)
     "*variable-modifier unann-type *annotation \"...\" identifier")))

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

(defthm cst-variable-modifier-branches-match-alt
 (implies
  (cst-matchp abnf::cst "variable-modifier")
  (cst-list-list-alt-matchp (abnf::tree-nonleaf->branches abnf::cst)
                            "annotation / %s\"final\"")))

Theorem: cst-method-modifier-branches-match-alt

(defthm cst-method-modifier-branches-match-alt
 (implies
  (cst-matchp abnf::cst "method-modifier")
  (cst-list-list-alt-matchp
   (abnf::tree-nonleaf->branches abnf::cst)
   "annotation / %s\"public\" / %s\"protected\" / %s\"private\" / %s\"abstract\" / %s\"static\" / %s\"final\" / %s\"synchronized\" / %s\"native\" / %s\"strictfp\"")))

Theorem: cst-result-branches-match-alt

(defthm cst-result-branches-match-alt
 (implies
  (cst-matchp abnf::cst "result")
  (cst-list-list-alt-matchp (abnf::tree-nonleaf->branches abnf::cst)
                            "unann-type / %s\"void\"")))

Theorem: cst-throws-branches-match-alt

(defthm cst-throws-branches-match-alt
 (implies
  (cst-matchp abnf::cst "throws")
  (cst-list-list-alt-matchp (abnf::tree-nonleaf->branches abnf::cst)
                            "%s\"throws\" exception-type-list")))

Theorem: cst-exception-type-list-branches-match-alt

(defthm cst-exception-type-list-branches-match-alt
  (implies (cst-matchp abnf::cst "exception-type-list")
           (cst-list-list-alt-matchp
                (abnf::tree-nonleaf->branches abnf::cst)
                "exception-type *( \",\" exception-type )")))

Theorem: cst-exception-type-branches-match-alt

(defthm cst-exception-type-branches-match-alt
 (implies
  (cst-matchp abnf::cst "exception-type")
  (cst-list-list-alt-matchp (abnf::tree-nonleaf->branches abnf::cst)
                            "class-type / type-variable")))

Theorem: cst-method-body-branches-match-alt

(defthm cst-method-body-branches-match-alt
 (implies
  (cst-matchp abnf::cst "method-body")
  (cst-list-list-alt-matchp (abnf::tree-nonleaf->branches abnf::cst)
                            "block / \";\"")))

Theorem: cst-instance-initializer-branches-match-alt

(defthm cst-instance-initializer-branches-match-alt
 (implies
  (cst-matchp abnf::cst "instance-initializer")
  (cst-list-list-alt-matchp (abnf::tree-nonleaf->branches abnf::cst)
                            "block")))

Theorem: cst-static-initializer-branches-match-alt

(defthm cst-static-initializer-branches-match-alt
 (implies
  (cst-matchp abnf::cst "static-initializer")
  (cst-list-list-alt-matchp (abnf::tree-nonleaf->branches abnf::cst)
                            "%s\"static\" block")))

Theorem: cst-constructor-declaration-branches-match-alt

(defthm cst-constructor-declaration-branches-match-alt
 (implies
  (cst-matchp abnf::cst "constructor-declaration")
  (cst-list-list-alt-matchp
   (abnf::tree-nonleaf->branches abnf::cst)
   "*constructor-modifier constructor-declarator [ throws ] constructor-body")))

Theorem: cst-constructor-declarator-branches-match-alt

(defthm cst-constructor-declarator-branches-match-alt
 (implies
  (cst-matchp abnf::cst "constructor-declarator")
  (cst-list-list-alt-matchp
   (abnf::tree-nonleaf->branches abnf::cst)
   "[ type-parameters ] simple-type-name \"(\" [ receiver-parameter \",\" ] [ formal-parameter-list ] \")\"")))

Theorem: cst-simple-type-name-branches-match-alt

(defthm cst-simple-type-name-branches-match-alt
 (implies
  (cst-matchp abnf::cst "simple-type-name")
  (cst-list-list-alt-matchp (abnf::tree-nonleaf->branches abnf::cst)
                            "type-identifier")))

Theorem: cst-constructor-modifier-branches-match-alt

(defthm cst-constructor-modifier-branches-match-alt
 (implies
     (cst-matchp abnf::cst "constructor-modifier")
     (cst-list-list-alt-matchp
          (abnf::tree-nonleaf->branches abnf::cst)
          "annotation / %s\"public\" / %s\"protected\" / %s\"private\"")))

Theorem: cst-constructor-body-branches-match-alt

(defthm cst-constructor-body-branches-match-alt
 (implies
  (cst-matchp abnf::cst "constructor-body")
  (cst-list-list-alt-matchp
   (abnf::tree-nonleaf->branches abnf::cst)
   "\"{\" [ block-statements ] constructor-invocation [ block-statements ] \"}\" / \"{\" [ block-statements ] \"}\"")))

Theorem: cst-constructor-invocation-branches-match-alt

(defthm cst-constructor-invocation-branches-match-alt
 (implies
  (cst-matchp abnf::cst "constructor-invocation")
  (cst-list-list-alt-matchp
   (abnf::tree-nonleaf->branches abnf::cst)
   "[ type-arguments ] %s\"this\" \"(\" [ argument-list ] \")\" \";\" / [ type-arguments ] %s\"super\" \"(\" [ argument-list ] \")\" \";\" / expression-name \".\" [ type-arguments ] %s\"super\" \"(\" [ argument-list ] \")\" \";\" / primary \".\" [ type-arguments ] %s\"super\" \"(\" [ argument-list ] \")\" \";\"")))

Theorem: cst-enum-declaration-branches-match-alt

(defthm cst-enum-declaration-branches-match-alt
 (implies
  (cst-matchp abnf::cst "enum-declaration")
  (cst-list-list-alt-matchp
   (abnf::tree-nonleaf->branches abnf::cst)
   "*class-modifier %s\"enum\" type-identifier [ class-implements ] enum-body")))

Theorem: cst-enum-body-branches-match-alt

(defthm cst-enum-body-branches-match-alt
 (implies
  (cst-matchp abnf::cst "enum-body")
  (cst-list-list-alt-matchp
   (abnf::tree-nonleaf->branches abnf::cst)
   "\"{\" [ enum-constant-list ] [ \",\" ] [ enum-body-declarations ] \"}\"")))

Theorem: cst-enum-constant-list-branches-match-alt

(defthm cst-enum-constant-list-branches-match-alt
  (implies (cst-matchp abnf::cst "enum-constant-list")
           (cst-list-list-alt-matchp
                (abnf::tree-nonleaf->branches abnf::cst)
                "enum-constant *( \",\" enum-constant )")))

Theorem: cst-enum-constant-branches-match-alt

(defthm cst-enum-constant-branches-match-alt
 (implies
  (cst-matchp abnf::cst "enum-constant")
  (cst-list-list-alt-matchp
   (abnf::tree-nonleaf->branches abnf::cst)
   "*enum-constant-modifier identifier [ \"(\" [ argument-list ] \")\" ] [ class-body ]")))

Theorem: cst-enum-constant-modifier-branches-match-alt

(defthm cst-enum-constant-modifier-branches-match-alt
 (implies
  (cst-matchp abnf::cst "enum-constant-modifier")
  (cst-list-list-alt-matchp (abnf::tree-nonleaf->branches abnf::cst)
                            "annotation")))

Theorem: cst-enum-body-declarations-branches-match-alt

(defthm cst-enum-body-declarations-branches-match-alt
 (implies
  (cst-matchp abnf::cst "enum-body-declarations")
  (cst-list-list-alt-matchp (abnf::tree-nonleaf->branches abnf::cst)
                            "\";\" *class-body-declaration")))

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)
   "*class-modifier %s\"record\" type-identifier [ type-parameters ] record-header [ class-implements ] record-body")))

Theorem: cst-record-header-branches-match-alt

(defthm cst-record-header-branches-match-alt
 (implies
  (cst-matchp abnf::cst "record-header")
  (cst-list-list-alt-matchp (abnf::tree-nonleaf->branches abnf::cst)
                            "\"(\" record-component-list \")\"")))

Theorem: cst-record-component-list-branches-match-alt

(defthm cst-record-component-list-branches-match-alt
  (implies (cst-matchp abnf::cst "record-component-list")
           (cst-list-list-alt-matchp
                (abnf::tree-nonleaf->branches abnf::cst)
                "record-component *( \",\" record-component )")))

Theorem: cst-record-component-branches-match-alt

(defthm cst-record-component-branches-match-alt
 (implies
  (cst-matchp abnf::cst "record-component")
  (cst-list-list-alt-matchp
   (abnf::tree-nonleaf->branches abnf::cst)
   "*record-component-modifier unann-type identifier / variable-arity-record-component")))

Theorem: cst-variable-arity-record-component-branches-match-alt

(defthm cst-variable-arity-record-component-branches-match-alt
 (implies
  (cst-matchp abnf::cst
              "variable-arity-record-component")
  (cst-list-list-alt-matchp
   (abnf::tree-nonleaf->branches abnf::cst)
   "*record-component-modifier unann-type *annotation \"...\" identifier")))

Theorem: cst-record-component-modifier-branches-match-alt

(defthm cst-record-component-modifier-branches-match-alt
 (implies
  (cst-matchp abnf::cst "record-component-modifier")
  (cst-list-list-alt-matchp (abnf::tree-nonleaf->branches abnf::cst)
                            "annotation")))

Theorem: cst-record-body-branches-match-alt

(defthm cst-record-body-branches-match-alt
 (implies
  (cst-matchp abnf::cst "record-body")
  (cst-list-list-alt-matchp (abnf::tree-nonleaf->branches abnf::cst)
                            "\"{\" *record-body-declaration \"}\"")))

Theorem: cst-record-body-declaration-branches-match-alt

(defthm cst-record-body-declaration-branches-match-alt
 (implies
  (cst-matchp abnf::cst "record-body-declaration")
  (cst-list-list-alt-matchp
       (abnf::tree-nonleaf->branches abnf::cst)
       "class-body-declaration / compact-constructor-declaration")))

Theorem: cst-compact-constructor-declaration-branches-match-alt

(defthm cst-compact-constructor-declaration-branches-match-alt
 (implies
   (cst-matchp abnf::cst
               "compact-constructor-declaration")
   (cst-list-list-alt-matchp
        (abnf::tree-nonleaf->branches abnf::cst)
        "*constructor-modifier simple-type-name constructor-body")))

Theorem: cst-interface-declaration-branches-match-alt

(defthm cst-interface-declaration-branches-match-alt
 (implies
  (cst-matchp abnf::cst "interface-declaration")
  (cst-list-list-alt-matchp
   (abnf::tree-nonleaf->branches abnf::cst)
   "normal-interface-declaration / annotation-interface-declaration")))

Theorem: cst-normal-interface-declaration-branches-match-alt

(defthm cst-normal-interface-declaration-branches-match-alt
 (implies
  (cst-matchp abnf::cst
              "normal-interface-declaration")
  (cst-list-list-alt-matchp
   (abnf::tree-nonleaf->branches abnf::cst)
   "*interface-modifier %s\"interface\" type-identifier [ type-parameters ] [ interface-extends ] [ interface-permits ] interface-body")))

Theorem: cst-interface-modifier-branches-match-alt

(defthm cst-interface-modifier-branches-match-alt
 (implies
  (cst-matchp abnf::cst "interface-modifier")
  (cst-list-list-alt-matchp
   (abnf::tree-nonleaf->branches abnf::cst)
   "annotation / %s\"public\" / %s\"protected\" / %s\"private\" / %s\"abstract\" / %s\"static\" / %s\"sealed\" / %s\"non-sealed\" / %s\"strictfp\"")))

Theorem: cst-interface-extends-branches-match-alt

(defthm cst-interface-extends-branches-match-alt
 (implies
  (cst-matchp abnf::cst "interface-extends")
  (cst-list-list-alt-matchp (abnf::tree-nonleaf->branches abnf::cst)
                            "%s\"extends\" interface-type-list")))

Theorem: cst-interface-permits-branches-match-alt

(defthm cst-interface-permits-branches-match-alt
  (implies (cst-matchp abnf::cst "interface-permits")
           (cst-list-list-alt-matchp
                (abnf::tree-nonleaf->branches abnf::cst)
                "%s\"permits\" type-name *( \",\" type-name )")))

Theorem: cst-interface-body-branches-match-alt

(defthm cst-interface-body-branches-match-alt
  (implies (cst-matchp abnf::cst "interface-body")
           (cst-list-list-alt-matchp
                (abnf::tree-nonleaf->branches abnf::cst)
                "\"{\" *interface-member-declaration \"}\"")))

Theorem: cst-interface-member-declaration-branches-match-alt

(defthm cst-interface-member-declaration-branches-match-alt
 (implies
  (cst-matchp abnf::cst
              "interface-member-declaration")
  (cst-list-list-alt-matchp
   (abnf::tree-nonleaf->branches abnf::cst)
   "constant-declaration / interface-method-declaration / class-declaration / interface-declaration / \";\"")))

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)
     "*constant-modifier unann-type variable-declarator-list \";\"")))

Theorem: cst-constant-modifier-branches-match-alt

(defthm cst-constant-modifier-branches-match-alt
 (implies (cst-matchp abnf::cst "constant-modifier")
          (cst-list-list-alt-matchp
               (abnf::tree-nonleaf->branches abnf::cst)
               "annotation / %s\"public\" / %s\"static\" / %s\"final\"")))

Theorem: cst-interface-method-declaration-branches-match-alt

(defthm cst-interface-method-declaration-branches-match-alt
 (implies
      (cst-matchp abnf::cst
                  "interface-method-declaration")
      (cst-list-list-alt-matchp
           (abnf::tree-nonleaf->branches abnf::cst)
           "*interface-method-modifier method-header method-body")))

Theorem: cst-interface-method-modifier-branches-match-alt

(defthm cst-interface-method-modifier-branches-match-alt
 (implies
  (cst-matchp abnf::cst "interface-method-modifier")
  (cst-list-list-alt-matchp
   (abnf::tree-nonleaf->branches abnf::cst)
   "annotation / %s\"public\" / %s\"private\" / %s\"abstract\" / %s\"default\" / %s\"static\" / %s\"strictfp\"")))

Theorem: cst-annotation-interface-declaration-branches-match-alt

(defthm cst-annotation-interface-declaration-branches-match-alt
 (implies
  (cst-matchp abnf::cst
              "annotation-interface-declaration")
  (cst-list-list-alt-matchp
   (abnf::tree-nonleaf->branches abnf::cst)
   "*interface-modifier \"@\" %s\"interface\" type-identifier annotation-interface-body")))

Theorem: cst-annotation-interface-body-branches-match-alt

(defthm cst-annotation-interface-body-branches-match-alt
 (implies (cst-matchp abnf::cst "annotation-interface-body")
          (cst-list-list-alt-matchp
               (abnf::tree-nonleaf->branches abnf::cst)
               "\"{\" *annotation-interface-member-declaration \"}\"")))

Theorem: cst-annotation-interface-member-declaration-branches-match-alt

(defthm
     cst-annotation-interface-member-declaration-branches-match-alt
 (implies
  (cst-matchp abnf::cst
              "annotation-interface-member-declaration")
  (cst-list-list-alt-matchp
   (abnf::tree-nonleaf->branches abnf::cst)
   "annotation-interface-element-declaration / constant-declaration / class-declaration / interface-declaration / \";\"")))

Theorem: cst-annotation-interface-element-declaration-branches-match-alt

(defthm
    cst-annotation-interface-element-declaration-branches-match-alt
 (implies
  (cst-matchp abnf::cst
              "annotation-interface-element-declaration")
  (cst-list-list-alt-matchp
   (abnf::tree-nonleaf->branches abnf::cst)
   "*annotation-interface-element-modifier unann-type identifier \"(\" \")\" [ dims ] [ default-value ] \";\"")))

Theorem: cst-annotation-interface-element-modifier-branches-match-alt

(defthm cst-annotation-interface-element-modifier-branches-match-alt
  (implies (cst-matchp abnf::cst
                       "annotation-interface-element-modifier")
           (cst-list-list-alt-matchp
                (abnf::tree-nonleaf->branches abnf::cst)
                "annotation / %s\"public\" / %s\"abstract\"")))

Theorem: cst-default-value-branches-match-alt

(defthm cst-default-value-branches-match-alt
 (implies
  (cst-matchp abnf::cst "default-value")
  (cst-list-list-alt-matchp (abnf::tree-nonleaf->branches abnf::cst)
                            "%s\"default\" element-value")))

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)
   "normal-annotation / marker-annotation / single-element-annotation")))

Theorem: cst-normal-annotation-branches-match-alt

(defthm cst-normal-annotation-branches-match-alt
  (implies
       (cst-matchp abnf::cst "normal-annotation")
       (cst-list-list-alt-matchp
            (abnf::tree-nonleaf->branches abnf::cst)
            "\"@\" type-name \"(\" [ element-value-pair-list ] \")\"")))

Theorem: cst-element-value-pair-list-branches-match-alt

(defthm cst-element-value-pair-list-branches-match-alt
  (implies (cst-matchp abnf::cst "element-value-pair-list")
           (cst-list-list-alt-matchp
                (abnf::tree-nonleaf->branches abnf::cst)
                "element-value-pair *( \",\" element-value-pair )")))

Theorem: cst-element-value-pair-branches-match-alt

(defthm cst-element-value-pair-branches-match-alt
 (implies
  (cst-matchp abnf::cst "element-value-pair")
  (cst-list-list-alt-matchp (abnf::tree-nonleaf->branches abnf::cst)
                            "identifier \"=\" element-value")))

Theorem: cst-element-value-branches-match-alt

(defthm cst-element-value-branches-match-alt
 (implies
  (cst-matchp abnf::cst "element-value")
  (cst-list-list-alt-matchp
   (abnf::tree-nonleaf->branches abnf::cst)
   "conditional-expression / element-value-array-initializer / annotation")))

Theorem: cst-element-value-array-initializer-branches-match-alt

(defthm cst-element-value-array-initializer-branches-match-alt
  (implies (cst-matchp abnf::cst
                       "element-value-array-initializer")
           (cst-list-list-alt-matchp
                (abnf::tree-nonleaf->branches abnf::cst)
                "\"{\" [ element-value-list ] [ \",\" ] \"}\"")))

Theorem: cst-element-value-list-branches-match-alt

(defthm cst-element-value-list-branches-match-alt
  (implies (cst-matchp abnf::cst "element-value-list")
           (cst-list-list-alt-matchp
                (abnf::tree-nonleaf->branches abnf::cst)
                "element-value *( \",\" element-value )")))

Theorem: cst-marker-annotation-branches-match-alt

(defthm cst-marker-annotation-branches-match-alt
 (implies
  (cst-matchp abnf::cst "marker-annotation")
  (cst-list-list-alt-matchp (abnf::tree-nonleaf->branches abnf::cst)
                            "\"@\" type-name")))

Theorem: cst-single-element-annotation-branches-match-alt

(defthm cst-single-element-annotation-branches-match-alt
 (implies
  (cst-matchp abnf::cst "single-element-annotation")
  (cst-list-list-alt-matchp (abnf::tree-nonleaf->branches abnf::cst)
                            "\"@\" type-name \"(\" element-value \")\"")))

Theorem: cst-array-initializer-branches-match-alt

(defthm cst-array-initializer-branches-match-alt
  (implies (cst-matchp abnf::cst "array-initializer")
           (cst-list-list-alt-matchp
                (abnf::tree-nonleaf->branches abnf::cst)
                "\"{\" [ variable-initializer-list ] [ \",\" ] \"}\"")))

Theorem: cst-variable-initializer-list-branches-match-alt

(defthm cst-variable-initializer-list-branches-match-alt
  (implies
       (cst-matchp abnf::cst "variable-initializer-list")
       (cst-list-list-alt-matchp
            (abnf::tree-nonleaf->branches abnf::cst)
            "variable-initializer *( \",\" variable-initializer )")))

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)
                            "\"{\" [ block-statements ] \"}\"")))

Theorem: cst-block-statements-branches-match-alt

(defthm cst-block-statements-branches-match-alt
 (implies
  (cst-matchp abnf::cst "block-statements")
  (cst-list-list-alt-matchp (abnf::tree-nonleaf->branches abnf::cst)
                            "1*block-statement")))

Theorem: cst-block-statement-branches-match-alt

(defthm cst-block-statement-branches-match-alt
 (implies
  (cst-matchp abnf::cst "block-statement")
  (cst-list-list-alt-matchp
   (abnf::tree-nonleaf->branches abnf::cst)
   "local-class-or-interface-declaration / local-variable-declaration-statement / statement")))

Theorem: cst-local-class-or-interface-declaration-branches-match-alt

(defthm cst-local-class-or-interface-declaration-branches-match-alt
 (implies (cst-matchp abnf::cst
                      "local-class-or-interface-declaration")
          (cst-list-list-alt-matchp
               (abnf::tree-nonleaf->branches abnf::cst)
               "class-declaration / normal-interface-declaration")))

Theorem: cst-local-variable-declaration-branches-match-alt

(defthm cst-local-variable-declaration-branches-match-alt
 (implies
  (cst-matchp abnf::cst "local-variable-declaration")
  (cst-list-list-alt-matchp
   (abnf::tree-nonleaf->branches abnf::cst)
   "*variable-modifier local-variable-type variable-declarator-list")))

Theorem: cst-local-variable-type-branches-match-alt

(defthm cst-local-variable-type-branches-match-alt
 (implies
  (cst-matchp abnf::cst "local-variable-type")
  (cst-list-list-alt-matchp (abnf::tree-nonleaf->branches abnf::cst)
                            "unann-type / %s\"var\"")))

Theorem: cst-local-variable-declaration-statement-branches-match-alt

(defthm cst-local-variable-declaration-statement-branches-match-alt
 (implies
  (cst-matchp abnf::cst
              "local-variable-declaration-statement")
  (cst-list-list-alt-matchp (abnf::tree-nonleaf->branches abnf::cst)
                            "local-variable-declaration \";\"")))

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)
   "statement-without-trailing-substatement / labeled-statement / if-then-statement / if-then-else-statement / while-statement / for-statement")))

Theorem: cst-statement-no-short-if-branches-match-alt

(defthm cst-statement-no-short-if-branches-match-alt
 (implies
  (cst-matchp abnf::cst "statement-no-short-if")
  (cst-list-list-alt-matchp
   (abnf::tree-nonleaf->branches abnf::cst)
   "statement-without-trailing-substatement / labeled-statement-no-short-if / if-then-else-statement-no-short-if / while-statement-no-short-if / for-statement-no-short-if")))

Theorem: cst-statement-without-trailing-substatement-branches-match-alt

(defthm
     cst-statement-without-trailing-substatement-branches-match-alt
 (implies
  (cst-matchp abnf::cst
              "statement-without-trailing-substatement")
  (cst-list-list-alt-matchp
   (abnf::tree-nonleaf->branches abnf::cst)
   "block / empty-statement / expression-statement / assert-statement / switch-statement / do-statement / break-statement / continue-statement / return-statement / synchronized-statement / throw-statement / try-statement / yield-statement")))

Theorem: cst-empty-statement-branches-match-alt

(defthm cst-empty-statement-branches-match-alt
 (implies
  (cst-matchp abnf::cst "empty-statement")
  (cst-list-list-alt-matchp (abnf::tree-nonleaf->branches abnf::cst)
                            "\";\"")))

Theorem: cst-labeled-statement-branches-match-alt

(defthm cst-labeled-statement-branches-match-alt
 (implies
  (cst-matchp abnf::cst "labeled-statement")
  (cst-list-list-alt-matchp (abnf::tree-nonleaf->branches abnf::cst)
                            "identifier \":\" statement")))

Theorem: cst-labeled-statement-no-short-if-branches-match-alt

(defthm cst-labeled-statement-no-short-if-branches-match-alt
  (implies (cst-matchp abnf::cst
                       "labeled-statement-no-short-if")
           (cst-list-list-alt-matchp
                (abnf::tree-nonleaf->branches abnf::cst)
                "identifier \":\" statement-no-short-if")))

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)
                            "statement-expression \";\"")))

Theorem: cst-statement-expression-branches-match-alt

(defthm cst-statement-expression-branches-match-alt
 (implies
  (cst-matchp abnf::cst "statement-expression")
  (cst-list-list-alt-matchp
   (abnf::tree-nonleaf->branches abnf::cst)
   "assignment / pre-increment-expression / pre-decrement-expression / post-increment-expression / post-decrement-expression / method-invocation / class-instance-creation-expression")))

Theorem: cst-if-then-statement-branches-match-alt

(defthm cst-if-then-statement-branches-match-alt
 (implies
  (cst-matchp abnf::cst "if-then-statement")
  (cst-list-list-alt-matchp (abnf::tree-nonleaf->branches abnf::cst)
                            "%s\"if\" \"(\" expression \")\" statement")))

Theorem: cst-if-then-else-statement-branches-match-alt

(defthm cst-if-then-else-statement-branches-match-alt
 (implies
  (cst-matchp abnf::cst "if-then-else-statement")
  (cst-list-list-alt-matchp
   (abnf::tree-nonleaf->branches abnf::cst)
   "%s\"if\" \"(\" expression \")\" statement-no-short-if %s\"else\" statement")))

Theorem: cst-if-then-else-statement-no-short-if-branches-match-alt

(defthm cst-if-then-else-statement-no-short-if-branches-match-alt
 (implies
  (cst-matchp abnf::cst
              "if-then-else-statement-no-short-if")
  (cst-list-list-alt-matchp
   (abnf::tree-nonleaf->branches abnf::cst)
   "%s\"if\" \"(\" expression \")\" statement-no-short-if %s\"else\" statement-no-short-if")))

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\" expression \":\" expression \";\"")))

Theorem: cst-switch-statement-branches-match-alt

(defthm cst-switch-statement-branches-match-alt
  (implies (cst-matchp abnf::cst "switch-statement")
           (cst-list-list-alt-matchp
                (abnf::tree-nonleaf->branches abnf::cst)
                "%s\"switch\" \"(\" expression \")\" switch-block")))

Theorem: cst-switch-block-branches-match-alt

(defthm cst-switch-block-branches-match-alt
 (implies
  (cst-matchp abnf::cst "switch-block")
  (cst-list-list-alt-matchp
   (abnf::tree-nonleaf->branches abnf::cst)
   "\"{\" 1*switch-rule \"}\" / \"{\" *switch-block-statement-group *( switch-label \":\" ) \"}\"")))

Theorem: cst-switch-rule-branches-match-alt

(defthm cst-switch-rule-branches-match-alt
 (implies
  (cst-matchp abnf::cst "switch-rule")
  (cst-list-list-alt-matchp
   (abnf::tree-nonleaf->branches abnf::cst)
   "switch-label \"->\" expression \";\" / switch-label \"->\" block / switch-label \"->\" throw-statement")))

Theorem: cst-switch-block-statement-group-branches-match-alt

(defthm cst-switch-block-statement-group-branches-match-alt
 (implies
   (cst-matchp abnf::cst
               "switch-block-statement-group")
   (cst-list-list-alt-matchp
        (abnf::tree-nonleaf->branches abnf::cst)
        "switch-label \":\" *( switch-label \":\" ) block-statements")))

Theorem: cst-switch-label-branches-match-alt

(defthm cst-switch-label-branches-match-alt
 (implies
  (cst-matchp abnf::cst "switch-label")
  (cst-list-list-alt-matchp
   (abnf::tree-nonleaf->branches abnf::cst)
   "%s\"case\" case-constant *( \",\" case-constant ) / %s\"case\" %s\"null\" [ \",\" %s\"default\" ] / %s\"case\" case-pattern *( \",\" case-pattern ) [ guard ] / %s\"default\"")))

Theorem: cst-case-constant-branches-match-alt

(defthm cst-case-constant-branches-match-alt
 (implies
  (cst-matchp abnf::cst "case-constant")
  (cst-list-list-alt-matchp (abnf::tree-nonleaf->branches abnf::cst)
                            "conditional-expression")))

Theorem: cst-case-pattern-branches-match-alt

(defthm cst-case-pattern-branches-match-alt
 (implies
  (cst-matchp abnf::cst "case-pattern")
  (cst-list-list-alt-matchp (abnf::tree-nonleaf->branches abnf::cst)
                            "pattern")))

Theorem: cst-guard-branches-match-alt

(defthm cst-guard-branches-match-alt
 (implies
  (cst-matchp abnf::cst "guard")
  (cst-list-list-alt-matchp (abnf::tree-nonleaf->branches abnf::cst)
                            "%s\"when\" expression")))

Theorem: cst-while-statement-branches-match-alt

(defthm cst-while-statement-branches-match-alt
  (implies (cst-matchp abnf::cst "while-statement")
           (cst-list-list-alt-matchp
                (abnf::tree-nonleaf->branches abnf::cst)
                "%s\"while\" \"(\" expression \")\" statement")))

Theorem: cst-while-statement-no-short-if-branches-match-alt

(defthm cst-while-statement-no-short-if-branches-match-alt
  (implies
       (cst-matchp abnf::cst "while-statement-no-short-if")
       (cst-list-list-alt-matchp
            (abnf::tree-nonleaf->branches abnf::cst)
            "%s\"while\" \"(\" expression \")\" statement-no-short-if")))

Theorem: cst-do-statement-branches-match-alt

(defthm cst-do-statement-branches-match-alt
  (implies
       (cst-matchp abnf::cst "do-statement")
       (cst-list-list-alt-matchp
            (abnf::tree-nonleaf->branches abnf::cst)
            "%s\"do\" statement %s\"while\" \"(\" expression \")\" \";\"")))

Theorem: cst-for-statement-branches-match-alt

(defthm cst-for-statement-branches-match-alt
  (implies (cst-matchp abnf::cst "for-statement")
           (cst-list-list-alt-matchp
                (abnf::tree-nonleaf->branches abnf::cst)
                "basic-for-statement / enhanced-for-statement")))

Theorem: cst-for-statement-no-short-if-branches-match-alt

(defthm cst-for-statement-no-short-if-branches-match-alt
 (implies
  (cst-matchp abnf::cst "for-statement-no-short-if")
  (cst-list-list-alt-matchp
   (abnf::tree-nonleaf->branches abnf::cst)
   "basic-for-statement-no-short-if / enhanced-for-statement-no-short-if")))

Theorem: cst-basic-for-statement-branches-match-alt

(defthm cst-basic-for-statement-branches-match-alt
 (implies
  (cst-matchp abnf::cst "basic-for-statement")
  (cst-list-list-alt-matchp
   (abnf::tree-nonleaf->branches abnf::cst)
   "%s\"for\" \"(\" [ for-init ] \";\" [ expression ] \";\" [ for-update ] \")\" statement")))

Theorem: cst-basic-for-statement-no-short-if-branches-match-alt

(defthm cst-basic-for-statement-no-short-if-branches-match-alt
 (implies
  (cst-matchp abnf::cst
              "basic-for-statement-no-short-if")
  (cst-list-list-alt-matchp
   (abnf::tree-nonleaf->branches abnf::cst)
   "%s\"for\" \"(\" [ for-init ] \";\" [ expression ] \";\" [ for-update ] \")\" statement-no-short-if")))

Theorem: cst-for-init-branches-match-alt

(defthm cst-for-init-branches-match-alt
 (implies
    (cst-matchp abnf::cst "for-init")
    (cst-list-list-alt-matchp
         (abnf::tree-nonleaf->branches abnf::cst)
         "statement-expression-list / local-variable-declaration")))

Theorem: cst-for-update-branches-match-alt

(defthm cst-for-update-branches-match-alt
 (implies
  (cst-matchp abnf::cst "for-update")
  (cst-list-list-alt-matchp (abnf::tree-nonleaf->branches abnf::cst)
                            "statement-expression-list")))

Theorem: cst-statement-expression-list-branches-match-alt

(defthm cst-statement-expression-list-branches-match-alt
  (implies
       (cst-matchp abnf::cst "statement-expression-list")
       (cst-list-list-alt-matchp
            (abnf::tree-nonleaf->branches abnf::cst)
            "statement-expression *( \",\" statement-expression )")))

Theorem: cst-enhanced-for-statement-branches-match-alt

(defthm cst-enhanced-for-statement-branches-match-alt
 (implies
  (cst-matchp abnf::cst "enhanced-for-statement")
  (cst-list-list-alt-matchp
   (abnf::tree-nonleaf->branches abnf::cst)
   "%s\"for\" \"(\" local-variable-declaration \":\" expression \")\" statement")))

Theorem: cst-enhanced-for-statement-no-short-if-branches-match-alt

(defthm cst-enhanced-for-statement-no-short-if-branches-match-alt
 (implies
  (cst-matchp abnf::cst
              "enhanced-for-statement-no-short-if")
  (cst-list-list-alt-matchp
   (abnf::tree-nonleaf->branches abnf::cst)
   "%s\"for\" \"(\" local-variable-declaration \":\" expression \")\" statement-no-short-if")))

Theorem: cst-break-statement-branches-match-alt

(defthm cst-break-statement-branches-match-alt
 (implies
  (cst-matchp abnf::cst "break-statement")
  (cst-list-list-alt-matchp (abnf::tree-nonleaf->branches abnf::cst)
                            "%s\"break\" [ identifier ] \";\"")))

Theorem: cst-continue-statement-branches-match-alt

(defthm cst-continue-statement-branches-match-alt
 (implies
  (cst-matchp abnf::cst "continue-statement")
  (cst-list-list-alt-matchp (abnf::tree-nonleaf->branches abnf::cst)
                            "%s\"continue\" [ identifier ] \";\"")))

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-throw-statement-branches-match-alt

(defthm cst-throw-statement-branches-match-alt
 (implies
  (cst-matchp abnf::cst "throw-statement")
  (cst-list-list-alt-matchp (abnf::tree-nonleaf->branches abnf::cst)
                            "%s\"throw\" expression \";\"")))

Theorem: cst-synchronized-statement-branches-match-alt

(defthm cst-synchronized-statement-branches-match-alt
  (implies (cst-matchp abnf::cst "synchronized-statement")
           (cst-list-list-alt-matchp
                (abnf::tree-nonleaf->branches abnf::cst)
                "%s\"synchronized\" \"(\" expression \")\" block")))

Theorem: cst-try-statement-branches-match-alt

(defthm cst-try-statement-branches-match-alt
 (implies
  (cst-matchp abnf::cst "try-statement")
  (cst-list-list-alt-matchp
   (abnf::tree-nonleaf->branches abnf::cst)
   "%s\"try\" block catches / %s\"try\" block [ catches ] finally / try-with-resources-statement")))

Theorem: cst-catches-branches-match-alt

(defthm cst-catches-branches-match-alt
 (implies
  (cst-matchp abnf::cst "catches")
  (cst-list-list-alt-matchp (abnf::tree-nonleaf->branches abnf::cst)
                            "1*catch-clause")))

Theorem: cst-catch-clause-branches-match-alt

(defthm cst-catch-clause-branches-match-alt
  (implies (cst-matchp abnf::cst "catch-clause")
           (cst-list-list-alt-matchp
                (abnf::tree-nonleaf->branches abnf::cst)
                "%s\"catch\" \"(\" catch-formal-parameter \")\" block")))

Theorem: cst-catch-formal-parameter-branches-match-alt

(defthm cst-catch-formal-parameter-branches-match-alt
 (implies
      (cst-matchp abnf::cst "catch-formal-parameter")
      (cst-list-list-alt-matchp
           (abnf::tree-nonleaf->branches abnf::cst)
           "*variable-modifier catch-type variable-declarator-id")))

Theorem: cst-catch-type-branches-match-alt

(defthm cst-catch-type-branches-match-alt
  (implies (cst-matchp abnf::cst "catch-type")
           (cst-list-list-alt-matchp
                (abnf::tree-nonleaf->branches abnf::cst)
                "unann-class-type *( \"|\" class-type )")))

Theorem: cst-finally-branches-match-alt

(defthm cst-finally-branches-match-alt
 (implies
  (cst-matchp abnf::cst "finally")
  (cst-list-list-alt-matchp (abnf::tree-nonleaf->branches abnf::cst)
                            "%s\"finally\" block")))

Theorem: cst-try-with-resources-statement-branches-match-alt

(defthm cst-try-with-resources-statement-branches-match-alt
 (implies
  (cst-matchp abnf::cst
              "try-with-resources-statement")
  (cst-list-list-alt-matchp
   (abnf::tree-nonleaf->branches abnf::cst)
   "%s\"try\" resource-specification block [ catches ] [ finally ]")))

Theorem: cst-resource-specification-branches-match-alt

(defthm cst-resource-specification-branches-match-alt
 (implies
  (cst-matchp abnf::cst "resource-specification")
  (cst-list-list-alt-matchp (abnf::tree-nonleaf->branches abnf::cst)
                            "\"(\" resource-list [ \";\" ] \")\"")))

Theorem: cst-resource-list-branches-match-alt

(defthm cst-resource-list-branches-match-alt
 (implies
  (cst-matchp abnf::cst "resource-list")
  (cst-list-list-alt-matchp (abnf::tree-nonleaf->branches abnf::cst)
                            "resource *( \";\" resource )")))

Theorem: cst-resource-branches-match-alt

(defthm cst-resource-branches-match-alt
  (implies (cst-matchp abnf::cst "resource")
           (cst-list-list-alt-matchp
                (abnf::tree-nonleaf->branches abnf::cst)
                "local-variable-declaration / variable-access")))

Theorem: cst-variable-access-branches-match-alt

(defthm cst-variable-access-branches-match-alt
 (implies
  (cst-matchp abnf::cst "variable-access")
  (cst-list-list-alt-matchp (abnf::tree-nonleaf->branches abnf::cst)
                            "expression-name / field-access")))

Theorem: cst-yield-statement-branches-match-alt

(defthm cst-yield-statement-branches-match-alt
 (implies
  (cst-matchp abnf::cst "yield-statement")
  (cst-list-list-alt-matchp (abnf::tree-nonleaf->branches abnf::cst)
                            "%s\"yield\" expression \";\"")))

Theorem: cst-pattern-branches-match-alt

(defthm cst-pattern-branches-match-alt
 (implies
  (cst-matchp abnf::cst "pattern")
  (cst-list-list-alt-matchp (abnf::tree-nonleaf->branches abnf::cst)
                            "type-pattern / record-pattern")))

Theorem: cst-type-pattern-branches-match-alt

(defthm cst-type-pattern-branches-match-alt
 (implies
  (cst-matchp abnf::cst "type-pattern")
  (cst-list-list-alt-matchp (abnf::tree-nonleaf->branches abnf::cst)
                            "local-variable-declaration")))

Theorem: cst-record-pattern-branches-match-alt

(defthm cst-record-pattern-branches-match-alt
  (implies
       (cst-matchp abnf::cst "record-pattern")
       (cst-list-list-alt-matchp
            (abnf::tree-nonleaf->branches abnf::cst)
            "reference-type \"(\" [ component-pattern-list ] \")\"")))

Theorem: cst-component-pattern-list-branches-match-alt

(defthm cst-component-pattern-list-branches-match-alt
  (implies (cst-matchp abnf::cst "component-pattern-list")
           (cst-list-list-alt-matchp
                (abnf::tree-nonleaf->branches abnf::cst)
                "component-pattern *( \",\" component-pattern )")))

Theorem: cst-component-pattern-branches-match-alt

(defthm cst-component-pattern-branches-match-alt
 (implies
  (cst-matchp abnf::cst "component-pattern")
  (cst-list-list-alt-matchp (abnf::tree-nonleaf->branches abnf::cst)
                            "pattern / match-all-pattern")))

Theorem: cst-match-all-pattern-branches-match-alt

(defthm cst-match-all-pattern-branches-match-alt
 (implies
  (cst-matchp abnf::cst "match-all-pattern")
  (cst-list-list-alt-matchp (abnf::tree-nonleaf->branches abnf::cst)
                            "\"_\"")))

Theorem: cst-expression-branches-match-alt

(defthm cst-expression-branches-match-alt
  (implies (cst-matchp abnf::cst "expression")
           (cst-list-list-alt-matchp
                (abnf::tree-nonleaf->branches abnf::cst)
                "lambda-expression / assignment-expression")))

Theorem: cst-primary-branches-match-alt

(defthm cst-primary-branches-match-alt
 (implies (cst-matchp abnf::cst "primary")
          (cst-list-list-alt-matchp
               (abnf::tree-nonleaf->branches abnf::cst)
               "primary-no-new-array / array-creation-expression")))

Theorem: cst-primary-no-new-array-branches-match-alt

(defthm cst-primary-no-new-array-branches-match-alt
 (implies
  (cst-matchp abnf::cst "primary-no-new-array")
  (cst-list-list-alt-matchp
   (abnf::tree-nonleaf->branches abnf::cst)
   "literal / class-literal / %s\"this\" / type-name \".\" %s\"this\" / \"(\" expression \")\" / class-instance-creation-expression / field-access / array-access / method-invocation / method-reference")))

Theorem: cst-class-literal-branches-match-alt

(defthm cst-class-literal-branches-match-alt
 (implies
  (cst-matchp abnf::cst "class-literal")
  (cst-list-list-alt-matchp
   (abnf::tree-nonleaf->branches abnf::cst)
   "type-name *( \"[\" \"]\" ) \".\" %s\"class\" / numeric-type *( \"[\" \"]\" ) \".\" %s\"class\" / %s\"boolean\" *( \"[\" \"]\" ) \".\" %s\"class\" / %s\"void\" \".\" %s\"class\"")))

Theorem: cst-class-instance-creation-expression-branches-match-alt

(defthm cst-class-instance-creation-expression-branches-match-alt
 (implies
  (cst-matchp abnf::cst
              "class-instance-creation-expression")
  (cst-list-list-alt-matchp
   (abnf::tree-nonleaf->branches abnf::cst)
   "unqualified-class-instance-creation-expression / expression-name \".\" unqualified-class-instance-creation-expression / primary \".\" unqualified-class-instance-creation-expression")))

Theorem: cst-unqualified-class-instance-creation-expression-branches-match-alt

(defthm
 cst-unqualified-class-instance-creation-expression-branches-match-alt
 (implies
  (cst-matchp abnf::cst
              "unqualified-class-instance-creation-expression")
  (cst-list-list-alt-matchp
   (abnf::tree-nonleaf->branches abnf::cst)
   "%s\"new\" [ type-arguments ] class-or-interface-type-to-instantiate \"(\" [ argument-list ] \")\" [ class-body ]")))

Theorem: cst-class-or-interface-type-to-instantiate-branches-match-alt

(defthm
      cst-class-or-interface-type-to-instantiate-branches-match-alt
 (implies
  (cst-matchp abnf::cst
              "class-or-interface-type-to-instantiate")
  (cst-list-list-alt-matchp
   (abnf::tree-nonleaf->branches abnf::cst)
   "*annotation identifier *( \".\" *annotation identifier ) [ type-arguments-or-diamond ]")))

Theorem: cst-type-arguments-or-diamond-branches-match-alt

(defthm cst-type-arguments-or-diamond-branches-match-alt
 (implies
  (cst-matchp abnf::cst "type-arguments-or-diamond")
  (cst-list-list-alt-matchp (abnf::tree-nonleaf->branches abnf::cst)
                            "type-arguments / \"<>\"")))

Theorem: cst-array-creation-expression-branches-match-alt

(defthm cst-array-creation-expression-branches-match-alt
 (implies
  (cst-matchp abnf::cst "array-creation-expression")
  (cst-list-list-alt-matchp
   (abnf::tree-nonleaf->branches abnf::cst)
   "array-creation-expression-without-initializer / array-creation-expression-with-initializer")))

Theorem: cst-array-creation-expression-without-initializer-branches-match-alt

(defthm
 cst-array-creation-expression-without-initializer-branches-match-alt
 (implies
  (cst-matchp abnf::cst
              "array-creation-expression-without-initializer")
  (cst-list-list-alt-matchp
   (abnf::tree-nonleaf->branches abnf::cst)
   "%s\"new\" primitive-type dim-exprs [ dims ] / %s\"new\" class-or-interface-type dim-exprs [ dims ]")))

Theorem: cst-array-creation-expression-with-initializer-branches-match-alt

(defthm
  cst-array-creation-expression-with-initializer-branches-match-alt
 (implies
  (cst-matchp abnf::cst
              "array-creation-expression-with-initializer")
  (cst-list-list-alt-matchp
   (abnf::tree-nonleaf->branches abnf::cst)
   "%s\"new\" primitive-type dims array-initializer / %s\"new\" class-or-interface-type dims array-initializer")))

Theorem: cst-dim-exprs-branches-match-alt

(defthm cst-dim-exprs-branches-match-alt
 (implies
  (cst-matchp abnf::cst "dim-exprs")
  (cst-list-list-alt-matchp (abnf::tree-nonleaf->branches abnf::cst)
                            "1*dim-expr")))

Theorem: cst-dim-expr-branches-match-alt

(defthm cst-dim-expr-branches-match-alt
 (implies
  (cst-matchp abnf::cst "dim-expr")
  (cst-list-list-alt-matchp (abnf::tree-nonleaf->branches abnf::cst)
                            "*annotation \"[\" expression \"]\"")))

Theorem: cst-array-access-branches-match-alt

(defthm cst-array-access-branches-match-alt
 (implies
  (cst-matchp abnf::cst "array-access")
  (cst-list-list-alt-matchp
   (abnf::tree-nonleaf->branches abnf::cst)
   "expression-name \"[\" expression \"]\" / primary-no-new-array \"[\" expression \"]\" / array-creation-expression-with-initializer \"[\" expression \"]\"")))

Theorem: cst-field-access-branches-match-alt

(defthm cst-field-access-branches-match-alt
 (implies
  (cst-matchp abnf::cst "field-access")
  (cst-list-list-alt-matchp
   (abnf::tree-nonleaf->branches abnf::cst)
   "primary \".\" identifier / %s\"super\" \".\" identifier / type-name \".\" %s\"super\" \".\" identifier")))

Theorem: cst-method-invocation-branches-match-alt

(defthm cst-method-invocation-branches-match-alt
 (implies
  (cst-matchp abnf::cst "method-invocation")
  (cst-list-list-alt-matchp
   (abnf::tree-nonleaf->branches abnf::cst)
   "method-name \"(\" [ argument-list ] \")\" / type-name \".\" [ type-arguments ] identifier \"(\" [ argument-list ] \")\" / expression-name \".\" [ type-arguments ] identifier \"(\" [ argument-list ] \")\" / primary \".\" [ type-arguments ] identifier \"(\" [ argument-list ] \")\" / %s\"super\" \".\" [ type-arguments ] identifier \"(\" [ argument-list ] \")\" / type-name \".\" %s\"super\" \".\" [ type-arguments ] identifier \"(\" [ argument-list ] \")\"")))

Theorem: cst-argument-list-branches-match-alt

(defthm cst-argument-list-branches-match-alt
 (implies
  (cst-matchp abnf::cst "argument-list")
  (cst-list-list-alt-matchp (abnf::tree-nonleaf->branches abnf::cst)
                            "expression *( \",\" expression )")))

Theorem: cst-method-reference-branches-match-alt

(defthm cst-method-reference-branches-match-alt
 (implies
  (cst-matchp abnf::cst "method-reference")
  (cst-list-list-alt-matchp
   (abnf::tree-nonleaf->branches abnf::cst)
   "expression-name \"::\" [ type-arguments ] identifier / primary \"::\" [ type-arguments ] identifier / reference-type \"::\" [ type-arguments ] identifier / %s\"super\" \"::\" [ type-arguments ] identifier / type-name \".\" %s\"super\" \"::\" [ type-arguments ] identifier / class-type \"::\" [ type-arguments ] %s\"new\" / array-type \"::\" %s\"new\"")))

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-name / post-increment-expression / post-decrement-expression")))

Theorem: cst-post-increment-expression-branches-match-alt

(defthm cst-post-increment-expression-branches-match-alt
 (implies
  (cst-matchp abnf::cst "post-increment-expression")
  (cst-list-list-alt-matchp (abnf::tree-nonleaf->branches abnf::cst)
                            "postfix-expression \"++\"")))

Theorem: cst-post-decrement-expression-branches-match-alt

(defthm cst-post-decrement-expression-branches-match-alt
 (implies
  (cst-matchp abnf::cst "post-decrement-expression")
  (cst-list-list-alt-matchp (abnf::tree-nonleaf->branches abnf::cst)
                            "postfix-expression \"--\"")))

Theorem: cst-unary-expression-branches-match-alt

(defthm cst-unary-expression-branches-match-alt
 (implies
  (cst-matchp abnf::cst "unary-expression")
  (cst-list-list-alt-matchp
   (abnf::tree-nonleaf->branches abnf::cst)
   "pre-increment-expression / pre-decrement-expression / \"+\" unary-expression / \"-\" unary-expression / unary-expression-not-plus-minus")))

Theorem: cst-pre-increment-expression-branches-match-alt

(defthm cst-pre-increment-expression-branches-match-alt
 (implies
  (cst-matchp abnf::cst "pre-increment-expression")
  (cst-list-list-alt-matchp (abnf::tree-nonleaf->branches abnf::cst)
                            "\"++\" unary-expression")))

Theorem: cst-pre-decrement-expression-branches-match-alt

(defthm cst-pre-decrement-expression-branches-match-alt
 (implies
  (cst-matchp abnf::cst "pre-decrement-expression")
  (cst-list-list-alt-matchp (abnf::tree-nonleaf->branches abnf::cst)
                            "\"--\" unary-expression")))

Theorem: cst-unary-expression-not-plus-minus-branches-match-alt

(defthm cst-unary-expression-not-plus-minus-branches-match-alt
 (implies
  (cst-matchp abnf::cst
              "unary-expression-not-plus-minus")
  (cst-list-list-alt-matchp
   (abnf::tree-nonleaf->branches abnf::cst)
   "postfix-expression / \"~\" unary-expression / \"!\" unary-expression / cast-expression / switch-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)
   "\"(\" primitive-type \")\" unary-expression / \"(\" reference-type *additional-bound \")\" unary-expression-not-plus-minus / \"(\" reference-type *additional-bound \")\" lambda-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)
   "unary-expression / multiplicative-expression \"*\" unary-expression / multiplicative-expression \"/\" unary-expression / multiplicative-expression \"%\" unary-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 / shift-expression \">>>\" additive-expression")))

Theorem: cst-relational-expression-branches-match-alt

(defthm cst-relational-expression-branches-match-alt
 (implies
  (cst-matchp abnf::cst "relational-expression")
  (cst-list-list-alt-matchp
   (abnf::tree-nonleaf->branches abnf::cst)
   "shift-expression / relational-expression \"<\" shift-expression / relational-expression \">\" shift-expression / relational-expression \"<=\" shift-expression / relational-expression \">=\" shift-expression / instanceof-expression")))

Theorem: cst-instanceof-expression-branches-match-alt

(defthm cst-instanceof-expression-branches-match-alt
 (implies
  (cst-matchp abnf::cst "instanceof-expression")
  (cst-list-list-alt-matchp
   (abnf::tree-nonleaf->branches abnf::cst)
   "relational-expression %s\"instanceof\" reference-type / relational-expression %s\"instanceof\" pattern")))

Theorem: cst-equality-expression-branches-match-alt

(defthm cst-equality-expression-branches-match-alt
 (implies
  (cst-matchp abnf::cst "equality-expression")
  (cst-list-list-alt-matchp
   (abnf::tree-nonleaf->branches abnf::cst)
   "relational-expression / equality-expression \"==\" relational-expression / equality-expression \"!=\" relational-expression")))

Theorem: cst-and-expression-branches-match-alt

(defthm cst-and-expression-branches-match-alt
 (implies
  (cst-matchp abnf::cst "and-expression")
  (cst-list-list-alt-matchp
   (abnf::tree-nonleaf->branches abnf::cst)
   "equality-expression / and-expression \"&\" equality-expression")))

Theorem: cst-exclusive-or-expression-branches-match-alt

(defthm cst-exclusive-or-expression-branches-match-alt
 (implies
  (cst-matchp abnf::cst "exclusive-or-expression")
  (cst-list-list-alt-matchp
    (abnf::tree-nonleaf->branches abnf::cst)
    "and-expression / exclusive-or-expression \"^\" and-expression")))

Theorem: cst-inclusive-or-expression-branches-match-alt

(defthm cst-inclusive-or-expression-branches-match-alt
 (implies
  (cst-matchp abnf::cst "inclusive-or-expression")
  (cst-list-list-alt-matchp
   (abnf::tree-nonleaf->branches abnf::cst)
   "exclusive-or-expression / inclusive-or-expression \"|\" exclusive-or-expression")))

Theorem: cst-conditional-and-expression-branches-match-alt

(defthm cst-conditional-and-expression-branches-match-alt
 (implies
  (cst-matchp abnf::cst "conditional-and-expression")
  (cst-list-list-alt-matchp
   (abnf::tree-nonleaf->branches abnf::cst)
   "inclusive-or-expression / conditional-and-expression \"&&\" inclusive-or-expression")))

Theorem: cst-conditional-or-expression-branches-match-alt

(defthm cst-conditional-or-expression-branches-match-alt
 (implies
  (cst-matchp abnf::cst "conditional-or-expression")
  (cst-list-list-alt-matchp
   (abnf::tree-nonleaf->branches abnf::cst)
   "conditional-and-expression / conditional-or-expression \"||\" conditional-and-expression")))

Theorem: cst-conditional-expression-branches-match-alt

(defthm cst-conditional-expression-branches-match-alt
 (implies
  (cst-matchp abnf::cst "conditional-expression")
  (cst-list-list-alt-matchp
   (abnf::tree-nonleaf->branches abnf::cst)
   "conditional-or-expression / conditional-or-expression \"?\" expression \":\" conditional-expression / conditional-or-expression \"?\" expression \":\" lambda-expression")))

Theorem: cst-assignment-expression-branches-match-alt

(defthm cst-assignment-expression-branches-match-alt
 (implies
  (cst-matchp abnf::cst "assignment-expression")
  (cst-list-list-alt-matchp (abnf::tree-nonleaf->branches abnf::cst)
                            "conditional-expression / assignment")))

Theorem: cst-assignment-branches-match-alt

(defthm cst-assignment-branches-match-alt
  (implies (cst-matchp abnf::cst "assignment")
           (cst-list-list-alt-matchp
                (abnf::tree-nonleaf->branches abnf::cst)
                "left-hand-side assignment-operator expression")))

Theorem: cst-left-hand-side-branches-match-alt

(defthm cst-left-hand-side-branches-match-alt
  (implies (cst-matchp abnf::cst "left-hand-side")
           (cst-list-list-alt-matchp
                (abnf::tree-nonleaf->branches abnf::cst)
                "expression-name / field-access / array-access")))

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-lambda-expression-branches-match-alt

(defthm cst-lambda-expression-branches-match-alt
 (implies
  (cst-matchp abnf::cst "lambda-expression")
  (cst-list-list-alt-matchp (abnf::tree-nonleaf->branches abnf::cst)
                            "lambda-parameters \"->\" lambda-body")))

Theorem: cst-lambda-parameters-branches-match-alt

(defthm cst-lambda-parameters-branches-match-alt
 (implies
  (cst-matchp abnf::cst "lambda-parameters")
  (cst-list-list-alt-matchp
   (abnf::tree-nonleaf->branches abnf::cst)
   "\"(\" [ lambda-parameter-list ] \")\" / concise-lambda-parameter")))

Theorem: cst-lambda-parameter-list-branches-match-alt

(defthm cst-lambda-parameter-list-branches-match-alt
 (implies
  (cst-matchp abnf::cst "lambda-parameter-list")
  (cst-list-list-alt-matchp
   (abnf::tree-nonleaf->branches abnf::cst)
   "normal-lambda-parameter *( \",\" normal-lambda-parameter ) / concise-lambda-parameter *( \",\" concise-lambda-parameter )")))

Theorem: cst-normal-lambda-parameter-branches-match-alt

(defthm cst-normal-lambda-parameter-branches-match-alt
 (implies
  (cst-matchp abnf::cst "normal-lambda-parameter")
  (cst-list-list-alt-matchp
   (abnf::tree-nonleaf->branches abnf::cst)
   "*variable-modifier lambda-parameter-type variable-declarator-id / variable-arity-parameter")))

Theorem: cst-lambda-parameter-type-branches-match-alt

(defthm cst-lambda-parameter-type-branches-match-alt
 (implies
  (cst-matchp abnf::cst "lambda-parameter-type")
  (cst-list-list-alt-matchp (abnf::tree-nonleaf->branches abnf::cst)
                            "unann-type / %s\"var\"")))

Theorem: cst-concise-lambda-parameter-branches-match-alt

(defthm cst-concise-lambda-parameter-branches-match-alt
 (implies
  (cst-matchp abnf::cst "concise-lambda-parameter")
  (cst-list-list-alt-matchp (abnf::tree-nonleaf->branches abnf::cst)
                            "identifier / \"_\"")))

Theorem: cst-lambda-body-branches-match-alt

(defthm cst-lambda-body-branches-match-alt
 (implies
  (cst-matchp abnf::cst "lambda-body")
  (cst-list-list-alt-matchp (abnf::tree-nonleaf->branches abnf::cst)
                            "expression / block")))

Theorem: cst-switch-expression-branches-match-alt

(defthm cst-switch-expression-branches-match-alt
  (implies (cst-matchp abnf::cst "switch-expression")
           (cst-list-list-alt-matchp
                (abnf::tree-nonleaf->branches abnf::cst)
                "%s\"switch\" \"(\" expression \")\" switch-block")))

Theorem: cst-unicode-input-character-concs

(defthm cst-unicode-input-character-concs
 (implies
  (cst-list-list-alt-matchp abnf::cstss
                            "unicode-escape / raw-input-character")
  (or
    (cst-list-list-conc-matchp abnf::cstss "unicode-escape")
    (cst-list-list-conc-matchp abnf::cstss "raw-input-character"))))

Theorem: cst-unicode-escape-concs

(defthm cst-unicode-escape-concs
 (implies
  (cst-list-list-alt-matchp
       abnf::cstss
       "\"\\\" unicode-marker hex-digit hex-digit hex-digit hex-digit")
  (or
   (cst-list-list-conc-matchp
    abnf::cstss
    "\"\\\" unicode-marker hex-digit hex-digit hex-digit hex-digit"))))

Theorem: cst-unicode-marker-concs

(defthm cst-unicode-marker-concs
  (implies (cst-list-list-alt-matchp abnf::cstss "1*%s\"u\"")
           (or (cst-list-list-conc-matchp abnf::cstss "1*%s\"u\""))))

Theorem: cst-hex-digit-concs

(defthm cst-hex-digit-concs
 (implies
  (cst-list-list-alt-matchp
   abnf::cstss
   "\"0\" / \"1\" / \"2\" / \"3\" / \"4\" / \"5\" / \"6\" / \"7\" / \"8\" / \"9\" / \"a\" / \"b\" / \"c\" / \"d\" / \"e\" / \"f\"")
  (or (cst-list-list-conc-matchp abnf::cstss "\"0\"")
      (cst-list-list-conc-matchp abnf::cstss "\"1\"")
      (cst-list-list-conc-matchp abnf::cstss "\"2\"")
      (cst-list-list-conc-matchp abnf::cstss "\"3\"")
      (cst-list-list-conc-matchp abnf::cstss "\"4\"")
      (cst-list-list-conc-matchp abnf::cstss "\"5\"")
      (cst-list-list-conc-matchp abnf::cstss "\"6\"")
      (cst-list-list-conc-matchp abnf::cstss "\"7\"")
      (cst-list-list-conc-matchp abnf::cstss "\"8\"")
      (cst-list-list-conc-matchp abnf::cstss "\"9\"")
      (cst-list-list-conc-matchp abnf::cstss "\"a\"")
      (cst-list-list-conc-matchp abnf::cstss "\"b\"")
      (cst-list-list-conc-matchp abnf::cstss "\"c\"")
      (cst-list-list-conc-matchp abnf::cstss "\"d\"")
      (cst-list-list-conc-matchp abnf::cstss "\"e\"")
      (cst-list-list-conc-matchp abnf::cstss "\"f\""))))

Theorem: cst-raw-input-character-concs

(defthm cst-raw-input-character-concs
  (implies (cst-list-list-alt-matchp abnf::cstss "%x0-FFFF")
           (or (cst-list-list-conc-matchp abnf::cstss "%x0-FFFF"))))

Theorem: cst-line-terminator-concs

(defthm cst-line-terminator-concs
 (implies
      (cst-list-list-alt-matchp abnf::cstss "%d10 / %d13 / %d13.10")
      (or (cst-list-list-conc-matchp abnf::cstss "%d10")
          (cst-list-list-conc-matchp abnf::cstss "%d13")
          (cst-list-list-conc-matchp abnf::cstss "%d13.10"))))

Theorem: cst-input-character-concs

(defthm cst-input-character-concs
 (implies
    (cst-list-list-alt-matchp abnf::cstss "unicode-input-character")
    (or (cst-list-list-conc-matchp abnf::cstss
                                   "unicode-input-character"))))

Theorem: cst-input-concs

(defthm cst-input-concs
 (implies
     (cst-list-list-alt-matchp abnf::cstss "*input-element [ sub ]")
     (or (cst-list-list-conc-matchp
              abnf::cstss "*input-element [ sub ]"))))

Theorem: cst-input-element-concs

(defthm cst-input-element-concs
 (implies (cst-list-list-alt-matchp abnf::cstss
                                    "white-space / comment / token")
          (or (cst-list-list-conc-matchp abnf::cstss "white-space")
              (cst-list-list-conc-matchp abnf::cstss "comment")
              (cst-list-list-conc-matchp abnf::cstss "token"))))

Theorem: cst-token-concs

(defthm cst-token-concs
  (implies
       (cst-list-list-alt-matchp
            abnf::cstss
            "identifier / keyword / literal / separator / operator")
       (or (cst-list-list-conc-matchp abnf::cstss "identifier")
           (cst-list-list-conc-matchp abnf::cstss "keyword")
           (cst-list-list-conc-matchp abnf::cstss "literal")
           (cst-list-list-conc-matchp abnf::cstss "separator")
           (cst-list-list-conc-matchp abnf::cstss "operator"))))

Theorem: cst-sub-concs

(defthm cst-sub-concs
  (implies (cst-list-list-alt-matchp abnf::cstss "%d26")
           (or (cst-list-list-conc-matchp abnf::cstss "%d26"))))

Theorem: cst-white-space-concs

(defthm cst-white-space-concs
 (implies
    (cst-list-list-alt-matchp abnf::cstss
                              "%d32 / %d9 / %d12 / line-terminator")
    (or (cst-list-list-conc-matchp abnf::cstss "%d32")
        (cst-list-list-conc-matchp abnf::cstss "%d9")
        (cst-list-list-conc-matchp abnf::cstss "%d12")
        (cst-list-list-conc-matchp abnf::cstss "line-terminator"))))

Theorem: cst-comment-concs

(defthm cst-comment-concs
 (implies
  (cst-list-list-alt-matchp
       abnf::cstss
       "traditional-comment / end-of-line-comment")
  (or
    (cst-list-list-conc-matchp abnf::cstss "traditional-comment")
    (cst-list-list-conc-matchp abnf::cstss "end-of-line-comment"))))

Theorem: cst-traditional-comment-concs

(defthm cst-traditional-comment-concs
 (implies
  (cst-list-list-alt-matchp abnf::cstss "\"/\" \"*\" comment-tail")
  (or
   (cst-list-list-conc-matchp abnf::cstss "\"/\" \"*\" comment-tail"))))

Theorem: cst-comment-tail-concs

(defthm cst-comment-tail-concs
 (implies
  (cst-list-list-alt-matchp
       abnf::cstss
       "\"*\" comment-tail-star / not-star comment-tail")
  (or
     (cst-list-list-conc-matchp abnf::cstss "\"*\" comment-tail-star")
     (cst-list-list-conc-matchp
          abnf::cstss "not-star comment-tail"))))

Theorem: cst-comment-tail-star-concs

(defthm cst-comment-tail-star-concs
 (implies
  (cst-list-list-alt-matchp
    abnf::cstss
    "\"/\" / \"*\" comment-tail-star / not-star-not-slash comment-tail")
  (or
    (cst-list-list-conc-matchp abnf::cstss "\"/\"")
    (cst-list-list-conc-matchp abnf::cstss "\"*\" comment-tail-star")
    (cst-list-list-conc-matchp abnf::cstss
                               "not-star-not-slash comment-tail"))))

Theorem: cst-not-star-concs

(defthm cst-not-star-concs
 (implies
    (cst-list-list-alt-matchp abnf::cstss
                              "input-character / line-terminator")
    (or (cst-list-list-conc-matchp abnf::cstss "input-character")
        (cst-list-list-conc-matchp abnf::cstss "line-terminator"))))

Theorem: cst-not-star-not-slash-concs

(defthm cst-not-star-not-slash-concs
 (implies
    (cst-list-list-alt-matchp abnf::cstss
                              "input-character / line-terminator")
    (or (cst-list-list-conc-matchp abnf::cstss "input-character")
        (cst-list-list-conc-matchp abnf::cstss "line-terminator"))))

Theorem: cst-end-of-line-comment-concs

(defthm cst-end-of-line-comment-concs
 (implies
   (cst-list-list-alt-matchp abnf::cstss "\"/\" \"/\" *input-character")
   (or (cst-list-list-conc-matchp abnf::cstss
                                  "\"/\" \"/\" *input-character"))))

Theorem: cst-identifier-concs

(defthm cst-identifier-concs
 (implies
   (cst-list-list-alt-matchp abnf::cstss "identifier-chars")
   (or (cst-list-list-conc-matchp abnf::cstss "identifier-chars"))))

Theorem: cst-identifier-chars-concs

(defthm cst-identifier-chars-concs
 (implies
      (cst-list-list-alt-matchp abnf::cstss
                                "java-letter *java-letter-or-digit")
      (or (cst-list-list-conc-matchp
               abnf::cstss
               "java-letter *java-letter-or-digit"))))

Theorem: cst-java-letter-concs

(defthm cst-java-letter-concs
 (implies
  (cst-list-list-alt-matchp abnf::cstss "raw-input-character")
  (or
    (cst-list-list-conc-matchp abnf::cstss "raw-input-character"))))

Theorem: cst-java-letter-or-digit-concs

(defthm cst-java-letter-or-digit-concs
 (implies
  (cst-list-list-alt-matchp abnf::cstss "raw-input-character")
  (or
    (cst-list-list-conc-matchp abnf::cstss "raw-input-character"))))

Theorem: cst-type-identifier-concs

(defthm cst-type-identifier-concs
  (implies
       (cst-list-list-alt-matchp abnf::cstss "identifier")
       (or (cst-list-list-conc-matchp abnf::cstss "identifier"))))

Theorem: cst-unqualified-method-identifier-concs

(defthm cst-unqualified-method-identifier-concs
  (implies
       (cst-list-list-alt-matchp abnf::cstss "identifier")
       (or (cst-list-list-conc-matchp abnf::cstss "identifier"))))

Theorem: cst-keyword-concs

(defthm cst-keyword-concs
 (implies
  (cst-list-list-alt-matchp abnf::cstss
                            "reserved-keyword / contextual-keyword")
  (or
     (cst-list-list-conc-matchp abnf::cstss "reserved-keyword")
     (cst-list-list-conc-matchp abnf::cstss "contextual-keyword"))))

Theorem: cst-reserved-keyword-concs

(defthm cst-reserved-keyword-concs
 (implies
  (cst-list-list-alt-matchp
   abnf::cstss
   "%s\"abstract\" / %s\"assert\" / %s\"boolean\" / %s\"break\" / %s\"byte\" / %s\"case\" / %s\"catch\" / %s\"char\" / %s\"class\" / %s\"const\" / %s\"continue\" / %s\"default\" / %s\"do\" / %s\"double\" / %s\"else\" / %s\"enum\" / %s\"extends\" / %s\"final\" / %s\"finally\" / %s\"float\" / %s\"for\" / %s\"if\" / %s\"goto\" / %s\"implements\" / %s\"import\" / %s\"instanceof\" / %s\"int\" / %s\"interface\" / %s\"long\" / %s\"native\" / %s\"new\" / %s\"package\" / %s\"private\" / %s\"protected\" / %s\"public\" / %s\"return\" / %s\"short\" / %s\"static\" / %s\"strictfp\" / %s\"super\" / %s\"switch\" / %s\"synchronized\" / %s\"this\" / %s\"throw\" / %s\"throws\" / %s\"transient\" / %s\"try\" / %s\"void\" / %s\"volatile\" / %s\"while\" / \"_\"")
  (or (cst-list-list-conc-matchp abnf::cstss "%s\"abstract\"")
      (cst-list-list-conc-matchp abnf::cstss "%s\"assert\"")
      (cst-list-list-conc-matchp abnf::cstss "%s\"boolean\"")
      (cst-list-list-conc-matchp abnf::cstss "%s\"break\"")
      (cst-list-list-conc-matchp abnf::cstss "%s\"byte\"")
      (cst-list-list-conc-matchp abnf::cstss "%s\"case\"")
      (cst-list-list-conc-matchp abnf::cstss "%s\"catch\"")
      (cst-list-list-conc-matchp abnf::cstss "%s\"char\"")
      (cst-list-list-conc-matchp abnf::cstss "%s\"class\"")
      (cst-list-list-conc-matchp abnf::cstss "%s\"const\"")
      (cst-list-list-conc-matchp abnf::cstss "%s\"continue\"")
      (cst-list-list-conc-matchp abnf::cstss "%s\"default\"")
      (cst-list-list-conc-matchp abnf::cstss "%s\"do\"")
      (cst-list-list-conc-matchp abnf::cstss "%s\"double\"")
      (cst-list-list-conc-matchp abnf::cstss "%s\"else\"")
      (cst-list-list-conc-matchp abnf::cstss "%s\"enum\"")
      (cst-list-list-conc-matchp abnf::cstss "%s\"extends\"")
      (cst-list-list-conc-matchp abnf::cstss "%s\"final\"")
      (cst-list-list-conc-matchp abnf::cstss "%s\"finally\"")
      (cst-list-list-conc-matchp abnf::cstss "%s\"float\"")
      (cst-list-list-conc-matchp abnf::cstss "%s\"for\"")
      (cst-list-list-conc-matchp abnf::cstss "%s\"if\"")
      (cst-list-list-conc-matchp abnf::cstss "%s\"goto\"")
      (cst-list-list-conc-matchp abnf::cstss "%s\"implements\"")
      (cst-list-list-conc-matchp abnf::cstss "%s\"import\"")
      (cst-list-list-conc-matchp abnf::cstss "%s\"instanceof\"")
      (cst-list-list-conc-matchp abnf::cstss "%s\"int\"")
      (cst-list-list-conc-matchp abnf::cstss "%s\"interface\"")
      (cst-list-list-conc-matchp abnf::cstss "%s\"long\"")
      (cst-list-list-conc-matchp abnf::cstss "%s\"native\"")
      (cst-list-list-conc-matchp abnf::cstss "%s\"new\"")
      (cst-list-list-conc-matchp abnf::cstss "%s\"package\"")
      (cst-list-list-conc-matchp abnf::cstss "%s\"private\"")
      (cst-list-list-conc-matchp abnf::cstss "%s\"protected\"")
      (cst-list-list-conc-matchp abnf::cstss "%s\"public\"")
      (cst-list-list-conc-matchp abnf::cstss "%s\"return\"")
      (cst-list-list-conc-matchp abnf::cstss "%s\"short\"")
      (cst-list-list-conc-matchp abnf::cstss "%s\"static\"")
      (cst-list-list-conc-matchp abnf::cstss "%s\"strictfp\"")
      (cst-list-list-conc-matchp abnf::cstss "%s\"super\"")
      (cst-list-list-conc-matchp abnf::cstss "%s\"switch\"")
      (cst-list-list-conc-matchp abnf::cstss "%s\"synchronized\"")
      (cst-list-list-conc-matchp abnf::cstss "%s\"this\"")
      (cst-list-list-conc-matchp abnf::cstss "%s\"throw\"")
      (cst-list-list-conc-matchp abnf::cstss "%s\"throws\"")
      (cst-list-list-conc-matchp abnf::cstss "%s\"transient\"")
      (cst-list-list-conc-matchp abnf::cstss "%s\"try\"")
      (cst-list-list-conc-matchp abnf::cstss "%s\"void\"")
      (cst-list-list-conc-matchp abnf::cstss "%s\"volatile\"")
      (cst-list-list-conc-matchp abnf::cstss "%s\"while\"")
      (cst-list-list-conc-matchp abnf::cstss "\"_\""))))

Theorem: cst-contextual-keyword-concs

(defthm cst-contextual-keyword-concs
 (implies
  (cst-list-list-alt-matchp
   abnf::cstss
   "%s\"exports\" / %s\"module\" / %s\"non-sealed\" / %s\"open\" / %s\"opens\" / %s\"permits\" / %s\"provides\" / %s\"record\" / %s\"requires\" / %s\"sealed\" / %s\"to\" / %s\"transitive\" / %s\"uses\" / %s\"var\" / %s\"when\" / %s\"with\" / %s\"yield\"")
  (or (cst-list-list-conc-matchp abnf::cstss "%s\"exports\"")
      (cst-list-list-conc-matchp abnf::cstss "%s\"module\"")
      (cst-list-list-conc-matchp abnf::cstss "%s\"non-sealed\"")
      (cst-list-list-conc-matchp abnf::cstss "%s\"open\"")
      (cst-list-list-conc-matchp abnf::cstss "%s\"opens\"")
      (cst-list-list-conc-matchp abnf::cstss "%s\"permits\"")
      (cst-list-list-conc-matchp abnf::cstss "%s\"provides\"")
      (cst-list-list-conc-matchp abnf::cstss "%s\"record\"")
      (cst-list-list-conc-matchp abnf::cstss "%s\"requires\"")
      (cst-list-list-conc-matchp abnf::cstss "%s\"sealed\"")
      (cst-list-list-conc-matchp abnf::cstss "%s\"to\"")
      (cst-list-list-conc-matchp abnf::cstss "%s\"transitive\"")
      (cst-list-list-conc-matchp abnf::cstss "%s\"uses\"")
      (cst-list-list-conc-matchp abnf::cstss "%s\"var\"")
      (cst-list-list-conc-matchp abnf::cstss "%s\"when\"")
      (cst-list-list-conc-matchp abnf::cstss "%s\"with\"")
      (cst-list-list-conc-matchp abnf::cstss "%s\"yield\""))))

Theorem: cst-literal-concs

(defthm cst-literal-concs
 (implies
  (cst-list-list-alt-matchp
   abnf::cstss
   "integer-literal / floating-point-literal / boolean-literal / character-literal / string-literal / text-block / null-literal")
  (or
    (cst-list-list-conc-matchp abnf::cstss "integer-literal")
    (cst-list-list-conc-matchp abnf::cstss "floating-point-literal")
    (cst-list-list-conc-matchp abnf::cstss "boolean-literal")
    (cst-list-list-conc-matchp abnf::cstss "character-literal")
    (cst-list-list-conc-matchp abnf::cstss "string-literal")
    (cst-list-list-conc-matchp abnf::cstss "text-block")
    (cst-list-list-conc-matchp abnf::cstss "null-literal"))))

Theorem: cst-integer-literal-concs

(defthm cst-integer-literal-concs
 (implies
  (cst-list-list-alt-matchp
   abnf::cstss
   "decimal-integer-literal / hex-integer-literal / octal-integer-literal / binary-integer-literal")
  (or
   (cst-list-list-conc-matchp abnf::cstss "decimal-integer-literal")
   (cst-list-list-conc-matchp abnf::cstss "hex-integer-literal")
   (cst-list-list-conc-matchp abnf::cstss "octal-integer-literal")
   (cst-list-list-conc-matchp
        abnf::cstss "binary-integer-literal"))))

Theorem: cst-decimal-integer-literal-concs

(defthm cst-decimal-integer-literal-concs
  (implies (cst-list-list-alt-matchp
                abnf::cstss
                "decimal-numeral [ integer-type-suffix ]")
           (or (cst-list-list-conc-matchp
                    abnf::cstss
                    "decimal-numeral [ integer-type-suffix ]"))))

Theorem: cst-hex-integer-literal-concs

(defthm cst-hex-integer-literal-concs
 (implies
    (cst-list-list-alt-matchp abnf::cstss
                              "hex-numeral [ integer-type-suffix ]")
    (or (cst-list-list-conc-matchp
             abnf::cstss
             "hex-numeral [ integer-type-suffix ]"))))

Theorem: cst-octal-integer-literal-concs

(defthm cst-octal-integer-literal-concs
 (implies
  (cst-list-list-alt-matchp abnf::cstss
                            "octal-numeral [ integer-type-suffix ]")
  (or (cst-list-list-conc-matchp
           abnf::cstss
           "octal-numeral [ integer-type-suffix ]"))))

Theorem: cst-binary-integer-literal-concs

(defthm cst-binary-integer-literal-concs
  (implies (cst-list-list-alt-matchp
                abnf::cstss
                "binary-numeral [ integer-type-suffix ]")
           (or (cst-list-list-conc-matchp
                    abnf::cstss
                    "binary-numeral [ integer-type-suffix ]"))))

Theorem: cst-integer-type-suffix-concs

(defthm cst-integer-type-suffix-concs
  (implies (cst-list-list-alt-matchp abnf::cstss "\"l\"")
           (or (cst-list-list-conc-matchp abnf::cstss "\"l\""))))

Theorem: cst-decimal-numeral-concs

(defthm cst-decimal-numeral-concs
 (implies
  (cst-list-list-alt-matchp
   abnf::cstss
   "\"0\" / non-zero-digit [ digits ] / non-zero-digit underscores digits")
  (or (cst-list-list-conc-matchp abnf::cstss "\"0\"")
      (cst-list-list-conc-matchp
           abnf::cstss "non-zero-digit [ digits ]")
      (cst-list-list-conc-matchp
           abnf::cstss
           "non-zero-digit underscores digits"))))

Theorem: cst-non-zero-digit-concs

(defthm cst-non-zero-digit-concs
  (implies
       (cst-list-list-alt-matchp
            abnf::cstss
            "\"1\" / \"2\" / \"3\" / \"4\" / \"5\" / \"6\" / \"7\" / \"8\" / \"9\"")
       (or (cst-list-list-conc-matchp abnf::cstss "\"1\"")
           (cst-list-list-conc-matchp abnf::cstss "\"2\"")
           (cst-list-list-conc-matchp abnf::cstss "\"3\"")
           (cst-list-list-conc-matchp abnf::cstss "\"4\"")
           (cst-list-list-conc-matchp abnf::cstss "\"5\"")
           (cst-list-list-conc-matchp abnf::cstss "\"6\"")
           (cst-list-list-conc-matchp abnf::cstss "\"7\"")
           (cst-list-list-conc-matchp abnf::cstss "\"8\"")
           (cst-list-list-conc-matchp abnf::cstss "\"9\""))))

Theorem: cst-digits-concs

(defthm cst-digits-concs
  (implies (cst-list-list-alt-matchp
                abnf::cstss
                "digit / digit [ digits-and-underscores ] digit")
           (or (cst-list-list-conc-matchp abnf::cstss "digit")
               (cst-list-list-conc-matchp
                    abnf::cstss
                    "digit [ digits-and-underscores ] digit"))))

Theorem: cst-digit-concs

(defthm cst-digit-concs
 (implies
     (cst-list-list-alt-matchp abnf::cstss "\"0\" / non-zero-digit")
     (or (cst-list-list-conc-matchp abnf::cstss "\"0\"")
         (cst-list-list-conc-matchp abnf::cstss "non-zero-digit"))))

Theorem: cst-digits-and-underscores-concs

(defthm cst-digits-and-underscores-concs
  (implies (cst-list-list-alt-matchp
                abnf::cstss
                "digit-or-underscore *digit-or-underscore")
           (or (cst-list-list-conc-matchp
                    abnf::cstss
                    "digit-or-underscore *digit-or-underscore"))))

Theorem: cst-digit-or-underscore-concs

(defthm cst-digit-or-underscore-concs
  (implies (cst-list-list-alt-matchp abnf::cstss "digit / \"_\"")
           (or (cst-list-list-conc-matchp abnf::cstss "digit")
               (cst-list-list-conc-matchp abnf::cstss "\"_\""))))

Theorem: cst-underscores-concs

(defthm cst-underscores-concs
  (implies (cst-list-list-alt-matchp abnf::cstss "1*\"_\"")
           (or (cst-list-list-conc-matchp abnf::cstss "1*\"_\""))))

Theorem: cst-hex-numeral-concs

(defthm cst-hex-numeral-concs
 (implies
    (cst-list-list-alt-matchp abnf::cstss "\"0x\" hex-digits")
    (or (cst-list-list-conc-matchp abnf::cstss "\"0x\" hex-digits"))))

Theorem: cst-hex-digits-concs

(defthm cst-hex-digits-concs
 (implies
  (cst-list-list-alt-matchp
   abnf::cstss
   "hex-digit / hex-digit [ hex-digits-and-underscores ] hex-digit")
  (or (cst-list-list-conc-matchp abnf::cstss "hex-digit")
      (cst-list-list-conc-matchp
           abnf::cstss
           "hex-digit [ hex-digits-and-underscores ] hex-digit"))))

Theorem: cst-hex-digits-and-underscores-concs

(defthm cst-hex-digits-and-underscores-concs
 (implies
  (cst-list-list-alt-matchp abnf::cstss "1*hex-digit-or-underscore")
  (or (cst-list-list-conc-matchp abnf::cstss
                                 "1*hex-digit-or-underscore"))))

Theorem: cst-hex-digit-or-underscore-concs

(defthm cst-hex-digit-or-underscore-concs
  (implies (cst-list-list-alt-matchp abnf::cstss "hex-digit / \"_\"")
           (or (cst-list-list-conc-matchp abnf::cstss "hex-digit")
               (cst-list-list-conc-matchp abnf::cstss "\"_\""))))

Theorem: cst-octal-numeral-concs

(defthm cst-octal-numeral-concs
 (implies
   (cst-list-list-alt-matchp
        abnf::cstss
        "\"0\" octal-digits / \"0\" underscores octal-digits")
   (or (cst-list-list-conc-matchp abnf::cstss "\"0\" octal-digits")
       (cst-list-list-conc-matchp abnf::cstss
                                  "\"0\" underscores octal-digits"))))

Theorem: cst-octal-digits-concs

(defthm cst-octal-digits-concs
 (implies
  (cst-list-list-alt-matchp
   abnf::cstss
   "octal-digit / octal-digit [ octal-digits-and-underscores ] octal-digit")
  (or
   (cst-list-list-conc-matchp abnf::cstss "octal-digit")
   (cst-list-list-conc-matchp
      abnf::cstss
      "octal-digit [ octal-digits-and-underscores ] octal-digit"))))

Theorem: cst-octal-digit-concs

(defthm cst-octal-digit-concs
  (implies (cst-list-list-alt-matchp
                abnf::cstss
                "\"0\" / \"1\" / \"2\" / \"3\" / \"4\" / \"5\" / \"6\" / \"7\"")
           (or (cst-list-list-conc-matchp abnf::cstss "\"0\"")
               (cst-list-list-conc-matchp abnf::cstss "\"1\"")
               (cst-list-list-conc-matchp abnf::cstss "\"2\"")
               (cst-list-list-conc-matchp abnf::cstss "\"3\"")
               (cst-list-list-conc-matchp abnf::cstss "\"4\"")
               (cst-list-list-conc-matchp abnf::cstss "\"5\"")
               (cst-list-list-conc-matchp abnf::cstss "\"6\"")
               (cst-list-list-conc-matchp abnf::cstss "\"7\""))))

Theorem: cst-octal-digits-and-underscores-concs

(defthm cst-octal-digits-and-underscores-concs
 (implies
    (cst-list-list-alt-matchp abnf::cstss
                              "1*octal-digit-or-underscore")
    (or (cst-list-list-conc-matchp abnf::cstss
                                   "1*octal-digit-or-underscore"))))

Theorem: cst-octal-digit-or-underscore-concs

(defthm cst-octal-digit-or-underscore-concs
 (implies (cst-list-list-alt-matchp abnf::cstss "octal-digit / \"_\"")
          (or (cst-list-list-conc-matchp abnf::cstss "octal-digit")
              (cst-list-list-conc-matchp abnf::cstss "\"_\""))))

Theorem: cst-binary-numeral-concs

(defthm cst-binary-numeral-concs
 (implies
  (cst-list-list-alt-matchp abnf::cstss "\"0b\" binary-digits")
  (or
     (cst-list-list-conc-matchp abnf::cstss "\"0b\" binary-digits"))))

Theorem: cst-binary-digits-concs

(defthm cst-binary-digits-concs
 (implies
  (cst-list-list-alt-matchp
   abnf::cstss
   "binary-digit / binary-digit [ binary-digits-and-underscores ] binary-digit")
  (or
   (cst-list-list-conc-matchp abnf::cstss "binary-digit")
   (cst-list-list-conc-matchp
    abnf::cstss
    "binary-digit [ binary-digits-and-underscores ] binary-digit"))))

Theorem: cst-binary-digit-concs

(defthm cst-binary-digit-concs
  (implies (cst-list-list-alt-matchp abnf::cstss "\"0\" / \"1\"")
           (or (cst-list-list-conc-matchp abnf::cstss "\"0\"")
               (cst-list-list-conc-matchp abnf::cstss "\"1\""))))

Theorem: cst-binary-digits-and-underscores-concs

(defthm cst-binary-digits-and-underscores-concs
 (implies
   (cst-list-list-alt-matchp abnf::cstss
                             "1*binary-digit-or-underscore")
   (or (cst-list-list-conc-matchp abnf::cstss
                                  "1*binary-digit-or-underscore"))))

Theorem: cst-binary-digit-or-underscore-concs

(defthm cst-binary-digit-or-underscore-concs
  (implies
       (cst-list-list-alt-matchp abnf::cstss "binary-digit / \"_\"")
       (or (cst-list-list-conc-matchp abnf::cstss "binary-digit")
           (cst-list-list-conc-matchp abnf::cstss "\"_\""))))

Theorem: cst-floating-point-literal-concs

(defthm cst-floating-point-literal-concs
 (implies
  (cst-list-list-alt-matchp
   abnf::cstss
   "decimal-floating-point-literal / hexadecimal-floating-point-literal")
  (or (cst-list-list-conc-matchp abnf::cstss
                                 "decimal-floating-point-literal")
      (cst-list-list-conc-matchp
           abnf::cstss
           "hexadecimal-floating-point-literal"))))

Theorem: cst-decimal-floating-point-literal-concs

(defthm cst-decimal-floating-point-literal-concs
 (implies
  (cst-list-list-alt-matchp
   abnf::cstss
   "digits \".\" [ digits ] [ exponent-part ] [ float-type-suffix ] / \".\" digits [ exponent-part ] [ float-type-suffix ] / digits exponent-part [ float-type-suffix ] / digits [ exponent-part ] float-type-suffix")
  (or
   (cst-list-list-conc-matchp
    abnf::cstss
    "digits \".\" [ digits ] [ exponent-part ] [ float-type-suffix ]")
   (cst-list-list-conc-matchp
        abnf::cstss
        "\".\" digits [ exponent-part ] [ float-type-suffix ]")
   (cst-list-list-conc-matchp
        abnf::cstss
        "digits exponent-part [ float-type-suffix ]")
   (cst-list-list-conc-matchp
        abnf::cstss
        "digits [ exponent-part ] float-type-suffix"))))

Theorem: cst-exponent-part-concs

(defthm cst-exponent-part-concs
 (implies
      (cst-list-list-alt-matchp abnf::cstss
                                "exponent-indicator signed-integer")
      (or (cst-list-list-conc-matchp
               abnf::cstss
               "exponent-indicator signed-integer"))))

Theorem: cst-exponent-indicator-concs

(defthm cst-exponent-indicator-concs
  (implies (cst-list-list-alt-matchp abnf::cstss "\"e\"")
           (or (cst-list-list-conc-matchp abnf::cstss "\"e\""))))

Theorem: cst-signed-integer-concs

(defthm cst-signed-integer-concs
 (implies
    (cst-list-list-alt-matchp abnf::cstss "[ sign ] digits")
    (or (cst-list-list-conc-matchp abnf::cstss "[ sign ] digits"))))

Theorem: cst-sign-concs

(defthm cst-sign-concs
  (implies (cst-list-list-alt-matchp abnf::cstss "\"+\" / \"-\"")
           (or (cst-list-list-conc-matchp abnf::cstss "\"+\"")
               (cst-list-list-conc-matchp abnf::cstss "\"-\""))))

Theorem: cst-float-type-suffix-concs

(defthm cst-float-type-suffix-concs
  (implies (cst-list-list-alt-matchp abnf::cstss "\"f\" / \"d\"")
           (or (cst-list-list-conc-matchp abnf::cstss "\"f\"")
               (cst-list-list-conc-matchp abnf::cstss "\"d\""))))

Theorem: cst-hexadecimal-floating-point-literal-concs

(defthm cst-hexadecimal-floating-point-literal-concs
 (implies
  (cst-list-list-alt-matchp
       abnf::cstss
       "hex-significand binary-exponent [ float-type-suffix ]")
  (or
    (cst-list-list-conc-matchp
         abnf::cstss
         "hex-significand binary-exponent [ float-type-suffix ]"))))

Theorem: cst-hex-significand-concs

(defthm cst-hex-significand-concs
 (implies
   (cst-list-list-alt-matchp
        abnf::cstss
        "hex-numeral [ \".\" ] / \"0x\" [ hex-digits ] \".\" hex-digits")
   (or (cst-list-list-conc-matchp abnf::cstss "hex-numeral [ \".\" ]")
       (cst-list-list-conc-matchp
            abnf::cstss
            "\"0x\" [ hex-digits ] \".\" hex-digits"))))

Theorem: cst-binary-exponent-concs

(defthm cst-binary-exponent-concs
  (implies (cst-list-list-alt-matchp
                abnf::cstss
                "binary-exponent-indicator signed-integer")
           (or (cst-list-list-conc-matchp
                    abnf::cstss
                    "binary-exponent-indicator signed-integer"))))

Theorem: cst-binary-exponent-indicator-concs

(defthm cst-binary-exponent-indicator-concs
  (implies (cst-list-list-alt-matchp abnf::cstss "\"p\"")
           (or (cst-list-list-conc-matchp abnf::cstss "\"p\""))))

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-character-literal-concs

(defthm cst-character-literal-concs
  (implies
       (cst-list-list-alt-matchp
            abnf::cstss
            "\"'\" single-character \"'\" / \"'\" escape-sequence \"'\"")
       (or (cst-list-list-conc-matchp
                abnf::cstss "\"'\" single-character \"'\"")
           (cst-list-list-conc-matchp abnf::cstss
                                      "\"'\" escape-sequence \"'\""))))

Theorem: cst-single-character-concs

(defthm cst-single-character-concs
 (implies
    (cst-list-list-alt-matchp abnf::cstss "input-character")
    (or (cst-list-list-conc-matchp abnf::cstss "input-character"))))

Theorem: cst-string-literal-concs

(defthm cst-string-literal-concs
 (implies
    (cst-list-list-alt-matchp abnf::cstss
                              "%d34 *string-character %d34")
    (or (cst-list-list-conc-matchp abnf::cstss
                                   "%d34 *string-character %d34"))))

Theorem: cst-string-character-concs

(defthm cst-string-character-concs
 (implies
    (cst-list-list-alt-matchp abnf::cstss
                              "input-character / escape-sequence")
    (or (cst-list-list-conc-matchp abnf::cstss "input-character")
        (cst-list-list-conc-matchp abnf::cstss "escape-sequence"))))

Theorem: cst-text-block-concs

(defthm cst-text-block-concs
 (implies
  (cst-list-list-alt-matchp
   abnf::cstss
   "%d34 %d34 %d34 *text-block-white-space line-terminator *text-block-character %d34 %d34 %d34")
  (or
   (cst-list-list-conc-matchp
    abnf::cstss
    "%d34 %d34 %d34 *text-block-white-space line-terminator *text-block-character %d34 %d34 %d34"))))

Theorem: cst-text-block-white-space-concs

(defthm cst-text-block-white-space-concs
  (implies
       (cst-list-list-alt-matchp abnf::cstss "white-space")
       (or (cst-list-list-conc-matchp abnf::cstss "white-space"))))

Theorem: cst-text-block-character-concs

(defthm cst-text-block-character-concs
 (implies
    (cst-list-list-alt-matchp
         abnf::cstss
         "input-character / escape-sequence / line-terminator")
    (or (cst-list-list-conc-matchp abnf::cstss "input-character")
        (cst-list-list-conc-matchp abnf::cstss "escape-sequence")
        (cst-list-list-conc-matchp abnf::cstss "line-terminator"))))

Theorem: cst-escape-sequence-concs

(defthm cst-escape-sequence-concs
 (implies
  (cst-list-list-alt-matchp
   abnf::cstss
   "%s\"\\b\" / %s\"\\s\" / %s\"\\t\" / %s\"\\n\" / %s\"\\f\" / %s\"\\r\" / line-terminator / \"\\\" %d34 / \"\\'\" / \"\\\\\" / octal-escape")
  (or (cst-list-list-conc-matchp abnf::cstss "%s\"\\b\"")
      (cst-list-list-conc-matchp abnf::cstss "%s\"\\s\"")
      (cst-list-list-conc-matchp abnf::cstss "%s\"\\t\"")
      (cst-list-list-conc-matchp abnf::cstss "%s\"\\n\"")
      (cst-list-list-conc-matchp abnf::cstss "%s\"\\f\"")
      (cst-list-list-conc-matchp abnf::cstss "%s\"\\r\"")
      (cst-list-list-conc-matchp abnf::cstss "line-terminator")
      (cst-list-list-conc-matchp abnf::cstss "\"\\\" %d34")
      (cst-list-list-conc-matchp abnf::cstss "\"\\'\"")
      (cst-list-list-conc-matchp abnf::cstss "\"\\\\\"")
      (cst-list-list-conc-matchp abnf::cstss "octal-escape"))))

Theorem: cst-octal-escape-concs

(defthm cst-octal-escape-concs
 (implies
  (cst-list-list-alt-matchp
   abnf::cstss
   "\"\\\" octal-digit / \"\\\" octal-digit octal-digit / \"\\\" zero-to-three octal-digit octal-digit")
  (or (cst-list-list-conc-matchp abnf::cstss "\"\\\" octal-digit")
      (cst-list-list-conc-matchp abnf::cstss
                                 "\"\\\" octal-digit octal-digit")
      (cst-list-list-conc-matchp
           abnf::cstss
           "\"\\\" zero-to-three octal-digit octal-digit"))))

Theorem: cst-zero-to-three-concs

(defthm cst-zero-to-three-concs
 (implies
      (cst-list-list-alt-matchp abnf::cstss "\"0\" / \"1\" / \"2\" / \"3\"")
      (or (cst-list-list-conc-matchp abnf::cstss "\"0\"")
          (cst-list-list-conc-matchp abnf::cstss "\"1\"")
          (cst-list-list-conc-matchp abnf::cstss "\"2\"")
          (cst-list-list-conc-matchp abnf::cstss "\"3\""))))

Theorem: cst-null-literal-concs

(defthm cst-null-literal-concs
  (implies (cst-list-list-alt-matchp abnf::cstss "%s\"null\"")
           (or (cst-list-list-conc-matchp abnf::cstss "%s\"null\""))))

Theorem: cst-separator-concs

(defthm cst-separator-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 "\"::\""))))

Theorem: cst-operator-concs

(defthm cst-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 "\"||\"")
      (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-type-concs

(defthm cst-type-concs
 (implies
     (cst-list-list-alt-matchp abnf::cstss
                               "primitive-type / reference-type")
     (or (cst-list-list-conc-matchp abnf::cstss "primitive-type")
         (cst-list-list-conc-matchp abnf::cstss "reference-type"))))

Theorem: cst-primitive-type-concs

(defthm cst-primitive-type-concs
  (implies
       (cst-list-list-alt-matchp
            abnf::cstss
            "*annotation numeric-type / *annotation %s\"boolean\"")
       (or (cst-list-list-conc-matchp
                abnf::cstss "*annotation numeric-type")
           (cst-list-list-conc-matchp abnf::cstss
                                      "*annotation %s\"boolean\""))))

Theorem: cst-numeric-type-concs

(defthm cst-numeric-type-concs
 (implies
  (cst-list-list-alt-matchp abnf::cstss
                            "integral-type / floating-point-type")
  (or
    (cst-list-list-conc-matchp abnf::cstss "integral-type")
    (cst-list-list-conc-matchp abnf::cstss "floating-point-type"))))

Theorem: cst-integral-type-concs

(defthm cst-integral-type-concs
  (implies
       (cst-list-list-alt-matchp
            abnf::cstss
            "%s\"byte\" / %s\"short\" / %s\"int\" / %s\"long\" / %s\"char\"")
       (or (cst-list-list-conc-matchp abnf::cstss "%s\"byte\"")
           (cst-list-list-conc-matchp abnf::cstss "%s\"short\"")
           (cst-list-list-conc-matchp abnf::cstss "%s\"int\"")
           (cst-list-list-conc-matchp abnf::cstss "%s\"long\"")
           (cst-list-list-conc-matchp abnf::cstss "%s\"char\""))))

Theorem: cst-floating-point-type-concs

(defthm cst-floating-point-type-concs
 (implies
     (cst-list-list-alt-matchp abnf::cstss "%s\"float\" / %s\"double\"")
     (or (cst-list-list-conc-matchp abnf::cstss "%s\"float\"")
         (cst-list-list-conc-matchp abnf::cstss "%s\"double\""))))

Theorem: cst-reference-type-concs

(defthm cst-reference-type-concs
 (implies
  (cst-list-list-alt-matchp
       abnf::cstss
       "class-or-interface-type / type-variable / array-type")
  (or
   (cst-list-list-conc-matchp abnf::cstss "class-or-interface-type")
   (cst-list-list-conc-matchp abnf::cstss "type-variable")
   (cst-list-list-conc-matchp abnf::cstss "array-type"))))

Theorem: cst-class-or-interface-type-concs

(defthm cst-class-or-interface-type-concs
 (implies
     (cst-list-list-alt-matchp abnf::cstss
                               "class-type / interface-type")
     (or (cst-list-list-conc-matchp abnf::cstss "class-type")
         (cst-list-list-conc-matchp abnf::cstss "interface-type"))))

Theorem: cst-class-type-concs

(defthm cst-class-type-concs
 (implies
  (cst-list-list-alt-matchp
   abnf::cstss
   "*annotation type-identifier [ type-arguments ] / package-name \".\" *annotation type-identifier [ type-arguments ] / class-or-interface-type \".\" *annotation type-identifier [ type-arguments ]")
  (or
   (cst-list-list-conc-matchp
        abnf::cstss
        "*annotation type-identifier [ type-arguments ]")
   (cst-list-list-conc-matchp
    abnf::cstss
    "package-name \".\" *annotation type-identifier [ type-arguments ]")
   (cst-list-list-conc-matchp
    abnf::cstss
    "class-or-interface-type \".\" *annotation type-identifier [ type-arguments ]"))))

Theorem: cst-interface-type-concs

(defthm cst-interface-type-concs
  (implies
       (cst-list-list-alt-matchp abnf::cstss "class-type")
       (or (cst-list-list-conc-matchp abnf::cstss "class-type"))))

Theorem: cst-type-variable-concs

(defthm cst-type-variable-concs
 (implies
    (cst-list-list-alt-matchp abnf::cstss
                              "*annotation type-identifier")
    (or (cst-list-list-conc-matchp abnf::cstss
                                   "*annotation type-identifier"))))

Theorem: cst-array-type-concs

(defthm cst-array-type-concs
 (implies
  (cst-list-list-alt-matchp
   abnf::cstss
   "primitive-type dims / class-or-interface-type dims / type-variable dims")
  (or
     (cst-list-list-conc-matchp abnf::cstss "primitive-type dims")
     (cst-list-list-conc-matchp abnf::cstss
                                "class-or-interface-type dims")
     (cst-list-list-conc-matchp abnf::cstss "type-variable dims"))))

Theorem: cst-dims-concs

(defthm cst-dims-concs
 (implies
  (cst-list-list-alt-matchp abnf::cstss "1*( *annotation \"[\" \"]\" )")
  (or (cst-list-list-conc-matchp abnf::cstss
                                 "1*( *annotation \"[\" \"]\" )"))))

Theorem: cst-type-parameter-concs

(defthm cst-type-parameter-concs
 (implies
  (cst-list-list-alt-matchp
       abnf::cstss
       "*type-parameter-modifier type-identifier [ type-bound ]")
  (or
   (cst-list-list-conc-matchp
       abnf::cstss
       "*type-parameter-modifier type-identifier [ type-bound ]"))))

Theorem: cst-type-parameter-modifier-concs

(defthm cst-type-parameter-modifier-concs
  (implies
       (cst-list-list-alt-matchp abnf::cstss "annotation")
       (or (cst-list-list-conc-matchp abnf::cstss "annotation"))))

Theorem: cst-type-bound-concs

(defthm cst-type-bound-concs
 (implies
  (cst-list-list-alt-matchp
   abnf::cstss
   "%s\"extends\" type-variable / %s\"extends\" class-or-interface-type *additional-bound")
  (or
    (cst-list-list-conc-matchp
         abnf::cstss "%s\"extends\" type-variable")
    (cst-list-list-conc-matchp
         abnf::cstss
         "%s\"extends\" class-or-interface-type *additional-bound"))))

Theorem: cst-additional-bound-concs

(defthm cst-additional-bound-concs
 (implies
  (cst-list-list-alt-matchp abnf::cstss "\"&\" interface-type")
  (or
     (cst-list-list-conc-matchp abnf::cstss "\"&\" interface-type"))))

Theorem: cst-type-arguments-concs

(defthm cst-type-arguments-concs
 (implies
     (cst-list-list-alt-matchp abnf::cstss
                               "\"<\" type-argument-list \">\"")
     (or (cst-list-list-conc-matchp abnf::cstss
                                    "\"<\" type-argument-list \">\""))))

Theorem: cst-type-argument-list-concs

(defthm cst-type-argument-list-concs
 (implies
   (cst-list-list-alt-matchp abnf::cstss
                             "type-argument *( \",\" type-argument )")
   (or (cst-list-list-conc-matchp
            abnf::cstss
            "type-argument *( \",\" type-argument )"))))

Theorem: cst-type-argument-concs

(defthm cst-type-argument-concs
 (implies
  (cst-list-list-alt-matchp abnf::cstss "reference-type / wildcard")
  (or (cst-list-list-conc-matchp abnf::cstss "reference-type")
      (cst-list-list-conc-matchp abnf::cstss "wildcard"))))

Theorem: cst-wildcard-concs

(defthm cst-wildcard-concs
 (implies
    (cst-list-list-alt-matchp abnf::cstss
                              "*annotation \"?\" [ wildcard-bounds ]")
    (or (cst-list-list-conc-matchp
             abnf::cstss
             "*annotation \"?\" [ wildcard-bounds ]"))))

Theorem: cst-wildcard-bounds-concs

(defthm cst-wildcard-bounds-concs
  (implies
       (cst-list-list-alt-matchp
            abnf::cstss
            "%s\"extends\" reference-type / %s\"super\" reference-type")
       (or (cst-list-list-conc-matchp abnf::cstss
                                      "%s\"extends\" reference-type")
           (cst-list-list-conc-matchp abnf::cstss
                                      "%s\"super\" reference-type"))))

Theorem: cst-module-name-concs

(defthm cst-module-name-concs
 (implies
     (cst-list-list-alt-matchp
          abnf::cstss
          "identifier / module-name \".\" identifier")
     (or (cst-list-list-conc-matchp abnf::cstss "identifier")
         (cst-list-list-conc-matchp abnf::cstss
                                    "module-name \".\" identifier"))))

Theorem: cst-package-name-concs

(defthm cst-package-name-concs
 (implies
    (cst-list-list-alt-matchp
         abnf::cstss
         "identifier / package-name \".\" identifier")
    (or (cst-list-list-conc-matchp abnf::cstss "identifier")
        (cst-list-list-conc-matchp abnf::cstss
                                   "package-name \".\" identifier"))))

Theorem: cst-type-name-concs

(defthm cst-type-name-concs
 (implies
  (cst-list-list-alt-matchp
       abnf::cstss
       "type-identifier / package-or-type-name \".\" type-identifier")
  (or (cst-list-list-conc-matchp abnf::cstss "type-identifier")
      (cst-list-list-conc-matchp
           abnf::cstss
           "package-or-type-name \".\" type-identifier"))))

Theorem: cst-package-or-type-name-concs

(defthm cst-package-or-type-name-concs
  (implies (cst-list-list-alt-matchp
                abnf::cstss
                "identifier / package-or-type-name \".\" identifier")
           (or (cst-list-list-conc-matchp abnf::cstss "identifier")
               (cst-list-list-conc-matchp
                    abnf::cstss
                    "package-or-type-name \".\" identifier"))))

Theorem: cst-expression-name-concs

(defthm cst-expression-name-concs
 (implies
  (cst-list-list-alt-matchp
       abnf::cstss
       "identifier / ambiguous-name \".\" identifier")
  (or (cst-list-list-conc-matchp abnf::cstss "identifier")
      (cst-list-list-conc-matchp abnf::cstss
                                 "ambiguous-name \".\" identifier"))))

Theorem: cst-method-name-concs

(defthm cst-method-name-concs
 (implies
  (cst-list-list-alt-matchp abnf::cstss
                            "unqualified-method-identifier")
  (or (cst-list-list-conc-matchp abnf::cstss
                                 "unqualified-method-identifier"))))

Theorem: cst-ambiguous-name-concs

(defthm cst-ambiguous-name-concs
 (implies
  (cst-list-list-alt-matchp
       abnf::cstss
       "identifier / ambiguous-name \".\" identifier")
  (or (cst-list-list-conc-matchp abnf::cstss "identifier")
      (cst-list-list-conc-matchp abnf::cstss
                                 "ambiguous-name \".\" identifier"))))

Theorem: cst-compilation-unit-concs

(defthm cst-compilation-unit-concs
 (implies
  (cst-list-list-alt-matchp
   abnf::cstss
   "ordinary-compilation-unit / compact-compilation-unit / modular-compilation-unit")
  (or (cst-list-list-conc-matchp
           abnf::cstss "ordinary-compilation-unit")
      (cst-list-list-conc-matchp
           abnf::cstss "compact-compilation-unit")
      (cst-list-list-conc-matchp abnf::cstss
                                 "modular-compilation-unit"))))

Theorem: cst-ordinary-compilation-unit-concs

(defthm cst-ordinary-compilation-unit-concs
 (implies
  (cst-list-list-alt-matchp
   abnf::cstss
   "[ package-declaration ] *import-declaration *top-level-class-or-interface-declaration")
  (or
   (cst-list-list-conc-matchp
    abnf::cstss
    "[ package-declaration ] *import-declaration *top-level-class-or-interface-declaration"))))

Theorem: cst-compact-compilation-unit-concs

(defthm cst-compact-compilation-unit-concs
 (implies
  (cst-list-list-alt-matchp
   abnf::cstss
   "*import-declaration *class-member-declaration-no-method *method-declaration *class-member-declaration")
  (or
   (cst-list-list-conc-matchp
    abnf::cstss
    "*import-declaration *class-member-declaration-no-method *method-declaration *class-member-declaration"))))

Theorem: cst-class-member-declaration-no-method-concs

(defthm cst-class-member-declaration-no-method-concs
 (implies
  (cst-list-list-alt-matchp
   abnf::cstss
   "field-declaration / class-declaration / interface-declaration / \";\"")
  (or
     (cst-list-list-conc-matchp abnf::cstss "field-declaration")
     (cst-list-list-conc-matchp abnf::cstss "class-declaration")
     (cst-list-list-conc-matchp abnf::cstss "interface-declaration")
     (cst-list-list-conc-matchp abnf::cstss "\";\""))))

Theorem: cst-modular-compilation-unit-concs

(defthm cst-modular-compilation-unit-concs
  (implies (cst-list-list-alt-matchp
                abnf::cstss
                "*import-declaration module-declaration")
           (or (cst-list-list-conc-matchp
                    abnf::cstss
                    "*import-declaration module-declaration"))))

Theorem: cst-package-declaration-concs

(defthm cst-package-declaration-concs
 (implies
  (cst-list-list-alt-matchp
   abnf::cstss
   "*package-modifier %s\"package\" identifier *( \".\" identifier ) \";\"")
  (or
   (cst-list-list-conc-matchp
    abnf::cstss
    "*package-modifier %s\"package\" identifier *( \".\" identifier ) \";\""))))

Theorem: cst-package-modifier-concs

(defthm cst-package-modifier-concs
  (implies
       (cst-list-list-alt-matchp abnf::cstss "annotation")
       (or (cst-list-list-conc-matchp abnf::cstss "annotation"))))

Theorem: cst-import-declaration-concs

(defthm cst-import-declaration-concs
 (implies
  (cst-list-list-alt-matchp
   abnf::cstss
   "single-type-import-declaration / type-import-on-demand-declaration / single-static-import-declaration / static-import-on-demand-declaration / single-module-import-declaration")
  (or
   (cst-list-list-conc-matchp abnf::cstss
                              "single-type-import-declaration")
   (cst-list-list-conc-matchp abnf::cstss
                              "type-import-on-demand-declaration")
   (cst-list-list-conc-matchp abnf::cstss
                              "single-static-import-declaration")
   (cst-list-list-conc-matchp abnf::cstss
                              "static-import-on-demand-declaration")
   (cst-list-list-conc-matchp abnf::cstss
                              "single-module-import-declaration"))))

Theorem: cst-single-type-import-declaration-concs

(defthm cst-single-type-import-declaration-concs
 (implies
   (cst-list-list-alt-matchp abnf::cstss "%s\"import\" type-name \";\"")
   (or (cst-list-list-conc-matchp abnf::cstss
                                  "%s\"import\" type-name \";\""))))

Theorem: cst-type-import-on-demand-declaration-concs

(defthm cst-type-import-on-demand-declaration-concs
 (implies (cst-list-list-alt-matchp
               abnf::cstss
               "%s\"import\" package-or-type-name \".\" \"*\" \";\"")
          (or (cst-list-list-conc-matchp
                   abnf::cstss
                   "%s\"import\" package-or-type-name \".\" \"*\" \";\""))))

Theorem: cst-single-static-import-declaration-concs

(defthm cst-single-static-import-declaration-concs
 (implies
   (cst-list-list-alt-matchp
        abnf::cstss
        "%s\"import\" %s\"static\" type-name \".\" identifier \";\"")
   (or (cst-list-list-conc-matchp
            abnf::cstss
            "%s\"import\" %s\"static\" type-name \".\" identifier \";\""))))

Theorem: cst-static-import-on-demand-declaration-concs

(defthm cst-static-import-on-demand-declaration-concs
 (implies (cst-list-list-alt-matchp
               abnf::cstss
               "%s\"import\" %s\"static\" type-name \".\" \"*\" \";\"")
          (or (cst-list-list-conc-matchp
                   abnf::cstss
                   "%s\"import\" %s\"static\" type-name \".\" \"*\" \";\""))))

Theorem: cst-single-module-import-declaration-concs

(defthm cst-single-module-import-declaration-concs
 (implies
  (cst-list-list-alt-matchp abnf::cstss
                            "%s\"import\" %s\"module\" module-name \";\"")
  (or (cst-list-list-conc-matchp
           abnf::cstss
           "%s\"import\" %s\"module\" module-name \";\""))))

Theorem: cst-top-level-class-or-interface-declaration-concs

(defthm cst-top-level-class-or-interface-declaration-concs
 (implies
  (cst-list-list-alt-matchp
       abnf::cstss
       "class-declaration / interface-declaration / \";\"")
  (or
     (cst-list-list-conc-matchp abnf::cstss "class-declaration")
     (cst-list-list-conc-matchp abnf::cstss "interface-declaration")
     (cst-list-list-conc-matchp abnf::cstss "\";\""))))

Theorem: cst-module-declaration-concs

(defthm cst-module-declaration-concs
 (implies
  (cst-list-list-alt-matchp
   abnf::cstss
   "*annotation [ %s\"open\" ] %s\"module\" identifier *( \".\" identifier ) \"{\" *module-directive \"}\"")
  (or
   (cst-list-list-conc-matchp
    abnf::cstss
    "*annotation [ %s\"open\" ] %s\"module\" identifier *( \".\" identifier ) \"{\" *module-directive \"}\""))))

Theorem: cst-module-directive-concs

(defthm cst-module-directive-concs
 (implies
  (cst-list-list-alt-matchp
   abnf::cstss
   "%s\"requires\" *requires-modifier module-name \";\" / %s\"exports\" package-name [ %s\"to\" module-name *( \",\" module-name ) ] \";\" / %s\"opens\" package-name [ %s\"to\" module-name *( \",\" module-name ) ] \";\" / %s\"uses\" type-name \";\" / %s\"provides\" type-name %s\"with\" type-name *( \",\" type-name ) \";\"")
  (or
   (cst-list-list-conc-matchp
        abnf::cstss
        "%s\"requires\" *requires-modifier module-name \";\"")
   (cst-list-list-conc-matchp
    abnf::cstss
    "%s\"exports\" package-name [ %s\"to\" module-name *( \",\" module-name ) ] \";\"")
   (cst-list-list-conc-matchp
    abnf::cstss
    "%s\"opens\" package-name [ %s\"to\" module-name *( \",\" module-name ) ] \";\"")
   (cst-list-list-conc-matchp abnf::cstss "%s\"uses\" type-name \";\"")
   (cst-list-list-conc-matchp
    abnf::cstss
    "%s\"provides\" type-name %s\"with\" type-name *( \",\" type-name ) \";\""))))

Theorem: cst-requires-modifier-concs

(defthm cst-requires-modifier-concs
  (implies
       (cst-list-list-alt-matchp abnf::cstss
                                 "%s\"transitive\" / %s\"static\"")
       (or (cst-list-list-conc-matchp abnf::cstss "%s\"transitive\"")
           (cst-list-list-conc-matchp abnf::cstss "%s\"static\""))))

Theorem: cst-class-declaration-concs

(defthm cst-class-declaration-concs
 (implies
  (cst-list-list-alt-matchp
   abnf::cstss
   "normal-class-declaration / enum-declaration / record-declaration")
  (or
     (cst-list-list-conc-matchp
          abnf::cstss "normal-class-declaration")
     (cst-list-list-conc-matchp abnf::cstss "enum-declaration")
     (cst-list-list-conc-matchp abnf::cstss "record-declaration"))))

Theorem: cst-normal-class-declaration-concs

(defthm cst-normal-class-declaration-concs
 (implies
  (cst-list-list-alt-matchp
   abnf::cstss
   "*class-modifier %s\"class\" type-identifier [ type-parameters ] [ class-extends ] [ class-implements ] [ class-permits ] class-body")
  (or
   (cst-list-list-conc-matchp
    abnf::cstss
    "*class-modifier %s\"class\" type-identifier [ type-parameters ] [ class-extends ] [ class-implements ] [ class-permits ] class-body"))))

Theorem: cst-class-modifier-concs

(defthm cst-class-modifier-concs
 (implies
  (cst-list-list-alt-matchp
   abnf::cstss
   "annotation / %s\"public\" / %s\"protected\" / %s\"private\" / %s\"abstract\" / %s\"static\" / %s\"final\" / %s\"sealed\" / %s\"non-sealed\" / %s\"strictfp\"")
  (or (cst-list-list-conc-matchp abnf::cstss "annotation")
      (cst-list-list-conc-matchp abnf::cstss "%s\"public\"")
      (cst-list-list-conc-matchp abnf::cstss "%s\"protected\"")
      (cst-list-list-conc-matchp abnf::cstss "%s\"private\"")
      (cst-list-list-conc-matchp abnf::cstss "%s\"abstract\"")
      (cst-list-list-conc-matchp abnf::cstss "%s\"static\"")
      (cst-list-list-conc-matchp abnf::cstss "%s\"final\"")
      (cst-list-list-conc-matchp abnf::cstss "%s\"sealed\"")
      (cst-list-list-conc-matchp abnf::cstss "%s\"non-sealed\"")
      (cst-list-list-conc-matchp abnf::cstss "%s\"strictfp\""))))

Theorem: cst-type-parameters-concs

(defthm cst-type-parameters-concs
 (implies
    (cst-list-list-alt-matchp abnf::cstss
                              "\"<\" type-parameter-list \">\"")
    (or (cst-list-list-conc-matchp abnf::cstss
                                   "\"<\" type-parameter-list \">\""))))

Theorem: cst-type-parameter-list-concs

(defthm cst-type-parameter-list-concs
  (implies (cst-list-list-alt-matchp
                abnf::cstss
                "type-parameter *( \",\" type-parameter )")
           (or (cst-list-list-conc-matchp
                    abnf::cstss
                    "type-parameter *( \",\" type-parameter )"))))

Theorem: cst-class-extends-concs

(defthm cst-class-extends-concs
 (implies
     (cst-list-list-alt-matchp abnf::cstss "%s\"extends\" class-type")
     (or (cst-list-list-conc-matchp
              abnf::cstss "%s\"extends\" class-type"))))

Theorem: cst-class-implements-concs

(defthm cst-class-implements-concs
 (implies
     (cst-list-list-alt-matchp abnf::cstss
                               "%s\"implements\" interface-type-list")
     (or (cst-list-list-conc-matchp
              abnf::cstss
              "%s\"implements\" interface-type-list"))))

Theorem: cst-interface-type-list-concs

(defthm cst-interface-type-list-concs
  (implies (cst-list-list-alt-matchp
                abnf::cstss
                "interface-type *( \",\" interface-type )")
           (or (cst-list-list-conc-matchp
                    abnf::cstss
                    "interface-type *( \",\" interface-type )"))))

Theorem: cst-class-permits-concs

(defthm cst-class-permits-concs
  (implies (cst-list-list-alt-matchp
                abnf::cstss
                "%s\"permits\" type-name *( \",\" type-name )")
           (or (cst-list-list-conc-matchp
                    abnf::cstss
                    "%s\"permits\" type-name *( \",\" type-name )"))))

Theorem: cst-class-body-concs

(defthm cst-class-body-concs
 (implies
  (cst-list-list-alt-matchp abnf::cstss
                            "\"{\" *class-body-declaration \"}\"")
  (or
    (cst-list-list-conc-matchp abnf::cstss
                               "\"{\" *class-body-declaration \"}\""))))

Theorem: cst-class-body-declaration-concs

(defthm cst-class-body-declaration-concs
 (implies
  (cst-list-list-alt-matchp
   abnf::cstss
   "class-member-declaration / instance-initializer / static-initializer / constructor-declaration")
  (or (cst-list-list-conc-matchp
           abnf::cstss "class-member-declaration")
      (cst-list-list-conc-matchp abnf::cstss "instance-initializer")
      (cst-list-list-conc-matchp abnf::cstss "static-initializer")
      (cst-list-list-conc-matchp abnf::cstss
                                 "constructor-declaration"))))

Theorem: cst-class-member-declaration-concs

(defthm cst-class-member-declaration-concs
 (implies
  (cst-list-list-alt-matchp
   abnf::cstss
   "field-declaration / method-declaration / class-declaration / interface-declaration / \";\"")
  (or
     (cst-list-list-conc-matchp abnf::cstss "field-declaration")
     (cst-list-list-conc-matchp abnf::cstss "method-declaration")
     (cst-list-list-conc-matchp abnf::cstss "class-declaration")
     (cst-list-list-conc-matchp abnf::cstss "interface-declaration")
     (cst-list-list-conc-matchp abnf::cstss "\";\""))))

Theorem: cst-field-declaration-concs

(defthm cst-field-declaration-concs
 (implies
  (cst-list-list-alt-matchp
       abnf::cstss
       "*field-modifier unann-type variable-declarator-list \";\"")
  (or
   (cst-list-list-conc-matchp
       abnf::cstss
       "*field-modifier unann-type variable-declarator-list \";\""))))

Theorem: cst-variable-declarator-list-concs

(defthm cst-variable-declarator-list-concs
 (implies
     (cst-list-list-alt-matchp
          abnf::cstss
          "variable-declarator *( \",\" variable-declarator )")
     (or (cst-list-list-conc-matchp
              abnf::cstss
              "variable-declarator *( \",\" variable-declarator )"))))

Theorem: cst-variable-declarator-concs

(defthm cst-variable-declarator-concs
 (implies
  (cst-list-list-alt-matchp
       abnf::cstss
       "variable-declarator-id [ \"=\" variable-initializer ]")
  (or (cst-list-list-conc-matchp
           abnf::cstss
           "variable-declarator-id [ \"=\" variable-initializer ]"))))

Theorem: cst-variable-declarator-id-concs

(defthm cst-variable-declarator-id-concs
 (implies
  (cst-list-list-alt-matchp abnf::cstss "identifier [ dims ] / \"_\"")
  (or (cst-list-list-conc-matchp abnf::cstss "identifier [ dims ]")
      (cst-list-list-conc-matchp abnf::cstss "\"_\""))))

Theorem: cst-variable-initializer-concs

(defthm cst-variable-initializer-concs
 (implies
  (cst-list-list-alt-matchp abnf::cstss
                            "expression / array-initializer")
  (or (cst-list-list-conc-matchp abnf::cstss "expression")
      (cst-list-list-conc-matchp abnf::cstss "array-initializer"))))

Theorem: cst-unann-type-concs

(defthm cst-unann-type-concs
 (implies
  (cst-list-list-alt-matchp
       abnf::cstss
       "unann-primitive-type / unann-reference-type")
  (or
   (cst-list-list-conc-matchp abnf::cstss "unann-primitive-type")
   (cst-list-list-conc-matchp abnf::cstss "unann-reference-type"))))

Theorem: cst-unann-primitive-type-concs

(defthm cst-unann-primitive-type-concs
  (implies
       (cst-list-list-alt-matchp abnf::cstss
                                 "numeric-type / %s\"boolean\"")
       (or (cst-list-list-conc-matchp abnf::cstss "numeric-type")
           (cst-list-list-conc-matchp abnf::cstss "%s\"boolean\""))))

Theorem: cst-unann-reference-type-concs

(defthm cst-unann-reference-type-concs
 (implies
  (cst-list-list-alt-matchp
   abnf::cstss
   "unann-class-or-interface-type / unann-type-variable / unann-array-type")
  (or (cst-list-list-conc-matchp abnf::cstss
                                 "unann-class-or-interface-type")
      (cst-list-list-conc-matchp abnf::cstss "unann-type-variable")
      (cst-list-list-conc-matchp abnf::cstss "unann-array-type"))))

Theorem: cst-unann-class-or-interface-type-concs

(defthm cst-unann-class-or-interface-type-concs
 (implies
  (cst-list-list-alt-matchp
       abnf::cstss
       "unann-class-type / unann-interface-type")
  (or
   (cst-list-list-conc-matchp abnf::cstss "unann-class-type")
   (cst-list-list-conc-matchp abnf::cstss "unann-interface-type"))))

Theorem: cst-unann-class-type-concs

(defthm cst-unann-class-type-concs
 (implies
  (cst-list-list-alt-matchp
   abnf::cstss
   "type-identifier [ type-arguments ] / package-name \".\" *annotation type-identifier [ type-arguments ] / unann-class-or-interface-type \".\" *annotation type-identifier [ type-arguments ]")
  (or
   (cst-list-list-conc-matchp abnf::cstss
                              "type-identifier [ type-arguments ]")
   (cst-list-list-conc-matchp
    abnf::cstss
    "package-name \".\" *annotation type-identifier [ type-arguments ]")
   (cst-list-list-conc-matchp
    abnf::cstss
    "unann-class-or-interface-type \".\" *annotation type-identifier [ type-arguments ]"))))

Theorem: cst-unann-interface-type-concs

(defthm cst-unann-interface-type-concs
 (implies
   (cst-list-list-alt-matchp abnf::cstss "unann-class-type")
   (or (cst-list-list-conc-matchp abnf::cstss "unann-class-type"))))

Theorem: cst-unann-type-variable-concs

(defthm cst-unann-type-variable-concs
 (implies
    (cst-list-list-alt-matchp abnf::cstss "type-identifier")
    (or (cst-list-list-conc-matchp abnf::cstss "type-identifier"))))

Theorem: cst-unann-array-type-concs

(defthm cst-unann-array-type-concs
 (implies
  (cst-list-list-alt-matchp
   abnf::cstss
   "unann-primitive-type dims / unann-class-or-interface-type dims / unann-type-variable dims")
  (or
    (cst-list-list-conc-matchp
         abnf::cstss "unann-primitive-type dims")
    (cst-list-list-conc-matchp abnf::cstss
                               "unann-class-or-interface-type dims")
    (cst-list-list-conc-matchp abnf::cstss
                               "unann-type-variable dims"))))

Theorem: cst-field-modifier-concs

(defthm cst-field-modifier-concs
 (implies
  (cst-list-list-alt-matchp
   abnf::cstss
   "annotation / %s\"public\" / %s\"protected\" / %s\"private\" / %s\"static\" / %s\"final\" / %s\"transient\" / %s\"volatile\"")
  (or (cst-list-list-conc-matchp abnf::cstss "annotation")
      (cst-list-list-conc-matchp abnf::cstss "%s\"public\"")
      (cst-list-list-conc-matchp abnf::cstss "%s\"protected\"")
      (cst-list-list-conc-matchp abnf::cstss "%s\"private\"")
      (cst-list-list-conc-matchp abnf::cstss "%s\"static\"")
      (cst-list-list-conc-matchp abnf::cstss "%s\"final\"")
      (cst-list-list-conc-matchp abnf::cstss "%s\"transient\"")
      (cst-list-list-conc-matchp abnf::cstss "%s\"volatile\""))))

Theorem: cst-method-declaration-concs

(defthm cst-method-declaration-concs
  (implies (cst-list-list-alt-matchp
                abnf::cstss
                "*method-modifier method-header method-body")
           (or (cst-list-list-conc-matchp
                    abnf::cstss
                    "*method-modifier method-header method-body"))))

Theorem: cst-method-header-concs

(defthm cst-method-header-concs
 (implies
  (cst-list-list-alt-matchp
   abnf::cstss
   "result method-declarator [ throws ] / type-parameters *annotation result method-declarator [ throws ]")
  (or
   (cst-list-list-conc-matchp abnf::cstss
                              "result method-declarator [ throws ]")
   (cst-list-list-conc-matchp
    abnf::cstss
    "type-parameters *annotation result method-declarator [ throws ]"))))

Theorem: cst-method-declarator-concs

(defthm cst-method-declarator-concs
 (implies
  (cst-list-list-alt-matchp
   abnf::cstss
   "identifier \"(\" [ receiver-parameter \",\" ] [ formal-parameter-list ] \")\" [ dims ]")
  (or
   (cst-list-list-conc-matchp
    abnf::cstss
    "identifier \"(\" [ receiver-parameter \",\" ] [ formal-parameter-list ] \")\" [ dims ]"))))

Theorem: cst-receiver-parameter-concs

(defthm cst-receiver-parameter-concs
 (implies
   (cst-list-list-alt-matchp
        abnf::cstss
        "*annotation unann-type [ identifier \".\" ] %s\"this\"")
   (or (cst-list-list-conc-matchp
            abnf::cstss
            "*annotation unann-type [ identifier \".\" ] %s\"this\""))))

Theorem: cst-formal-parameter-list-concs

(defthm cst-formal-parameter-list-concs
  (implies (cst-list-list-alt-matchp
                abnf::cstss
                "formal-parameter *( \",\" formal-parameter )")
           (or (cst-list-list-conc-matchp
                    abnf::cstss
                    "formal-parameter *( \",\" formal-parameter )"))))

Theorem: cst-formal-parameter-concs

(defthm cst-formal-parameter-concs
 (implies
  (cst-list-list-alt-matchp
   abnf::cstss
   "*variable-modifier unann-type variable-declarator-id / variable-arity-parameter")
  (or (cst-list-list-conc-matchp
           abnf::cstss
           "*variable-modifier unann-type variable-declarator-id")
      (cst-list-list-conc-matchp abnf::cstss
                                 "variable-arity-parameter"))))

Theorem: cst-variable-arity-parameter-concs

(defthm cst-variable-arity-parameter-concs
 (implies
  (cst-list-list-alt-matchp
       abnf::cstss
       "*variable-modifier unann-type *annotation \"...\" identifier")
  (or
   (cst-list-list-conc-matchp
    abnf::cstss
    "*variable-modifier unann-type *annotation \"...\" identifier"))))

Theorem: cst-variable-modifier-concs

(defthm cst-variable-modifier-concs
 (implies
     (cst-list-list-alt-matchp abnf::cstss "annotation / %s\"final\"")
     (or (cst-list-list-conc-matchp abnf::cstss "annotation")
         (cst-list-list-conc-matchp abnf::cstss "%s\"final\""))))

Theorem: cst-method-modifier-concs

(defthm cst-method-modifier-concs
 (implies
  (cst-list-list-alt-matchp
   abnf::cstss
   "annotation / %s\"public\" / %s\"protected\" / %s\"private\" / %s\"abstract\" / %s\"static\" / %s\"final\" / %s\"synchronized\" / %s\"native\" / %s\"strictfp\"")
  (or (cst-list-list-conc-matchp abnf::cstss "annotation")
      (cst-list-list-conc-matchp abnf::cstss "%s\"public\"")
      (cst-list-list-conc-matchp abnf::cstss "%s\"protected\"")
      (cst-list-list-conc-matchp abnf::cstss "%s\"private\"")
      (cst-list-list-conc-matchp abnf::cstss "%s\"abstract\"")
      (cst-list-list-conc-matchp abnf::cstss "%s\"static\"")
      (cst-list-list-conc-matchp abnf::cstss "%s\"final\"")
      (cst-list-list-conc-matchp abnf::cstss "%s\"synchronized\"")
      (cst-list-list-conc-matchp abnf::cstss "%s\"native\"")
      (cst-list-list-conc-matchp abnf::cstss "%s\"strictfp\""))))

Theorem: cst-result-concs

(defthm cst-result-concs
 (implies
      (cst-list-list-alt-matchp abnf::cstss "unann-type / %s\"void\"")
      (or (cst-list-list-conc-matchp abnf::cstss "unann-type")
          (cst-list-list-conc-matchp abnf::cstss "%s\"void\""))))

Theorem: cst-throws-concs

(defthm cst-throws-concs
 (implies
  (cst-list-list-alt-matchp abnf::cstss
                            "%s\"throws\" exception-type-list")
  (or
     (cst-list-list-conc-matchp abnf::cstss
                                "%s\"throws\" exception-type-list"))))

Theorem: cst-exception-type-list-concs

(defthm cst-exception-type-list-concs
  (implies (cst-list-list-alt-matchp
                abnf::cstss
                "exception-type *( \",\" exception-type )")
           (or (cst-list-list-conc-matchp
                    abnf::cstss
                    "exception-type *( \",\" exception-type )"))))

Theorem: cst-exception-type-concs

(defthm cst-exception-type-concs
 (implies
      (cst-list-list-alt-matchp abnf::cstss
                                "class-type / type-variable")
      (or (cst-list-list-conc-matchp abnf::cstss "class-type")
          (cst-list-list-conc-matchp abnf::cstss "type-variable"))))

Theorem: cst-method-body-concs

(defthm cst-method-body-concs
  (implies (cst-list-list-alt-matchp abnf::cstss "block / \";\"")
           (or (cst-list-list-conc-matchp abnf::cstss "block")
               (cst-list-list-conc-matchp abnf::cstss "\";\""))))

Theorem: cst-instance-initializer-concs

(defthm cst-instance-initializer-concs
  (implies (cst-list-list-alt-matchp abnf::cstss "block")
           (or (cst-list-list-conc-matchp abnf::cstss "block"))))

Theorem: cst-static-initializer-concs

(defthm cst-static-initializer-concs
 (implies
   (cst-list-list-alt-matchp abnf::cstss "%s\"static\" block")
   (or (cst-list-list-conc-matchp abnf::cstss "%s\"static\" block"))))

Theorem: cst-constructor-declaration-concs

(defthm cst-constructor-declaration-concs
 (implies
  (cst-list-list-alt-matchp
   abnf::cstss
   "*constructor-modifier constructor-declarator [ throws ] constructor-body")
  (or
   (cst-list-list-conc-matchp
    abnf::cstss
    "*constructor-modifier constructor-declarator [ throws ] constructor-body"))))

Theorem: cst-constructor-declarator-concs

(defthm cst-constructor-declarator-concs
 (implies
  (cst-list-list-alt-matchp
   abnf::cstss
   "[ type-parameters ] simple-type-name \"(\" [ receiver-parameter \",\" ] [ formal-parameter-list ] \")\"")
  (or
   (cst-list-list-conc-matchp
    abnf::cstss
    "[ type-parameters ] simple-type-name \"(\" [ receiver-parameter \",\" ] [ formal-parameter-list ] \")\""))))

Theorem: cst-simple-type-name-concs

(defthm cst-simple-type-name-concs
 (implies
    (cst-list-list-alt-matchp abnf::cstss "type-identifier")
    (or (cst-list-list-conc-matchp abnf::cstss "type-identifier"))))

Theorem: cst-constructor-modifier-concs

(defthm cst-constructor-modifier-concs
  (implies
       (cst-list-list-alt-matchp
            abnf::cstss
            "annotation / %s\"public\" / %s\"protected\" / %s\"private\"")
       (or (cst-list-list-conc-matchp abnf::cstss "annotation")
           (cst-list-list-conc-matchp abnf::cstss "%s\"public\"")
           (cst-list-list-conc-matchp abnf::cstss "%s\"protected\"")
           (cst-list-list-conc-matchp abnf::cstss "%s\"private\""))))

Theorem: cst-constructor-body-concs

(defthm cst-constructor-body-concs
 (implies
  (cst-list-list-alt-matchp
   abnf::cstss
   "\"{\" [ block-statements ] constructor-invocation [ block-statements ] \"}\" / \"{\" [ block-statements ] \"}\"")
  (or
   (cst-list-list-conc-matchp
    abnf::cstss
    "\"{\" [ block-statements ] constructor-invocation [ block-statements ] \"}\"")
   (cst-list-list-conc-matchp abnf::cstss
                              "\"{\" [ block-statements ] \"}\""))))

Theorem: cst-constructor-invocation-concs

(defthm cst-constructor-invocation-concs
 (implies
  (cst-list-list-alt-matchp
   abnf::cstss
   "[ type-arguments ] %s\"this\" \"(\" [ argument-list ] \")\" \";\" / [ type-arguments ] %s\"super\" \"(\" [ argument-list ] \")\" \";\" / expression-name \".\" [ type-arguments ] %s\"super\" \"(\" [ argument-list ] \")\" \";\" / primary \".\" [ type-arguments ] %s\"super\" \"(\" [ argument-list ] \")\" \";\"")
  (or
   (cst-list-list-conc-matchp
        abnf::cstss
        "[ type-arguments ] %s\"this\" \"(\" [ argument-list ] \")\" \";\"")
   (cst-list-list-conc-matchp
       abnf::cstss
       "[ type-arguments ] %s\"super\" \"(\" [ argument-list ] \")\" \";\"")
   (cst-list-list-conc-matchp
    abnf::cstss
    "expression-name \".\" [ type-arguments ] %s\"super\" \"(\" [ argument-list ] \")\" \";\"")
   (cst-list-list-conc-matchp
    abnf::cstss
    "primary \".\" [ type-arguments ] %s\"super\" \"(\" [ argument-list ] \")\" \";\""))))

Theorem: cst-enum-declaration-concs

(defthm cst-enum-declaration-concs
 (implies
  (cst-list-list-alt-matchp
   abnf::cstss
   "*class-modifier %s\"enum\" type-identifier [ class-implements ] enum-body")
  (or
   (cst-list-list-conc-matchp
    abnf::cstss
    "*class-modifier %s\"enum\" type-identifier [ class-implements ] enum-body"))))

Theorem: cst-enum-body-concs

(defthm cst-enum-body-concs
 (implies
  (cst-list-list-alt-matchp
   abnf::cstss
   "\"{\" [ enum-constant-list ] [ \",\" ] [ enum-body-declarations ] \"}\"")
  (or
   (cst-list-list-conc-matchp
    abnf::cstss
    "\"{\" [ enum-constant-list ] [ \",\" ] [ enum-body-declarations ] \"}\""))))

Theorem: cst-enum-constant-list-concs

(defthm cst-enum-constant-list-concs
 (implies
   (cst-list-list-alt-matchp abnf::cstss
                             "enum-constant *( \",\" enum-constant )")
   (or (cst-list-list-conc-matchp
            abnf::cstss
            "enum-constant *( \",\" enum-constant )"))))

Theorem: cst-enum-constant-concs

(defthm cst-enum-constant-concs
 (implies
  (cst-list-list-alt-matchp
   abnf::cstss
   "*enum-constant-modifier identifier [ \"(\" [ argument-list ] \")\" ] [ class-body ]")
  (or
   (cst-list-list-conc-matchp
    abnf::cstss
    "*enum-constant-modifier identifier [ \"(\" [ argument-list ] \")\" ] [ class-body ]"))))

Theorem: cst-enum-constant-modifier-concs

(defthm cst-enum-constant-modifier-concs
  (implies
       (cst-list-list-alt-matchp abnf::cstss "annotation")
       (or (cst-list-list-conc-matchp abnf::cstss "annotation"))))

Theorem: cst-enum-body-declarations-concs

(defthm cst-enum-body-declarations-concs
 (implies
    (cst-list-list-alt-matchp abnf::cstss
                              "\";\" *class-body-declaration")
    (or (cst-list-list-conc-matchp abnf::cstss
                                   "\";\" *class-body-declaration"))))

Theorem: cst-record-declaration-concs

(defthm cst-record-declaration-concs
 (implies
  (cst-list-list-alt-matchp
   abnf::cstss
   "*class-modifier %s\"record\" type-identifier [ type-parameters ] record-header [ class-implements ] record-body")
  (or
   (cst-list-list-conc-matchp
    abnf::cstss
    "*class-modifier %s\"record\" type-identifier [ type-parameters ] record-header [ class-implements ] record-body"))))

Theorem: cst-record-header-concs

(defthm cst-record-header-concs
 (implies
  (cst-list-list-alt-matchp abnf::cstss
                            "\"(\" record-component-list \")\"")
  (or (cst-list-list-conc-matchp abnf::cstss
                                 "\"(\" record-component-list \")\""))))

Theorem: cst-record-component-list-concs

(defthm cst-record-component-list-concs
  (implies (cst-list-list-alt-matchp
                abnf::cstss
                "record-component *( \",\" record-component )")
           (or (cst-list-list-conc-matchp
                    abnf::cstss
                    "record-component *( \",\" record-component )"))))

Theorem: cst-record-component-concs

(defthm cst-record-component-concs
 (implies
  (cst-list-list-alt-matchp
   abnf::cstss
   "*record-component-modifier unann-type identifier / variable-arity-record-component")
  (or
    (cst-list-list-conc-matchp
         abnf::cstss
         "*record-component-modifier unann-type identifier")
    (cst-list-list-conc-matchp abnf::cstss
                               "variable-arity-record-component"))))

Theorem: cst-variable-arity-record-component-concs

(defthm cst-variable-arity-record-component-concs
 (implies
  (cst-list-list-alt-matchp
   abnf::cstss
   "*record-component-modifier unann-type *annotation \"...\" identifier")
  (or
   (cst-list-list-conc-matchp
    abnf::cstss
    "*record-component-modifier unann-type *annotation \"...\" identifier"))))

Theorem: cst-record-component-modifier-concs

(defthm cst-record-component-modifier-concs
  (implies
       (cst-list-list-alt-matchp abnf::cstss "annotation")
       (or (cst-list-list-conc-matchp abnf::cstss "annotation"))))

Theorem: cst-record-body-concs

(defthm cst-record-body-concs
 (implies
  (cst-list-list-alt-matchp abnf::cstss
                            "\"{\" *record-body-declaration \"}\"")
  (or
   (cst-list-list-conc-matchp abnf::cstss
                              "\"{\" *record-body-declaration \"}\""))))

Theorem: cst-record-body-declaration-concs

(defthm cst-record-body-declaration-concs
 (implies
  (cst-list-list-alt-matchp
       abnf::cstss
       "class-body-declaration / compact-constructor-declaration")
  (or
    (cst-list-list-conc-matchp abnf::cstss "class-body-declaration")
    (cst-list-list-conc-matchp abnf::cstss
                               "compact-constructor-declaration"))))

Theorem: cst-compact-constructor-declaration-concs

(defthm cst-compact-constructor-declaration-concs
 (implies
  (cst-list-list-alt-matchp
       abnf::cstss
       "*constructor-modifier simple-type-name constructor-body")
  (or
   (cst-list-list-conc-matchp
       abnf::cstss
       "*constructor-modifier simple-type-name constructor-body"))))

Theorem: cst-interface-declaration-concs

(defthm cst-interface-declaration-concs
 (implies
  (cst-list-list-alt-matchp
   abnf::cstss
   "normal-interface-declaration / annotation-interface-declaration")
  (or
   (cst-list-list-conc-matchp abnf::cstss
                              "normal-interface-declaration")
   (cst-list-list-conc-matchp abnf::cstss
                              "annotation-interface-declaration"))))

Theorem: cst-normal-interface-declaration-concs

(defthm cst-normal-interface-declaration-concs
 (implies
  (cst-list-list-alt-matchp
   abnf::cstss
   "*interface-modifier %s\"interface\" type-identifier [ type-parameters ] [ interface-extends ] [ interface-permits ] interface-body")
  (or
   (cst-list-list-conc-matchp
    abnf::cstss
    "*interface-modifier %s\"interface\" type-identifier [ type-parameters ] [ interface-extends ] [ interface-permits ] interface-body"))))

Theorem: cst-interface-modifier-concs

(defthm cst-interface-modifier-concs
 (implies
  (cst-list-list-alt-matchp
   abnf::cstss
   "annotation / %s\"public\" / %s\"protected\" / %s\"private\" / %s\"abstract\" / %s\"static\" / %s\"sealed\" / %s\"non-sealed\" / %s\"strictfp\"")
  (or (cst-list-list-conc-matchp abnf::cstss "annotation")
      (cst-list-list-conc-matchp abnf::cstss "%s\"public\"")
      (cst-list-list-conc-matchp abnf::cstss "%s\"protected\"")
      (cst-list-list-conc-matchp abnf::cstss "%s\"private\"")
      (cst-list-list-conc-matchp abnf::cstss "%s\"abstract\"")
      (cst-list-list-conc-matchp abnf::cstss "%s\"static\"")
      (cst-list-list-conc-matchp abnf::cstss "%s\"sealed\"")
      (cst-list-list-conc-matchp abnf::cstss "%s\"non-sealed\"")
      (cst-list-list-conc-matchp abnf::cstss "%s\"strictfp\""))))

Theorem: cst-interface-extends-concs

(defthm cst-interface-extends-concs
 (implies
  (cst-list-list-alt-matchp abnf::cstss
                            "%s\"extends\" interface-type-list")
  (or
    (cst-list-list-conc-matchp abnf::cstss
                               "%s\"extends\" interface-type-list"))))

Theorem: cst-interface-permits-concs

(defthm cst-interface-permits-concs
  (implies (cst-list-list-alt-matchp
                abnf::cstss
                "%s\"permits\" type-name *( \",\" type-name )")
           (or (cst-list-list-conc-matchp
                    abnf::cstss
                    "%s\"permits\" type-name *( \",\" type-name )"))))

Theorem: cst-interface-body-concs

(defthm cst-interface-body-concs
 (implies
  (cst-list-list-alt-matchp abnf::cstss
                            "\"{\" *interface-member-declaration \"}\"")
  (or (cst-list-list-conc-matchp
           abnf::cstss
           "\"{\" *interface-member-declaration \"}\""))))

Theorem: cst-interface-member-declaration-concs

(defthm cst-interface-member-declaration-concs
 (implies
  (cst-list-list-alt-matchp
   abnf::cstss
   "constant-declaration / interface-method-declaration / class-declaration / interface-declaration / \";\"")
  (or
     (cst-list-list-conc-matchp abnf::cstss "constant-declaration")
     (cst-list-list-conc-matchp abnf::cstss
                                "interface-method-declaration")
     (cst-list-list-conc-matchp abnf::cstss "class-declaration")
     (cst-list-list-conc-matchp abnf::cstss "interface-declaration")
     (cst-list-list-conc-matchp abnf::cstss "\";\""))))

Theorem: cst-constant-declaration-concs

(defthm cst-constant-declaration-concs
 (implies
  (cst-list-list-alt-matchp
       abnf::cstss
       "*constant-modifier unann-type variable-declarator-list \";\"")
  (or
   (cst-list-list-conc-matchp
    abnf::cstss
    "*constant-modifier unann-type variable-declarator-list \";\""))))

Theorem: cst-constant-modifier-concs

(defthm cst-constant-modifier-concs
 (implies (cst-list-list-alt-matchp
               abnf::cstss
               "annotation / %s\"public\" / %s\"static\" / %s\"final\"")
          (or (cst-list-list-conc-matchp abnf::cstss "annotation")
              (cst-list-list-conc-matchp abnf::cstss "%s\"public\"")
              (cst-list-list-conc-matchp abnf::cstss "%s\"static\"")
              (cst-list-list-conc-matchp abnf::cstss "%s\"final\""))))

Theorem: cst-interface-method-declaration-concs

(defthm cst-interface-method-declaration-concs
 (implies
  (cst-list-list-alt-matchp
       abnf::cstss
       "*interface-method-modifier method-header method-body")
  (or
     (cst-list-list-conc-matchp
          abnf::cstss
          "*interface-method-modifier method-header method-body"))))

Theorem: cst-interface-method-modifier-concs

(defthm cst-interface-method-modifier-concs
 (implies
  (cst-list-list-alt-matchp
   abnf::cstss
   "annotation / %s\"public\" / %s\"private\" / %s\"abstract\" / %s\"default\" / %s\"static\" / %s\"strictfp\"")
  (or (cst-list-list-conc-matchp abnf::cstss "annotation")
      (cst-list-list-conc-matchp abnf::cstss "%s\"public\"")
      (cst-list-list-conc-matchp abnf::cstss "%s\"private\"")
      (cst-list-list-conc-matchp abnf::cstss "%s\"abstract\"")
      (cst-list-list-conc-matchp abnf::cstss "%s\"default\"")
      (cst-list-list-conc-matchp abnf::cstss "%s\"static\"")
      (cst-list-list-conc-matchp abnf::cstss "%s\"strictfp\""))))

Theorem: cst-annotation-interface-declaration-concs

(defthm cst-annotation-interface-declaration-concs
 (implies
  (cst-list-list-alt-matchp
   abnf::cstss
   "*interface-modifier \"@\" %s\"interface\" type-identifier annotation-interface-body")
  (or
   (cst-list-list-conc-matchp
    abnf::cstss
    "*interface-modifier \"@\" %s\"interface\" type-identifier annotation-interface-body"))))

Theorem: cst-annotation-interface-body-concs

(defthm cst-annotation-interface-body-concs
 (implies
     (cst-list-list-alt-matchp
          abnf::cstss
          "\"{\" *annotation-interface-member-declaration \"}\"")
     (or (cst-list-list-conc-matchp
              abnf::cstss
              "\"{\" *annotation-interface-member-declaration \"}\""))))

Theorem: cst-annotation-interface-member-declaration-concs

(defthm cst-annotation-interface-member-declaration-concs
 (implies
  (cst-list-list-alt-matchp
   abnf::cstss
   "annotation-interface-element-declaration / constant-declaration / class-declaration / interface-declaration / \";\"")
  (or
     (cst-list-list-conc-matchp
          abnf::cstss
          "annotation-interface-element-declaration")
     (cst-list-list-conc-matchp abnf::cstss "constant-declaration")
     (cst-list-list-conc-matchp abnf::cstss "class-declaration")
     (cst-list-list-conc-matchp abnf::cstss "interface-declaration")
     (cst-list-list-conc-matchp abnf::cstss "\";\""))))

Theorem: cst-annotation-interface-element-declaration-concs

(defthm cst-annotation-interface-element-declaration-concs
 (implies
  (cst-list-list-alt-matchp
   abnf::cstss
   "*annotation-interface-element-modifier unann-type identifier \"(\" \")\" [ dims ] [ default-value ] \";\"")
  (or
   (cst-list-list-conc-matchp
    abnf::cstss
    "*annotation-interface-element-modifier unann-type identifier \"(\" \")\" [ dims ] [ default-value ] \";\""))))

Theorem: cst-annotation-interface-element-modifier-concs

(defthm cst-annotation-interface-element-modifier-concs
  (implies
       (cst-list-list-alt-matchp
            abnf::cstss
            "annotation / %s\"public\" / %s\"abstract\"")
       (or (cst-list-list-conc-matchp abnf::cstss "annotation")
           (cst-list-list-conc-matchp abnf::cstss "%s\"public\"")
           (cst-list-list-conc-matchp abnf::cstss "%s\"abstract\""))))

Theorem: cst-default-value-concs

(defthm cst-default-value-concs
 (implies
  (cst-list-list-alt-matchp abnf::cstss "%s\"default\" element-value")
  (or (cst-list-list-conc-matchp abnf::cstss
                                 "%s\"default\" element-value"))))

Theorem: cst-annotation-concs

(defthm cst-annotation-concs
 (implies
  (cst-list-list-alt-matchp
   abnf::cstss
   "normal-annotation / marker-annotation / single-element-annotation")
  (or (cst-list-list-conc-matchp abnf::cstss "normal-annotation")
      (cst-list-list-conc-matchp abnf::cstss "marker-annotation")
      (cst-list-list-conc-matchp abnf::cstss
                                 "single-element-annotation"))))

Theorem: cst-normal-annotation-concs

(defthm cst-normal-annotation-concs
 (implies
    (cst-list-list-alt-matchp
         abnf::cstss
         "\"@\" type-name \"(\" [ element-value-pair-list ] \")\"")
    (or (cst-list-list-conc-matchp
             abnf::cstss
             "\"@\" type-name \"(\" [ element-value-pair-list ] \")\""))))

Theorem: cst-element-value-pair-list-concs

(defthm cst-element-value-pair-list-concs
  (implies
       (cst-list-list-alt-matchp
            abnf::cstss
            "element-value-pair *( \",\" element-value-pair )")
       (or (cst-list-list-conc-matchp
                abnf::cstss
                "element-value-pair *( \",\" element-value-pair )"))))

Theorem: cst-element-value-pair-concs

(defthm cst-element-value-pair-concs
 (implies
   (cst-list-list-alt-matchp abnf::cstss
                             "identifier \"=\" element-value")
   (or (cst-list-list-conc-matchp abnf::cstss
                                  "identifier \"=\" element-value"))))

Theorem: cst-element-value-concs

(defthm cst-element-value-concs
 (implies
  (cst-list-list-alt-matchp
   abnf::cstss
   "conditional-expression / element-value-array-initializer / annotation")
  (or
    (cst-list-list-conc-matchp abnf::cstss "conditional-expression")
    (cst-list-list-conc-matchp abnf::cstss
                               "element-value-array-initializer")
    (cst-list-list-conc-matchp abnf::cstss "annotation"))))

Theorem: cst-element-value-array-initializer-concs

(defthm cst-element-value-array-initializer-concs
  (implies (cst-list-list-alt-matchp
                abnf::cstss
                "\"{\" [ element-value-list ] [ \",\" ] \"}\"")
           (or (cst-list-list-conc-matchp
                    abnf::cstss
                    "\"{\" [ element-value-list ] [ \",\" ] \"}\""))))

Theorem: cst-element-value-list-concs

(defthm cst-element-value-list-concs
 (implies
   (cst-list-list-alt-matchp abnf::cstss
                             "element-value *( \",\" element-value )")
   (or (cst-list-list-conc-matchp
            abnf::cstss
            "element-value *( \",\" element-value )"))))

Theorem: cst-marker-annotation-concs

(defthm cst-marker-annotation-concs
 (implies
      (cst-list-list-alt-matchp abnf::cstss "\"@\" type-name")
      (or (cst-list-list-conc-matchp abnf::cstss "\"@\" type-name"))))

Theorem: cst-single-element-annotation-concs

(defthm cst-single-element-annotation-concs
 (implies
    (cst-list-list-alt-matchp abnf::cstss
                              "\"@\" type-name \"(\" element-value \")\"")
    (or (cst-list-list-conc-matchp
             abnf::cstss
             "\"@\" type-name \"(\" element-value \")\""))))

Theorem: cst-array-initializer-concs

(defthm cst-array-initializer-concs
  (implies
       (cst-list-list-alt-matchp
            abnf::cstss
            "\"{\" [ variable-initializer-list ] [ \",\" ] \"}\"")
       (or (cst-list-list-conc-matchp
                abnf::cstss
                "\"{\" [ variable-initializer-list ] [ \",\" ] \"}\""))))

Theorem: cst-variable-initializer-list-concs

(defthm cst-variable-initializer-list-concs
 (implies
   (cst-list-list-alt-matchp
        abnf::cstss
        "variable-initializer *( \",\" variable-initializer )")
   (or (cst-list-list-conc-matchp
            abnf::cstss
            "variable-initializer *( \",\" variable-initializer )"))))

Theorem: cst-block-concs

(defthm cst-block-concs
 (implies
   (cst-list-list-alt-matchp abnf::cstss
                             "\"{\" [ block-statements ] \"}\"")
   (or (cst-list-list-conc-matchp abnf::cstss
                                  "\"{\" [ block-statements ] \"}\""))))

Theorem: cst-block-statements-concs

(defthm cst-block-statements-concs
 (implies
  (cst-list-list-alt-matchp abnf::cstss "1*block-statement")
  (or (cst-list-list-conc-matchp abnf::cstss "1*block-statement"))))

Theorem: cst-block-statement-concs

(defthm cst-block-statement-concs
 (implies
  (cst-list-list-alt-matchp
   abnf::cstss
   "local-class-or-interface-declaration / local-variable-declaration-statement / statement")
  (or (cst-list-list-conc-matchp
           abnf::cstss
           "local-class-or-interface-declaration")
      (cst-list-list-conc-matchp
           abnf::cstss
           "local-variable-declaration-statement")
      (cst-list-list-conc-matchp abnf::cstss "statement"))))

Theorem: cst-local-class-or-interface-declaration-concs

(defthm cst-local-class-or-interface-declaration-concs
 (implies
   (cst-list-list-alt-matchp
        abnf::cstss
        "class-declaration / normal-interface-declaration")
   (or (cst-list-list-conc-matchp abnf::cstss "class-declaration")
       (cst-list-list-conc-matchp abnf::cstss
                                  "normal-interface-declaration"))))

Theorem: cst-local-variable-declaration-concs

(defthm cst-local-variable-declaration-concs
 (implies
  (cst-list-list-alt-matchp
   abnf::cstss
   "*variable-modifier local-variable-type variable-declarator-list")
  (or
   (cst-list-list-conc-matchp
    abnf::cstss
    "*variable-modifier local-variable-type variable-declarator-list"))))

Theorem: cst-local-variable-type-concs

(defthm cst-local-variable-type-concs
  (implies
       (cst-list-list-alt-matchp abnf::cstss "unann-type / %s\"var\"")
       (or (cst-list-list-conc-matchp abnf::cstss "unann-type")
           (cst-list-list-conc-matchp abnf::cstss "%s\"var\""))))

Theorem: cst-local-variable-declaration-statement-concs

(defthm cst-local-variable-declaration-statement-concs
 (implies
  (cst-list-list-alt-matchp abnf::cstss
                            "local-variable-declaration \";\"")
  (or
     (cst-list-list-conc-matchp abnf::cstss
                                "local-variable-declaration \";\""))))

Theorem: cst-statement-concs

(defthm cst-statement-concs
 (implies
  (cst-list-list-alt-matchp
   abnf::cstss
   "statement-without-trailing-substatement / labeled-statement / if-then-statement / if-then-else-statement / while-statement / for-statement")
  (or
    (cst-list-list-conc-matchp
         abnf::cstss
         "statement-without-trailing-substatement")
    (cst-list-list-conc-matchp abnf::cstss "labeled-statement")
    (cst-list-list-conc-matchp abnf::cstss "if-then-statement")
    (cst-list-list-conc-matchp abnf::cstss "if-then-else-statement")
    (cst-list-list-conc-matchp abnf::cstss "while-statement")
    (cst-list-list-conc-matchp abnf::cstss "for-statement"))))

Theorem: cst-statement-no-short-if-concs

(defthm cst-statement-no-short-if-concs
 (implies
  (cst-list-list-alt-matchp
   abnf::cstss
   "statement-without-trailing-substatement / labeled-statement-no-short-if / if-then-else-statement-no-short-if / while-statement-no-short-if / for-statement-no-short-if")
  (or
    (cst-list-list-conc-matchp
         abnf::cstss
         "statement-without-trailing-substatement")
    (cst-list-list-conc-matchp abnf::cstss
                               "labeled-statement-no-short-if")
    (cst-list-list-conc-matchp abnf::cstss
                               "if-then-else-statement-no-short-if")
    (cst-list-list-conc-matchp abnf::cstss
                               "while-statement-no-short-if")
    (cst-list-list-conc-matchp abnf::cstss
                               "for-statement-no-short-if"))))

Theorem: cst-statement-without-trailing-substatement-concs

(defthm cst-statement-without-trailing-substatement-concs
 (implies
  (cst-list-list-alt-matchp
   abnf::cstss
   "block / empty-statement / expression-statement / assert-statement / switch-statement / do-statement / break-statement / continue-statement / return-statement / synchronized-statement / throw-statement / try-statement / yield-statement")
  (or
    (cst-list-list-conc-matchp abnf::cstss "block")
    (cst-list-list-conc-matchp abnf::cstss "empty-statement")
    (cst-list-list-conc-matchp abnf::cstss "expression-statement")
    (cst-list-list-conc-matchp abnf::cstss "assert-statement")
    (cst-list-list-conc-matchp abnf::cstss "switch-statement")
    (cst-list-list-conc-matchp abnf::cstss "do-statement")
    (cst-list-list-conc-matchp abnf::cstss "break-statement")
    (cst-list-list-conc-matchp abnf::cstss "continue-statement")
    (cst-list-list-conc-matchp abnf::cstss "return-statement")
    (cst-list-list-conc-matchp abnf::cstss "synchronized-statement")
    (cst-list-list-conc-matchp abnf::cstss "throw-statement")
    (cst-list-list-conc-matchp abnf::cstss "try-statement")
    (cst-list-list-conc-matchp abnf::cstss "yield-statement"))))

Theorem: cst-empty-statement-concs

(defthm cst-empty-statement-concs
  (implies (cst-list-list-alt-matchp abnf::cstss "\";\"")
           (or (cst-list-list-conc-matchp abnf::cstss "\";\""))))

Theorem: cst-labeled-statement-concs

(defthm cst-labeled-statement-concs
 (implies
   (cst-list-list-alt-matchp abnf::cstss "identifier \":\" statement")
   (or (cst-list-list-conc-matchp abnf::cstss
                                  "identifier \":\" statement"))))

Theorem: cst-labeled-statement-no-short-if-concs

(defthm cst-labeled-statement-no-short-if-concs
 (implies
   (cst-list-list-alt-matchp abnf::cstss
                             "identifier \":\" statement-no-short-if")
   (or (cst-list-list-conc-matchp
            abnf::cstss
            "identifier \":\" statement-no-short-if"))))

Theorem: cst-expression-statement-concs

(defthm cst-expression-statement-concs
 (implies
   (cst-list-list-alt-matchp abnf::cstss "statement-expression \";\"")
   (or (cst-list-list-conc-matchp abnf::cstss
                                  "statement-expression \";\""))))

Theorem: cst-statement-expression-concs

(defthm cst-statement-expression-concs
 (implies
  (cst-list-list-alt-matchp
   abnf::cstss
   "assignment / pre-increment-expression / pre-decrement-expression / post-increment-expression / post-decrement-expression / method-invocation / class-instance-creation-expression")
  (or (cst-list-list-conc-matchp abnf::cstss "assignment")
      (cst-list-list-conc-matchp
           abnf::cstss "pre-increment-expression")
      (cst-list-list-conc-matchp
           abnf::cstss "pre-decrement-expression")
      (cst-list-list-conc-matchp
           abnf::cstss "post-increment-expression")
      (cst-list-list-conc-matchp
           abnf::cstss "post-decrement-expression")
      (cst-list-list-conc-matchp abnf::cstss "method-invocation")
      (cst-list-list-conc-matchp
           abnf::cstss
           "class-instance-creation-expression"))))

Theorem: cst-if-then-statement-concs

(defthm cst-if-then-statement-concs
 (implies
    (cst-list-list-alt-matchp abnf::cstss
                              "%s\"if\" \"(\" expression \")\" statement")
    (or (cst-list-list-conc-matchp
             abnf::cstss
             "%s\"if\" \"(\" expression \")\" statement"))))

Theorem: cst-if-then-else-statement-concs

(defthm cst-if-then-else-statement-concs
 (implies
  (cst-list-list-alt-matchp
   abnf::cstss
   "%s\"if\" \"(\" expression \")\" statement-no-short-if %s\"else\" statement")
  (or
   (cst-list-list-conc-matchp
    abnf::cstss
    "%s\"if\" \"(\" expression \")\" statement-no-short-if %s\"else\" statement"))))

Theorem: cst-if-then-else-statement-no-short-if-concs

(defthm cst-if-then-else-statement-no-short-if-concs
 (implies
  (cst-list-list-alt-matchp
   abnf::cstss
   "%s\"if\" \"(\" expression \")\" statement-no-short-if %s\"else\" statement-no-short-if")
  (or
   (cst-list-list-conc-matchp
    abnf::cstss
    "%s\"if\" \"(\" expression \")\" statement-no-short-if %s\"else\" statement-no-short-if"))))

Theorem: cst-assert-statement-concs

(defthm cst-assert-statement-concs
 (implies
  (cst-list-list-alt-matchp
   abnf::cstss
   "%s\"assert\" expression \";\" / %s\"assert\" expression \":\" expression \";\"")
  (or (cst-list-list-conc-matchp
           abnf::cstss "%s\"assert\" expression \";\"")
      (cst-list-list-conc-matchp
           abnf::cstss
           "%s\"assert\" expression \":\" expression \";\""))))

Theorem: cst-switch-statement-concs

(defthm cst-switch-statement-concs
  (implies (cst-list-list-alt-matchp
                abnf::cstss
                "%s\"switch\" \"(\" expression \")\" switch-block")
           (or (cst-list-list-conc-matchp
                    abnf::cstss
                    "%s\"switch\" \"(\" expression \")\" switch-block"))))

Theorem: cst-switch-block-concs

(defthm cst-switch-block-concs
 (implies
  (cst-list-list-alt-matchp
   abnf::cstss
   "\"{\" 1*switch-rule \"}\" / \"{\" *switch-block-statement-group *( switch-label \":\" ) \"}\"")
  (or
   (cst-list-list-conc-matchp abnf::cstss "\"{\" 1*switch-rule \"}\"")
   (cst-list-list-conc-matchp
    abnf::cstss
    "\"{\" *switch-block-statement-group *( switch-label \":\" ) \"}\""))))

Theorem: cst-switch-rule-concs

(defthm cst-switch-rule-concs
 (implies
  (cst-list-list-alt-matchp
   abnf::cstss
   "switch-label \"->\" expression \";\" / switch-label \"->\" block / switch-label \"->\" throw-statement")
  (or
   (cst-list-list-conc-matchp abnf::cstss
                              "switch-label \"->\" expression \";\"")
   (cst-list-list-conc-matchp abnf::cstss "switch-label \"->\" block")
   (cst-list-list-conc-matchp
        abnf::cstss
        "switch-label \"->\" throw-statement"))))

Theorem: cst-switch-block-statement-group-concs

(defthm cst-switch-block-statement-group-concs
 (implies
  (cst-list-list-alt-matchp
       abnf::cstss
       "switch-label \":\" *( switch-label \":\" ) block-statements")
  (or
   (cst-list-list-conc-matchp
       abnf::cstss
       "switch-label \":\" *( switch-label \":\" ) block-statements"))))

Theorem: cst-switch-label-concs

(defthm cst-switch-label-concs
 (implies
  (cst-list-list-alt-matchp
   abnf::cstss
   "%s\"case\" case-constant *( \",\" case-constant ) / %s\"case\" %s\"null\" [ \",\" %s\"default\" ] / %s\"case\" case-pattern *( \",\" case-pattern ) [ guard ] / %s\"default\"")
  (or (cst-list-list-conc-matchp
           abnf::cstss
           "%s\"case\" case-constant *( \",\" case-constant )")
      (cst-list-list-conc-matchp
           abnf::cstss
           "%s\"case\" %s\"null\" [ \",\" %s\"default\" ]")
      (cst-list-list-conc-matchp
           abnf::cstss
           "%s\"case\" case-pattern *( \",\" case-pattern ) [ guard ]")
      (cst-list-list-conc-matchp abnf::cstss "%s\"default\""))))

Theorem: cst-case-constant-concs

(defthm cst-case-constant-concs
 (implies
     (cst-list-list-alt-matchp abnf::cstss "conditional-expression")
     (or (cst-list-list-conc-matchp
              abnf::cstss "conditional-expression"))))

Theorem: cst-case-pattern-concs

(defthm cst-case-pattern-concs
  (implies (cst-list-list-alt-matchp abnf::cstss "pattern")
           (or (cst-list-list-conc-matchp abnf::cstss "pattern"))))

Theorem: cst-guard-concs

(defthm cst-guard-concs
 (implies
  (cst-list-list-alt-matchp abnf::cstss "%s\"when\" expression")
  (or
    (cst-list-list-conc-matchp abnf::cstss "%s\"when\" expression"))))

Theorem: cst-while-statement-concs

(defthm cst-while-statement-concs
  (implies (cst-list-list-alt-matchp
                abnf::cstss
                "%s\"while\" \"(\" expression \")\" statement")
           (or (cst-list-list-conc-matchp
                    abnf::cstss
                    "%s\"while\" \"(\" expression \")\" statement"))))

Theorem: cst-while-statement-no-short-if-concs

(defthm cst-while-statement-no-short-if-concs
 (implies
   (cst-list-list-alt-matchp
        abnf::cstss
        "%s\"while\" \"(\" expression \")\" statement-no-short-if")
   (or (cst-list-list-conc-matchp
            abnf::cstss
            "%s\"while\" \"(\" expression \")\" statement-no-short-if"))))

Theorem: cst-do-statement-concs

(defthm cst-do-statement-concs
 (implies
    (cst-list-list-alt-matchp
         abnf::cstss
         "%s\"do\" statement %s\"while\" \"(\" expression \")\" \";\"")
    (or (cst-list-list-conc-matchp
             abnf::cstss
             "%s\"do\" statement %s\"while\" \"(\" expression \")\" \";\""))))

Theorem: cst-for-statement-concs

(defthm cst-for-statement-concs
 (implies
   (cst-list-list-alt-matchp
        abnf::cstss
        "basic-for-statement / enhanced-for-statement")
   (or (cst-list-list-conc-matchp abnf::cstss "basic-for-statement")
       (cst-list-list-conc-matchp
            abnf::cstss "enhanced-for-statement"))))

Theorem: cst-for-statement-no-short-if-concs

(defthm cst-for-statement-no-short-if-concs
 (implies
  (cst-list-list-alt-matchp
   abnf::cstss
   "basic-for-statement-no-short-if / enhanced-for-statement-no-short-if")
  (or (cst-list-list-conc-matchp abnf::cstss
                                 "basic-for-statement-no-short-if")
      (cst-list-list-conc-matchp
           abnf::cstss
           "enhanced-for-statement-no-short-if"))))

Theorem: cst-basic-for-statement-concs

(defthm cst-basic-for-statement-concs
 (implies
  (cst-list-list-alt-matchp
   abnf::cstss
   "%s\"for\" \"(\" [ for-init ] \";\" [ expression ] \";\" [ for-update ] \")\" statement")
  (or
   (cst-list-list-conc-matchp
    abnf::cstss
    "%s\"for\" \"(\" [ for-init ] \";\" [ expression ] \";\" [ for-update ] \")\" statement"))))

Theorem: cst-basic-for-statement-no-short-if-concs

(defthm cst-basic-for-statement-no-short-if-concs
 (implies
  (cst-list-list-alt-matchp
   abnf::cstss
   "%s\"for\" \"(\" [ for-init ] \";\" [ expression ] \";\" [ for-update ] \")\" statement-no-short-if")
  (or
   (cst-list-list-conc-matchp
    abnf::cstss
    "%s\"for\" \"(\" [ for-init ] \";\" [ expression ] \";\" [ for-update ] \")\" statement-no-short-if"))))

Theorem: cst-for-init-concs

(defthm cst-for-init-concs
 (implies
     (cst-list-list-alt-matchp
          abnf::cstss
          "statement-expression-list / local-variable-declaration")
     (or (cst-list-list-conc-matchp
              abnf::cstss "statement-expression-list")
         (cst-list-list-conc-matchp abnf::cstss
                                    "local-variable-declaration"))))

Theorem: cst-for-update-concs

(defthm cst-for-update-concs
 (implies
  (cst-list-list-alt-matchp abnf::cstss "statement-expression-list")
  (or (cst-list-list-conc-matchp abnf::cstss
                                 "statement-expression-list"))))

Theorem: cst-statement-expression-list-concs

(defthm cst-statement-expression-list-concs
 (implies
   (cst-list-list-alt-matchp
        abnf::cstss
        "statement-expression *( \",\" statement-expression )")
   (or (cst-list-list-conc-matchp
            abnf::cstss
            "statement-expression *( \",\" statement-expression )"))))

Theorem: cst-enhanced-for-statement-concs

(defthm cst-enhanced-for-statement-concs
 (implies
  (cst-list-list-alt-matchp
   abnf::cstss
   "%s\"for\" \"(\" local-variable-declaration \":\" expression \")\" statement")
  (or
   (cst-list-list-conc-matchp
    abnf::cstss
    "%s\"for\" \"(\" local-variable-declaration \":\" expression \")\" statement"))))

Theorem: cst-enhanced-for-statement-no-short-if-concs

(defthm cst-enhanced-for-statement-no-short-if-concs
 (implies
  (cst-list-list-alt-matchp
   abnf::cstss
   "%s\"for\" \"(\" local-variable-declaration \":\" expression \")\" statement-no-short-if")
  (or
   (cst-list-list-conc-matchp
    abnf::cstss
    "%s\"for\" \"(\" local-variable-declaration \":\" expression \")\" statement-no-short-if"))))

Theorem: cst-break-statement-concs

(defthm cst-break-statement-concs
 (implies
   (cst-list-list-alt-matchp abnf::cstss
                             "%s\"break\" [ identifier ] \";\"")
   (or (cst-list-list-conc-matchp abnf::cstss
                                  "%s\"break\" [ identifier ] \";\""))))

Theorem: cst-continue-statement-concs

(defthm cst-continue-statement-concs
 (implies
  (cst-list-list-alt-matchp abnf::cstss
                            "%s\"continue\" [ identifier ] \";\"")
  (or
    (cst-list-list-conc-matchp abnf::cstss
                               "%s\"continue\" [ identifier ] \";\""))))

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-throw-statement-concs

(defthm cst-throw-statement-concs
 (implies
   (cst-list-list-alt-matchp abnf::cstss "%s\"throw\" expression \";\"")
   (or (cst-list-list-conc-matchp abnf::cstss
                                  "%s\"throw\" expression \";\""))))

Theorem: cst-synchronized-statement-concs

(defthm cst-synchronized-statement-concs
  (implies (cst-list-list-alt-matchp
                abnf::cstss
                "%s\"synchronized\" \"(\" expression \")\" block")
           (or (cst-list-list-conc-matchp
                    abnf::cstss
                    "%s\"synchronized\" \"(\" expression \")\" block"))))

Theorem: cst-try-statement-concs

(defthm cst-try-statement-concs
 (implies
  (cst-list-list-alt-matchp
   abnf::cstss
   "%s\"try\" block catches / %s\"try\" block [ catches ] finally / try-with-resources-statement")
  (or
     (cst-list-list-conc-matchp abnf::cstss "%s\"try\" block catches")
     (cst-list-list-conc-matchp abnf::cstss
                                "%s\"try\" block [ catches ] finally")
     (cst-list-list-conc-matchp abnf::cstss
                                "try-with-resources-statement"))))

Theorem: cst-catches-concs

(defthm cst-catches-concs
 (implies
     (cst-list-list-alt-matchp abnf::cstss "1*catch-clause")
     (or (cst-list-list-conc-matchp abnf::cstss "1*catch-clause"))))

Theorem: cst-catch-clause-concs

(defthm cst-catch-clause-concs
  (implies
       (cst-list-list-alt-matchp
            abnf::cstss
            "%s\"catch\" \"(\" catch-formal-parameter \")\" block")
       (or (cst-list-list-conc-matchp
                abnf::cstss
                "%s\"catch\" \"(\" catch-formal-parameter \")\" block"))))

Theorem: cst-catch-formal-parameter-concs

(defthm cst-catch-formal-parameter-concs
 (implies
  (cst-list-list-alt-matchp
       abnf::cstss
       "*variable-modifier catch-type variable-declarator-id")
  (or
     (cst-list-list-conc-matchp
          abnf::cstss
          "*variable-modifier catch-type variable-declarator-id"))))

Theorem: cst-catch-type-concs

(defthm cst-catch-type-concs
 (implies
   (cst-list-list-alt-matchp abnf::cstss
                             "unann-class-type *( \"|\" class-type )")
   (or (cst-list-list-conc-matchp
            abnf::cstss
            "unann-class-type *( \"|\" class-type )"))))

Theorem: cst-finally-concs

(defthm cst-finally-concs
 (implies
  (cst-list-list-alt-matchp abnf::cstss "%s\"finally\" block")
  (or (cst-list-list-conc-matchp abnf::cstss "%s\"finally\" block"))))

Theorem: cst-try-with-resources-statement-concs

(defthm cst-try-with-resources-statement-concs
 (implies
  (cst-list-list-alt-matchp
     abnf::cstss
     "%s\"try\" resource-specification block [ catches ] [ finally ]")
  (or
   (cst-list-list-conc-matchp
    abnf::cstss
    "%s\"try\" resource-specification block [ catches ] [ finally ]"))))

Theorem: cst-resource-specification-concs

(defthm cst-resource-specification-concs
 (implies
  (cst-list-list-alt-matchp abnf::cstss
                            "\"(\" resource-list [ \";\" ] \")\"")
  (or (cst-list-list-conc-matchp abnf::cstss
                                 "\"(\" resource-list [ \";\" ] \")\""))))

Theorem: cst-resource-list-concs

(defthm cst-resource-list-concs
 (implies
     (cst-list-list-alt-matchp abnf::cstss
                               "resource *( \";\" resource )")
     (or (cst-list-list-conc-matchp abnf::cstss
                                    "resource *( \";\" resource )"))))

Theorem: cst-resource-concs

(defthm cst-resource-concs
 (implies
    (cst-list-list-alt-matchp
         abnf::cstss
         "local-variable-declaration / variable-access")
    (or (cst-list-list-conc-matchp abnf::cstss
                                   "local-variable-declaration")
        (cst-list-list-conc-matchp abnf::cstss "variable-access"))))

Theorem: cst-variable-access-concs

(defthm cst-variable-access-concs
  (implies
       (cst-list-list-alt-matchp abnf::cstss
                                 "expression-name / field-access")
       (or (cst-list-list-conc-matchp abnf::cstss "expression-name")
           (cst-list-list-conc-matchp abnf::cstss "field-access"))))

Theorem: cst-yield-statement-concs

(defthm cst-yield-statement-concs
 (implies
   (cst-list-list-alt-matchp abnf::cstss "%s\"yield\" expression \";\"")
   (or (cst-list-list-conc-matchp abnf::cstss
                                  "%s\"yield\" expression \";\""))))

Theorem: cst-pattern-concs

(defthm cst-pattern-concs
 (implies
     (cst-list-list-alt-matchp abnf::cstss
                               "type-pattern / record-pattern")
     (or (cst-list-list-conc-matchp abnf::cstss "type-pattern")
         (cst-list-list-conc-matchp abnf::cstss "record-pattern"))))

Theorem: cst-type-pattern-concs

(defthm cst-type-pattern-concs
 (implies
     (cst-list-list-alt-matchp abnf::cstss
                               "local-variable-declaration")
     (or (cst-list-list-conc-matchp abnf::cstss
                                    "local-variable-declaration"))))

Theorem: cst-record-pattern-concs

(defthm cst-record-pattern-concs
 (implies
    (cst-list-list-alt-matchp
         abnf::cstss
         "reference-type \"(\" [ component-pattern-list ] \")\"")
    (or (cst-list-list-conc-matchp
             abnf::cstss
             "reference-type \"(\" [ component-pattern-list ] \")\""))))

Theorem: cst-component-pattern-list-concs

(defthm cst-component-pattern-list-concs
  (implies
       (cst-list-list-alt-matchp
            abnf::cstss
            "component-pattern *( \",\" component-pattern )")
       (or (cst-list-list-conc-matchp
                abnf::cstss
                "component-pattern *( \",\" component-pattern )"))))

Theorem: cst-component-pattern-concs

(defthm cst-component-pattern-concs
 (implies
  (cst-list-list-alt-matchp abnf::cstss
                            "pattern / match-all-pattern")
  (or (cst-list-list-conc-matchp abnf::cstss "pattern")
      (cst-list-list-conc-matchp abnf::cstss "match-all-pattern"))))

Theorem: cst-match-all-pattern-concs

(defthm cst-match-all-pattern-concs
  (implies (cst-list-list-alt-matchp abnf::cstss "\"_\"")
           (or (cst-list-list-conc-matchp abnf::cstss "\"_\""))))

Theorem: cst-expression-concs

(defthm cst-expression-concs
 (implies
     (cst-list-list-alt-matchp
          abnf::cstss
          "lambda-expression / assignment-expression")
     (or (cst-list-list-conc-matchp abnf::cstss "lambda-expression")
         (cst-list-list-conc-matchp
              abnf::cstss "assignment-expression"))))

Theorem: cst-primary-concs

(defthm cst-primary-concs
 (implies
  (cst-list-list-alt-matchp
       abnf::cstss
       "primary-no-new-array / array-creation-expression")
  (or (cst-list-list-conc-matchp abnf::cstss "primary-no-new-array")
      (cst-list-list-conc-matchp abnf::cstss
                                 "array-creation-expression"))))

Theorem: cst-primary-no-new-array-concs

(defthm cst-primary-no-new-array-concs
 (implies
  (cst-list-list-alt-matchp
   abnf::cstss
   "literal / class-literal / %s\"this\" / type-name \".\" %s\"this\" / \"(\" expression \")\" / class-instance-creation-expression / field-access / array-access / method-invocation / method-reference")
  (or
    (cst-list-list-conc-matchp abnf::cstss "literal")
    (cst-list-list-conc-matchp abnf::cstss "class-literal")
    (cst-list-list-conc-matchp abnf::cstss "%s\"this\"")
    (cst-list-list-conc-matchp abnf::cstss "type-name \".\" %s\"this\"")
    (cst-list-list-conc-matchp abnf::cstss "\"(\" expression \")\"")
    (cst-list-list-conc-matchp abnf::cstss
                               "class-instance-creation-expression")
    (cst-list-list-conc-matchp abnf::cstss "field-access")
    (cst-list-list-conc-matchp abnf::cstss "array-access")
    (cst-list-list-conc-matchp abnf::cstss "method-invocation")
    (cst-list-list-conc-matchp abnf::cstss "method-reference"))))

Theorem: cst-class-literal-concs

(defthm cst-class-literal-concs
 (implies
  (cst-list-list-alt-matchp
   abnf::cstss
   "type-name *( \"[\" \"]\" ) \".\" %s\"class\" / numeric-type *( \"[\" \"]\" ) \".\" %s\"class\" / %s\"boolean\" *( \"[\" \"]\" ) \".\" %s\"class\" / %s\"void\" \".\" %s\"class\"")
  (or (cst-list-list-conc-matchp
           abnf::cstss
           "type-name *( \"[\" \"]\" ) \".\" %s\"class\"")
      (cst-list-list-conc-matchp
           abnf::cstss
           "numeric-type *( \"[\" \"]\" ) \".\" %s\"class\"")
      (cst-list-list-conc-matchp
           abnf::cstss
           "%s\"boolean\" *( \"[\" \"]\" ) \".\" %s\"class\"")
      (cst-list-list-conc-matchp
           abnf::cstss "%s\"void\" \".\" %s\"class\""))))

Theorem: cst-class-instance-creation-expression-concs

(defthm cst-class-instance-creation-expression-concs
 (implies
  (cst-list-list-alt-matchp
   abnf::cstss
   "unqualified-class-instance-creation-expression / expression-name \".\" unqualified-class-instance-creation-expression / primary \".\" unqualified-class-instance-creation-expression")
  (or
   (cst-list-list-conc-matchp
        abnf::cstss
        "unqualified-class-instance-creation-expression")
   (cst-list-list-conc-matchp
    abnf::cstss
    "expression-name \".\" unqualified-class-instance-creation-expression")
   (cst-list-list-conc-matchp
    abnf::cstss
    "primary \".\" unqualified-class-instance-creation-expression"))))

Theorem: cst-unqualified-class-instance-creation-expression-concs

(defthm cst-unqualified-class-instance-creation-expression-concs
 (implies
  (cst-list-list-alt-matchp
   abnf::cstss
   "%s\"new\" [ type-arguments ] class-or-interface-type-to-instantiate \"(\" [ argument-list ] \")\" [ class-body ]")
  (or
   (cst-list-list-conc-matchp
    abnf::cstss
    "%s\"new\" [ type-arguments ] class-or-interface-type-to-instantiate \"(\" [ argument-list ] \")\" [ class-body ]"))))

Theorem: cst-class-or-interface-type-to-instantiate-concs

(defthm cst-class-or-interface-type-to-instantiate-concs
 (implies
  (cst-list-list-alt-matchp
   abnf::cstss
   "*annotation identifier *( \".\" *annotation identifier ) [ type-arguments-or-diamond ]")
  (or
   (cst-list-list-conc-matchp
    abnf::cstss
    "*annotation identifier *( \".\" *annotation identifier ) [ type-arguments-or-diamond ]"))))

Theorem: cst-type-arguments-or-diamond-concs

(defthm cst-type-arguments-or-diamond-concs
 (implies
      (cst-list-list-alt-matchp abnf::cstss "type-arguments / \"<>\"")
      (or (cst-list-list-conc-matchp abnf::cstss "type-arguments")
          (cst-list-list-conc-matchp abnf::cstss "\"<>\""))))

Theorem: cst-array-creation-expression-concs

(defthm cst-array-creation-expression-concs
 (implies
  (cst-list-list-alt-matchp
   abnf::cstss
   "array-creation-expression-without-initializer / array-creation-expression-with-initializer")
  (or (cst-list-list-conc-matchp
           abnf::cstss
           "array-creation-expression-without-initializer")
      (cst-list-list-conc-matchp
           abnf::cstss
           "array-creation-expression-with-initializer"))))

Theorem: cst-array-creation-expression-without-initializer-concs

(defthm cst-array-creation-expression-without-initializer-concs
 (implies
  (cst-list-list-alt-matchp
   abnf::cstss
   "%s\"new\" primitive-type dim-exprs [ dims ] / %s\"new\" class-or-interface-type dim-exprs [ dims ]")
  (or (cst-list-list-conc-matchp
           abnf::cstss
           "%s\"new\" primitive-type dim-exprs [ dims ]")
      (cst-list-list-conc-matchp
           abnf::cstss
           "%s\"new\" class-or-interface-type dim-exprs [ dims ]"))))

Theorem: cst-array-creation-expression-with-initializer-concs

(defthm cst-array-creation-expression-with-initializer-concs
 (implies
  (cst-list-list-alt-matchp
   abnf::cstss
   "%s\"new\" primitive-type dims array-initializer / %s\"new\" class-or-interface-type dims array-initializer")
  (or
   (cst-list-list-conc-matchp
        abnf::cstss
        "%s\"new\" primitive-type dims array-initializer")
   (cst-list-list-conc-matchp
        abnf::cstss
        "%s\"new\" class-or-interface-type dims array-initializer"))))

Theorem: cst-dim-exprs-concs

(defthm cst-dim-exprs-concs
  (implies
       (cst-list-list-alt-matchp abnf::cstss "1*dim-expr")
       (or (cst-list-list-conc-matchp abnf::cstss "1*dim-expr"))))

Theorem: cst-dim-expr-concs

(defthm cst-dim-expr-concs
 (implies
  (cst-list-list-alt-matchp abnf::cstss
                            "*annotation \"[\" expression \"]\"")
  (or
     (cst-list-list-conc-matchp abnf::cstss
                                "*annotation \"[\" expression \"]\""))))

Theorem: cst-array-access-concs

(defthm cst-array-access-concs
 (implies
  (cst-list-list-alt-matchp
   abnf::cstss
   "expression-name \"[\" expression \"]\" / primary-no-new-array \"[\" expression \"]\" / array-creation-expression-with-initializer \"[\" expression \"]\"")
  (or
   (cst-list-list-conc-matchp abnf::cstss
                              "expression-name \"[\" expression \"]\"")
   (cst-list-list-conc-matchp
        abnf::cstss
        "primary-no-new-array \"[\" expression \"]\"")
   (cst-list-list-conc-matchp
    abnf::cstss
    "array-creation-expression-with-initializer \"[\" expression \"]\""))))

Theorem: cst-field-access-concs

(defthm cst-field-access-concs
 (implies
  (cst-list-list-alt-matchp
   abnf::cstss
   "primary \".\" identifier / %s\"super\" \".\" identifier / type-name \".\" %s\"super\" \".\" identifier")
  (or
    (cst-list-list-conc-matchp abnf::cstss "primary \".\" identifier")
    (cst-list-list-conc-matchp
         abnf::cstss "%s\"super\" \".\" identifier")
    (cst-list-list-conc-matchp
         abnf::cstss
         "type-name \".\" %s\"super\" \".\" identifier"))))

Theorem: cst-method-invocation-concs

(defthm cst-method-invocation-concs
 (implies
  (cst-list-list-alt-matchp
   abnf::cstss
   "method-name \"(\" [ argument-list ] \")\" / type-name \".\" [ type-arguments ] identifier \"(\" [ argument-list ] \")\" / expression-name \".\" [ type-arguments ] identifier \"(\" [ argument-list ] \")\" / primary \".\" [ type-arguments ] identifier \"(\" [ argument-list ] \")\" / %s\"super\" \".\" [ type-arguments ] identifier \"(\" [ argument-list ] \")\" / type-name \".\" %s\"super\" \".\" [ type-arguments ] identifier \"(\" [ argument-list ] \")\"")
  (or
   (cst-list-list-conc-matchp
        abnf::cstss
        "method-name \"(\" [ argument-list ] \")\"")
   (cst-list-list-conc-matchp
    abnf::cstss
    "type-name \".\" [ type-arguments ] identifier \"(\" [ argument-list ] \")\"")
   (cst-list-list-conc-matchp
    abnf::cstss
    "expression-name \".\" [ type-arguments ] identifier \"(\" [ argument-list ] \")\"")
   (cst-list-list-conc-matchp
    abnf::cstss
    "primary \".\" [ type-arguments ] identifier \"(\" [ argument-list ] \")\"")
   (cst-list-list-conc-matchp
    abnf::cstss
    "%s\"super\" \".\" [ type-arguments ] identifier \"(\" [ argument-list ] \")\"")
   (cst-list-list-conc-matchp
    abnf::cstss
    "type-name \".\" %s\"super\" \".\" [ type-arguments ] identifier \"(\" [ argument-list ] \")\""))))

Theorem: cst-argument-list-concs

(defthm cst-argument-list-concs
 (implies
  (cst-list-list-alt-matchp abnf::cstss
                            "expression *( \",\" expression )")
  (or
     (cst-list-list-conc-matchp abnf::cstss
                                "expression *( \",\" expression )"))))

Theorem: cst-method-reference-concs

(defthm cst-method-reference-concs
 (implies
  (cst-list-list-alt-matchp
   abnf::cstss
   "expression-name \"::\" [ type-arguments ] identifier / primary \"::\" [ type-arguments ] identifier / reference-type \"::\" [ type-arguments ] identifier / %s\"super\" \"::\" [ type-arguments ] identifier / type-name \".\" %s\"super\" \"::\" [ type-arguments ] identifier / class-type \"::\" [ type-arguments ] %s\"new\" / array-type \"::\" %s\"new\"")
  (or
   (cst-list-list-conc-matchp
        abnf::cstss
        "expression-name \"::\" [ type-arguments ] identifier")
   (cst-list-list-conc-matchp
        abnf::cstss
        "primary \"::\" [ type-arguments ] identifier")
   (cst-list-list-conc-matchp
        abnf::cstss
        "reference-type \"::\" [ type-arguments ] identifier")
   (cst-list-list-conc-matchp
        abnf::cstss
        "%s\"super\" \"::\" [ type-arguments ] identifier")
   (cst-list-list-conc-matchp
       abnf::cstss
       "type-name \".\" %s\"super\" \"::\" [ type-arguments ] identifier")
   (cst-list-list-conc-matchp
        abnf::cstss
        "class-type \"::\" [ type-arguments ] %s\"new\"")
   (cst-list-list-conc-matchp abnf::cstss
                              "array-type \"::\" %s\"new\""))))

Theorem: cst-postfix-expression-concs

(defthm cst-postfix-expression-concs
 (implies
  (cst-list-list-alt-matchp
   abnf::cstss
   "primary / expression-name / post-increment-expression / post-decrement-expression")
  (or (cst-list-list-conc-matchp abnf::cstss "primary")
      (cst-list-list-conc-matchp abnf::cstss "expression-name")
      (cst-list-list-conc-matchp
           abnf::cstss "post-increment-expression")
      (cst-list-list-conc-matchp abnf::cstss
                                 "post-decrement-expression"))))

Theorem: cst-post-increment-expression-concs

(defthm cst-post-increment-expression-concs
 (implies
    (cst-list-list-alt-matchp abnf::cstss "postfix-expression \"++\"")
    (or (cst-list-list-conc-matchp abnf::cstss
                                   "postfix-expression \"++\""))))

Theorem: cst-post-decrement-expression-concs

(defthm cst-post-decrement-expression-concs
 (implies
    (cst-list-list-alt-matchp abnf::cstss "postfix-expression \"--\"")
    (or (cst-list-list-conc-matchp abnf::cstss
                                   "postfix-expression \"--\""))))

Theorem: cst-unary-expression-concs

(defthm cst-unary-expression-concs
 (implies
  (cst-list-list-alt-matchp
   abnf::cstss
   "pre-increment-expression / pre-decrement-expression / \"+\" unary-expression / \"-\" unary-expression / unary-expression-not-plus-minus")
  (or
    (cst-list-list-conc-matchp
         abnf::cstss "pre-increment-expression")
    (cst-list-list-conc-matchp
         abnf::cstss "pre-decrement-expression")
    (cst-list-list-conc-matchp abnf::cstss "\"+\" unary-expression")
    (cst-list-list-conc-matchp abnf::cstss "\"-\" unary-expression")
    (cst-list-list-conc-matchp abnf::cstss
                               "unary-expression-not-plus-minus"))))

Theorem: cst-pre-increment-expression-concs

(defthm cst-pre-increment-expression-concs
 (implies
      (cst-list-list-alt-matchp abnf::cstss "\"++\" unary-expression")
      (or (cst-list-list-conc-matchp
               abnf::cstss "\"++\" unary-expression"))))

Theorem: cst-pre-decrement-expression-concs

(defthm cst-pre-decrement-expression-concs
 (implies
      (cst-list-list-alt-matchp abnf::cstss "\"--\" unary-expression")
      (or (cst-list-list-conc-matchp
               abnf::cstss "\"--\" unary-expression"))))

Theorem: cst-unary-expression-not-plus-minus-concs

(defthm cst-unary-expression-not-plus-minus-concs
 (implies
  (cst-list-list-alt-matchp
   abnf::cstss
   "postfix-expression / \"~\" unary-expression / \"!\" unary-expression / cast-expression / switch-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")
      (cst-list-list-conc-matchp abnf::cstss "cast-expression")
      (cst-list-list-conc-matchp abnf::cstss "switch-expression"))))

Theorem: cst-cast-expression-concs

(defthm cst-cast-expression-concs
 (implies
  (cst-list-list-alt-matchp
   abnf::cstss
   "\"(\" primitive-type \")\" unary-expression / \"(\" reference-type *additional-bound \")\" unary-expression-not-plus-minus / \"(\" reference-type *additional-bound \")\" lambda-expression")
  (or
   (cst-list-list-conc-matchp
        abnf::cstss
        "\"(\" primitive-type \")\" unary-expression")
   (cst-list-list-conc-matchp
    abnf::cstss
    "\"(\" reference-type *additional-bound \")\" unary-expression-not-plus-minus")
   (cst-list-list-conc-matchp
    abnf::cstss
    "\"(\" reference-type *additional-bound \")\" lambda-expression"))))

Theorem: cst-multiplicative-expression-concs

(defthm cst-multiplicative-expression-concs
 (implies
  (cst-list-list-alt-matchp
   abnf::cstss
   "unary-expression / multiplicative-expression \"*\" unary-expression / multiplicative-expression \"/\" unary-expression / multiplicative-expression \"%\" unary-expression")
  (or (cst-list-list-conc-matchp abnf::cstss "unary-expression")
      (cst-list-list-conc-matchp
           abnf::cstss
           "multiplicative-expression \"*\" unary-expression")
      (cst-list-list-conc-matchp
           abnf::cstss
           "multiplicative-expression \"/\" unary-expression")
      (cst-list-list-conc-matchp
           abnf::cstss
           "multiplicative-expression \"%\" unary-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 / 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")
      (cst-list-list-conc-matchp
           abnf::cstss
           "shift-expression \">>>\" additive-expression"))))

Theorem: cst-relational-expression-concs

(defthm cst-relational-expression-concs
 (implies
  (cst-list-list-alt-matchp
   abnf::cstss
   "shift-expression / relational-expression \"<\" shift-expression / relational-expression \">\" shift-expression / relational-expression \"<=\" shift-expression / relational-expression \">=\" shift-expression / instanceof-expression")
  (or (cst-list-list-conc-matchp abnf::cstss "shift-expression")
      (cst-list-list-conc-matchp
           abnf::cstss
           "relational-expression \"<\" shift-expression")
      (cst-list-list-conc-matchp
           abnf::cstss
           "relational-expression \">\" shift-expression")
      (cst-list-list-conc-matchp
           abnf::cstss
           "relational-expression \"<=\" shift-expression")
      (cst-list-list-conc-matchp
           abnf::cstss
           "relational-expression \">=\" shift-expression")
      (cst-list-list-conc-matchp
           abnf::cstss "instanceof-expression"))))

Theorem: cst-instanceof-expression-concs

(defthm cst-instanceof-expression-concs
 (implies
  (cst-list-list-alt-matchp
   abnf::cstss
   "relational-expression %s\"instanceof\" reference-type / relational-expression %s\"instanceof\" pattern")
  (or (cst-list-list-conc-matchp
           abnf::cstss
           "relational-expression %s\"instanceof\" reference-type")
      (cst-list-list-conc-matchp
           abnf::cstss
           "relational-expression %s\"instanceof\" pattern"))))

Theorem: cst-equality-expression-concs

(defthm cst-equality-expression-concs
 (implies
  (cst-list-list-alt-matchp
   abnf::cstss
   "relational-expression / equality-expression \"==\" relational-expression / equality-expression \"!=\" relational-expression")
  (or
     (cst-list-list-conc-matchp abnf::cstss "relational-expression")
     (cst-list-list-conc-matchp
          abnf::cstss
          "equality-expression \"==\" relational-expression")
     (cst-list-list-conc-matchp
          abnf::cstss
          "equality-expression \"!=\" relational-expression"))))

Theorem: cst-and-expression-concs

(defthm cst-and-expression-concs
 (implies
  (cst-list-list-alt-matchp
     abnf::cstss
     "equality-expression / and-expression \"&\" equality-expression")
  (or (cst-list-list-conc-matchp abnf::cstss "equality-expression")
      (cst-list-list-conc-matchp
           abnf::cstss
           "and-expression \"&\" equality-expression"))))

Theorem: cst-exclusive-or-expression-concs

(defthm cst-exclusive-or-expression-concs
 (implies
  (cst-list-list-alt-matchp
      abnf::cstss
      "and-expression / exclusive-or-expression \"^\" and-expression")
  (or (cst-list-list-conc-matchp abnf::cstss "and-expression")
      (cst-list-list-conc-matchp
           abnf::cstss
           "exclusive-or-expression \"^\" and-expression"))))

Theorem: cst-inclusive-or-expression-concs

(defthm cst-inclusive-or-expression-concs
 (implies
  (cst-list-list-alt-matchp
   abnf::cstss
   "exclusive-or-expression / inclusive-or-expression \"|\" exclusive-or-expression")
  (or
   (cst-list-list-conc-matchp abnf::cstss "exclusive-or-expression")
   (cst-list-list-conc-matchp
        abnf::cstss
        "inclusive-or-expression \"|\" exclusive-or-expression"))))

Theorem: cst-conditional-and-expression-concs

(defthm cst-conditional-and-expression-concs
 (implies
  (cst-list-list-alt-matchp
   abnf::cstss
   "inclusive-or-expression / conditional-and-expression \"&&\" inclusive-or-expression")
  (or
   (cst-list-list-conc-matchp abnf::cstss "inclusive-or-expression")
   (cst-list-list-conc-matchp
       abnf::cstss
       "conditional-and-expression \"&&\" inclusive-or-expression"))))

Theorem: cst-conditional-or-expression-concs

(defthm cst-conditional-or-expression-concs
 (implies
  (cst-list-list-alt-matchp
   abnf::cstss
   "conditional-and-expression / conditional-or-expression \"||\" conditional-and-expression")
  (or
   (cst-list-list-conc-matchp abnf::cstss
                              "conditional-and-expression")
   (cst-list-list-conc-matchp
     abnf::cstss
     "conditional-or-expression \"||\" conditional-and-expression"))))

Theorem: cst-conditional-expression-concs

(defthm cst-conditional-expression-concs
 (implies
  (cst-list-list-alt-matchp
   abnf::cstss
   "conditional-or-expression / conditional-or-expression \"?\" expression \":\" conditional-expression / conditional-or-expression \"?\" expression \":\" lambda-expression")
  (or
   (cst-list-list-conc-matchp
        abnf::cstss "conditional-or-expression")
   (cst-list-list-conc-matchp
    abnf::cstss
    "conditional-or-expression \"?\" expression \":\" conditional-expression")
   (cst-list-list-conc-matchp
    abnf::cstss
    "conditional-or-expression \"?\" expression \":\" lambda-expression"))))

Theorem: cst-assignment-expression-concs

(defthm cst-assignment-expression-concs
 (implies
  (cst-list-list-alt-matchp abnf::cstss
                            "conditional-expression / assignment")
  (or
    (cst-list-list-conc-matchp abnf::cstss "conditional-expression")
    (cst-list-list-conc-matchp abnf::cstss "assignment"))))

Theorem: cst-assignment-concs

(defthm cst-assignment-concs
  (implies
       (cst-list-list-alt-matchp
            abnf::cstss
            "left-hand-side assignment-operator expression")
       (or (cst-list-list-conc-matchp
                abnf::cstss
                "left-hand-side assignment-operator expression"))))

Theorem: cst-left-hand-side-concs

(defthm cst-left-hand-side-concs
  (implies
       (cst-list-list-alt-matchp
            abnf::cstss
            "expression-name / field-access / array-access")
       (or (cst-list-list-conc-matchp abnf::cstss "expression-name")
           (cst-list-list-conc-matchp abnf::cstss "field-access")
           (cst-list-list-conc-matchp abnf::cstss "array-access"))))

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 "\"|=\""))))

Theorem: cst-lambda-expression-concs

(defthm cst-lambda-expression-concs
 (implies
     (cst-list-list-alt-matchp abnf::cstss
                               "lambda-parameters \"->\" lambda-body")
     (or (cst-list-list-conc-matchp
              abnf::cstss
              "lambda-parameters \"->\" lambda-body"))))

Theorem: cst-lambda-parameters-concs

(defthm cst-lambda-parameters-concs
 (implies
  (cst-list-list-alt-matchp
     abnf::cstss
     "\"(\" [ lambda-parameter-list ] \")\" / concise-lambda-parameter")
  (or
     (cst-list-list-conc-matchp abnf::cstss
                                "\"(\" [ lambda-parameter-list ] \")\"")
     (cst-list-list-conc-matchp abnf::cstss
                                "concise-lambda-parameter"))))

Theorem: cst-lambda-parameter-list-concs

(defthm cst-lambda-parameter-list-concs
 (implies
  (cst-list-list-alt-matchp
   abnf::cstss
   "normal-lambda-parameter *( \",\" normal-lambda-parameter ) / concise-lambda-parameter *( \",\" concise-lambda-parameter )")
  (or
   (cst-list-list-conc-matchp
        abnf::cstss
        "normal-lambda-parameter *( \",\" normal-lambda-parameter )")
   (cst-list-list-conc-matchp
    abnf::cstss
    "concise-lambda-parameter *( \",\" concise-lambda-parameter )"))))

Theorem: cst-normal-lambda-parameter-concs

(defthm cst-normal-lambda-parameter-concs
 (implies
  (cst-list-list-alt-matchp
   abnf::cstss
   "*variable-modifier lambda-parameter-type variable-declarator-id / variable-arity-parameter")
  (or
   (cst-list-list-conc-matchp
    abnf::cstss
    "*variable-modifier lambda-parameter-type variable-declarator-id")
   (cst-list-list-conc-matchp abnf::cstss
                              "variable-arity-parameter"))))

Theorem: cst-lambda-parameter-type-concs

(defthm cst-lambda-parameter-type-concs
  (implies
       (cst-list-list-alt-matchp abnf::cstss "unann-type / %s\"var\"")
       (or (cst-list-list-conc-matchp abnf::cstss "unann-type")
           (cst-list-list-conc-matchp abnf::cstss "%s\"var\""))))

Theorem: cst-concise-lambda-parameter-concs

(defthm cst-concise-lambda-parameter-concs
  (implies (cst-list-list-alt-matchp abnf::cstss "identifier / \"_\"")
           (or (cst-list-list-conc-matchp abnf::cstss "identifier")
               (cst-list-list-conc-matchp abnf::cstss "\"_\""))))

Theorem: cst-lambda-body-concs

(defthm cst-lambda-body-concs
  (implies
       (cst-list-list-alt-matchp abnf::cstss "expression / block")
       (or (cst-list-list-conc-matchp abnf::cstss "expression")
           (cst-list-list-conc-matchp abnf::cstss "block"))))

Theorem: cst-switch-expression-concs

(defthm cst-switch-expression-concs
  (implies (cst-list-list-alt-matchp
                abnf::cstss
                "%s\"switch\" \"(\" expression \")\" switch-block")
           (or (cst-list-list-conc-matchp
                    abnf::cstss
                    "%s\"switch\" \"(\" expression \")\" switch-block"))))

Theorem: cst-unicode-input-character-conc1-matching

(defthm cst-unicode-input-character-conc1-matching
  (implies (cst-list-list-conc-matchp abnf::cstss "unicode-escape")
           (and (equal (len abnf::cstss) 1)
                (cst-list-rep-matchp (nth 0 abnf::cstss)
                                     "unicode-escape"))))

Theorem: cst-unicode-input-character-conc2-matching

(defthm cst-unicode-input-character-conc2-matching
  (implies
       (cst-list-list-conc-matchp abnf::cstss "raw-input-character")
       (and (equal (len abnf::cstss) 1)
            (cst-list-rep-matchp (nth 0 abnf::cstss)
                                 "raw-input-character"))))

Theorem: cst-unicode-marker-conc-matching

(defthm cst-unicode-marker-conc-matching
  (implies (cst-list-list-conc-matchp abnf::cstss "1*%s\"u\"")
           (and (equal (len abnf::cstss) 1)
                (cst-list-rep-matchp (nth 0 abnf::cstss)
                                     "1*%s\"u\""))))

Theorem: cst-hex-digit-conc1-matching

(defthm cst-hex-digit-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-hex-digit-conc2-matching

(defthm cst-hex-digit-conc2-matching
  (implies (cst-list-list-conc-matchp abnf::cstss "\"1\"")
           (and (equal (len abnf::cstss) 1)
                (cst-list-rep-matchp (nth 0 abnf::cstss)
                                     "\"1\""))))

Theorem: cst-hex-digit-conc3-matching

(defthm cst-hex-digit-conc3-matching
  (implies (cst-list-list-conc-matchp abnf::cstss "\"2\"")
           (and (equal (len abnf::cstss) 1)
                (cst-list-rep-matchp (nth 0 abnf::cstss)
                                     "\"2\""))))

Theorem: cst-hex-digit-conc4-matching

(defthm cst-hex-digit-conc4-matching
  (implies (cst-list-list-conc-matchp abnf::cstss "\"3\"")
           (and (equal (len abnf::cstss) 1)
                (cst-list-rep-matchp (nth 0 abnf::cstss)
                                     "\"3\""))))

Theorem: cst-hex-digit-conc5-matching

(defthm cst-hex-digit-conc5-matching
  (implies (cst-list-list-conc-matchp abnf::cstss "\"4\"")
           (and (equal (len abnf::cstss) 1)
                (cst-list-rep-matchp (nth 0 abnf::cstss)
                                     "\"4\""))))

Theorem: cst-hex-digit-conc6-matching

(defthm cst-hex-digit-conc6-matching
  (implies (cst-list-list-conc-matchp abnf::cstss "\"5\"")
           (and (equal (len abnf::cstss) 1)
                (cst-list-rep-matchp (nth 0 abnf::cstss)
                                     "\"5\""))))

Theorem: cst-hex-digit-conc7-matching

(defthm cst-hex-digit-conc7-matching
  (implies (cst-list-list-conc-matchp abnf::cstss "\"6\"")
           (and (equal (len abnf::cstss) 1)
                (cst-list-rep-matchp (nth 0 abnf::cstss)
                                     "\"6\""))))

Theorem: cst-hex-digit-conc8-matching

(defthm cst-hex-digit-conc8-matching
  (implies (cst-list-list-conc-matchp abnf::cstss "\"7\"")
           (and (equal (len abnf::cstss) 1)
                (cst-list-rep-matchp (nth 0 abnf::cstss)
                                     "\"7\""))))

Theorem: cst-hex-digit-conc9-matching

(defthm cst-hex-digit-conc9-matching
  (implies (cst-list-list-conc-matchp abnf::cstss "\"8\"")
           (and (equal (len abnf::cstss) 1)
                (cst-list-rep-matchp (nth 0 abnf::cstss)
                                     "\"8\""))))

Theorem: cst-hex-digit-conc10-matching

(defthm cst-hex-digit-conc10-matching
  (implies (cst-list-list-conc-matchp abnf::cstss "\"9\"")
           (and (equal (len abnf::cstss) 1)
                (cst-list-rep-matchp (nth 0 abnf::cstss)
                                     "\"9\""))))

Theorem: cst-hex-digit-conc11-matching

(defthm cst-hex-digit-conc11-matching
  (implies (cst-list-list-conc-matchp abnf::cstss "\"a\"")
           (and (equal (len abnf::cstss) 1)
                (cst-list-rep-matchp (nth 0 abnf::cstss)
                                     "\"a\""))))

Theorem: cst-hex-digit-conc12-matching

(defthm cst-hex-digit-conc12-matching
  (implies (cst-list-list-conc-matchp abnf::cstss "\"b\"")
           (and (equal (len abnf::cstss) 1)
                (cst-list-rep-matchp (nth 0 abnf::cstss)
                                     "\"b\""))))

Theorem: cst-hex-digit-conc13-matching

(defthm cst-hex-digit-conc13-matching
  (implies (cst-list-list-conc-matchp abnf::cstss "\"c\"")
           (and (equal (len abnf::cstss) 1)
                (cst-list-rep-matchp (nth 0 abnf::cstss)
                                     "\"c\""))))

Theorem: cst-hex-digit-conc14-matching

(defthm cst-hex-digit-conc14-matching
  (implies (cst-list-list-conc-matchp abnf::cstss "\"d\"")
           (and (equal (len abnf::cstss) 1)
                (cst-list-rep-matchp (nth 0 abnf::cstss)
                                     "\"d\""))))

Theorem: cst-hex-digit-conc15-matching

(defthm cst-hex-digit-conc15-matching
  (implies (cst-list-list-conc-matchp abnf::cstss "\"e\"")
           (and (equal (len abnf::cstss) 1)
                (cst-list-rep-matchp (nth 0 abnf::cstss)
                                     "\"e\""))))

Theorem: cst-hex-digit-conc16-matching

(defthm cst-hex-digit-conc16-matching
  (implies (cst-list-list-conc-matchp abnf::cstss "\"f\"")
           (and (equal (len abnf::cstss) 1)
                (cst-list-rep-matchp (nth 0 abnf::cstss)
                                     "\"f\""))))

Theorem: cst-raw-input-character-conc-matching

(defthm cst-raw-input-character-conc-matching
  (implies (cst-list-list-conc-matchp abnf::cstss "%x0-FFFF")
           (and (equal (len abnf::cstss) 1)
                (cst-list-rep-matchp (nth 0 abnf::cstss)
                                     "%x0-FFFF"))))

Theorem: cst-line-terminator-conc1-matching

(defthm cst-line-terminator-conc1-matching
  (implies (cst-list-list-conc-matchp abnf::cstss "%d10")
           (and (equal (len abnf::cstss) 1)
                (cst-list-rep-matchp (nth 0 abnf::cstss)
                                     "%d10"))))

Theorem: cst-line-terminator-conc2-matching

(defthm cst-line-terminator-conc2-matching
  (implies (cst-list-list-conc-matchp abnf::cstss "%d13")
           (and (equal (len abnf::cstss) 1)
                (cst-list-rep-matchp (nth 0 abnf::cstss)
                                     "%d13"))))

Theorem: cst-line-terminator-conc3-matching

(defthm cst-line-terminator-conc3-matching
  (implies (cst-list-list-conc-matchp abnf::cstss "%d13.10")
           (and (equal (len abnf::cstss) 1)
                (cst-list-rep-matchp (nth 0 abnf::cstss)
                                     "%d13.10"))))

Theorem: cst-input-character-conc-matching

(defthm cst-input-character-conc-matching
 (implies
   (cst-list-list-conc-matchp abnf::cstss "unicode-input-character")
   (and (equal (len abnf::cstss) 1)
        (cst-list-rep-matchp (nth 0 abnf::cstss)
                             "unicode-input-character"))))

Theorem: cst-input-element-conc1-matching

(defthm cst-input-element-conc1-matching
  (implies (cst-list-list-conc-matchp abnf::cstss "white-space")
           (and (equal (len abnf::cstss) 1)
                (cst-list-rep-matchp (nth 0 abnf::cstss)
                                     "white-space"))))

Theorem: cst-input-element-conc2-matching

(defthm cst-input-element-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-input-element-conc3-matching

(defthm cst-input-element-conc3-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-token-conc1-matching

(defthm cst-token-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-token-conc2-matching

(defthm cst-token-conc2-matching
  (implies (cst-list-list-conc-matchp abnf::cstss "keyword")
           (and (equal (len abnf::cstss) 1)
                (cst-list-rep-matchp (nth 0 abnf::cstss)
                                     "keyword"))))

Theorem: cst-token-conc3-matching

(defthm cst-token-conc3-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-token-conc4-matching

(defthm cst-token-conc4-matching
  (implies (cst-list-list-conc-matchp abnf::cstss "separator")
           (and (equal (len abnf::cstss) 1)
                (cst-list-rep-matchp (nth 0 abnf::cstss)
                                     "separator"))))

Theorem: cst-token-conc5-matching

(defthm cst-token-conc5-matching
  (implies (cst-list-list-conc-matchp abnf::cstss "operator")
           (and (equal (len abnf::cstss) 1)
                (cst-list-rep-matchp (nth 0 abnf::cstss)
                                     "operator"))))

Theorem: cst-sub-conc-matching

(defthm cst-sub-conc-matching
  (implies (cst-list-list-conc-matchp abnf::cstss "%d26")
           (and (equal (len abnf::cstss) 1)
                (cst-list-rep-matchp (nth 0 abnf::cstss)
                                     "%d26"))))

Theorem: cst-white-space-conc1-matching

(defthm cst-white-space-conc1-matching
  (implies (cst-list-list-conc-matchp abnf::cstss "%d32")
           (and (equal (len abnf::cstss) 1)
                (cst-list-rep-matchp (nth 0 abnf::cstss)
                                     "%d32"))))

Theorem: cst-white-space-conc2-matching

(defthm cst-white-space-conc2-matching
  (implies (cst-list-list-conc-matchp abnf::cstss "%d9")
           (and (equal (len abnf::cstss) 1)
                (cst-list-rep-matchp (nth 0 abnf::cstss)
                                     "%d9"))))

Theorem: cst-white-space-conc3-matching

(defthm cst-white-space-conc3-matching
  (implies (cst-list-list-conc-matchp abnf::cstss "%d12")
           (and (equal (len abnf::cstss) 1)
                (cst-list-rep-matchp (nth 0 abnf::cstss)
                                     "%d12"))))

Theorem: cst-white-space-conc4-matching

(defthm cst-white-space-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-comment-conc1-matching

(defthm cst-comment-conc1-matching
  (implies
       (cst-list-list-conc-matchp abnf::cstss "traditional-comment")
       (and (equal (len abnf::cstss) 1)
            (cst-list-rep-matchp (nth 0 abnf::cstss)
                                 "traditional-comment"))))

Theorem: cst-comment-conc2-matching

(defthm cst-comment-conc2-matching
  (implies
       (cst-list-list-conc-matchp abnf::cstss "end-of-line-comment")
       (and (equal (len abnf::cstss) 1)
            (cst-list-rep-matchp (nth 0 abnf::cstss)
                                 "end-of-line-comment"))))

Theorem: cst-comment-tail-star-conc1-matching

(defthm cst-comment-tail-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-conc1-matching

(defthm cst-not-star-conc1-matching
  (implies (cst-list-list-conc-matchp abnf::cstss "input-character")
           (and (equal (len abnf::cstss) 1)
                (cst-list-rep-matchp (nth 0 abnf::cstss)
                                     "input-character"))))

Theorem: cst-not-star-conc2-matching

(defthm cst-not-star-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-star-not-slash-conc1-matching

(defthm cst-not-star-not-slash-conc1-matching
  (implies (cst-list-list-conc-matchp abnf::cstss "input-character")
           (and (equal (len abnf::cstss) 1)
                (cst-list-rep-matchp (nth 0 abnf::cstss)
                                     "input-character"))))

Theorem: cst-not-star-not-slash-conc2-matching

(defthm cst-not-star-not-slash-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-identifier-conc-matching

(defthm cst-identifier-conc-matching
 (implies (cst-list-list-conc-matchp abnf::cstss "identifier-chars")
          (and (equal (len abnf::cstss) 1)
               (cst-list-rep-matchp (nth 0 abnf::cstss)
                                    "identifier-chars"))))

Theorem: cst-java-letter-conc-matching

(defthm cst-java-letter-conc-matching
  (implies
       (cst-list-list-conc-matchp abnf::cstss "raw-input-character")
       (and (equal (len abnf::cstss) 1)
            (cst-list-rep-matchp (nth 0 abnf::cstss)
                                 "raw-input-character"))))

Theorem: cst-java-letter-or-digit-conc-matching

(defthm cst-java-letter-or-digit-conc-matching
  (implies
       (cst-list-list-conc-matchp abnf::cstss "raw-input-character")
       (and (equal (len abnf::cstss) 1)
            (cst-list-rep-matchp (nth 0 abnf::cstss)
                                 "raw-input-character"))))

Theorem: cst-type-identifier-conc-matching

(defthm cst-type-identifier-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-unqualified-method-identifier-conc-matching

(defthm cst-unqualified-method-identifier-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-keyword-conc1-matching

(defthm cst-keyword-conc1-matching
 (implies (cst-list-list-conc-matchp abnf::cstss "reserved-keyword")
          (and (equal (len abnf::cstss) 1)
               (cst-list-rep-matchp (nth 0 abnf::cstss)
                                    "reserved-keyword"))))

Theorem: cst-keyword-conc2-matching

(defthm cst-keyword-conc2-matching
  (implies
       (cst-list-list-conc-matchp abnf::cstss "contextual-keyword")
       (and (equal (len abnf::cstss) 1)
            (cst-list-rep-matchp (nth 0 abnf::cstss)
                                 "contextual-keyword"))))

Theorem: cst-reserved-keyword-conc1-matching

(defthm cst-reserved-keyword-conc1-matching
  (implies (cst-list-list-conc-matchp abnf::cstss "%s\"abstract\"")
           (and (equal (len abnf::cstss) 1)
                (cst-list-rep-matchp (nth 0 abnf::cstss)
                                     "%s\"abstract\""))))

Theorem: cst-reserved-keyword-conc2-matching

(defthm cst-reserved-keyword-conc2-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-reserved-keyword-conc3-matching

(defthm cst-reserved-keyword-conc3-matching
  (implies (cst-list-list-conc-matchp abnf::cstss "%s\"boolean\"")
           (and (equal (len abnf::cstss) 1)
                (cst-list-rep-matchp (nth 0 abnf::cstss)
                                     "%s\"boolean\""))))

Theorem: cst-reserved-keyword-conc4-matching

(defthm cst-reserved-keyword-conc4-matching
  (implies (cst-list-list-conc-matchp abnf::cstss "%s\"break\"")
           (and (equal (len abnf::cstss) 1)
                (cst-list-rep-matchp (nth 0 abnf::cstss)
                                     "%s\"break\""))))

Theorem: cst-reserved-keyword-conc5-matching

(defthm cst-reserved-keyword-conc5-matching
  (implies (cst-list-list-conc-matchp abnf::cstss "%s\"byte\"")
           (and (equal (len abnf::cstss) 1)
                (cst-list-rep-matchp (nth 0 abnf::cstss)
                                     "%s\"byte\""))))

Theorem: cst-reserved-keyword-conc6-matching

(defthm cst-reserved-keyword-conc6-matching
  (implies (cst-list-list-conc-matchp abnf::cstss "%s\"case\"")
           (and (equal (len abnf::cstss) 1)
                (cst-list-rep-matchp (nth 0 abnf::cstss)
                                     "%s\"case\""))))

Theorem: cst-reserved-keyword-conc7-matching

(defthm cst-reserved-keyword-conc7-matching
  (implies (cst-list-list-conc-matchp abnf::cstss "%s\"catch\"")
           (and (equal (len abnf::cstss) 1)
                (cst-list-rep-matchp (nth 0 abnf::cstss)
                                     "%s\"catch\""))))

Theorem: cst-reserved-keyword-conc8-matching

(defthm cst-reserved-keyword-conc8-matching
  (implies (cst-list-list-conc-matchp abnf::cstss "%s\"char\"")
           (and (equal (len abnf::cstss) 1)
                (cst-list-rep-matchp (nth 0 abnf::cstss)
                                     "%s\"char\""))))

Theorem: cst-reserved-keyword-conc9-matching

(defthm cst-reserved-keyword-conc9-matching
  (implies (cst-list-list-conc-matchp abnf::cstss "%s\"class\"")
           (and (equal (len abnf::cstss) 1)
                (cst-list-rep-matchp (nth 0 abnf::cstss)
                                     "%s\"class\""))))

Theorem: cst-reserved-keyword-conc10-matching

(defthm cst-reserved-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-reserved-keyword-conc11-matching

(defthm cst-reserved-keyword-conc11-matching
  (implies (cst-list-list-conc-matchp abnf::cstss "%s\"continue\"")
           (and (equal (len abnf::cstss) 1)
                (cst-list-rep-matchp (nth 0 abnf::cstss)
                                     "%s\"continue\""))))

Theorem: cst-reserved-keyword-conc12-matching

(defthm cst-reserved-keyword-conc12-matching
  (implies (cst-list-list-conc-matchp abnf::cstss "%s\"default\"")
           (and (equal (len abnf::cstss) 1)
                (cst-list-rep-matchp (nth 0 abnf::cstss)
                                     "%s\"default\""))))

Theorem: cst-reserved-keyword-conc13-matching

(defthm cst-reserved-keyword-conc13-matching
  (implies (cst-list-list-conc-matchp abnf::cstss "%s\"do\"")
           (and (equal (len abnf::cstss) 1)
                (cst-list-rep-matchp (nth 0 abnf::cstss)
                                     "%s\"do\""))))

Theorem: cst-reserved-keyword-conc14-matching

(defthm cst-reserved-keyword-conc14-matching
  (implies (cst-list-list-conc-matchp abnf::cstss "%s\"double\"")
           (and (equal (len abnf::cstss) 1)
                (cst-list-rep-matchp (nth 0 abnf::cstss)
                                     "%s\"double\""))))

Theorem: cst-reserved-keyword-conc15-matching

(defthm cst-reserved-keyword-conc15-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-reserved-keyword-conc16-matching

(defthm cst-reserved-keyword-conc16-matching
  (implies (cst-list-list-conc-matchp abnf::cstss "%s\"enum\"")
           (and (equal (len abnf::cstss) 1)
                (cst-list-rep-matchp (nth 0 abnf::cstss)
                                     "%s\"enum\""))))

Theorem: cst-reserved-keyword-conc17-matching

(defthm cst-reserved-keyword-conc17-matching
  (implies (cst-list-list-conc-matchp abnf::cstss "%s\"extends\"")
           (and (equal (len abnf::cstss) 1)
                (cst-list-rep-matchp (nth 0 abnf::cstss)
                                     "%s\"extends\""))))

Theorem: cst-reserved-keyword-conc18-matching

(defthm cst-reserved-keyword-conc18-matching
  (implies (cst-list-list-conc-matchp abnf::cstss "%s\"final\"")
           (and (equal (len abnf::cstss) 1)
                (cst-list-rep-matchp (nth 0 abnf::cstss)
                                     "%s\"final\""))))

Theorem: cst-reserved-keyword-conc19-matching

(defthm cst-reserved-keyword-conc19-matching
  (implies (cst-list-list-conc-matchp abnf::cstss "%s\"finally\"")
           (and (equal (len abnf::cstss) 1)
                (cst-list-rep-matchp (nth 0 abnf::cstss)
                                     "%s\"finally\""))))

Theorem: cst-reserved-keyword-conc20-matching

(defthm cst-reserved-keyword-conc20-matching
  (implies (cst-list-list-conc-matchp abnf::cstss "%s\"float\"")
           (and (equal (len abnf::cstss) 1)
                (cst-list-rep-matchp (nth 0 abnf::cstss)
                                     "%s\"float\""))))

Theorem: cst-reserved-keyword-conc21-matching

(defthm cst-reserved-keyword-conc21-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-reserved-keyword-conc22-matching

(defthm cst-reserved-keyword-conc22-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-reserved-keyword-conc23-matching

(defthm cst-reserved-keyword-conc23-matching
  (implies (cst-list-list-conc-matchp abnf::cstss "%s\"goto\"")
           (and (equal (len abnf::cstss) 1)
                (cst-list-rep-matchp (nth 0 abnf::cstss)
                                     "%s\"goto\""))))

Theorem: cst-reserved-keyword-conc24-matching

(defthm cst-reserved-keyword-conc24-matching
  (implies (cst-list-list-conc-matchp abnf::cstss "%s\"implements\"")
           (and (equal (len abnf::cstss) 1)
                (cst-list-rep-matchp (nth 0 abnf::cstss)
                                     "%s\"implements\""))))

Theorem: cst-reserved-keyword-conc25-matching

(defthm cst-reserved-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-reserved-keyword-conc26-matching

(defthm cst-reserved-keyword-conc26-matching
  (implies (cst-list-list-conc-matchp abnf::cstss "%s\"instanceof\"")
           (and (equal (len abnf::cstss) 1)
                (cst-list-rep-matchp (nth 0 abnf::cstss)
                                     "%s\"instanceof\""))))

Theorem: cst-reserved-keyword-conc27-matching

(defthm cst-reserved-keyword-conc27-matching
  (implies (cst-list-list-conc-matchp abnf::cstss "%s\"int\"")
           (and (equal (len abnf::cstss) 1)
                (cst-list-rep-matchp (nth 0 abnf::cstss)
                                     "%s\"int\""))))

Theorem: cst-reserved-keyword-conc28-matching

(defthm cst-reserved-keyword-conc28-matching
  (implies (cst-list-list-conc-matchp abnf::cstss "%s\"interface\"")
           (and (equal (len abnf::cstss) 1)
                (cst-list-rep-matchp (nth 0 abnf::cstss)
                                     "%s\"interface\""))))

Theorem: cst-reserved-keyword-conc29-matching

(defthm cst-reserved-keyword-conc29-matching
  (implies (cst-list-list-conc-matchp abnf::cstss "%s\"long\"")
           (and (equal (len abnf::cstss) 1)
                (cst-list-rep-matchp (nth 0 abnf::cstss)
                                     "%s\"long\""))))

Theorem: cst-reserved-keyword-conc30-matching

(defthm cst-reserved-keyword-conc30-matching
  (implies (cst-list-list-conc-matchp abnf::cstss "%s\"native\"")
           (and (equal (len abnf::cstss) 1)
                (cst-list-rep-matchp (nth 0 abnf::cstss)
                                     "%s\"native\""))))

Theorem: cst-reserved-keyword-conc31-matching

(defthm cst-reserved-keyword-conc31-matching
  (implies (cst-list-list-conc-matchp abnf::cstss "%s\"new\"")
           (and (equal (len abnf::cstss) 1)
                (cst-list-rep-matchp (nth 0 abnf::cstss)
                                     "%s\"new\""))))

Theorem: cst-reserved-keyword-conc32-matching

(defthm cst-reserved-keyword-conc32-matching
  (implies (cst-list-list-conc-matchp abnf::cstss "%s\"package\"")
           (and (equal (len abnf::cstss) 1)
                (cst-list-rep-matchp (nth 0 abnf::cstss)
                                     "%s\"package\""))))

Theorem: cst-reserved-keyword-conc33-matching

(defthm cst-reserved-keyword-conc33-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-reserved-keyword-conc34-matching

(defthm cst-reserved-keyword-conc34-matching
  (implies (cst-list-list-conc-matchp abnf::cstss "%s\"protected\"")
           (and (equal (len abnf::cstss) 1)
                (cst-list-rep-matchp (nth 0 abnf::cstss)
                                     "%s\"protected\""))))

Theorem: cst-reserved-keyword-conc35-matching

(defthm cst-reserved-keyword-conc35-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-reserved-keyword-conc36-matching

(defthm cst-reserved-keyword-conc36-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-reserved-keyword-conc37-matching

(defthm cst-reserved-keyword-conc37-matching
  (implies (cst-list-list-conc-matchp abnf::cstss "%s\"short\"")
           (and (equal (len abnf::cstss) 1)
                (cst-list-rep-matchp (nth 0 abnf::cstss)
                                     "%s\"short\""))))

Theorem: cst-reserved-keyword-conc38-matching

(defthm cst-reserved-keyword-conc38-matching
  (implies (cst-list-list-conc-matchp abnf::cstss "%s\"static\"")
           (and (equal (len abnf::cstss) 1)
                (cst-list-rep-matchp (nth 0 abnf::cstss)
                                     "%s\"static\""))))

Theorem: cst-reserved-keyword-conc39-matching

(defthm cst-reserved-keyword-conc39-matching
  (implies (cst-list-list-conc-matchp abnf::cstss "%s\"strictfp\"")
           (and (equal (len abnf::cstss) 1)
                (cst-list-rep-matchp (nth 0 abnf::cstss)
                                     "%s\"strictfp\""))))

Theorem: cst-reserved-keyword-conc40-matching

(defthm cst-reserved-keyword-conc40-matching
  (implies (cst-list-list-conc-matchp abnf::cstss "%s\"super\"")
           (and (equal (len abnf::cstss) 1)
                (cst-list-rep-matchp (nth 0 abnf::cstss)
                                     "%s\"super\""))))

Theorem: cst-reserved-keyword-conc41-matching

(defthm cst-reserved-keyword-conc41-matching
  (implies (cst-list-list-conc-matchp abnf::cstss "%s\"switch\"")
           (and (equal (len abnf::cstss) 1)
                (cst-list-rep-matchp (nth 0 abnf::cstss)
                                     "%s\"switch\""))))

Theorem: cst-reserved-keyword-conc42-matching

(defthm cst-reserved-keyword-conc42-matching
 (implies (cst-list-list-conc-matchp abnf::cstss "%s\"synchronized\"")
          (and (equal (len abnf::cstss) 1)
               (cst-list-rep-matchp (nth 0 abnf::cstss)
                                    "%s\"synchronized\""))))

Theorem: cst-reserved-keyword-conc43-matching

(defthm cst-reserved-keyword-conc43-matching
  (implies (cst-list-list-conc-matchp abnf::cstss "%s\"this\"")
           (and (equal (len abnf::cstss) 1)
                (cst-list-rep-matchp (nth 0 abnf::cstss)
                                     "%s\"this\""))))

Theorem: cst-reserved-keyword-conc44-matching

(defthm cst-reserved-keyword-conc44-matching
  (implies (cst-list-list-conc-matchp abnf::cstss "%s\"throw\"")
           (and (equal (len abnf::cstss) 1)
                (cst-list-rep-matchp (nth 0 abnf::cstss)
                                     "%s\"throw\""))))

Theorem: cst-reserved-keyword-conc45-matching

(defthm cst-reserved-keyword-conc45-matching
  (implies (cst-list-list-conc-matchp abnf::cstss "%s\"throws\"")
           (and (equal (len abnf::cstss) 1)
                (cst-list-rep-matchp (nth 0 abnf::cstss)
                                     "%s\"throws\""))))

Theorem: cst-reserved-keyword-conc46-matching

(defthm cst-reserved-keyword-conc46-matching
  (implies (cst-list-list-conc-matchp abnf::cstss "%s\"transient\"")
           (and (equal (len abnf::cstss) 1)
                (cst-list-rep-matchp (nth 0 abnf::cstss)
                                     "%s\"transient\""))))

Theorem: cst-reserved-keyword-conc47-matching

(defthm cst-reserved-keyword-conc47-matching
  (implies (cst-list-list-conc-matchp abnf::cstss "%s\"try\"")
           (and (equal (len abnf::cstss) 1)
                (cst-list-rep-matchp (nth 0 abnf::cstss)
                                     "%s\"try\""))))

Theorem: cst-reserved-keyword-conc48-matching

(defthm cst-reserved-keyword-conc48-matching
  (implies (cst-list-list-conc-matchp abnf::cstss "%s\"void\"")
           (and (equal (len abnf::cstss) 1)
                (cst-list-rep-matchp (nth 0 abnf::cstss)
                                     "%s\"void\""))))

Theorem: cst-reserved-keyword-conc49-matching

(defthm cst-reserved-keyword-conc49-matching
  (implies (cst-list-list-conc-matchp abnf::cstss "%s\"volatile\"")
           (and (equal (len abnf::cstss) 1)
                (cst-list-rep-matchp (nth 0 abnf::cstss)
                                     "%s\"volatile\""))))

Theorem: cst-reserved-keyword-conc50-matching

(defthm cst-reserved-keyword-conc50-matching
  (implies (cst-list-list-conc-matchp abnf::cstss "%s\"while\"")
           (and (equal (len abnf::cstss) 1)
                (cst-list-rep-matchp (nth 0 abnf::cstss)
                                     "%s\"while\""))))

Theorem: cst-reserved-keyword-conc51-matching

(defthm cst-reserved-keyword-conc51-matching
  (implies (cst-list-list-conc-matchp abnf::cstss "\"_\"")
           (and (equal (len abnf::cstss) 1)
                (cst-list-rep-matchp (nth 0 abnf::cstss)
                                     "\"_\""))))

Theorem: cst-contextual-keyword-conc1-matching

(defthm cst-contextual-keyword-conc1-matching
  (implies (cst-list-list-conc-matchp abnf::cstss "%s\"exports\"")
           (and (equal (len abnf::cstss) 1)
                (cst-list-rep-matchp (nth 0 abnf::cstss)
                                     "%s\"exports\""))))

Theorem: cst-contextual-keyword-conc2-matching

(defthm cst-contextual-keyword-conc2-matching
  (implies (cst-list-list-conc-matchp abnf::cstss "%s\"module\"")
           (and (equal (len abnf::cstss) 1)
                (cst-list-rep-matchp (nth 0 abnf::cstss)
                                     "%s\"module\""))))

Theorem: cst-contextual-keyword-conc3-matching

(defthm cst-contextual-keyword-conc3-matching
  (implies (cst-list-list-conc-matchp abnf::cstss "%s\"non-sealed\"")
           (and (equal (len abnf::cstss) 1)
                (cst-list-rep-matchp (nth 0 abnf::cstss)
                                     "%s\"non-sealed\""))))

Theorem: cst-contextual-keyword-conc4-matching

(defthm cst-contextual-keyword-conc4-matching
  (implies (cst-list-list-conc-matchp abnf::cstss "%s\"open\"")
           (and (equal (len abnf::cstss) 1)
                (cst-list-rep-matchp (nth 0 abnf::cstss)
                                     "%s\"open\""))))

Theorem: cst-contextual-keyword-conc5-matching

(defthm cst-contextual-keyword-conc5-matching
  (implies (cst-list-list-conc-matchp abnf::cstss "%s\"opens\"")
           (and (equal (len abnf::cstss) 1)
                (cst-list-rep-matchp (nth 0 abnf::cstss)
                                     "%s\"opens\""))))

Theorem: cst-contextual-keyword-conc6-matching

(defthm cst-contextual-keyword-conc6-matching
  (implies (cst-list-list-conc-matchp abnf::cstss "%s\"permits\"")
           (and (equal (len abnf::cstss) 1)
                (cst-list-rep-matchp (nth 0 abnf::cstss)
                                     "%s\"permits\""))))

Theorem: cst-contextual-keyword-conc7-matching

(defthm cst-contextual-keyword-conc7-matching
  (implies (cst-list-list-conc-matchp abnf::cstss "%s\"provides\"")
           (and (equal (len abnf::cstss) 1)
                (cst-list-rep-matchp (nth 0 abnf::cstss)
                                     "%s\"provides\""))))

Theorem: cst-contextual-keyword-conc8-matching

(defthm cst-contextual-keyword-conc8-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-contextual-keyword-conc9-matching

(defthm cst-contextual-keyword-conc9-matching
  (implies (cst-list-list-conc-matchp abnf::cstss "%s\"requires\"")
           (and (equal (len abnf::cstss) 1)
                (cst-list-rep-matchp (nth 0 abnf::cstss)
                                     "%s\"requires\""))))

Theorem: cst-contextual-keyword-conc10-matching

(defthm cst-contextual-keyword-conc10-matching
  (implies (cst-list-list-conc-matchp abnf::cstss "%s\"sealed\"")
           (and (equal (len abnf::cstss) 1)
                (cst-list-rep-matchp (nth 0 abnf::cstss)
                                     "%s\"sealed\""))))

Theorem: cst-contextual-keyword-conc11-matching

(defthm cst-contextual-keyword-conc11-matching
  (implies (cst-list-list-conc-matchp abnf::cstss "%s\"to\"")
           (and (equal (len abnf::cstss) 1)
                (cst-list-rep-matchp (nth 0 abnf::cstss)
                                     "%s\"to\""))))

Theorem: cst-contextual-keyword-conc12-matching

(defthm cst-contextual-keyword-conc12-matching
  (implies (cst-list-list-conc-matchp abnf::cstss "%s\"transitive\"")
           (and (equal (len abnf::cstss) 1)
                (cst-list-rep-matchp (nth 0 abnf::cstss)
                                     "%s\"transitive\""))))

Theorem: cst-contextual-keyword-conc13-matching

(defthm cst-contextual-keyword-conc13-matching
  (implies (cst-list-list-conc-matchp abnf::cstss "%s\"uses\"")
           (and (equal (len abnf::cstss) 1)
                (cst-list-rep-matchp (nth 0 abnf::cstss)
                                     "%s\"uses\""))))

Theorem: cst-contextual-keyword-conc14-matching

(defthm cst-contextual-keyword-conc14-matching
  (implies (cst-list-list-conc-matchp abnf::cstss "%s\"var\"")
           (and (equal (len abnf::cstss) 1)
                (cst-list-rep-matchp (nth 0 abnf::cstss)
                                     "%s\"var\""))))

Theorem: cst-contextual-keyword-conc15-matching

(defthm cst-contextual-keyword-conc15-matching
  (implies (cst-list-list-conc-matchp abnf::cstss "%s\"when\"")
           (and (equal (len abnf::cstss) 1)
                (cst-list-rep-matchp (nth 0 abnf::cstss)
                                     "%s\"when\""))))

Theorem: cst-contextual-keyword-conc16-matching

(defthm cst-contextual-keyword-conc16-matching
  (implies (cst-list-list-conc-matchp abnf::cstss "%s\"with\"")
           (and (equal (len abnf::cstss) 1)
                (cst-list-rep-matchp (nth 0 abnf::cstss)
                                     "%s\"with\""))))

Theorem: cst-contextual-keyword-conc17-matching

(defthm cst-contextual-keyword-conc17-matching
  (implies (cst-list-list-conc-matchp abnf::cstss "%s\"yield\"")
           (and (equal (len abnf::cstss) 1)
                (cst-list-rep-matchp (nth 0 abnf::cstss)
                                     "%s\"yield\""))))

Theorem: cst-literal-conc1-matching

(defthm cst-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-literal-conc2-matching

(defthm cst-literal-conc2-matching
 (implies
    (cst-list-list-conc-matchp abnf::cstss "floating-point-literal")
    (and (equal (len abnf::cstss) 1)
         (cst-list-rep-matchp (nth 0 abnf::cstss)
                              "floating-point-literal"))))

Theorem: cst-literal-conc3-matching

(defthm cst-literal-conc3-matching
  (implies (cst-list-list-conc-matchp abnf::cstss "boolean-literal")
           (and (equal (len abnf::cstss) 1)
                (cst-list-rep-matchp (nth 0 abnf::cstss)
                                     "boolean-literal"))))

Theorem: cst-literal-conc4-matching

(defthm cst-literal-conc4-matching
  (implies
       (cst-list-list-conc-matchp abnf::cstss "character-literal")
       (and (equal (len abnf::cstss) 1)
            (cst-list-rep-matchp (nth 0 abnf::cstss)
                                 "character-literal"))))

Theorem: cst-literal-conc5-matching

(defthm cst-literal-conc5-matching
  (implies (cst-list-list-conc-matchp abnf::cstss "string-literal")
           (and (equal (len abnf::cstss) 1)
                (cst-list-rep-matchp (nth 0 abnf::cstss)
                                     "string-literal"))))

Theorem: cst-literal-conc6-matching

(defthm cst-literal-conc6-matching
  (implies (cst-list-list-conc-matchp abnf::cstss "text-block")
           (and (equal (len abnf::cstss) 1)
                (cst-list-rep-matchp (nth 0 abnf::cstss)
                                     "text-block"))))

Theorem: cst-literal-conc7-matching

(defthm cst-literal-conc7-matching
  (implies (cst-list-list-conc-matchp abnf::cstss "null-literal")
           (and (equal (len abnf::cstss) 1)
                (cst-list-rep-matchp (nth 0 abnf::cstss)
                                     "null-literal"))))

Theorem: cst-integer-literal-conc1-matching

(defthm cst-integer-literal-conc1-matching
 (implies
   (cst-list-list-conc-matchp abnf::cstss "decimal-integer-literal")
   (and (equal (len abnf::cstss) 1)
        (cst-list-rep-matchp (nth 0 abnf::cstss)
                             "decimal-integer-literal"))))

Theorem: cst-integer-literal-conc2-matching

(defthm cst-integer-literal-conc2-matching
  (implies
       (cst-list-list-conc-matchp abnf::cstss "hex-integer-literal")
       (and (equal (len abnf::cstss) 1)
            (cst-list-rep-matchp (nth 0 abnf::cstss)
                                 "hex-integer-literal"))))

Theorem: cst-integer-literal-conc3-matching

(defthm cst-integer-literal-conc3-matching
 (implies
     (cst-list-list-conc-matchp abnf::cstss "octal-integer-literal")
     (and (equal (len abnf::cstss) 1)
          (cst-list-rep-matchp (nth 0 abnf::cstss)
                               "octal-integer-literal"))))

Theorem: cst-integer-literal-conc4-matching

(defthm cst-integer-literal-conc4-matching
 (implies
    (cst-list-list-conc-matchp abnf::cstss "binary-integer-literal")
    (and (equal (len abnf::cstss) 1)
         (cst-list-rep-matchp (nth 0 abnf::cstss)
                              "binary-integer-literal"))))

Theorem: cst-integer-type-suffix-conc-matching

(defthm cst-integer-type-suffix-conc-matching
  (implies (cst-list-list-conc-matchp abnf::cstss "\"l\"")
           (and (equal (len abnf::cstss) 1)
                (cst-list-rep-matchp (nth 0 abnf::cstss)
                                     "\"l\""))))

Theorem: cst-decimal-numeral-conc1-matching

(defthm cst-decimal-numeral-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-non-zero-digit-conc1-matching

(defthm cst-non-zero-digit-conc1-matching
  (implies (cst-list-list-conc-matchp abnf::cstss "\"1\"")
           (and (equal (len abnf::cstss) 1)
                (cst-list-rep-matchp (nth 0 abnf::cstss)
                                     "\"1\""))))

Theorem: cst-non-zero-digit-conc2-matching

(defthm cst-non-zero-digit-conc2-matching
  (implies (cst-list-list-conc-matchp abnf::cstss "\"2\"")
           (and (equal (len abnf::cstss) 1)
                (cst-list-rep-matchp (nth 0 abnf::cstss)
                                     "\"2\""))))

Theorem: cst-non-zero-digit-conc3-matching

(defthm cst-non-zero-digit-conc3-matching
  (implies (cst-list-list-conc-matchp abnf::cstss "\"3\"")
           (and (equal (len abnf::cstss) 1)
                (cst-list-rep-matchp (nth 0 abnf::cstss)
                                     "\"3\""))))

Theorem: cst-non-zero-digit-conc4-matching

(defthm cst-non-zero-digit-conc4-matching
  (implies (cst-list-list-conc-matchp abnf::cstss "\"4\"")
           (and (equal (len abnf::cstss) 1)
                (cst-list-rep-matchp (nth 0 abnf::cstss)
                                     "\"4\""))))

Theorem: cst-non-zero-digit-conc5-matching

(defthm cst-non-zero-digit-conc5-matching
  (implies (cst-list-list-conc-matchp abnf::cstss "\"5\"")
           (and (equal (len abnf::cstss) 1)
                (cst-list-rep-matchp (nth 0 abnf::cstss)
                                     "\"5\""))))

Theorem: cst-non-zero-digit-conc6-matching

(defthm cst-non-zero-digit-conc6-matching
  (implies (cst-list-list-conc-matchp abnf::cstss "\"6\"")
           (and (equal (len abnf::cstss) 1)
                (cst-list-rep-matchp (nth 0 abnf::cstss)
                                     "\"6\""))))

Theorem: cst-non-zero-digit-conc7-matching

(defthm cst-non-zero-digit-conc7-matching
  (implies (cst-list-list-conc-matchp abnf::cstss "\"7\"")
           (and (equal (len abnf::cstss) 1)
                (cst-list-rep-matchp (nth 0 abnf::cstss)
                                     "\"7\""))))

Theorem: cst-non-zero-digit-conc8-matching

(defthm cst-non-zero-digit-conc8-matching
  (implies (cst-list-list-conc-matchp abnf::cstss "\"8\"")
           (and (equal (len abnf::cstss) 1)
                (cst-list-rep-matchp (nth 0 abnf::cstss)
                                     "\"8\""))))

Theorem: cst-non-zero-digit-conc9-matching

(defthm cst-non-zero-digit-conc9-matching
  (implies (cst-list-list-conc-matchp abnf::cstss "\"9\"")
           (and (equal (len abnf::cstss) 1)
                (cst-list-rep-matchp (nth 0 abnf::cstss)
                                     "\"9\""))))

Theorem: cst-digits-conc1-matching

(defthm cst-digits-conc1-matching
  (implies (cst-list-list-conc-matchp abnf::cstss "digit")
           (and (equal (len abnf::cstss) 1)
                (cst-list-rep-matchp (nth 0 abnf::cstss)
                                     "digit"))))

Theorem: cst-digit-conc1-matching

(defthm cst-digit-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-digit-conc2-matching

(defthm cst-digit-conc2-matching
  (implies (cst-list-list-conc-matchp abnf::cstss "non-zero-digit")
           (and (equal (len abnf::cstss) 1)
                (cst-list-rep-matchp (nth 0 abnf::cstss)
                                     "non-zero-digit"))))

Theorem: cst-digit-or-underscore-conc1-matching

(defthm cst-digit-or-underscore-conc1-matching
  (implies (cst-list-list-conc-matchp abnf::cstss "digit")
           (and (equal (len abnf::cstss) 1)
                (cst-list-rep-matchp (nth 0 abnf::cstss)
                                     "digit"))))

Theorem: cst-digit-or-underscore-conc2-matching

(defthm cst-digit-or-underscore-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-underscores-conc-matching

(defthm cst-underscores-conc-matching
  (implies (cst-list-list-conc-matchp abnf::cstss "1*\"_\"")
           (and (equal (len abnf::cstss) 1)
                (cst-list-rep-matchp (nth 0 abnf::cstss)
                                     "1*\"_\""))))

Theorem: cst-hex-digits-conc1-matching

(defthm cst-hex-digits-conc1-matching
  (implies (cst-list-list-conc-matchp abnf::cstss "hex-digit")
           (and (equal (len abnf::cstss) 1)
                (cst-list-rep-matchp (nth 0 abnf::cstss)
                                     "hex-digit"))))

Theorem: cst-hex-digits-and-underscores-conc-matching

(defthm cst-hex-digits-and-underscores-conc-matching
  (implies (cst-list-list-conc-matchp
                abnf::cstss "1*hex-digit-or-underscore")
           (and (equal (len abnf::cstss) 1)
                (cst-list-rep-matchp (nth 0 abnf::cstss)
                                     "1*hex-digit-or-underscore"))))

Theorem: cst-hex-digit-or-underscore-conc1-matching

(defthm cst-hex-digit-or-underscore-conc1-matching
  (implies (cst-list-list-conc-matchp abnf::cstss "hex-digit")
           (and (equal (len abnf::cstss) 1)
                (cst-list-rep-matchp (nth 0 abnf::cstss)
                                     "hex-digit"))))

Theorem: cst-hex-digit-or-underscore-conc2-matching

(defthm cst-hex-digit-or-underscore-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-octal-digits-conc1-matching

(defthm cst-octal-digits-conc1-matching
  (implies (cst-list-list-conc-matchp abnf::cstss "octal-digit")
           (and (equal (len abnf::cstss) 1)
                (cst-list-rep-matchp (nth 0 abnf::cstss)
                                     "octal-digit"))))

Theorem: cst-octal-digit-conc1-matching

(defthm cst-octal-digit-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-octal-digit-conc2-matching

(defthm cst-octal-digit-conc2-matching
  (implies (cst-list-list-conc-matchp abnf::cstss "\"1\"")
           (and (equal (len abnf::cstss) 1)
                (cst-list-rep-matchp (nth 0 abnf::cstss)
                                     "\"1\""))))

Theorem: cst-octal-digit-conc3-matching

(defthm cst-octal-digit-conc3-matching
  (implies (cst-list-list-conc-matchp abnf::cstss "\"2\"")
           (and (equal (len abnf::cstss) 1)
                (cst-list-rep-matchp (nth 0 abnf::cstss)
                                     "\"2\""))))

Theorem: cst-octal-digit-conc4-matching

(defthm cst-octal-digit-conc4-matching
  (implies (cst-list-list-conc-matchp abnf::cstss "\"3\"")
           (and (equal (len abnf::cstss) 1)
                (cst-list-rep-matchp (nth 0 abnf::cstss)
                                     "\"3\""))))

Theorem: cst-octal-digit-conc5-matching

(defthm cst-octal-digit-conc5-matching
  (implies (cst-list-list-conc-matchp abnf::cstss "\"4\"")
           (and (equal (len abnf::cstss) 1)
                (cst-list-rep-matchp (nth 0 abnf::cstss)
                                     "\"4\""))))

Theorem: cst-octal-digit-conc6-matching

(defthm cst-octal-digit-conc6-matching
  (implies (cst-list-list-conc-matchp abnf::cstss "\"5\"")
           (and (equal (len abnf::cstss) 1)
                (cst-list-rep-matchp (nth 0 abnf::cstss)
                                     "\"5\""))))

Theorem: cst-octal-digit-conc7-matching

(defthm cst-octal-digit-conc7-matching
  (implies (cst-list-list-conc-matchp abnf::cstss "\"6\"")
           (and (equal (len abnf::cstss) 1)
                (cst-list-rep-matchp (nth 0 abnf::cstss)
                                     "\"6\""))))

Theorem: cst-octal-digit-conc8-matching

(defthm cst-octal-digit-conc8-matching
  (implies (cst-list-list-conc-matchp abnf::cstss "\"7\"")
           (and (equal (len abnf::cstss) 1)
                (cst-list-rep-matchp (nth 0 abnf::cstss)
                                     "\"7\""))))

Theorem: cst-octal-digits-and-underscores-conc-matching

(defthm cst-octal-digits-and-underscores-conc-matching
  (implies
       (cst-list-list-conc-matchp abnf::cstss
                                  "1*octal-digit-or-underscore")
       (and (equal (len abnf::cstss) 1)
            (cst-list-rep-matchp (nth 0 abnf::cstss)
                                 "1*octal-digit-or-underscore"))))

Theorem: cst-octal-digit-or-underscore-conc1-matching

(defthm cst-octal-digit-or-underscore-conc1-matching
  (implies (cst-list-list-conc-matchp abnf::cstss "octal-digit")
           (and (equal (len abnf::cstss) 1)
                (cst-list-rep-matchp (nth 0 abnf::cstss)
                                     "octal-digit"))))

Theorem: cst-octal-digit-or-underscore-conc2-matching

(defthm cst-octal-digit-or-underscore-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-binary-digits-conc1-matching

(defthm cst-binary-digits-conc1-matching
  (implies (cst-list-list-conc-matchp abnf::cstss "binary-digit")
           (and (equal (len abnf::cstss) 1)
                (cst-list-rep-matchp (nth 0 abnf::cstss)
                                     "binary-digit"))))

Theorem: cst-binary-digit-conc1-matching

(defthm cst-binary-digit-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-binary-digit-conc2-matching

(defthm cst-binary-digit-conc2-matching
  (implies (cst-list-list-conc-matchp abnf::cstss "\"1\"")
           (and (equal (len abnf::cstss) 1)
                (cst-list-rep-matchp (nth 0 abnf::cstss)
                                     "\"1\""))))

Theorem: cst-binary-digits-and-underscores-conc-matching

(defthm cst-binary-digits-and-underscores-conc-matching
  (implies
       (cst-list-list-conc-matchp abnf::cstss
                                  "1*binary-digit-or-underscore")
       (and (equal (len abnf::cstss) 1)
            (cst-list-rep-matchp (nth 0 abnf::cstss)
                                 "1*binary-digit-or-underscore"))))

Theorem: cst-binary-digit-or-underscore-conc1-matching

(defthm cst-binary-digit-or-underscore-conc1-matching
  (implies (cst-list-list-conc-matchp abnf::cstss "binary-digit")
           (and (equal (len abnf::cstss) 1)
                (cst-list-rep-matchp (nth 0 abnf::cstss)
                                     "binary-digit"))))

Theorem: cst-binary-digit-or-underscore-conc2-matching

(defthm cst-binary-digit-or-underscore-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-floating-point-literal-conc1-matching

(defthm cst-floating-point-literal-conc1-matching
 (implies
      (cst-list-list-conc-matchp abnf::cstss
                                 "decimal-floating-point-literal")
      (and (equal (len abnf::cstss) 1)
           (cst-list-rep-matchp (nth 0 abnf::cstss)
                                "decimal-floating-point-literal"))))

Theorem: cst-floating-point-literal-conc2-matching

(defthm cst-floating-point-literal-conc2-matching
 (implies
  (cst-list-list-conc-matchp abnf::cstss
                             "hexadecimal-floating-point-literal")
  (and (equal (len abnf::cstss) 1)
       (cst-list-rep-matchp (nth 0 abnf::cstss)
                            "hexadecimal-floating-point-literal"))))

Theorem: cst-exponent-indicator-conc-matching

(defthm cst-exponent-indicator-conc-matching
  (implies (cst-list-list-conc-matchp abnf::cstss "\"e\"")
           (and (equal (len abnf::cstss) 1)
                (cst-list-rep-matchp (nth 0 abnf::cstss)
                                     "\"e\""))))

Theorem: cst-sign-conc1-matching

(defthm cst-sign-conc1-matching
  (implies (cst-list-list-conc-matchp abnf::cstss "\"+\"")
           (and (equal (len abnf::cstss) 1)
                (cst-list-rep-matchp (nth 0 abnf::cstss)
                                     "\"+\""))))

Theorem: cst-sign-conc2-matching

(defthm cst-sign-conc2-matching
  (implies (cst-list-list-conc-matchp abnf::cstss "\"-\"")
           (and (equal (len abnf::cstss) 1)
                (cst-list-rep-matchp (nth 0 abnf::cstss)
                                     "\"-\""))))

Theorem: cst-float-type-suffix-conc1-matching

(defthm cst-float-type-suffix-conc1-matching
  (implies (cst-list-list-conc-matchp abnf::cstss "\"f\"")
           (and (equal (len abnf::cstss) 1)
                (cst-list-rep-matchp (nth 0 abnf::cstss)
                                     "\"f\""))))

Theorem: cst-float-type-suffix-conc2-matching

(defthm cst-float-type-suffix-conc2-matching
  (implies (cst-list-list-conc-matchp abnf::cstss "\"d\"")
           (and (equal (len abnf::cstss) 1)
                (cst-list-rep-matchp (nth 0 abnf::cstss)
                                     "\"d\""))))

Theorem: cst-binary-exponent-indicator-conc-matching

(defthm cst-binary-exponent-indicator-conc-matching
  (implies (cst-list-list-conc-matchp abnf::cstss "\"p\"")
           (and (equal (len abnf::cstss) 1)
                (cst-list-rep-matchp (nth 0 abnf::cstss)
                                     "\"p\""))))

Theorem: cst-boolean-literal-conc1-matching

(defthm cst-boolean-literal-conc1-matching
  (implies (cst-list-list-conc-matchp abnf::cstss "%s\"true\"")
           (and (equal (len abnf::cstss) 1)
                (cst-list-rep-matchp (nth 0 abnf::cstss)
                                     "%s\"true\""))))

Theorem: cst-boolean-literal-conc2-matching

(defthm cst-boolean-literal-conc2-matching
  (implies (cst-list-list-conc-matchp abnf::cstss "%s\"false\"")
           (and (equal (len abnf::cstss) 1)
                (cst-list-rep-matchp (nth 0 abnf::cstss)
                                     "%s\"false\""))))

Theorem: cst-single-character-conc-matching

(defthm cst-single-character-conc-matching
  (implies (cst-list-list-conc-matchp abnf::cstss "input-character")
           (and (equal (len abnf::cstss) 1)
                (cst-list-rep-matchp (nth 0 abnf::cstss)
                                     "input-character"))))

Theorem: cst-string-character-conc1-matching

(defthm cst-string-character-conc1-matching
  (implies (cst-list-list-conc-matchp abnf::cstss "input-character")
           (and (equal (len abnf::cstss) 1)
                (cst-list-rep-matchp (nth 0 abnf::cstss)
                                     "input-character"))))

Theorem: cst-string-character-conc2-matching

(defthm cst-string-character-conc2-matching
  (implies (cst-list-list-conc-matchp abnf::cstss "escape-sequence")
           (and (equal (len abnf::cstss) 1)
                (cst-list-rep-matchp (nth 0 abnf::cstss)
                                     "escape-sequence"))))

Theorem: cst-text-block-white-space-conc-matching

(defthm cst-text-block-white-space-conc-matching
  (implies (cst-list-list-conc-matchp abnf::cstss "white-space")
           (and (equal (len abnf::cstss) 1)
                (cst-list-rep-matchp (nth 0 abnf::cstss)
                                     "white-space"))))

Theorem: cst-text-block-character-conc1-matching

(defthm cst-text-block-character-conc1-matching
  (implies (cst-list-list-conc-matchp abnf::cstss "input-character")
           (and (equal (len abnf::cstss) 1)
                (cst-list-rep-matchp (nth 0 abnf::cstss)
                                     "input-character"))))

Theorem: cst-text-block-character-conc2-matching

(defthm cst-text-block-character-conc2-matching
  (implies (cst-list-list-conc-matchp abnf::cstss "escape-sequence")
           (and (equal (len abnf::cstss) 1)
                (cst-list-rep-matchp (nth 0 abnf::cstss)
                                     "escape-sequence"))))

Theorem: cst-text-block-character-conc3-matching

(defthm cst-text-block-character-conc3-matching
  (implies (cst-list-list-conc-matchp abnf::cstss "line-terminator")
           (and (equal (len abnf::cstss) 1)
                (cst-list-rep-matchp (nth 0 abnf::cstss)
                                     "line-terminator"))))

Theorem: cst-escape-sequence-conc1-matching

(defthm cst-escape-sequence-conc1-matching
  (implies (cst-list-list-conc-matchp abnf::cstss "%s\"\\b\"")
           (and (equal (len abnf::cstss) 1)
                (cst-list-rep-matchp (nth 0 abnf::cstss)
                                     "%s\"\\b\""))))

Theorem: cst-escape-sequence-conc2-matching

(defthm cst-escape-sequence-conc2-matching
  (implies (cst-list-list-conc-matchp abnf::cstss "%s\"\\s\"")
           (and (equal (len abnf::cstss) 1)
                (cst-list-rep-matchp (nth 0 abnf::cstss)
                                     "%s\"\\s\""))))

Theorem: cst-escape-sequence-conc3-matching

(defthm cst-escape-sequence-conc3-matching
  (implies (cst-list-list-conc-matchp abnf::cstss "%s\"\\t\"")
           (and (equal (len abnf::cstss) 1)
                (cst-list-rep-matchp (nth 0 abnf::cstss)
                                     "%s\"\\t\""))))

Theorem: cst-escape-sequence-conc4-matching

(defthm cst-escape-sequence-conc4-matching
  (implies (cst-list-list-conc-matchp abnf::cstss "%s\"\\n\"")
           (and (equal (len abnf::cstss) 1)
                (cst-list-rep-matchp (nth 0 abnf::cstss)
                                     "%s\"\\n\""))))

Theorem: cst-escape-sequence-conc5-matching

(defthm cst-escape-sequence-conc5-matching
  (implies (cst-list-list-conc-matchp abnf::cstss "%s\"\\f\"")
           (and (equal (len abnf::cstss) 1)
                (cst-list-rep-matchp (nth 0 abnf::cstss)
                                     "%s\"\\f\""))))

Theorem: cst-escape-sequence-conc6-matching

(defthm cst-escape-sequence-conc6-matching
  (implies (cst-list-list-conc-matchp abnf::cstss "%s\"\\r\"")
           (and (equal (len abnf::cstss) 1)
                (cst-list-rep-matchp (nth 0 abnf::cstss)
                                     "%s\"\\r\""))))

Theorem: cst-escape-sequence-conc7-matching

(defthm cst-escape-sequence-conc7-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-escape-sequence-conc9-matching

(defthm cst-escape-sequence-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-escape-sequence-conc10-matching

(defthm cst-escape-sequence-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-escape-sequence-conc11-matching

(defthm cst-escape-sequence-conc11-matching
  (implies (cst-list-list-conc-matchp abnf::cstss "octal-escape")
           (and (equal (len abnf::cstss) 1)
                (cst-list-rep-matchp (nth 0 abnf::cstss)
                                     "octal-escape"))))

Theorem: cst-zero-to-three-conc1-matching

(defthm cst-zero-to-three-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-zero-to-three-conc2-matching

(defthm cst-zero-to-three-conc2-matching
  (implies (cst-list-list-conc-matchp abnf::cstss "\"1\"")
           (and (equal (len abnf::cstss) 1)
                (cst-list-rep-matchp (nth 0 abnf::cstss)
                                     "\"1\""))))

Theorem: cst-zero-to-three-conc3-matching

(defthm cst-zero-to-three-conc3-matching
  (implies (cst-list-list-conc-matchp abnf::cstss "\"2\"")
           (and (equal (len abnf::cstss) 1)
                (cst-list-rep-matchp (nth 0 abnf::cstss)
                                     "\"2\""))))

Theorem: cst-zero-to-three-conc4-matching

(defthm cst-zero-to-three-conc4-matching
  (implies (cst-list-list-conc-matchp abnf::cstss "\"3\"")
           (and (equal (len abnf::cstss) 1)
                (cst-list-rep-matchp (nth 0 abnf::cstss)
                                     "\"3\""))))

Theorem: cst-null-literal-conc-matching

(defthm cst-null-literal-conc-matching
  (implies (cst-list-list-conc-matchp abnf::cstss "%s\"null\"")
           (and (equal (len abnf::cstss) 1)
                (cst-list-rep-matchp (nth 0 abnf::cstss)
                                     "%s\"null\""))))

Theorem: cst-separator-conc1-matching

(defthm cst-separator-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-separator-conc2-matching

(defthm cst-separator-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-separator-conc3-matching

(defthm cst-separator-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-separator-conc4-matching

(defthm cst-separator-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-separator-conc5-matching

(defthm cst-separator-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-separator-conc6-matching

(defthm cst-separator-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-separator-conc7-matching

(defthm cst-separator-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-separator-conc8-matching

(defthm cst-separator-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-separator-conc9-matching

(defthm cst-separator-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-separator-conc10-matching

(defthm cst-separator-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-separator-conc11-matching

(defthm cst-separator-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-separator-conc12-matching

(defthm cst-separator-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-operator-conc1-matching

(defthm cst-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-operator-conc2-matching

(defthm cst-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-operator-conc3-matching

(defthm cst-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-operator-conc4-matching

(defthm cst-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-operator-conc5-matching

(defthm cst-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-operator-conc6-matching

(defthm cst-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-operator-conc7-matching

(defthm cst-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-operator-conc8-matching

(defthm cst-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-operator-conc9-matching

(defthm cst-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-operator-conc10-matching

(defthm cst-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-operator-conc11-matching

(defthm cst-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-operator-conc12-matching

(defthm cst-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-operator-conc13-matching

(defthm cst-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-operator-conc14-matching

(defthm cst-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-operator-conc15-matching

(defthm cst-operator-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-operator-conc16-matching

(defthm cst-operator-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-operator-conc17-matching

(defthm cst-operator-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-operator-conc18-matching

(defthm cst-operator-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-operator-conc19-matching

(defthm cst-operator-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-operator-conc20-matching

(defthm cst-operator-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-operator-conc21-matching

(defthm cst-operator-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-operator-conc22-matching

(defthm cst-operator-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-operator-conc23-matching

(defthm cst-operator-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-operator-conc24-matching

(defthm cst-operator-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-operator-conc25-matching

(defthm cst-operator-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-operator-conc26-matching

(defthm cst-operator-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-operator-conc27-matching

(defthm cst-operator-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-operator-conc28-matching

(defthm cst-operator-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-operator-conc29-matching

(defthm cst-operator-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-operator-conc30-matching

(defthm cst-operator-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-operator-conc31-matching

(defthm cst-operator-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-operator-conc32-matching

(defthm cst-operator-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-operator-conc33-matching

(defthm cst-operator-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-operator-conc34-matching

(defthm cst-operator-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-operator-conc35-matching

(defthm cst-operator-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-operator-conc36-matching

(defthm cst-operator-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-operator-conc37-matching

(defthm cst-operator-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-operator-conc38-matching

(defthm cst-operator-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-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 "reference-type")
           (and (equal (len abnf::cstss) 1)
                (cst-list-rep-matchp (nth 0 abnf::cstss)
                                     "reference-type"))))

Theorem: cst-numeric-type-conc1-matching

(defthm cst-numeric-type-conc1-matching
  (implies (cst-list-list-conc-matchp abnf::cstss "integral-type")
           (and (equal (len abnf::cstss) 1)
                (cst-list-rep-matchp (nth 0 abnf::cstss)
                                     "integral-type"))))

Theorem: cst-numeric-type-conc2-matching

(defthm cst-numeric-type-conc2-matching
  (implies
       (cst-list-list-conc-matchp abnf::cstss "floating-point-type")
       (and (equal (len abnf::cstss) 1)
            (cst-list-rep-matchp (nth 0 abnf::cstss)
                                 "floating-point-type"))))

Theorem: cst-integral-type-conc1-matching

(defthm cst-integral-type-conc1-matching
  (implies (cst-list-list-conc-matchp abnf::cstss "%s\"byte\"")
           (and (equal (len abnf::cstss) 1)
                (cst-list-rep-matchp (nth 0 abnf::cstss)
                                     "%s\"byte\""))))

Theorem: cst-integral-type-conc2-matching

(defthm cst-integral-type-conc2-matching
  (implies (cst-list-list-conc-matchp abnf::cstss "%s\"short\"")
           (and (equal (len abnf::cstss) 1)
                (cst-list-rep-matchp (nth 0 abnf::cstss)
                                     "%s\"short\""))))

Theorem: cst-integral-type-conc3-matching

(defthm cst-integral-type-conc3-matching
  (implies (cst-list-list-conc-matchp abnf::cstss "%s\"int\"")
           (and (equal (len abnf::cstss) 1)
                (cst-list-rep-matchp (nth 0 abnf::cstss)
                                     "%s\"int\""))))

Theorem: cst-integral-type-conc4-matching

(defthm cst-integral-type-conc4-matching
  (implies (cst-list-list-conc-matchp abnf::cstss "%s\"long\"")
           (and (equal (len abnf::cstss) 1)
                (cst-list-rep-matchp (nth 0 abnf::cstss)
                                     "%s\"long\""))))

Theorem: cst-integral-type-conc5-matching

(defthm cst-integral-type-conc5-matching
  (implies (cst-list-list-conc-matchp abnf::cstss "%s\"char\"")
           (and (equal (len abnf::cstss) 1)
                (cst-list-rep-matchp (nth 0 abnf::cstss)
                                     "%s\"char\""))))

Theorem: cst-floating-point-type-conc1-matching

(defthm cst-floating-point-type-conc1-matching
  (implies (cst-list-list-conc-matchp abnf::cstss "%s\"float\"")
           (and (equal (len abnf::cstss) 1)
                (cst-list-rep-matchp (nth 0 abnf::cstss)
                                     "%s\"float\""))))

Theorem: cst-floating-point-type-conc2-matching

(defthm cst-floating-point-type-conc2-matching
  (implies (cst-list-list-conc-matchp abnf::cstss "%s\"double\"")
           (and (equal (len abnf::cstss) 1)
                (cst-list-rep-matchp (nth 0 abnf::cstss)
                                     "%s\"double\""))))

Theorem: cst-reference-type-conc1-matching

(defthm cst-reference-type-conc1-matching
 (implies
   (cst-list-list-conc-matchp abnf::cstss "class-or-interface-type")
   (and (equal (len abnf::cstss) 1)
        (cst-list-rep-matchp (nth 0 abnf::cstss)
                             "class-or-interface-type"))))

Theorem: cst-reference-type-conc2-matching

(defthm cst-reference-type-conc2-matching
  (implies (cst-list-list-conc-matchp abnf::cstss "type-variable")
           (and (equal (len abnf::cstss) 1)
                (cst-list-rep-matchp (nth 0 abnf::cstss)
                                     "type-variable"))))

Theorem: cst-reference-type-conc3-matching

(defthm cst-reference-type-conc3-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-class-or-interface-type-conc1-matching

(defthm cst-class-or-interface-type-conc1-matching
  (implies (cst-list-list-conc-matchp abnf::cstss "class-type")
           (and (equal (len abnf::cstss) 1)
                (cst-list-rep-matchp (nth 0 abnf::cstss)
                                     "class-type"))))

Theorem: cst-class-or-interface-type-conc2-matching

(defthm cst-class-or-interface-type-conc2-matching
  (implies (cst-list-list-conc-matchp abnf::cstss "interface-type")
           (and (equal (len abnf::cstss) 1)
                (cst-list-rep-matchp (nth 0 abnf::cstss)
                                     "interface-type"))))

Theorem: cst-interface-type-conc-matching

(defthm cst-interface-type-conc-matching
  (implies (cst-list-list-conc-matchp abnf::cstss "class-type")
           (and (equal (len abnf::cstss) 1)
                (cst-list-rep-matchp (nth 0 abnf::cstss)
                                     "class-type"))))

Theorem: cst-dims-conc-matching

(defthm cst-dims-conc-matching
  (implies (cst-list-list-conc-matchp
                abnf::cstss "1*( *annotation \"[\" \"]\" )")
           (and (equal (len abnf::cstss) 1)
                (cst-list-rep-matchp (nth 0 abnf::cstss)
                                     "1*( *annotation \"[\" \"]\" )"))))

Theorem: cst-type-parameter-modifier-conc-matching

(defthm cst-type-parameter-modifier-conc-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-type-argument-conc1-matching

(defthm cst-type-argument-conc1-matching
  (implies (cst-list-list-conc-matchp abnf::cstss "reference-type")
           (and (equal (len abnf::cstss) 1)
                (cst-list-rep-matchp (nth 0 abnf::cstss)
                                     "reference-type"))))

Theorem: cst-type-argument-conc2-matching

(defthm cst-type-argument-conc2-matching
  (implies (cst-list-list-conc-matchp abnf::cstss "wildcard")
           (and (equal (len abnf::cstss) 1)
                (cst-list-rep-matchp (nth 0 abnf::cstss)
                                     "wildcard"))))

Theorem: cst-module-name-conc1-matching

(defthm cst-module-name-conc1-matching
  (implies (cst-list-list-conc-matchp abnf::cstss "identifier")
           (and (equal (len abnf::cstss) 1)
                (cst-list-rep-matchp (nth 0 abnf::cstss)
                                     "identifier"))))

Theorem: cst-package-name-conc1-matching

(defthm cst-package-name-conc1-matching
  (implies (cst-list-list-conc-matchp abnf::cstss "identifier")
           (and (equal (len abnf::cstss) 1)
                (cst-list-rep-matchp (nth 0 abnf::cstss)
                                     "identifier"))))

Theorem: cst-type-name-conc1-matching

(defthm cst-type-name-conc1-matching
  (implies (cst-list-list-conc-matchp abnf::cstss "type-identifier")
           (and (equal (len abnf::cstss) 1)
                (cst-list-rep-matchp (nth 0 abnf::cstss)
                                     "type-identifier"))))

Theorem: cst-package-or-type-name-conc1-matching

(defthm cst-package-or-type-name-conc1-matching
  (implies (cst-list-list-conc-matchp abnf::cstss "identifier")
           (and (equal (len abnf::cstss) 1)
                (cst-list-rep-matchp (nth 0 abnf::cstss)
                                     "identifier"))))

Theorem: cst-expression-name-conc1-matching

(defthm cst-expression-name-conc1-matching
  (implies (cst-list-list-conc-matchp abnf::cstss "identifier")
           (and (equal (len abnf::cstss) 1)
                (cst-list-rep-matchp (nth 0 abnf::cstss)
                                     "identifier"))))

Theorem: cst-method-name-conc-matching

(defthm cst-method-name-conc-matching
  (implies
       (cst-list-list-conc-matchp abnf::cstss
                                  "unqualified-method-identifier")
       (and (equal (len abnf::cstss) 1)
            (cst-list-rep-matchp (nth 0 abnf::cstss)
                                 "unqualified-method-identifier"))))

Theorem: cst-ambiguous-name-conc1-matching

(defthm cst-ambiguous-name-conc1-matching
  (implies (cst-list-list-conc-matchp abnf::cstss "identifier")
           (and (equal (len abnf::cstss) 1)
                (cst-list-rep-matchp (nth 0 abnf::cstss)
                                     "identifier"))))

Theorem: cst-compilation-unit-conc1-matching

(defthm cst-compilation-unit-conc1-matching
  (implies (cst-list-list-conc-matchp
                abnf::cstss "ordinary-compilation-unit")
           (and (equal (len abnf::cstss) 1)
                (cst-list-rep-matchp (nth 0 abnf::cstss)
                                     "ordinary-compilation-unit"))))

Theorem: cst-compilation-unit-conc2-matching

(defthm cst-compilation-unit-conc2-matching
 (implies
  (cst-list-list-conc-matchp abnf::cstss "compact-compilation-unit")
  (and (equal (len abnf::cstss) 1)
       (cst-list-rep-matchp (nth 0 abnf::cstss)
                            "compact-compilation-unit"))))

Theorem: cst-compilation-unit-conc3-matching

(defthm cst-compilation-unit-conc3-matching
 (implies
  (cst-list-list-conc-matchp abnf::cstss "modular-compilation-unit")
  (and (equal (len abnf::cstss) 1)
       (cst-list-rep-matchp (nth 0 abnf::cstss)
                            "modular-compilation-unit"))))

Theorem: cst-class-member-declaration-no-method-conc1-matching

(defthm cst-class-member-declaration-no-method-conc1-matching
  (implies
       (cst-list-list-conc-matchp abnf::cstss "field-declaration")
       (and (equal (len abnf::cstss) 1)
            (cst-list-rep-matchp (nth 0 abnf::cstss)
                                 "field-declaration"))))

Theorem: cst-class-member-declaration-no-method-conc2-matching

(defthm cst-class-member-declaration-no-method-conc2-matching
  (implies
       (cst-list-list-conc-matchp abnf::cstss "class-declaration")
       (and (equal (len abnf::cstss) 1)
            (cst-list-rep-matchp (nth 0 abnf::cstss)
                                 "class-declaration"))))

Theorem: cst-class-member-declaration-no-method-conc3-matching

(defthm cst-class-member-declaration-no-method-conc3-matching
 (implies
     (cst-list-list-conc-matchp abnf::cstss "interface-declaration")
     (and (equal (len abnf::cstss) 1)
          (cst-list-rep-matchp (nth 0 abnf::cstss)
                               "interface-declaration"))))

Theorem: cst-class-member-declaration-no-method-conc4-matching

(defthm cst-class-member-declaration-no-method-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-package-modifier-conc-matching

(defthm cst-package-modifier-conc-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-import-declaration-conc1-matching

(defthm cst-import-declaration-conc1-matching
 (implies
      (cst-list-list-conc-matchp abnf::cstss
                                 "single-type-import-declaration")
      (and (equal (len abnf::cstss) 1)
           (cst-list-rep-matchp (nth 0 abnf::cstss)
                                "single-type-import-declaration"))))

Theorem: cst-import-declaration-conc2-matching

(defthm cst-import-declaration-conc2-matching
 (implies
   (cst-list-list-conc-matchp abnf::cstss
                              "type-import-on-demand-declaration")
   (and (equal (len abnf::cstss) 1)
        (cst-list-rep-matchp (nth 0 abnf::cstss)
                             "type-import-on-demand-declaration"))))

Theorem: cst-import-declaration-conc3-matching

(defthm cst-import-declaration-conc3-matching
 (implies
    (cst-list-list-conc-matchp abnf::cstss
                               "single-static-import-declaration")
    (and (equal (len abnf::cstss) 1)
         (cst-list-rep-matchp (nth 0 abnf::cstss)
                              "single-static-import-declaration"))))

Theorem: cst-import-declaration-conc4-matching

(defthm cst-import-declaration-conc4-matching
 (implies
  (cst-list-list-conc-matchp abnf::cstss
                             "static-import-on-demand-declaration")
  (and
      (equal (len abnf::cstss) 1)
      (cst-list-rep-matchp (nth 0 abnf::cstss)
                           "static-import-on-demand-declaration"))))

Theorem: cst-import-declaration-conc5-matching

(defthm cst-import-declaration-conc5-matching
 (implies
    (cst-list-list-conc-matchp abnf::cstss
                               "single-module-import-declaration")
    (and (equal (len abnf::cstss) 1)
         (cst-list-rep-matchp (nth 0 abnf::cstss)
                              "single-module-import-declaration"))))

Theorem: cst-top-level-class-or-interface-declaration-conc1-matching

(defthm cst-top-level-class-or-interface-declaration-conc1-matching
  (implies
       (cst-list-list-conc-matchp abnf::cstss "class-declaration")
       (and (equal (len abnf::cstss) 1)
            (cst-list-rep-matchp (nth 0 abnf::cstss)
                                 "class-declaration"))))

Theorem: cst-top-level-class-or-interface-declaration-conc2-matching

(defthm cst-top-level-class-or-interface-declaration-conc2-matching
 (implies
     (cst-list-list-conc-matchp abnf::cstss "interface-declaration")
     (and (equal (len abnf::cstss) 1)
          (cst-list-rep-matchp (nth 0 abnf::cstss)
                               "interface-declaration"))))

Theorem: cst-top-level-class-or-interface-declaration-conc3-matching

(defthm cst-top-level-class-or-interface-declaration-conc3-matching
  (implies (cst-list-list-conc-matchp abnf::cstss "\";\"")
           (and (equal (len abnf::cstss) 1)
                (cst-list-rep-matchp (nth 0 abnf::cstss)
                                     "\";\""))))

Theorem: cst-requires-modifier-conc1-matching

(defthm cst-requires-modifier-conc1-matching
  (implies (cst-list-list-conc-matchp abnf::cstss "%s\"transitive\"")
           (and (equal (len abnf::cstss) 1)
                (cst-list-rep-matchp (nth 0 abnf::cstss)
                                     "%s\"transitive\""))))

Theorem: cst-requires-modifier-conc2-matching

(defthm cst-requires-modifier-conc2-matching
  (implies (cst-list-list-conc-matchp abnf::cstss "%s\"static\"")
           (and (equal (len abnf::cstss) 1)
                (cst-list-rep-matchp (nth 0 abnf::cstss)
                                     "%s\"static\""))))

Theorem: cst-class-declaration-conc1-matching

(defthm cst-class-declaration-conc1-matching
 (implies
  (cst-list-list-conc-matchp abnf::cstss "normal-class-declaration")
  (and (equal (len abnf::cstss) 1)
       (cst-list-rep-matchp (nth 0 abnf::cstss)
                            "normal-class-declaration"))))

Theorem: cst-class-declaration-conc2-matching

(defthm cst-class-declaration-conc2-matching
 (implies (cst-list-list-conc-matchp abnf::cstss "enum-declaration")
          (and (equal (len abnf::cstss) 1)
               (cst-list-rep-matchp (nth 0 abnf::cstss)
                                    "enum-declaration"))))

Theorem: cst-class-declaration-conc3-matching

(defthm cst-class-declaration-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-class-modifier-conc1-matching

(defthm cst-class-modifier-conc1-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-class-modifier-conc2-matching

(defthm cst-class-modifier-conc2-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-class-modifier-conc3-matching

(defthm cst-class-modifier-conc3-matching
  (implies (cst-list-list-conc-matchp abnf::cstss "%s\"protected\"")
           (and (equal (len abnf::cstss) 1)
                (cst-list-rep-matchp (nth 0 abnf::cstss)
                                     "%s\"protected\""))))

Theorem: cst-class-modifier-conc4-matching

(defthm cst-class-modifier-conc4-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-class-modifier-conc5-matching

(defthm cst-class-modifier-conc5-matching
  (implies (cst-list-list-conc-matchp abnf::cstss "%s\"abstract\"")
           (and (equal (len abnf::cstss) 1)
                (cst-list-rep-matchp (nth 0 abnf::cstss)
                                     "%s\"abstract\""))))

Theorem: cst-class-modifier-conc6-matching

(defthm cst-class-modifier-conc6-matching
  (implies (cst-list-list-conc-matchp abnf::cstss "%s\"static\"")
           (and (equal (len abnf::cstss) 1)
                (cst-list-rep-matchp (nth 0 abnf::cstss)
                                     "%s\"static\""))))

Theorem: cst-class-modifier-conc7-matching

(defthm cst-class-modifier-conc7-matching
  (implies (cst-list-list-conc-matchp abnf::cstss "%s\"final\"")
           (and (equal (len abnf::cstss) 1)
                (cst-list-rep-matchp (nth 0 abnf::cstss)
                                     "%s\"final\""))))

Theorem: cst-class-modifier-conc8-matching

(defthm cst-class-modifier-conc8-matching
  (implies (cst-list-list-conc-matchp abnf::cstss "%s\"sealed\"")
           (and (equal (len abnf::cstss) 1)
                (cst-list-rep-matchp (nth 0 abnf::cstss)
                                     "%s\"sealed\""))))

Theorem: cst-class-modifier-conc9-matching

(defthm cst-class-modifier-conc9-matching
  (implies (cst-list-list-conc-matchp abnf::cstss "%s\"non-sealed\"")
           (and (equal (len abnf::cstss) 1)
                (cst-list-rep-matchp (nth 0 abnf::cstss)
                                     "%s\"non-sealed\""))))

Theorem: cst-class-modifier-conc10-matching

(defthm cst-class-modifier-conc10-matching
  (implies (cst-list-list-conc-matchp abnf::cstss "%s\"strictfp\"")
           (and (equal (len abnf::cstss) 1)
                (cst-list-rep-matchp (nth 0 abnf::cstss)
                                     "%s\"strictfp\""))))

Theorem: cst-class-body-declaration-conc1-matching

(defthm cst-class-body-declaration-conc1-matching
 (implies
  (cst-list-list-conc-matchp abnf::cstss "class-member-declaration")
  (and (equal (len abnf::cstss) 1)
       (cst-list-rep-matchp (nth 0 abnf::cstss)
                            "class-member-declaration"))))

Theorem: cst-class-body-declaration-conc2-matching

(defthm cst-class-body-declaration-conc2-matching
 (implies
      (cst-list-list-conc-matchp abnf::cstss "instance-initializer")
      (and (equal (len abnf::cstss) 1)
           (cst-list-rep-matchp (nth 0 abnf::cstss)
                                "instance-initializer"))))

Theorem: cst-class-body-declaration-conc3-matching

(defthm cst-class-body-declaration-conc3-matching
  (implies
       (cst-list-list-conc-matchp abnf::cstss "static-initializer")
       (and (equal (len abnf::cstss) 1)
            (cst-list-rep-matchp (nth 0 abnf::cstss)
                                 "static-initializer"))))

Theorem: cst-class-body-declaration-conc4-matching

(defthm cst-class-body-declaration-conc4-matching
 (implies
   (cst-list-list-conc-matchp abnf::cstss "constructor-declaration")
   (and (equal (len abnf::cstss) 1)
        (cst-list-rep-matchp (nth 0 abnf::cstss)
                             "constructor-declaration"))))

Theorem: cst-class-member-declaration-conc1-matching

(defthm cst-class-member-declaration-conc1-matching
  (implies
       (cst-list-list-conc-matchp abnf::cstss "field-declaration")
       (and (equal (len abnf::cstss) 1)
            (cst-list-rep-matchp (nth 0 abnf::cstss)
                                 "field-declaration"))))

Theorem: cst-class-member-declaration-conc2-matching

(defthm cst-class-member-declaration-conc2-matching
  (implies
       (cst-list-list-conc-matchp abnf::cstss "method-declaration")
       (and (equal (len abnf::cstss) 1)
            (cst-list-rep-matchp (nth 0 abnf::cstss)
                                 "method-declaration"))))

Theorem: cst-class-member-declaration-conc3-matching

(defthm cst-class-member-declaration-conc3-matching
  (implies
       (cst-list-list-conc-matchp abnf::cstss "class-declaration")
       (and (equal (len abnf::cstss) 1)
            (cst-list-rep-matchp (nth 0 abnf::cstss)
                                 "class-declaration"))))

Theorem: cst-class-member-declaration-conc4-matching

(defthm cst-class-member-declaration-conc4-matching
 (implies
     (cst-list-list-conc-matchp abnf::cstss "interface-declaration")
     (and (equal (len abnf::cstss) 1)
          (cst-list-rep-matchp (nth 0 abnf::cstss)
                               "interface-declaration"))))

Theorem: cst-class-member-declaration-conc5-matching

(defthm cst-class-member-declaration-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-variable-declarator-id-conc2-matching

(defthm cst-variable-declarator-id-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-variable-initializer-conc1-matching

(defthm cst-variable-initializer-conc1-matching
  (implies (cst-list-list-conc-matchp abnf::cstss "expression")
           (and (equal (len abnf::cstss) 1)
                (cst-list-rep-matchp (nth 0 abnf::cstss)
                                     "expression"))))

Theorem: cst-variable-initializer-conc2-matching

(defthm cst-variable-initializer-conc2-matching
  (implies
       (cst-list-list-conc-matchp abnf::cstss "array-initializer")
       (and (equal (len abnf::cstss) 1)
            (cst-list-rep-matchp (nth 0 abnf::cstss)
                                 "array-initializer"))))

Theorem: cst-unann-type-conc1-matching

(defthm cst-unann-type-conc1-matching
 (implies
      (cst-list-list-conc-matchp abnf::cstss "unann-primitive-type")
      (and (equal (len abnf::cstss) 1)
           (cst-list-rep-matchp (nth 0 abnf::cstss)
                                "unann-primitive-type"))))

Theorem: cst-unann-type-conc2-matching

(defthm cst-unann-type-conc2-matching
 (implies
      (cst-list-list-conc-matchp abnf::cstss "unann-reference-type")
      (and (equal (len abnf::cstss) 1)
           (cst-list-rep-matchp (nth 0 abnf::cstss)
                                "unann-reference-type"))))

Theorem: cst-unann-primitive-type-conc1-matching

(defthm cst-unann-primitive-type-conc1-matching
  (implies (cst-list-list-conc-matchp abnf::cstss "numeric-type")
           (and (equal (len abnf::cstss) 1)
                (cst-list-rep-matchp (nth 0 abnf::cstss)
                                     "numeric-type"))))

Theorem: cst-unann-primitive-type-conc2-matching

(defthm cst-unann-primitive-type-conc2-matching
  (implies (cst-list-list-conc-matchp abnf::cstss "%s\"boolean\"")
           (and (equal (len abnf::cstss) 1)
                (cst-list-rep-matchp (nth 0 abnf::cstss)
                                     "%s\"boolean\""))))

Theorem: cst-unann-reference-type-conc1-matching

(defthm cst-unann-reference-type-conc1-matching
  (implies
       (cst-list-list-conc-matchp abnf::cstss
                                  "unann-class-or-interface-type")
       (and (equal (len abnf::cstss) 1)
            (cst-list-rep-matchp (nth 0 abnf::cstss)
                                 "unann-class-or-interface-type"))))

Theorem: cst-unann-reference-type-conc2-matching

(defthm cst-unann-reference-type-conc2-matching
  (implies
       (cst-list-list-conc-matchp abnf::cstss "unann-type-variable")
       (and (equal (len abnf::cstss) 1)
            (cst-list-rep-matchp (nth 0 abnf::cstss)
                                 "unann-type-variable"))))

Theorem: cst-unann-reference-type-conc3-matching

(defthm cst-unann-reference-type-conc3-matching
 (implies (cst-list-list-conc-matchp abnf::cstss "unann-array-type")
          (and (equal (len abnf::cstss) 1)
               (cst-list-rep-matchp (nth 0 abnf::cstss)
                                    "unann-array-type"))))

Theorem: cst-unann-class-or-interface-type-conc1-matching

(defthm cst-unann-class-or-interface-type-conc1-matching
 (implies (cst-list-list-conc-matchp abnf::cstss "unann-class-type")
          (and (equal (len abnf::cstss) 1)
               (cst-list-rep-matchp (nth 0 abnf::cstss)
                                    "unann-class-type"))))

Theorem: cst-unann-class-or-interface-type-conc2-matching

(defthm cst-unann-class-or-interface-type-conc2-matching
 (implies
      (cst-list-list-conc-matchp abnf::cstss "unann-interface-type")
      (and (equal (len abnf::cstss) 1)
           (cst-list-rep-matchp (nth 0 abnf::cstss)
                                "unann-interface-type"))))

Theorem: cst-unann-interface-type-conc-matching

(defthm cst-unann-interface-type-conc-matching
 (implies (cst-list-list-conc-matchp abnf::cstss "unann-class-type")
          (and (equal (len abnf::cstss) 1)
               (cst-list-rep-matchp (nth 0 abnf::cstss)
                                    "unann-class-type"))))

Theorem: cst-unann-type-variable-conc-matching

(defthm cst-unann-type-variable-conc-matching
  (implies (cst-list-list-conc-matchp abnf::cstss "type-identifier")
           (and (equal (len abnf::cstss) 1)
                (cst-list-rep-matchp (nth 0 abnf::cstss)
                                     "type-identifier"))))

Theorem: cst-field-modifier-conc1-matching

(defthm cst-field-modifier-conc1-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-field-modifier-conc2-matching

(defthm cst-field-modifier-conc2-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-field-modifier-conc3-matching

(defthm cst-field-modifier-conc3-matching
  (implies (cst-list-list-conc-matchp abnf::cstss "%s\"protected\"")
           (and (equal (len abnf::cstss) 1)
                (cst-list-rep-matchp (nth 0 abnf::cstss)
                                     "%s\"protected\""))))

Theorem: cst-field-modifier-conc4-matching

(defthm cst-field-modifier-conc4-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-field-modifier-conc5-matching

(defthm cst-field-modifier-conc5-matching
  (implies (cst-list-list-conc-matchp abnf::cstss "%s\"static\"")
           (and (equal (len abnf::cstss) 1)
                (cst-list-rep-matchp (nth 0 abnf::cstss)
                                     "%s\"static\""))))

Theorem: cst-field-modifier-conc6-matching

(defthm cst-field-modifier-conc6-matching
  (implies (cst-list-list-conc-matchp abnf::cstss "%s\"final\"")
           (and (equal (len abnf::cstss) 1)
                (cst-list-rep-matchp (nth 0 abnf::cstss)
                                     "%s\"final\""))))

Theorem: cst-field-modifier-conc7-matching

(defthm cst-field-modifier-conc7-matching
  (implies (cst-list-list-conc-matchp abnf::cstss "%s\"transient\"")
           (and (equal (len abnf::cstss) 1)
                (cst-list-rep-matchp (nth 0 abnf::cstss)
                                     "%s\"transient\""))))

Theorem: cst-field-modifier-conc8-matching

(defthm cst-field-modifier-conc8-matching
  (implies (cst-list-list-conc-matchp abnf::cstss "%s\"volatile\"")
           (and (equal (len abnf::cstss) 1)
                (cst-list-rep-matchp (nth 0 abnf::cstss)
                                     "%s\"volatile\""))))

Theorem: cst-formal-parameter-conc2-matching

(defthm cst-formal-parameter-conc2-matching
 (implies
  (cst-list-list-conc-matchp abnf::cstss "variable-arity-parameter")
  (and (equal (len abnf::cstss) 1)
       (cst-list-rep-matchp (nth 0 abnf::cstss)
                            "variable-arity-parameter"))))

Theorem: cst-variable-modifier-conc1-matching

(defthm cst-variable-modifier-conc1-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-variable-modifier-conc2-matching

(defthm cst-variable-modifier-conc2-matching
  (implies (cst-list-list-conc-matchp abnf::cstss "%s\"final\"")
           (and (equal (len abnf::cstss) 1)
                (cst-list-rep-matchp (nth 0 abnf::cstss)
                                     "%s\"final\""))))

Theorem: cst-method-modifier-conc1-matching

(defthm cst-method-modifier-conc1-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-method-modifier-conc2-matching

(defthm cst-method-modifier-conc2-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-method-modifier-conc3-matching

(defthm cst-method-modifier-conc3-matching
  (implies (cst-list-list-conc-matchp abnf::cstss "%s\"protected\"")
           (and (equal (len abnf::cstss) 1)
                (cst-list-rep-matchp (nth 0 abnf::cstss)
                                     "%s\"protected\""))))

Theorem: cst-method-modifier-conc4-matching

(defthm cst-method-modifier-conc4-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-method-modifier-conc5-matching

(defthm cst-method-modifier-conc5-matching
  (implies (cst-list-list-conc-matchp abnf::cstss "%s\"abstract\"")
           (and (equal (len abnf::cstss) 1)
                (cst-list-rep-matchp (nth 0 abnf::cstss)
                                     "%s\"abstract\""))))

Theorem: cst-method-modifier-conc6-matching

(defthm cst-method-modifier-conc6-matching
  (implies (cst-list-list-conc-matchp abnf::cstss "%s\"static\"")
           (and (equal (len abnf::cstss) 1)
                (cst-list-rep-matchp (nth 0 abnf::cstss)
                                     "%s\"static\""))))

Theorem: cst-method-modifier-conc7-matching

(defthm cst-method-modifier-conc7-matching
  (implies (cst-list-list-conc-matchp abnf::cstss "%s\"final\"")
           (and (equal (len abnf::cstss) 1)
                (cst-list-rep-matchp (nth 0 abnf::cstss)
                                     "%s\"final\""))))

Theorem: cst-method-modifier-conc8-matching

(defthm cst-method-modifier-conc8-matching
 (implies (cst-list-list-conc-matchp abnf::cstss "%s\"synchronized\"")
          (and (equal (len abnf::cstss) 1)
               (cst-list-rep-matchp (nth 0 abnf::cstss)
                                    "%s\"synchronized\""))))

Theorem: cst-method-modifier-conc9-matching

(defthm cst-method-modifier-conc9-matching
  (implies (cst-list-list-conc-matchp abnf::cstss "%s\"native\"")
           (and (equal (len abnf::cstss) 1)
                (cst-list-rep-matchp (nth 0 abnf::cstss)
                                     "%s\"native\""))))

Theorem: cst-method-modifier-conc10-matching

(defthm cst-method-modifier-conc10-matching
  (implies (cst-list-list-conc-matchp abnf::cstss "%s\"strictfp\"")
           (and (equal (len abnf::cstss) 1)
                (cst-list-rep-matchp (nth 0 abnf::cstss)
                                     "%s\"strictfp\""))))

Theorem: cst-result-conc1-matching

(defthm cst-result-conc1-matching
  (implies (cst-list-list-conc-matchp abnf::cstss "unann-type")
           (and (equal (len abnf::cstss) 1)
                (cst-list-rep-matchp (nth 0 abnf::cstss)
                                     "unann-type"))))

Theorem: cst-result-conc2-matching

(defthm cst-result-conc2-matching
  (implies (cst-list-list-conc-matchp abnf::cstss "%s\"void\"")
           (and (equal (len abnf::cstss) 1)
                (cst-list-rep-matchp (nth 0 abnf::cstss)
                                     "%s\"void\""))))

Theorem: cst-exception-type-conc1-matching

(defthm cst-exception-type-conc1-matching
  (implies (cst-list-list-conc-matchp abnf::cstss "class-type")
           (and (equal (len abnf::cstss) 1)
                (cst-list-rep-matchp (nth 0 abnf::cstss)
                                     "class-type"))))

Theorem: cst-exception-type-conc2-matching

(defthm cst-exception-type-conc2-matching
  (implies (cst-list-list-conc-matchp abnf::cstss "type-variable")
           (and (equal (len abnf::cstss) 1)
                (cst-list-rep-matchp (nth 0 abnf::cstss)
                                     "type-variable"))))

Theorem: cst-method-body-conc1-matching

(defthm cst-method-body-conc1-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-method-body-conc2-matching

(defthm cst-method-body-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-instance-initializer-conc-matching

(defthm cst-instance-initializer-conc-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-simple-type-name-conc-matching

(defthm cst-simple-type-name-conc-matching
  (implies (cst-list-list-conc-matchp abnf::cstss "type-identifier")
           (and (equal (len abnf::cstss) 1)
                (cst-list-rep-matchp (nth 0 abnf::cstss)
                                     "type-identifier"))))

Theorem: cst-constructor-modifier-conc1-matching

(defthm cst-constructor-modifier-conc1-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-constructor-modifier-conc2-matching

(defthm cst-constructor-modifier-conc2-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-constructor-modifier-conc3-matching

(defthm cst-constructor-modifier-conc3-matching
  (implies (cst-list-list-conc-matchp abnf::cstss "%s\"protected\"")
           (and (equal (len abnf::cstss) 1)
                (cst-list-rep-matchp (nth 0 abnf::cstss)
                                     "%s\"protected\""))))

Theorem: cst-constructor-modifier-conc4-matching

(defthm cst-constructor-modifier-conc4-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-enum-constant-modifier-conc-matching

(defthm cst-enum-constant-modifier-conc-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-record-component-conc2-matching

(defthm cst-record-component-conc2-matching
 (implies
     (cst-list-list-conc-matchp abnf::cstss
                                "variable-arity-record-component")
     (and (equal (len abnf::cstss) 1)
          (cst-list-rep-matchp (nth 0 abnf::cstss)
                               "variable-arity-record-component"))))

Theorem: cst-record-component-modifier-conc-matching

(defthm cst-record-component-modifier-conc-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-record-body-declaration-conc1-matching

(defthm cst-record-body-declaration-conc1-matching
 (implies
    (cst-list-list-conc-matchp abnf::cstss "class-body-declaration")
    (and (equal (len abnf::cstss) 1)
         (cst-list-rep-matchp (nth 0 abnf::cstss)
                              "class-body-declaration"))))

Theorem: cst-record-body-declaration-conc2-matching

(defthm cst-record-body-declaration-conc2-matching
 (implies
     (cst-list-list-conc-matchp abnf::cstss
                                "compact-constructor-declaration")
     (and (equal (len abnf::cstss) 1)
          (cst-list-rep-matchp (nth 0 abnf::cstss)
                               "compact-constructor-declaration"))))

Theorem: cst-interface-declaration-conc1-matching

(defthm cst-interface-declaration-conc1-matching
  (implies
       (cst-list-list-conc-matchp abnf::cstss
                                  "normal-interface-declaration")
       (and (equal (len abnf::cstss) 1)
            (cst-list-rep-matchp (nth 0 abnf::cstss)
                                 "normal-interface-declaration"))))

Theorem: cst-interface-declaration-conc2-matching

(defthm cst-interface-declaration-conc2-matching
 (implies
    (cst-list-list-conc-matchp abnf::cstss
                               "annotation-interface-declaration")
    (and (equal (len abnf::cstss) 1)
         (cst-list-rep-matchp (nth 0 abnf::cstss)
                              "annotation-interface-declaration"))))

Theorem: cst-interface-modifier-conc1-matching

(defthm cst-interface-modifier-conc1-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-interface-modifier-conc2-matching

(defthm cst-interface-modifier-conc2-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-interface-modifier-conc3-matching

(defthm cst-interface-modifier-conc3-matching
  (implies (cst-list-list-conc-matchp abnf::cstss "%s\"protected\"")
           (and (equal (len abnf::cstss) 1)
                (cst-list-rep-matchp (nth 0 abnf::cstss)
                                     "%s\"protected\""))))

Theorem: cst-interface-modifier-conc4-matching

(defthm cst-interface-modifier-conc4-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-interface-modifier-conc5-matching

(defthm cst-interface-modifier-conc5-matching
  (implies (cst-list-list-conc-matchp abnf::cstss "%s\"abstract\"")
           (and (equal (len abnf::cstss) 1)
                (cst-list-rep-matchp (nth 0 abnf::cstss)
                                     "%s\"abstract\""))))

Theorem: cst-interface-modifier-conc6-matching

(defthm cst-interface-modifier-conc6-matching
  (implies (cst-list-list-conc-matchp abnf::cstss "%s\"static\"")
           (and (equal (len abnf::cstss) 1)
                (cst-list-rep-matchp (nth 0 abnf::cstss)
                                     "%s\"static\""))))

Theorem: cst-interface-modifier-conc7-matching

(defthm cst-interface-modifier-conc7-matching
  (implies (cst-list-list-conc-matchp abnf::cstss "%s\"sealed\"")
           (and (equal (len abnf::cstss) 1)
                (cst-list-rep-matchp (nth 0 abnf::cstss)
                                     "%s\"sealed\""))))

Theorem: cst-interface-modifier-conc8-matching

(defthm cst-interface-modifier-conc8-matching
  (implies (cst-list-list-conc-matchp abnf::cstss "%s\"non-sealed\"")
           (and (equal (len abnf::cstss) 1)
                (cst-list-rep-matchp (nth 0 abnf::cstss)
                                     "%s\"non-sealed\""))))

Theorem: cst-interface-modifier-conc9-matching

(defthm cst-interface-modifier-conc9-matching
  (implies (cst-list-list-conc-matchp abnf::cstss "%s\"strictfp\"")
           (and (equal (len abnf::cstss) 1)
                (cst-list-rep-matchp (nth 0 abnf::cstss)
                                     "%s\"strictfp\""))))

Theorem: cst-interface-member-declaration-conc1-matching

(defthm cst-interface-member-declaration-conc1-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-interface-member-declaration-conc2-matching

(defthm cst-interface-member-declaration-conc2-matching
  (implies
       (cst-list-list-conc-matchp abnf::cstss
                                  "interface-method-declaration")
       (and (equal (len abnf::cstss) 1)
            (cst-list-rep-matchp (nth 0 abnf::cstss)
                                 "interface-method-declaration"))))

Theorem: cst-interface-member-declaration-conc3-matching

(defthm cst-interface-member-declaration-conc3-matching
  (implies
       (cst-list-list-conc-matchp abnf::cstss "class-declaration")
       (and (equal (len abnf::cstss) 1)
            (cst-list-rep-matchp (nth 0 abnf::cstss)
                                 "class-declaration"))))

Theorem: cst-interface-member-declaration-conc4-matching

(defthm cst-interface-member-declaration-conc4-matching
 (implies
     (cst-list-list-conc-matchp abnf::cstss "interface-declaration")
     (and (equal (len abnf::cstss) 1)
          (cst-list-rep-matchp (nth 0 abnf::cstss)
                               "interface-declaration"))))

Theorem: cst-interface-member-declaration-conc5-matching

(defthm cst-interface-member-declaration-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-constant-modifier-conc1-matching

(defthm cst-constant-modifier-conc1-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-constant-modifier-conc2-matching

(defthm cst-constant-modifier-conc2-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-constant-modifier-conc3-matching

(defthm cst-constant-modifier-conc3-matching
  (implies (cst-list-list-conc-matchp abnf::cstss "%s\"static\"")
           (and (equal (len abnf::cstss) 1)
                (cst-list-rep-matchp (nth 0 abnf::cstss)
                                     "%s\"static\""))))

Theorem: cst-constant-modifier-conc4-matching

(defthm cst-constant-modifier-conc4-matching
  (implies (cst-list-list-conc-matchp abnf::cstss "%s\"final\"")
           (and (equal (len abnf::cstss) 1)
                (cst-list-rep-matchp (nth 0 abnf::cstss)
                                     "%s\"final\""))))

Theorem: cst-interface-method-modifier-conc1-matching

(defthm cst-interface-method-modifier-conc1-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-interface-method-modifier-conc2-matching

(defthm cst-interface-method-modifier-conc2-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-interface-method-modifier-conc3-matching

(defthm cst-interface-method-modifier-conc3-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-interface-method-modifier-conc4-matching

(defthm cst-interface-method-modifier-conc4-matching
  (implies (cst-list-list-conc-matchp abnf::cstss "%s\"abstract\"")
           (and (equal (len abnf::cstss) 1)
                (cst-list-rep-matchp (nth 0 abnf::cstss)
                                     "%s\"abstract\""))))

Theorem: cst-interface-method-modifier-conc5-matching

(defthm cst-interface-method-modifier-conc5-matching
  (implies (cst-list-list-conc-matchp abnf::cstss "%s\"default\"")
           (and (equal (len abnf::cstss) 1)
                (cst-list-rep-matchp (nth 0 abnf::cstss)
                                     "%s\"default\""))))

Theorem: cst-interface-method-modifier-conc6-matching

(defthm cst-interface-method-modifier-conc6-matching
  (implies (cst-list-list-conc-matchp abnf::cstss "%s\"static\"")
           (and (equal (len abnf::cstss) 1)
                (cst-list-rep-matchp (nth 0 abnf::cstss)
                                     "%s\"static\""))))

Theorem: cst-interface-method-modifier-conc7-matching

(defthm cst-interface-method-modifier-conc7-matching
  (implies (cst-list-list-conc-matchp abnf::cstss "%s\"strictfp\"")
           (and (equal (len abnf::cstss) 1)
                (cst-list-rep-matchp (nth 0 abnf::cstss)
                                     "%s\"strictfp\""))))

Theorem: cst-annotation-interface-member-declaration-conc1-matching

(defthm cst-annotation-interface-member-declaration-conc1-matching
  (implies (cst-list-list-conc-matchp
                abnf::cstss
                "annotation-interface-element-declaration")
           (and (equal (len abnf::cstss) 1)
                (cst-list-rep-matchp
                     (nth 0 abnf::cstss)
                     "annotation-interface-element-declaration"))))

Theorem: cst-annotation-interface-member-declaration-conc2-matching

(defthm cst-annotation-interface-member-declaration-conc2-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-annotation-interface-member-declaration-conc3-matching

(defthm cst-annotation-interface-member-declaration-conc3-matching
  (implies
       (cst-list-list-conc-matchp abnf::cstss "class-declaration")
       (and (equal (len abnf::cstss) 1)
            (cst-list-rep-matchp (nth 0 abnf::cstss)
                                 "class-declaration"))))

Theorem: cst-annotation-interface-member-declaration-conc4-matching

(defthm cst-annotation-interface-member-declaration-conc4-matching
 (implies
     (cst-list-list-conc-matchp abnf::cstss "interface-declaration")
     (and (equal (len abnf::cstss) 1)
          (cst-list-rep-matchp (nth 0 abnf::cstss)
                               "interface-declaration"))))

Theorem: cst-annotation-interface-member-declaration-conc5-matching

(defthm cst-annotation-interface-member-declaration-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-annotation-interface-element-modifier-conc1-matching

(defthm cst-annotation-interface-element-modifier-conc1-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-annotation-interface-element-modifier-conc2-matching

(defthm cst-annotation-interface-element-modifier-conc2-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-annotation-interface-element-modifier-conc3-matching

(defthm cst-annotation-interface-element-modifier-conc3-matching
  (implies (cst-list-list-conc-matchp abnf::cstss "%s\"abstract\"")
           (and (equal (len abnf::cstss) 1)
                (cst-list-rep-matchp (nth 0 abnf::cstss)
                                     "%s\"abstract\""))))

Theorem: cst-annotation-conc1-matching

(defthm cst-annotation-conc1-matching
  (implies
       (cst-list-list-conc-matchp abnf::cstss "normal-annotation")
       (and (equal (len abnf::cstss) 1)
            (cst-list-rep-matchp (nth 0 abnf::cstss)
                                 "normal-annotation"))))

Theorem: cst-annotation-conc2-matching

(defthm cst-annotation-conc2-matching
  (implies
       (cst-list-list-conc-matchp abnf::cstss "marker-annotation")
       (and (equal (len abnf::cstss) 1)
            (cst-list-rep-matchp (nth 0 abnf::cstss)
                                 "marker-annotation"))))

Theorem: cst-annotation-conc3-matching

(defthm cst-annotation-conc3-matching
  (implies (cst-list-list-conc-matchp
                abnf::cstss "single-element-annotation")
           (and (equal (len abnf::cstss) 1)
                (cst-list-rep-matchp (nth 0 abnf::cstss)
                                     "single-element-annotation"))))

Theorem: cst-element-value-conc1-matching

(defthm cst-element-value-conc1-matching
 (implies
    (cst-list-list-conc-matchp abnf::cstss "conditional-expression")
    (and (equal (len abnf::cstss) 1)
         (cst-list-rep-matchp (nth 0 abnf::cstss)
                              "conditional-expression"))))

Theorem: cst-element-value-conc2-matching

(defthm cst-element-value-conc2-matching
 (implies
     (cst-list-list-conc-matchp abnf::cstss
                                "element-value-array-initializer")
     (and (equal (len abnf::cstss) 1)
          (cst-list-rep-matchp (nth 0 abnf::cstss)
                               "element-value-array-initializer"))))

Theorem: cst-element-value-conc3-matching

(defthm cst-element-value-conc3-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-block-statements-conc-matching

(defthm cst-block-statements-conc-matching
  (implies
       (cst-list-list-conc-matchp abnf::cstss "1*block-statement")
       (and (equal (len abnf::cstss) 1)
            (cst-list-rep-matchp (nth 0 abnf::cstss)
                                 "1*block-statement"))))

Theorem: cst-block-statement-conc1-matching

(defthm cst-block-statement-conc1-matching
 (implies
  (cst-list-list-conc-matchp abnf::cstss
                             "local-class-or-interface-declaration")
  (and
     (equal (len abnf::cstss) 1)
     (cst-list-rep-matchp (nth 0 abnf::cstss)
                          "local-class-or-interface-declaration"))))

Theorem: cst-block-statement-conc2-matching

(defthm cst-block-statement-conc2-matching
 (implies
  (cst-list-list-conc-matchp abnf::cstss
                             "local-variable-declaration-statement")
  (and
     (equal (len abnf::cstss) 1)
     (cst-list-rep-matchp (nth 0 abnf::cstss)
                          "local-variable-declaration-statement"))))

Theorem: cst-block-statement-conc3-matching

(defthm cst-block-statement-conc3-matching
  (implies (cst-list-list-conc-matchp abnf::cstss "statement")
           (and (equal (len abnf::cstss) 1)
                (cst-list-rep-matchp (nth 0 abnf::cstss)
                                     "statement"))))

Theorem: cst-local-class-or-interface-declaration-conc1-matching

(defthm cst-local-class-or-interface-declaration-conc1-matching
  (implies
       (cst-list-list-conc-matchp abnf::cstss "class-declaration")
       (and (equal (len abnf::cstss) 1)
            (cst-list-rep-matchp (nth 0 abnf::cstss)
                                 "class-declaration"))))

Theorem: cst-local-class-or-interface-declaration-conc2-matching

(defthm cst-local-class-or-interface-declaration-conc2-matching
  (implies
       (cst-list-list-conc-matchp abnf::cstss
                                  "normal-interface-declaration")
       (and (equal (len abnf::cstss) 1)
            (cst-list-rep-matchp (nth 0 abnf::cstss)
                                 "normal-interface-declaration"))))

Theorem: cst-local-variable-type-conc1-matching

(defthm cst-local-variable-type-conc1-matching
  (implies (cst-list-list-conc-matchp abnf::cstss "unann-type")
           (and (equal (len abnf::cstss) 1)
                (cst-list-rep-matchp (nth 0 abnf::cstss)
                                     "unann-type"))))

Theorem: cst-local-variable-type-conc2-matching

(defthm cst-local-variable-type-conc2-matching
  (implies (cst-list-list-conc-matchp abnf::cstss "%s\"var\"")
           (and (equal (len abnf::cstss) 1)
                (cst-list-rep-matchp (nth 0 abnf::cstss)
                                     "%s\"var\""))))

Theorem: cst-statement-conc1-matching

(defthm cst-statement-conc1-matching
  (implies (cst-list-list-conc-matchp
                abnf::cstss
                "statement-without-trailing-substatement")
           (and (equal (len abnf::cstss) 1)
                (cst-list-rep-matchp
                     (nth 0 abnf::cstss)
                     "statement-without-trailing-substatement"))))

Theorem: cst-statement-conc2-matching

(defthm cst-statement-conc2-matching
  (implies
       (cst-list-list-conc-matchp abnf::cstss "labeled-statement")
       (and (equal (len abnf::cstss) 1)
            (cst-list-rep-matchp (nth 0 abnf::cstss)
                                 "labeled-statement"))))

Theorem: cst-statement-conc3-matching

(defthm cst-statement-conc3-matching
  (implies
       (cst-list-list-conc-matchp abnf::cstss "if-then-statement")
       (and (equal (len abnf::cstss) 1)
            (cst-list-rep-matchp (nth 0 abnf::cstss)
                                 "if-then-statement"))))

Theorem: cst-statement-conc4-matching

(defthm cst-statement-conc4-matching
 (implies
    (cst-list-list-conc-matchp abnf::cstss "if-then-else-statement")
    (and (equal (len abnf::cstss) 1)
         (cst-list-rep-matchp (nth 0 abnf::cstss)
                              "if-then-else-statement"))))

Theorem: cst-statement-conc5-matching

(defthm cst-statement-conc5-matching
  (implies (cst-list-list-conc-matchp abnf::cstss "while-statement")
           (and (equal (len abnf::cstss) 1)
                (cst-list-rep-matchp (nth 0 abnf::cstss)
                                     "while-statement"))))

Theorem: cst-statement-conc6-matching

(defthm cst-statement-conc6-matching
  (implies (cst-list-list-conc-matchp abnf::cstss "for-statement")
           (and (equal (len abnf::cstss) 1)
                (cst-list-rep-matchp (nth 0 abnf::cstss)
                                     "for-statement"))))

Theorem: cst-statement-no-short-if-conc1-matching

(defthm cst-statement-no-short-if-conc1-matching
  (implies (cst-list-list-conc-matchp
                abnf::cstss
                "statement-without-trailing-substatement")
           (and (equal (len abnf::cstss) 1)
                (cst-list-rep-matchp
                     (nth 0 abnf::cstss)
                     "statement-without-trailing-substatement"))))

Theorem: cst-statement-no-short-if-conc2-matching

(defthm cst-statement-no-short-if-conc2-matching
  (implies
       (cst-list-list-conc-matchp abnf::cstss
                                  "labeled-statement-no-short-if")
       (and (equal (len abnf::cstss) 1)
            (cst-list-rep-matchp (nth 0 abnf::cstss)
                                 "labeled-statement-no-short-if"))))

Theorem: cst-statement-no-short-if-conc3-matching

(defthm cst-statement-no-short-if-conc3-matching
 (implies
  (cst-list-list-conc-matchp abnf::cstss
                             "if-then-else-statement-no-short-if")
  (and (equal (len abnf::cstss) 1)
       (cst-list-rep-matchp (nth 0 abnf::cstss)
                            "if-then-else-statement-no-short-if"))))

Theorem: cst-statement-no-short-if-conc4-matching

(defthm cst-statement-no-short-if-conc4-matching
  (implies
       (cst-list-list-conc-matchp abnf::cstss
                                  "while-statement-no-short-if")
       (and (equal (len abnf::cstss) 1)
            (cst-list-rep-matchp (nth 0 abnf::cstss)
                                 "while-statement-no-short-if"))))

Theorem: cst-statement-no-short-if-conc5-matching

(defthm cst-statement-no-short-if-conc5-matching
  (implies (cst-list-list-conc-matchp
                abnf::cstss "for-statement-no-short-if")
           (and (equal (len abnf::cstss) 1)
                (cst-list-rep-matchp (nth 0 abnf::cstss)
                                     "for-statement-no-short-if"))))

Theorem: cst-statement-without-trailing-substatement-conc1-matching

(defthm cst-statement-without-trailing-substatement-conc1-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-statement-without-trailing-substatement-conc2-matching

(defthm cst-statement-without-trailing-substatement-conc2-matching
  (implies (cst-list-list-conc-matchp abnf::cstss "empty-statement")
           (and (equal (len abnf::cstss) 1)
                (cst-list-rep-matchp (nth 0 abnf::cstss)
                                     "empty-statement"))))

Theorem: cst-statement-without-trailing-substatement-conc3-matching

(defthm cst-statement-without-trailing-substatement-conc3-matching
 (implies
      (cst-list-list-conc-matchp abnf::cstss "expression-statement")
      (and (equal (len abnf::cstss) 1)
           (cst-list-rep-matchp (nth 0 abnf::cstss)
                                "expression-statement"))))

Theorem: cst-statement-without-trailing-substatement-conc4-matching

(defthm cst-statement-without-trailing-substatement-conc4-matching
 (implies (cst-list-list-conc-matchp abnf::cstss "assert-statement")
          (and (equal (len abnf::cstss) 1)
               (cst-list-rep-matchp (nth 0 abnf::cstss)
                                    "assert-statement"))))

Theorem: cst-statement-without-trailing-substatement-conc5-matching

(defthm cst-statement-without-trailing-substatement-conc5-matching
 (implies (cst-list-list-conc-matchp abnf::cstss "switch-statement")
          (and (equal (len abnf::cstss) 1)
               (cst-list-rep-matchp (nth 0 abnf::cstss)
                                    "switch-statement"))))

Theorem: cst-statement-without-trailing-substatement-conc6-matching

(defthm cst-statement-without-trailing-substatement-conc6-matching
  (implies (cst-list-list-conc-matchp abnf::cstss "do-statement")
           (and (equal (len abnf::cstss) 1)
                (cst-list-rep-matchp (nth 0 abnf::cstss)
                                     "do-statement"))))

Theorem: cst-statement-without-trailing-substatement-conc7-matching

(defthm cst-statement-without-trailing-substatement-conc7-matching
  (implies (cst-list-list-conc-matchp abnf::cstss "break-statement")
           (and (equal (len abnf::cstss) 1)
                (cst-list-rep-matchp (nth 0 abnf::cstss)
                                     "break-statement"))))

Theorem: cst-statement-without-trailing-substatement-conc8-matching

(defthm cst-statement-without-trailing-substatement-conc8-matching
  (implies
       (cst-list-list-conc-matchp abnf::cstss "continue-statement")
       (and (equal (len abnf::cstss) 1)
            (cst-list-rep-matchp (nth 0 abnf::cstss)
                                 "continue-statement"))))

Theorem: cst-statement-without-trailing-substatement-conc9-matching

(defthm cst-statement-without-trailing-substatement-conc9-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-without-trailing-substatement-conc10-matching

(defthm cst-statement-without-trailing-substatement-conc10-matching
 (implies
    (cst-list-list-conc-matchp abnf::cstss "synchronized-statement")
    (and (equal (len abnf::cstss) 1)
         (cst-list-rep-matchp (nth 0 abnf::cstss)
                              "synchronized-statement"))))

Theorem: cst-statement-without-trailing-substatement-conc11-matching

(defthm cst-statement-without-trailing-substatement-conc11-matching
  (implies (cst-list-list-conc-matchp abnf::cstss "throw-statement")
           (and (equal (len abnf::cstss) 1)
                (cst-list-rep-matchp (nth 0 abnf::cstss)
                                     "throw-statement"))))

Theorem: cst-statement-without-trailing-substatement-conc12-matching

(defthm cst-statement-without-trailing-substatement-conc12-matching
  (implies (cst-list-list-conc-matchp abnf::cstss "try-statement")
           (and (equal (len abnf::cstss) 1)
                (cst-list-rep-matchp (nth 0 abnf::cstss)
                                     "try-statement"))))

Theorem: cst-statement-without-trailing-substatement-conc13-matching

(defthm cst-statement-without-trailing-substatement-conc13-matching
  (implies (cst-list-list-conc-matchp abnf::cstss "yield-statement")
           (and (equal (len abnf::cstss) 1)
                (cst-list-rep-matchp (nth 0 abnf::cstss)
                                     "yield-statement"))))

Theorem: cst-empty-statement-conc-matching

(defthm cst-empty-statement-conc-matching
  (implies (cst-list-list-conc-matchp abnf::cstss "\";\"")
           (and (equal (len abnf::cstss) 1)
                (cst-list-rep-matchp (nth 0 abnf::cstss)
                                     "\";\""))))

Theorem: cst-statement-expression-conc1-matching

(defthm cst-statement-expression-conc1-matching
  (implies (cst-list-list-conc-matchp abnf::cstss "assignment")
           (and (equal (len abnf::cstss) 1)
                (cst-list-rep-matchp (nth 0 abnf::cstss)
                                     "assignment"))))

Theorem: cst-statement-expression-conc2-matching

(defthm cst-statement-expression-conc2-matching
 (implies
  (cst-list-list-conc-matchp abnf::cstss "pre-increment-expression")
  (and (equal (len abnf::cstss) 1)
       (cst-list-rep-matchp (nth 0 abnf::cstss)
                            "pre-increment-expression"))))

Theorem: cst-statement-expression-conc3-matching

(defthm cst-statement-expression-conc3-matching
 (implies
  (cst-list-list-conc-matchp abnf::cstss "pre-decrement-expression")
  (and (equal (len abnf::cstss) 1)
       (cst-list-rep-matchp (nth 0 abnf::cstss)
                            "pre-decrement-expression"))))

Theorem: cst-statement-expression-conc4-matching

(defthm cst-statement-expression-conc4-matching
  (implies (cst-list-list-conc-matchp
                abnf::cstss "post-increment-expression")
           (and (equal (len abnf::cstss) 1)
                (cst-list-rep-matchp (nth 0 abnf::cstss)
                                     "post-increment-expression"))))

Theorem: cst-statement-expression-conc5-matching

(defthm cst-statement-expression-conc5-matching
  (implies (cst-list-list-conc-matchp
                abnf::cstss "post-decrement-expression")
           (and (equal (len abnf::cstss) 1)
                (cst-list-rep-matchp (nth 0 abnf::cstss)
                                     "post-decrement-expression"))))

Theorem: cst-statement-expression-conc6-matching

(defthm cst-statement-expression-conc6-matching
  (implies
       (cst-list-list-conc-matchp abnf::cstss "method-invocation")
       (and (equal (len abnf::cstss) 1)
            (cst-list-rep-matchp (nth 0 abnf::cstss)
                                 "method-invocation"))))

Theorem: cst-statement-expression-conc7-matching

(defthm cst-statement-expression-conc7-matching
 (implies
  (cst-list-list-conc-matchp abnf::cstss
                             "class-instance-creation-expression")
  (and (equal (len abnf::cstss) 1)
       (cst-list-rep-matchp (nth 0 abnf::cstss)
                            "class-instance-creation-expression"))))

Theorem: cst-switch-label-conc4-matching

(defthm cst-switch-label-conc4-matching
  (implies (cst-list-list-conc-matchp abnf::cstss "%s\"default\"")
           (and (equal (len abnf::cstss) 1)
                (cst-list-rep-matchp (nth 0 abnf::cstss)
                                     "%s\"default\""))))

Theorem: cst-case-constant-conc-matching

(defthm cst-case-constant-conc-matching
 (implies
    (cst-list-list-conc-matchp abnf::cstss "conditional-expression")
    (and (equal (len abnf::cstss) 1)
         (cst-list-rep-matchp (nth 0 abnf::cstss)
                              "conditional-expression"))))

Theorem: cst-case-pattern-conc-matching

(defthm cst-case-pattern-conc-matching
  (implies (cst-list-list-conc-matchp abnf::cstss "pattern")
           (and (equal (len abnf::cstss) 1)
                (cst-list-rep-matchp (nth 0 abnf::cstss)
                                     "pattern"))))

Theorem: cst-for-statement-conc1-matching

(defthm cst-for-statement-conc1-matching
  (implies
       (cst-list-list-conc-matchp abnf::cstss "basic-for-statement")
       (and (equal (len abnf::cstss) 1)
            (cst-list-rep-matchp (nth 0 abnf::cstss)
                                 "basic-for-statement"))))

Theorem: cst-for-statement-conc2-matching

(defthm cst-for-statement-conc2-matching
 (implies
    (cst-list-list-conc-matchp abnf::cstss "enhanced-for-statement")
    (and (equal (len abnf::cstss) 1)
         (cst-list-rep-matchp (nth 0 abnf::cstss)
                              "enhanced-for-statement"))))

Theorem: cst-for-statement-no-short-if-conc1-matching

(defthm cst-for-statement-no-short-if-conc1-matching
 (implies
     (cst-list-list-conc-matchp abnf::cstss
                                "basic-for-statement-no-short-if")
     (and (equal (len abnf::cstss) 1)
          (cst-list-rep-matchp (nth 0 abnf::cstss)
                               "basic-for-statement-no-short-if"))))

Theorem: cst-for-statement-no-short-if-conc2-matching

(defthm cst-for-statement-no-short-if-conc2-matching
 (implies
  (cst-list-list-conc-matchp abnf::cstss
                             "enhanced-for-statement-no-short-if")
  (and (equal (len abnf::cstss) 1)
       (cst-list-rep-matchp (nth 0 abnf::cstss)
                            "enhanced-for-statement-no-short-if"))))

Theorem: cst-for-init-conc1-matching

(defthm cst-for-init-conc1-matching
  (implies (cst-list-list-conc-matchp
                abnf::cstss "statement-expression-list")
           (and (equal (len abnf::cstss) 1)
                (cst-list-rep-matchp (nth 0 abnf::cstss)
                                     "statement-expression-list"))))

Theorem: cst-for-init-conc2-matching

(defthm cst-for-init-conc2-matching
 (implies (cst-list-list-conc-matchp abnf::cstss
                                     "local-variable-declaration")
          (and (equal (len abnf::cstss) 1)
               (cst-list-rep-matchp (nth 0 abnf::cstss)
                                    "local-variable-declaration"))))

Theorem: cst-for-update-conc-matching

(defthm cst-for-update-conc-matching
  (implies (cst-list-list-conc-matchp
                abnf::cstss "statement-expression-list")
           (and (equal (len abnf::cstss) 1)
                (cst-list-rep-matchp (nth 0 abnf::cstss)
                                     "statement-expression-list"))))

Theorem: cst-try-statement-conc3-matching

(defthm cst-try-statement-conc3-matching
  (implies
       (cst-list-list-conc-matchp abnf::cstss
                                  "try-with-resources-statement")
       (and (equal (len abnf::cstss) 1)
            (cst-list-rep-matchp (nth 0 abnf::cstss)
                                 "try-with-resources-statement"))))

Theorem: cst-catches-conc-matching

(defthm cst-catches-conc-matching
  (implies (cst-list-list-conc-matchp abnf::cstss "1*catch-clause")
           (and (equal (len abnf::cstss) 1)
                (cst-list-rep-matchp (nth 0 abnf::cstss)
                                     "1*catch-clause"))))

Theorem: cst-resource-conc1-matching

(defthm cst-resource-conc1-matching
 (implies (cst-list-list-conc-matchp abnf::cstss
                                     "local-variable-declaration")
          (and (equal (len abnf::cstss) 1)
               (cst-list-rep-matchp (nth 0 abnf::cstss)
                                    "local-variable-declaration"))))

Theorem: cst-resource-conc2-matching

(defthm cst-resource-conc2-matching
  (implies (cst-list-list-conc-matchp abnf::cstss "variable-access")
           (and (equal (len abnf::cstss) 1)
                (cst-list-rep-matchp (nth 0 abnf::cstss)
                                     "variable-access"))))

Theorem: cst-variable-access-conc1-matching

(defthm cst-variable-access-conc1-matching
  (implies (cst-list-list-conc-matchp abnf::cstss "expression-name")
           (and (equal (len abnf::cstss) 1)
                (cst-list-rep-matchp (nth 0 abnf::cstss)
                                     "expression-name"))))

Theorem: cst-variable-access-conc2-matching

(defthm cst-variable-access-conc2-matching
  (implies (cst-list-list-conc-matchp abnf::cstss "field-access")
           (and (equal (len abnf::cstss) 1)
                (cst-list-rep-matchp (nth 0 abnf::cstss)
                                     "field-access"))))

Theorem: cst-pattern-conc1-matching

(defthm cst-pattern-conc1-matching
  (implies (cst-list-list-conc-matchp abnf::cstss "type-pattern")
           (and (equal (len abnf::cstss) 1)
                (cst-list-rep-matchp (nth 0 abnf::cstss)
                                     "type-pattern"))))

Theorem: cst-pattern-conc2-matching

(defthm cst-pattern-conc2-matching
  (implies (cst-list-list-conc-matchp abnf::cstss "record-pattern")
           (and (equal (len abnf::cstss) 1)
                (cst-list-rep-matchp (nth 0 abnf::cstss)
                                     "record-pattern"))))

Theorem: cst-type-pattern-conc-matching

(defthm cst-type-pattern-conc-matching
 (implies (cst-list-list-conc-matchp abnf::cstss
                                     "local-variable-declaration")
          (and (equal (len abnf::cstss) 1)
               (cst-list-rep-matchp (nth 0 abnf::cstss)
                                    "local-variable-declaration"))))

Theorem: cst-component-pattern-conc1-matching

(defthm cst-component-pattern-conc1-matching
  (implies (cst-list-list-conc-matchp abnf::cstss "pattern")
           (and (equal (len abnf::cstss) 1)
                (cst-list-rep-matchp (nth 0 abnf::cstss)
                                     "pattern"))))

Theorem: cst-component-pattern-conc2-matching

(defthm cst-component-pattern-conc2-matching
  (implies
       (cst-list-list-conc-matchp abnf::cstss "match-all-pattern")
       (and (equal (len abnf::cstss) 1)
            (cst-list-rep-matchp (nth 0 abnf::cstss)
                                 "match-all-pattern"))))

Theorem: cst-match-all-pattern-conc-matching

(defthm cst-match-all-pattern-conc-matching
  (implies (cst-list-list-conc-matchp abnf::cstss "\"_\"")
           (and (equal (len abnf::cstss) 1)
                (cst-list-rep-matchp (nth 0 abnf::cstss)
                                     "\"_\""))))

Theorem: cst-expression-conc1-matching

(defthm cst-expression-conc1-matching
  (implies
       (cst-list-list-conc-matchp abnf::cstss "lambda-expression")
       (and (equal (len abnf::cstss) 1)
            (cst-list-rep-matchp (nth 0 abnf::cstss)
                                 "lambda-expression"))))

Theorem: cst-expression-conc2-matching

(defthm cst-expression-conc2-matching
 (implies
     (cst-list-list-conc-matchp abnf::cstss "assignment-expression")
     (and (equal (len abnf::cstss) 1)
          (cst-list-rep-matchp (nth 0 abnf::cstss)
                               "assignment-expression"))))

Theorem: cst-primary-conc1-matching

(defthm cst-primary-conc1-matching
 (implies
      (cst-list-list-conc-matchp abnf::cstss "primary-no-new-array")
      (and (equal (len abnf::cstss) 1)
           (cst-list-rep-matchp (nth 0 abnf::cstss)
                                "primary-no-new-array"))))

Theorem: cst-primary-conc2-matching

(defthm cst-primary-conc2-matching
  (implies (cst-list-list-conc-matchp
                abnf::cstss "array-creation-expression")
           (and (equal (len abnf::cstss) 1)
                (cst-list-rep-matchp (nth 0 abnf::cstss)
                                     "array-creation-expression"))))

Theorem: cst-primary-no-new-array-conc1-matching

(defthm cst-primary-no-new-array-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-no-new-array-conc2-matching

(defthm cst-primary-no-new-array-conc2-matching
  (implies (cst-list-list-conc-matchp abnf::cstss "class-literal")
           (and (equal (len abnf::cstss) 1)
                (cst-list-rep-matchp (nth 0 abnf::cstss)
                                     "class-literal"))))

Theorem: cst-primary-no-new-array-conc3-matching

(defthm cst-primary-no-new-array-conc3-matching
  (implies (cst-list-list-conc-matchp abnf::cstss "%s\"this\"")
           (and (equal (len abnf::cstss) 1)
                (cst-list-rep-matchp (nth 0 abnf::cstss)
                                     "%s\"this\""))))

Theorem: cst-primary-no-new-array-conc6-matching

(defthm cst-primary-no-new-array-conc6-matching
 (implies
  (cst-list-list-conc-matchp abnf::cstss
                             "class-instance-creation-expression")
  (and (equal (len abnf::cstss) 1)
       (cst-list-rep-matchp (nth 0 abnf::cstss)
                            "class-instance-creation-expression"))))

Theorem: cst-primary-no-new-array-conc7-matching

(defthm cst-primary-no-new-array-conc7-matching
  (implies (cst-list-list-conc-matchp abnf::cstss "field-access")
           (and (equal (len abnf::cstss) 1)
                (cst-list-rep-matchp (nth 0 abnf::cstss)
                                     "field-access"))))

Theorem: cst-primary-no-new-array-conc8-matching

(defthm cst-primary-no-new-array-conc8-matching
  (implies (cst-list-list-conc-matchp abnf::cstss "array-access")
           (and (equal (len abnf::cstss) 1)
                (cst-list-rep-matchp (nth 0 abnf::cstss)
                                     "array-access"))))

Theorem: cst-primary-no-new-array-conc9-matching

(defthm cst-primary-no-new-array-conc9-matching
  (implies
       (cst-list-list-conc-matchp abnf::cstss "method-invocation")
       (and (equal (len abnf::cstss) 1)
            (cst-list-rep-matchp (nth 0 abnf::cstss)
                                 "method-invocation"))))

Theorem: cst-primary-no-new-array-conc10-matching

(defthm cst-primary-no-new-array-conc10-matching
 (implies (cst-list-list-conc-matchp abnf::cstss "method-reference")
          (and (equal (len abnf::cstss) 1)
               (cst-list-rep-matchp (nth 0 abnf::cstss)
                                    "method-reference"))))

Theorem: cst-class-instance-creation-expression-conc1-matching

(defthm cst-class-instance-creation-expression-conc1-matching
 (implies
      (cst-list-list-conc-matchp
           abnf::cstss
           "unqualified-class-instance-creation-expression")
      (and (equal (len abnf::cstss) 1)
           (cst-list-rep-matchp
                (nth 0 abnf::cstss)
                "unqualified-class-instance-creation-expression"))))

Theorem: cst-type-arguments-or-diamond-conc1-matching

(defthm cst-type-arguments-or-diamond-conc1-matching
  (implies (cst-list-list-conc-matchp abnf::cstss "type-arguments")
           (and (equal (len abnf::cstss) 1)
                (cst-list-rep-matchp (nth 0 abnf::cstss)
                                     "type-arguments"))))

Theorem: cst-type-arguments-or-diamond-conc2-matching

(defthm cst-type-arguments-or-diamond-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-array-creation-expression-conc1-matching

(defthm cst-array-creation-expression-conc1-matching
  (implies
       (cst-list-list-conc-matchp
            abnf::cstss
            "array-creation-expression-without-initializer")
       (and (equal (len abnf::cstss) 1)
            (cst-list-rep-matchp
                 (nth 0 abnf::cstss)
                 "array-creation-expression-without-initializer"))))

Theorem: cst-array-creation-expression-conc2-matching

(defthm cst-array-creation-expression-conc2-matching
 (implies (cst-list-list-conc-matchp
               abnf::cstss
               "array-creation-expression-with-initializer")
          (and (equal (len abnf::cstss) 1)
               (cst-list-rep-matchp
                    (nth 0 abnf::cstss)
                    "array-creation-expression-with-initializer"))))

Theorem: cst-dim-exprs-conc-matching

(defthm cst-dim-exprs-conc-matching
  (implies (cst-list-list-conc-matchp abnf::cstss "1*dim-expr")
           (and (equal (len abnf::cstss) 1)
                (cst-list-rep-matchp (nth 0 abnf::cstss)
                                     "1*dim-expr"))))

Theorem: cst-postfix-expression-conc1-matching

(defthm cst-postfix-expression-conc1-matching
  (implies (cst-list-list-conc-matchp abnf::cstss "primary")
           (and (equal (len abnf::cstss) 1)
                (cst-list-rep-matchp (nth 0 abnf::cstss)
                                     "primary"))))

Theorem: cst-postfix-expression-conc2-matching

(defthm cst-postfix-expression-conc2-matching
  (implies (cst-list-list-conc-matchp abnf::cstss "expression-name")
           (and (equal (len abnf::cstss) 1)
                (cst-list-rep-matchp (nth 0 abnf::cstss)
                                     "expression-name"))))

Theorem: cst-postfix-expression-conc3-matching

(defthm cst-postfix-expression-conc3-matching
  (implies (cst-list-list-conc-matchp
                abnf::cstss "post-increment-expression")
           (and (equal (len abnf::cstss) 1)
                (cst-list-rep-matchp (nth 0 abnf::cstss)
                                     "post-increment-expression"))))

Theorem: cst-postfix-expression-conc4-matching

(defthm cst-postfix-expression-conc4-matching
  (implies (cst-list-list-conc-matchp
                abnf::cstss "post-decrement-expression")
           (and (equal (len abnf::cstss) 1)
                (cst-list-rep-matchp (nth 0 abnf::cstss)
                                     "post-decrement-expression"))))

Theorem: cst-unary-expression-conc1-matching

(defthm cst-unary-expression-conc1-matching
 (implies
  (cst-list-list-conc-matchp abnf::cstss "pre-increment-expression")
  (and (equal (len abnf::cstss) 1)
       (cst-list-rep-matchp (nth 0 abnf::cstss)
                            "pre-increment-expression"))))

Theorem: cst-unary-expression-conc2-matching

(defthm cst-unary-expression-conc2-matching
 (implies
  (cst-list-list-conc-matchp abnf::cstss "pre-decrement-expression")
  (and (equal (len abnf::cstss) 1)
       (cst-list-rep-matchp (nth 0 abnf::cstss)
                            "pre-decrement-expression"))))

Theorem: cst-unary-expression-conc5-matching

(defthm cst-unary-expression-conc5-matching
 (implies
     (cst-list-list-conc-matchp abnf::cstss
                                "unary-expression-not-plus-minus")
     (and (equal (len abnf::cstss) 1)
          (cst-list-rep-matchp (nth 0 abnf::cstss)
                               "unary-expression-not-plus-minus"))))

Theorem: cst-unary-expression-not-plus-minus-conc1-matching

(defthm cst-unary-expression-not-plus-minus-conc1-matching
  (implies
       (cst-list-list-conc-matchp abnf::cstss "postfix-expression")
       (and (equal (len abnf::cstss) 1)
            (cst-list-rep-matchp (nth 0 abnf::cstss)
                                 "postfix-expression"))))

Theorem: cst-unary-expression-not-plus-minus-conc4-matching

(defthm cst-unary-expression-not-plus-minus-conc4-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-unary-expression-not-plus-minus-conc5-matching

(defthm cst-unary-expression-not-plus-minus-conc5-matching
  (implies
       (cst-list-list-conc-matchp abnf::cstss "switch-expression")
       (and (equal (len abnf::cstss) 1)
            (cst-list-rep-matchp (nth 0 abnf::cstss)
                                 "switch-expression"))))

Theorem: cst-multiplicative-expression-conc1-matching

(defthm cst-multiplicative-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-additive-expression-conc1-matching

(defthm cst-additive-expression-conc1-matching
  (implies (cst-list-list-conc-matchp
                abnf::cstss "multiplicative-expression")
           (and (equal (len abnf::cstss) 1)
                (cst-list-rep-matchp (nth 0 abnf::cstss)
                                     "multiplicative-expression"))))

Theorem: cst-shift-expression-conc1-matching

(defthm cst-shift-expression-conc1-matching
  (implies
       (cst-list-list-conc-matchp abnf::cstss "additive-expression")
       (and (equal (len abnf::cstss) 1)
            (cst-list-rep-matchp (nth 0 abnf::cstss)
                                 "additive-expression"))))

Theorem: cst-relational-expression-conc1-matching

(defthm cst-relational-expression-conc1-matching
 (implies (cst-list-list-conc-matchp abnf::cstss "shift-expression")
          (and (equal (len abnf::cstss) 1)
               (cst-list-rep-matchp (nth 0 abnf::cstss)
                                    "shift-expression"))))

Theorem: cst-relational-expression-conc6-matching

(defthm cst-relational-expression-conc6-matching
 (implies
     (cst-list-list-conc-matchp abnf::cstss "instanceof-expression")
     (and (equal (len abnf::cstss) 1)
          (cst-list-rep-matchp (nth 0 abnf::cstss)
                               "instanceof-expression"))))

Theorem: cst-equality-expression-conc1-matching

(defthm cst-equality-expression-conc1-matching
 (implies
     (cst-list-list-conc-matchp abnf::cstss "relational-expression")
     (and (equal (len abnf::cstss) 1)
          (cst-list-rep-matchp (nth 0 abnf::cstss)
                               "relational-expression"))))

Theorem: cst-and-expression-conc1-matching

(defthm cst-and-expression-conc1-matching
  (implies
       (cst-list-list-conc-matchp abnf::cstss "equality-expression")
       (and (equal (len abnf::cstss) 1)
            (cst-list-rep-matchp (nth 0 abnf::cstss)
                                 "equality-expression"))))

Theorem: cst-exclusive-or-expression-conc1-matching

(defthm cst-exclusive-or-expression-conc1-matching
  (implies (cst-list-list-conc-matchp abnf::cstss "and-expression")
           (and (equal (len abnf::cstss) 1)
                (cst-list-rep-matchp (nth 0 abnf::cstss)
                                     "and-expression"))))

Theorem: cst-inclusive-or-expression-conc1-matching

(defthm cst-inclusive-or-expression-conc1-matching
 (implies
   (cst-list-list-conc-matchp abnf::cstss "exclusive-or-expression")
   (and (equal (len abnf::cstss) 1)
        (cst-list-rep-matchp (nth 0 abnf::cstss)
                             "exclusive-or-expression"))))

Theorem: cst-conditional-and-expression-conc1-matching

(defthm cst-conditional-and-expression-conc1-matching
 (implies
   (cst-list-list-conc-matchp abnf::cstss "inclusive-or-expression")
   (and (equal (len abnf::cstss) 1)
        (cst-list-rep-matchp (nth 0 abnf::cstss)
                             "inclusive-or-expression"))))

Theorem: cst-conditional-or-expression-conc1-matching

(defthm cst-conditional-or-expression-conc1-matching
 (implies (cst-list-list-conc-matchp abnf::cstss
                                     "conditional-and-expression")
          (and (equal (len abnf::cstss) 1)
               (cst-list-rep-matchp (nth 0 abnf::cstss)
                                    "conditional-and-expression"))))

Theorem: cst-conditional-expression-conc1-matching

(defthm cst-conditional-expression-conc1-matching
  (implies (cst-list-list-conc-matchp
                abnf::cstss "conditional-or-expression")
           (and (equal (len abnf::cstss) 1)
                (cst-list-rep-matchp (nth 0 abnf::cstss)
                                     "conditional-or-expression"))))

Theorem: cst-assignment-expression-conc1-matching

(defthm cst-assignment-expression-conc1-matching
 (implies
    (cst-list-list-conc-matchp abnf::cstss "conditional-expression")
    (and (equal (len abnf::cstss) 1)
         (cst-list-rep-matchp (nth 0 abnf::cstss)
                              "conditional-expression"))))

Theorem: cst-assignment-expression-conc2-matching

(defthm cst-assignment-expression-conc2-matching
  (implies (cst-list-list-conc-matchp abnf::cstss "assignment")
           (and (equal (len abnf::cstss) 1)
                (cst-list-rep-matchp (nth 0 abnf::cstss)
                                     "assignment"))))

Theorem: cst-left-hand-side-conc1-matching

(defthm cst-left-hand-side-conc1-matching
  (implies (cst-list-list-conc-matchp abnf::cstss "expression-name")
           (and (equal (len abnf::cstss) 1)
                (cst-list-rep-matchp (nth 0 abnf::cstss)
                                     "expression-name"))))

Theorem: cst-left-hand-side-conc2-matching

(defthm cst-left-hand-side-conc2-matching
  (implies (cst-list-list-conc-matchp abnf::cstss "field-access")
           (and (equal (len abnf::cstss) 1)
                (cst-list-rep-matchp (nth 0 abnf::cstss)
                                     "field-access"))))

Theorem: cst-left-hand-side-conc3-matching

(defthm cst-left-hand-side-conc3-matching
  (implies (cst-list-list-conc-matchp abnf::cstss "array-access")
           (and (equal (len abnf::cstss) 1)
                (cst-list-rep-matchp (nth 0 abnf::cstss)
                                     "array-access"))))

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-lambda-parameters-conc2-matching

(defthm cst-lambda-parameters-conc2-matching
 (implies
  (cst-list-list-conc-matchp abnf::cstss "concise-lambda-parameter")
  (and (equal (len abnf::cstss) 1)
       (cst-list-rep-matchp (nth 0 abnf::cstss)
                            "concise-lambda-parameter"))))

Theorem: cst-normal-lambda-parameter-conc2-matching

(defthm cst-normal-lambda-parameter-conc2-matching
 (implies
  (cst-list-list-conc-matchp abnf::cstss "variable-arity-parameter")
  (and (equal (len abnf::cstss) 1)
       (cst-list-rep-matchp (nth 0 abnf::cstss)
                            "variable-arity-parameter"))))

Theorem: cst-lambda-parameter-type-conc1-matching

(defthm cst-lambda-parameter-type-conc1-matching
  (implies (cst-list-list-conc-matchp abnf::cstss "unann-type")
           (and (equal (len abnf::cstss) 1)
                (cst-list-rep-matchp (nth 0 abnf::cstss)
                                     "unann-type"))))

Theorem: cst-lambda-parameter-type-conc2-matching

(defthm cst-lambda-parameter-type-conc2-matching
  (implies (cst-list-list-conc-matchp abnf::cstss "%s\"var\"")
           (and (equal (len abnf::cstss) 1)
                (cst-list-rep-matchp (nth 0 abnf::cstss)
                                     "%s\"var\""))))

Theorem: cst-concise-lambda-parameter-conc1-matching

(defthm cst-concise-lambda-parameter-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-concise-lambda-parameter-conc2-matching

(defthm cst-concise-lambda-parameter-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-lambda-body-conc1-matching

(defthm cst-lambda-body-conc1-matching
  (implies (cst-list-list-conc-matchp abnf::cstss "expression")
           (and (equal (len abnf::cstss) 1)
                (cst-list-rep-matchp (nth 0 abnf::cstss)
                                     "expression"))))

Theorem: cst-lambda-body-conc2-matching

(defthm cst-lambda-body-conc2-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-unicode-input-character-conc1-rep-matching

(defthm cst-unicode-input-character-conc1-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "unicode-escape")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "unicode-escape"))))

Theorem: cst-unicode-input-character-conc2-rep-matching

(defthm cst-unicode-input-character-conc2-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "raw-input-character")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "raw-input-character"))))

Theorem: cst-hex-digit-conc1-rep-matching

(defthm cst-hex-digit-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-hex-digit-conc2-rep-matching

(defthm cst-hex-digit-conc2-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "\"1\"")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts) "\"1\""))))

Theorem: cst-hex-digit-conc3-rep-matching

(defthm cst-hex-digit-conc3-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "\"2\"")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts) "\"2\""))))

Theorem: cst-hex-digit-conc4-rep-matching

(defthm cst-hex-digit-conc4-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "\"3\"")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts) "\"3\""))))

Theorem: cst-hex-digit-conc5-rep-matching

(defthm cst-hex-digit-conc5-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "\"4\"")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts) "\"4\""))))

Theorem: cst-hex-digit-conc6-rep-matching

(defthm cst-hex-digit-conc6-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "\"5\"")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts) "\"5\""))))

Theorem: cst-hex-digit-conc7-rep-matching

(defthm cst-hex-digit-conc7-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "\"6\"")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts) "\"6\""))))

Theorem: cst-hex-digit-conc8-rep-matching

(defthm cst-hex-digit-conc8-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "\"7\"")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts) "\"7\""))))

Theorem: cst-hex-digit-conc9-rep-matching

(defthm cst-hex-digit-conc9-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "\"8\"")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts) "\"8\""))))

Theorem: cst-hex-digit-conc10-rep-matching

(defthm cst-hex-digit-conc10-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "\"9\"")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts) "\"9\""))))

Theorem: cst-hex-digit-conc11-rep-matching

(defthm cst-hex-digit-conc11-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "\"a\"")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts) "\"a\""))))

Theorem: cst-hex-digit-conc12-rep-matching

(defthm cst-hex-digit-conc12-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "\"b\"")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts) "\"b\""))))

Theorem: cst-hex-digit-conc13-rep-matching

(defthm cst-hex-digit-conc13-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "\"c\"")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts) "\"c\""))))

Theorem: cst-hex-digit-conc14-rep-matching

(defthm cst-hex-digit-conc14-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "\"d\"")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts) "\"d\""))))

Theorem: cst-hex-digit-conc15-rep-matching

(defthm cst-hex-digit-conc15-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "\"e\"")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts) "\"e\""))))

Theorem: cst-hex-digit-conc16-rep-matching

(defthm cst-hex-digit-conc16-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "\"f\"")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts) "\"f\""))))

Theorem: cst-raw-input-character-conc-rep-matching

(defthm cst-raw-input-character-conc-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "%x0-FFFF")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "%x0-FFFF"))))

Theorem: cst-line-terminator-conc1-rep-matching

(defthm cst-line-terminator-conc1-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "%d10")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "%d10"))))

Theorem: cst-line-terminator-conc2-rep-matching

(defthm cst-line-terminator-conc2-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "%d13")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "%d13"))))

Theorem: cst-line-terminator-conc3-rep-matching

(defthm cst-line-terminator-conc3-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "%d13.10")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "%d13.10"))))

Theorem: cst-input-character-conc-rep-matching

(defthm cst-input-character-conc-rep-matching
 (implies (cst-list-rep-matchp abnf::csts "unicode-input-character")
          (and (equal (len abnf::csts) 1)
               (cst-matchp (nth 0 abnf::csts)
                           "unicode-input-character"))))

Theorem: cst-input-element-conc1-rep-matching

(defthm cst-input-element-conc1-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "white-space")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "white-space"))))

Theorem: cst-input-element-conc2-rep-matching

(defthm cst-input-element-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-input-element-conc3-rep-matching

(defthm cst-input-element-conc3-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-token-conc1-rep-matching

(defthm cst-token-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-token-conc2-rep-matching

(defthm cst-token-conc2-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "keyword")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "keyword"))))

Theorem: cst-token-conc3-rep-matching

(defthm cst-token-conc3-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-token-conc4-rep-matching

(defthm cst-token-conc4-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "separator")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "separator"))))

Theorem: cst-token-conc5-rep-matching

(defthm cst-token-conc5-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "operator")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "operator"))))

Theorem: cst-sub-conc-rep-matching

(defthm cst-sub-conc-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "%d26")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "%d26"))))

Theorem: cst-white-space-conc1-rep-matching

(defthm cst-white-space-conc1-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "%d32")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "%d32"))))

Theorem: cst-white-space-conc2-rep-matching

(defthm cst-white-space-conc2-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "%d9")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts) "%d9"))))

Theorem: cst-white-space-conc3-rep-matching

(defthm cst-white-space-conc3-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "%d12")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "%d12"))))

Theorem: cst-white-space-conc4-rep-matching

(defthm cst-white-space-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-comment-conc1-rep-matching

(defthm cst-comment-conc1-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "traditional-comment")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "traditional-comment"))))

Theorem: cst-comment-conc2-rep-matching

(defthm cst-comment-conc2-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "end-of-line-comment")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "end-of-line-comment"))))

Theorem: cst-comment-tail-star-conc1-rep-matching

(defthm cst-comment-tail-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-conc1-rep-matching

(defthm cst-not-star-conc1-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "input-character")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "input-character"))))

Theorem: cst-not-star-conc2-rep-matching

(defthm cst-not-star-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-star-not-slash-conc1-rep-matching

(defthm cst-not-star-not-slash-conc1-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "input-character")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "input-character"))))

Theorem: cst-not-star-not-slash-conc2-rep-matching

(defthm cst-not-star-not-slash-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-identifier-conc-rep-matching

(defthm cst-identifier-conc-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "identifier-chars")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "identifier-chars"))))

Theorem: cst-java-letter-conc-rep-matching

(defthm cst-java-letter-conc-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "raw-input-character")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "raw-input-character"))))

Theorem: cst-java-letter-or-digit-conc-rep-matching

(defthm cst-java-letter-or-digit-conc-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "raw-input-character")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "raw-input-character"))))

Theorem: cst-type-identifier-conc-rep-matching

(defthm cst-type-identifier-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-unqualified-method-identifier-conc-rep-matching

(defthm cst-unqualified-method-identifier-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-keyword-conc1-rep-matching

(defthm cst-keyword-conc1-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "reserved-keyword")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "reserved-keyword"))))

Theorem: cst-keyword-conc2-rep-matching

(defthm cst-keyword-conc2-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "contextual-keyword")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "contextual-keyword"))))

Theorem: cst-reserved-keyword-conc1-rep-matching

(defthm cst-reserved-keyword-conc1-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "%s\"abstract\"")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "%s\"abstract\""))))

Theorem: cst-reserved-keyword-conc2-rep-matching

(defthm cst-reserved-keyword-conc2-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-reserved-keyword-conc3-rep-matching

(defthm cst-reserved-keyword-conc3-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "%s\"boolean\"")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "%s\"boolean\""))))

Theorem: cst-reserved-keyword-conc4-rep-matching

(defthm cst-reserved-keyword-conc4-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "%s\"break\"")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "%s\"break\""))))

Theorem: cst-reserved-keyword-conc5-rep-matching

(defthm cst-reserved-keyword-conc5-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "%s\"byte\"")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "%s\"byte\""))))

Theorem: cst-reserved-keyword-conc6-rep-matching

(defthm cst-reserved-keyword-conc6-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "%s\"case\"")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "%s\"case\""))))

Theorem: cst-reserved-keyword-conc7-rep-matching

(defthm cst-reserved-keyword-conc7-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "%s\"catch\"")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "%s\"catch\""))))

Theorem: cst-reserved-keyword-conc8-rep-matching

(defthm cst-reserved-keyword-conc8-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "%s\"char\"")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "%s\"char\""))))

Theorem: cst-reserved-keyword-conc9-rep-matching

(defthm cst-reserved-keyword-conc9-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "%s\"class\"")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "%s\"class\""))))

Theorem: cst-reserved-keyword-conc10-rep-matching

(defthm cst-reserved-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-reserved-keyword-conc11-rep-matching

(defthm cst-reserved-keyword-conc11-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "%s\"continue\"")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "%s\"continue\""))))

Theorem: cst-reserved-keyword-conc12-rep-matching

(defthm cst-reserved-keyword-conc12-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "%s\"default\"")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "%s\"default\""))))

Theorem: cst-reserved-keyword-conc13-rep-matching

(defthm cst-reserved-keyword-conc13-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "%s\"do\"")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "%s\"do\""))))

Theorem: cst-reserved-keyword-conc14-rep-matching

(defthm cst-reserved-keyword-conc14-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "%s\"double\"")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "%s\"double\""))))

Theorem: cst-reserved-keyword-conc15-rep-matching

(defthm cst-reserved-keyword-conc15-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-reserved-keyword-conc16-rep-matching

(defthm cst-reserved-keyword-conc16-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "%s\"enum\"")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "%s\"enum\""))))

Theorem: cst-reserved-keyword-conc17-rep-matching

(defthm cst-reserved-keyword-conc17-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "%s\"extends\"")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "%s\"extends\""))))

Theorem: cst-reserved-keyword-conc18-rep-matching

(defthm cst-reserved-keyword-conc18-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "%s\"final\"")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "%s\"final\""))))

Theorem: cst-reserved-keyword-conc19-rep-matching

(defthm cst-reserved-keyword-conc19-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "%s\"finally\"")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "%s\"finally\""))))

Theorem: cst-reserved-keyword-conc20-rep-matching

(defthm cst-reserved-keyword-conc20-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "%s\"float\"")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "%s\"float\""))))

Theorem: cst-reserved-keyword-conc21-rep-matching

(defthm cst-reserved-keyword-conc21-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-reserved-keyword-conc22-rep-matching

(defthm cst-reserved-keyword-conc22-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-reserved-keyword-conc23-rep-matching

(defthm cst-reserved-keyword-conc23-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "%s\"goto\"")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "%s\"goto\""))))

Theorem: cst-reserved-keyword-conc24-rep-matching

(defthm cst-reserved-keyword-conc24-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "%s\"implements\"")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "%s\"implements\""))))

Theorem: cst-reserved-keyword-conc25-rep-matching

(defthm cst-reserved-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-reserved-keyword-conc26-rep-matching

(defthm cst-reserved-keyword-conc26-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "%s\"instanceof\"")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "%s\"instanceof\""))))

Theorem: cst-reserved-keyword-conc27-rep-matching

(defthm cst-reserved-keyword-conc27-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "%s\"int\"")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "%s\"int\""))))

Theorem: cst-reserved-keyword-conc28-rep-matching

(defthm cst-reserved-keyword-conc28-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "%s\"interface\"")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "%s\"interface\""))))

Theorem: cst-reserved-keyword-conc29-rep-matching

(defthm cst-reserved-keyword-conc29-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "%s\"long\"")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "%s\"long\""))))

Theorem: cst-reserved-keyword-conc30-rep-matching

(defthm cst-reserved-keyword-conc30-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "%s\"native\"")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "%s\"native\""))))

Theorem: cst-reserved-keyword-conc31-rep-matching

(defthm cst-reserved-keyword-conc31-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "%s\"new\"")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "%s\"new\""))))

Theorem: cst-reserved-keyword-conc32-rep-matching

(defthm cst-reserved-keyword-conc32-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "%s\"package\"")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "%s\"package\""))))

Theorem: cst-reserved-keyword-conc33-rep-matching

(defthm cst-reserved-keyword-conc33-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-reserved-keyword-conc34-rep-matching

(defthm cst-reserved-keyword-conc34-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "%s\"protected\"")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "%s\"protected\""))))

Theorem: cst-reserved-keyword-conc35-rep-matching

(defthm cst-reserved-keyword-conc35-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-reserved-keyword-conc36-rep-matching

(defthm cst-reserved-keyword-conc36-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-reserved-keyword-conc37-rep-matching

(defthm cst-reserved-keyword-conc37-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "%s\"short\"")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "%s\"short\""))))

Theorem: cst-reserved-keyword-conc38-rep-matching

(defthm cst-reserved-keyword-conc38-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "%s\"static\"")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "%s\"static\""))))

Theorem: cst-reserved-keyword-conc39-rep-matching

(defthm cst-reserved-keyword-conc39-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "%s\"strictfp\"")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "%s\"strictfp\""))))

Theorem: cst-reserved-keyword-conc40-rep-matching

(defthm cst-reserved-keyword-conc40-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "%s\"super\"")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "%s\"super\""))))

Theorem: cst-reserved-keyword-conc41-rep-matching

(defthm cst-reserved-keyword-conc41-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "%s\"switch\"")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "%s\"switch\""))))

Theorem: cst-reserved-keyword-conc42-rep-matching

(defthm cst-reserved-keyword-conc42-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "%s\"synchronized\"")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "%s\"synchronized\""))))

Theorem: cst-reserved-keyword-conc43-rep-matching

(defthm cst-reserved-keyword-conc43-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "%s\"this\"")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "%s\"this\""))))

Theorem: cst-reserved-keyword-conc44-rep-matching

(defthm cst-reserved-keyword-conc44-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "%s\"throw\"")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "%s\"throw\""))))

Theorem: cst-reserved-keyword-conc45-rep-matching

(defthm cst-reserved-keyword-conc45-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "%s\"throws\"")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "%s\"throws\""))))

Theorem: cst-reserved-keyword-conc46-rep-matching

(defthm cst-reserved-keyword-conc46-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "%s\"transient\"")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "%s\"transient\""))))

Theorem: cst-reserved-keyword-conc47-rep-matching

(defthm cst-reserved-keyword-conc47-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "%s\"try\"")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "%s\"try\""))))

Theorem: cst-reserved-keyword-conc48-rep-matching

(defthm cst-reserved-keyword-conc48-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "%s\"void\"")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "%s\"void\""))))

Theorem: cst-reserved-keyword-conc49-rep-matching

(defthm cst-reserved-keyword-conc49-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "%s\"volatile\"")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "%s\"volatile\""))))

Theorem: cst-reserved-keyword-conc50-rep-matching

(defthm cst-reserved-keyword-conc50-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "%s\"while\"")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "%s\"while\""))))

Theorem: cst-reserved-keyword-conc51-rep-matching

(defthm cst-reserved-keyword-conc51-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "\"_\"")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts) "\"_\""))))

Theorem: cst-contextual-keyword-conc1-rep-matching

(defthm cst-contextual-keyword-conc1-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "%s\"exports\"")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "%s\"exports\""))))

Theorem: cst-contextual-keyword-conc2-rep-matching

(defthm cst-contextual-keyword-conc2-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "%s\"module\"")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "%s\"module\""))))

Theorem: cst-contextual-keyword-conc3-rep-matching

(defthm cst-contextual-keyword-conc3-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "%s\"non-sealed\"")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "%s\"non-sealed\""))))

Theorem: cst-contextual-keyword-conc4-rep-matching

(defthm cst-contextual-keyword-conc4-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "%s\"open\"")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "%s\"open\""))))

Theorem: cst-contextual-keyword-conc5-rep-matching

(defthm cst-contextual-keyword-conc5-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "%s\"opens\"")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "%s\"opens\""))))

Theorem: cst-contextual-keyword-conc6-rep-matching

(defthm cst-contextual-keyword-conc6-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "%s\"permits\"")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "%s\"permits\""))))

Theorem: cst-contextual-keyword-conc7-rep-matching

(defthm cst-contextual-keyword-conc7-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "%s\"provides\"")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "%s\"provides\""))))

Theorem: cst-contextual-keyword-conc8-rep-matching

(defthm cst-contextual-keyword-conc8-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-contextual-keyword-conc9-rep-matching

(defthm cst-contextual-keyword-conc9-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "%s\"requires\"")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "%s\"requires\""))))

Theorem: cst-contextual-keyword-conc10-rep-matching

(defthm cst-contextual-keyword-conc10-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "%s\"sealed\"")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "%s\"sealed\""))))

Theorem: cst-contextual-keyword-conc11-rep-matching

(defthm cst-contextual-keyword-conc11-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "%s\"to\"")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "%s\"to\""))))

Theorem: cst-contextual-keyword-conc12-rep-matching

(defthm cst-contextual-keyword-conc12-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "%s\"transitive\"")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "%s\"transitive\""))))

Theorem: cst-contextual-keyword-conc13-rep-matching

(defthm cst-contextual-keyword-conc13-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "%s\"uses\"")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "%s\"uses\""))))

Theorem: cst-contextual-keyword-conc14-rep-matching

(defthm cst-contextual-keyword-conc14-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "%s\"var\"")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "%s\"var\""))))

Theorem: cst-contextual-keyword-conc15-rep-matching

(defthm cst-contextual-keyword-conc15-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "%s\"when\"")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "%s\"when\""))))

Theorem: cst-contextual-keyword-conc16-rep-matching

(defthm cst-contextual-keyword-conc16-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "%s\"with\"")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "%s\"with\""))))

Theorem: cst-contextual-keyword-conc17-rep-matching

(defthm cst-contextual-keyword-conc17-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "%s\"yield\"")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "%s\"yield\""))))

Theorem: cst-literal-conc1-rep-matching

(defthm cst-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-literal-conc2-rep-matching

(defthm cst-literal-conc2-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "floating-point-literal")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "floating-point-literal"))))

Theorem: cst-literal-conc3-rep-matching

(defthm cst-literal-conc3-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "boolean-literal")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "boolean-literal"))))

Theorem: cst-literal-conc4-rep-matching

(defthm cst-literal-conc4-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "character-literal")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "character-literal"))))

Theorem: cst-literal-conc5-rep-matching

(defthm cst-literal-conc5-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "string-literal")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "string-literal"))))

Theorem: cst-literal-conc6-rep-matching

(defthm cst-literal-conc6-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "text-block")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "text-block"))))

Theorem: cst-literal-conc7-rep-matching

(defthm cst-literal-conc7-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "null-literal")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "null-literal"))))

Theorem: cst-integer-literal-conc1-rep-matching

(defthm cst-integer-literal-conc1-rep-matching
 (implies (cst-list-rep-matchp abnf::csts "decimal-integer-literal")
          (and (equal (len abnf::csts) 1)
               (cst-matchp (nth 0 abnf::csts)
                           "decimal-integer-literal"))))

Theorem: cst-integer-literal-conc2-rep-matching

(defthm cst-integer-literal-conc2-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "hex-integer-literal")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "hex-integer-literal"))))

Theorem: cst-integer-literal-conc3-rep-matching

(defthm cst-integer-literal-conc3-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "octal-integer-literal")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "octal-integer-literal"))))

Theorem: cst-integer-literal-conc4-rep-matching

(defthm cst-integer-literal-conc4-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "binary-integer-literal")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "binary-integer-literal"))))

Theorem: cst-integer-type-suffix-conc-rep-matching

(defthm cst-integer-type-suffix-conc-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "\"l\"")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts) "\"l\""))))

Theorem: cst-decimal-numeral-conc1-rep-matching

(defthm cst-decimal-numeral-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-non-zero-digit-conc1-rep-matching

(defthm cst-non-zero-digit-conc1-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "\"1\"")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts) "\"1\""))))

Theorem: cst-non-zero-digit-conc2-rep-matching

(defthm cst-non-zero-digit-conc2-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "\"2\"")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts) "\"2\""))))

Theorem: cst-non-zero-digit-conc3-rep-matching

(defthm cst-non-zero-digit-conc3-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "\"3\"")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts) "\"3\""))))

Theorem: cst-non-zero-digit-conc4-rep-matching

(defthm cst-non-zero-digit-conc4-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "\"4\"")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts) "\"4\""))))

Theorem: cst-non-zero-digit-conc5-rep-matching

(defthm cst-non-zero-digit-conc5-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "\"5\"")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts) "\"5\""))))

Theorem: cst-non-zero-digit-conc6-rep-matching

(defthm cst-non-zero-digit-conc6-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "\"6\"")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts) "\"6\""))))

Theorem: cst-non-zero-digit-conc7-rep-matching

(defthm cst-non-zero-digit-conc7-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "\"7\"")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts) "\"7\""))))

Theorem: cst-non-zero-digit-conc8-rep-matching

(defthm cst-non-zero-digit-conc8-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "\"8\"")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts) "\"8\""))))

Theorem: cst-non-zero-digit-conc9-rep-matching

(defthm cst-non-zero-digit-conc9-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "\"9\"")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts) "\"9\""))))

Theorem: cst-digits-conc1-rep-matching

(defthm cst-digits-conc1-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "digit")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "digit"))))

Theorem: cst-digit-conc1-rep-matching

(defthm cst-digit-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-digit-conc2-rep-matching

(defthm cst-digit-conc2-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "non-zero-digit")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "non-zero-digit"))))

Theorem: cst-digit-or-underscore-conc1-rep-matching

(defthm cst-digit-or-underscore-conc1-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "digit")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "digit"))))

Theorem: cst-digit-or-underscore-conc2-rep-matching

(defthm cst-digit-or-underscore-conc2-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "\"_\"")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts) "\"_\""))))

Theorem: cst-hex-digits-conc1-rep-matching

(defthm cst-hex-digits-conc1-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "hex-digit")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "hex-digit"))))

Theorem: cst-hex-digit-or-underscore-conc1-rep-matching

(defthm cst-hex-digit-or-underscore-conc1-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "hex-digit")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "hex-digit"))))

Theorem: cst-hex-digit-or-underscore-conc2-rep-matching

(defthm cst-hex-digit-or-underscore-conc2-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "\"_\"")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts) "\"_\""))))

Theorem: cst-octal-digits-conc1-rep-matching

(defthm cst-octal-digits-conc1-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "octal-digit")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "octal-digit"))))

Theorem: cst-octal-digit-conc1-rep-matching

(defthm cst-octal-digit-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-octal-digit-conc2-rep-matching

(defthm cst-octal-digit-conc2-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "\"1\"")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts) "\"1\""))))

Theorem: cst-octal-digit-conc3-rep-matching

(defthm cst-octal-digit-conc3-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "\"2\"")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts) "\"2\""))))

Theorem: cst-octal-digit-conc4-rep-matching

(defthm cst-octal-digit-conc4-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "\"3\"")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts) "\"3\""))))

Theorem: cst-octal-digit-conc5-rep-matching

(defthm cst-octal-digit-conc5-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "\"4\"")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts) "\"4\""))))

Theorem: cst-octal-digit-conc6-rep-matching

(defthm cst-octal-digit-conc6-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "\"5\"")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts) "\"5\""))))

Theorem: cst-octal-digit-conc7-rep-matching

(defthm cst-octal-digit-conc7-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "\"6\"")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts) "\"6\""))))

Theorem: cst-octal-digit-conc8-rep-matching

(defthm cst-octal-digit-conc8-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "\"7\"")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts) "\"7\""))))

Theorem: cst-octal-digit-or-underscore-conc1-rep-matching

(defthm cst-octal-digit-or-underscore-conc1-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "octal-digit")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "octal-digit"))))

Theorem: cst-octal-digit-or-underscore-conc2-rep-matching

(defthm cst-octal-digit-or-underscore-conc2-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "\"_\"")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts) "\"_\""))))

Theorem: cst-binary-digits-conc1-rep-matching

(defthm cst-binary-digits-conc1-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "binary-digit")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "binary-digit"))))

Theorem: cst-binary-digit-conc1-rep-matching

(defthm cst-binary-digit-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-binary-digit-conc2-rep-matching

(defthm cst-binary-digit-conc2-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "\"1\"")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts) "\"1\""))))

Theorem: cst-binary-digit-or-underscore-conc1-rep-matching

(defthm cst-binary-digit-or-underscore-conc1-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "binary-digit")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "binary-digit"))))

Theorem: cst-binary-digit-or-underscore-conc2-rep-matching

(defthm cst-binary-digit-or-underscore-conc2-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "\"_\"")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts) "\"_\""))))

Theorem: cst-floating-point-literal-conc1-rep-matching

(defthm cst-floating-point-literal-conc1-rep-matching
  (implies (cst-list-rep-matchp abnf::csts
                                "decimal-floating-point-literal")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "decimal-floating-point-literal"))))

Theorem: cst-floating-point-literal-conc2-rep-matching

(defthm cst-floating-point-literal-conc2-rep-matching
 (implies (cst-list-rep-matchp abnf::csts
                               "hexadecimal-floating-point-literal")
          (and (equal (len abnf::csts) 1)
               (cst-matchp (nth 0 abnf::csts)
                           "hexadecimal-floating-point-literal"))))

Theorem: cst-exponent-indicator-conc-rep-matching

(defthm cst-exponent-indicator-conc-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "\"e\"")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts) "\"e\""))))

Theorem: cst-sign-conc1-rep-matching

(defthm cst-sign-conc1-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "\"+\"")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts) "\"+\""))))

Theorem: cst-sign-conc2-rep-matching

(defthm cst-sign-conc2-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "\"-\"")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts) "\"-\""))))

Theorem: cst-float-type-suffix-conc1-rep-matching

(defthm cst-float-type-suffix-conc1-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "\"f\"")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts) "\"f\""))))

Theorem: cst-float-type-suffix-conc2-rep-matching

(defthm cst-float-type-suffix-conc2-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "\"d\"")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts) "\"d\""))))

Theorem: cst-binary-exponent-indicator-conc-rep-matching

(defthm cst-binary-exponent-indicator-conc-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "\"p\"")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts) "\"p\""))))

Theorem: cst-boolean-literal-conc1-rep-matching

(defthm cst-boolean-literal-conc1-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "%s\"true\"")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "%s\"true\""))))

Theorem: cst-boolean-literal-conc2-rep-matching

(defthm cst-boolean-literal-conc2-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "%s\"false\"")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "%s\"false\""))))

Theorem: cst-single-character-conc-rep-matching

(defthm cst-single-character-conc-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "input-character")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "input-character"))))

Theorem: cst-string-character-conc1-rep-matching

(defthm cst-string-character-conc1-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "input-character")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "input-character"))))

Theorem: cst-string-character-conc2-rep-matching

(defthm cst-string-character-conc2-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "escape-sequence")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "escape-sequence"))))

Theorem: cst-text-block-white-space-conc-rep-matching

(defthm cst-text-block-white-space-conc-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "white-space")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "white-space"))))

Theorem: cst-text-block-character-conc1-rep-matching

(defthm cst-text-block-character-conc1-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "input-character")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "input-character"))))

Theorem: cst-text-block-character-conc2-rep-matching

(defthm cst-text-block-character-conc2-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "escape-sequence")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "escape-sequence"))))

Theorem: cst-text-block-character-conc3-rep-matching

(defthm cst-text-block-character-conc3-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "line-terminator")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "line-terminator"))))

Theorem: cst-escape-sequence-conc1-rep-matching

(defthm cst-escape-sequence-conc1-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "%s\"\\b\"")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "%s\"\\b\""))))

Theorem: cst-escape-sequence-conc2-rep-matching

(defthm cst-escape-sequence-conc2-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "%s\"\\s\"")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "%s\"\\s\""))))

Theorem: cst-escape-sequence-conc3-rep-matching

(defthm cst-escape-sequence-conc3-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "%s\"\\t\"")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "%s\"\\t\""))))

Theorem: cst-escape-sequence-conc4-rep-matching

(defthm cst-escape-sequence-conc4-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "%s\"\\n\"")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "%s\"\\n\""))))

Theorem: cst-escape-sequence-conc5-rep-matching

(defthm cst-escape-sequence-conc5-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "%s\"\\f\"")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "%s\"\\f\""))))

Theorem: cst-escape-sequence-conc6-rep-matching

(defthm cst-escape-sequence-conc6-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "%s\"\\r\"")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "%s\"\\r\""))))

Theorem: cst-escape-sequence-conc7-rep-matching

(defthm cst-escape-sequence-conc7-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-escape-sequence-conc9-rep-matching

(defthm cst-escape-sequence-conc9-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "\"\\'\"")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "\"\\'\""))))

Theorem: cst-escape-sequence-conc10-rep-matching

(defthm cst-escape-sequence-conc10-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "\"\\\\\"")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "\"\\\\\""))))

Theorem: cst-escape-sequence-conc11-rep-matching

(defthm cst-escape-sequence-conc11-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "octal-escape")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "octal-escape"))))

Theorem: cst-zero-to-three-conc1-rep-matching

(defthm cst-zero-to-three-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-zero-to-three-conc2-rep-matching

(defthm cst-zero-to-three-conc2-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "\"1\"")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts) "\"1\""))))

Theorem: cst-zero-to-three-conc3-rep-matching

(defthm cst-zero-to-three-conc3-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "\"2\"")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts) "\"2\""))))

Theorem: cst-zero-to-three-conc4-rep-matching

(defthm cst-zero-to-three-conc4-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "\"3\"")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts) "\"3\""))))

Theorem: cst-null-literal-conc-rep-matching

(defthm cst-null-literal-conc-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "%s\"null\"")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "%s\"null\""))))

Theorem: cst-separator-conc1-rep-matching

(defthm cst-separator-conc1-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "\"(\"")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts) "\"(\""))))

Theorem: cst-separator-conc2-rep-matching

(defthm cst-separator-conc2-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "\")\"")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts) "\")\""))))

Theorem: cst-separator-conc3-rep-matching

(defthm cst-separator-conc3-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "\"{\"")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts) "\"{\""))))

Theorem: cst-separator-conc4-rep-matching

(defthm cst-separator-conc4-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "\"}\"")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts) "\"}\""))))

Theorem: cst-separator-conc5-rep-matching

(defthm cst-separator-conc5-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "\"[\"")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts) "\"[\""))))

Theorem: cst-separator-conc6-rep-matching

(defthm cst-separator-conc6-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "\"]\"")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts) "\"]\""))))

Theorem: cst-separator-conc7-rep-matching

(defthm cst-separator-conc7-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "\";\"")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts) "\";\""))))

Theorem: cst-separator-conc8-rep-matching

(defthm cst-separator-conc8-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "\",\"")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts) "\",\""))))

Theorem: cst-separator-conc9-rep-matching

(defthm cst-separator-conc9-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "\".\"")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts) "\".\""))))

Theorem: cst-separator-conc10-rep-matching

(defthm cst-separator-conc10-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "\"...\"")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "\"...\""))))

Theorem: cst-separator-conc11-rep-matching

(defthm cst-separator-conc11-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "\"@\"")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts) "\"@\""))))

Theorem: cst-separator-conc12-rep-matching

(defthm cst-separator-conc12-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "\"::\"")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "\"::\""))))

Theorem: cst-operator-conc1-rep-matching

(defthm cst-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-operator-conc2-rep-matching

(defthm cst-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-operator-conc3-rep-matching

(defthm cst-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-operator-conc4-rep-matching

(defthm cst-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-operator-conc5-rep-matching

(defthm cst-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-operator-conc6-rep-matching

(defthm cst-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-operator-conc7-rep-matching

(defthm cst-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-operator-conc8-rep-matching

(defthm cst-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-operator-conc9-rep-matching

(defthm cst-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-operator-conc10-rep-matching

(defthm cst-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-operator-conc11-rep-matching

(defthm cst-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-operator-conc12-rep-matching

(defthm cst-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-operator-conc13-rep-matching

(defthm cst-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-operator-conc14-rep-matching

(defthm cst-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-operator-conc15-rep-matching

(defthm cst-operator-conc15-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "\"++\"")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "\"++\""))))

Theorem: cst-operator-conc16-rep-matching

(defthm cst-operator-conc16-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "\"--\"")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "\"--\""))))

Theorem: cst-operator-conc17-rep-matching

(defthm cst-operator-conc17-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "\"+\"")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts) "\"+\""))))

Theorem: cst-operator-conc18-rep-matching

(defthm cst-operator-conc18-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "\"-\"")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts) "\"-\""))))

Theorem: cst-operator-conc19-rep-matching

(defthm cst-operator-conc19-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "\"*\"")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts) "\"*\""))))

Theorem: cst-operator-conc20-rep-matching

(defthm cst-operator-conc20-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "\"/\"")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts) "\"/\""))))

Theorem: cst-operator-conc21-rep-matching

(defthm cst-operator-conc21-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "\"&\"")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts) "\"&\""))))

Theorem: cst-operator-conc22-rep-matching

(defthm cst-operator-conc22-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "\"|\"")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts) "\"|\""))))

Theorem: cst-operator-conc23-rep-matching

(defthm cst-operator-conc23-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "\"^\"")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts) "\"^\""))))

Theorem: cst-operator-conc24-rep-matching

(defthm cst-operator-conc24-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "\"%\"")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts) "\"%\""))))

Theorem: cst-operator-conc25-rep-matching

(defthm cst-operator-conc25-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "\"<<\"")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "\"<<\""))))

Theorem: cst-operator-conc26-rep-matching

(defthm cst-operator-conc26-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "\">>\"")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "\">>\""))))

Theorem: cst-operator-conc27-rep-matching

(defthm cst-operator-conc27-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "\">>>\"")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "\">>>\""))))

Theorem: cst-operator-conc28-rep-matching

(defthm cst-operator-conc28-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "\"+=\"")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "\"+=\""))))

Theorem: cst-operator-conc29-rep-matching

(defthm cst-operator-conc29-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "\"-=\"")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "\"-=\""))))

Theorem: cst-operator-conc30-rep-matching

(defthm cst-operator-conc30-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "\"*=\"")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "\"*=\""))))

Theorem: cst-operator-conc31-rep-matching

(defthm cst-operator-conc31-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "\"/=\"")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "\"/=\""))))

Theorem: cst-operator-conc32-rep-matching

(defthm cst-operator-conc32-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "\"&=\"")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "\"&=\""))))

Theorem: cst-operator-conc33-rep-matching

(defthm cst-operator-conc33-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "\"|=\"")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "\"|=\""))))

Theorem: cst-operator-conc34-rep-matching

(defthm cst-operator-conc34-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "\"^=\"")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "\"^=\""))))

Theorem: cst-operator-conc35-rep-matching

(defthm cst-operator-conc35-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "\"%=\"")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "\"%=\""))))

Theorem: cst-operator-conc36-rep-matching

(defthm cst-operator-conc36-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "\"<<=\"")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "\"<<=\""))))

Theorem: cst-operator-conc37-rep-matching

(defthm cst-operator-conc37-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "\">>=\"")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "\">>=\""))))

Theorem: cst-operator-conc38-rep-matching

(defthm cst-operator-conc38-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "\">>>=\"")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "\">>>=\""))))

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 "reference-type")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "reference-type"))))

Theorem: cst-numeric-type-conc1-rep-matching

(defthm cst-numeric-type-conc1-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "integral-type")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "integral-type"))))

Theorem: cst-numeric-type-conc2-rep-matching

(defthm cst-numeric-type-conc2-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "floating-point-type")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "floating-point-type"))))

Theorem: cst-integral-type-conc1-rep-matching

(defthm cst-integral-type-conc1-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "%s\"byte\"")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "%s\"byte\""))))

Theorem: cst-integral-type-conc2-rep-matching

(defthm cst-integral-type-conc2-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "%s\"short\"")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "%s\"short\""))))

Theorem: cst-integral-type-conc3-rep-matching

(defthm cst-integral-type-conc3-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "%s\"int\"")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "%s\"int\""))))

Theorem: cst-integral-type-conc4-rep-matching

(defthm cst-integral-type-conc4-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "%s\"long\"")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "%s\"long\""))))

Theorem: cst-integral-type-conc5-rep-matching

(defthm cst-integral-type-conc5-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "%s\"char\"")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "%s\"char\""))))

Theorem: cst-floating-point-type-conc1-rep-matching

(defthm cst-floating-point-type-conc1-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "%s\"float\"")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "%s\"float\""))))

Theorem: cst-floating-point-type-conc2-rep-matching

(defthm cst-floating-point-type-conc2-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "%s\"double\"")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "%s\"double\""))))

Theorem: cst-reference-type-conc1-rep-matching

(defthm cst-reference-type-conc1-rep-matching
 (implies (cst-list-rep-matchp abnf::csts "class-or-interface-type")
          (and (equal (len abnf::csts) 1)
               (cst-matchp (nth 0 abnf::csts)
                           "class-or-interface-type"))))

Theorem: cst-reference-type-conc2-rep-matching

(defthm cst-reference-type-conc2-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "type-variable")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "type-variable"))))

Theorem: cst-reference-type-conc3-rep-matching

(defthm cst-reference-type-conc3-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-class-or-interface-type-conc1-rep-matching

(defthm cst-class-or-interface-type-conc1-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "class-type")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "class-type"))))

Theorem: cst-class-or-interface-type-conc2-rep-matching

(defthm cst-class-or-interface-type-conc2-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "interface-type")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "interface-type"))))

Theorem: cst-interface-type-conc-rep-matching

(defthm cst-interface-type-conc-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "class-type")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "class-type"))))

Theorem: cst-type-parameter-modifier-conc-rep-matching

(defthm cst-type-parameter-modifier-conc-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-type-argument-conc1-rep-matching

(defthm cst-type-argument-conc1-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "reference-type")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "reference-type"))))

Theorem: cst-type-argument-conc2-rep-matching

(defthm cst-type-argument-conc2-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "wildcard")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "wildcard"))))

Theorem: cst-module-name-conc1-rep-matching

(defthm cst-module-name-conc1-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "identifier")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "identifier"))))

Theorem: cst-package-name-conc1-rep-matching

(defthm cst-package-name-conc1-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "identifier")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "identifier"))))

Theorem: cst-type-name-conc1-rep-matching

(defthm cst-type-name-conc1-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "type-identifier")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "type-identifier"))))

Theorem: cst-package-or-type-name-conc1-rep-matching

(defthm cst-package-or-type-name-conc1-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "identifier")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "identifier"))))

Theorem: cst-expression-name-conc1-rep-matching

(defthm cst-expression-name-conc1-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "identifier")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "identifier"))))

Theorem: cst-method-name-conc-rep-matching

(defthm cst-method-name-conc-rep-matching
  (implies (cst-list-rep-matchp abnf::csts
                                "unqualified-method-identifier")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "unqualified-method-identifier"))))

Theorem: cst-ambiguous-name-conc1-rep-matching

(defthm cst-ambiguous-name-conc1-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "identifier")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "identifier"))))

Theorem: cst-compilation-unit-conc1-rep-matching

(defthm cst-compilation-unit-conc1-rep-matching
  (implies
       (cst-list-rep-matchp abnf::csts "ordinary-compilation-unit")
       (and (equal (len abnf::csts) 1)
            (cst-matchp (nth 0 abnf::csts)
                        "ordinary-compilation-unit"))))

Theorem: cst-compilation-unit-conc2-rep-matching

(defthm cst-compilation-unit-conc2-rep-matching
  (implies
       (cst-list-rep-matchp abnf::csts "compact-compilation-unit")
       (and (equal (len abnf::csts) 1)
            (cst-matchp (nth 0 abnf::csts)
                        "compact-compilation-unit"))))

Theorem: cst-compilation-unit-conc3-rep-matching

(defthm cst-compilation-unit-conc3-rep-matching
  (implies
       (cst-list-rep-matchp abnf::csts "modular-compilation-unit")
       (and (equal (len abnf::csts) 1)
            (cst-matchp (nth 0 abnf::csts)
                        "modular-compilation-unit"))))

Theorem: cst-class-member-declaration-no-method-conc1-rep-matching

(defthm cst-class-member-declaration-no-method-conc1-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "field-declaration")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "field-declaration"))))

Theorem: cst-class-member-declaration-no-method-conc2-rep-matching

(defthm cst-class-member-declaration-no-method-conc2-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "class-declaration")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "class-declaration"))))

Theorem: cst-class-member-declaration-no-method-conc3-rep-matching

(defthm cst-class-member-declaration-no-method-conc3-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "interface-declaration")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "interface-declaration"))))

Theorem: cst-class-member-declaration-no-method-conc4-rep-matching

(defthm cst-class-member-declaration-no-method-conc4-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "\";\"")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts) "\";\""))))

Theorem: cst-package-modifier-conc-rep-matching

(defthm cst-package-modifier-conc-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-import-declaration-conc1-rep-matching

(defthm cst-import-declaration-conc1-rep-matching
  (implies (cst-list-rep-matchp abnf::csts
                                "single-type-import-declaration")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "single-type-import-declaration"))))

Theorem: cst-import-declaration-conc2-rep-matching

(defthm cst-import-declaration-conc2-rep-matching
  (implies (cst-list-rep-matchp abnf::csts
                                "type-import-on-demand-declaration")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "type-import-on-demand-declaration"))))

Theorem: cst-import-declaration-conc3-rep-matching

(defthm cst-import-declaration-conc3-rep-matching
  (implies (cst-list-rep-matchp abnf::csts
                                "single-static-import-declaration")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "single-static-import-declaration"))))

Theorem: cst-import-declaration-conc4-rep-matching

(defthm cst-import-declaration-conc4-rep-matching
  (implies
       (cst-list-rep-matchp abnf::csts
                            "static-import-on-demand-declaration")
       (and (equal (len abnf::csts) 1)
            (cst-matchp (nth 0 abnf::csts)
                        "static-import-on-demand-declaration"))))

Theorem: cst-import-declaration-conc5-rep-matching

(defthm cst-import-declaration-conc5-rep-matching
  (implies (cst-list-rep-matchp abnf::csts
                                "single-module-import-declaration")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "single-module-import-declaration"))))

Theorem: cst-top-level-class-or-interface-declaration-conc1-rep-matching

(defthm
    cst-top-level-class-or-interface-declaration-conc1-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "class-declaration")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "class-declaration"))))

Theorem: cst-top-level-class-or-interface-declaration-conc2-rep-matching

(defthm
    cst-top-level-class-or-interface-declaration-conc2-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "interface-declaration")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "interface-declaration"))))

Theorem: cst-top-level-class-or-interface-declaration-conc3-rep-matching

(defthm
    cst-top-level-class-or-interface-declaration-conc3-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "\";\"")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts) "\";\""))))

Theorem: cst-requires-modifier-conc1-rep-matching

(defthm cst-requires-modifier-conc1-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "%s\"transitive\"")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "%s\"transitive\""))))

Theorem: cst-requires-modifier-conc2-rep-matching

(defthm cst-requires-modifier-conc2-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "%s\"static\"")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "%s\"static\""))))

Theorem: cst-class-declaration-conc1-rep-matching

(defthm cst-class-declaration-conc1-rep-matching
  (implies
       (cst-list-rep-matchp abnf::csts "normal-class-declaration")
       (and (equal (len abnf::csts) 1)
            (cst-matchp (nth 0 abnf::csts)
                        "normal-class-declaration"))))

Theorem: cst-class-declaration-conc2-rep-matching

(defthm cst-class-declaration-conc2-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "enum-declaration")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "enum-declaration"))))

Theorem: cst-class-declaration-conc3-rep-matching

(defthm cst-class-declaration-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-class-modifier-conc1-rep-matching

(defthm cst-class-modifier-conc1-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-class-modifier-conc2-rep-matching

(defthm cst-class-modifier-conc2-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-class-modifier-conc3-rep-matching

(defthm cst-class-modifier-conc3-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "%s\"protected\"")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "%s\"protected\""))))

Theorem: cst-class-modifier-conc4-rep-matching

(defthm cst-class-modifier-conc4-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-class-modifier-conc5-rep-matching

(defthm cst-class-modifier-conc5-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "%s\"abstract\"")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "%s\"abstract\""))))

Theorem: cst-class-modifier-conc6-rep-matching

(defthm cst-class-modifier-conc6-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "%s\"static\"")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "%s\"static\""))))

Theorem: cst-class-modifier-conc7-rep-matching

(defthm cst-class-modifier-conc7-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "%s\"final\"")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "%s\"final\""))))

Theorem: cst-class-modifier-conc8-rep-matching

(defthm cst-class-modifier-conc8-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "%s\"sealed\"")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "%s\"sealed\""))))

Theorem: cst-class-modifier-conc9-rep-matching

(defthm cst-class-modifier-conc9-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "%s\"non-sealed\"")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "%s\"non-sealed\""))))

Theorem: cst-class-modifier-conc10-rep-matching

(defthm cst-class-modifier-conc10-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "%s\"strictfp\"")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "%s\"strictfp\""))))

Theorem: cst-class-body-declaration-conc1-rep-matching

(defthm cst-class-body-declaration-conc1-rep-matching
  (implies
       (cst-list-rep-matchp abnf::csts "class-member-declaration")
       (and (equal (len abnf::csts) 1)
            (cst-matchp (nth 0 abnf::csts)
                        "class-member-declaration"))))

Theorem: cst-class-body-declaration-conc2-rep-matching

(defthm cst-class-body-declaration-conc2-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "instance-initializer")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "instance-initializer"))))

Theorem: cst-class-body-declaration-conc3-rep-matching

(defthm cst-class-body-declaration-conc3-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "static-initializer")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "static-initializer"))))

Theorem: cst-class-body-declaration-conc4-rep-matching

(defthm cst-class-body-declaration-conc4-rep-matching
 (implies (cst-list-rep-matchp abnf::csts "constructor-declaration")
          (and (equal (len abnf::csts) 1)
               (cst-matchp (nth 0 abnf::csts)
                           "constructor-declaration"))))

Theorem: cst-class-member-declaration-conc1-rep-matching

(defthm cst-class-member-declaration-conc1-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "field-declaration")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "field-declaration"))))

Theorem: cst-class-member-declaration-conc2-rep-matching

(defthm cst-class-member-declaration-conc2-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "method-declaration")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "method-declaration"))))

Theorem: cst-class-member-declaration-conc3-rep-matching

(defthm cst-class-member-declaration-conc3-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "class-declaration")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "class-declaration"))))

Theorem: cst-class-member-declaration-conc4-rep-matching

(defthm cst-class-member-declaration-conc4-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "interface-declaration")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "interface-declaration"))))

Theorem: cst-class-member-declaration-conc5-rep-matching

(defthm cst-class-member-declaration-conc5-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "\";\"")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts) "\";\""))))

Theorem: cst-variable-declarator-id-conc2-rep-matching

(defthm cst-variable-declarator-id-conc2-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "\"_\"")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts) "\"_\""))))

Theorem: cst-variable-initializer-conc1-rep-matching

(defthm cst-variable-initializer-conc1-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "expression")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "expression"))))

Theorem: cst-variable-initializer-conc2-rep-matching

(defthm cst-variable-initializer-conc2-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "array-initializer")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "array-initializer"))))

Theorem: cst-unann-type-conc1-rep-matching

(defthm cst-unann-type-conc1-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "unann-primitive-type")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "unann-primitive-type"))))

Theorem: cst-unann-type-conc2-rep-matching

(defthm cst-unann-type-conc2-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "unann-reference-type")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "unann-reference-type"))))

Theorem: cst-unann-primitive-type-conc1-rep-matching

(defthm cst-unann-primitive-type-conc1-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "numeric-type")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "numeric-type"))))

Theorem: cst-unann-primitive-type-conc2-rep-matching

(defthm cst-unann-primitive-type-conc2-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "%s\"boolean\"")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "%s\"boolean\""))))

Theorem: cst-unann-reference-type-conc1-rep-matching

(defthm cst-unann-reference-type-conc1-rep-matching
  (implies (cst-list-rep-matchp abnf::csts
                                "unann-class-or-interface-type")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "unann-class-or-interface-type"))))

Theorem: cst-unann-reference-type-conc2-rep-matching

(defthm cst-unann-reference-type-conc2-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "unann-type-variable")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "unann-type-variable"))))

Theorem: cst-unann-reference-type-conc3-rep-matching

(defthm cst-unann-reference-type-conc3-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "unann-array-type")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "unann-array-type"))))

Theorem: cst-unann-class-or-interface-type-conc1-rep-matching

(defthm cst-unann-class-or-interface-type-conc1-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "unann-class-type")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "unann-class-type"))))

Theorem: cst-unann-class-or-interface-type-conc2-rep-matching

(defthm cst-unann-class-or-interface-type-conc2-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "unann-interface-type")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "unann-interface-type"))))

Theorem: cst-unann-interface-type-conc-rep-matching

(defthm cst-unann-interface-type-conc-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "unann-class-type")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "unann-class-type"))))

Theorem: cst-unann-type-variable-conc-rep-matching

(defthm cst-unann-type-variable-conc-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "type-identifier")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "type-identifier"))))

Theorem: cst-field-modifier-conc1-rep-matching

(defthm cst-field-modifier-conc1-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-field-modifier-conc2-rep-matching

(defthm cst-field-modifier-conc2-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-field-modifier-conc3-rep-matching

(defthm cst-field-modifier-conc3-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "%s\"protected\"")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "%s\"protected\""))))

Theorem: cst-field-modifier-conc4-rep-matching

(defthm cst-field-modifier-conc4-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-field-modifier-conc5-rep-matching

(defthm cst-field-modifier-conc5-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "%s\"static\"")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "%s\"static\""))))

Theorem: cst-field-modifier-conc6-rep-matching

(defthm cst-field-modifier-conc6-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "%s\"final\"")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "%s\"final\""))))

Theorem: cst-field-modifier-conc7-rep-matching

(defthm cst-field-modifier-conc7-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "%s\"transient\"")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "%s\"transient\""))))

Theorem: cst-field-modifier-conc8-rep-matching

(defthm cst-field-modifier-conc8-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "%s\"volatile\"")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "%s\"volatile\""))))

Theorem: cst-formal-parameter-conc2-rep-matching

(defthm cst-formal-parameter-conc2-rep-matching
  (implies
       (cst-list-rep-matchp abnf::csts "variable-arity-parameter")
       (and (equal (len abnf::csts) 1)
            (cst-matchp (nth 0 abnf::csts)
                        "variable-arity-parameter"))))

Theorem: cst-variable-modifier-conc1-rep-matching

(defthm cst-variable-modifier-conc1-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-variable-modifier-conc2-rep-matching

(defthm cst-variable-modifier-conc2-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "%s\"final\"")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "%s\"final\""))))

Theorem: cst-method-modifier-conc1-rep-matching

(defthm cst-method-modifier-conc1-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-method-modifier-conc2-rep-matching

(defthm cst-method-modifier-conc2-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-method-modifier-conc3-rep-matching

(defthm cst-method-modifier-conc3-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "%s\"protected\"")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "%s\"protected\""))))

Theorem: cst-method-modifier-conc4-rep-matching

(defthm cst-method-modifier-conc4-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-method-modifier-conc5-rep-matching

(defthm cst-method-modifier-conc5-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "%s\"abstract\"")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "%s\"abstract\""))))

Theorem: cst-method-modifier-conc6-rep-matching

(defthm cst-method-modifier-conc6-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "%s\"static\"")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "%s\"static\""))))

Theorem: cst-method-modifier-conc7-rep-matching

(defthm cst-method-modifier-conc7-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "%s\"final\"")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "%s\"final\""))))

Theorem: cst-method-modifier-conc8-rep-matching

(defthm cst-method-modifier-conc8-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "%s\"synchronized\"")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "%s\"synchronized\""))))

Theorem: cst-method-modifier-conc9-rep-matching

(defthm cst-method-modifier-conc9-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "%s\"native\"")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "%s\"native\""))))

Theorem: cst-method-modifier-conc10-rep-matching

(defthm cst-method-modifier-conc10-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "%s\"strictfp\"")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "%s\"strictfp\""))))

Theorem: cst-result-conc1-rep-matching

(defthm cst-result-conc1-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "unann-type")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "unann-type"))))

Theorem: cst-result-conc2-rep-matching

(defthm cst-result-conc2-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "%s\"void\"")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "%s\"void\""))))

Theorem: cst-exception-type-conc1-rep-matching

(defthm cst-exception-type-conc1-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "class-type")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "class-type"))))

Theorem: cst-exception-type-conc2-rep-matching

(defthm cst-exception-type-conc2-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "type-variable")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "type-variable"))))

Theorem: cst-method-body-conc1-rep-matching

(defthm cst-method-body-conc1-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-method-body-conc2-rep-matching

(defthm cst-method-body-conc2-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "\";\"")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts) "\";\""))))

Theorem: cst-instance-initializer-conc-rep-matching

(defthm cst-instance-initializer-conc-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-simple-type-name-conc-rep-matching

(defthm cst-simple-type-name-conc-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "type-identifier")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "type-identifier"))))

Theorem: cst-constructor-modifier-conc1-rep-matching

(defthm cst-constructor-modifier-conc1-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-constructor-modifier-conc2-rep-matching

(defthm cst-constructor-modifier-conc2-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-constructor-modifier-conc3-rep-matching

(defthm cst-constructor-modifier-conc3-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "%s\"protected\"")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "%s\"protected\""))))

Theorem: cst-constructor-modifier-conc4-rep-matching

(defthm cst-constructor-modifier-conc4-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-enum-constant-modifier-conc-rep-matching

(defthm cst-enum-constant-modifier-conc-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-record-component-conc2-rep-matching

(defthm cst-record-component-conc2-rep-matching
  (implies (cst-list-rep-matchp abnf::csts
                                "variable-arity-record-component")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "variable-arity-record-component"))))

Theorem: cst-record-component-modifier-conc-rep-matching

(defthm cst-record-component-modifier-conc-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-record-body-declaration-conc1-rep-matching

(defthm cst-record-body-declaration-conc1-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "class-body-declaration")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "class-body-declaration"))))

Theorem: cst-record-body-declaration-conc2-rep-matching

(defthm cst-record-body-declaration-conc2-rep-matching
  (implies (cst-list-rep-matchp abnf::csts
                                "compact-constructor-declaration")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "compact-constructor-declaration"))))

Theorem: cst-interface-declaration-conc1-rep-matching

(defthm cst-interface-declaration-conc1-rep-matching
  (implies (cst-list-rep-matchp abnf::csts
                                "normal-interface-declaration")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "normal-interface-declaration"))))

Theorem: cst-interface-declaration-conc2-rep-matching

(defthm cst-interface-declaration-conc2-rep-matching
  (implies (cst-list-rep-matchp abnf::csts
                                "annotation-interface-declaration")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "annotation-interface-declaration"))))

Theorem: cst-interface-modifier-conc1-rep-matching

(defthm cst-interface-modifier-conc1-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-interface-modifier-conc2-rep-matching

(defthm cst-interface-modifier-conc2-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-interface-modifier-conc3-rep-matching

(defthm cst-interface-modifier-conc3-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "%s\"protected\"")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "%s\"protected\""))))

Theorem: cst-interface-modifier-conc4-rep-matching

(defthm cst-interface-modifier-conc4-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-interface-modifier-conc5-rep-matching

(defthm cst-interface-modifier-conc5-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "%s\"abstract\"")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "%s\"abstract\""))))

Theorem: cst-interface-modifier-conc6-rep-matching

(defthm cst-interface-modifier-conc6-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "%s\"static\"")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "%s\"static\""))))

Theorem: cst-interface-modifier-conc7-rep-matching

(defthm cst-interface-modifier-conc7-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "%s\"sealed\"")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "%s\"sealed\""))))

Theorem: cst-interface-modifier-conc8-rep-matching

(defthm cst-interface-modifier-conc8-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "%s\"non-sealed\"")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "%s\"non-sealed\""))))

Theorem: cst-interface-modifier-conc9-rep-matching

(defthm cst-interface-modifier-conc9-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "%s\"strictfp\"")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "%s\"strictfp\""))))

Theorem: cst-interface-member-declaration-conc1-rep-matching

(defthm cst-interface-member-declaration-conc1-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-interface-member-declaration-conc2-rep-matching

(defthm cst-interface-member-declaration-conc2-rep-matching
  (implies (cst-list-rep-matchp abnf::csts
                                "interface-method-declaration")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "interface-method-declaration"))))

Theorem: cst-interface-member-declaration-conc3-rep-matching

(defthm cst-interface-member-declaration-conc3-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "class-declaration")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "class-declaration"))))

Theorem: cst-interface-member-declaration-conc4-rep-matching

(defthm cst-interface-member-declaration-conc4-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "interface-declaration")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "interface-declaration"))))

Theorem: cst-interface-member-declaration-conc5-rep-matching

(defthm cst-interface-member-declaration-conc5-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "\";\"")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts) "\";\""))))

Theorem: cst-constant-modifier-conc1-rep-matching

(defthm cst-constant-modifier-conc1-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-constant-modifier-conc2-rep-matching

(defthm cst-constant-modifier-conc2-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-constant-modifier-conc3-rep-matching

(defthm cst-constant-modifier-conc3-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "%s\"static\"")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "%s\"static\""))))

Theorem: cst-constant-modifier-conc4-rep-matching

(defthm cst-constant-modifier-conc4-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "%s\"final\"")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "%s\"final\""))))

Theorem: cst-interface-method-modifier-conc1-rep-matching

(defthm cst-interface-method-modifier-conc1-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-interface-method-modifier-conc2-rep-matching

(defthm cst-interface-method-modifier-conc2-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-interface-method-modifier-conc3-rep-matching

(defthm cst-interface-method-modifier-conc3-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-interface-method-modifier-conc4-rep-matching

(defthm cst-interface-method-modifier-conc4-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "%s\"abstract\"")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "%s\"abstract\""))))

Theorem: cst-interface-method-modifier-conc5-rep-matching

(defthm cst-interface-method-modifier-conc5-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "%s\"default\"")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "%s\"default\""))))

Theorem: cst-interface-method-modifier-conc6-rep-matching

(defthm cst-interface-method-modifier-conc6-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "%s\"static\"")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "%s\"static\""))))

Theorem: cst-interface-method-modifier-conc7-rep-matching

(defthm cst-interface-method-modifier-conc7-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "%s\"strictfp\"")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "%s\"strictfp\""))))

Theorem: cst-annotation-interface-member-declaration-conc1-rep-matching

(defthm
     cst-annotation-interface-member-declaration-conc1-rep-matching
 (implies
    (cst-list-rep-matchp abnf::csts
                         "annotation-interface-element-declaration")
    (and (equal (len abnf::csts) 1)
         (cst-matchp (nth 0 abnf::csts)
                     "annotation-interface-element-declaration"))))

Theorem: cst-annotation-interface-member-declaration-conc2-rep-matching

(defthm
     cst-annotation-interface-member-declaration-conc2-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-annotation-interface-member-declaration-conc3-rep-matching

(defthm
     cst-annotation-interface-member-declaration-conc3-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "class-declaration")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "class-declaration"))))

Theorem: cst-annotation-interface-member-declaration-conc4-rep-matching

(defthm
     cst-annotation-interface-member-declaration-conc4-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "interface-declaration")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "interface-declaration"))))

Theorem: cst-annotation-interface-member-declaration-conc5-rep-matching

(defthm
     cst-annotation-interface-member-declaration-conc5-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "\";\"")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts) "\";\""))))

Theorem: cst-annotation-interface-element-modifier-conc1-rep-matching

(defthm cst-annotation-interface-element-modifier-conc1-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-annotation-interface-element-modifier-conc2-rep-matching

(defthm cst-annotation-interface-element-modifier-conc2-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-annotation-interface-element-modifier-conc3-rep-matching

(defthm cst-annotation-interface-element-modifier-conc3-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "%s\"abstract\"")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "%s\"abstract\""))))

Theorem: cst-annotation-conc1-rep-matching

(defthm cst-annotation-conc1-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "normal-annotation")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "normal-annotation"))))

Theorem: cst-annotation-conc2-rep-matching

(defthm cst-annotation-conc2-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "marker-annotation")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "marker-annotation"))))

Theorem: cst-annotation-conc3-rep-matching

(defthm cst-annotation-conc3-rep-matching
  (implies
       (cst-list-rep-matchp abnf::csts "single-element-annotation")
       (and (equal (len abnf::csts) 1)
            (cst-matchp (nth 0 abnf::csts)
                        "single-element-annotation"))))

Theorem: cst-element-value-conc1-rep-matching

(defthm cst-element-value-conc1-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "conditional-expression")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "conditional-expression"))))

Theorem: cst-element-value-conc2-rep-matching

(defthm cst-element-value-conc2-rep-matching
  (implies (cst-list-rep-matchp abnf::csts
                                "element-value-array-initializer")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "element-value-array-initializer"))))

Theorem: cst-element-value-conc3-rep-matching

(defthm cst-element-value-conc3-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-block-statement-conc1-rep-matching

(defthm cst-block-statement-conc1-rep-matching
  (implies
       (cst-list-rep-matchp abnf::csts
                            "local-class-or-interface-declaration")
       (and (equal (len abnf::csts) 1)
            (cst-matchp (nth 0 abnf::csts)
                        "local-class-or-interface-declaration"))))

Theorem: cst-block-statement-conc2-rep-matching

(defthm cst-block-statement-conc2-rep-matching
  (implies
       (cst-list-rep-matchp abnf::csts
                            "local-variable-declaration-statement")
       (and (equal (len abnf::csts) 1)
            (cst-matchp (nth 0 abnf::csts)
                        "local-variable-declaration-statement"))))

Theorem: cst-block-statement-conc3-rep-matching

(defthm cst-block-statement-conc3-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "statement")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "statement"))))

Theorem: cst-local-class-or-interface-declaration-conc1-rep-matching

(defthm cst-local-class-or-interface-declaration-conc1-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "class-declaration")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "class-declaration"))))

Theorem: cst-local-class-or-interface-declaration-conc2-rep-matching

(defthm cst-local-class-or-interface-declaration-conc2-rep-matching
  (implies (cst-list-rep-matchp abnf::csts
                                "normal-interface-declaration")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "normal-interface-declaration"))))

Theorem: cst-local-variable-type-conc1-rep-matching

(defthm cst-local-variable-type-conc1-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "unann-type")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "unann-type"))))

Theorem: cst-local-variable-type-conc2-rep-matching

(defthm cst-local-variable-type-conc2-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "%s\"var\"")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "%s\"var\""))))

Theorem: cst-statement-conc1-rep-matching

(defthm cst-statement-conc1-rep-matching
 (implies
     (cst-list-rep-matchp abnf::csts
                          "statement-without-trailing-substatement")
     (and (equal (len abnf::csts) 1)
          (cst-matchp (nth 0 abnf::csts)
                      "statement-without-trailing-substatement"))))

Theorem: cst-statement-conc2-rep-matching

(defthm cst-statement-conc2-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "labeled-statement")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "labeled-statement"))))

Theorem: cst-statement-conc3-rep-matching

(defthm cst-statement-conc3-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "if-then-statement")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "if-then-statement"))))

Theorem: cst-statement-conc4-rep-matching

(defthm cst-statement-conc4-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "if-then-else-statement")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "if-then-else-statement"))))

Theorem: cst-statement-conc5-rep-matching

(defthm cst-statement-conc5-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "while-statement")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "while-statement"))))

Theorem: cst-statement-conc6-rep-matching

(defthm cst-statement-conc6-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "for-statement")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "for-statement"))))

Theorem: cst-statement-no-short-if-conc1-rep-matching

(defthm cst-statement-no-short-if-conc1-rep-matching
 (implies
     (cst-list-rep-matchp abnf::csts
                          "statement-without-trailing-substatement")
     (and (equal (len abnf::csts) 1)
          (cst-matchp (nth 0 abnf::csts)
                      "statement-without-trailing-substatement"))))

Theorem: cst-statement-no-short-if-conc2-rep-matching

(defthm cst-statement-no-short-if-conc2-rep-matching
  (implies (cst-list-rep-matchp abnf::csts
                                "labeled-statement-no-short-if")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "labeled-statement-no-short-if"))))

Theorem: cst-statement-no-short-if-conc3-rep-matching

(defthm cst-statement-no-short-if-conc3-rep-matching
 (implies (cst-list-rep-matchp abnf::csts
                               "if-then-else-statement-no-short-if")
          (and (equal (len abnf::csts) 1)
               (cst-matchp (nth 0 abnf::csts)
                           "if-then-else-statement-no-short-if"))))

Theorem: cst-statement-no-short-if-conc4-rep-matching

(defthm cst-statement-no-short-if-conc4-rep-matching
  (implies (cst-list-rep-matchp abnf::csts
                                "while-statement-no-short-if")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "while-statement-no-short-if"))))

Theorem: cst-statement-no-short-if-conc5-rep-matching

(defthm cst-statement-no-short-if-conc5-rep-matching
  (implies
       (cst-list-rep-matchp abnf::csts "for-statement-no-short-if")
       (and (equal (len abnf::csts) 1)
            (cst-matchp (nth 0 abnf::csts)
                        "for-statement-no-short-if"))))

Theorem: cst-statement-without-trailing-substatement-conc1-rep-matching

(defthm
     cst-statement-without-trailing-substatement-conc1-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-statement-without-trailing-substatement-conc2-rep-matching

(defthm
     cst-statement-without-trailing-substatement-conc2-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "empty-statement")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "empty-statement"))))

Theorem: cst-statement-without-trailing-substatement-conc3-rep-matching

(defthm
     cst-statement-without-trailing-substatement-conc3-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "expression-statement")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "expression-statement"))))

Theorem: cst-statement-without-trailing-substatement-conc4-rep-matching

(defthm
     cst-statement-without-trailing-substatement-conc4-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "assert-statement")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "assert-statement"))))

Theorem: cst-statement-without-trailing-substatement-conc5-rep-matching

(defthm
     cst-statement-without-trailing-substatement-conc5-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "switch-statement")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "switch-statement"))))

Theorem: cst-statement-without-trailing-substatement-conc6-rep-matching

(defthm
     cst-statement-without-trailing-substatement-conc6-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "do-statement")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "do-statement"))))

Theorem: cst-statement-without-trailing-substatement-conc7-rep-matching

(defthm
     cst-statement-without-trailing-substatement-conc7-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "break-statement")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "break-statement"))))

Theorem: cst-statement-without-trailing-substatement-conc8-rep-matching

(defthm
     cst-statement-without-trailing-substatement-conc8-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "continue-statement")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "continue-statement"))))

Theorem: cst-statement-without-trailing-substatement-conc9-rep-matching

(defthm
     cst-statement-without-trailing-substatement-conc9-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-without-trailing-substatement-conc10-rep-matching

(defthm
    cst-statement-without-trailing-substatement-conc10-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "synchronized-statement")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "synchronized-statement"))))

Theorem: cst-statement-without-trailing-substatement-conc11-rep-matching

(defthm
    cst-statement-without-trailing-substatement-conc11-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "throw-statement")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "throw-statement"))))

Theorem: cst-statement-without-trailing-substatement-conc12-rep-matching

(defthm
    cst-statement-without-trailing-substatement-conc12-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "try-statement")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "try-statement"))))

Theorem: cst-statement-without-trailing-substatement-conc13-rep-matching

(defthm
    cst-statement-without-trailing-substatement-conc13-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "yield-statement")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "yield-statement"))))

Theorem: cst-empty-statement-conc-rep-matching

(defthm cst-empty-statement-conc-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "\";\"")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts) "\";\""))))

Theorem: cst-statement-expression-conc1-rep-matching

(defthm cst-statement-expression-conc1-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "assignment")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "assignment"))))

Theorem: cst-statement-expression-conc2-rep-matching

(defthm cst-statement-expression-conc2-rep-matching
  (implies
       (cst-list-rep-matchp abnf::csts "pre-increment-expression")
       (and (equal (len abnf::csts) 1)
            (cst-matchp (nth 0 abnf::csts)
                        "pre-increment-expression"))))

Theorem: cst-statement-expression-conc3-rep-matching

(defthm cst-statement-expression-conc3-rep-matching
  (implies
       (cst-list-rep-matchp abnf::csts "pre-decrement-expression")
       (and (equal (len abnf::csts) 1)
            (cst-matchp (nth 0 abnf::csts)
                        "pre-decrement-expression"))))

Theorem: cst-statement-expression-conc4-rep-matching

(defthm cst-statement-expression-conc4-rep-matching
  (implies
       (cst-list-rep-matchp abnf::csts "post-increment-expression")
       (and (equal (len abnf::csts) 1)
            (cst-matchp (nth 0 abnf::csts)
                        "post-increment-expression"))))

Theorem: cst-statement-expression-conc5-rep-matching

(defthm cst-statement-expression-conc5-rep-matching
  (implies
       (cst-list-rep-matchp abnf::csts "post-decrement-expression")
       (and (equal (len abnf::csts) 1)
            (cst-matchp (nth 0 abnf::csts)
                        "post-decrement-expression"))))

Theorem: cst-statement-expression-conc6-rep-matching

(defthm cst-statement-expression-conc6-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "method-invocation")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "method-invocation"))))

Theorem: cst-statement-expression-conc7-rep-matching

(defthm cst-statement-expression-conc7-rep-matching
 (implies (cst-list-rep-matchp abnf::csts
                               "class-instance-creation-expression")
          (and (equal (len abnf::csts) 1)
               (cst-matchp (nth 0 abnf::csts)
                           "class-instance-creation-expression"))))

Theorem: cst-switch-label-conc4-rep-matching

(defthm cst-switch-label-conc4-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "%s\"default\"")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "%s\"default\""))))

Theorem: cst-case-constant-conc-rep-matching

(defthm cst-case-constant-conc-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "conditional-expression")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "conditional-expression"))))

Theorem: cst-case-pattern-conc-rep-matching

(defthm cst-case-pattern-conc-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "pattern")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "pattern"))))

Theorem: cst-for-statement-conc1-rep-matching

(defthm cst-for-statement-conc1-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "basic-for-statement")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "basic-for-statement"))))

Theorem: cst-for-statement-conc2-rep-matching

(defthm cst-for-statement-conc2-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "enhanced-for-statement")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "enhanced-for-statement"))))

Theorem: cst-for-statement-no-short-if-conc1-rep-matching

(defthm cst-for-statement-no-short-if-conc1-rep-matching
  (implies (cst-list-rep-matchp abnf::csts
                                "basic-for-statement-no-short-if")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "basic-for-statement-no-short-if"))))

Theorem: cst-for-statement-no-short-if-conc2-rep-matching

(defthm cst-for-statement-no-short-if-conc2-rep-matching
 (implies (cst-list-rep-matchp abnf::csts
                               "enhanced-for-statement-no-short-if")
          (and (equal (len abnf::csts) 1)
               (cst-matchp (nth 0 abnf::csts)
                           "enhanced-for-statement-no-short-if"))))

Theorem: cst-for-init-conc1-rep-matching

(defthm cst-for-init-conc1-rep-matching
  (implies
       (cst-list-rep-matchp abnf::csts "statement-expression-list")
       (and (equal (len abnf::csts) 1)
            (cst-matchp (nth 0 abnf::csts)
                        "statement-expression-list"))))

Theorem: cst-for-init-conc2-rep-matching

(defthm cst-for-init-conc2-rep-matching
  (implies
       (cst-list-rep-matchp abnf::csts "local-variable-declaration")
       (and (equal (len abnf::csts) 1)
            (cst-matchp (nth 0 abnf::csts)
                        "local-variable-declaration"))))

Theorem: cst-for-update-conc-rep-matching

(defthm cst-for-update-conc-rep-matching
  (implies
       (cst-list-rep-matchp abnf::csts "statement-expression-list")
       (and (equal (len abnf::csts) 1)
            (cst-matchp (nth 0 abnf::csts)
                        "statement-expression-list"))))

Theorem: cst-try-statement-conc3-rep-matching

(defthm cst-try-statement-conc3-rep-matching
  (implies (cst-list-rep-matchp abnf::csts
                                "try-with-resources-statement")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "try-with-resources-statement"))))

Theorem: cst-resource-conc1-rep-matching

(defthm cst-resource-conc1-rep-matching
  (implies
       (cst-list-rep-matchp abnf::csts "local-variable-declaration")
       (and (equal (len abnf::csts) 1)
            (cst-matchp (nth 0 abnf::csts)
                        "local-variable-declaration"))))

Theorem: cst-resource-conc2-rep-matching

(defthm cst-resource-conc2-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "variable-access")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "variable-access"))))

Theorem: cst-variable-access-conc1-rep-matching

(defthm cst-variable-access-conc1-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "expression-name")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "expression-name"))))

Theorem: cst-variable-access-conc2-rep-matching

(defthm cst-variable-access-conc2-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "field-access")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "field-access"))))

Theorem: cst-pattern-conc1-rep-matching

(defthm cst-pattern-conc1-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "type-pattern")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "type-pattern"))))

Theorem: cst-pattern-conc2-rep-matching

(defthm cst-pattern-conc2-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "record-pattern")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "record-pattern"))))

Theorem: cst-type-pattern-conc-rep-matching

(defthm cst-type-pattern-conc-rep-matching
  (implies
       (cst-list-rep-matchp abnf::csts "local-variable-declaration")
       (and (equal (len abnf::csts) 1)
            (cst-matchp (nth 0 abnf::csts)
                        "local-variable-declaration"))))

Theorem: cst-component-pattern-conc1-rep-matching

(defthm cst-component-pattern-conc1-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "pattern")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "pattern"))))

Theorem: cst-component-pattern-conc2-rep-matching

(defthm cst-component-pattern-conc2-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "match-all-pattern")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "match-all-pattern"))))

Theorem: cst-match-all-pattern-conc-rep-matching

(defthm cst-match-all-pattern-conc-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "\"_\"")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts) "\"_\""))))

Theorem: cst-expression-conc1-rep-matching

(defthm cst-expression-conc1-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "lambda-expression")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "lambda-expression"))))

Theorem: cst-expression-conc2-rep-matching

(defthm cst-expression-conc2-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "assignment-expression")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "assignment-expression"))))

Theorem: cst-primary-conc1-rep-matching

(defthm cst-primary-conc1-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "primary-no-new-array")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "primary-no-new-array"))))

Theorem: cst-primary-conc2-rep-matching

(defthm cst-primary-conc2-rep-matching
  (implies
       (cst-list-rep-matchp abnf::csts "array-creation-expression")
       (and (equal (len abnf::csts) 1)
            (cst-matchp (nth 0 abnf::csts)
                        "array-creation-expression"))))

Theorem: cst-primary-no-new-array-conc1-rep-matching

(defthm cst-primary-no-new-array-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-no-new-array-conc2-rep-matching

(defthm cst-primary-no-new-array-conc2-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "class-literal")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "class-literal"))))

Theorem: cst-primary-no-new-array-conc3-rep-matching

(defthm cst-primary-no-new-array-conc3-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "%s\"this\"")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "%s\"this\""))))

Theorem: cst-primary-no-new-array-conc6-rep-matching

(defthm cst-primary-no-new-array-conc6-rep-matching
 (implies (cst-list-rep-matchp abnf::csts
                               "class-instance-creation-expression")
          (and (equal (len abnf::csts) 1)
               (cst-matchp (nth 0 abnf::csts)
                           "class-instance-creation-expression"))))

Theorem: cst-primary-no-new-array-conc7-rep-matching

(defthm cst-primary-no-new-array-conc7-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "field-access")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "field-access"))))

Theorem: cst-primary-no-new-array-conc8-rep-matching

(defthm cst-primary-no-new-array-conc8-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "array-access")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "array-access"))))

Theorem: cst-primary-no-new-array-conc9-rep-matching

(defthm cst-primary-no-new-array-conc9-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "method-invocation")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "method-invocation"))))

Theorem: cst-primary-no-new-array-conc10-rep-matching

(defthm cst-primary-no-new-array-conc10-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "method-reference")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "method-reference"))))

Theorem: cst-class-instance-creation-expression-conc1-rep-matching

(defthm cst-class-instance-creation-expression-conc1-rep-matching
 (implies
  (cst-list-rep-matchp
       abnf::csts
       "unqualified-class-instance-creation-expression")
  (and
    (equal (len abnf::csts) 1)
    (cst-matchp (nth 0 abnf::csts)
                "unqualified-class-instance-creation-expression"))))

Theorem: cst-type-arguments-or-diamond-conc1-rep-matching

(defthm cst-type-arguments-or-diamond-conc1-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "type-arguments")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "type-arguments"))))

Theorem: cst-type-arguments-or-diamond-conc2-rep-matching

(defthm cst-type-arguments-or-diamond-conc2-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "\"<>\"")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "\"<>\""))))

Theorem: cst-array-creation-expression-conc1-rep-matching

(defthm cst-array-creation-expression-conc1-rep-matching
 (implies
  (cst-list-rep-matchp
       abnf::csts
       "array-creation-expression-without-initializer")
  (and
     (equal (len abnf::csts) 1)
     (cst-matchp (nth 0 abnf::csts)
                 "array-creation-expression-without-initializer"))))

Theorem: cst-array-creation-expression-conc2-rep-matching

(defthm cst-array-creation-expression-conc2-rep-matching
 (implies
  (cst-list-rep-matchp abnf::csts
                       "array-creation-expression-with-initializer")
  (and (equal (len abnf::csts) 1)
       (cst-matchp (nth 0 abnf::csts)
                   "array-creation-expression-with-initializer"))))

Theorem: cst-postfix-expression-conc1-rep-matching

(defthm cst-postfix-expression-conc1-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "primary")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "primary"))))

Theorem: cst-postfix-expression-conc2-rep-matching

(defthm cst-postfix-expression-conc2-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "expression-name")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "expression-name"))))

Theorem: cst-postfix-expression-conc3-rep-matching

(defthm cst-postfix-expression-conc3-rep-matching
  (implies
       (cst-list-rep-matchp abnf::csts "post-increment-expression")
       (and (equal (len abnf::csts) 1)
            (cst-matchp (nth 0 abnf::csts)
                        "post-increment-expression"))))

Theorem: cst-postfix-expression-conc4-rep-matching

(defthm cst-postfix-expression-conc4-rep-matching
  (implies
       (cst-list-rep-matchp abnf::csts "post-decrement-expression")
       (and (equal (len abnf::csts) 1)
            (cst-matchp (nth 0 abnf::csts)
                        "post-decrement-expression"))))

Theorem: cst-unary-expression-conc1-rep-matching

(defthm cst-unary-expression-conc1-rep-matching
  (implies
       (cst-list-rep-matchp abnf::csts "pre-increment-expression")
       (and (equal (len abnf::csts) 1)
            (cst-matchp (nth 0 abnf::csts)
                        "pre-increment-expression"))))

Theorem: cst-unary-expression-conc2-rep-matching

(defthm cst-unary-expression-conc2-rep-matching
  (implies
       (cst-list-rep-matchp abnf::csts "pre-decrement-expression")
       (and (equal (len abnf::csts) 1)
            (cst-matchp (nth 0 abnf::csts)
                        "pre-decrement-expression"))))

Theorem: cst-unary-expression-conc5-rep-matching

(defthm cst-unary-expression-conc5-rep-matching
  (implies (cst-list-rep-matchp abnf::csts
                                "unary-expression-not-plus-minus")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "unary-expression-not-plus-minus"))))

Theorem: cst-unary-expression-not-plus-minus-conc1-rep-matching

(defthm cst-unary-expression-not-plus-minus-conc1-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "postfix-expression")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "postfix-expression"))))

Theorem: cst-unary-expression-not-plus-minus-conc4-rep-matching

(defthm cst-unary-expression-not-plus-minus-conc4-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-unary-expression-not-plus-minus-conc5-rep-matching

(defthm cst-unary-expression-not-plus-minus-conc5-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "switch-expression")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "switch-expression"))))

Theorem: cst-multiplicative-expression-conc1-rep-matching

(defthm cst-multiplicative-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-additive-expression-conc1-rep-matching

(defthm cst-additive-expression-conc1-rep-matching
  (implies
       (cst-list-rep-matchp abnf::csts "multiplicative-expression")
       (and (equal (len abnf::csts) 1)
            (cst-matchp (nth 0 abnf::csts)
                        "multiplicative-expression"))))

Theorem: cst-shift-expression-conc1-rep-matching

(defthm cst-shift-expression-conc1-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "additive-expression")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "additive-expression"))))

Theorem: cst-relational-expression-conc1-rep-matching

(defthm cst-relational-expression-conc1-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "shift-expression")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "shift-expression"))))

Theorem: cst-relational-expression-conc6-rep-matching

(defthm cst-relational-expression-conc6-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "instanceof-expression")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "instanceof-expression"))))

Theorem: cst-equality-expression-conc1-rep-matching

(defthm cst-equality-expression-conc1-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "relational-expression")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "relational-expression"))))

Theorem: cst-and-expression-conc1-rep-matching

(defthm cst-and-expression-conc1-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "equality-expression")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "equality-expression"))))

Theorem: cst-exclusive-or-expression-conc1-rep-matching

(defthm cst-exclusive-or-expression-conc1-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "and-expression")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "and-expression"))))

Theorem: cst-inclusive-or-expression-conc1-rep-matching

(defthm cst-inclusive-or-expression-conc1-rep-matching
 (implies (cst-list-rep-matchp abnf::csts "exclusive-or-expression")
          (and (equal (len abnf::csts) 1)
               (cst-matchp (nth 0 abnf::csts)
                           "exclusive-or-expression"))))

Theorem: cst-conditional-and-expression-conc1-rep-matching

(defthm cst-conditional-and-expression-conc1-rep-matching
 (implies (cst-list-rep-matchp abnf::csts "inclusive-or-expression")
          (and (equal (len abnf::csts) 1)
               (cst-matchp (nth 0 abnf::csts)
                           "inclusive-or-expression"))))

Theorem: cst-conditional-or-expression-conc1-rep-matching

(defthm cst-conditional-or-expression-conc1-rep-matching
  (implies
       (cst-list-rep-matchp abnf::csts "conditional-and-expression")
       (and (equal (len abnf::csts) 1)
            (cst-matchp (nth 0 abnf::csts)
                        "conditional-and-expression"))))

Theorem: cst-conditional-expression-conc1-rep-matching

(defthm cst-conditional-expression-conc1-rep-matching
  (implies
       (cst-list-rep-matchp abnf::csts "conditional-or-expression")
       (and (equal (len abnf::csts) 1)
            (cst-matchp (nth 0 abnf::csts)
                        "conditional-or-expression"))))

Theorem: cst-assignment-expression-conc1-rep-matching

(defthm cst-assignment-expression-conc1-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "conditional-expression")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "conditional-expression"))))

Theorem: cst-assignment-expression-conc2-rep-matching

(defthm cst-assignment-expression-conc2-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "assignment")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "assignment"))))

Theorem: cst-left-hand-side-conc1-rep-matching

(defthm cst-left-hand-side-conc1-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "expression-name")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "expression-name"))))

Theorem: cst-left-hand-side-conc2-rep-matching

(defthm cst-left-hand-side-conc2-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "field-access")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "field-access"))))

Theorem: cst-left-hand-side-conc3-rep-matching

(defthm cst-left-hand-side-conc3-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "array-access")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "array-access"))))

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-lambda-parameters-conc2-rep-matching

(defthm cst-lambda-parameters-conc2-rep-matching
  (implies
       (cst-list-rep-matchp abnf::csts "concise-lambda-parameter")
       (and (equal (len abnf::csts) 1)
            (cst-matchp (nth 0 abnf::csts)
                        "concise-lambda-parameter"))))

Theorem: cst-normal-lambda-parameter-conc2-rep-matching

(defthm cst-normal-lambda-parameter-conc2-rep-matching
  (implies
       (cst-list-rep-matchp abnf::csts "variable-arity-parameter")
       (and (equal (len abnf::csts) 1)
            (cst-matchp (nth 0 abnf::csts)
                        "variable-arity-parameter"))))

Theorem: cst-lambda-parameter-type-conc1-rep-matching

(defthm cst-lambda-parameter-type-conc1-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "unann-type")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "unann-type"))))

Theorem: cst-lambda-parameter-type-conc2-rep-matching

(defthm cst-lambda-parameter-type-conc2-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "%s\"var\"")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "%s\"var\""))))

Theorem: cst-concise-lambda-parameter-conc1-rep-matching

(defthm cst-concise-lambda-parameter-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-concise-lambda-parameter-conc2-rep-matching

(defthm cst-concise-lambda-parameter-conc2-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "\"_\"")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts) "\"_\""))))

Theorem: cst-lambda-body-conc1-rep-matching

(defthm cst-lambda-body-conc1-rep-matching
  (implies (cst-list-rep-matchp abnf::csts "expression")
           (and (equal (len abnf::csts) 1)
                (cst-matchp (nth 0 abnf::csts)
                            "expression"))))

Theorem: cst-lambda-body-conc2-rep-matching

(defthm cst-lambda-body-conc2-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-unicode-input-character-conc-equivs

(defthm cst-unicode-input-character-conc-equivs
 (implies
  (cst-matchp abnf::cst "unicode-input-character")
  (and
   (iff
     (cst-list-list-conc-matchp
          (abnf::tree-nonleaf->branches abnf::cst)
          "unicode-escape")
     (equal
          (abnf::tree-nonleaf->rulename?
               (nth 0
                    (nth 0
                         (abnf::tree-nonleaf->branches abnf::cst))))
          (abnf::rulename "unicode-escape")))
   (iff
     (cst-list-list-conc-matchp
          (abnf::tree-nonleaf->branches abnf::cst)
          "raw-input-character")
     (equal
          (abnf::tree-nonleaf->rulename?
               (nth 0
                    (nth 0
                         (abnf::tree-nonleaf->branches abnf::cst))))
          (abnf::rulename "raw-input-character"))))))

Theorem: cst-input-element-conc-equivs

(defthm cst-input-element-conc-equivs
 (implies
  (cst-matchp abnf::cst "input-element")
  (and
   (iff
     (cst-list-list-conc-matchp
          (abnf::tree-nonleaf->branches abnf::cst)
          "white-space")
     (equal
          (abnf::tree-nonleaf->rulename?
               (nth 0
                    (nth 0
                         (abnf::tree-nonleaf->branches abnf::cst))))
          (abnf::rulename "white-space")))
   (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)
          "token")
     (equal
          (abnf::tree-nonleaf->rulename?
               (nth 0
                    (nth 0
                         (abnf::tree-nonleaf->branches abnf::cst))))
          (abnf::rulename "token"))))))

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)
          "identifier")
     (equal
          (abnf::tree-nonleaf->rulename?
               (nth 0
                    (nth 0
                         (abnf::tree-nonleaf->branches abnf::cst))))
          (abnf::rulename "identifier")))
   (iff
     (cst-list-list-conc-matchp
          (abnf::tree-nonleaf->branches abnf::cst)
          "keyword")
     (equal
          (abnf::tree-nonleaf->rulename?
               (nth 0
                    (nth 0
                         (abnf::tree-nonleaf->branches abnf::cst))))
          (abnf::rulename "keyword")))
   (iff
     (cst-list-list-conc-matchp
          (abnf::tree-nonleaf->branches abnf::cst)
          "literal")
     (equal
          (abnf::tree-nonleaf->rulename?
               (nth 0
                    (nth 0
                         (abnf::tree-nonleaf->branches abnf::cst))))
          (abnf::rulename "literal")))
   (iff
     (cst-list-list-conc-matchp
          (abnf::tree-nonleaf->branches abnf::cst)
          "separator")
     (equal
          (abnf::tree-nonleaf->rulename?
               (nth 0
                    (nth 0
                         (abnf::tree-nonleaf->branches abnf::cst))))
          (abnf::rulename "separator")))
   (iff
     (cst-list-list-conc-matchp
          (abnf::tree-nonleaf->branches abnf::cst)
          "operator")
     (equal
          (abnf::tree-nonleaf->rulename?
               (nth 0
                    (nth 0
                         (abnf::tree-nonleaf->branches abnf::cst))))
          (abnf::rulename "operator"))))))

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)
          "traditional-comment")
     (equal
          (abnf::tree-nonleaf->rulename?
               (nth 0
                    (nth 0
                         (abnf::tree-nonleaf->branches abnf::cst))))
          (abnf::rulename "traditional-comment")))
   (iff
     (cst-list-list-conc-matchp
          (abnf::tree-nonleaf->branches abnf::cst)
          "end-of-line-comment")
     (equal
          (abnf::tree-nonleaf->rulename?
               (nth 0
                    (nth 0
                         (abnf::tree-nonleaf->branches abnf::cst))))
          (abnf::rulename "end-of-line-comment"))))))

Theorem: cst-not-star-conc-equivs

(defthm cst-not-star-conc-equivs
 (implies
  (cst-matchp abnf::cst "not-star")
  (and
   (iff
     (cst-list-list-conc-matchp
          (abnf::tree-nonleaf->branches abnf::cst)
          "input-character")
     (equal
          (abnf::tree-nonleaf->rulename?
               (nth 0
                    (nth 0
                         (abnf::tree-nonleaf->branches abnf::cst))))
          (abnf::rulename "input-character")))
   (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-not-star-not-slash-conc-equivs

(defthm cst-not-star-not-slash-conc-equivs
 (implies
  (cst-matchp abnf::cst "not-star-not-slash")
  (and
   (iff
     (cst-list-list-conc-matchp
          (abnf::tree-nonleaf->branches abnf::cst)
          "input-character")
     (equal
          (abnf::tree-nonleaf->rulename?
               (nth 0
                    (nth 0
                         (abnf::tree-nonleaf->branches abnf::cst))))
          (abnf::rulename "input-character")))
   (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-keyword-conc-equivs

(defthm cst-keyword-conc-equivs
 (implies
  (cst-matchp abnf::cst "keyword")
  (and
   (iff
     (cst-list-list-conc-matchp
          (abnf::tree-nonleaf->branches abnf::cst)
          "reserved-keyword")
     (equal
          (abnf::tree-nonleaf->rulename?
               (nth 0
                    (nth 0
                         (abnf::tree-nonleaf->branches abnf::cst))))
          (abnf::rulename "reserved-keyword")))
   (iff
     (cst-list-list-conc-matchp
          (abnf::tree-nonleaf->branches abnf::cst)
          "contextual-keyword")
     (equal
          (abnf::tree-nonleaf->rulename?
               (nth 0
                    (nth 0
                         (abnf::tree-nonleaf->branches abnf::cst))))
          (abnf::rulename "contextual-keyword"))))))

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)
          "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)
          "floating-point-literal")
     (equal
          (abnf::tree-nonleaf->rulename?
               (nth 0
                    (nth 0
                         (abnf::tree-nonleaf->branches abnf::cst))))
          (abnf::rulename "floating-point-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)
          "character-literal")
     (equal
          (abnf::tree-nonleaf->rulename?
               (nth 0
                    (nth 0
                         (abnf::tree-nonleaf->branches abnf::cst))))
          (abnf::rulename "character-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")))
   (iff
     (cst-list-list-conc-matchp
          (abnf::tree-nonleaf->branches abnf::cst)
          "text-block")
     (equal
          (abnf::tree-nonleaf->rulename?
               (nth 0
                    (nth 0
                         (abnf::tree-nonleaf->branches abnf::cst))))
          (abnf::rulename "text-block")))
   (iff
     (cst-list-list-conc-matchp
          (abnf::tree-nonleaf->branches abnf::cst)
          "null-literal")
     (equal
          (abnf::tree-nonleaf->rulename?
               (nth 0
                    (nth 0
                         (abnf::tree-nonleaf->branches abnf::cst))))
          (abnf::rulename "null-literal"))))))

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)
          "decimal-integer-literal")
     (equal
          (abnf::tree-nonleaf->rulename?
               (nth 0
                    (nth 0
                         (abnf::tree-nonleaf->branches abnf::cst))))
          (abnf::rulename "decimal-integer-literal")))
   (iff
     (cst-list-list-conc-matchp
          (abnf::tree-nonleaf->branches abnf::cst)
          "hex-integer-literal")
     (equal
          (abnf::tree-nonleaf->rulename?
               (nth 0
                    (nth 0
                         (abnf::tree-nonleaf->branches abnf::cst))))
          (abnf::rulename "hex-integer-literal")))
   (iff
     (cst-list-list-conc-matchp
          (abnf::tree-nonleaf->branches abnf::cst)
          "octal-integer-literal")
     (equal
          (abnf::tree-nonleaf->rulename?
               (nth 0
                    (nth 0
                         (abnf::tree-nonleaf->branches abnf::cst))))
          (abnf::rulename "octal-integer-literal")))
   (iff
     (cst-list-list-conc-matchp
          (abnf::tree-nonleaf->branches abnf::cst)
          "binary-integer-literal")
     (equal
          (abnf::tree-nonleaf->rulename?
               (nth 0
                    (nth 0
                         (abnf::tree-nonleaf->branches abnf::cst))))
          (abnf::rulename "binary-integer-literal"))))))

Theorem: cst-digit-conc-equivs

(defthm cst-digit-conc-equivs
 (implies
  (cst-matchp abnf::cst "digit")
  (and
      (iff (cst-list-list-conc-matchp
                (abnf::tree-nonleaf->branches abnf::cst)
                "\"0\"")
           (abnf::tree-case
                (nth 0
                     (nth 0
                          (abnf::tree-nonleaf->branches abnf::cst)))
                :leafterm))
      (iff (cst-list-list-conc-matchp
                (abnf::tree-nonleaf->branches abnf::cst)
                "non-zero-digit")
           (abnf::tree-case
                (nth 0
                     (nth 0
                          (abnf::tree-nonleaf->branches abnf::cst)))
                :nonleaf)))))

Theorem: cst-digit-or-underscore-conc-equivs

(defthm cst-digit-or-underscore-conc-equivs
 (implies
  (cst-matchp abnf::cst "digit-or-underscore")
  (and
      (iff (cst-list-list-conc-matchp
                (abnf::tree-nonleaf->branches abnf::cst)
                "digit")
           (abnf::tree-case
                (nth 0
                     (nth 0
                          (abnf::tree-nonleaf->branches abnf::cst)))
                :nonleaf))
      (iff (cst-list-list-conc-matchp
                (abnf::tree-nonleaf->branches abnf::cst)
                "\"_\"")
           (abnf::tree-case
                (nth 0
                     (nth 0
                          (abnf::tree-nonleaf->branches abnf::cst)))
                :leafterm)))))

Theorem: cst-hex-digit-or-underscore-conc-equivs

(defthm cst-hex-digit-or-underscore-conc-equivs
 (implies
  (cst-matchp abnf::cst "hex-digit-or-underscore")
  (and
      (iff (cst-list-list-conc-matchp
                (abnf::tree-nonleaf->branches abnf::cst)
                "hex-digit")
           (abnf::tree-case
                (nth 0
                     (nth 0
                          (abnf::tree-nonleaf->branches abnf::cst)))
                :nonleaf))
      (iff (cst-list-list-conc-matchp
                (abnf::tree-nonleaf->branches abnf::cst)
                "\"_\"")
           (abnf::tree-case
                (nth 0
                     (nth 0
                          (abnf::tree-nonleaf->branches abnf::cst)))
                :leafterm)))))

Theorem: cst-octal-digit-or-underscore-conc-equivs

(defthm cst-octal-digit-or-underscore-conc-equivs
 (implies
  (cst-matchp abnf::cst "octal-digit-or-underscore")
  (and
      (iff (cst-list-list-conc-matchp
                (abnf::tree-nonleaf->branches abnf::cst)
                "octal-digit")
           (abnf::tree-case
                (nth 0
                     (nth 0
                          (abnf::tree-nonleaf->branches abnf::cst)))
                :nonleaf))
      (iff (cst-list-list-conc-matchp
                (abnf::tree-nonleaf->branches abnf::cst)
                "\"_\"")
           (abnf::tree-case
                (nth 0
                     (nth 0
                          (abnf::tree-nonleaf->branches abnf::cst)))
                :leafterm)))))

Theorem: cst-binary-digit-or-underscore-conc-equivs

(defthm cst-binary-digit-or-underscore-conc-equivs
 (implies
  (cst-matchp abnf::cst "binary-digit-or-underscore")
  (and
      (iff (cst-list-list-conc-matchp
                (abnf::tree-nonleaf->branches abnf::cst)
                "binary-digit")
           (abnf::tree-case
                (nth 0
                     (nth 0
                          (abnf::tree-nonleaf->branches abnf::cst)))
                :nonleaf))
      (iff (cst-list-list-conc-matchp
                (abnf::tree-nonleaf->branches abnf::cst)
                "\"_\"")
           (abnf::tree-case
                (nth 0
                     (nth 0
                          (abnf::tree-nonleaf->branches abnf::cst)))
                :leafterm)))))

Theorem: cst-floating-point-literal-conc-equivs

(defthm cst-floating-point-literal-conc-equivs
 (implies
  (cst-matchp abnf::cst "floating-point-literal")
  (and
   (iff
     (cst-list-list-conc-matchp
          (abnf::tree-nonleaf->branches abnf::cst)
          "decimal-floating-point-literal")
     (equal
          (abnf::tree-nonleaf->rulename?
               (nth 0
                    (nth 0
                         (abnf::tree-nonleaf->branches abnf::cst))))
          (abnf::rulename "decimal-floating-point-literal")))
   (iff
     (cst-list-list-conc-matchp
          (abnf::tree-nonleaf->branches abnf::cst)
          "hexadecimal-floating-point-literal")
     (equal
          (abnf::tree-nonleaf->rulename?
               (nth 0
                    (nth 0
                         (abnf::tree-nonleaf->branches abnf::cst))))
          (abnf::rulename "hexadecimal-floating-point-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)
          "input-character")
     (equal
          (abnf::tree-nonleaf->rulename?
               (nth 0
                    (nth 0
                         (abnf::tree-nonleaf->branches abnf::cst))))
          (abnf::rulename "input-character")))
   (iff
     (cst-list-list-conc-matchp
          (abnf::tree-nonleaf->branches abnf::cst)
          "escape-sequence")
     (equal
          (abnf::tree-nonleaf->rulename?
               (nth 0
                    (nth 0
                         (abnf::tree-nonleaf->branches abnf::cst))))
          (abnf::rulename "escape-sequence"))))))

Theorem: cst-text-block-character-conc-equivs

(defthm cst-text-block-character-conc-equivs
 (implies
  (cst-matchp abnf::cst "text-block-character")
  (and
   (iff
     (cst-list-list-conc-matchp
          (abnf::tree-nonleaf->branches abnf::cst)
          "input-character")
     (equal
          (abnf::tree-nonleaf->rulename?
               (nth 0
                    (nth 0
                         (abnf::tree-nonleaf->branches abnf::cst))))
          (abnf::rulename "input-character")))
   (iff
     (cst-list-list-conc-matchp
          (abnf::tree-nonleaf->branches abnf::cst)
          "escape-sequence")
     (equal
          (abnf::tree-nonleaf->rulename?
               (nth 0
                    (nth 0
                         (abnf::tree-nonleaf->branches abnf::cst))))
          (abnf::rulename "escape-sequence")))
   (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-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)
          "reference-type")
     (equal
          (abnf::tree-nonleaf->rulename?
               (nth 0
                    (nth 0
                         (abnf::tree-nonleaf->branches abnf::cst))))
          (abnf::rulename "reference-type"))))))

Theorem: cst-numeric-type-conc-equivs

(defthm cst-numeric-type-conc-equivs
 (implies
  (cst-matchp abnf::cst "numeric-type")
  (and
   (iff
     (cst-list-list-conc-matchp
          (abnf::tree-nonleaf->branches abnf::cst)
          "integral-type")
     (equal
          (abnf::tree-nonleaf->rulename?
               (nth 0
                    (nth 0
                         (abnf::tree-nonleaf->branches abnf::cst))))
          (abnf::rulename "integral-type")))
   (iff
     (cst-list-list-conc-matchp
          (abnf::tree-nonleaf->branches abnf::cst)
          "floating-point-type")
     (equal
          (abnf::tree-nonleaf->rulename?
               (nth 0
                    (nth 0
                         (abnf::tree-nonleaf->branches abnf::cst))))
          (abnf::rulename "floating-point-type"))))))

Theorem: cst-reference-type-conc-equivs

(defthm cst-reference-type-conc-equivs
 (implies
  (cst-matchp abnf::cst "reference-type")
  (and
   (iff
     (cst-list-list-conc-matchp
          (abnf::tree-nonleaf->branches abnf::cst)
          "class-or-interface-type")
     (equal
          (abnf::tree-nonleaf->rulename?
               (nth 0
                    (nth 0
                         (abnf::tree-nonleaf->branches abnf::cst))))
          (abnf::rulename "class-or-interface-type")))
   (iff
     (cst-list-list-conc-matchp
          (abnf::tree-nonleaf->branches abnf::cst)
          "type-variable")
     (equal
          (abnf::tree-nonleaf->rulename?
               (nth 0
                    (nth 0
                         (abnf::tree-nonleaf->branches abnf::cst))))
          (abnf::rulename "type-variable")))
   (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-class-or-interface-type-conc-equivs

(defthm cst-class-or-interface-type-conc-equivs
 (implies
  (cst-matchp abnf::cst "class-or-interface-type")
  (and
   (iff
     (cst-list-list-conc-matchp
          (abnf::tree-nonleaf->branches abnf::cst)
          "class-type")
     (equal
          (abnf::tree-nonleaf->rulename?
               (nth 0
                    (nth 0
                         (abnf::tree-nonleaf->branches abnf::cst))))
          (abnf::rulename "class-type")))
   (iff
     (cst-list-list-conc-matchp
          (abnf::tree-nonleaf->branches abnf::cst)
          "interface-type")
     (equal
          (abnf::tree-nonleaf->rulename?
               (nth 0
                    (nth 0
                         (abnf::tree-nonleaf->branches abnf::cst))))
          (abnf::rulename "interface-type"))))))

Theorem: cst-type-argument-conc-equivs

(defthm cst-type-argument-conc-equivs
 (implies
  (cst-matchp abnf::cst "type-argument")
  (and
   (iff
     (cst-list-list-conc-matchp
          (abnf::tree-nonleaf->branches abnf::cst)
          "reference-type")
     (equal
          (abnf::tree-nonleaf->rulename?
               (nth 0
                    (nth 0
                         (abnf::tree-nonleaf->branches abnf::cst))))
          (abnf::rulename "reference-type")))
   (iff
     (cst-list-list-conc-matchp
          (abnf::tree-nonleaf->branches abnf::cst)
          "wildcard")
     (equal
          (abnf::tree-nonleaf->rulename?
               (nth 0
                    (nth 0
                         (abnf::tree-nonleaf->branches abnf::cst))))
          (abnf::rulename "wildcard"))))))

Theorem: cst-compilation-unit-conc-equivs

(defthm cst-compilation-unit-conc-equivs
 (implies
  (cst-matchp abnf::cst "compilation-unit")
  (and
   (iff
     (cst-list-list-conc-matchp
          (abnf::tree-nonleaf->branches abnf::cst)
          "ordinary-compilation-unit")
     (equal
          (abnf::tree-nonleaf->rulename?
               (nth 0
                    (nth 0
                         (abnf::tree-nonleaf->branches abnf::cst))))
          (abnf::rulename "ordinary-compilation-unit")))
   (iff
     (cst-list-list-conc-matchp
          (abnf::tree-nonleaf->branches abnf::cst)
          "compact-compilation-unit")
     (equal
          (abnf::tree-nonleaf->rulename?
               (nth 0
                    (nth 0
                         (abnf::tree-nonleaf->branches abnf::cst))))
          (abnf::rulename "compact-compilation-unit")))
   (iff
     (cst-list-list-conc-matchp
          (abnf::tree-nonleaf->branches abnf::cst)
          "modular-compilation-unit")
     (equal
          (abnf::tree-nonleaf->rulename?
               (nth 0
                    (nth 0
                         (abnf::tree-nonleaf->branches abnf::cst))))
          (abnf::rulename "modular-compilation-unit"))))))

Theorem: cst-import-declaration-conc-equivs

(defthm cst-import-declaration-conc-equivs
 (implies
  (cst-matchp abnf::cst "import-declaration")
  (and
   (iff
     (cst-list-list-conc-matchp
          (abnf::tree-nonleaf->branches abnf::cst)
          "single-type-import-declaration")
     (equal
          (abnf::tree-nonleaf->rulename?
               (nth 0
                    (nth 0
                         (abnf::tree-nonleaf->branches abnf::cst))))
          (abnf::rulename "single-type-import-declaration")))
   (iff
     (cst-list-list-conc-matchp
          (abnf::tree-nonleaf->branches abnf::cst)
          "type-import-on-demand-declaration")
     (equal
          (abnf::tree-nonleaf->rulename?
               (nth 0
                    (nth 0
                         (abnf::tree-nonleaf->branches abnf::cst))))
          (abnf::rulename "type-import-on-demand-declaration")))
   (iff
     (cst-list-list-conc-matchp
          (abnf::tree-nonleaf->branches abnf::cst)
          "single-static-import-declaration")
     (equal
          (abnf::tree-nonleaf->rulename?
               (nth 0
                    (nth 0
                         (abnf::tree-nonleaf->branches abnf::cst))))
          (abnf::rulename "single-static-import-declaration")))
   (iff
     (cst-list-list-conc-matchp
          (abnf::tree-nonleaf->branches abnf::cst)
          "static-import-on-demand-declaration")
     (equal
          (abnf::tree-nonleaf->rulename?
               (nth 0
                    (nth 0
                         (abnf::tree-nonleaf->branches abnf::cst))))
          (abnf::rulename "static-import-on-demand-declaration")))
   (iff
     (cst-list-list-conc-matchp
          (abnf::tree-nonleaf->branches abnf::cst)
          "single-module-import-declaration")
     (equal
          (abnf::tree-nonleaf->rulename?
               (nth 0
                    (nth 0
                         (abnf::tree-nonleaf->branches abnf::cst))))
          (abnf::rulename "single-module-import-declaration"))))))

Theorem: cst-class-declaration-conc-equivs

(defthm cst-class-declaration-conc-equivs
 (implies
  (cst-matchp abnf::cst "class-declaration")
  (and
   (iff
     (cst-list-list-conc-matchp
          (abnf::tree-nonleaf->branches abnf::cst)
          "normal-class-declaration")
     (equal
          (abnf::tree-nonleaf->rulename?
               (nth 0
                    (nth 0
                         (abnf::tree-nonleaf->branches abnf::cst))))
          (abnf::rulename "normal-class-declaration")))
   (iff
     (cst-list-list-conc-matchp
          (abnf::tree-nonleaf->branches abnf::cst)
          "enum-declaration")
     (equal
          (abnf::tree-nonleaf->rulename?
               (nth 0
                    (nth 0
                         (abnf::tree-nonleaf->branches abnf::cst))))
          (abnf::rulename "enum-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"))))))

Theorem: cst-class-body-declaration-conc-equivs

(defthm cst-class-body-declaration-conc-equivs
 (implies
  (cst-matchp abnf::cst "class-body-declaration")
  (and
   (iff
     (cst-list-list-conc-matchp
          (abnf::tree-nonleaf->branches abnf::cst)
          "class-member-declaration")
     (equal
          (abnf::tree-nonleaf->rulename?
               (nth 0
                    (nth 0
                         (abnf::tree-nonleaf->branches abnf::cst))))
          (abnf::rulename "class-member-declaration")))
   (iff
     (cst-list-list-conc-matchp
          (abnf::tree-nonleaf->branches abnf::cst)
          "instance-initializer")
     (equal
          (abnf::tree-nonleaf->rulename?
               (nth 0
                    (nth 0
                         (abnf::tree-nonleaf->branches abnf::cst))))
          (abnf::rulename "instance-initializer")))
   (iff
     (cst-list-list-conc-matchp
          (abnf::tree-nonleaf->branches abnf::cst)
          "static-initializer")
     (equal
          (abnf::tree-nonleaf->rulename?
               (nth 0
                    (nth 0
                         (abnf::tree-nonleaf->branches abnf::cst))))
          (abnf::rulename "static-initializer")))
   (iff
     (cst-list-list-conc-matchp
          (abnf::tree-nonleaf->branches abnf::cst)
          "constructor-declaration")
     (equal
          (abnf::tree-nonleaf->rulename?
               (nth 0
                    (nth 0
                         (abnf::tree-nonleaf->branches abnf::cst))))
          (abnf::rulename "constructor-declaration"))))))

Theorem: cst-variable-initializer-conc-equivs

(defthm cst-variable-initializer-conc-equivs
 (implies
  (cst-matchp abnf::cst "variable-initializer")
  (and
   (iff
     (cst-list-list-conc-matchp
          (abnf::tree-nonleaf->branches abnf::cst)
          "expression")
     (equal
          (abnf::tree-nonleaf->rulename?
               (nth 0
                    (nth 0
                         (abnf::tree-nonleaf->branches abnf::cst))))
          (abnf::rulename "expression")))
   (iff
     (cst-list-list-conc-matchp
          (abnf::tree-nonleaf->branches abnf::cst)
          "array-initializer")
     (equal
          (abnf::tree-nonleaf->rulename?
               (nth 0
                    (nth 0
                         (abnf::tree-nonleaf->branches abnf::cst))))
          (abnf::rulename "array-initializer"))))))

Theorem: cst-unann-type-conc-equivs

(defthm cst-unann-type-conc-equivs
 (implies
  (cst-matchp abnf::cst "unann-type")
  (and
   (iff
     (cst-list-list-conc-matchp
          (abnf::tree-nonleaf->branches abnf::cst)
          "unann-primitive-type")
     (equal
          (abnf::tree-nonleaf->rulename?
               (nth 0
                    (nth 0
                         (abnf::tree-nonleaf->branches abnf::cst))))
          (abnf::rulename "unann-primitive-type")))
   (iff
     (cst-list-list-conc-matchp
          (abnf::tree-nonleaf->branches abnf::cst)
          "unann-reference-type")
     (equal
          (abnf::tree-nonleaf->rulename?
               (nth 0
                    (nth 0
                         (abnf::tree-nonleaf->branches abnf::cst))))
          (abnf::rulename "unann-reference-type"))))))

Theorem: cst-unann-primitive-type-conc-equivs

(defthm cst-unann-primitive-type-conc-equivs
 (implies
  (cst-matchp abnf::cst "unann-primitive-type")
  (and
      (iff (cst-list-list-conc-matchp
                (abnf::tree-nonleaf->branches abnf::cst)
                "numeric-type")
           (abnf::tree-case
                (nth 0
                     (nth 0
                          (abnf::tree-nonleaf->branches abnf::cst)))
                :nonleaf))
      (iff (cst-list-list-conc-matchp
                (abnf::tree-nonleaf->branches abnf::cst)
                "%s\"boolean\"")
           (abnf::tree-case
                (nth 0
                     (nth 0
                          (abnf::tree-nonleaf->branches abnf::cst)))
                :leafterm)))))

Theorem: cst-unann-reference-type-conc-equivs

(defthm cst-unann-reference-type-conc-equivs
 (implies
  (cst-matchp abnf::cst "unann-reference-type")
  (and
   (iff
     (cst-list-list-conc-matchp
          (abnf::tree-nonleaf->branches abnf::cst)
          "unann-class-or-interface-type")
     (equal
          (abnf::tree-nonleaf->rulename?
               (nth 0
                    (nth 0
                         (abnf::tree-nonleaf->branches abnf::cst))))
          (abnf::rulename "unann-class-or-interface-type")))
   (iff
     (cst-list-list-conc-matchp
          (abnf::tree-nonleaf->branches abnf::cst)
          "unann-type-variable")
     (equal
          (abnf::tree-nonleaf->rulename?
               (nth 0
                    (nth 0
                         (abnf::tree-nonleaf->branches abnf::cst))))
          (abnf::rulename "unann-type-variable")))
   (iff
     (cst-list-list-conc-matchp
          (abnf::tree-nonleaf->branches abnf::cst)
          "unann-array-type")
     (equal
          (abnf::tree-nonleaf->rulename?
               (nth 0
                    (nth 0
                         (abnf::tree-nonleaf->branches abnf::cst))))
          (abnf::rulename "unann-array-type"))))))

Theorem: cst-unann-class-or-interface-type-conc-equivs

(defthm cst-unann-class-or-interface-type-conc-equivs
 (implies
  (cst-matchp abnf::cst
              "unann-class-or-interface-type")
  (and
   (iff
     (cst-list-list-conc-matchp
          (abnf::tree-nonleaf->branches abnf::cst)
          "unann-class-type")
     (equal
          (abnf::tree-nonleaf->rulename?
               (nth 0
                    (nth 0
                         (abnf::tree-nonleaf->branches abnf::cst))))
          (abnf::rulename "unann-class-type")))
   (iff
     (cst-list-list-conc-matchp
          (abnf::tree-nonleaf->branches abnf::cst)
          "unann-interface-type")
     (equal
          (abnf::tree-nonleaf->rulename?
               (nth 0
                    (nth 0
                         (abnf::tree-nonleaf->branches abnf::cst))))
          (abnf::rulename "unann-interface-type"))))))

Theorem: cst-variable-modifier-conc-equivs

(defthm cst-variable-modifier-conc-equivs
 (implies
  (cst-matchp abnf::cst "variable-modifier")
  (and
      (iff (cst-list-list-conc-matchp
                (abnf::tree-nonleaf->branches abnf::cst)
                "annotation")
           (abnf::tree-case
                (nth 0
                     (nth 0
                          (abnf::tree-nonleaf->branches abnf::cst)))
                :nonleaf))
      (iff (cst-list-list-conc-matchp
                (abnf::tree-nonleaf->branches abnf::cst)
                "%s\"final\"")
           (abnf::tree-case
                (nth 0
                     (nth 0
                          (abnf::tree-nonleaf->branches abnf::cst)))
                :leafterm)))))

Theorem: cst-result-conc-equivs

(defthm cst-result-conc-equivs
 (implies
  (cst-matchp abnf::cst "result")
  (and
      (iff (cst-list-list-conc-matchp
                (abnf::tree-nonleaf->branches abnf::cst)
                "unann-type")
           (abnf::tree-case
                (nth 0
                     (nth 0
                          (abnf::tree-nonleaf->branches abnf::cst)))
                :nonleaf))
      (iff (cst-list-list-conc-matchp
                (abnf::tree-nonleaf->branches abnf::cst)
                "%s\"void\"")
           (abnf::tree-case
                (nth 0
                     (nth 0
                          (abnf::tree-nonleaf->branches abnf::cst)))
                :leafterm)))))

Theorem: cst-exception-type-conc-equivs

(defthm cst-exception-type-conc-equivs
 (implies
  (cst-matchp abnf::cst "exception-type")
  (and
   (iff
     (cst-list-list-conc-matchp
          (abnf::tree-nonleaf->branches abnf::cst)
          "class-type")
     (equal
          (abnf::tree-nonleaf->rulename?
               (nth 0
                    (nth 0
                         (abnf::tree-nonleaf->branches abnf::cst))))
          (abnf::rulename "class-type")))
   (iff
     (cst-list-list-conc-matchp
          (abnf::tree-nonleaf->branches abnf::cst)
          "type-variable")
     (equal
          (abnf::tree-nonleaf->rulename?
               (nth 0
                    (nth 0
                         (abnf::tree-nonleaf->branches abnf::cst))))
          (abnf::rulename "type-variable"))))))

Theorem: cst-method-body-conc-equivs

(defthm cst-method-body-conc-equivs
 (implies
  (cst-matchp abnf::cst "method-body")
  (and
      (iff (cst-list-list-conc-matchp
                (abnf::tree-nonleaf->branches abnf::cst)
                "block")
           (abnf::tree-case
                (nth 0
                     (nth 0
                          (abnf::tree-nonleaf->branches abnf::cst)))
                :nonleaf))
      (iff (cst-list-list-conc-matchp
                (abnf::tree-nonleaf->branches abnf::cst)
                "\";\"")
           (abnf::tree-case
                (nth 0
                     (nth 0
                          (abnf::tree-nonleaf->branches abnf::cst)))
                :leafterm)))))

Theorem: cst-record-body-declaration-conc-equivs

(defthm cst-record-body-declaration-conc-equivs
 (implies
  (cst-matchp abnf::cst "record-body-declaration")
  (and
   (iff
     (cst-list-list-conc-matchp
          (abnf::tree-nonleaf->branches abnf::cst)
          "class-body-declaration")
     (equal
          (abnf::tree-nonleaf->rulename?
               (nth 0
                    (nth 0
                         (abnf::tree-nonleaf->branches abnf::cst))))
          (abnf::rulename "class-body-declaration")))
   (iff
     (cst-list-list-conc-matchp
          (abnf::tree-nonleaf->branches abnf::cst)
          "compact-constructor-declaration")
     (equal
          (abnf::tree-nonleaf->rulename?
               (nth 0
                    (nth 0
                         (abnf::tree-nonleaf->branches abnf::cst))))
          (abnf::rulename "compact-constructor-declaration"))))))

Theorem: cst-interface-declaration-conc-equivs

(defthm cst-interface-declaration-conc-equivs
 (implies
  (cst-matchp abnf::cst "interface-declaration")
  (and
   (iff
     (cst-list-list-conc-matchp
          (abnf::tree-nonleaf->branches abnf::cst)
          "normal-interface-declaration")
     (equal
          (abnf::tree-nonleaf->rulename?
               (nth 0
                    (nth 0
                         (abnf::tree-nonleaf->branches abnf::cst))))
          (abnf::rulename "normal-interface-declaration")))
   (iff
     (cst-list-list-conc-matchp
          (abnf::tree-nonleaf->branches abnf::cst)
          "annotation-interface-declaration")
     (equal
          (abnf::tree-nonleaf->rulename?
               (nth 0
                    (nth 0
                         (abnf::tree-nonleaf->branches abnf::cst))))
          (abnf::rulename "annotation-interface-declaration"))))))

Theorem: cst-annotation-conc-equivs

(defthm cst-annotation-conc-equivs
 (implies
  (cst-matchp abnf::cst "annotation")
  (and
   (iff
     (cst-list-list-conc-matchp
          (abnf::tree-nonleaf->branches abnf::cst)
          "normal-annotation")
     (equal
          (abnf::tree-nonleaf->rulename?
               (nth 0
                    (nth 0
                         (abnf::tree-nonleaf->branches abnf::cst))))
          (abnf::rulename "normal-annotation")))
   (iff
     (cst-list-list-conc-matchp
          (abnf::tree-nonleaf->branches abnf::cst)
          "marker-annotation")
     (equal
          (abnf::tree-nonleaf->rulename?
               (nth 0
                    (nth 0
                         (abnf::tree-nonleaf->branches abnf::cst))))
          (abnf::rulename "marker-annotation")))
   (iff
     (cst-list-list-conc-matchp
          (abnf::tree-nonleaf->branches abnf::cst)
          "single-element-annotation")
     (equal
          (abnf::tree-nonleaf->rulename?
               (nth 0
                    (nth 0
                         (abnf::tree-nonleaf->branches abnf::cst))))
          (abnf::rulename "single-element-annotation"))))))

Theorem: cst-element-value-conc-equivs

(defthm cst-element-value-conc-equivs
 (implies
  (cst-matchp abnf::cst "element-value")
  (and
   (iff
     (cst-list-list-conc-matchp
          (abnf::tree-nonleaf->branches abnf::cst)
          "conditional-expression")
     (equal
          (abnf::tree-nonleaf->rulename?
               (nth 0
                    (nth 0
                         (abnf::tree-nonleaf->branches abnf::cst))))
          (abnf::rulename "conditional-expression")))
   (iff
     (cst-list-list-conc-matchp
          (abnf::tree-nonleaf->branches abnf::cst)
          "element-value-array-initializer")
     (equal
          (abnf::tree-nonleaf->rulename?
               (nth 0
                    (nth 0
                         (abnf::tree-nonleaf->branches abnf::cst))))
          (abnf::rulename "element-value-array-initializer")))
   (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"))))))

Theorem: cst-block-statement-conc-equivs

(defthm cst-block-statement-conc-equivs
 (implies
  (cst-matchp abnf::cst "block-statement")
  (and
   (iff
     (cst-list-list-conc-matchp
          (abnf::tree-nonleaf->branches abnf::cst)
          "local-class-or-interface-declaration")
     (equal
          (abnf::tree-nonleaf->rulename?
               (nth 0
                    (nth 0
                         (abnf::tree-nonleaf->branches abnf::cst))))
          (abnf::rulename "local-class-or-interface-declaration")))
   (iff
     (cst-list-list-conc-matchp
          (abnf::tree-nonleaf->branches abnf::cst)
          "local-variable-declaration-statement")
     (equal
          (abnf::tree-nonleaf->rulename?
               (nth 0
                    (nth 0
                         (abnf::tree-nonleaf->branches abnf::cst))))
          (abnf::rulename "local-variable-declaration-statement")))
   (iff
     (cst-list-list-conc-matchp
          (abnf::tree-nonleaf->branches abnf::cst)
          "statement")
     (equal
          (abnf::tree-nonleaf->rulename?
               (nth 0
                    (nth 0
                         (abnf::tree-nonleaf->branches abnf::cst))))
          (abnf::rulename "statement"))))))

Theorem: cst-local-class-or-interface-declaration-conc-equivs

(defthm cst-local-class-or-interface-declaration-conc-equivs
 (implies
  (cst-matchp abnf::cst
              "local-class-or-interface-declaration")
  (and
   (iff
     (cst-list-list-conc-matchp
          (abnf::tree-nonleaf->branches abnf::cst)
          "class-declaration")
     (equal
          (abnf::tree-nonleaf->rulename?
               (nth 0
                    (nth 0
                         (abnf::tree-nonleaf->branches abnf::cst))))
          (abnf::rulename "class-declaration")))
   (iff
     (cst-list-list-conc-matchp
          (abnf::tree-nonleaf->branches abnf::cst)
          "normal-interface-declaration")
     (equal
          (abnf::tree-nonleaf->rulename?
               (nth 0
                    (nth 0
                         (abnf::tree-nonleaf->branches abnf::cst))))
          (abnf::rulename "normal-interface-declaration"))))))

Theorem: cst-local-variable-type-conc-equivs

(defthm cst-local-variable-type-conc-equivs
 (implies
  (cst-matchp abnf::cst "local-variable-type")
  (and
      (iff (cst-list-list-conc-matchp
                (abnf::tree-nonleaf->branches abnf::cst)
                "unann-type")
           (abnf::tree-case
                (nth 0
                     (nth 0
                          (abnf::tree-nonleaf->branches abnf::cst)))
                :nonleaf))
      (iff (cst-list-list-conc-matchp
                (abnf::tree-nonleaf->branches abnf::cst)
                "%s\"var\"")
           (abnf::tree-case
                (nth 0
                     (nth 0
                          (abnf::tree-nonleaf->branches abnf::cst)))
                :leafterm)))))

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)
         "statement-without-trailing-substatement")
    (equal
        (abnf::tree-nonleaf->rulename?
             (nth 0
                  (nth 0
                       (abnf::tree-nonleaf->branches abnf::cst))))
        (abnf::rulename "statement-without-trailing-substatement")))
   (iff
     (cst-list-list-conc-matchp
          (abnf::tree-nonleaf->branches abnf::cst)
          "labeled-statement")
     (equal
          (abnf::tree-nonleaf->rulename?
               (nth 0
                    (nth 0
                         (abnf::tree-nonleaf->branches abnf::cst))))
          (abnf::rulename "labeled-statement")))
   (iff
     (cst-list-list-conc-matchp
          (abnf::tree-nonleaf->branches abnf::cst)
          "if-then-statement")
     (equal
          (abnf::tree-nonleaf->rulename?
               (nth 0
                    (nth 0
                         (abnf::tree-nonleaf->branches abnf::cst))))
          (abnf::rulename "if-then-statement")))
   (iff
     (cst-list-list-conc-matchp
          (abnf::tree-nonleaf->branches abnf::cst)
          "if-then-else-statement")
     (equal
          (abnf::tree-nonleaf->rulename?
               (nth 0
                    (nth 0
                         (abnf::tree-nonleaf->branches abnf::cst))))
          (abnf::rulename "if-then-else-statement")))
   (iff
     (cst-list-list-conc-matchp
          (abnf::tree-nonleaf->branches abnf::cst)
          "while-statement")
     (equal
          (abnf::tree-nonleaf->rulename?
               (nth 0
                    (nth 0
                         (abnf::tree-nonleaf->branches abnf::cst))))
          (abnf::rulename "while-statement")))
   (iff
     (cst-list-list-conc-matchp
          (abnf::tree-nonleaf->branches abnf::cst)
          "for-statement")
     (equal
          (abnf::tree-nonleaf->rulename?
               (nth 0
                    (nth 0
                         (abnf::tree-nonleaf->branches abnf::cst))))
          (abnf::rulename "for-statement"))))))

Theorem: cst-statement-no-short-if-conc-equivs

(defthm cst-statement-no-short-if-conc-equivs
 (implies
  (cst-matchp abnf::cst "statement-no-short-if")
  (and
   (iff
    (cst-list-list-conc-matchp
         (abnf::tree-nonleaf->branches abnf::cst)
         "statement-without-trailing-substatement")
    (equal
        (abnf::tree-nonleaf->rulename?
             (nth 0
                  (nth 0
                       (abnf::tree-nonleaf->branches abnf::cst))))
        (abnf::rulename "statement-without-trailing-substatement")))
   (iff
     (cst-list-list-conc-matchp
          (abnf::tree-nonleaf->branches abnf::cst)
          "labeled-statement-no-short-if")
     (equal
          (abnf::tree-nonleaf->rulename?
               (nth 0
                    (nth 0
                         (abnf::tree-nonleaf->branches abnf::cst))))
          (abnf::rulename "labeled-statement-no-short-if")))
   (iff
     (cst-list-list-conc-matchp
          (abnf::tree-nonleaf->branches abnf::cst)
          "if-then-else-statement-no-short-if")
     (equal
          (abnf::tree-nonleaf->rulename?
               (nth 0
                    (nth 0
                         (abnf::tree-nonleaf->branches abnf::cst))))
          (abnf::rulename "if-then-else-statement-no-short-if")))
   (iff
     (cst-list-list-conc-matchp
          (abnf::tree-nonleaf->branches abnf::cst)
          "while-statement-no-short-if")
     (equal
          (abnf::tree-nonleaf->rulename?
               (nth 0
                    (nth 0
                         (abnf::tree-nonleaf->branches abnf::cst))))
          (abnf::rulename "while-statement-no-short-if")))
   (iff
     (cst-list-list-conc-matchp
          (abnf::tree-nonleaf->branches abnf::cst)
          "for-statement-no-short-if")
     (equal
          (abnf::tree-nonleaf->rulename?
               (nth 0
                    (nth 0
                         (abnf::tree-nonleaf->branches abnf::cst))))
          (abnf::rulename "for-statement-no-short-if"))))))

Theorem: cst-statement-without-trailing-substatement-conc-equivs

(defthm cst-statement-without-trailing-substatement-conc-equivs
 (implies
  (cst-matchp abnf::cst
              "statement-without-trailing-substatement")
  (and
   (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")))
   (iff
     (cst-list-list-conc-matchp
          (abnf::tree-nonleaf->branches abnf::cst)
          "empty-statement")
     (equal
          (abnf::tree-nonleaf->rulename?
               (nth 0
                    (nth 0
                         (abnf::tree-nonleaf->branches abnf::cst))))
          (abnf::rulename "empty-statement")))
   (iff
     (cst-list-list-conc-matchp
          (abnf::tree-nonleaf->branches abnf::cst)
          "expression-statement")
     (equal
          (abnf::tree-nonleaf->rulename?
               (nth 0
                    (nth 0
                         (abnf::tree-nonleaf->branches abnf::cst))))
          (abnf::rulename "expression-statement")))
   (iff
     (cst-list-list-conc-matchp
          (abnf::tree-nonleaf->branches abnf::cst)
          "assert-statement")
     (equal
          (abnf::tree-nonleaf->rulename?
               (nth 0
                    (nth 0
                         (abnf::tree-nonleaf->branches abnf::cst))))
          (abnf::rulename "assert-statement")))
   (iff
     (cst-list-list-conc-matchp
          (abnf::tree-nonleaf->branches abnf::cst)
          "switch-statement")
     (equal
          (abnf::tree-nonleaf->rulename?
               (nth 0
                    (nth 0
                         (abnf::tree-nonleaf->branches abnf::cst))))
          (abnf::rulename "switch-statement")))
   (iff
     (cst-list-list-conc-matchp
          (abnf::tree-nonleaf->branches abnf::cst)
          "do-statement")
     (equal
          (abnf::tree-nonleaf->rulename?
               (nth 0
                    (nth 0
                         (abnf::tree-nonleaf->branches abnf::cst))))
          (abnf::rulename "do-statement")))
   (iff
     (cst-list-list-conc-matchp
          (abnf::tree-nonleaf->branches abnf::cst)
          "break-statement")
     (equal
          (abnf::tree-nonleaf->rulename?
               (nth 0
                    (nth 0
                         (abnf::tree-nonleaf->branches abnf::cst))))
          (abnf::rulename "break-statement")))
   (iff
     (cst-list-list-conc-matchp
          (abnf::tree-nonleaf->branches abnf::cst)
          "continue-statement")
     (equal
          (abnf::tree-nonleaf->rulename?
               (nth 0
                    (nth 0
                         (abnf::tree-nonleaf->branches abnf::cst))))
          (abnf::rulename "continue-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)
          "synchronized-statement")
     (equal
          (abnf::tree-nonleaf->rulename?
               (nth 0
                    (nth 0
                         (abnf::tree-nonleaf->branches abnf::cst))))
          (abnf::rulename "synchronized-statement")))
   (iff
     (cst-list-list-conc-matchp
          (abnf::tree-nonleaf->branches abnf::cst)
          "throw-statement")
     (equal
          (abnf::tree-nonleaf->rulename?
               (nth 0
                    (nth 0
                         (abnf::tree-nonleaf->branches abnf::cst))))
          (abnf::rulename "throw-statement")))
   (iff
     (cst-list-list-conc-matchp
          (abnf::tree-nonleaf->branches abnf::cst)
          "try-statement")
     (equal
          (abnf::tree-nonleaf->rulename?
               (nth 0
                    (nth 0
                         (abnf::tree-nonleaf->branches abnf::cst))))
          (abnf::rulename "try-statement")))
   (iff
     (cst-list-list-conc-matchp
          (abnf::tree-nonleaf->branches abnf::cst)
          "yield-statement")
     (equal
          (abnf::tree-nonleaf->rulename?
               (nth 0
                    (nth 0
                         (abnf::tree-nonleaf->branches abnf::cst))))
          (abnf::rulename "yield-statement"))))))

Theorem: cst-statement-expression-conc-equivs

(defthm cst-statement-expression-conc-equivs
 (implies
  (cst-matchp abnf::cst "statement-expression")
  (and
   (iff
     (cst-list-list-conc-matchp
          (abnf::tree-nonleaf->branches abnf::cst)
          "assignment")
     (equal
          (abnf::tree-nonleaf->rulename?
               (nth 0
                    (nth 0
                         (abnf::tree-nonleaf->branches abnf::cst))))
          (abnf::rulename "assignment")))
   (iff
     (cst-list-list-conc-matchp
          (abnf::tree-nonleaf->branches abnf::cst)
          "pre-increment-expression")
     (equal
          (abnf::tree-nonleaf->rulename?
               (nth 0
                    (nth 0
                         (abnf::tree-nonleaf->branches abnf::cst))))
          (abnf::rulename "pre-increment-expression")))
   (iff
     (cst-list-list-conc-matchp
          (abnf::tree-nonleaf->branches abnf::cst)
          "pre-decrement-expression")
     (equal
          (abnf::tree-nonleaf->rulename?
               (nth 0
                    (nth 0
                         (abnf::tree-nonleaf->branches abnf::cst))))
          (abnf::rulename "pre-decrement-expression")))
   (iff
     (cst-list-list-conc-matchp
          (abnf::tree-nonleaf->branches abnf::cst)
          "post-increment-expression")
     (equal
          (abnf::tree-nonleaf->rulename?
               (nth 0
                    (nth 0
                         (abnf::tree-nonleaf->branches abnf::cst))))
          (abnf::rulename "post-increment-expression")))
   (iff
     (cst-list-list-conc-matchp
          (abnf::tree-nonleaf->branches abnf::cst)
          "post-decrement-expression")
     (equal
          (abnf::tree-nonleaf->rulename?
               (nth 0
                    (nth 0
                         (abnf::tree-nonleaf->branches abnf::cst))))
          (abnf::rulename "post-decrement-expression")))
   (iff
     (cst-list-list-conc-matchp
          (abnf::tree-nonleaf->branches abnf::cst)
          "method-invocation")
     (equal
          (abnf::tree-nonleaf->rulename?
               (nth 0
                    (nth 0
                         (abnf::tree-nonleaf->branches abnf::cst))))
          (abnf::rulename "method-invocation")))
   (iff
     (cst-list-list-conc-matchp
          (abnf::tree-nonleaf->branches abnf::cst)
          "class-instance-creation-expression")
     (equal
          (abnf::tree-nonleaf->rulename?
               (nth 0
                    (nth 0
                         (abnf::tree-nonleaf->branches abnf::cst))))
          (abnf::rulename "class-instance-creation-expression"))))))

Theorem: cst-for-statement-conc-equivs

(defthm cst-for-statement-conc-equivs
 (implies
  (cst-matchp abnf::cst "for-statement")
  (and
   (iff
     (cst-list-list-conc-matchp
          (abnf::tree-nonleaf->branches abnf::cst)
          "basic-for-statement")
     (equal
          (abnf::tree-nonleaf->rulename?
               (nth 0
                    (nth 0
                         (abnf::tree-nonleaf->branches abnf::cst))))
          (abnf::rulename "basic-for-statement")))
   (iff
     (cst-list-list-conc-matchp
          (abnf::tree-nonleaf->branches abnf::cst)
          "enhanced-for-statement")
     (equal
          (abnf::tree-nonleaf->rulename?
               (nth 0
                    (nth 0
                         (abnf::tree-nonleaf->branches abnf::cst))))
          (abnf::rulename "enhanced-for-statement"))))))

Theorem: cst-for-statement-no-short-if-conc-equivs

(defthm cst-for-statement-no-short-if-conc-equivs
 (implies
  (cst-matchp abnf::cst "for-statement-no-short-if")
  (and
   (iff
     (cst-list-list-conc-matchp
          (abnf::tree-nonleaf->branches abnf::cst)
          "basic-for-statement-no-short-if")
     (equal
          (abnf::tree-nonleaf->rulename?
               (nth 0
                    (nth 0
                         (abnf::tree-nonleaf->branches abnf::cst))))
          (abnf::rulename "basic-for-statement-no-short-if")))
   (iff
     (cst-list-list-conc-matchp
          (abnf::tree-nonleaf->branches abnf::cst)
          "enhanced-for-statement-no-short-if")
     (equal
          (abnf::tree-nonleaf->rulename?
               (nth 0
                    (nth 0
                         (abnf::tree-nonleaf->branches abnf::cst))))
          (abnf::rulename "enhanced-for-statement-no-short-if"))))))

Theorem: cst-for-init-conc-equivs

(defthm cst-for-init-conc-equivs
 (implies
  (cst-matchp abnf::cst "for-init")
  (and
   (iff
     (cst-list-list-conc-matchp
          (abnf::tree-nonleaf->branches abnf::cst)
          "statement-expression-list")
     (equal
          (abnf::tree-nonleaf->rulename?
               (nth 0
                    (nth 0
                         (abnf::tree-nonleaf->branches abnf::cst))))
          (abnf::rulename "statement-expression-list")))
   (iff
     (cst-list-list-conc-matchp
          (abnf::tree-nonleaf->branches abnf::cst)
          "local-variable-declaration")
     (equal
          (abnf::tree-nonleaf->rulename?
               (nth 0
                    (nth 0
                         (abnf::tree-nonleaf->branches abnf::cst))))
          (abnf::rulename "local-variable-declaration"))))))

Theorem: cst-resource-conc-equivs

(defthm cst-resource-conc-equivs
 (implies
  (cst-matchp abnf::cst "resource")
  (and
   (iff
     (cst-list-list-conc-matchp
          (abnf::tree-nonleaf->branches abnf::cst)
          "local-variable-declaration")
     (equal
          (abnf::tree-nonleaf->rulename?
               (nth 0
                    (nth 0
                         (abnf::tree-nonleaf->branches abnf::cst))))
          (abnf::rulename "local-variable-declaration")))
   (iff
     (cst-list-list-conc-matchp
          (abnf::tree-nonleaf->branches abnf::cst)
          "variable-access")
     (equal
          (abnf::tree-nonleaf->rulename?
               (nth 0
                    (nth 0
                         (abnf::tree-nonleaf->branches abnf::cst))))
          (abnf::rulename "variable-access"))))))

Theorem: cst-variable-access-conc-equivs

(defthm cst-variable-access-conc-equivs
 (implies
  (cst-matchp abnf::cst "variable-access")
  (and
   (iff
     (cst-list-list-conc-matchp
          (abnf::tree-nonleaf->branches abnf::cst)
          "expression-name")
     (equal
          (abnf::tree-nonleaf->rulename?
               (nth 0
                    (nth 0
                         (abnf::tree-nonleaf->branches abnf::cst))))
          (abnf::rulename "expression-name")))
   (iff
     (cst-list-list-conc-matchp
          (abnf::tree-nonleaf->branches abnf::cst)
          "field-access")
     (equal
          (abnf::tree-nonleaf->rulename?
               (nth 0
                    (nth 0
                         (abnf::tree-nonleaf->branches abnf::cst))))
          (abnf::rulename "field-access"))))))

Theorem: cst-pattern-conc-equivs

(defthm cst-pattern-conc-equivs
 (implies
  (cst-matchp abnf::cst "pattern")
  (and
   (iff
     (cst-list-list-conc-matchp
          (abnf::tree-nonleaf->branches abnf::cst)
          "type-pattern")
     (equal
          (abnf::tree-nonleaf->rulename?
               (nth 0
                    (nth 0
                         (abnf::tree-nonleaf->branches abnf::cst))))
          (abnf::rulename "type-pattern")))
   (iff
     (cst-list-list-conc-matchp
          (abnf::tree-nonleaf->branches abnf::cst)
          "record-pattern")
     (equal
          (abnf::tree-nonleaf->rulename?
               (nth 0
                    (nth 0
                         (abnf::tree-nonleaf->branches abnf::cst))))
          (abnf::rulename "record-pattern"))))))

Theorem: cst-component-pattern-conc-equivs

(defthm cst-component-pattern-conc-equivs
 (implies
  (cst-matchp abnf::cst "component-pattern")
  (and
   (iff
     (cst-list-list-conc-matchp
          (abnf::tree-nonleaf->branches abnf::cst)
          "pattern")
     (equal
          (abnf::tree-nonleaf->rulename?
               (nth 0
                    (nth 0
                         (abnf::tree-nonleaf->branches abnf::cst))))
          (abnf::rulename "pattern")))
   (iff
     (cst-list-list-conc-matchp
          (abnf::tree-nonleaf->branches abnf::cst)
          "match-all-pattern")
     (equal
          (abnf::tree-nonleaf->rulename?
               (nth 0
                    (nth 0
                         (abnf::tree-nonleaf->branches abnf::cst))))
          (abnf::rulename "match-all-pattern"))))))

Theorem: cst-expression-conc-equivs

(defthm cst-expression-conc-equivs
 (implies
  (cst-matchp abnf::cst "expression")
  (and
   (iff
     (cst-list-list-conc-matchp
          (abnf::tree-nonleaf->branches abnf::cst)
          "lambda-expression")
     (equal
          (abnf::tree-nonleaf->rulename?
               (nth 0
                    (nth 0
                         (abnf::tree-nonleaf->branches abnf::cst))))
          (abnf::rulename "lambda-expression")))
   (iff
     (cst-list-list-conc-matchp
          (abnf::tree-nonleaf->branches abnf::cst)
          "assignment-expression")
     (equal
          (abnf::tree-nonleaf->rulename?
               (nth 0
                    (nth 0
                         (abnf::tree-nonleaf->branches abnf::cst))))
          (abnf::rulename "assignment-expression"))))))

Theorem: cst-primary-conc-equivs

(defthm cst-primary-conc-equivs
 (implies
  (cst-matchp abnf::cst "primary")
  (and
   (iff
     (cst-list-list-conc-matchp
          (abnf::tree-nonleaf->branches abnf::cst)
          "primary-no-new-array")
     (equal
          (abnf::tree-nonleaf->rulename?
               (nth 0
                    (nth 0
                         (abnf::tree-nonleaf->branches abnf::cst))))
          (abnf::rulename "primary-no-new-array")))
   (iff
     (cst-list-list-conc-matchp
          (abnf::tree-nonleaf->branches abnf::cst)
          "array-creation-expression")
     (equal
          (abnf::tree-nonleaf->rulename?
               (nth 0
                    (nth 0
                         (abnf::tree-nonleaf->branches abnf::cst))))
          (abnf::rulename "array-creation-expression"))))))

Theorem: cst-type-arguments-or-diamond-conc-equivs

(defthm cst-type-arguments-or-diamond-conc-equivs
 (implies
  (cst-matchp abnf::cst "type-arguments-or-diamond")
  (and
      (iff (cst-list-list-conc-matchp
                (abnf::tree-nonleaf->branches abnf::cst)
                "type-arguments")
           (abnf::tree-case
                (nth 0
                     (nth 0
                          (abnf::tree-nonleaf->branches abnf::cst)))
                :nonleaf))
      (iff (cst-list-list-conc-matchp
                (abnf::tree-nonleaf->branches abnf::cst)
                "\"<>\"")
           (abnf::tree-case
                (nth 0
                     (nth 0
                          (abnf::tree-nonleaf->branches abnf::cst)))
                :leafterm)))))

Theorem: cst-array-creation-expression-conc-equivs

(defthm cst-array-creation-expression-conc-equivs
 (implies
  (cst-matchp abnf::cst "array-creation-expression")
  (and
   (iff
     (cst-list-list-conc-matchp
          (abnf::tree-nonleaf->branches abnf::cst)
          "array-creation-expression-without-initializer")
     (equal
          (abnf::tree-nonleaf->rulename?
               (nth 0
                    (nth 0
                         (abnf::tree-nonleaf->branches abnf::cst))))
          (abnf::rulename
               "array-creation-expression-without-initializer")))
   (iff
     (cst-list-list-conc-matchp
          (abnf::tree-nonleaf->branches abnf::cst)
          "array-creation-expression-with-initializer")
     (equal
          (abnf::tree-nonleaf->rulename?
               (nth 0
                    (nth 0
                         (abnf::tree-nonleaf->branches abnf::cst))))
          (abnf::rulename
               "array-creation-expression-with-initializer"))))))

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")
     (equal
          (abnf::tree-nonleaf->rulename?
               (nth 0
                    (nth 0
                         (abnf::tree-nonleaf->branches abnf::cst))))
          (abnf::rulename "primary")))
   (iff
     (cst-list-list-conc-matchp
          (abnf::tree-nonleaf->branches abnf::cst)
          "expression-name")
     (equal
          (abnf::tree-nonleaf->rulename?
               (nth 0
                    (nth 0
                         (abnf::tree-nonleaf->branches abnf::cst))))
          (abnf::rulename "expression-name")))
   (iff
     (cst-list-list-conc-matchp
          (abnf::tree-nonleaf->branches abnf::cst)
          "post-increment-expression")
     (equal
          (abnf::tree-nonleaf->rulename?
               (nth 0
                    (nth 0
                         (abnf::tree-nonleaf->branches abnf::cst))))
          (abnf::rulename "post-increment-expression")))
   (iff
     (cst-list-list-conc-matchp
          (abnf::tree-nonleaf->branches abnf::cst)
          "post-decrement-expression")
     (equal
          (abnf::tree-nonleaf->rulename?
               (nth 0
                    (nth 0
                         (abnf::tree-nonleaf->branches abnf::cst))))
          (abnf::rulename "post-decrement-expression"))))))

Theorem: cst-assignment-expression-conc-equivs

(defthm cst-assignment-expression-conc-equivs
 (implies
  (cst-matchp abnf::cst "assignment-expression")
  (and
   (iff
     (cst-list-list-conc-matchp
          (abnf::tree-nonleaf->branches abnf::cst)
          "conditional-expression")
     (equal
          (abnf::tree-nonleaf->rulename?
               (nth 0
                    (nth 0
                         (abnf::tree-nonleaf->branches abnf::cst))))
          (abnf::rulename "conditional-expression")))
   (iff
     (cst-list-list-conc-matchp
          (abnf::tree-nonleaf->branches abnf::cst)
          "assignment")
     (equal
          (abnf::tree-nonleaf->rulename?
               (nth 0
                    (nth 0
                         (abnf::tree-nonleaf->branches abnf::cst))))
          (abnf::rulename "assignment"))))))

Theorem: cst-left-hand-side-conc-equivs

(defthm cst-left-hand-side-conc-equivs
 (implies
  (cst-matchp abnf::cst "left-hand-side")
  (and
   (iff
     (cst-list-list-conc-matchp
          (abnf::tree-nonleaf->branches abnf::cst)
          "expression-name")
     (equal
          (abnf::tree-nonleaf->rulename?
               (nth 0
                    (nth 0
                         (abnf::tree-nonleaf->branches abnf::cst))))
          (abnf::rulename "expression-name")))
   (iff
     (cst-list-list-conc-matchp
          (abnf::tree-nonleaf->branches abnf::cst)
          "field-access")
     (equal
          (abnf::tree-nonleaf->rulename?
               (nth 0
                    (nth 0
                         (abnf::tree-nonleaf->branches abnf::cst))))
          (abnf::rulename "field-access")))
   (iff
     (cst-list-list-conc-matchp
          (abnf::tree-nonleaf->branches abnf::cst)
          "array-access")
     (equal
          (abnf::tree-nonleaf->rulename?
               (nth 0
                    (nth 0
                         (abnf::tree-nonleaf->branches abnf::cst))))
          (abnf::rulename "array-access"))))))

Theorem: cst-lambda-parameter-type-conc-equivs

(defthm cst-lambda-parameter-type-conc-equivs
 (implies
  (cst-matchp abnf::cst "lambda-parameter-type")
  (and
      (iff (cst-list-list-conc-matchp
                (abnf::tree-nonleaf->branches abnf::cst)
                "unann-type")
           (abnf::tree-case
                (nth 0
                     (nth 0
                          (abnf::tree-nonleaf->branches abnf::cst)))
                :nonleaf))
      (iff (cst-list-list-conc-matchp
                (abnf::tree-nonleaf->branches abnf::cst)
                "%s\"var\"")
           (abnf::tree-case
                (nth 0
                     (nth 0
                          (abnf::tree-nonleaf->branches abnf::cst)))
                :leafterm)))))

Theorem: cst-concise-lambda-parameter-conc-equivs

(defthm cst-concise-lambda-parameter-conc-equivs
 (implies
  (cst-matchp abnf::cst "concise-lambda-parameter")
  (and
      (iff (cst-list-list-conc-matchp
                (abnf::tree-nonleaf->branches abnf::cst)
                "identifier")
           (abnf::tree-case
                (nth 0
                     (nth 0
                          (abnf::tree-nonleaf->branches abnf::cst)))
                :nonleaf))
      (iff (cst-list-list-conc-matchp
                (abnf::tree-nonleaf->branches abnf::cst)
                "\"_\"")
           (abnf::tree-case
                (nth 0
                     (nth 0
                          (abnf::tree-nonleaf->branches abnf::cst)))
                :leafterm)))))

Theorem: cst-lambda-body-conc-equivs

(defthm cst-lambda-body-conc-equivs
 (implies
  (cst-matchp abnf::cst "lambda-body")
  (and
   (iff
     (cst-list-list-conc-matchp
          (abnf::tree-nonleaf->branches abnf::cst)
          "expression")
     (equal
          (abnf::tree-nonleaf->rulename?
               (nth 0
                    (nth 0
                         (abnf::tree-nonleaf->branches abnf::cst))))
          (abnf::rulename "expression")))
   (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"))))))

Function: cst-unicode-input-character-conc?

(defun cst-unicode-input-character-conc? (abnf::cst)
 (declare (xargs :guard (abnf::treep abnf::cst)))
 (declare
    (xargs :guard (cst-matchp abnf::cst "unicode-input-character")))
 (cond
  ((equal (abnf::tree-nonleaf->rulename?
               (nth 0
                    (nth 0
                         (abnf::tree-nonleaf->branches abnf::cst))))
          (abnf::rulename "unicode-escape"))
   1)
  ((equal (abnf::tree-nonleaf->rulename?
               (nth 0
                    (nth 0
                         (abnf::tree-nonleaf->branches abnf::cst))))
          (abnf::rulename "raw-input-character"))
   2)
  (t (prog2$ (impossible) 1))))

Theorem: posp-of-cst-unicode-input-character-conc?

(defthm posp-of-cst-unicode-input-character-conc?
  (b* ((number (cst-unicode-input-character-conc? abnf::cst)))
    (posp number))
  :rule-classes :rewrite)

Theorem: cst-unicode-input-character-conc?-possibilities

(defthm cst-unicode-input-character-conc?-possibilities
 (b* ((number (cst-unicode-input-character-conc? abnf::cst)))
   (or (equal number 1) (equal number 2)))
 :rule-classes
 ((:forward-chaining
   :trigger-terms ((cst-unicode-input-character-conc? abnf::cst)))))

Theorem: cst-unicode-input-character-conc?-of-tree-fix-cst

(defthm cst-unicode-input-character-conc?-of-tree-fix-cst
 (equal
      (cst-unicode-input-character-conc? (abnf::tree-fix abnf::cst))
      (cst-unicode-input-character-conc? abnf::cst)))

Theorem: cst-unicode-input-character-conc?-tree-equiv-congruence-on-cst

(defthm
     cst-unicode-input-character-conc?-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-unicode-input-character-conc? abnf::cst)
                  (cst-unicode-input-character-conc? cst-equiv)))
  :rule-classes :congruence)

Theorem: cst-unicode-input-character-conc?-1-iff-match-conc

(defthm cst-unicode-input-character-conc?-1-iff-match-conc
  (implies (cst-matchp abnf::cst "unicode-input-character")
           (iff (equal (cst-unicode-input-character-conc? abnf::cst)
                       1)
                (cst-list-list-conc-matchp
                     (abnf::tree-nonleaf->branches abnf::cst)
                     "unicode-escape"))))

Theorem: cst-unicode-input-character-conc?-2-iff-match-conc

(defthm cst-unicode-input-character-conc?-2-iff-match-conc
  (implies (cst-matchp abnf::cst "unicode-input-character")
           (iff (equal (cst-unicode-input-character-conc? abnf::cst)
                       2)
                (cst-list-list-conc-matchp
                     (abnf::tree-nonleaf->branches abnf::cst)
                     "raw-input-character"))))

Function: cst-input-element-conc?

(defun cst-input-element-conc? (abnf::cst)
 (declare (xargs :guard (abnf::treep abnf::cst)))
 (declare (xargs :guard (cst-matchp abnf::cst "input-element")))
 (cond
  ((equal (abnf::tree-nonleaf->rulename?
               (nth 0
                    (nth 0
                         (abnf::tree-nonleaf->branches abnf::cst))))
          (abnf::rulename "white-space"))
   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 "token"))
   3)
  (t (prog2$ (impossible) 1))))

Theorem: posp-of-cst-input-element-conc?

(defthm posp-of-cst-input-element-conc?
  (b* ((number (cst-input-element-conc? abnf::cst)))
    (posp number))
  :rule-classes :rewrite)

Theorem: cst-input-element-conc?-possibilities

(defthm cst-input-element-conc?-possibilities
  (b* ((number (cst-input-element-conc? abnf::cst)))
    (or (equal number 1)
        (equal number 2)
        (equal number 3)))
  :rule-classes
  ((:forward-chaining
        :trigger-terms ((cst-input-element-conc? abnf::cst)))))

Theorem: cst-input-element-conc?-of-tree-fix-cst

(defthm cst-input-element-conc?-of-tree-fix-cst
  (equal (cst-input-element-conc? (abnf::tree-fix abnf::cst))
         (cst-input-element-conc? abnf::cst)))

Theorem: cst-input-element-conc?-tree-equiv-congruence-on-cst

(defthm cst-input-element-conc?-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-input-element-conc? abnf::cst)
                  (cst-input-element-conc? cst-equiv)))
  :rule-classes :congruence)

Theorem: cst-input-element-conc?-1-iff-match-conc

(defthm cst-input-element-conc?-1-iff-match-conc
  (implies (cst-matchp abnf::cst "input-element")
           (iff (equal (cst-input-element-conc? abnf::cst)
                       1)
                (cst-list-list-conc-matchp
                     (abnf::tree-nonleaf->branches abnf::cst)
                     "white-space"))))

Theorem: cst-input-element-conc?-2-iff-match-conc

(defthm cst-input-element-conc?-2-iff-match-conc
  (implies (cst-matchp abnf::cst "input-element")
           (iff (equal (cst-input-element-conc? abnf::cst)
                       2)
                (cst-list-list-conc-matchp
                     (abnf::tree-nonleaf->branches abnf::cst)
                     "comment"))))

Theorem: cst-input-element-conc?-3-iff-match-conc

(defthm cst-input-element-conc?-3-iff-match-conc
  (implies (cst-matchp abnf::cst "input-element")
           (iff (equal (cst-input-element-conc? abnf::cst)
                       3)
                (cst-list-list-conc-matchp
                     (abnf::tree-nonleaf->branches abnf::cst)
                     "token"))))

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")))
 (cond
  ((equal (abnf::tree-nonleaf->rulename?
               (nth 0
                    (nth 0
                         (abnf::tree-nonleaf->branches abnf::cst))))
          (abnf::rulename "identifier"))
   1)
  ((equal (abnf::tree-nonleaf->rulename?
               (nth 0
                    (nth 0
                         (abnf::tree-nonleaf->branches abnf::cst))))
          (abnf::rulename "keyword"))
   2)
  ((equal (abnf::tree-nonleaf->rulename?
               (nth 0
                    (nth 0
                         (abnf::tree-nonleaf->branches abnf::cst))))
          (abnf::rulename "literal"))
   3)
  ((equal (abnf::tree-nonleaf->rulename?
               (nth 0
                    (nth 0
                         (abnf::tree-nonleaf->branches abnf::cst))))
          (abnf::rulename "separator"))
   4)
  ((equal (abnf::tree-nonleaf->rulename?
               (nth 0
                    (nth 0
                         (abnf::tree-nonleaf->branches abnf::cst))))
          (abnf::rulename "operator"))
   5)
  (t (prog2$ (impossible) 1))))

Theorem: posp-of-cst-token-conc?

(defthm posp-of-cst-token-conc?
  (b* ((number (cst-token-conc? abnf::cst)))
    (posp number))
  :rule-classes :rewrite)

Theorem: cst-token-conc?-possibilities

(defthm cst-token-conc?-possibilities
 (b* ((number (cst-token-conc? abnf::cst)))
   (or (equal number 1)
       (equal number 2)
       (equal number 3)
       (equal number 4)
       (equal number 5)))
 :rule-classes
 ((:forward-chaining :trigger-terms ((cst-token-conc? abnf::cst)))))

Theorem: cst-token-conc?-of-tree-fix-cst

(defthm cst-token-conc?-of-tree-fix-cst
  (equal (cst-token-conc? (abnf::tree-fix abnf::cst))
         (cst-token-conc? abnf::cst)))

Theorem: cst-token-conc?-tree-equiv-congruence-on-cst

(defthm cst-token-conc?-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-token-conc? abnf::cst)
                  (cst-token-conc? cst-equiv)))
  :rule-classes :congruence)

Theorem: cst-token-conc?-1-iff-match-conc

(defthm cst-token-conc?-1-iff-match-conc
  (implies (cst-matchp abnf::cst "token")
           (iff (equal (cst-token-conc? abnf::cst) 1)
                (cst-list-list-conc-matchp
                     (abnf::tree-nonleaf->branches abnf::cst)
                     "identifier"))))

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)
                     "keyword"))))

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)
                     "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)
                     "separator"))))

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)
                     "operator"))))

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")))
 (cond
  ((equal (abnf::tree-nonleaf->rulename?
               (nth 0
                    (nth 0
                         (abnf::tree-nonleaf->branches abnf::cst))))
          (abnf::rulename "traditional-comment"))
   1)
  ((equal (abnf::tree-nonleaf->rulename?
               (nth 0
                    (nth 0
                         (abnf::tree-nonleaf->branches abnf::cst))))
          (abnf::rulename "end-of-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)
                     "traditional-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)
                     "end-of-line-comment"))))

Function: cst-not-star-conc?

(defun cst-not-star-conc? (abnf::cst)
 (declare (xargs :guard (abnf::treep abnf::cst)))
 (declare (xargs :guard (cst-matchp abnf::cst "not-star")))
 (cond
  ((equal (abnf::tree-nonleaf->rulename?
               (nth 0
                    (nth 0
                         (abnf::tree-nonleaf->branches abnf::cst))))
          (abnf::rulename "input-character"))
   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-not-star-conc?

(defthm posp-of-cst-not-star-conc?
  (b* ((number (cst-not-star-conc? abnf::cst)))
    (posp number))
  :rule-classes :rewrite)

Theorem: cst-not-star-conc?-possibilities

(defthm cst-not-star-conc?-possibilities
  (b* ((number (cst-not-star-conc? abnf::cst)))
    (or (equal number 1) (equal number 2)))
  :rule-classes
  ((:forward-chaining
        :trigger-terms ((cst-not-star-conc? abnf::cst)))))

Theorem: cst-not-star-conc?-of-tree-fix-cst

(defthm cst-not-star-conc?-of-tree-fix-cst
  (equal (cst-not-star-conc? (abnf::tree-fix abnf::cst))
         (cst-not-star-conc? abnf::cst)))

Theorem: cst-not-star-conc?-tree-equiv-congruence-on-cst

(defthm cst-not-star-conc?-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-not-star-conc? abnf::cst)
                  (cst-not-star-conc? cst-equiv)))
  :rule-classes :congruence)

Theorem: cst-not-star-conc?-1-iff-match-conc

(defthm cst-not-star-conc?-1-iff-match-conc
  (implies (cst-matchp abnf::cst "not-star")
           (iff (equal (cst-not-star-conc? abnf::cst) 1)
                (cst-list-list-conc-matchp
                     (abnf::tree-nonleaf->branches abnf::cst)
                     "input-character"))))

Theorem: cst-not-star-conc?-2-iff-match-conc

(defthm cst-not-star-conc?-2-iff-match-conc
  (implies (cst-matchp abnf::cst "not-star")
           (iff (equal (cst-not-star-conc? abnf::cst) 2)
                (cst-list-list-conc-matchp
                     (abnf::tree-nonleaf->branches abnf::cst)
                     "line-terminator"))))

Function: cst-not-star-not-slash-conc?

(defun cst-not-star-not-slash-conc? (abnf::cst)
 (declare (xargs :guard (abnf::treep abnf::cst)))
 (declare
      (xargs :guard (cst-matchp abnf::cst "not-star-not-slash")))
 (cond
  ((equal (abnf::tree-nonleaf->rulename?
               (nth 0
                    (nth 0
                         (abnf::tree-nonleaf->branches abnf::cst))))
          (abnf::rulename "input-character"))
   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-not-star-not-slash-conc?

(defthm posp-of-cst-not-star-not-slash-conc?
  (b* ((number (cst-not-star-not-slash-conc? abnf::cst)))
    (posp number))
  :rule-classes :rewrite)

Theorem: cst-not-star-not-slash-conc?-possibilities

(defthm cst-not-star-not-slash-conc?-possibilities
  (b* ((number (cst-not-star-not-slash-conc? abnf::cst)))
    (or (equal number 1) (equal number 2)))
  :rule-classes
  ((:forward-chaining
        :trigger-terms ((cst-not-star-not-slash-conc? abnf::cst)))))

Theorem: cst-not-star-not-slash-conc?-of-tree-fix-cst

(defthm cst-not-star-not-slash-conc?-of-tree-fix-cst
  (equal (cst-not-star-not-slash-conc? (abnf::tree-fix abnf::cst))
         (cst-not-star-not-slash-conc? abnf::cst)))

Theorem: cst-not-star-not-slash-conc?-tree-equiv-congruence-on-cst

(defthm cst-not-star-not-slash-conc?-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-not-star-not-slash-conc? abnf::cst)
                  (cst-not-star-not-slash-conc? cst-equiv)))
  :rule-classes :congruence)

Theorem: cst-not-star-not-slash-conc?-1-iff-match-conc

(defthm cst-not-star-not-slash-conc?-1-iff-match-conc
  (implies (cst-matchp abnf::cst "not-star-not-slash")
           (iff (equal (cst-not-star-not-slash-conc? abnf::cst)
                       1)
                (cst-list-list-conc-matchp
                     (abnf::tree-nonleaf->branches abnf::cst)
                     "input-character"))))

Theorem: cst-not-star-not-slash-conc?-2-iff-match-conc

(defthm cst-not-star-not-slash-conc?-2-iff-match-conc
  (implies (cst-matchp abnf::cst "not-star-not-slash")
           (iff (equal (cst-not-star-not-slash-conc? abnf::cst)
                       2)
                (cst-list-list-conc-matchp
                     (abnf::tree-nonleaf->branches abnf::cst)
                     "line-terminator"))))

Function: cst-keyword-conc?

(defun cst-keyword-conc? (abnf::cst)
 (declare (xargs :guard (abnf::treep abnf::cst)))
 (declare (xargs :guard (cst-matchp abnf::cst "keyword")))
 (cond
  ((equal (abnf::tree-nonleaf->rulename?
               (nth 0
                    (nth 0
                         (abnf::tree-nonleaf->branches abnf::cst))))
          (abnf::rulename "reserved-keyword"))
   1)
  ((equal (abnf::tree-nonleaf->rulename?
               (nth 0
                    (nth 0
                         (abnf::tree-nonleaf->branches abnf::cst))))
          (abnf::rulename "contextual-keyword"))
   2)
  (t (prog2$ (impossible) 1))))

Theorem: posp-of-cst-keyword-conc?

(defthm posp-of-cst-keyword-conc?
  (b* ((number (cst-keyword-conc? abnf::cst)))
    (posp number))
  :rule-classes :rewrite)

Theorem: cst-keyword-conc?-possibilities

(defthm cst-keyword-conc?-possibilities
  (b* ((number (cst-keyword-conc? abnf::cst)))
    (or (equal number 1) (equal number 2)))
  :rule-classes
  ((:forward-chaining
        :trigger-terms ((cst-keyword-conc? abnf::cst)))))

Theorem: cst-keyword-conc?-of-tree-fix-cst

(defthm cst-keyword-conc?-of-tree-fix-cst
  (equal (cst-keyword-conc? (abnf::tree-fix abnf::cst))
         (cst-keyword-conc? abnf::cst)))

Theorem: cst-keyword-conc?-tree-equiv-congruence-on-cst

(defthm cst-keyword-conc?-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-keyword-conc? abnf::cst)
                  (cst-keyword-conc? cst-equiv)))
  :rule-classes :congruence)

Theorem: cst-keyword-conc?-1-iff-match-conc

(defthm cst-keyword-conc?-1-iff-match-conc
  (implies (cst-matchp abnf::cst "keyword")
           (iff (equal (cst-keyword-conc? abnf::cst) 1)
                (cst-list-list-conc-matchp
                     (abnf::tree-nonleaf->branches abnf::cst)
                     "reserved-keyword"))))

Theorem: cst-keyword-conc?-2-iff-match-conc

(defthm cst-keyword-conc?-2-iff-match-conc
  (implies (cst-matchp abnf::cst "keyword")
           (iff (equal (cst-keyword-conc? abnf::cst) 2)
                (cst-list-list-conc-matchp
                     (abnf::tree-nonleaf->branches abnf::cst)
                     "contextual-keyword"))))

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")))
 (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 "floating-point-literal"))
   2)
  ((equal (abnf::tree-nonleaf->rulename?
               (nth 0
                    (nth 0
                         (abnf::tree-nonleaf->branches abnf::cst))))
          (abnf::rulename "boolean-literal"))
   3)
  ((equal (abnf::tree-nonleaf->rulename?
               (nth 0
                    (nth 0
                         (abnf::tree-nonleaf->branches abnf::cst))))
          (abnf::rulename "character-literal"))
   4)
  ((equal (abnf::tree-nonleaf->rulename?
               (nth 0
                    (nth 0
                         (abnf::tree-nonleaf->branches abnf::cst))))
          (abnf::rulename "string-literal"))
   5)
  ((equal (abnf::tree-nonleaf->rulename?
               (nth 0
                    (nth 0
                         (abnf::tree-nonleaf->branches abnf::cst))))
          (abnf::rulename "text-block"))
   6)
  ((equal (abnf::tree-nonleaf->rulename?
               (nth 0
                    (nth 0
                         (abnf::tree-nonleaf->branches abnf::cst))))
          (abnf::rulename "null-literal"))
   7)
  (t (prog2$ (impossible) 1))))

Theorem: posp-of-cst-literal-conc?

(defthm posp-of-cst-literal-conc?
  (b* ((number (cst-literal-conc? abnf::cst)))
    (posp number))
  :rule-classes :rewrite)

Theorem: cst-literal-conc?-possibilities

(defthm cst-literal-conc?-possibilities
  (b* ((number (cst-literal-conc? abnf::cst)))
    (or (equal number 1)
        (equal number 2)
        (equal number 3)
        (equal number 4)
        (equal number 5)
        (equal number 6)
        (equal number 7)))
  :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)
                     "integer-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)
                     "floating-point-literal"))))

Theorem: cst-literal-conc?-3-iff-match-conc

(defthm cst-literal-conc?-3-iff-match-conc
  (implies (cst-matchp abnf::cst "literal")
           (iff (equal (cst-literal-conc? abnf::cst) 3)
                (cst-list-list-conc-matchp
                     (abnf::tree-nonleaf->branches abnf::cst)
                     "boolean-literal"))))

Theorem: cst-literal-conc?-4-iff-match-conc

(defthm cst-literal-conc?-4-iff-match-conc
  (implies (cst-matchp abnf::cst "literal")
           (iff (equal (cst-literal-conc? abnf::cst) 4)
                (cst-list-list-conc-matchp
                     (abnf::tree-nonleaf->branches abnf::cst)
                     "character-literal"))))

Theorem: cst-literal-conc?-5-iff-match-conc

(defthm cst-literal-conc?-5-iff-match-conc
  (implies (cst-matchp abnf::cst "literal")
           (iff (equal (cst-literal-conc? abnf::cst) 5)
                (cst-list-list-conc-matchp
                     (abnf::tree-nonleaf->branches abnf::cst)
                     "string-literal"))))

Theorem: cst-literal-conc?-6-iff-match-conc

(defthm cst-literal-conc?-6-iff-match-conc
  (implies (cst-matchp abnf::cst "literal")
           (iff (equal (cst-literal-conc? abnf::cst) 6)
                (cst-list-list-conc-matchp
                     (abnf::tree-nonleaf->branches abnf::cst)
                     "text-block"))))

Theorem: cst-literal-conc?-7-iff-match-conc

(defthm cst-literal-conc?-7-iff-match-conc
  (implies (cst-matchp abnf::cst "literal")
           (iff (equal (cst-literal-conc? abnf::cst) 7)
                (cst-list-list-conc-matchp
                     (abnf::tree-nonleaf->branches abnf::cst)
                     "null-literal"))))

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")))
 (cond
  ((equal (abnf::tree-nonleaf->rulename?
               (nth 0
                    (nth 0
                         (abnf::tree-nonleaf->branches abnf::cst))))
          (abnf::rulename "decimal-integer-literal"))
   1)
  ((equal (abnf::tree-nonleaf->rulename?
               (nth 0
                    (nth 0
                         (abnf::tree-nonleaf->branches abnf::cst))))
          (abnf::rulename "hex-integer-literal"))
   2)
  ((equal (abnf::tree-nonleaf->rulename?
               (nth 0
                    (nth 0
                         (abnf::tree-nonleaf->branches abnf::cst))))
          (abnf::rulename "octal-integer-literal"))
   3)
  ((equal (abnf::tree-nonleaf->rulename?
               (nth 0
                    (nth 0
                         (abnf::tree-nonleaf->branches abnf::cst))))
          (abnf::rulename "binary-integer-literal"))
   4)
  (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)
        (equal number 3)
        (equal number 4)))
  :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)
                     "decimal-integer-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)
                     "hex-integer-literal"))))

Theorem: cst-integer-literal-conc?-3-iff-match-conc

(defthm cst-integer-literal-conc?-3-iff-match-conc
  (implies (cst-matchp abnf::cst "integer-literal")
           (iff (equal (cst-integer-literal-conc? abnf::cst)
                       3)
                (cst-list-list-conc-matchp
                     (abnf::tree-nonleaf->branches abnf::cst)
                     "octal-integer-literal"))))

Theorem: cst-integer-literal-conc?-4-iff-match-conc

(defthm cst-integer-literal-conc?-4-iff-match-conc
  (implies (cst-matchp abnf::cst "integer-literal")
           (iff (equal (cst-integer-literal-conc? abnf::cst)
                       4)
                (cst-list-list-conc-matchp
                     (abnf::tree-nonleaf->branches abnf::cst)
                     "binary-integer-literal"))))

Function: cst-floating-point-literal-conc?

(defun cst-floating-point-literal-conc? (abnf::cst)
 (declare (xargs :guard (abnf::treep abnf::cst)))
 (declare
     (xargs :guard (cst-matchp abnf::cst "floating-point-literal")))
 (cond
  ((equal (abnf::tree-nonleaf->rulename?
               (nth 0
                    (nth 0
                         (abnf::tree-nonleaf->branches abnf::cst))))
          (abnf::rulename "decimal-floating-point-literal"))
   1)
  ((equal (abnf::tree-nonleaf->rulename?
               (nth 0
                    (nth 0
                         (abnf::tree-nonleaf->branches abnf::cst))))
          (abnf::rulename "hexadecimal-floating-point-literal"))
   2)
  (t (prog2$ (impossible) 1))))

Theorem: posp-of-cst-floating-point-literal-conc?

(defthm posp-of-cst-floating-point-literal-conc?
  (b* ((number (cst-floating-point-literal-conc? abnf::cst)))
    (posp number))
  :rule-classes :rewrite)

Theorem: cst-floating-point-literal-conc?-possibilities

(defthm cst-floating-point-literal-conc?-possibilities
 (b* ((number (cst-floating-point-literal-conc? abnf::cst)))
   (or (equal number 1) (equal number 2)))
 :rule-classes
 ((:forward-chaining
    :trigger-terms ((cst-floating-point-literal-conc? abnf::cst)))))

Theorem: cst-floating-point-literal-conc?-of-tree-fix-cst

(defthm cst-floating-point-literal-conc?-of-tree-fix-cst
  (equal
       (cst-floating-point-literal-conc? (abnf::tree-fix abnf::cst))
       (cst-floating-point-literal-conc? abnf::cst)))

Theorem: cst-floating-point-literal-conc?-tree-equiv-congruence-on-cst

(defthm
      cst-floating-point-literal-conc?-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-floating-point-literal-conc? abnf::cst)
                  (cst-floating-point-literal-conc? cst-equiv)))
  :rule-classes :congruence)

Theorem: cst-floating-point-literal-conc?-1-iff-match-conc

(defthm cst-floating-point-literal-conc?-1-iff-match-conc
  (implies (cst-matchp abnf::cst "floating-point-literal")
           (iff (equal (cst-floating-point-literal-conc? abnf::cst)
                       1)
                (cst-list-list-conc-matchp
                     (abnf::tree-nonleaf->branches abnf::cst)
                     "decimal-floating-point-literal"))))

Theorem: cst-floating-point-literal-conc?-2-iff-match-conc

(defthm cst-floating-point-literal-conc?-2-iff-match-conc
  (implies (cst-matchp abnf::cst "floating-point-literal")
           (iff (equal (cst-floating-point-literal-conc? abnf::cst)
                       2)
                (cst-list-list-conc-matchp
                     (abnf::tree-nonleaf->branches abnf::cst)
                     "hexadecimal-floating-point-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")))
 (cond
  ((equal (abnf::tree-nonleaf->rulename?
               (nth 0
                    (nth 0
                         (abnf::tree-nonleaf->branches abnf::cst))))
          (abnf::rulename "input-character"))
   1)
  ((equal (abnf::tree-nonleaf->rulename?
               (nth 0
                    (nth 0
                         (abnf::tree-nonleaf->branches abnf::cst))))
          (abnf::rulename "escape-sequence"))
   2)
  (t (prog2$ (impossible) 1))))

Theorem: posp-of-cst-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)
                     "input-character"))))

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)
                     "escape-sequence"))))

Function: cst-text-block-character-conc?

(defun cst-text-block-character-conc? (abnf::cst)
 (declare (xargs :guard (abnf::treep abnf::cst)))
 (declare
      (xargs :guard (cst-matchp abnf::cst "text-block-character")))
 (cond
  ((equal (abnf::tree-nonleaf->rulename?
               (nth 0
                    (nth 0
                         (abnf::tree-nonleaf->branches abnf::cst))))
          (abnf::rulename "input-character"))
   1)
  ((equal (abnf::tree-nonleaf->rulename?
               (nth 0
                    (nth 0
                         (abnf::tree-nonleaf->branches abnf::cst))))
          (abnf::rulename "escape-sequence"))
   2)
  ((equal (abnf::tree-nonleaf->rulename?
               (nth 0
                    (nth 0
                         (abnf::tree-nonleaf->branches abnf::cst))))
          (abnf::rulename "line-terminator"))
   3)
  (t (prog2$ (impossible) 1))))

Theorem: posp-of-cst-text-block-character-conc?

(defthm posp-of-cst-text-block-character-conc?
  (b* ((number (cst-text-block-character-conc? abnf::cst)))
    (posp number))
  :rule-classes :rewrite)

Theorem: cst-text-block-character-conc?-possibilities

(defthm cst-text-block-character-conc?-possibilities
 (b* ((number (cst-text-block-character-conc? abnf::cst)))
   (or (equal number 1)
       (equal number 2)
       (equal number 3)))
 :rule-classes
 ((:forward-chaining
      :trigger-terms ((cst-text-block-character-conc? abnf::cst)))))

Theorem: cst-text-block-character-conc?-of-tree-fix-cst

(defthm cst-text-block-character-conc?-of-tree-fix-cst
  (equal (cst-text-block-character-conc? (abnf::tree-fix abnf::cst))
         (cst-text-block-character-conc? abnf::cst)))

Theorem: cst-text-block-character-conc?-tree-equiv-congruence-on-cst

(defthm cst-text-block-character-conc?-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-text-block-character-conc? abnf::cst)
                  (cst-text-block-character-conc? cst-equiv)))
  :rule-classes :congruence)

Theorem: cst-text-block-character-conc?-1-iff-match-conc

(defthm cst-text-block-character-conc?-1-iff-match-conc
  (implies (cst-matchp abnf::cst "text-block-character")
           (iff (equal (cst-text-block-character-conc? abnf::cst)
                       1)
                (cst-list-list-conc-matchp
                     (abnf::tree-nonleaf->branches abnf::cst)
                     "input-character"))))

Theorem: cst-text-block-character-conc?-2-iff-match-conc

(defthm cst-text-block-character-conc?-2-iff-match-conc
  (implies (cst-matchp abnf::cst "text-block-character")
           (iff (equal (cst-text-block-character-conc? abnf::cst)
                       2)
                (cst-list-list-conc-matchp
                     (abnf::tree-nonleaf->branches abnf::cst)
                     "escape-sequence"))))

Theorem: cst-text-block-character-conc?-3-iff-match-conc

(defthm cst-text-block-character-conc?-3-iff-match-conc
  (implies (cst-matchp abnf::cst "text-block-character")
           (iff (equal (cst-text-block-character-conc? abnf::cst)
                       3)
                (cst-list-list-conc-matchp
                     (abnf::tree-nonleaf->branches abnf::cst)
                     "line-terminator"))))

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")))
 (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 "reference-type"))
   2)
  (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)))
  :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)
                     "reference-type"))))

Function: cst-numeric-type-conc?

(defun cst-numeric-type-conc? (abnf::cst)
 (declare (xargs :guard (abnf::treep abnf::cst)))
 (declare (xargs :guard (cst-matchp abnf::cst "numeric-type")))
 (cond
  ((equal (abnf::tree-nonleaf->rulename?
               (nth 0
                    (nth 0
                         (abnf::tree-nonleaf->branches abnf::cst))))
          (abnf::rulename "integral-type"))
   1)
  ((equal (abnf::tree-nonleaf->rulename?
               (nth 0
                    (nth 0
                         (abnf::tree-nonleaf->branches abnf::cst))))
          (abnf::rulename "floating-point-type"))
   2)
  (t (prog2$ (impossible) 1))))

Theorem: posp-of-cst-numeric-type-conc?

(defthm posp-of-cst-numeric-type-conc?
  (b* ((number (cst-numeric-type-conc? abnf::cst)))
    (posp number))
  :rule-classes :rewrite)

Theorem: cst-numeric-type-conc?-possibilities

(defthm cst-numeric-type-conc?-possibilities
  (b* ((number (cst-numeric-type-conc? abnf::cst)))
    (or (equal number 1) (equal number 2)))
  :rule-classes
  ((:forward-chaining
        :trigger-terms ((cst-numeric-type-conc? abnf::cst)))))

Theorem: cst-numeric-type-conc?-of-tree-fix-cst

(defthm cst-numeric-type-conc?-of-tree-fix-cst
  (equal (cst-numeric-type-conc? (abnf::tree-fix abnf::cst))
         (cst-numeric-type-conc? abnf::cst)))

Theorem: cst-numeric-type-conc?-tree-equiv-congruence-on-cst

(defthm cst-numeric-type-conc?-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-numeric-type-conc? abnf::cst)
                  (cst-numeric-type-conc? cst-equiv)))
  :rule-classes :congruence)

Theorem: cst-numeric-type-conc?-1-iff-match-conc

(defthm cst-numeric-type-conc?-1-iff-match-conc
  (implies (cst-matchp abnf::cst "numeric-type")
           (iff (equal (cst-numeric-type-conc? abnf::cst)
                       1)
                (cst-list-list-conc-matchp
                     (abnf::tree-nonleaf->branches abnf::cst)
                     "integral-type"))))

Theorem: cst-numeric-type-conc?-2-iff-match-conc

(defthm cst-numeric-type-conc?-2-iff-match-conc
  (implies (cst-matchp abnf::cst "numeric-type")
           (iff (equal (cst-numeric-type-conc? abnf::cst)
                       2)
                (cst-list-list-conc-matchp
                     (abnf::tree-nonleaf->branches abnf::cst)
                     "floating-point-type"))))

Function: cst-reference-type-conc?

(defun cst-reference-type-conc? (abnf::cst)
 (declare (xargs :guard (abnf::treep abnf::cst)))
 (declare (xargs :guard (cst-matchp abnf::cst "reference-type")))
 (cond
  ((equal (abnf::tree-nonleaf->rulename?
               (nth 0
                    (nth 0
                         (abnf::tree-nonleaf->branches abnf::cst))))
          (abnf::rulename "class-or-interface-type"))
   1)
  ((equal (abnf::tree-nonleaf->rulename?
               (nth 0
                    (nth 0
                         (abnf::tree-nonleaf->branches abnf::cst))))
          (abnf::rulename "type-variable"))
   2)
  ((equal (abnf::tree-nonleaf->rulename?
               (nth 0
                    (nth 0
                         (abnf::tree-nonleaf->branches abnf::cst))))
          (abnf::rulename "array-type"))
   3)
  (t (prog2$ (impossible) 1))))

Theorem: posp-of-cst-reference-type-conc?

(defthm posp-of-cst-reference-type-conc?
  (b* ((number (cst-reference-type-conc? abnf::cst)))
    (posp number))
  :rule-classes :rewrite)

Theorem: cst-reference-type-conc?-possibilities

(defthm cst-reference-type-conc?-possibilities
  (b* ((number (cst-reference-type-conc? abnf::cst)))
    (or (equal number 1)
        (equal number 2)
        (equal number 3)))
  :rule-classes
  ((:forward-chaining
        :trigger-terms ((cst-reference-type-conc? abnf::cst)))))

Theorem: cst-reference-type-conc?-of-tree-fix-cst

(defthm cst-reference-type-conc?-of-tree-fix-cst
  (equal (cst-reference-type-conc? (abnf::tree-fix abnf::cst))
         (cst-reference-type-conc? abnf::cst)))

Theorem: cst-reference-type-conc?-tree-equiv-congruence-on-cst

(defthm cst-reference-type-conc?-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-reference-type-conc? abnf::cst)
                  (cst-reference-type-conc? cst-equiv)))
  :rule-classes :congruence)

Theorem: cst-reference-type-conc?-1-iff-match-conc

(defthm cst-reference-type-conc?-1-iff-match-conc
  (implies (cst-matchp abnf::cst "reference-type")
           (iff (equal (cst-reference-type-conc? abnf::cst)
                       1)
                (cst-list-list-conc-matchp
                     (abnf::tree-nonleaf->branches abnf::cst)
                     "class-or-interface-type"))))

Theorem: cst-reference-type-conc?-2-iff-match-conc

(defthm cst-reference-type-conc?-2-iff-match-conc
  (implies (cst-matchp abnf::cst "reference-type")
           (iff (equal (cst-reference-type-conc? abnf::cst)
                       2)
                (cst-list-list-conc-matchp
                     (abnf::tree-nonleaf->branches abnf::cst)
                     "type-variable"))))

Theorem: cst-reference-type-conc?-3-iff-match-conc

(defthm cst-reference-type-conc?-3-iff-match-conc
  (implies (cst-matchp abnf::cst "reference-type")
           (iff (equal (cst-reference-type-conc? abnf::cst)
                       3)
                (cst-list-list-conc-matchp
                     (abnf::tree-nonleaf->branches abnf::cst)
                     "array-type"))))

Function: cst-class-or-interface-type-conc?

(defun cst-class-or-interface-type-conc? (abnf::cst)
 (declare (xargs :guard (abnf::treep abnf::cst)))
 (declare
    (xargs :guard (cst-matchp abnf::cst "class-or-interface-type")))
 (cond
  ((equal (abnf::tree-nonleaf->rulename?
               (nth 0
                    (nth 0
                         (abnf::tree-nonleaf->branches abnf::cst))))
          (abnf::rulename "class-type"))
   1)
  ((equal (abnf::tree-nonleaf->rulename?
               (nth 0
                    (nth 0
                         (abnf::tree-nonleaf->branches abnf::cst))))
          (abnf::rulename "interface-type"))
   2)
  (t (prog2$ (impossible) 1))))

Theorem: posp-of-cst-class-or-interface-type-conc?

(defthm posp-of-cst-class-or-interface-type-conc?
  (b* ((number (cst-class-or-interface-type-conc? abnf::cst)))
    (posp number))
  :rule-classes :rewrite)

Theorem: cst-class-or-interface-type-conc?-possibilities

(defthm cst-class-or-interface-type-conc?-possibilities
 (b* ((number (cst-class-or-interface-type-conc? abnf::cst)))
   (or (equal number 1) (equal number 2)))
 :rule-classes
 ((:forward-chaining
   :trigger-terms ((cst-class-or-interface-type-conc? abnf::cst)))))

Theorem: cst-class-or-interface-type-conc?-of-tree-fix-cst

(defthm cst-class-or-interface-type-conc?-of-tree-fix-cst
 (equal
      (cst-class-or-interface-type-conc? (abnf::tree-fix abnf::cst))
      (cst-class-or-interface-type-conc? abnf::cst)))

Theorem: cst-class-or-interface-type-conc?-tree-equiv-congruence-on-cst

(defthm
     cst-class-or-interface-type-conc?-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-class-or-interface-type-conc? abnf::cst)
                  (cst-class-or-interface-type-conc? cst-equiv)))
  :rule-classes :congruence)

Theorem: cst-class-or-interface-type-conc?-1-iff-match-conc

(defthm cst-class-or-interface-type-conc?-1-iff-match-conc
  (implies (cst-matchp abnf::cst "class-or-interface-type")
           (iff (equal (cst-class-or-interface-type-conc? abnf::cst)
                       1)
                (cst-list-list-conc-matchp
                     (abnf::tree-nonleaf->branches abnf::cst)
                     "class-type"))))

Theorem: cst-class-or-interface-type-conc?-2-iff-match-conc

(defthm cst-class-or-interface-type-conc?-2-iff-match-conc
  (implies (cst-matchp abnf::cst "class-or-interface-type")
           (iff (equal (cst-class-or-interface-type-conc? abnf::cst)
                       2)
                (cst-list-list-conc-matchp
                     (abnf::tree-nonleaf->branches abnf::cst)
                     "interface-type"))))

Function: cst-type-argument-conc?

(defun cst-type-argument-conc? (abnf::cst)
 (declare (xargs :guard (abnf::treep abnf::cst)))
 (declare (xargs :guard (cst-matchp abnf::cst "type-argument")))
 (cond
  ((equal (abnf::tree-nonleaf->rulename?
               (nth 0
                    (nth 0
                         (abnf::tree-nonleaf->branches abnf::cst))))
          (abnf::rulename "reference-type"))
   1)
  ((equal (abnf::tree-nonleaf->rulename?
               (nth 0
                    (nth 0
                         (abnf::tree-nonleaf->branches abnf::cst))))
          (abnf::rulename "wildcard"))
   2)
  (t (prog2$ (impossible) 1))))

Theorem: posp-of-cst-type-argument-conc?

(defthm posp-of-cst-type-argument-conc?
  (b* ((number (cst-type-argument-conc? abnf::cst)))
    (posp number))
  :rule-classes :rewrite)

Theorem: cst-type-argument-conc?-possibilities

(defthm cst-type-argument-conc?-possibilities
  (b* ((number (cst-type-argument-conc? abnf::cst)))
    (or (equal number 1) (equal number 2)))
  :rule-classes
  ((:forward-chaining
        :trigger-terms ((cst-type-argument-conc? abnf::cst)))))

Theorem: cst-type-argument-conc?-of-tree-fix-cst

(defthm cst-type-argument-conc?-of-tree-fix-cst
  (equal (cst-type-argument-conc? (abnf::tree-fix abnf::cst))
         (cst-type-argument-conc? abnf::cst)))

Theorem: cst-type-argument-conc?-tree-equiv-congruence-on-cst

(defthm cst-type-argument-conc?-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-type-argument-conc? abnf::cst)
                  (cst-type-argument-conc? cst-equiv)))
  :rule-classes :congruence)

Theorem: cst-type-argument-conc?-1-iff-match-conc

(defthm cst-type-argument-conc?-1-iff-match-conc
  (implies (cst-matchp abnf::cst "type-argument")
           (iff (equal (cst-type-argument-conc? abnf::cst)
                       1)
                (cst-list-list-conc-matchp
                     (abnf::tree-nonleaf->branches abnf::cst)
                     "reference-type"))))

Theorem: cst-type-argument-conc?-2-iff-match-conc

(defthm cst-type-argument-conc?-2-iff-match-conc
  (implies (cst-matchp abnf::cst "type-argument")
           (iff (equal (cst-type-argument-conc? abnf::cst)
                       2)
                (cst-list-list-conc-matchp
                     (abnf::tree-nonleaf->branches abnf::cst)
                     "wildcard"))))

Function: cst-compilation-unit-conc?

(defun cst-compilation-unit-conc? (abnf::cst)
 (declare (xargs :guard (abnf::treep abnf::cst)))
 (declare (xargs :guard (cst-matchp abnf::cst "compilation-unit")))
 (cond
  ((equal (abnf::tree-nonleaf->rulename?
               (nth 0
                    (nth 0
                         (abnf::tree-nonleaf->branches abnf::cst))))
          (abnf::rulename "ordinary-compilation-unit"))
   1)
  ((equal (abnf::tree-nonleaf->rulename?
               (nth 0
                    (nth 0
                         (abnf::tree-nonleaf->branches abnf::cst))))
          (abnf::rulename "compact-compilation-unit"))
   2)
  ((equal (abnf::tree-nonleaf->rulename?
               (nth 0
                    (nth 0
                         (abnf::tree-nonleaf->branches abnf::cst))))
          (abnf::rulename "modular-compilation-unit"))
   3)
  (t (prog2$ (impossible) 1))))

Theorem: posp-of-cst-compilation-unit-conc?

(defthm posp-of-cst-compilation-unit-conc?
  (b* ((number (cst-compilation-unit-conc? abnf::cst)))
    (posp number))
  :rule-classes :rewrite)

Theorem: cst-compilation-unit-conc?-possibilities

(defthm cst-compilation-unit-conc?-possibilities
  (b* ((number (cst-compilation-unit-conc? abnf::cst)))
    (or (equal number 1)
        (equal number 2)
        (equal number 3)))
  :rule-classes
  ((:forward-chaining
        :trigger-terms ((cst-compilation-unit-conc? abnf::cst)))))

Theorem: cst-compilation-unit-conc?-of-tree-fix-cst

(defthm cst-compilation-unit-conc?-of-tree-fix-cst
  (equal (cst-compilation-unit-conc? (abnf::tree-fix abnf::cst))
         (cst-compilation-unit-conc? abnf::cst)))

Theorem: cst-compilation-unit-conc?-tree-equiv-congruence-on-cst

(defthm cst-compilation-unit-conc?-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-compilation-unit-conc? abnf::cst)
                  (cst-compilation-unit-conc? cst-equiv)))
  :rule-classes :congruence)

Theorem: cst-compilation-unit-conc?-1-iff-match-conc

(defthm cst-compilation-unit-conc?-1-iff-match-conc
  (implies (cst-matchp abnf::cst "compilation-unit")
           (iff (equal (cst-compilation-unit-conc? abnf::cst)
                       1)
                (cst-list-list-conc-matchp
                     (abnf::tree-nonleaf->branches abnf::cst)
                     "ordinary-compilation-unit"))))

Theorem: cst-compilation-unit-conc?-2-iff-match-conc

(defthm cst-compilation-unit-conc?-2-iff-match-conc
  (implies (cst-matchp abnf::cst "compilation-unit")
           (iff (equal (cst-compilation-unit-conc? abnf::cst)
                       2)
                (cst-list-list-conc-matchp
                     (abnf::tree-nonleaf->branches abnf::cst)
                     "compact-compilation-unit"))))

Theorem: cst-compilation-unit-conc?-3-iff-match-conc

(defthm cst-compilation-unit-conc?-3-iff-match-conc
  (implies (cst-matchp abnf::cst "compilation-unit")
           (iff (equal (cst-compilation-unit-conc? abnf::cst)
                       3)
                (cst-list-list-conc-matchp
                     (abnf::tree-nonleaf->branches abnf::cst)
                     "modular-compilation-unit"))))

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")))
 (cond
  ((equal (abnf::tree-nonleaf->rulename?
               (nth 0
                    (nth 0
                         (abnf::tree-nonleaf->branches abnf::cst))))
          (abnf::rulename "single-type-import-declaration"))
   1)
  ((equal (abnf::tree-nonleaf->rulename?
               (nth 0
                    (nth 0
                         (abnf::tree-nonleaf->branches abnf::cst))))
          (abnf::rulename "type-import-on-demand-declaration"))
   2)
  ((equal (abnf::tree-nonleaf->rulename?
               (nth 0
                    (nth 0
                         (abnf::tree-nonleaf->branches abnf::cst))))
          (abnf::rulename "single-static-import-declaration"))
   3)
  ((equal (abnf::tree-nonleaf->rulename?
               (nth 0
                    (nth 0
                         (abnf::tree-nonleaf->branches abnf::cst))))
          (abnf::rulename "static-import-on-demand-declaration"))
   4)
  ((equal (abnf::tree-nonleaf->rulename?
               (nth 0
                    (nth 0
                         (abnf::tree-nonleaf->branches abnf::cst))))
          (abnf::rulename "single-module-import-declaration"))
   5)
  (t (prog2$ (impossible) 1))))

Theorem: posp-of-cst-import-declaration-conc?

(defthm posp-of-cst-import-declaration-conc?
  (b* ((number (cst-import-declaration-conc? abnf::cst)))
    (posp number))
  :rule-classes :rewrite)

Theorem: cst-import-declaration-conc?-possibilities

(defthm cst-import-declaration-conc?-possibilities
  (b* ((number (cst-import-declaration-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-import-declaration-conc? abnf::cst)))))

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)

Theorem: cst-import-declaration-conc?-1-iff-match-conc

(defthm cst-import-declaration-conc?-1-iff-match-conc
  (implies (cst-matchp abnf::cst "import-declaration")
           (iff (equal (cst-import-declaration-conc? abnf::cst)
                       1)
                (cst-list-list-conc-matchp
                     (abnf::tree-nonleaf->branches abnf::cst)
                     "single-type-import-declaration"))))

Theorem: cst-import-declaration-conc?-2-iff-match-conc

(defthm cst-import-declaration-conc?-2-iff-match-conc
  (implies (cst-matchp abnf::cst "import-declaration")
           (iff (equal (cst-import-declaration-conc? abnf::cst)
                       2)
                (cst-list-list-conc-matchp
                     (abnf::tree-nonleaf->branches abnf::cst)
                     "type-import-on-demand-declaration"))))

Theorem: cst-import-declaration-conc?-3-iff-match-conc

(defthm cst-import-declaration-conc?-3-iff-match-conc
  (implies (cst-matchp abnf::cst "import-declaration")
           (iff (equal (cst-import-declaration-conc? abnf::cst)
                       3)
                (cst-list-list-conc-matchp
                     (abnf::tree-nonleaf->branches abnf::cst)
                     "single-static-import-declaration"))))

Theorem: cst-import-declaration-conc?-4-iff-match-conc

(defthm cst-import-declaration-conc?-4-iff-match-conc
  (implies (cst-matchp abnf::cst "import-declaration")
           (iff (equal (cst-import-declaration-conc? abnf::cst)
                       4)
                (cst-list-list-conc-matchp
                     (abnf::tree-nonleaf->branches abnf::cst)
                     "static-import-on-demand-declaration"))))

Theorem: cst-import-declaration-conc?-5-iff-match-conc

(defthm cst-import-declaration-conc?-5-iff-match-conc
  (implies (cst-matchp abnf::cst "import-declaration")
           (iff (equal (cst-import-declaration-conc? abnf::cst)
                       5)
                (cst-list-list-conc-matchp
                     (abnf::tree-nonleaf->branches abnf::cst)
                     "single-module-import-declaration"))))

Function: cst-class-declaration-conc?

(defun cst-class-declaration-conc? (abnf::cst)
 (declare (xargs :guard (abnf::treep abnf::cst)))
 (declare (xargs :guard (cst-matchp abnf::cst "class-declaration")))
 (cond
  ((equal (abnf::tree-nonleaf->rulename?
               (nth 0
                    (nth 0
                         (abnf::tree-nonleaf->branches abnf::cst))))
          (abnf::rulename "normal-class-declaration"))
   1)
  ((equal (abnf::tree-nonleaf->rulename?
               (nth 0
                    (nth 0
                         (abnf::tree-nonleaf->branches abnf::cst))))
          (abnf::rulename "enum-declaration"))
   2)
  ((equal (abnf::tree-nonleaf->rulename?
               (nth 0
                    (nth 0
                         (abnf::tree-nonleaf->branches abnf::cst))))
          (abnf::rulename "record-declaration"))
   3)
  (t (prog2$ (impossible) 1))))

Theorem: posp-of-cst-class-declaration-conc?

(defthm posp-of-cst-class-declaration-conc?
  (b* ((number (cst-class-declaration-conc? abnf::cst)))
    (posp number))
  :rule-classes :rewrite)

Theorem: cst-class-declaration-conc?-possibilities

(defthm cst-class-declaration-conc?-possibilities
  (b* ((number (cst-class-declaration-conc? abnf::cst)))
    (or (equal number 1)
        (equal number 2)
        (equal number 3)))
  :rule-classes
  ((:forward-chaining
        :trigger-terms ((cst-class-declaration-conc? abnf::cst)))))

Theorem: cst-class-declaration-conc?-of-tree-fix-cst

(defthm cst-class-declaration-conc?-of-tree-fix-cst
  (equal (cst-class-declaration-conc? (abnf::tree-fix abnf::cst))
         (cst-class-declaration-conc? abnf::cst)))

Theorem: cst-class-declaration-conc?-tree-equiv-congruence-on-cst

(defthm cst-class-declaration-conc?-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-class-declaration-conc? abnf::cst)
                  (cst-class-declaration-conc? cst-equiv)))
  :rule-classes :congruence)

Theorem: cst-class-declaration-conc?-1-iff-match-conc

(defthm cst-class-declaration-conc?-1-iff-match-conc
  (implies (cst-matchp abnf::cst "class-declaration")
           (iff (equal (cst-class-declaration-conc? abnf::cst)
                       1)
                (cst-list-list-conc-matchp
                     (abnf::tree-nonleaf->branches abnf::cst)
                     "normal-class-declaration"))))

Theorem: cst-class-declaration-conc?-2-iff-match-conc

(defthm cst-class-declaration-conc?-2-iff-match-conc
  (implies (cst-matchp abnf::cst "class-declaration")
           (iff (equal (cst-class-declaration-conc? abnf::cst)
                       2)
                (cst-list-list-conc-matchp
                     (abnf::tree-nonleaf->branches abnf::cst)
                     "enum-declaration"))))

Theorem: cst-class-declaration-conc?-3-iff-match-conc

(defthm cst-class-declaration-conc?-3-iff-match-conc
  (implies (cst-matchp abnf::cst "class-declaration")
           (iff (equal (cst-class-declaration-conc? abnf::cst)
                       3)
                (cst-list-list-conc-matchp
                     (abnf::tree-nonleaf->branches abnf::cst)
                     "record-declaration"))))

Function: cst-class-body-declaration-conc?

(defun cst-class-body-declaration-conc? (abnf::cst)
 (declare (xargs :guard (abnf::treep abnf::cst)))
 (declare
     (xargs :guard (cst-matchp abnf::cst "class-body-declaration")))
 (cond
  ((equal (abnf::tree-nonleaf->rulename?
               (nth 0
                    (nth 0
                         (abnf::tree-nonleaf->branches abnf::cst))))
          (abnf::rulename "class-member-declaration"))
   1)
  ((equal (abnf::tree-nonleaf->rulename?
               (nth 0
                    (nth 0
                         (abnf::tree-nonleaf->branches abnf::cst))))
          (abnf::rulename "instance-initializer"))
   2)
  ((equal (abnf::tree-nonleaf->rulename?
               (nth 0
                    (nth 0
                         (abnf::tree-nonleaf->branches abnf::cst))))
          (abnf::rulename "static-initializer"))
   3)
  ((equal (abnf::tree-nonleaf->rulename?
               (nth 0
                    (nth 0
                         (abnf::tree-nonleaf->branches abnf::cst))))
          (abnf::rulename "constructor-declaration"))
   4)
  (t (prog2$ (impossible) 1))))

Theorem: posp-of-cst-class-body-declaration-conc?

(defthm posp-of-cst-class-body-declaration-conc?
  (b* ((number (cst-class-body-declaration-conc? abnf::cst)))
    (posp number))
  :rule-classes :rewrite)

Theorem: cst-class-body-declaration-conc?-possibilities

(defthm cst-class-body-declaration-conc?-possibilities
 (b* ((number (cst-class-body-declaration-conc? abnf::cst)))
   (or (equal number 1)
       (equal number 2)
       (equal number 3)
       (equal number 4)))
 :rule-classes
 ((:forward-chaining
    :trigger-terms ((cst-class-body-declaration-conc? abnf::cst)))))

Theorem: cst-class-body-declaration-conc?-of-tree-fix-cst

(defthm cst-class-body-declaration-conc?-of-tree-fix-cst
  (equal
       (cst-class-body-declaration-conc? (abnf::tree-fix abnf::cst))
       (cst-class-body-declaration-conc? abnf::cst)))

Theorem: cst-class-body-declaration-conc?-tree-equiv-congruence-on-cst

(defthm
      cst-class-body-declaration-conc?-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-class-body-declaration-conc? abnf::cst)
                  (cst-class-body-declaration-conc? cst-equiv)))
  :rule-classes :congruence)

Theorem: cst-class-body-declaration-conc?-1-iff-match-conc

(defthm cst-class-body-declaration-conc?-1-iff-match-conc
  (implies (cst-matchp abnf::cst "class-body-declaration")
           (iff (equal (cst-class-body-declaration-conc? abnf::cst)
                       1)
                (cst-list-list-conc-matchp
                     (abnf::tree-nonleaf->branches abnf::cst)
                     "class-member-declaration"))))

Theorem: cst-class-body-declaration-conc?-2-iff-match-conc

(defthm cst-class-body-declaration-conc?-2-iff-match-conc
  (implies (cst-matchp abnf::cst "class-body-declaration")
           (iff (equal (cst-class-body-declaration-conc? abnf::cst)
                       2)
                (cst-list-list-conc-matchp
                     (abnf::tree-nonleaf->branches abnf::cst)
                     "instance-initializer"))))

Theorem: cst-class-body-declaration-conc?-3-iff-match-conc

(defthm cst-class-body-declaration-conc?-3-iff-match-conc
  (implies (cst-matchp abnf::cst "class-body-declaration")
           (iff (equal (cst-class-body-declaration-conc? abnf::cst)
                       3)
                (cst-list-list-conc-matchp
                     (abnf::tree-nonleaf->branches abnf::cst)
                     "static-initializer"))))

Theorem: cst-class-body-declaration-conc?-4-iff-match-conc

(defthm cst-class-body-declaration-conc?-4-iff-match-conc
  (implies (cst-matchp abnf::cst "class-body-declaration")
           (iff (equal (cst-class-body-declaration-conc? abnf::cst)
                       4)
                (cst-list-list-conc-matchp
                     (abnf::tree-nonleaf->branches abnf::cst)
                     "constructor-declaration"))))

Function: cst-variable-initializer-conc?

(defun cst-variable-initializer-conc? (abnf::cst)
 (declare (xargs :guard (abnf::treep abnf::cst)))
 (declare
      (xargs :guard (cst-matchp abnf::cst "variable-initializer")))
 (cond
  ((equal (abnf::tree-nonleaf->rulename?
               (nth 0
                    (nth 0
                         (abnf::tree-nonleaf->branches abnf::cst))))
          (abnf::rulename "expression"))
   1)
  ((equal (abnf::tree-nonleaf->rulename?
               (nth 0
                    (nth 0
                         (abnf::tree-nonleaf->branches abnf::cst))))
          (abnf::rulename "array-initializer"))
   2)
  (t (prog2$ (impossible) 1))))

Theorem: posp-of-cst-variable-initializer-conc?

(defthm posp-of-cst-variable-initializer-conc?
  (b* ((number (cst-variable-initializer-conc? abnf::cst)))
    (posp number))
  :rule-classes :rewrite)

Theorem: cst-variable-initializer-conc?-possibilities

(defthm cst-variable-initializer-conc?-possibilities
 (b* ((number (cst-variable-initializer-conc? abnf::cst)))
   (or (equal number 1) (equal number 2)))
 :rule-classes
 ((:forward-chaining
      :trigger-terms ((cst-variable-initializer-conc? abnf::cst)))))

Theorem: cst-variable-initializer-conc?-of-tree-fix-cst

(defthm cst-variable-initializer-conc?-of-tree-fix-cst
  (equal (cst-variable-initializer-conc? (abnf::tree-fix abnf::cst))
         (cst-variable-initializer-conc? abnf::cst)))

Theorem: cst-variable-initializer-conc?-tree-equiv-congruence-on-cst

(defthm cst-variable-initializer-conc?-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-variable-initializer-conc? abnf::cst)
                  (cst-variable-initializer-conc? cst-equiv)))
  :rule-classes :congruence)

Theorem: cst-variable-initializer-conc?-1-iff-match-conc

(defthm cst-variable-initializer-conc?-1-iff-match-conc
  (implies (cst-matchp abnf::cst "variable-initializer")
           (iff (equal (cst-variable-initializer-conc? abnf::cst)
                       1)
                (cst-list-list-conc-matchp
                     (abnf::tree-nonleaf->branches abnf::cst)
                     "expression"))))

Theorem: cst-variable-initializer-conc?-2-iff-match-conc

(defthm cst-variable-initializer-conc?-2-iff-match-conc
  (implies (cst-matchp abnf::cst "variable-initializer")
           (iff (equal (cst-variable-initializer-conc? abnf::cst)
                       2)
                (cst-list-list-conc-matchp
                     (abnf::tree-nonleaf->branches abnf::cst)
                     "array-initializer"))))

Function: cst-unann-type-conc?

(defun cst-unann-type-conc? (abnf::cst)
 (declare (xargs :guard (abnf::treep abnf::cst)))
 (declare (xargs :guard (cst-matchp abnf::cst "unann-type")))
 (cond
  ((equal (abnf::tree-nonleaf->rulename?
               (nth 0
                    (nth 0
                         (abnf::tree-nonleaf->branches abnf::cst))))
          (abnf::rulename "unann-primitive-type"))
   1)
  ((equal (abnf::tree-nonleaf->rulename?
               (nth 0
                    (nth 0
                         (abnf::tree-nonleaf->branches abnf::cst))))
          (abnf::rulename "unann-reference-type"))
   2)
  (t (prog2$ (impossible) 1))))

Theorem: posp-of-cst-unann-type-conc?

(defthm posp-of-cst-unann-type-conc?
  (b* ((number (cst-unann-type-conc? abnf::cst)))
    (posp number))
  :rule-classes :rewrite)

Theorem: cst-unann-type-conc?-possibilities

(defthm cst-unann-type-conc?-possibilities
  (b* ((number (cst-unann-type-conc? abnf::cst)))
    (or (equal number 1) (equal number 2)))
  :rule-classes
  ((:forward-chaining
        :trigger-terms ((cst-unann-type-conc? abnf::cst)))))

Theorem: cst-unann-type-conc?-of-tree-fix-cst

(defthm cst-unann-type-conc?-of-tree-fix-cst
  (equal (cst-unann-type-conc? (abnf::tree-fix abnf::cst))
         (cst-unann-type-conc? abnf::cst)))

Theorem: cst-unann-type-conc?-tree-equiv-congruence-on-cst

(defthm cst-unann-type-conc?-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-unann-type-conc? abnf::cst)
                  (cst-unann-type-conc? cst-equiv)))
  :rule-classes :congruence)

Theorem: cst-unann-type-conc?-1-iff-match-conc

(defthm cst-unann-type-conc?-1-iff-match-conc
  (implies (cst-matchp abnf::cst "unann-type")
           (iff (equal (cst-unann-type-conc? abnf::cst)
                       1)
                (cst-list-list-conc-matchp
                     (abnf::tree-nonleaf->branches abnf::cst)
                     "unann-primitive-type"))))

Theorem: cst-unann-type-conc?-2-iff-match-conc

(defthm cst-unann-type-conc?-2-iff-match-conc
  (implies (cst-matchp abnf::cst "unann-type")
           (iff (equal (cst-unann-type-conc? abnf::cst)
                       2)
                (cst-list-list-conc-matchp
                     (abnf::tree-nonleaf->branches abnf::cst)
                     "unann-reference-type"))))

Function: cst-unann-reference-type-conc?

(defun cst-unann-reference-type-conc? (abnf::cst)
 (declare (xargs :guard (abnf::treep abnf::cst)))
 (declare
      (xargs :guard (cst-matchp abnf::cst "unann-reference-type")))
 (cond
  ((equal (abnf::tree-nonleaf->rulename?
               (nth 0
                    (nth 0
                         (abnf::tree-nonleaf->branches abnf::cst))))
          (abnf::rulename "unann-class-or-interface-type"))
   1)
  ((equal (abnf::tree-nonleaf->rulename?
               (nth 0
                    (nth 0
                         (abnf::tree-nonleaf->branches abnf::cst))))
          (abnf::rulename "unann-type-variable"))
   2)
  ((equal (abnf::tree-nonleaf->rulename?
               (nth 0
                    (nth 0
                         (abnf::tree-nonleaf->branches abnf::cst))))
          (abnf::rulename "unann-array-type"))
   3)
  (t (prog2$ (impossible) 1))))

Theorem: posp-of-cst-unann-reference-type-conc?

(defthm posp-of-cst-unann-reference-type-conc?
  (b* ((number (cst-unann-reference-type-conc? abnf::cst)))
    (posp number))
  :rule-classes :rewrite)

Theorem: cst-unann-reference-type-conc?-possibilities

(defthm cst-unann-reference-type-conc?-possibilities
 (b* ((number (cst-unann-reference-type-conc? abnf::cst)))
   (or (equal number 1)
       (equal number 2)
       (equal number 3)))
 :rule-classes
 ((:forward-chaining
      :trigger-terms ((cst-unann-reference-type-conc? abnf::cst)))))

Theorem: cst-unann-reference-type-conc?-of-tree-fix-cst

(defthm cst-unann-reference-type-conc?-of-tree-fix-cst
  (equal (cst-unann-reference-type-conc? (abnf::tree-fix abnf::cst))
         (cst-unann-reference-type-conc? abnf::cst)))

Theorem: cst-unann-reference-type-conc?-tree-equiv-congruence-on-cst

(defthm cst-unann-reference-type-conc?-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-unann-reference-type-conc? abnf::cst)
                  (cst-unann-reference-type-conc? cst-equiv)))
  :rule-classes :congruence)

Theorem: cst-unann-reference-type-conc?-1-iff-match-conc

(defthm cst-unann-reference-type-conc?-1-iff-match-conc
  (implies (cst-matchp abnf::cst "unann-reference-type")
           (iff (equal (cst-unann-reference-type-conc? abnf::cst)
                       1)
                (cst-list-list-conc-matchp
                     (abnf::tree-nonleaf->branches abnf::cst)
                     "unann-class-or-interface-type"))))

Theorem: cst-unann-reference-type-conc?-2-iff-match-conc

(defthm cst-unann-reference-type-conc?-2-iff-match-conc
  (implies (cst-matchp abnf::cst "unann-reference-type")
           (iff (equal (cst-unann-reference-type-conc? abnf::cst)
                       2)
                (cst-list-list-conc-matchp
                     (abnf::tree-nonleaf->branches abnf::cst)
                     "unann-type-variable"))))

Theorem: cst-unann-reference-type-conc?-3-iff-match-conc

(defthm cst-unann-reference-type-conc?-3-iff-match-conc
  (implies (cst-matchp abnf::cst "unann-reference-type")
           (iff (equal (cst-unann-reference-type-conc? abnf::cst)
                       3)
                (cst-list-list-conc-matchp
                     (abnf::tree-nonleaf->branches abnf::cst)
                     "unann-array-type"))))

Function: cst-unann-class-or-interface-type-conc?

(defun cst-unann-class-or-interface-type-conc? (abnf::cst)
 (declare (xargs :guard (abnf::treep abnf::cst)))
 (declare
      (xargs :guard (cst-matchp abnf::cst
                                "unann-class-or-interface-type")))
 (cond
  ((equal (abnf::tree-nonleaf->rulename?
               (nth 0
                    (nth 0
                         (abnf::tree-nonleaf->branches abnf::cst))))
          (abnf::rulename "unann-class-type"))
   1)
  ((equal (abnf::tree-nonleaf->rulename?
               (nth 0
                    (nth 0
                         (abnf::tree-nonleaf->branches abnf::cst))))
          (abnf::rulename "unann-interface-type"))
   2)
  (t (prog2$ (impossible) 1))))

Theorem: posp-of-cst-unann-class-or-interface-type-conc?

(defthm posp-of-cst-unann-class-or-interface-type-conc?
  (b* ((number (cst-unann-class-or-interface-type-conc? abnf::cst)))
    (posp number))
  :rule-classes :rewrite)

Theorem: cst-unann-class-or-interface-type-conc?-possibilities

(defthm cst-unann-class-or-interface-type-conc?-possibilities
  (b* ((number (cst-unann-class-or-interface-type-conc? abnf::cst)))
    (or (equal number 1) (equal number 2)))
  :rule-classes
  ((:forward-chaining
        :trigger-terms
        ((cst-unann-class-or-interface-type-conc? abnf::cst)))))

Theorem: cst-unann-class-or-interface-type-conc?-of-tree-fix-cst

(defthm cst-unann-class-or-interface-type-conc?-of-tree-fix-cst
  (equal (cst-unann-class-or-interface-type-conc?
              (abnf::tree-fix abnf::cst))
         (cst-unann-class-or-interface-type-conc? abnf::cst)))

Theorem: cst-unann-class-or-interface-type-conc?-tree-equiv-congruence-on-cst

(defthm
 cst-unann-class-or-interface-type-conc?-tree-equiv-congruence-on-cst
 (implies
      (abnf::tree-equiv abnf::cst cst-equiv)
      (equal (cst-unann-class-or-interface-type-conc? abnf::cst)
             (cst-unann-class-or-interface-type-conc? cst-equiv)))
 :rule-classes :congruence)

Theorem: cst-unann-class-or-interface-type-conc?-1-iff-match-conc

(defthm cst-unann-class-or-interface-type-conc?-1-iff-match-conc
 (implies
     (cst-matchp abnf::cst
                 "unann-class-or-interface-type")
     (iff (equal (cst-unann-class-or-interface-type-conc? abnf::cst)
                 1)
          (cst-list-list-conc-matchp
               (abnf::tree-nonleaf->branches abnf::cst)
               "unann-class-type"))))

Theorem: cst-unann-class-or-interface-type-conc?-2-iff-match-conc

(defthm cst-unann-class-or-interface-type-conc?-2-iff-match-conc
 (implies
     (cst-matchp abnf::cst
                 "unann-class-or-interface-type")
     (iff (equal (cst-unann-class-or-interface-type-conc? abnf::cst)
                 2)
          (cst-list-list-conc-matchp
               (abnf::tree-nonleaf->branches abnf::cst)
               "unann-interface-type"))))

Function: cst-exception-type-conc?

(defun cst-exception-type-conc? (abnf::cst)
 (declare (xargs :guard (abnf::treep abnf::cst)))
 (declare (xargs :guard (cst-matchp abnf::cst "exception-type")))
 (cond
  ((equal (abnf::tree-nonleaf->rulename?
               (nth 0
                    (nth 0
                         (abnf::tree-nonleaf->branches abnf::cst))))
          (abnf::rulename "class-type"))
   1)
  ((equal (abnf::tree-nonleaf->rulename?
               (nth 0
                    (nth 0
                         (abnf::tree-nonleaf->branches abnf::cst))))
          (abnf::rulename "type-variable"))
   2)
  (t (prog2$ (impossible) 1))))

Theorem: posp-of-cst-exception-type-conc?

(defthm posp-of-cst-exception-type-conc?
  (b* ((number (cst-exception-type-conc? abnf::cst)))
    (posp number))
  :rule-classes :rewrite)

Theorem: cst-exception-type-conc?-possibilities

(defthm cst-exception-type-conc?-possibilities
  (b* ((number (cst-exception-type-conc? abnf::cst)))
    (or (equal number 1) (equal number 2)))
  :rule-classes
  ((:forward-chaining
        :trigger-terms ((cst-exception-type-conc? abnf::cst)))))

Theorem: cst-exception-type-conc?-of-tree-fix-cst

(defthm cst-exception-type-conc?-of-tree-fix-cst
  (equal (cst-exception-type-conc? (abnf::tree-fix abnf::cst))
         (cst-exception-type-conc? abnf::cst)))

Theorem: cst-exception-type-conc?-tree-equiv-congruence-on-cst

(defthm cst-exception-type-conc?-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-exception-type-conc? abnf::cst)
                  (cst-exception-type-conc? cst-equiv)))
  :rule-classes :congruence)

Theorem: cst-exception-type-conc?-1-iff-match-conc

(defthm cst-exception-type-conc?-1-iff-match-conc
  (implies (cst-matchp abnf::cst "exception-type")
           (iff (equal (cst-exception-type-conc? abnf::cst)
                       1)
                (cst-list-list-conc-matchp
                     (abnf::tree-nonleaf->branches abnf::cst)
                     "class-type"))))

Theorem: cst-exception-type-conc?-2-iff-match-conc

(defthm cst-exception-type-conc?-2-iff-match-conc
  (implies (cst-matchp abnf::cst "exception-type")
           (iff (equal (cst-exception-type-conc? abnf::cst)
                       2)
                (cst-list-list-conc-matchp
                     (abnf::tree-nonleaf->branches abnf::cst)
                     "type-variable"))))

Function: cst-record-body-declaration-conc?

(defun cst-record-body-declaration-conc? (abnf::cst)
 (declare (xargs :guard (abnf::treep abnf::cst)))
 (declare
    (xargs :guard (cst-matchp abnf::cst "record-body-declaration")))
 (cond
  ((equal (abnf::tree-nonleaf->rulename?
               (nth 0
                    (nth 0
                         (abnf::tree-nonleaf->branches abnf::cst))))
          (abnf::rulename "class-body-declaration"))
   1)
  ((equal (abnf::tree-nonleaf->rulename?
               (nth 0
                    (nth 0
                         (abnf::tree-nonleaf->branches abnf::cst))))
          (abnf::rulename "compact-constructor-declaration"))
   2)
  (t (prog2$ (impossible) 1))))

Theorem: posp-of-cst-record-body-declaration-conc?

(defthm posp-of-cst-record-body-declaration-conc?
  (b* ((number (cst-record-body-declaration-conc? abnf::cst)))
    (posp number))
  :rule-classes :rewrite)

Theorem: cst-record-body-declaration-conc?-possibilities

(defthm cst-record-body-declaration-conc?-possibilities
 (b* ((number (cst-record-body-declaration-conc? abnf::cst)))
   (or (equal number 1) (equal number 2)))
 :rule-classes
 ((:forward-chaining
   :trigger-terms ((cst-record-body-declaration-conc? abnf::cst)))))

Theorem: cst-record-body-declaration-conc?-of-tree-fix-cst

(defthm cst-record-body-declaration-conc?-of-tree-fix-cst
 (equal
      (cst-record-body-declaration-conc? (abnf::tree-fix abnf::cst))
      (cst-record-body-declaration-conc? abnf::cst)))

Theorem: cst-record-body-declaration-conc?-tree-equiv-congruence-on-cst

(defthm
     cst-record-body-declaration-conc?-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-record-body-declaration-conc? abnf::cst)
                  (cst-record-body-declaration-conc? cst-equiv)))
  :rule-classes :congruence)

Theorem: cst-record-body-declaration-conc?-1-iff-match-conc

(defthm cst-record-body-declaration-conc?-1-iff-match-conc
  (implies (cst-matchp abnf::cst "record-body-declaration")
           (iff (equal (cst-record-body-declaration-conc? abnf::cst)
                       1)
                (cst-list-list-conc-matchp
                     (abnf::tree-nonleaf->branches abnf::cst)
                     "class-body-declaration"))))

Theorem: cst-record-body-declaration-conc?-2-iff-match-conc

(defthm cst-record-body-declaration-conc?-2-iff-match-conc
  (implies (cst-matchp abnf::cst "record-body-declaration")
           (iff (equal (cst-record-body-declaration-conc? abnf::cst)
                       2)
                (cst-list-list-conc-matchp
                     (abnf::tree-nonleaf->branches abnf::cst)
                     "compact-constructor-declaration"))))

Function: cst-interface-declaration-conc?

(defun cst-interface-declaration-conc? (abnf::cst)
 (declare (xargs :guard (abnf::treep abnf::cst)))
 (declare
      (xargs :guard (cst-matchp abnf::cst "interface-declaration")))
 (cond
  ((equal (abnf::tree-nonleaf->rulename?
               (nth 0
                    (nth 0
                         (abnf::tree-nonleaf->branches abnf::cst))))
          (abnf::rulename "normal-interface-declaration"))
   1)
  ((equal (abnf::tree-nonleaf->rulename?
               (nth 0
                    (nth 0
                         (abnf::tree-nonleaf->branches abnf::cst))))
          (abnf::rulename "annotation-interface-declaration"))
   2)
  (t (prog2$ (impossible) 1))))

Theorem: posp-of-cst-interface-declaration-conc?

(defthm posp-of-cst-interface-declaration-conc?
  (b* ((number (cst-interface-declaration-conc? abnf::cst)))
    (posp number))
  :rule-classes :rewrite)

Theorem: cst-interface-declaration-conc?-possibilities

(defthm cst-interface-declaration-conc?-possibilities
 (b* ((number (cst-interface-declaration-conc? abnf::cst)))
   (or (equal number 1) (equal number 2)))
 :rule-classes
 ((:forward-chaining
     :trigger-terms ((cst-interface-declaration-conc? abnf::cst)))))

Theorem: cst-interface-declaration-conc?-of-tree-fix-cst

(defthm cst-interface-declaration-conc?-of-tree-fix-cst
 (equal (cst-interface-declaration-conc? (abnf::tree-fix abnf::cst))
        (cst-interface-declaration-conc? abnf::cst)))

Theorem: cst-interface-declaration-conc?-tree-equiv-congruence-on-cst

(defthm cst-interface-declaration-conc?-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-interface-declaration-conc? abnf::cst)
                  (cst-interface-declaration-conc? cst-equiv)))
  :rule-classes :congruence)

Theorem: cst-interface-declaration-conc?-1-iff-match-conc

(defthm cst-interface-declaration-conc?-1-iff-match-conc
  (implies (cst-matchp abnf::cst "interface-declaration")
           (iff (equal (cst-interface-declaration-conc? abnf::cst)
                       1)
                (cst-list-list-conc-matchp
                     (abnf::tree-nonleaf->branches abnf::cst)
                     "normal-interface-declaration"))))

Theorem: cst-interface-declaration-conc?-2-iff-match-conc

(defthm cst-interface-declaration-conc?-2-iff-match-conc
  (implies (cst-matchp abnf::cst "interface-declaration")
           (iff (equal (cst-interface-declaration-conc? abnf::cst)
                       2)
                (cst-list-list-conc-matchp
                     (abnf::tree-nonleaf->branches abnf::cst)
                     "annotation-interface-declaration"))))

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")))
 (cond
  ((equal (abnf::tree-nonleaf->rulename?
               (nth 0
                    (nth 0
                         (abnf::tree-nonleaf->branches abnf::cst))))
          (abnf::rulename "normal-annotation"))
   1)
  ((equal (abnf::tree-nonleaf->rulename?
               (nth 0
                    (nth 0
                         (abnf::tree-nonleaf->branches abnf::cst))))
          (abnf::rulename "marker-annotation"))
   2)
  ((equal (abnf::tree-nonleaf->rulename?
               (nth 0
                    (nth 0
                         (abnf::tree-nonleaf->branches abnf::cst))))
          (abnf::rulename "single-element-annotation"))
   3)
  (t (prog2$ (impossible) 1))))

Theorem: posp-of-cst-annotation-conc?

(defthm posp-of-cst-annotation-conc?
  (b* ((number (cst-annotation-conc? abnf::cst)))
    (posp number))
  :rule-classes :rewrite)

Theorem: cst-annotation-conc?-possibilities

(defthm cst-annotation-conc?-possibilities
  (b* ((number (cst-annotation-conc? abnf::cst)))
    (or (equal number 1)
        (equal number 2)
        (equal number 3)))
  :rule-classes
  ((:forward-chaining
        :trigger-terms ((cst-annotation-conc? abnf::cst)))))

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)

Theorem: cst-annotation-conc?-1-iff-match-conc

(defthm cst-annotation-conc?-1-iff-match-conc
  (implies (cst-matchp abnf::cst "annotation")
           (iff (equal (cst-annotation-conc? abnf::cst)
                       1)
                (cst-list-list-conc-matchp
                     (abnf::tree-nonleaf->branches abnf::cst)
                     "normal-annotation"))))

Theorem: cst-annotation-conc?-2-iff-match-conc

(defthm cst-annotation-conc?-2-iff-match-conc
  (implies (cst-matchp abnf::cst "annotation")
           (iff (equal (cst-annotation-conc? abnf::cst)
                       2)
                (cst-list-list-conc-matchp
                     (abnf::tree-nonleaf->branches abnf::cst)
                     "marker-annotation"))))

Theorem: cst-annotation-conc?-3-iff-match-conc

(defthm cst-annotation-conc?-3-iff-match-conc
  (implies (cst-matchp abnf::cst "annotation")
           (iff (equal (cst-annotation-conc? abnf::cst)
                       3)
                (cst-list-list-conc-matchp
                     (abnf::tree-nonleaf->branches abnf::cst)
                     "single-element-annotation"))))

Function: cst-element-value-conc?

(defun cst-element-value-conc? (abnf::cst)
 (declare (xargs :guard (abnf::treep abnf::cst)))
 (declare (xargs :guard (cst-matchp abnf::cst "element-value")))
 (cond
  ((equal (abnf::tree-nonleaf->rulename?
               (nth 0
                    (nth 0
                         (abnf::tree-nonleaf->branches abnf::cst))))
          (abnf::rulename "conditional-expression"))
   1)
  ((equal (abnf::tree-nonleaf->rulename?
               (nth 0
                    (nth 0
                         (abnf::tree-nonleaf->branches abnf::cst))))
          (abnf::rulename "element-value-array-initializer"))
   2)
  ((equal (abnf::tree-nonleaf->rulename?
               (nth 0
                    (nth 0
                         (abnf::tree-nonleaf->branches abnf::cst))))
          (abnf::rulename "annotation"))
   3)
  (t (prog2$ (impossible) 1))))

Theorem: posp-of-cst-element-value-conc?

(defthm posp-of-cst-element-value-conc?
  (b* ((number (cst-element-value-conc? abnf::cst)))
    (posp number))
  :rule-classes :rewrite)

Theorem: cst-element-value-conc?-possibilities

(defthm cst-element-value-conc?-possibilities
  (b* ((number (cst-element-value-conc? abnf::cst)))
    (or (equal number 1)
        (equal number 2)
        (equal number 3)))
  :rule-classes
  ((:forward-chaining
        :trigger-terms ((cst-element-value-conc? abnf::cst)))))

Theorem: cst-element-value-conc?-of-tree-fix-cst

(defthm cst-element-value-conc?-of-tree-fix-cst
  (equal (cst-element-value-conc? (abnf::tree-fix abnf::cst))
         (cst-element-value-conc? abnf::cst)))

Theorem: cst-element-value-conc?-tree-equiv-congruence-on-cst

(defthm cst-element-value-conc?-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-element-value-conc? abnf::cst)
                  (cst-element-value-conc? cst-equiv)))
  :rule-classes :congruence)

Theorem: cst-element-value-conc?-1-iff-match-conc

(defthm cst-element-value-conc?-1-iff-match-conc
  (implies (cst-matchp abnf::cst "element-value")
           (iff (equal (cst-element-value-conc? abnf::cst)
                       1)
                (cst-list-list-conc-matchp
                     (abnf::tree-nonleaf->branches abnf::cst)
                     "conditional-expression"))))

Theorem: cst-element-value-conc?-2-iff-match-conc

(defthm cst-element-value-conc?-2-iff-match-conc
  (implies (cst-matchp abnf::cst "element-value")
           (iff (equal (cst-element-value-conc? abnf::cst)
                       2)
                (cst-list-list-conc-matchp
                     (abnf::tree-nonleaf->branches abnf::cst)
                     "element-value-array-initializer"))))

Theorem: cst-element-value-conc?-3-iff-match-conc

(defthm cst-element-value-conc?-3-iff-match-conc
  (implies (cst-matchp abnf::cst "element-value")
           (iff (equal (cst-element-value-conc? abnf::cst)
                       3)
                (cst-list-list-conc-matchp
                     (abnf::tree-nonleaf->branches abnf::cst)
                     "annotation"))))

Function: cst-block-statement-conc?

(defun cst-block-statement-conc? (abnf::cst)
 (declare (xargs :guard (abnf::treep abnf::cst)))
 (declare (xargs :guard (cst-matchp abnf::cst "block-statement")))
 (cond
  ((equal (abnf::tree-nonleaf->rulename?
               (nth 0
                    (nth 0
                         (abnf::tree-nonleaf->branches abnf::cst))))
          (abnf::rulename "local-class-or-interface-declaration"))
   1)
  ((equal (abnf::tree-nonleaf->rulename?
               (nth 0
                    (nth 0
                         (abnf::tree-nonleaf->branches abnf::cst))))
          (abnf::rulename "local-variable-declaration-statement"))
   2)
  ((equal (abnf::tree-nonleaf->rulename?
               (nth 0
                    (nth 0
                         (abnf::tree-nonleaf->branches abnf::cst))))
          (abnf::rulename "statement"))
   3)
  (t (prog2$ (impossible) 1))))

Theorem: posp-of-cst-block-statement-conc?

(defthm posp-of-cst-block-statement-conc?
  (b* ((number (cst-block-statement-conc? abnf::cst)))
    (posp number))
  :rule-classes :rewrite)

Theorem: cst-block-statement-conc?-possibilities

(defthm cst-block-statement-conc?-possibilities
  (b* ((number (cst-block-statement-conc? abnf::cst)))
    (or (equal number 1)
        (equal number 2)
        (equal number 3)))
  :rule-classes
  ((:forward-chaining
        :trigger-terms ((cst-block-statement-conc? abnf::cst)))))

Theorem: cst-block-statement-conc?-of-tree-fix-cst

(defthm cst-block-statement-conc?-of-tree-fix-cst
  (equal (cst-block-statement-conc? (abnf::tree-fix abnf::cst))
         (cst-block-statement-conc? abnf::cst)))

Theorem: cst-block-statement-conc?-tree-equiv-congruence-on-cst

(defthm cst-block-statement-conc?-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-block-statement-conc? abnf::cst)
                  (cst-block-statement-conc? cst-equiv)))
  :rule-classes :congruence)

Theorem: cst-block-statement-conc?-1-iff-match-conc

(defthm cst-block-statement-conc?-1-iff-match-conc
  (implies (cst-matchp abnf::cst "block-statement")
           (iff (equal (cst-block-statement-conc? abnf::cst)
                       1)
                (cst-list-list-conc-matchp
                     (abnf::tree-nonleaf->branches abnf::cst)
                     "local-class-or-interface-declaration"))))

Theorem: cst-block-statement-conc?-2-iff-match-conc

(defthm cst-block-statement-conc?-2-iff-match-conc
  (implies (cst-matchp abnf::cst "block-statement")
           (iff (equal (cst-block-statement-conc? abnf::cst)
                       2)
                (cst-list-list-conc-matchp
                     (abnf::tree-nonleaf->branches abnf::cst)
                     "local-variable-declaration-statement"))))

Theorem: cst-block-statement-conc?-3-iff-match-conc

(defthm cst-block-statement-conc?-3-iff-match-conc
  (implies (cst-matchp abnf::cst "block-statement")
           (iff (equal (cst-block-statement-conc? abnf::cst)
                       3)
                (cst-list-list-conc-matchp
                     (abnf::tree-nonleaf->branches abnf::cst)
                     "statement"))))

Function: cst-local-class-or-interface-declaration-conc?

(defun cst-local-class-or-interface-declaration-conc? (abnf::cst)
 (declare (xargs :guard (abnf::treep abnf::cst)))
 (declare
   (xargs
        :guard (cst-matchp abnf::cst
                           "local-class-or-interface-declaration")))
 (cond
  ((equal (abnf::tree-nonleaf->rulename?
               (nth 0
                    (nth 0
                         (abnf::tree-nonleaf->branches abnf::cst))))
          (abnf::rulename "class-declaration"))
   1)
  ((equal (abnf::tree-nonleaf->rulename?
               (nth 0
                    (nth 0
                         (abnf::tree-nonleaf->branches abnf::cst))))
          (abnf::rulename "normal-interface-declaration"))
   2)
  (t (prog2$ (impossible) 1))))

Theorem: posp-of-cst-local-class-or-interface-declaration-conc?

(defthm posp-of-cst-local-class-or-interface-declaration-conc?
 (b*
  ((number
        (cst-local-class-or-interface-declaration-conc? abnf::cst)))
  (posp number))
 :rule-classes :rewrite)

Theorem: cst-local-class-or-interface-declaration-conc?-possibilities

(defthm cst-local-class-or-interface-declaration-conc?-possibilities
 (b*
  ((number
        (cst-local-class-or-interface-declaration-conc? abnf::cst)))
  (or (equal number 1) (equal number 2)))
 :rule-classes
 ((:forward-chaining
     :trigger-terms
     ((cst-local-class-or-interface-declaration-conc? abnf::cst)))))

Theorem: cst-local-class-or-interface-declaration-conc?-of-tree-fix-cst

(defthm
     cst-local-class-or-interface-declaration-conc?-of-tree-fix-cst
 (equal (cst-local-class-or-interface-declaration-conc?
             (abnf::tree-fix abnf::cst))
        (cst-local-class-or-interface-declaration-conc? abnf::cst)))

Theorem: cst-local-class-or-interface-declaration-conc?-tree-equiv-congruence-on-cst

(defthm
 cst-local-class-or-interface-declaration-conc?-tree-equiv-congruence-on-cst
 (implies
   (abnf::tree-equiv abnf::cst cst-equiv)
   (equal
        (cst-local-class-or-interface-declaration-conc? abnf::cst)
        (cst-local-class-or-interface-declaration-conc? cst-equiv)))
 :rule-classes :congruence)

Theorem: cst-local-class-or-interface-declaration-conc?-1-iff-match-conc

(defthm
    cst-local-class-or-interface-declaration-conc?-1-iff-match-conc
 (implies
  (cst-matchp abnf::cst
              "local-class-or-interface-declaration")
  (iff
   (equal (cst-local-class-or-interface-declaration-conc? abnf::cst)
          1)
   (cst-list-list-conc-matchp
        (abnf::tree-nonleaf->branches abnf::cst)
        "class-declaration"))))

Theorem: cst-local-class-or-interface-declaration-conc?-2-iff-match-conc

(defthm
    cst-local-class-or-interface-declaration-conc?-2-iff-match-conc
 (implies
  (cst-matchp abnf::cst
              "local-class-or-interface-declaration")
  (iff
   (equal (cst-local-class-or-interface-declaration-conc? abnf::cst)
          2)
   (cst-list-list-conc-matchp
        (abnf::tree-nonleaf->branches abnf::cst)
        "normal-interface-declaration"))))

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")))
 (cond
  ((equal
        (abnf::tree-nonleaf->rulename?
             (nth 0
                  (nth 0
                       (abnf::tree-nonleaf->branches abnf::cst))))
        (abnf::rulename "statement-without-trailing-substatement"))
   1)
  ((equal (abnf::tree-nonleaf->rulename?
               (nth 0
                    (nth 0
                         (abnf::tree-nonleaf->branches abnf::cst))))
          (abnf::rulename "labeled-statement"))
   2)
  ((equal (abnf::tree-nonleaf->rulename?
               (nth 0
                    (nth 0
                         (abnf::tree-nonleaf->branches abnf::cst))))
          (abnf::rulename "if-then-statement"))
   3)
  ((equal (abnf::tree-nonleaf->rulename?
               (nth 0
                    (nth 0
                         (abnf::tree-nonleaf->branches abnf::cst))))
          (abnf::rulename "if-then-else-statement"))
   4)
  ((equal (abnf::tree-nonleaf->rulename?
               (nth 0
                    (nth 0
                         (abnf::tree-nonleaf->branches abnf::cst))))
          (abnf::rulename "while-statement"))
   5)
  ((equal (abnf::tree-nonleaf->rulename?
               (nth 0
                    (nth 0
                         (abnf::tree-nonleaf->branches abnf::cst))))
          (abnf::rulename "for-statement"))
   6)
  (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)))
  :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)
                     "statement-without-trailing-substatement"))))

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)
                     "labeled-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)
                     "if-then-statement"))))

Theorem: cst-statement-conc?-4-iff-match-conc

(defthm cst-statement-conc?-4-iff-match-conc
  (implies (cst-matchp abnf::cst "statement")
           (iff (equal (cst-statement-conc? abnf::cst)
                       4)
                (cst-list-list-conc-matchp
                     (abnf::tree-nonleaf->branches abnf::cst)
                     "if-then-else-statement"))))

Theorem: cst-statement-conc?-5-iff-match-conc

(defthm cst-statement-conc?-5-iff-match-conc
  (implies (cst-matchp abnf::cst "statement")
           (iff (equal (cst-statement-conc? abnf::cst)
                       5)
                (cst-list-list-conc-matchp
                     (abnf::tree-nonleaf->branches abnf::cst)
                     "while-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)
                     "for-statement"))))

Function: cst-statement-no-short-if-conc?

(defun cst-statement-no-short-if-conc? (abnf::cst)
 (declare (xargs :guard (abnf::treep abnf::cst)))
 (declare
      (xargs :guard (cst-matchp abnf::cst "statement-no-short-if")))
 (cond
  ((equal
        (abnf::tree-nonleaf->rulename?
             (nth 0
                  (nth 0
                       (abnf::tree-nonleaf->branches abnf::cst))))
        (abnf::rulename "statement-without-trailing-substatement"))
   1)
  ((equal (abnf::tree-nonleaf->rulename?
               (nth 0
                    (nth 0
                         (abnf::tree-nonleaf->branches abnf::cst))))
          (abnf::rulename "labeled-statement-no-short-if"))
   2)
  ((equal (abnf::tree-nonleaf->rulename?
               (nth 0
                    (nth 0
                         (abnf::tree-nonleaf->branches abnf::cst))))
          (abnf::rulename "if-then-else-statement-no-short-if"))
   3)
  ((equal (abnf::tree-nonleaf->rulename?
               (nth 0
                    (nth 0
                         (abnf::tree-nonleaf->branches abnf::cst))))
          (abnf::rulename "while-statement-no-short-if"))
   4)
  ((equal (abnf::tree-nonleaf->rulename?
               (nth 0
                    (nth 0
                         (abnf::tree-nonleaf->branches abnf::cst))))
          (abnf::rulename "for-statement-no-short-if"))
   5)
  (t (prog2$ (impossible) 1))))

Theorem: posp-of-cst-statement-no-short-if-conc?

(defthm posp-of-cst-statement-no-short-if-conc?
  (b* ((number (cst-statement-no-short-if-conc? abnf::cst)))
    (posp number))
  :rule-classes :rewrite)

Theorem: cst-statement-no-short-if-conc?-possibilities

(defthm cst-statement-no-short-if-conc?-possibilities
 (b* ((number (cst-statement-no-short-if-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-statement-no-short-if-conc? abnf::cst)))))

Theorem: cst-statement-no-short-if-conc?-of-tree-fix-cst

(defthm cst-statement-no-short-if-conc?-of-tree-fix-cst
 (equal (cst-statement-no-short-if-conc? (abnf::tree-fix abnf::cst))
        (cst-statement-no-short-if-conc? abnf::cst)))

Theorem: cst-statement-no-short-if-conc?-tree-equiv-congruence-on-cst

(defthm cst-statement-no-short-if-conc?-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-statement-no-short-if-conc? abnf::cst)
                  (cst-statement-no-short-if-conc? cst-equiv)))
  :rule-classes :congruence)

Theorem: cst-statement-no-short-if-conc?-1-iff-match-conc

(defthm cst-statement-no-short-if-conc?-1-iff-match-conc
  (implies (cst-matchp abnf::cst "statement-no-short-if")
           (iff (equal (cst-statement-no-short-if-conc? abnf::cst)
                       1)
                (cst-list-list-conc-matchp
                     (abnf::tree-nonleaf->branches abnf::cst)
                     "statement-without-trailing-substatement"))))

Theorem: cst-statement-no-short-if-conc?-2-iff-match-conc

(defthm cst-statement-no-short-if-conc?-2-iff-match-conc
  (implies (cst-matchp abnf::cst "statement-no-short-if")
           (iff (equal (cst-statement-no-short-if-conc? abnf::cst)
                       2)
                (cst-list-list-conc-matchp
                     (abnf::tree-nonleaf->branches abnf::cst)
                     "labeled-statement-no-short-if"))))

Theorem: cst-statement-no-short-if-conc?-3-iff-match-conc

(defthm cst-statement-no-short-if-conc?-3-iff-match-conc
  (implies (cst-matchp abnf::cst "statement-no-short-if")
           (iff (equal (cst-statement-no-short-if-conc? abnf::cst)
                       3)
                (cst-list-list-conc-matchp
                     (abnf::tree-nonleaf->branches abnf::cst)
                     "if-then-else-statement-no-short-if"))))

Theorem: cst-statement-no-short-if-conc?-4-iff-match-conc

(defthm cst-statement-no-short-if-conc?-4-iff-match-conc
  (implies (cst-matchp abnf::cst "statement-no-short-if")
           (iff (equal (cst-statement-no-short-if-conc? abnf::cst)
                       4)
                (cst-list-list-conc-matchp
                     (abnf::tree-nonleaf->branches abnf::cst)
                     "while-statement-no-short-if"))))

Theorem: cst-statement-no-short-if-conc?-5-iff-match-conc

(defthm cst-statement-no-short-if-conc?-5-iff-match-conc
  (implies (cst-matchp abnf::cst "statement-no-short-if")
           (iff (equal (cst-statement-no-short-if-conc? abnf::cst)
                       5)
                (cst-list-list-conc-matchp
                     (abnf::tree-nonleaf->branches abnf::cst)
                     "for-statement-no-short-if"))))

Function: cst-statement-without-trailing-substatement-conc?

(defun cst-statement-without-trailing-substatement-conc? (abnf::cst)
 (declare (xargs :guard (abnf::treep abnf::cst)))
 (declare
  (xargs
     :guard (cst-matchp abnf::cst
                        "statement-without-trailing-substatement")))
 (cond
  ((equal (abnf::tree-nonleaf->rulename?
               (nth 0
                    (nth 0
                         (abnf::tree-nonleaf->branches abnf::cst))))
          (abnf::rulename "block"))
   1)
  ((equal (abnf::tree-nonleaf->rulename?
               (nth 0
                    (nth 0
                         (abnf::tree-nonleaf->branches abnf::cst))))
          (abnf::rulename "empty-statement"))
   2)
  ((equal (abnf::tree-nonleaf->rulename?
               (nth 0
                    (nth 0
                         (abnf::tree-nonleaf->branches abnf::cst))))
          (abnf::rulename "expression-statement"))
   3)
  ((equal (abnf::tree-nonleaf->rulename?
               (nth 0
                    (nth 0
                         (abnf::tree-nonleaf->branches abnf::cst))))
          (abnf::rulename "assert-statement"))
   4)
  ((equal (abnf::tree-nonleaf->rulename?
               (nth 0
                    (nth 0
                         (abnf::tree-nonleaf->branches abnf::cst))))
          (abnf::rulename "switch-statement"))
   5)
  ((equal (abnf::tree-nonleaf->rulename?
               (nth 0
                    (nth 0
                         (abnf::tree-nonleaf->branches abnf::cst))))
          (abnf::rulename "do-statement"))
   6)
  ((equal (abnf::tree-nonleaf->rulename?
               (nth 0
                    (nth 0
                         (abnf::tree-nonleaf->branches abnf::cst))))
          (abnf::rulename "break-statement"))
   7)
  ((equal (abnf::tree-nonleaf->rulename?
               (nth 0
                    (nth 0
                         (abnf::tree-nonleaf->branches abnf::cst))))
          (abnf::rulename "continue-statement"))
   8)
  ((equal (abnf::tree-nonleaf->rulename?
               (nth 0
                    (nth 0
                         (abnf::tree-nonleaf->branches abnf::cst))))
          (abnf::rulename "return-statement"))
   9)
  ((equal (abnf::tree-nonleaf->rulename?
               (nth 0
                    (nth 0
                         (abnf::tree-nonleaf->branches abnf::cst))))
          (abnf::rulename "synchronized-statement"))
   10)
  ((equal (abnf::tree-nonleaf->rulename?
               (nth 0
                    (nth 0
                         (abnf::tree-nonleaf->branches abnf::cst))))
          (abnf::rulename "throw-statement"))
   11)
  ((equal (abnf::tree-nonleaf->rulename?
               (nth 0
                    (nth 0
                         (abnf::tree-nonleaf->branches abnf::cst))))
          (abnf::rulename "try-statement"))
   12)
  ((equal (abnf::tree-nonleaf->rulename?
               (nth 0
                    (nth 0
                         (abnf::tree-nonleaf->branches abnf::cst))))
          (abnf::rulename "yield-statement"))
   13)
  (t (prog2$ (impossible) 1))))

Theorem: posp-of-cst-statement-without-trailing-substatement-conc?

(defthm posp-of-cst-statement-without-trailing-substatement-conc?
 (b*
  ((number
     (cst-statement-without-trailing-substatement-conc? abnf::cst)))
  (posp number))
 :rule-classes :rewrite)

Theorem: cst-statement-without-trailing-substatement-conc?-possibilities

(defthm
    cst-statement-without-trailing-substatement-conc?-possibilities
 (b*
  ((number
     (cst-statement-without-trailing-substatement-conc? abnf::cst)))
  (or (equal number 1)
      (equal number 2)
      (equal number 3)
      (equal number 4)
      (equal number 5)
      (equal number 6)
      (equal number 7)
      (equal number 8)
      (equal number 9)
      (equal number 10)
      (equal number 11)
      (equal number 12)
      (equal number 13)))
 :rule-classes
 ((:forward-chaining :trigger-terms ((cst-statement-without-trailing-substatement-conc?
                                          abnf::cst)))))

Theorem: cst-statement-without-trailing-substatement-conc?-of-tree-fix-cst

(defthm
  cst-statement-without-trailing-substatement-conc?-of-tree-fix-cst
 (equal
     (cst-statement-without-trailing-substatement-conc?
          (abnf::tree-fix abnf::cst))
     (cst-statement-without-trailing-substatement-conc? abnf::cst)))

Theorem: cst-statement-without-trailing-substatement-conc?-tree-equiv-congruence-on-cst

(defthm
 cst-statement-without-trailing-substatement-conc?-tree-equiv-congruence-on-cst
 (implies
  (abnf::tree-equiv abnf::cst cst-equiv)
  (equal
     (cst-statement-without-trailing-substatement-conc? abnf::cst)
     (cst-statement-without-trailing-substatement-conc? cst-equiv)))
 :rule-classes :congruence)

Theorem: cst-statement-without-trailing-substatement-conc?-1-iff-match-conc

(defthm
 cst-statement-without-trailing-substatement-conc?-1-iff-match-conc
 (implies
  (cst-matchp abnf::cst
              "statement-without-trailing-substatement")
  (iff
   (equal
       (cst-statement-without-trailing-substatement-conc? abnf::cst)
       1)
   (cst-list-list-conc-matchp
        (abnf::tree-nonleaf->branches abnf::cst)
        "block"))))

Theorem: cst-statement-without-trailing-substatement-conc?-2-iff-match-conc

(defthm
 cst-statement-without-trailing-substatement-conc?-2-iff-match-conc
 (implies
  (cst-matchp abnf::cst
              "statement-without-trailing-substatement")
  (iff
   (equal
       (cst-statement-without-trailing-substatement-conc? abnf::cst)
       2)
   (cst-list-list-conc-matchp
        (abnf::tree-nonleaf->branches abnf::cst)
        "empty-statement"))))

Theorem: cst-statement-without-trailing-substatement-conc?-3-iff-match-conc

(defthm
 cst-statement-without-trailing-substatement-conc?-3-iff-match-conc
 (implies
  (cst-matchp abnf::cst
              "statement-without-trailing-substatement")
  (iff
   (equal
       (cst-statement-without-trailing-substatement-conc? abnf::cst)
       3)
   (cst-list-list-conc-matchp
        (abnf::tree-nonleaf->branches abnf::cst)
        "expression-statement"))))

Theorem: cst-statement-without-trailing-substatement-conc?-4-iff-match-conc

(defthm
 cst-statement-without-trailing-substatement-conc?-4-iff-match-conc
 (implies
  (cst-matchp abnf::cst
              "statement-without-trailing-substatement")
  (iff
   (equal
       (cst-statement-without-trailing-substatement-conc? abnf::cst)
       4)
   (cst-list-list-conc-matchp
        (abnf::tree-nonleaf->branches abnf::cst)
        "assert-statement"))))

Theorem: cst-statement-without-trailing-substatement-conc?-5-iff-match-conc

(defthm
 cst-statement-without-trailing-substatement-conc?-5-iff-match-conc
 (implies
  (cst-matchp abnf::cst
              "statement-without-trailing-substatement")
  (iff
   (equal
       (cst-statement-without-trailing-substatement-conc? abnf::cst)
       5)
   (cst-list-list-conc-matchp
        (abnf::tree-nonleaf->branches abnf::cst)
        "switch-statement"))))

Theorem: cst-statement-without-trailing-substatement-conc?-6-iff-match-conc

(defthm
 cst-statement-without-trailing-substatement-conc?-6-iff-match-conc
 (implies
  (cst-matchp abnf::cst
              "statement-without-trailing-substatement")
  (iff
   (equal
       (cst-statement-without-trailing-substatement-conc? abnf::cst)
       6)
   (cst-list-list-conc-matchp
        (abnf::tree-nonleaf->branches abnf::cst)
        "do-statement"))))

Theorem: cst-statement-without-trailing-substatement-conc?-7-iff-match-conc

(defthm
 cst-statement-without-trailing-substatement-conc?-7-iff-match-conc
 (implies
  (cst-matchp abnf::cst
              "statement-without-trailing-substatement")
  (iff
   (equal
       (cst-statement-without-trailing-substatement-conc? abnf::cst)
       7)
   (cst-list-list-conc-matchp
        (abnf::tree-nonleaf->branches abnf::cst)
        "break-statement"))))

Theorem: cst-statement-without-trailing-substatement-conc?-8-iff-match-conc

(defthm
 cst-statement-without-trailing-substatement-conc?-8-iff-match-conc
 (implies
  (cst-matchp abnf::cst
              "statement-without-trailing-substatement")
  (iff
   (equal
       (cst-statement-without-trailing-substatement-conc? abnf::cst)
       8)
   (cst-list-list-conc-matchp
        (abnf::tree-nonleaf->branches abnf::cst)
        "continue-statement"))))

Theorem: cst-statement-without-trailing-substatement-conc?-9-iff-match-conc

(defthm
 cst-statement-without-trailing-substatement-conc?-9-iff-match-conc
 (implies
  (cst-matchp abnf::cst
              "statement-without-trailing-substatement")
  (iff
   (equal
       (cst-statement-without-trailing-substatement-conc? abnf::cst)
       9)
   (cst-list-list-conc-matchp
        (abnf::tree-nonleaf->branches abnf::cst)
        "return-statement"))))

Theorem: cst-statement-without-trailing-substatement-conc?-10-iff-match-conc

(defthm
 cst-statement-without-trailing-substatement-conc?-10-iff-match-conc
 (implies
  (cst-matchp abnf::cst
              "statement-without-trailing-substatement")
  (iff
   (equal
       (cst-statement-without-trailing-substatement-conc? abnf::cst)
       10)
   (cst-list-list-conc-matchp
        (abnf::tree-nonleaf->branches abnf::cst)
        "synchronized-statement"))))

Theorem: cst-statement-without-trailing-substatement-conc?-11-iff-match-conc

(defthm
 cst-statement-without-trailing-substatement-conc?-11-iff-match-conc
 (implies
  (cst-matchp abnf::cst
              "statement-without-trailing-substatement")
  (iff
   (equal
       (cst-statement-without-trailing-substatement-conc? abnf::cst)
       11)
   (cst-list-list-conc-matchp
        (abnf::tree-nonleaf->branches abnf::cst)
        "throw-statement"))))

Theorem: cst-statement-without-trailing-substatement-conc?-12-iff-match-conc

(defthm
 cst-statement-without-trailing-substatement-conc?-12-iff-match-conc
 (implies
  (cst-matchp abnf::cst
              "statement-without-trailing-substatement")
  (iff
   (equal
       (cst-statement-without-trailing-substatement-conc? abnf::cst)
       12)
   (cst-list-list-conc-matchp
        (abnf::tree-nonleaf->branches abnf::cst)
        "try-statement"))))

Theorem: cst-statement-without-trailing-substatement-conc?-13-iff-match-conc

(defthm
 cst-statement-without-trailing-substatement-conc?-13-iff-match-conc
 (implies
  (cst-matchp abnf::cst
              "statement-without-trailing-substatement")
  (iff
   (equal
       (cst-statement-without-trailing-substatement-conc? abnf::cst)
       13)
   (cst-list-list-conc-matchp
        (abnf::tree-nonleaf->branches abnf::cst)
        "yield-statement"))))

Function: cst-statement-expression-conc?

(defun cst-statement-expression-conc? (abnf::cst)
 (declare (xargs :guard (abnf::treep abnf::cst)))
 (declare
      (xargs :guard (cst-matchp abnf::cst "statement-expression")))
 (cond
  ((equal (abnf::tree-nonleaf->rulename?
               (nth 0
                    (nth 0
                         (abnf::tree-nonleaf->branches abnf::cst))))
          (abnf::rulename "assignment"))
   1)
  ((equal (abnf::tree-nonleaf->rulename?
               (nth 0
                    (nth 0
                         (abnf::tree-nonleaf->branches abnf::cst))))
          (abnf::rulename "pre-increment-expression"))
   2)
  ((equal (abnf::tree-nonleaf->rulename?
               (nth 0
                    (nth 0
                         (abnf::tree-nonleaf->branches abnf::cst))))
          (abnf::rulename "pre-decrement-expression"))
   3)
  ((equal (abnf::tree-nonleaf->rulename?
               (nth 0
                    (nth 0
                         (abnf::tree-nonleaf->branches abnf::cst))))
          (abnf::rulename "post-increment-expression"))
   4)
  ((equal (abnf::tree-nonleaf->rulename?
               (nth 0
                    (nth 0
                         (abnf::tree-nonleaf->branches abnf::cst))))
          (abnf::rulename "post-decrement-expression"))
   5)
  ((equal (abnf::tree-nonleaf->rulename?
               (nth 0
                    (nth 0
                         (abnf::tree-nonleaf->branches abnf::cst))))
          (abnf::rulename "method-invocation"))
   6)
  ((equal (abnf::tree-nonleaf->rulename?
               (nth 0
                    (nth 0
                         (abnf::tree-nonleaf->branches abnf::cst))))
          (abnf::rulename "class-instance-creation-expression"))
   7)
  (t (prog2$ (impossible) 1))))

Theorem: posp-of-cst-statement-expression-conc?

(defthm posp-of-cst-statement-expression-conc?
  (b* ((number (cst-statement-expression-conc? abnf::cst)))
    (posp number))
  :rule-classes :rewrite)

Theorem: cst-statement-expression-conc?-possibilities

(defthm cst-statement-expression-conc?-possibilities
 (b* ((number (cst-statement-expression-conc? abnf::cst)))
   (or (equal number 1)
       (equal number 2)
       (equal number 3)
       (equal number 4)
       (equal number 5)
       (equal number 6)
       (equal number 7)))
 :rule-classes
 ((:forward-chaining
      :trigger-terms ((cst-statement-expression-conc? abnf::cst)))))

Theorem: cst-statement-expression-conc?-of-tree-fix-cst

(defthm cst-statement-expression-conc?-of-tree-fix-cst
  (equal (cst-statement-expression-conc? (abnf::tree-fix abnf::cst))
         (cst-statement-expression-conc? abnf::cst)))

Theorem: cst-statement-expression-conc?-tree-equiv-congruence-on-cst

(defthm cst-statement-expression-conc?-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-statement-expression-conc? abnf::cst)
                  (cst-statement-expression-conc? cst-equiv)))
  :rule-classes :congruence)

Theorem: cst-statement-expression-conc?-1-iff-match-conc

(defthm cst-statement-expression-conc?-1-iff-match-conc
  (implies (cst-matchp abnf::cst "statement-expression")
           (iff (equal (cst-statement-expression-conc? abnf::cst)
                       1)
                (cst-list-list-conc-matchp
                     (abnf::tree-nonleaf->branches abnf::cst)
                     "assignment"))))

Theorem: cst-statement-expression-conc?-2-iff-match-conc

(defthm cst-statement-expression-conc?-2-iff-match-conc
  (implies (cst-matchp abnf::cst "statement-expression")
           (iff (equal (cst-statement-expression-conc? abnf::cst)
                       2)
                (cst-list-list-conc-matchp
                     (abnf::tree-nonleaf->branches abnf::cst)
                     "pre-increment-expression"))))

Theorem: cst-statement-expression-conc?-3-iff-match-conc

(defthm cst-statement-expression-conc?-3-iff-match-conc
  (implies (cst-matchp abnf::cst "statement-expression")
           (iff (equal (cst-statement-expression-conc? abnf::cst)
                       3)
                (cst-list-list-conc-matchp
                     (abnf::tree-nonleaf->branches abnf::cst)
                     "pre-decrement-expression"))))

Theorem: cst-statement-expression-conc?-4-iff-match-conc

(defthm cst-statement-expression-conc?-4-iff-match-conc
  (implies (cst-matchp abnf::cst "statement-expression")
           (iff (equal (cst-statement-expression-conc? abnf::cst)
                       4)
                (cst-list-list-conc-matchp
                     (abnf::tree-nonleaf->branches abnf::cst)
                     "post-increment-expression"))))

Theorem: cst-statement-expression-conc?-5-iff-match-conc

(defthm cst-statement-expression-conc?-5-iff-match-conc
  (implies (cst-matchp abnf::cst "statement-expression")
           (iff (equal (cst-statement-expression-conc? abnf::cst)
                       5)
                (cst-list-list-conc-matchp
                     (abnf::tree-nonleaf->branches abnf::cst)
                     "post-decrement-expression"))))

Theorem: cst-statement-expression-conc?-6-iff-match-conc

(defthm cst-statement-expression-conc?-6-iff-match-conc
  (implies (cst-matchp abnf::cst "statement-expression")
           (iff (equal (cst-statement-expression-conc? abnf::cst)
                       6)
                (cst-list-list-conc-matchp
                     (abnf::tree-nonleaf->branches abnf::cst)
                     "method-invocation"))))

Theorem: cst-statement-expression-conc?-7-iff-match-conc

(defthm cst-statement-expression-conc?-7-iff-match-conc
  (implies (cst-matchp abnf::cst "statement-expression")
           (iff (equal (cst-statement-expression-conc? abnf::cst)
                       7)
                (cst-list-list-conc-matchp
                     (abnf::tree-nonleaf->branches abnf::cst)
                     "class-instance-creation-expression"))))

Function: cst-for-statement-conc?

(defun cst-for-statement-conc? (abnf::cst)
 (declare (xargs :guard (abnf::treep abnf::cst)))
 (declare (xargs :guard (cst-matchp abnf::cst "for-statement")))
 (cond
  ((equal (abnf::tree-nonleaf->rulename?
               (nth 0
                    (nth 0
                         (abnf::tree-nonleaf->branches abnf::cst))))
          (abnf::rulename "basic-for-statement"))
   1)
  ((equal (abnf::tree-nonleaf->rulename?
               (nth 0
                    (nth 0
                         (abnf::tree-nonleaf->branches abnf::cst))))
          (abnf::rulename "enhanced-for-statement"))
   2)
  (t (prog2$ (impossible) 1))))

Theorem: posp-of-cst-for-statement-conc?

(defthm posp-of-cst-for-statement-conc?
  (b* ((number (cst-for-statement-conc? abnf::cst)))
    (posp number))
  :rule-classes :rewrite)

Theorem: cst-for-statement-conc?-possibilities

(defthm cst-for-statement-conc?-possibilities
  (b* ((number (cst-for-statement-conc? abnf::cst)))
    (or (equal number 1) (equal number 2)))
  :rule-classes
  ((:forward-chaining
        :trigger-terms ((cst-for-statement-conc? abnf::cst)))))

Theorem: cst-for-statement-conc?-of-tree-fix-cst

(defthm cst-for-statement-conc?-of-tree-fix-cst
  (equal (cst-for-statement-conc? (abnf::tree-fix abnf::cst))
         (cst-for-statement-conc? abnf::cst)))

Theorem: cst-for-statement-conc?-tree-equiv-congruence-on-cst

(defthm cst-for-statement-conc?-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-for-statement-conc? abnf::cst)
                  (cst-for-statement-conc? cst-equiv)))
  :rule-classes :congruence)

Theorem: cst-for-statement-conc?-1-iff-match-conc

(defthm cst-for-statement-conc?-1-iff-match-conc
  (implies (cst-matchp abnf::cst "for-statement")
           (iff (equal (cst-for-statement-conc? abnf::cst)
                       1)
                (cst-list-list-conc-matchp
                     (abnf::tree-nonleaf->branches abnf::cst)
                     "basic-for-statement"))))

Theorem: cst-for-statement-conc?-2-iff-match-conc

(defthm cst-for-statement-conc?-2-iff-match-conc
  (implies (cst-matchp abnf::cst "for-statement")
           (iff (equal (cst-for-statement-conc? abnf::cst)
                       2)
                (cst-list-list-conc-matchp
                     (abnf::tree-nonleaf->branches abnf::cst)
                     "enhanced-for-statement"))))

Function: cst-for-statement-no-short-if-conc?

(defun cst-for-statement-no-short-if-conc? (abnf::cst)
 (declare (xargs :guard (abnf::treep abnf::cst)))
 (declare
  (xargs :guard (cst-matchp abnf::cst "for-statement-no-short-if")))
 (cond
  ((equal (abnf::tree-nonleaf->rulename?
               (nth 0
                    (nth 0
                         (abnf::tree-nonleaf->branches abnf::cst))))
          (abnf::rulename "basic-for-statement-no-short-if"))
   1)
  ((equal (abnf::tree-nonleaf->rulename?
               (nth 0
                    (nth 0
                         (abnf::tree-nonleaf->branches abnf::cst))))
          (abnf::rulename "enhanced-for-statement-no-short-if"))
   2)
  (t (prog2$ (impossible) 1))))

Theorem: posp-of-cst-for-statement-no-short-if-conc?

(defthm posp-of-cst-for-statement-no-short-if-conc?
  (b* ((number (cst-for-statement-no-short-if-conc? abnf::cst)))
    (posp number))
  :rule-classes :rewrite)

Theorem: cst-for-statement-no-short-if-conc?-possibilities

(defthm cst-for-statement-no-short-if-conc?-possibilities
  (b* ((number (cst-for-statement-no-short-if-conc? abnf::cst)))
    (or (equal number 1) (equal number 2)))
  :rule-classes
  ((:forward-chaining
        :trigger-terms
        ((cst-for-statement-no-short-if-conc? abnf::cst)))))

Theorem: cst-for-statement-no-short-if-conc?-of-tree-fix-cst

(defthm cst-for-statement-no-short-if-conc?-of-tree-fix-cst
 (equal
    (cst-for-statement-no-short-if-conc? (abnf::tree-fix abnf::cst))
    (cst-for-statement-no-short-if-conc? abnf::cst)))

Theorem: cst-for-statement-no-short-if-conc?-tree-equiv-congruence-on-cst

(defthm
   cst-for-statement-no-short-if-conc?-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-for-statement-no-short-if-conc? abnf::cst)
                  (cst-for-statement-no-short-if-conc? cst-equiv)))
  :rule-classes :congruence)

Theorem: cst-for-statement-no-short-if-conc?-1-iff-match-conc

(defthm cst-for-statement-no-short-if-conc?-1-iff-match-conc
  (implies
       (cst-matchp abnf::cst "for-statement-no-short-if")
       (iff (equal (cst-for-statement-no-short-if-conc? abnf::cst)
                   1)
            (cst-list-list-conc-matchp
                 (abnf::tree-nonleaf->branches abnf::cst)
                 "basic-for-statement-no-short-if"))))

Theorem: cst-for-statement-no-short-if-conc?-2-iff-match-conc

(defthm cst-for-statement-no-short-if-conc?-2-iff-match-conc
  (implies
       (cst-matchp abnf::cst "for-statement-no-short-if")
       (iff (equal (cst-for-statement-no-short-if-conc? abnf::cst)
                   2)
            (cst-list-list-conc-matchp
                 (abnf::tree-nonleaf->branches abnf::cst)
                 "enhanced-for-statement-no-short-if"))))

Function: cst-for-init-conc?

(defun cst-for-init-conc? (abnf::cst)
 (declare (xargs :guard (abnf::treep abnf::cst)))
 (declare (xargs :guard (cst-matchp abnf::cst "for-init")))
 (cond
  ((equal (abnf::tree-nonleaf->rulename?
               (nth 0
                    (nth 0
                         (abnf::tree-nonleaf->branches abnf::cst))))
          (abnf::rulename "statement-expression-list"))
   1)
  ((equal (abnf::tree-nonleaf->rulename?
               (nth 0
                    (nth 0
                         (abnf::tree-nonleaf->branches abnf::cst))))
          (abnf::rulename "local-variable-declaration"))
   2)
  (t (prog2$ (impossible) 1))))

Theorem: posp-of-cst-for-init-conc?

(defthm posp-of-cst-for-init-conc?
  (b* ((number (cst-for-init-conc? abnf::cst)))
    (posp number))
  :rule-classes :rewrite)

Theorem: cst-for-init-conc?-possibilities

(defthm cst-for-init-conc?-possibilities
  (b* ((number (cst-for-init-conc? abnf::cst)))
    (or (equal number 1) (equal number 2)))
  :rule-classes
  ((:forward-chaining
        :trigger-terms ((cst-for-init-conc? abnf::cst)))))

Theorem: cst-for-init-conc?-of-tree-fix-cst

(defthm cst-for-init-conc?-of-tree-fix-cst
  (equal (cst-for-init-conc? (abnf::tree-fix abnf::cst))
         (cst-for-init-conc? abnf::cst)))

Theorem: cst-for-init-conc?-tree-equiv-congruence-on-cst

(defthm cst-for-init-conc?-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-for-init-conc? abnf::cst)
                  (cst-for-init-conc? cst-equiv)))
  :rule-classes :congruence)

Theorem: cst-for-init-conc?-1-iff-match-conc

(defthm cst-for-init-conc?-1-iff-match-conc
  (implies (cst-matchp abnf::cst "for-init")
           (iff (equal (cst-for-init-conc? abnf::cst) 1)
                (cst-list-list-conc-matchp
                     (abnf::tree-nonleaf->branches abnf::cst)
                     "statement-expression-list"))))

Theorem: cst-for-init-conc?-2-iff-match-conc

(defthm cst-for-init-conc?-2-iff-match-conc
  (implies (cst-matchp abnf::cst "for-init")
           (iff (equal (cst-for-init-conc? abnf::cst) 2)
                (cst-list-list-conc-matchp
                     (abnf::tree-nonleaf->branches abnf::cst)
                     "local-variable-declaration"))))

Function: cst-resource-conc?

(defun cst-resource-conc? (abnf::cst)
 (declare (xargs :guard (abnf::treep abnf::cst)))
 (declare (xargs :guard (cst-matchp abnf::cst "resource")))
 (cond
  ((equal (abnf::tree-nonleaf->rulename?
               (nth 0
                    (nth 0
                         (abnf::tree-nonleaf->branches abnf::cst))))
          (abnf::rulename "local-variable-declaration"))
   1)
  ((equal (abnf::tree-nonleaf->rulename?
               (nth 0
                    (nth 0
                         (abnf::tree-nonleaf->branches abnf::cst))))
          (abnf::rulename "variable-access"))
   2)
  (t (prog2$ (impossible) 1))))

Theorem: posp-of-cst-resource-conc?

(defthm posp-of-cst-resource-conc?
  (b* ((number (cst-resource-conc? abnf::cst)))
    (posp number))
  :rule-classes :rewrite)

Theorem: cst-resource-conc?-possibilities

(defthm cst-resource-conc?-possibilities
  (b* ((number (cst-resource-conc? abnf::cst)))
    (or (equal number 1) (equal number 2)))
  :rule-classes
  ((:forward-chaining
        :trigger-terms ((cst-resource-conc? abnf::cst)))))

Theorem: cst-resource-conc?-of-tree-fix-cst

(defthm cst-resource-conc?-of-tree-fix-cst
  (equal (cst-resource-conc? (abnf::tree-fix abnf::cst))
         (cst-resource-conc? abnf::cst)))

Theorem: cst-resource-conc?-tree-equiv-congruence-on-cst

(defthm cst-resource-conc?-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-resource-conc? abnf::cst)
                  (cst-resource-conc? cst-equiv)))
  :rule-classes :congruence)

Theorem: cst-resource-conc?-1-iff-match-conc

(defthm cst-resource-conc?-1-iff-match-conc
  (implies (cst-matchp abnf::cst "resource")
           (iff (equal (cst-resource-conc? abnf::cst) 1)
                (cst-list-list-conc-matchp
                     (abnf::tree-nonleaf->branches abnf::cst)
                     "local-variable-declaration"))))

Theorem: cst-resource-conc?-2-iff-match-conc

(defthm cst-resource-conc?-2-iff-match-conc
  (implies (cst-matchp abnf::cst "resource")
           (iff (equal (cst-resource-conc? abnf::cst) 2)
                (cst-list-list-conc-matchp
                     (abnf::tree-nonleaf->branches abnf::cst)
                     "variable-access"))))

Function: cst-variable-access-conc?

(defun cst-variable-access-conc? (abnf::cst)
 (declare (xargs :guard (abnf::treep abnf::cst)))
 (declare (xargs :guard (cst-matchp abnf::cst "variable-access")))
 (cond
  ((equal (abnf::tree-nonleaf->rulename?
               (nth 0
                    (nth 0
                         (abnf::tree-nonleaf->branches abnf::cst))))
          (abnf::rulename "expression-name"))
   1)
  ((equal (abnf::tree-nonleaf->rulename?
               (nth 0
                    (nth 0
                         (abnf::tree-nonleaf->branches abnf::cst))))
          (abnf::rulename "field-access"))
   2)
  (t (prog2$ (impossible) 1))))

Theorem: posp-of-cst-variable-access-conc?

(defthm posp-of-cst-variable-access-conc?
  (b* ((number (cst-variable-access-conc? abnf::cst)))
    (posp number))
  :rule-classes :rewrite)

Theorem: cst-variable-access-conc?-possibilities

(defthm cst-variable-access-conc?-possibilities
  (b* ((number (cst-variable-access-conc? abnf::cst)))
    (or (equal number 1) (equal number 2)))
  :rule-classes
  ((:forward-chaining
        :trigger-terms ((cst-variable-access-conc? abnf::cst)))))

Theorem: cst-variable-access-conc?-of-tree-fix-cst

(defthm cst-variable-access-conc?-of-tree-fix-cst
  (equal (cst-variable-access-conc? (abnf::tree-fix abnf::cst))
         (cst-variable-access-conc? abnf::cst)))

Theorem: cst-variable-access-conc?-tree-equiv-congruence-on-cst

(defthm cst-variable-access-conc?-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-variable-access-conc? abnf::cst)
                  (cst-variable-access-conc? cst-equiv)))
  :rule-classes :congruence)

Theorem: cst-variable-access-conc?-1-iff-match-conc

(defthm cst-variable-access-conc?-1-iff-match-conc
  (implies (cst-matchp abnf::cst "variable-access")
           (iff (equal (cst-variable-access-conc? abnf::cst)
                       1)
                (cst-list-list-conc-matchp
                     (abnf::tree-nonleaf->branches abnf::cst)
                     "expression-name"))))

Theorem: cst-variable-access-conc?-2-iff-match-conc

(defthm cst-variable-access-conc?-2-iff-match-conc
  (implies (cst-matchp abnf::cst "variable-access")
           (iff (equal (cst-variable-access-conc? abnf::cst)
                       2)
                (cst-list-list-conc-matchp
                     (abnf::tree-nonleaf->branches abnf::cst)
                     "field-access"))))

Function: cst-pattern-conc?

(defun cst-pattern-conc? (abnf::cst)
 (declare (xargs :guard (abnf::treep abnf::cst)))
 (declare (xargs :guard (cst-matchp abnf::cst "pattern")))
 (cond
  ((equal (abnf::tree-nonleaf->rulename?
               (nth 0
                    (nth 0
                         (abnf::tree-nonleaf->branches abnf::cst))))
          (abnf::rulename "type-pattern"))
   1)
  ((equal (abnf::tree-nonleaf->rulename?
               (nth 0
                    (nth 0
                         (abnf::tree-nonleaf->branches abnf::cst))))
          (abnf::rulename "record-pattern"))
   2)
  (t (prog2$ (impossible) 1))))

Theorem: posp-of-cst-pattern-conc?

(defthm posp-of-cst-pattern-conc?
  (b* ((number (cst-pattern-conc? abnf::cst)))
    (posp number))
  :rule-classes :rewrite)

Theorem: cst-pattern-conc?-possibilities

(defthm cst-pattern-conc?-possibilities
  (b* ((number (cst-pattern-conc? abnf::cst)))
    (or (equal number 1) (equal number 2)))
  :rule-classes
  ((:forward-chaining
        :trigger-terms ((cst-pattern-conc? abnf::cst)))))

Theorem: cst-pattern-conc?-of-tree-fix-cst

(defthm cst-pattern-conc?-of-tree-fix-cst
  (equal (cst-pattern-conc? (abnf::tree-fix abnf::cst))
         (cst-pattern-conc? abnf::cst)))

Theorem: cst-pattern-conc?-tree-equiv-congruence-on-cst

(defthm cst-pattern-conc?-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-pattern-conc? abnf::cst)
                  (cst-pattern-conc? cst-equiv)))
  :rule-classes :congruence)

Theorem: cst-pattern-conc?-1-iff-match-conc

(defthm cst-pattern-conc?-1-iff-match-conc
  (implies (cst-matchp abnf::cst "pattern")
           (iff (equal (cst-pattern-conc? abnf::cst) 1)
                (cst-list-list-conc-matchp
                     (abnf::tree-nonleaf->branches abnf::cst)
                     "type-pattern"))))

Theorem: cst-pattern-conc?-2-iff-match-conc

(defthm cst-pattern-conc?-2-iff-match-conc
  (implies (cst-matchp abnf::cst "pattern")
           (iff (equal (cst-pattern-conc? abnf::cst) 2)
                (cst-list-list-conc-matchp
                     (abnf::tree-nonleaf->branches abnf::cst)
                     "record-pattern"))))

Function: cst-component-pattern-conc?

(defun cst-component-pattern-conc? (abnf::cst)
 (declare (xargs :guard (abnf::treep abnf::cst)))
 (declare (xargs :guard (cst-matchp abnf::cst "component-pattern")))
 (cond
  ((equal (abnf::tree-nonleaf->rulename?
               (nth 0
                    (nth 0
                         (abnf::tree-nonleaf->branches abnf::cst))))
          (abnf::rulename "pattern"))
   1)
  ((equal (abnf::tree-nonleaf->rulename?
               (nth 0
                    (nth 0
                         (abnf::tree-nonleaf->branches abnf::cst))))
          (abnf::rulename "match-all-pattern"))
   2)
  (t (prog2$ (impossible) 1))))

Theorem: posp-of-cst-component-pattern-conc?

(defthm posp-of-cst-component-pattern-conc?
  (b* ((number (cst-component-pattern-conc? abnf::cst)))
    (posp number))
  :rule-classes :rewrite)

Theorem: cst-component-pattern-conc?-possibilities

(defthm cst-component-pattern-conc?-possibilities
  (b* ((number (cst-component-pattern-conc? abnf::cst)))
    (or (equal number 1) (equal number 2)))
  :rule-classes
  ((:forward-chaining
        :trigger-terms ((cst-component-pattern-conc? abnf::cst)))))

Theorem: cst-component-pattern-conc?-of-tree-fix-cst

(defthm cst-component-pattern-conc?-of-tree-fix-cst
  (equal (cst-component-pattern-conc? (abnf::tree-fix abnf::cst))
         (cst-component-pattern-conc? abnf::cst)))

Theorem: cst-component-pattern-conc?-tree-equiv-congruence-on-cst

(defthm cst-component-pattern-conc?-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-component-pattern-conc? abnf::cst)
                  (cst-component-pattern-conc? cst-equiv)))
  :rule-classes :congruence)

Theorem: cst-component-pattern-conc?-1-iff-match-conc

(defthm cst-component-pattern-conc?-1-iff-match-conc
  (implies (cst-matchp abnf::cst "component-pattern")
           (iff (equal (cst-component-pattern-conc? abnf::cst)
                       1)
                (cst-list-list-conc-matchp
                     (abnf::tree-nonleaf->branches abnf::cst)
                     "pattern"))))

Theorem: cst-component-pattern-conc?-2-iff-match-conc

(defthm cst-component-pattern-conc?-2-iff-match-conc
  (implies (cst-matchp abnf::cst "component-pattern")
           (iff (equal (cst-component-pattern-conc? abnf::cst)
                       2)
                (cst-list-list-conc-matchp
                     (abnf::tree-nonleaf->branches abnf::cst)
                     "match-all-pattern"))))

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")))
 (cond
  ((equal (abnf::tree-nonleaf->rulename?
               (nth 0
                    (nth 0
                         (abnf::tree-nonleaf->branches abnf::cst))))
          (abnf::rulename "lambda-expression"))
   1)
  ((equal (abnf::tree-nonleaf->rulename?
               (nth 0
                    (nth 0
                         (abnf::tree-nonleaf->branches abnf::cst))))
          (abnf::rulename "assignment-expression"))
   2)
  (t (prog2$ (impossible) 1))))

Theorem: posp-of-cst-expression-conc?

(defthm posp-of-cst-expression-conc?
  (b* ((number (cst-expression-conc? abnf::cst)))
    (posp number))
  :rule-classes :rewrite)

Theorem: cst-expression-conc?-possibilities

(defthm cst-expression-conc?-possibilities
  (b* ((number (cst-expression-conc? abnf::cst)))
    (or (equal number 1) (equal number 2)))
  :rule-classes
  ((:forward-chaining
        :trigger-terms ((cst-expression-conc? abnf::cst)))))

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)

Theorem: cst-expression-conc?-1-iff-match-conc

(defthm cst-expression-conc?-1-iff-match-conc
  (implies (cst-matchp abnf::cst "expression")
           (iff (equal (cst-expression-conc? abnf::cst)
                       1)
                (cst-list-list-conc-matchp
                     (abnf::tree-nonleaf->branches abnf::cst)
                     "lambda-expression"))))

Theorem: cst-expression-conc?-2-iff-match-conc

(defthm cst-expression-conc?-2-iff-match-conc
  (implies (cst-matchp abnf::cst "expression")
           (iff (equal (cst-expression-conc? abnf::cst)
                       2)
                (cst-list-list-conc-matchp
                     (abnf::tree-nonleaf->branches abnf::cst)
                     "assignment-expression"))))

Function: cst-primary-conc?

(defun cst-primary-conc? (abnf::cst)
 (declare (xargs :guard (abnf::treep abnf::cst)))
 (declare (xargs :guard (cst-matchp abnf::cst "primary")))
 (cond
  ((equal (abnf::tree-nonleaf->rulename?
               (nth 0
                    (nth 0
                         (abnf::tree-nonleaf->branches abnf::cst))))
          (abnf::rulename "primary-no-new-array"))
   1)
  ((equal (abnf::tree-nonleaf->rulename?
               (nth 0
                    (nth 0
                         (abnf::tree-nonleaf->branches abnf::cst))))
          (abnf::rulename "array-creation-expression"))
   2)
  (t (prog2$ (impossible) 1))))

Theorem: posp-of-cst-primary-conc?

(defthm posp-of-cst-primary-conc?
  (b* ((number (cst-primary-conc? abnf::cst)))
    (posp number))
  :rule-classes :rewrite)

Theorem: cst-primary-conc?-possibilities

(defthm cst-primary-conc?-possibilities
  (b* ((number (cst-primary-conc? abnf::cst)))
    (or (equal number 1) (equal number 2)))
  :rule-classes
  ((:forward-chaining
        :trigger-terms ((cst-primary-conc? abnf::cst)))))

Theorem: cst-primary-conc?-of-tree-fix-cst

(defthm cst-primary-conc?-of-tree-fix-cst
  (equal (cst-primary-conc? (abnf::tree-fix abnf::cst))
         (cst-primary-conc? abnf::cst)))

Theorem: cst-primary-conc?-tree-equiv-congruence-on-cst

(defthm cst-primary-conc?-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-primary-conc? abnf::cst)
                  (cst-primary-conc? cst-equiv)))
  :rule-classes :congruence)

Theorem: cst-primary-conc?-1-iff-match-conc

(defthm cst-primary-conc?-1-iff-match-conc
  (implies (cst-matchp abnf::cst "primary")
           (iff (equal (cst-primary-conc? abnf::cst) 1)
                (cst-list-list-conc-matchp
                     (abnf::tree-nonleaf->branches abnf::cst)
                     "primary-no-new-array"))))

Theorem: cst-primary-conc?-2-iff-match-conc

(defthm cst-primary-conc?-2-iff-match-conc
  (implies (cst-matchp abnf::cst "primary")
           (iff (equal (cst-primary-conc? abnf::cst) 2)
                (cst-list-list-conc-matchp
                     (abnf::tree-nonleaf->branches abnf::cst)
                     "array-creation-expression"))))

Function: cst-array-creation-expression-conc?

(defun cst-array-creation-expression-conc? (abnf::cst)
 (declare (xargs :guard (abnf::treep abnf::cst)))
 (declare
  (xargs :guard (cst-matchp abnf::cst "array-creation-expression")))
 (cond
  ((equal (abnf::tree-nonleaf->rulename?
               (nth 0
                    (nth 0
                         (abnf::tree-nonleaf->branches abnf::cst))))
          (abnf::rulename
               "array-creation-expression-without-initializer"))
   1)
  ((equal
      (abnf::tree-nonleaf->rulename?
           (nth 0
                (nth 0
                     (abnf::tree-nonleaf->branches abnf::cst))))
      (abnf::rulename "array-creation-expression-with-initializer"))
   2)
  (t (prog2$ (impossible) 1))))

Theorem: posp-of-cst-array-creation-expression-conc?

(defthm posp-of-cst-array-creation-expression-conc?
  (b* ((number (cst-array-creation-expression-conc? abnf::cst)))
    (posp number))
  :rule-classes :rewrite)

Theorem: cst-array-creation-expression-conc?-possibilities

(defthm cst-array-creation-expression-conc?-possibilities
  (b* ((number (cst-array-creation-expression-conc? abnf::cst)))
    (or (equal number 1) (equal number 2)))
  :rule-classes
  ((:forward-chaining
        :trigger-terms
        ((cst-array-creation-expression-conc? abnf::cst)))))

Theorem: cst-array-creation-expression-conc?-of-tree-fix-cst

(defthm cst-array-creation-expression-conc?-of-tree-fix-cst
 (equal
    (cst-array-creation-expression-conc? (abnf::tree-fix abnf::cst))
    (cst-array-creation-expression-conc? abnf::cst)))

Theorem: cst-array-creation-expression-conc?-tree-equiv-congruence-on-cst

(defthm
   cst-array-creation-expression-conc?-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-array-creation-expression-conc? abnf::cst)
                  (cst-array-creation-expression-conc? cst-equiv)))
  :rule-classes :congruence)

Theorem: cst-array-creation-expression-conc?-1-iff-match-conc

(defthm cst-array-creation-expression-conc?-1-iff-match-conc
  (implies
       (cst-matchp abnf::cst "array-creation-expression")
       (iff (equal (cst-array-creation-expression-conc? abnf::cst)
                   1)
            (cst-list-list-conc-matchp
                 (abnf::tree-nonleaf->branches abnf::cst)
                 "array-creation-expression-without-initializer"))))

Theorem: cst-array-creation-expression-conc?-2-iff-match-conc

(defthm cst-array-creation-expression-conc?-2-iff-match-conc
  (implies
       (cst-matchp abnf::cst "array-creation-expression")
       (iff (equal (cst-array-creation-expression-conc? abnf::cst)
                   2)
            (cst-list-list-conc-matchp
                 (abnf::tree-nonleaf->branches abnf::cst)
                 "array-creation-expression-with-initializer"))))

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")))
 (cond
  ((equal (abnf::tree-nonleaf->rulename?
               (nth 0
                    (nth 0
                         (abnf::tree-nonleaf->branches abnf::cst))))
          (abnf::rulename "primary"))
   1)
  ((equal (abnf::tree-nonleaf->rulename?
               (nth 0
                    (nth 0
                         (abnf::tree-nonleaf->branches abnf::cst))))
          (abnf::rulename "expression-name"))
   2)
  ((equal (abnf::tree-nonleaf->rulename?
               (nth 0
                    (nth 0
                         (abnf::tree-nonleaf->branches abnf::cst))))
          (abnf::rulename "post-increment-expression"))
   3)
  ((equal (abnf::tree-nonleaf->rulename?
               (nth 0
                    (nth 0
                         (abnf::tree-nonleaf->branches abnf::cst))))
          (abnf::rulename "post-decrement-expression"))
   4)
  (t (prog2$ (impossible) 1))))

Theorem: posp-of-cst-postfix-expression-conc?

(defthm posp-of-cst-postfix-expression-conc?
  (b* ((number (cst-postfix-expression-conc? abnf::cst)))
    (posp number))
  :rule-classes :rewrite)

Theorem: cst-postfix-expression-conc?-possibilities

(defthm cst-postfix-expression-conc?-possibilities
  (b* ((number (cst-postfix-expression-conc? abnf::cst)))
    (or (equal number 1)
        (equal number 2)
        (equal number 3)
        (equal number 4)))
  :rule-classes
  ((:forward-chaining
        :trigger-terms ((cst-postfix-expression-conc? abnf::cst)))))

Theorem: cst-postfix-expression-conc?-of-tree-fix-cst

(defthm cst-postfix-expression-conc?-of-tree-fix-cst
  (equal (cst-postfix-expression-conc? (abnf::tree-fix abnf::cst))
         (cst-postfix-expression-conc? abnf::cst)))

Theorem: cst-postfix-expression-conc?-tree-equiv-congruence-on-cst

(defthm cst-postfix-expression-conc?-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-postfix-expression-conc? abnf::cst)
                  (cst-postfix-expression-conc? cst-equiv)))
  :rule-classes :congruence)

Theorem: cst-postfix-expression-conc?-1-iff-match-conc

(defthm cst-postfix-expression-conc?-1-iff-match-conc
  (implies (cst-matchp abnf::cst "postfix-expression")
           (iff (equal (cst-postfix-expression-conc? abnf::cst)
                       1)
                (cst-list-list-conc-matchp
                     (abnf::tree-nonleaf->branches abnf::cst)
                     "primary"))))

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)
                     "expression-name"))))

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)
                     "post-increment-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)
                     "post-decrement-expression"))))

Function: cst-assignment-expression-conc?

(defun cst-assignment-expression-conc? (abnf::cst)
 (declare (xargs :guard (abnf::treep abnf::cst)))
 (declare
      (xargs :guard (cst-matchp abnf::cst "assignment-expression")))
 (cond
  ((equal (abnf::tree-nonleaf->rulename?
               (nth 0
                    (nth 0
                         (abnf::tree-nonleaf->branches abnf::cst))))
          (abnf::rulename "conditional-expression"))
   1)
  ((equal (abnf::tree-nonleaf->rulename?
               (nth 0
                    (nth 0
                         (abnf::tree-nonleaf->branches abnf::cst))))
          (abnf::rulename "assignment"))
   2)
  (t (prog2$ (impossible) 1))))

Theorem: posp-of-cst-assignment-expression-conc?

(defthm posp-of-cst-assignment-expression-conc?
  (b* ((number (cst-assignment-expression-conc? abnf::cst)))
    (posp number))
  :rule-classes :rewrite)

Theorem: cst-assignment-expression-conc?-possibilities

(defthm cst-assignment-expression-conc?-possibilities
 (b* ((number (cst-assignment-expression-conc? abnf::cst)))
   (or (equal number 1) (equal number 2)))
 :rule-classes
 ((:forward-chaining
     :trigger-terms ((cst-assignment-expression-conc? abnf::cst)))))

Theorem: cst-assignment-expression-conc?-of-tree-fix-cst

(defthm cst-assignment-expression-conc?-of-tree-fix-cst
 (equal (cst-assignment-expression-conc? (abnf::tree-fix abnf::cst))
        (cst-assignment-expression-conc? abnf::cst)))

Theorem: cst-assignment-expression-conc?-tree-equiv-congruence-on-cst

(defthm cst-assignment-expression-conc?-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-assignment-expression-conc? abnf::cst)
                  (cst-assignment-expression-conc? cst-equiv)))
  :rule-classes :congruence)

Theorem: cst-assignment-expression-conc?-1-iff-match-conc

(defthm cst-assignment-expression-conc?-1-iff-match-conc
  (implies (cst-matchp abnf::cst "assignment-expression")
           (iff (equal (cst-assignment-expression-conc? abnf::cst)
                       1)
                (cst-list-list-conc-matchp
                     (abnf::tree-nonleaf->branches abnf::cst)
                     "conditional-expression"))))

Theorem: cst-assignment-expression-conc?-2-iff-match-conc

(defthm cst-assignment-expression-conc?-2-iff-match-conc
  (implies (cst-matchp abnf::cst "assignment-expression")
           (iff (equal (cst-assignment-expression-conc? abnf::cst)
                       2)
                (cst-list-list-conc-matchp
                     (abnf::tree-nonleaf->branches abnf::cst)
                     "assignment"))))

Function: cst-left-hand-side-conc?

(defun cst-left-hand-side-conc? (abnf::cst)
 (declare (xargs :guard (abnf::treep abnf::cst)))
 (declare (xargs :guard (cst-matchp abnf::cst "left-hand-side")))
 (cond
  ((equal (abnf::tree-nonleaf->rulename?
               (nth 0
                    (nth 0
                         (abnf::tree-nonleaf->branches abnf::cst))))
          (abnf::rulename "expression-name"))
   1)
  ((equal (abnf::tree-nonleaf->rulename?
               (nth 0
                    (nth 0
                         (abnf::tree-nonleaf->branches abnf::cst))))
          (abnf::rulename "field-access"))
   2)
  ((equal (abnf::tree-nonleaf->rulename?
               (nth 0
                    (nth 0
                         (abnf::tree-nonleaf->branches abnf::cst))))
          (abnf::rulename "array-access"))
   3)
  (t (prog2$ (impossible) 1))))

Theorem: posp-of-cst-left-hand-side-conc?

(defthm posp-of-cst-left-hand-side-conc?
  (b* ((number (cst-left-hand-side-conc? abnf::cst)))
    (posp number))
  :rule-classes :rewrite)

Theorem: cst-left-hand-side-conc?-possibilities

(defthm cst-left-hand-side-conc?-possibilities
  (b* ((number (cst-left-hand-side-conc? abnf::cst)))
    (or (equal number 1)
        (equal number 2)
        (equal number 3)))
  :rule-classes
  ((:forward-chaining
        :trigger-terms ((cst-left-hand-side-conc? abnf::cst)))))

Theorem: cst-left-hand-side-conc?-of-tree-fix-cst

(defthm cst-left-hand-side-conc?-of-tree-fix-cst
  (equal (cst-left-hand-side-conc? (abnf::tree-fix abnf::cst))
         (cst-left-hand-side-conc? abnf::cst)))

Theorem: cst-left-hand-side-conc?-tree-equiv-congruence-on-cst

(defthm cst-left-hand-side-conc?-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-left-hand-side-conc? abnf::cst)
                  (cst-left-hand-side-conc? cst-equiv)))
  :rule-classes :congruence)

Theorem: cst-left-hand-side-conc?-1-iff-match-conc

(defthm cst-left-hand-side-conc?-1-iff-match-conc
  (implies (cst-matchp abnf::cst "left-hand-side")
           (iff (equal (cst-left-hand-side-conc? abnf::cst)
                       1)
                (cst-list-list-conc-matchp
                     (abnf::tree-nonleaf->branches abnf::cst)
                     "expression-name"))))

Theorem: cst-left-hand-side-conc?-2-iff-match-conc

(defthm cst-left-hand-side-conc?-2-iff-match-conc
  (implies (cst-matchp abnf::cst "left-hand-side")
           (iff (equal (cst-left-hand-side-conc? abnf::cst)
                       2)
                (cst-list-list-conc-matchp
                     (abnf::tree-nonleaf->branches abnf::cst)
                     "field-access"))))

Theorem: cst-left-hand-side-conc?-3-iff-match-conc

(defthm cst-left-hand-side-conc?-3-iff-match-conc
  (implies (cst-matchp abnf::cst "left-hand-side")
           (iff (equal (cst-left-hand-side-conc? abnf::cst)
                       3)
                (cst-list-list-conc-matchp
                     (abnf::tree-nonleaf->branches abnf::cst)
                     "array-access"))))

Function: cst-lambda-body-conc?

(defun cst-lambda-body-conc? (abnf::cst)
 (declare (xargs :guard (abnf::treep abnf::cst)))
 (declare (xargs :guard (cst-matchp abnf::cst "lambda-body")))
 (cond
  ((equal (abnf::tree-nonleaf->rulename?
               (nth 0
                    (nth 0
                         (abnf::tree-nonleaf->branches abnf::cst))))
          (abnf::rulename "expression"))
   1)
  ((equal (abnf::tree-nonleaf->rulename?
               (nth 0
                    (nth 0
                         (abnf::tree-nonleaf->branches abnf::cst))))
          (abnf::rulename "block"))
   2)
  (t (prog2$ (impossible) 1))))

Theorem: posp-of-cst-lambda-body-conc?

(defthm posp-of-cst-lambda-body-conc?
  (b* ((number (cst-lambda-body-conc? abnf::cst)))
    (posp number))
  :rule-classes :rewrite)

Theorem: cst-lambda-body-conc?-possibilities

(defthm cst-lambda-body-conc?-possibilities
  (b* ((number (cst-lambda-body-conc? abnf::cst)))
    (or (equal number 1) (equal number 2)))
  :rule-classes
  ((:forward-chaining
        :trigger-terms ((cst-lambda-body-conc? abnf::cst)))))

Theorem: cst-lambda-body-conc?-of-tree-fix-cst

(defthm cst-lambda-body-conc?-of-tree-fix-cst
  (equal (cst-lambda-body-conc? (abnf::tree-fix abnf::cst))
         (cst-lambda-body-conc? abnf::cst)))

Theorem: cst-lambda-body-conc?-tree-equiv-congruence-on-cst

(defthm cst-lambda-body-conc?-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-lambda-body-conc? abnf::cst)
                  (cst-lambda-body-conc? cst-equiv)))
  :rule-classes :congruence)

Theorem: cst-lambda-body-conc?-1-iff-match-conc

(defthm cst-lambda-body-conc?-1-iff-match-conc
  (implies (cst-matchp abnf::cst "lambda-body")
           (iff (equal (cst-lambda-body-conc? abnf::cst)
                       1)
                (cst-list-list-conc-matchp
                     (abnf::tree-nonleaf->branches abnf::cst)
                     "expression"))))

Theorem: cst-lambda-body-conc?-2-iff-match-conc

(defthm cst-lambda-body-conc?-2-iff-match-conc
  (implies (cst-matchp abnf::cst "lambda-body")
           (iff (equal (cst-lambda-body-conc? abnf::cst)
                       2)
                (cst-list-list-conc-matchp
                     (abnf::tree-nonleaf->branches abnf::cst)
                     "block"))))

Function: cst-unicode-input-character-conc1

(defun cst-unicode-input-character-conc1 (abnf::cst)
 (declare (xargs :guard (abnf::treep abnf::cst)))
 (declare
  (xargs
    :guard (and (cst-matchp abnf::cst "unicode-input-character")
                (equal (cst-unicode-input-character-conc? abnf::cst)
                       1))))
 (abnf::tree-nonleaf->branches abnf::cst))

Theorem: tree-list-listp-of-cst-unicode-input-character-conc1

(defthm tree-list-listp-of-cst-unicode-input-character-conc1
  (b* ((abnf::cstss (cst-unicode-input-character-conc1 abnf::cst)))
    (abnf::tree-list-listp abnf::cstss))
  :rule-classes :rewrite)

Theorem: cst-unicode-input-character-conc1-match

(defthm cst-unicode-input-character-conc1-match
 (implies
   (and (cst-matchp abnf::cst "unicode-input-character")
        (equal (cst-unicode-input-character-conc? abnf::cst)
               1))
   (b* ((abnf::cstss (cst-unicode-input-character-conc1 abnf::cst)))
     (cst-list-list-conc-matchp abnf::cstss "unicode-escape")))
 :rule-classes :rewrite)

Theorem: cst-unicode-input-character-conc1-of-tree-fix-cst

(defthm cst-unicode-input-character-conc1-of-tree-fix-cst
 (equal
      (cst-unicode-input-character-conc1 (abnf::tree-fix abnf::cst))
      (cst-unicode-input-character-conc1 abnf::cst)))

Theorem: cst-unicode-input-character-conc1-tree-equiv-congruence-on-cst

(defthm
     cst-unicode-input-character-conc1-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-unicode-input-character-conc1 abnf::cst)
                  (cst-unicode-input-character-conc1 cst-equiv)))
  :rule-classes :congruence)

Function: cst-unicode-input-character-conc2

(defun cst-unicode-input-character-conc2 (abnf::cst)
 (declare (xargs :guard (abnf::treep abnf::cst)))
 (declare
  (xargs
    :guard (and (cst-matchp abnf::cst "unicode-input-character")
                (equal (cst-unicode-input-character-conc? abnf::cst)
                       2))))
 (abnf::tree-nonleaf->branches abnf::cst))

Theorem: tree-list-listp-of-cst-unicode-input-character-conc2

(defthm tree-list-listp-of-cst-unicode-input-character-conc2
  (b* ((abnf::cstss (cst-unicode-input-character-conc2 abnf::cst)))
    (abnf::tree-list-listp abnf::cstss))
  :rule-classes :rewrite)

Theorem: cst-unicode-input-character-conc2-match

(defthm cst-unicode-input-character-conc2-match
 (implies
   (and (cst-matchp abnf::cst "unicode-input-character")
        (equal (cst-unicode-input-character-conc? abnf::cst)
               2))
   (b* ((abnf::cstss (cst-unicode-input-character-conc2 abnf::cst)))
     (cst-list-list-conc-matchp abnf::cstss "raw-input-character")))
 :rule-classes :rewrite)

Theorem: cst-unicode-input-character-conc2-of-tree-fix-cst

(defthm cst-unicode-input-character-conc2-of-tree-fix-cst
 (equal
      (cst-unicode-input-character-conc2 (abnf::tree-fix abnf::cst))
      (cst-unicode-input-character-conc2 abnf::cst)))

Theorem: cst-unicode-input-character-conc2-tree-equiv-congruence-on-cst

(defthm
     cst-unicode-input-character-conc2-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-unicode-input-character-conc2 abnf::cst)
                  (cst-unicode-input-character-conc2 cst-equiv)))
  :rule-classes :congruence)

Function: cst-unicode-escape-conc

(defun cst-unicode-escape-conc (abnf::cst)
  (declare (xargs :guard (abnf::treep abnf::cst)))
  (declare (xargs :guard (cst-matchp abnf::cst "unicode-escape")))
  (abnf::tree-nonleaf->branches abnf::cst))

Theorem: tree-list-listp-of-cst-unicode-escape-conc

(defthm tree-list-listp-of-cst-unicode-escape-conc
  (b* ((abnf::cstss (cst-unicode-escape-conc abnf::cst)))
    (abnf::tree-list-listp abnf::cstss))
  :rule-classes :rewrite)

Theorem: cst-unicode-escape-conc-match

(defthm cst-unicode-escape-conc-match
 (implies
  (cst-matchp abnf::cst "unicode-escape")
  (b* ((abnf::cstss (cst-unicode-escape-conc abnf::cst)))
   (cst-list-list-conc-matchp
     abnf::cstss
     "\"\\\" unicode-marker hex-digit hex-digit hex-digit hex-digit")))
 :rule-classes :rewrite)

Theorem: cst-unicode-escape-conc-of-tree-fix-cst

(defthm cst-unicode-escape-conc-of-tree-fix-cst
  (equal (cst-unicode-escape-conc (abnf::tree-fix abnf::cst))
         (cst-unicode-escape-conc abnf::cst)))

Theorem: cst-unicode-escape-conc-tree-equiv-congruence-on-cst

(defthm cst-unicode-escape-conc-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-unicode-escape-conc abnf::cst)
                  (cst-unicode-escape-conc cst-equiv)))
  :rule-classes :congruence)

Function: cst-unicode-marker-conc

(defun cst-unicode-marker-conc (abnf::cst)
  (declare (xargs :guard (abnf::treep abnf::cst)))
  (declare (xargs :guard (cst-matchp abnf::cst "unicode-marker")))
  (abnf::tree-nonleaf->branches abnf::cst))

Theorem: tree-list-listp-of-cst-unicode-marker-conc

(defthm tree-list-listp-of-cst-unicode-marker-conc
  (b* ((abnf::cstss (cst-unicode-marker-conc abnf::cst)))
    (abnf::tree-list-listp abnf::cstss))
  :rule-classes :rewrite)

Theorem: cst-unicode-marker-conc-match

(defthm cst-unicode-marker-conc-match
  (implies (cst-matchp abnf::cst "unicode-marker")
           (b* ((abnf::cstss (cst-unicode-marker-conc abnf::cst)))
             (cst-list-list-conc-matchp abnf::cstss "1*%s\"u\"")))
  :rule-classes :rewrite)

Theorem: cst-unicode-marker-conc-of-tree-fix-cst

(defthm cst-unicode-marker-conc-of-tree-fix-cst
  (equal (cst-unicode-marker-conc (abnf::tree-fix abnf::cst))
         (cst-unicode-marker-conc abnf::cst)))

Theorem: cst-unicode-marker-conc-tree-equiv-congruence-on-cst

(defthm cst-unicode-marker-conc-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-unicode-marker-conc abnf::cst)
                  (cst-unicode-marker-conc cst-equiv)))
  :rule-classes :congruence)

Function: cst-raw-input-character-conc

(defun cst-raw-input-character-conc (abnf::cst)
  (declare (xargs :guard (abnf::treep abnf::cst)))
  (declare
       (xargs :guard (cst-matchp abnf::cst "raw-input-character")))
  (abnf::tree-nonleaf->branches abnf::cst))

Theorem: tree-list-listp-of-cst-raw-input-character-conc

(defthm tree-list-listp-of-cst-raw-input-character-conc
  (b* ((abnf::cstss (cst-raw-input-character-conc abnf::cst)))
    (abnf::tree-list-listp abnf::cstss))
  :rule-classes :rewrite)

Theorem: cst-raw-input-character-conc-match

(defthm cst-raw-input-character-conc-match
  (implies
       (cst-matchp abnf::cst "raw-input-character")
       (b* ((abnf::cstss (cst-raw-input-character-conc abnf::cst)))
         (cst-list-list-conc-matchp abnf::cstss "%x0-FFFF")))
  :rule-classes :rewrite)

Theorem: cst-raw-input-character-conc-of-tree-fix-cst

(defthm cst-raw-input-character-conc-of-tree-fix-cst
  (equal (cst-raw-input-character-conc (abnf::tree-fix abnf::cst))
         (cst-raw-input-character-conc abnf::cst)))

Theorem: cst-raw-input-character-conc-tree-equiv-congruence-on-cst

(defthm cst-raw-input-character-conc-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-raw-input-character-conc abnf::cst)
                  (cst-raw-input-character-conc cst-equiv)))
  :rule-classes :congruence)

Function: cst-input-character-conc

(defun cst-input-character-conc (abnf::cst)
  (declare (xargs :guard (abnf::treep abnf::cst)))
  (declare (xargs :guard (cst-matchp abnf::cst "input-character")))
  (abnf::tree-nonleaf->branches abnf::cst))

Theorem: tree-list-listp-of-cst-input-character-conc

(defthm tree-list-listp-of-cst-input-character-conc
  (b* ((abnf::cstss (cst-input-character-conc abnf::cst)))
    (abnf::tree-list-listp abnf::cstss))
  :rule-classes :rewrite)

Theorem: cst-input-character-conc-match

(defthm cst-input-character-conc-match
  (implies (cst-matchp abnf::cst "input-character")
           (b* ((abnf::cstss (cst-input-character-conc abnf::cst)))
             (cst-list-list-conc-matchp
                  abnf::cstss "unicode-input-character")))
  :rule-classes :rewrite)

Theorem: cst-input-character-conc-of-tree-fix-cst

(defthm cst-input-character-conc-of-tree-fix-cst
  (equal (cst-input-character-conc (abnf::tree-fix abnf::cst))
         (cst-input-character-conc abnf::cst)))

Theorem: cst-input-character-conc-tree-equiv-congruence-on-cst

(defthm cst-input-character-conc-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-input-character-conc abnf::cst)
                  (cst-input-character-conc cst-equiv)))
  :rule-classes :congruence)

Function: cst-input-conc

(defun cst-input-conc (abnf::cst)
  (declare (xargs :guard (abnf::treep abnf::cst)))
  (declare (xargs :guard (cst-matchp abnf::cst "input")))
  (abnf::tree-nonleaf->branches abnf::cst))

Theorem: tree-list-listp-of-cst-input-conc

(defthm tree-list-listp-of-cst-input-conc
  (b* ((abnf::cstss (cst-input-conc abnf::cst)))
    (abnf::tree-list-listp abnf::cstss))
  :rule-classes :rewrite)

Theorem: cst-input-conc-match

(defthm cst-input-conc-match
  (implies (cst-matchp abnf::cst "input")
           (b* ((abnf::cstss (cst-input-conc abnf::cst)))
             (cst-list-list-conc-matchp
                  abnf::cstss "*input-element [ sub ]")))
  :rule-classes :rewrite)

Theorem: cst-input-conc-of-tree-fix-cst

(defthm cst-input-conc-of-tree-fix-cst
  (equal (cst-input-conc (abnf::tree-fix abnf::cst))
         (cst-input-conc abnf::cst)))

Theorem: cst-input-conc-tree-equiv-congruence-on-cst

(defthm cst-input-conc-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-input-conc abnf::cst)
                  (cst-input-conc cst-equiv)))
  :rule-classes :congruence)

Function: cst-input-element-conc1

(defun cst-input-element-conc1 (abnf::cst)
  (declare (xargs :guard (abnf::treep abnf::cst)))
  (declare
       (xargs :guard (and (cst-matchp abnf::cst "input-element")
                          (equal (cst-input-element-conc? abnf::cst)
                                 1))))
  (abnf::tree-nonleaf->branches abnf::cst))

Theorem: tree-list-listp-of-cst-input-element-conc1

(defthm tree-list-listp-of-cst-input-element-conc1
  (b* ((abnf::cstss (cst-input-element-conc1 abnf::cst)))
    (abnf::tree-list-listp abnf::cstss))
  :rule-classes :rewrite)

Theorem: cst-input-element-conc1-match

(defthm cst-input-element-conc1-match
  (implies (and (cst-matchp abnf::cst "input-element")
                (equal (cst-input-element-conc? abnf::cst)
                       1))
           (b* ((abnf::cstss (cst-input-element-conc1 abnf::cst)))
             (cst-list-list-conc-matchp abnf::cstss "white-space")))
  :rule-classes :rewrite)

Theorem: cst-input-element-conc1-of-tree-fix-cst

(defthm cst-input-element-conc1-of-tree-fix-cst
  (equal (cst-input-element-conc1 (abnf::tree-fix abnf::cst))
         (cst-input-element-conc1 abnf::cst)))

Theorem: cst-input-element-conc1-tree-equiv-congruence-on-cst

(defthm cst-input-element-conc1-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-input-element-conc1 abnf::cst)
                  (cst-input-element-conc1 cst-equiv)))
  :rule-classes :congruence)

Function: cst-input-element-conc2

(defun cst-input-element-conc2 (abnf::cst)
  (declare (xargs :guard (abnf::treep abnf::cst)))
  (declare
       (xargs :guard (and (cst-matchp abnf::cst "input-element")
                          (equal (cst-input-element-conc? abnf::cst)
                                 2))))
  (abnf::tree-nonleaf->branches abnf::cst))

Theorem: tree-list-listp-of-cst-input-element-conc2

(defthm tree-list-listp-of-cst-input-element-conc2
  (b* ((abnf::cstss (cst-input-element-conc2 abnf::cst)))
    (abnf::tree-list-listp abnf::cstss))
  :rule-classes :rewrite)

Theorem: cst-input-element-conc2-match

(defthm cst-input-element-conc2-match
  (implies (and (cst-matchp abnf::cst "input-element")
                (equal (cst-input-element-conc? abnf::cst)
                       2))
           (b* ((abnf::cstss (cst-input-element-conc2 abnf::cst)))
             (cst-list-list-conc-matchp abnf::cstss "comment")))
  :rule-classes :rewrite)

Theorem: cst-input-element-conc2-of-tree-fix-cst

(defthm cst-input-element-conc2-of-tree-fix-cst
  (equal (cst-input-element-conc2 (abnf::tree-fix abnf::cst))
         (cst-input-element-conc2 abnf::cst)))

Theorem: cst-input-element-conc2-tree-equiv-congruence-on-cst

(defthm cst-input-element-conc2-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-input-element-conc2 abnf::cst)
                  (cst-input-element-conc2 cst-equiv)))
  :rule-classes :congruence)

Function: cst-input-element-conc3

(defun cst-input-element-conc3 (abnf::cst)
  (declare (xargs :guard (abnf::treep abnf::cst)))
  (declare
       (xargs :guard (and (cst-matchp abnf::cst "input-element")
                          (equal (cst-input-element-conc? abnf::cst)
                                 3))))
  (abnf::tree-nonleaf->branches abnf::cst))

Theorem: tree-list-listp-of-cst-input-element-conc3

(defthm tree-list-listp-of-cst-input-element-conc3
  (b* ((abnf::cstss (cst-input-element-conc3 abnf::cst)))
    (abnf::tree-list-listp abnf::cstss))
  :rule-classes :rewrite)

Theorem: cst-input-element-conc3-match

(defthm cst-input-element-conc3-match
  (implies (and (cst-matchp abnf::cst "input-element")
                (equal (cst-input-element-conc? abnf::cst)
                       3))
           (b* ((abnf::cstss (cst-input-element-conc3 abnf::cst)))
             (cst-list-list-conc-matchp abnf::cstss "token")))
  :rule-classes :rewrite)

Theorem: cst-input-element-conc3-of-tree-fix-cst

(defthm cst-input-element-conc3-of-tree-fix-cst
  (equal (cst-input-element-conc3 (abnf::tree-fix abnf::cst))
         (cst-input-element-conc3 abnf::cst)))

Theorem: cst-input-element-conc3-tree-equiv-congruence-on-cst

(defthm cst-input-element-conc3-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-input-element-conc3 abnf::cst)
                  (cst-input-element-conc3 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))))
  (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 "identifier")))
  :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))))
  (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 "keyword")))
  :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))))
  (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 "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))))
  (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 "separator")))
  :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))))
  (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 "operator")))
  :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-sub-conc

(defun cst-sub-conc (abnf::cst)
  (declare (xargs :guard (abnf::treep abnf::cst)))
  (declare (xargs :guard (cst-matchp abnf::cst "sub")))
  (abnf::tree-nonleaf->branches abnf::cst))

Theorem: tree-list-listp-of-cst-sub-conc

(defthm tree-list-listp-of-cst-sub-conc
  (b* ((abnf::cstss (cst-sub-conc abnf::cst)))
    (abnf::tree-list-listp abnf::cstss))
  :rule-classes :rewrite)

Theorem: cst-sub-conc-match

(defthm cst-sub-conc-match
  (implies (cst-matchp abnf::cst "sub")
           (b* ((abnf::cstss (cst-sub-conc abnf::cst)))
             (cst-list-list-conc-matchp abnf::cstss "%d26")))
  :rule-classes :rewrite)

Theorem: cst-sub-conc-of-tree-fix-cst

(defthm cst-sub-conc-of-tree-fix-cst
  (equal (cst-sub-conc (abnf::tree-fix abnf::cst))
         (cst-sub-conc abnf::cst)))

Theorem: cst-sub-conc-tree-equiv-congruence-on-cst

(defthm cst-sub-conc-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-sub-conc abnf::cst)
                  (cst-sub-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))))
  (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 "traditional-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))))
  (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 "end-of-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-traditional-comment-conc

(defun cst-traditional-comment-conc (abnf::cst)
  (declare (xargs :guard (abnf::treep abnf::cst)))
  (declare
       (xargs :guard (cst-matchp abnf::cst "traditional-comment")))
  (abnf::tree-nonleaf->branches abnf::cst))

Theorem: tree-list-listp-of-cst-traditional-comment-conc

(defthm tree-list-listp-of-cst-traditional-comment-conc
  (b* ((abnf::cstss (cst-traditional-comment-conc abnf::cst)))
    (abnf::tree-list-listp abnf::cstss))
  :rule-classes :rewrite)

Theorem: cst-traditional-comment-conc-match

(defthm cst-traditional-comment-conc-match
 (implies
  (cst-matchp abnf::cst "traditional-comment")
  (b* ((abnf::cstss (cst-traditional-comment-conc abnf::cst)))
    (cst-list-list-conc-matchp abnf::cstss "\"/\" \"*\" comment-tail")))
 :rule-classes :rewrite)

Theorem: cst-traditional-comment-conc-of-tree-fix-cst

(defthm cst-traditional-comment-conc-of-tree-fix-cst
  (equal (cst-traditional-comment-conc (abnf::tree-fix abnf::cst))
         (cst-traditional-comment-conc abnf::cst)))

Theorem: cst-traditional-comment-conc-tree-equiv-congruence-on-cst

(defthm cst-traditional-comment-conc-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-traditional-comment-conc abnf::cst)
                  (cst-traditional-comment-conc cst-equiv)))
  :rule-classes :congruence)

Function: cst-not-star-conc1

(defun cst-not-star-conc1 (abnf::cst)
  (declare (xargs :guard (abnf::treep abnf::cst)))
  (declare (xargs :guard (and (cst-matchp abnf::cst "not-star")
                              (equal (cst-not-star-conc? abnf::cst)
                                     1))))
  (abnf::tree-nonleaf->branches abnf::cst))

Theorem: tree-list-listp-of-cst-not-star-conc1

(defthm tree-list-listp-of-cst-not-star-conc1
  (b* ((abnf::cstss (cst-not-star-conc1 abnf::cst)))
    (abnf::tree-list-listp abnf::cstss))
  :rule-classes :rewrite)

Theorem: cst-not-star-conc1-match

(defthm cst-not-star-conc1-match
  (implies
       (and (cst-matchp abnf::cst "not-star")
            (equal (cst-not-star-conc? abnf::cst)
                   1))
       (b* ((abnf::cstss (cst-not-star-conc1 abnf::cst)))
         (cst-list-list-conc-matchp abnf::cstss "input-character")))
  :rule-classes :rewrite)

Theorem: cst-not-star-conc1-of-tree-fix-cst

(defthm cst-not-star-conc1-of-tree-fix-cst
  (equal (cst-not-star-conc1 (abnf::tree-fix abnf::cst))
         (cst-not-star-conc1 abnf::cst)))

Theorem: cst-not-star-conc1-tree-equiv-congruence-on-cst

(defthm cst-not-star-conc1-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-not-star-conc1 abnf::cst)
                  (cst-not-star-conc1 cst-equiv)))
  :rule-classes :congruence)

Function: cst-not-star-conc2

(defun cst-not-star-conc2 (abnf::cst)
  (declare (xargs :guard (abnf::treep abnf::cst)))
  (declare (xargs :guard (and (cst-matchp abnf::cst "not-star")
                              (equal (cst-not-star-conc? abnf::cst)
                                     2))))
  (abnf::tree-nonleaf->branches abnf::cst))

Theorem: tree-list-listp-of-cst-not-star-conc2

(defthm tree-list-listp-of-cst-not-star-conc2
  (b* ((abnf::cstss (cst-not-star-conc2 abnf::cst)))
    (abnf::tree-list-listp abnf::cstss))
  :rule-classes :rewrite)

Theorem: cst-not-star-conc2-match

(defthm cst-not-star-conc2-match
  (implies
       (and (cst-matchp abnf::cst "not-star")
            (equal (cst-not-star-conc? abnf::cst)
                   2))
       (b* ((abnf::cstss (cst-not-star-conc2 abnf::cst)))
         (cst-list-list-conc-matchp abnf::cstss "line-terminator")))
  :rule-classes :rewrite)

Theorem: cst-not-star-conc2-of-tree-fix-cst

(defthm cst-not-star-conc2-of-tree-fix-cst
  (equal (cst-not-star-conc2 (abnf::tree-fix abnf::cst))
         (cst-not-star-conc2 abnf::cst)))

Theorem: cst-not-star-conc2-tree-equiv-congruence-on-cst

(defthm cst-not-star-conc2-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-not-star-conc2 abnf::cst)
                  (cst-not-star-conc2 cst-equiv)))
  :rule-classes :congruence)

Function: cst-not-star-not-slash-conc1

(defun cst-not-star-not-slash-conc1 (abnf::cst)
 (declare (xargs :guard (abnf::treep abnf::cst)))
 (declare
  (xargs :guard (and (cst-matchp abnf::cst "not-star-not-slash")
                     (equal (cst-not-star-not-slash-conc? abnf::cst)
                            1))))
 (abnf::tree-nonleaf->branches abnf::cst))

Theorem: tree-list-listp-of-cst-not-star-not-slash-conc1

(defthm tree-list-listp-of-cst-not-star-not-slash-conc1
  (b* ((abnf::cstss (cst-not-star-not-slash-conc1 abnf::cst)))
    (abnf::tree-list-listp abnf::cstss))
  :rule-classes :rewrite)

Theorem: cst-not-star-not-slash-conc1-match

(defthm cst-not-star-not-slash-conc1-match
  (implies
       (and (cst-matchp abnf::cst "not-star-not-slash")
            (equal (cst-not-star-not-slash-conc? abnf::cst)
                   1))
       (b* ((abnf::cstss (cst-not-star-not-slash-conc1 abnf::cst)))
         (cst-list-list-conc-matchp abnf::cstss "input-character")))
  :rule-classes :rewrite)

Theorem: cst-not-star-not-slash-conc1-of-tree-fix-cst

(defthm cst-not-star-not-slash-conc1-of-tree-fix-cst
  (equal (cst-not-star-not-slash-conc1 (abnf::tree-fix abnf::cst))
         (cst-not-star-not-slash-conc1 abnf::cst)))

Theorem: cst-not-star-not-slash-conc1-tree-equiv-congruence-on-cst

(defthm cst-not-star-not-slash-conc1-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-not-star-not-slash-conc1 abnf::cst)
                  (cst-not-star-not-slash-conc1 cst-equiv)))
  :rule-classes :congruence)

Function: cst-not-star-not-slash-conc2

(defun cst-not-star-not-slash-conc2 (abnf::cst)
 (declare (xargs :guard (abnf::treep abnf::cst)))
 (declare
  (xargs :guard (and (cst-matchp abnf::cst "not-star-not-slash")
                     (equal (cst-not-star-not-slash-conc? abnf::cst)
                            2))))
 (abnf::tree-nonleaf->branches abnf::cst))

Theorem: tree-list-listp-of-cst-not-star-not-slash-conc2

(defthm tree-list-listp-of-cst-not-star-not-slash-conc2
  (b* ((abnf::cstss (cst-not-star-not-slash-conc2 abnf::cst)))
    (abnf::tree-list-listp abnf::cstss))
  :rule-classes :rewrite)

Theorem: cst-not-star-not-slash-conc2-match

(defthm cst-not-star-not-slash-conc2-match
  (implies
       (and (cst-matchp abnf::cst "not-star-not-slash")
            (equal (cst-not-star-not-slash-conc? abnf::cst)
                   2))
       (b* ((abnf::cstss (cst-not-star-not-slash-conc2 abnf::cst)))
         (cst-list-list-conc-matchp abnf::cstss "line-terminator")))
  :rule-classes :rewrite)

Theorem: cst-not-star-not-slash-conc2-of-tree-fix-cst

(defthm cst-not-star-not-slash-conc2-of-tree-fix-cst
  (equal (cst-not-star-not-slash-conc2 (abnf::tree-fix abnf::cst))
         (cst-not-star-not-slash-conc2 abnf::cst)))

Theorem: cst-not-star-not-slash-conc2-tree-equiv-congruence-on-cst

(defthm cst-not-star-not-slash-conc2-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-not-star-not-slash-conc2 abnf::cst)
                  (cst-not-star-not-slash-conc2 cst-equiv)))
  :rule-classes :congruence)

Function: cst-end-of-line-comment-conc

(defun cst-end-of-line-comment-conc (abnf::cst)
  (declare (xargs :guard (abnf::treep abnf::cst)))
  (declare
       (xargs :guard (cst-matchp abnf::cst "end-of-line-comment")))
  (abnf::tree-nonleaf->branches abnf::cst))

Theorem: tree-list-listp-of-cst-end-of-line-comment-conc

(defthm tree-list-listp-of-cst-end-of-line-comment-conc
  (b* ((abnf::cstss (cst-end-of-line-comment-conc abnf::cst)))
    (abnf::tree-list-listp abnf::cstss))
  :rule-classes :rewrite)

Theorem: cst-end-of-line-comment-conc-match

(defthm cst-end-of-line-comment-conc-match
  (implies
       (cst-matchp abnf::cst "end-of-line-comment")
       (b* ((abnf::cstss (cst-end-of-line-comment-conc abnf::cst)))
         (cst-list-list-conc-matchp abnf::cstss
                                    "\"/\" \"/\" *input-character")))
  :rule-classes :rewrite)

Theorem: cst-end-of-line-comment-conc-of-tree-fix-cst

(defthm cst-end-of-line-comment-conc-of-tree-fix-cst
  (equal (cst-end-of-line-comment-conc (abnf::tree-fix abnf::cst))
         (cst-end-of-line-comment-conc abnf::cst)))

Theorem: cst-end-of-line-comment-conc-tree-equiv-congruence-on-cst

(defthm cst-end-of-line-comment-conc-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-end-of-line-comment-conc abnf::cst)
                  (cst-end-of-line-comment-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")))
  (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 "identifier-chars")))
 :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-identifier-chars-conc

(defun cst-identifier-chars-conc (abnf::cst)
  (declare (xargs :guard (abnf::treep abnf::cst)))
  (declare (xargs :guard (cst-matchp abnf::cst "identifier-chars")))
  (abnf::tree-nonleaf->branches abnf::cst))

Theorem: tree-list-listp-of-cst-identifier-chars-conc

(defthm tree-list-listp-of-cst-identifier-chars-conc
  (b* ((abnf::cstss (cst-identifier-chars-conc abnf::cst)))
    (abnf::tree-list-listp abnf::cstss))
  :rule-classes :rewrite)

Theorem: cst-identifier-chars-conc-match

(defthm cst-identifier-chars-conc-match
 (implies
  (cst-matchp abnf::cst "identifier-chars")
  (b* ((abnf::cstss (cst-identifier-chars-conc abnf::cst)))
   (cst-list-list-conc-matchp abnf::cstss
                              "java-letter *java-letter-or-digit")))
 :rule-classes :rewrite)

Theorem: cst-identifier-chars-conc-of-tree-fix-cst

(defthm cst-identifier-chars-conc-of-tree-fix-cst
  (equal (cst-identifier-chars-conc (abnf::tree-fix abnf::cst))
         (cst-identifier-chars-conc abnf::cst)))

Theorem: cst-identifier-chars-conc-tree-equiv-congruence-on-cst

(defthm cst-identifier-chars-conc-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-identifier-chars-conc abnf::cst)
                  (cst-identifier-chars-conc cst-equiv)))
  :rule-classes :congruence)

Function: cst-java-letter-conc

(defun cst-java-letter-conc (abnf::cst)
  (declare (xargs :guard (abnf::treep abnf::cst)))
  (declare (xargs :guard (cst-matchp abnf::cst "java-letter")))
  (abnf::tree-nonleaf->branches abnf::cst))

Theorem: tree-list-listp-of-cst-java-letter-conc

(defthm tree-list-listp-of-cst-java-letter-conc
  (b* ((abnf::cstss (cst-java-letter-conc abnf::cst)))
    (abnf::tree-list-listp abnf::cstss))
  :rule-classes :rewrite)

Theorem: cst-java-letter-conc-match

(defthm cst-java-letter-conc-match
 (implies
   (cst-matchp abnf::cst "java-letter")
   (b* ((abnf::cstss (cst-java-letter-conc abnf::cst)))
     (cst-list-list-conc-matchp abnf::cstss "raw-input-character")))
 :rule-classes :rewrite)

Theorem: cst-java-letter-conc-of-tree-fix-cst

(defthm cst-java-letter-conc-of-tree-fix-cst
  (equal (cst-java-letter-conc (abnf::tree-fix abnf::cst))
         (cst-java-letter-conc abnf::cst)))

Theorem: cst-java-letter-conc-tree-equiv-congruence-on-cst

(defthm cst-java-letter-conc-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-java-letter-conc abnf::cst)
                  (cst-java-letter-conc cst-equiv)))
  :rule-classes :congruence)

Function: cst-java-letter-or-digit-conc

(defun cst-java-letter-or-digit-conc (abnf::cst)
  (declare (xargs :guard (abnf::treep abnf::cst)))
  (declare
       (xargs :guard (cst-matchp abnf::cst "java-letter-or-digit")))
  (abnf::tree-nonleaf->branches abnf::cst))

Theorem: tree-list-listp-of-cst-java-letter-or-digit-conc

(defthm tree-list-listp-of-cst-java-letter-or-digit-conc
  (b* ((abnf::cstss (cst-java-letter-or-digit-conc abnf::cst)))
    (abnf::tree-list-listp abnf::cstss))
  :rule-classes :rewrite)

Theorem: cst-java-letter-or-digit-conc-match

(defthm cst-java-letter-or-digit-conc-match
 (implies
   (cst-matchp abnf::cst "java-letter-or-digit")
   (b* ((abnf::cstss (cst-java-letter-or-digit-conc abnf::cst)))
     (cst-list-list-conc-matchp abnf::cstss "raw-input-character")))
 :rule-classes :rewrite)

Theorem: cst-java-letter-or-digit-conc-of-tree-fix-cst

(defthm cst-java-letter-or-digit-conc-of-tree-fix-cst
  (equal (cst-java-letter-or-digit-conc (abnf::tree-fix abnf::cst))
         (cst-java-letter-or-digit-conc abnf::cst)))

Theorem: cst-java-letter-or-digit-conc-tree-equiv-congruence-on-cst

(defthm cst-java-letter-or-digit-conc-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-java-letter-or-digit-conc abnf::cst)
                  (cst-java-letter-or-digit-conc cst-equiv)))
  :rule-classes :congruence)

Function: cst-type-identifier-conc

(defun cst-type-identifier-conc (abnf::cst)
  (declare (xargs :guard (abnf::treep abnf::cst)))
  (declare (xargs :guard (cst-matchp abnf::cst "type-identifier")))
  (abnf::tree-nonleaf->branches abnf::cst))

Theorem: tree-list-listp-of-cst-type-identifier-conc

(defthm tree-list-listp-of-cst-type-identifier-conc
  (b* ((abnf::cstss (cst-type-identifier-conc abnf::cst)))
    (abnf::tree-list-listp abnf::cstss))
  :rule-classes :rewrite)

Theorem: cst-type-identifier-conc-match

(defthm cst-type-identifier-conc-match
  (implies (cst-matchp abnf::cst "type-identifier")
           (b* ((abnf::cstss (cst-type-identifier-conc abnf::cst)))
             (cst-list-list-conc-matchp abnf::cstss "identifier")))
  :rule-classes :rewrite)

Theorem: cst-type-identifier-conc-of-tree-fix-cst

(defthm cst-type-identifier-conc-of-tree-fix-cst
  (equal (cst-type-identifier-conc (abnf::tree-fix abnf::cst))
         (cst-type-identifier-conc abnf::cst)))

Theorem: cst-type-identifier-conc-tree-equiv-congruence-on-cst

(defthm cst-type-identifier-conc-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-type-identifier-conc abnf::cst)
                  (cst-type-identifier-conc cst-equiv)))
  :rule-classes :congruence)

Function: cst-unqualified-method-identifier-conc

(defun cst-unqualified-method-identifier-conc (abnf::cst)
  (declare (xargs :guard (abnf::treep abnf::cst)))
  (declare
       (xargs :guard (cst-matchp abnf::cst
                                 "unqualified-method-identifier")))
  (abnf::tree-nonleaf->branches abnf::cst))

Theorem: tree-list-listp-of-cst-unqualified-method-identifier-conc

(defthm tree-list-listp-of-cst-unqualified-method-identifier-conc
 (b*
  ((abnf::cstss (cst-unqualified-method-identifier-conc abnf::cst)))
  (abnf::tree-list-listp abnf::cstss))
 :rule-classes :rewrite)

Theorem: cst-unqualified-method-identifier-conc-match

(defthm cst-unqualified-method-identifier-conc-match
 (implies
      (cst-matchp abnf::cst
                  "unqualified-method-identifier")
      (b* ((abnf::cstss
                (cst-unqualified-method-identifier-conc abnf::cst)))
        (cst-list-list-conc-matchp abnf::cstss "identifier")))
 :rule-classes :rewrite)

Theorem: cst-unqualified-method-identifier-conc-of-tree-fix-cst

(defthm cst-unqualified-method-identifier-conc-of-tree-fix-cst
  (equal (cst-unqualified-method-identifier-conc
              (abnf::tree-fix abnf::cst))
         (cst-unqualified-method-identifier-conc abnf::cst)))

Theorem: cst-unqualified-method-identifier-conc-tree-equiv-congruence-on-cst

(defthm
 cst-unqualified-method-identifier-conc-tree-equiv-congruence-on-cst
 (implies
      (abnf::tree-equiv abnf::cst cst-equiv)
      (equal (cst-unqualified-method-identifier-conc abnf::cst)
             (cst-unqualified-method-identifier-conc cst-equiv)))
 :rule-classes :congruence)

Function: cst-keyword-conc1

(defun cst-keyword-conc1 (abnf::cst)
  (declare (xargs :guard (abnf::treep abnf::cst)))
  (declare (xargs :guard (and (cst-matchp abnf::cst "keyword")
                              (equal (cst-keyword-conc? abnf::cst)
                                     1))))
  (abnf::tree-nonleaf->branches abnf::cst))

Theorem: tree-list-listp-of-cst-keyword-conc1

(defthm tree-list-listp-of-cst-keyword-conc1
  (b* ((abnf::cstss (cst-keyword-conc1 abnf::cst)))
    (abnf::tree-list-listp abnf::cstss))
  :rule-classes :rewrite)

Theorem: cst-keyword-conc1-match

(defthm cst-keyword-conc1-match
 (implies
      (and (cst-matchp abnf::cst "keyword")
           (equal (cst-keyword-conc? abnf::cst) 1))
      (b* ((abnf::cstss (cst-keyword-conc1 abnf::cst)))
        (cst-list-list-conc-matchp abnf::cstss "reserved-keyword")))
 :rule-classes :rewrite)

Theorem: cst-keyword-conc1-of-tree-fix-cst

(defthm cst-keyword-conc1-of-tree-fix-cst
  (equal (cst-keyword-conc1 (abnf::tree-fix abnf::cst))
         (cst-keyword-conc1 abnf::cst)))

Theorem: cst-keyword-conc1-tree-equiv-congruence-on-cst

(defthm cst-keyword-conc1-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-keyword-conc1 abnf::cst)
                  (cst-keyword-conc1 cst-equiv)))
  :rule-classes :congruence)

Function: cst-keyword-conc2

(defun cst-keyword-conc2 (abnf::cst)
  (declare (xargs :guard (abnf::treep abnf::cst)))
  (declare (xargs :guard (and (cst-matchp abnf::cst "keyword")
                              (equal (cst-keyword-conc? abnf::cst)
                                     2))))
  (abnf::tree-nonleaf->branches abnf::cst))

Theorem: tree-list-listp-of-cst-keyword-conc2

(defthm tree-list-listp-of-cst-keyword-conc2
  (b* ((abnf::cstss (cst-keyword-conc2 abnf::cst)))
    (abnf::tree-list-listp abnf::cstss))
  :rule-classes :rewrite)

Theorem: cst-keyword-conc2-match

(defthm cst-keyword-conc2-match
 (implies
    (and (cst-matchp abnf::cst "keyword")
         (equal (cst-keyword-conc? abnf::cst) 2))
    (b* ((abnf::cstss (cst-keyword-conc2 abnf::cst)))
      (cst-list-list-conc-matchp abnf::cstss "contextual-keyword")))
 :rule-classes :rewrite)

Theorem: cst-keyword-conc2-of-tree-fix-cst

(defthm cst-keyword-conc2-of-tree-fix-cst
  (equal (cst-keyword-conc2 (abnf::tree-fix abnf::cst))
         (cst-keyword-conc2 abnf::cst)))

Theorem: cst-keyword-conc2-tree-equiv-congruence-on-cst

(defthm cst-keyword-conc2-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-keyword-conc2 abnf::cst)
                  (cst-keyword-conc2 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))))
  (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 "integer-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))))
  (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 "floating-point-literal")))
  :rule-classes :rewrite)

Theorem: cst-literal-conc2-of-tree-fix-cst

(defthm cst-literal-conc2-of-tree-fix-cst
  (equal (cst-literal-conc2 (abnf::tree-fix abnf::cst))
         (cst-literal-conc2 abnf::cst)))

Theorem: cst-literal-conc2-tree-equiv-congruence-on-cst

(defthm cst-literal-conc2-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-literal-conc2 abnf::cst)
                  (cst-literal-conc2 cst-equiv)))
  :rule-classes :congruence)

Function: cst-literal-conc3

(defun cst-literal-conc3 (abnf::cst)
  (declare (xargs :guard (abnf::treep abnf::cst)))
  (declare (xargs :guard (and (cst-matchp abnf::cst "literal")
                              (equal (cst-literal-conc? abnf::cst)
                                     3))))
  (abnf::tree-nonleaf->branches abnf::cst))

Theorem: tree-list-listp-of-cst-literal-conc3

(defthm tree-list-listp-of-cst-literal-conc3
  (b* ((abnf::cstss (cst-literal-conc3 abnf::cst)))
    (abnf::tree-list-listp abnf::cstss))
  :rule-classes :rewrite)

Theorem: cst-literal-conc3-match

(defthm cst-literal-conc3-match
  (implies
       (and (cst-matchp abnf::cst "literal")
            (equal (cst-literal-conc? abnf::cst) 3))
       (b* ((abnf::cstss (cst-literal-conc3 abnf::cst)))
         (cst-list-list-conc-matchp abnf::cstss "boolean-literal")))
  :rule-classes :rewrite)

Theorem: cst-literal-conc3-of-tree-fix-cst

(defthm cst-literal-conc3-of-tree-fix-cst
  (equal (cst-literal-conc3 (abnf::tree-fix abnf::cst))
         (cst-literal-conc3 abnf::cst)))

Theorem: cst-literal-conc3-tree-equiv-congruence-on-cst

(defthm cst-literal-conc3-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-literal-conc3 abnf::cst)
                  (cst-literal-conc3 cst-equiv)))
  :rule-classes :congruence)

Function: cst-literal-conc4

(defun cst-literal-conc4 (abnf::cst)
  (declare (xargs :guard (abnf::treep abnf::cst)))
  (declare (xargs :guard (and (cst-matchp abnf::cst "literal")
                              (equal (cst-literal-conc? abnf::cst)
                                     4))))
  (abnf::tree-nonleaf->branches abnf::cst))

Theorem: tree-list-listp-of-cst-literal-conc4

(defthm tree-list-listp-of-cst-literal-conc4
  (b* ((abnf::cstss (cst-literal-conc4 abnf::cst)))
    (abnf::tree-list-listp abnf::cstss))
  :rule-classes :rewrite)

Theorem: cst-literal-conc4-match

(defthm cst-literal-conc4-match
 (implies
     (and (cst-matchp abnf::cst "literal")
          (equal (cst-literal-conc? abnf::cst) 4))
     (b* ((abnf::cstss (cst-literal-conc4 abnf::cst)))
       (cst-list-list-conc-matchp abnf::cstss "character-literal")))
 :rule-classes :rewrite)

Theorem: cst-literal-conc4-of-tree-fix-cst

(defthm cst-literal-conc4-of-tree-fix-cst
  (equal (cst-literal-conc4 (abnf::tree-fix abnf::cst))
         (cst-literal-conc4 abnf::cst)))

Theorem: cst-literal-conc4-tree-equiv-congruence-on-cst

(defthm cst-literal-conc4-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-literal-conc4 abnf::cst)
                  (cst-literal-conc4 cst-equiv)))
  :rule-classes :congruence)

Function: cst-literal-conc5

(defun cst-literal-conc5 (abnf::cst)
  (declare (xargs :guard (abnf::treep abnf::cst)))
  (declare (xargs :guard (and (cst-matchp abnf::cst "literal")
                              (equal (cst-literal-conc? abnf::cst)
                                     5))))
  (abnf::tree-nonleaf->branches abnf::cst))

Theorem: tree-list-listp-of-cst-literal-conc5

(defthm tree-list-listp-of-cst-literal-conc5
  (b* ((abnf::cstss (cst-literal-conc5 abnf::cst)))
    (abnf::tree-list-listp abnf::cstss))
  :rule-classes :rewrite)

Theorem: cst-literal-conc5-match

(defthm cst-literal-conc5-match
  (implies
       (and (cst-matchp abnf::cst "literal")
            (equal (cst-literal-conc? abnf::cst) 5))
       (b* ((abnf::cstss (cst-literal-conc5 abnf::cst)))
         (cst-list-list-conc-matchp abnf::cstss "string-literal")))
  :rule-classes :rewrite)

Theorem: cst-literal-conc5-of-tree-fix-cst

(defthm cst-literal-conc5-of-tree-fix-cst
  (equal (cst-literal-conc5 (abnf::tree-fix abnf::cst))
         (cst-literal-conc5 abnf::cst)))

Theorem: cst-literal-conc5-tree-equiv-congruence-on-cst

(defthm cst-literal-conc5-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-literal-conc5 abnf::cst)
                  (cst-literal-conc5 cst-equiv)))
  :rule-classes :congruence)

Function: cst-literal-conc6

(defun cst-literal-conc6 (abnf::cst)
  (declare (xargs :guard (abnf::treep abnf::cst)))
  (declare (xargs :guard (and (cst-matchp abnf::cst "literal")
                              (equal (cst-literal-conc? abnf::cst)
                                     6))))
  (abnf::tree-nonleaf->branches abnf::cst))

Theorem: tree-list-listp-of-cst-literal-conc6

(defthm tree-list-listp-of-cst-literal-conc6
  (b* ((abnf::cstss (cst-literal-conc6 abnf::cst)))
    (abnf::tree-list-listp abnf::cstss))
  :rule-classes :rewrite)

Theorem: cst-literal-conc6-match

(defthm cst-literal-conc6-match
  (implies (and (cst-matchp abnf::cst "literal")
                (equal (cst-literal-conc? abnf::cst) 6))
           (b* ((abnf::cstss (cst-literal-conc6 abnf::cst)))
             (cst-list-list-conc-matchp abnf::cstss "text-block")))
  :rule-classes :rewrite)

Theorem: cst-literal-conc6-of-tree-fix-cst

(defthm cst-literal-conc6-of-tree-fix-cst
  (equal (cst-literal-conc6 (abnf::tree-fix abnf::cst))
         (cst-literal-conc6 abnf::cst)))

Theorem: cst-literal-conc6-tree-equiv-congruence-on-cst

(defthm cst-literal-conc6-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-literal-conc6 abnf::cst)
                  (cst-literal-conc6 cst-equiv)))
  :rule-classes :congruence)

Function: cst-literal-conc7

(defun cst-literal-conc7 (abnf::cst)
  (declare (xargs :guard (abnf::treep abnf::cst)))
  (declare (xargs :guard (and (cst-matchp abnf::cst "literal")
                              (equal (cst-literal-conc? abnf::cst)
                                     7))))
  (abnf::tree-nonleaf->branches abnf::cst))

Theorem: tree-list-listp-of-cst-literal-conc7

(defthm tree-list-listp-of-cst-literal-conc7
  (b* ((abnf::cstss (cst-literal-conc7 abnf::cst)))
    (abnf::tree-list-listp abnf::cstss))
  :rule-classes :rewrite)

Theorem: cst-literal-conc7-match

(defthm cst-literal-conc7-match
 (implies (and (cst-matchp abnf::cst "literal")
               (equal (cst-literal-conc? abnf::cst) 7))
          (b* ((abnf::cstss (cst-literal-conc7 abnf::cst)))
            (cst-list-list-conc-matchp abnf::cstss "null-literal")))
 :rule-classes :rewrite)

Theorem: cst-literal-conc7-of-tree-fix-cst

(defthm cst-literal-conc7-of-tree-fix-cst
  (equal (cst-literal-conc7 (abnf::tree-fix abnf::cst))
         (cst-literal-conc7 abnf::cst)))

Theorem: cst-literal-conc7-tree-equiv-congruence-on-cst

(defthm cst-literal-conc7-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-literal-conc7 abnf::cst)
                  (cst-literal-conc7 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))))
 (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 "decimal-integer-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))))
 (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 "hex-integer-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-integer-literal-conc3

(defun cst-integer-literal-conc3 (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)
                               3))))
 (abnf::tree-nonleaf->branches abnf::cst))

Theorem: tree-list-listp-of-cst-integer-literal-conc3

(defthm tree-list-listp-of-cst-integer-literal-conc3
  (b* ((abnf::cstss (cst-integer-literal-conc3 abnf::cst)))
    (abnf::tree-list-listp abnf::cstss))
  :rule-classes :rewrite)

Theorem: cst-integer-literal-conc3-match

(defthm cst-integer-literal-conc3-match
 (implies
  (and (cst-matchp abnf::cst "integer-literal")
       (equal (cst-integer-literal-conc? abnf::cst)
              3))
  (b* ((abnf::cstss (cst-integer-literal-conc3 abnf::cst)))
   (cst-list-list-conc-matchp abnf::cstss "octal-integer-literal")))
 :rule-classes :rewrite)

Theorem: cst-integer-literal-conc3-of-tree-fix-cst

(defthm cst-integer-literal-conc3-of-tree-fix-cst
  (equal (cst-integer-literal-conc3 (abnf::tree-fix abnf::cst))
         (cst-integer-literal-conc3 abnf::cst)))

Theorem: cst-integer-literal-conc3-tree-equiv-congruence-on-cst

(defthm cst-integer-literal-conc3-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-integer-literal-conc3 abnf::cst)
                  (cst-integer-literal-conc3 cst-equiv)))
  :rule-classes :congruence)

Function: cst-integer-literal-conc4

(defun cst-integer-literal-conc4 (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)
                               4))))
 (abnf::tree-nonleaf->branches abnf::cst))

Theorem: tree-list-listp-of-cst-integer-literal-conc4

(defthm tree-list-listp-of-cst-integer-literal-conc4
  (b* ((abnf::cstss (cst-integer-literal-conc4 abnf::cst)))
    (abnf::tree-list-listp abnf::cstss))
  :rule-classes :rewrite)

Theorem: cst-integer-literal-conc4-match

(defthm cst-integer-literal-conc4-match
  (implies (and (cst-matchp abnf::cst "integer-literal")
                (equal (cst-integer-literal-conc? abnf::cst)
                       4))
           (b* ((abnf::cstss (cst-integer-literal-conc4 abnf::cst)))
             (cst-list-list-conc-matchp
                  abnf::cstss "binary-integer-literal")))
  :rule-classes :rewrite)

Theorem: cst-integer-literal-conc4-of-tree-fix-cst

(defthm cst-integer-literal-conc4-of-tree-fix-cst
  (equal (cst-integer-literal-conc4 (abnf::tree-fix abnf::cst))
         (cst-integer-literal-conc4 abnf::cst)))

Theorem: cst-integer-literal-conc4-tree-equiv-congruence-on-cst

(defthm cst-integer-literal-conc4-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-integer-literal-conc4 abnf::cst)
                  (cst-integer-literal-conc4 cst-equiv)))
  :rule-classes :congruence)

Function: cst-decimal-integer-literal-conc

(defun cst-decimal-integer-literal-conc (abnf::cst)
 (declare (xargs :guard (abnf::treep abnf::cst)))
 (declare
    (xargs :guard (cst-matchp abnf::cst "decimal-integer-literal")))
 (abnf::tree-nonleaf->branches abnf::cst))

Theorem: tree-list-listp-of-cst-decimal-integer-literal-conc

(defthm tree-list-listp-of-cst-decimal-integer-literal-conc
  (b* ((abnf::cstss (cst-decimal-integer-literal-conc abnf::cst)))
    (abnf::tree-list-listp abnf::cstss))
  :rule-classes :rewrite)

Theorem: cst-decimal-integer-literal-conc-match

(defthm cst-decimal-integer-literal-conc-match
 (implies
    (cst-matchp abnf::cst "decimal-integer-literal")
    (b* ((abnf::cstss (cst-decimal-integer-literal-conc abnf::cst)))
      (cst-list-list-conc-matchp
           abnf::cstss
           "decimal-numeral [ integer-type-suffix ]")))
 :rule-classes :rewrite)

Theorem: cst-decimal-integer-literal-conc-of-tree-fix-cst

(defthm cst-decimal-integer-literal-conc-of-tree-fix-cst
  (equal
       (cst-decimal-integer-literal-conc (abnf::tree-fix abnf::cst))
       (cst-decimal-integer-literal-conc abnf::cst)))

Theorem: cst-decimal-integer-literal-conc-tree-equiv-congruence-on-cst

(defthm
      cst-decimal-integer-literal-conc-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-decimal-integer-literal-conc abnf::cst)
                  (cst-decimal-integer-literal-conc cst-equiv)))
  :rule-classes :congruence)

Function: cst-hex-integer-literal-conc

(defun cst-hex-integer-literal-conc (abnf::cst)
  (declare (xargs :guard (abnf::treep abnf::cst)))
  (declare
       (xargs :guard (cst-matchp abnf::cst "hex-integer-literal")))
  (abnf::tree-nonleaf->branches abnf::cst))

Theorem: tree-list-listp-of-cst-hex-integer-literal-conc

(defthm tree-list-listp-of-cst-hex-integer-literal-conc
  (b* ((abnf::cstss (cst-hex-integer-literal-conc abnf::cst)))
    (abnf::tree-list-listp abnf::cstss))
  :rule-classes :rewrite)

Theorem: cst-hex-integer-literal-conc-match

(defthm cst-hex-integer-literal-conc-match
  (implies
       (cst-matchp abnf::cst "hex-integer-literal")
       (b* ((abnf::cstss (cst-hex-integer-literal-conc abnf::cst)))
         (cst-list-list-conc-matchp
              abnf::cstss
              "hex-numeral [ integer-type-suffix ]")))
  :rule-classes :rewrite)

Theorem: cst-hex-integer-literal-conc-of-tree-fix-cst

(defthm cst-hex-integer-literal-conc-of-tree-fix-cst
  (equal (cst-hex-integer-literal-conc (abnf::tree-fix abnf::cst))
         (cst-hex-integer-literal-conc abnf::cst)))

Theorem: cst-hex-integer-literal-conc-tree-equiv-congruence-on-cst

(defthm cst-hex-integer-literal-conc-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-hex-integer-literal-conc abnf::cst)
                  (cst-hex-integer-literal-conc cst-equiv)))
  :rule-classes :congruence)

Function: cst-octal-integer-literal-conc

(defun cst-octal-integer-literal-conc (abnf::cst)
 (declare (xargs :guard (abnf::treep abnf::cst)))
 (declare
      (xargs :guard (cst-matchp abnf::cst "octal-integer-literal")))
 (abnf::tree-nonleaf->branches abnf::cst))

Theorem: tree-list-listp-of-cst-octal-integer-literal-conc

(defthm tree-list-listp-of-cst-octal-integer-literal-conc
  (b* ((abnf::cstss (cst-octal-integer-literal-conc abnf::cst)))
    (abnf::tree-list-listp abnf::cstss))
  :rule-classes :rewrite)

Theorem: cst-octal-integer-literal-conc-match

(defthm cst-octal-integer-literal-conc-match
 (implies
      (cst-matchp abnf::cst "octal-integer-literal")
      (b* ((abnf::cstss (cst-octal-integer-literal-conc abnf::cst)))
        (cst-list-list-conc-matchp
             abnf::cstss
             "octal-numeral [ integer-type-suffix ]")))
 :rule-classes :rewrite)

Theorem: cst-octal-integer-literal-conc-of-tree-fix-cst

(defthm cst-octal-integer-literal-conc-of-tree-fix-cst
  (equal (cst-octal-integer-literal-conc (abnf::tree-fix abnf::cst))
         (cst-octal-integer-literal-conc abnf::cst)))

Theorem: cst-octal-integer-literal-conc-tree-equiv-congruence-on-cst

(defthm cst-octal-integer-literal-conc-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-octal-integer-literal-conc abnf::cst)
                  (cst-octal-integer-literal-conc cst-equiv)))
  :rule-classes :congruence)

Function: cst-binary-integer-literal-conc

(defun cst-binary-integer-literal-conc (abnf::cst)
 (declare (xargs :guard (abnf::treep abnf::cst)))
 (declare
     (xargs :guard (cst-matchp abnf::cst "binary-integer-literal")))
 (abnf::tree-nonleaf->branches abnf::cst))

Theorem: tree-list-listp-of-cst-binary-integer-literal-conc

(defthm tree-list-listp-of-cst-binary-integer-literal-conc
  (b* ((abnf::cstss (cst-binary-integer-literal-conc abnf::cst)))
    (abnf::tree-list-listp abnf::cstss))
  :rule-classes :rewrite)

Theorem: cst-binary-integer-literal-conc-match

(defthm cst-binary-integer-literal-conc-match
 (implies
     (cst-matchp abnf::cst "binary-integer-literal")
     (b* ((abnf::cstss (cst-binary-integer-literal-conc abnf::cst)))
       (cst-list-list-conc-matchp
            abnf::cstss
            "binary-numeral [ integer-type-suffix ]")))
 :rule-classes :rewrite)

Theorem: cst-binary-integer-literal-conc-of-tree-fix-cst

(defthm cst-binary-integer-literal-conc-of-tree-fix-cst
 (equal (cst-binary-integer-literal-conc (abnf::tree-fix abnf::cst))
        (cst-binary-integer-literal-conc abnf::cst)))

Theorem: cst-binary-integer-literal-conc-tree-equiv-congruence-on-cst

(defthm cst-binary-integer-literal-conc-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-binary-integer-literal-conc abnf::cst)
                  (cst-binary-integer-literal-conc cst-equiv)))
  :rule-classes :congruence)

Function: cst-integer-type-suffix-conc

(defun cst-integer-type-suffix-conc (abnf::cst)
  (declare (xargs :guard (abnf::treep abnf::cst)))
  (declare
       (xargs :guard (cst-matchp abnf::cst "integer-type-suffix")))
  (abnf::tree-nonleaf->branches abnf::cst))

Theorem: tree-list-listp-of-cst-integer-type-suffix-conc

(defthm tree-list-listp-of-cst-integer-type-suffix-conc
  (b* ((abnf::cstss (cst-integer-type-suffix-conc abnf::cst)))
    (abnf::tree-list-listp abnf::cstss))
  :rule-classes :rewrite)

Theorem: cst-integer-type-suffix-conc-match

(defthm cst-integer-type-suffix-conc-match
  (implies
       (cst-matchp abnf::cst "integer-type-suffix")
       (b* ((abnf::cstss (cst-integer-type-suffix-conc abnf::cst)))
         (cst-list-list-conc-matchp abnf::cstss "\"l\"")))
  :rule-classes :rewrite)

Theorem: cst-integer-type-suffix-conc-of-tree-fix-cst

(defthm cst-integer-type-suffix-conc-of-tree-fix-cst
  (equal (cst-integer-type-suffix-conc (abnf::tree-fix abnf::cst))
         (cst-integer-type-suffix-conc abnf::cst)))

Theorem: cst-integer-type-suffix-conc-tree-equiv-congruence-on-cst

(defthm cst-integer-type-suffix-conc-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-integer-type-suffix-conc abnf::cst)
                  (cst-integer-type-suffix-conc cst-equiv)))
  :rule-classes :congruence)

Function: cst-digits-and-underscores-conc

(defun cst-digits-and-underscores-conc (abnf::cst)
 (declare (xargs :guard (abnf::treep abnf::cst)))
 (declare
     (xargs :guard (cst-matchp abnf::cst "digits-and-underscores")))
 (abnf::tree-nonleaf->branches abnf::cst))

Theorem: tree-list-listp-of-cst-digits-and-underscores-conc

(defthm tree-list-listp-of-cst-digits-and-underscores-conc
  (b* ((abnf::cstss (cst-digits-and-underscores-conc abnf::cst)))
    (abnf::tree-list-listp abnf::cstss))
  :rule-classes :rewrite)

Theorem: cst-digits-and-underscores-conc-match

(defthm cst-digits-and-underscores-conc-match
 (implies
     (cst-matchp abnf::cst "digits-and-underscores")
     (b* ((abnf::cstss (cst-digits-and-underscores-conc abnf::cst)))
       (cst-list-list-conc-matchp
            abnf::cstss
            "digit-or-underscore *digit-or-underscore")))
 :rule-classes :rewrite)

Theorem: cst-digits-and-underscores-conc-of-tree-fix-cst

(defthm cst-digits-and-underscores-conc-of-tree-fix-cst
 (equal (cst-digits-and-underscores-conc (abnf::tree-fix abnf::cst))
        (cst-digits-and-underscores-conc abnf::cst)))

Theorem: cst-digits-and-underscores-conc-tree-equiv-congruence-on-cst

(defthm cst-digits-and-underscores-conc-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-digits-and-underscores-conc abnf::cst)
                  (cst-digits-and-underscores-conc cst-equiv)))
  :rule-classes :congruence)

Function: cst-underscores-conc

(defun cst-underscores-conc (abnf::cst)
  (declare (xargs :guard (abnf::treep abnf::cst)))
  (declare (xargs :guard (cst-matchp abnf::cst "underscores")))
  (abnf::tree-nonleaf->branches abnf::cst))

Theorem: tree-list-listp-of-cst-underscores-conc

(defthm tree-list-listp-of-cst-underscores-conc
  (b* ((abnf::cstss (cst-underscores-conc abnf::cst)))
    (abnf::tree-list-listp abnf::cstss))
  :rule-classes :rewrite)

Theorem: cst-underscores-conc-match

(defthm cst-underscores-conc-match
  (implies (cst-matchp abnf::cst "underscores")
           (b* ((abnf::cstss (cst-underscores-conc abnf::cst)))
             (cst-list-list-conc-matchp abnf::cstss "1*\"_\"")))
  :rule-classes :rewrite)

Theorem: cst-underscores-conc-of-tree-fix-cst

(defthm cst-underscores-conc-of-tree-fix-cst
  (equal (cst-underscores-conc (abnf::tree-fix abnf::cst))
         (cst-underscores-conc abnf::cst)))

Theorem: cst-underscores-conc-tree-equiv-congruence-on-cst

(defthm cst-underscores-conc-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-underscores-conc abnf::cst)
                  (cst-underscores-conc cst-equiv)))
  :rule-classes :congruence)

Function: cst-hex-numeral-conc

(defun cst-hex-numeral-conc (abnf::cst)
  (declare (xargs :guard (abnf::treep abnf::cst)))
  (declare (xargs :guard (cst-matchp abnf::cst "hex-numeral")))
  (abnf::tree-nonleaf->branches abnf::cst))

Theorem: tree-list-listp-of-cst-hex-numeral-conc

(defthm tree-list-listp-of-cst-hex-numeral-conc
  (b* ((abnf::cstss (cst-hex-numeral-conc abnf::cst)))
    (abnf::tree-list-listp abnf::cstss))
  :rule-classes :rewrite)

Theorem: cst-hex-numeral-conc-match

(defthm cst-hex-numeral-conc-match
  (implies
       (cst-matchp abnf::cst "hex-numeral")
       (b* ((abnf::cstss (cst-hex-numeral-conc abnf::cst)))
         (cst-list-list-conc-matchp abnf::cstss "\"0x\" hex-digits")))
  :rule-classes :rewrite)

Theorem: cst-hex-numeral-conc-of-tree-fix-cst

(defthm cst-hex-numeral-conc-of-tree-fix-cst
  (equal (cst-hex-numeral-conc (abnf::tree-fix abnf::cst))
         (cst-hex-numeral-conc abnf::cst)))

Theorem: cst-hex-numeral-conc-tree-equiv-congruence-on-cst

(defthm cst-hex-numeral-conc-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-hex-numeral-conc abnf::cst)
                  (cst-hex-numeral-conc cst-equiv)))
  :rule-classes :congruence)

Function: cst-hex-digits-and-underscores-conc

(defun cst-hex-digits-and-underscores-conc (abnf::cst)
  (declare (xargs :guard (abnf::treep abnf::cst)))
  (declare (xargs :guard (cst-matchp abnf::cst
                                     "hex-digits-and-underscores")))
  (abnf::tree-nonleaf->branches abnf::cst))

Theorem: tree-list-listp-of-cst-hex-digits-and-underscores-conc

(defthm tree-list-listp-of-cst-hex-digits-and-underscores-conc
 (b* ((abnf::cstss (cst-hex-digits-and-underscores-conc abnf::cst)))
   (abnf::tree-list-listp abnf::cstss))
 :rule-classes :rewrite)

Theorem: cst-hex-digits-and-underscores-conc-match

(defthm cst-hex-digits-and-underscores-conc-match
 (implies
   (cst-matchp abnf::cst "hex-digits-and-underscores")
   (b*
     ((abnf::cstss (cst-hex-digits-and-underscores-conc abnf::cst)))
     (cst-list-list-conc-matchp abnf::cstss
                                "1*hex-digit-or-underscore")))
 :rule-classes :rewrite)

Theorem: cst-hex-digits-and-underscores-conc-of-tree-fix-cst

(defthm cst-hex-digits-and-underscores-conc-of-tree-fix-cst
 (equal
    (cst-hex-digits-and-underscores-conc (abnf::tree-fix abnf::cst))
    (cst-hex-digits-and-underscores-conc abnf::cst)))

Theorem: cst-hex-digits-and-underscores-conc-tree-equiv-congruence-on-cst

(defthm
   cst-hex-digits-and-underscores-conc-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-hex-digits-and-underscores-conc abnf::cst)
                  (cst-hex-digits-and-underscores-conc cst-equiv)))
  :rule-classes :congruence)

Function: cst-octal-digits-and-underscores-conc

(defun cst-octal-digits-and-underscores-conc (abnf::cst)
  (declare (xargs :guard (abnf::treep abnf::cst)))
  (declare
       (xargs :guard (cst-matchp abnf::cst
                                 "octal-digits-and-underscores")))
  (abnf::tree-nonleaf->branches abnf::cst))

Theorem: tree-list-listp-of-cst-octal-digits-and-underscores-conc

(defthm tree-list-listp-of-cst-octal-digits-and-underscores-conc
  (b*
   ((abnf::cstss (cst-octal-digits-and-underscores-conc abnf::cst)))
   (abnf::tree-list-listp abnf::cstss))
  :rule-classes :rewrite)

Theorem: cst-octal-digits-and-underscores-conc-match

(defthm cst-octal-digits-and-underscores-conc-match
 (implies
  (cst-matchp abnf::cst
              "octal-digits-and-underscores")
  (b*
   ((abnf::cstss (cst-octal-digits-and-underscores-conc abnf::cst)))
   (cst-list-list-conc-matchp abnf::cstss
                              "1*octal-digit-or-underscore")))
 :rule-classes :rewrite)

Theorem: cst-octal-digits-and-underscores-conc-of-tree-fix-cst

(defthm cst-octal-digits-and-underscores-conc-of-tree-fix-cst
 (equal
  (cst-octal-digits-and-underscores-conc (abnf::tree-fix abnf::cst))
  (cst-octal-digits-and-underscores-conc abnf::cst)))

Theorem: cst-octal-digits-and-underscores-conc-tree-equiv-congruence-on-cst

(defthm
 cst-octal-digits-and-underscores-conc-tree-equiv-congruence-on-cst
 (implies (abnf::tree-equiv abnf::cst cst-equiv)
          (equal (cst-octal-digits-and-underscores-conc abnf::cst)
                 (cst-octal-digits-and-underscores-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")))
  (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 "\"0b\" binary-digits")))
 :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-binary-digits-and-underscores-conc

(defun cst-binary-digits-and-underscores-conc (abnf::cst)
  (declare (xargs :guard (abnf::treep abnf::cst)))
  (declare
       (xargs :guard (cst-matchp abnf::cst
                                 "binary-digits-and-underscores")))
  (abnf::tree-nonleaf->branches abnf::cst))

Theorem: tree-list-listp-of-cst-binary-digits-and-underscores-conc

(defthm tree-list-listp-of-cst-binary-digits-and-underscores-conc
 (b*
  ((abnf::cstss (cst-binary-digits-and-underscores-conc abnf::cst)))
  (abnf::tree-list-listp abnf::cstss))
 :rule-classes :rewrite)

Theorem: cst-binary-digits-and-underscores-conc-match

(defthm cst-binary-digits-and-underscores-conc-match
 (implies
      (cst-matchp abnf::cst
                  "binary-digits-and-underscores")
      (b* ((abnf::cstss
                (cst-binary-digits-and-underscores-conc abnf::cst)))
        (cst-list-list-conc-matchp abnf::cstss
                                   "1*binary-digit-or-underscore")))
 :rule-classes :rewrite)

Theorem: cst-binary-digits-and-underscores-conc-of-tree-fix-cst

(defthm cst-binary-digits-and-underscores-conc-of-tree-fix-cst
  (equal (cst-binary-digits-and-underscores-conc
              (abnf::tree-fix abnf::cst))
         (cst-binary-digits-and-underscores-conc abnf::cst)))

Theorem: cst-binary-digits-and-underscores-conc-tree-equiv-congruence-on-cst

(defthm
 cst-binary-digits-and-underscores-conc-tree-equiv-congruence-on-cst
 (implies
      (abnf::tree-equiv abnf::cst cst-equiv)
      (equal (cst-binary-digits-and-underscores-conc abnf::cst)
             (cst-binary-digits-and-underscores-conc cst-equiv)))
 :rule-classes :congruence)

Function: cst-floating-point-literal-conc1

(defun cst-floating-point-literal-conc1 (abnf::cst)
 (declare (xargs :guard (abnf::treep abnf::cst)))
 (declare
  (xargs
     :guard (and (cst-matchp abnf::cst "floating-point-literal")
                 (equal (cst-floating-point-literal-conc? abnf::cst)
                        1))))
 (abnf::tree-nonleaf->branches abnf::cst))

Theorem: tree-list-listp-of-cst-floating-point-literal-conc1

(defthm tree-list-listp-of-cst-floating-point-literal-conc1
  (b* ((abnf::cstss (cst-floating-point-literal-conc1 abnf::cst)))
    (abnf::tree-list-listp abnf::cstss))
  :rule-classes :rewrite)

Theorem: cst-floating-point-literal-conc1-match

(defthm cst-floating-point-literal-conc1-match
 (implies
    (and (cst-matchp abnf::cst "floating-point-literal")
         (equal (cst-floating-point-literal-conc? abnf::cst)
                1))
    (b* ((abnf::cstss (cst-floating-point-literal-conc1 abnf::cst)))
      (cst-list-list-conc-matchp abnf::cstss
                                 "decimal-floating-point-literal")))
 :rule-classes :rewrite)

Theorem: cst-floating-point-literal-conc1-of-tree-fix-cst

(defthm cst-floating-point-literal-conc1-of-tree-fix-cst
  (equal
       (cst-floating-point-literal-conc1 (abnf::tree-fix abnf::cst))
       (cst-floating-point-literal-conc1 abnf::cst)))

Theorem: cst-floating-point-literal-conc1-tree-equiv-congruence-on-cst

(defthm
      cst-floating-point-literal-conc1-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-floating-point-literal-conc1 abnf::cst)
                  (cst-floating-point-literal-conc1 cst-equiv)))
  :rule-classes :congruence)

Function: cst-floating-point-literal-conc2

(defun cst-floating-point-literal-conc2 (abnf::cst)
 (declare (xargs :guard (abnf::treep abnf::cst)))
 (declare
  (xargs
     :guard (and (cst-matchp abnf::cst "floating-point-literal")
                 (equal (cst-floating-point-literal-conc? abnf::cst)
                        2))))
 (abnf::tree-nonleaf->branches abnf::cst))

Theorem: tree-list-listp-of-cst-floating-point-literal-conc2

(defthm tree-list-listp-of-cst-floating-point-literal-conc2
  (b* ((abnf::cstss (cst-floating-point-literal-conc2 abnf::cst)))
    (abnf::tree-list-listp abnf::cstss))
  :rule-classes :rewrite)

Theorem: cst-floating-point-literal-conc2-match

(defthm cst-floating-point-literal-conc2-match
 (implies
    (and (cst-matchp abnf::cst "floating-point-literal")
         (equal (cst-floating-point-literal-conc? abnf::cst)
                2))
    (b* ((abnf::cstss (cst-floating-point-literal-conc2 abnf::cst)))
      (cst-list-list-conc-matchp
           abnf::cstss
           "hexadecimal-floating-point-literal")))
 :rule-classes :rewrite)

Theorem: cst-floating-point-literal-conc2-of-tree-fix-cst

(defthm cst-floating-point-literal-conc2-of-tree-fix-cst
  (equal
       (cst-floating-point-literal-conc2 (abnf::tree-fix abnf::cst))
       (cst-floating-point-literal-conc2 abnf::cst)))

Theorem: cst-floating-point-literal-conc2-tree-equiv-congruence-on-cst

(defthm
      cst-floating-point-literal-conc2-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-floating-point-literal-conc2 abnf::cst)
                  (cst-floating-point-literal-conc2 cst-equiv)))
  :rule-classes :congruence)

Function: cst-exponent-part-conc

(defun cst-exponent-part-conc (abnf::cst)
  (declare (xargs :guard (abnf::treep abnf::cst)))
  (declare (xargs :guard (cst-matchp abnf::cst "exponent-part")))
  (abnf::tree-nonleaf->branches abnf::cst))

Theorem: tree-list-listp-of-cst-exponent-part-conc

(defthm tree-list-listp-of-cst-exponent-part-conc
  (b* ((abnf::cstss (cst-exponent-part-conc abnf::cst)))
    (abnf::tree-list-listp abnf::cstss))
  :rule-classes :rewrite)

Theorem: cst-exponent-part-conc-match

(defthm cst-exponent-part-conc-match
 (implies
  (cst-matchp abnf::cst "exponent-part")
  (b* ((abnf::cstss (cst-exponent-part-conc abnf::cst)))
   (cst-list-list-conc-matchp abnf::cstss
                              "exponent-indicator signed-integer")))
 :rule-classes :rewrite)

Theorem: cst-exponent-part-conc-of-tree-fix-cst

(defthm cst-exponent-part-conc-of-tree-fix-cst
  (equal (cst-exponent-part-conc (abnf::tree-fix abnf::cst))
         (cst-exponent-part-conc abnf::cst)))

Theorem: cst-exponent-part-conc-tree-equiv-congruence-on-cst

(defthm cst-exponent-part-conc-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-exponent-part-conc abnf::cst)
                  (cst-exponent-part-conc cst-equiv)))
  :rule-classes :congruence)

Function: cst-exponent-indicator-conc

(defun cst-exponent-indicator-conc (abnf::cst)
  (declare (xargs :guard (abnf::treep abnf::cst)))
  (declare
       (xargs :guard (cst-matchp abnf::cst "exponent-indicator")))
  (abnf::tree-nonleaf->branches abnf::cst))

Theorem: tree-list-listp-of-cst-exponent-indicator-conc

(defthm tree-list-listp-of-cst-exponent-indicator-conc
  (b* ((abnf::cstss (cst-exponent-indicator-conc abnf::cst)))
    (abnf::tree-list-listp abnf::cstss))
  :rule-classes :rewrite)

Theorem: cst-exponent-indicator-conc-match

(defthm cst-exponent-indicator-conc-match
  (implies
       (cst-matchp abnf::cst "exponent-indicator")
       (b* ((abnf::cstss (cst-exponent-indicator-conc abnf::cst)))
         (cst-list-list-conc-matchp abnf::cstss "\"e\"")))
  :rule-classes :rewrite)

Theorem: cst-exponent-indicator-conc-of-tree-fix-cst

(defthm cst-exponent-indicator-conc-of-tree-fix-cst
  (equal (cst-exponent-indicator-conc (abnf::tree-fix abnf::cst))
         (cst-exponent-indicator-conc abnf::cst)))

Theorem: cst-exponent-indicator-conc-tree-equiv-congruence-on-cst

(defthm cst-exponent-indicator-conc-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-exponent-indicator-conc abnf::cst)
                  (cst-exponent-indicator-conc cst-equiv)))
  :rule-classes :congruence)

Function: cst-signed-integer-conc

(defun cst-signed-integer-conc (abnf::cst)
  (declare (xargs :guard (abnf::treep abnf::cst)))
  (declare (xargs :guard (cst-matchp abnf::cst "signed-integer")))
  (abnf::tree-nonleaf->branches abnf::cst))

Theorem: tree-list-listp-of-cst-signed-integer-conc

(defthm tree-list-listp-of-cst-signed-integer-conc
  (b* ((abnf::cstss (cst-signed-integer-conc abnf::cst)))
    (abnf::tree-list-listp abnf::cstss))
  :rule-classes :rewrite)

Theorem: cst-signed-integer-conc-match

(defthm cst-signed-integer-conc-match
  (implies
       (cst-matchp abnf::cst "signed-integer")
       (b* ((abnf::cstss (cst-signed-integer-conc abnf::cst)))
         (cst-list-list-conc-matchp abnf::cstss "[ sign ] digits")))
  :rule-classes :rewrite)

Theorem: cst-signed-integer-conc-of-tree-fix-cst

(defthm cst-signed-integer-conc-of-tree-fix-cst
  (equal (cst-signed-integer-conc (abnf::tree-fix abnf::cst))
         (cst-signed-integer-conc abnf::cst)))

Theorem: cst-signed-integer-conc-tree-equiv-congruence-on-cst

(defthm cst-signed-integer-conc-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-signed-integer-conc abnf::cst)
                  (cst-signed-integer-conc cst-equiv)))
  :rule-classes :congruence)

Function: cst-hexadecimal-floating-point-literal-conc

(defun cst-hexadecimal-floating-point-literal-conc (abnf::cst)
 (declare (xargs :guard (abnf::treep abnf::cst)))
 (declare
   (xargs :guard (cst-matchp abnf::cst
                             "hexadecimal-floating-point-literal")))
 (abnf::tree-nonleaf->branches abnf::cst))

Theorem: tree-list-listp-of-cst-hexadecimal-floating-point-literal-conc

(defthm
     tree-list-listp-of-cst-hexadecimal-floating-point-literal-conc
 (b* ((abnf::cstss
           (cst-hexadecimal-floating-point-literal-conc abnf::cst)))
   (abnf::tree-list-listp abnf::cstss))
 :rule-classes :rewrite)

Theorem: cst-hexadecimal-floating-point-literal-conc-match

(defthm cst-hexadecimal-floating-point-literal-conc-match
 (implies
   (cst-matchp abnf::cst
               "hexadecimal-floating-point-literal")
   (b*
     ((abnf::cstss
           (cst-hexadecimal-floating-point-literal-conc abnf::cst)))
     (cst-list-list-conc-matchp
          abnf::cstss
          "hex-significand binary-exponent [ float-type-suffix ]")))
 :rule-classes :rewrite)

Theorem: cst-hexadecimal-floating-point-literal-conc-of-tree-fix-cst

(defthm cst-hexadecimal-floating-point-literal-conc-of-tree-fix-cst
  (equal (cst-hexadecimal-floating-point-literal-conc
              (abnf::tree-fix abnf::cst))
         (cst-hexadecimal-floating-point-literal-conc abnf::cst)))

Theorem: cst-hexadecimal-floating-point-literal-conc-tree-equiv-congruence-on-cst

(defthm
 cst-hexadecimal-floating-point-literal-conc-tree-equiv-congruence-on-cst
 (implies
    (abnf::tree-equiv abnf::cst cst-equiv)
    (equal (cst-hexadecimal-floating-point-literal-conc abnf::cst)
           (cst-hexadecimal-floating-point-literal-conc cst-equiv)))
 :rule-classes :congruence)

Function: cst-binary-exponent-conc

(defun cst-binary-exponent-conc (abnf::cst)
  (declare (xargs :guard (abnf::treep abnf::cst)))
  (declare (xargs :guard (cst-matchp abnf::cst "binary-exponent")))
  (abnf::tree-nonleaf->branches abnf::cst))

Theorem: tree-list-listp-of-cst-binary-exponent-conc

(defthm tree-list-listp-of-cst-binary-exponent-conc
  (b* ((abnf::cstss (cst-binary-exponent-conc abnf::cst)))
    (abnf::tree-list-listp abnf::cstss))
  :rule-classes :rewrite)

Theorem: cst-binary-exponent-conc-match

(defthm cst-binary-exponent-conc-match
  (implies (cst-matchp abnf::cst "binary-exponent")
           (b* ((abnf::cstss (cst-binary-exponent-conc abnf::cst)))
             (cst-list-list-conc-matchp
                  abnf::cstss
                  "binary-exponent-indicator signed-integer")))
  :rule-classes :rewrite)

Theorem: cst-binary-exponent-conc-of-tree-fix-cst

(defthm cst-binary-exponent-conc-of-tree-fix-cst
  (equal (cst-binary-exponent-conc (abnf::tree-fix abnf::cst))
         (cst-binary-exponent-conc abnf::cst)))

Theorem: cst-binary-exponent-conc-tree-equiv-congruence-on-cst

(defthm cst-binary-exponent-conc-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-binary-exponent-conc abnf::cst)
                  (cst-binary-exponent-conc cst-equiv)))
  :rule-classes :congruence)

Function: cst-binary-exponent-indicator-conc

(defun cst-binary-exponent-indicator-conc (abnf::cst)
 (declare (xargs :guard (abnf::treep abnf::cst)))
 (declare
  (xargs :guard (cst-matchp abnf::cst "binary-exponent-indicator")))
 (abnf::tree-nonleaf->branches abnf::cst))

Theorem: tree-list-listp-of-cst-binary-exponent-indicator-conc

(defthm tree-list-listp-of-cst-binary-exponent-indicator-conc
  (b* ((abnf::cstss (cst-binary-exponent-indicator-conc abnf::cst)))
    (abnf::tree-list-listp abnf::cstss))
  :rule-classes :rewrite)

Theorem: cst-binary-exponent-indicator-conc-match

(defthm cst-binary-exponent-indicator-conc-match
 (implies
  (cst-matchp abnf::cst "binary-exponent-indicator")
  (b* ((abnf::cstss (cst-binary-exponent-indicator-conc abnf::cst)))
    (cst-list-list-conc-matchp abnf::cstss "\"p\"")))
 :rule-classes :rewrite)

Theorem: cst-binary-exponent-indicator-conc-of-tree-fix-cst

(defthm cst-binary-exponent-indicator-conc-of-tree-fix-cst
 (equal
     (cst-binary-exponent-indicator-conc (abnf::tree-fix abnf::cst))
     (cst-binary-exponent-indicator-conc abnf::cst)))

Theorem: cst-binary-exponent-indicator-conc-tree-equiv-congruence-on-cst

(defthm
    cst-binary-exponent-indicator-conc-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-binary-exponent-indicator-conc abnf::cst)
                  (cst-binary-exponent-indicator-conc cst-equiv)))
  :rule-classes :congruence)

Function: cst-single-character-conc

(defun cst-single-character-conc (abnf::cst)
  (declare (xargs :guard (abnf::treep abnf::cst)))
  (declare (xargs :guard (cst-matchp abnf::cst "single-character")))
  (abnf::tree-nonleaf->branches abnf::cst))

Theorem: tree-list-listp-of-cst-single-character-conc

(defthm tree-list-listp-of-cst-single-character-conc
  (b* ((abnf::cstss (cst-single-character-conc abnf::cst)))
    (abnf::tree-list-listp abnf::cstss))
  :rule-classes :rewrite)

Theorem: cst-single-character-conc-match

(defthm cst-single-character-conc-match
  (implies
       (cst-matchp abnf::cst "single-character")
       (b* ((abnf::cstss (cst-single-character-conc abnf::cst)))
         (cst-list-list-conc-matchp abnf::cstss "input-character")))
  :rule-classes :rewrite)

Theorem: cst-single-character-conc-of-tree-fix-cst

(defthm cst-single-character-conc-of-tree-fix-cst
  (equal (cst-single-character-conc (abnf::tree-fix abnf::cst))
         (cst-single-character-conc abnf::cst)))

Theorem: cst-single-character-conc-tree-equiv-congruence-on-cst

(defthm cst-single-character-conc-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-single-character-conc abnf::cst)
                  (cst-single-character-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")))
  (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
                                    "%d34 *string-character %d34")))
  :rule-classes :rewrite)

Theorem: cst-string-literal-conc-of-tree-fix-cst

(defthm cst-string-literal-conc-of-tree-fix-cst
  (equal (cst-string-literal-conc (abnf::tree-fix abnf::cst))
         (cst-string-literal-conc abnf::cst)))

Theorem: cst-string-literal-conc-tree-equiv-congruence-on-cst

(defthm cst-string-literal-conc-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-string-literal-conc abnf::cst)
                  (cst-string-literal-conc cst-equiv)))
  :rule-classes :congruence)

Function: cst-string-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))))
 (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 "input-character")))
  :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))))
 (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 "escape-sequence")))
  :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-text-block-conc

(defun cst-text-block-conc (abnf::cst)
  (declare (xargs :guard (abnf::treep abnf::cst)))
  (declare (xargs :guard (cst-matchp abnf::cst "text-block")))
  (abnf::tree-nonleaf->branches abnf::cst))

Theorem: tree-list-listp-of-cst-text-block-conc

(defthm tree-list-listp-of-cst-text-block-conc
  (b* ((abnf::cstss (cst-text-block-conc abnf::cst)))
    (abnf::tree-list-listp abnf::cstss))
  :rule-classes :rewrite)

Theorem: cst-text-block-conc-match

(defthm cst-text-block-conc-match
 (implies
  (cst-matchp abnf::cst "text-block")
  (b* ((abnf::cstss (cst-text-block-conc abnf::cst)))
   (cst-list-list-conc-matchp
    abnf::cstss
    "%d34 %d34 %d34 *text-block-white-space line-terminator *text-block-character %d34 %d34 %d34")))
 :rule-classes :rewrite)

Theorem: cst-text-block-conc-of-tree-fix-cst

(defthm cst-text-block-conc-of-tree-fix-cst
  (equal (cst-text-block-conc (abnf::tree-fix abnf::cst))
         (cst-text-block-conc abnf::cst)))

Theorem: cst-text-block-conc-tree-equiv-congruence-on-cst

(defthm cst-text-block-conc-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-text-block-conc abnf::cst)
                  (cst-text-block-conc cst-equiv)))
  :rule-classes :congruence)

Function: cst-text-block-white-space-conc

(defun cst-text-block-white-space-conc (abnf::cst)
 (declare (xargs :guard (abnf::treep abnf::cst)))
 (declare
     (xargs :guard (cst-matchp abnf::cst "text-block-white-space")))
 (abnf::tree-nonleaf->branches abnf::cst))

Theorem: tree-list-listp-of-cst-text-block-white-space-conc

(defthm tree-list-listp-of-cst-text-block-white-space-conc
  (b* ((abnf::cstss (cst-text-block-white-space-conc abnf::cst)))
    (abnf::tree-list-listp abnf::cstss))
  :rule-classes :rewrite)

Theorem: cst-text-block-white-space-conc-match

(defthm cst-text-block-white-space-conc-match
 (implies
     (cst-matchp abnf::cst "text-block-white-space")
     (b* ((abnf::cstss (cst-text-block-white-space-conc abnf::cst)))
       (cst-list-list-conc-matchp abnf::cstss "white-space")))
 :rule-classes :rewrite)

Theorem: cst-text-block-white-space-conc-of-tree-fix-cst

(defthm cst-text-block-white-space-conc-of-tree-fix-cst
 (equal (cst-text-block-white-space-conc (abnf::tree-fix abnf::cst))
        (cst-text-block-white-space-conc abnf::cst)))

Theorem: cst-text-block-white-space-conc-tree-equiv-congruence-on-cst

(defthm cst-text-block-white-space-conc-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-text-block-white-space-conc abnf::cst)
                  (cst-text-block-white-space-conc cst-equiv)))
  :rule-classes :congruence)

Function: cst-text-block-character-conc1

(defun cst-text-block-character-conc1 (abnf::cst)
 (declare (xargs :guard (abnf::treep abnf::cst)))
 (declare
  (xargs
       :guard (and (cst-matchp abnf::cst "text-block-character")
                   (equal (cst-text-block-character-conc? abnf::cst)
                          1))))
 (abnf::tree-nonleaf->branches abnf::cst))

Theorem: tree-list-listp-of-cst-text-block-character-conc1

(defthm tree-list-listp-of-cst-text-block-character-conc1
  (b* ((abnf::cstss (cst-text-block-character-conc1 abnf::cst)))
    (abnf::tree-list-listp abnf::cstss))
  :rule-classes :rewrite)

Theorem: cst-text-block-character-conc1-match

(defthm cst-text-block-character-conc1-match
 (implies
      (and (cst-matchp abnf::cst "text-block-character")
           (equal (cst-text-block-character-conc? abnf::cst)
                  1))
      (b* ((abnf::cstss (cst-text-block-character-conc1 abnf::cst)))
        (cst-list-list-conc-matchp abnf::cstss "input-character")))
 :rule-classes :rewrite)

Theorem: cst-text-block-character-conc1-of-tree-fix-cst

(defthm cst-text-block-character-conc1-of-tree-fix-cst
  (equal (cst-text-block-character-conc1 (abnf::tree-fix abnf::cst))
         (cst-text-block-character-conc1 abnf::cst)))

Theorem: cst-text-block-character-conc1-tree-equiv-congruence-on-cst

(defthm cst-text-block-character-conc1-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-text-block-character-conc1 abnf::cst)
                  (cst-text-block-character-conc1 cst-equiv)))
  :rule-classes :congruence)

Function: cst-text-block-character-conc2

(defun cst-text-block-character-conc2 (abnf::cst)
 (declare (xargs :guard (abnf::treep abnf::cst)))
 (declare
  (xargs
       :guard (and (cst-matchp abnf::cst "text-block-character")
                   (equal (cst-text-block-character-conc? abnf::cst)
                          2))))
 (abnf::tree-nonleaf->branches abnf::cst))

Theorem: tree-list-listp-of-cst-text-block-character-conc2

(defthm tree-list-listp-of-cst-text-block-character-conc2
  (b* ((abnf::cstss (cst-text-block-character-conc2 abnf::cst)))
    (abnf::tree-list-listp abnf::cstss))
  :rule-classes :rewrite)

Theorem: cst-text-block-character-conc2-match

(defthm cst-text-block-character-conc2-match
 (implies
      (and (cst-matchp abnf::cst "text-block-character")
           (equal (cst-text-block-character-conc? abnf::cst)
                  2))
      (b* ((abnf::cstss (cst-text-block-character-conc2 abnf::cst)))
        (cst-list-list-conc-matchp abnf::cstss "escape-sequence")))
 :rule-classes :rewrite)

Theorem: cst-text-block-character-conc2-of-tree-fix-cst

(defthm cst-text-block-character-conc2-of-tree-fix-cst
  (equal (cst-text-block-character-conc2 (abnf::tree-fix abnf::cst))
         (cst-text-block-character-conc2 abnf::cst)))

Theorem: cst-text-block-character-conc2-tree-equiv-congruence-on-cst

(defthm cst-text-block-character-conc2-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-text-block-character-conc2 abnf::cst)
                  (cst-text-block-character-conc2 cst-equiv)))
  :rule-classes :congruence)

Function: cst-text-block-character-conc3

(defun cst-text-block-character-conc3 (abnf::cst)
 (declare (xargs :guard (abnf::treep abnf::cst)))
 (declare
  (xargs
       :guard (and (cst-matchp abnf::cst "text-block-character")
                   (equal (cst-text-block-character-conc? abnf::cst)
                          3))))
 (abnf::tree-nonleaf->branches abnf::cst))

Theorem: tree-list-listp-of-cst-text-block-character-conc3

(defthm tree-list-listp-of-cst-text-block-character-conc3
  (b* ((abnf::cstss (cst-text-block-character-conc3 abnf::cst)))
    (abnf::tree-list-listp abnf::cstss))
  :rule-classes :rewrite)

Theorem: cst-text-block-character-conc3-match

(defthm cst-text-block-character-conc3-match
 (implies
      (and (cst-matchp abnf::cst "text-block-character")
           (equal (cst-text-block-character-conc? abnf::cst)
                  3))
      (b* ((abnf::cstss (cst-text-block-character-conc3 abnf::cst)))
        (cst-list-list-conc-matchp abnf::cstss "line-terminator")))
 :rule-classes :rewrite)

Theorem: cst-text-block-character-conc3-of-tree-fix-cst

(defthm cst-text-block-character-conc3-of-tree-fix-cst
  (equal (cst-text-block-character-conc3 (abnf::tree-fix abnf::cst))
         (cst-text-block-character-conc3 abnf::cst)))

Theorem: cst-text-block-character-conc3-tree-equiv-congruence-on-cst

(defthm cst-text-block-character-conc3-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-text-block-character-conc3 abnf::cst)
                  (cst-text-block-character-conc3 cst-equiv)))
  :rule-classes :congruence)

Function: cst-null-literal-conc

(defun cst-null-literal-conc (abnf::cst)
  (declare (xargs :guard (abnf::treep abnf::cst)))
  (declare (xargs :guard (cst-matchp abnf::cst "null-literal")))
  (abnf::tree-nonleaf->branches abnf::cst))

Theorem: tree-list-listp-of-cst-null-literal-conc

(defthm tree-list-listp-of-cst-null-literal-conc
  (b* ((abnf::cstss (cst-null-literal-conc abnf::cst)))
    (abnf::tree-list-listp abnf::cstss))
  :rule-classes :rewrite)

Theorem: cst-null-literal-conc-match

(defthm cst-null-literal-conc-match
  (implies (cst-matchp abnf::cst "null-literal")
           (b* ((abnf::cstss (cst-null-literal-conc abnf::cst)))
             (cst-list-list-conc-matchp abnf::cstss "%s\"null\"")))
  :rule-classes :rewrite)

Theorem: cst-null-literal-conc-of-tree-fix-cst

(defthm cst-null-literal-conc-of-tree-fix-cst
  (equal (cst-null-literal-conc (abnf::tree-fix abnf::cst))
         (cst-null-literal-conc abnf::cst)))

Theorem: cst-null-literal-conc-tree-equiv-congruence-on-cst

(defthm cst-null-literal-conc-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-null-literal-conc abnf::cst)
                  (cst-null-literal-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))))
 (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))))
 (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 "reference-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-numeric-type-conc1

(defun cst-numeric-type-conc1 (abnf::cst)
  (declare (xargs :guard (abnf::treep abnf::cst)))
  (declare
       (xargs :guard (and (cst-matchp abnf::cst "numeric-type")
                          (equal (cst-numeric-type-conc? abnf::cst)
                                 1))))
  (abnf::tree-nonleaf->branches abnf::cst))

Theorem: tree-list-listp-of-cst-numeric-type-conc1

(defthm tree-list-listp-of-cst-numeric-type-conc1
  (b* ((abnf::cstss (cst-numeric-type-conc1 abnf::cst)))
    (abnf::tree-list-listp abnf::cstss))
  :rule-classes :rewrite)

Theorem: cst-numeric-type-conc1-match

(defthm cst-numeric-type-conc1-match
  (implies
       (and (cst-matchp abnf::cst "numeric-type")
            (equal (cst-numeric-type-conc? abnf::cst)
                   1))
       (b* ((abnf::cstss (cst-numeric-type-conc1 abnf::cst)))
         (cst-list-list-conc-matchp abnf::cstss "integral-type")))
  :rule-classes :rewrite)

Theorem: cst-numeric-type-conc1-of-tree-fix-cst

(defthm cst-numeric-type-conc1-of-tree-fix-cst
  (equal (cst-numeric-type-conc1 (abnf::tree-fix abnf::cst))
         (cst-numeric-type-conc1 abnf::cst)))

Theorem: cst-numeric-type-conc1-tree-equiv-congruence-on-cst

(defthm cst-numeric-type-conc1-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-numeric-type-conc1 abnf::cst)
                  (cst-numeric-type-conc1 cst-equiv)))
  :rule-classes :congruence)

Function: cst-numeric-type-conc2

(defun cst-numeric-type-conc2 (abnf::cst)
  (declare (xargs :guard (abnf::treep abnf::cst)))
  (declare
       (xargs :guard (and (cst-matchp abnf::cst "numeric-type")
                          (equal (cst-numeric-type-conc? abnf::cst)
                                 2))))
  (abnf::tree-nonleaf->branches abnf::cst))

Theorem: tree-list-listp-of-cst-numeric-type-conc2

(defthm tree-list-listp-of-cst-numeric-type-conc2
  (b* ((abnf::cstss (cst-numeric-type-conc2 abnf::cst)))
    (abnf::tree-list-listp abnf::cstss))
  :rule-classes :rewrite)

Theorem: cst-numeric-type-conc2-match

(defthm cst-numeric-type-conc2-match
 (implies
   (and (cst-matchp abnf::cst "numeric-type")
        (equal (cst-numeric-type-conc? abnf::cst)
               2))
   (b* ((abnf::cstss (cst-numeric-type-conc2 abnf::cst)))
     (cst-list-list-conc-matchp abnf::cstss "floating-point-type")))
 :rule-classes :rewrite)

Theorem: cst-numeric-type-conc2-of-tree-fix-cst

(defthm cst-numeric-type-conc2-of-tree-fix-cst
  (equal (cst-numeric-type-conc2 (abnf::tree-fix abnf::cst))
         (cst-numeric-type-conc2 abnf::cst)))

Theorem: cst-numeric-type-conc2-tree-equiv-congruence-on-cst

(defthm cst-numeric-type-conc2-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-numeric-type-conc2 abnf::cst)
                  (cst-numeric-type-conc2 cst-equiv)))
  :rule-classes :congruence)

Function: cst-reference-type-conc1

(defun cst-reference-type-conc1 (abnf::cst)
 (declare (xargs :guard (abnf::treep abnf::cst)))
 (declare
      (xargs :guard (and (cst-matchp abnf::cst "reference-type")
                         (equal (cst-reference-type-conc? abnf::cst)
                                1))))
 (abnf::tree-nonleaf->branches abnf::cst))

Theorem: tree-list-listp-of-cst-reference-type-conc1

(defthm tree-list-listp-of-cst-reference-type-conc1
  (b* ((abnf::cstss (cst-reference-type-conc1 abnf::cst)))
    (abnf::tree-list-listp abnf::cstss))
  :rule-classes :rewrite)

Theorem: cst-reference-type-conc1-match

(defthm cst-reference-type-conc1-match
  (implies (and (cst-matchp abnf::cst "reference-type")
                (equal (cst-reference-type-conc? abnf::cst)
                       1))
           (b* ((abnf::cstss (cst-reference-type-conc1 abnf::cst)))
             (cst-list-list-conc-matchp
                  abnf::cstss "class-or-interface-type")))
  :rule-classes :rewrite)

Theorem: cst-reference-type-conc1-of-tree-fix-cst

(defthm cst-reference-type-conc1-of-tree-fix-cst
  (equal (cst-reference-type-conc1 (abnf::tree-fix abnf::cst))
         (cst-reference-type-conc1 abnf::cst)))

Theorem: cst-reference-type-conc1-tree-equiv-congruence-on-cst

(defthm cst-reference-type-conc1-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-reference-type-conc1 abnf::cst)
                  (cst-reference-type-conc1 cst-equiv)))
  :rule-classes :congruence)

Function: cst-reference-type-conc2

(defun cst-reference-type-conc2 (abnf::cst)
 (declare (xargs :guard (abnf::treep abnf::cst)))
 (declare
      (xargs :guard (and (cst-matchp abnf::cst "reference-type")
                         (equal (cst-reference-type-conc? abnf::cst)
                                2))))
 (abnf::tree-nonleaf->branches abnf::cst))

Theorem: tree-list-listp-of-cst-reference-type-conc2

(defthm tree-list-listp-of-cst-reference-type-conc2
  (b* ((abnf::cstss (cst-reference-type-conc2 abnf::cst)))
    (abnf::tree-list-listp abnf::cstss))
  :rule-classes :rewrite)

Theorem: cst-reference-type-conc2-match

(defthm cst-reference-type-conc2-match
  (implies
       (and (cst-matchp abnf::cst "reference-type")
            (equal (cst-reference-type-conc? abnf::cst)
                   2))
       (b* ((abnf::cstss (cst-reference-type-conc2 abnf::cst)))
         (cst-list-list-conc-matchp abnf::cstss "type-variable")))
  :rule-classes :rewrite)

Theorem: cst-reference-type-conc2-of-tree-fix-cst

(defthm cst-reference-type-conc2-of-tree-fix-cst
  (equal (cst-reference-type-conc2 (abnf::tree-fix abnf::cst))
         (cst-reference-type-conc2 abnf::cst)))

Theorem: cst-reference-type-conc2-tree-equiv-congruence-on-cst

(defthm cst-reference-type-conc2-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-reference-type-conc2 abnf::cst)
                  (cst-reference-type-conc2 cst-equiv)))
  :rule-classes :congruence)

Function: cst-reference-type-conc3

(defun cst-reference-type-conc3 (abnf::cst)
 (declare (xargs :guard (abnf::treep abnf::cst)))
 (declare
      (xargs :guard (and (cst-matchp abnf::cst "reference-type")
                         (equal (cst-reference-type-conc? abnf::cst)
                                3))))
 (abnf::tree-nonleaf->branches abnf::cst))

Theorem: tree-list-listp-of-cst-reference-type-conc3

(defthm tree-list-listp-of-cst-reference-type-conc3
  (b* ((abnf::cstss (cst-reference-type-conc3 abnf::cst)))
    (abnf::tree-list-listp abnf::cstss))
  :rule-classes :rewrite)

Theorem: cst-reference-type-conc3-match

(defthm cst-reference-type-conc3-match
  (implies (and (cst-matchp abnf::cst "reference-type")
                (equal (cst-reference-type-conc? abnf::cst)
                       3))
           (b* ((abnf::cstss (cst-reference-type-conc3 abnf::cst)))
             (cst-list-list-conc-matchp abnf::cstss "array-type")))
  :rule-classes :rewrite)

Theorem: cst-reference-type-conc3-of-tree-fix-cst

(defthm cst-reference-type-conc3-of-tree-fix-cst
  (equal (cst-reference-type-conc3 (abnf::tree-fix abnf::cst))
         (cst-reference-type-conc3 abnf::cst)))

Theorem: cst-reference-type-conc3-tree-equiv-congruence-on-cst

(defthm cst-reference-type-conc3-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-reference-type-conc3 abnf::cst)
                  (cst-reference-type-conc3 cst-equiv)))
  :rule-classes :congruence)

Function: cst-class-or-interface-type-conc1

(defun cst-class-or-interface-type-conc1 (abnf::cst)
 (declare (xargs :guard (abnf::treep abnf::cst)))
 (declare
  (xargs
    :guard (and (cst-matchp abnf::cst "class-or-interface-type")
                (equal (cst-class-or-interface-type-conc? abnf::cst)
                       1))))
 (abnf::tree-nonleaf->branches abnf::cst))

Theorem: tree-list-listp-of-cst-class-or-interface-type-conc1

(defthm tree-list-listp-of-cst-class-or-interface-type-conc1
  (b* ((abnf::cstss (cst-class-or-interface-type-conc1 abnf::cst)))
    (abnf::tree-list-listp abnf::cstss))
  :rule-classes :rewrite)

Theorem: cst-class-or-interface-type-conc1-match

(defthm cst-class-or-interface-type-conc1-match
 (implies
   (and (cst-matchp abnf::cst "class-or-interface-type")
        (equal (cst-class-or-interface-type-conc? abnf::cst)
               1))
   (b* ((abnf::cstss (cst-class-or-interface-type-conc1 abnf::cst)))
     (cst-list-list-conc-matchp abnf::cstss "class-type")))
 :rule-classes :rewrite)

Theorem: cst-class-or-interface-type-conc1-of-tree-fix-cst

(defthm cst-class-or-interface-type-conc1-of-tree-fix-cst
 (equal
      (cst-class-or-interface-type-conc1 (abnf::tree-fix abnf::cst))
      (cst-class-or-interface-type-conc1 abnf::cst)))

Theorem: cst-class-or-interface-type-conc1-tree-equiv-congruence-on-cst

(defthm
     cst-class-or-interface-type-conc1-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-class-or-interface-type-conc1 abnf::cst)
                  (cst-class-or-interface-type-conc1 cst-equiv)))
  :rule-classes :congruence)

Function: cst-class-or-interface-type-conc2

(defun cst-class-or-interface-type-conc2 (abnf::cst)
 (declare (xargs :guard (abnf::treep abnf::cst)))
 (declare
  (xargs
    :guard (and (cst-matchp abnf::cst "class-or-interface-type")
                (equal (cst-class-or-interface-type-conc? abnf::cst)
                       2))))
 (abnf::tree-nonleaf->branches abnf::cst))

Theorem: tree-list-listp-of-cst-class-or-interface-type-conc2

(defthm tree-list-listp-of-cst-class-or-interface-type-conc2
  (b* ((abnf::cstss (cst-class-or-interface-type-conc2 abnf::cst)))
    (abnf::tree-list-listp abnf::cstss))
  :rule-classes :rewrite)

Theorem: cst-class-or-interface-type-conc2-match

(defthm cst-class-or-interface-type-conc2-match
 (implies
   (and (cst-matchp abnf::cst "class-or-interface-type")
        (equal (cst-class-or-interface-type-conc? abnf::cst)
               2))
   (b* ((abnf::cstss (cst-class-or-interface-type-conc2 abnf::cst)))
     (cst-list-list-conc-matchp abnf::cstss "interface-type")))
 :rule-classes :rewrite)

Theorem: cst-class-or-interface-type-conc2-of-tree-fix-cst

(defthm cst-class-or-interface-type-conc2-of-tree-fix-cst
 (equal
      (cst-class-or-interface-type-conc2 (abnf::tree-fix abnf::cst))
      (cst-class-or-interface-type-conc2 abnf::cst)))

Theorem: cst-class-or-interface-type-conc2-tree-equiv-congruence-on-cst

(defthm
     cst-class-or-interface-type-conc2-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-class-or-interface-type-conc2 abnf::cst)
                  (cst-class-or-interface-type-conc2 cst-equiv)))
  :rule-classes :congruence)

Function: cst-interface-type-conc

(defun cst-interface-type-conc (abnf::cst)
  (declare (xargs :guard (abnf::treep abnf::cst)))
  (declare (xargs :guard (cst-matchp abnf::cst "interface-type")))
  (abnf::tree-nonleaf->branches abnf::cst))

Theorem: tree-list-listp-of-cst-interface-type-conc

(defthm tree-list-listp-of-cst-interface-type-conc
  (b* ((abnf::cstss (cst-interface-type-conc abnf::cst)))
    (abnf::tree-list-listp abnf::cstss))
  :rule-classes :rewrite)

Theorem: cst-interface-type-conc-match

(defthm cst-interface-type-conc-match
  (implies (cst-matchp abnf::cst "interface-type")
           (b* ((abnf::cstss (cst-interface-type-conc abnf::cst)))
             (cst-list-list-conc-matchp abnf::cstss "class-type")))
  :rule-classes :rewrite)

Theorem: cst-interface-type-conc-of-tree-fix-cst

(defthm cst-interface-type-conc-of-tree-fix-cst
  (equal (cst-interface-type-conc (abnf::tree-fix abnf::cst))
         (cst-interface-type-conc abnf::cst)))

Theorem: cst-interface-type-conc-tree-equiv-congruence-on-cst

(defthm cst-interface-type-conc-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-interface-type-conc abnf::cst)
                  (cst-interface-type-conc cst-equiv)))
  :rule-classes :congruence)

Function: cst-type-variable-conc

(defun cst-type-variable-conc (abnf::cst)
  (declare (xargs :guard (abnf::treep abnf::cst)))
  (declare (xargs :guard (cst-matchp abnf::cst "type-variable")))
  (abnf::tree-nonleaf->branches abnf::cst))

Theorem: tree-list-listp-of-cst-type-variable-conc

(defthm tree-list-listp-of-cst-type-variable-conc
  (b* ((abnf::cstss (cst-type-variable-conc abnf::cst)))
    (abnf::tree-list-listp abnf::cstss))
  :rule-classes :rewrite)

Theorem: cst-type-variable-conc-match

(defthm cst-type-variable-conc-match
  (implies
       (cst-matchp abnf::cst "type-variable")
       (b* ((abnf::cstss (cst-type-variable-conc abnf::cst)))
         (cst-list-list-conc-matchp abnf::cstss
                                    "*annotation type-identifier")))
  :rule-classes :rewrite)

Theorem: cst-type-variable-conc-of-tree-fix-cst

(defthm cst-type-variable-conc-of-tree-fix-cst
  (equal (cst-type-variable-conc (abnf::tree-fix abnf::cst))
         (cst-type-variable-conc abnf::cst)))

Theorem: cst-type-variable-conc-tree-equiv-congruence-on-cst

(defthm cst-type-variable-conc-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-type-variable-conc abnf::cst)
                  (cst-type-variable-conc cst-equiv)))
  :rule-classes :congruence)

Function: cst-dims-conc

(defun cst-dims-conc (abnf::cst)
  (declare (xargs :guard (abnf::treep abnf::cst)))
  (declare (xargs :guard (cst-matchp abnf::cst "dims")))
  (abnf::tree-nonleaf->branches abnf::cst))

Theorem: tree-list-listp-of-cst-dims-conc

(defthm tree-list-listp-of-cst-dims-conc
  (b* ((abnf::cstss (cst-dims-conc abnf::cst)))
    (abnf::tree-list-listp abnf::cstss))
  :rule-classes :rewrite)

Theorem: cst-dims-conc-match

(defthm cst-dims-conc-match
  (implies
       (cst-matchp abnf::cst "dims")
       (b* ((abnf::cstss (cst-dims-conc abnf::cst)))
         (cst-list-list-conc-matchp abnf::cstss
                                    "1*( *annotation \"[\" \"]\" )")))
  :rule-classes :rewrite)

Theorem: cst-dims-conc-of-tree-fix-cst

(defthm cst-dims-conc-of-tree-fix-cst
  (equal (cst-dims-conc (abnf::tree-fix abnf::cst))
         (cst-dims-conc abnf::cst)))

Theorem: cst-dims-conc-tree-equiv-congruence-on-cst

(defthm cst-dims-conc-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-dims-conc abnf::cst)
                  (cst-dims-conc cst-equiv)))
  :rule-classes :congruence)

Function: cst-type-parameter-conc

(defun cst-type-parameter-conc (abnf::cst)
  (declare (xargs :guard (abnf::treep abnf::cst)))
  (declare (xargs :guard (cst-matchp abnf::cst "type-parameter")))
  (abnf::tree-nonleaf->branches abnf::cst))

Theorem: tree-list-listp-of-cst-type-parameter-conc

(defthm tree-list-listp-of-cst-type-parameter-conc
  (b* ((abnf::cstss (cst-type-parameter-conc abnf::cst)))
    (abnf::tree-list-listp abnf::cstss))
  :rule-classes :rewrite)

Theorem: cst-type-parameter-conc-match

(defthm cst-type-parameter-conc-match
 (implies
  (cst-matchp abnf::cst "type-parameter")
  (b* ((abnf::cstss (cst-type-parameter-conc abnf::cst)))
   (cst-list-list-conc-matchp
        abnf::cstss
        "*type-parameter-modifier type-identifier [ type-bound ]")))
 :rule-classes :rewrite)

Theorem: cst-type-parameter-conc-of-tree-fix-cst

(defthm cst-type-parameter-conc-of-tree-fix-cst
  (equal (cst-type-parameter-conc (abnf::tree-fix abnf::cst))
         (cst-type-parameter-conc abnf::cst)))

Theorem: cst-type-parameter-conc-tree-equiv-congruence-on-cst

(defthm cst-type-parameter-conc-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-type-parameter-conc abnf::cst)
                  (cst-type-parameter-conc cst-equiv)))
  :rule-classes :congruence)

Function: cst-type-parameter-modifier-conc

(defun cst-type-parameter-modifier-conc (abnf::cst)
 (declare (xargs :guard (abnf::treep abnf::cst)))
 (declare
    (xargs :guard (cst-matchp abnf::cst "type-parameter-modifier")))
 (abnf::tree-nonleaf->branches abnf::cst))

Theorem: tree-list-listp-of-cst-type-parameter-modifier-conc

(defthm tree-list-listp-of-cst-type-parameter-modifier-conc
  (b* ((abnf::cstss (cst-type-parameter-modifier-conc abnf::cst)))
    (abnf::tree-list-listp abnf::cstss))
  :rule-classes :rewrite)

Theorem: cst-type-parameter-modifier-conc-match

(defthm cst-type-parameter-modifier-conc-match
 (implies
    (cst-matchp abnf::cst "type-parameter-modifier")
    (b* ((abnf::cstss (cst-type-parameter-modifier-conc abnf::cst)))
      (cst-list-list-conc-matchp abnf::cstss "annotation")))
 :rule-classes :rewrite)

Theorem: cst-type-parameter-modifier-conc-of-tree-fix-cst

(defthm cst-type-parameter-modifier-conc-of-tree-fix-cst
  (equal
       (cst-type-parameter-modifier-conc (abnf::tree-fix abnf::cst))
       (cst-type-parameter-modifier-conc abnf::cst)))

Theorem: cst-type-parameter-modifier-conc-tree-equiv-congruence-on-cst

(defthm
      cst-type-parameter-modifier-conc-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-type-parameter-modifier-conc abnf::cst)
                  (cst-type-parameter-modifier-conc cst-equiv)))
  :rule-classes :congruence)

Function: cst-additional-bound-conc

(defun cst-additional-bound-conc (abnf::cst)
  (declare (xargs :guard (abnf::treep abnf::cst)))
  (declare (xargs :guard (cst-matchp abnf::cst "additional-bound")))
  (abnf::tree-nonleaf->branches abnf::cst))

Theorem: tree-list-listp-of-cst-additional-bound-conc

(defthm tree-list-listp-of-cst-additional-bound-conc
  (b* ((abnf::cstss (cst-additional-bound-conc abnf::cst)))
    (abnf::tree-list-listp abnf::cstss))
  :rule-classes :rewrite)

Theorem: cst-additional-bound-conc-match

(defthm cst-additional-bound-conc-match
 (implies
    (cst-matchp abnf::cst "additional-bound")
    (b* ((abnf::cstss (cst-additional-bound-conc abnf::cst)))
      (cst-list-list-conc-matchp abnf::cstss "\"&\" interface-type")))
 :rule-classes :rewrite)

Theorem: cst-additional-bound-conc-of-tree-fix-cst

(defthm cst-additional-bound-conc-of-tree-fix-cst
  (equal (cst-additional-bound-conc (abnf::tree-fix abnf::cst))
         (cst-additional-bound-conc abnf::cst)))

Theorem: cst-additional-bound-conc-tree-equiv-congruence-on-cst

(defthm cst-additional-bound-conc-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-additional-bound-conc abnf::cst)
                  (cst-additional-bound-conc cst-equiv)))
  :rule-classes :congruence)

Function: cst-type-arguments-conc

(defun cst-type-arguments-conc (abnf::cst)
  (declare (xargs :guard (abnf::treep abnf::cst)))
  (declare (xargs :guard (cst-matchp abnf::cst "type-arguments")))
  (abnf::tree-nonleaf->branches abnf::cst))

Theorem: tree-list-listp-of-cst-type-arguments-conc

(defthm tree-list-listp-of-cst-type-arguments-conc
  (b* ((abnf::cstss (cst-type-arguments-conc abnf::cst)))
    (abnf::tree-list-listp abnf::cstss))
  :rule-classes :rewrite)

Theorem: cst-type-arguments-conc-match

(defthm cst-type-arguments-conc-match
  (implies
       (cst-matchp abnf::cst "type-arguments")
       (b* ((abnf::cstss (cst-type-arguments-conc abnf::cst)))
         (cst-list-list-conc-matchp abnf::cstss
                                    "\"<\" type-argument-list \">\"")))
  :rule-classes :rewrite)

Theorem: cst-type-arguments-conc-of-tree-fix-cst

(defthm cst-type-arguments-conc-of-tree-fix-cst
  (equal (cst-type-arguments-conc (abnf::tree-fix abnf::cst))
         (cst-type-arguments-conc abnf::cst)))

Theorem: cst-type-arguments-conc-tree-equiv-congruence-on-cst

(defthm cst-type-arguments-conc-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-type-arguments-conc abnf::cst)
                  (cst-type-arguments-conc cst-equiv)))
  :rule-classes :congruence)

Function: cst-type-argument-list-conc

(defun cst-type-argument-list-conc (abnf::cst)
  (declare (xargs :guard (abnf::treep abnf::cst)))
  (declare
       (xargs :guard (cst-matchp abnf::cst "type-argument-list")))
  (abnf::tree-nonleaf->branches abnf::cst))

Theorem: tree-list-listp-of-cst-type-argument-list-conc

(defthm tree-list-listp-of-cst-type-argument-list-conc
  (b* ((abnf::cstss (cst-type-argument-list-conc abnf::cst)))
    (abnf::tree-list-listp abnf::cstss))
  :rule-classes :rewrite)

Theorem: cst-type-argument-list-conc-match

(defthm cst-type-argument-list-conc-match
  (implies
       (cst-matchp abnf::cst "type-argument-list")
       (b* ((abnf::cstss (cst-type-argument-list-conc abnf::cst)))
         (cst-list-list-conc-matchp
              abnf::cstss
              "type-argument *( \",\" type-argument )")))
  :rule-classes :rewrite)

Theorem: cst-type-argument-list-conc-of-tree-fix-cst

(defthm cst-type-argument-list-conc-of-tree-fix-cst
  (equal (cst-type-argument-list-conc (abnf::tree-fix abnf::cst))
         (cst-type-argument-list-conc abnf::cst)))

Theorem: cst-type-argument-list-conc-tree-equiv-congruence-on-cst

(defthm cst-type-argument-list-conc-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-type-argument-list-conc abnf::cst)
                  (cst-type-argument-list-conc cst-equiv)))
  :rule-classes :congruence)

Function: cst-type-argument-conc1

(defun cst-type-argument-conc1 (abnf::cst)
  (declare (xargs :guard (abnf::treep abnf::cst)))
  (declare
       (xargs :guard (and (cst-matchp abnf::cst "type-argument")
                          (equal (cst-type-argument-conc? abnf::cst)
                                 1))))
  (abnf::tree-nonleaf->branches abnf::cst))

Theorem: tree-list-listp-of-cst-type-argument-conc1

(defthm tree-list-listp-of-cst-type-argument-conc1
  (b* ((abnf::cstss (cst-type-argument-conc1 abnf::cst)))
    (abnf::tree-list-listp abnf::cstss))
  :rule-classes :rewrite)

Theorem: cst-type-argument-conc1-match

(defthm cst-type-argument-conc1-match
  (implies
       (and (cst-matchp abnf::cst "type-argument")
            (equal (cst-type-argument-conc? abnf::cst)
                   1))
       (b* ((abnf::cstss (cst-type-argument-conc1 abnf::cst)))
         (cst-list-list-conc-matchp abnf::cstss "reference-type")))
  :rule-classes :rewrite)

Theorem: cst-type-argument-conc1-of-tree-fix-cst

(defthm cst-type-argument-conc1-of-tree-fix-cst
  (equal (cst-type-argument-conc1 (abnf::tree-fix abnf::cst))
         (cst-type-argument-conc1 abnf::cst)))

Theorem: cst-type-argument-conc1-tree-equiv-congruence-on-cst

(defthm cst-type-argument-conc1-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-type-argument-conc1 abnf::cst)
                  (cst-type-argument-conc1 cst-equiv)))
  :rule-classes :congruence)

Function: cst-type-argument-conc2

(defun cst-type-argument-conc2 (abnf::cst)
  (declare (xargs :guard (abnf::treep abnf::cst)))
  (declare
       (xargs :guard (and (cst-matchp abnf::cst "type-argument")
                          (equal (cst-type-argument-conc? abnf::cst)
                                 2))))
  (abnf::tree-nonleaf->branches abnf::cst))

Theorem: tree-list-listp-of-cst-type-argument-conc2

(defthm tree-list-listp-of-cst-type-argument-conc2
  (b* ((abnf::cstss (cst-type-argument-conc2 abnf::cst)))
    (abnf::tree-list-listp abnf::cstss))
  :rule-classes :rewrite)

Theorem: cst-type-argument-conc2-match

(defthm cst-type-argument-conc2-match
  (implies (and (cst-matchp abnf::cst "type-argument")
                (equal (cst-type-argument-conc? abnf::cst)
                       2))
           (b* ((abnf::cstss (cst-type-argument-conc2 abnf::cst)))
             (cst-list-list-conc-matchp abnf::cstss "wildcard")))
  :rule-classes :rewrite)

Theorem: cst-type-argument-conc2-of-tree-fix-cst

(defthm cst-type-argument-conc2-of-tree-fix-cst
  (equal (cst-type-argument-conc2 (abnf::tree-fix abnf::cst))
         (cst-type-argument-conc2 abnf::cst)))

Theorem: cst-type-argument-conc2-tree-equiv-congruence-on-cst

(defthm cst-type-argument-conc2-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-type-argument-conc2 abnf::cst)
                  (cst-type-argument-conc2 cst-equiv)))
  :rule-classes :congruence)

Function: cst-wildcard-conc

(defun cst-wildcard-conc (abnf::cst)
  (declare (xargs :guard (abnf::treep abnf::cst)))
  (declare (xargs :guard (cst-matchp abnf::cst "wildcard")))
  (abnf::tree-nonleaf->branches abnf::cst))

Theorem: tree-list-listp-of-cst-wildcard-conc

(defthm tree-list-listp-of-cst-wildcard-conc
  (b* ((abnf::cstss (cst-wildcard-conc abnf::cst)))
    (abnf::tree-list-listp abnf::cstss))
  :rule-classes :rewrite)

Theorem: cst-wildcard-conc-match

(defthm cst-wildcard-conc-match
  (implies (cst-matchp abnf::cst "wildcard")
           (b* ((abnf::cstss (cst-wildcard-conc abnf::cst)))
             (cst-list-list-conc-matchp
                  abnf::cstss
                  "*annotation \"?\" [ wildcard-bounds ]")))
  :rule-classes :rewrite)

Theorem: cst-wildcard-conc-of-tree-fix-cst

(defthm cst-wildcard-conc-of-tree-fix-cst
  (equal (cst-wildcard-conc (abnf::tree-fix abnf::cst))
         (cst-wildcard-conc abnf::cst)))

Theorem: cst-wildcard-conc-tree-equiv-congruence-on-cst

(defthm cst-wildcard-conc-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-wildcard-conc abnf::cst)
                  (cst-wildcard-conc cst-equiv)))
  :rule-classes :congruence)

Function: cst-method-name-conc

(defun cst-method-name-conc (abnf::cst)
  (declare (xargs :guard (abnf::treep abnf::cst)))
  (declare (xargs :guard (cst-matchp abnf::cst "method-name")))
  (abnf::tree-nonleaf->branches abnf::cst))

Theorem: tree-list-listp-of-cst-method-name-conc

(defthm tree-list-listp-of-cst-method-name-conc
  (b* ((abnf::cstss (cst-method-name-conc abnf::cst)))
    (abnf::tree-list-listp abnf::cstss))
  :rule-classes :rewrite)

Theorem: cst-method-name-conc-match

(defthm cst-method-name-conc-match
 (implies
     (cst-matchp abnf::cst "method-name")
     (b* ((abnf::cstss (cst-method-name-conc abnf::cst)))
       (cst-list-list-conc-matchp abnf::cstss
                                  "unqualified-method-identifier")))
 :rule-classes :rewrite)

Theorem: cst-method-name-conc-of-tree-fix-cst

(defthm cst-method-name-conc-of-tree-fix-cst
  (equal (cst-method-name-conc (abnf::tree-fix abnf::cst))
         (cst-method-name-conc abnf::cst)))

Theorem: cst-method-name-conc-tree-equiv-congruence-on-cst

(defthm cst-method-name-conc-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-method-name-conc abnf::cst)
                  (cst-method-name-conc cst-equiv)))
  :rule-classes :congruence)

Function: cst-compilation-unit-conc1

(defun cst-compilation-unit-conc1 (abnf::cst)
 (declare (xargs :guard (abnf::treep abnf::cst)))
 (declare
    (xargs :guard (and (cst-matchp abnf::cst "compilation-unit")
                       (equal (cst-compilation-unit-conc? abnf::cst)
                              1))))
 (abnf::tree-nonleaf->branches abnf::cst))

Theorem: tree-list-listp-of-cst-compilation-unit-conc1

(defthm tree-list-listp-of-cst-compilation-unit-conc1
  (b* ((abnf::cstss (cst-compilation-unit-conc1 abnf::cst)))
    (abnf::tree-list-listp abnf::cstss))
  :rule-classes :rewrite)

Theorem: cst-compilation-unit-conc1-match

(defthm cst-compilation-unit-conc1-match
  (implies
       (and (cst-matchp abnf::cst "compilation-unit")
            (equal (cst-compilation-unit-conc? abnf::cst)
                   1))
       (b* ((abnf::cstss (cst-compilation-unit-conc1 abnf::cst)))
         (cst-list-list-conc-matchp abnf::cstss
                                    "ordinary-compilation-unit")))
  :rule-classes :rewrite)

Theorem: cst-compilation-unit-conc1-of-tree-fix-cst

(defthm cst-compilation-unit-conc1-of-tree-fix-cst
  (equal (cst-compilation-unit-conc1 (abnf::tree-fix abnf::cst))
         (cst-compilation-unit-conc1 abnf::cst)))

Theorem: cst-compilation-unit-conc1-tree-equiv-congruence-on-cst

(defthm cst-compilation-unit-conc1-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-compilation-unit-conc1 abnf::cst)
                  (cst-compilation-unit-conc1 cst-equiv)))
  :rule-classes :congruence)

Function: cst-compilation-unit-conc2

(defun cst-compilation-unit-conc2 (abnf::cst)
 (declare (xargs :guard (abnf::treep abnf::cst)))
 (declare
    (xargs :guard (and (cst-matchp abnf::cst "compilation-unit")
                       (equal (cst-compilation-unit-conc? abnf::cst)
                              2))))
 (abnf::tree-nonleaf->branches abnf::cst))

Theorem: tree-list-listp-of-cst-compilation-unit-conc2

(defthm tree-list-listp-of-cst-compilation-unit-conc2
  (b* ((abnf::cstss (cst-compilation-unit-conc2 abnf::cst)))
    (abnf::tree-list-listp abnf::cstss))
  :rule-classes :rewrite)

Theorem: cst-compilation-unit-conc2-match

(defthm cst-compilation-unit-conc2-match
 (implies (and (cst-matchp abnf::cst "compilation-unit")
               (equal (cst-compilation-unit-conc? abnf::cst)
                      2))
          (b* ((abnf::cstss (cst-compilation-unit-conc2 abnf::cst)))
            (cst-list-list-conc-matchp abnf::cstss
                                       "compact-compilation-unit")))
 :rule-classes :rewrite)

Theorem: cst-compilation-unit-conc2-of-tree-fix-cst

(defthm cst-compilation-unit-conc2-of-tree-fix-cst
  (equal (cst-compilation-unit-conc2 (abnf::tree-fix abnf::cst))
         (cst-compilation-unit-conc2 abnf::cst)))

Theorem: cst-compilation-unit-conc2-tree-equiv-congruence-on-cst

(defthm cst-compilation-unit-conc2-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-compilation-unit-conc2 abnf::cst)
                  (cst-compilation-unit-conc2 cst-equiv)))
  :rule-classes :congruence)

Function: cst-compilation-unit-conc3

(defun cst-compilation-unit-conc3 (abnf::cst)
 (declare (xargs :guard (abnf::treep abnf::cst)))
 (declare
    (xargs :guard (and (cst-matchp abnf::cst "compilation-unit")
                       (equal (cst-compilation-unit-conc? abnf::cst)
                              3))))
 (abnf::tree-nonleaf->branches abnf::cst))

Theorem: tree-list-listp-of-cst-compilation-unit-conc3

(defthm tree-list-listp-of-cst-compilation-unit-conc3
  (b* ((abnf::cstss (cst-compilation-unit-conc3 abnf::cst)))
    (abnf::tree-list-listp abnf::cstss))
  :rule-classes :rewrite)

Theorem: cst-compilation-unit-conc3-match

(defthm cst-compilation-unit-conc3-match
 (implies (and (cst-matchp abnf::cst "compilation-unit")
               (equal (cst-compilation-unit-conc? abnf::cst)
                      3))
          (b* ((abnf::cstss (cst-compilation-unit-conc3 abnf::cst)))
            (cst-list-list-conc-matchp abnf::cstss
                                       "modular-compilation-unit")))
 :rule-classes :rewrite)

Theorem: cst-compilation-unit-conc3-of-tree-fix-cst

(defthm cst-compilation-unit-conc3-of-tree-fix-cst
  (equal (cst-compilation-unit-conc3 (abnf::tree-fix abnf::cst))
         (cst-compilation-unit-conc3 abnf::cst)))

Theorem: cst-compilation-unit-conc3-tree-equiv-congruence-on-cst

(defthm cst-compilation-unit-conc3-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-compilation-unit-conc3 abnf::cst)
                  (cst-compilation-unit-conc3 cst-equiv)))
  :rule-classes :congruence)

Function: cst-ordinary-compilation-unit-conc

(defun cst-ordinary-compilation-unit-conc (abnf::cst)
 (declare (xargs :guard (abnf::treep abnf::cst)))
 (declare
  (xargs :guard (cst-matchp abnf::cst "ordinary-compilation-unit")))
 (abnf::tree-nonleaf->branches abnf::cst))

Theorem: tree-list-listp-of-cst-ordinary-compilation-unit-conc

(defthm tree-list-listp-of-cst-ordinary-compilation-unit-conc
  (b* ((abnf::cstss (cst-ordinary-compilation-unit-conc abnf::cst)))
    (abnf::tree-list-listp abnf::cstss))
  :rule-classes :rewrite)

Theorem: cst-ordinary-compilation-unit-conc-match

(defthm cst-ordinary-compilation-unit-conc-match
 (implies
  (cst-matchp abnf::cst "ordinary-compilation-unit")
  (b* ((abnf::cstss (cst-ordinary-compilation-unit-conc abnf::cst)))
   (cst-list-list-conc-matchp
    abnf::cstss
    "[ package-declaration ] *import-declaration *top-level-class-or-interface-declaration")))
 :rule-classes :rewrite)

Theorem: cst-ordinary-compilation-unit-conc-of-tree-fix-cst

(defthm cst-ordinary-compilation-unit-conc-of-tree-fix-cst
 (equal
     (cst-ordinary-compilation-unit-conc (abnf::tree-fix abnf::cst))
     (cst-ordinary-compilation-unit-conc abnf::cst)))

Theorem: cst-ordinary-compilation-unit-conc-tree-equiv-congruence-on-cst

(defthm
    cst-ordinary-compilation-unit-conc-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-ordinary-compilation-unit-conc abnf::cst)
                  (cst-ordinary-compilation-unit-conc cst-equiv)))
  :rule-classes :congruence)

Function: cst-compact-compilation-unit-conc

(defun cst-compact-compilation-unit-conc (abnf::cst)
 (declare (xargs :guard (abnf::treep abnf::cst)))
 (declare
   (xargs :guard (cst-matchp abnf::cst "compact-compilation-unit")))
 (abnf::tree-nonleaf->branches abnf::cst))

Theorem: tree-list-listp-of-cst-compact-compilation-unit-conc

(defthm tree-list-listp-of-cst-compact-compilation-unit-conc
  (b* ((abnf::cstss (cst-compact-compilation-unit-conc abnf::cst)))
    (abnf::tree-list-listp abnf::cstss))
  :rule-classes :rewrite)

Theorem: cst-compact-compilation-unit-conc-match

(defthm cst-compact-compilation-unit-conc-match
 (implies
  (cst-matchp abnf::cst "compact-compilation-unit")
  (b* ((abnf::cstss (cst-compact-compilation-unit-conc abnf::cst)))
   (cst-list-list-conc-matchp
    abnf::cstss
    "*import-declaration *class-member-declaration-no-method *method-declaration *class-member-declaration")))
 :rule-classes :rewrite)

Theorem: cst-compact-compilation-unit-conc-of-tree-fix-cst

(defthm cst-compact-compilation-unit-conc-of-tree-fix-cst
 (equal
      (cst-compact-compilation-unit-conc (abnf::tree-fix abnf::cst))
      (cst-compact-compilation-unit-conc abnf::cst)))

Theorem: cst-compact-compilation-unit-conc-tree-equiv-congruence-on-cst

(defthm
     cst-compact-compilation-unit-conc-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-compact-compilation-unit-conc abnf::cst)
                  (cst-compact-compilation-unit-conc cst-equiv)))
  :rule-classes :congruence)

Function: cst-modular-compilation-unit-conc

(defun cst-modular-compilation-unit-conc (abnf::cst)
 (declare (xargs :guard (abnf::treep abnf::cst)))
 (declare
   (xargs :guard (cst-matchp abnf::cst "modular-compilation-unit")))
 (abnf::tree-nonleaf->branches abnf::cst))

Theorem: tree-list-listp-of-cst-modular-compilation-unit-conc

(defthm tree-list-listp-of-cst-modular-compilation-unit-conc
  (b* ((abnf::cstss (cst-modular-compilation-unit-conc abnf::cst)))
    (abnf::tree-list-listp abnf::cstss))
  :rule-classes :rewrite)

Theorem: cst-modular-compilation-unit-conc-match

(defthm cst-modular-compilation-unit-conc-match
 (implies
   (cst-matchp abnf::cst "modular-compilation-unit")
   (b* ((abnf::cstss (cst-modular-compilation-unit-conc abnf::cst)))
     (cst-list-list-conc-matchp
          abnf::cstss
          "*import-declaration module-declaration")))
 :rule-classes :rewrite)

Theorem: cst-modular-compilation-unit-conc-of-tree-fix-cst

(defthm cst-modular-compilation-unit-conc-of-tree-fix-cst
 (equal
      (cst-modular-compilation-unit-conc (abnf::tree-fix abnf::cst))
      (cst-modular-compilation-unit-conc abnf::cst)))

Theorem: cst-modular-compilation-unit-conc-tree-equiv-congruence-on-cst

(defthm
     cst-modular-compilation-unit-conc-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-modular-compilation-unit-conc abnf::cst)
                  (cst-modular-compilation-unit-conc cst-equiv)))
  :rule-classes :congruence)

Function: cst-package-declaration-conc

(defun cst-package-declaration-conc (abnf::cst)
  (declare (xargs :guard (abnf::treep abnf::cst)))
  (declare
       (xargs :guard (cst-matchp abnf::cst "package-declaration")))
  (abnf::tree-nonleaf->branches abnf::cst))

Theorem: tree-list-listp-of-cst-package-declaration-conc

(defthm tree-list-listp-of-cst-package-declaration-conc
  (b* ((abnf::cstss (cst-package-declaration-conc abnf::cst)))
    (abnf::tree-list-listp abnf::cstss))
  :rule-classes :rewrite)

Theorem: cst-package-declaration-conc-match

(defthm cst-package-declaration-conc-match
 (implies
  (cst-matchp abnf::cst "package-declaration")
  (b* ((abnf::cstss (cst-package-declaration-conc abnf::cst)))
   (cst-list-list-conc-matchp
    abnf::cstss
    "*package-modifier %s\"package\" identifier *( \".\" identifier ) \";\"")))
 :rule-classes :rewrite)

Theorem: cst-package-declaration-conc-of-tree-fix-cst

(defthm cst-package-declaration-conc-of-tree-fix-cst
  (equal (cst-package-declaration-conc (abnf::tree-fix abnf::cst))
         (cst-package-declaration-conc abnf::cst)))

Theorem: cst-package-declaration-conc-tree-equiv-congruence-on-cst

(defthm cst-package-declaration-conc-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-package-declaration-conc abnf::cst)
                  (cst-package-declaration-conc cst-equiv)))
  :rule-classes :congruence)

Function: cst-package-modifier-conc

(defun cst-package-modifier-conc (abnf::cst)
  (declare (xargs :guard (abnf::treep abnf::cst)))
  (declare (xargs :guard (cst-matchp abnf::cst "package-modifier")))
  (abnf::tree-nonleaf->branches abnf::cst))

Theorem: tree-list-listp-of-cst-package-modifier-conc

(defthm tree-list-listp-of-cst-package-modifier-conc
  (b* ((abnf::cstss (cst-package-modifier-conc abnf::cst)))
    (abnf::tree-list-listp abnf::cstss))
  :rule-classes :rewrite)

Theorem: cst-package-modifier-conc-match

(defthm cst-package-modifier-conc-match
  (implies (cst-matchp abnf::cst "package-modifier")
           (b* ((abnf::cstss (cst-package-modifier-conc abnf::cst)))
             (cst-list-list-conc-matchp abnf::cstss "annotation")))
  :rule-classes :rewrite)

Theorem: cst-package-modifier-conc-of-tree-fix-cst

(defthm cst-package-modifier-conc-of-tree-fix-cst
  (equal (cst-package-modifier-conc (abnf::tree-fix abnf::cst))
         (cst-package-modifier-conc abnf::cst)))

Theorem: cst-package-modifier-conc-tree-equiv-congruence-on-cst

(defthm cst-package-modifier-conc-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-package-modifier-conc abnf::cst)
                  (cst-package-modifier-conc cst-equiv)))
  :rule-classes :congruence)

Function: cst-import-declaration-conc1

(defun cst-import-declaration-conc1 (abnf::cst)
 (declare (xargs :guard (abnf::treep abnf::cst)))
 (declare
  (xargs :guard (and (cst-matchp abnf::cst "import-declaration")
                     (equal (cst-import-declaration-conc? abnf::cst)
                            1))))
 (abnf::tree-nonleaf->branches abnf::cst))

Theorem: tree-list-listp-of-cst-import-declaration-conc1

(defthm tree-list-listp-of-cst-import-declaration-conc1
  (b* ((abnf::cstss (cst-import-declaration-conc1 abnf::cst)))
    (abnf::tree-list-listp abnf::cstss))
  :rule-classes :rewrite)

Theorem: cst-import-declaration-conc1-match

(defthm cst-import-declaration-conc1-match
 (implies
    (and (cst-matchp abnf::cst "import-declaration")
         (equal (cst-import-declaration-conc? abnf::cst)
                1))
    (b* ((abnf::cstss (cst-import-declaration-conc1 abnf::cst)))
      (cst-list-list-conc-matchp abnf::cstss
                                 "single-type-import-declaration")))
 :rule-classes :rewrite)

Theorem: cst-import-declaration-conc1-of-tree-fix-cst

(defthm cst-import-declaration-conc1-of-tree-fix-cst
  (equal (cst-import-declaration-conc1 (abnf::tree-fix abnf::cst))
         (cst-import-declaration-conc1 abnf::cst)))

Theorem: cst-import-declaration-conc1-tree-equiv-congruence-on-cst

(defthm cst-import-declaration-conc1-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-import-declaration-conc1 abnf::cst)
                  (cst-import-declaration-conc1 cst-equiv)))
  :rule-classes :congruence)

Function: cst-import-declaration-conc2

(defun cst-import-declaration-conc2 (abnf::cst)
 (declare (xargs :guard (abnf::treep abnf::cst)))
 (declare
  (xargs :guard (and (cst-matchp abnf::cst "import-declaration")
                     (equal (cst-import-declaration-conc? abnf::cst)
                            2))))
 (abnf::tree-nonleaf->branches abnf::cst))

Theorem: tree-list-listp-of-cst-import-declaration-conc2

(defthm tree-list-listp-of-cst-import-declaration-conc2
  (b* ((abnf::cstss (cst-import-declaration-conc2 abnf::cst)))
    (abnf::tree-list-listp abnf::cstss))
  :rule-classes :rewrite)

Theorem: cst-import-declaration-conc2-match

(defthm cst-import-declaration-conc2-match
 (implies
  (and (cst-matchp abnf::cst "import-declaration")
       (equal (cst-import-declaration-conc? abnf::cst)
              2))
  (b* ((abnf::cstss (cst-import-declaration-conc2 abnf::cst)))
   (cst-list-list-conc-matchp abnf::cstss
                              "type-import-on-demand-declaration")))
 :rule-classes :rewrite)

Theorem: cst-import-declaration-conc2-of-tree-fix-cst

(defthm cst-import-declaration-conc2-of-tree-fix-cst
  (equal (cst-import-declaration-conc2 (abnf::tree-fix abnf::cst))
         (cst-import-declaration-conc2 abnf::cst)))

Theorem: cst-import-declaration-conc2-tree-equiv-congruence-on-cst

(defthm cst-import-declaration-conc2-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-import-declaration-conc2 abnf::cst)
                  (cst-import-declaration-conc2 cst-equiv)))
  :rule-classes :congruence)

Function: cst-import-declaration-conc3

(defun cst-import-declaration-conc3 (abnf::cst)
 (declare (xargs :guard (abnf::treep abnf::cst)))
 (declare
  (xargs :guard (and (cst-matchp abnf::cst "import-declaration")
                     (equal (cst-import-declaration-conc? abnf::cst)
                            3))))
 (abnf::tree-nonleaf->branches abnf::cst))

Theorem: tree-list-listp-of-cst-import-declaration-conc3

(defthm tree-list-listp-of-cst-import-declaration-conc3
  (b* ((abnf::cstss (cst-import-declaration-conc3 abnf::cst)))
    (abnf::tree-list-listp abnf::cstss))
  :rule-classes :rewrite)

Theorem: cst-import-declaration-conc3-match

(defthm cst-import-declaration-conc3-match
 (implies
  (and (cst-matchp abnf::cst "import-declaration")
       (equal (cst-import-declaration-conc? abnf::cst)
              3))
  (b* ((abnf::cstss (cst-import-declaration-conc3 abnf::cst)))
    (cst-list-list-conc-matchp abnf::cstss
                               "single-static-import-declaration")))
 :rule-classes :rewrite)

Theorem: cst-import-declaration-conc3-of-tree-fix-cst

(defthm cst-import-declaration-conc3-of-tree-fix-cst
  (equal (cst-import-declaration-conc3 (abnf::tree-fix abnf::cst))
         (cst-import-declaration-conc3 abnf::cst)))

Theorem: cst-import-declaration-conc3-tree-equiv-congruence-on-cst

(defthm cst-import-declaration-conc3-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-import-declaration-conc3 abnf::cst)
                  (cst-import-declaration-conc3 cst-equiv)))
  :rule-classes :congruence)

Function: cst-import-declaration-conc4

(defun cst-import-declaration-conc4 (abnf::cst)
 (declare (xargs :guard (abnf::treep abnf::cst)))
 (declare
  (xargs :guard (and (cst-matchp abnf::cst "import-declaration")
                     (equal (cst-import-declaration-conc? abnf::cst)
                            4))))
 (abnf::tree-nonleaf->branches abnf::cst))

Theorem: tree-list-listp-of-cst-import-declaration-conc4

(defthm tree-list-listp-of-cst-import-declaration-conc4
  (b* ((abnf::cstss (cst-import-declaration-conc4 abnf::cst)))
    (abnf::tree-list-listp abnf::cstss))
  :rule-classes :rewrite)

Theorem: cst-import-declaration-conc4-match

(defthm cst-import-declaration-conc4-match
  (implies
       (and (cst-matchp abnf::cst "import-declaration")
            (equal (cst-import-declaration-conc? abnf::cst)
                   4))
       (b* ((abnf::cstss (cst-import-declaration-conc4 abnf::cst)))
         (cst-list-list-conc-matchp
              abnf::cstss
              "static-import-on-demand-declaration")))
  :rule-classes :rewrite)

Theorem: cst-import-declaration-conc4-of-tree-fix-cst

(defthm cst-import-declaration-conc4-of-tree-fix-cst
  (equal (cst-import-declaration-conc4 (abnf::tree-fix abnf::cst))
         (cst-import-declaration-conc4 abnf::cst)))

Theorem: cst-import-declaration-conc4-tree-equiv-congruence-on-cst

(defthm cst-import-declaration-conc4-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-import-declaration-conc4 abnf::cst)
                  (cst-import-declaration-conc4 cst-equiv)))
  :rule-classes :congruence)

Function: cst-import-declaration-conc5

(defun cst-import-declaration-conc5 (abnf::cst)
 (declare (xargs :guard (abnf::treep abnf::cst)))
 (declare
  (xargs :guard (and (cst-matchp abnf::cst "import-declaration")
                     (equal (cst-import-declaration-conc? abnf::cst)
                            5))))
 (abnf::tree-nonleaf->branches abnf::cst))

Theorem: tree-list-listp-of-cst-import-declaration-conc5

(defthm tree-list-listp-of-cst-import-declaration-conc5
  (b* ((abnf::cstss (cst-import-declaration-conc5 abnf::cst)))
    (abnf::tree-list-listp abnf::cstss))
  :rule-classes :rewrite)

Theorem: cst-import-declaration-conc5-match

(defthm cst-import-declaration-conc5-match
 (implies
  (and (cst-matchp abnf::cst "import-declaration")
       (equal (cst-import-declaration-conc? abnf::cst)
              5))
  (b* ((abnf::cstss (cst-import-declaration-conc5 abnf::cst)))
    (cst-list-list-conc-matchp abnf::cstss
                               "single-module-import-declaration")))
 :rule-classes :rewrite)

Theorem: cst-import-declaration-conc5-of-tree-fix-cst

(defthm cst-import-declaration-conc5-of-tree-fix-cst
  (equal (cst-import-declaration-conc5 (abnf::tree-fix abnf::cst))
         (cst-import-declaration-conc5 abnf::cst)))

Theorem: cst-import-declaration-conc5-tree-equiv-congruence-on-cst

(defthm cst-import-declaration-conc5-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-import-declaration-conc5 abnf::cst)
                  (cst-import-declaration-conc5 cst-equiv)))
  :rule-classes :congruence)

Function: cst-single-type-import-declaration-conc

(defun cst-single-type-import-declaration-conc (abnf::cst)
  (declare (xargs :guard (abnf::treep abnf::cst)))
  (declare
       (xargs :guard (cst-matchp abnf::cst
                                 "single-type-import-declaration")))
  (abnf::tree-nonleaf->branches abnf::cst))

Theorem: tree-list-listp-of-cst-single-type-import-declaration-conc

(defthm tree-list-listp-of-cst-single-type-import-declaration-conc
  (b* ((abnf::cstss
            (cst-single-type-import-declaration-conc abnf::cst)))
    (abnf::tree-list-listp abnf::cstss))
  :rule-classes :rewrite)

Theorem: cst-single-type-import-declaration-conc-match

(defthm cst-single-type-import-declaration-conc-match
 (implies
     (cst-matchp abnf::cst
                 "single-type-import-declaration")
     (b* ((abnf::cstss
               (cst-single-type-import-declaration-conc abnf::cst)))
       (cst-list-list-conc-matchp abnf::cstss
                                  "%s\"import\" type-name \";\"")))
 :rule-classes :rewrite)

Theorem: cst-single-type-import-declaration-conc-of-tree-fix-cst

(defthm cst-single-type-import-declaration-conc-of-tree-fix-cst
  (equal (cst-single-type-import-declaration-conc
              (abnf::tree-fix abnf::cst))
         (cst-single-type-import-declaration-conc abnf::cst)))

Theorem: cst-single-type-import-declaration-conc-tree-equiv-congruence-on-cst

(defthm
 cst-single-type-import-declaration-conc-tree-equiv-congruence-on-cst
 (implies
      (abnf::tree-equiv abnf::cst cst-equiv)
      (equal (cst-single-type-import-declaration-conc abnf::cst)
             (cst-single-type-import-declaration-conc cst-equiv)))
 :rule-classes :congruence)

Function: cst-type-import-on-demand-declaration-conc

(defun cst-type-import-on-demand-declaration-conc (abnf::cst)
 (declare (xargs :guard (abnf::treep abnf::cst)))
 (declare
    (xargs :guard (cst-matchp abnf::cst
                              "type-import-on-demand-declaration")))
 (abnf::tree-nonleaf->branches abnf::cst))

Theorem: tree-list-listp-of-cst-type-import-on-demand-declaration-conc

(defthm
      tree-list-listp-of-cst-type-import-on-demand-declaration-conc
  (b* ((abnf::cstss
            (cst-type-import-on-demand-declaration-conc abnf::cst)))
    (abnf::tree-list-listp abnf::cstss))
  :rule-classes :rewrite)

Theorem: cst-type-import-on-demand-declaration-conc-match

(defthm cst-type-import-on-demand-declaration-conc-match
 (implies
  (cst-matchp abnf::cst
              "type-import-on-demand-declaration")
  (b* ((abnf::cstss
            (cst-type-import-on-demand-declaration-conc abnf::cst)))
    (cst-list-list-conc-matchp
         abnf::cstss
         "%s\"import\" package-or-type-name \".\" \"*\" \";\"")))
 :rule-classes :rewrite)

Theorem: cst-type-import-on-demand-declaration-conc-of-tree-fix-cst

(defthm cst-type-import-on-demand-declaration-conc-of-tree-fix-cst
  (equal (cst-type-import-on-demand-declaration-conc
              (abnf::tree-fix abnf::cst))
         (cst-type-import-on-demand-declaration-conc abnf::cst)))

Theorem: cst-type-import-on-demand-declaration-conc-tree-equiv-congruence-on-cst

(defthm
 cst-type-import-on-demand-declaration-conc-tree-equiv-congruence-on-cst
 (implies
     (abnf::tree-equiv abnf::cst cst-equiv)
     (equal (cst-type-import-on-demand-declaration-conc abnf::cst)
            (cst-type-import-on-demand-declaration-conc cst-equiv)))
 :rule-classes :congruence)

Function: cst-single-static-import-declaration-conc

(defun cst-single-static-import-declaration-conc (abnf::cst)
 (declare (xargs :guard (abnf::treep abnf::cst)))
 (declare
     (xargs :guard (cst-matchp abnf::cst
                               "single-static-import-declaration")))
 (abnf::tree-nonleaf->branches abnf::cst))

Theorem: tree-list-listp-of-cst-single-static-import-declaration-conc

(defthm tree-list-listp-of-cst-single-static-import-declaration-conc
  (b* ((abnf::cstss
            (cst-single-static-import-declaration-conc abnf::cst)))
    (abnf::tree-list-listp abnf::cstss))
  :rule-classes :rewrite)

Theorem: cst-single-static-import-declaration-conc-match

(defthm cst-single-static-import-declaration-conc-match
 (implies
   (cst-matchp abnf::cst
               "single-static-import-declaration")
   (b* ((abnf::cstss
             (cst-single-static-import-declaration-conc abnf::cst)))
     (cst-list-list-conc-matchp
          abnf::cstss
          "%s\"import\" %s\"static\" type-name \".\" identifier \";\"")))
 :rule-classes :rewrite)

Theorem: cst-single-static-import-declaration-conc-of-tree-fix-cst

(defthm cst-single-static-import-declaration-conc-of-tree-fix-cst
  (equal (cst-single-static-import-declaration-conc
              (abnf::tree-fix abnf::cst))
         (cst-single-static-import-declaration-conc abnf::cst)))

Theorem: cst-single-static-import-declaration-conc-tree-equiv-congruence-on-cst

(defthm
 cst-single-static-import-declaration-conc-tree-equiv-congruence-on-cst
 (implies
      (abnf::tree-equiv abnf::cst cst-equiv)
      (equal (cst-single-static-import-declaration-conc abnf::cst)
             (cst-single-static-import-declaration-conc cst-equiv)))
 :rule-classes :congruence)

Function: cst-static-import-on-demand-declaration-conc

(defun cst-static-import-on-demand-declaration-conc (abnf::cst)
 (declare (xargs :guard (abnf::treep abnf::cst)))
 (declare
  (xargs :guard (cst-matchp abnf::cst
                            "static-import-on-demand-declaration")))
 (abnf::tree-nonleaf->branches abnf::cst))

Theorem: tree-list-listp-of-cst-static-import-on-demand-declaration-conc

(defthm
    tree-list-listp-of-cst-static-import-on-demand-declaration-conc
  (b*
    ((abnf::cstss
          (cst-static-import-on-demand-declaration-conc abnf::cst)))
    (abnf::tree-list-listp abnf::cstss))
  :rule-classes :rewrite)

Theorem: cst-static-import-on-demand-declaration-conc-match

(defthm cst-static-import-on-demand-declaration-conc-match
 (implies
   (cst-matchp abnf::cst
               "static-import-on-demand-declaration")
   (b*
    ((abnf::cstss
          (cst-static-import-on-demand-declaration-conc abnf::cst)))
    (cst-list-list-conc-matchp
         abnf::cstss
         "%s\"import\" %s\"static\" type-name \".\" \"*\" \";\"")))
 :rule-classes :rewrite)

Theorem: cst-static-import-on-demand-declaration-conc-of-tree-fix-cst

(defthm cst-static-import-on-demand-declaration-conc-of-tree-fix-cst
  (equal (cst-static-import-on-demand-declaration-conc
              (abnf::tree-fix abnf::cst))
         (cst-static-import-on-demand-declaration-conc abnf::cst)))

Theorem: cst-static-import-on-demand-declaration-conc-tree-equiv-congruence-on-cst

(defthm
 cst-static-import-on-demand-declaration-conc-tree-equiv-congruence-on-cst
 (implies
   (abnf::tree-equiv abnf::cst cst-equiv)
   (equal (cst-static-import-on-demand-declaration-conc abnf::cst)
          (cst-static-import-on-demand-declaration-conc cst-equiv)))
 :rule-classes :congruence)

Function: cst-single-module-import-declaration-conc

(defun cst-single-module-import-declaration-conc (abnf::cst)
 (declare (xargs :guard (abnf::treep abnf::cst)))
 (declare
     (xargs :guard (cst-matchp abnf::cst
                               "single-module-import-declaration")))
 (abnf::tree-nonleaf->branches abnf::cst))

Theorem: tree-list-listp-of-cst-single-module-import-declaration-conc

(defthm tree-list-listp-of-cst-single-module-import-declaration-conc
  (b* ((abnf::cstss
            (cst-single-module-import-declaration-conc abnf::cst)))
    (abnf::tree-list-listp abnf::cstss))
  :rule-classes :rewrite)

Theorem: cst-single-module-import-declaration-conc-match

(defthm cst-single-module-import-declaration-conc-match
 (implies
   (cst-matchp abnf::cst
               "single-module-import-declaration")
   (b* ((abnf::cstss
             (cst-single-module-import-declaration-conc abnf::cst)))
     (cst-list-list-conc-matchp
          abnf::cstss
          "%s\"import\" %s\"module\" module-name \";\"")))
 :rule-classes :rewrite)

Theorem: cst-single-module-import-declaration-conc-of-tree-fix-cst

(defthm cst-single-module-import-declaration-conc-of-tree-fix-cst
  (equal (cst-single-module-import-declaration-conc
              (abnf::tree-fix abnf::cst))
         (cst-single-module-import-declaration-conc abnf::cst)))

Theorem: cst-single-module-import-declaration-conc-tree-equiv-congruence-on-cst

(defthm
 cst-single-module-import-declaration-conc-tree-equiv-congruence-on-cst
 (implies
      (abnf::tree-equiv abnf::cst cst-equiv)
      (equal (cst-single-module-import-declaration-conc abnf::cst)
             (cst-single-module-import-declaration-conc cst-equiv)))
 :rule-classes :congruence)

Function: cst-module-declaration-conc

(defun cst-module-declaration-conc (abnf::cst)
  (declare (xargs :guard (abnf::treep abnf::cst)))
  (declare
       (xargs :guard (cst-matchp abnf::cst "module-declaration")))
  (abnf::tree-nonleaf->branches abnf::cst))

Theorem: tree-list-listp-of-cst-module-declaration-conc

(defthm tree-list-listp-of-cst-module-declaration-conc
  (b* ((abnf::cstss (cst-module-declaration-conc abnf::cst)))
    (abnf::tree-list-listp abnf::cstss))
  :rule-classes :rewrite)

Theorem: cst-module-declaration-conc-match

(defthm cst-module-declaration-conc-match
 (implies
  (cst-matchp abnf::cst "module-declaration")
  (b* ((abnf::cstss (cst-module-declaration-conc abnf::cst)))
   (cst-list-list-conc-matchp
    abnf::cstss
    "*annotation [ %s\"open\" ] %s\"module\" identifier *( \".\" identifier ) \"{\" *module-directive \"}\"")))
 :rule-classes :rewrite)

Theorem: cst-module-declaration-conc-of-tree-fix-cst

(defthm cst-module-declaration-conc-of-tree-fix-cst
  (equal (cst-module-declaration-conc (abnf::tree-fix abnf::cst))
         (cst-module-declaration-conc abnf::cst)))

Theorem: cst-module-declaration-conc-tree-equiv-congruence-on-cst

(defthm cst-module-declaration-conc-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-module-declaration-conc abnf::cst)
                  (cst-module-declaration-conc cst-equiv)))
  :rule-classes :congruence)

Function: cst-class-declaration-conc1

(defun cst-class-declaration-conc1 (abnf::cst)
 (declare (xargs :guard (abnf::treep abnf::cst)))
 (declare
   (xargs :guard (and (cst-matchp abnf::cst "class-declaration")
                      (equal (cst-class-declaration-conc? abnf::cst)
                             1))))
 (abnf::tree-nonleaf->branches abnf::cst))

Theorem: tree-list-listp-of-cst-class-declaration-conc1

(defthm tree-list-listp-of-cst-class-declaration-conc1
  (b* ((abnf::cstss (cst-class-declaration-conc1 abnf::cst)))
    (abnf::tree-list-listp abnf::cstss))
  :rule-classes :rewrite)

Theorem: cst-class-declaration-conc1-match

(defthm cst-class-declaration-conc1-match
  (implies
       (and (cst-matchp abnf::cst "class-declaration")
            (equal (cst-class-declaration-conc? abnf::cst)
                   1))
       (b* ((abnf::cstss (cst-class-declaration-conc1 abnf::cst)))
         (cst-list-list-conc-matchp abnf::cstss
                                    "normal-class-declaration")))
  :rule-classes :rewrite)

Theorem: cst-class-declaration-conc1-of-tree-fix-cst

(defthm cst-class-declaration-conc1-of-tree-fix-cst
  (equal (cst-class-declaration-conc1 (abnf::tree-fix abnf::cst))
         (cst-class-declaration-conc1 abnf::cst)))

Theorem: cst-class-declaration-conc1-tree-equiv-congruence-on-cst

(defthm cst-class-declaration-conc1-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-class-declaration-conc1 abnf::cst)
                  (cst-class-declaration-conc1 cst-equiv)))
  :rule-classes :congruence)

Function: cst-class-declaration-conc2

(defun cst-class-declaration-conc2 (abnf::cst)
 (declare (xargs :guard (abnf::treep abnf::cst)))
 (declare
   (xargs :guard (and (cst-matchp abnf::cst "class-declaration")
                      (equal (cst-class-declaration-conc? abnf::cst)
                             2))))
 (abnf::tree-nonleaf->branches abnf::cst))

Theorem: tree-list-listp-of-cst-class-declaration-conc2

(defthm tree-list-listp-of-cst-class-declaration-conc2
  (b* ((abnf::cstss (cst-class-declaration-conc2 abnf::cst)))
    (abnf::tree-list-listp abnf::cstss))
  :rule-classes :rewrite)

Theorem: cst-class-declaration-conc2-match

(defthm cst-class-declaration-conc2-match
 (implies
      (and (cst-matchp abnf::cst "class-declaration")
           (equal (cst-class-declaration-conc? abnf::cst)
                  2))
      (b* ((abnf::cstss (cst-class-declaration-conc2 abnf::cst)))
        (cst-list-list-conc-matchp abnf::cstss "enum-declaration")))
 :rule-classes :rewrite)

Theorem: cst-class-declaration-conc2-of-tree-fix-cst

(defthm cst-class-declaration-conc2-of-tree-fix-cst
  (equal (cst-class-declaration-conc2 (abnf::tree-fix abnf::cst))
         (cst-class-declaration-conc2 abnf::cst)))

Theorem: cst-class-declaration-conc2-tree-equiv-congruence-on-cst

(defthm cst-class-declaration-conc2-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-class-declaration-conc2 abnf::cst)
                  (cst-class-declaration-conc2 cst-equiv)))
  :rule-classes :congruence)

Function: cst-class-declaration-conc3

(defun cst-class-declaration-conc3 (abnf::cst)
 (declare (xargs :guard (abnf::treep abnf::cst)))
 (declare
   (xargs :guard (and (cst-matchp abnf::cst "class-declaration")
                      (equal (cst-class-declaration-conc? abnf::cst)
                             3))))
 (abnf::tree-nonleaf->branches abnf::cst))

Theorem: tree-list-listp-of-cst-class-declaration-conc3

(defthm tree-list-listp-of-cst-class-declaration-conc3
  (b* ((abnf::cstss (cst-class-declaration-conc3 abnf::cst)))
    (abnf::tree-list-listp abnf::cstss))
  :rule-classes :rewrite)

Theorem: cst-class-declaration-conc3-match

(defthm cst-class-declaration-conc3-match
 (implies
    (and (cst-matchp abnf::cst "class-declaration")
         (equal (cst-class-declaration-conc? abnf::cst)
                3))
    (b* ((abnf::cstss (cst-class-declaration-conc3 abnf::cst)))
      (cst-list-list-conc-matchp abnf::cstss "record-declaration")))
 :rule-classes :rewrite)

Theorem: cst-class-declaration-conc3-of-tree-fix-cst

(defthm cst-class-declaration-conc3-of-tree-fix-cst
  (equal (cst-class-declaration-conc3 (abnf::tree-fix abnf::cst))
         (cst-class-declaration-conc3 abnf::cst)))

Theorem: cst-class-declaration-conc3-tree-equiv-congruence-on-cst

(defthm cst-class-declaration-conc3-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-class-declaration-conc3 abnf::cst)
                  (cst-class-declaration-conc3 cst-equiv)))
  :rule-classes :congruence)

Function: cst-normal-class-declaration-conc

(defun cst-normal-class-declaration-conc (abnf::cst)
 (declare (xargs :guard (abnf::treep abnf::cst)))
 (declare
   (xargs :guard (cst-matchp abnf::cst "normal-class-declaration")))
 (abnf::tree-nonleaf->branches abnf::cst))

Theorem: tree-list-listp-of-cst-normal-class-declaration-conc

(defthm tree-list-listp-of-cst-normal-class-declaration-conc
  (b* ((abnf::cstss (cst-normal-class-declaration-conc abnf::cst)))
    (abnf::tree-list-listp abnf::cstss))
  :rule-classes :rewrite)

Theorem: cst-normal-class-declaration-conc-match

(defthm cst-normal-class-declaration-conc-match
 (implies
  (cst-matchp abnf::cst "normal-class-declaration")
  (b* ((abnf::cstss (cst-normal-class-declaration-conc abnf::cst)))
   (cst-list-list-conc-matchp
    abnf::cstss
    "*class-modifier %s\"class\" type-identifier [ type-parameters ] [ class-extends ] [ class-implements ] [ class-permits ] class-body")))
 :rule-classes :rewrite)

Theorem: cst-normal-class-declaration-conc-of-tree-fix-cst

(defthm cst-normal-class-declaration-conc-of-tree-fix-cst
 (equal
      (cst-normal-class-declaration-conc (abnf::tree-fix abnf::cst))
      (cst-normal-class-declaration-conc abnf::cst)))

Theorem: cst-normal-class-declaration-conc-tree-equiv-congruence-on-cst

(defthm
     cst-normal-class-declaration-conc-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-normal-class-declaration-conc abnf::cst)
                  (cst-normal-class-declaration-conc cst-equiv)))
  :rule-classes :congruence)

Function: cst-type-parameters-conc

(defun cst-type-parameters-conc (abnf::cst)
  (declare (xargs :guard (abnf::treep abnf::cst)))
  (declare (xargs :guard (cst-matchp abnf::cst "type-parameters")))
  (abnf::tree-nonleaf->branches abnf::cst))

Theorem: tree-list-listp-of-cst-type-parameters-conc

(defthm tree-list-listp-of-cst-type-parameters-conc
  (b* ((abnf::cstss (cst-type-parameters-conc abnf::cst)))
    (abnf::tree-list-listp abnf::cstss))
  :rule-classes :rewrite)

Theorem: cst-type-parameters-conc-match

(defthm cst-type-parameters-conc-match
  (implies
       (cst-matchp abnf::cst "type-parameters")
       (b* ((abnf::cstss (cst-type-parameters-conc abnf::cst)))
         (cst-list-list-conc-matchp abnf::cstss
                                    "\"<\" type-parameter-list \">\"")))
  :rule-classes :rewrite)

Theorem: cst-type-parameters-conc-of-tree-fix-cst

(defthm cst-type-parameters-conc-of-tree-fix-cst
  (equal (cst-type-parameters-conc (abnf::tree-fix abnf::cst))
         (cst-type-parameters-conc abnf::cst)))

Theorem: cst-type-parameters-conc-tree-equiv-congruence-on-cst

(defthm cst-type-parameters-conc-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-type-parameters-conc abnf::cst)
                  (cst-type-parameters-conc cst-equiv)))
  :rule-classes :congruence)

Function: cst-type-parameter-list-conc

(defun cst-type-parameter-list-conc (abnf::cst)
  (declare (xargs :guard (abnf::treep abnf::cst)))
  (declare
       (xargs :guard (cst-matchp abnf::cst "type-parameter-list")))
  (abnf::tree-nonleaf->branches abnf::cst))

Theorem: tree-list-listp-of-cst-type-parameter-list-conc

(defthm tree-list-listp-of-cst-type-parameter-list-conc
  (b* ((abnf::cstss (cst-type-parameter-list-conc abnf::cst)))
    (abnf::tree-list-listp abnf::cstss))
  :rule-classes :rewrite)

Theorem: cst-type-parameter-list-conc-match

(defthm cst-type-parameter-list-conc-match
  (implies
       (cst-matchp abnf::cst "type-parameter-list")
       (b* ((abnf::cstss (cst-type-parameter-list-conc abnf::cst)))
         (cst-list-list-conc-matchp
              abnf::cstss
              "type-parameter *( \",\" type-parameter )")))
  :rule-classes :rewrite)

Theorem: cst-type-parameter-list-conc-of-tree-fix-cst

(defthm cst-type-parameter-list-conc-of-tree-fix-cst
  (equal (cst-type-parameter-list-conc (abnf::tree-fix abnf::cst))
         (cst-type-parameter-list-conc abnf::cst)))

Theorem: cst-type-parameter-list-conc-tree-equiv-congruence-on-cst

(defthm cst-type-parameter-list-conc-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-type-parameter-list-conc abnf::cst)
                  (cst-type-parameter-list-conc cst-equiv)))
  :rule-classes :congruence)

Function: cst-class-extends-conc

(defun cst-class-extends-conc (abnf::cst)
  (declare (xargs :guard (abnf::treep abnf::cst)))
  (declare (xargs :guard (cst-matchp abnf::cst "class-extends")))
  (abnf::tree-nonleaf->branches abnf::cst))

Theorem: tree-list-listp-of-cst-class-extends-conc

(defthm tree-list-listp-of-cst-class-extends-conc
  (b* ((abnf::cstss (cst-class-extends-conc abnf::cst)))
    (abnf::tree-list-listp abnf::cstss))
  :rule-classes :rewrite)

Theorem: cst-class-extends-conc-match

(defthm cst-class-extends-conc-match
  (implies (cst-matchp abnf::cst "class-extends")
           (b* ((abnf::cstss (cst-class-extends-conc abnf::cst)))
             (cst-list-list-conc-matchp
                  abnf::cstss "%s\"extends\" class-type")))
  :rule-classes :rewrite)

Theorem: cst-class-extends-conc-of-tree-fix-cst

(defthm cst-class-extends-conc-of-tree-fix-cst
  (equal (cst-class-extends-conc (abnf::tree-fix abnf::cst))
         (cst-class-extends-conc abnf::cst)))

Theorem: cst-class-extends-conc-tree-equiv-congruence-on-cst

(defthm cst-class-extends-conc-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-class-extends-conc abnf::cst)
                  (cst-class-extends-conc cst-equiv)))
  :rule-classes :congruence)

Function: cst-class-implements-conc

(defun cst-class-implements-conc (abnf::cst)
  (declare (xargs :guard (abnf::treep abnf::cst)))
  (declare (xargs :guard (cst-matchp abnf::cst "class-implements")))
  (abnf::tree-nonleaf->branches abnf::cst))

Theorem: tree-list-listp-of-cst-class-implements-conc

(defthm tree-list-listp-of-cst-class-implements-conc
  (b* ((abnf::cstss (cst-class-implements-conc abnf::cst)))
    (abnf::tree-list-listp abnf::cstss))
  :rule-classes :rewrite)

Theorem: cst-class-implements-conc-match

(defthm cst-class-implements-conc-match
  (implies (cst-matchp abnf::cst "class-implements")
           (b* ((abnf::cstss (cst-class-implements-conc abnf::cst)))
             (cst-list-list-conc-matchp
                  abnf::cstss
                  "%s\"implements\" interface-type-list")))
  :rule-classes :rewrite)

Theorem: cst-class-implements-conc-of-tree-fix-cst

(defthm cst-class-implements-conc-of-tree-fix-cst
  (equal (cst-class-implements-conc (abnf::tree-fix abnf::cst))
         (cst-class-implements-conc abnf::cst)))

Theorem: cst-class-implements-conc-tree-equiv-congruence-on-cst

(defthm cst-class-implements-conc-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-class-implements-conc abnf::cst)
                  (cst-class-implements-conc cst-equiv)))
  :rule-classes :congruence)

Function: cst-interface-type-list-conc

(defun cst-interface-type-list-conc (abnf::cst)
  (declare (xargs :guard (abnf::treep abnf::cst)))
  (declare
       (xargs :guard (cst-matchp abnf::cst "interface-type-list")))
  (abnf::tree-nonleaf->branches abnf::cst))

Theorem: tree-list-listp-of-cst-interface-type-list-conc

(defthm tree-list-listp-of-cst-interface-type-list-conc
  (b* ((abnf::cstss (cst-interface-type-list-conc abnf::cst)))
    (abnf::tree-list-listp abnf::cstss))
  :rule-classes :rewrite)

Theorem: cst-interface-type-list-conc-match

(defthm cst-interface-type-list-conc-match
  (implies
       (cst-matchp abnf::cst "interface-type-list")
       (b* ((abnf::cstss (cst-interface-type-list-conc abnf::cst)))
         (cst-list-list-conc-matchp
              abnf::cstss
              "interface-type *( \",\" interface-type )")))
  :rule-classes :rewrite)

Theorem: cst-interface-type-list-conc-of-tree-fix-cst

(defthm cst-interface-type-list-conc-of-tree-fix-cst
  (equal (cst-interface-type-list-conc (abnf::tree-fix abnf::cst))
         (cst-interface-type-list-conc abnf::cst)))

Theorem: cst-interface-type-list-conc-tree-equiv-congruence-on-cst

(defthm cst-interface-type-list-conc-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-interface-type-list-conc abnf::cst)
                  (cst-interface-type-list-conc cst-equiv)))
  :rule-classes :congruence)

Function: cst-class-permits-conc

(defun cst-class-permits-conc (abnf::cst)
  (declare (xargs :guard (abnf::treep abnf::cst)))
  (declare (xargs :guard (cst-matchp abnf::cst "class-permits")))
  (abnf::tree-nonleaf->branches abnf::cst))

Theorem: tree-list-listp-of-cst-class-permits-conc

(defthm tree-list-listp-of-cst-class-permits-conc
  (b* ((abnf::cstss (cst-class-permits-conc abnf::cst)))
    (abnf::tree-list-listp abnf::cstss))
  :rule-classes :rewrite)

Theorem: cst-class-permits-conc-match

(defthm cst-class-permits-conc-match
  (implies (cst-matchp abnf::cst "class-permits")
           (b* ((abnf::cstss (cst-class-permits-conc abnf::cst)))
             (cst-list-list-conc-matchp
                  abnf::cstss
                  "%s\"permits\" type-name *( \",\" type-name )")))
  :rule-classes :rewrite)

Theorem: cst-class-permits-conc-of-tree-fix-cst

(defthm cst-class-permits-conc-of-tree-fix-cst
  (equal (cst-class-permits-conc (abnf::tree-fix abnf::cst))
         (cst-class-permits-conc abnf::cst)))

Theorem: cst-class-permits-conc-tree-equiv-congruence-on-cst

(defthm cst-class-permits-conc-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-class-permits-conc abnf::cst)
                  (cst-class-permits-conc cst-equiv)))
  :rule-classes :congruence)

Function: cst-class-body-conc

(defun cst-class-body-conc (abnf::cst)
  (declare (xargs :guard (abnf::treep abnf::cst)))
  (declare (xargs :guard (cst-matchp abnf::cst "class-body")))
  (abnf::tree-nonleaf->branches abnf::cst))

Theorem: tree-list-listp-of-cst-class-body-conc

(defthm tree-list-listp-of-cst-class-body-conc
  (b* ((abnf::cstss (cst-class-body-conc abnf::cst)))
    (abnf::tree-list-listp abnf::cstss))
  :rule-classes :rewrite)

Theorem: cst-class-body-conc-match

(defthm cst-class-body-conc-match
 (implies
   (cst-matchp abnf::cst "class-body")
   (b* ((abnf::cstss (cst-class-body-conc abnf::cst)))
     (cst-list-list-conc-matchp abnf::cstss
                                "\"{\" *class-body-declaration \"}\"")))
 :rule-classes :rewrite)

Theorem: cst-class-body-conc-of-tree-fix-cst

(defthm cst-class-body-conc-of-tree-fix-cst
  (equal (cst-class-body-conc (abnf::tree-fix abnf::cst))
         (cst-class-body-conc abnf::cst)))

Theorem: cst-class-body-conc-tree-equiv-congruence-on-cst

(defthm cst-class-body-conc-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-class-body-conc abnf::cst)
                  (cst-class-body-conc cst-equiv)))
  :rule-classes :congruence)

Function: cst-class-body-declaration-conc1

(defun cst-class-body-declaration-conc1 (abnf::cst)
 (declare (xargs :guard (abnf::treep abnf::cst)))
 (declare
  (xargs
     :guard (and (cst-matchp abnf::cst "class-body-declaration")
                 (equal (cst-class-body-declaration-conc? abnf::cst)
                        1))))
 (abnf::tree-nonleaf->branches abnf::cst))

Theorem: tree-list-listp-of-cst-class-body-declaration-conc1

(defthm tree-list-listp-of-cst-class-body-declaration-conc1
  (b* ((abnf::cstss (cst-class-body-declaration-conc1 abnf::cst)))
    (abnf::tree-list-listp abnf::cstss))
  :rule-classes :rewrite)

Theorem: cst-class-body-declaration-conc1-match

(defthm cst-class-body-declaration-conc1-match
 (implies
    (and (cst-matchp abnf::cst "class-body-declaration")
         (equal (cst-class-body-declaration-conc? abnf::cst)
                1))
    (b* ((abnf::cstss (cst-class-body-declaration-conc1 abnf::cst)))
      (cst-list-list-conc-matchp abnf::cstss
                                 "class-member-declaration")))
 :rule-classes :rewrite)

Theorem: cst-class-body-declaration-conc1-of-tree-fix-cst

(defthm cst-class-body-declaration-conc1-of-tree-fix-cst
  (equal
       (cst-class-body-declaration-conc1 (abnf::tree-fix abnf::cst))
       (cst-class-body-declaration-conc1 abnf::cst)))

Theorem: cst-class-body-declaration-conc1-tree-equiv-congruence-on-cst

(defthm
      cst-class-body-declaration-conc1-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-class-body-declaration-conc1 abnf::cst)
                  (cst-class-body-declaration-conc1 cst-equiv)))
  :rule-classes :congruence)

Function: cst-class-body-declaration-conc2

(defun cst-class-body-declaration-conc2 (abnf::cst)
 (declare (xargs :guard (abnf::treep abnf::cst)))
 (declare
  (xargs
     :guard (and (cst-matchp abnf::cst "class-body-declaration")
                 (equal (cst-class-body-declaration-conc? abnf::cst)
                        2))))
 (abnf::tree-nonleaf->branches abnf::cst))

Theorem: tree-list-listp-of-cst-class-body-declaration-conc2

(defthm tree-list-listp-of-cst-class-body-declaration-conc2
  (b* ((abnf::cstss (cst-class-body-declaration-conc2 abnf::cst)))
    (abnf::tree-list-listp abnf::cstss))
  :rule-classes :rewrite)

Theorem: cst-class-body-declaration-conc2-match

(defthm cst-class-body-declaration-conc2-match
 (implies
  (and (cst-matchp abnf::cst "class-body-declaration")
       (equal (cst-class-body-declaration-conc? abnf::cst)
              2))
  (b* ((abnf::cstss (cst-class-body-declaration-conc2 abnf::cst)))
    (cst-list-list-conc-matchp abnf::cstss "instance-initializer")))
 :rule-classes :rewrite)

Theorem: cst-class-body-declaration-conc2-of-tree-fix-cst

(defthm cst-class-body-declaration-conc2-of-tree-fix-cst
  (equal
       (cst-class-body-declaration-conc2 (abnf::tree-fix abnf::cst))
       (cst-class-body-declaration-conc2 abnf::cst)))

Theorem: cst-class-body-declaration-conc2-tree-equiv-congruence-on-cst

(defthm
      cst-class-body-declaration-conc2-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-class-body-declaration-conc2 abnf::cst)
                  (cst-class-body-declaration-conc2 cst-equiv)))
  :rule-classes :congruence)

Function: cst-class-body-declaration-conc3

(defun cst-class-body-declaration-conc3 (abnf::cst)
 (declare (xargs :guard (abnf::treep abnf::cst)))
 (declare
  (xargs
     :guard (and (cst-matchp abnf::cst "class-body-declaration")
                 (equal (cst-class-body-declaration-conc? abnf::cst)
                        3))))
 (abnf::tree-nonleaf->branches abnf::cst))

Theorem: tree-list-listp-of-cst-class-body-declaration-conc3

(defthm tree-list-listp-of-cst-class-body-declaration-conc3
  (b* ((abnf::cstss (cst-class-body-declaration-conc3 abnf::cst)))
    (abnf::tree-list-listp abnf::cstss))
  :rule-classes :rewrite)

Theorem: cst-class-body-declaration-conc3-match

(defthm cst-class-body-declaration-conc3-match
 (implies
    (and (cst-matchp abnf::cst "class-body-declaration")
         (equal (cst-class-body-declaration-conc? abnf::cst)
                3))
    (b* ((abnf::cstss (cst-class-body-declaration-conc3 abnf::cst)))
      (cst-list-list-conc-matchp abnf::cstss "static-initializer")))
 :rule-classes :rewrite)

Theorem: cst-class-body-declaration-conc3-of-tree-fix-cst

(defthm cst-class-body-declaration-conc3-of-tree-fix-cst
  (equal
       (cst-class-body-declaration-conc3 (abnf::tree-fix abnf::cst))
       (cst-class-body-declaration-conc3 abnf::cst)))

Theorem: cst-class-body-declaration-conc3-tree-equiv-congruence-on-cst

(defthm
      cst-class-body-declaration-conc3-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-class-body-declaration-conc3 abnf::cst)
                  (cst-class-body-declaration-conc3 cst-equiv)))
  :rule-classes :congruence)

Function: cst-class-body-declaration-conc4

(defun cst-class-body-declaration-conc4 (abnf::cst)
 (declare (xargs :guard (abnf::treep abnf::cst)))
 (declare
  (xargs
     :guard (and (cst-matchp abnf::cst "class-body-declaration")
                 (equal (cst-class-body-declaration-conc? abnf::cst)
                        4))))
 (abnf::tree-nonleaf->branches abnf::cst))

Theorem: tree-list-listp-of-cst-class-body-declaration-conc4

(defthm tree-list-listp-of-cst-class-body-declaration-conc4
  (b* ((abnf::cstss (cst-class-body-declaration-conc4 abnf::cst)))
    (abnf::tree-list-listp abnf::cstss))
  :rule-classes :rewrite)

Theorem: cst-class-body-declaration-conc4-match

(defthm cst-class-body-declaration-conc4-match
 (implies
    (and (cst-matchp abnf::cst "class-body-declaration")
         (equal (cst-class-body-declaration-conc? abnf::cst)
                4))
    (b* ((abnf::cstss (cst-class-body-declaration-conc4 abnf::cst)))
      (cst-list-list-conc-matchp
           abnf::cstss "constructor-declaration")))
 :rule-classes :rewrite)

Theorem: cst-class-body-declaration-conc4-of-tree-fix-cst

(defthm cst-class-body-declaration-conc4-of-tree-fix-cst
  (equal
       (cst-class-body-declaration-conc4 (abnf::tree-fix abnf::cst))
       (cst-class-body-declaration-conc4 abnf::cst)))

Theorem: cst-class-body-declaration-conc4-tree-equiv-congruence-on-cst

(defthm
      cst-class-body-declaration-conc4-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-class-body-declaration-conc4 abnf::cst)
                  (cst-class-body-declaration-conc4 cst-equiv)))
  :rule-classes :congruence)

Function: cst-field-declaration-conc

(defun cst-field-declaration-conc (abnf::cst)
 (declare (xargs :guard (abnf::treep abnf::cst)))
 (declare (xargs :guard (cst-matchp abnf::cst "field-declaration")))
 (abnf::tree-nonleaf->branches abnf::cst))

Theorem: tree-list-listp-of-cst-field-declaration-conc

(defthm tree-list-listp-of-cst-field-declaration-conc
  (b* ((abnf::cstss (cst-field-declaration-conc abnf::cst)))
    (abnf::tree-list-listp abnf::cstss))
  :rule-classes :rewrite)

Theorem: cst-field-declaration-conc-match

(defthm cst-field-declaration-conc-match
 (implies
  (cst-matchp abnf::cst "field-declaration")
  (b* ((abnf::cstss (cst-field-declaration-conc abnf::cst)))
   (cst-list-list-conc-matchp
        abnf::cstss
        "*field-modifier unann-type variable-declarator-list \";\"")))
 :rule-classes :rewrite)

Theorem: cst-field-declaration-conc-of-tree-fix-cst

(defthm cst-field-declaration-conc-of-tree-fix-cst
  (equal (cst-field-declaration-conc (abnf::tree-fix abnf::cst))
         (cst-field-declaration-conc abnf::cst)))

Theorem: cst-field-declaration-conc-tree-equiv-congruence-on-cst

(defthm cst-field-declaration-conc-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-field-declaration-conc abnf::cst)
                  (cst-field-declaration-conc cst-equiv)))
  :rule-classes :congruence)

Function: cst-variable-declarator-list-conc

(defun cst-variable-declarator-list-conc (abnf::cst)
 (declare (xargs :guard (abnf::treep abnf::cst)))
 (declare
   (xargs :guard (cst-matchp abnf::cst "variable-declarator-list")))
 (abnf::tree-nonleaf->branches abnf::cst))

Theorem: tree-list-listp-of-cst-variable-declarator-list-conc

(defthm tree-list-listp-of-cst-variable-declarator-list-conc
  (b* ((abnf::cstss (cst-variable-declarator-list-conc abnf::cst)))
    (abnf::tree-list-listp abnf::cstss))
  :rule-classes :rewrite)

Theorem: cst-variable-declarator-list-conc-match

(defthm cst-variable-declarator-list-conc-match
 (implies
   (cst-matchp abnf::cst "variable-declarator-list")
   (b* ((abnf::cstss (cst-variable-declarator-list-conc abnf::cst)))
     (cst-list-list-conc-matchp
          abnf::cstss
          "variable-declarator *( \",\" variable-declarator )")))
 :rule-classes :rewrite)

Theorem: cst-variable-declarator-list-conc-of-tree-fix-cst

(defthm cst-variable-declarator-list-conc-of-tree-fix-cst
 (equal
      (cst-variable-declarator-list-conc (abnf::tree-fix abnf::cst))
      (cst-variable-declarator-list-conc abnf::cst)))

Theorem: cst-variable-declarator-list-conc-tree-equiv-congruence-on-cst

(defthm
     cst-variable-declarator-list-conc-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-variable-declarator-list-conc abnf::cst)
                  (cst-variable-declarator-list-conc cst-equiv)))
  :rule-classes :congruence)

Function: cst-variable-declarator-conc

(defun cst-variable-declarator-conc (abnf::cst)
  (declare (xargs :guard (abnf::treep abnf::cst)))
  (declare
       (xargs :guard (cst-matchp abnf::cst "variable-declarator")))
  (abnf::tree-nonleaf->branches abnf::cst))

Theorem: tree-list-listp-of-cst-variable-declarator-conc

(defthm tree-list-listp-of-cst-variable-declarator-conc
  (b* ((abnf::cstss (cst-variable-declarator-conc abnf::cst)))
    (abnf::tree-list-listp abnf::cstss))
  :rule-classes :rewrite)

Theorem: cst-variable-declarator-conc-match

(defthm cst-variable-declarator-conc-match
 (implies
     (cst-matchp abnf::cst "variable-declarator")
     (b* ((abnf::cstss (cst-variable-declarator-conc abnf::cst)))
       (cst-list-list-conc-matchp
            abnf::cstss
            "variable-declarator-id [ \"=\" variable-initializer ]")))
 :rule-classes :rewrite)

Theorem: cst-variable-declarator-conc-of-tree-fix-cst

(defthm cst-variable-declarator-conc-of-tree-fix-cst
  (equal (cst-variable-declarator-conc (abnf::tree-fix abnf::cst))
         (cst-variable-declarator-conc abnf::cst)))

Theorem: cst-variable-declarator-conc-tree-equiv-congruence-on-cst

(defthm cst-variable-declarator-conc-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-variable-declarator-conc abnf::cst)
                  (cst-variable-declarator-conc cst-equiv)))
  :rule-classes :congruence)

Function: cst-variable-initializer-conc1

(defun cst-variable-initializer-conc1 (abnf::cst)
 (declare (xargs :guard (abnf::treep abnf::cst)))
 (declare
  (xargs
       :guard (and (cst-matchp abnf::cst "variable-initializer")
                   (equal (cst-variable-initializer-conc? abnf::cst)
                          1))))
 (abnf::tree-nonleaf->branches abnf::cst))

Theorem: tree-list-listp-of-cst-variable-initializer-conc1

(defthm tree-list-listp-of-cst-variable-initializer-conc1
  (b* ((abnf::cstss (cst-variable-initializer-conc1 abnf::cst)))
    (abnf::tree-list-listp abnf::cstss))
  :rule-classes :rewrite)

Theorem: cst-variable-initializer-conc1-match

(defthm cst-variable-initializer-conc1-match
 (implies
      (and (cst-matchp abnf::cst "variable-initializer")
           (equal (cst-variable-initializer-conc? abnf::cst)
                  1))
      (b* ((abnf::cstss (cst-variable-initializer-conc1 abnf::cst)))
        (cst-list-list-conc-matchp abnf::cstss "expression")))
 :rule-classes :rewrite)

Theorem: cst-variable-initializer-conc1-of-tree-fix-cst

(defthm cst-variable-initializer-conc1-of-tree-fix-cst
  (equal (cst-variable-initializer-conc1 (abnf::tree-fix abnf::cst))
         (cst-variable-initializer-conc1 abnf::cst)))

Theorem: cst-variable-initializer-conc1-tree-equiv-congruence-on-cst

(defthm cst-variable-initializer-conc1-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-variable-initializer-conc1 abnf::cst)
                  (cst-variable-initializer-conc1 cst-equiv)))
  :rule-classes :congruence)

Function: cst-variable-initializer-conc2

(defun cst-variable-initializer-conc2 (abnf::cst)
 (declare (xargs :guard (abnf::treep abnf::cst)))
 (declare
  (xargs
       :guard (and (cst-matchp abnf::cst "variable-initializer")
                   (equal (cst-variable-initializer-conc? abnf::cst)
                          2))))
 (abnf::tree-nonleaf->branches abnf::cst))

Theorem: tree-list-listp-of-cst-variable-initializer-conc2

(defthm tree-list-listp-of-cst-variable-initializer-conc2
  (b* ((abnf::cstss (cst-variable-initializer-conc2 abnf::cst)))
    (abnf::tree-list-listp abnf::cstss))
  :rule-classes :rewrite)

Theorem: cst-variable-initializer-conc2-match

(defthm cst-variable-initializer-conc2-match
 (implies
     (and (cst-matchp abnf::cst "variable-initializer")
          (equal (cst-variable-initializer-conc? abnf::cst)
                 2))
     (b* ((abnf::cstss (cst-variable-initializer-conc2 abnf::cst)))
       (cst-list-list-conc-matchp abnf::cstss "array-initializer")))
 :rule-classes :rewrite)

Theorem: cst-variable-initializer-conc2-of-tree-fix-cst

(defthm cst-variable-initializer-conc2-of-tree-fix-cst
  (equal (cst-variable-initializer-conc2 (abnf::tree-fix abnf::cst))
         (cst-variable-initializer-conc2 abnf::cst)))

Theorem: cst-variable-initializer-conc2-tree-equiv-congruence-on-cst

(defthm cst-variable-initializer-conc2-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-variable-initializer-conc2 abnf::cst)
                  (cst-variable-initializer-conc2 cst-equiv)))
  :rule-classes :congruence)

Function: cst-unann-type-conc1

(defun cst-unann-type-conc1 (abnf::cst)
 (declare (xargs :guard (abnf::treep abnf::cst)))
 (declare (xargs :guard (and (cst-matchp abnf::cst "unann-type")
                             (equal (cst-unann-type-conc? abnf::cst)
                                    1))))
 (abnf::tree-nonleaf->branches abnf::cst))

Theorem: tree-list-listp-of-cst-unann-type-conc1

(defthm tree-list-listp-of-cst-unann-type-conc1
  (b* ((abnf::cstss (cst-unann-type-conc1 abnf::cst)))
    (abnf::tree-list-listp abnf::cstss))
  :rule-classes :rewrite)

Theorem: cst-unann-type-conc1-match

(defthm cst-unann-type-conc1-match
 (implies
  (and (cst-matchp abnf::cst "unann-type")
       (equal (cst-unann-type-conc? abnf::cst)
              1))
  (b* ((abnf::cstss (cst-unann-type-conc1 abnf::cst)))
    (cst-list-list-conc-matchp abnf::cstss "unann-primitive-type")))
 :rule-classes :rewrite)

Theorem: cst-unann-type-conc1-of-tree-fix-cst

(defthm cst-unann-type-conc1-of-tree-fix-cst
  (equal (cst-unann-type-conc1 (abnf::tree-fix abnf::cst))
         (cst-unann-type-conc1 abnf::cst)))

Theorem: cst-unann-type-conc1-tree-equiv-congruence-on-cst

(defthm cst-unann-type-conc1-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-unann-type-conc1 abnf::cst)
                  (cst-unann-type-conc1 cst-equiv)))
  :rule-classes :congruence)

Function: cst-unann-type-conc2

(defun cst-unann-type-conc2 (abnf::cst)
 (declare (xargs :guard (abnf::treep abnf::cst)))
 (declare (xargs :guard (and (cst-matchp abnf::cst "unann-type")
                             (equal (cst-unann-type-conc? abnf::cst)
                                    2))))
 (abnf::tree-nonleaf->branches abnf::cst))

Theorem: tree-list-listp-of-cst-unann-type-conc2

(defthm tree-list-listp-of-cst-unann-type-conc2
  (b* ((abnf::cstss (cst-unann-type-conc2 abnf::cst)))
    (abnf::tree-list-listp abnf::cstss))
  :rule-classes :rewrite)

Theorem: cst-unann-type-conc2-match

(defthm cst-unann-type-conc2-match
 (implies
  (and (cst-matchp abnf::cst "unann-type")
       (equal (cst-unann-type-conc? abnf::cst)
              2))
  (b* ((abnf::cstss (cst-unann-type-conc2 abnf::cst)))
    (cst-list-list-conc-matchp abnf::cstss "unann-reference-type")))
 :rule-classes :rewrite)

Theorem: cst-unann-type-conc2-of-tree-fix-cst

(defthm cst-unann-type-conc2-of-tree-fix-cst
  (equal (cst-unann-type-conc2 (abnf::tree-fix abnf::cst))
         (cst-unann-type-conc2 abnf::cst)))

Theorem: cst-unann-type-conc2-tree-equiv-congruence-on-cst

(defthm cst-unann-type-conc2-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-unann-type-conc2 abnf::cst)
                  (cst-unann-type-conc2 cst-equiv)))
  :rule-classes :congruence)

Function: cst-unann-reference-type-conc1

(defun cst-unann-reference-type-conc1 (abnf::cst)
 (declare (xargs :guard (abnf::treep abnf::cst)))
 (declare
  (xargs
       :guard (and (cst-matchp abnf::cst "unann-reference-type")
                   (equal (cst-unann-reference-type-conc? abnf::cst)
                          1))))
 (abnf::tree-nonleaf->branches abnf::cst))

Theorem: tree-list-listp-of-cst-unann-reference-type-conc1

(defthm tree-list-listp-of-cst-unann-reference-type-conc1
  (b* ((abnf::cstss (cst-unann-reference-type-conc1 abnf::cst)))
    (abnf::tree-list-listp abnf::cstss))
  :rule-classes :rewrite)

Theorem: cst-unann-reference-type-conc1-match

(defthm cst-unann-reference-type-conc1-match
 (implies
     (and (cst-matchp abnf::cst "unann-reference-type")
          (equal (cst-unann-reference-type-conc? abnf::cst)
                 1))
     (b* ((abnf::cstss (cst-unann-reference-type-conc1 abnf::cst)))
       (cst-list-list-conc-matchp abnf::cstss
                                  "unann-class-or-interface-type")))
 :rule-classes :rewrite)

Theorem: cst-unann-reference-type-conc1-of-tree-fix-cst

(defthm cst-unann-reference-type-conc1-of-tree-fix-cst
  (equal (cst-unann-reference-type-conc1 (abnf::tree-fix abnf::cst))
         (cst-unann-reference-type-conc1 abnf::cst)))

Theorem: cst-unann-reference-type-conc1-tree-equiv-congruence-on-cst

(defthm cst-unann-reference-type-conc1-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-unann-reference-type-conc1 abnf::cst)
                  (cst-unann-reference-type-conc1 cst-equiv)))
  :rule-classes :congruence)

Function: cst-unann-reference-type-conc2

(defun cst-unann-reference-type-conc2 (abnf::cst)
 (declare (xargs :guard (abnf::treep abnf::cst)))
 (declare
  (xargs
       :guard (and (cst-matchp abnf::cst "unann-reference-type")
                   (equal (cst-unann-reference-type-conc? abnf::cst)
                          2))))
 (abnf::tree-nonleaf->branches abnf::cst))

Theorem: tree-list-listp-of-cst-unann-reference-type-conc2

(defthm tree-list-listp-of-cst-unann-reference-type-conc2
  (b* ((abnf::cstss (cst-unann-reference-type-conc2 abnf::cst)))
    (abnf::tree-list-listp abnf::cstss))
  :rule-classes :rewrite)

Theorem: cst-unann-reference-type-conc2-match

(defthm cst-unann-reference-type-conc2-match
 (implies
   (and (cst-matchp abnf::cst "unann-reference-type")
        (equal (cst-unann-reference-type-conc? abnf::cst)
               2))
   (b* ((abnf::cstss (cst-unann-reference-type-conc2 abnf::cst)))
     (cst-list-list-conc-matchp abnf::cstss "unann-type-variable")))
 :rule-classes :rewrite)

Theorem: cst-unann-reference-type-conc2-of-tree-fix-cst

(defthm cst-unann-reference-type-conc2-of-tree-fix-cst
  (equal (cst-unann-reference-type-conc2 (abnf::tree-fix abnf::cst))
         (cst-unann-reference-type-conc2 abnf::cst)))

Theorem: cst-unann-reference-type-conc2-tree-equiv-congruence-on-cst

(defthm cst-unann-reference-type-conc2-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-unann-reference-type-conc2 abnf::cst)
                  (cst-unann-reference-type-conc2 cst-equiv)))
  :rule-classes :congruence)

Function: cst-unann-reference-type-conc3

(defun cst-unann-reference-type-conc3 (abnf::cst)
 (declare (xargs :guard (abnf::treep abnf::cst)))
 (declare
  (xargs
       :guard (and (cst-matchp abnf::cst "unann-reference-type")
                   (equal (cst-unann-reference-type-conc? abnf::cst)
                          3))))
 (abnf::tree-nonleaf->branches abnf::cst))

Theorem: tree-list-listp-of-cst-unann-reference-type-conc3

(defthm tree-list-listp-of-cst-unann-reference-type-conc3
  (b* ((abnf::cstss (cst-unann-reference-type-conc3 abnf::cst)))
    (abnf::tree-list-listp abnf::cstss))
  :rule-classes :rewrite)

Theorem: cst-unann-reference-type-conc3-match

(defthm cst-unann-reference-type-conc3-match
 (implies
      (and (cst-matchp abnf::cst "unann-reference-type")
           (equal (cst-unann-reference-type-conc? abnf::cst)
                  3))
      (b* ((abnf::cstss (cst-unann-reference-type-conc3 abnf::cst)))
        (cst-list-list-conc-matchp abnf::cstss "unann-array-type")))
 :rule-classes :rewrite)

Theorem: cst-unann-reference-type-conc3-of-tree-fix-cst

(defthm cst-unann-reference-type-conc3-of-tree-fix-cst
  (equal (cst-unann-reference-type-conc3 (abnf::tree-fix abnf::cst))
         (cst-unann-reference-type-conc3 abnf::cst)))

Theorem: cst-unann-reference-type-conc3-tree-equiv-congruence-on-cst

(defthm cst-unann-reference-type-conc3-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-unann-reference-type-conc3 abnf::cst)
                  (cst-unann-reference-type-conc3 cst-equiv)))
  :rule-classes :congruence)

Function: cst-unann-class-or-interface-type-conc1

(defun cst-unann-class-or-interface-type-conc1 (abnf::cst)
 (declare (xargs :guard (abnf::treep abnf::cst)))
 (declare
  (xargs
     :guard
     (and (cst-matchp abnf::cst
                      "unann-class-or-interface-type")
          (equal (cst-unann-class-or-interface-type-conc? abnf::cst)
                 1))))
 (abnf::tree-nonleaf->branches abnf::cst))

Theorem: tree-list-listp-of-cst-unann-class-or-interface-type-conc1

(defthm tree-list-listp-of-cst-unann-class-or-interface-type-conc1
  (b* ((abnf::cstss
            (cst-unann-class-or-interface-type-conc1 abnf::cst)))
    (abnf::tree-list-listp abnf::cstss))
  :rule-classes :rewrite)

Theorem: cst-unann-class-or-interface-type-conc1-match

(defthm cst-unann-class-or-interface-type-conc1-match
 (implies
     (and (cst-matchp abnf::cst
                      "unann-class-or-interface-type")
          (equal (cst-unann-class-or-interface-type-conc? abnf::cst)
                 1))
     (b* ((abnf::cstss
               (cst-unann-class-or-interface-type-conc1 abnf::cst)))
       (cst-list-list-conc-matchp abnf::cstss "unann-class-type")))
 :rule-classes :rewrite)

Theorem: cst-unann-class-or-interface-type-conc1-of-tree-fix-cst

(defthm cst-unann-class-or-interface-type-conc1-of-tree-fix-cst
  (equal (cst-unann-class-or-interface-type-conc1
              (abnf::tree-fix abnf::cst))
         (cst-unann-class-or-interface-type-conc1 abnf::cst)))

Theorem: cst-unann-class-or-interface-type-conc1-tree-equiv-congruence-on-cst

(defthm
 cst-unann-class-or-interface-type-conc1-tree-equiv-congruence-on-cst
 (implies
      (abnf::tree-equiv abnf::cst cst-equiv)
      (equal (cst-unann-class-or-interface-type-conc1 abnf::cst)
             (cst-unann-class-or-interface-type-conc1 cst-equiv)))
 :rule-classes :congruence)

Function: cst-unann-class-or-interface-type-conc2

(defun cst-unann-class-or-interface-type-conc2 (abnf::cst)
 (declare (xargs :guard (abnf::treep abnf::cst)))
 (declare
  (xargs
     :guard
     (and (cst-matchp abnf::cst
                      "unann-class-or-interface-type")
          (equal (cst-unann-class-or-interface-type-conc? abnf::cst)
                 2))))
 (abnf::tree-nonleaf->branches abnf::cst))

Theorem: tree-list-listp-of-cst-unann-class-or-interface-type-conc2

(defthm tree-list-listp-of-cst-unann-class-or-interface-type-conc2
  (b* ((abnf::cstss
            (cst-unann-class-or-interface-type-conc2 abnf::cst)))
    (abnf::tree-list-listp abnf::cstss))
  :rule-classes :rewrite)

Theorem: cst-unann-class-or-interface-type-conc2-match

(defthm cst-unann-class-or-interface-type-conc2-match
 (implies
  (and (cst-matchp abnf::cst
                   "unann-class-or-interface-type")
       (equal (cst-unann-class-or-interface-type-conc? abnf::cst)
              2))
  (b* ((abnf::cstss
            (cst-unann-class-or-interface-type-conc2 abnf::cst)))
    (cst-list-list-conc-matchp abnf::cstss "unann-interface-type")))
 :rule-classes :rewrite)

Theorem: cst-unann-class-or-interface-type-conc2-of-tree-fix-cst

(defthm cst-unann-class-or-interface-type-conc2-of-tree-fix-cst
  (equal (cst-unann-class-or-interface-type-conc2
              (abnf::tree-fix abnf::cst))
         (cst-unann-class-or-interface-type-conc2 abnf::cst)))

Theorem: cst-unann-class-or-interface-type-conc2-tree-equiv-congruence-on-cst

(defthm
 cst-unann-class-or-interface-type-conc2-tree-equiv-congruence-on-cst
 (implies
      (abnf::tree-equiv abnf::cst cst-equiv)
      (equal (cst-unann-class-or-interface-type-conc2 abnf::cst)
             (cst-unann-class-or-interface-type-conc2 cst-equiv)))
 :rule-classes :congruence)

Function: cst-unann-interface-type-conc

(defun cst-unann-interface-type-conc (abnf::cst)
  (declare (xargs :guard (abnf::treep abnf::cst)))
  (declare
       (xargs :guard (cst-matchp abnf::cst "unann-interface-type")))
  (abnf::tree-nonleaf->branches abnf::cst))

Theorem: tree-list-listp-of-cst-unann-interface-type-conc

(defthm tree-list-listp-of-cst-unann-interface-type-conc
  (b* ((abnf::cstss (cst-unann-interface-type-conc abnf::cst)))
    (abnf::tree-list-listp abnf::cstss))
  :rule-classes :rewrite)

Theorem: cst-unann-interface-type-conc-match

(defthm cst-unann-interface-type-conc-match
 (implies
      (cst-matchp abnf::cst "unann-interface-type")
      (b* ((abnf::cstss (cst-unann-interface-type-conc abnf::cst)))
        (cst-list-list-conc-matchp abnf::cstss "unann-class-type")))
 :rule-classes :rewrite)

Theorem: cst-unann-interface-type-conc-of-tree-fix-cst

(defthm cst-unann-interface-type-conc-of-tree-fix-cst
  (equal (cst-unann-interface-type-conc (abnf::tree-fix abnf::cst))
         (cst-unann-interface-type-conc abnf::cst)))

Theorem: cst-unann-interface-type-conc-tree-equiv-congruence-on-cst

(defthm cst-unann-interface-type-conc-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-unann-interface-type-conc abnf::cst)
                  (cst-unann-interface-type-conc cst-equiv)))
  :rule-classes :congruence)

Function: cst-unann-type-variable-conc

(defun cst-unann-type-variable-conc (abnf::cst)
  (declare (xargs :guard (abnf::treep abnf::cst)))
  (declare
       (xargs :guard (cst-matchp abnf::cst "unann-type-variable")))
  (abnf::tree-nonleaf->branches abnf::cst))

Theorem: tree-list-listp-of-cst-unann-type-variable-conc

(defthm tree-list-listp-of-cst-unann-type-variable-conc
  (b* ((abnf::cstss (cst-unann-type-variable-conc abnf::cst)))
    (abnf::tree-list-listp abnf::cstss))
  :rule-classes :rewrite)

Theorem: cst-unann-type-variable-conc-match

(defthm cst-unann-type-variable-conc-match
  (implies
       (cst-matchp abnf::cst "unann-type-variable")
       (b* ((abnf::cstss (cst-unann-type-variable-conc abnf::cst)))
         (cst-list-list-conc-matchp abnf::cstss "type-identifier")))
  :rule-classes :rewrite)

Theorem: cst-unann-type-variable-conc-of-tree-fix-cst

(defthm cst-unann-type-variable-conc-of-tree-fix-cst
  (equal (cst-unann-type-variable-conc (abnf::tree-fix abnf::cst))
         (cst-unann-type-variable-conc abnf::cst)))

Theorem: cst-unann-type-variable-conc-tree-equiv-congruence-on-cst

(defthm cst-unann-type-variable-conc-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-unann-type-variable-conc abnf::cst)
                  (cst-unann-type-variable-conc cst-equiv)))
  :rule-classes :congruence)

Function: cst-method-declaration-conc

(defun cst-method-declaration-conc (abnf::cst)
  (declare (xargs :guard (abnf::treep abnf::cst)))
  (declare
       (xargs :guard (cst-matchp abnf::cst "method-declaration")))
  (abnf::tree-nonleaf->branches abnf::cst))

Theorem: tree-list-listp-of-cst-method-declaration-conc

(defthm tree-list-listp-of-cst-method-declaration-conc
  (b* ((abnf::cstss (cst-method-declaration-conc abnf::cst)))
    (abnf::tree-list-listp abnf::cstss))
  :rule-classes :rewrite)

Theorem: cst-method-declaration-conc-match

(defthm cst-method-declaration-conc-match
  (implies
       (cst-matchp abnf::cst "method-declaration")
       (b* ((abnf::cstss (cst-method-declaration-conc abnf::cst)))
         (cst-list-list-conc-matchp
              abnf::cstss
              "*method-modifier method-header method-body")))
  :rule-classes :rewrite)

Theorem: cst-method-declaration-conc-of-tree-fix-cst

(defthm cst-method-declaration-conc-of-tree-fix-cst
  (equal (cst-method-declaration-conc (abnf::tree-fix abnf::cst))
         (cst-method-declaration-conc abnf::cst)))

Theorem: cst-method-declaration-conc-tree-equiv-congruence-on-cst

(defthm cst-method-declaration-conc-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-method-declaration-conc abnf::cst)
                  (cst-method-declaration-conc cst-equiv)))
  :rule-classes :congruence)

Function: cst-method-declarator-conc

(defun cst-method-declarator-conc (abnf::cst)
 (declare (xargs :guard (abnf::treep abnf::cst)))
 (declare (xargs :guard (cst-matchp abnf::cst "method-declarator")))
 (abnf::tree-nonleaf->branches abnf::cst))

Theorem: tree-list-listp-of-cst-method-declarator-conc

(defthm tree-list-listp-of-cst-method-declarator-conc
  (b* ((abnf::cstss (cst-method-declarator-conc abnf::cst)))
    (abnf::tree-list-listp abnf::cstss))
  :rule-classes :rewrite)

Theorem: cst-method-declarator-conc-match

(defthm cst-method-declarator-conc-match
 (implies
  (cst-matchp abnf::cst "method-declarator")
  (b* ((abnf::cstss (cst-method-declarator-conc abnf::cst)))
   (cst-list-list-conc-matchp
    abnf::cstss
    "identifier \"(\" [ receiver-parameter \",\" ] [ formal-parameter-list ] \")\" [ dims ]")))
 :rule-classes :rewrite)

Theorem: cst-method-declarator-conc-of-tree-fix-cst

(defthm cst-method-declarator-conc-of-tree-fix-cst
  (equal (cst-method-declarator-conc (abnf::tree-fix abnf::cst))
         (cst-method-declarator-conc abnf::cst)))

Theorem: cst-method-declarator-conc-tree-equiv-congruence-on-cst

(defthm cst-method-declarator-conc-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-method-declarator-conc abnf::cst)
                  (cst-method-declarator-conc cst-equiv)))
  :rule-classes :congruence)

Function: cst-receiver-parameter-conc

(defun cst-receiver-parameter-conc (abnf::cst)
  (declare (xargs :guard (abnf::treep abnf::cst)))
  (declare
       (xargs :guard (cst-matchp abnf::cst "receiver-parameter")))
  (abnf::tree-nonleaf->branches abnf::cst))

Theorem: tree-list-listp-of-cst-receiver-parameter-conc

(defthm tree-list-listp-of-cst-receiver-parameter-conc
  (b* ((abnf::cstss (cst-receiver-parameter-conc abnf::cst)))
    (abnf::tree-list-listp abnf::cstss))
  :rule-classes :rewrite)

Theorem: cst-receiver-parameter-conc-match

(defthm cst-receiver-parameter-conc-match
 (implies
      (cst-matchp abnf::cst "receiver-parameter")
      (b* ((abnf::cstss (cst-receiver-parameter-conc abnf::cst)))
        (cst-list-list-conc-matchp
             abnf::cstss
             "*annotation unann-type [ identifier \".\" ] %s\"this\"")))
 :rule-classes :rewrite)

Theorem: cst-receiver-parameter-conc-of-tree-fix-cst

(defthm cst-receiver-parameter-conc-of-tree-fix-cst
  (equal (cst-receiver-parameter-conc (abnf::tree-fix abnf::cst))
         (cst-receiver-parameter-conc abnf::cst)))

Theorem: cst-receiver-parameter-conc-tree-equiv-congruence-on-cst

(defthm cst-receiver-parameter-conc-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-receiver-parameter-conc abnf::cst)
                  (cst-receiver-parameter-conc cst-equiv)))
  :rule-classes :congruence)

Function: cst-formal-parameter-list-conc

(defun cst-formal-parameter-list-conc (abnf::cst)
 (declare (xargs :guard (abnf::treep abnf::cst)))
 (declare
      (xargs :guard (cst-matchp abnf::cst "formal-parameter-list")))
 (abnf::tree-nonleaf->branches abnf::cst))

Theorem: tree-list-listp-of-cst-formal-parameter-list-conc

(defthm tree-list-listp-of-cst-formal-parameter-list-conc
  (b* ((abnf::cstss (cst-formal-parameter-list-conc abnf::cst)))
    (abnf::tree-list-listp abnf::cstss))
  :rule-classes :rewrite)

Theorem: cst-formal-parameter-list-conc-match

(defthm cst-formal-parameter-list-conc-match
 (implies
      (cst-matchp abnf::cst "formal-parameter-list")
      (b* ((abnf::cstss (cst-formal-parameter-list-conc abnf::cst)))
        (cst-list-list-conc-matchp
             abnf::cstss
             "formal-parameter *( \",\" formal-parameter )")))
 :rule-classes :rewrite)

Theorem: cst-formal-parameter-list-conc-of-tree-fix-cst

(defthm cst-formal-parameter-list-conc-of-tree-fix-cst
  (equal (cst-formal-parameter-list-conc (abnf::tree-fix abnf::cst))
         (cst-formal-parameter-list-conc abnf::cst)))

Theorem: cst-formal-parameter-list-conc-tree-equiv-congruence-on-cst

(defthm cst-formal-parameter-list-conc-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-formal-parameter-list-conc abnf::cst)
                  (cst-formal-parameter-list-conc cst-equiv)))
  :rule-classes :congruence)

Function: cst-variable-arity-parameter-conc

(defun cst-variable-arity-parameter-conc (abnf::cst)
 (declare (xargs :guard (abnf::treep abnf::cst)))
 (declare
   (xargs :guard (cst-matchp abnf::cst "variable-arity-parameter")))
 (abnf::tree-nonleaf->branches abnf::cst))

Theorem: tree-list-listp-of-cst-variable-arity-parameter-conc

(defthm tree-list-listp-of-cst-variable-arity-parameter-conc
  (b* ((abnf::cstss (cst-variable-arity-parameter-conc abnf::cst)))
    (abnf::tree-list-listp abnf::cstss))
  :rule-classes :rewrite)

Theorem: cst-variable-arity-parameter-conc-match

(defthm cst-variable-arity-parameter-conc-match
 (implies
  (cst-matchp abnf::cst "variable-arity-parameter")
  (b* ((abnf::cstss (cst-variable-arity-parameter-conc abnf::cst)))
   (cst-list-list-conc-matchp
     abnf::cstss
     "*variable-modifier unann-type *annotation \"...\" identifier")))
 :rule-classes :rewrite)

Theorem: cst-variable-arity-parameter-conc-of-tree-fix-cst

(defthm cst-variable-arity-parameter-conc-of-tree-fix-cst
 (equal
      (cst-variable-arity-parameter-conc (abnf::tree-fix abnf::cst))
      (cst-variable-arity-parameter-conc abnf::cst)))

Theorem: cst-variable-arity-parameter-conc-tree-equiv-congruence-on-cst

(defthm
     cst-variable-arity-parameter-conc-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-variable-arity-parameter-conc abnf::cst)
                  (cst-variable-arity-parameter-conc cst-equiv)))
  :rule-classes :congruence)

Function: cst-throws-conc

(defun cst-throws-conc (abnf::cst)
  (declare (xargs :guard (abnf::treep abnf::cst)))
  (declare (xargs :guard (cst-matchp abnf::cst "throws")))
  (abnf::tree-nonleaf->branches abnf::cst))

Theorem: tree-list-listp-of-cst-throws-conc

(defthm tree-list-listp-of-cst-throws-conc
  (b* ((abnf::cstss (cst-throws-conc abnf::cst)))
    (abnf::tree-list-listp abnf::cstss))
  :rule-classes :rewrite)

Theorem: cst-throws-conc-match

(defthm cst-throws-conc-match
 (implies
    (cst-matchp abnf::cst "throws")
    (b* ((abnf::cstss (cst-throws-conc abnf::cst)))
      (cst-list-list-conc-matchp abnf::cstss
                                 "%s\"throws\" exception-type-list")))
 :rule-classes :rewrite)

Theorem: cst-throws-conc-of-tree-fix-cst

(defthm cst-throws-conc-of-tree-fix-cst
  (equal (cst-throws-conc (abnf::tree-fix abnf::cst))
         (cst-throws-conc abnf::cst)))

Theorem: cst-throws-conc-tree-equiv-congruence-on-cst

(defthm cst-throws-conc-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-throws-conc abnf::cst)
                  (cst-throws-conc cst-equiv)))
  :rule-classes :congruence)

Function: cst-exception-type-list-conc

(defun cst-exception-type-list-conc (abnf::cst)
  (declare (xargs :guard (abnf::treep abnf::cst)))
  (declare
       (xargs :guard (cst-matchp abnf::cst "exception-type-list")))
  (abnf::tree-nonleaf->branches abnf::cst))

Theorem: tree-list-listp-of-cst-exception-type-list-conc

(defthm tree-list-listp-of-cst-exception-type-list-conc
  (b* ((abnf::cstss (cst-exception-type-list-conc abnf::cst)))
    (abnf::tree-list-listp abnf::cstss))
  :rule-classes :rewrite)

Theorem: cst-exception-type-list-conc-match

(defthm cst-exception-type-list-conc-match
  (implies
       (cst-matchp abnf::cst "exception-type-list")
       (b* ((abnf::cstss (cst-exception-type-list-conc abnf::cst)))
         (cst-list-list-conc-matchp
              abnf::cstss
              "exception-type *( \",\" exception-type )")))
  :rule-classes :rewrite)

Theorem: cst-exception-type-list-conc-of-tree-fix-cst

(defthm cst-exception-type-list-conc-of-tree-fix-cst
  (equal (cst-exception-type-list-conc (abnf::tree-fix abnf::cst))
         (cst-exception-type-list-conc abnf::cst)))

Theorem: cst-exception-type-list-conc-tree-equiv-congruence-on-cst

(defthm cst-exception-type-list-conc-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-exception-type-list-conc abnf::cst)
                  (cst-exception-type-list-conc cst-equiv)))
  :rule-classes :congruence)

Function: cst-exception-type-conc1

(defun cst-exception-type-conc1 (abnf::cst)
 (declare (xargs :guard (abnf::treep abnf::cst)))
 (declare
      (xargs :guard (and (cst-matchp abnf::cst "exception-type")
                         (equal (cst-exception-type-conc? abnf::cst)
                                1))))
 (abnf::tree-nonleaf->branches abnf::cst))

Theorem: tree-list-listp-of-cst-exception-type-conc1

(defthm tree-list-listp-of-cst-exception-type-conc1
  (b* ((abnf::cstss (cst-exception-type-conc1 abnf::cst)))
    (abnf::tree-list-listp abnf::cstss))
  :rule-classes :rewrite)

Theorem: cst-exception-type-conc1-match

(defthm cst-exception-type-conc1-match
  (implies (and (cst-matchp abnf::cst "exception-type")
                (equal (cst-exception-type-conc? abnf::cst)
                       1))
           (b* ((abnf::cstss (cst-exception-type-conc1 abnf::cst)))
             (cst-list-list-conc-matchp abnf::cstss "class-type")))
  :rule-classes :rewrite)

Theorem: cst-exception-type-conc1-of-tree-fix-cst

(defthm cst-exception-type-conc1-of-tree-fix-cst
  (equal (cst-exception-type-conc1 (abnf::tree-fix abnf::cst))
         (cst-exception-type-conc1 abnf::cst)))

Theorem: cst-exception-type-conc1-tree-equiv-congruence-on-cst

(defthm cst-exception-type-conc1-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-exception-type-conc1 abnf::cst)
                  (cst-exception-type-conc1 cst-equiv)))
  :rule-classes :congruence)

Function: cst-exception-type-conc2

(defun cst-exception-type-conc2 (abnf::cst)
 (declare (xargs :guard (abnf::treep abnf::cst)))
 (declare
      (xargs :guard (and (cst-matchp abnf::cst "exception-type")
                         (equal (cst-exception-type-conc? abnf::cst)
                                2))))
 (abnf::tree-nonleaf->branches abnf::cst))

Theorem: tree-list-listp-of-cst-exception-type-conc2

(defthm tree-list-listp-of-cst-exception-type-conc2
  (b* ((abnf::cstss (cst-exception-type-conc2 abnf::cst)))
    (abnf::tree-list-listp abnf::cstss))
  :rule-classes :rewrite)

Theorem: cst-exception-type-conc2-match

(defthm cst-exception-type-conc2-match
  (implies
       (and (cst-matchp abnf::cst "exception-type")
            (equal (cst-exception-type-conc? abnf::cst)
                   2))
       (b* ((abnf::cstss (cst-exception-type-conc2 abnf::cst)))
         (cst-list-list-conc-matchp abnf::cstss "type-variable")))
  :rule-classes :rewrite)

Theorem: cst-exception-type-conc2-of-tree-fix-cst

(defthm cst-exception-type-conc2-of-tree-fix-cst
  (equal (cst-exception-type-conc2 (abnf::tree-fix abnf::cst))
         (cst-exception-type-conc2 abnf::cst)))

Theorem: cst-exception-type-conc2-tree-equiv-congruence-on-cst

(defthm cst-exception-type-conc2-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-exception-type-conc2 abnf::cst)
                  (cst-exception-type-conc2 cst-equiv)))
  :rule-classes :congruence)

Function: cst-instance-initializer-conc

(defun cst-instance-initializer-conc (abnf::cst)
  (declare (xargs :guard (abnf::treep abnf::cst)))
  (declare
       (xargs :guard (cst-matchp abnf::cst "instance-initializer")))
  (abnf::tree-nonleaf->branches abnf::cst))

Theorem: tree-list-listp-of-cst-instance-initializer-conc

(defthm tree-list-listp-of-cst-instance-initializer-conc
  (b* ((abnf::cstss (cst-instance-initializer-conc abnf::cst)))
    (abnf::tree-list-listp abnf::cstss))
  :rule-classes :rewrite)

Theorem: cst-instance-initializer-conc-match

(defthm cst-instance-initializer-conc-match
  (implies
       (cst-matchp abnf::cst "instance-initializer")
       (b* ((abnf::cstss (cst-instance-initializer-conc abnf::cst)))
         (cst-list-list-conc-matchp abnf::cstss "block")))
  :rule-classes :rewrite)

Theorem: cst-instance-initializer-conc-of-tree-fix-cst

(defthm cst-instance-initializer-conc-of-tree-fix-cst
  (equal (cst-instance-initializer-conc (abnf::tree-fix abnf::cst))
         (cst-instance-initializer-conc abnf::cst)))

Theorem: cst-instance-initializer-conc-tree-equiv-congruence-on-cst

(defthm cst-instance-initializer-conc-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-instance-initializer-conc abnf::cst)
                  (cst-instance-initializer-conc cst-equiv)))
  :rule-classes :congruence)

Function: cst-static-initializer-conc

(defun cst-static-initializer-conc (abnf::cst)
  (declare (xargs :guard (abnf::treep abnf::cst)))
  (declare
       (xargs :guard (cst-matchp abnf::cst "static-initializer")))
  (abnf::tree-nonleaf->branches abnf::cst))

Theorem: tree-list-listp-of-cst-static-initializer-conc

(defthm tree-list-listp-of-cst-static-initializer-conc
  (b* ((abnf::cstss (cst-static-initializer-conc abnf::cst)))
    (abnf::tree-list-listp abnf::cstss))
  :rule-classes :rewrite)

Theorem: cst-static-initializer-conc-match

(defthm cst-static-initializer-conc-match
 (implies
      (cst-matchp abnf::cst "static-initializer")
      (b* ((abnf::cstss (cst-static-initializer-conc abnf::cst)))
        (cst-list-list-conc-matchp abnf::cstss "%s\"static\" block")))
 :rule-classes :rewrite)

Theorem: cst-static-initializer-conc-of-tree-fix-cst

(defthm cst-static-initializer-conc-of-tree-fix-cst
  (equal (cst-static-initializer-conc (abnf::tree-fix abnf::cst))
         (cst-static-initializer-conc abnf::cst)))

Theorem: cst-static-initializer-conc-tree-equiv-congruence-on-cst

(defthm cst-static-initializer-conc-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-static-initializer-conc abnf::cst)
                  (cst-static-initializer-conc cst-equiv)))
  :rule-classes :congruence)

Function: cst-constructor-declaration-conc

(defun cst-constructor-declaration-conc (abnf::cst)
 (declare (xargs :guard (abnf::treep abnf::cst)))
 (declare
    (xargs :guard (cst-matchp abnf::cst "constructor-declaration")))
 (abnf::tree-nonleaf->branches abnf::cst))

Theorem: tree-list-listp-of-cst-constructor-declaration-conc

(defthm tree-list-listp-of-cst-constructor-declaration-conc
  (b* ((abnf::cstss (cst-constructor-declaration-conc abnf::cst)))
    (abnf::tree-list-listp abnf::cstss))
  :rule-classes :rewrite)

Theorem: cst-constructor-declaration-conc-match

(defthm cst-constructor-declaration-conc-match
 (implies
  (cst-matchp abnf::cst "constructor-declaration")
  (b* ((abnf::cstss (cst-constructor-declaration-conc abnf::cst)))
   (cst-list-list-conc-matchp
    abnf::cstss
    "*constructor-modifier constructor-declarator [ throws ] constructor-body")))
 :rule-classes :rewrite)

Theorem: cst-constructor-declaration-conc-of-tree-fix-cst

(defthm cst-constructor-declaration-conc-of-tree-fix-cst
  (equal
       (cst-constructor-declaration-conc (abnf::tree-fix abnf::cst))
       (cst-constructor-declaration-conc abnf::cst)))

Theorem: cst-constructor-declaration-conc-tree-equiv-congruence-on-cst

(defthm
      cst-constructor-declaration-conc-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-constructor-declaration-conc abnf::cst)
                  (cst-constructor-declaration-conc cst-equiv)))
  :rule-classes :congruence)

Function: cst-constructor-declarator-conc

(defun cst-constructor-declarator-conc (abnf::cst)
 (declare (xargs :guard (abnf::treep abnf::cst)))
 (declare
     (xargs :guard (cst-matchp abnf::cst "constructor-declarator")))
 (abnf::tree-nonleaf->branches abnf::cst))

Theorem: tree-list-listp-of-cst-constructor-declarator-conc

(defthm tree-list-listp-of-cst-constructor-declarator-conc
  (b* ((abnf::cstss (cst-constructor-declarator-conc abnf::cst)))
    (abnf::tree-list-listp abnf::cstss))
  :rule-classes :rewrite)

Theorem: cst-constructor-declarator-conc-match

(defthm cst-constructor-declarator-conc-match
 (implies
  (cst-matchp abnf::cst "constructor-declarator")
  (b* ((abnf::cstss (cst-constructor-declarator-conc abnf::cst)))
   (cst-list-list-conc-matchp
    abnf::cstss
    "[ type-parameters ] simple-type-name \"(\" [ receiver-parameter \",\" ] [ formal-parameter-list ] \")\"")))
 :rule-classes :rewrite)

Theorem: cst-constructor-declarator-conc-of-tree-fix-cst

(defthm cst-constructor-declarator-conc-of-tree-fix-cst
 (equal (cst-constructor-declarator-conc (abnf::tree-fix abnf::cst))
        (cst-constructor-declarator-conc abnf::cst)))

Theorem: cst-constructor-declarator-conc-tree-equiv-congruence-on-cst

(defthm cst-constructor-declarator-conc-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-constructor-declarator-conc abnf::cst)
                  (cst-constructor-declarator-conc cst-equiv)))
  :rule-classes :congruence)

Function: cst-simple-type-name-conc

(defun cst-simple-type-name-conc (abnf::cst)
  (declare (xargs :guard (abnf::treep abnf::cst)))
  (declare (xargs :guard (cst-matchp abnf::cst "simple-type-name")))
  (abnf::tree-nonleaf->branches abnf::cst))

Theorem: tree-list-listp-of-cst-simple-type-name-conc

(defthm tree-list-listp-of-cst-simple-type-name-conc
  (b* ((abnf::cstss (cst-simple-type-name-conc abnf::cst)))
    (abnf::tree-list-listp abnf::cstss))
  :rule-classes :rewrite)

Theorem: cst-simple-type-name-conc-match

(defthm cst-simple-type-name-conc-match
  (implies
       (cst-matchp abnf::cst "simple-type-name")
       (b* ((abnf::cstss (cst-simple-type-name-conc abnf::cst)))
         (cst-list-list-conc-matchp abnf::cstss "type-identifier")))
  :rule-classes :rewrite)

Theorem: cst-simple-type-name-conc-of-tree-fix-cst

(defthm cst-simple-type-name-conc-of-tree-fix-cst
  (equal (cst-simple-type-name-conc (abnf::tree-fix abnf::cst))
         (cst-simple-type-name-conc abnf::cst)))

Theorem: cst-simple-type-name-conc-tree-equiv-congruence-on-cst

(defthm cst-simple-type-name-conc-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-simple-type-name-conc abnf::cst)
                  (cst-simple-type-name-conc cst-equiv)))
  :rule-classes :congruence)

Function: cst-enum-declaration-conc

(defun cst-enum-declaration-conc (abnf::cst)
  (declare (xargs :guard (abnf::treep abnf::cst)))
  (declare (xargs :guard (cst-matchp abnf::cst "enum-declaration")))
  (abnf::tree-nonleaf->branches abnf::cst))

Theorem: tree-list-listp-of-cst-enum-declaration-conc

(defthm tree-list-listp-of-cst-enum-declaration-conc
  (b* ((abnf::cstss (cst-enum-declaration-conc abnf::cst)))
    (abnf::tree-list-listp abnf::cstss))
  :rule-classes :rewrite)

Theorem: cst-enum-declaration-conc-match

(defthm cst-enum-declaration-conc-match
 (implies
  (cst-matchp abnf::cst "enum-declaration")
  (b* ((abnf::cstss (cst-enum-declaration-conc abnf::cst)))
   (cst-list-list-conc-matchp
    abnf::cstss
    "*class-modifier %s\"enum\" type-identifier [ class-implements ] enum-body")))
 :rule-classes :rewrite)

Theorem: cst-enum-declaration-conc-of-tree-fix-cst

(defthm cst-enum-declaration-conc-of-tree-fix-cst
  (equal (cst-enum-declaration-conc (abnf::tree-fix abnf::cst))
         (cst-enum-declaration-conc abnf::cst)))

Theorem: cst-enum-declaration-conc-tree-equiv-congruence-on-cst

(defthm cst-enum-declaration-conc-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-enum-declaration-conc abnf::cst)
                  (cst-enum-declaration-conc cst-equiv)))
  :rule-classes :congruence)

Function: cst-enum-body-conc

(defun cst-enum-body-conc (abnf::cst)
  (declare (xargs :guard (abnf::treep abnf::cst)))
  (declare (xargs :guard (cst-matchp abnf::cst "enum-body")))
  (abnf::tree-nonleaf->branches abnf::cst))

Theorem: tree-list-listp-of-cst-enum-body-conc

(defthm tree-list-listp-of-cst-enum-body-conc
  (b* ((abnf::cstss (cst-enum-body-conc abnf::cst)))
    (abnf::tree-list-listp abnf::cstss))
  :rule-classes :rewrite)

Theorem: cst-enum-body-conc-match

(defthm cst-enum-body-conc-match
 (implies
  (cst-matchp abnf::cst "enum-body")
  (b* ((abnf::cstss (cst-enum-body-conc abnf::cst)))
   (cst-list-list-conc-matchp
    abnf::cstss
    "\"{\" [ enum-constant-list ] [ \",\" ] [ enum-body-declarations ] \"}\"")))
 :rule-classes :rewrite)

Theorem: cst-enum-body-conc-of-tree-fix-cst

(defthm cst-enum-body-conc-of-tree-fix-cst
  (equal (cst-enum-body-conc (abnf::tree-fix abnf::cst))
         (cst-enum-body-conc abnf::cst)))

Theorem: cst-enum-body-conc-tree-equiv-congruence-on-cst

(defthm cst-enum-body-conc-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-enum-body-conc abnf::cst)
                  (cst-enum-body-conc cst-equiv)))
  :rule-classes :congruence)

Function: cst-enum-constant-list-conc

(defun cst-enum-constant-list-conc (abnf::cst)
  (declare (xargs :guard (abnf::treep abnf::cst)))
  (declare
       (xargs :guard (cst-matchp abnf::cst "enum-constant-list")))
  (abnf::tree-nonleaf->branches abnf::cst))

Theorem: tree-list-listp-of-cst-enum-constant-list-conc

(defthm tree-list-listp-of-cst-enum-constant-list-conc
  (b* ((abnf::cstss (cst-enum-constant-list-conc abnf::cst)))
    (abnf::tree-list-listp abnf::cstss))
  :rule-classes :rewrite)

Theorem: cst-enum-constant-list-conc-match

(defthm cst-enum-constant-list-conc-match
  (implies
       (cst-matchp abnf::cst "enum-constant-list")
       (b* ((abnf::cstss (cst-enum-constant-list-conc abnf::cst)))
         (cst-list-list-conc-matchp
              abnf::cstss
              "enum-constant *( \",\" enum-constant )")))
  :rule-classes :rewrite)

Theorem: cst-enum-constant-list-conc-of-tree-fix-cst

(defthm cst-enum-constant-list-conc-of-tree-fix-cst
  (equal (cst-enum-constant-list-conc (abnf::tree-fix abnf::cst))
         (cst-enum-constant-list-conc abnf::cst)))

Theorem: cst-enum-constant-list-conc-tree-equiv-congruence-on-cst

(defthm cst-enum-constant-list-conc-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-enum-constant-list-conc abnf::cst)
                  (cst-enum-constant-list-conc cst-equiv)))
  :rule-classes :congruence)

Function: cst-enum-constant-conc

(defun cst-enum-constant-conc (abnf::cst)
  (declare (xargs :guard (abnf::treep abnf::cst)))
  (declare (xargs :guard (cst-matchp abnf::cst "enum-constant")))
  (abnf::tree-nonleaf->branches abnf::cst))

Theorem: tree-list-listp-of-cst-enum-constant-conc

(defthm tree-list-listp-of-cst-enum-constant-conc
  (b* ((abnf::cstss (cst-enum-constant-conc abnf::cst)))
    (abnf::tree-list-listp abnf::cstss))
  :rule-classes :rewrite)

Theorem: cst-enum-constant-conc-match

(defthm cst-enum-constant-conc-match
 (implies
  (cst-matchp abnf::cst "enum-constant")
  (b* ((abnf::cstss (cst-enum-constant-conc abnf::cst)))
   (cst-list-list-conc-matchp
    abnf::cstss
    "*enum-constant-modifier identifier [ \"(\" [ argument-list ] \")\" ] [ class-body ]")))
 :rule-classes :rewrite)

Theorem: cst-enum-constant-conc-of-tree-fix-cst

(defthm cst-enum-constant-conc-of-tree-fix-cst
  (equal (cst-enum-constant-conc (abnf::tree-fix abnf::cst))
         (cst-enum-constant-conc abnf::cst)))

Theorem: cst-enum-constant-conc-tree-equiv-congruence-on-cst

(defthm cst-enum-constant-conc-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-enum-constant-conc abnf::cst)
                  (cst-enum-constant-conc cst-equiv)))
  :rule-classes :congruence)

Function: cst-enum-constant-modifier-conc

(defun cst-enum-constant-modifier-conc (abnf::cst)
 (declare (xargs :guard (abnf::treep abnf::cst)))
 (declare
     (xargs :guard (cst-matchp abnf::cst "enum-constant-modifier")))
 (abnf::tree-nonleaf->branches abnf::cst))

Theorem: tree-list-listp-of-cst-enum-constant-modifier-conc

(defthm tree-list-listp-of-cst-enum-constant-modifier-conc
  (b* ((abnf::cstss (cst-enum-constant-modifier-conc abnf::cst)))
    (abnf::tree-list-listp abnf::cstss))
  :rule-classes :rewrite)

Theorem: cst-enum-constant-modifier-conc-match

(defthm cst-enum-constant-modifier-conc-match
 (implies
     (cst-matchp abnf::cst "enum-constant-modifier")
     (b* ((abnf::cstss (cst-enum-constant-modifier-conc abnf::cst)))
       (cst-list-list-conc-matchp abnf::cstss "annotation")))
 :rule-classes :rewrite)

Theorem: cst-enum-constant-modifier-conc-of-tree-fix-cst

(defthm cst-enum-constant-modifier-conc-of-tree-fix-cst
 (equal (cst-enum-constant-modifier-conc (abnf::tree-fix abnf::cst))
        (cst-enum-constant-modifier-conc abnf::cst)))

Theorem: cst-enum-constant-modifier-conc-tree-equiv-congruence-on-cst

(defthm cst-enum-constant-modifier-conc-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-enum-constant-modifier-conc abnf::cst)
                  (cst-enum-constant-modifier-conc cst-equiv)))
  :rule-classes :congruence)

Function: cst-enum-body-declarations-conc

(defun cst-enum-body-declarations-conc (abnf::cst)
 (declare (xargs :guard (abnf::treep abnf::cst)))
 (declare
     (xargs :guard (cst-matchp abnf::cst "enum-body-declarations")))
 (abnf::tree-nonleaf->branches abnf::cst))

Theorem: tree-list-listp-of-cst-enum-body-declarations-conc

(defthm tree-list-listp-of-cst-enum-body-declarations-conc
  (b* ((abnf::cstss (cst-enum-body-declarations-conc abnf::cst)))
    (abnf::tree-list-listp abnf::cstss))
  :rule-classes :rewrite)

Theorem: cst-enum-body-declarations-conc-match

(defthm cst-enum-body-declarations-conc-match
 (implies
     (cst-matchp abnf::cst "enum-body-declarations")
     (b* ((abnf::cstss (cst-enum-body-declarations-conc abnf::cst)))
       (cst-list-list-conc-matchp abnf::cstss
                                  "\";\" *class-body-declaration")))
 :rule-classes :rewrite)

Theorem: cst-enum-body-declarations-conc-of-tree-fix-cst

(defthm cst-enum-body-declarations-conc-of-tree-fix-cst
 (equal (cst-enum-body-declarations-conc (abnf::tree-fix abnf::cst))
        (cst-enum-body-declarations-conc abnf::cst)))

Theorem: cst-enum-body-declarations-conc-tree-equiv-congruence-on-cst

(defthm cst-enum-body-declarations-conc-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-enum-body-declarations-conc abnf::cst)
                  (cst-enum-body-declarations-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")))
  (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
    "*class-modifier %s\"record\" type-identifier [ type-parameters ] record-header [ class-implements ] record-body")))
 :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-record-header-conc

(defun cst-record-header-conc (abnf::cst)
  (declare (xargs :guard (abnf::treep abnf::cst)))
  (declare (xargs :guard (cst-matchp abnf::cst "record-header")))
  (abnf::tree-nonleaf->branches abnf::cst))

Theorem: tree-list-listp-of-cst-record-header-conc

(defthm tree-list-listp-of-cst-record-header-conc
  (b* ((abnf::cstss (cst-record-header-conc abnf::cst)))
    (abnf::tree-list-listp abnf::cstss))
  :rule-classes :rewrite)

Theorem: cst-record-header-conc-match

(defthm cst-record-header-conc-match
 (implies
     (cst-matchp abnf::cst "record-header")
     (b* ((abnf::cstss (cst-record-header-conc abnf::cst)))
       (cst-list-list-conc-matchp abnf::cstss
                                  "\"(\" record-component-list \")\"")))
 :rule-classes :rewrite)

Theorem: cst-record-header-conc-of-tree-fix-cst

(defthm cst-record-header-conc-of-tree-fix-cst
  (equal (cst-record-header-conc (abnf::tree-fix abnf::cst))
         (cst-record-header-conc abnf::cst)))

Theorem: cst-record-header-conc-tree-equiv-congruence-on-cst

(defthm cst-record-header-conc-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-record-header-conc abnf::cst)
                  (cst-record-header-conc cst-equiv)))
  :rule-classes :congruence)

Function: cst-record-component-list-conc

(defun cst-record-component-list-conc (abnf::cst)
 (declare (xargs :guard (abnf::treep abnf::cst)))
 (declare
      (xargs :guard (cst-matchp abnf::cst "record-component-list")))
 (abnf::tree-nonleaf->branches abnf::cst))

Theorem: tree-list-listp-of-cst-record-component-list-conc

(defthm tree-list-listp-of-cst-record-component-list-conc
  (b* ((abnf::cstss (cst-record-component-list-conc abnf::cst)))
    (abnf::tree-list-listp abnf::cstss))
  :rule-classes :rewrite)

Theorem: cst-record-component-list-conc-match

(defthm cst-record-component-list-conc-match
 (implies
      (cst-matchp abnf::cst "record-component-list")
      (b* ((abnf::cstss (cst-record-component-list-conc abnf::cst)))
        (cst-list-list-conc-matchp
             abnf::cstss
             "record-component *( \",\" record-component )")))
 :rule-classes :rewrite)

Theorem: cst-record-component-list-conc-of-tree-fix-cst

(defthm cst-record-component-list-conc-of-tree-fix-cst
  (equal (cst-record-component-list-conc (abnf::tree-fix abnf::cst))
         (cst-record-component-list-conc abnf::cst)))

Theorem: cst-record-component-list-conc-tree-equiv-congruence-on-cst

(defthm cst-record-component-list-conc-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-record-component-list-conc abnf::cst)
                  (cst-record-component-list-conc cst-equiv)))
  :rule-classes :congruence)

Function: cst-variable-arity-record-component-conc

(defun cst-variable-arity-record-component-conc (abnf::cst)
 (declare (xargs :guard (abnf::treep abnf::cst)))
 (declare
      (xargs :guard (cst-matchp abnf::cst
                                "variable-arity-record-component")))
 (abnf::tree-nonleaf->branches abnf::cst))

Theorem: tree-list-listp-of-cst-variable-arity-record-component-conc

(defthm tree-list-listp-of-cst-variable-arity-record-component-conc
  (b* ((abnf::cstss
            (cst-variable-arity-record-component-conc abnf::cst)))
    (abnf::tree-list-listp abnf::cstss))
  :rule-classes :rewrite)

Theorem: cst-variable-arity-record-component-conc-match

(defthm cst-variable-arity-record-component-conc-match
 (implies
  (cst-matchp abnf::cst
              "variable-arity-record-component")
  (b* ((abnf::cstss
            (cst-variable-arity-record-component-conc abnf::cst)))
   (cst-list-list-conc-matchp
    abnf::cstss
    "*record-component-modifier unann-type *annotation \"...\" identifier")))
 :rule-classes :rewrite)

Theorem: cst-variable-arity-record-component-conc-of-tree-fix-cst

(defthm cst-variable-arity-record-component-conc-of-tree-fix-cst
  (equal (cst-variable-arity-record-component-conc
              (abnf::tree-fix abnf::cst))
         (cst-variable-arity-record-component-conc abnf::cst)))

Theorem: cst-variable-arity-record-component-conc-tree-equiv-congruence-on-cst

(defthm
 cst-variable-arity-record-component-conc-tree-equiv-congruence-on-cst
 (implies
      (abnf::tree-equiv abnf::cst cst-equiv)
      (equal (cst-variable-arity-record-component-conc abnf::cst)
             (cst-variable-arity-record-component-conc cst-equiv)))
 :rule-classes :congruence)

Function: cst-record-component-modifier-conc

(defun cst-record-component-modifier-conc (abnf::cst)
 (declare (xargs :guard (abnf::treep abnf::cst)))
 (declare
  (xargs :guard (cst-matchp abnf::cst "record-component-modifier")))
 (abnf::tree-nonleaf->branches abnf::cst))

Theorem: tree-list-listp-of-cst-record-component-modifier-conc

(defthm tree-list-listp-of-cst-record-component-modifier-conc
  (b* ((abnf::cstss (cst-record-component-modifier-conc abnf::cst)))
    (abnf::tree-list-listp abnf::cstss))
  :rule-classes :rewrite)

Theorem: cst-record-component-modifier-conc-match

(defthm cst-record-component-modifier-conc-match
 (implies
  (cst-matchp abnf::cst "record-component-modifier")
  (b* ((abnf::cstss (cst-record-component-modifier-conc abnf::cst)))
    (cst-list-list-conc-matchp abnf::cstss "annotation")))
 :rule-classes :rewrite)

Theorem: cst-record-component-modifier-conc-of-tree-fix-cst

(defthm cst-record-component-modifier-conc-of-tree-fix-cst
 (equal
     (cst-record-component-modifier-conc (abnf::tree-fix abnf::cst))
     (cst-record-component-modifier-conc abnf::cst)))

Theorem: cst-record-component-modifier-conc-tree-equiv-congruence-on-cst

(defthm
    cst-record-component-modifier-conc-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-record-component-modifier-conc abnf::cst)
                  (cst-record-component-modifier-conc cst-equiv)))
  :rule-classes :congruence)

Function: cst-record-body-conc

(defun cst-record-body-conc (abnf::cst)
  (declare (xargs :guard (abnf::treep abnf::cst)))
  (declare (xargs :guard (cst-matchp abnf::cst "record-body")))
  (abnf::tree-nonleaf->branches abnf::cst))

Theorem: tree-list-listp-of-cst-record-body-conc

(defthm tree-list-listp-of-cst-record-body-conc
  (b* ((abnf::cstss (cst-record-body-conc abnf::cst)))
    (abnf::tree-list-listp abnf::cstss))
  :rule-classes :rewrite)

Theorem: cst-record-body-conc-match

(defthm cst-record-body-conc-match
 (implies
  (cst-matchp abnf::cst "record-body")
  (b* ((abnf::cstss (cst-record-body-conc abnf::cst)))
    (cst-list-list-conc-matchp abnf::cstss
                               "\"{\" *record-body-declaration \"}\"")))
 :rule-classes :rewrite)

Theorem: cst-record-body-conc-of-tree-fix-cst

(defthm cst-record-body-conc-of-tree-fix-cst
  (equal (cst-record-body-conc (abnf::tree-fix abnf::cst))
         (cst-record-body-conc abnf::cst)))

Theorem: cst-record-body-conc-tree-equiv-congruence-on-cst

(defthm cst-record-body-conc-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-record-body-conc abnf::cst)
                  (cst-record-body-conc cst-equiv)))
  :rule-classes :congruence)

Function: cst-record-body-declaration-conc1

(defun cst-record-body-declaration-conc1 (abnf::cst)
 (declare (xargs :guard (abnf::treep abnf::cst)))
 (declare
  (xargs
    :guard (and (cst-matchp abnf::cst "record-body-declaration")
                (equal (cst-record-body-declaration-conc? abnf::cst)
                       1))))
 (abnf::tree-nonleaf->branches abnf::cst))

Theorem: tree-list-listp-of-cst-record-body-declaration-conc1

(defthm tree-list-listp-of-cst-record-body-declaration-conc1
  (b* ((abnf::cstss (cst-record-body-declaration-conc1 abnf::cst)))
    (abnf::tree-list-listp abnf::cstss))
  :rule-classes :rewrite)

Theorem: cst-record-body-declaration-conc1-match

(defthm cst-record-body-declaration-conc1-match
 (implies
   (and (cst-matchp abnf::cst "record-body-declaration")
        (equal (cst-record-body-declaration-conc? abnf::cst)
               1))
   (b* ((abnf::cstss (cst-record-body-declaration-conc1 abnf::cst)))
     (cst-list-list-conc-matchp
          abnf::cstss "class-body-declaration")))
 :rule-classes :rewrite)

Theorem: cst-record-body-declaration-conc1-of-tree-fix-cst

(defthm cst-record-body-declaration-conc1-of-tree-fix-cst
 (equal
      (cst-record-body-declaration-conc1 (abnf::tree-fix abnf::cst))
      (cst-record-body-declaration-conc1 abnf::cst)))

Theorem: cst-record-body-declaration-conc1-tree-equiv-congruence-on-cst

(defthm
     cst-record-body-declaration-conc1-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-record-body-declaration-conc1 abnf::cst)
                  (cst-record-body-declaration-conc1 cst-equiv)))
  :rule-classes :congruence)

Function: cst-record-body-declaration-conc2

(defun cst-record-body-declaration-conc2 (abnf::cst)
 (declare (xargs :guard (abnf::treep abnf::cst)))
 (declare
  (xargs
    :guard (and (cst-matchp abnf::cst "record-body-declaration")
                (equal (cst-record-body-declaration-conc? abnf::cst)
                       2))))
 (abnf::tree-nonleaf->branches abnf::cst))

Theorem: tree-list-listp-of-cst-record-body-declaration-conc2

(defthm tree-list-listp-of-cst-record-body-declaration-conc2
  (b* ((abnf::cstss (cst-record-body-declaration-conc2 abnf::cst)))
    (abnf::tree-list-listp abnf::cstss))
  :rule-classes :rewrite)

Theorem: cst-record-body-declaration-conc2-match

(defthm cst-record-body-declaration-conc2-match
 (implies
   (and (cst-matchp abnf::cst "record-body-declaration")
        (equal (cst-record-body-declaration-conc? abnf::cst)
               2))
   (b* ((abnf::cstss (cst-record-body-declaration-conc2 abnf::cst)))
     (cst-list-list-conc-matchp abnf::cstss
                                "compact-constructor-declaration")))
 :rule-classes :rewrite)

Theorem: cst-record-body-declaration-conc2-of-tree-fix-cst

(defthm cst-record-body-declaration-conc2-of-tree-fix-cst
 (equal
      (cst-record-body-declaration-conc2 (abnf::tree-fix abnf::cst))
      (cst-record-body-declaration-conc2 abnf::cst)))

Theorem: cst-record-body-declaration-conc2-tree-equiv-congruence-on-cst

(defthm
     cst-record-body-declaration-conc2-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-record-body-declaration-conc2 abnf::cst)
                  (cst-record-body-declaration-conc2 cst-equiv)))
  :rule-classes :congruence)

Function: cst-compact-constructor-declaration-conc

(defun cst-compact-constructor-declaration-conc (abnf::cst)
 (declare (xargs :guard (abnf::treep abnf::cst)))
 (declare
      (xargs :guard (cst-matchp abnf::cst
                                "compact-constructor-declaration")))
 (abnf::tree-nonleaf->branches abnf::cst))

Theorem: tree-list-listp-of-cst-compact-constructor-declaration-conc

(defthm tree-list-listp-of-cst-compact-constructor-declaration-conc
  (b* ((abnf::cstss
            (cst-compact-constructor-declaration-conc abnf::cst)))
    (abnf::tree-list-listp abnf::cstss))
  :rule-classes :rewrite)

Theorem: cst-compact-constructor-declaration-conc-match

(defthm cst-compact-constructor-declaration-conc-match
 (implies
  (cst-matchp abnf::cst
              "compact-constructor-declaration")
  (b* ((abnf::cstss
            (cst-compact-constructor-declaration-conc abnf::cst)))
   (cst-list-list-conc-matchp
        abnf::cstss
        "*constructor-modifier simple-type-name constructor-body")))
 :rule-classes :rewrite)

Theorem: cst-compact-constructor-declaration-conc-of-tree-fix-cst

(defthm cst-compact-constructor-declaration-conc-of-tree-fix-cst
  (equal (cst-compact-constructor-declaration-conc
              (abnf::tree-fix abnf::cst))
         (cst-compact-constructor-declaration-conc abnf::cst)))

Theorem: cst-compact-constructor-declaration-conc-tree-equiv-congruence-on-cst

(defthm
 cst-compact-constructor-declaration-conc-tree-equiv-congruence-on-cst
 (implies
      (abnf::tree-equiv abnf::cst cst-equiv)
      (equal (cst-compact-constructor-declaration-conc abnf::cst)
             (cst-compact-constructor-declaration-conc cst-equiv)))
 :rule-classes :congruence)

Function: cst-interface-declaration-conc1

(defun cst-interface-declaration-conc1 (abnf::cst)
 (declare (xargs :guard (abnf::treep abnf::cst)))
 (declare
  (xargs
      :guard (and (cst-matchp abnf::cst "interface-declaration")
                  (equal (cst-interface-declaration-conc? abnf::cst)
                         1))))
 (abnf::tree-nonleaf->branches abnf::cst))

Theorem: tree-list-listp-of-cst-interface-declaration-conc1

(defthm tree-list-listp-of-cst-interface-declaration-conc1
  (b* ((abnf::cstss (cst-interface-declaration-conc1 abnf::cst)))
    (abnf::tree-list-listp abnf::cstss))
  :rule-classes :rewrite)

Theorem: cst-interface-declaration-conc1-match

(defthm cst-interface-declaration-conc1-match
 (implies
     (and (cst-matchp abnf::cst "interface-declaration")
          (equal (cst-interface-declaration-conc? abnf::cst)
                 1))
     (b* ((abnf::cstss (cst-interface-declaration-conc1 abnf::cst)))
       (cst-list-list-conc-matchp abnf::cstss
                                  "normal-interface-declaration")))
 :rule-classes :rewrite)

Theorem: cst-interface-declaration-conc1-of-tree-fix-cst

(defthm cst-interface-declaration-conc1-of-tree-fix-cst
 (equal (cst-interface-declaration-conc1 (abnf::tree-fix abnf::cst))
        (cst-interface-declaration-conc1 abnf::cst)))

Theorem: cst-interface-declaration-conc1-tree-equiv-congruence-on-cst

(defthm cst-interface-declaration-conc1-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-interface-declaration-conc1 abnf::cst)
                  (cst-interface-declaration-conc1 cst-equiv)))
  :rule-classes :congruence)

Function: cst-interface-declaration-conc2

(defun cst-interface-declaration-conc2 (abnf::cst)
 (declare (xargs :guard (abnf::treep abnf::cst)))
 (declare
  (xargs
      :guard (and (cst-matchp abnf::cst "interface-declaration")
                  (equal (cst-interface-declaration-conc? abnf::cst)
                         2))))
 (abnf::tree-nonleaf->branches abnf::cst))

Theorem: tree-list-listp-of-cst-interface-declaration-conc2

(defthm tree-list-listp-of-cst-interface-declaration-conc2
  (b* ((abnf::cstss (cst-interface-declaration-conc2 abnf::cst)))
    (abnf::tree-list-listp abnf::cstss))
  :rule-classes :rewrite)

Theorem: cst-interface-declaration-conc2-match

(defthm cst-interface-declaration-conc2-match
 (implies
  (and (cst-matchp abnf::cst "interface-declaration")
       (equal (cst-interface-declaration-conc? abnf::cst)
              2))
  (b* ((abnf::cstss (cst-interface-declaration-conc2 abnf::cst)))
    (cst-list-list-conc-matchp abnf::cstss
                               "annotation-interface-declaration")))
 :rule-classes :rewrite)

Theorem: cst-interface-declaration-conc2-of-tree-fix-cst

(defthm cst-interface-declaration-conc2-of-tree-fix-cst
 (equal (cst-interface-declaration-conc2 (abnf::tree-fix abnf::cst))
        (cst-interface-declaration-conc2 abnf::cst)))

Theorem: cst-interface-declaration-conc2-tree-equiv-congruence-on-cst

(defthm cst-interface-declaration-conc2-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-interface-declaration-conc2 abnf::cst)
                  (cst-interface-declaration-conc2 cst-equiv)))
  :rule-classes :congruence)

Function: cst-normal-interface-declaration-conc

(defun cst-normal-interface-declaration-conc (abnf::cst)
  (declare (xargs :guard (abnf::treep abnf::cst)))
  (declare
       (xargs :guard (cst-matchp abnf::cst
                                 "normal-interface-declaration")))
  (abnf::tree-nonleaf->branches abnf::cst))

Theorem: tree-list-listp-of-cst-normal-interface-declaration-conc

(defthm tree-list-listp-of-cst-normal-interface-declaration-conc
  (b*
   ((abnf::cstss (cst-normal-interface-declaration-conc abnf::cst)))
   (abnf::tree-list-listp abnf::cstss))
  :rule-classes :rewrite)

Theorem: cst-normal-interface-declaration-conc-match

(defthm cst-normal-interface-declaration-conc-match
 (implies
  (cst-matchp abnf::cst
              "normal-interface-declaration")
  (b*
   ((abnf::cstss (cst-normal-interface-declaration-conc abnf::cst)))
   (cst-list-list-conc-matchp
    abnf::cstss
    "*interface-modifier %s\"interface\" type-identifier [ type-parameters ] [ interface-extends ] [ interface-permits ] interface-body")))
 :rule-classes :rewrite)

Theorem: cst-normal-interface-declaration-conc-of-tree-fix-cst

(defthm cst-normal-interface-declaration-conc-of-tree-fix-cst
 (equal
  (cst-normal-interface-declaration-conc (abnf::tree-fix abnf::cst))
  (cst-normal-interface-declaration-conc abnf::cst)))

Theorem: cst-normal-interface-declaration-conc-tree-equiv-congruence-on-cst

(defthm
 cst-normal-interface-declaration-conc-tree-equiv-congruence-on-cst
 (implies (abnf::tree-equiv abnf::cst cst-equiv)
          (equal (cst-normal-interface-declaration-conc abnf::cst)
                 (cst-normal-interface-declaration-conc cst-equiv)))
 :rule-classes :congruence)

Function: cst-interface-extends-conc

(defun cst-interface-extends-conc (abnf::cst)
 (declare (xargs :guard (abnf::treep abnf::cst)))
 (declare (xargs :guard (cst-matchp abnf::cst "interface-extends")))
 (abnf::tree-nonleaf->branches abnf::cst))

Theorem: tree-list-listp-of-cst-interface-extends-conc

(defthm tree-list-listp-of-cst-interface-extends-conc
  (b* ((abnf::cstss (cst-interface-extends-conc abnf::cst)))
    (abnf::tree-list-listp abnf::cstss))
  :rule-classes :rewrite)

Theorem: cst-interface-extends-conc-match

(defthm cst-interface-extends-conc-match
 (implies
   (cst-matchp abnf::cst "interface-extends")
   (b* ((abnf::cstss (cst-interface-extends-conc abnf::cst)))
     (cst-list-list-conc-matchp abnf::cstss
                                "%s\"extends\" interface-type-list")))
 :rule-classes :rewrite)

Theorem: cst-interface-extends-conc-of-tree-fix-cst

(defthm cst-interface-extends-conc-of-tree-fix-cst
  (equal (cst-interface-extends-conc (abnf::tree-fix abnf::cst))
         (cst-interface-extends-conc abnf::cst)))

Theorem: cst-interface-extends-conc-tree-equiv-congruence-on-cst

(defthm cst-interface-extends-conc-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-interface-extends-conc abnf::cst)
                  (cst-interface-extends-conc cst-equiv)))
  :rule-classes :congruence)

Function: cst-interface-permits-conc

(defun cst-interface-permits-conc (abnf::cst)
 (declare (xargs :guard (abnf::treep abnf::cst)))
 (declare (xargs :guard (cst-matchp abnf::cst "interface-permits")))
 (abnf::tree-nonleaf->branches abnf::cst))

Theorem: tree-list-listp-of-cst-interface-permits-conc

(defthm tree-list-listp-of-cst-interface-permits-conc
  (b* ((abnf::cstss (cst-interface-permits-conc abnf::cst)))
    (abnf::tree-list-listp abnf::cstss))
  :rule-classes :rewrite)

Theorem: cst-interface-permits-conc-match

(defthm cst-interface-permits-conc-match
 (implies (cst-matchp abnf::cst "interface-permits")
          (b* ((abnf::cstss (cst-interface-permits-conc abnf::cst)))
            (cst-list-list-conc-matchp
                 abnf::cstss
                 "%s\"permits\" type-name *( \",\" type-name )")))
 :rule-classes :rewrite)

Theorem: cst-interface-permits-conc-of-tree-fix-cst

(defthm cst-interface-permits-conc-of-tree-fix-cst
  (equal (cst-interface-permits-conc (abnf::tree-fix abnf::cst))
         (cst-interface-permits-conc abnf::cst)))

Theorem: cst-interface-permits-conc-tree-equiv-congruence-on-cst

(defthm cst-interface-permits-conc-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-interface-permits-conc abnf::cst)
                  (cst-interface-permits-conc cst-equiv)))
  :rule-classes :congruence)

Function: cst-interface-body-conc

(defun cst-interface-body-conc (abnf::cst)
  (declare (xargs :guard (abnf::treep abnf::cst)))
  (declare (xargs :guard (cst-matchp abnf::cst "interface-body")))
  (abnf::tree-nonleaf->branches abnf::cst))

Theorem: tree-list-listp-of-cst-interface-body-conc

(defthm tree-list-listp-of-cst-interface-body-conc
  (b* ((abnf::cstss (cst-interface-body-conc abnf::cst)))
    (abnf::tree-list-listp abnf::cstss))
  :rule-classes :rewrite)

Theorem: cst-interface-body-conc-match

(defthm cst-interface-body-conc-match
  (implies (cst-matchp abnf::cst "interface-body")
           (b* ((abnf::cstss (cst-interface-body-conc abnf::cst)))
             (cst-list-list-conc-matchp
                  abnf::cstss
                  "\"{\" *interface-member-declaration \"}\"")))
  :rule-classes :rewrite)

Theorem: cst-interface-body-conc-of-tree-fix-cst

(defthm cst-interface-body-conc-of-tree-fix-cst
  (equal (cst-interface-body-conc (abnf::tree-fix abnf::cst))
         (cst-interface-body-conc abnf::cst)))

Theorem: cst-interface-body-conc-tree-equiv-congruence-on-cst

(defthm cst-interface-body-conc-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-interface-body-conc abnf::cst)
                  (cst-interface-body-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")))
  (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
     "*constant-modifier unann-type variable-declarator-list \";\"")))
 :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-interface-method-declaration-conc

(defun cst-interface-method-declaration-conc (abnf::cst)
  (declare (xargs :guard (abnf::treep abnf::cst)))
  (declare
       (xargs :guard (cst-matchp abnf::cst
                                 "interface-method-declaration")))
  (abnf::tree-nonleaf->branches abnf::cst))

Theorem: tree-list-listp-of-cst-interface-method-declaration-conc

(defthm tree-list-listp-of-cst-interface-method-declaration-conc
  (b*
   ((abnf::cstss (cst-interface-method-declaration-conc abnf::cst)))
   (abnf::tree-list-listp abnf::cstss))
  :rule-classes :rewrite)

Theorem: cst-interface-method-declaration-conc-match

(defthm cst-interface-method-declaration-conc-match
 (implies
  (cst-matchp abnf::cst
              "interface-method-declaration")
  (b*
   ((abnf::cstss (cst-interface-method-declaration-conc abnf::cst)))
   (cst-list-list-conc-matchp
        abnf::cstss
        "*interface-method-modifier method-header method-body")))
 :rule-classes :rewrite)

Theorem: cst-interface-method-declaration-conc-of-tree-fix-cst

(defthm cst-interface-method-declaration-conc-of-tree-fix-cst
 (equal
  (cst-interface-method-declaration-conc (abnf::tree-fix abnf::cst))
  (cst-interface-method-declaration-conc abnf::cst)))

Theorem: cst-interface-method-declaration-conc-tree-equiv-congruence-on-cst

(defthm
 cst-interface-method-declaration-conc-tree-equiv-congruence-on-cst
 (implies (abnf::tree-equiv abnf::cst cst-equiv)
          (equal (cst-interface-method-declaration-conc abnf::cst)
                 (cst-interface-method-declaration-conc cst-equiv)))
 :rule-classes :congruence)

Function: cst-annotation-interface-declaration-conc

(defun cst-annotation-interface-declaration-conc (abnf::cst)
 (declare (xargs :guard (abnf::treep abnf::cst)))
 (declare
     (xargs :guard (cst-matchp abnf::cst
                               "annotation-interface-declaration")))
 (abnf::tree-nonleaf->branches abnf::cst))

Theorem: tree-list-listp-of-cst-annotation-interface-declaration-conc

(defthm tree-list-listp-of-cst-annotation-interface-declaration-conc
  (b* ((abnf::cstss
            (cst-annotation-interface-declaration-conc abnf::cst)))
    (abnf::tree-list-listp abnf::cstss))
  :rule-classes :rewrite)

Theorem: cst-annotation-interface-declaration-conc-match

(defthm cst-annotation-interface-declaration-conc-match
 (implies
  (cst-matchp abnf::cst
              "annotation-interface-declaration")
  (b* ((abnf::cstss
            (cst-annotation-interface-declaration-conc abnf::cst)))
   (cst-list-list-conc-matchp
    abnf::cstss
    "*interface-modifier \"@\" %s\"interface\" type-identifier annotation-interface-body")))
 :rule-classes :rewrite)

Theorem: cst-annotation-interface-declaration-conc-of-tree-fix-cst

(defthm cst-annotation-interface-declaration-conc-of-tree-fix-cst
  (equal (cst-annotation-interface-declaration-conc
              (abnf::tree-fix abnf::cst))
         (cst-annotation-interface-declaration-conc abnf::cst)))

Theorem: cst-annotation-interface-declaration-conc-tree-equiv-congruence-on-cst

(defthm
 cst-annotation-interface-declaration-conc-tree-equiv-congruence-on-cst
 (implies
      (abnf::tree-equiv abnf::cst cst-equiv)
      (equal (cst-annotation-interface-declaration-conc abnf::cst)
             (cst-annotation-interface-declaration-conc cst-equiv)))
 :rule-classes :congruence)

Function: cst-annotation-interface-body-conc

(defun cst-annotation-interface-body-conc (abnf::cst)
 (declare (xargs :guard (abnf::treep abnf::cst)))
 (declare
  (xargs :guard (cst-matchp abnf::cst "annotation-interface-body")))
 (abnf::tree-nonleaf->branches abnf::cst))

Theorem: tree-list-listp-of-cst-annotation-interface-body-conc

(defthm tree-list-listp-of-cst-annotation-interface-body-conc
  (b* ((abnf::cstss (cst-annotation-interface-body-conc abnf::cst)))
    (abnf::tree-list-listp abnf::cstss))
  :rule-classes :rewrite)

Theorem: cst-annotation-interface-body-conc-match

(defthm cst-annotation-interface-body-conc-match
 (implies
  (cst-matchp abnf::cst "annotation-interface-body")
  (b* ((abnf::cstss (cst-annotation-interface-body-conc abnf::cst)))
    (cst-list-list-conc-matchp
         abnf::cstss
         "\"{\" *annotation-interface-member-declaration \"}\"")))
 :rule-classes :rewrite)

Theorem: cst-annotation-interface-body-conc-of-tree-fix-cst

(defthm cst-annotation-interface-body-conc-of-tree-fix-cst
 (equal
     (cst-annotation-interface-body-conc (abnf::tree-fix abnf::cst))
     (cst-annotation-interface-body-conc abnf::cst)))

Theorem: cst-annotation-interface-body-conc-tree-equiv-congruence-on-cst

(defthm
    cst-annotation-interface-body-conc-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-annotation-interface-body-conc abnf::cst)
                  (cst-annotation-interface-body-conc cst-equiv)))
  :rule-classes :congruence)

Function: cst-annotation-interface-element-declaration-conc

(defun cst-annotation-interface-element-declaration-conc (abnf::cst)
 (declare (xargs :guard (abnf::treep abnf::cst)))
 (declare
  (xargs
    :guard (cst-matchp abnf::cst
                       "annotation-interface-element-declaration")))
 (abnf::tree-nonleaf->branches abnf::cst))

Theorem: tree-list-listp-of-cst-annotation-interface-element-declaration-conc

(defthm
 tree-list-listp-of-cst-annotation-interface-element-declaration-conc
 (b*
  ((abnf::cstss
     (cst-annotation-interface-element-declaration-conc abnf::cst)))
  (abnf::tree-list-listp abnf::cstss))
 :rule-classes :rewrite)

Theorem: cst-annotation-interface-element-declaration-conc-match

(defthm cst-annotation-interface-element-declaration-conc-match
 (implies
  (cst-matchp abnf::cst
              "annotation-interface-element-declaration")
  (b*
   ((abnf::cstss
     (cst-annotation-interface-element-declaration-conc abnf::cst)))
   (cst-list-list-conc-matchp
    abnf::cstss
    "*annotation-interface-element-modifier unann-type identifier \"(\" \")\" [ dims ] [ default-value ] \";\"")))
 :rule-classes :rewrite)

Theorem: cst-annotation-interface-element-declaration-conc-of-tree-fix-cst

(defthm
  cst-annotation-interface-element-declaration-conc-of-tree-fix-cst
 (equal
     (cst-annotation-interface-element-declaration-conc
          (abnf::tree-fix abnf::cst))
     (cst-annotation-interface-element-declaration-conc abnf::cst)))

Theorem: cst-annotation-interface-element-declaration-conc-tree-equiv-congruence-on-cst

(defthm
 cst-annotation-interface-element-declaration-conc-tree-equiv-congruence-on-cst
 (implies
  (abnf::tree-equiv abnf::cst cst-equiv)
  (equal
     (cst-annotation-interface-element-declaration-conc abnf::cst)
     (cst-annotation-interface-element-declaration-conc cst-equiv)))
 :rule-classes :congruence)

Function: cst-default-value-conc

(defun cst-default-value-conc (abnf::cst)
  (declare (xargs :guard (abnf::treep abnf::cst)))
  (declare (xargs :guard (cst-matchp abnf::cst "default-value")))
  (abnf::tree-nonleaf->branches abnf::cst))

Theorem: tree-list-listp-of-cst-default-value-conc

(defthm tree-list-listp-of-cst-default-value-conc
  (b* ((abnf::cstss (cst-default-value-conc abnf::cst)))
    (abnf::tree-list-listp abnf::cstss))
  :rule-classes :rewrite)

Theorem: cst-default-value-conc-match

(defthm cst-default-value-conc-match
  (implies
       (cst-matchp abnf::cst "default-value")
       (b* ((abnf::cstss (cst-default-value-conc abnf::cst)))
         (cst-list-list-conc-matchp abnf::cstss
                                    "%s\"default\" element-value")))
  :rule-classes :rewrite)

Theorem: cst-default-value-conc-of-tree-fix-cst

(defthm cst-default-value-conc-of-tree-fix-cst
  (equal (cst-default-value-conc (abnf::tree-fix abnf::cst))
         (cst-default-value-conc abnf::cst)))

Theorem: cst-default-value-conc-tree-equiv-congruence-on-cst

(defthm cst-default-value-conc-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-default-value-conc abnf::cst)
                  (cst-default-value-conc cst-equiv)))
  :rule-classes :congruence)

Function: cst-annotation-conc1

(defun cst-annotation-conc1 (abnf::cst)
 (declare (xargs :guard (abnf::treep abnf::cst)))
 (declare (xargs :guard (and (cst-matchp abnf::cst "annotation")
                             (equal (cst-annotation-conc? abnf::cst)
                                    1))))
 (abnf::tree-nonleaf->branches abnf::cst))

Theorem: tree-list-listp-of-cst-annotation-conc1

(defthm tree-list-listp-of-cst-annotation-conc1
  (b* ((abnf::cstss (cst-annotation-conc1 abnf::cst)))
    (abnf::tree-list-listp abnf::cstss))
  :rule-classes :rewrite)

Theorem: cst-annotation-conc1-match

(defthm cst-annotation-conc1-match
 (implies
     (and (cst-matchp abnf::cst "annotation")
          (equal (cst-annotation-conc? abnf::cst)
                 1))
     (b* ((abnf::cstss (cst-annotation-conc1 abnf::cst)))
       (cst-list-list-conc-matchp abnf::cstss "normal-annotation")))
 :rule-classes :rewrite)

Theorem: cst-annotation-conc1-of-tree-fix-cst

(defthm cst-annotation-conc1-of-tree-fix-cst
  (equal (cst-annotation-conc1 (abnf::tree-fix abnf::cst))
         (cst-annotation-conc1 abnf::cst)))

Theorem: cst-annotation-conc1-tree-equiv-congruence-on-cst

(defthm cst-annotation-conc1-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-annotation-conc1 abnf::cst)
                  (cst-annotation-conc1 cst-equiv)))
  :rule-classes :congruence)

Function: cst-annotation-conc2

(defun cst-annotation-conc2 (abnf::cst)
 (declare (xargs :guard (abnf::treep abnf::cst)))
 (declare (xargs :guard (and (cst-matchp abnf::cst "annotation")
                             (equal (cst-annotation-conc? abnf::cst)
                                    2))))
 (abnf::tree-nonleaf->branches abnf::cst))

Theorem: tree-list-listp-of-cst-annotation-conc2

(defthm tree-list-listp-of-cst-annotation-conc2
  (b* ((abnf::cstss (cst-annotation-conc2 abnf::cst)))
    (abnf::tree-list-listp abnf::cstss))
  :rule-classes :rewrite)

Theorem: cst-annotation-conc2-match

(defthm cst-annotation-conc2-match
 (implies
     (and (cst-matchp abnf::cst "annotation")
          (equal (cst-annotation-conc? abnf::cst)
                 2))
     (b* ((abnf::cstss (cst-annotation-conc2 abnf::cst)))
       (cst-list-list-conc-matchp abnf::cstss "marker-annotation")))
 :rule-classes :rewrite)

Theorem: cst-annotation-conc2-of-tree-fix-cst

(defthm cst-annotation-conc2-of-tree-fix-cst
  (equal (cst-annotation-conc2 (abnf::tree-fix abnf::cst))
         (cst-annotation-conc2 abnf::cst)))

Theorem: cst-annotation-conc2-tree-equiv-congruence-on-cst

(defthm cst-annotation-conc2-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-annotation-conc2 abnf::cst)
                  (cst-annotation-conc2 cst-equiv)))
  :rule-classes :congruence)

Function: cst-annotation-conc3

(defun cst-annotation-conc3 (abnf::cst)
 (declare (xargs :guard (abnf::treep abnf::cst)))
 (declare (xargs :guard (and (cst-matchp abnf::cst "annotation")
                             (equal (cst-annotation-conc? abnf::cst)
                                    3))))
 (abnf::tree-nonleaf->branches abnf::cst))

Theorem: tree-list-listp-of-cst-annotation-conc3

(defthm tree-list-listp-of-cst-annotation-conc3
  (b* ((abnf::cstss (cst-annotation-conc3 abnf::cst)))
    (abnf::tree-list-listp abnf::cstss))
  :rule-classes :rewrite)

Theorem: cst-annotation-conc3-match

(defthm cst-annotation-conc3-match
  (implies
       (and (cst-matchp abnf::cst "annotation")
            (equal (cst-annotation-conc? abnf::cst)
                   3))
       (b* ((abnf::cstss (cst-annotation-conc3 abnf::cst)))
         (cst-list-list-conc-matchp abnf::cstss
                                    "single-element-annotation")))
  :rule-classes :rewrite)

Theorem: cst-annotation-conc3-of-tree-fix-cst

(defthm cst-annotation-conc3-of-tree-fix-cst
  (equal (cst-annotation-conc3 (abnf::tree-fix abnf::cst))
         (cst-annotation-conc3 abnf::cst)))

Theorem: cst-annotation-conc3-tree-equiv-congruence-on-cst

(defthm cst-annotation-conc3-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-annotation-conc3 abnf::cst)
                  (cst-annotation-conc3 cst-equiv)))
  :rule-classes :congruence)

Function: cst-normal-annotation-conc

(defun cst-normal-annotation-conc (abnf::cst)
 (declare (xargs :guard (abnf::treep abnf::cst)))
 (declare (xargs :guard (cst-matchp abnf::cst "normal-annotation")))
 (abnf::tree-nonleaf->branches abnf::cst))

Theorem: tree-list-listp-of-cst-normal-annotation-conc

(defthm tree-list-listp-of-cst-normal-annotation-conc
  (b* ((abnf::cstss (cst-normal-annotation-conc abnf::cst)))
    (abnf::tree-list-listp abnf::cstss))
  :rule-classes :rewrite)

Theorem: cst-normal-annotation-conc-match

(defthm cst-normal-annotation-conc-match
  (implies
       (cst-matchp abnf::cst "normal-annotation")
       (b* ((abnf::cstss (cst-normal-annotation-conc abnf::cst)))
         (cst-list-list-conc-matchp
              abnf::cstss
              "\"@\" type-name \"(\" [ element-value-pair-list ] \")\"")))
  :rule-classes :rewrite)

Theorem: cst-normal-annotation-conc-of-tree-fix-cst

(defthm cst-normal-annotation-conc-of-tree-fix-cst
  (equal (cst-normal-annotation-conc (abnf::tree-fix abnf::cst))
         (cst-normal-annotation-conc abnf::cst)))

Theorem: cst-normal-annotation-conc-tree-equiv-congruence-on-cst

(defthm cst-normal-annotation-conc-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-normal-annotation-conc abnf::cst)
                  (cst-normal-annotation-conc cst-equiv)))
  :rule-classes :congruence)

Function: cst-element-value-pair-list-conc

(defun cst-element-value-pair-list-conc (abnf::cst)
 (declare (xargs :guard (abnf::treep abnf::cst)))
 (declare
    (xargs :guard (cst-matchp abnf::cst "element-value-pair-list")))
 (abnf::tree-nonleaf->branches abnf::cst))

Theorem: tree-list-listp-of-cst-element-value-pair-list-conc

(defthm tree-list-listp-of-cst-element-value-pair-list-conc
  (b* ((abnf::cstss (cst-element-value-pair-list-conc abnf::cst)))
    (abnf::tree-list-listp abnf::cstss))
  :rule-classes :rewrite)

Theorem: cst-element-value-pair-list-conc-match

(defthm cst-element-value-pair-list-conc-match
 (implies
    (cst-matchp abnf::cst "element-value-pair-list")
    (b* ((abnf::cstss (cst-element-value-pair-list-conc abnf::cst)))
      (cst-list-list-conc-matchp
           abnf::cstss
           "element-value-pair *( \",\" element-value-pair )")))
 :rule-classes :rewrite)

Theorem: cst-element-value-pair-list-conc-of-tree-fix-cst

(defthm cst-element-value-pair-list-conc-of-tree-fix-cst
  (equal
       (cst-element-value-pair-list-conc (abnf::tree-fix abnf::cst))
       (cst-element-value-pair-list-conc abnf::cst)))

Theorem: cst-element-value-pair-list-conc-tree-equiv-congruence-on-cst

(defthm
      cst-element-value-pair-list-conc-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-element-value-pair-list-conc abnf::cst)
                  (cst-element-value-pair-list-conc cst-equiv)))
  :rule-classes :congruence)

Function: cst-element-value-pair-conc

(defun cst-element-value-pair-conc (abnf::cst)
  (declare (xargs :guard (abnf::treep abnf::cst)))
  (declare
       (xargs :guard (cst-matchp abnf::cst "element-value-pair")))
  (abnf::tree-nonleaf->branches abnf::cst))

Theorem: tree-list-listp-of-cst-element-value-pair-conc

(defthm tree-list-listp-of-cst-element-value-pair-conc
  (b* ((abnf::cstss (cst-element-value-pair-conc abnf::cst)))
    (abnf::tree-list-listp abnf::cstss))
  :rule-classes :rewrite)

Theorem: cst-element-value-pair-conc-match

(defthm cst-element-value-pair-conc-match
 (implies
      (cst-matchp abnf::cst "element-value-pair")
      (b* ((abnf::cstss (cst-element-value-pair-conc abnf::cst)))
        (cst-list-list-conc-matchp abnf::cstss
                                   "identifier \"=\" element-value")))
 :rule-classes :rewrite)

Theorem: cst-element-value-pair-conc-of-tree-fix-cst

(defthm cst-element-value-pair-conc-of-tree-fix-cst
  (equal (cst-element-value-pair-conc (abnf::tree-fix abnf::cst))
         (cst-element-value-pair-conc abnf::cst)))

Theorem: cst-element-value-pair-conc-tree-equiv-congruence-on-cst

(defthm cst-element-value-pair-conc-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-element-value-pair-conc abnf::cst)
                  (cst-element-value-pair-conc cst-equiv)))
  :rule-classes :congruence)

Function: cst-element-value-conc1

(defun cst-element-value-conc1 (abnf::cst)
  (declare (xargs :guard (abnf::treep abnf::cst)))
  (declare
       (xargs :guard (and (cst-matchp abnf::cst "element-value")
                          (equal (cst-element-value-conc? abnf::cst)
                                 1))))
  (abnf::tree-nonleaf->branches abnf::cst))

Theorem: tree-list-listp-of-cst-element-value-conc1

(defthm tree-list-listp-of-cst-element-value-conc1
  (b* ((abnf::cstss (cst-element-value-conc1 abnf::cst)))
    (abnf::tree-list-listp abnf::cstss))
  :rule-classes :rewrite)

Theorem: cst-element-value-conc1-match

(defthm cst-element-value-conc1-match
  (implies (and (cst-matchp abnf::cst "element-value")
                (equal (cst-element-value-conc? abnf::cst)
                       1))
           (b* ((abnf::cstss (cst-element-value-conc1 abnf::cst)))
             (cst-list-list-conc-matchp
                  abnf::cstss "conditional-expression")))
  :rule-classes :rewrite)

Theorem: cst-element-value-conc1-of-tree-fix-cst

(defthm cst-element-value-conc1-of-tree-fix-cst
  (equal (cst-element-value-conc1 (abnf::tree-fix abnf::cst))
         (cst-element-value-conc1 abnf::cst)))

Theorem: cst-element-value-conc1-tree-equiv-congruence-on-cst

(defthm cst-element-value-conc1-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-element-value-conc1 abnf::cst)
                  (cst-element-value-conc1 cst-equiv)))
  :rule-classes :congruence)

Function: cst-element-value-conc2

(defun cst-element-value-conc2 (abnf::cst)
  (declare (xargs :guard (abnf::treep abnf::cst)))
  (declare
       (xargs :guard (and (cst-matchp abnf::cst "element-value")
                          (equal (cst-element-value-conc? abnf::cst)
                                 2))))
  (abnf::tree-nonleaf->branches abnf::cst))

Theorem: tree-list-listp-of-cst-element-value-conc2

(defthm tree-list-listp-of-cst-element-value-conc2
  (b* ((abnf::cstss (cst-element-value-conc2 abnf::cst)))
    (abnf::tree-list-listp abnf::cstss))
  :rule-classes :rewrite)

Theorem: cst-element-value-conc2-match

(defthm cst-element-value-conc2-match
 (implies
   (and (cst-matchp abnf::cst "element-value")
        (equal (cst-element-value-conc? abnf::cst)
               2))
   (b* ((abnf::cstss (cst-element-value-conc2 abnf::cst)))
     (cst-list-list-conc-matchp abnf::cstss
                                "element-value-array-initializer")))
 :rule-classes :rewrite)

Theorem: cst-element-value-conc2-of-tree-fix-cst

(defthm cst-element-value-conc2-of-tree-fix-cst
  (equal (cst-element-value-conc2 (abnf::tree-fix abnf::cst))
         (cst-element-value-conc2 abnf::cst)))

Theorem: cst-element-value-conc2-tree-equiv-congruence-on-cst

(defthm cst-element-value-conc2-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-element-value-conc2 abnf::cst)
                  (cst-element-value-conc2 cst-equiv)))
  :rule-classes :congruence)

Function: cst-element-value-conc3

(defun cst-element-value-conc3 (abnf::cst)
  (declare (xargs :guard (abnf::treep abnf::cst)))
  (declare
       (xargs :guard (and (cst-matchp abnf::cst "element-value")
                          (equal (cst-element-value-conc? abnf::cst)
                                 3))))
  (abnf::tree-nonleaf->branches abnf::cst))

Theorem: tree-list-listp-of-cst-element-value-conc3

(defthm tree-list-listp-of-cst-element-value-conc3
  (b* ((abnf::cstss (cst-element-value-conc3 abnf::cst)))
    (abnf::tree-list-listp abnf::cstss))
  :rule-classes :rewrite)

Theorem: cst-element-value-conc3-match

(defthm cst-element-value-conc3-match
  (implies (and (cst-matchp abnf::cst "element-value")
                (equal (cst-element-value-conc? abnf::cst)
                       3))
           (b* ((abnf::cstss (cst-element-value-conc3 abnf::cst)))
             (cst-list-list-conc-matchp abnf::cstss "annotation")))
  :rule-classes :rewrite)

Theorem: cst-element-value-conc3-of-tree-fix-cst

(defthm cst-element-value-conc3-of-tree-fix-cst
  (equal (cst-element-value-conc3 (abnf::tree-fix abnf::cst))
         (cst-element-value-conc3 abnf::cst)))

Theorem: cst-element-value-conc3-tree-equiv-congruence-on-cst

(defthm cst-element-value-conc3-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-element-value-conc3 abnf::cst)
                  (cst-element-value-conc3 cst-equiv)))
  :rule-classes :congruence)

Function: cst-element-value-array-initializer-conc

(defun cst-element-value-array-initializer-conc (abnf::cst)
 (declare (xargs :guard (abnf::treep abnf::cst)))
 (declare
      (xargs :guard (cst-matchp abnf::cst
                                "element-value-array-initializer")))
 (abnf::tree-nonleaf->branches abnf::cst))

Theorem: tree-list-listp-of-cst-element-value-array-initializer-conc

(defthm tree-list-listp-of-cst-element-value-array-initializer-conc
  (b* ((abnf::cstss
            (cst-element-value-array-initializer-conc abnf::cst)))
    (abnf::tree-list-listp abnf::cstss))
  :rule-classes :rewrite)

Theorem: cst-element-value-array-initializer-conc-match

(defthm cst-element-value-array-initializer-conc-match
 (implies
    (cst-matchp abnf::cst
                "element-value-array-initializer")
    (b* ((abnf::cstss
              (cst-element-value-array-initializer-conc abnf::cst)))
      (cst-list-list-conc-matchp
           abnf::cstss
           "\"{\" [ element-value-list ] [ \",\" ] \"}\"")))
 :rule-classes :rewrite)

Theorem: cst-element-value-array-initializer-conc-of-tree-fix-cst

(defthm cst-element-value-array-initializer-conc-of-tree-fix-cst
  (equal (cst-element-value-array-initializer-conc
              (abnf::tree-fix abnf::cst))
         (cst-element-value-array-initializer-conc abnf::cst)))

Theorem: cst-element-value-array-initializer-conc-tree-equiv-congruence-on-cst

(defthm
 cst-element-value-array-initializer-conc-tree-equiv-congruence-on-cst
 (implies
      (abnf::tree-equiv abnf::cst cst-equiv)
      (equal (cst-element-value-array-initializer-conc abnf::cst)
             (cst-element-value-array-initializer-conc cst-equiv)))
 :rule-classes :congruence)

Function: cst-element-value-list-conc

(defun cst-element-value-list-conc (abnf::cst)
  (declare (xargs :guard (abnf::treep abnf::cst)))
  (declare
       (xargs :guard (cst-matchp abnf::cst "element-value-list")))
  (abnf::tree-nonleaf->branches abnf::cst))

Theorem: tree-list-listp-of-cst-element-value-list-conc

(defthm tree-list-listp-of-cst-element-value-list-conc
  (b* ((abnf::cstss (cst-element-value-list-conc abnf::cst)))
    (abnf::tree-list-listp abnf::cstss))
  :rule-classes :rewrite)

Theorem: cst-element-value-list-conc-match

(defthm cst-element-value-list-conc-match
  (implies
       (cst-matchp abnf::cst "element-value-list")
       (b* ((abnf::cstss (cst-element-value-list-conc abnf::cst)))
         (cst-list-list-conc-matchp
              abnf::cstss
              "element-value *( \",\" element-value )")))
  :rule-classes :rewrite)

Theorem: cst-element-value-list-conc-of-tree-fix-cst

(defthm cst-element-value-list-conc-of-tree-fix-cst
  (equal (cst-element-value-list-conc (abnf::tree-fix abnf::cst))
         (cst-element-value-list-conc abnf::cst)))

Theorem: cst-element-value-list-conc-tree-equiv-congruence-on-cst

(defthm cst-element-value-list-conc-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-element-value-list-conc abnf::cst)
                  (cst-element-value-list-conc cst-equiv)))
  :rule-classes :congruence)

Function: cst-marker-annotation-conc

(defun cst-marker-annotation-conc (abnf::cst)
 (declare (xargs :guard (abnf::treep abnf::cst)))
 (declare (xargs :guard (cst-matchp abnf::cst "marker-annotation")))
 (abnf::tree-nonleaf->branches abnf::cst))

Theorem: tree-list-listp-of-cst-marker-annotation-conc

(defthm tree-list-listp-of-cst-marker-annotation-conc
  (b* ((abnf::cstss (cst-marker-annotation-conc abnf::cst)))
    (abnf::tree-list-listp abnf::cstss))
  :rule-classes :rewrite)

Theorem: cst-marker-annotation-conc-match

(defthm cst-marker-annotation-conc-match
  (implies
       (cst-matchp abnf::cst "marker-annotation")
       (b* ((abnf::cstss (cst-marker-annotation-conc abnf::cst)))
         (cst-list-list-conc-matchp abnf::cstss "\"@\" type-name")))
  :rule-classes :rewrite)

Theorem: cst-marker-annotation-conc-of-tree-fix-cst

(defthm cst-marker-annotation-conc-of-tree-fix-cst
  (equal (cst-marker-annotation-conc (abnf::tree-fix abnf::cst))
         (cst-marker-annotation-conc abnf::cst)))

Theorem: cst-marker-annotation-conc-tree-equiv-congruence-on-cst

(defthm cst-marker-annotation-conc-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-marker-annotation-conc abnf::cst)
                  (cst-marker-annotation-conc cst-equiv)))
  :rule-classes :congruence)

Function: cst-single-element-annotation-conc

(defun cst-single-element-annotation-conc (abnf::cst)
 (declare (xargs :guard (abnf::treep abnf::cst)))
 (declare
  (xargs :guard (cst-matchp abnf::cst "single-element-annotation")))
 (abnf::tree-nonleaf->branches abnf::cst))

Theorem: tree-list-listp-of-cst-single-element-annotation-conc

(defthm tree-list-listp-of-cst-single-element-annotation-conc
  (b* ((abnf::cstss (cst-single-element-annotation-conc abnf::cst)))
    (abnf::tree-list-listp abnf::cstss))
  :rule-classes :rewrite)

Theorem: cst-single-element-annotation-conc-match

(defthm cst-single-element-annotation-conc-match
 (implies
  (cst-matchp abnf::cst "single-element-annotation")
  (b* ((abnf::cstss (cst-single-element-annotation-conc abnf::cst)))
    (cst-list-list-conc-matchp
         abnf::cstss
         "\"@\" type-name \"(\" element-value \")\"")))
 :rule-classes :rewrite)

Theorem: cst-single-element-annotation-conc-of-tree-fix-cst

(defthm cst-single-element-annotation-conc-of-tree-fix-cst
 (equal
     (cst-single-element-annotation-conc (abnf::tree-fix abnf::cst))
     (cst-single-element-annotation-conc abnf::cst)))

Theorem: cst-single-element-annotation-conc-tree-equiv-congruence-on-cst

(defthm
    cst-single-element-annotation-conc-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-single-element-annotation-conc abnf::cst)
                  (cst-single-element-annotation-conc cst-equiv)))
  :rule-classes :congruence)

Function: cst-array-initializer-conc

(defun cst-array-initializer-conc (abnf::cst)
 (declare (xargs :guard (abnf::treep abnf::cst)))
 (declare (xargs :guard (cst-matchp abnf::cst "array-initializer")))
 (abnf::tree-nonleaf->branches abnf::cst))

Theorem: tree-list-listp-of-cst-array-initializer-conc

(defthm tree-list-listp-of-cst-array-initializer-conc
  (b* ((abnf::cstss (cst-array-initializer-conc abnf::cst)))
    (abnf::tree-list-listp abnf::cstss))
  :rule-classes :rewrite)

Theorem: cst-array-initializer-conc-match

(defthm cst-array-initializer-conc-match
 (implies (cst-matchp abnf::cst "array-initializer")
          (b* ((abnf::cstss (cst-array-initializer-conc abnf::cst)))
            (cst-list-list-conc-matchp
                 abnf::cstss
                 "\"{\" [ variable-initializer-list ] [ \",\" ] \"}\"")))
 :rule-classes :rewrite)

Theorem: cst-array-initializer-conc-of-tree-fix-cst

(defthm cst-array-initializer-conc-of-tree-fix-cst
  (equal (cst-array-initializer-conc (abnf::tree-fix abnf::cst))
         (cst-array-initializer-conc abnf::cst)))

Theorem: cst-array-initializer-conc-tree-equiv-congruence-on-cst

(defthm cst-array-initializer-conc-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-array-initializer-conc abnf::cst)
                  (cst-array-initializer-conc cst-equiv)))
  :rule-classes :congruence)

Function: cst-variable-initializer-list-conc

(defun cst-variable-initializer-list-conc (abnf::cst)
 (declare (xargs :guard (abnf::treep abnf::cst)))
 (declare
  (xargs :guard (cst-matchp abnf::cst "variable-initializer-list")))
 (abnf::tree-nonleaf->branches abnf::cst))

Theorem: tree-list-listp-of-cst-variable-initializer-list-conc

(defthm tree-list-listp-of-cst-variable-initializer-list-conc
  (b* ((abnf::cstss (cst-variable-initializer-list-conc abnf::cst)))
    (abnf::tree-list-listp abnf::cstss))
  :rule-classes :rewrite)

Theorem: cst-variable-initializer-list-conc-match

(defthm cst-variable-initializer-list-conc-match
 (implies
  (cst-matchp abnf::cst "variable-initializer-list")
  (b* ((abnf::cstss (cst-variable-initializer-list-conc abnf::cst)))
    (cst-list-list-conc-matchp
         abnf::cstss
         "variable-initializer *( \",\" variable-initializer )")))
 :rule-classes :rewrite)

Theorem: cst-variable-initializer-list-conc-of-tree-fix-cst

(defthm cst-variable-initializer-list-conc-of-tree-fix-cst
 (equal
     (cst-variable-initializer-list-conc (abnf::tree-fix abnf::cst))
     (cst-variable-initializer-list-conc abnf::cst)))

Theorem: cst-variable-initializer-list-conc-tree-equiv-congruence-on-cst

(defthm
    cst-variable-initializer-list-conc-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-variable-initializer-list-conc abnf::cst)
                  (cst-variable-initializer-list-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")))
  (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
                                   "\"{\" [ block-statements ] \"}\"")))
 :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-block-statements-conc

(defun cst-block-statements-conc (abnf::cst)
  (declare (xargs :guard (abnf::treep abnf::cst)))
  (declare (xargs :guard (cst-matchp abnf::cst "block-statements")))
  (abnf::tree-nonleaf->branches abnf::cst))

Theorem: tree-list-listp-of-cst-block-statements-conc

(defthm tree-list-listp-of-cst-block-statements-conc
  (b* ((abnf::cstss (cst-block-statements-conc abnf::cst)))
    (abnf::tree-list-listp abnf::cstss))
  :rule-classes :rewrite)

Theorem: cst-block-statements-conc-match

(defthm cst-block-statements-conc-match
 (implies
     (cst-matchp abnf::cst "block-statements")
     (b* ((abnf::cstss (cst-block-statements-conc abnf::cst)))
       (cst-list-list-conc-matchp abnf::cstss "1*block-statement")))
 :rule-classes :rewrite)

Theorem: cst-block-statements-conc-of-tree-fix-cst

(defthm cst-block-statements-conc-of-tree-fix-cst
  (equal (cst-block-statements-conc (abnf::tree-fix abnf::cst))
         (cst-block-statements-conc abnf::cst)))

Theorem: cst-block-statements-conc-tree-equiv-congruence-on-cst

(defthm cst-block-statements-conc-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-block-statements-conc abnf::cst)
                  (cst-block-statements-conc cst-equiv)))
  :rule-classes :congruence)

Function: cst-block-statement-conc1

(defun cst-block-statement-conc1 (abnf::cst)
 (declare (xargs :guard (abnf::treep abnf::cst)))
 (declare
     (xargs :guard (and (cst-matchp abnf::cst "block-statement")
                        (equal (cst-block-statement-conc? abnf::cst)
                               1))))
 (abnf::tree-nonleaf->branches abnf::cst))

Theorem: tree-list-listp-of-cst-block-statement-conc1

(defthm tree-list-listp-of-cst-block-statement-conc1
  (b* ((abnf::cstss (cst-block-statement-conc1 abnf::cst)))
    (abnf::tree-list-listp abnf::cstss))
  :rule-classes :rewrite)

Theorem: cst-block-statement-conc1-match

(defthm cst-block-statement-conc1-match
  (implies (and (cst-matchp abnf::cst "block-statement")
                (equal (cst-block-statement-conc? abnf::cst)
                       1))
           (b* ((abnf::cstss (cst-block-statement-conc1 abnf::cst)))
             (cst-list-list-conc-matchp
                  abnf::cstss
                  "local-class-or-interface-declaration")))
  :rule-classes :rewrite)

Theorem: cst-block-statement-conc1-of-tree-fix-cst

(defthm cst-block-statement-conc1-of-tree-fix-cst
  (equal (cst-block-statement-conc1 (abnf::tree-fix abnf::cst))
         (cst-block-statement-conc1 abnf::cst)))

Theorem: cst-block-statement-conc1-tree-equiv-congruence-on-cst

(defthm cst-block-statement-conc1-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-block-statement-conc1 abnf::cst)
                  (cst-block-statement-conc1 cst-equiv)))
  :rule-classes :congruence)

Function: cst-block-statement-conc2

(defun cst-block-statement-conc2 (abnf::cst)
 (declare (xargs :guard (abnf::treep abnf::cst)))
 (declare
     (xargs :guard (and (cst-matchp abnf::cst "block-statement")
                        (equal (cst-block-statement-conc? abnf::cst)
                               2))))
 (abnf::tree-nonleaf->branches abnf::cst))

Theorem: tree-list-listp-of-cst-block-statement-conc2

(defthm tree-list-listp-of-cst-block-statement-conc2
  (b* ((abnf::cstss (cst-block-statement-conc2 abnf::cst)))
    (abnf::tree-list-listp abnf::cstss))
  :rule-classes :rewrite)

Theorem: cst-block-statement-conc2-match

(defthm cst-block-statement-conc2-match
  (implies (and (cst-matchp abnf::cst "block-statement")
                (equal (cst-block-statement-conc? abnf::cst)
                       2))
           (b* ((abnf::cstss (cst-block-statement-conc2 abnf::cst)))
             (cst-list-list-conc-matchp
                  abnf::cstss
                  "local-variable-declaration-statement")))
  :rule-classes :rewrite)

Theorem: cst-block-statement-conc2-of-tree-fix-cst

(defthm cst-block-statement-conc2-of-tree-fix-cst
  (equal (cst-block-statement-conc2 (abnf::tree-fix abnf::cst))
         (cst-block-statement-conc2 abnf::cst)))

Theorem: cst-block-statement-conc2-tree-equiv-congruence-on-cst

(defthm cst-block-statement-conc2-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-block-statement-conc2 abnf::cst)
                  (cst-block-statement-conc2 cst-equiv)))
  :rule-classes :congruence)

Function: cst-block-statement-conc3

(defun cst-block-statement-conc3 (abnf::cst)
 (declare (xargs :guard (abnf::treep abnf::cst)))
 (declare
     (xargs :guard (and (cst-matchp abnf::cst "block-statement")
                        (equal (cst-block-statement-conc? abnf::cst)
                               3))))
 (abnf::tree-nonleaf->branches abnf::cst))

Theorem: tree-list-listp-of-cst-block-statement-conc3

(defthm tree-list-listp-of-cst-block-statement-conc3
  (b* ((abnf::cstss (cst-block-statement-conc3 abnf::cst)))
    (abnf::tree-list-listp abnf::cstss))
  :rule-classes :rewrite)

Theorem: cst-block-statement-conc3-match

(defthm cst-block-statement-conc3-match
  (implies (and (cst-matchp abnf::cst "block-statement")
                (equal (cst-block-statement-conc? abnf::cst)
                       3))
           (b* ((abnf::cstss (cst-block-statement-conc3 abnf::cst)))
             (cst-list-list-conc-matchp abnf::cstss "statement")))
  :rule-classes :rewrite)

Theorem: cst-block-statement-conc3-of-tree-fix-cst

(defthm cst-block-statement-conc3-of-tree-fix-cst
  (equal (cst-block-statement-conc3 (abnf::tree-fix abnf::cst))
         (cst-block-statement-conc3 abnf::cst)))

Theorem: cst-block-statement-conc3-tree-equiv-congruence-on-cst

(defthm cst-block-statement-conc3-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-block-statement-conc3 abnf::cst)
                  (cst-block-statement-conc3 cst-equiv)))
  :rule-classes :congruence)

Function: cst-local-class-or-interface-declaration-conc1

(defun cst-local-class-or-interface-declaration-conc1 (abnf::cst)
 (declare (xargs :guard (abnf::treep abnf::cst)))
 (declare
  (xargs
   :guard
   (and
     (cst-matchp abnf::cst
                 "local-class-or-interface-declaration")
     (equal
          (cst-local-class-or-interface-declaration-conc? abnf::cst)
          1))))
 (abnf::tree-nonleaf->branches abnf::cst))

Theorem: tree-list-listp-of-cst-local-class-or-interface-declaration-conc1

(defthm
  tree-list-listp-of-cst-local-class-or-interface-declaration-conc1
 (b*
  ((abnf::cstss
        (cst-local-class-or-interface-declaration-conc1 abnf::cst)))
  (abnf::tree-list-listp abnf::cstss))
 :rule-classes :rewrite)

Theorem: cst-local-class-or-interface-declaration-conc1-match

(defthm cst-local-class-or-interface-declaration-conc1-match
 (implies
  (and
   (cst-matchp abnf::cst
               "local-class-or-interface-declaration")
   (equal (cst-local-class-or-interface-declaration-conc? abnf::cst)
          1))
  (b*
   ((abnf::cstss
        (cst-local-class-or-interface-declaration-conc1 abnf::cst)))
   (cst-list-list-conc-matchp abnf::cstss "class-declaration")))
 :rule-classes :rewrite)

Theorem: cst-local-class-or-interface-declaration-conc1-of-tree-fix-cst

(defthm
     cst-local-class-or-interface-declaration-conc1-of-tree-fix-cst
 (equal (cst-local-class-or-interface-declaration-conc1
             (abnf::tree-fix abnf::cst))
        (cst-local-class-or-interface-declaration-conc1 abnf::cst)))

Theorem: cst-local-class-or-interface-declaration-conc1-tree-equiv-congruence-on-cst

(defthm
 cst-local-class-or-interface-declaration-conc1-tree-equiv-congruence-on-cst
 (implies
   (abnf::tree-equiv abnf::cst cst-equiv)
   (equal
        (cst-local-class-or-interface-declaration-conc1 abnf::cst)
        (cst-local-class-or-interface-declaration-conc1 cst-equiv)))
 :rule-classes :congruence)

Function: cst-local-class-or-interface-declaration-conc2

(defun cst-local-class-or-interface-declaration-conc2 (abnf::cst)
 (declare (xargs :guard (abnf::treep abnf::cst)))
 (declare
  (xargs
   :guard
   (and
     (cst-matchp abnf::cst
                 "local-class-or-interface-declaration")
     (equal
          (cst-local-class-or-interface-declaration-conc? abnf::cst)
          2))))
 (abnf::tree-nonleaf->branches abnf::cst))

Theorem: tree-list-listp-of-cst-local-class-or-interface-declaration-conc2

(defthm
  tree-list-listp-of-cst-local-class-or-interface-declaration-conc2
 (b*
  ((abnf::cstss
        (cst-local-class-or-interface-declaration-conc2 abnf::cst)))
  (abnf::tree-list-listp abnf::cstss))
 :rule-classes :rewrite)

Theorem: cst-local-class-or-interface-declaration-conc2-match

(defthm cst-local-class-or-interface-declaration-conc2-match
 (implies
  (and
   (cst-matchp abnf::cst
               "local-class-or-interface-declaration")
   (equal (cst-local-class-or-interface-declaration-conc? abnf::cst)
          2))
  (b*
   ((abnf::cstss
        (cst-local-class-or-interface-declaration-conc2 abnf::cst)))
   (cst-list-list-conc-matchp abnf::cstss
                              "normal-interface-declaration")))
 :rule-classes :rewrite)

Theorem: cst-local-class-or-interface-declaration-conc2-of-tree-fix-cst

(defthm
     cst-local-class-or-interface-declaration-conc2-of-tree-fix-cst
 (equal (cst-local-class-or-interface-declaration-conc2
             (abnf::tree-fix abnf::cst))
        (cst-local-class-or-interface-declaration-conc2 abnf::cst)))

Theorem: cst-local-class-or-interface-declaration-conc2-tree-equiv-congruence-on-cst

(defthm
 cst-local-class-or-interface-declaration-conc2-tree-equiv-congruence-on-cst
 (implies
   (abnf::tree-equiv abnf::cst cst-equiv)
   (equal
        (cst-local-class-or-interface-declaration-conc2 abnf::cst)
        (cst-local-class-or-interface-declaration-conc2 cst-equiv)))
 :rule-classes :congruence)

Function: cst-local-variable-declaration-conc

(defun cst-local-variable-declaration-conc (abnf::cst)
  (declare (xargs :guard (abnf::treep abnf::cst)))
  (declare (xargs :guard (cst-matchp abnf::cst
                                     "local-variable-declaration")))
  (abnf::tree-nonleaf->branches abnf::cst))

Theorem: tree-list-listp-of-cst-local-variable-declaration-conc

(defthm tree-list-listp-of-cst-local-variable-declaration-conc
 (b* ((abnf::cstss (cst-local-variable-declaration-conc abnf::cst)))
   (abnf::tree-list-listp abnf::cstss))
 :rule-classes :rewrite)

Theorem: cst-local-variable-declaration-conc-match

(defthm cst-local-variable-declaration-conc-match
 (implies
  (cst-matchp abnf::cst "local-variable-declaration")
  (b*
    ((abnf::cstss (cst-local-variable-declaration-conc abnf::cst)))
   (cst-list-list-conc-matchp
    abnf::cstss
    "*variable-modifier local-variable-type variable-declarator-list")))
 :rule-classes :rewrite)

Theorem: cst-local-variable-declaration-conc-of-tree-fix-cst

(defthm cst-local-variable-declaration-conc-of-tree-fix-cst
 (equal
    (cst-local-variable-declaration-conc (abnf::tree-fix abnf::cst))
    (cst-local-variable-declaration-conc abnf::cst)))

Theorem: cst-local-variable-declaration-conc-tree-equiv-congruence-on-cst

(defthm
   cst-local-variable-declaration-conc-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-local-variable-declaration-conc abnf::cst)
                  (cst-local-variable-declaration-conc cst-equiv)))
  :rule-classes :congruence)

Function: cst-local-variable-declaration-statement-conc

(defun cst-local-variable-declaration-statement-conc (abnf::cst)
 (declare (xargs :guard (abnf::treep abnf::cst)))
 (declare
   (xargs
        :guard (cst-matchp abnf::cst
                           "local-variable-declaration-statement")))
 (abnf::tree-nonleaf->branches abnf::cst))

Theorem: tree-list-listp-of-cst-local-variable-declaration-statement-conc

(defthm
   tree-list-listp-of-cst-local-variable-declaration-statement-conc
  (b*
   ((abnf::cstss
         (cst-local-variable-declaration-statement-conc abnf::cst)))
   (abnf::tree-list-listp abnf::cstss))
  :rule-classes :rewrite)

Theorem: cst-local-variable-declaration-statement-conc-match

(defthm cst-local-variable-declaration-statement-conc-match
 (implies
  (cst-matchp abnf::cst
              "local-variable-declaration-statement")
  (b*
   ((abnf::cstss
         (cst-local-variable-declaration-statement-conc abnf::cst)))
   (cst-list-list-conc-matchp abnf::cstss
                              "local-variable-declaration \";\"")))
 :rule-classes :rewrite)

Theorem: cst-local-variable-declaration-statement-conc-of-tree-fix-cst

(defthm
      cst-local-variable-declaration-statement-conc-of-tree-fix-cst
  (equal (cst-local-variable-declaration-statement-conc
              (abnf::tree-fix abnf::cst))
         (cst-local-variable-declaration-statement-conc abnf::cst)))

Theorem: cst-local-variable-declaration-statement-conc-tree-equiv-congruence-on-cst

(defthm
 cst-local-variable-declaration-statement-conc-tree-equiv-congruence-on-cst
 (implies
  (abnf::tree-equiv abnf::cst cst-equiv)
  (equal (cst-local-variable-declaration-statement-conc abnf::cst)
         (cst-local-variable-declaration-statement-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))))
  (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
                  "statement-without-trailing-substatement")))
  :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))))
  (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 "labeled-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))))
  (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 "if-then-statement")))
 :rule-classes :rewrite)

Theorem: cst-statement-conc3-of-tree-fix-cst

(defthm cst-statement-conc3-of-tree-fix-cst
  (equal (cst-statement-conc3 (abnf::tree-fix abnf::cst))
         (cst-statement-conc3 abnf::cst)))

Theorem: cst-statement-conc3-tree-equiv-congruence-on-cst

(defthm cst-statement-conc3-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-statement-conc3 abnf::cst)
                  (cst-statement-conc3 cst-equiv)))
  :rule-classes :congruence)

Function: cst-statement-conc4

(defun cst-statement-conc4 (abnf::cst)
  (declare (xargs :guard (abnf::treep abnf::cst)))
  (declare (xargs :guard (and (cst-matchp abnf::cst "statement")
                              (equal (cst-statement-conc? abnf::cst)
                                     4))))
  (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 "if-then-else-statement")))
  :rule-classes :rewrite)

Theorem: cst-statement-conc4-of-tree-fix-cst

(defthm cst-statement-conc4-of-tree-fix-cst
  (equal (cst-statement-conc4 (abnf::tree-fix abnf::cst))
         (cst-statement-conc4 abnf::cst)))

Theorem: cst-statement-conc4-tree-equiv-congruence-on-cst

(defthm cst-statement-conc4-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-statement-conc4 abnf::cst)
                  (cst-statement-conc4 cst-equiv)))
  :rule-classes :congruence)

Function: cst-statement-conc5

(defun cst-statement-conc5 (abnf::cst)
  (declare (xargs :guard (abnf::treep abnf::cst)))
  (declare (xargs :guard (and (cst-matchp abnf::cst "statement")
                              (equal (cst-statement-conc? abnf::cst)
                                     5))))
  (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 "while-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))))
  (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 "for-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-no-short-if-conc1

(defun cst-statement-no-short-if-conc1 (abnf::cst)
 (declare (xargs :guard (abnf::treep abnf::cst)))
 (declare
  (xargs
      :guard (and (cst-matchp abnf::cst "statement-no-short-if")
                  (equal (cst-statement-no-short-if-conc? abnf::cst)
                         1))))
 (abnf::tree-nonleaf->branches abnf::cst))

Theorem: tree-list-listp-of-cst-statement-no-short-if-conc1

(defthm tree-list-listp-of-cst-statement-no-short-if-conc1
  (b* ((abnf::cstss (cst-statement-no-short-if-conc1 abnf::cst)))
    (abnf::tree-list-listp abnf::cstss))
  :rule-classes :rewrite)

Theorem: cst-statement-no-short-if-conc1-match

(defthm cst-statement-no-short-if-conc1-match
 (implies
     (and (cst-matchp abnf::cst "statement-no-short-if")
          (equal (cst-statement-no-short-if-conc? abnf::cst)
                 1))
     (b* ((abnf::cstss (cst-statement-no-short-if-conc1 abnf::cst)))
       (cst-list-list-conc-matchp
            abnf::cstss
            "statement-without-trailing-substatement")))
 :rule-classes :rewrite)

Theorem: cst-statement-no-short-if-conc1-of-tree-fix-cst

(defthm cst-statement-no-short-if-conc1-of-tree-fix-cst
 (equal (cst-statement-no-short-if-conc1 (abnf::tree-fix abnf::cst))
        (cst-statement-no-short-if-conc1 abnf::cst)))

Theorem: cst-statement-no-short-if-conc1-tree-equiv-congruence-on-cst

(defthm cst-statement-no-short-if-conc1-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-statement-no-short-if-conc1 abnf::cst)
                  (cst-statement-no-short-if-conc1 cst-equiv)))
  :rule-classes :congruence)

Function: cst-statement-no-short-if-conc2

(defun cst-statement-no-short-if-conc2 (abnf::cst)
 (declare (xargs :guard (abnf::treep abnf::cst)))
 (declare
  (xargs
      :guard (and (cst-matchp abnf::cst "statement-no-short-if")
                  (equal (cst-statement-no-short-if-conc? abnf::cst)
                         2))))
 (abnf::tree-nonleaf->branches abnf::cst))

Theorem: tree-list-listp-of-cst-statement-no-short-if-conc2

(defthm tree-list-listp-of-cst-statement-no-short-if-conc2
  (b* ((abnf::cstss (cst-statement-no-short-if-conc2 abnf::cst)))
    (abnf::tree-list-listp abnf::cstss))
  :rule-classes :rewrite)

Theorem: cst-statement-no-short-if-conc2-match

(defthm cst-statement-no-short-if-conc2-match
 (implies
     (and (cst-matchp abnf::cst "statement-no-short-if")
          (equal (cst-statement-no-short-if-conc? abnf::cst)
                 2))
     (b* ((abnf::cstss (cst-statement-no-short-if-conc2 abnf::cst)))
       (cst-list-list-conc-matchp abnf::cstss
                                  "labeled-statement-no-short-if")))
 :rule-classes :rewrite)

Theorem: cst-statement-no-short-if-conc2-of-tree-fix-cst

(defthm cst-statement-no-short-if-conc2-of-tree-fix-cst
 (equal (cst-statement-no-short-if-conc2 (abnf::tree-fix abnf::cst))
        (cst-statement-no-short-if-conc2 abnf::cst)))

Theorem: cst-statement-no-short-if-conc2-tree-equiv-congruence-on-cst

(defthm cst-statement-no-short-if-conc2-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-statement-no-short-if-conc2 abnf::cst)
                  (cst-statement-no-short-if-conc2 cst-equiv)))
  :rule-classes :congruence)

Function: cst-statement-no-short-if-conc3

(defun cst-statement-no-short-if-conc3 (abnf::cst)
 (declare (xargs :guard (abnf::treep abnf::cst)))
 (declare
  (xargs
      :guard (and (cst-matchp abnf::cst "statement-no-short-if")
                  (equal (cst-statement-no-short-if-conc? abnf::cst)
                         3))))
 (abnf::tree-nonleaf->branches abnf::cst))

Theorem: tree-list-listp-of-cst-statement-no-short-if-conc3

(defthm tree-list-listp-of-cst-statement-no-short-if-conc3
  (b* ((abnf::cstss (cst-statement-no-short-if-conc3 abnf::cst)))
    (abnf::tree-list-listp abnf::cstss))
  :rule-classes :rewrite)

Theorem: cst-statement-no-short-if-conc3-match

(defthm cst-statement-no-short-if-conc3-match
 (implies
     (and (cst-matchp abnf::cst "statement-no-short-if")
          (equal (cst-statement-no-short-if-conc? abnf::cst)
                 3))
     (b* ((abnf::cstss (cst-statement-no-short-if-conc3 abnf::cst)))
       (cst-list-list-conc-matchp
            abnf::cstss
            "if-then-else-statement-no-short-if")))
 :rule-classes :rewrite)

Theorem: cst-statement-no-short-if-conc3-of-tree-fix-cst

(defthm cst-statement-no-short-if-conc3-of-tree-fix-cst
 (equal (cst-statement-no-short-if-conc3 (abnf::tree-fix abnf::cst))
        (cst-statement-no-short-if-conc3 abnf::cst)))

Theorem: cst-statement-no-short-if-conc3-tree-equiv-congruence-on-cst

(defthm cst-statement-no-short-if-conc3-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-statement-no-short-if-conc3 abnf::cst)
                  (cst-statement-no-short-if-conc3 cst-equiv)))
  :rule-classes :congruence)

Function: cst-statement-no-short-if-conc4

(defun cst-statement-no-short-if-conc4 (abnf::cst)
 (declare (xargs :guard (abnf::treep abnf::cst)))
 (declare
  (xargs
      :guard (and (cst-matchp abnf::cst "statement-no-short-if")
                  (equal (cst-statement-no-short-if-conc? abnf::cst)
                         4))))
 (abnf::tree-nonleaf->branches abnf::cst))

Theorem: tree-list-listp-of-cst-statement-no-short-if-conc4

(defthm tree-list-listp-of-cst-statement-no-short-if-conc4
  (b* ((abnf::cstss (cst-statement-no-short-if-conc4 abnf::cst)))
    (abnf::tree-list-listp abnf::cstss))
  :rule-classes :rewrite)

Theorem: cst-statement-no-short-if-conc4-match

(defthm cst-statement-no-short-if-conc4-match
 (implies
     (and (cst-matchp abnf::cst "statement-no-short-if")
          (equal (cst-statement-no-short-if-conc? abnf::cst)
                 4))
     (b* ((abnf::cstss (cst-statement-no-short-if-conc4 abnf::cst)))
       (cst-list-list-conc-matchp abnf::cstss
                                  "while-statement-no-short-if")))
 :rule-classes :rewrite)

Theorem: cst-statement-no-short-if-conc4-of-tree-fix-cst

(defthm cst-statement-no-short-if-conc4-of-tree-fix-cst
 (equal (cst-statement-no-short-if-conc4 (abnf::tree-fix abnf::cst))
        (cst-statement-no-short-if-conc4 abnf::cst)))

Theorem: cst-statement-no-short-if-conc4-tree-equiv-congruence-on-cst

(defthm cst-statement-no-short-if-conc4-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-statement-no-short-if-conc4 abnf::cst)
                  (cst-statement-no-short-if-conc4 cst-equiv)))
  :rule-classes :congruence)

Function: cst-statement-no-short-if-conc5

(defun cst-statement-no-short-if-conc5 (abnf::cst)
 (declare (xargs :guard (abnf::treep abnf::cst)))
 (declare
  (xargs
      :guard (and (cst-matchp abnf::cst "statement-no-short-if")
                  (equal (cst-statement-no-short-if-conc? abnf::cst)
                         5))))
 (abnf::tree-nonleaf->branches abnf::cst))

Theorem: tree-list-listp-of-cst-statement-no-short-if-conc5

(defthm tree-list-listp-of-cst-statement-no-short-if-conc5
  (b* ((abnf::cstss (cst-statement-no-short-if-conc5 abnf::cst)))
    (abnf::tree-list-listp abnf::cstss))
  :rule-classes :rewrite)

Theorem: cst-statement-no-short-if-conc5-match

(defthm cst-statement-no-short-if-conc5-match
 (implies
     (and (cst-matchp abnf::cst "statement-no-short-if")
          (equal (cst-statement-no-short-if-conc? abnf::cst)
                 5))
     (b* ((abnf::cstss (cst-statement-no-short-if-conc5 abnf::cst)))
       (cst-list-list-conc-matchp abnf::cstss
                                  "for-statement-no-short-if")))
 :rule-classes :rewrite)

Theorem: cst-statement-no-short-if-conc5-of-tree-fix-cst

(defthm cst-statement-no-short-if-conc5-of-tree-fix-cst
 (equal (cst-statement-no-short-if-conc5 (abnf::tree-fix abnf::cst))
        (cst-statement-no-short-if-conc5 abnf::cst)))

Theorem: cst-statement-no-short-if-conc5-tree-equiv-congruence-on-cst

(defthm cst-statement-no-short-if-conc5-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-statement-no-short-if-conc5 abnf::cst)
                  (cst-statement-no-short-if-conc5 cst-equiv)))
  :rule-classes :congruence)

Function: cst-statement-without-trailing-substatement-conc1

(defun cst-statement-without-trailing-substatement-conc1 (abnf::cst)
 (declare (xargs :guard (abnf::treep abnf::cst)))
 (declare
  (xargs
   :guard
   (and
    (cst-matchp abnf::cst
                "statement-without-trailing-substatement")
    (equal
       (cst-statement-without-trailing-substatement-conc? abnf::cst)
       1))))
 (abnf::tree-nonleaf->branches abnf::cst))

Theorem: tree-list-listp-of-cst-statement-without-trailing-substatement-conc1

(defthm
 tree-list-listp-of-cst-statement-without-trailing-substatement-conc1
 (b*
  ((abnf::cstss
     (cst-statement-without-trailing-substatement-conc1 abnf::cst)))
  (abnf::tree-list-listp abnf::cstss))
 :rule-classes :rewrite)

Theorem: cst-statement-without-trailing-substatement-conc1-match

(defthm cst-statement-without-trailing-substatement-conc1-match
 (implies
  (and
   (cst-matchp abnf::cst
               "statement-without-trailing-substatement")
   (equal
       (cst-statement-without-trailing-substatement-conc? abnf::cst)
       1))
  (b*
   ((abnf::cstss
     (cst-statement-without-trailing-substatement-conc1 abnf::cst)))
   (cst-list-list-conc-matchp abnf::cstss "block")))
 :rule-classes :rewrite)

Theorem: cst-statement-without-trailing-substatement-conc1-of-tree-fix-cst

(defthm
  cst-statement-without-trailing-substatement-conc1-of-tree-fix-cst
 (equal
     (cst-statement-without-trailing-substatement-conc1
          (abnf::tree-fix abnf::cst))
     (cst-statement-without-trailing-substatement-conc1 abnf::cst)))

Theorem: cst-statement-without-trailing-substatement-conc1-tree-equiv-congruence-on-cst

(defthm
 cst-statement-without-trailing-substatement-conc1-tree-equiv-congruence-on-cst
 (implies
  (abnf::tree-equiv abnf::cst cst-equiv)
  (equal
     (cst-statement-without-trailing-substatement-conc1 abnf::cst)
     (cst-statement-without-trailing-substatement-conc1 cst-equiv)))
 :rule-classes :congruence)

Function: cst-statement-without-trailing-substatement-conc2

(defun cst-statement-without-trailing-substatement-conc2 (abnf::cst)
 (declare (xargs :guard (abnf::treep abnf::cst)))
 (declare
  (xargs
   :guard
   (and
    (cst-matchp abnf::cst
                "statement-without-trailing-substatement")
    (equal
       (cst-statement-without-trailing-substatement-conc? abnf::cst)
       2))))
 (abnf::tree-nonleaf->branches abnf::cst))

Theorem: tree-list-listp-of-cst-statement-without-trailing-substatement-conc2

(defthm
 tree-list-listp-of-cst-statement-without-trailing-substatement-conc2
 (b*
  ((abnf::cstss
     (cst-statement-without-trailing-substatement-conc2 abnf::cst)))
  (abnf::tree-list-listp abnf::cstss))
 :rule-classes :rewrite)

Theorem: cst-statement-without-trailing-substatement-conc2-match

(defthm cst-statement-without-trailing-substatement-conc2-match
 (implies
  (and
   (cst-matchp abnf::cst
               "statement-without-trailing-substatement")
   (equal
       (cst-statement-without-trailing-substatement-conc? abnf::cst)
       2))
  (b*
   ((abnf::cstss
     (cst-statement-without-trailing-substatement-conc2 abnf::cst)))
   (cst-list-list-conc-matchp abnf::cstss "empty-statement")))
 :rule-classes :rewrite)

Theorem: cst-statement-without-trailing-substatement-conc2-of-tree-fix-cst

(defthm
  cst-statement-without-trailing-substatement-conc2-of-tree-fix-cst
 (equal
     (cst-statement-without-trailing-substatement-conc2
          (abnf::tree-fix abnf::cst))
     (cst-statement-without-trailing-substatement-conc2 abnf::cst)))

Theorem: cst-statement-without-trailing-substatement-conc2-tree-equiv-congruence-on-cst

(defthm
 cst-statement-without-trailing-substatement-conc2-tree-equiv-congruence-on-cst
 (implies
  (abnf::tree-equiv abnf::cst cst-equiv)
  (equal
     (cst-statement-without-trailing-substatement-conc2 abnf::cst)
     (cst-statement-without-trailing-substatement-conc2 cst-equiv)))
 :rule-classes :congruence)

Function: cst-statement-without-trailing-substatement-conc3

(defun cst-statement-without-trailing-substatement-conc3 (abnf::cst)
 (declare (xargs :guard (abnf::treep abnf::cst)))
 (declare
  (xargs
   :guard
   (and
    (cst-matchp abnf::cst
                "statement-without-trailing-substatement")
    (equal
       (cst-statement-without-trailing-substatement-conc? abnf::cst)
       3))))
 (abnf::tree-nonleaf->branches abnf::cst))

Theorem: tree-list-listp-of-cst-statement-without-trailing-substatement-conc3

(defthm
 tree-list-listp-of-cst-statement-without-trailing-substatement-conc3
 (b*
  ((abnf::cstss
     (cst-statement-without-trailing-substatement-conc3 abnf::cst)))
  (abnf::tree-list-listp abnf::cstss))
 :rule-classes :rewrite)

Theorem: cst-statement-without-trailing-substatement-conc3-match

(defthm cst-statement-without-trailing-substatement-conc3-match
 (implies
  (and
   (cst-matchp abnf::cst
               "statement-without-trailing-substatement")
   (equal
       (cst-statement-without-trailing-substatement-conc? abnf::cst)
       3))
  (b*
   ((abnf::cstss
     (cst-statement-without-trailing-substatement-conc3 abnf::cst)))
   (cst-list-list-conc-matchp abnf::cstss "expression-statement")))
 :rule-classes :rewrite)

Theorem: cst-statement-without-trailing-substatement-conc3-of-tree-fix-cst

(defthm
  cst-statement-without-trailing-substatement-conc3-of-tree-fix-cst
 (equal
     (cst-statement-without-trailing-substatement-conc3
          (abnf::tree-fix abnf::cst))
     (cst-statement-without-trailing-substatement-conc3 abnf::cst)))

Theorem: cst-statement-without-trailing-substatement-conc3-tree-equiv-congruence-on-cst

(defthm
 cst-statement-without-trailing-substatement-conc3-tree-equiv-congruence-on-cst
 (implies
  (abnf::tree-equiv abnf::cst cst-equiv)
  (equal
     (cst-statement-without-trailing-substatement-conc3 abnf::cst)
     (cst-statement-without-trailing-substatement-conc3 cst-equiv)))
 :rule-classes :congruence)

Function: cst-statement-without-trailing-substatement-conc4

(defun cst-statement-without-trailing-substatement-conc4 (abnf::cst)
 (declare (xargs :guard (abnf::treep abnf::cst)))
 (declare
  (xargs
   :guard
   (and
    (cst-matchp abnf::cst
                "statement-without-trailing-substatement")
    (equal
       (cst-statement-without-trailing-substatement-conc? abnf::cst)
       4))))
 (abnf::tree-nonleaf->branches abnf::cst))

Theorem: tree-list-listp-of-cst-statement-without-trailing-substatement-conc4

(defthm
 tree-list-listp-of-cst-statement-without-trailing-substatement-conc4
 (b*
  ((abnf::cstss
     (cst-statement-without-trailing-substatement-conc4 abnf::cst)))
  (abnf::tree-list-listp abnf::cstss))
 :rule-classes :rewrite)

Theorem: cst-statement-without-trailing-substatement-conc4-match

(defthm cst-statement-without-trailing-substatement-conc4-match
 (implies
  (and
   (cst-matchp abnf::cst
               "statement-without-trailing-substatement")
   (equal
       (cst-statement-without-trailing-substatement-conc? abnf::cst)
       4))
  (b*
   ((abnf::cstss
     (cst-statement-without-trailing-substatement-conc4 abnf::cst)))
   (cst-list-list-conc-matchp abnf::cstss "assert-statement")))
 :rule-classes :rewrite)

Theorem: cst-statement-without-trailing-substatement-conc4-of-tree-fix-cst

(defthm
  cst-statement-without-trailing-substatement-conc4-of-tree-fix-cst
 (equal
     (cst-statement-without-trailing-substatement-conc4
          (abnf::tree-fix abnf::cst))
     (cst-statement-without-trailing-substatement-conc4 abnf::cst)))

Theorem: cst-statement-without-trailing-substatement-conc4-tree-equiv-congruence-on-cst

(defthm
 cst-statement-without-trailing-substatement-conc4-tree-equiv-congruence-on-cst
 (implies
  (abnf::tree-equiv abnf::cst cst-equiv)
  (equal
     (cst-statement-without-trailing-substatement-conc4 abnf::cst)
     (cst-statement-without-trailing-substatement-conc4 cst-equiv)))
 :rule-classes :congruence)

Function: cst-statement-without-trailing-substatement-conc5

(defun cst-statement-without-trailing-substatement-conc5 (abnf::cst)
 (declare (xargs :guard (abnf::treep abnf::cst)))
 (declare
  (xargs
   :guard
   (and
    (cst-matchp abnf::cst
                "statement-without-trailing-substatement")
    (equal
       (cst-statement-without-trailing-substatement-conc? abnf::cst)
       5))))
 (abnf::tree-nonleaf->branches abnf::cst))

Theorem: tree-list-listp-of-cst-statement-without-trailing-substatement-conc5

(defthm
 tree-list-listp-of-cst-statement-without-trailing-substatement-conc5
 (b*
  ((abnf::cstss
     (cst-statement-without-trailing-substatement-conc5 abnf::cst)))
  (abnf::tree-list-listp abnf::cstss))
 :rule-classes :rewrite)

Theorem: cst-statement-without-trailing-substatement-conc5-match

(defthm cst-statement-without-trailing-substatement-conc5-match
 (implies
  (and
   (cst-matchp abnf::cst
               "statement-without-trailing-substatement")
   (equal
       (cst-statement-without-trailing-substatement-conc? abnf::cst)
       5))
  (b*
   ((abnf::cstss
     (cst-statement-without-trailing-substatement-conc5 abnf::cst)))
   (cst-list-list-conc-matchp abnf::cstss "switch-statement")))
 :rule-classes :rewrite)

Theorem: cst-statement-without-trailing-substatement-conc5-of-tree-fix-cst

(defthm
  cst-statement-without-trailing-substatement-conc5-of-tree-fix-cst
 (equal
     (cst-statement-without-trailing-substatement-conc5
          (abnf::tree-fix abnf::cst))
     (cst-statement-without-trailing-substatement-conc5 abnf::cst)))

Theorem: cst-statement-without-trailing-substatement-conc5-tree-equiv-congruence-on-cst

(defthm
 cst-statement-without-trailing-substatement-conc5-tree-equiv-congruence-on-cst
 (implies
  (abnf::tree-equiv abnf::cst cst-equiv)
  (equal
     (cst-statement-without-trailing-substatement-conc5 abnf::cst)
     (cst-statement-without-trailing-substatement-conc5 cst-equiv)))
 :rule-classes :congruence)

Function: cst-statement-without-trailing-substatement-conc6

(defun cst-statement-without-trailing-substatement-conc6 (abnf::cst)
 (declare (xargs :guard (abnf::treep abnf::cst)))
 (declare
  (xargs
   :guard
   (and
    (cst-matchp abnf::cst
                "statement-without-trailing-substatement")
    (equal
       (cst-statement-without-trailing-substatement-conc? abnf::cst)
       6))))
 (abnf::tree-nonleaf->branches abnf::cst))

Theorem: tree-list-listp-of-cst-statement-without-trailing-substatement-conc6

(defthm
 tree-list-listp-of-cst-statement-without-trailing-substatement-conc6
 (b*
  ((abnf::cstss
     (cst-statement-without-trailing-substatement-conc6 abnf::cst)))
  (abnf::tree-list-listp abnf::cstss))
 :rule-classes :rewrite)

Theorem: cst-statement-without-trailing-substatement-conc6-match

(defthm cst-statement-without-trailing-substatement-conc6-match
 (implies
  (and
   (cst-matchp abnf::cst
               "statement-without-trailing-substatement")
   (equal
       (cst-statement-without-trailing-substatement-conc? abnf::cst)
       6))
  (b*
   ((abnf::cstss
     (cst-statement-without-trailing-substatement-conc6 abnf::cst)))
   (cst-list-list-conc-matchp abnf::cstss "do-statement")))
 :rule-classes :rewrite)

Theorem: cst-statement-without-trailing-substatement-conc6-of-tree-fix-cst

(defthm
  cst-statement-without-trailing-substatement-conc6-of-tree-fix-cst
 (equal
     (cst-statement-without-trailing-substatement-conc6
          (abnf::tree-fix abnf::cst))
     (cst-statement-without-trailing-substatement-conc6 abnf::cst)))

Theorem: cst-statement-without-trailing-substatement-conc6-tree-equiv-congruence-on-cst

(defthm
 cst-statement-without-trailing-substatement-conc6-tree-equiv-congruence-on-cst
 (implies
  (abnf::tree-equiv abnf::cst cst-equiv)
  (equal
     (cst-statement-without-trailing-substatement-conc6 abnf::cst)
     (cst-statement-without-trailing-substatement-conc6 cst-equiv)))
 :rule-classes :congruence)

Function: cst-statement-without-trailing-substatement-conc7

(defun cst-statement-without-trailing-substatement-conc7 (abnf::cst)
 (declare (xargs :guard (abnf::treep abnf::cst)))
 (declare
  (xargs
   :guard
   (and
    (cst-matchp abnf::cst
                "statement-without-trailing-substatement")
    (equal
       (cst-statement-without-trailing-substatement-conc? abnf::cst)
       7))))
 (abnf::tree-nonleaf->branches abnf::cst))

Theorem: tree-list-listp-of-cst-statement-without-trailing-substatement-conc7

(defthm
 tree-list-listp-of-cst-statement-without-trailing-substatement-conc7
 (b*
  ((abnf::cstss
     (cst-statement-without-trailing-substatement-conc7 abnf::cst)))
  (abnf::tree-list-listp abnf::cstss))
 :rule-classes :rewrite)

Theorem: cst-statement-without-trailing-substatement-conc7-match

(defthm cst-statement-without-trailing-substatement-conc7-match
 (implies
  (and
   (cst-matchp abnf::cst
               "statement-without-trailing-substatement")
   (equal
       (cst-statement-without-trailing-substatement-conc? abnf::cst)
       7))
  (b*
   ((abnf::cstss
     (cst-statement-without-trailing-substatement-conc7 abnf::cst)))
   (cst-list-list-conc-matchp abnf::cstss "break-statement")))
 :rule-classes :rewrite)

Theorem: cst-statement-without-trailing-substatement-conc7-of-tree-fix-cst

(defthm
  cst-statement-without-trailing-substatement-conc7-of-tree-fix-cst
 (equal
     (cst-statement-without-trailing-substatement-conc7
          (abnf::tree-fix abnf::cst))
     (cst-statement-without-trailing-substatement-conc7 abnf::cst)))

Theorem: cst-statement-without-trailing-substatement-conc7-tree-equiv-congruence-on-cst

(defthm
 cst-statement-without-trailing-substatement-conc7-tree-equiv-congruence-on-cst
 (implies
  (abnf::tree-equiv abnf::cst cst-equiv)
  (equal
     (cst-statement-without-trailing-substatement-conc7 abnf::cst)
     (cst-statement-without-trailing-substatement-conc7 cst-equiv)))
 :rule-classes :congruence)

Function: cst-statement-without-trailing-substatement-conc8

(defun cst-statement-without-trailing-substatement-conc8 (abnf::cst)
 (declare (xargs :guard (abnf::treep abnf::cst)))
 (declare
  (xargs
   :guard
   (and
    (cst-matchp abnf::cst
                "statement-without-trailing-substatement")
    (equal
       (cst-statement-without-trailing-substatement-conc? abnf::cst)
       8))))
 (abnf::tree-nonleaf->branches abnf::cst))

Theorem: tree-list-listp-of-cst-statement-without-trailing-substatement-conc8

(defthm
 tree-list-listp-of-cst-statement-without-trailing-substatement-conc8
 (b*
  ((abnf::cstss
     (cst-statement-without-trailing-substatement-conc8 abnf::cst)))
  (abnf::tree-list-listp abnf::cstss))
 :rule-classes :rewrite)

Theorem: cst-statement-without-trailing-substatement-conc8-match

(defthm cst-statement-without-trailing-substatement-conc8-match
 (implies
  (and
   (cst-matchp abnf::cst
               "statement-without-trailing-substatement")
   (equal
       (cst-statement-without-trailing-substatement-conc? abnf::cst)
       8))
  (b*
   ((abnf::cstss
     (cst-statement-without-trailing-substatement-conc8 abnf::cst)))
   (cst-list-list-conc-matchp abnf::cstss "continue-statement")))
 :rule-classes :rewrite)

Theorem: cst-statement-without-trailing-substatement-conc8-of-tree-fix-cst

(defthm
  cst-statement-without-trailing-substatement-conc8-of-tree-fix-cst
 (equal
     (cst-statement-without-trailing-substatement-conc8
          (abnf::tree-fix abnf::cst))
     (cst-statement-without-trailing-substatement-conc8 abnf::cst)))

Theorem: cst-statement-without-trailing-substatement-conc8-tree-equiv-congruence-on-cst

(defthm
 cst-statement-without-trailing-substatement-conc8-tree-equiv-congruence-on-cst
 (implies
  (abnf::tree-equiv abnf::cst cst-equiv)
  (equal
     (cst-statement-without-trailing-substatement-conc8 abnf::cst)
     (cst-statement-without-trailing-substatement-conc8 cst-equiv)))
 :rule-classes :congruence)

Function: cst-statement-without-trailing-substatement-conc9

(defun cst-statement-without-trailing-substatement-conc9 (abnf::cst)
 (declare (xargs :guard (abnf::treep abnf::cst)))
 (declare
  (xargs
   :guard
   (and
    (cst-matchp abnf::cst
                "statement-without-trailing-substatement")
    (equal
       (cst-statement-without-trailing-substatement-conc? abnf::cst)
       9))))
 (abnf::tree-nonleaf->branches abnf::cst))

Theorem: tree-list-listp-of-cst-statement-without-trailing-substatement-conc9

(defthm
 tree-list-listp-of-cst-statement-without-trailing-substatement-conc9
 (b*
  ((abnf::cstss
     (cst-statement-without-trailing-substatement-conc9 abnf::cst)))
  (abnf::tree-list-listp abnf::cstss))
 :rule-classes :rewrite)

Theorem: cst-statement-without-trailing-substatement-conc9-match

(defthm cst-statement-without-trailing-substatement-conc9-match
 (implies
  (and
   (cst-matchp abnf::cst
               "statement-without-trailing-substatement")
   (equal
       (cst-statement-without-trailing-substatement-conc? abnf::cst)
       9))
  (b*
   ((abnf::cstss
     (cst-statement-without-trailing-substatement-conc9 abnf::cst)))
   (cst-list-list-conc-matchp abnf::cstss "return-statement")))
 :rule-classes :rewrite)

Theorem: cst-statement-without-trailing-substatement-conc9-of-tree-fix-cst

(defthm
  cst-statement-without-trailing-substatement-conc9-of-tree-fix-cst
 (equal
     (cst-statement-without-trailing-substatement-conc9
          (abnf::tree-fix abnf::cst))
     (cst-statement-without-trailing-substatement-conc9 abnf::cst)))

Theorem: cst-statement-without-trailing-substatement-conc9-tree-equiv-congruence-on-cst

(defthm
 cst-statement-without-trailing-substatement-conc9-tree-equiv-congruence-on-cst
 (implies
  (abnf::tree-equiv abnf::cst cst-equiv)
  (equal
     (cst-statement-without-trailing-substatement-conc9 abnf::cst)
     (cst-statement-without-trailing-substatement-conc9 cst-equiv)))
 :rule-classes :congruence)

Function: cst-statement-without-trailing-substatement-conc10

(defun cst-statement-without-trailing-substatement-conc10
       (abnf::cst)
 (declare (xargs :guard (abnf::treep abnf::cst)))
 (declare
  (xargs
   :guard
   (and
    (cst-matchp abnf::cst
                "statement-without-trailing-substatement")
    (equal
       (cst-statement-without-trailing-substatement-conc? abnf::cst)
       10))))
 (abnf::tree-nonleaf->branches abnf::cst))

Theorem: tree-list-listp-of-cst-statement-without-trailing-substatement-conc10

(defthm
 tree-list-listp-of-cst-statement-without-trailing-substatement-conc10
 (b*
  ((abnf::cstss
    (cst-statement-without-trailing-substatement-conc10 abnf::cst)))
  (abnf::tree-list-listp abnf::cstss))
 :rule-classes :rewrite)

Theorem: cst-statement-without-trailing-substatement-conc10-match

(defthm cst-statement-without-trailing-substatement-conc10-match
 (implies
  (and
   (cst-matchp abnf::cst
               "statement-without-trailing-substatement")
   (equal
       (cst-statement-without-trailing-substatement-conc? abnf::cst)
       10))
  (b* ((abnf::cstss (cst-statement-without-trailing-substatement-conc10
                         abnf::cst)))
    (cst-list-list-conc-matchp
         abnf::cstss "synchronized-statement")))
 :rule-classes :rewrite)

Theorem: cst-statement-without-trailing-substatement-conc10-of-tree-fix-cst

(defthm
 cst-statement-without-trailing-substatement-conc10-of-tree-fix-cst
 (equal
    (cst-statement-without-trailing-substatement-conc10
         (abnf::tree-fix abnf::cst))
    (cst-statement-without-trailing-substatement-conc10 abnf::cst)))

Theorem: cst-statement-without-trailing-substatement-conc10-tree-equiv-congruence-on-cst

(defthm
 cst-statement-without-trailing-substatement-conc10-tree-equiv-congruence-on-cst
 (implies
  (abnf::tree-equiv abnf::cst cst-equiv)
  (equal
    (cst-statement-without-trailing-substatement-conc10 abnf::cst)
    (cst-statement-without-trailing-substatement-conc10 cst-equiv)))
 :rule-classes :congruence)

Function: cst-statement-without-trailing-substatement-conc11

(defun cst-statement-without-trailing-substatement-conc11
       (abnf::cst)
 (declare (xargs :guard (abnf::treep abnf::cst)))
 (declare
  (xargs
   :guard
   (and
    (cst-matchp abnf::cst
                "statement-without-trailing-substatement")
    (equal
       (cst-statement-without-trailing-substatement-conc? abnf::cst)
       11))))
 (abnf::tree-nonleaf->branches abnf::cst))

Theorem: tree-list-listp-of-cst-statement-without-trailing-substatement-conc11

(defthm
 tree-list-listp-of-cst-statement-without-trailing-substatement-conc11
 (b*
  ((abnf::cstss
    (cst-statement-without-trailing-substatement-conc11 abnf::cst)))
  (abnf::tree-list-listp abnf::cstss))
 :rule-classes :rewrite)

Theorem: cst-statement-without-trailing-substatement-conc11-match

(defthm cst-statement-without-trailing-substatement-conc11-match
 (implies
  (and
   (cst-matchp abnf::cst
               "statement-without-trailing-substatement")
   (equal
       (cst-statement-without-trailing-substatement-conc? abnf::cst)
       11))
  (b* ((abnf::cstss (cst-statement-without-trailing-substatement-conc11
                         abnf::cst)))
    (cst-list-list-conc-matchp abnf::cstss "throw-statement")))
 :rule-classes :rewrite)

Theorem: cst-statement-without-trailing-substatement-conc11-of-tree-fix-cst

(defthm
 cst-statement-without-trailing-substatement-conc11-of-tree-fix-cst
 (equal
    (cst-statement-without-trailing-substatement-conc11
         (abnf::tree-fix abnf::cst))
    (cst-statement-without-trailing-substatement-conc11 abnf::cst)))

Theorem: cst-statement-without-trailing-substatement-conc11-tree-equiv-congruence-on-cst

(defthm
 cst-statement-without-trailing-substatement-conc11-tree-equiv-congruence-on-cst
 (implies
  (abnf::tree-equiv abnf::cst cst-equiv)
  (equal
    (cst-statement-without-trailing-substatement-conc11 abnf::cst)
    (cst-statement-without-trailing-substatement-conc11 cst-equiv)))
 :rule-classes :congruence)

Function: cst-statement-without-trailing-substatement-conc12

(defun cst-statement-without-trailing-substatement-conc12
       (abnf::cst)
 (declare (xargs :guard (abnf::treep abnf::cst)))
 (declare
  (xargs
   :guard
   (and
    (cst-matchp abnf::cst
                "statement-without-trailing-substatement")
    (equal
       (cst-statement-without-trailing-substatement-conc? abnf::cst)
       12))))
 (abnf::tree-nonleaf->branches abnf::cst))

Theorem: tree-list-listp-of-cst-statement-without-trailing-substatement-conc12

(defthm
 tree-list-listp-of-cst-statement-without-trailing-substatement-conc12
 (b*
  ((abnf::cstss
    (cst-statement-without-trailing-substatement-conc12 abnf::cst)))
  (abnf::tree-list-listp abnf::cstss))
 :rule-classes :rewrite)

Theorem: cst-statement-without-trailing-substatement-conc12-match

(defthm cst-statement-without-trailing-substatement-conc12-match
 (implies
  (and
   (cst-matchp abnf::cst
               "statement-without-trailing-substatement")
   (equal
       (cst-statement-without-trailing-substatement-conc? abnf::cst)
       12))
  (b* ((abnf::cstss (cst-statement-without-trailing-substatement-conc12
                         abnf::cst)))
    (cst-list-list-conc-matchp abnf::cstss "try-statement")))
 :rule-classes :rewrite)

Theorem: cst-statement-without-trailing-substatement-conc12-of-tree-fix-cst

(defthm
 cst-statement-without-trailing-substatement-conc12-of-tree-fix-cst
 (equal
    (cst-statement-without-trailing-substatement-conc12
         (abnf::tree-fix abnf::cst))
    (cst-statement-without-trailing-substatement-conc12 abnf::cst)))

Theorem: cst-statement-without-trailing-substatement-conc12-tree-equiv-congruence-on-cst

(defthm
 cst-statement-without-trailing-substatement-conc12-tree-equiv-congruence-on-cst
 (implies
  (abnf::tree-equiv abnf::cst cst-equiv)
  (equal
    (cst-statement-without-trailing-substatement-conc12 abnf::cst)
    (cst-statement-without-trailing-substatement-conc12 cst-equiv)))
 :rule-classes :congruence)

Function: cst-statement-without-trailing-substatement-conc13

(defun cst-statement-without-trailing-substatement-conc13
       (abnf::cst)
 (declare (xargs :guard (abnf::treep abnf::cst)))
 (declare
  (xargs
   :guard
   (and
    (cst-matchp abnf::cst
                "statement-without-trailing-substatement")
    (equal
       (cst-statement-without-trailing-substatement-conc? abnf::cst)
       13))))
 (abnf::tree-nonleaf->branches abnf::cst))

Theorem: tree-list-listp-of-cst-statement-without-trailing-substatement-conc13

(defthm
 tree-list-listp-of-cst-statement-without-trailing-substatement-conc13
 (b*
  ((abnf::cstss
    (cst-statement-without-trailing-substatement-conc13 abnf::cst)))
  (abnf::tree-list-listp abnf::cstss))
 :rule-classes :rewrite)

Theorem: cst-statement-without-trailing-substatement-conc13-match

(defthm cst-statement-without-trailing-substatement-conc13-match
 (implies
  (and
   (cst-matchp abnf::cst
               "statement-without-trailing-substatement")
   (equal
       (cst-statement-without-trailing-substatement-conc? abnf::cst)
       13))
  (b* ((abnf::cstss (cst-statement-without-trailing-substatement-conc13
                         abnf::cst)))
    (cst-list-list-conc-matchp abnf::cstss "yield-statement")))
 :rule-classes :rewrite)

Theorem: cst-statement-without-trailing-substatement-conc13-of-tree-fix-cst

(defthm
 cst-statement-without-trailing-substatement-conc13-of-tree-fix-cst
 (equal
    (cst-statement-without-trailing-substatement-conc13
         (abnf::tree-fix abnf::cst))
    (cst-statement-without-trailing-substatement-conc13 abnf::cst)))

Theorem: cst-statement-without-trailing-substatement-conc13-tree-equiv-congruence-on-cst

(defthm
 cst-statement-without-trailing-substatement-conc13-tree-equiv-congruence-on-cst
 (implies
  (abnf::tree-equiv abnf::cst cst-equiv)
  (equal
    (cst-statement-without-trailing-substatement-conc13 abnf::cst)
    (cst-statement-without-trailing-substatement-conc13 cst-equiv)))
 :rule-classes :congruence)

Function: cst-empty-statement-conc

(defun cst-empty-statement-conc (abnf::cst)
  (declare (xargs :guard (abnf::treep abnf::cst)))
  (declare (xargs :guard (cst-matchp abnf::cst "empty-statement")))
  (abnf::tree-nonleaf->branches abnf::cst))

Theorem: tree-list-listp-of-cst-empty-statement-conc

(defthm tree-list-listp-of-cst-empty-statement-conc
  (b* ((abnf::cstss (cst-empty-statement-conc abnf::cst)))
    (abnf::tree-list-listp abnf::cstss))
  :rule-classes :rewrite)

Theorem: cst-empty-statement-conc-match

(defthm cst-empty-statement-conc-match
  (implies (cst-matchp abnf::cst "empty-statement")
           (b* ((abnf::cstss (cst-empty-statement-conc abnf::cst)))
             (cst-list-list-conc-matchp abnf::cstss "\";\"")))
  :rule-classes :rewrite)

Theorem: cst-empty-statement-conc-of-tree-fix-cst

(defthm cst-empty-statement-conc-of-tree-fix-cst
  (equal (cst-empty-statement-conc (abnf::tree-fix abnf::cst))
         (cst-empty-statement-conc abnf::cst)))

Theorem: cst-empty-statement-conc-tree-equiv-congruence-on-cst

(defthm cst-empty-statement-conc-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-empty-statement-conc abnf::cst)
                  (cst-empty-statement-conc cst-equiv)))
  :rule-classes :congruence)

Function: cst-labeled-statement-conc

(defun cst-labeled-statement-conc (abnf::cst)
 (declare (xargs :guard (abnf::treep abnf::cst)))
 (declare (xargs :guard (cst-matchp abnf::cst "labeled-statement")))
 (abnf::tree-nonleaf->branches abnf::cst))

Theorem: tree-list-listp-of-cst-labeled-statement-conc

(defthm tree-list-listp-of-cst-labeled-statement-conc
  (b* ((abnf::cstss (cst-labeled-statement-conc abnf::cst)))
    (abnf::tree-list-listp abnf::cstss))
  :rule-classes :rewrite)

Theorem: cst-labeled-statement-conc-match

(defthm cst-labeled-statement-conc-match
 (implies (cst-matchp abnf::cst "labeled-statement")
          (b* ((abnf::cstss (cst-labeled-statement-conc abnf::cst)))
            (cst-list-list-conc-matchp abnf::cstss
                                       "identifier \":\" statement")))
 :rule-classes :rewrite)

Theorem: cst-labeled-statement-conc-of-tree-fix-cst

(defthm cst-labeled-statement-conc-of-tree-fix-cst
  (equal (cst-labeled-statement-conc (abnf::tree-fix abnf::cst))
         (cst-labeled-statement-conc abnf::cst)))

Theorem: cst-labeled-statement-conc-tree-equiv-congruence-on-cst

(defthm cst-labeled-statement-conc-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-labeled-statement-conc abnf::cst)
                  (cst-labeled-statement-conc cst-equiv)))
  :rule-classes :congruence)

Function: cst-labeled-statement-no-short-if-conc

(defun cst-labeled-statement-no-short-if-conc (abnf::cst)
  (declare (xargs :guard (abnf::treep abnf::cst)))
  (declare
       (xargs :guard (cst-matchp abnf::cst
                                 "labeled-statement-no-short-if")))
  (abnf::tree-nonleaf->branches abnf::cst))

Theorem: tree-list-listp-of-cst-labeled-statement-no-short-if-conc

(defthm tree-list-listp-of-cst-labeled-statement-no-short-if-conc
 (b*
  ((abnf::cstss (cst-labeled-statement-no-short-if-conc abnf::cst)))
  (abnf::tree-list-listp abnf::cstss))
 :rule-classes :rewrite)

Theorem: cst-labeled-statement-no-short-if-conc-match

(defthm cst-labeled-statement-no-short-if-conc-match
 (implies
      (cst-matchp abnf::cst
                  "labeled-statement-no-short-if")
      (b* ((abnf::cstss
                (cst-labeled-statement-no-short-if-conc abnf::cst)))
        (cst-list-list-conc-matchp
             abnf::cstss
             "identifier \":\" statement-no-short-if")))
 :rule-classes :rewrite)

Theorem: cst-labeled-statement-no-short-if-conc-of-tree-fix-cst

(defthm cst-labeled-statement-no-short-if-conc-of-tree-fix-cst
  (equal (cst-labeled-statement-no-short-if-conc
              (abnf::tree-fix abnf::cst))
         (cst-labeled-statement-no-short-if-conc abnf::cst)))

Theorem: cst-labeled-statement-no-short-if-conc-tree-equiv-congruence-on-cst

(defthm
 cst-labeled-statement-no-short-if-conc-tree-equiv-congruence-on-cst
 (implies
      (abnf::tree-equiv abnf::cst cst-equiv)
      (equal (cst-labeled-statement-no-short-if-conc abnf::cst)
             (cst-labeled-statement-no-short-if-conc 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")))
  (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
                                    "statement-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-statement-expression-conc1

(defun cst-statement-expression-conc1 (abnf::cst)
 (declare (xargs :guard (abnf::treep abnf::cst)))
 (declare
  (xargs
       :guard (and (cst-matchp abnf::cst "statement-expression")
                   (equal (cst-statement-expression-conc? abnf::cst)
                          1))))
 (abnf::tree-nonleaf->branches abnf::cst))

Theorem: tree-list-listp-of-cst-statement-expression-conc1

(defthm tree-list-listp-of-cst-statement-expression-conc1
  (b* ((abnf::cstss (cst-statement-expression-conc1 abnf::cst)))
    (abnf::tree-list-listp abnf::cstss))
  :rule-classes :rewrite)

Theorem: cst-statement-expression-conc1-match

(defthm cst-statement-expression-conc1-match
 (implies
      (and (cst-matchp abnf::cst "statement-expression")
           (equal (cst-statement-expression-conc? abnf::cst)
                  1))
      (b* ((abnf::cstss (cst-statement-expression-conc1 abnf::cst)))
        (cst-list-list-conc-matchp abnf::cstss "assignment")))
 :rule-classes :rewrite)

Theorem: cst-statement-expression-conc1-of-tree-fix-cst

(defthm cst-statement-expression-conc1-of-tree-fix-cst
  (equal (cst-statement-expression-conc1 (abnf::tree-fix abnf::cst))
         (cst-statement-expression-conc1 abnf::cst)))

Theorem: cst-statement-expression-conc1-tree-equiv-congruence-on-cst

(defthm cst-statement-expression-conc1-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-statement-expression-conc1 abnf::cst)
                  (cst-statement-expression-conc1 cst-equiv)))
  :rule-classes :congruence)

Function: cst-statement-expression-conc2

(defun cst-statement-expression-conc2 (abnf::cst)
 (declare (xargs :guard (abnf::treep abnf::cst)))
 (declare
  (xargs
       :guard (and (cst-matchp abnf::cst "statement-expression")
                   (equal (cst-statement-expression-conc? abnf::cst)
                          2))))
 (abnf::tree-nonleaf->branches abnf::cst))

Theorem: tree-list-listp-of-cst-statement-expression-conc2

(defthm tree-list-listp-of-cst-statement-expression-conc2
  (b* ((abnf::cstss (cst-statement-expression-conc2 abnf::cst)))
    (abnf::tree-list-listp abnf::cstss))
  :rule-classes :rewrite)

Theorem: cst-statement-expression-conc2-match

(defthm cst-statement-expression-conc2-match
 (implies
      (and (cst-matchp abnf::cst "statement-expression")
           (equal (cst-statement-expression-conc? abnf::cst)
                  2))
      (b* ((abnf::cstss (cst-statement-expression-conc2 abnf::cst)))
        (cst-list-list-conc-matchp abnf::cstss
                                   "pre-increment-expression")))
 :rule-classes :rewrite)

Theorem: cst-statement-expression-conc2-of-tree-fix-cst

(defthm cst-statement-expression-conc2-of-tree-fix-cst
  (equal (cst-statement-expression-conc2 (abnf::tree-fix abnf::cst))
         (cst-statement-expression-conc2 abnf::cst)))

Theorem: cst-statement-expression-conc2-tree-equiv-congruence-on-cst

(defthm cst-statement-expression-conc2-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-statement-expression-conc2 abnf::cst)
                  (cst-statement-expression-conc2 cst-equiv)))
  :rule-classes :congruence)

Function: cst-statement-expression-conc3

(defun cst-statement-expression-conc3 (abnf::cst)
 (declare (xargs :guard (abnf::treep abnf::cst)))
 (declare
  (xargs
       :guard (and (cst-matchp abnf::cst "statement-expression")
                   (equal (cst-statement-expression-conc? abnf::cst)
                          3))))
 (abnf::tree-nonleaf->branches abnf::cst))

Theorem: tree-list-listp-of-cst-statement-expression-conc3

(defthm tree-list-listp-of-cst-statement-expression-conc3
  (b* ((abnf::cstss (cst-statement-expression-conc3 abnf::cst)))
    (abnf::tree-list-listp abnf::cstss))
  :rule-classes :rewrite)

Theorem: cst-statement-expression-conc3-match

(defthm cst-statement-expression-conc3-match
 (implies
      (and (cst-matchp abnf::cst "statement-expression")
           (equal (cst-statement-expression-conc? abnf::cst)
                  3))
      (b* ((abnf::cstss (cst-statement-expression-conc3 abnf::cst)))
        (cst-list-list-conc-matchp abnf::cstss
                                   "pre-decrement-expression")))
 :rule-classes :rewrite)

Theorem: cst-statement-expression-conc3-of-tree-fix-cst

(defthm cst-statement-expression-conc3-of-tree-fix-cst
  (equal (cst-statement-expression-conc3 (abnf::tree-fix abnf::cst))
         (cst-statement-expression-conc3 abnf::cst)))

Theorem: cst-statement-expression-conc3-tree-equiv-congruence-on-cst

(defthm cst-statement-expression-conc3-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-statement-expression-conc3 abnf::cst)
                  (cst-statement-expression-conc3 cst-equiv)))
  :rule-classes :congruence)

Function: cst-statement-expression-conc4

(defun cst-statement-expression-conc4 (abnf::cst)
 (declare (xargs :guard (abnf::treep abnf::cst)))
 (declare
  (xargs
       :guard (and (cst-matchp abnf::cst "statement-expression")
                   (equal (cst-statement-expression-conc? abnf::cst)
                          4))))
 (abnf::tree-nonleaf->branches abnf::cst))

Theorem: tree-list-listp-of-cst-statement-expression-conc4

(defthm tree-list-listp-of-cst-statement-expression-conc4
  (b* ((abnf::cstss (cst-statement-expression-conc4 abnf::cst)))
    (abnf::tree-list-listp abnf::cstss))
  :rule-classes :rewrite)

Theorem: cst-statement-expression-conc4-match

(defthm cst-statement-expression-conc4-match
 (implies
      (and (cst-matchp abnf::cst "statement-expression")
           (equal (cst-statement-expression-conc? abnf::cst)
                  4))
      (b* ((abnf::cstss (cst-statement-expression-conc4 abnf::cst)))
        (cst-list-list-conc-matchp abnf::cstss
                                   "post-increment-expression")))
 :rule-classes :rewrite)

Theorem: cst-statement-expression-conc4-of-tree-fix-cst

(defthm cst-statement-expression-conc4-of-tree-fix-cst
  (equal (cst-statement-expression-conc4 (abnf::tree-fix abnf::cst))
         (cst-statement-expression-conc4 abnf::cst)))

Theorem: cst-statement-expression-conc4-tree-equiv-congruence-on-cst

(defthm cst-statement-expression-conc4-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-statement-expression-conc4 abnf::cst)
                  (cst-statement-expression-conc4 cst-equiv)))
  :rule-classes :congruence)

Function: cst-statement-expression-conc5

(defun cst-statement-expression-conc5 (abnf::cst)
 (declare (xargs :guard (abnf::treep abnf::cst)))
 (declare
  (xargs
       :guard (and (cst-matchp abnf::cst "statement-expression")
                   (equal (cst-statement-expression-conc? abnf::cst)
                          5))))
 (abnf::tree-nonleaf->branches abnf::cst))

Theorem: tree-list-listp-of-cst-statement-expression-conc5

(defthm tree-list-listp-of-cst-statement-expression-conc5
  (b* ((abnf::cstss (cst-statement-expression-conc5 abnf::cst)))
    (abnf::tree-list-listp abnf::cstss))
  :rule-classes :rewrite)

Theorem: cst-statement-expression-conc5-match

(defthm cst-statement-expression-conc5-match
 (implies
      (and (cst-matchp abnf::cst "statement-expression")
           (equal (cst-statement-expression-conc? abnf::cst)
                  5))
      (b* ((abnf::cstss (cst-statement-expression-conc5 abnf::cst)))
        (cst-list-list-conc-matchp abnf::cstss
                                   "post-decrement-expression")))
 :rule-classes :rewrite)

Theorem: cst-statement-expression-conc5-of-tree-fix-cst

(defthm cst-statement-expression-conc5-of-tree-fix-cst
  (equal (cst-statement-expression-conc5 (abnf::tree-fix abnf::cst))
         (cst-statement-expression-conc5 abnf::cst)))

Theorem: cst-statement-expression-conc5-tree-equiv-congruence-on-cst

(defthm cst-statement-expression-conc5-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-statement-expression-conc5 abnf::cst)
                  (cst-statement-expression-conc5 cst-equiv)))
  :rule-classes :congruence)

Function: cst-statement-expression-conc6

(defun cst-statement-expression-conc6 (abnf::cst)
 (declare (xargs :guard (abnf::treep abnf::cst)))
 (declare
  (xargs
       :guard (and (cst-matchp abnf::cst "statement-expression")
                   (equal (cst-statement-expression-conc? abnf::cst)
                          6))))
 (abnf::tree-nonleaf->branches abnf::cst))

Theorem: tree-list-listp-of-cst-statement-expression-conc6

(defthm tree-list-listp-of-cst-statement-expression-conc6
  (b* ((abnf::cstss (cst-statement-expression-conc6 abnf::cst)))
    (abnf::tree-list-listp abnf::cstss))
  :rule-classes :rewrite)

Theorem: cst-statement-expression-conc6-match

(defthm cst-statement-expression-conc6-match
 (implies
     (and (cst-matchp abnf::cst "statement-expression")
          (equal (cst-statement-expression-conc? abnf::cst)
                 6))
     (b* ((abnf::cstss (cst-statement-expression-conc6 abnf::cst)))
       (cst-list-list-conc-matchp abnf::cstss "method-invocation")))
 :rule-classes :rewrite)

Theorem: cst-statement-expression-conc6-of-tree-fix-cst

(defthm cst-statement-expression-conc6-of-tree-fix-cst
  (equal (cst-statement-expression-conc6 (abnf::tree-fix abnf::cst))
         (cst-statement-expression-conc6 abnf::cst)))

Theorem: cst-statement-expression-conc6-tree-equiv-congruence-on-cst

(defthm cst-statement-expression-conc6-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-statement-expression-conc6 abnf::cst)
                  (cst-statement-expression-conc6 cst-equiv)))
  :rule-classes :congruence)

Function: cst-statement-expression-conc7

(defun cst-statement-expression-conc7 (abnf::cst)
 (declare (xargs :guard (abnf::treep abnf::cst)))
 (declare
  (xargs
       :guard (and (cst-matchp abnf::cst "statement-expression")
                   (equal (cst-statement-expression-conc? abnf::cst)
                          7))))
 (abnf::tree-nonleaf->branches abnf::cst))

Theorem: tree-list-listp-of-cst-statement-expression-conc7

(defthm tree-list-listp-of-cst-statement-expression-conc7
  (b* ((abnf::cstss (cst-statement-expression-conc7 abnf::cst)))
    (abnf::tree-list-listp abnf::cstss))
  :rule-classes :rewrite)

Theorem: cst-statement-expression-conc7-match

(defthm cst-statement-expression-conc7-match
 (implies
      (and (cst-matchp abnf::cst "statement-expression")
           (equal (cst-statement-expression-conc? abnf::cst)
                  7))
      (b* ((abnf::cstss (cst-statement-expression-conc7 abnf::cst)))
        (cst-list-list-conc-matchp
             abnf::cstss
             "class-instance-creation-expression")))
 :rule-classes :rewrite)

Theorem: cst-statement-expression-conc7-of-tree-fix-cst

(defthm cst-statement-expression-conc7-of-tree-fix-cst
  (equal (cst-statement-expression-conc7 (abnf::tree-fix abnf::cst))
         (cst-statement-expression-conc7 abnf::cst)))

Theorem: cst-statement-expression-conc7-tree-equiv-congruence-on-cst

(defthm cst-statement-expression-conc7-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-statement-expression-conc7 abnf::cst)
                  (cst-statement-expression-conc7 cst-equiv)))
  :rule-classes :congruence)

Function: cst-if-then-statement-conc

(defun cst-if-then-statement-conc (abnf::cst)
 (declare (xargs :guard (abnf::treep abnf::cst)))
 (declare (xargs :guard (cst-matchp abnf::cst "if-then-statement")))
 (abnf::tree-nonleaf->branches abnf::cst))

Theorem: tree-list-listp-of-cst-if-then-statement-conc

(defthm tree-list-listp-of-cst-if-then-statement-conc
  (b* ((abnf::cstss (cst-if-then-statement-conc abnf::cst)))
    (abnf::tree-list-listp abnf::cstss))
  :rule-classes :rewrite)

Theorem: cst-if-then-statement-conc-match

(defthm cst-if-then-statement-conc-match
 (implies (cst-matchp abnf::cst "if-then-statement")
          (b* ((abnf::cstss (cst-if-then-statement-conc abnf::cst)))
            (cst-list-list-conc-matchp
                 abnf::cstss
                 "%s\"if\" \"(\" expression \")\" statement")))
 :rule-classes :rewrite)

Theorem: cst-if-then-statement-conc-of-tree-fix-cst

(defthm cst-if-then-statement-conc-of-tree-fix-cst
  (equal (cst-if-then-statement-conc (abnf::tree-fix abnf::cst))
         (cst-if-then-statement-conc abnf::cst)))

Theorem: cst-if-then-statement-conc-tree-equiv-congruence-on-cst

(defthm cst-if-then-statement-conc-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-if-then-statement-conc abnf::cst)
                  (cst-if-then-statement-conc cst-equiv)))
  :rule-classes :congruence)

Function: cst-if-then-else-statement-conc

(defun cst-if-then-else-statement-conc (abnf::cst)
 (declare (xargs :guard (abnf::treep abnf::cst)))
 (declare
     (xargs :guard (cst-matchp abnf::cst "if-then-else-statement")))
 (abnf::tree-nonleaf->branches abnf::cst))

Theorem: tree-list-listp-of-cst-if-then-else-statement-conc

(defthm tree-list-listp-of-cst-if-then-else-statement-conc
  (b* ((abnf::cstss (cst-if-then-else-statement-conc abnf::cst)))
    (abnf::tree-list-listp abnf::cstss))
  :rule-classes :rewrite)

Theorem: cst-if-then-else-statement-conc-match

(defthm cst-if-then-else-statement-conc-match
 (implies
  (cst-matchp abnf::cst "if-then-else-statement")
  (b* ((abnf::cstss (cst-if-then-else-statement-conc abnf::cst)))
   (cst-list-list-conc-matchp
    abnf::cstss
    "%s\"if\" \"(\" expression \")\" statement-no-short-if %s\"else\" statement")))
 :rule-classes :rewrite)

Theorem: cst-if-then-else-statement-conc-of-tree-fix-cst

(defthm cst-if-then-else-statement-conc-of-tree-fix-cst
 (equal (cst-if-then-else-statement-conc (abnf::tree-fix abnf::cst))
        (cst-if-then-else-statement-conc abnf::cst)))

Theorem: cst-if-then-else-statement-conc-tree-equiv-congruence-on-cst

(defthm cst-if-then-else-statement-conc-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-if-then-else-statement-conc abnf::cst)
                  (cst-if-then-else-statement-conc cst-equiv)))
  :rule-classes :congruence)

Function: cst-if-then-else-statement-no-short-if-conc

(defun cst-if-then-else-statement-no-short-if-conc (abnf::cst)
 (declare (xargs :guard (abnf::treep abnf::cst)))
 (declare
   (xargs :guard (cst-matchp abnf::cst
                             "if-then-else-statement-no-short-if")))
 (abnf::tree-nonleaf->branches abnf::cst))

Theorem: tree-list-listp-of-cst-if-then-else-statement-no-short-if-conc

(defthm
     tree-list-listp-of-cst-if-then-else-statement-no-short-if-conc
 (b* ((abnf::cstss
           (cst-if-then-else-statement-no-short-if-conc abnf::cst)))
   (abnf::tree-list-listp abnf::cstss))
 :rule-classes :rewrite)

Theorem: cst-if-then-else-statement-no-short-if-conc-match

(defthm cst-if-then-else-statement-no-short-if-conc-match
 (implies
  (cst-matchp abnf::cst
              "if-then-else-statement-no-short-if")
  (b*
    ((abnf::cstss
          (cst-if-then-else-statement-no-short-if-conc abnf::cst)))
   (cst-list-list-conc-matchp
    abnf::cstss
    "%s\"if\" \"(\" expression \")\" statement-no-short-if %s\"else\" statement-no-short-if")))
 :rule-classes :rewrite)

Theorem: cst-if-then-else-statement-no-short-if-conc-of-tree-fix-cst

(defthm cst-if-then-else-statement-no-short-if-conc-of-tree-fix-cst
  (equal (cst-if-then-else-statement-no-short-if-conc
              (abnf::tree-fix abnf::cst))
         (cst-if-then-else-statement-no-short-if-conc abnf::cst)))

Theorem: cst-if-then-else-statement-no-short-if-conc-tree-equiv-congruence-on-cst

(defthm
 cst-if-then-else-statement-no-short-if-conc-tree-equiv-congruence-on-cst
 (implies
    (abnf::tree-equiv abnf::cst cst-equiv)
    (equal (cst-if-then-else-statement-no-short-if-conc abnf::cst)
           (cst-if-then-else-statement-no-short-if-conc cst-equiv)))
 :rule-classes :congruence)

Function: cst-switch-statement-conc

(defun cst-switch-statement-conc (abnf::cst)
  (declare (xargs :guard (abnf::treep abnf::cst)))
  (declare (xargs :guard (cst-matchp abnf::cst "switch-statement")))
  (abnf::tree-nonleaf->branches abnf::cst))

Theorem: tree-list-listp-of-cst-switch-statement-conc

(defthm tree-list-listp-of-cst-switch-statement-conc
  (b* ((abnf::cstss (cst-switch-statement-conc abnf::cst)))
    (abnf::tree-list-listp abnf::cstss))
  :rule-classes :rewrite)

Theorem: cst-switch-statement-conc-match

(defthm cst-switch-statement-conc-match
  (implies (cst-matchp abnf::cst "switch-statement")
           (b* ((abnf::cstss (cst-switch-statement-conc abnf::cst)))
             (cst-list-list-conc-matchp
                  abnf::cstss
                  "%s\"switch\" \"(\" expression \")\" switch-block")))
  :rule-classes :rewrite)

Theorem: cst-switch-statement-conc-of-tree-fix-cst

(defthm cst-switch-statement-conc-of-tree-fix-cst
  (equal (cst-switch-statement-conc (abnf::tree-fix abnf::cst))
         (cst-switch-statement-conc abnf::cst)))

Theorem: cst-switch-statement-conc-tree-equiv-congruence-on-cst

(defthm cst-switch-statement-conc-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-switch-statement-conc abnf::cst)
                  (cst-switch-statement-conc cst-equiv)))
  :rule-classes :congruence)

Function: cst-switch-block-statement-group-conc

(defun cst-switch-block-statement-group-conc (abnf::cst)
  (declare (xargs :guard (abnf::treep abnf::cst)))
  (declare
       (xargs :guard (cst-matchp abnf::cst
                                 "switch-block-statement-group")))
  (abnf::tree-nonleaf->branches abnf::cst))

Theorem: tree-list-listp-of-cst-switch-block-statement-group-conc

(defthm tree-list-listp-of-cst-switch-block-statement-group-conc
  (b*
   ((abnf::cstss (cst-switch-block-statement-group-conc abnf::cst)))
   (abnf::tree-list-listp abnf::cstss))
  :rule-classes :rewrite)

Theorem: cst-switch-block-statement-group-conc-match

(defthm cst-switch-block-statement-group-conc-match
 (implies
  (cst-matchp abnf::cst
              "switch-block-statement-group")
  (b*
   ((abnf::cstss (cst-switch-block-statement-group-conc abnf::cst)))
   (cst-list-list-conc-matchp
        abnf::cstss
        "switch-label \":\" *( switch-label \":\" ) block-statements")))
 :rule-classes :rewrite)

Theorem: cst-switch-block-statement-group-conc-of-tree-fix-cst

(defthm cst-switch-block-statement-group-conc-of-tree-fix-cst
 (equal
  (cst-switch-block-statement-group-conc (abnf::tree-fix abnf::cst))
  (cst-switch-block-statement-group-conc abnf::cst)))

Theorem: cst-switch-block-statement-group-conc-tree-equiv-congruence-on-cst

(defthm
 cst-switch-block-statement-group-conc-tree-equiv-congruence-on-cst
 (implies (abnf::tree-equiv abnf::cst cst-equiv)
          (equal (cst-switch-block-statement-group-conc abnf::cst)
                 (cst-switch-block-statement-group-conc cst-equiv)))
 :rule-classes :congruence)

Function: cst-case-constant-conc

(defun cst-case-constant-conc (abnf::cst)
  (declare (xargs :guard (abnf::treep abnf::cst)))
  (declare (xargs :guard (cst-matchp abnf::cst "case-constant")))
  (abnf::tree-nonleaf->branches abnf::cst))

Theorem: tree-list-listp-of-cst-case-constant-conc

(defthm tree-list-listp-of-cst-case-constant-conc
  (b* ((abnf::cstss (cst-case-constant-conc abnf::cst)))
    (abnf::tree-list-listp abnf::cstss))
  :rule-classes :rewrite)

Theorem: cst-case-constant-conc-match

(defthm cst-case-constant-conc-match
  (implies (cst-matchp abnf::cst "case-constant")
           (b* ((abnf::cstss (cst-case-constant-conc abnf::cst)))
             (cst-list-list-conc-matchp
                  abnf::cstss "conditional-expression")))
  :rule-classes :rewrite)

Theorem: cst-case-constant-conc-of-tree-fix-cst

(defthm cst-case-constant-conc-of-tree-fix-cst
  (equal (cst-case-constant-conc (abnf::tree-fix abnf::cst))
         (cst-case-constant-conc abnf::cst)))

Theorem: cst-case-constant-conc-tree-equiv-congruence-on-cst

(defthm cst-case-constant-conc-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-case-constant-conc abnf::cst)
                  (cst-case-constant-conc cst-equiv)))
  :rule-classes :congruence)

Function: cst-case-pattern-conc

(defun cst-case-pattern-conc (abnf::cst)
  (declare (xargs :guard (abnf::treep abnf::cst)))
  (declare (xargs :guard (cst-matchp abnf::cst "case-pattern")))
  (abnf::tree-nonleaf->branches abnf::cst))

Theorem: tree-list-listp-of-cst-case-pattern-conc

(defthm tree-list-listp-of-cst-case-pattern-conc
  (b* ((abnf::cstss (cst-case-pattern-conc abnf::cst)))
    (abnf::tree-list-listp abnf::cstss))
  :rule-classes :rewrite)

Theorem: cst-case-pattern-conc-match

(defthm cst-case-pattern-conc-match
  (implies (cst-matchp abnf::cst "case-pattern")
           (b* ((abnf::cstss (cst-case-pattern-conc abnf::cst)))
             (cst-list-list-conc-matchp abnf::cstss "pattern")))
  :rule-classes :rewrite)

Theorem: cst-case-pattern-conc-of-tree-fix-cst

(defthm cst-case-pattern-conc-of-tree-fix-cst
  (equal (cst-case-pattern-conc (abnf::tree-fix abnf::cst))
         (cst-case-pattern-conc abnf::cst)))

Theorem: cst-case-pattern-conc-tree-equiv-congruence-on-cst

(defthm cst-case-pattern-conc-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-case-pattern-conc abnf::cst)
                  (cst-case-pattern-conc cst-equiv)))
  :rule-classes :congruence)

Function: cst-guard-conc

(defun cst-guard-conc (abnf::cst)
  (declare (xargs :guard (abnf::treep abnf::cst)))
  (declare (xargs :guard (cst-matchp abnf::cst "guard")))
  (abnf::tree-nonleaf->branches abnf::cst))

Theorem: tree-list-listp-of-cst-guard-conc

(defthm tree-list-listp-of-cst-guard-conc
  (b* ((abnf::cstss (cst-guard-conc abnf::cst)))
    (abnf::tree-list-listp abnf::cstss))
  :rule-classes :rewrite)

Theorem: cst-guard-conc-match

(defthm cst-guard-conc-match
 (implies
   (cst-matchp abnf::cst "guard")
   (b* ((abnf::cstss (cst-guard-conc abnf::cst)))
     (cst-list-list-conc-matchp abnf::cstss "%s\"when\" expression")))
 :rule-classes :rewrite)

Theorem: cst-guard-conc-of-tree-fix-cst

(defthm cst-guard-conc-of-tree-fix-cst
  (equal (cst-guard-conc (abnf::tree-fix abnf::cst))
         (cst-guard-conc abnf::cst)))

Theorem: cst-guard-conc-tree-equiv-congruence-on-cst

(defthm cst-guard-conc-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-guard-conc abnf::cst)
                  (cst-guard-conc cst-equiv)))
  :rule-classes :congruence)

Function: cst-while-statement-conc

(defun cst-while-statement-conc (abnf::cst)
  (declare (xargs :guard (abnf::treep abnf::cst)))
  (declare (xargs :guard (cst-matchp abnf::cst "while-statement")))
  (abnf::tree-nonleaf->branches abnf::cst))

Theorem: tree-list-listp-of-cst-while-statement-conc

(defthm tree-list-listp-of-cst-while-statement-conc
  (b* ((abnf::cstss (cst-while-statement-conc abnf::cst)))
    (abnf::tree-list-listp abnf::cstss))
  :rule-classes :rewrite)

Theorem: cst-while-statement-conc-match

(defthm cst-while-statement-conc-match
  (implies (cst-matchp abnf::cst "while-statement")
           (b* ((abnf::cstss (cst-while-statement-conc abnf::cst)))
             (cst-list-list-conc-matchp
                  abnf::cstss
                  "%s\"while\" \"(\" expression \")\" statement")))
  :rule-classes :rewrite)

Theorem: cst-while-statement-conc-of-tree-fix-cst

(defthm cst-while-statement-conc-of-tree-fix-cst
  (equal (cst-while-statement-conc (abnf::tree-fix abnf::cst))
         (cst-while-statement-conc abnf::cst)))

Theorem: cst-while-statement-conc-tree-equiv-congruence-on-cst

(defthm cst-while-statement-conc-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-while-statement-conc abnf::cst)
                  (cst-while-statement-conc cst-equiv)))
  :rule-classes :congruence)

Function: cst-while-statement-no-short-if-conc

(defun cst-while-statement-no-short-if-conc (abnf::cst)
 (declare (xargs :guard (abnf::treep abnf::cst)))
 (declare (xargs :guard (cst-matchp abnf::cst
                                    "while-statement-no-short-if")))
 (abnf::tree-nonleaf->branches abnf::cst))

Theorem: tree-list-listp-of-cst-while-statement-no-short-if-conc

(defthm tree-list-listp-of-cst-while-statement-no-short-if-conc
  (b*
    ((abnf::cstss (cst-while-statement-no-short-if-conc abnf::cst)))
    (abnf::tree-list-listp abnf::cstss))
  :rule-classes :rewrite)

Theorem: cst-while-statement-no-short-if-conc-match

(defthm cst-while-statement-no-short-if-conc-match
 (implies
   (cst-matchp abnf::cst "while-statement-no-short-if")
   (b*
    ((abnf::cstss (cst-while-statement-no-short-if-conc abnf::cst)))
    (cst-list-list-conc-matchp
         abnf::cstss
         "%s\"while\" \"(\" expression \")\" statement-no-short-if")))
 :rule-classes :rewrite)

Theorem: cst-while-statement-no-short-if-conc-of-tree-fix-cst

(defthm cst-while-statement-no-short-if-conc-of-tree-fix-cst
 (equal
   (cst-while-statement-no-short-if-conc (abnf::tree-fix abnf::cst))
   (cst-while-statement-no-short-if-conc abnf::cst)))

Theorem: cst-while-statement-no-short-if-conc-tree-equiv-congruence-on-cst

(defthm
  cst-while-statement-no-short-if-conc-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-while-statement-no-short-if-conc abnf::cst)
                  (cst-while-statement-no-short-if-conc cst-equiv)))
  :rule-classes :congruence)

Function: cst-do-statement-conc

(defun cst-do-statement-conc (abnf::cst)
  (declare (xargs :guard (abnf::treep abnf::cst)))
  (declare (xargs :guard (cst-matchp abnf::cst "do-statement")))
  (abnf::tree-nonleaf->branches abnf::cst))

Theorem: tree-list-listp-of-cst-do-statement-conc

(defthm tree-list-listp-of-cst-do-statement-conc
  (b* ((abnf::cstss (cst-do-statement-conc abnf::cst)))
    (abnf::tree-list-listp abnf::cstss))
  :rule-classes :rewrite)

Theorem: cst-do-statement-conc-match

(defthm cst-do-statement-conc-match
  (implies
       (cst-matchp abnf::cst "do-statement")
       (b* ((abnf::cstss (cst-do-statement-conc abnf::cst)))
         (cst-list-list-conc-matchp
              abnf::cstss
              "%s\"do\" statement %s\"while\" \"(\" expression \")\" \";\"")))
  :rule-classes :rewrite)

Theorem: cst-do-statement-conc-of-tree-fix-cst

(defthm cst-do-statement-conc-of-tree-fix-cst
  (equal (cst-do-statement-conc (abnf::tree-fix abnf::cst))
         (cst-do-statement-conc abnf::cst)))

Theorem: cst-do-statement-conc-tree-equiv-congruence-on-cst

(defthm cst-do-statement-conc-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-do-statement-conc abnf::cst)
                  (cst-do-statement-conc cst-equiv)))
  :rule-classes :congruence)

Function: cst-for-statement-conc1

(defun cst-for-statement-conc1 (abnf::cst)
  (declare (xargs :guard (abnf::treep abnf::cst)))
  (declare
       (xargs :guard (and (cst-matchp abnf::cst "for-statement")
                          (equal (cst-for-statement-conc? abnf::cst)
                                 1))))
  (abnf::tree-nonleaf->branches abnf::cst))

Theorem: tree-list-listp-of-cst-for-statement-conc1

(defthm tree-list-listp-of-cst-for-statement-conc1
  (b* ((abnf::cstss (cst-for-statement-conc1 abnf::cst)))
    (abnf::tree-list-listp abnf::cstss))
  :rule-classes :rewrite)

Theorem: cst-for-statement-conc1-match

(defthm cst-for-statement-conc1-match
 (implies
   (and (cst-matchp abnf::cst "for-statement")
        (equal (cst-for-statement-conc? abnf::cst)
               1))
   (b* ((abnf::cstss (cst-for-statement-conc1 abnf::cst)))
     (cst-list-list-conc-matchp abnf::cstss "basic-for-statement")))
 :rule-classes :rewrite)

Theorem: cst-for-statement-conc1-of-tree-fix-cst

(defthm cst-for-statement-conc1-of-tree-fix-cst
  (equal (cst-for-statement-conc1 (abnf::tree-fix abnf::cst))
         (cst-for-statement-conc1 abnf::cst)))

Theorem: cst-for-statement-conc1-tree-equiv-congruence-on-cst

(defthm cst-for-statement-conc1-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-for-statement-conc1 abnf::cst)
                  (cst-for-statement-conc1 cst-equiv)))
  :rule-classes :congruence)

Function: cst-for-statement-conc2

(defun cst-for-statement-conc2 (abnf::cst)
  (declare (xargs :guard (abnf::treep abnf::cst)))
  (declare
       (xargs :guard (and (cst-matchp abnf::cst "for-statement")
                          (equal (cst-for-statement-conc? abnf::cst)
                                 2))))
  (abnf::tree-nonleaf->branches abnf::cst))

Theorem: tree-list-listp-of-cst-for-statement-conc2

(defthm tree-list-listp-of-cst-for-statement-conc2
  (b* ((abnf::cstss (cst-for-statement-conc2 abnf::cst)))
    (abnf::tree-list-listp abnf::cstss))
  :rule-classes :rewrite)

Theorem: cst-for-statement-conc2-match

(defthm cst-for-statement-conc2-match
  (implies (and (cst-matchp abnf::cst "for-statement")
                (equal (cst-for-statement-conc? abnf::cst)
                       2))
           (b* ((abnf::cstss (cst-for-statement-conc2 abnf::cst)))
             (cst-list-list-conc-matchp
                  abnf::cstss "enhanced-for-statement")))
  :rule-classes :rewrite)

Theorem: cst-for-statement-conc2-of-tree-fix-cst

(defthm cst-for-statement-conc2-of-tree-fix-cst
  (equal (cst-for-statement-conc2 (abnf::tree-fix abnf::cst))
         (cst-for-statement-conc2 abnf::cst)))

Theorem: cst-for-statement-conc2-tree-equiv-congruence-on-cst

(defthm cst-for-statement-conc2-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-for-statement-conc2 abnf::cst)
                  (cst-for-statement-conc2 cst-equiv)))
  :rule-classes :congruence)

Function: cst-for-statement-no-short-if-conc1

(defun cst-for-statement-no-short-if-conc1 (abnf::cst)
 (declare (xargs :guard (abnf::treep abnf::cst)))
 (declare
  (xargs :guard
         (and (cst-matchp abnf::cst "for-statement-no-short-if")
              (equal (cst-for-statement-no-short-if-conc? abnf::cst)
                     1))))
 (abnf::tree-nonleaf->branches abnf::cst))

Theorem: tree-list-listp-of-cst-for-statement-no-short-if-conc1

(defthm tree-list-listp-of-cst-for-statement-no-short-if-conc1
 (b* ((abnf::cstss (cst-for-statement-no-short-if-conc1 abnf::cst)))
   (abnf::tree-list-listp abnf::cstss))
 :rule-classes :rewrite)

Theorem: cst-for-statement-no-short-if-conc1-match

(defthm cst-for-statement-no-short-if-conc1-match
 (implies
   (and (cst-matchp abnf::cst "for-statement-no-short-if")
        (equal (cst-for-statement-no-short-if-conc? abnf::cst)
               1))
   (b*
     ((abnf::cstss (cst-for-statement-no-short-if-conc1 abnf::cst)))
     (cst-list-list-conc-matchp abnf::cstss
                                "basic-for-statement-no-short-if")))
 :rule-classes :rewrite)

Theorem: cst-for-statement-no-short-if-conc1-of-tree-fix-cst

(defthm cst-for-statement-no-short-if-conc1-of-tree-fix-cst
 (equal
    (cst-for-statement-no-short-if-conc1 (abnf::tree-fix abnf::cst))
    (cst-for-statement-no-short-if-conc1 abnf::cst)))

Theorem: cst-for-statement-no-short-if-conc1-tree-equiv-congruence-on-cst

(defthm
   cst-for-statement-no-short-if-conc1-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-for-statement-no-short-if-conc1 abnf::cst)
                  (cst-for-statement-no-short-if-conc1 cst-equiv)))
  :rule-classes :congruence)

Function: cst-for-statement-no-short-if-conc2

(defun cst-for-statement-no-short-if-conc2 (abnf::cst)
 (declare (xargs :guard (abnf::treep abnf::cst)))
 (declare
  (xargs :guard
         (and (cst-matchp abnf::cst "for-statement-no-short-if")
              (equal (cst-for-statement-no-short-if-conc? abnf::cst)
                     2))))
 (abnf::tree-nonleaf->branches abnf::cst))

Theorem: tree-list-listp-of-cst-for-statement-no-short-if-conc2

(defthm tree-list-listp-of-cst-for-statement-no-short-if-conc2
 (b* ((abnf::cstss (cst-for-statement-no-short-if-conc2 abnf::cst)))
   (abnf::tree-list-listp abnf::cstss))
 :rule-classes :rewrite)

Theorem: cst-for-statement-no-short-if-conc2-match

(defthm cst-for-statement-no-short-if-conc2-match
 (implies
   (and (cst-matchp abnf::cst "for-statement-no-short-if")
        (equal (cst-for-statement-no-short-if-conc? abnf::cst)
               2))
   (b*
     ((abnf::cstss (cst-for-statement-no-short-if-conc2 abnf::cst)))
     (cst-list-list-conc-matchp
          abnf::cstss
          "enhanced-for-statement-no-short-if")))
 :rule-classes :rewrite)

Theorem: cst-for-statement-no-short-if-conc2-of-tree-fix-cst

(defthm cst-for-statement-no-short-if-conc2-of-tree-fix-cst
 (equal
    (cst-for-statement-no-short-if-conc2 (abnf::tree-fix abnf::cst))
    (cst-for-statement-no-short-if-conc2 abnf::cst)))

Theorem: cst-for-statement-no-short-if-conc2-tree-equiv-congruence-on-cst

(defthm
   cst-for-statement-no-short-if-conc2-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-for-statement-no-short-if-conc2 abnf::cst)
                  (cst-for-statement-no-short-if-conc2 cst-equiv)))
  :rule-classes :congruence)

Function: cst-basic-for-statement-conc

(defun cst-basic-for-statement-conc (abnf::cst)
  (declare (xargs :guard (abnf::treep abnf::cst)))
  (declare
       (xargs :guard (cst-matchp abnf::cst "basic-for-statement")))
  (abnf::tree-nonleaf->branches abnf::cst))

Theorem: tree-list-listp-of-cst-basic-for-statement-conc

(defthm tree-list-listp-of-cst-basic-for-statement-conc
  (b* ((abnf::cstss (cst-basic-for-statement-conc abnf::cst)))
    (abnf::tree-list-listp abnf::cstss))
  :rule-classes :rewrite)

Theorem: cst-basic-for-statement-conc-match

(defthm cst-basic-for-statement-conc-match
 (implies
  (cst-matchp abnf::cst "basic-for-statement")
  (b* ((abnf::cstss (cst-basic-for-statement-conc abnf::cst)))
   (cst-list-list-conc-matchp
    abnf::cstss
    "%s\"for\" \"(\" [ for-init ] \";\" [ expression ] \";\" [ for-update ] \")\" statement")))
 :rule-classes :rewrite)

Theorem: cst-basic-for-statement-conc-of-tree-fix-cst

(defthm cst-basic-for-statement-conc-of-tree-fix-cst
  (equal (cst-basic-for-statement-conc (abnf::tree-fix abnf::cst))
         (cst-basic-for-statement-conc abnf::cst)))

Theorem: cst-basic-for-statement-conc-tree-equiv-congruence-on-cst

(defthm cst-basic-for-statement-conc-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-basic-for-statement-conc abnf::cst)
                  (cst-basic-for-statement-conc cst-equiv)))
  :rule-classes :congruence)

Function: cst-basic-for-statement-no-short-if-conc

(defun cst-basic-for-statement-no-short-if-conc (abnf::cst)
 (declare (xargs :guard (abnf::treep abnf::cst)))
 (declare
      (xargs :guard (cst-matchp abnf::cst
                                "basic-for-statement-no-short-if")))
 (abnf::tree-nonleaf->branches abnf::cst))

Theorem: tree-list-listp-of-cst-basic-for-statement-no-short-if-conc

(defthm tree-list-listp-of-cst-basic-for-statement-no-short-if-conc
  (b* ((abnf::cstss
            (cst-basic-for-statement-no-short-if-conc abnf::cst)))
    (abnf::tree-list-listp abnf::cstss))
  :rule-classes :rewrite)

Theorem: cst-basic-for-statement-no-short-if-conc-match

(defthm cst-basic-for-statement-no-short-if-conc-match
 (implies
  (cst-matchp abnf::cst
              "basic-for-statement-no-short-if")
  (b* ((abnf::cstss
            (cst-basic-for-statement-no-short-if-conc abnf::cst)))
   (cst-list-list-conc-matchp
    abnf::cstss
    "%s\"for\" \"(\" [ for-init ] \";\" [ expression ] \";\" [ for-update ] \")\" statement-no-short-if")))
 :rule-classes :rewrite)

Theorem: cst-basic-for-statement-no-short-if-conc-of-tree-fix-cst

(defthm cst-basic-for-statement-no-short-if-conc-of-tree-fix-cst
  (equal (cst-basic-for-statement-no-short-if-conc
              (abnf::tree-fix abnf::cst))
         (cst-basic-for-statement-no-short-if-conc abnf::cst)))

Theorem: cst-basic-for-statement-no-short-if-conc-tree-equiv-congruence-on-cst

(defthm
 cst-basic-for-statement-no-short-if-conc-tree-equiv-congruence-on-cst
 (implies
      (abnf::tree-equiv abnf::cst cst-equiv)
      (equal (cst-basic-for-statement-no-short-if-conc abnf::cst)
             (cst-basic-for-statement-no-short-if-conc cst-equiv)))
 :rule-classes :congruence)

Function: cst-for-init-conc1

(defun cst-for-init-conc1 (abnf::cst)
  (declare (xargs :guard (abnf::treep abnf::cst)))
  (declare (xargs :guard (and (cst-matchp abnf::cst "for-init")
                              (equal (cst-for-init-conc? abnf::cst)
                                     1))))
  (abnf::tree-nonleaf->branches abnf::cst))

Theorem: tree-list-listp-of-cst-for-init-conc1

(defthm tree-list-listp-of-cst-for-init-conc1
  (b* ((abnf::cstss (cst-for-init-conc1 abnf::cst)))
    (abnf::tree-list-listp abnf::cstss))
  :rule-classes :rewrite)

Theorem: cst-for-init-conc1-match

(defthm cst-for-init-conc1-match
  (implies
       (and (cst-matchp abnf::cst "for-init")
            (equal (cst-for-init-conc? abnf::cst)
                   1))
       (b* ((abnf::cstss (cst-for-init-conc1 abnf::cst)))
         (cst-list-list-conc-matchp abnf::cstss
                                    "statement-expression-list")))
  :rule-classes :rewrite)

Theorem: cst-for-init-conc1-of-tree-fix-cst

(defthm cst-for-init-conc1-of-tree-fix-cst
  (equal (cst-for-init-conc1 (abnf::tree-fix abnf::cst))
         (cst-for-init-conc1 abnf::cst)))

Theorem: cst-for-init-conc1-tree-equiv-congruence-on-cst

(defthm cst-for-init-conc1-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-for-init-conc1 abnf::cst)
                  (cst-for-init-conc1 cst-equiv)))
  :rule-classes :congruence)

Function: cst-for-init-conc2

(defun cst-for-init-conc2 (abnf::cst)
  (declare (xargs :guard (abnf::treep abnf::cst)))
  (declare (xargs :guard (and (cst-matchp abnf::cst "for-init")
                              (equal (cst-for-init-conc? abnf::cst)
                                     2))))
  (abnf::tree-nonleaf->branches abnf::cst))

Theorem: tree-list-listp-of-cst-for-init-conc2

(defthm tree-list-listp-of-cst-for-init-conc2
  (b* ((abnf::cstss (cst-for-init-conc2 abnf::cst)))
    (abnf::tree-list-listp abnf::cstss))
  :rule-classes :rewrite)

Theorem: cst-for-init-conc2-match

(defthm cst-for-init-conc2-match
  (implies
       (and (cst-matchp abnf::cst "for-init")
            (equal (cst-for-init-conc? abnf::cst)
                   2))
       (b* ((abnf::cstss (cst-for-init-conc2 abnf::cst)))
         (cst-list-list-conc-matchp abnf::cstss
                                    "local-variable-declaration")))
  :rule-classes :rewrite)

Theorem: cst-for-init-conc2-of-tree-fix-cst

(defthm cst-for-init-conc2-of-tree-fix-cst
  (equal (cst-for-init-conc2 (abnf::tree-fix abnf::cst))
         (cst-for-init-conc2 abnf::cst)))

Theorem: cst-for-init-conc2-tree-equiv-congruence-on-cst

(defthm cst-for-init-conc2-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-for-init-conc2 abnf::cst)
                  (cst-for-init-conc2 cst-equiv)))
  :rule-classes :congruence)

Function: cst-for-update-conc

(defun cst-for-update-conc (abnf::cst)
  (declare (xargs :guard (abnf::treep abnf::cst)))
  (declare (xargs :guard (cst-matchp abnf::cst "for-update")))
  (abnf::tree-nonleaf->branches abnf::cst))

Theorem: tree-list-listp-of-cst-for-update-conc

(defthm tree-list-listp-of-cst-for-update-conc
  (b* ((abnf::cstss (cst-for-update-conc abnf::cst)))
    (abnf::tree-list-listp abnf::cstss))
  :rule-classes :rewrite)

Theorem: cst-for-update-conc-match

(defthm cst-for-update-conc-match
  (implies
       (cst-matchp abnf::cst "for-update")
       (b* ((abnf::cstss (cst-for-update-conc abnf::cst)))
         (cst-list-list-conc-matchp abnf::cstss
                                    "statement-expression-list")))
  :rule-classes :rewrite)

Theorem: cst-for-update-conc-of-tree-fix-cst

(defthm cst-for-update-conc-of-tree-fix-cst
  (equal (cst-for-update-conc (abnf::tree-fix abnf::cst))
         (cst-for-update-conc abnf::cst)))

Theorem: cst-for-update-conc-tree-equiv-congruence-on-cst

(defthm cst-for-update-conc-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-for-update-conc abnf::cst)
                  (cst-for-update-conc cst-equiv)))
  :rule-classes :congruence)

Function: cst-statement-expression-list-conc

(defun cst-statement-expression-list-conc (abnf::cst)
 (declare (xargs :guard (abnf::treep abnf::cst)))
 (declare
  (xargs :guard (cst-matchp abnf::cst "statement-expression-list")))
 (abnf::tree-nonleaf->branches abnf::cst))

Theorem: tree-list-listp-of-cst-statement-expression-list-conc

(defthm tree-list-listp-of-cst-statement-expression-list-conc
  (b* ((abnf::cstss (cst-statement-expression-list-conc abnf::cst)))
    (abnf::tree-list-listp abnf::cstss))
  :rule-classes :rewrite)

Theorem: cst-statement-expression-list-conc-match

(defthm cst-statement-expression-list-conc-match
 (implies
  (cst-matchp abnf::cst "statement-expression-list")
  (b* ((abnf::cstss (cst-statement-expression-list-conc abnf::cst)))
    (cst-list-list-conc-matchp
         abnf::cstss
         "statement-expression *( \",\" statement-expression )")))
 :rule-classes :rewrite)

Theorem: cst-statement-expression-list-conc-of-tree-fix-cst

(defthm cst-statement-expression-list-conc-of-tree-fix-cst
 (equal
     (cst-statement-expression-list-conc (abnf::tree-fix abnf::cst))
     (cst-statement-expression-list-conc abnf::cst)))

Theorem: cst-statement-expression-list-conc-tree-equiv-congruence-on-cst

(defthm
    cst-statement-expression-list-conc-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-statement-expression-list-conc abnf::cst)
                  (cst-statement-expression-list-conc cst-equiv)))
  :rule-classes :congruence)

Function: cst-enhanced-for-statement-conc

(defun cst-enhanced-for-statement-conc (abnf::cst)
 (declare (xargs :guard (abnf::treep abnf::cst)))
 (declare
     (xargs :guard (cst-matchp abnf::cst "enhanced-for-statement")))
 (abnf::tree-nonleaf->branches abnf::cst))

Theorem: tree-list-listp-of-cst-enhanced-for-statement-conc

(defthm tree-list-listp-of-cst-enhanced-for-statement-conc
  (b* ((abnf::cstss (cst-enhanced-for-statement-conc abnf::cst)))
    (abnf::tree-list-listp abnf::cstss))
  :rule-classes :rewrite)

Theorem: cst-enhanced-for-statement-conc-match

(defthm cst-enhanced-for-statement-conc-match
 (implies
  (cst-matchp abnf::cst "enhanced-for-statement")
  (b* ((abnf::cstss (cst-enhanced-for-statement-conc abnf::cst)))
   (cst-list-list-conc-matchp
    abnf::cstss
    "%s\"for\" \"(\" local-variable-declaration \":\" expression \")\" statement")))
 :rule-classes :rewrite)

Theorem: cst-enhanced-for-statement-conc-of-tree-fix-cst

(defthm cst-enhanced-for-statement-conc-of-tree-fix-cst
 (equal (cst-enhanced-for-statement-conc (abnf::tree-fix abnf::cst))
        (cst-enhanced-for-statement-conc abnf::cst)))

Theorem: cst-enhanced-for-statement-conc-tree-equiv-congruence-on-cst

(defthm cst-enhanced-for-statement-conc-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-enhanced-for-statement-conc abnf::cst)
                  (cst-enhanced-for-statement-conc cst-equiv)))
  :rule-classes :congruence)

Function: cst-enhanced-for-statement-no-short-if-conc

(defun cst-enhanced-for-statement-no-short-if-conc (abnf::cst)
 (declare (xargs :guard (abnf::treep abnf::cst)))
 (declare
   (xargs :guard (cst-matchp abnf::cst
                             "enhanced-for-statement-no-short-if")))
 (abnf::tree-nonleaf->branches abnf::cst))

Theorem: tree-list-listp-of-cst-enhanced-for-statement-no-short-if-conc

(defthm
     tree-list-listp-of-cst-enhanced-for-statement-no-short-if-conc
 (b* ((abnf::cstss
           (cst-enhanced-for-statement-no-short-if-conc abnf::cst)))
   (abnf::tree-list-listp abnf::cstss))
 :rule-classes :rewrite)

Theorem: cst-enhanced-for-statement-no-short-if-conc-match

(defthm cst-enhanced-for-statement-no-short-if-conc-match
 (implies
  (cst-matchp abnf::cst
              "enhanced-for-statement-no-short-if")
  (b*
    ((abnf::cstss
          (cst-enhanced-for-statement-no-short-if-conc abnf::cst)))
   (cst-list-list-conc-matchp
    abnf::cstss
    "%s\"for\" \"(\" local-variable-declaration \":\" expression \")\" statement-no-short-if")))
 :rule-classes :rewrite)

Theorem: cst-enhanced-for-statement-no-short-if-conc-of-tree-fix-cst

(defthm cst-enhanced-for-statement-no-short-if-conc-of-tree-fix-cst
  (equal (cst-enhanced-for-statement-no-short-if-conc
              (abnf::tree-fix abnf::cst))
         (cst-enhanced-for-statement-no-short-if-conc abnf::cst)))

Theorem: cst-enhanced-for-statement-no-short-if-conc-tree-equiv-congruence-on-cst

(defthm
 cst-enhanced-for-statement-no-short-if-conc-tree-equiv-congruence-on-cst
 (implies
    (abnf::tree-equiv abnf::cst cst-equiv)
    (equal (cst-enhanced-for-statement-no-short-if-conc abnf::cst)
           (cst-enhanced-for-statement-no-short-if-conc cst-equiv)))
 :rule-classes :congruence)

Function: cst-break-statement-conc

(defun cst-break-statement-conc (abnf::cst)
  (declare (xargs :guard (abnf::treep abnf::cst)))
  (declare (xargs :guard (cst-matchp abnf::cst "break-statement")))
  (abnf::tree-nonleaf->branches abnf::cst))

Theorem: tree-list-listp-of-cst-break-statement-conc

(defthm tree-list-listp-of-cst-break-statement-conc
  (b* ((abnf::cstss (cst-break-statement-conc abnf::cst)))
    (abnf::tree-list-listp abnf::cstss))
  :rule-classes :rewrite)

Theorem: cst-break-statement-conc-match

(defthm cst-break-statement-conc-match
 (implies
      (cst-matchp abnf::cst "break-statement")
      (b* ((abnf::cstss (cst-break-statement-conc abnf::cst)))
        (cst-list-list-conc-matchp abnf::cstss
                                   "%s\"break\" [ identifier ] \";\"")))
 :rule-classes :rewrite)

Theorem: cst-break-statement-conc-of-tree-fix-cst

(defthm cst-break-statement-conc-of-tree-fix-cst
  (equal (cst-break-statement-conc (abnf::tree-fix abnf::cst))
         (cst-break-statement-conc abnf::cst)))

Theorem: cst-break-statement-conc-tree-equiv-congruence-on-cst

(defthm cst-break-statement-conc-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-break-statement-conc abnf::cst)
                  (cst-break-statement-conc cst-equiv)))
  :rule-classes :congruence)

Function: cst-continue-statement-conc

(defun cst-continue-statement-conc (abnf::cst)
  (declare (xargs :guard (abnf::treep abnf::cst)))
  (declare
       (xargs :guard (cst-matchp abnf::cst "continue-statement")))
  (abnf::tree-nonleaf->branches abnf::cst))

Theorem: tree-list-listp-of-cst-continue-statement-conc

(defthm tree-list-listp-of-cst-continue-statement-conc
  (b* ((abnf::cstss (cst-continue-statement-conc abnf::cst)))
    (abnf::tree-list-listp abnf::cstss))
  :rule-classes :rewrite)

Theorem: cst-continue-statement-conc-match

(defthm cst-continue-statement-conc-match
 (implies
   (cst-matchp abnf::cst "continue-statement")
   (b* ((abnf::cstss (cst-continue-statement-conc abnf::cst)))
     (cst-list-list-conc-matchp abnf::cstss
                                "%s\"continue\" [ identifier ] \";\"")))
 :rule-classes :rewrite)

Theorem: cst-continue-statement-conc-of-tree-fix-cst

(defthm cst-continue-statement-conc-of-tree-fix-cst
  (equal (cst-continue-statement-conc (abnf::tree-fix abnf::cst))
         (cst-continue-statement-conc abnf::cst)))

Theorem: cst-continue-statement-conc-tree-equiv-congruence-on-cst

(defthm cst-continue-statement-conc-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-continue-statement-conc abnf::cst)
                  (cst-continue-statement-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")))
  (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-throw-statement-conc

(defun cst-throw-statement-conc (abnf::cst)
  (declare (xargs :guard (abnf::treep abnf::cst)))
  (declare (xargs :guard (cst-matchp abnf::cst "throw-statement")))
  (abnf::tree-nonleaf->branches abnf::cst))

Theorem: tree-list-listp-of-cst-throw-statement-conc

(defthm tree-list-listp-of-cst-throw-statement-conc
  (b* ((abnf::cstss (cst-throw-statement-conc abnf::cst)))
    (abnf::tree-list-listp abnf::cstss))
  :rule-classes :rewrite)

Theorem: cst-throw-statement-conc-match

(defthm cst-throw-statement-conc-match
 (implies (cst-matchp abnf::cst "throw-statement")
          (b* ((abnf::cstss (cst-throw-statement-conc abnf::cst)))
            (cst-list-list-conc-matchp abnf::cstss
                                       "%s\"throw\" expression \";\"")))
 :rule-classes :rewrite)

Theorem: cst-throw-statement-conc-of-tree-fix-cst

(defthm cst-throw-statement-conc-of-tree-fix-cst
  (equal (cst-throw-statement-conc (abnf::tree-fix abnf::cst))
         (cst-throw-statement-conc abnf::cst)))

Theorem: cst-throw-statement-conc-tree-equiv-congruence-on-cst

(defthm cst-throw-statement-conc-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-throw-statement-conc abnf::cst)
                  (cst-throw-statement-conc cst-equiv)))
  :rule-classes :congruence)

Function: cst-synchronized-statement-conc

(defun cst-synchronized-statement-conc (abnf::cst)
 (declare (xargs :guard (abnf::treep abnf::cst)))
 (declare
     (xargs :guard (cst-matchp abnf::cst "synchronized-statement")))
 (abnf::tree-nonleaf->branches abnf::cst))

Theorem: tree-list-listp-of-cst-synchronized-statement-conc

(defthm tree-list-listp-of-cst-synchronized-statement-conc
  (b* ((abnf::cstss (cst-synchronized-statement-conc abnf::cst)))
    (abnf::tree-list-listp abnf::cstss))
  :rule-classes :rewrite)

Theorem: cst-synchronized-statement-conc-match

(defthm cst-synchronized-statement-conc-match
 (implies
     (cst-matchp abnf::cst "synchronized-statement")
     (b* ((abnf::cstss (cst-synchronized-statement-conc abnf::cst)))
       (cst-list-list-conc-matchp
            abnf::cstss
            "%s\"synchronized\" \"(\" expression \")\" block")))
 :rule-classes :rewrite)

Theorem: cst-synchronized-statement-conc-of-tree-fix-cst

(defthm cst-synchronized-statement-conc-of-tree-fix-cst
 (equal (cst-synchronized-statement-conc (abnf::tree-fix abnf::cst))
        (cst-synchronized-statement-conc abnf::cst)))

Theorem: cst-synchronized-statement-conc-tree-equiv-congruence-on-cst

(defthm cst-synchronized-statement-conc-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-synchronized-statement-conc abnf::cst)
                  (cst-synchronized-statement-conc cst-equiv)))
  :rule-classes :congruence)

Function: cst-catches-conc

(defun cst-catches-conc (abnf::cst)
  (declare (xargs :guard (abnf::treep abnf::cst)))
  (declare (xargs :guard (cst-matchp abnf::cst "catches")))
  (abnf::tree-nonleaf->branches abnf::cst))

Theorem: tree-list-listp-of-cst-catches-conc

(defthm tree-list-listp-of-cst-catches-conc
  (b* ((abnf::cstss (cst-catches-conc abnf::cst)))
    (abnf::tree-list-listp abnf::cstss))
  :rule-classes :rewrite)

Theorem: cst-catches-conc-match

(defthm cst-catches-conc-match
  (implies
       (cst-matchp abnf::cst "catches")
       (b* ((abnf::cstss (cst-catches-conc abnf::cst)))
         (cst-list-list-conc-matchp abnf::cstss "1*catch-clause")))
  :rule-classes :rewrite)

Theorem: cst-catches-conc-of-tree-fix-cst

(defthm cst-catches-conc-of-tree-fix-cst
  (equal (cst-catches-conc (abnf::tree-fix abnf::cst))
         (cst-catches-conc abnf::cst)))

Theorem: cst-catches-conc-tree-equiv-congruence-on-cst

(defthm cst-catches-conc-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-catches-conc abnf::cst)
                  (cst-catches-conc cst-equiv)))
  :rule-classes :congruence)

Function: cst-catch-clause-conc

(defun cst-catch-clause-conc (abnf::cst)
  (declare (xargs :guard (abnf::treep abnf::cst)))
  (declare (xargs :guard (cst-matchp abnf::cst "catch-clause")))
  (abnf::tree-nonleaf->branches abnf::cst))

Theorem: tree-list-listp-of-cst-catch-clause-conc

(defthm tree-list-listp-of-cst-catch-clause-conc
  (b* ((abnf::cstss (cst-catch-clause-conc abnf::cst)))
    (abnf::tree-list-listp abnf::cstss))
  :rule-classes :rewrite)

Theorem: cst-catch-clause-conc-match

(defthm cst-catch-clause-conc-match
 (implies (cst-matchp abnf::cst "catch-clause")
          (b* ((abnf::cstss (cst-catch-clause-conc abnf::cst)))
            (cst-list-list-conc-matchp
                 abnf::cstss
                 "%s\"catch\" \"(\" catch-formal-parameter \")\" block")))
 :rule-classes :rewrite)

Theorem: cst-catch-clause-conc-of-tree-fix-cst

(defthm cst-catch-clause-conc-of-tree-fix-cst
  (equal (cst-catch-clause-conc (abnf::tree-fix abnf::cst))
         (cst-catch-clause-conc abnf::cst)))

Theorem: cst-catch-clause-conc-tree-equiv-congruence-on-cst

(defthm cst-catch-clause-conc-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-catch-clause-conc abnf::cst)
                  (cst-catch-clause-conc cst-equiv)))
  :rule-classes :congruence)

Function: cst-catch-formal-parameter-conc

(defun cst-catch-formal-parameter-conc (abnf::cst)
 (declare (xargs :guard (abnf::treep abnf::cst)))
 (declare
     (xargs :guard (cst-matchp abnf::cst "catch-formal-parameter")))
 (abnf::tree-nonleaf->branches abnf::cst))

Theorem: tree-list-listp-of-cst-catch-formal-parameter-conc

(defthm tree-list-listp-of-cst-catch-formal-parameter-conc
  (b* ((abnf::cstss (cst-catch-formal-parameter-conc abnf::cst)))
    (abnf::tree-list-listp abnf::cstss))
  :rule-classes :rewrite)

Theorem: cst-catch-formal-parameter-conc-match

(defthm cst-catch-formal-parameter-conc-match
 (implies
    (cst-matchp abnf::cst "catch-formal-parameter")
    (b* ((abnf::cstss (cst-catch-formal-parameter-conc abnf::cst)))
      (cst-list-list-conc-matchp
           abnf::cstss
           "*variable-modifier catch-type variable-declarator-id")))
 :rule-classes :rewrite)

Theorem: cst-catch-formal-parameter-conc-of-tree-fix-cst

(defthm cst-catch-formal-parameter-conc-of-tree-fix-cst
 (equal (cst-catch-formal-parameter-conc (abnf::tree-fix abnf::cst))
        (cst-catch-formal-parameter-conc abnf::cst)))

Theorem: cst-catch-formal-parameter-conc-tree-equiv-congruence-on-cst

(defthm cst-catch-formal-parameter-conc-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-catch-formal-parameter-conc abnf::cst)
                  (cst-catch-formal-parameter-conc cst-equiv)))
  :rule-classes :congruence)

Function: cst-catch-type-conc

(defun cst-catch-type-conc (abnf::cst)
  (declare (xargs :guard (abnf::treep abnf::cst)))
  (declare (xargs :guard (cst-matchp abnf::cst "catch-type")))
  (abnf::tree-nonleaf->branches abnf::cst))

Theorem: tree-list-listp-of-cst-catch-type-conc

(defthm tree-list-listp-of-cst-catch-type-conc
  (b* ((abnf::cstss (cst-catch-type-conc abnf::cst)))
    (abnf::tree-list-listp abnf::cstss))
  :rule-classes :rewrite)

Theorem: cst-catch-type-conc-match

(defthm cst-catch-type-conc-match
  (implies (cst-matchp abnf::cst "catch-type")
           (b* ((abnf::cstss (cst-catch-type-conc abnf::cst)))
             (cst-list-list-conc-matchp
                  abnf::cstss
                  "unann-class-type *( \"|\" class-type )")))
  :rule-classes :rewrite)

Theorem: cst-catch-type-conc-of-tree-fix-cst

(defthm cst-catch-type-conc-of-tree-fix-cst
  (equal (cst-catch-type-conc (abnf::tree-fix abnf::cst))
         (cst-catch-type-conc abnf::cst)))

Theorem: cst-catch-type-conc-tree-equiv-congruence-on-cst

(defthm cst-catch-type-conc-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-catch-type-conc abnf::cst)
                  (cst-catch-type-conc cst-equiv)))
  :rule-classes :congruence)

Function: cst-finally-conc

(defun cst-finally-conc (abnf::cst)
  (declare (xargs :guard (abnf::treep abnf::cst)))
  (declare (xargs :guard (cst-matchp abnf::cst "finally")))
  (abnf::tree-nonleaf->branches abnf::cst))

Theorem: tree-list-listp-of-cst-finally-conc

(defthm tree-list-listp-of-cst-finally-conc
  (b* ((abnf::cstss (cst-finally-conc abnf::cst)))
    (abnf::tree-list-listp abnf::cstss))
  :rule-classes :rewrite)

Theorem: cst-finally-conc-match

(defthm cst-finally-conc-match
 (implies
     (cst-matchp abnf::cst "finally")
     (b* ((abnf::cstss (cst-finally-conc abnf::cst)))
       (cst-list-list-conc-matchp abnf::cstss "%s\"finally\" block")))
 :rule-classes :rewrite)

Theorem: cst-finally-conc-of-tree-fix-cst

(defthm cst-finally-conc-of-tree-fix-cst
  (equal (cst-finally-conc (abnf::tree-fix abnf::cst))
         (cst-finally-conc abnf::cst)))

Theorem: cst-finally-conc-tree-equiv-congruence-on-cst

(defthm cst-finally-conc-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-finally-conc abnf::cst)
                  (cst-finally-conc cst-equiv)))
  :rule-classes :congruence)

Function: cst-try-with-resources-statement-conc

(defun cst-try-with-resources-statement-conc (abnf::cst)
  (declare (xargs :guard (abnf::treep abnf::cst)))
  (declare
       (xargs :guard (cst-matchp abnf::cst
                                 "try-with-resources-statement")))
  (abnf::tree-nonleaf->branches abnf::cst))

Theorem: tree-list-listp-of-cst-try-with-resources-statement-conc

(defthm tree-list-listp-of-cst-try-with-resources-statement-conc
  (b*
   ((abnf::cstss (cst-try-with-resources-statement-conc abnf::cst)))
   (abnf::tree-list-listp abnf::cstss))
  :rule-classes :rewrite)

Theorem: cst-try-with-resources-statement-conc-match

(defthm cst-try-with-resources-statement-conc-match
 (implies
  (cst-matchp abnf::cst
              "try-with-resources-statement")
  (b*
   ((abnf::cstss (cst-try-with-resources-statement-conc abnf::cst)))
   (cst-list-list-conc-matchp
    abnf::cstss
    "%s\"try\" resource-specification block [ catches ] [ finally ]")))
 :rule-classes :rewrite)

Theorem: cst-try-with-resources-statement-conc-of-tree-fix-cst

(defthm cst-try-with-resources-statement-conc-of-tree-fix-cst
 (equal
  (cst-try-with-resources-statement-conc (abnf::tree-fix abnf::cst))
  (cst-try-with-resources-statement-conc abnf::cst)))

Theorem: cst-try-with-resources-statement-conc-tree-equiv-congruence-on-cst

(defthm
 cst-try-with-resources-statement-conc-tree-equiv-congruence-on-cst
 (implies (abnf::tree-equiv abnf::cst cst-equiv)
          (equal (cst-try-with-resources-statement-conc abnf::cst)
                 (cst-try-with-resources-statement-conc cst-equiv)))
 :rule-classes :congruence)

Function: cst-resource-specification-conc

(defun cst-resource-specification-conc (abnf::cst)
 (declare (xargs :guard (abnf::treep abnf::cst)))
 (declare
     (xargs :guard (cst-matchp abnf::cst "resource-specification")))
 (abnf::tree-nonleaf->branches abnf::cst))

Theorem: tree-list-listp-of-cst-resource-specification-conc

(defthm tree-list-listp-of-cst-resource-specification-conc
  (b* ((abnf::cstss (cst-resource-specification-conc abnf::cst)))
    (abnf::tree-list-listp abnf::cstss))
  :rule-classes :rewrite)

Theorem: cst-resource-specification-conc-match

(defthm cst-resource-specification-conc-match
 (implies
     (cst-matchp abnf::cst "resource-specification")
     (b* ((abnf::cstss (cst-resource-specification-conc abnf::cst)))
       (cst-list-list-conc-matchp abnf::cstss
                                  "\"(\" resource-list [ \";\" ] \")\"")))
 :rule-classes :rewrite)

Theorem: cst-resource-specification-conc-of-tree-fix-cst

(defthm cst-resource-specification-conc-of-tree-fix-cst
 (equal (cst-resource-specification-conc (abnf::tree-fix abnf::cst))
        (cst-resource-specification-conc abnf::cst)))

Theorem: cst-resource-specification-conc-tree-equiv-congruence-on-cst

(defthm cst-resource-specification-conc-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-resource-specification-conc abnf::cst)
                  (cst-resource-specification-conc cst-equiv)))
  :rule-classes :congruence)

Function: cst-resource-list-conc

(defun cst-resource-list-conc (abnf::cst)
  (declare (xargs :guard (abnf::treep abnf::cst)))
  (declare (xargs :guard (cst-matchp abnf::cst "resource-list")))
  (abnf::tree-nonleaf->branches abnf::cst))

Theorem: tree-list-listp-of-cst-resource-list-conc

(defthm tree-list-listp-of-cst-resource-list-conc
  (b* ((abnf::cstss (cst-resource-list-conc abnf::cst)))
    (abnf::tree-list-listp abnf::cstss))
  :rule-classes :rewrite)

Theorem: cst-resource-list-conc-match

(defthm cst-resource-list-conc-match
  (implies
       (cst-matchp abnf::cst "resource-list")
       (b* ((abnf::cstss (cst-resource-list-conc abnf::cst)))
         (cst-list-list-conc-matchp abnf::cstss
                                    "resource *( \";\" resource )")))
  :rule-classes :rewrite)

Theorem: cst-resource-list-conc-of-tree-fix-cst

(defthm cst-resource-list-conc-of-tree-fix-cst
  (equal (cst-resource-list-conc (abnf::tree-fix abnf::cst))
         (cst-resource-list-conc abnf::cst)))

Theorem: cst-resource-list-conc-tree-equiv-congruence-on-cst

(defthm cst-resource-list-conc-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-resource-list-conc abnf::cst)
                  (cst-resource-list-conc cst-equiv)))
  :rule-classes :congruence)

Function: cst-resource-conc1

(defun cst-resource-conc1 (abnf::cst)
  (declare (xargs :guard (abnf::treep abnf::cst)))
  (declare (xargs :guard (and (cst-matchp abnf::cst "resource")
                              (equal (cst-resource-conc? abnf::cst)
                                     1))))
  (abnf::tree-nonleaf->branches abnf::cst))

Theorem: tree-list-listp-of-cst-resource-conc1

(defthm tree-list-listp-of-cst-resource-conc1
  (b* ((abnf::cstss (cst-resource-conc1 abnf::cst)))
    (abnf::tree-list-listp abnf::cstss))
  :rule-classes :rewrite)

Theorem: cst-resource-conc1-match

(defthm cst-resource-conc1-match
  (implies
       (and (cst-matchp abnf::cst "resource")
            (equal (cst-resource-conc? abnf::cst)
                   1))
       (b* ((abnf::cstss (cst-resource-conc1 abnf::cst)))
         (cst-list-list-conc-matchp abnf::cstss
                                    "local-variable-declaration")))
  :rule-classes :rewrite)

Theorem: cst-resource-conc1-of-tree-fix-cst

(defthm cst-resource-conc1-of-tree-fix-cst
  (equal (cst-resource-conc1 (abnf::tree-fix abnf::cst))
         (cst-resource-conc1 abnf::cst)))

Theorem: cst-resource-conc1-tree-equiv-congruence-on-cst

(defthm cst-resource-conc1-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-resource-conc1 abnf::cst)
                  (cst-resource-conc1 cst-equiv)))
  :rule-classes :congruence)

Function: cst-resource-conc2

(defun cst-resource-conc2 (abnf::cst)
  (declare (xargs :guard (abnf::treep abnf::cst)))
  (declare (xargs :guard (and (cst-matchp abnf::cst "resource")
                              (equal (cst-resource-conc? abnf::cst)
                                     2))))
  (abnf::tree-nonleaf->branches abnf::cst))

Theorem: tree-list-listp-of-cst-resource-conc2

(defthm tree-list-listp-of-cst-resource-conc2
  (b* ((abnf::cstss (cst-resource-conc2 abnf::cst)))
    (abnf::tree-list-listp abnf::cstss))
  :rule-classes :rewrite)

Theorem: cst-resource-conc2-match

(defthm cst-resource-conc2-match
  (implies
       (and (cst-matchp abnf::cst "resource")
            (equal (cst-resource-conc? abnf::cst)
                   2))
       (b* ((abnf::cstss (cst-resource-conc2 abnf::cst)))
         (cst-list-list-conc-matchp abnf::cstss "variable-access")))
  :rule-classes :rewrite)

Theorem: cst-resource-conc2-of-tree-fix-cst

(defthm cst-resource-conc2-of-tree-fix-cst
  (equal (cst-resource-conc2 (abnf::tree-fix abnf::cst))
         (cst-resource-conc2 abnf::cst)))

Theorem: cst-resource-conc2-tree-equiv-congruence-on-cst

(defthm cst-resource-conc2-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-resource-conc2 abnf::cst)
                  (cst-resource-conc2 cst-equiv)))
  :rule-classes :congruence)

Function: cst-variable-access-conc1

(defun cst-variable-access-conc1 (abnf::cst)
 (declare (xargs :guard (abnf::treep abnf::cst)))
 (declare
     (xargs :guard (and (cst-matchp abnf::cst "variable-access")
                        (equal (cst-variable-access-conc? abnf::cst)
                               1))))
 (abnf::tree-nonleaf->branches abnf::cst))

Theorem: tree-list-listp-of-cst-variable-access-conc1

(defthm tree-list-listp-of-cst-variable-access-conc1
  (b* ((abnf::cstss (cst-variable-access-conc1 abnf::cst)))
    (abnf::tree-list-listp abnf::cstss))
  :rule-classes :rewrite)

Theorem: cst-variable-access-conc1-match

(defthm cst-variable-access-conc1-match
  (implies
       (and (cst-matchp abnf::cst "variable-access")
            (equal (cst-variable-access-conc? abnf::cst)
                   1))
       (b* ((abnf::cstss (cst-variable-access-conc1 abnf::cst)))
         (cst-list-list-conc-matchp abnf::cstss "expression-name")))
  :rule-classes :rewrite)

Theorem: cst-variable-access-conc1-of-tree-fix-cst

(defthm cst-variable-access-conc1-of-tree-fix-cst
  (equal (cst-variable-access-conc1 (abnf::tree-fix abnf::cst))
         (cst-variable-access-conc1 abnf::cst)))

Theorem: cst-variable-access-conc1-tree-equiv-congruence-on-cst

(defthm cst-variable-access-conc1-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-variable-access-conc1 abnf::cst)
                  (cst-variable-access-conc1 cst-equiv)))
  :rule-classes :congruence)

Function: cst-variable-access-conc2

(defun cst-variable-access-conc2 (abnf::cst)
 (declare (xargs :guard (abnf::treep abnf::cst)))
 (declare
     (xargs :guard (and (cst-matchp abnf::cst "variable-access")
                        (equal (cst-variable-access-conc? abnf::cst)
                               2))))
 (abnf::tree-nonleaf->branches abnf::cst))

Theorem: tree-list-listp-of-cst-variable-access-conc2

(defthm tree-list-listp-of-cst-variable-access-conc2
  (b* ((abnf::cstss (cst-variable-access-conc2 abnf::cst)))
    (abnf::tree-list-listp abnf::cstss))
  :rule-classes :rewrite)

Theorem: cst-variable-access-conc2-match

(defthm cst-variable-access-conc2-match
 (implies (and (cst-matchp abnf::cst "variable-access")
               (equal (cst-variable-access-conc? abnf::cst)
                      2))
          (b* ((abnf::cstss (cst-variable-access-conc2 abnf::cst)))
            (cst-list-list-conc-matchp abnf::cstss "field-access")))
 :rule-classes :rewrite)

Theorem: cst-variable-access-conc2-of-tree-fix-cst

(defthm cst-variable-access-conc2-of-tree-fix-cst
  (equal (cst-variable-access-conc2 (abnf::tree-fix abnf::cst))
         (cst-variable-access-conc2 abnf::cst)))

Theorem: cst-variable-access-conc2-tree-equiv-congruence-on-cst

(defthm cst-variable-access-conc2-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-variable-access-conc2 abnf::cst)
                  (cst-variable-access-conc2 cst-equiv)))
  :rule-classes :congruence)

Function: cst-yield-statement-conc

(defun cst-yield-statement-conc (abnf::cst)
  (declare (xargs :guard (abnf::treep abnf::cst)))
  (declare (xargs :guard (cst-matchp abnf::cst "yield-statement")))
  (abnf::tree-nonleaf->branches abnf::cst))

Theorem: tree-list-listp-of-cst-yield-statement-conc

(defthm tree-list-listp-of-cst-yield-statement-conc
  (b* ((abnf::cstss (cst-yield-statement-conc abnf::cst)))
    (abnf::tree-list-listp abnf::cstss))
  :rule-classes :rewrite)

Theorem: cst-yield-statement-conc-match

(defthm cst-yield-statement-conc-match
 (implies (cst-matchp abnf::cst "yield-statement")
          (b* ((abnf::cstss (cst-yield-statement-conc abnf::cst)))
            (cst-list-list-conc-matchp abnf::cstss
                                       "%s\"yield\" expression \";\"")))
 :rule-classes :rewrite)

Theorem: cst-yield-statement-conc-of-tree-fix-cst

(defthm cst-yield-statement-conc-of-tree-fix-cst
  (equal (cst-yield-statement-conc (abnf::tree-fix abnf::cst))
         (cst-yield-statement-conc abnf::cst)))

Theorem: cst-yield-statement-conc-tree-equiv-congruence-on-cst

(defthm cst-yield-statement-conc-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-yield-statement-conc abnf::cst)
                  (cst-yield-statement-conc cst-equiv)))
  :rule-classes :congruence)

Function: cst-pattern-conc1

(defun cst-pattern-conc1 (abnf::cst)
  (declare (xargs :guard (abnf::treep abnf::cst)))
  (declare (xargs :guard (and (cst-matchp abnf::cst "pattern")
                              (equal (cst-pattern-conc? abnf::cst)
                                     1))))
  (abnf::tree-nonleaf->branches abnf::cst))

Theorem: tree-list-listp-of-cst-pattern-conc1

(defthm tree-list-listp-of-cst-pattern-conc1
  (b* ((abnf::cstss (cst-pattern-conc1 abnf::cst)))
    (abnf::tree-list-listp abnf::cstss))
  :rule-classes :rewrite)

Theorem: cst-pattern-conc1-match

(defthm cst-pattern-conc1-match
 (implies (and (cst-matchp abnf::cst "pattern")
               (equal (cst-pattern-conc? abnf::cst) 1))
          (b* ((abnf::cstss (cst-pattern-conc1 abnf::cst)))
            (cst-list-list-conc-matchp abnf::cstss "type-pattern")))
 :rule-classes :rewrite)

Theorem: cst-pattern-conc1-of-tree-fix-cst

(defthm cst-pattern-conc1-of-tree-fix-cst
  (equal (cst-pattern-conc1 (abnf::tree-fix abnf::cst))
         (cst-pattern-conc1 abnf::cst)))

Theorem: cst-pattern-conc1-tree-equiv-congruence-on-cst

(defthm cst-pattern-conc1-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-pattern-conc1 abnf::cst)
                  (cst-pattern-conc1 cst-equiv)))
  :rule-classes :congruence)

Function: cst-pattern-conc2

(defun cst-pattern-conc2 (abnf::cst)
  (declare (xargs :guard (abnf::treep abnf::cst)))
  (declare (xargs :guard (and (cst-matchp abnf::cst "pattern")
                              (equal (cst-pattern-conc? abnf::cst)
                                     2))))
  (abnf::tree-nonleaf->branches abnf::cst))

Theorem: tree-list-listp-of-cst-pattern-conc2

(defthm tree-list-listp-of-cst-pattern-conc2
  (b* ((abnf::cstss (cst-pattern-conc2 abnf::cst)))
    (abnf::tree-list-listp abnf::cstss))
  :rule-classes :rewrite)

Theorem: cst-pattern-conc2-match

(defthm cst-pattern-conc2-match
  (implies
       (and (cst-matchp abnf::cst "pattern")
            (equal (cst-pattern-conc? abnf::cst) 2))
       (b* ((abnf::cstss (cst-pattern-conc2 abnf::cst)))
         (cst-list-list-conc-matchp abnf::cstss "record-pattern")))
  :rule-classes :rewrite)

Theorem: cst-pattern-conc2-of-tree-fix-cst

(defthm cst-pattern-conc2-of-tree-fix-cst
  (equal (cst-pattern-conc2 (abnf::tree-fix abnf::cst))
         (cst-pattern-conc2 abnf::cst)))

Theorem: cst-pattern-conc2-tree-equiv-congruence-on-cst

(defthm cst-pattern-conc2-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-pattern-conc2 abnf::cst)
                  (cst-pattern-conc2 cst-equiv)))
  :rule-classes :congruence)

Function: cst-type-pattern-conc

(defun cst-type-pattern-conc (abnf::cst)
  (declare (xargs :guard (abnf::treep abnf::cst)))
  (declare (xargs :guard (cst-matchp abnf::cst "type-pattern")))
  (abnf::tree-nonleaf->branches abnf::cst))

Theorem: tree-list-listp-of-cst-type-pattern-conc

(defthm tree-list-listp-of-cst-type-pattern-conc
  (b* ((abnf::cstss (cst-type-pattern-conc abnf::cst)))
    (abnf::tree-list-listp abnf::cstss))
  :rule-classes :rewrite)

Theorem: cst-type-pattern-conc-match

(defthm cst-type-pattern-conc-match
  (implies
       (cst-matchp abnf::cst "type-pattern")
       (b* ((abnf::cstss (cst-type-pattern-conc abnf::cst)))
         (cst-list-list-conc-matchp abnf::cstss
                                    "local-variable-declaration")))
  :rule-classes :rewrite)

Theorem: cst-type-pattern-conc-of-tree-fix-cst

(defthm cst-type-pattern-conc-of-tree-fix-cst
  (equal (cst-type-pattern-conc (abnf::tree-fix abnf::cst))
         (cst-type-pattern-conc abnf::cst)))

Theorem: cst-type-pattern-conc-tree-equiv-congruence-on-cst

(defthm cst-type-pattern-conc-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-type-pattern-conc abnf::cst)
                  (cst-type-pattern-conc cst-equiv)))
  :rule-classes :congruence)

Function: cst-record-pattern-conc

(defun cst-record-pattern-conc (abnf::cst)
  (declare (xargs :guard (abnf::treep abnf::cst)))
  (declare (xargs :guard (cst-matchp abnf::cst "record-pattern")))
  (abnf::tree-nonleaf->branches abnf::cst))

Theorem: tree-list-listp-of-cst-record-pattern-conc

(defthm tree-list-listp-of-cst-record-pattern-conc
  (b* ((abnf::cstss (cst-record-pattern-conc abnf::cst)))
    (abnf::tree-list-listp abnf::cstss))
  :rule-classes :rewrite)

Theorem: cst-record-pattern-conc-match

(defthm cst-record-pattern-conc-match
  (implies
       (cst-matchp abnf::cst "record-pattern")
       (b* ((abnf::cstss (cst-record-pattern-conc abnf::cst)))
         (cst-list-list-conc-matchp
              abnf::cstss
              "reference-type \"(\" [ component-pattern-list ] \")\"")))
  :rule-classes :rewrite)

Theorem: cst-record-pattern-conc-of-tree-fix-cst

(defthm cst-record-pattern-conc-of-tree-fix-cst
  (equal (cst-record-pattern-conc (abnf::tree-fix abnf::cst))
         (cst-record-pattern-conc abnf::cst)))

Theorem: cst-record-pattern-conc-tree-equiv-congruence-on-cst

(defthm cst-record-pattern-conc-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-record-pattern-conc abnf::cst)
                  (cst-record-pattern-conc cst-equiv)))
  :rule-classes :congruence)

Function: cst-component-pattern-list-conc

(defun cst-component-pattern-list-conc (abnf::cst)
 (declare (xargs :guard (abnf::treep abnf::cst)))
 (declare
     (xargs :guard (cst-matchp abnf::cst "component-pattern-list")))
 (abnf::tree-nonleaf->branches abnf::cst))

Theorem: tree-list-listp-of-cst-component-pattern-list-conc

(defthm tree-list-listp-of-cst-component-pattern-list-conc
  (b* ((abnf::cstss (cst-component-pattern-list-conc abnf::cst)))
    (abnf::tree-list-listp abnf::cstss))
  :rule-classes :rewrite)

Theorem: cst-component-pattern-list-conc-match

(defthm cst-component-pattern-list-conc-match
 (implies
     (cst-matchp abnf::cst "component-pattern-list")
     (b* ((abnf::cstss (cst-component-pattern-list-conc abnf::cst)))
       (cst-list-list-conc-matchp
            abnf::cstss
            "component-pattern *( \",\" component-pattern )")))
 :rule-classes :rewrite)

Theorem: cst-component-pattern-list-conc-of-tree-fix-cst

(defthm cst-component-pattern-list-conc-of-tree-fix-cst
 (equal (cst-component-pattern-list-conc (abnf::tree-fix abnf::cst))
        (cst-component-pattern-list-conc abnf::cst)))

Theorem: cst-component-pattern-list-conc-tree-equiv-congruence-on-cst

(defthm cst-component-pattern-list-conc-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-component-pattern-list-conc abnf::cst)
                  (cst-component-pattern-list-conc cst-equiv)))
  :rule-classes :congruence)

Function: cst-component-pattern-conc1

(defun cst-component-pattern-conc1 (abnf::cst)
 (declare (xargs :guard (abnf::treep abnf::cst)))
 (declare
   (xargs :guard (and (cst-matchp abnf::cst "component-pattern")
                      (equal (cst-component-pattern-conc? abnf::cst)
                             1))))
 (abnf::tree-nonleaf->branches abnf::cst))

Theorem: tree-list-listp-of-cst-component-pattern-conc1

(defthm tree-list-listp-of-cst-component-pattern-conc1
  (b* ((abnf::cstss (cst-component-pattern-conc1 abnf::cst)))
    (abnf::tree-list-listp abnf::cstss))
  :rule-classes :rewrite)

Theorem: cst-component-pattern-conc1-match

(defthm cst-component-pattern-conc1-match
  (implies
       (and (cst-matchp abnf::cst "component-pattern")
            (equal (cst-component-pattern-conc? abnf::cst)
                   1))
       (b* ((abnf::cstss (cst-component-pattern-conc1 abnf::cst)))
         (cst-list-list-conc-matchp abnf::cstss "pattern")))
  :rule-classes :rewrite)

Theorem: cst-component-pattern-conc1-of-tree-fix-cst

(defthm cst-component-pattern-conc1-of-tree-fix-cst
  (equal (cst-component-pattern-conc1 (abnf::tree-fix abnf::cst))
         (cst-component-pattern-conc1 abnf::cst)))

Theorem: cst-component-pattern-conc1-tree-equiv-congruence-on-cst

(defthm cst-component-pattern-conc1-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-component-pattern-conc1 abnf::cst)
                  (cst-component-pattern-conc1 cst-equiv)))
  :rule-classes :congruence)

Function: cst-component-pattern-conc2

(defun cst-component-pattern-conc2 (abnf::cst)
 (declare (xargs :guard (abnf::treep abnf::cst)))
 (declare
   (xargs :guard (and (cst-matchp abnf::cst "component-pattern")
                      (equal (cst-component-pattern-conc? abnf::cst)
                             2))))
 (abnf::tree-nonleaf->branches abnf::cst))

Theorem: tree-list-listp-of-cst-component-pattern-conc2

(defthm tree-list-listp-of-cst-component-pattern-conc2
  (b* ((abnf::cstss (cst-component-pattern-conc2 abnf::cst)))
    (abnf::tree-list-listp abnf::cstss))
  :rule-classes :rewrite)

Theorem: cst-component-pattern-conc2-match

(defthm cst-component-pattern-conc2-match
 (implies
     (and (cst-matchp abnf::cst "component-pattern")
          (equal (cst-component-pattern-conc? abnf::cst)
                 2))
     (b* ((abnf::cstss (cst-component-pattern-conc2 abnf::cst)))
       (cst-list-list-conc-matchp abnf::cstss "match-all-pattern")))
 :rule-classes :rewrite)

Theorem: cst-component-pattern-conc2-of-tree-fix-cst

(defthm cst-component-pattern-conc2-of-tree-fix-cst
  (equal (cst-component-pattern-conc2 (abnf::tree-fix abnf::cst))
         (cst-component-pattern-conc2 abnf::cst)))

Theorem: cst-component-pattern-conc2-tree-equiv-congruence-on-cst

(defthm cst-component-pattern-conc2-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-component-pattern-conc2 abnf::cst)
                  (cst-component-pattern-conc2 cst-equiv)))
  :rule-classes :congruence)

Function: cst-match-all-pattern-conc

(defun cst-match-all-pattern-conc (abnf::cst)
 (declare (xargs :guard (abnf::treep abnf::cst)))
 (declare (xargs :guard (cst-matchp abnf::cst "match-all-pattern")))
 (abnf::tree-nonleaf->branches abnf::cst))

Theorem: tree-list-listp-of-cst-match-all-pattern-conc

(defthm tree-list-listp-of-cst-match-all-pattern-conc
  (b* ((abnf::cstss (cst-match-all-pattern-conc abnf::cst)))
    (abnf::tree-list-listp abnf::cstss))
  :rule-classes :rewrite)

Theorem: cst-match-all-pattern-conc-match

(defthm cst-match-all-pattern-conc-match
 (implies (cst-matchp abnf::cst "match-all-pattern")
          (b* ((abnf::cstss (cst-match-all-pattern-conc abnf::cst)))
            (cst-list-list-conc-matchp abnf::cstss "\"_\"")))
 :rule-classes :rewrite)

Theorem: cst-match-all-pattern-conc-of-tree-fix-cst

(defthm cst-match-all-pattern-conc-of-tree-fix-cst
  (equal (cst-match-all-pattern-conc (abnf::tree-fix abnf::cst))
         (cst-match-all-pattern-conc abnf::cst)))

Theorem: cst-match-all-pattern-conc-tree-equiv-congruence-on-cst

(defthm cst-match-all-pattern-conc-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-match-all-pattern-conc abnf::cst)
                  (cst-match-all-pattern-conc cst-equiv)))
  :rule-classes :congruence)

Function: cst-expression-conc1

(defun cst-expression-conc1 (abnf::cst)
 (declare (xargs :guard (abnf::treep abnf::cst)))
 (declare (xargs :guard (and (cst-matchp abnf::cst "expression")
                             (equal (cst-expression-conc? abnf::cst)
                                    1))))
 (abnf::tree-nonleaf->branches abnf::cst))

Theorem: tree-list-listp-of-cst-expression-conc1

(defthm tree-list-listp-of-cst-expression-conc1
  (b* ((abnf::cstss (cst-expression-conc1 abnf::cst)))
    (abnf::tree-list-listp abnf::cstss))
  :rule-classes :rewrite)

Theorem: cst-expression-conc1-match

(defthm cst-expression-conc1-match
 (implies
     (and (cst-matchp abnf::cst "expression")
          (equal (cst-expression-conc? abnf::cst)
                 1))
     (b* ((abnf::cstss (cst-expression-conc1 abnf::cst)))
       (cst-list-list-conc-matchp abnf::cstss "lambda-expression")))
 :rule-classes :rewrite)

Theorem: cst-expression-conc1-of-tree-fix-cst

(defthm cst-expression-conc1-of-tree-fix-cst
  (equal (cst-expression-conc1 (abnf::tree-fix abnf::cst))
         (cst-expression-conc1 abnf::cst)))

Theorem: cst-expression-conc1-tree-equiv-congruence-on-cst

(defthm cst-expression-conc1-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-expression-conc1 abnf::cst)
                  (cst-expression-conc1 cst-equiv)))
  :rule-classes :congruence)

Function: cst-expression-conc2

(defun cst-expression-conc2 (abnf::cst)
 (declare (xargs :guard (abnf::treep abnf::cst)))
 (declare (xargs :guard (and (cst-matchp abnf::cst "expression")
                             (equal (cst-expression-conc? abnf::cst)
                                    2))))
 (abnf::tree-nonleaf->branches abnf::cst))

Theorem: tree-list-listp-of-cst-expression-conc2

(defthm tree-list-listp-of-cst-expression-conc2
  (b* ((abnf::cstss (cst-expression-conc2 abnf::cst)))
    (abnf::tree-list-listp abnf::cstss))
  :rule-classes :rewrite)

Theorem: cst-expression-conc2-match

(defthm cst-expression-conc2-match
 (implies
  (and (cst-matchp abnf::cst "expression")
       (equal (cst-expression-conc? abnf::cst)
              2))
  (b* ((abnf::cstss (cst-expression-conc2 abnf::cst)))
   (cst-list-list-conc-matchp abnf::cstss "assignment-expression")))
 :rule-classes :rewrite)

Theorem: cst-expression-conc2-of-tree-fix-cst

(defthm cst-expression-conc2-of-tree-fix-cst
  (equal (cst-expression-conc2 (abnf::tree-fix abnf::cst))
         (cst-expression-conc2 abnf::cst)))

Theorem: cst-expression-conc2-tree-equiv-congruence-on-cst

(defthm cst-expression-conc2-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-expression-conc2 abnf::cst)
                  (cst-expression-conc2 cst-equiv)))
  :rule-classes :congruence)

Function: cst-primary-conc1

(defun cst-primary-conc1 (abnf::cst)
  (declare (xargs :guard (abnf::treep abnf::cst)))
  (declare (xargs :guard (and (cst-matchp abnf::cst "primary")
                              (equal (cst-primary-conc? abnf::cst)
                                     1))))
  (abnf::tree-nonleaf->branches abnf::cst))

Theorem: tree-list-listp-of-cst-primary-conc1

(defthm tree-list-listp-of-cst-primary-conc1
  (b* ((abnf::cstss (cst-primary-conc1 abnf::cst)))
    (abnf::tree-list-listp abnf::cstss))
  :rule-classes :rewrite)

Theorem: cst-primary-conc1-match

(defthm cst-primary-conc1-match
 (implies
  (and (cst-matchp abnf::cst "primary")
       (equal (cst-primary-conc? abnf::cst) 1))
  (b* ((abnf::cstss (cst-primary-conc1 abnf::cst)))
    (cst-list-list-conc-matchp abnf::cstss "primary-no-new-array")))
 :rule-classes :rewrite)

Theorem: cst-primary-conc1-of-tree-fix-cst

(defthm cst-primary-conc1-of-tree-fix-cst
  (equal (cst-primary-conc1 (abnf::tree-fix abnf::cst))
         (cst-primary-conc1 abnf::cst)))

Theorem: cst-primary-conc1-tree-equiv-congruence-on-cst

(defthm cst-primary-conc1-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-primary-conc1 abnf::cst)
                  (cst-primary-conc1 cst-equiv)))
  :rule-classes :congruence)

Function: cst-primary-conc2

(defun cst-primary-conc2 (abnf::cst)
  (declare (xargs :guard (abnf::treep abnf::cst)))
  (declare (xargs :guard (and (cst-matchp abnf::cst "primary")
                              (equal (cst-primary-conc? abnf::cst)
                                     2))))
  (abnf::tree-nonleaf->branches abnf::cst))

Theorem: tree-list-listp-of-cst-primary-conc2

(defthm tree-list-listp-of-cst-primary-conc2
  (b* ((abnf::cstss (cst-primary-conc2 abnf::cst)))
    (abnf::tree-list-listp abnf::cstss))
  :rule-classes :rewrite)

Theorem: cst-primary-conc2-match

(defthm cst-primary-conc2-match
  (implies
       (and (cst-matchp abnf::cst "primary")
            (equal (cst-primary-conc? abnf::cst) 2))
       (b* ((abnf::cstss (cst-primary-conc2 abnf::cst)))
         (cst-list-list-conc-matchp abnf::cstss
                                    "array-creation-expression")))
  :rule-classes :rewrite)

Theorem: cst-primary-conc2-of-tree-fix-cst

(defthm cst-primary-conc2-of-tree-fix-cst
  (equal (cst-primary-conc2 (abnf::tree-fix abnf::cst))
         (cst-primary-conc2 abnf::cst)))

Theorem: cst-primary-conc2-tree-equiv-congruence-on-cst

(defthm cst-primary-conc2-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-primary-conc2 abnf::cst)
                  (cst-primary-conc2 cst-equiv)))
  :rule-classes :congruence)

Function: cst-unqualified-class-instance-creation-expression-conc

(defun cst-unqualified-class-instance-creation-expression-conc
       (abnf::cst)
 (declare (xargs :guard (abnf::treep abnf::cst)))
 (declare
  (xargs
     :guard
     (cst-matchp abnf::cst
                 "unqualified-class-instance-creation-expression")))
 (abnf::tree-nonleaf->branches abnf::cst))

Theorem: tree-list-listp-of-cst-unqualified-class-instance-creation-expression-conc

(defthm
 tree-list-listp-of-cst-unqualified-class-instance-creation-expression-conc
 (b* ((abnf::cstss (cst-unqualified-class-instance-creation-expression-conc
                        abnf::cst)))
   (abnf::tree-list-listp abnf::cstss))
 :rule-classes :rewrite)

Theorem: cst-unqualified-class-instance-creation-expression-conc-match

(defthm
      cst-unqualified-class-instance-creation-expression-conc-match
 (implies
  (cst-matchp abnf::cst
              "unqualified-class-instance-creation-expression")
  (b* ((abnf::cstss (cst-unqualified-class-instance-creation-expression-conc
                         abnf::cst)))
   (cst-list-list-conc-matchp
    abnf::cstss
    "%s\"new\" [ type-arguments ] class-or-interface-type-to-instantiate \"(\" [ argument-list ] \")\" [ class-body ]")))
 :rule-classes :rewrite)

Theorem: cst-unqualified-class-instance-creation-expression-conc-of-tree-fix-cst

(defthm
 cst-unqualified-class-instance-creation-expression-conc-of-tree-fix-cst
 (equal (cst-unqualified-class-instance-creation-expression-conc
             (abnf::tree-fix abnf::cst))
        (cst-unqualified-class-instance-creation-expression-conc
             abnf::cst)))

Theorem: cst-unqualified-class-instance-creation-expression-conc-tree-equiv-congruence-on-cst

(defthm
 cst-unqualified-class-instance-creation-expression-conc-tree-equiv-congruence-on-cst
 (implies (abnf::tree-equiv abnf::cst cst-equiv)
          (equal (cst-unqualified-class-instance-creation-expression-conc
                      abnf::cst)
                 (cst-unqualified-class-instance-creation-expression-conc
                      cst-equiv)))
 :rule-classes :congruence)

Function: cst-class-or-interface-type-to-instantiate-conc

(defun cst-class-or-interface-type-to-instantiate-conc (abnf::cst)
 (declare (xargs :guard (abnf::treep abnf::cst)))
 (declare
  (xargs
      :guard (cst-matchp abnf::cst
                         "class-or-interface-type-to-instantiate")))
 (abnf::tree-nonleaf->branches abnf::cst))

Theorem: tree-list-listp-of-cst-class-or-interface-type-to-instantiate-conc

(defthm
 tree-list-listp-of-cst-class-or-interface-type-to-instantiate-conc
 (b*
  ((abnf::cstss
       (cst-class-or-interface-type-to-instantiate-conc abnf::cst)))
  (abnf::tree-list-listp abnf::cstss))
 :rule-classes :rewrite)

Theorem: cst-class-or-interface-type-to-instantiate-conc-match

(defthm cst-class-or-interface-type-to-instantiate-conc-match
 (implies
  (cst-matchp abnf::cst
              "class-or-interface-type-to-instantiate")
  (b*
   ((abnf::cstss
       (cst-class-or-interface-type-to-instantiate-conc abnf::cst)))
   (cst-list-list-conc-matchp
    abnf::cstss
    "*annotation identifier *( \".\" *annotation identifier ) [ type-arguments-or-diamond ]")))
 :rule-classes :rewrite)

Theorem: cst-class-or-interface-type-to-instantiate-conc-of-tree-fix-cst

(defthm
    cst-class-or-interface-type-to-instantiate-conc-of-tree-fix-cst
  (equal
       (cst-class-or-interface-type-to-instantiate-conc
            (abnf::tree-fix abnf::cst))
       (cst-class-or-interface-type-to-instantiate-conc abnf::cst)))

Theorem: cst-class-or-interface-type-to-instantiate-conc-tree-equiv-congruence-on-cst

(defthm
 cst-class-or-interface-type-to-instantiate-conc-tree-equiv-congruence-on-cst
 (implies
  (abnf::tree-equiv abnf::cst cst-equiv)
  (equal
       (cst-class-or-interface-type-to-instantiate-conc abnf::cst)
       (cst-class-or-interface-type-to-instantiate-conc cst-equiv)))
 :rule-classes :congruence)

Function: cst-array-creation-expression-conc1

(defun cst-array-creation-expression-conc1 (abnf::cst)
 (declare (xargs :guard (abnf::treep abnf::cst)))
 (declare
  (xargs :guard
         (and (cst-matchp abnf::cst "array-creation-expression")
              (equal (cst-array-creation-expression-conc? abnf::cst)
                     1))))
 (abnf::tree-nonleaf->branches abnf::cst))

Theorem: tree-list-listp-of-cst-array-creation-expression-conc1

(defthm tree-list-listp-of-cst-array-creation-expression-conc1
 (b* ((abnf::cstss (cst-array-creation-expression-conc1 abnf::cst)))
   (abnf::tree-list-listp abnf::cstss))
 :rule-classes :rewrite)

Theorem: cst-array-creation-expression-conc1-match

(defthm cst-array-creation-expression-conc1-match
 (implies
   (and (cst-matchp abnf::cst "array-creation-expression")
        (equal (cst-array-creation-expression-conc? abnf::cst)
               1))
   (b*
     ((abnf::cstss (cst-array-creation-expression-conc1 abnf::cst)))
     (cst-list-list-conc-matchp
          abnf::cstss
          "array-creation-expression-without-initializer")))
 :rule-classes :rewrite)

Theorem: cst-array-creation-expression-conc1-of-tree-fix-cst

(defthm cst-array-creation-expression-conc1-of-tree-fix-cst
 (equal
    (cst-array-creation-expression-conc1 (abnf::tree-fix abnf::cst))
    (cst-array-creation-expression-conc1 abnf::cst)))

Theorem: cst-array-creation-expression-conc1-tree-equiv-congruence-on-cst

(defthm
   cst-array-creation-expression-conc1-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-array-creation-expression-conc1 abnf::cst)
                  (cst-array-creation-expression-conc1 cst-equiv)))
  :rule-classes :congruence)

Function: cst-array-creation-expression-conc2

(defun cst-array-creation-expression-conc2 (abnf::cst)
 (declare (xargs :guard (abnf::treep abnf::cst)))
 (declare
  (xargs :guard
         (and (cst-matchp abnf::cst "array-creation-expression")
              (equal (cst-array-creation-expression-conc? abnf::cst)
                     2))))
 (abnf::tree-nonleaf->branches abnf::cst))

Theorem: tree-list-listp-of-cst-array-creation-expression-conc2

(defthm tree-list-listp-of-cst-array-creation-expression-conc2
 (b* ((abnf::cstss (cst-array-creation-expression-conc2 abnf::cst)))
   (abnf::tree-list-listp abnf::cstss))
 :rule-classes :rewrite)

Theorem: cst-array-creation-expression-conc2-match

(defthm cst-array-creation-expression-conc2-match
 (implies
   (and (cst-matchp abnf::cst "array-creation-expression")
        (equal (cst-array-creation-expression-conc? abnf::cst)
               2))
   (b*
     ((abnf::cstss (cst-array-creation-expression-conc2 abnf::cst)))
     (cst-list-list-conc-matchp
          abnf::cstss
          "array-creation-expression-with-initializer")))
 :rule-classes :rewrite)

Theorem: cst-array-creation-expression-conc2-of-tree-fix-cst

(defthm cst-array-creation-expression-conc2-of-tree-fix-cst
 (equal
    (cst-array-creation-expression-conc2 (abnf::tree-fix abnf::cst))
    (cst-array-creation-expression-conc2 abnf::cst)))

Theorem: cst-array-creation-expression-conc2-tree-equiv-congruence-on-cst

(defthm
   cst-array-creation-expression-conc2-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-array-creation-expression-conc2 abnf::cst)
                  (cst-array-creation-expression-conc2 cst-equiv)))
  :rule-classes :congruence)

Function: cst-dim-exprs-conc

(defun cst-dim-exprs-conc (abnf::cst)
  (declare (xargs :guard (abnf::treep abnf::cst)))
  (declare (xargs :guard (cst-matchp abnf::cst "dim-exprs")))
  (abnf::tree-nonleaf->branches abnf::cst))

Theorem: tree-list-listp-of-cst-dim-exprs-conc

(defthm tree-list-listp-of-cst-dim-exprs-conc
  (b* ((abnf::cstss (cst-dim-exprs-conc abnf::cst)))
    (abnf::tree-list-listp abnf::cstss))
  :rule-classes :rewrite)

Theorem: cst-dim-exprs-conc-match

(defthm cst-dim-exprs-conc-match
  (implies (cst-matchp abnf::cst "dim-exprs")
           (b* ((abnf::cstss (cst-dim-exprs-conc abnf::cst)))
             (cst-list-list-conc-matchp abnf::cstss "1*dim-expr")))
  :rule-classes :rewrite)

Theorem: cst-dim-exprs-conc-of-tree-fix-cst

(defthm cst-dim-exprs-conc-of-tree-fix-cst
  (equal (cst-dim-exprs-conc (abnf::tree-fix abnf::cst))
         (cst-dim-exprs-conc abnf::cst)))

Theorem: cst-dim-exprs-conc-tree-equiv-congruence-on-cst

(defthm cst-dim-exprs-conc-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-dim-exprs-conc abnf::cst)
                  (cst-dim-exprs-conc cst-equiv)))
  :rule-classes :congruence)

Function: cst-dim-expr-conc

(defun cst-dim-expr-conc (abnf::cst)
  (declare (xargs :guard (abnf::treep abnf::cst)))
  (declare (xargs :guard (cst-matchp abnf::cst "dim-expr")))
  (abnf::tree-nonleaf->branches abnf::cst))

Theorem: tree-list-listp-of-cst-dim-expr-conc

(defthm tree-list-listp-of-cst-dim-expr-conc
  (b* ((abnf::cstss (cst-dim-expr-conc abnf::cst)))
    (abnf::tree-list-listp abnf::cstss))
  :rule-classes :rewrite)

Theorem: cst-dim-expr-conc-match

(defthm cst-dim-expr-conc-match
 (implies
    (cst-matchp abnf::cst "dim-expr")
    (b* ((abnf::cstss (cst-dim-expr-conc abnf::cst)))
      (cst-list-list-conc-matchp abnf::cstss
                                 "*annotation \"[\" expression \"]\"")))
 :rule-classes :rewrite)

Theorem: cst-dim-expr-conc-of-tree-fix-cst

(defthm cst-dim-expr-conc-of-tree-fix-cst
  (equal (cst-dim-expr-conc (abnf::tree-fix abnf::cst))
         (cst-dim-expr-conc abnf::cst)))

Theorem: cst-dim-expr-conc-tree-equiv-congruence-on-cst

(defthm cst-dim-expr-conc-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-dim-expr-conc abnf::cst)
                  (cst-dim-expr-conc cst-equiv)))
  :rule-classes :congruence)

Function: cst-argument-list-conc

(defun cst-argument-list-conc (abnf::cst)
  (declare (xargs :guard (abnf::treep abnf::cst)))
  (declare (xargs :guard (cst-matchp abnf::cst "argument-list")))
  (abnf::tree-nonleaf->branches abnf::cst))

Theorem: tree-list-listp-of-cst-argument-list-conc

(defthm tree-list-listp-of-cst-argument-list-conc
  (b* ((abnf::cstss (cst-argument-list-conc abnf::cst)))
    (abnf::tree-list-listp abnf::cstss))
  :rule-classes :rewrite)

Theorem: cst-argument-list-conc-match

(defthm cst-argument-list-conc-match
 (implies
    (cst-matchp abnf::cst "argument-list")
    (b* ((abnf::cstss (cst-argument-list-conc abnf::cst)))
      (cst-list-list-conc-matchp abnf::cstss
                                 "expression *( \",\" expression )")))
 :rule-classes :rewrite)

Theorem: cst-argument-list-conc-of-tree-fix-cst

(defthm cst-argument-list-conc-of-tree-fix-cst
  (equal (cst-argument-list-conc (abnf::tree-fix abnf::cst))
         (cst-argument-list-conc abnf::cst)))

Theorem: cst-argument-list-conc-tree-equiv-congruence-on-cst

(defthm cst-argument-list-conc-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-argument-list-conc abnf::cst)
                  (cst-argument-list-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))))
 (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")))
  :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))))
 (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 "expression-name")))
  :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))))
 (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
                                    "post-increment-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))))
 (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
                                    "post-decrement-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-post-increment-expression-conc

(defun cst-post-increment-expression-conc (abnf::cst)
 (declare (xargs :guard (abnf::treep abnf::cst)))
 (declare
  (xargs :guard (cst-matchp abnf::cst "post-increment-expression")))
 (abnf::tree-nonleaf->branches abnf::cst))

Theorem: tree-list-listp-of-cst-post-increment-expression-conc

(defthm tree-list-listp-of-cst-post-increment-expression-conc
  (b* ((abnf::cstss (cst-post-increment-expression-conc abnf::cst)))
    (abnf::tree-list-listp abnf::cstss))
  :rule-classes :rewrite)

Theorem: cst-post-increment-expression-conc-match

(defthm cst-post-increment-expression-conc-match
 (implies
  (cst-matchp abnf::cst "post-increment-expression")
  (b* ((abnf::cstss (cst-post-increment-expression-conc abnf::cst)))
    (cst-list-list-conc-matchp
         abnf::cstss "postfix-expression \"++\"")))
 :rule-classes :rewrite)

Theorem: cst-post-increment-expression-conc-of-tree-fix-cst

(defthm cst-post-increment-expression-conc-of-tree-fix-cst
 (equal
     (cst-post-increment-expression-conc (abnf::tree-fix abnf::cst))
     (cst-post-increment-expression-conc abnf::cst)))

Theorem: cst-post-increment-expression-conc-tree-equiv-congruence-on-cst

(defthm
    cst-post-increment-expression-conc-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-post-increment-expression-conc abnf::cst)
                  (cst-post-increment-expression-conc cst-equiv)))
  :rule-classes :congruence)

Function: cst-post-decrement-expression-conc

(defun cst-post-decrement-expression-conc (abnf::cst)
 (declare (xargs :guard (abnf::treep abnf::cst)))
 (declare
  (xargs :guard (cst-matchp abnf::cst "post-decrement-expression")))
 (abnf::tree-nonleaf->branches abnf::cst))

Theorem: tree-list-listp-of-cst-post-decrement-expression-conc

(defthm tree-list-listp-of-cst-post-decrement-expression-conc
  (b* ((abnf::cstss (cst-post-decrement-expression-conc abnf::cst)))
    (abnf::tree-list-listp abnf::cstss))
  :rule-classes :rewrite)

Theorem: cst-post-decrement-expression-conc-match

(defthm cst-post-decrement-expression-conc-match
 (implies
  (cst-matchp abnf::cst "post-decrement-expression")
  (b* ((abnf::cstss (cst-post-decrement-expression-conc abnf::cst)))
    (cst-list-list-conc-matchp
         abnf::cstss "postfix-expression \"--\"")))
 :rule-classes :rewrite)

Theorem: cst-post-decrement-expression-conc-of-tree-fix-cst

(defthm cst-post-decrement-expression-conc-of-tree-fix-cst
 (equal
     (cst-post-decrement-expression-conc (abnf::tree-fix abnf::cst))
     (cst-post-decrement-expression-conc abnf::cst)))

Theorem: cst-post-decrement-expression-conc-tree-equiv-congruence-on-cst

(defthm
    cst-post-decrement-expression-conc-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-post-decrement-expression-conc abnf::cst)
                  (cst-post-decrement-expression-conc cst-equiv)))
  :rule-classes :congruence)

Function: cst-pre-increment-expression-conc

(defun cst-pre-increment-expression-conc (abnf::cst)
 (declare (xargs :guard (abnf::treep abnf::cst)))
 (declare
   (xargs :guard (cst-matchp abnf::cst "pre-increment-expression")))
 (abnf::tree-nonleaf->branches abnf::cst))

Theorem: tree-list-listp-of-cst-pre-increment-expression-conc

(defthm tree-list-listp-of-cst-pre-increment-expression-conc
  (b* ((abnf::cstss (cst-pre-increment-expression-conc abnf::cst)))
    (abnf::tree-list-listp abnf::cstss))
  :rule-classes :rewrite)

Theorem: cst-pre-increment-expression-conc-match

(defthm cst-pre-increment-expression-conc-match
 (implies
  (cst-matchp abnf::cst "pre-increment-expression")
  (b* ((abnf::cstss (cst-pre-increment-expression-conc abnf::cst)))
   (cst-list-list-conc-matchp abnf::cstss "\"++\" unary-expression")))
 :rule-classes :rewrite)

Theorem: cst-pre-increment-expression-conc-of-tree-fix-cst

(defthm cst-pre-increment-expression-conc-of-tree-fix-cst
 (equal
      (cst-pre-increment-expression-conc (abnf::tree-fix abnf::cst))
      (cst-pre-increment-expression-conc abnf::cst)))

Theorem: cst-pre-increment-expression-conc-tree-equiv-congruence-on-cst

(defthm
     cst-pre-increment-expression-conc-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-pre-increment-expression-conc abnf::cst)
                  (cst-pre-increment-expression-conc cst-equiv)))
  :rule-classes :congruence)

Function: cst-pre-decrement-expression-conc

(defun cst-pre-decrement-expression-conc (abnf::cst)
 (declare (xargs :guard (abnf::treep abnf::cst)))
 (declare
   (xargs :guard (cst-matchp abnf::cst "pre-decrement-expression")))
 (abnf::tree-nonleaf->branches abnf::cst))

Theorem: tree-list-listp-of-cst-pre-decrement-expression-conc

(defthm tree-list-listp-of-cst-pre-decrement-expression-conc
  (b* ((abnf::cstss (cst-pre-decrement-expression-conc abnf::cst)))
    (abnf::tree-list-listp abnf::cstss))
  :rule-classes :rewrite)

Theorem: cst-pre-decrement-expression-conc-match

(defthm cst-pre-decrement-expression-conc-match
 (implies
  (cst-matchp abnf::cst "pre-decrement-expression")
  (b* ((abnf::cstss (cst-pre-decrement-expression-conc abnf::cst)))
   (cst-list-list-conc-matchp abnf::cstss "\"--\" unary-expression")))
 :rule-classes :rewrite)

Theorem: cst-pre-decrement-expression-conc-of-tree-fix-cst

(defthm cst-pre-decrement-expression-conc-of-tree-fix-cst
 (equal
      (cst-pre-decrement-expression-conc (abnf::tree-fix abnf::cst))
      (cst-pre-decrement-expression-conc abnf::cst)))

Theorem: cst-pre-decrement-expression-conc-tree-equiv-congruence-on-cst

(defthm
     cst-pre-decrement-expression-conc-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-pre-decrement-expression-conc abnf::cst)
                  (cst-pre-decrement-expression-conc cst-equiv)))
  :rule-classes :congruence)

Function: cst-assignment-expression-conc1

(defun cst-assignment-expression-conc1 (abnf::cst)
 (declare (xargs :guard (abnf::treep abnf::cst)))
 (declare
  (xargs
      :guard (and (cst-matchp abnf::cst "assignment-expression")
                  (equal (cst-assignment-expression-conc? abnf::cst)
                         1))))
 (abnf::tree-nonleaf->branches abnf::cst))

Theorem: tree-list-listp-of-cst-assignment-expression-conc1

(defthm tree-list-listp-of-cst-assignment-expression-conc1
  (b* ((abnf::cstss (cst-assignment-expression-conc1 abnf::cst)))
    (abnf::tree-list-listp abnf::cstss))
  :rule-classes :rewrite)

Theorem: cst-assignment-expression-conc1-match

(defthm cst-assignment-expression-conc1-match
 (implies
     (and (cst-matchp abnf::cst "assignment-expression")
          (equal (cst-assignment-expression-conc? abnf::cst)
                 1))
     (b* ((abnf::cstss (cst-assignment-expression-conc1 abnf::cst)))
       (cst-list-list-conc-matchp
            abnf::cstss "conditional-expression")))
 :rule-classes :rewrite)

Theorem: cst-assignment-expression-conc1-of-tree-fix-cst

(defthm cst-assignment-expression-conc1-of-tree-fix-cst
 (equal (cst-assignment-expression-conc1 (abnf::tree-fix abnf::cst))
        (cst-assignment-expression-conc1 abnf::cst)))

Theorem: cst-assignment-expression-conc1-tree-equiv-congruence-on-cst

(defthm cst-assignment-expression-conc1-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-assignment-expression-conc1 abnf::cst)
                  (cst-assignment-expression-conc1 cst-equiv)))
  :rule-classes :congruence)

Function: cst-assignment-expression-conc2

(defun cst-assignment-expression-conc2 (abnf::cst)
 (declare (xargs :guard (abnf::treep abnf::cst)))
 (declare
  (xargs
      :guard (and (cst-matchp abnf::cst "assignment-expression")
                  (equal (cst-assignment-expression-conc? abnf::cst)
                         2))))
 (abnf::tree-nonleaf->branches abnf::cst))

Theorem: tree-list-listp-of-cst-assignment-expression-conc2

(defthm tree-list-listp-of-cst-assignment-expression-conc2
  (b* ((abnf::cstss (cst-assignment-expression-conc2 abnf::cst)))
    (abnf::tree-list-listp abnf::cstss))
  :rule-classes :rewrite)

Theorem: cst-assignment-expression-conc2-match

(defthm cst-assignment-expression-conc2-match
 (implies
     (and (cst-matchp abnf::cst "assignment-expression")
          (equal (cst-assignment-expression-conc? abnf::cst)
                 2))
     (b* ((abnf::cstss (cst-assignment-expression-conc2 abnf::cst)))
       (cst-list-list-conc-matchp abnf::cstss "assignment")))
 :rule-classes :rewrite)

Theorem: cst-assignment-expression-conc2-of-tree-fix-cst

(defthm cst-assignment-expression-conc2-of-tree-fix-cst
 (equal (cst-assignment-expression-conc2 (abnf::tree-fix abnf::cst))
        (cst-assignment-expression-conc2 abnf::cst)))

Theorem: cst-assignment-expression-conc2-tree-equiv-congruence-on-cst

(defthm cst-assignment-expression-conc2-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-assignment-expression-conc2 abnf::cst)
                  (cst-assignment-expression-conc2 cst-equiv)))
  :rule-classes :congruence)

Function: cst-assignment-conc

(defun cst-assignment-conc (abnf::cst)
  (declare (xargs :guard (abnf::treep abnf::cst)))
  (declare (xargs :guard (cst-matchp abnf::cst "assignment")))
  (abnf::tree-nonleaf->branches abnf::cst))

Theorem: tree-list-listp-of-cst-assignment-conc

(defthm tree-list-listp-of-cst-assignment-conc
  (b* ((abnf::cstss (cst-assignment-conc abnf::cst)))
    (abnf::tree-list-listp abnf::cstss))
  :rule-classes :rewrite)

Theorem: cst-assignment-conc-match

(defthm cst-assignment-conc-match
  (implies (cst-matchp abnf::cst "assignment")
           (b* ((abnf::cstss (cst-assignment-conc abnf::cst)))
             (cst-list-list-conc-matchp
                  abnf::cstss
                  "left-hand-side assignment-operator expression")))
  :rule-classes :rewrite)

Theorem: cst-assignment-conc-of-tree-fix-cst

(defthm cst-assignment-conc-of-tree-fix-cst
  (equal (cst-assignment-conc (abnf::tree-fix abnf::cst))
         (cst-assignment-conc abnf::cst)))

Theorem: cst-assignment-conc-tree-equiv-congruence-on-cst

(defthm cst-assignment-conc-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-assignment-conc abnf::cst)
                  (cst-assignment-conc cst-equiv)))
  :rule-classes :congruence)

Function: cst-left-hand-side-conc1

(defun cst-left-hand-side-conc1 (abnf::cst)
 (declare (xargs :guard (abnf::treep abnf::cst)))
 (declare
      (xargs :guard (and (cst-matchp abnf::cst "left-hand-side")
                         (equal (cst-left-hand-side-conc? abnf::cst)
                                1))))
 (abnf::tree-nonleaf->branches abnf::cst))

Theorem: tree-list-listp-of-cst-left-hand-side-conc1

(defthm tree-list-listp-of-cst-left-hand-side-conc1
  (b* ((abnf::cstss (cst-left-hand-side-conc1 abnf::cst)))
    (abnf::tree-list-listp abnf::cstss))
  :rule-classes :rewrite)

Theorem: cst-left-hand-side-conc1-match

(defthm cst-left-hand-side-conc1-match
  (implies
       (and (cst-matchp abnf::cst "left-hand-side")
            (equal (cst-left-hand-side-conc? abnf::cst)
                   1))
       (b* ((abnf::cstss (cst-left-hand-side-conc1 abnf::cst)))
         (cst-list-list-conc-matchp abnf::cstss "expression-name")))
  :rule-classes :rewrite)

Theorem: cst-left-hand-side-conc1-of-tree-fix-cst

(defthm cst-left-hand-side-conc1-of-tree-fix-cst
  (equal (cst-left-hand-side-conc1 (abnf::tree-fix abnf::cst))
         (cst-left-hand-side-conc1 abnf::cst)))

Theorem: cst-left-hand-side-conc1-tree-equiv-congruence-on-cst

(defthm cst-left-hand-side-conc1-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-left-hand-side-conc1 abnf::cst)
                  (cst-left-hand-side-conc1 cst-equiv)))
  :rule-classes :congruence)

Function: cst-left-hand-side-conc2

(defun cst-left-hand-side-conc2 (abnf::cst)
 (declare (xargs :guard (abnf::treep abnf::cst)))
 (declare
      (xargs :guard (and (cst-matchp abnf::cst "left-hand-side")
                         (equal (cst-left-hand-side-conc? abnf::cst)
                                2))))
 (abnf::tree-nonleaf->branches abnf::cst))

Theorem: tree-list-listp-of-cst-left-hand-side-conc2

(defthm tree-list-listp-of-cst-left-hand-side-conc2
  (b* ((abnf::cstss (cst-left-hand-side-conc2 abnf::cst)))
    (abnf::tree-list-listp abnf::cstss))
  :rule-classes :rewrite)

Theorem: cst-left-hand-side-conc2-match

(defthm cst-left-hand-side-conc2-match
 (implies (and (cst-matchp abnf::cst "left-hand-side")
               (equal (cst-left-hand-side-conc? abnf::cst)
                      2))
          (b* ((abnf::cstss (cst-left-hand-side-conc2 abnf::cst)))
            (cst-list-list-conc-matchp abnf::cstss "field-access")))
 :rule-classes :rewrite)

Theorem: cst-left-hand-side-conc2-of-tree-fix-cst

(defthm cst-left-hand-side-conc2-of-tree-fix-cst
  (equal (cst-left-hand-side-conc2 (abnf::tree-fix abnf::cst))
         (cst-left-hand-side-conc2 abnf::cst)))

Theorem: cst-left-hand-side-conc2-tree-equiv-congruence-on-cst

(defthm cst-left-hand-side-conc2-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-left-hand-side-conc2 abnf::cst)
                  (cst-left-hand-side-conc2 cst-equiv)))
  :rule-classes :congruence)

Function: cst-left-hand-side-conc3

(defun cst-left-hand-side-conc3 (abnf::cst)
 (declare (xargs :guard (abnf::treep abnf::cst)))
 (declare
      (xargs :guard (and (cst-matchp abnf::cst "left-hand-side")
                         (equal (cst-left-hand-side-conc? abnf::cst)
                                3))))
 (abnf::tree-nonleaf->branches abnf::cst))

Theorem: tree-list-listp-of-cst-left-hand-side-conc3

(defthm tree-list-listp-of-cst-left-hand-side-conc3
  (b* ((abnf::cstss (cst-left-hand-side-conc3 abnf::cst)))
    (abnf::tree-list-listp abnf::cstss))
  :rule-classes :rewrite)

Theorem: cst-left-hand-side-conc3-match

(defthm cst-left-hand-side-conc3-match
 (implies (and (cst-matchp abnf::cst "left-hand-side")
               (equal (cst-left-hand-side-conc? abnf::cst)
                      3))
          (b* ((abnf::cstss (cst-left-hand-side-conc3 abnf::cst)))
            (cst-list-list-conc-matchp abnf::cstss "array-access")))
 :rule-classes :rewrite)

Theorem: cst-left-hand-side-conc3-of-tree-fix-cst

(defthm cst-left-hand-side-conc3-of-tree-fix-cst
  (equal (cst-left-hand-side-conc3 (abnf::tree-fix abnf::cst))
         (cst-left-hand-side-conc3 abnf::cst)))

Theorem: cst-left-hand-side-conc3-tree-equiv-congruence-on-cst

(defthm cst-left-hand-side-conc3-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-left-hand-side-conc3 abnf::cst)
                  (cst-left-hand-side-conc3 cst-equiv)))
  :rule-classes :congruence)

Function: cst-lambda-expression-conc

(defun cst-lambda-expression-conc (abnf::cst)
 (declare (xargs :guard (abnf::treep abnf::cst)))
 (declare (xargs :guard (cst-matchp abnf::cst "lambda-expression")))
 (abnf::tree-nonleaf->branches abnf::cst))

Theorem: tree-list-listp-of-cst-lambda-expression-conc

(defthm tree-list-listp-of-cst-lambda-expression-conc
  (b* ((abnf::cstss (cst-lambda-expression-conc abnf::cst)))
    (abnf::tree-list-listp abnf::cstss))
  :rule-classes :rewrite)

Theorem: cst-lambda-expression-conc-match

(defthm cst-lambda-expression-conc-match
 (implies (cst-matchp abnf::cst "lambda-expression")
          (b* ((abnf::cstss (cst-lambda-expression-conc abnf::cst)))
            (cst-list-list-conc-matchp
                 abnf::cstss
                 "lambda-parameters \"->\" lambda-body")))
 :rule-classes :rewrite)

Theorem: cst-lambda-expression-conc-of-tree-fix-cst

(defthm cst-lambda-expression-conc-of-tree-fix-cst
  (equal (cst-lambda-expression-conc (abnf::tree-fix abnf::cst))
         (cst-lambda-expression-conc abnf::cst)))

Theorem: cst-lambda-expression-conc-tree-equiv-congruence-on-cst

(defthm cst-lambda-expression-conc-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-lambda-expression-conc abnf::cst)
                  (cst-lambda-expression-conc cst-equiv)))
  :rule-classes :congruence)

Function: cst-lambda-body-conc1

(defun cst-lambda-body-conc1 (abnf::cst)
  (declare (xargs :guard (abnf::treep abnf::cst)))
  (declare
       (xargs :guard (and (cst-matchp abnf::cst "lambda-body")
                          (equal (cst-lambda-body-conc? abnf::cst)
                                 1))))
  (abnf::tree-nonleaf->branches abnf::cst))

Theorem: tree-list-listp-of-cst-lambda-body-conc1

(defthm tree-list-listp-of-cst-lambda-body-conc1
  (b* ((abnf::cstss (cst-lambda-body-conc1 abnf::cst)))
    (abnf::tree-list-listp abnf::cstss))
  :rule-classes :rewrite)

Theorem: cst-lambda-body-conc1-match

(defthm cst-lambda-body-conc1-match
  (implies (and (cst-matchp abnf::cst "lambda-body")
                (equal (cst-lambda-body-conc? abnf::cst)
                       1))
           (b* ((abnf::cstss (cst-lambda-body-conc1 abnf::cst)))
             (cst-list-list-conc-matchp abnf::cstss "expression")))
  :rule-classes :rewrite)

Theorem: cst-lambda-body-conc1-of-tree-fix-cst

(defthm cst-lambda-body-conc1-of-tree-fix-cst
  (equal (cst-lambda-body-conc1 (abnf::tree-fix abnf::cst))
         (cst-lambda-body-conc1 abnf::cst)))

Theorem: cst-lambda-body-conc1-tree-equiv-congruence-on-cst

(defthm cst-lambda-body-conc1-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-lambda-body-conc1 abnf::cst)
                  (cst-lambda-body-conc1 cst-equiv)))
  :rule-classes :congruence)

Function: cst-lambda-body-conc2

(defun cst-lambda-body-conc2 (abnf::cst)
  (declare (xargs :guard (abnf::treep abnf::cst)))
  (declare
       (xargs :guard (and (cst-matchp abnf::cst "lambda-body")
                          (equal (cst-lambda-body-conc? abnf::cst)
                                 2))))
  (abnf::tree-nonleaf->branches abnf::cst))

Theorem: tree-list-listp-of-cst-lambda-body-conc2

(defthm tree-list-listp-of-cst-lambda-body-conc2
  (b* ((abnf::cstss (cst-lambda-body-conc2 abnf::cst)))
    (abnf::tree-list-listp abnf::cstss))
  :rule-classes :rewrite)

Theorem: cst-lambda-body-conc2-match

(defthm cst-lambda-body-conc2-match
  (implies (and (cst-matchp abnf::cst "lambda-body")
                (equal (cst-lambda-body-conc? abnf::cst)
                       2))
           (b* ((abnf::cstss (cst-lambda-body-conc2 abnf::cst)))
             (cst-list-list-conc-matchp abnf::cstss "block")))
  :rule-classes :rewrite)

Theorem: cst-lambda-body-conc2-of-tree-fix-cst

(defthm cst-lambda-body-conc2-of-tree-fix-cst
  (equal (cst-lambda-body-conc2 (abnf::tree-fix abnf::cst))
         (cst-lambda-body-conc2 abnf::cst)))

Theorem: cst-lambda-body-conc2-tree-equiv-congruence-on-cst

(defthm cst-lambda-body-conc2-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-lambda-body-conc2 abnf::cst)
                  (cst-lambda-body-conc2 cst-equiv)))
  :rule-classes :congruence)

Function: cst-switch-expression-conc

(defun cst-switch-expression-conc (abnf::cst)
 (declare (xargs :guard (abnf::treep abnf::cst)))
 (declare (xargs :guard (cst-matchp abnf::cst "switch-expression")))
 (abnf::tree-nonleaf->branches abnf::cst))

Theorem: tree-list-listp-of-cst-switch-expression-conc

(defthm tree-list-listp-of-cst-switch-expression-conc
  (b* ((abnf::cstss (cst-switch-expression-conc abnf::cst)))
    (abnf::tree-list-listp abnf::cstss))
  :rule-classes :rewrite)

Theorem: cst-switch-expression-conc-match

(defthm cst-switch-expression-conc-match
 (implies (cst-matchp abnf::cst "switch-expression")
          (b* ((abnf::cstss (cst-switch-expression-conc abnf::cst)))
            (cst-list-list-conc-matchp
                 abnf::cstss
                 "%s\"switch\" \"(\" expression \")\" switch-block")))
 :rule-classes :rewrite)

Theorem: cst-switch-expression-conc-of-tree-fix-cst

(defthm cst-switch-expression-conc-of-tree-fix-cst
  (equal (cst-switch-expression-conc (abnf::tree-fix abnf::cst))
         (cst-switch-expression-conc abnf::cst)))

Theorem: cst-switch-expression-conc-tree-equiv-congruence-on-cst

(defthm cst-switch-expression-conc-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-switch-expression-conc abnf::cst)
                  (cst-switch-expression-conc cst-equiv)))
  :rule-classes :congruence)

Function: cst-unicode-input-character-conc1-rep

(defun cst-unicode-input-character-conc1-rep (abnf::cst)
 (declare (xargs :guard (abnf::treep abnf::cst)))
 (declare
  (xargs
    :guard (and (cst-matchp abnf::cst "unicode-input-character")
                (equal (cst-unicode-input-character-conc? abnf::cst)
                       1))))
 (abnf::tree-list-fix
      (nth 0
           (cst-unicode-input-character-conc1 abnf::cst))))

Theorem: tree-listp-of-cst-unicode-input-character-conc1-rep

(defthm tree-listp-of-cst-unicode-input-character-conc1-rep
  (b*
    ((abnf::csts (cst-unicode-input-character-conc1-rep abnf::cst)))
    (abnf::tree-listp abnf::csts))
  :rule-classes :rewrite)

Theorem: cst-unicode-input-character-conc1-rep-match

(defthm cst-unicode-input-character-conc1-rep-match
 (implies
   (and (cst-matchp abnf::cst "unicode-input-character")
        (equal (cst-unicode-input-character-conc? abnf::cst)
               1))
   (b*
    ((abnf::csts (cst-unicode-input-character-conc1-rep abnf::cst)))
    (cst-list-rep-matchp abnf::csts "unicode-escape")))
 :rule-classes :rewrite)

Theorem: cst-unicode-input-character-conc1-rep-of-tree-fix-cst

(defthm cst-unicode-input-character-conc1-rep-of-tree-fix-cst
 (equal
  (cst-unicode-input-character-conc1-rep (abnf::tree-fix abnf::cst))
  (cst-unicode-input-character-conc1-rep abnf::cst)))

Theorem: cst-unicode-input-character-conc1-rep-tree-equiv-congruence-on-cst

(defthm
 cst-unicode-input-character-conc1-rep-tree-equiv-congruence-on-cst
 (implies (abnf::tree-equiv abnf::cst cst-equiv)
          (equal (cst-unicode-input-character-conc1-rep abnf::cst)
                 (cst-unicode-input-character-conc1-rep cst-equiv)))
 :rule-classes :congruence)

Function: cst-unicode-input-character-conc2-rep

(defun cst-unicode-input-character-conc2-rep (abnf::cst)
 (declare (xargs :guard (abnf::treep abnf::cst)))
 (declare
  (xargs
    :guard (and (cst-matchp abnf::cst "unicode-input-character")
                (equal (cst-unicode-input-character-conc? abnf::cst)
                       2))))
 (abnf::tree-list-fix
      (nth 0
           (cst-unicode-input-character-conc2 abnf::cst))))

Theorem: tree-listp-of-cst-unicode-input-character-conc2-rep

(defthm tree-listp-of-cst-unicode-input-character-conc2-rep
  (b*
    ((abnf::csts (cst-unicode-input-character-conc2-rep abnf::cst)))
    (abnf::tree-listp abnf::csts))
  :rule-classes :rewrite)

Theorem: cst-unicode-input-character-conc2-rep-match

(defthm cst-unicode-input-character-conc2-rep-match
 (implies
   (and (cst-matchp abnf::cst "unicode-input-character")
        (equal (cst-unicode-input-character-conc? abnf::cst)
               2))
   (b*
    ((abnf::csts (cst-unicode-input-character-conc2-rep abnf::cst)))
    (cst-list-rep-matchp abnf::csts "raw-input-character")))
 :rule-classes :rewrite)

Theorem: cst-unicode-input-character-conc2-rep-of-tree-fix-cst

(defthm cst-unicode-input-character-conc2-rep-of-tree-fix-cst
 (equal
  (cst-unicode-input-character-conc2-rep (abnf::tree-fix abnf::cst))
  (cst-unicode-input-character-conc2-rep abnf::cst)))

Theorem: cst-unicode-input-character-conc2-rep-tree-equiv-congruence-on-cst

(defthm
 cst-unicode-input-character-conc2-rep-tree-equiv-congruence-on-cst
 (implies (abnf::tree-equiv abnf::cst cst-equiv)
          (equal (cst-unicode-input-character-conc2-rep abnf::cst)
                 (cst-unicode-input-character-conc2-rep cst-equiv)))
 :rule-classes :congruence)

Function: cst-raw-input-character-conc-rep

(defun cst-raw-input-character-conc-rep (abnf::cst)
  (declare (xargs :guard (abnf::treep abnf::cst)))
  (declare
       (xargs :guard (cst-matchp abnf::cst "raw-input-character")))
  (abnf::tree-list-fix
       (nth 0
            (cst-raw-input-character-conc abnf::cst))))

Theorem: tree-listp-of-cst-raw-input-character-conc-rep

(defthm tree-listp-of-cst-raw-input-character-conc-rep
  (b* ((abnf::csts (cst-raw-input-character-conc-rep abnf::cst)))
    (abnf::tree-listp abnf::csts))
  :rule-classes :rewrite)

Theorem: cst-raw-input-character-conc-rep-match

(defthm cst-raw-input-character-conc-rep-match
 (implies
     (cst-matchp abnf::cst "raw-input-character")
     (b* ((abnf::csts (cst-raw-input-character-conc-rep abnf::cst)))
       (cst-list-rep-matchp abnf::csts "%x0-FFFF")))
 :rule-classes :rewrite)

Theorem: cst-raw-input-character-conc-rep-of-tree-fix-cst

(defthm cst-raw-input-character-conc-rep-of-tree-fix-cst
  (equal
       (cst-raw-input-character-conc-rep (abnf::tree-fix abnf::cst))
       (cst-raw-input-character-conc-rep abnf::cst)))

Theorem: cst-raw-input-character-conc-rep-tree-equiv-congruence-on-cst

(defthm
      cst-raw-input-character-conc-rep-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-raw-input-character-conc-rep abnf::cst)
                  (cst-raw-input-character-conc-rep cst-equiv)))
  :rule-classes :congruence)

Function: cst-input-character-conc-rep

(defun cst-input-character-conc-rep (abnf::cst)
  (declare (xargs :guard (abnf::treep abnf::cst)))
  (declare (xargs :guard (cst-matchp abnf::cst "input-character")))
  (abnf::tree-list-fix (nth 0
                            (cst-input-character-conc abnf::cst))))

Theorem: tree-listp-of-cst-input-character-conc-rep

(defthm tree-listp-of-cst-input-character-conc-rep
  (b* ((abnf::csts (cst-input-character-conc-rep abnf::cst)))
    (abnf::tree-listp abnf::csts))
  :rule-classes :rewrite)

Theorem: cst-input-character-conc-rep-match

(defthm cst-input-character-conc-rep-match
 (implies
      (cst-matchp abnf::cst "input-character")
      (b* ((abnf::csts (cst-input-character-conc-rep abnf::cst)))
        (cst-list-rep-matchp abnf::csts "unicode-input-character")))
 :rule-classes :rewrite)

Theorem: cst-input-character-conc-rep-of-tree-fix-cst

(defthm cst-input-character-conc-rep-of-tree-fix-cst
  (equal (cst-input-character-conc-rep (abnf::tree-fix abnf::cst))
         (cst-input-character-conc-rep abnf::cst)))

Theorem: cst-input-character-conc-rep-tree-equiv-congruence-on-cst

(defthm cst-input-character-conc-rep-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-input-character-conc-rep abnf::cst)
                  (cst-input-character-conc-rep cst-equiv)))
  :rule-classes :congruence)

Function: cst-input-element-conc1-rep

(defun cst-input-element-conc1-rep (abnf::cst)
  (declare (xargs :guard (abnf::treep abnf::cst)))
  (declare
       (xargs :guard (and (cst-matchp abnf::cst "input-element")
                          (equal (cst-input-element-conc? abnf::cst)
                                 1))))
  (abnf::tree-list-fix (nth 0 (cst-input-element-conc1 abnf::cst))))

Theorem: tree-listp-of-cst-input-element-conc1-rep

(defthm tree-listp-of-cst-input-element-conc1-rep
  (b* ((abnf::csts (cst-input-element-conc1-rep abnf::cst)))
    (abnf::tree-listp abnf::csts))
  :rule-classes :rewrite)

Theorem: cst-input-element-conc1-rep-match

(defthm cst-input-element-conc1-rep-match
 (implies (and (cst-matchp abnf::cst "input-element")
               (equal (cst-input-element-conc? abnf::cst)
                      1))
          (b* ((abnf::csts (cst-input-element-conc1-rep abnf::cst)))
            (cst-list-rep-matchp abnf::csts "white-space")))
 :rule-classes :rewrite)

Theorem: cst-input-element-conc1-rep-of-tree-fix-cst

(defthm cst-input-element-conc1-rep-of-tree-fix-cst
  (equal (cst-input-element-conc1-rep (abnf::tree-fix abnf::cst))
         (cst-input-element-conc1-rep abnf::cst)))

Theorem: cst-input-element-conc1-rep-tree-equiv-congruence-on-cst

(defthm cst-input-element-conc1-rep-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-input-element-conc1-rep abnf::cst)
                  (cst-input-element-conc1-rep cst-equiv)))
  :rule-classes :congruence)

Function: cst-input-element-conc2-rep

(defun cst-input-element-conc2-rep (abnf::cst)
  (declare (xargs :guard (abnf::treep abnf::cst)))
  (declare
       (xargs :guard (and (cst-matchp abnf::cst "input-element")
                          (equal (cst-input-element-conc? abnf::cst)
                                 2))))
  (abnf::tree-list-fix (nth 0 (cst-input-element-conc2 abnf::cst))))

Theorem: tree-listp-of-cst-input-element-conc2-rep

(defthm tree-listp-of-cst-input-element-conc2-rep
  (b* ((abnf::csts (cst-input-element-conc2-rep abnf::cst)))
    (abnf::tree-listp abnf::csts))
  :rule-classes :rewrite)

Theorem: cst-input-element-conc2-rep-match

(defthm cst-input-element-conc2-rep-match
 (implies (and (cst-matchp abnf::cst "input-element")
               (equal (cst-input-element-conc? abnf::cst)
                      2))
          (b* ((abnf::csts (cst-input-element-conc2-rep abnf::cst)))
            (cst-list-rep-matchp abnf::csts "comment")))
 :rule-classes :rewrite)

Theorem: cst-input-element-conc2-rep-of-tree-fix-cst

(defthm cst-input-element-conc2-rep-of-tree-fix-cst
  (equal (cst-input-element-conc2-rep (abnf::tree-fix abnf::cst))
         (cst-input-element-conc2-rep abnf::cst)))

Theorem: cst-input-element-conc2-rep-tree-equiv-congruence-on-cst

(defthm cst-input-element-conc2-rep-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-input-element-conc2-rep abnf::cst)
                  (cst-input-element-conc2-rep cst-equiv)))
  :rule-classes :congruence)

Function: cst-input-element-conc3-rep

(defun cst-input-element-conc3-rep (abnf::cst)
  (declare (xargs :guard (abnf::treep abnf::cst)))
  (declare
       (xargs :guard (and (cst-matchp abnf::cst "input-element")
                          (equal (cst-input-element-conc? abnf::cst)
                                 3))))
  (abnf::tree-list-fix (nth 0 (cst-input-element-conc3 abnf::cst))))

Theorem: tree-listp-of-cst-input-element-conc3-rep

(defthm tree-listp-of-cst-input-element-conc3-rep
  (b* ((abnf::csts (cst-input-element-conc3-rep abnf::cst)))
    (abnf::tree-listp abnf::csts))
  :rule-classes :rewrite)

Theorem: cst-input-element-conc3-rep-match

(defthm cst-input-element-conc3-rep-match
 (implies (and (cst-matchp abnf::cst "input-element")
               (equal (cst-input-element-conc? abnf::cst)
                      3))
          (b* ((abnf::csts (cst-input-element-conc3-rep abnf::cst)))
            (cst-list-rep-matchp abnf::csts "token")))
 :rule-classes :rewrite)

Theorem: cst-input-element-conc3-rep-of-tree-fix-cst

(defthm cst-input-element-conc3-rep-of-tree-fix-cst
  (equal (cst-input-element-conc3-rep (abnf::tree-fix abnf::cst))
         (cst-input-element-conc3-rep abnf::cst)))

Theorem: cst-input-element-conc3-rep-tree-equiv-congruence-on-cst

(defthm cst-input-element-conc3-rep-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-input-element-conc3-rep abnf::cst)
                  (cst-input-element-conc3-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))))
  (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 "identifier")))
  :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))))
  (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 "keyword")))
  :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))))
  (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 "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))))
  (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 "separator")))
  :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))))
  (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 "operator")))
  :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-sub-conc-rep

(defun cst-sub-conc-rep (abnf::cst)
  (declare (xargs :guard (abnf::treep abnf::cst)))
  (declare (xargs :guard (cst-matchp abnf::cst "sub")))
  (abnf::tree-list-fix (nth 0 (cst-sub-conc abnf::cst))))

Theorem: tree-listp-of-cst-sub-conc-rep

(defthm tree-listp-of-cst-sub-conc-rep
  (b* ((abnf::csts (cst-sub-conc-rep abnf::cst)))
    (abnf::tree-listp abnf::csts))
  :rule-classes :rewrite)

Theorem: cst-sub-conc-rep-match

(defthm cst-sub-conc-rep-match
  (implies (cst-matchp abnf::cst "sub")
           (b* ((abnf::csts (cst-sub-conc-rep abnf::cst)))
             (cst-list-rep-matchp abnf::csts "%d26")))
  :rule-classes :rewrite)

Theorem: cst-sub-conc-rep-of-tree-fix-cst

(defthm cst-sub-conc-rep-of-tree-fix-cst
  (equal (cst-sub-conc-rep (abnf::tree-fix abnf::cst))
         (cst-sub-conc-rep abnf::cst)))

Theorem: cst-sub-conc-rep-tree-equiv-congruence-on-cst

(defthm cst-sub-conc-rep-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-sub-conc-rep abnf::cst)
                  (cst-sub-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))))
  (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 "traditional-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))))
  (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 "end-of-line-comment")))
 :rule-classes :rewrite)

Theorem: cst-comment-conc2-rep-of-tree-fix-cst

(defthm cst-comment-conc2-rep-of-tree-fix-cst
  (equal (cst-comment-conc2-rep (abnf::tree-fix abnf::cst))
         (cst-comment-conc2-rep abnf::cst)))

Theorem: cst-comment-conc2-rep-tree-equiv-congruence-on-cst

(defthm cst-comment-conc2-rep-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-comment-conc2-rep abnf::cst)
                  (cst-comment-conc2-rep cst-equiv)))
  :rule-classes :congruence)

Function: cst-not-star-conc1-rep

(defun cst-not-star-conc1-rep (abnf::cst)
  (declare (xargs :guard (abnf::treep abnf::cst)))
  (declare (xargs :guard (and (cst-matchp abnf::cst "not-star")
                              (equal (cst-not-star-conc? abnf::cst)
                                     1))))
  (abnf::tree-list-fix (nth 0 (cst-not-star-conc1 abnf::cst))))

Theorem: tree-listp-of-cst-not-star-conc1-rep

(defthm tree-listp-of-cst-not-star-conc1-rep
  (b* ((abnf::csts (cst-not-star-conc1-rep abnf::cst)))
    (abnf::tree-listp abnf::csts))
  :rule-classes :rewrite)

Theorem: cst-not-star-conc1-rep-match

(defthm cst-not-star-conc1-rep-match
  (implies (and (cst-matchp abnf::cst "not-star")
                (equal (cst-not-star-conc? abnf::cst)
                       1))
           (b* ((abnf::csts (cst-not-star-conc1-rep abnf::cst)))
             (cst-list-rep-matchp abnf::csts "input-character")))
  :rule-classes :rewrite)

Theorem: cst-not-star-conc1-rep-of-tree-fix-cst

(defthm cst-not-star-conc1-rep-of-tree-fix-cst
  (equal (cst-not-star-conc1-rep (abnf::tree-fix abnf::cst))
         (cst-not-star-conc1-rep abnf::cst)))

Theorem: cst-not-star-conc1-rep-tree-equiv-congruence-on-cst

(defthm cst-not-star-conc1-rep-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-not-star-conc1-rep abnf::cst)
                  (cst-not-star-conc1-rep cst-equiv)))
  :rule-classes :congruence)

Function: cst-not-star-conc2-rep

(defun cst-not-star-conc2-rep (abnf::cst)
  (declare (xargs :guard (abnf::treep abnf::cst)))
  (declare (xargs :guard (and (cst-matchp abnf::cst "not-star")
                              (equal (cst-not-star-conc? abnf::cst)
                                     2))))
  (abnf::tree-list-fix (nth 0 (cst-not-star-conc2 abnf::cst))))

Theorem: tree-listp-of-cst-not-star-conc2-rep

(defthm tree-listp-of-cst-not-star-conc2-rep
  (b* ((abnf::csts (cst-not-star-conc2-rep abnf::cst)))
    (abnf::tree-listp abnf::csts))
  :rule-classes :rewrite)

Theorem: cst-not-star-conc2-rep-match

(defthm cst-not-star-conc2-rep-match
  (implies (and (cst-matchp abnf::cst "not-star")
                (equal (cst-not-star-conc? abnf::cst)
                       2))
           (b* ((abnf::csts (cst-not-star-conc2-rep abnf::cst)))
             (cst-list-rep-matchp abnf::csts "line-terminator")))
  :rule-classes :rewrite)

Theorem: cst-not-star-conc2-rep-of-tree-fix-cst

(defthm cst-not-star-conc2-rep-of-tree-fix-cst
  (equal (cst-not-star-conc2-rep (abnf::tree-fix abnf::cst))
         (cst-not-star-conc2-rep abnf::cst)))

Theorem: cst-not-star-conc2-rep-tree-equiv-congruence-on-cst

(defthm cst-not-star-conc2-rep-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-not-star-conc2-rep abnf::cst)
                  (cst-not-star-conc2-rep cst-equiv)))
  :rule-classes :congruence)

Function: cst-not-star-not-slash-conc1-rep

(defun cst-not-star-not-slash-conc1-rep (abnf::cst)
 (declare (xargs :guard (abnf::treep abnf::cst)))
 (declare
  (xargs :guard (and (cst-matchp abnf::cst "not-star-not-slash")
                     (equal (cst-not-star-not-slash-conc? abnf::cst)
                            1))))
 (abnf::tree-list-fix
      (nth 0
           (cst-not-star-not-slash-conc1 abnf::cst))))

Theorem: tree-listp-of-cst-not-star-not-slash-conc1-rep

(defthm tree-listp-of-cst-not-star-not-slash-conc1-rep
  (b* ((abnf::csts (cst-not-star-not-slash-conc1-rep abnf::cst)))
    (abnf::tree-listp abnf::csts))
  :rule-classes :rewrite)

Theorem: cst-not-star-not-slash-conc1-rep-match

(defthm cst-not-star-not-slash-conc1-rep-match
 (implies
     (and (cst-matchp abnf::cst "not-star-not-slash")
          (equal (cst-not-star-not-slash-conc? abnf::cst)
                 1))
     (b* ((abnf::csts (cst-not-star-not-slash-conc1-rep abnf::cst)))
       (cst-list-rep-matchp abnf::csts "input-character")))
 :rule-classes :rewrite)

Theorem: cst-not-star-not-slash-conc1-rep-of-tree-fix-cst

(defthm cst-not-star-not-slash-conc1-rep-of-tree-fix-cst
  (equal
       (cst-not-star-not-slash-conc1-rep (abnf::tree-fix abnf::cst))
       (cst-not-star-not-slash-conc1-rep abnf::cst)))

Theorem: cst-not-star-not-slash-conc1-rep-tree-equiv-congruence-on-cst

(defthm
      cst-not-star-not-slash-conc1-rep-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-not-star-not-slash-conc1-rep abnf::cst)
                  (cst-not-star-not-slash-conc1-rep cst-equiv)))
  :rule-classes :congruence)

Function: cst-not-star-not-slash-conc2-rep

(defun cst-not-star-not-slash-conc2-rep (abnf::cst)
 (declare (xargs :guard (abnf::treep abnf::cst)))
 (declare
  (xargs :guard (and (cst-matchp abnf::cst "not-star-not-slash")
                     (equal (cst-not-star-not-slash-conc? abnf::cst)
                            2))))
 (abnf::tree-list-fix
      (nth 0
           (cst-not-star-not-slash-conc2 abnf::cst))))

Theorem: tree-listp-of-cst-not-star-not-slash-conc2-rep

(defthm tree-listp-of-cst-not-star-not-slash-conc2-rep
  (b* ((abnf::csts (cst-not-star-not-slash-conc2-rep abnf::cst)))
    (abnf::tree-listp abnf::csts))
  :rule-classes :rewrite)

Theorem: cst-not-star-not-slash-conc2-rep-match

(defthm cst-not-star-not-slash-conc2-rep-match
 (implies
     (and (cst-matchp abnf::cst "not-star-not-slash")
          (equal (cst-not-star-not-slash-conc? abnf::cst)
                 2))
     (b* ((abnf::csts (cst-not-star-not-slash-conc2-rep abnf::cst)))
       (cst-list-rep-matchp abnf::csts "line-terminator")))
 :rule-classes :rewrite)

Theorem: cst-not-star-not-slash-conc2-rep-of-tree-fix-cst

(defthm cst-not-star-not-slash-conc2-rep-of-tree-fix-cst
  (equal
       (cst-not-star-not-slash-conc2-rep (abnf::tree-fix abnf::cst))
       (cst-not-star-not-slash-conc2-rep abnf::cst)))

Theorem: cst-not-star-not-slash-conc2-rep-tree-equiv-congruence-on-cst

(defthm
      cst-not-star-not-slash-conc2-rep-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-not-star-not-slash-conc2-rep abnf::cst)
                  (cst-not-star-not-slash-conc2-rep cst-equiv)))
  :rule-classes :congruence)

Function: cst-identifier-conc-rep

(defun cst-identifier-conc-rep (abnf::cst)
  (declare (xargs :guard (abnf::treep abnf::cst)))
  (declare (xargs :guard (cst-matchp abnf::cst "identifier")))
  (abnf::tree-list-fix (nth 0 (cst-identifier-conc abnf::cst))))

Theorem: tree-listp-of-cst-identifier-conc-rep

(defthm tree-listp-of-cst-identifier-conc-rep
  (b* ((abnf::csts (cst-identifier-conc-rep abnf::cst)))
    (abnf::tree-listp abnf::csts))
  :rule-classes :rewrite)

Theorem: cst-identifier-conc-rep-match

(defthm cst-identifier-conc-rep-match
  (implies (cst-matchp abnf::cst "identifier")
           (b* ((abnf::csts (cst-identifier-conc-rep abnf::cst)))
             (cst-list-rep-matchp abnf::csts "identifier-chars")))
  :rule-classes :rewrite)

Theorem: cst-identifier-conc-rep-of-tree-fix-cst

(defthm cst-identifier-conc-rep-of-tree-fix-cst
  (equal (cst-identifier-conc-rep (abnf::tree-fix abnf::cst))
         (cst-identifier-conc-rep abnf::cst)))

Theorem: cst-identifier-conc-rep-tree-equiv-congruence-on-cst

(defthm cst-identifier-conc-rep-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-identifier-conc-rep abnf::cst)
                  (cst-identifier-conc-rep cst-equiv)))
  :rule-classes :congruence)

Function: cst-java-letter-conc-rep

(defun cst-java-letter-conc-rep (abnf::cst)
  (declare (xargs :guard (abnf::treep abnf::cst)))
  (declare (xargs :guard (cst-matchp abnf::cst "java-letter")))
  (abnf::tree-list-fix (nth 0 (cst-java-letter-conc abnf::cst))))

Theorem: tree-listp-of-cst-java-letter-conc-rep

(defthm tree-listp-of-cst-java-letter-conc-rep
  (b* ((abnf::csts (cst-java-letter-conc-rep abnf::cst)))
    (abnf::tree-listp abnf::csts))
  :rule-classes :rewrite)

Theorem: cst-java-letter-conc-rep-match

(defthm cst-java-letter-conc-rep-match
 (implies (cst-matchp abnf::cst "java-letter")
          (b* ((abnf::csts (cst-java-letter-conc-rep abnf::cst)))
            (cst-list-rep-matchp abnf::csts "raw-input-character")))
 :rule-classes :rewrite)

Theorem: cst-java-letter-conc-rep-of-tree-fix-cst

(defthm cst-java-letter-conc-rep-of-tree-fix-cst
  (equal (cst-java-letter-conc-rep (abnf::tree-fix abnf::cst))
         (cst-java-letter-conc-rep abnf::cst)))

Theorem: cst-java-letter-conc-rep-tree-equiv-congruence-on-cst

(defthm cst-java-letter-conc-rep-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-java-letter-conc-rep abnf::cst)
                  (cst-java-letter-conc-rep cst-equiv)))
  :rule-classes :congruence)

Function: cst-java-letter-or-digit-conc-rep

(defun cst-java-letter-or-digit-conc-rep (abnf::cst)
  (declare (xargs :guard (abnf::treep abnf::cst)))
  (declare
       (xargs :guard (cst-matchp abnf::cst "java-letter-or-digit")))
  (abnf::tree-list-fix
       (nth 0
            (cst-java-letter-or-digit-conc abnf::cst))))

Theorem: tree-listp-of-cst-java-letter-or-digit-conc-rep

(defthm tree-listp-of-cst-java-letter-or-digit-conc-rep
  (b* ((abnf::csts (cst-java-letter-or-digit-conc-rep abnf::cst)))
    (abnf::tree-listp abnf::csts))
  :rule-classes :rewrite)

Theorem: cst-java-letter-or-digit-conc-rep-match

(defthm cst-java-letter-or-digit-conc-rep-match
 (implies
    (cst-matchp abnf::cst "java-letter-or-digit")
    (b* ((abnf::csts (cst-java-letter-or-digit-conc-rep abnf::cst)))
      (cst-list-rep-matchp abnf::csts "raw-input-character")))
 :rule-classes :rewrite)

Theorem: cst-java-letter-or-digit-conc-rep-of-tree-fix-cst

(defthm cst-java-letter-or-digit-conc-rep-of-tree-fix-cst
 (equal
      (cst-java-letter-or-digit-conc-rep (abnf::tree-fix abnf::cst))
      (cst-java-letter-or-digit-conc-rep abnf::cst)))

Theorem: cst-java-letter-or-digit-conc-rep-tree-equiv-congruence-on-cst

(defthm
     cst-java-letter-or-digit-conc-rep-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-java-letter-or-digit-conc-rep abnf::cst)
                  (cst-java-letter-or-digit-conc-rep cst-equiv)))
  :rule-classes :congruence)

Function: cst-type-identifier-conc-rep

(defun cst-type-identifier-conc-rep (abnf::cst)
  (declare (xargs :guard (abnf::treep abnf::cst)))
  (declare (xargs :guard (cst-matchp abnf::cst "type-identifier")))
  (abnf::tree-list-fix (nth 0
                            (cst-type-identifier-conc abnf::cst))))

Theorem: tree-listp-of-cst-type-identifier-conc-rep

(defthm tree-listp-of-cst-type-identifier-conc-rep
  (b* ((abnf::csts (cst-type-identifier-conc-rep abnf::cst)))
    (abnf::tree-listp abnf::csts))
  :rule-classes :rewrite)

Theorem: cst-type-identifier-conc-rep-match

(defthm cst-type-identifier-conc-rep-match
  (implies
       (cst-matchp abnf::cst "type-identifier")
       (b* ((abnf::csts (cst-type-identifier-conc-rep abnf::cst)))
         (cst-list-rep-matchp abnf::csts "identifier")))
  :rule-classes :rewrite)

Theorem: cst-type-identifier-conc-rep-of-tree-fix-cst

(defthm cst-type-identifier-conc-rep-of-tree-fix-cst
  (equal (cst-type-identifier-conc-rep (abnf::tree-fix abnf::cst))
         (cst-type-identifier-conc-rep abnf::cst)))

Theorem: cst-type-identifier-conc-rep-tree-equiv-congruence-on-cst

(defthm cst-type-identifier-conc-rep-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-type-identifier-conc-rep abnf::cst)
                  (cst-type-identifier-conc-rep cst-equiv)))
  :rule-classes :congruence)

Function: cst-unqualified-method-identifier-conc-rep

(defun cst-unqualified-method-identifier-conc-rep (abnf::cst)
  (declare (xargs :guard (abnf::treep abnf::cst)))
  (declare
       (xargs :guard (cst-matchp abnf::cst
                                 "unqualified-method-identifier")))
  (abnf::tree-list-fix
       (nth 0
            (cst-unqualified-method-identifier-conc abnf::cst))))

Theorem: tree-listp-of-cst-unqualified-method-identifier-conc-rep

(defthm tree-listp-of-cst-unqualified-method-identifier-conc-rep
  (b* ((abnf::csts
            (cst-unqualified-method-identifier-conc-rep abnf::cst)))
    (abnf::tree-listp abnf::csts))
  :rule-classes :rewrite)

Theorem: cst-unqualified-method-identifier-conc-rep-match

(defthm cst-unqualified-method-identifier-conc-rep-match
 (implies
  (cst-matchp abnf::cst
              "unqualified-method-identifier")
  (b* ((abnf::csts
            (cst-unqualified-method-identifier-conc-rep abnf::cst)))
    (cst-list-rep-matchp abnf::csts "identifier")))
 :rule-classes :rewrite)

Theorem: cst-unqualified-method-identifier-conc-rep-of-tree-fix-cst

(defthm cst-unqualified-method-identifier-conc-rep-of-tree-fix-cst
  (equal (cst-unqualified-method-identifier-conc-rep
              (abnf::tree-fix abnf::cst))
         (cst-unqualified-method-identifier-conc-rep abnf::cst)))

Theorem: cst-unqualified-method-identifier-conc-rep-tree-equiv-congruence-on-cst

(defthm
 cst-unqualified-method-identifier-conc-rep-tree-equiv-congruence-on-cst
 (implies
     (abnf::tree-equiv abnf::cst cst-equiv)
     (equal (cst-unqualified-method-identifier-conc-rep abnf::cst)
            (cst-unqualified-method-identifier-conc-rep cst-equiv)))
 :rule-classes :congruence)

Function: cst-keyword-conc1-rep

(defun cst-keyword-conc1-rep (abnf::cst)
  (declare (xargs :guard (abnf::treep abnf::cst)))
  (declare (xargs :guard (and (cst-matchp abnf::cst "keyword")
                              (equal (cst-keyword-conc? abnf::cst)
                                     1))))
  (abnf::tree-list-fix (nth 0 (cst-keyword-conc1 abnf::cst))))

Theorem: tree-listp-of-cst-keyword-conc1-rep

(defthm tree-listp-of-cst-keyword-conc1-rep
  (b* ((abnf::csts (cst-keyword-conc1-rep abnf::cst)))
    (abnf::tree-listp abnf::csts))
  :rule-classes :rewrite)

Theorem: cst-keyword-conc1-rep-match

(defthm cst-keyword-conc1-rep-match
  (implies (and (cst-matchp abnf::cst "keyword")
                (equal (cst-keyword-conc? abnf::cst) 1))
           (b* ((abnf::csts (cst-keyword-conc1-rep abnf::cst)))
             (cst-list-rep-matchp abnf::csts "reserved-keyword")))
  :rule-classes :rewrite)

Theorem: cst-keyword-conc1-rep-of-tree-fix-cst

(defthm cst-keyword-conc1-rep-of-tree-fix-cst
  (equal (cst-keyword-conc1-rep (abnf::tree-fix abnf::cst))
         (cst-keyword-conc1-rep abnf::cst)))

Theorem: cst-keyword-conc1-rep-tree-equiv-congruence-on-cst

(defthm cst-keyword-conc1-rep-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-keyword-conc1-rep abnf::cst)
                  (cst-keyword-conc1-rep cst-equiv)))
  :rule-classes :congruence)

Function: cst-keyword-conc2-rep

(defun cst-keyword-conc2-rep (abnf::cst)
  (declare (xargs :guard (abnf::treep abnf::cst)))
  (declare (xargs :guard (and (cst-matchp abnf::cst "keyword")
                              (equal (cst-keyword-conc? abnf::cst)
                                     2))))
  (abnf::tree-list-fix (nth 0 (cst-keyword-conc2 abnf::cst))))

Theorem: tree-listp-of-cst-keyword-conc2-rep

(defthm tree-listp-of-cst-keyword-conc2-rep
  (b* ((abnf::csts (cst-keyword-conc2-rep abnf::cst)))
    (abnf::tree-listp abnf::csts))
  :rule-classes :rewrite)

Theorem: cst-keyword-conc2-rep-match

(defthm cst-keyword-conc2-rep-match
  (implies (and (cst-matchp abnf::cst "keyword")
                (equal (cst-keyword-conc? abnf::cst) 2))
           (b* ((abnf::csts (cst-keyword-conc2-rep abnf::cst)))
             (cst-list-rep-matchp abnf::csts "contextual-keyword")))
  :rule-classes :rewrite)

Theorem: cst-keyword-conc2-rep-of-tree-fix-cst

(defthm cst-keyword-conc2-rep-of-tree-fix-cst
  (equal (cst-keyword-conc2-rep (abnf::tree-fix abnf::cst))
         (cst-keyword-conc2-rep abnf::cst)))

Theorem: cst-keyword-conc2-rep-tree-equiv-congruence-on-cst

(defthm cst-keyword-conc2-rep-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-keyword-conc2-rep abnf::cst)
                  (cst-keyword-conc2-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))))
  (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 "integer-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))))
  (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 "floating-point-literal")))
  :rule-classes :rewrite)

Theorem: cst-literal-conc2-rep-of-tree-fix-cst

(defthm cst-literal-conc2-rep-of-tree-fix-cst
  (equal (cst-literal-conc2-rep (abnf::tree-fix abnf::cst))
         (cst-literal-conc2-rep abnf::cst)))

Theorem: cst-literal-conc2-rep-tree-equiv-congruence-on-cst

(defthm cst-literal-conc2-rep-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-literal-conc2-rep abnf::cst)
                  (cst-literal-conc2-rep cst-equiv)))
  :rule-classes :congruence)

Function: cst-literal-conc3-rep

(defun cst-literal-conc3-rep (abnf::cst)
  (declare (xargs :guard (abnf::treep abnf::cst)))
  (declare (xargs :guard (and (cst-matchp abnf::cst "literal")
                              (equal (cst-literal-conc? abnf::cst)
                                     3))))
  (abnf::tree-list-fix (nth 0 (cst-literal-conc3 abnf::cst))))

Theorem: tree-listp-of-cst-literal-conc3-rep

(defthm tree-listp-of-cst-literal-conc3-rep
  (b* ((abnf::csts (cst-literal-conc3-rep abnf::cst)))
    (abnf::tree-listp abnf::csts))
  :rule-classes :rewrite)

Theorem: cst-literal-conc3-rep-match

(defthm cst-literal-conc3-rep-match
  (implies (and (cst-matchp abnf::cst "literal")
                (equal (cst-literal-conc? abnf::cst) 3))
           (b* ((abnf::csts (cst-literal-conc3-rep abnf::cst)))
             (cst-list-rep-matchp abnf::csts "boolean-literal")))
  :rule-classes :rewrite)

Theorem: cst-literal-conc3-rep-of-tree-fix-cst

(defthm cst-literal-conc3-rep-of-tree-fix-cst
  (equal (cst-literal-conc3-rep (abnf::tree-fix abnf::cst))
         (cst-literal-conc3-rep abnf::cst)))

Theorem: cst-literal-conc3-rep-tree-equiv-congruence-on-cst

(defthm cst-literal-conc3-rep-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-literal-conc3-rep abnf::cst)
                  (cst-literal-conc3-rep cst-equiv)))
  :rule-classes :congruence)

Function: cst-literal-conc4-rep

(defun cst-literal-conc4-rep (abnf::cst)
  (declare (xargs :guard (abnf::treep abnf::cst)))
  (declare (xargs :guard (and (cst-matchp abnf::cst "literal")
                              (equal (cst-literal-conc? abnf::cst)
                                     4))))
  (abnf::tree-list-fix (nth 0 (cst-literal-conc4 abnf::cst))))

Theorem: tree-listp-of-cst-literal-conc4-rep

(defthm tree-listp-of-cst-literal-conc4-rep
  (b* ((abnf::csts (cst-literal-conc4-rep abnf::cst)))
    (abnf::tree-listp abnf::csts))
  :rule-classes :rewrite)

Theorem: cst-literal-conc4-rep-match

(defthm cst-literal-conc4-rep-match
  (implies (and (cst-matchp abnf::cst "literal")
                (equal (cst-literal-conc? abnf::cst) 4))
           (b* ((abnf::csts (cst-literal-conc4-rep abnf::cst)))
             (cst-list-rep-matchp abnf::csts "character-literal")))
  :rule-classes :rewrite)

Theorem: cst-literal-conc4-rep-of-tree-fix-cst

(defthm cst-literal-conc4-rep-of-tree-fix-cst
  (equal (cst-literal-conc4-rep (abnf::tree-fix abnf::cst))
         (cst-literal-conc4-rep abnf::cst)))

Theorem: cst-literal-conc4-rep-tree-equiv-congruence-on-cst

(defthm cst-literal-conc4-rep-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-literal-conc4-rep abnf::cst)
                  (cst-literal-conc4-rep cst-equiv)))
  :rule-classes :congruence)

Function: cst-literal-conc5-rep

(defun cst-literal-conc5-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)
                                     5))))
  (abnf::tree-list-fix (nth 0 (cst-literal-conc5 abnf::cst))))

Theorem: tree-listp-of-cst-literal-conc5-rep

(defthm tree-listp-of-cst-literal-conc5-rep
  (b* ((abnf::csts (cst-literal-conc5-rep abnf::cst)))
    (abnf::tree-listp abnf::csts))
  :rule-classes :rewrite)

Theorem: cst-literal-conc5-rep-match

(defthm cst-literal-conc5-rep-match
  (implies (and (cst-matchp abnf::cst "literal")
                (equal (cst-literal-conc? abnf::cst) 5))
           (b* ((abnf::csts (cst-literal-conc5-rep abnf::cst)))
             (cst-list-rep-matchp abnf::csts "string-literal")))
  :rule-classes :rewrite)

Theorem: cst-literal-conc5-rep-of-tree-fix-cst

(defthm cst-literal-conc5-rep-of-tree-fix-cst
  (equal (cst-literal-conc5-rep (abnf::tree-fix abnf::cst))
         (cst-literal-conc5-rep abnf::cst)))

Theorem: cst-literal-conc5-rep-tree-equiv-congruence-on-cst

(defthm cst-literal-conc5-rep-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-literal-conc5-rep abnf::cst)
                  (cst-literal-conc5-rep cst-equiv)))
  :rule-classes :congruence)

Function: cst-literal-conc6-rep

(defun cst-literal-conc6-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)
                                     6))))
  (abnf::tree-list-fix (nth 0 (cst-literal-conc6 abnf::cst))))

Theorem: tree-listp-of-cst-literal-conc6-rep

(defthm tree-listp-of-cst-literal-conc6-rep
  (b* ((abnf::csts (cst-literal-conc6-rep abnf::cst)))
    (abnf::tree-listp abnf::csts))
  :rule-classes :rewrite)

Theorem: cst-literal-conc6-rep-match

(defthm cst-literal-conc6-rep-match
  (implies (and (cst-matchp abnf::cst "literal")
                (equal (cst-literal-conc? abnf::cst) 6))
           (b* ((abnf::csts (cst-literal-conc6-rep abnf::cst)))
             (cst-list-rep-matchp abnf::csts "text-block")))
  :rule-classes :rewrite)

Theorem: cst-literal-conc6-rep-of-tree-fix-cst

(defthm cst-literal-conc6-rep-of-tree-fix-cst
  (equal (cst-literal-conc6-rep (abnf::tree-fix abnf::cst))
         (cst-literal-conc6-rep abnf::cst)))

Theorem: cst-literal-conc6-rep-tree-equiv-congruence-on-cst

(defthm cst-literal-conc6-rep-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-literal-conc6-rep abnf::cst)
                  (cst-literal-conc6-rep cst-equiv)))
  :rule-classes :congruence)

Function: cst-literal-conc7-rep

(defun cst-literal-conc7-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)
                                     7))))
  (abnf::tree-list-fix (nth 0 (cst-literal-conc7 abnf::cst))))

Theorem: tree-listp-of-cst-literal-conc7-rep

(defthm tree-listp-of-cst-literal-conc7-rep
  (b* ((abnf::csts (cst-literal-conc7-rep abnf::cst)))
    (abnf::tree-listp abnf::csts))
  :rule-classes :rewrite)

Theorem: cst-literal-conc7-rep-match

(defthm cst-literal-conc7-rep-match
  (implies (and (cst-matchp abnf::cst "literal")
                (equal (cst-literal-conc? abnf::cst) 7))
           (b* ((abnf::csts (cst-literal-conc7-rep abnf::cst)))
             (cst-list-rep-matchp abnf::csts "null-literal")))
  :rule-classes :rewrite)

Theorem: cst-literal-conc7-rep-of-tree-fix-cst

(defthm cst-literal-conc7-rep-of-tree-fix-cst
  (equal (cst-literal-conc7-rep (abnf::tree-fix abnf::cst))
         (cst-literal-conc7-rep abnf::cst)))

Theorem: cst-literal-conc7-rep-tree-equiv-congruence-on-cst

(defthm cst-literal-conc7-rep-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-literal-conc7-rep abnf::cst)
                  (cst-literal-conc7-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))))
 (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 "decimal-integer-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))))
 (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 "hex-integer-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-integer-literal-conc3-rep

(defun cst-integer-literal-conc3-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)
                               3))))
 (abnf::tree-list-fix (nth 0
                           (cst-integer-literal-conc3 abnf::cst))))

Theorem: tree-listp-of-cst-integer-literal-conc3-rep

(defthm tree-listp-of-cst-integer-literal-conc3-rep
  (b* ((abnf::csts (cst-integer-literal-conc3-rep abnf::cst)))
    (abnf::tree-listp abnf::csts))
  :rule-classes :rewrite)

Theorem: cst-integer-literal-conc3-rep-match

(defthm cst-integer-literal-conc3-rep-match
  (implies
       (and (cst-matchp abnf::cst "integer-literal")
            (equal (cst-integer-literal-conc? abnf::cst)
                   3))
       (b* ((abnf::csts (cst-integer-literal-conc3-rep abnf::cst)))
         (cst-list-rep-matchp abnf::csts "octal-integer-literal")))
  :rule-classes :rewrite)

Theorem: cst-integer-literal-conc3-rep-of-tree-fix-cst

(defthm cst-integer-literal-conc3-rep-of-tree-fix-cst
  (equal (cst-integer-literal-conc3-rep (abnf::tree-fix abnf::cst))
         (cst-integer-literal-conc3-rep abnf::cst)))

Theorem: cst-integer-literal-conc3-rep-tree-equiv-congruence-on-cst

(defthm cst-integer-literal-conc3-rep-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-integer-literal-conc3-rep abnf::cst)
                  (cst-integer-literal-conc3-rep cst-equiv)))
  :rule-classes :congruence)

Function: cst-integer-literal-conc4-rep

(defun cst-integer-literal-conc4-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)
                               4))))
 (abnf::tree-list-fix (nth 0
                           (cst-integer-literal-conc4 abnf::cst))))

Theorem: tree-listp-of-cst-integer-literal-conc4-rep

(defthm tree-listp-of-cst-integer-literal-conc4-rep
  (b* ((abnf::csts (cst-integer-literal-conc4-rep abnf::cst)))
    (abnf::tree-listp abnf::csts))
  :rule-classes :rewrite)

Theorem: cst-integer-literal-conc4-rep-match

(defthm cst-integer-literal-conc4-rep-match
  (implies
       (and (cst-matchp abnf::cst "integer-literal")
            (equal (cst-integer-literal-conc? abnf::cst)
                   4))
       (b* ((abnf::csts (cst-integer-literal-conc4-rep abnf::cst)))
         (cst-list-rep-matchp abnf::csts "binary-integer-literal")))
  :rule-classes :rewrite)

Theorem: cst-integer-literal-conc4-rep-of-tree-fix-cst

(defthm cst-integer-literal-conc4-rep-of-tree-fix-cst
  (equal (cst-integer-literal-conc4-rep (abnf::tree-fix abnf::cst))
         (cst-integer-literal-conc4-rep abnf::cst)))

Theorem: cst-integer-literal-conc4-rep-tree-equiv-congruence-on-cst

(defthm cst-integer-literal-conc4-rep-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-integer-literal-conc4-rep abnf::cst)
                  (cst-integer-literal-conc4-rep cst-equiv)))
  :rule-classes :congruence)

Function: cst-integer-type-suffix-conc-rep

(defun cst-integer-type-suffix-conc-rep (abnf::cst)
  (declare (xargs :guard (abnf::treep abnf::cst)))
  (declare
       (xargs :guard (cst-matchp abnf::cst "integer-type-suffix")))
  (abnf::tree-list-fix
       (nth 0
            (cst-integer-type-suffix-conc abnf::cst))))

Theorem: tree-listp-of-cst-integer-type-suffix-conc-rep

(defthm tree-listp-of-cst-integer-type-suffix-conc-rep
  (b* ((abnf::csts (cst-integer-type-suffix-conc-rep abnf::cst)))
    (abnf::tree-listp abnf::csts))
  :rule-classes :rewrite)

Theorem: cst-integer-type-suffix-conc-rep-match

(defthm cst-integer-type-suffix-conc-rep-match
 (implies
     (cst-matchp abnf::cst "integer-type-suffix")
     (b* ((abnf::csts (cst-integer-type-suffix-conc-rep abnf::cst)))
       (cst-list-rep-matchp abnf::csts "\"l\"")))
 :rule-classes :rewrite)

Theorem: cst-integer-type-suffix-conc-rep-of-tree-fix-cst

(defthm cst-integer-type-suffix-conc-rep-of-tree-fix-cst
  (equal
       (cst-integer-type-suffix-conc-rep (abnf::tree-fix abnf::cst))
       (cst-integer-type-suffix-conc-rep abnf::cst)))

Theorem: cst-integer-type-suffix-conc-rep-tree-equiv-congruence-on-cst

(defthm
      cst-integer-type-suffix-conc-rep-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-integer-type-suffix-conc-rep abnf::cst)
                  (cst-integer-type-suffix-conc-rep cst-equiv)))
  :rule-classes :congruence)

Function: cst-floating-point-literal-conc1-rep

(defun cst-floating-point-literal-conc1-rep (abnf::cst)
 (declare (xargs :guard (abnf::treep abnf::cst)))
 (declare
  (xargs
     :guard (and (cst-matchp abnf::cst "floating-point-literal")
                 (equal (cst-floating-point-literal-conc? abnf::cst)
                        1))))
 (abnf::tree-list-fix
      (nth 0
           (cst-floating-point-literal-conc1 abnf::cst))))

Theorem: tree-listp-of-cst-floating-point-literal-conc1-rep

(defthm tree-listp-of-cst-floating-point-literal-conc1-rep
 (b* ((abnf::csts (cst-floating-point-literal-conc1-rep abnf::cst)))
   (abnf::tree-listp abnf::csts))
 :rule-classes :rewrite)

Theorem: cst-floating-point-literal-conc1-rep-match

(defthm cst-floating-point-literal-conc1-rep-match
 (implies
   (and (cst-matchp abnf::cst "floating-point-literal")
        (equal (cst-floating-point-literal-conc? abnf::cst)
               1))
   (b*
     ((abnf::csts (cst-floating-point-literal-conc1-rep abnf::cst)))
     (cst-list-rep-matchp abnf::csts
                          "decimal-floating-point-literal")))
 :rule-classes :rewrite)

Theorem: cst-floating-point-literal-conc1-rep-of-tree-fix-cst

(defthm cst-floating-point-literal-conc1-rep-of-tree-fix-cst
 (equal
   (cst-floating-point-literal-conc1-rep (abnf::tree-fix abnf::cst))
   (cst-floating-point-literal-conc1-rep abnf::cst)))

Theorem: cst-floating-point-literal-conc1-rep-tree-equiv-congruence-on-cst

(defthm
  cst-floating-point-literal-conc1-rep-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-floating-point-literal-conc1-rep abnf::cst)
                  (cst-floating-point-literal-conc1-rep cst-equiv)))
  :rule-classes :congruence)

Function: cst-floating-point-literal-conc2-rep

(defun cst-floating-point-literal-conc2-rep (abnf::cst)
 (declare (xargs :guard (abnf::treep abnf::cst)))
 (declare
  (xargs
     :guard (and (cst-matchp abnf::cst "floating-point-literal")
                 (equal (cst-floating-point-literal-conc? abnf::cst)
                        2))))
 (abnf::tree-list-fix
      (nth 0
           (cst-floating-point-literal-conc2 abnf::cst))))

Theorem: tree-listp-of-cst-floating-point-literal-conc2-rep

(defthm tree-listp-of-cst-floating-point-literal-conc2-rep
 (b* ((abnf::csts (cst-floating-point-literal-conc2-rep abnf::cst)))
   (abnf::tree-listp abnf::csts))
 :rule-classes :rewrite)

Theorem: cst-floating-point-literal-conc2-rep-match

(defthm cst-floating-point-literal-conc2-rep-match
 (implies
   (and (cst-matchp abnf::cst "floating-point-literal")
        (equal (cst-floating-point-literal-conc? abnf::cst)
               2))
   (b*
     ((abnf::csts (cst-floating-point-literal-conc2-rep abnf::cst)))
     (cst-list-rep-matchp abnf::csts
                          "hexadecimal-floating-point-literal")))
 :rule-classes :rewrite)

Theorem: cst-floating-point-literal-conc2-rep-of-tree-fix-cst

(defthm cst-floating-point-literal-conc2-rep-of-tree-fix-cst
 (equal
   (cst-floating-point-literal-conc2-rep (abnf::tree-fix abnf::cst))
   (cst-floating-point-literal-conc2-rep abnf::cst)))

Theorem: cst-floating-point-literal-conc2-rep-tree-equiv-congruence-on-cst

(defthm
  cst-floating-point-literal-conc2-rep-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-floating-point-literal-conc2-rep abnf::cst)
                  (cst-floating-point-literal-conc2-rep cst-equiv)))
  :rule-classes :congruence)

Function: cst-exponent-indicator-conc-rep

(defun cst-exponent-indicator-conc-rep (abnf::cst)
  (declare (xargs :guard (abnf::treep abnf::cst)))
  (declare
       (xargs :guard (cst-matchp abnf::cst "exponent-indicator")))
  (abnf::tree-list-fix
       (nth 0
            (cst-exponent-indicator-conc abnf::cst))))

Theorem: tree-listp-of-cst-exponent-indicator-conc-rep

(defthm tree-listp-of-cst-exponent-indicator-conc-rep
  (b* ((abnf::csts (cst-exponent-indicator-conc-rep abnf::cst)))
    (abnf::tree-listp abnf::csts))
  :rule-classes :rewrite)

Theorem: cst-exponent-indicator-conc-rep-match

(defthm cst-exponent-indicator-conc-rep-match
 (implies
      (cst-matchp abnf::cst "exponent-indicator")
      (b* ((abnf::csts (cst-exponent-indicator-conc-rep abnf::cst)))
        (cst-list-rep-matchp abnf::csts "\"e\"")))
 :rule-classes :rewrite)

Theorem: cst-exponent-indicator-conc-rep-of-tree-fix-cst

(defthm cst-exponent-indicator-conc-rep-of-tree-fix-cst
 (equal (cst-exponent-indicator-conc-rep (abnf::tree-fix abnf::cst))
        (cst-exponent-indicator-conc-rep abnf::cst)))

Theorem: cst-exponent-indicator-conc-rep-tree-equiv-congruence-on-cst

(defthm cst-exponent-indicator-conc-rep-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-exponent-indicator-conc-rep abnf::cst)
                  (cst-exponent-indicator-conc-rep cst-equiv)))
  :rule-classes :congruence)

Function: cst-binary-exponent-indicator-conc-rep

(defun cst-binary-exponent-indicator-conc-rep (abnf::cst)
 (declare (xargs :guard (abnf::treep abnf::cst)))
 (declare
  (xargs :guard (cst-matchp abnf::cst "binary-exponent-indicator")))
 (abnf::tree-list-fix
      (nth 0
           (cst-binary-exponent-indicator-conc abnf::cst))))

Theorem: tree-listp-of-cst-binary-exponent-indicator-conc-rep

(defthm tree-listp-of-cst-binary-exponent-indicator-conc-rep
  (b*
   ((abnf::csts (cst-binary-exponent-indicator-conc-rep abnf::cst)))
   (abnf::tree-listp abnf::csts))
  :rule-classes :rewrite)

Theorem: cst-binary-exponent-indicator-conc-rep-match

(defthm cst-binary-exponent-indicator-conc-rep-match
 (implies
  (cst-matchp abnf::cst "binary-exponent-indicator")
  (b*
   ((abnf::csts (cst-binary-exponent-indicator-conc-rep abnf::cst)))
   (cst-list-rep-matchp abnf::csts "\"p\"")))
 :rule-classes :rewrite)

Theorem: cst-binary-exponent-indicator-conc-rep-of-tree-fix-cst

(defthm cst-binary-exponent-indicator-conc-rep-of-tree-fix-cst
  (equal (cst-binary-exponent-indicator-conc-rep
              (abnf::tree-fix abnf::cst))
         (cst-binary-exponent-indicator-conc-rep abnf::cst)))

Theorem: cst-binary-exponent-indicator-conc-rep-tree-equiv-congruence-on-cst

(defthm
 cst-binary-exponent-indicator-conc-rep-tree-equiv-congruence-on-cst
 (implies
      (abnf::tree-equiv abnf::cst cst-equiv)
      (equal (cst-binary-exponent-indicator-conc-rep abnf::cst)
             (cst-binary-exponent-indicator-conc-rep cst-equiv)))
 :rule-classes :congruence)

Function: cst-single-character-conc-rep

(defun cst-single-character-conc-rep (abnf::cst)
  (declare (xargs :guard (abnf::treep abnf::cst)))
  (declare (xargs :guard (cst-matchp abnf::cst "single-character")))
  (abnf::tree-list-fix (nth 0
                            (cst-single-character-conc abnf::cst))))

Theorem: tree-listp-of-cst-single-character-conc-rep

(defthm tree-listp-of-cst-single-character-conc-rep
  (b* ((abnf::csts (cst-single-character-conc-rep abnf::cst)))
    (abnf::tree-listp abnf::csts))
  :rule-classes :rewrite)

Theorem: cst-single-character-conc-rep-match

(defthm cst-single-character-conc-rep-match
  (implies
       (cst-matchp abnf::cst "single-character")
       (b* ((abnf::csts (cst-single-character-conc-rep abnf::cst)))
         (cst-list-rep-matchp abnf::csts "input-character")))
  :rule-classes :rewrite)

Theorem: cst-single-character-conc-rep-of-tree-fix-cst

(defthm cst-single-character-conc-rep-of-tree-fix-cst
  (equal (cst-single-character-conc-rep (abnf::tree-fix abnf::cst))
         (cst-single-character-conc-rep abnf::cst)))

Theorem: cst-single-character-conc-rep-tree-equiv-congruence-on-cst

(defthm cst-single-character-conc-rep-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-single-character-conc-rep abnf::cst)
                  (cst-single-character-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))))
 (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 "input-character")))
  :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))))
 (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 "escape-sequence")))
  :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-text-block-white-space-conc-rep

(defun cst-text-block-white-space-conc-rep (abnf::cst)
 (declare (xargs :guard (abnf::treep abnf::cst)))
 (declare
     (xargs :guard (cst-matchp abnf::cst "text-block-white-space")))
 (abnf::tree-list-fix
      (nth 0
           (cst-text-block-white-space-conc abnf::cst))))

Theorem: tree-listp-of-cst-text-block-white-space-conc-rep

(defthm tree-listp-of-cst-text-block-white-space-conc-rep
  (b* ((abnf::csts (cst-text-block-white-space-conc-rep abnf::cst)))
    (abnf::tree-listp abnf::csts))
  :rule-classes :rewrite)

Theorem: cst-text-block-white-space-conc-rep-match

(defthm cst-text-block-white-space-conc-rep-match
 (implies
  (cst-matchp abnf::cst "text-block-white-space")
  (b* ((abnf::csts (cst-text-block-white-space-conc-rep abnf::cst)))
    (cst-list-rep-matchp abnf::csts "white-space")))
 :rule-classes :rewrite)

Theorem: cst-text-block-white-space-conc-rep-of-tree-fix-cst

(defthm cst-text-block-white-space-conc-rep-of-tree-fix-cst
 (equal
    (cst-text-block-white-space-conc-rep (abnf::tree-fix abnf::cst))
    (cst-text-block-white-space-conc-rep abnf::cst)))

Theorem: cst-text-block-white-space-conc-rep-tree-equiv-congruence-on-cst

(defthm
   cst-text-block-white-space-conc-rep-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-text-block-white-space-conc-rep abnf::cst)
                  (cst-text-block-white-space-conc-rep cst-equiv)))
  :rule-classes :congruence)

Function: cst-text-block-character-conc1-rep

(defun cst-text-block-character-conc1-rep (abnf::cst)
 (declare (xargs :guard (abnf::treep abnf::cst)))
 (declare
  (xargs
       :guard (and (cst-matchp abnf::cst "text-block-character")
                   (equal (cst-text-block-character-conc? abnf::cst)
                          1))))
 (abnf::tree-list-fix
      (nth 0
           (cst-text-block-character-conc1 abnf::cst))))

Theorem: tree-listp-of-cst-text-block-character-conc1-rep

(defthm tree-listp-of-cst-text-block-character-conc1-rep
  (b* ((abnf::csts (cst-text-block-character-conc1-rep abnf::cst)))
    (abnf::tree-listp abnf::csts))
  :rule-classes :rewrite)

Theorem: cst-text-block-character-conc1-rep-match

(defthm cst-text-block-character-conc1-rep-match
 (implies
   (and (cst-matchp abnf::cst "text-block-character")
        (equal (cst-text-block-character-conc? abnf::cst)
               1))
   (b* ((abnf::csts (cst-text-block-character-conc1-rep abnf::cst)))
     (cst-list-rep-matchp abnf::csts "input-character")))
 :rule-classes :rewrite)

Theorem: cst-text-block-character-conc1-rep-of-tree-fix-cst

(defthm cst-text-block-character-conc1-rep-of-tree-fix-cst
 (equal
     (cst-text-block-character-conc1-rep (abnf::tree-fix abnf::cst))
     (cst-text-block-character-conc1-rep abnf::cst)))

Theorem: cst-text-block-character-conc1-rep-tree-equiv-congruence-on-cst

(defthm
    cst-text-block-character-conc1-rep-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-text-block-character-conc1-rep abnf::cst)
                  (cst-text-block-character-conc1-rep cst-equiv)))
  :rule-classes :congruence)

Function: cst-text-block-character-conc2-rep

(defun cst-text-block-character-conc2-rep (abnf::cst)
 (declare (xargs :guard (abnf::treep abnf::cst)))
 (declare
  (xargs
       :guard (and (cst-matchp abnf::cst "text-block-character")
                   (equal (cst-text-block-character-conc? abnf::cst)
                          2))))
 (abnf::tree-list-fix
      (nth 0
           (cst-text-block-character-conc2 abnf::cst))))

Theorem: tree-listp-of-cst-text-block-character-conc2-rep

(defthm tree-listp-of-cst-text-block-character-conc2-rep
  (b* ((abnf::csts (cst-text-block-character-conc2-rep abnf::cst)))
    (abnf::tree-listp abnf::csts))
  :rule-classes :rewrite)

Theorem: cst-text-block-character-conc2-rep-match

(defthm cst-text-block-character-conc2-rep-match
 (implies
   (and (cst-matchp abnf::cst "text-block-character")
        (equal (cst-text-block-character-conc? abnf::cst)
               2))
   (b* ((abnf::csts (cst-text-block-character-conc2-rep abnf::cst)))
     (cst-list-rep-matchp abnf::csts "escape-sequence")))
 :rule-classes :rewrite)

Theorem: cst-text-block-character-conc2-rep-of-tree-fix-cst

(defthm cst-text-block-character-conc2-rep-of-tree-fix-cst
 (equal
     (cst-text-block-character-conc2-rep (abnf::tree-fix abnf::cst))
     (cst-text-block-character-conc2-rep abnf::cst)))

Theorem: cst-text-block-character-conc2-rep-tree-equiv-congruence-on-cst

(defthm
    cst-text-block-character-conc2-rep-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-text-block-character-conc2-rep abnf::cst)
                  (cst-text-block-character-conc2-rep cst-equiv)))
  :rule-classes :congruence)

Function: cst-text-block-character-conc3-rep

(defun cst-text-block-character-conc3-rep (abnf::cst)
 (declare (xargs :guard (abnf::treep abnf::cst)))
 (declare
  (xargs
       :guard (and (cst-matchp abnf::cst "text-block-character")
                   (equal (cst-text-block-character-conc? abnf::cst)
                          3))))
 (abnf::tree-list-fix
      (nth 0
           (cst-text-block-character-conc3 abnf::cst))))

Theorem: tree-listp-of-cst-text-block-character-conc3-rep

(defthm tree-listp-of-cst-text-block-character-conc3-rep
  (b* ((abnf::csts (cst-text-block-character-conc3-rep abnf::cst)))
    (abnf::tree-listp abnf::csts))
  :rule-classes :rewrite)

Theorem: cst-text-block-character-conc3-rep-match

(defthm cst-text-block-character-conc3-rep-match
 (implies
   (and (cst-matchp abnf::cst "text-block-character")
        (equal (cst-text-block-character-conc? abnf::cst)
               3))
   (b* ((abnf::csts (cst-text-block-character-conc3-rep abnf::cst)))
     (cst-list-rep-matchp abnf::csts "line-terminator")))
 :rule-classes :rewrite)

Theorem: cst-text-block-character-conc3-rep-of-tree-fix-cst

(defthm cst-text-block-character-conc3-rep-of-tree-fix-cst
 (equal
     (cst-text-block-character-conc3-rep (abnf::tree-fix abnf::cst))
     (cst-text-block-character-conc3-rep abnf::cst)))

Theorem: cst-text-block-character-conc3-rep-tree-equiv-congruence-on-cst

(defthm
    cst-text-block-character-conc3-rep-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-text-block-character-conc3-rep abnf::cst)
                  (cst-text-block-character-conc3-rep cst-equiv)))
  :rule-classes :congruence)

Function: cst-null-literal-conc-rep

(defun cst-null-literal-conc-rep (abnf::cst)
  (declare (xargs :guard (abnf::treep abnf::cst)))
  (declare (xargs :guard (cst-matchp abnf::cst "null-literal")))
  (abnf::tree-list-fix (nth 0 (cst-null-literal-conc abnf::cst))))

Theorem: tree-listp-of-cst-null-literal-conc-rep

(defthm tree-listp-of-cst-null-literal-conc-rep
  (b* ((abnf::csts (cst-null-literal-conc-rep abnf::cst)))
    (abnf::tree-listp abnf::csts))
  :rule-classes :rewrite)

Theorem: cst-null-literal-conc-rep-match

(defthm cst-null-literal-conc-rep-match
  (implies (cst-matchp abnf::cst "null-literal")
           (b* ((abnf::csts (cst-null-literal-conc-rep abnf::cst)))
             (cst-list-rep-matchp abnf::csts "%s\"null\"")))
  :rule-classes :rewrite)

Theorem: cst-null-literal-conc-rep-of-tree-fix-cst

(defthm cst-null-literal-conc-rep-of-tree-fix-cst
  (equal (cst-null-literal-conc-rep (abnf::tree-fix abnf::cst))
         (cst-null-literal-conc-rep abnf::cst)))

Theorem: cst-null-literal-conc-rep-tree-equiv-congruence-on-cst

(defthm cst-null-literal-conc-rep-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-null-literal-conc-rep abnf::cst)
                  (cst-null-literal-conc-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))))
 (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))))
 (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 "reference-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-numeric-type-conc1-rep

(defun cst-numeric-type-conc1-rep (abnf::cst)
  (declare (xargs :guard (abnf::treep abnf::cst)))
  (declare
       (xargs :guard (and (cst-matchp abnf::cst "numeric-type")
                          (equal (cst-numeric-type-conc? abnf::cst)
                                 1))))
  (abnf::tree-list-fix (nth 0 (cst-numeric-type-conc1 abnf::cst))))

Theorem: tree-listp-of-cst-numeric-type-conc1-rep

(defthm tree-listp-of-cst-numeric-type-conc1-rep
  (b* ((abnf::csts (cst-numeric-type-conc1-rep abnf::cst)))
    (abnf::tree-listp abnf::csts))
  :rule-classes :rewrite)

Theorem: cst-numeric-type-conc1-rep-match

(defthm cst-numeric-type-conc1-rep-match
  (implies (and (cst-matchp abnf::cst "numeric-type")
                (equal (cst-numeric-type-conc? abnf::cst)
                       1))
           (b* ((abnf::csts (cst-numeric-type-conc1-rep abnf::cst)))
             (cst-list-rep-matchp abnf::csts "integral-type")))
  :rule-classes :rewrite)

Theorem: cst-numeric-type-conc1-rep-of-tree-fix-cst

(defthm cst-numeric-type-conc1-rep-of-tree-fix-cst
  (equal (cst-numeric-type-conc1-rep (abnf::tree-fix abnf::cst))
         (cst-numeric-type-conc1-rep abnf::cst)))

Theorem: cst-numeric-type-conc1-rep-tree-equiv-congruence-on-cst

(defthm cst-numeric-type-conc1-rep-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-numeric-type-conc1-rep abnf::cst)
                  (cst-numeric-type-conc1-rep cst-equiv)))
  :rule-classes :congruence)

Function: cst-numeric-type-conc2-rep

(defun cst-numeric-type-conc2-rep (abnf::cst)
  (declare (xargs :guard (abnf::treep abnf::cst)))
  (declare
       (xargs :guard (and (cst-matchp abnf::cst "numeric-type")
                          (equal (cst-numeric-type-conc? abnf::cst)
                                 2))))
  (abnf::tree-list-fix (nth 0 (cst-numeric-type-conc2 abnf::cst))))

Theorem: tree-listp-of-cst-numeric-type-conc2-rep

(defthm tree-listp-of-cst-numeric-type-conc2-rep
  (b* ((abnf::csts (cst-numeric-type-conc2-rep abnf::cst)))
    (abnf::tree-listp abnf::csts))
  :rule-classes :rewrite)

Theorem: cst-numeric-type-conc2-rep-match

(defthm cst-numeric-type-conc2-rep-match
 (implies (and (cst-matchp abnf::cst "numeric-type")
               (equal (cst-numeric-type-conc? abnf::cst)
                      2))
          (b* ((abnf::csts (cst-numeric-type-conc2-rep abnf::cst)))
            (cst-list-rep-matchp abnf::csts "floating-point-type")))
 :rule-classes :rewrite)

Theorem: cst-numeric-type-conc2-rep-of-tree-fix-cst

(defthm cst-numeric-type-conc2-rep-of-tree-fix-cst
  (equal (cst-numeric-type-conc2-rep (abnf::tree-fix abnf::cst))
         (cst-numeric-type-conc2-rep abnf::cst)))

Theorem: cst-numeric-type-conc2-rep-tree-equiv-congruence-on-cst

(defthm cst-numeric-type-conc2-rep-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-numeric-type-conc2-rep abnf::cst)
                  (cst-numeric-type-conc2-rep cst-equiv)))
  :rule-classes :congruence)

Function: cst-reference-type-conc1-rep

(defun cst-reference-type-conc1-rep (abnf::cst)
 (declare (xargs :guard (abnf::treep abnf::cst)))
 (declare
      (xargs :guard (and (cst-matchp abnf::cst "reference-type")
                         (equal (cst-reference-type-conc? abnf::cst)
                                1))))
 (abnf::tree-list-fix (nth 0
                           (cst-reference-type-conc1 abnf::cst))))

Theorem: tree-listp-of-cst-reference-type-conc1-rep

(defthm tree-listp-of-cst-reference-type-conc1-rep
  (b* ((abnf::csts (cst-reference-type-conc1-rep abnf::cst)))
    (abnf::tree-listp abnf::csts))
  :rule-classes :rewrite)

Theorem: cst-reference-type-conc1-rep-match

(defthm cst-reference-type-conc1-rep-match
 (implies
      (and (cst-matchp abnf::cst "reference-type")
           (equal (cst-reference-type-conc? abnf::cst)
                  1))
      (b* ((abnf::csts (cst-reference-type-conc1-rep abnf::cst)))
        (cst-list-rep-matchp abnf::csts "class-or-interface-type")))
 :rule-classes :rewrite)

Theorem: cst-reference-type-conc1-rep-of-tree-fix-cst

(defthm cst-reference-type-conc1-rep-of-tree-fix-cst
  (equal (cst-reference-type-conc1-rep (abnf::tree-fix abnf::cst))
         (cst-reference-type-conc1-rep abnf::cst)))

Theorem: cst-reference-type-conc1-rep-tree-equiv-congruence-on-cst

(defthm cst-reference-type-conc1-rep-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-reference-type-conc1-rep abnf::cst)
                  (cst-reference-type-conc1-rep cst-equiv)))
  :rule-classes :congruence)

Function: cst-reference-type-conc2-rep

(defun cst-reference-type-conc2-rep (abnf::cst)
 (declare (xargs :guard (abnf::treep abnf::cst)))
 (declare
      (xargs :guard (and (cst-matchp abnf::cst "reference-type")
                         (equal (cst-reference-type-conc? abnf::cst)
                                2))))
 (abnf::tree-list-fix (nth 0
                           (cst-reference-type-conc2 abnf::cst))))

Theorem: tree-listp-of-cst-reference-type-conc2-rep

(defthm tree-listp-of-cst-reference-type-conc2-rep
  (b* ((abnf::csts (cst-reference-type-conc2-rep abnf::cst)))
    (abnf::tree-listp abnf::csts))
  :rule-classes :rewrite)

Theorem: cst-reference-type-conc2-rep-match

(defthm cst-reference-type-conc2-rep-match
  (implies
       (and (cst-matchp abnf::cst "reference-type")
            (equal (cst-reference-type-conc? abnf::cst)
                   2))
       (b* ((abnf::csts (cst-reference-type-conc2-rep abnf::cst)))
         (cst-list-rep-matchp abnf::csts "type-variable")))
  :rule-classes :rewrite)

Theorem: cst-reference-type-conc2-rep-of-tree-fix-cst

(defthm cst-reference-type-conc2-rep-of-tree-fix-cst
  (equal (cst-reference-type-conc2-rep (abnf::tree-fix abnf::cst))
         (cst-reference-type-conc2-rep abnf::cst)))

Theorem: cst-reference-type-conc2-rep-tree-equiv-congruence-on-cst

(defthm cst-reference-type-conc2-rep-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-reference-type-conc2-rep abnf::cst)
                  (cst-reference-type-conc2-rep cst-equiv)))
  :rule-classes :congruence)

Function: cst-reference-type-conc3-rep

(defun cst-reference-type-conc3-rep (abnf::cst)
 (declare (xargs :guard (abnf::treep abnf::cst)))
 (declare
      (xargs :guard (and (cst-matchp abnf::cst "reference-type")
                         (equal (cst-reference-type-conc? abnf::cst)
                                3))))
 (abnf::tree-list-fix (nth 0
                           (cst-reference-type-conc3 abnf::cst))))

Theorem: tree-listp-of-cst-reference-type-conc3-rep

(defthm tree-listp-of-cst-reference-type-conc3-rep
  (b* ((abnf::csts (cst-reference-type-conc3-rep abnf::cst)))
    (abnf::tree-listp abnf::csts))
  :rule-classes :rewrite)

Theorem: cst-reference-type-conc3-rep-match

(defthm cst-reference-type-conc3-rep-match
  (implies
       (and (cst-matchp abnf::cst "reference-type")
            (equal (cst-reference-type-conc? abnf::cst)
                   3))
       (b* ((abnf::csts (cst-reference-type-conc3-rep abnf::cst)))
         (cst-list-rep-matchp abnf::csts "array-type")))
  :rule-classes :rewrite)

Theorem: cst-reference-type-conc3-rep-of-tree-fix-cst

(defthm cst-reference-type-conc3-rep-of-tree-fix-cst
  (equal (cst-reference-type-conc3-rep (abnf::tree-fix abnf::cst))
         (cst-reference-type-conc3-rep abnf::cst)))

Theorem: cst-reference-type-conc3-rep-tree-equiv-congruence-on-cst

(defthm cst-reference-type-conc3-rep-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-reference-type-conc3-rep abnf::cst)
                  (cst-reference-type-conc3-rep cst-equiv)))
  :rule-classes :congruence)

Function: cst-class-or-interface-type-conc1-rep

(defun cst-class-or-interface-type-conc1-rep (abnf::cst)
 (declare (xargs :guard (abnf::treep abnf::cst)))
 (declare
  (xargs
    :guard (and (cst-matchp abnf::cst "class-or-interface-type")
                (equal (cst-class-or-interface-type-conc? abnf::cst)
                       1))))
 (abnf::tree-list-fix
      (nth 0
           (cst-class-or-interface-type-conc1 abnf::cst))))

Theorem: tree-listp-of-cst-class-or-interface-type-conc1-rep

(defthm tree-listp-of-cst-class-or-interface-type-conc1-rep
  (b*
    ((abnf::csts (cst-class-or-interface-type-conc1-rep abnf::cst)))
    (abnf::tree-listp abnf::csts))
  :rule-classes :rewrite)

Theorem: cst-class-or-interface-type-conc1-rep-match

(defthm cst-class-or-interface-type-conc1-rep-match
 (implies
   (and (cst-matchp abnf::cst "class-or-interface-type")
        (equal (cst-class-or-interface-type-conc? abnf::cst)
               1))
   (b*
    ((abnf::csts (cst-class-or-interface-type-conc1-rep abnf::cst)))
    (cst-list-rep-matchp abnf::csts "class-type")))
 :rule-classes :rewrite)

Theorem: cst-class-or-interface-type-conc1-rep-of-tree-fix-cst

(defthm cst-class-or-interface-type-conc1-rep-of-tree-fix-cst
 (equal
  (cst-class-or-interface-type-conc1-rep (abnf::tree-fix abnf::cst))
  (cst-class-or-interface-type-conc1-rep abnf::cst)))

Theorem: cst-class-or-interface-type-conc1-rep-tree-equiv-congruence-on-cst

(defthm
 cst-class-or-interface-type-conc1-rep-tree-equiv-congruence-on-cst
 (implies (abnf::tree-equiv abnf::cst cst-equiv)
          (equal (cst-class-or-interface-type-conc1-rep abnf::cst)
                 (cst-class-or-interface-type-conc1-rep cst-equiv)))
 :rule-classes :congruence)

Function: cst-class-or-interface-type-conc2-rep

(defun cst-class-or-interface-type-conc2-rep (abnf::cst)
 (declare (xargs :guard (abnf::treep abnf::cst)))
 (declare
  (xargs
    :guard (and (cst-matchp abnf::cst "class-or-interface-type")
                (equal (cst-class-or-interface-type-conc? abnf::cst)
                       2))))
 (abnf::tree-list-fix
      (nth 0
           (cst-class-or-interface-type-conc2 abnf::cst))))

Theorem: tree-listp-of-cst-class-or-interface-type-conc2-rep

(defthm tree-listp-of-cst-class-or-interface-type-conc2-rep
  (b*
    ((abnf::csts (cst-class-or-interface-type-conc2-rep abnf::cst)))
    (abnf::tree-listp abnf::csts))
  :rule-classes :rewrite)

Theorem: cst-class-or-interface-type-conc2-rep-match

(defthm cst-class-or-interface-type-conc2-rep-match
 (implies
   (and (cst-matchp abnf::cst "class-or-interface-type")
        (equal (cst-class-or-interface-type-conc? abnf::cst)
               2))
   (b*
    ((abnf::csts (cst-class-or-interface-type-conc2-rep abnf::cst)))
    (cst-list-rep-matchp abnf::csts "interface-type")))
 :rule-classes :rewrite)

Theorem: cst-class-or-interface-type-conc2-rep-of-tree-fix-cst

(defthm cst-class-or-interface-type-conc2-rep-of-tree-fix-cst
 (equal
  (cst-class-or-interface-type-conc2-rep (abnf::tree-fix abnf::cst))
  (cst-class-or-interface-type-conc2-rep abnf::cst)))

Theorem: cst-class-or-interface-type-conc2-rep-tree-equiv-congruence-on-cst

(defthm
 cst-class-or-interface-type-conc2-rep-tree-equiv-congruence-on-cst
 (implies (abnf::tree-equiv abnf::cst cst-equiv)
          (equal (cst-class-or-interface-type-conc2-rep abnf::cst)
                 (cst-class-or-interface-type-conc2-rep cst-equiv)))
 :rule-classes :congruence)

Function: cst-interface-type-conc-rep

(defun cst-interface-type-conc-rep (abnf::cst)
  (declare (xargs :guard (abnf::treep abnf::cst)))
  (declare (xargs :guard (cst-matchp abnf::cst "interface-type")))
  (abnf::tree-list-fix (nth 0 (cst-interface-type-conc abnf::cst))))

Theorem: tree-listp-of-cst-interface-type-conc-rep

(defthm tree-listp-of-cst-interface-type-conc-rep
  (b* ((abnf::csts (cst-interface-type-conc-rep abnf::cst)))
    (abnf::tree-listp abnf::csts))
  :rule-classes :rewrite)

Theorem: cst-interface-type-conc-rep-match

(defthm cst-interface-type-conc-rep-match
 (implies (cst-matchp abnf::cst "interface-type")
          (b* ((abnf::csts (cst-interface-type-conc-rep abnf::cst)))
            (cst-list-rep-matchp abnf::csts "class-type")))
 :rule-classes :rewrite)

Theorem: cst-interface-type-conc-rep-of-tree-fix-cst

(defthm cst-interface-type-conc-rep-of-tree-fix-cst
  (equal (cst-interface-type-conc-rep (abnf::tree-fix abnf::cst))
         (cst-interface-type-conc-rep abnf::cst)))

Theorem: cst-interface-type-conc-rep-tree-equiv-congruence-on-cst

(defthm cst-interface-type-conc-rep-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-interface-type-conc-rep abnf::cst)
                  (cst-interface-type-conc-rep cst-equiv)))
  :rule-classes :congruence)

Function: cst-type-parameter-modifier-conc-rep

(defun cst-type-parameter-modifier-conc-rep (abnf::cst)
 (declare (xargs :guard (abnf::treep abnf::cst)))
 (declare
    (xargs :guard (cst-matchp abnf::cst "type-parameter-modifier")))
 (abnf::tree-list-fix
      (nth 0
           (cst-type-parameter-modifier-conc abnf::cst))))

Theorem: tree-listp-of-cst-type-parameter-modifier-conc-rep

(defthm tree-listp-of-cst-type-parameter-modifier-conc-rep
 (b* ((abnf::csts (cst-type-parameter-modifier-conc-rep abnf::cst)))
   (abnf::tree-listp abnf::csts))
 :rule-classes :rewrite)

Theorem: cst-type-parameter-modifier-conc-rep-match

(defthm cst-type-parameter-modifier-conc-rep-match
 (implies
   (cst-matchp abnf::cst "type-parameter-modifier")
   (b*
     ((abnf::csts (cst-type-parameter-modifier-conc-rep abnf::cst)))
     (cst-list-rep-matchp abnf::csts "annotation")))
 :rule-classes :rewrite)

Theorem: cst-type-parameter-modifier-conc-rep-of-tree-fix-cst

(defthm cst-type-parameter-modifier-conc-rep-of-tree-fix-cst
 (equal
   (cst-type-parameter-modifier-conc-rep (abnf::tree-fix abnf::cst))
   (cst-type-parameter-modifier-conc-rep abnf::cst)))

Theorem: cst-type-parameter-modifier-conc-rep-tree-equiv-congruence-on-cst

(defthm
  cst-type-parameter-modifier-conc-rep-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-type-parameter-modifier-conc-rep abnf::cst)
                  (cst-type-parameter-modifier-conc-rep cst-equiv)))
  :rule-classes :congruence)

Function: cst-type-argument-conc1-rep

(defun cst-type-argument-conc1-rep (abnf::cst)
  (declare (xargs :guard (abnf::treep abnf::cst)))
  (declare
       (xargs :guard (and (cst-matchp abnf::cst "type-argument")
                          (equal (cst-type-argument-conc? abnf::cst)
                                 1))))
  (abnf::tree-list-fix (nth 0 (cst-type-argument-conc1 abnf::cst))))

Theorem: tree-listp-of-cst-type-argument-conc1-rep

(defthm tree-listp-of-cst-type-argument-conc1-rep
  (b* ((abnf::csts (cst-type-argument-conc1-rep abnf::cst)))
    (abnf::tree-listp abnf::csts))
  :rule-classes :rewrite)

Theorem: cst-type-argument-conc1-rep-match

(defthm cst-type-argument-conc1-rep-match
 (implies (and (cst-matchp abnf::cst "type-argument")
               (equal (cst-type-argument-conc? abnf::cst)
                      1))
          (b* ((abnf::csts (cst-type-argument-conc1-rep abnf::cst)))
            (cst-list-rep-matchp abnf::csts "reference-type")))
 :rule-classes :rewrite)

Theorem: cst-type-argument-conc1-rep-of-tree-fix-cst

(defthm cst-type-argument-conc1-rep-of-tree-fix-cst
  (equal (cst-type-argument-conc1-rep (abnf::tree-fix abnf::cst))
         (cst-type-argument-conc1-rep abnf::cst)))

Theorem: cst-type-argument-conc1-rep-tree-equiv-congruence-on-cst

(defthm cst-type-argument-conc1-rep-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-type-argument-conc1-rep abnf::cst)
                  (cst-type-argument-conc1-rep cst-equiv)))
  :rule-classes :congruence)

Function: cst-type-argument-conc2-rep

(defun cst-type-argument-conc2-rep (abnf::cst)
  (declare (xargs :guard (abnf::treep abnf::cst)))
  (declare
       (xargs :guard (and (cst-matchp abnf::cst "type-argument")
                          (equal (cst-type-argument-conc? abnf::cst)
                                 2))))
  (abnf::tree-list-fix (nth 0 (cst-type-argument-conc2 abnf::cst))))

Theorem: tree-listp-of-cst-type-argument-conc2-rep

(defthm tree-listp-of-cst-type-argument-conc2-rep
  (b* ((abnf::csts (cst-type-argument-conc2-rep abnf::cst)))
    (abnf::tree-listp abnf::csts))
  :rule-classes :rewrite)

Theorem: cst-type-argument-conc2-rep-match

(defthm cst-type-argument-conc2-rep-match
 (implies (and (cst-matchp abnf::cst "type-argument")
               (equal (cst-type-argument-conc? abnf::cst)
                      2))
          (b* ((abnf::csts (cst-type-argument-conc2-rep abnf::cst)))
            (cst-list-rep-matchp abnf::csts "wildcard")))
 :rule-classes :rewrite)

Theorem: cst-type-argument-conc2-rep-of-tree-fix-cst

(defthm cst-type-argument-conc2-rep-of-tree-fix-cst
  (equal (cst-type-argument-conc2-rep (abnf::tree-fix abnf::cst))
         (cst-type-argument-conc2-rep abnf::cst)))

Theorem: cst-type-argument-conc2-rep-tree-equiv-congruence-on-cst

(defthm cst-type-argument-conc2-rep-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-type-argument-conc2-rep abnf::cst)
                  (cst-type-argument-conc2-rep cst-equiv)))
  :rule-classes :congruence)

Function: cst-method-name-conc-rep

(defun cst-method-name-conc-rep (abnf::cst)
  (declare (xargs :guard (abnf::treep abnf::cst)))
  (declare (xargs :guard (cst-matchp abnf::cst "method-name")))
  (abnf::tree-list-fix (nth 0 (cst-method-name-conc abnf::cst))))

Theorem: tree-listp-of-cst-method-name-conc-rep

(defthm tree-listp-of-cst-method-name-conc-rep
  (b* ((abnf::csts (cst-method-name-conc-rep abnf::cst)))
    (abnf::tree-listp abnf::csts))
  :rule-classes :rewrite)

Theorem: cst-method-name-conc-rep-match

(defthm cst-method-name-conc-rep-match
  (implies (cst-matchp abnf::cst "method-name")
           (b* ((abnf::csts (cst-method-name-conc-rep abnf::cst)))
             (cst-list-rep-matchp abnf::csts
                                  "unqualified-method-identifier")))
  :rule-classes :rewrite)

Theorem: cst-method-name-conc-rep-of-tree-fix-cst

(defthm cst-method-name-conc-rep-of-tree-fix-cst
  (equal (cst-method-name-conc-rep (abnf::tree-fix abnf::cst))
         (cst-method-name-conc-rep abnf::cst)))

Theorem: cst-method-name-conc-rep-tree-equiv-congruence-on-cst

(defthm cst-method-name-conc-rep-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-method-name-conc-rep abnf::cst)
                  (cst-method-name-conc-rep cst-equiv)))
  :rule-classes :congruence)

Function: cst-compilation-unit-conc1-rep

(defun cst-compilation-unit-conc1-rep (abnf::cst)
 (declare (xargs :guard (abnf::treep abnf::cst)))
 (declare
    (xargs :guard (and (cst-matchp abnf::cst "compilation-unit")
                       (equal (cst-compilation-unit-conc? abnf::cst)
                              1))))
 (abnf::tree-list-fix (nth 0
                           (cst-compilation-unit-conc1 abnf::cst))))

Theorem: tree-listp-of-cst-compilation-unit-conc1-rep

(defthm tree-listp-of-cst-compilation-unit-conc1-rep
  (b* ((abnf::csts (cst-compilation-unit-conc1-rep abnf::cst)))
    (abnf::tree-listp abnf::csts))
  :rule-classes :rewrite)

Theorem: cst-compilation-unit-conc1-rep-match

(defthm cst-compilation-unit-conc1-rep-match
  (implies
       (and (cst-matchp abnf::cst "compilation-unit")
            (equal (cst-compilation-unit-conc? abnf::cst)
                   1))
       (b* ((abnf::csts (cst-compilation-unit-conc1-rep abnf::cst)))
         (cst-list-rep-matchp abnf::csts
                              "ordinary-compilation-unit")))
  :rule-classes :rewrite)

Theorem: cst-compilation-unit-conc1-rep-of-tree-fix-cst

(defthm cst-compilation-unit-conc1-rep-of-tree-fix-cst
  (equal (cst-compilation-unit-conc1-rep (abnf::tree-fix abnf::cst))
         (cst-compilation-unit-conc1-rep abnf::cst)))

Theorem: cst-compilation-unit-conc1-rep-tree-equiv-congruence-on-cst

(defthm cst-compilation-unit-conc1-rep-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-compilation-unit-conc1-rep abnf::cst)
                  (cst-compilation-unit-conc1-rep cst-equiv)))
  :rule-classes :congruence)

Function: cst-compilation-unit-conc2-rep

(defun cst-compilation-unit-conc2-rep (abnf::cst)
 (declare (xargs :guard (abnf::treep abnf::cst)))
 (declare
    (xargs :guard (and (cst-matchp abnf::cst "compilation-unit")
                       (equal (cst-compilation-unit-conc? abnf::cst)
                              2))))
 (abnf::tree-list-fix (nth 0
                           (cst-compilation-unit-conc2 abnf::cst))))

Theorem: tree-listp-of-cst-compilation-unit-conc2-rep

(defthm tree-listp-of-cst-compilation-unit-conc2-rep
  (b* ((abnf::csts (cst-compilation-unit-conc2-rep abnf::cst)))
    (abnf::tree-listp abnf::csts))
  :rule-classes :rewrite)

Theorem: cst-compilation-unit-conc2-rep-match

(defthm cst-compilation-unit-conc2-rep-match
 (implies
     (and (cst-matchp abnf::cst "compilation-unit")
          (equal (cst-compilation-unit-conc? abnf::cst)
                 2))
     (b* ((abnf::csts (cst-compilation-unit-conc2-rep abnf::cst)))
       (cst-list-rep-matchp abnf::csts "compact-compilation-unit")))
 :rule-classes :rewrite)

Theorem: cst-compilation-unit-conc2-rep-of-tree-fix-cst

(defthm cst-compilation-unit-conc2-rep-of-tree-fix-cst
  (equal (cst-compilation-unit-conc2-rep (abnf::tree-fix abnf::cst))
         (cst-compilation-unit-conc2-rep abnf::cst)))

Theorem: cst-compilation-unit-conc2-rep-tree-equiv-congruence-on-cst

(defthm cst-compilation-unit-conc2-rep-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-compilation-unit-conc2-rep abnf::cst)
                  (cst-compilation-unit-conc2-rep cst-equiv)))
  :rule-classes :congruence)

Function: cst-compilation-unit-conc3-rep

(defun cst-compilation-unit-conc3-rep (abnf::cst)
 (declare (xargs :guard (abnf::treep abnf::cst)))
 (declare
    (xargs :guard (and (cst-matchp abnf::cst "compilation-unit")
                       (equal (cst-compilation-unit-conc? abnf::cst)
                              3))))
 (abnf::tree-list-fix (nth 0
                           (cst-compilation-unit-conc3 abnf::cst))))

Theorem: tree-listp-of-cst-compilation-unit-conc3-rep

(defthm tree-listp-of-cst-compilation-unit-conc3-rep
  (b* ((abnf::csts (cst-compilation-unit-conc3-rep abnf::cst)))
    (abnf::tree-listp abnf::csts))
  :rule-classes :rewrite)

Theorem: cst-compilation-unit-conc3-rep-match

(defthm cst-compilation-unit-conc3-rep-match
 (implies
     (and (cst-matchp abnf::cst "compilation-unit")
          (equal (cst-compilation-unit-conc? abnf::cst)
                 3))
     (b* ((abnf::csts (cst-compilation-unit-conc3-rep abnf::cst)))
       (cst-list-rep-matchp abnf::csts "modular-compilation-unit")))
 :rule-classes :rewrite)

Theorem: cst-compilation-unit-conc3-rep-of-tree-fix-cst

(defthm cst-compilation-unit-conc3-rep-of-tree-fix-cst
  (equal (cst-compilation-unit-conc3-rep (abnf::tree-fix abnf::cst))
         (cst-compilation-unit-conc3-rep abnf::cst)))

Theorem: cst-compilation-unit-conc3-rep-tree-equiv-congruence-on-cst

(defthm cst-compilation-unit-conc3-rep-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-compilation-unit-conc3-rep abnf::cst)
                  (cst-compilation-unit-conc3-rep cst-equiv)))
  :rule-classes :congruence)

Function: cst-package-modifier-conc-rep

(defun cst-package-modifier-conc-rep (abnf::cst)
  (declare (xargs :guard (abnf::treep abnf::cst)))
  (declare (xargs :guard (cst-matchp abnf::cst "package-modifier")))
  (abnf::tree-list-fix (nth 0
                            (cst-package-modifier-conc abnf::cst))))

Theorem: tree-listp-of-cst-package-modifier-conc-rep

(defthm tree-listp-of-cst-package-modifier-conc-rep
  (b* ((abnf::csts (cst-package-modifier-conc-rep abnf::cst)))
    (abnf::tree-listp abnf::csts))
  :rule-classes :rewrite)

Theorem: cst-package-modifier-conc-rep-match

(defthm cst-package-modifier-conc-rep-match
  (implies
       (cst-matchp abnf::cst "package-modifier")
       (b* ((abnf::csts (cst-package-modifier-conc-rep abnf::cst)))
         (cst-list-rep-matchp abnf::csts "annotation")))
  :rule-classes :rewrite)

Theorem: cst-package-modifier-conc-rep-of-tree-fix-cst

(defthm cst-package-modifier-conc-rep-of-tree-fix-cst
  (equal (cst-package-modifier-conc-rep (abnf::tree-fix abnf::cst))
         (cst-package-modifier-conc-rep abnf::cst)))

Theorem: cst-package-modifier-conc-rep-tree-equiv-congruence-on-cst

(defthm cst-package-modifier-conc-rep-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-package-modifier-conc-rep abnf::cst)
                  (cst-package-modifier-conc-rep cst-equiv)))
  :rule-classes :congruence)

Function: cst-import-declaration-conc1-rep

(defun cst-import-declaration-conc1-rep (abnf::cst)
 (declare (xargs :guard (abnf::treep abnf::cst)))
 (declare
  (xargs :guard (and (cst-matchp abnf::cst "import-declaration")
                     (equal (cst-import-declaration-conc? abnf::cst)
                            1))))
 (abnf::tree-list-fix
      (nth 0
           (cst-import-declaration-conc1 abnf::cst))))

Theorem: tree-listp-of-cst-import-declaration-conc1-rep

(defthm tree-listp-of-cst-import-declaration-conc1-rep
  (b* ((abnf::csts (cst-import-declaration-conc1-rep abnf::cst)))
    (abnf::tree-listp abnf::csts))
  :rule-classes :rewrite)

Theorem: cst-import-declaration-conc1-rep-match

(defthm cst-import-declaration-conc1-rep-match
 (implies
     (and (cst-matchp abnf::cst "import-declaration")
          (equal (cst-import-declaration-conc? abnf::cst)
                 1))
     (b* ((abnf::csts (cst-import-declaration-conc1-rep abnf::cst)))
       (cst-list-rep-matchp abnf::csts
                            "single-type-import-declaration")))
 :rule-classes :rewrite)

Theorem: cst-import-declaration-conc1-rep-of-tree-fix-cst

(defthm cst-import-declaration-conc1-rep-of-tree-fix-cst
  (equal
       (cst-import-declaration-conc1-rep (abnf::tree-fix abnf::cst))
       (cst-import-declaration-conc1-rep abnf::cst)))

Theorem: cst-import-declaration-conc1-rep-tree-equiv-congruence-on-cst

(defthm
      cst-import-declaration-conc1-rep-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-import-declaration-conc1-rep abnf::cst)
                  (cst-import-declaration-conc1-rep cst-equiv)))
  :rule-classes :congruence)

Function: cst-import-declaration-conc2-rep

(defun cst-import-declaration-conc2-rep (abnf::cst)
 (declare (xargs :guard (abnf::treep abnf::cst)))
 (declare
  (xargs :guard (and (cst-matchp abnf::cst "import-declaration")
                     (equal (cst-import-declaration-conc? abnf::cst)
                            2))))
 (abnf::tree-list-fix
      (nth 0
           (cst-import-declaration-conc2 abnf::cst))))

Theorem: tree-listp-of-cst-import-declaration-conc2-rep

(defthm tree-listp-of-cst-import-declaration-conc2-rep
  (b* ((abnf::csts (cst-import-declaration-conc2-rep abnf::cst)))
    (abnf::tree-listp abnf::csts))
  :rule-classes :rewrite)

Theorem: cst-import-declaration-conc2-rep-match

(defthm cst-import-declaration-conc2-rep-match
 (implies
     (and (cst-matchp abnf::cst "import-declaration")
          (equal (cst-import-declaration-conc? abnf::cst)
                 2))
     (b* ((abnf::csts (cst-import-declaration-conc2-rep abnf::cst)))
       (cst-list-rep-matchp abnf::csts
                            "type-import-on-demand-declaration")))
 :rule-classes :rewrite)

Theorem: cst-import-declaration-conc2-rep-of-tree-fix-cst

(defthm cst-import-declaration-conc2-rep-of-tree-fix-cst
  (equal
       (cst-import-declaration-conc2-rep (abnf::tree-fix abnf::cst))
       (cst-import-declaration-conc2-rep abnf::cst)))

Theorem: cst-import-declaration-conc2-rep-tree-equiv-congruence-on-cst

(defthm
      cst-import-declaration-conc2-rep-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-import-declaration-conc2-rep abnf::cst)
                  (cst-import-declaration-conc2-rep cst-equiv)))
  :rule-classes :congruence)

Function: cst-import-declaration-conc3-rep

(defun cst-import-declaration-conc3-rep (abnf::cst)
 (declare (xargs :guard (abnf::treep abnf::cst)))
 (declare
  (xargs :guard (and (cst-matchp abnf::cst "import-declaration")
                     (equal (cst-import-declaration-conc? abnf::cst)
                            3))))
 (abnf::tree-list-fix
      (nth 0
           (cst-import-declaration-conc3 abnf::cst))))

Theorem: tree-listp-of-cst-import-declaration-conc3-rep

(defthm tree-listp-of-cst-import-declaration-conc3-rep
  (b* ((abnf::csts (cst-import-declaration-conc3-rep abnf::cst)))
    (abnf::tree-listp abnf::csts))
  :rule-classes :rewrite)

Theorem: cst-import-declaration-conc3-rep-match

(defthm cst-import-declaration-conc3-rep-match
 (implies
     (and (cst-matchp abnf::cst "import-declaration")
          (equal (cst-import-declaration-conc? abnf::cst)
                 3))
     (b* ((abnf::csts (cst-import-declaration-conc3-rep abnf::cst)))
       (cst-list-rep-matchp abnf::csts
                            "single-static-import-declaration")))
 :rule-classes :rewrite)

Theorem: cst-import-declaration-conc3-rep-of-tree-fix-cst

(defthm cst-import-declaration-conc3-rep-of-tree-fix-cst
  (equal
       (cst-import-declaration-conc3-rep (abnf::tree-fix abnf::cst))
       (cst-import-declaration-conc3-rep abnf::cst)))

Theorem: cst-import-declaration-conc3-rep-tree-equiv-congruence-on-cst

(defthm
      cst-import-declaration-conc3-rep-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-import-declaration-conc3-rep abnf::cst)
                  (cst-import-declaration-conc3-rep cst-equiv)))
  :rule-classes :congruence)

Function: cst-import-declaration-conc4-rep

(defun cst-import-declaration-conc4-rep (abnf::cst)
 (declare (xargs :guard (abnf::treep abnf::cst)))
 (declare
  (xargs :guard (and (cst-matchp abnf::cst "import-declaration")
                     (equal (cst-import-declaration-conc? abnf::cst)
                            4))))
 (abnf::tree-list-fix
      (nth 0
           (cst-import-declaration-conc4 abnf::cst))))

Theorem: tree-listp-of-cst-import-declaration-conc4-rep

(defthm tree-listp-of-cst-import-declaration-conc4-rep
  (b* ((abnf::csts (cst-import-declaration-conc4-rep abnf::cst)))
    (abnf::tree-listp abnf::csts))
  :rule-classes :rewrite)

Theorem: cst-import-declaration-conc4-rep-match

(defthm cst-import-declaration-conc4-rep-match
 (implies
     (and (cst-matchp abnf::cst "import-declaration")
          (equal (cst-import-declaration-conc? abnf::cst)
                 4))
     (b* ((abnf::csts (cst-import-declaration-conc4-rep abnf::cst)))
       (cst-list-rep-matchp abnf::csts
                            "static-import-on-demand-declaration")))
 :rule-classes :rewrite)

Theorem: cst-import-declaration-conc4-rep-of-tree-fix-cst

(defthm cst-import-declaration-conc4-rep-of-tree-fix-cst
  (equal
       (cst-import-declaration-conc4-rep (abnf::tree-fix abnf::cst))
       (cst-import-declaration-conc4-rep abnf::cst)))

Theorem: cst-import-declaration-conc4-rep-tree-equiv-congruence-on-cst

(defthm
      cst-import-declaration-conc4-rep-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-import-declaration-conc4-rep abnf::cst)
                  (cst-import-declaration-conc4-rep cst-equiv)))
  :rule-classes :congruence)

Function: cst-import-declaration-conc5-rep

(defun cst-import-declaration-conc5-rep (abnf::cst)
 (declare (xargs :guard (abnf::treep abnf::cst)))
 (declare
  (xargs :guard (and (cst-matchp abnf::cst "import-declaration")
                     (equal (cst-import-declaration-conc? abnf::cst)
                            5))))
 (abnf::tree-list-fix
      (nth 0
           (cst-import-declaration-conc5 abnf::cst))))

Theorem: tree-listp-of-cst-import-declaration-conc5-rep

(defthm tree-listp-of-cst-import-declaration-conc5-rep
  (b* ((abnf::csts (cst-import-declaration-conc5-rep abnf::cst)))
    (abnf::tree-listp abnf::csts))
  :rule-classes :rewrite)

Theorem: cst-import-declaration-conc5-rep-match

(defthm cst-import-declaration-conc5-rep-match
 (implies
     (and (cst-matchp abnf::cst "import-declaration")
          (equal (cst-import-declaration-conc? abnf::cst)
                 5))
     (b* ((abnf::csts (cst-import-declaration-conc5-rep abnf::cst)))
       (cst-list-rep-matchp abnf::csts
                            "single-module-import-declaration")))
 :rule-classes :rewrite)

Theorem: cst-import-declaration-conc5-rep-of-tree-fix-cst

(defthm cst-import-declaration-conc5-rep-of-tree-fix-cst
  (equal
       (cst-import-declaration-conc5-rep (abnf::tree-fix abnf::cst))
       (cst-import-declaration-conc5-rep abnf::cst)))

Theorem: cst-import-declaration-conc5-rep-tree-equiv-congruence-on-cst

(defthm
      cst-import-declaration-conc5-rep-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-import-declaration-conc5-rep abnf::cst)
                  (cst-import-declaration-conc5-rep cst-equiv)))
  :rule-classes :congruence)

Function: cst-class-declaration-conc1-rep

(defun cst-class-declaration-conc1-rep (abnf::cst)
 (declare (xargs :guard (abnf::treep abnf::cst)))
 (declare
   (xargs :guard (and (cst-matchp abnf::cst "class-declaration")
                      (equal (cst-class-declaration-conc? abnf::cst)
                             1))))
 (abnf::tree-list-fix
      (nth 0
           (cst-class-declaration-conc1 abnf::cst))))

Theorem: tree-listp-of-cst-class-declaration-conc1-rep

(defthm tree-listp-of-cst-class-declaration-conc1-rep
  (b* ((abnf::csts (cst-class-declaration-conc1-rep abnf::cst)))
    (abnf::tree-listp abnf::csts))
  :rule-classes :rewrite)

Theorem: cst-class-declaration-conc1-rep-match

(defthm cst-class-declaration-conc1-rep-match
 (implies
     (and (cst-matchp abnf::cst "class-declaration")
          (equal (cst-class-declaration-conc? abnf::cst)
                 1))
     (b* ((abnf::csts (cst-class-declaration-conc1-rep abnf::cst)))
       (cst-list-rep-matchp abnf::csts "normal-class-declaration")))
 :rule-classes :rewrite)

Theorem: cst-class-declaration-conc1-rep-of-tree-fix-cst

(defthm cst-class-declaration-conc1-rep-of-tree-fix-cst
 (equal (cst-class-declaration-conc1-rep (abnf::tree-fix abnf::cst))
        (cst-class-declaration-conc1-rep abnf::cst)))

Theorem: cst-class-declaration-conc1-rep-tree-equiv-congruence-on-cst

(defthm cst-class-declaration-conc1-rep-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-class-declaration-conc1-rep abnf::cst)
                  (cst-class-declaration-conc1-rep cst-equiv)))
  :rule-classes :congruence)

Function: cst-class-declaration-conc2-rep

(defun cst-class-declaration-conc2-rep (abnf::cst)
 (declare (xargs :guard (abnf::treep abnf::cst)))
 (declare
   (xargs :guard (and (cst-matchp abnf::cst "class-declaration")
                      (equal (cst-class-declaration-conc? abnf::cst)
                             2))))
 (abnf::tree-list-fix
      (nth 0
           (cst-class-declaration-conc2 abnf::cst))))

Theorem: tree-listp-of-cst-class-declaration-conc2-rep

(defthm tree-listp-of-cst-class-declaration-conc2-rep
  (b* ((abnf::csts (cst-class-declaration-conc2-rep abnf::cst)))
    (abnf::tree-listp abnf::csts))
  :rule-classes :rewrite)

Theorem: cst-class-declaration-conc2-rep-match

(defthm cst-class-declaration-conc2-rep-match
 (implies
      (and (cst-matchp abnf::cst "class-declaration")
           (equal (cst-class-declaration-conc? abnf::cst)
                  2))
      (b* ((abnf::csts (cst-class-declaration-conc2-rep abnf::cst)))
        (cst-list-rep-matchp abnf::csts "enum-declaration")))
 :rule-classes :rewrite)

Theorem: cst-class-declaration-conc2-rep-of-tree-fix-cst

(defthm cst-class-declaration-conc2-rep-of-tree-fix-cst
 (equal (cst-class-declaration-conc2-rep (abnf::tree-fix abnf::cst))
        (cst-class-declaration-conc2-rep abnf::cst)))

Theorem: cst-class-declaration-conc2-rep-tree-equiv-congruence-on-cst

(defthm cst-class-declaration-conc2-rep-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-class-declaration-conc2-rep abnf::cst)
                  (cst-class-declaration-conc2-rep cst-equiv)))
  :rule-classes :congruence)

Function: cst-class-declaration-conc3-rep

(defun cst-class-declaration-conc3-rep (abnf::cst)
 (declare (xargs :guard (abnf::treep abnf::cst)))
 (declare
   (xargs :guard (and (cst-matchp abnf::cst "class-declaration")
                      (equal (cst-class-declaration-conc? abnf::cst)
                             3))))
 (abnf::tree-list-fix
      (nth 0
           (cst-class-declaration-conc3 abnf::cst))))

Theorem: tree-listp-of-cst-class-declaration-conc3-rep

(defthm tree-listp-of-cst-class-declaration-conc3-rep
  (b* ((abnf::csts (cst-class-declaration-conc3-rep abnf::cst)))
    (abnf::tree-listp abnf::csts))
  :rule-classes :rewrite)

Theorem: cst-class-declaration-conc3-rep-match

(defthm cst-class-declaration-conc3-rep-match
 (implies
      (and (cst-matchp abnf::cst "class-declaration")
           (equal (cst-class-declaration-conc? abnf::cst)
                  3))
      (b* ((abnf::csts (cst-class-declaration-conc3-rep abnf::cst)))
        (cst-list-rep-matchp abnf::csts "record-declaration")))
 :rule-classes :rewrite)

Theorem: cst-class-declaration-conc3-rep-of-tree-fix-cst

(defthm cst-class-declaration-conc3-rep-of-tree-fix-cst
 (equal (cst-class-declaration-conc3-rep (abnf::tree-fix abnf::cst))
        (cst-class-declaration-conc3-rep abnf::cst)))

Theorem: cst-class-declaration-conc3-rep-tree-equiv-congruence-on-cst

(defthm cst-class-declaration-conc3-rep-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-class-declaration-conc3-rep abnf::cst)
                  (cst-class-declaration-conc3-rep cst-equiv)))
  :rule-classes :congruence)

Function: cst-class-body-declaration-conc1-rep

(defun cst-class-body-declaration-conc1-rep (abnf::cst)
 (declare (xargs :guard (abnf::treep abnf::cst)))
 (declare
  (xargs
     :guard (and (cst-matchp abnf::cst "class-body-declaration")
                 (equal (cst-class-body-declaration-conc? abnf::cst)
                        1))))
 (abnf::tree-list-fix
      (nth 0
           (cst-class-body-declaration-conc1 abnf::cst))))

Theorem: tree-listp-of-cst-class-body-declaration-conc1-rep

(defthm tree-listp-of-cst-class-body-declaration-conc1-rep
 (b* ((abnf::csts (cst-class-body-declaration-conc1-rep abnf::cst)))
   (abnf::tree-listp abnf::csts))
 :rule-classes :rewrite)

Theorem: cst-class-body-declaration-conc1-rep-match

(defthm cst-class-body-declaration-conc1-rep-match
 (implies
   (and (cst-matchp abnf::cst "class-body-declaration")
        (equal (cst-class-body-declaration-conc? abnf::cst)
               1))
   (b*
     ((abnf::csts (cst-class-body-declaration-conc1-rep abnf::cst)))
     (cst-list-rep-matchp abnf::csts "class-member-declaration")))
 :rule-classes :rewrite)

Theorem: cst-class-body-declaration-conc1-rep-of-tree-fix-cst

(defthm cst-class-body-declaration-conc1-rep-of-tree-fix-cst
 (equal
   (cst-class-body-declaration-conc1-rep (abnf::tree-fix abnf::cst))
   (cst-class-body-declaration-conc1-rep abnf::cst)))

Theorem: cst-class-body-declaration-conc1-rep-tree-equiv-congruence-on-cst

(defthm
  cst-class-body-declaration-conc1-rep-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-class-body-declaration-conc1-rep abnf::cst)
                  (cst-class-body-declaration-conc1-rep cst-equiv)))
  :rule-classes :congruence)

Function: cst-class-body-declaration-conc2-rep

(defun cst-class-body-declaration-conc2-rep (abnf::cst)
 (declare (xargs :guard (abnf::treep abnf::cst)))
 (declare
  (xargs
     :guard (and (cst-matchp abnf::cst "class-body-declaration")
                 (equal (cst-class-body-declaration-conc? abnf::cst)
                        2))))
 (abnf::tree-list-fix
      (nth 0
           (cst-class-body-declaration-conc2 abnf::cst))))

Theorem: tree-listp-of-cst-class-body-declaration-conc2-rep

(defthm tree-listp-of-cst-class-body-declaration-conc2-rep
 (b* ((abnf::csts (cst-class-body-declaration-conc2-rep abnf::cst)))
   (abnf::tree-listp abnf::csts))
 :rule-classes :rewrite)

Theorem: cst-class-body-declaration-conc2-rep-match

(defthm cst-class-body-declaration-conc2-rep-match
 (implies
   (and (cst-matchp abnf::cst "class-body-declaration")
        (equal (cst-class-body-declaration-conc? abnf::cst)
               2))
   (b*
     ((abnf::csts (cst-class-body-declaration-conc2-rep abnf::cst)))
     (cst-list-rep-matchp abnf::csts "instance-initializer")))
 :rule-classes :rewrite)

Theorem: cst-class-body-declaration-conc2-rep-of-tree-fix-cst

(defthm cst-class-body-declaration-conc2-rep-of-tree-fix-cst
 (equal
   (cst-class-body-declaration-conc2-rep (abnf::tree-fix abnf::cst))
   (cst-class-body-declaration-conc2-rep abnf::cst)))

Theorem: cst-class-body-declaration-conc2-rep-tree-equiv-congruence-on-cst

(defthm
  cst-class-body-declaration-conc2-rep-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-class-body-declaration-conc2-rep abnf::cst)
                  (cst-class-body-declaration-conc2-rep cst-equiv)))
  :rule-classes :congruence)

Function: cst-class-body-declaration-conc3-rep

(defun cst-class-body-declaration-conc3-rep (abnf::cst)
 (declare (xargs :guard (abnf::treep abnf::cst)))
 (declare
  (xargs
     :guard (and (cst-matchp abnf::cst "class-body-declaration")
                 (equal (cst-class-body-declaration-conc? abnf::cst)
                        3))))
 (abnf::tree-list-fix
      (nth 0
           (cst-class-body-declaration-conc3 abnf::cst))))

Theorem: tree-listp-of-cst-class-body-declaration-conc3-rep

(defthm tree-listp-of-cst-class-body-declaration-conc3-rep
 (b* ((abnf::csts (cst-class-body-declaration-conc3-rep abnf::cst)))
   (abnf::tree-listp abnf::csts))
 :rule-classes :rewrite)

Theorem: cst-class-body-declaration-conc3-rep-match

(defthm cst-class-body-declaration-conc3-rep-match
 (implies
   (and (cst-matchp abnf::cst "class-body-declaration")
        (equal (cst-class-body-declaration-conc? abnf::cst)
               3))
   (b*
     ((abnf::csts (cst-class-body-declaration-conc3-rep abnf::cst)))
     (cst-list-rep-matchp abnf::csts "static-initializer")))
 :rule-classes :rewrite)

Theorem: cst-class-body-declaration-conc3-rep-of-tree-fix-cst

(defthm cst-class-body-declaration-conc3-rep-of-tree-fix-cst
 (equal
   (cst-class-body-declaration-conc3-rep (abnf::tree-fix abnf::cst))
   (cst-class-body-declaration-conc3-rep abnf::cst)))

Theorem: cst-class-body-declaration-conc3-rep-tree-equiv-congruence-on-cst

(defthm
  cst-class-body-declaration-conc3-rep-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-class-body-declaration-conc3-rep abnf::cst)
                  (cst-class-body-declaration-conc3-rep cst-equiv)))
  :rule-classes :congruence)

Function: cst-class-body-declaration-conc4-rep

(defun cst-class-body-declaration-conc4-rep (abnf::cst)
 (declare (xargs :guard (abnf::treep abnf::cst)))
 (declare
  (xargs
     :guard (and (cst-matchp abnf::cst "class-body-declaration")
                 (equal (cst-class-body-declaration-conc? abnf::cst)
                        4))))
 (abnf::tree-list-fix
      (nth 0
           (cst-class-body-declaration-conc4 abnf::cst))))

Theorem: tree-listp-of-cst-class-body-declaration-conc4-rep

(defthm tree-listp-of-cst-class-body-declaration-conc4-rep
 (b* ((abnf::csts (cst-class-body-declaration-conc4-rep abnf::cst)))
   (abnf::tree-listp abnf::csts))
 :rule-classes :rewrite)

Theorem: cst-class-body-declaration-conc4-rep-match

(defthm cst-class-body-declaration-conc4-rep-match
 (implies
   (and (cst-matchp abnf::cst "class-body-declaration")
        (equal (cst-class-body-declaration-conc? abnf::cst)
               4))
   (b*
     ((abnf::csts (cst-class-body-declaration-conc4-rep abnf::cst)))
     (cst-list-rep-matchp abnf::csts "constructor-declaration")))
 :rule-classes :rewrite)

Theorem: cst-class-body-declaration-conc4-rep-of-tree-fix-cst

(defthm cst-class-body-declaration-conc4-rep-of-tree-fix-cst
 (equal
   (cst-class-body-declaration-conc4-rep (abnf::tree-fix abnf::cst))
   (cst-class-body-declaration-conc4-rep abnf::cst)))

Theorem: cst-class-body-declaration-conc4-rep-tree-equiv-congruence-on-cst

(defthm
  cst-class-body-declaration-conc4-rep-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-class-body-declaration-conc4-rep abnf::cst)
                  (cst-class-body-declaration-conc4-rep cst-equiv)))
  :rule-classes :congruence)

Function: cst-variable-initializer-conc1-rep

(defun cst-variable-initializer-conc1-rep (abnf::cst)
 (declare (xargs :guard (abnf::treep abnf::cst)))
 (declare
  (xargs
       :guard (and (cst-matchp abnf::cst "variable-initializer")
                   (equal (cst-variable-initializer-conc? abnf::cst)
                          1))))
 (abnf::tree-list-fix
      (nth 0
           (cst-variable-initializer-conc1 abnf::cst))))

Theorem: tree-listp-of-cst-variable-initializer-conc1-rep

(defthm tree-listp-of-cst-variable-initializer-conc1-rep
  (b* ((abnf::csts (cst-variable-initializer-conc1-rep abnf::cst)))
    (abnf::tree-listp abnf::csts))
  :rule-classes :rewrite)

Theorem: cst-variable-initializer-conc1-rep-match

(defthm cst-variable-initializer-conc1-rep-match
 (implies
   (and (cst-matchp abnf::cst "variable-initializer")
        (equal (cst-variable-initializer-conc? abnf::cst)
               1))
   (b* ((abnf::csts (cst-variable-initializer-conc1-rep abnf::cst)))
     (cst-list-rep-matchp abnf::csts "expression")))
 :rule-classes :rewrite)

Theorem: cst-variable-initializer-conc1-rep-of-tree-fix-cst

(defthm cst-variable-initializer-conc1-rep-of-tree-fix-cst
 (equal
     (cst-variable-initializer-conc1-rep (abnf::tree-fix abnf::cst))
     (cst-variable-initializer-conc1-rep abnf::cst)))

Theorem: cst-variable-initializer-conc1-rep-tree-equiv-congruence-on-cst

(defthm
    cst-variable-initializer-conc1-rep-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-variable-initializer-conc1-rep abnf::cst)
                  (cst-variable-initializer-conc1-rep cst-equiv)))
  :rule-classes :congruence)

Function: cst-variable-initializer-conc2-rep

(defun cst-variable-initializer-conc2-rep (abnf::cst)
 (declare (xargs :guard (abnf::treep abnf::cst)))
 (declare
  (xargs
       :guard (and (cst-matchp abnf::cst "variable-initializer")
                   (equal (cst-variable-initializer-conc? abnf::cst)
                          2))))
 (abnf::tree-list-fix
      (nth 0
           (cst-variable-initializer-conc2 abnf::cst))))

Theorem: tree-listp-of-cst-variable-initializer-conc2-rep

(defthm tree-listp-of-cst-variable-initializer-conc2-rep
  (b* ((abnf::csts (cst-variable-initializer-conc2-rep abnf::cst)))
    (abnf::tree-listp abnf::csts))
  :rule-classes :rewrite)

Theorem: cst-variable-initializer-conc2-rep-match

(defthm cst-variable-initializer-conc2-rep-match
 (implies
   (and (cst-matchp abnf::cst "variable-initializer")
        (equal (cst-variable-initializer-conc? abnf::cst)
               2))
   (b* ((abnf::csts (cst-variable-initializer-conc2-rep abnf::cst)))
     (cst-list-rep-matchp abnf::csts "array-initializer")))
 :rule-classes :rewrite)

Theorem: cst-variable-initializer-conc2-rep-of-tree-fix-cst

(defthm cst-variable-initializer-conc2-rep-of-tree-fix-cst
 (equal
     (cst-variable-initializer-conc2-rep (abnf::tree-fix abnf::cst))
     (cst-variable-initializer-conc2-rep abnf::cst)))

Theorem: cst-variable-initializer-conc2-rep-tree-equiv-congruence-on-cst

(defthm
    cst-variable-initializer-conc2-rep-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-variable-initializer-conc2-rep abnf::cst)
                  (cst-variable-initializer-conc2-rep cst-equiv)))
  :rule-classes :congruence)

Function: cst-unann-type-conc1-rep

(defun cst-unann-type-conc1-rep (abnf::cst)
 (declare (xargs :guard (abnf::treep abnf::cst)))
 (declare (xargs :guard (and (cst-matchp abnf::cst "unann-type")
                             (equal (cst-unann-type-conc? abnf::cst)
                                    1))))
 (abnf::tree-list-fix (nth 0 (cst-unann-type-conc1 abnf::cst))))

Theorem: tree-listp-of-cst-unann-type-conc1-rep

(defthm tree-listp-of-cst-unann-type-conc1-rep
  (b* ((abnf::csts (cst-unann-type-conc1-rep abnf::cst)))
    (abnf::tree-listp abnf::csts))
  :rule-classes :rewrite)

Theorem: cst-unann-type-conc1-rep-match

(defthm cst-unann-type-conc1-rep-match
  (implies
       (and (cst-matchp abnf::cst "unann-type")
            (equal (cst-unann-type-conc? abnf::cst)
                   1))
       (b* ((abnf::csts (cst-unann-type-conc1-rep abnf::cst)))
         (cst-list-rep-matchp abnf::csts "unann-primitive-type")))
  :rule-classes :rewrite)

Theorem: cst-unann-type-conc1-rep-of-tree-fix-cst

(defthm cst-unann-type-conc1-rep-of-tree-fix-cst
  (equal (cst-unann-type-conc1-rep (abnf::tree-fix abnf::cst))
         (cst-unann-type-conc1-rep abnf::cst)))

Theorem: cst-unann-type-conc1-rep-tree-equiv-congruence-on-cst

(defthm cst-unann-type-conc1-rep-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-unann-type-conc1-rep abnf::cst)
                  (cst-unann-type-conc1-rep cst-equiv)))
  :rule-classes :congruence)

Function: cst-unann-type-conc2-rep

(defun cst-unann-type-conc2-rep (abnf::cst)
 (declare (xargs :guard (abnf::treep abnf::cst)))
 (declare (xargs :guard (and (cst-matchp abnf::cst "unann-type")
                             (equal (cst-unann-type-conc? abnf::cst)
                                    2))))
 (abnf::tree-list-fix (nth 0 (cst-unann-type-conc2 abnf::cst))))

Theorem: tree-listp-of-cst-unann-type-conc2-rep

(defthm tree-listp-of-cst-unann-type-conc2-rep
  (b* ((abnf::csts (cst-unann-type-conc2-rep abnf::cst)))
    (abnf::tree-listp abnf::csts))
  :rule-classes :rewrite)

Theorem: cst-unann-type-conc2-rep-match

(defthm cst-unann-type-conc2-rep-match
  (implies
       (and (cst-matchp abnf::cst "unann-type")
            (equal (cst-unann-type-conc? abnf::cst)
                   2))
       (b* ((abnf::csts (cst-unann-type-conc2-rep abnf::cst)))
         (cst-list-rep-matchp abnf::csts "unann-reference-type")))
  :rule-classes :rewrite)

Theorem: cst-unann-type-conc2-rep-of-tree-fix-cst

(defthm cst-unann-type-conc2-rep-of-tree-fix-cst
  (equal (cst-unann-type-conc2-rep (abnf::tree-fix abnf::cst))
         (cst-unann-type-conc2-rep abnf::cst)))

Theorem: cst-unann-type-conc2-rep-tree-equiv-congruence-on-cst

(defthm cst-unann-type-conc2-rep-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-unann-type-conc2-rep abnf::cst)
                  (cst-unann-type-conc2-rep cst-equiv)))
  :rule-classes :congruence)

Function: cst-unann-reference-type-conc1-rep

(defun cst-unann-reference-type-conc1-rep (abnf::cst)
 (declare (xargs :guard (abnf::treep abnf::cst)))
 (declare
  (xargs
       :guard (and (cst-matchp abnf::cst "unann-reference-type")
                   (equal (cst-unann-reference-type-conc? abnf::cst)
                          1))))
 (abnf::tree-list-fix
      (nth 0
           (cst-unann-reference-type-conc1 abnf::cst))))

Theorem: tree-listp-of-cst-unann-reference-type-conc1-rep

(defthm tree-listp-of-cst-unann-reference-type-conc1-rep
  (b* ((abnf::csts (cst-unann-reference-type-conc1-rep abnf::cst)))
    (abnf::tree-listp abnf::csts))
  :rule-classes :rewrite)

Theorem: cst-unann-reference-type-conc1-rep-match

(defthm cst-unann-reference-type-conc1-rep-match
 (implies
   (and (cst-matchp abnf::cst "unann-reference-type")
        (equal (cst-unann-reference-type-conc? abnf::cst)
               1))
   (b* ((abnf::csts (cst-unann-reference-type-conc1-rep abnf::cst)))
     (cst-list-rep-matchp abnf::csts
                          "unann-class-or-interface-type")))
 :rule-classes :rewrite)

Theorem: cst-unann-reference-type-conc1-rep-of-tree-fix-cst

(defthm cst-unann-reference-type-conc1-rep-of-tree-fix-cst
 (equal
     (cst-unann-reference-type-conc1-rep (abnf::tree-fix abnf::cst))
     (cst-unann-reference-type-conc1-rep abnf::cst)))

Theorem: cst-unann-reference-type-conc1-rep-tree-equiv-congruence-on-cst

(defthm
    cst-unann-reference-type-conc1-rep-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-unann-reference-type-conc1-rep abnf::cst)
                  (cst-unann-reference-type-conc1-rep cst-equiv)))
  :rule-classes :congruence)

Function: cst-unann-reference-type-conc2-rep

(defun cst-unann-reference-type-conc2-rep (abnf::cst)
 (declare (xargs :guard (abnf::treep abnf::cst)))
 (declare
  (xargs
       :guard (and (cst-matchp abnf::cst "unann-reference-type")
                   (equal (cst-unann-reference-type-conc? abnf::cst)
                          2))))
 (abnf::tree-list-fix
      (nth 0
           (cst-unann-reference-type-conc2 abnf::cst))))

Theorem: tree-listp-of-cst-unann-reference-type-conc2-rep

(defthm tree-listp-of-cst-unann-reference-type-conc2-rep
  (b* ((abnf::csts (cst-unann-reference-type-conc2-rep abnf::cst)))
    (abnf::tree-listp abnf::csts))
  :rule-classes :rewrite)

Theorem: cst-unann-reference-type-conc2-rep-match

(defthm cst-unann-reference-type-conc2-rep-match
 (implies
   (and (cst-matchp abnf::cst "unann-reference-type")
        (equal (cst-unann-reference-type-conc? abnf::cst)
               2))
   (b* ((abnf::csts (cst-unann-reference-type-conc2-rep abnf::cst)))
     (cst-list-rep-matchp abnf::csts "unann-type-variable")))
 :rule-classes :rewrite)

Theorem: cst-unann-reference-type-conc2-rep-of-tree-fix-cst

(defthm cst-unann-reference-type-conc2-rep-of-tree-fix-cst
 (equal
     (cst-unann-reference-type-conc2-rep (abnf::tree-fix abnf::cst))
     (cst-unann-reference-type-conc2-rep abnf::cst)))

Theorem: cst-unann-reference-type-conc2-rep-tree-equiv-congruence-on-cst

(defthm
    cst-unann-reference-type-conc2-rep-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-unann-reference-type-conc2-rep abnf::cst)
                  (cst-unann-reference-type-conc2-rep cst-equiv)))
  :rule-classes :congruence)

Function: cst-unann-reference-type-conc3-rep

(defun cst-unann-reference-type-conc3-rep (abnf::cst)
 (declare (xargs :guard (abnf::treep abnf::cst)))
 (declare
  (xargs
       :guard (and (cst-matchp abnf::cst "unann-reference-type")
                   (equal (cst-unann-reference-type-conc? abnf::cst)
                          3))))
 (abnf::tree-list-fix
      (nth 0
           (cst-unann-reference-type-conc3 abnf::cst))))

Theorem: tree-listp-of-cst-unann-reference-type-conc3-rep

(defthm tree-listp-of-cst-unann-reference-type-conc3-rep
  (b* ((abnf::csts (cst-unann-reference-type-conc3-rep abnf::cst)))
    (abnf::tree-listp abnf::csts))
  :rule-classes :rewrite)

Theorem: cst-unann-reference-type-conc3-rep-match

(defthm cst-unann-reference-type-conc3-rep-match
 (implies
   (and (cst-matchp abnf::cst "unann-reference-type")
        (equal (cst-unann-reference-type-conc? abnf::cst)
               3))
   (b* ((abnf::csts (cst-unann-reference-type-conc3-rep abnf::cst)))
     (cst-list-rep-matchp abnf::csts "unann-array-type")))
 :rule-classes :rewrite)

Theorem: cst-unann-reference-type-conc3-rep-of-tree-fix-cst

(defthm cst-unann-reference-type-conc3-rep-of-tree-fix-cst
 (equal
     (cst-unann-reference-type-conc3-rep (abnf::tree-fix abnf::cst))
     (cst-unann-reference-type-conc3-rep abnf::cst)))

Theorem: cst-unann-reference-type-conc3-rep-tree-equiv-congruence-on-cst

(defthm
    cst-unann-reference-type-conc3-rep-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-unann-reference-type-conc3-rep abnf::cst)
                  (cst-unann-reference-type-conc3-rep cst-equiv)))
  :rule-classes :congruence)

Function: cst-unann-class-or-interface-type-conc1-rep

(defun cst-unann-class-or-interface-type-conc1-rep (abnf::cst)
 (declare (xargs :guard (abnf::treep abnf::cst)))
 (declare
  (xargs
     :guard
     (and (cst-matchp abnf::cst
                      "unann-class-or-interface-type")
          (equal (cst-unann-class-or-interface-type-conc? abnf::cst)
                 1))))
 (abnf::tree-list-fix
      (nth 0
           (cst-unann-class-or-interface-type-conc1 abnf::cst))))

Theorem: tree-listp-of-cst-unann-class-or-interface-type-conc1-rep

(defthm tree-listp-of-cst-unann-class-or-interface-type-conc1-rep
 (b* ((abnf::csts
           (cst-unann-class-or-interface-type-conc1-rep abnf::cst)))
   (abnf::tree-listp abnf::csts))
 :rule-classes :rewrite)

Theorem: cst-unann-class-or-interface-type-conc1-rep-match

(defthm cst-unann-class-or-interface-type-conc1-rep-match
 (implies
   (and (cst-matchp abnf::cst
                    "unann-class-or-interface-type")
        (equal (cst-unann-class-or-interface-type-conc? abnf::cst)
               1))
   (b*
     ((abnf::csts
           (cst-unann-class-or-interface-type-conc1-rep abnf::cst)))
     (cst-list-rep-matchp abnf::csts "unann-class-type")))
 :rule-classes :rewrite)

Theorem: cst-unann-class-or-interface-type-conc1-rep-of-tree-fix-cst

(defthm cst-unann-class-or-interface-type-conc1-rep-of-tree-fix-cst
  (equal (cst-unann-class-or-interface-type-conc1-rep
              (abnf::tree-fix abnf::cst))
         (cst-unann-class-or-interface-type-conc1-rep abnf::cst)))

Theorem: cst-unann-class-or-interface-type-conc1-rep-tree-equiv-congruence-on-cst

(defthm
 cst-unann-class-or-interface-type-conc1-rep-tree-equiv-congruence-on-cst
 (implies
    (abnf::tree-equiv abnf::cst cst-equiv)
    (equal (cst-unann-class-or-interface-type-conc1-rep abnf::cst)
           (cst-unann-class-or-interface-type-conc1-rep cst-equiv)))
 :rule-classes :congruence)

Function: cst-unann-class-or-interface-type-conc2-rep

(defun cst-unann-class-or-interface-type-conc2-rep (abnf::cst)
 (declare (xargs :guard (abnf::treep abnf::cst)))
 (declare
  (xargs
     :guard
     (and (cst-matchp abnf::cst
                      "unann-class-or-interface-type")
          (equal (cst-unann-class-or-interface-type-conc? abnf::cst)
                 2))))
 (abnf::tree-list-fix
      (nth 0
           (cst-unann-class-or-interface-type-conc2 abnf::cst))))

Theorem: tree-listp-of-cst-unann-class-or-interface-type-conc2-rep

(defthm tree-listp-of-cst-unann-class-or-interface-type-conc2-rep
 (b* ((abnf::csts
           (cst-unann-class-or-interface-type-conc2-rep abnf::cst)))
   (abnf::tree-listp abnf::csts))
 :rule-classes :rewrite)

Theorem: cst-unann-class-or-interface-type-conc2-rep-match

(defthm cst-unann-class-or-interface-type-conc2-rep-match
 (implies
   (and (cst-matchp abnf::cst
                    "unann-class-or-interface-type")
        (equal (cst-unann-class-or-interface-type-conc? abnf::cst)
               2))
   (b*
     ((abnf::csts
           (cst-unann-class-or-interface-type-conc2-rep abnf::cst)))
     (cst-list-rep-matchp abnf::csts "unann-interface-type")))
 :rule-classes :rewrite)

Theorem: cst-unann-class-or-interface-type-conc2-rep-of-tree-fix-cst

(defthm cst-unann-class-or-interface-type-conc2-rep-of-tree-fix-cst
  (equal (cst-unann-class-or-interface-type-conc2-rep
              (abnf::tree-fix abnf::cst))
         (cst-unann-class-or-interface-type-conc2-rep abnf::cst)))

Theorem: cst-unann-class-or-interface-type-conc2-rep-tree-equiv-congruence-on-cst

(defthm
 cst-unann-class-or-interface-type-conc2-rep-tree-equiv-congruence-on-cst
 (implies
    (abnf::tree-equiv abnf::cst cst-equiv)
    (equal (cst-unann-class-or-interface-type-conc2-rep abnf::cst)
           (cst-unann-class-or-interface-type-conc2-rep cst-equiv)))
 :rule-classes :congruence)

Function: cst-unann-interface-type-conc-rep

(defun cst-unann-interface-type-conc-rep (abnf::cst)
  (declare (xargs :guard (abnf::treep abnf::cst)))
  (declare
       (xargs :guard (cst-matchp abnf::cst "unann-interface-type")))
  (abnf::tree-list-fix
       (nth 0
            (cst-unann-interface-type-conc abnf::cst))))

Theorem: tree-listp-of-cst-unann-interface-type-conc-rep

(defthm tree-listp-of-cst-unann-interface-type-conc-rep
  (b* ((abnf::csts (cst-unann-interface-type-conc-rep abnf::cst)))
    (abnf::tree-listp abnf::csts))
  :rule-classes :rewrite)

Theorem: cst-unann-interface-type-conc-rep-match

(defthm cst-unann-interface-type-conc-rep-match
 (implies
    (cst-matchp abnf::cst "unann-interface-type")
    (b* ((abnf::csts (cst-unann-interface-type-conc-rep abnf::cst)))
      (cst-list-rep-matchp abnf::csts "unann-class-type")))
 :rule-classes :rewrite)

Theorem: cst-unann-interface-type-conc-rep-of-tree-fix-cst

(defthm cst-unann-interface-type-conc-rep-of-tree-fix-cst
 (equal
      (cst-unann-interface-type-conc-rep (abnf::tree-fix abnf::cst))
      (cst-unann-interface-type-conc-rep abnf::cst)))

Theorem: cst-unann-interface-type-conc-rep-tree-equiv-congruence-on-cst

(defthm
     cst-unann-interface-type-conc-rep-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-unann-interface-type-conc-rep abnf::cst)
                  (cst-unann-interface-type-conc-rep cst-equiv)))
  :rule-classes :congruence)

Function: cst-unann-type-variable-conc-rep

(defun cst-unann-type-variable-conc-rep (abnf::cst)
  (declare (xargs :guard (abnf::treep abnf::cst)))
  (declare
       (xargs :guard (cst-matchp abnf::cst "unann-type-variable")))
  (abnf::tree-list-fix
       (nth 0
            (cst-unann-type-variable-conc abnf::cst))))

Theorem: tree-listp-of-cst-unann-type-variable-conc-rep

(defthm tree-listp-of-cst-unann-type-variable-conc-rep
  (b* ((abnf::csts (cst-unann-type-variable-conc-rep abnf::cst)))
    (abnf::tree-listp abnf::csts))
  :rule-classes :rewrite)

Theorem: cst-unann-type-variable-conc-rep-match

(defthm cst-unann-type-variable-conc-rep-match
 (implies
     (cst-matchp abnf::cst "unann-type-variable")
     (b* ((abnf::csts (cst-unann-type-variable-conc-rep abnf::cst)))
       (cst-list-rep-matchp abnf::csts "type-identifier")))
 :rule-classes :rewrite)

Theorem: cst-unann-type-variable-conc-rep-of-tree-fix-cst

(defthm cst-unann-type-variable-conc-rep-of-tree-fix-cst
  (equal
       (cst-unann-type-variable-conc-rep (abnf::tree-fix abnf::cst))
       (cst-unann-type-variable-conc-rep abnf::cst)))

Theorem: cst-unann-type-variable-conc-rep-tree-equiv-congruence-on-cst

(defthm
      cst-unann-type-variable-conc-rep-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-unann-type-variable-conc-rep abnf::cst)
                  (cst-unann-type-variable-conc-rep cst-equiv)))
  :rule-classes :congruence)

Function: cst-exception-type-conc1-rep

(defun cst-exception-type-conc1-rep (abnf::cst)
 (declare (xargs :guard (abnf::treep abnf::cst)))
 (declare
      (xargs :guard (and (cst-matchp abnf::cst "exception-type")
                         (equal (cst-exception-type-conc? abnf::cst)
                                1))))
 (abnf::tree-list-fix (nth 0
                           (cst-exception-type-conc1 abnf::cst))))

Theorem: tree-listp-of-cst-exception-type-conc1-rep

(defthm tree-listp-of-cst-exception-type-conc1-rep
  (b* ((abnf::csts (cst-exception-type-conc1-rep abnf::cst)))
    (abnf::tree-listp abnf::csts))
  :rule-classes :rewrite)

Theorem: cst-exception-type-conc1-rep-match

(defthm cst-exception-type-conc1-rep-match
  (implies
       (and (cst-matchp abnf::cst "exception-type")
            (equal (cst-exception-type-conc? abnf::cst)
                   1))
       (b* ((abnf::csts (cst-exception-type-conc1-rep abnf::cst)))
         (cst-list-rep-matchp abnf::csts "class-type")))
  :rule-classes :rewrite)

Theorem: cst-exception-type-conc1-rep-of-tree-fix-cst

(defthm cst-exception-type-conc1-rep-of-tree-fix-cst
  (equal (cst-exception-type-conc1-rep (abnf::tree-fix abnf::cst))
         (cst-exception-type-conc1-rep abnf::cst)))

Theorem: cst-exception-type-conc1-rep-tree-equiv-congruence-on-cst

(defthm cst-exception-type-conc1-rep-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-exception-type-conc1-rep abnf::cst)
                  (cst-exception-type-conc1-rep cst-equiv)))
  :rule-classes :congruence)

Function: cst-exception-type-conc2-rep

(defun cst-exception-type-conc2-rep (abnf::cst)
 (declare (xargs :guard (abnf::treep abnf::cst)))
 (declare
      (xargs :guard (and (cst-matchp abnf::cst "exception-type")
                         (equal (cst-exception-type-conc? abnf::cst)
                                2))))
 (abnf::tree-list-fix (nth 0
                           (cst-exception-type-conc2 abnf::cst))))

Theorem: tree-listp-of-cst-exception-type-conc2-rep

(defthm tree-listp-of-cst-exception-type-conc2-rep
  (b* ((abnf::csts (cst-exception-type-conc2-rep abnf::cst)))
    (abnf::tree-listp abnf::csts))
  :rule-classes :rewrite)

Theorem: cst-exception-type-conc2-rep-match

(defthm cst-exception-type-conc2-rep-match
  (implies
       (and (cst-matchp abnf::cst "exception-type")
            (equal (cst-exception-type-conc? abnf::cst)
                   2))
       (b* ((abnf::csts (cst-exception-type-conc2-rep abnf::cst)))
         (cst-list-rep-matchp abnf::csts "type-variable")))
  :rule-classes :rewrite)

Theorem: cst-exception-type-conc2-rep-of-tree-fix-cst

(defthm cst-exception-type-conc2-rep-of-tree-fix-cst
  (equal (cst-exception-type-conc2-rep (abnf::tree-fix abnf::cst))
         (cst-exception-type-conc2-rep abnf::cst)))

Theorem: cst-exception-type-conc2-rep-tree-equiv-congruence-on-cst

(defthm cst-exception-type-conc2-rep-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-exception-type-conc2-rep abnf::cst)
                  (cst-exception-type-conc2-rep cst-equiv)))
  :rule-classes :congruence)

Function: cst-instance-initializer-conc-rep

(defun cst-instance-initializer-conc-rep (abnf::cst)
  (declare (xargs :guard (abnf::treep abnf::cst)))
  (declare
       (xargs :guard (cst-matchp abnf::cst "instance-initializer")))
  (abnf::tree-list-fix
       (nth 0
            (cst-instance-initializer-conc abnf::cst))))

Theorem: tree-listp-of-cst-instance-initializer-conc-rep

(defthm tree-listp-of-cst-instance-initializer-conc-rep
  (b* ((abnf::csts (cst-instance-initializer-conc-rep abnf::cst)))
    (abnf::tree-listp abnf::csts))
  :rule-classes :rewrite)

Theorem: cst-instance-initializer-conc-rep-match

(defthm cst-instance-initializer-conc-rep-match
 (implies
    (cst-matchp abnf::cst "instance-initializer")
    (b* ((abnf::csts (cst-instance-initializer-conc-rep abnf::cst)))
      (cst-list-rep-matchp abnf::csts "block")))
 :rule-classes :rewrite)

Theorem: cst-instance-initializer-conc-rep-of-tree-fix-cst

(defthm cst-instance-initializer-conc-rep-of-tree-fix-cst
 (equal
      (cst-instance-initializer-conc-rep (abnf::tree-fix abnf::cst))
      (cst-instance-initializer-conc-rep abnf::cst)))

Theorem: cst-instance-initializer-conc-rep-tree-equiv-congruence-on-cst

(defthm
     cst-instance-initializer-conc-rep-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-instance-initializer-conc-rep abnf::cst)
                  (cst-instance-initializer-conc-rep cst-equiv)))
  :rule-classes :congruence)

Function: cst-simple-type-name-conc-rep

(defun cst-simple-type-name-conc-rep (abnf::cst)
  (declare (xargs :guard (abnf::treep abnf::cst)))
  (declare (xargs :guard (cst-matchp abnf::cst "simple-type-name")))
  (abnf::tree-list-fix (nth 0
                            (cst-simple-type-name-conc abnf::cst))))

Theorem: tree-listp-of-cst-simple-type-name-conc-rep

(defthm tree-listp-of-cst-simple-type-name-conc-rep
  (b* ((abnf::csts (cst-simple-type-name-conc-rep abnf::cst)))
    (abnf::tree-listp abnf::csts))
  :rule-classes :rewrite)

Theorem: cst-simple-type-name-conc-rep-match

(defthm cst-simple-type-name-conc-rep-match
  (implies
       (cst-matchp abnf::cst "simple-type-name")
       (b* ((abnf::csts (cst-simple-type-name-conc-rep abnf::cst)))
         (cst-list-rep-matchp abnf::csts "type-identifier")))
  :rule-classes :rewrite)

Theorem: cst-simple-type-name-conc-rep-of-tree-fix-cst

(defthm cst-simple-type-name-conc-rep-of-tree-fix-cst
  (equal (cst-simple-type-name-conc-rep (abnf::tree-fix abnf::cst))
         (cst-simple-type-name-conc-rep abnf::cst)))

Theorem: cst-simple-type-name-conc-rep-tree-equiv-congruence-on-cst

(defthm cst-simple-type-name-conc-rep-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-simple-type-name-conc-rep abnf::cst)
                  (cst-simple-type-name-conc-rep cst-equiv)))
  :rule-classes :congruence)

Function: cst-enum-constant-modifier-conc-rep

(defun cst-enum-constant-modifier-conc-rep (abnf::cst)
 (declare (xargs :guard (abnf::treep abnf::cst)))
 (declare
     (xargs :guard (cst-matchp abnf::cst "enum-constant-modifier")))
 (abnf::tree-list-fix
      (nth 0
           (cst-enum-constant-modifier-conc abnf::cst))))

Theorem: tree-listp-of-cst-enum-constant-modifier-conc-rep

(defthm tree-listp-of-cst-enum-constant-modifier-conc-rep
  (b* ((abnf::csts (cst-enum-constant-modifier-conc-rep abnf::cst)))
    (abnf::tree-listp abnf::csts))
  :rule-classes :rewrite)

Theorem: cst-enum-constant-modifier-conc-rep-match

(defthm cst-enum-constant-modifier-conc-rep-match
 (implies
  (cst-matchp abnf::cst "enum-constant-modifier")
  (b* ((abnf::csts (cst-enum-constant-modifier-conc-rep abnf::cst)))
    (cst-list-rep-matchp abnf::csts "annotation")))
 :rule-classes :rewrite)

Theorem: cst-enum-constant-modifier-conc-rep-of-tree-fix-cst

(defthm cst-enum-constant-modifier-conc-rep-of-tree-fix-cst
 (equal
    (cst-enum-constant-modifier-conc-rep (abnf::tree-fix abnf::cst))
    (cst-enum-constant-modifier-conc-rep abnf::cst)))

Theorem: cst-enum-constant-modifier-conc-rep-tree-equiv-congruence-on-cst

(defthm
   cst-enum-constant-modifier-conc-rep-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-enum-constant-modifier-conc-rep abnf::cst)
                  (cst-enum-constant-modifier-conc-rep cst-equiv)))
  :rule-classes :congruence)

Function: cst-record-component-modifier-conc-rep

(defun cst-record-component-modifier-conc-rep (abnf::cst)
 (declare (xargs :guard (abnf::treep abnf::cst)))
 (declare
  (xargs :guard (cst-matchp abnf::cst "record-component-modifier")))
 (abnf::tree-list-fix
      (nth 0
           (cst-record-component-modifier-conc abnf::cst))))

Theorem: tree-listp-of-cst-record-component-modifier-conc-rep

(defthm tree-listp-of-cst-record-component-modifier-conc-rep
  (b*
   ((abnf::csts (cst-record-component-modifier-conc-rep abnf::cst)))
   (abnf::tree-listp abnf::csts))
  :rule-classes :rewrite)

Theorem: cst-record-component-modifier-conc-rep-match

(defthm cst-record-component-modifier-conc-rep-match
 (implies
  (cst-matchp abnf::cst "record-component-modifier")
  (b*
   ((abnf::csts (cst-record-component-modifier-conc-rep abnf::cst)))
   (cst-list-rep-matchp abnf::csts "annotation")))
 :rule-classes :rewrite)

Theorem: cst-record-component-modifier-conc-rep-of-tree-fix-cst

(defthm cst-record-component-modifier-conc-rep-of-tree-fix-cst
  (equal (cst-record-component-modifier-conc-rep
              (abnf::tree-fix abnf::cst))
         (cst-record-component-modifier-conc-rep abnf::cst)))

Theorem: cst-record-component-modifier-conc-rep-tree-equiv-congruence-on-cst

(defthm
 cst-record-component-modifier-conc-rep-tree-equiv-congruence-on-cst
 (implies
      (abnf::tree-equiv abnf::cst cst-equiv)
      (equal (cst-record-component-modifier-conc-rep abnf::cst)
             (cst-record-component-modifier-conc-rep cst-equiv)))
 :rule-classes :congruence)

Function: cst-record-body-declaration-conc1-rep

(defun cst-record-body-declaration-conc1-rep (abnf::cst)
 (declare (xargs :guard (abnf::treep abnf::cst)))
 (declare
  (xargs
    :guard (and (cst-matchp abnf::cst "record-body-declaration")
                (equal (cst-record-body-declaration-conc? abnf::cst)
                       1))))
 (abnf::tree-list-fix
      (nth 0
           (cst-record-body-declaration-conc1 abnf::cst))))

Theorem: tree-listp-of-cst-record-body-declaration-conc1-rep

(defthm tree-listp-of-cst-record-body-declaration-conc1-rep
  (b*
    ((abnf::csts (cst-record-body-declaration-conc1-rep abnf::cst)))
    (abnf::tree-listp abnf::csts))
  :rule-classes :rewrite)

Theorem: cst-record-body-declaration-conc1-rep-match

(defthm cst-record-body-declaration-conc1-rep-match
 (implies
   (and (cst-matchp abnf::cst "record-body-declaration")
        (equal (cst-record-body-declaration-conc? abnf::cst)
               1))
   (b*
    ((abnf::csts (cst-record-body-declaration-conc1-rep abnf::cst)))
    (cst-list-rep-matchp abnf::csts "class-body-declaration")))
 :rule-classes :rewrite)

Theorem: cst-record-body-declaration-conc1-rep-of-tree-fix-cst

(defthm cst-record-body-declaration-conc1-rep-of-tree-fix-cst
 (equal
  (cst-record-body-declaration-conc1-rep (abnf::tree-fix abnf::cst))
  (cst-record-body-declaration-conc1-rep abnf::cst)))

Theorem: cst-record-body-declaration-conc1-rep-tree-equiv-congruence-on-cst

(defthm
 cst-record-body-declaration-conc1-rep-tree-equiv-congruence-on-cst
 (implies (abnf::tree-equiv abnf::cst cst-equiv)
          (equal (cst-record-body-declaration-conc1-rep abnf::cst)
                 (cst-record-body-declaration-conc1-rep cst-equiv)))
 :rule-classes :congruence)

Function: cst-record-body-declaration-conc2-rep

(defun cst-record-body-declaration-conc2-rep (abnf::cst)
 (declare (xargs :guard (abnf::treep abnf::cst)))
 (declare
  (xargs
    :guard (and (cst-matchp abnf::cst "record-body-declaration")
                (equal (cst-record-body-declaration-conc? abnf::cst)
                       2))))
 (abnf::tree-list-fix
      (nth 0
           (cst-record-body-declaration-conc2 abnf::cst))))

Theorem: tree-listp-of-cst-record-body-declaration-conc2-rep

(defthm tree-listp-of-cst-record-body-declaration-conc2-rep
  (b*
    ((abnf::csts (cst-record-body-declaration-conc2-rep abnf::cst)))
    (abnf::tree-listp abnf::csts))
  :rule-classes :rewrite)

Theorem: cst-record-body-declaration-conc2-rep-match

(defthm cst-record-body-declaration-conc2-rep-match
 (implies
   (and (cst-matchp abnf::cst "record-body-declaration")
        (equal (cst-record-body-declaration-conc? abnf::cst)
               2))
   (b*
    ((abnf::csts (cst-record-body-declaration-conc2-rep abnf::cst)))
    (cst-list-rep-matchp abnf::csts
                         "compact-constructor-declaration")))
 :rule-classes :rewrite)

Theorem: cst-record-body-declaration-conc2-rep-of-tree-fix-cst

(defthm cst-record-body-declaration-conc2-rep-of-tree-fix-cst
 (equal
  (cst-record-body-declaration-conc2-rep (abnf::tree-fix abnf::cst))
  (cst-record-body-declaration-conc2-rep abnf::cst)))

Theorem: cst-record-body-declaration-conc2-rep-tree-equiv-congruence-on-cst

(defthm
 cst-record-body-declaration-conc2-rep-tree-equiv-congruence-on-cst
 (implies (abnf::tree-equiv abnf::cst cst-equiv)
          (equal (cst-record-body-declaration-conc2-rep abnf::cst)
                 (cst-record-body-declaration-conc2-rep cst-equiv)))
 :rule-classes :congruence)

Function: cst-interface-declaration-conc1-rep

(defun cst-interface-declaration-conc1-rep (abnf::cst)
 (declare (xargs :guard (abnf::treep abnf::cst)))
 (declare
  (xargs
      :guard (and (cst-matchp abnf::cst "interface-declaration")
                  (equal (cst-interface-declaration-conc? abnf::cst)
                         1))))
 (abnf::tree-list-fix
      (nth 0
           (cst-interface-declaration-conc1 abnf::cst))))

Theorem: tree-listp-of-cst-interface-declaration-conc1-rep

(defthm tree-listp-of-cst-interface-declaration-conc1-rep
  (b* ((abnf::csts (cst-interface-declaration-conc1-rep abnf::cst)))
    (abnf::tree-listp abnf::csts))
  :rule-classes :rewrite)

Theorem: cst-interface-declaration-conc1-rep-match

(defthm cst-interface-declaration-conc1-rep-match
 (implies
  (and (cst-matchp abnf::cst "interface-declaration")
       (equal (cst-interface-declaration-conc? abnf::cst)
              1))
  (b* ((abnf::csts (cst-interface-declaration-conc1-rep abnf::cst)))
    (cst-list-rep-matchp abnf::csts
                         "normal-interface-declaration")))
 :rule-classes :rewrite)

Theorem: cst-interface-declaration-conc1-rep-of-tree-fix-cst

(defthm cst-interface-declaration-conc1-rep-of-tree-fix-cst
 (equal
    (cst-interface-declaration-conc1-rep (abnf::tree-fix abnf::cst))
    (cst-interface-declaration-conc1-rep abnf::cst)))

Theorem: cst-interface-declaration-conc1-rep-tree-equiv-congruence-on-cst

(defthm
   cst-interface-declaration-conc1-rep-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-interface-declaration-conc1-rep abnf::cst)
                  (cst-interface-declaration-conc1-rep cst-equiv)))
  :rule-classes :congruence)

Function: cst-interface-declaration-conc2-rep

(defun cst-interface-declaration-conc2-rep (abnf::cst)
 (declare (xargs :guard (abnf::treep abnf::cst)))
 (declare
  (xargs
      :guard (and (cst-matchp abnf::cst "interface-declaration")
                  (equal (cst-interface-declaration-conc? abnf::cst)
                         2))))
 (abnf::tree-list-fix
      (nth 0
           (cst-interface-declaration-conc2 abnf::cst))))

Theorem: tree-listp-of-cst-interface-declaration-conc2-rep

(defthm tree-listp-of-cst-interface-declaration-conc2-rep
  (b* ((abnf::csts (cst-interface-declaration-conc2-rep abnf::cst)))
    (abnf::tree-listp abnf::csts))
  :rule-classes :rewrite)

Theorem: cst-interface-declaration-conc2-rep-match

(defthm cst-interface-declaration-conc2-rep-match
 (implies
  (and (cst-matchp abnf::cst "interface-declaration")
       (equal (cst-interface-declaration-conc? abnf::cst)
              2))
  (b* ((abnf::csts (cst-interface-declaration-conc2-rep abnf::cst)))
    (cst-list-rep-matchp abnf::csts
                         "annotation-interface-declaration")))
 :rule-classes :rewrite)

Theorem: cst-interface-declaration-conc2-rep-of-tree-fix-cst

(defthm cst-interface-declaration-conc2-rep-of-tree-fix-cst
 (equal
    (cst-interface-declaration-conc2-rep (abnf::tree-fix abnf::cst))
    (cst-interface-declaration-conc2-rep abnf::cst)))

Theorem: cst-interface-declaration-conc2-rep-tree-equiv-congruence-on-cst

(defthm
   cst-interface-declaration-conc2-rep-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-interface-declaration-conc2-rep abnf::cst)
                  (cst-interface-declaration-conc2-rep cst-equiv)))
  :rule-classes :congruence)

Function: cst-annotation-conc1-rep

(defun cst-annotation-conc1-rep (abnf::cst)
 (declare (xargs :guard (abnf::treep abnf::cst)))
 (declare (xargs :guard (and (cst-matchp abnf::cst "annotation")
                             (equal (cst-annotation-conc? abnf::cst)
                                    1))))
 (abnf::tree-list-fix (nth 0 (cst-annotation-conc1 abnf::cst))))

Theorem: tree-listp-of-cst-annotation-conc1-rep

(defthm tree-listp-of-cst-annotation-conc1-rep
  (b* ((abnf::csts (cst-annotation-conc1-rep abnf::cst)))
    (abnf::tree-listp abnf::csts))
  :rule-classes :rewrite)

Theorem: cst-annotation-conc1-rep-match

(defthm cst-annotation-conc1-rep-match
  (implies (and (cst-matchp abnf::cst "annotation")
                (equal (cst-annotation-conc? abnf::cst)
                       1))
           (b* ((abnf::csts (cst-annotation-conc1-rep abnf::cst)))
             (cst-list-rep-matchp abnf::csts "normal-annotation")))
  :rule-classes :rewrite)

Theorem: cst-annotation-conc1-rep-of-tree-fix-cst

(defthm cst-annotation-conc1-rep-of-tree-fix-cst
  (equal (cst-annotation-conc1-rep (abnf::tree-fix abnf::cst))
         (cst-annotation-conc1-rep abnf::cst)))

Theorem: cst-annotation-conc1-rep-tree-equiv-congruence-on-cst

(defthm cst-annotation-conc1-rep-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-annotation-conc1-rep abnf::cst)
                  (cst-annotation-conc1-rep cst-equiv)))
  :rule-classes :congruence)

Function: cst-annotation-conc2-rep

(defun cst-annotation-conc2-rep (abnf::cst)
 (declare (xargs :guard (abnf::treep abnf::cst)))
 (declare (xargs :guard (and (cst-matchp abnf::cst "annotation")
                             (equal (cst-annotation-conc? abnf::cst)
                                    2))))
 (abnf::tree-list-fix (nth 0 (cst-annotation-conc2 abnf::cst))))

Theorem: tree-listp-of-cst-annotation-conc2-rep

(defthm tree-listp-of-cst-annotation-conc2-rep
  (b* ((abnf::csts (cst-annotation-conc2-rep abnf::cst)))
    (abnf::tree-listp abnf::csts))
  :rule-classes :rewrite)

Theorem: cst-annotation-conc2-rep-match

(defthm cst-annotation-conc2-rep-match
  (implies (and (cst-matchp abnf::cst "annotation")
                (equal (cst-annotation-conc? abnf::cst)
                       2))
           (b* ((abnf::csts (cst-annotation-conc2-rep abnf::cst)))
             (cst-list-rep-matchp abnf::csts "marker-annotation")))
  :rule-classes :rewrite)

Theorem: cst-annotation-conc2-rep-of-tree-fix-cst

(defthm cst-annotation-conc2-rep-of-tree-fix-cst
  (equal (cst-annotation-conc2-rep (abnf::tree-fix abnf::cst))
         (cst-annotation-conc2-rep abnf::cst)))

Theorem: cst-annotation-conc2-rep-tree-equiv-congruence-on-cst

(defthm cst-annotation-conc2-rep-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-annotation-conc2-rep abnf::cst)
                  (cst-annotation-conc2-rep cst-equiv)))
  :rule-classes :congruence)

Function: cst-annotation-conc3-rep

(defun cst-annotation-conc3-rep (abnf::cst)
 (declare (xargs :guard (abnf::treep abnf::cst)))
 (declare (xargs :guard (and (cst-matchp abnf::cst "annotation")
                             (equal (cst-annotation-conc? abnf::cst)
                                    3))))
 (abnf::tree-list-fix (nth 0 (cst-annotation-conc3 abnf::cst))))

Theorem: tree-listp-of-cst-annotation-conc3-rep

(defthm tree-listp-of-cst-annotation-conc3-rep
  (b* ((abnf::csts (cst-annotation-conc3-rep abnf::cst)))
    (abnf::tree-listp abnf::csts))
  :rule-classes :rewrite)

Theorem: cst-annotation-conc3-rep-match

(defthm cst-annotation-conc3-rep-match
  (implies (and (cst-matchp abnf::cst "annotation")
                (equal (cst-annotation-conc? abnf::cst)
                       3))
           (b* ((abnf::csts (cst-annotation-conc3-rep abnf::cst)))
             (cst-list-rep-matchp abnf::csts
                                  "single-element-annotation")))
  :rule-classes :rewrite)

Theorem: cst-annotation-conc3-rep-of-tree-fix-cst

(defthm cst-annotation-conc3-rep-of-tree-fix-cst
  (equal (cst-annotation-conc3-rep (abnf::tree-fix abnf::cst))
         (cst-annotation-conc3-rep abnf::cst)))

Theorem: cst-annotation-conc3-rep-tree-equiv-congruence-on-cst

(defthm cst-annotation-conc3-rep-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-annotation-conc3-rep abnf::cst)
                  (cst-annotation-conc3-rep cst-equiv)))
  :rule-classes :congruence)

Function: cst-element-value-conc1-rep

(defun cst-element-value-conc1-rep (abnf::cst)
  (declare (xargs :guard (abnf::treep abnf::cst)))
  (declare
       (xargs :guard (and (cst-matchp abnf::cst "element-value")
                          (equal (cst-element-value-conc? abnf::cst)
                                 1))))
  (abnf::tree-list-fix (nth 0 (cst-element-value-conc1 abnf::cst))))

Theorem: tree-listp-of-cst-element-value-conc1-rep

(defthm tree-listp-of-cst-element-value-conc1-rep
  (b* ((abnf::csts (cst-element-value-conc1-rep abnf::cst)))
    (abnf::tree-listp abnf::csts))
  :rule-classes :rewrite)

Theorem: cst-element-value-conc1-rep-match

(defthm cst-element-value-conc1-rep-match
  (implies
       (and (cst-matchp abnf::cst "element-value")
            (equal (cst-element-value-conc? abnf::cst)
                   1))
       (b* ((abnf::csts (cst-element-value-conc1-rep abnf::cst)))
         (cst-list-rep-matchp abnf::csts "conditional-expression")))
  :rule-classes :rewrite)

Theorem: cst-element-value-conc1-rep-of-tree-fix-cst

(defthm cst-element-value-conc1-rep-of-tree-fix-cst
  (equal (cst-element-value-conc1-rep (abnf::tree-fix abnf::cst))
         (cst-element-value-conc1-rep abnf::cst)))

Theorem: cst-element-value-conc1-rep-tree-equiv-congruence-on-cst

(defthm cst-element-value-conc1-rep-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-element-value-conc1-rep abnf::cst)
                  (cst-element-value-conc1-rep cst-equiv)))
  :rule-classes :congruence)

Function: cst-element-value-conc2-rep

(defun cst-element-value-conc2-rep (abnf::cst)
  (declare (xargs :guard (abnf::treep abnf::cst)))
  (declare
       (xargs :guard (and (cst-matchp abnf::cst "element-value")
                          (equal (cst-element-value-conc? abnf::cst)
                                 2))))
  (abnf::tree-list-fix (nth 0 (cst-element-value-conc2 abnf::cst))))

Theorem: tree-listp-of-cst-element-value-conc2-rep

(defthm tree-listp-of-cst-element-value-conc2-rep
  (b* ((abnf::csts (cst-element-value-conc2-rep abnf::cst)))
    (abnf::tree-listp abnf::csts))
  :rule-classes :rewrite)

Theorem: cst-element-value-conc2-rep-match

(defthm cst-element-value-conc2-rep-match
  (implies
       (and (cst-matchp abnf::cst "element-value")
            (equal (cst-element-value-conc? abnf::cst)
                   2))
       (b* ((abnf::csts (cst-element-value-conc2-rep abnf::cst)))
         (cst-list-rep-matchp abnf::csts
                              "element-value-array-initializer")))
  :rule-classes :rewrite)

Theorem: cst-element-value-conc2-rep-of-tree-fix-cst

(defthm cst-element-value-conc2-rep-of-tree-fix-cst
  (equal (cst-element-value-conc2-rep (abnf::tree-fix abnf::cst))
         (cst-element-value-conc2-rep abnf::cst)))

Theorem: cst-element-value-conc2-rep-tree-equiv-congruence-on-cst

(defthm cst-element-value-conc2-rep-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-element-value-conc2-rep abnf::cst)
                  (cst-element-value-conc2-rep cst-equiv)))
  :rule-classes :congruence)

Function: cst-element-value-conc3-rep

(defun cst-element-value-conc3-rep (abnf::cst)
  (declare (xargs :guard (abnf::treep abnf::cst)))
  (declare
       (xargs :guard (and (cst-matchp abnf::cst "element-value")
                          (equal (cst-element-value-conc? abnf::cst)
                                 3))))
  (abnf::tree-list-fix (nth 0 (cst-element-value-conc3 abnf::cst))))

Theorem: tree-listp-of-cst-element-value-conc3-rep

(defthm tree-listp-of-cst-element-value-conc3-rep
  (b* ((abnf::csts (cst-element-value-conc3-rep abnf::cst)))
    (abnf::tree-listp abnf::csts))
  :rule-classes :rewrite)

Theorem: cst-element-value-conc3-rep-match

(defthm cst-element-value-conc3-rep-match
 (implies (and (cst-matchp abnf::cst "element-value")
               (equal (cst-element-value-conc? abnf::cst)
                      3))
          (b* ((abnf::csts (cst-element-value-conc3-rep abnf::cst)))
            (cst-list-rep-matchp abnf::csts "annotation")))
 :rule-classes :rewrite)

Theorem: cst-element-value-conc3-rep-of-tree-fix-cst

(defthm cst-element-value-conc3-rep-of-tree-fix-cst
  (equal (cst-element-value-conc3-rep (abnf::tree-fix abnf::cst))
         (cst-element-value-conc3-rep abnf::cst)))

Theorem: cst-element-value-conc3-rep-tree-equiv-congruence-on-cst

(defthm cst-element-value-conc3-rep-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-element-value-conc3-rep abnf::cst)
                  (cst-element-value-conc3-rep cst-equiv)))
  :rule-classes :congruence)

Function: cst-block-statement-conc1-rep

(defun cst-block-statement-conc1-rep (abnf::cst)
 (declare (xargs :guard (abnf::treep abnf::cst)))
 (declare
     (xargs :guard (and (cst-matchp abnf::cst "block-statement")
                        (equal (cst-block-statement-conc? abnf::cst)
                               1))))
 (abnf::tree-list-fix (nth 0
                           (cst-block-statement-conc1 abnf::cst))))

Theorem: tree-listp-of-cst-block-statement-conc1-rep

(defthm tree-listp-of-cst-block-statement-conc1-rep
  (b* ((abnf::csts (cst-block-statement-conc1-rep abnf::cst)))
    (abnf::tree-listp abnf::csts))
  :rule-classes :rewrite)

Theorem: cst-block-statement-conc1-rep-match

(defthm cst-block-statement-conc1-rep-match
 (implies
    (and (cst-matchp abnf::cst "block-statement")
         (equal (cst-block-statement-conc? abnf::cst)
                1))
    (b* ((abnf::csts (cst-block-statement-conc1-rep abnf::cst)))
      (cst-list-rep-matchp abnf::csts
                           "local-class-or-interface-declaration")))
 :rule-classes :rewrite)

Theorem: cst-block-statement-conc1-rep-of-tree-fix-cst

(defthm cst-block-statement-conc1-rep-of-tree-fix-cst
  (equal (cst-block-statement-conc1-rep (abnf::tree-fix abnf::cst))
         (cst-block-statement-conc1-rep abnf::cst)))

Theorem: cst-block-statement-conc1-rep-tree-equiv-congruence-on-cst

(defthm cst-block-statement-conc1-rep-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-block-statement-conc1-rep abnf::cst)
                  (cst-block-statement-conc1-rep cst-equiv)))
  :rule-classes :congruence)

Function: cst-block-statement-conc2-rep

(defun cst-block-statement-conc2-rep (abnf::cst)
 (declare (xargs :guard (abnf::treep abnf::cst)))
 (declare
     (xargs :guard (and (cst-matchp abnf::cst "block-statement")
                        (equal (cst-block-statement-conc? abnf::cst)
                               2))))
 (abnf::tree-list-fix (nth 0
                           (cst-block-statement-conc2 abnf::cst))))

Theorem: tree-listp-of-cst-block-statement-conc2-rep

(defthm tree-listp-of-cst-block-statement-conc2-rep
  (b* ((abnf::csts (cst-block-statement-conc2-rep abnf::cst)))
    (abnf::tree-listp abnf::csts))
  :rule-classes :rewrite)

Theorem: cst-block-statement-conc2-rep-match

(defthm cst-block-statement-conc2-rep-match
 (implies
    (and (cst-matchp abnf::cst "block-statement")
         (equal (cst-block-statement-conc? abnf::cst)
                2))
    (b* ((abnf::csts (cst-block-statement-conc2-rep abnf::cst)))
      (cst-list-rep-matchp abnf::csts
                           "local-variable-declaration-statement")))
 :rule-classes :rewrite)

Theorem: cst-block-statement-conc2-rep-of-tree-fix-cst

(defthm cst-block-statement-conc2-rep-of-tree-fix-cst
  (equal (cst-block-statement-conc2-rep (abnf::tree-fix abnf::cst))
         (cst-block-statement-conc2-rep abnf::cst)))

Theorem: cst-block-statement-conc2-rep-tree-equiv-congruence-on-cst

(defthm cst-block-statement-conc2-rep-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-block-statement-conc2-rep abnf::cst)
                  (cst-block-statement-conc2-rep cst-equiv)))
  :rule-classes :congruence)

Function: cst-block-statement-conc3-rep

(defun cst-block-statement-conc3-rep (abnf::cst)
 (declare (xargs :guard (abnf::treep abnf::cst)))
 (declare
     (xargs :guard (and (cst-matchp abnf::cst "block-statement")
                        (equal (cst-block-statement-conc? abnf::cst)
                               3))))
 (abnf::tree-list-fix (nth 0
                           (cst-block-statement-conc3 abnf::cst))))

Theorem: tree-listp-of-cst-block-statement-conc3-rep

(defthm tree-listp-of-cst-block-statement-conc3-rep
  (b* ((abnf::csts (cst-block-statement-conc3-rep abnf::cst)))
    (abnf::tree-listp abnf::csts))
  :rule-classes :rewrite)

Theorem: cst-block-statement-conc3-rep-match

(defthm cst-block-statement-conc3-rep-match
  (implies
       (and (cst-matchp abnf::cst "block-statement")
            (equal (cst-block-statement-conc? abnf::cst)
                   3))
       (b* ((abnf::csts (cst-block-statement-conc3-rep abnf::cst)))
         (cst-list-rep-matchp abnf::csts "statement")))
  :rule-classes :rewrite)

Theorem: cst-block-statement-conc3-rep-of-tree-fix-cst

(defthm cst-block-statement-conc3-rep-of-tree-fix-cst
  (equal (cst-block-statement-conc3-rep (abnf::tree-fix abnf::cst))
         (cst-block-statement-conc3-rep abnf::cst)))

Theorem: cst-block-statement-conc3-rep-tree-equiv-congruence-on-cst

(defthm cst-block-statement-conc3-rep-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-block-statement-conc3-rep abnf::cst)
                  (cst-block-statement-conc3-rep cst-equiv)))
  :rule-classes :congruence)

Function: cst-local-class-or-interface-declaration-conc1-rep

(defun cst-local-class-or-interface-declaration-conc1-rep
       (abnf::cst)
 (declare (xargs :guard (abnf::treep abnf::cst)))
 (declare
  (xargs
   :guard
   (and
     (cst-matchp abnf::cst
                 "local-class-or-interface-declaration")
     (equal
          (cst-local-class-or-interface-declaration-conc? abnf::cst)
          1))))
 (abnf::tree-list-fix
  (nth 0
       (cst-local-class-or-interface-declaration-conc1 abnf::cst))))

Theorem: tree-listp-of-cst-local-class-or-interface-declaration-conc1-rep

(defthm
   tree-listp-of-cst-local-class-or-interface-declaration-conc1-rep
 (b*
  ((abnf::csts
    (cst-local-class-or-interface-declaration-conc1-rep abnf::cst)))
  (abnf::tree-listp abnf::csts))
 :rule-classes :rewrite)

Theorem: cst-local-class-or-interface-declaration-conc1-rep-match

(defthm cst-local-class-or-interface-declaration-conc1-rep-match
 (implies
  (and
   (cst-matchp abnf::cst
               "local-class-or-interface-declaration")
   (equal (cst-local-class-or-interface-declaration-conc? abnf::cst)
          1))
  (b* ((abnf::csts (cst-local-class-or-interface-declaration-conc1-rep
                        abnf::cst)))
    (cst-list-rep-matchp abnf::csts "class-declaration")))
 :rule-classes :rewrite)

Theorem: cst-local-class-or-interface-declaration-conc1-rep-of-tree-fix-cst

(defthm
 cst-local-class-or-interface-declaration-conc1-rep-of-tree-fix-cst
 (equal
    (cst-local-class-or-interface-declaration-conc1-rep
         (abnf::tree-fix abnf::cst))
    (cst-local-class-or-interface-declaration-conc1-rep abnf::cst)))

Theorem: cst-local-class-or-interface-declaration-conc1-rep-tree-equiv-congruence-on-cst

(defthm
 cst-local-class-or-interface-declaration-conc1-rep-tree-equiv-congruence-on-cst
 (implies
  (abnf::tree-equiv abnf::cst cst-equiv)
  (equal
    (cst-local-class-or-interface-declaration-conc1-rep abnf::cst)
    (cst-local-class-or-interface-declaration-conc1-rep cst-equiv)))
 :rule-classes :congruence)

Function: cst-local-class-or-interface-declaration-conc2-rep

(defun cst-local-class-or-interface-declaration-conc2-rep
       (abnf::cst)
 (declare (xargs :guard (abnf::treep abnf::cst)))
 (declare
  (xargs
   :guard
   (and
     (cst-matchp abnf::cst
                 "local-class-or-interface-declaration")
     (equal
          (cst-local-class-or-interface-declaration-conc? abnf::cst)
          2))))
 (abnf::tree-list-fix
  (nth 0
       (cst-local-class-or-interface-declaration-conc2 abnf::cst))))

Theorem: tree-listp-of-cst-local-class-or-interface-declaration-conc2-rep

(defthm
   tree-listp-of-cst-local-class-or-interface-declaration-conc2-rep
 (b*
  ((abnf::csts
    (cst-local-class-or-interface-declaration-conc2-rep abnf::cst)))
  (abnf::tree-listp abnf::csts))
 :rule-classes :rewrite)

Theorem: cst-local-class-or-interface-declaration-conc2-rep-match

(defthm cst-local-class-or-interface-declaration-conc2-rep-match
 (implies
  (and
   (cst-matchp abnf::cst
               "local-class-or-interface-declaration")
   (equal (cst-local-class-or-interface-declaration-conc? abnf::cst)
          2))
  (b* ((abnf::csts (cst-local-class-or-interface-declaration-conc2-rep
                        abnf::cst)))
    (cst-list-rep-matchp abnf::csts
                         "normal-interface-declaration")))
 :rule-classes :rewrite)

Theorem: cst-local-class-or-interface-declaration-conc2-rep-of-tree-fix-cst

(defthm
 cst-local-class-or-interface-declaration-conc2-rep-of-tree-fix-cst
 (equal
    (cst-local-class-or-interface-declaration-conc2-rep
         (abnf::tree-fix abnf::cst))
    (cst-local-class-or-interface-declaration-conc2-rep abnf::cst)))

Theorem: cst-local-class-or-interface-declaration-conc2-rep-tree-equiv-congruence-on-cst

(defthm
 cst-local-class-or-interface-declaration-conc2-rep-tree-equiv-congruence-on-cst
 (implies
  (abnf::tree-equiv abnf::cst cst-equiv)
  (equal
    (cst-local-class-or-interface-declaration-conc2-rep abnf::cst)
    (cst-local-class-or-interface-declaration-conc2-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))))
  (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
                        "statement-without-trailing-substatement")))
 :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))))
  (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 "labeled-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))))
  (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 "if-then-statement")))
  :rule-classes :rewrite)

Theorem: cst-statement-conc3-rep-of-tree-fix-cst

(defthm cst-statement-conc3-rep-of-tree-fix-cst
  (equal (cst-statement-conc3-rep (abnf::tree-fix abnf::cst))
         (cst-statement-conc3-rep abnf::cst)))

Theorem: cst-statement-conc3-rep-tree-equiv-congruence-on-cst

(defthm cst-statement-conc3-rep-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-statement-conc3-rep abnf::cst)
                  (cst-statement-conc3-rep cst-equiv)))
  :rule-classes :congruence)

Function: cst-statement-conc4-rep

(defun cst-statement-conc4-rep (abnf::cst)
  (declare (xargs :guard (abnf::treep abnf::cst)))
  (declare (xargs :guard (and (cst-matchp abnf::cst "statement")
                              (equal (cst-statement-conc? abnf::cst)
                                     4))))
  (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 "if-then-else-statement")))
  :rule-classes :rewrite)

Theorem: cst-statement-conc4-rep-of-tree-fix-cst

(defthm cst-statement-conc4-rep-of-tree-fix-cst
  (equal (cst-statement-conc4-rep (abnf::tree-fix abnf::cst))
         (cst-statement-conc4-rep abnf::cst)))

Theorem: cst-statement-conc4-rep-tree-equiv-congruence-on-cst

(defthm cst-statement-conc4-rep-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-statement-conc4-rep abnf::cst)
                  (cst-statement-conc4-rep cst-equiv)))
  :rule-classes :congruence)

Function: cst-statement-conc5-rep

(defun cst-statement-conc5-rep (abnf::cst)
  (declare (xargs :guard (abnf::treep abnf::cst)))
  (declare (xargs :guard (and (cst-matchp abnf::cst "statement")
                              (equal (cst-statement-conc? abnf::cst)
                                     5))))
  (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 "while-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))))
  (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 "for-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-no-short-if-conc1-rep

(defun cst-statement-no-short-if-conc1-rep (abnf::cst)
 (declare (xargs :guard (abnf::treep abnf::cst)))
 (declare
  (xargs
      :guard (and (cst-matchp abnf::cst "statement-no-short-if")
                  (equal (cst-statement-no-short-if-conc? abnf::cst)
                         1))))
 (abnf::tree-list-fix
      (nth 0
           (cst-statement-no-short-if-conc1 abnf::cst))))

Theorem: tree-listp-of-cst-statement-no-short-if-conc1-rep

(defthm tree-listp-of-cst-statement-no-short-if-conc1-rep
  (b* ((abnf::csts (cst-statement-no-short-if-conc1-rep abnf::cst)))
    (abnf::tree-listp abnf::csts))
  :rule-classes :rewrite)

Theorem: cst-statement-no-short-if-conc1-rep-match

(defthm cst-statement-no-short-if-conc1-rep-match
 (implies
  (and (cst-matchp abnf::cst "statement-no-short-if")
       (equal (cst-statement-no-short-if-conc? abnf::cst)
              1))
  (b* ((abnf::csts (cst-statement-no-short-if-conc1-rep abnf::cst)))
   (cst-list-rep-matchp abnf::csts
                        "statement-without-trailing-substatement")))
 :rule-classes :rewrite)

Theorem: cst-statement-no-short-if-conc1-rep-of-tree-fix-cst

(defthm cst-statement-no-short-if-conc1-rep-of-tree-fix-cst
 (equal
    (cst-statement-no-short-if-conc1-rep (abnf::tree-fix abnf::cst))
    (cst-statement-no-short-if-conc1-rep abnf::cst)))

Theorem: cst-statement-no-short-if-conc1-rep-tree-equiv-congruence-on-cst

(defthm
   cst-statement-no-short-if-conc1-rep-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-statement-no-short-if-conc1-rep abnf::cst)
                  (cst-statement-no-short-if-conc1-rep cst-equiv)))
  :rule-classes :congruence)

Function: cst-statement-no-short-if-conc2-rep

(defun cst-statement-no-short-if-conc2-rep (abnf::cst)
 (declare (xargs :guard (abnf::treep abnf::cst)))
 (declare
  (xargs
      :guard (and (cst-matchp abnf::cst "statement-no-short-if")
                  (equal (cst-statement-no-short-if-conc? abnf::cst)
                         2))))
 (abnf::tree-list-fix
      (nth 0
           (cst-statement-no-short-if-conc2 abnf::cst))))

Theorem: tree-listp-of-cst-statement-no-short-if-conc2-rep

(defthm tree-listp-of-cst-statement-no-short-if-conc2-rep
  (b* ((abnf::csts (cst-statement-no-short-if-conc2-rep abnf::cst)))
    (abnf::tree-listp abnf::csts))
  :rule-classes :rewrite)

Theorem: cst-statement-no-short-if-conc2-rep-match

(defthm cst-statement-no-short-if-conc2-rep-match
 (implies
  (and (cst-matchp abnf::cst "statement-no-short-if")
       (equal (cst-statement-no-short-if-conc? abnf::cst)
              2))
  (b* ((abnf::csts (cst-statement-no-short-if-conc2-rep abnf::cst)))
    (cst-list-rep-matchp abnf::csts
                         "labeled-statement-no-short-if")))
 :rule-classes :rewrite)

Theorem: cst-statement-no-short-if-conc2-rep-of-tree-fix-cst

(defthm cst-statement-no-short-if-conc2-rep-of-tree-fix-cst
 (equal
    (cst-statement-no-short-if-conc2-rep (abnf::tree-fix abnf::cst))
    (cst-statement-no-short-if-conc2-rep abnf::cst)))

Theorem: cst-statement-no-short-if-conc2-rep-tree-equiv-congruence-on-cst

(defthm
   cst-statement-no-short-if-conc2-rep-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-statement-no-short-if-conc2-rep abnf::cst)
                  (cst-statement-no-short-if-conc2-rep cst-equiv)))
  :rule-classes :congruence)

Function: cst-statement-no-short-if-conc3-rep

(defun cst-statement-no-short-if-conc3-rep (abnf::cst)
 (declare (xargs :guard (abnf::treep abnf::cst)))
 (declare
  (xargs
      :guard (and (cst-matchp abnf::cst "statement-no-short-if")
                  (equal (cst-statement-no-short-if-conc? abnf::cst)
                         3))))
 (abnf::tree-list-fix
      (nth 0
           (cst-statement-no-short-if-conc3 abnf::cst))))

Theorem: tree-listp-of-cst-statement-no-short-if-conc3-rep

(defthm tree-listp-of-cst-statement-no-short-if-conc3-rep
  (b* ((abnf::csts (cst-statement-no-short-if-conc3-rep abnf::cst)))
    (abnf::tree-listp abnf::csts))
  :rule-classes :rewrite)

Theorem: cst-statement-no-short-if-conc3-rep-match

(defthm cst-statement-no-short-if-conc3-rep-match
 (implies
  (and (cst-matchp abnf::cst "statement-no-short-if")
       (equal (cst-statement-no-short-if-conc? abnf::cst)
              3))
  (b* ((abnf::csts (cst-statement-no-short-if-conc3-rep abnf::cst)))
    (cst-list-rep-matchp abnf::csts
                         "if-then-else-statement-no-short-if")))
 :rule-classes :rewrite)

Theorem: cst-statement-no-short-if-conc3-rep-of-tree-fix-cst

(defthm cst-statement-no-short-if-conc3-rep-of-tree-fix-cst
 (equal
    (cst-statement-no-short-if-conc3-rep (abnf::tree-fix abnf::cst))
    (cst-statement-no-short-if-conc3-rep abnf::cst)))

Theorem: cst-statement-no-short-if-conc3-rep-tree-equiv-congruence-on-cst

(defthm
   cst-statement-no-short-if-conc3-rep-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-statement-no-short-if-conc3-rep abnf::cst)
                  (cst-statement-no-short-if-conc3-rep cst-equiv)))
  :rule-classes :congruence)

Function: cst-statement-no-short-if-conc4-rep

(defun cst-statement-no-short-if-conc4-rep (abnf::cst)
 (declare (xargs :guard (abnf::treep abnf::cst)))
 (declare
  (xargs
      :guard (and (cst-matchp abnf::cst "statement-no-short-if")
                  (equal (cst-statement-no-short-if-conc? abnf::cst)
                         4))))
 (abnf::tree-list-fix
      (nth 0
           (cst-statement-no-short-if-conc4 abnf::cst))))

Theorem: tree-listp-of-cst-statement-no-short-if-conc4-rep

(defthm tree-listp-of-cst-statement-no-short-if-conc4-rep
  (b* ((abnf::csts (cst-statement-no-short-if-conc4-rep abnf::cst)))
    (abnf::tree-listp abnf::csts))
  :rule-classes :rewrite)

Theorem: cst-statement-no-short-if-conc4-rep-match

(defthm cst-statement-no-short-if-conc4-rep-match
 (implies
  (and (cst-matchp abnf::cst "statement-no-short-if")
       (equal (cst-statement-no-short-if-conc? abnf::cst)
              4))
  (b* ((abnf::csts (cst-statement-no-short-if-conc4-rep abnf::cst)))
    (cst-list-rep-matchp abnf::csts
                         "while-statement-no-short-if")))
 :rule-classes :rewrite)

Theorem: cst-statement-no-short-if-conc4-rep-of-tree-fix-cst

(defthm cst-statement-no-short-if-conc4-rep-of-tree-fix-cst
 (equal
    (cst-statement-no-short-if-conc4-rep (abnf::tree-fix abnf::cst))
    (cst-statement-no-short-if-conc4-rep abnf::cst)))

Theorem: cst-statement-no-short-if-conc4-rep-tree-equiv-congruence-on-cst

(defthm
   cst-statement-no-short-if-conc4-rep-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-statement-no-short-if-conc4-rep abnf::cst)
                  (cst-statement-no-short-if-conc4-rep cst-equiv)))
  :rule-classes :congruence)

Function: cst-statement-no-short-if-conc5-rep

(defun cst-statement-no-short-if-conc5-rep (abnf::cst)
 (declare (xargs :guard (abnf::treep abnf::cst)))
 (declare
  (xargs
      :guard (and (cst-matchp abnf::cst "statement-no-short-if")
                  (equal (cst-statement-no-short-if-conc? abnf::cst)
                         5))))
 (abnf::tree-list-fix
      (nth 0
           (cst-statement-no-short-if-conc5 abnf::cst))))

Theorem: tree-listp-of-cst-statement-no-short-if-conc5-rep

(defthm tree-listp-of-cst-statement-no-short-if-conc5-rep
  (b* ((abnf::csts (cst-statement-no-short-if-conc5-rep abnf::cst)))
    (abnf::tree-listp abnf::csts))
  :rule-classes :rewrite)

Theorem: cst-statement-no-short-if-conc5-rep-match

(defthm cst-statement-no-short-if-conc5-rep-match
 (implies
  (and (cst-matchp abnf::cst "statement-no-short-if")
       (equal (cst-statement-no-short-if-conc? abnf::cst)
              5))
  (b* ((abnf::csts (cst-statement-no-short-if-conc5-rep abnf::cst)))
    (cst-list-rep-matchp abnf::csts
                         "for-statement-no-short-if")))
 :rule-classes :rewrite)

Theorem: cst-statement-no-short-if-conc5-rep-of-tree-fix-cst

(defthm cst-statement-no-short-if-conc5-rep-of-tree-fix-cst
 (equal
    (cst-statement-no-short-if-conc5-rep (abnf::tree-fix abnf::cst))
    (cst-statement-no-short-if-conc5-rep abnf::cst)))

Theorem: cst-statement-no-short-if-conc5-rep-tree-equiv-congruence-on-cst

(defthm
   cst-statement-no-short-if-conc5-rep-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-statement-no-short-if-conc5-rep abnf::cst)
                  (cst-statement-no-short-if-conc5-rep cst-equiv)))
  :rule-classes :congruence)

Function: cst-statement-without-trailing-substatement-conc1-rep

(defun cst-statement-without-trailing-substatement-conc1-rep
       (abnf::cst)
 (declare (xargs :guard (abnf::treep abnf::cst)))
 (declare
  (xargs
   :guard
   (and
    (cst-matchp abnf::cst
                "statement-without-trailing-substatement")
    (equal
       (cst-statement-without-trailing-substatement-conc? abnf::cst)
       1))))
 (abnf::tree-list-fix
  (nth
    0
    (cst-statement-without-trailing-substatement-conc1 abnf::cst))))

Theorem: tree-listp-of-cst-statement-without-trailing-substatement-conc1-rep

(defthm
 tree-listp-of-cst-statement-without-trailing-substatement-conc1-rep
 (b* ((abnf::csts (cst-statement-without-trailing-substatement-conc1-rep
                       abnf::cst)))
   (abnf::tree-listp abnf::csts))
 :rule-classes :rewrite)

Theorem: cst-statement-without-trailing-substatement-conc1-rep-match

(defthm cst-statement-without-trailing-substatement-conc1-rep-match
 (implies
  (and
   (cst-matchp abnf::cst
               "statement-without-trailing-substatement")
   (equal
       (cst-statement-without-trailing-substatement-conc? abnf::cst)
       1))
  (b* ((abnf::csts (cst-statement-without-trailing-substatement-conc1-rep
                        abnf::cst)))
    (cst-list-rep-matchp abnf::csts "block")))
 :rule-classes :rewrite)

Theorem: cst-statement-without-trailing-substatement-conc1-rep-of-tree-fix-cst

(defthm
 cst-statement-without-trailing-substatement-conc1-rep-of-tree-fix-cst
 (equal (cst-statement-without-trailing-substatement-conc1-rep
             (abnf::tree-fix abnf::cst))
        (cst-statement-without-trailing-substatement-conc1-rep
             abnf::cst)))

Theorem: cst-statement-without-trailing-substatement-conc1-rep-tree-equiv-congruence-on-cst

(defthm
 cst-statement-without-trailing-substatement-conc1-rep-tree-equiv-congruence-on-cst
 (implies
  (abnf::tree-equiv abnf::cst cst-equiv)
  (equal
   (cst-statement-without-trailing-substatement-conc1-rep abnf::cst)
   (cst-statement-without-trailing-substatement-conc1-rep
        cst-equiv)))
 :rule-classes :congruence)

Function: cst-statement-without-trailing-substatement-conc2-rep

(defun cst-statement-without-trailing-substatement-conc2-rep
       (abnf::cst)
 (declare (xargs :guard (abnf::treep abnf::cst)))
 (declare
  (xargs
   :guard
   (and
    (cst-matchp abnf::cst
                "statement-without-trailing-substatement")
    (equal
       (cst-statement-without-trailing-substatement-conc? abnf::cst)
       2))))
 (abnf::tree-list-fix
  (nth
    0
    (cst-statement-without-trailing-substatement-conc2 abnf::cst))))

Theorem: tree-listp-of-cst-statement-without-trailing-substatement-conc2-rep

(defthm
 tree-listp-of-cst-statement-without-trailing-substatement-conc2-rep
 (b* ((abnf::csts (cst-statement-without-trailing-substatement-conc2-rep
                       abnf::cst)))
   (abnf::tree-listp abnf::csts))
 :rule-classes :rewrite)

Theorem: cst-statement-without-trailing-substatement-conc2-rep-match

(defthm cst-statement-without-trailing-substatement-conc2-rep-match
 (implies
  (and
   (cst-matchp abnf::cst
               "statement-without-trailing-substatement")
   (equal
       (cst-statement-without-trailing-substatement-conc? abnf::cst)
       2))
  (b* ((abnf::csts (cst-statement-without-trailing-substatement-conc2-rep
                        abnf::cst)))
    (cst-list-rep-matchp abnf::csts "empty-statement")))
 :rule-classes :rewrite)

Theorem: cst-statement-without-trailing-substatement-conc2-rep-of-tree-fix-cst

(defthm
 cst-statement-without-trailing-substatement-conc2-rep-of-tree-fix-cst
 (equal (cst-statement-without-trailing-substatement-conc2-rep
             (abnf::tree-fix abnf::cst))
        (cst-statement-without-trailing-substatement-conc2-rep
             abnf::cst)))

Theorem: cst-statement-without-trailing-substatement-conc2-rep-tree-equiv-congruence-on-cst

(defthm
 cst-statement-without-trailing-substatement-conc2-rep-tree-equiv-congruence-on-cst
 (implies
  (abnf::tree-equiv abnf::cst cst-equiv)
  (equal
   (cst-statement-without-trailing-substatement-conc2-rep abnf::cst)
   (cst-statement-without-trailing-substatement-conc2-rep
        cst-equiv)))
 :rule-classes :congruence)

Function: cst-statement-without-trailing-substatement-conc3-rep

(defun cst-statement-without-trailing-substatement-conc3-rep
       (abnf::cst)
 (declare (xargs :guard (abnf::treep abnf::cst)))
 (declare
  (xargs
   :guard
   (and
    (cst-matchp abnf::cst
                "statement-without-trailing-substatement")
    (equal
       (cst-statement-without-trailing-substatement-conc? abnf::cst)
       3))))
 (abnf::tree-list-fix
  (nth
    0
    (cst-statement-without-trailing-substatement-conc3 abnf::cst))))

Theorem: tree-listp-of-cst-statement-without-trailing-substatement-conc3-rep

(defthm
 tree-listp-of-cst-statement-without-trailing-substatement-conc3-rep
 (b* ((abnf::csts (cst-statement-without-trailing-substatement-conc3-rep
                       abnf::cst)))
   (abnf::tree-listp abnf::csts))
 :rule-classes :rewrite)

Theorem: cst-statement-without-trailing-substatement-conc3-rep-match

(defthm cst-statement-without-trailing-substatement-conc3-rep-match
 (implies
  (and
   (cst-matchp abnf::cst
               "statement-without-trailing-substatement")
   (equal
       (cst-statement-without-trailing-substatement-conc? abnf::cst)
       3))
  (b* ((abnf::csts (cst-statement-without-trailing-substatement-conc3-rep
                        abnf::cst)))
    (cst-list-rep-matchp abnf::csts "expression-statement")))
 :rule-classes :rewrite)

Theorem: cst-statement-without-trailing-substatement-conc3-rep-of-tree-fix-cst

(defthm
 cst-statement-without-trailing-substatement-conc3-rep-of-tree-fix-cst
 (equal (cst-statement-without-trailing-substatement-conc3-rep
             (abnf::tree-fix abnf::cst))
        (cst-statement-without-trailing-substatement-conc3-rep
             abnf::cst)))

Theorem: cst-statement-without-trailing-substatement-conc3-rep-tree-equiv-congruence-on-cst

(defthm
 cst-statement-without-trailing-substatement-conc3-rep-tree-equiv-congruence-on-cst
 (implies
  (abnf::tree-equiv abnf::cst cst-equiv)
  (equal
   (cst-statement-without-trailing-substatement-conc3-rep abnf::cst)
   (cst-statement-without-trailing-substatement-conc3-rep
        cst-equiv)))
 :rule-classes :congruence)

Function: cst-statement-without-trailing-substatement-conc4-rep

(defun cst-statement-without-trailing-substatement-conc4-rep
       (abnf::cst)
 (declare (xargs :guard (abnf::treep abnf::cst)))
 (declare
  (xargs
   :guard
   (and
    (cst-matchp abnf::cst
                "statement-without-trailing-substatement")
    (equal
       (cst-statement-without-trailing-substatement-conc? abnf::cst)
       4))))
 (abnf::tree-list-fix
  (nth
    0
    (cst-statement-without-trailing-substatement-conc4 abnf::cst))))

Theorem: tree-listp-of-cst-statement-without-trailing-substatement-conc4-rep

(defthm
 tree-listp-of-cst-statement-without-trailing-substatement-conc4-rep
 (b* ((abnf::csts (cst-statement-without-trailing-substatement-conc4-rep
                       abnf::cst)))
   (abnf::tree-listp abnf::csts))
 :rule-classes :rewrite)

Theorem: cst-statement-without-trailing-substatement-conc4-rep-match

(defthm cst-statement-without-trailing-substatement-conc4-rep-match
 (implies
  (and
   (cst-matchp abnf::cst
               "statement-without-trailing-substatement")
   (equal
       (cst-statement-without-trailing-substatement-conc? abnf::cst)
       4))
  (b* ((abnf::csts (cst-statement-without-trailing-substatement-conc4-rep
                        abnf::cst)))
    (cst-list-rep-matchp abnf::csts "assert-statement")))
 :rule-classes :rewrite)

Theorem: cst-statement-without-trailing-substatement-conc4-rep-of-tree-fix-cst

(defthm
 cst-statement-without-trailing-substatement-conc4-rep-of-tree-fix-cst
 (equal (cst-statement-without-trailing-substatement-conc4-rep
             (abnf::tree-fix abnf::cst))
        (cst-statement-without-trailing-substatement-conc4-rep
             abnf::cst)))

Theorem: cst-statement-without-trailing-substatement-conc4-rep-tree-equiv-congruence-on-cst

(defthm
 cst-statement-without-trailing-substatement-conc4-rep-tree-equiv-congruence-on-cst
 (implies
  (abnf::tree-equiv abnf::cst cst-equiv)
  (equal
   (cst-statement-without-trailing-substatement-conc4-rep abnf::cst)
   (cst-statement-without-trailing-substatement-conc4-rep
        cst-equiv)))
 :rule-classes :congruence)

Function: cst-statement-without-trailing-substatement-conc5-rep

(defun cst-statement-without-trailing-substatement-conc5-rep
       (abnf::cst)
 (declare (xargs :guard (abnf::treep abnf::cst)))
 (declare
  (xargs
   :guard
   (and
    (cst-matchp abnf::cst
                "statement-without-trailing-substatement")
    (equal
       (cst-statement-without-trailing-substatement-conc? abnf::cst)
       5))))
 (abnf::tree-list-fix
  (nth
    0
    (cst-statement-without-trailing-substatement-conc5 abnf::cst))))

Theorem: tree-listp-of-cst-statement-without-trailing-substatement-conc5-rep

(defthm
 tree-listp-of-cst-statement-without-trailing-substatement-conc5-rep
 (b* ((abnf::csts (cst-statement-without-trailing-substatement-conc5-rep
                       abnf::cst)))
   (abnf::tree-listp abnf::csts))
 :rule-classes :rewrite)

Theorem: cst-statement-without-trailing-substatement-conc5-rep-match

(defthm cst-statement-without-trailing-substatement-conc5-rep-match
 (implies
  (and
   (cst-matchp abnf::cst
               "statement-without-trailing-substatement")
   (equal
       (cst-statement-without-trailing-substatement-conc? abnf::cst)
       5))
  (b* ((abnf::csts (cst-statement-without-trailing-substatement-conc5-rep
                        abnf::cst)))
    (cst-list-rep-matchp abnf::csts "switch-statement")))
 :rule-classes :rewrite)

Theorem: cst-statement-without-trailing-substatement-conc5-rep-of-tree-fix-cst

(defthm
 cst-statement-without-trailing-substatement-conc5-rep-of-tree-fix-cst
 (equal (cst-statement-without-trailing-substatement-conc5-rep
             (abnf::tree-fix abnf::cst))
        (cst-statement-without-trailing-substatement-conc5-rep
             abnf::cst)))

Theorem: cst-statement-without-trailing-substatement-conc5-rep-tree-equiv-congruence-on-cst

(defthm
 cst-statement-without-trailing-substatement-conc5-rep-tree-equiv-congruence-on-cst
 (implies
  (abnf::tree-equiv abnf::cst cst-equiv)
  (equal
   (cst-statement-without-trailing-substatement-conc5-rep abnf::cst)
   (cst-statement-without-trailing-substatement-conc5-rep
        cst-equiv)))
 :rule-classes :congruence)

Function: cst-statement-without-trailing-substatement-conc6-rep

(defun cst-statement-without-trailing-substatement-conc6-rep
       (abnf::cst)
 (declare (xargs :guard (abnf::treep abnf::cst)))
 (declare
  (xargs
   :guard
   (and
    (cst-matchp abnf::cst
                "statement-without-trailing-substatement")
    (equal
       (cst-statement-without-trailing-substatement-conc? abnf::cst)
       6))))
 (abnf::tree-list-fix
  (nth
    0
    (cst-statement-without-trailing-substatement-conc6 abnf::cst))))

Theorem: tree-listp-of-cst-statement-without-trailing-substatement-conc6-rep

(defthm
 tree-listp-of-cst-statement-without-trailing-substatement-conc6-rep
 (b* ((abnf::csts (cst-statement-without-trailing-substatement-conc6-rep
                       abnf::cst)))
   (abnf::tree-listp abnf::csts))
 :rule-classes :rewrite)

Theorem: cst-statement-without-trailing-substatement-conc6-rep-match

(defthm cst-statement-without-trailing-substatement-conc6-rep-match
 (implies
  (and
   (cst-matchp abnf::cst
               "statement-without-trailing-substatement")
   (equal
       (cst-statement-without-trailing-substatement-conc? abnf::cst)
       6))
  (b* ((abnf::csts (cst-statement-without-trailing-substatement-conc6-rep
                        abnf::cst)))
    (cst-list-rep-matchp abnf::csts "do-statement")))
 :rule-classes :rewrite)

Theorem: cst-statement-without-trailing-substatement-conc6-rep-of-tree-fix-cst

(defthm
 cst-statement-without-trailing-substatement-conc6-rep-of-tree-fix-cst
 (equal (cst-statement-without-trailing-substatement-conc6-rep
             (abnf::tree-fix abnf::cst))
        (cst-statement-without-trailing-substatement-conc6-rep
             abnf::cst)))

Theorem: cst-statement-without-trailing-substatement-conc6-rep-tree-equiv-congruence-on-cst

(defthm
 cst-statement-without-trailing-substatement-conc6-rep-tree-equiv-congruence-on-cst
 (implies
  (abnf::tree-equiv abnf::cst cst-equiv)
  (equal
   (cst-statement-without-trailing-substatement-conc6-rep abnf::cst)
   (cst-statement-without-trailing-substatement-conc6-rep
        cst-equiv)))
 :rule-classes :congruence)

Function: cst-statement-without-trailing-substatement-conc7-rep

(defun cst-statement-without-trailing-substatement-conc7-rep
       (abnf::cst)
 (declare (xargs :guard (abnf::treep abnf::cst)))
 (declare
  (xargs
   :guard
   (and
    (cst-matchp abnf::cst
                "statement-without-trailing-substatement")
    (equal
       (cst-statement-without-trailing-substatement-conc? abnf::cst)
       7))))
 (abnf::tree-list-fix
  (nth
    0
    (cst-statement-without-trailing-substatement-conc7 abnf::cst))))

Theorem: tree-listp-of-cst-statement-without-trailing-substatement-conc7-rep

(defthm
 tree-listp-of-cst-statement-without-trailing-substatement-conc7-rep
 (b* ((abnf::csts (cst-statement-without-trailing-substatement-conc7-rep
                       abnf::cst)))
   (abnf::tree-listp abnf::csts))
 :rule-classes :rewrite)

Theorem: cst-statement-without-trailing-substatement-conc7-rep-match

(defthm cst-statement-without-trailing-substatement-conc7-rep-match
 (implies
  (and
   (cst-matchp abnf::cst
               "statement-without-trailing-substatement")
   (equal
       (cst-statement-without-trailing-substatement-conc? abnf::cst)
       7))
  (b* ((abnf::csts (cst-statement-without-trailing-substatement-conc7-rep
                        abnf::cst)))
    (cst-list-rep-matchp abnf::csts "break-statement")))
 :rule-classes :rewrite)

Theorem: cst-statement-without-trailing-substatement-conc7-rep-of-tree-fix-cst

(defthm
 cst-statement-without-trailing-substatement-conc7-rep-of-tree-fix-cst
 (equal (cst-statement-without-trailing-substatement-conc7-rep
             (abnf::tree-fix abnf::cst))
        (cst-statement-without-trailing-substatement-conc7-rep
             abnf::cst)))

Theorem: cst-statement-without-trailing-substatement-conc7-rep-tree-equiv-congruence-on-cst

(defthm
 cst-statement-without-trailing-substatement-conc7-rep-tree-equiv-congruence-on-cst
 (implies
  (abnf::tree-equiv abnf::cst cst-equiv)
  (equal
   (cst-statement-without-trailing-substatement-conc7-rep abnf::cst)
   (cst-statement-without-trailing-substatement-conc7-rep
        cst-equiv)))
 :rule-classes :congruence)

Function: cst-statement-without-trailing-substatement-conc8-rep

(defun cst-statement-without-trailing-substatement-conc8-rep
       (abnf::cst)
 (declare (xargs :guard (abnf::treep abnf::cst)))
 (declare
  (xargs
   :guard
   (and
    (cst-matchp abnf::cst
                "statement-without-trailing-substatement")
    (equal
       (cst-statement-without-trailing-substatement-conc? abnf::cst)
       8))))
 (abnf::tree-list-fix
  (nth
    0
    (cst-statement-without-trailing-substatement-conc8 abnf::cst))))

Theorem: tree-listp-of-cst-statement-without-trailing-substatement-conc8-rep

(defthm
 tree-listp-of-cst-statement-without-trailing-substatement-conc8-rep
 (b* ((abnf::csts (cst-statement-without-trailing-substatement-conc8-rep
                       abnf::cst)))
   (abnf::tree-listp abnf::csts))
 :rule-classes :rewrite)

Theorem: cst-statement-without-trailing-substatement-conc8-rep-match

(defthm cst-statement-without-trailing-substatement-conc8-rep-match
 (implies
  (and
   (cst-matchp abnf::cst
               "statement-without-trailing-substatement")
   (equal
       (cst-statement-without-trailing-substatement-conc? abnf::cst)
       8))
  (b* ((abnf::csts (cst-statement-without-trailing-substatement-conc8-rep
                        abnf::cst)))
    (cst-list-rep-matchp abnf::csts "continue-statement")))
 :rule-classes :rewrite)

Theorem: cst-statement-without-trailing-substatement-conc8-rep-of-tree-fix-cst

(defthm
 cst-statement-without-trailing-substatement-conc8-rep-of-tree-fix-cst
 (equal (cst-statement-without-trailing-substatement-conc8-rep
             (abnf::tree-fix abnf::cst))
        (cst-statement-without-trailing-substatement-conc8-rep
             abnf::cst)))

Theorem: cst-statement-without-trailing-substatement-conc8-rep-tree-equiv-congruence-on-cst

(defthm
 cst-statement-without-trailing-substatement-conc8-rep-tree-equiv-congruence-on-cst
 (implies
  (abnf::tree-equiv abnf::cst cst-equiv)
  (equal
   (cst-statement-without-trailing-substatement-conc8-rep abnf::cst)
   (cst-statement-without-trailing-substatement-conc8-rep
        cst-equiv)))
 :rule-classes :congruence)

Function: cst-statement-without-trailing-substatement-conc9-rep

(defun cst-statement-without-trailing-substatement-conc9-rep
       (abnf::cst)
 (declare (xargs :guard (abnf::treep abnf::cst)))
 (declare
  (xargs
   :guard
   (and
    (cst-matchp abnf::cst
                "statement-without-trailing-substatement")
    (equal
       (cst-statement-without-trailing-substatement-conc? abnf::cst)
       9))))
 (abnf::tree-list-fix
  (nth
    0
    (cst-statement-without-trailing-substatement-conc9 abnf::cst))))

Theorem: tree-listp-of-cst-statement-without-trailing-substatement-conc9-rep

(defthm
 tree-listp-of-cst-statement-without-trailing-substatement-conc9-rep
 (b* ((abnf::csts (cst-statement-without-trailing-substatement-conc9-rep
                       abnf::cst)))
   (abnf::tree-listp abnf::csts))
 :rule-classes :rewrite)

Theorem: cst-statement-without-trailing-substatement-conc9-rep-match

(defthm cst-statement-without-trailing-substatement-conc9-rep-match
 (implies
  (and
   (cst-matchp abnf::cst
               "statement-without-trailing-substatement")
   (equal
       (cst-statement-without-trailing-substatement-conc? abnf::cst)
       9))
  (b* ((abnf::csts (cst-statement-without-trailing-substatement-conc9-rep
                        abnf::cst)))
    (cst-list-rep-matchp abnf::csts "return-statement")))
 :rule-classes :rewrite)

Theorem: cst-statement-without-trailing-substatement-conc9-rep-of-tree-fix-cst

(defthm
 cst-statement-without-trailing-substatement-conc9-rep-of-tree-fix-cst
 (equal (cst-statement-without-trailing-substatement-conc9-rep
             (abnf::tree-fix abnf::cst))
        (cst-statement-without-trailing-substatement-conc9-rep
             abnf::cst)))

Theorem: cst-statement-without-trailing-substatement-conc9-rep-tree-equiv-congruence-on-cst

(defthm
 cst-statement-without-trailing-substatement-conc9-rep-tree-equiv-congruence-on-cst
 (implies
  (abnf::tree-equiv abnf::cst cst-equiv)
  (equal
   (cst-statement-without-trailing-substatement-conc9-rep abnf::cst)
   (cst-statement-without-trailing-substatement-conc9-rep
        cst-equiv)))
 :rule-classes :congruence)

Function: cst-statement-without-trailing-substatement-conc10-rep

(defun cst-statement-without-trailing-substatement-conc10-rep
       (abnf::cst)
 (declare (xargs :guard (abnf::treep abnf::cst)))
 (declare
  (xargs
   :guard
   (and
    (cst-matchp abnf::cst
                "statement-without-trailing-substatement")
    (equal
       (cst-statement-without-trailing-substatement-conc? abnf::cst)
       10))))
 (abnf::tree-list-fix
  (nth
   0
   (cst-statement-without-trailing-substatement-conc10 abnf::cst))))

Theorem: tree-listp-of-cst-statement-without-trailing-substatement-conc10-rep

(defthm
 tree-listp-of-cst-statement-without-trailing-substatement-conc10-rep
 (b* ((abnf::csts (cst-statement-without-trailing-substatement-conc10-rep
                       abnf::cst)))
   (abnf::tree-listp abnf::csts))
 :rule-classes :rewrite)

Theorem: cst-statement-without-trailing-substatement-conc10-rep-match

(defthm cst-statement-without-trailing-substatement-conc10-rep-match
 (implies
  (and
   (cst-matchp abnf::cst
               "statement-without-trailing-substatement")
   (equal
       (cst-statement-without-trailing-substatement-conc? abnf::cst)
       10))
  (b* ((abnf::csts (cst-statement-without-trailing-substatement-conc10-rep
                        abnf::cst)))
    (cst-list-rep-matchp abnf::csts "synchronized-statement")))
 :rule-classes :rewrite)

Theorem: cst-statement-without-trailing-substatement-conc10-rep-of-tree-fix-cst

(defthm
 cst-statement-without-trailing-substatement-conc10-rep-of-tree-fix-cst
 (equal (cst-statement-without-trailing-substatement-conc10-rep
             (abnf::tree-fix abnf::cst))
        (cst-statement-without-trailing-substatement-conc10-rep
             abnf::cst)))

Theorem: cst-statement-without-trailing-substatement-conc10-rep-tree-equiv-congruence-on-cst

(defthm
 cst-statement-without-trailing-substatement-conc10-rep-tree-equiv-congruence-on-cst
 (implies (abnf::tree-equiv abnf::cst cst-equiv)
          (equal (cst-statement-without-trailing-substatement-conc10-rep
                      abnf::cst)
                 (cst-statement-without-trailing-substatement-conc10-rep
                      cst-equiv)))
 :rule-classes :congruence)

Function: cst-statement-without-trailing-substatement-conc11-rep

(defun cst-statement-without-trailing-substatement-conc11-rep
       (abnf::cst)
 (declare (xargs :guard (abnf::treep abnf::cst)))
 (declare
  (xargs
   :guard
   (and
    (cst-matchp abnf::cst
                "statement-without-trailing-substatement")
    (equal
       (cst-statement-without-trailing-substatement-conc? abnf::cst)
       11))))
 (abnf::tree-list-fix
  (nth
   0
   (cst-statement-without-trailing-substatement-conc11 abnf::cst))))

Theorem: tree-listp-of-cst-statement-without-trailing-substatement-conc11-rep

(defthm
 tree-listp-of-cst-statement-without-trailing-substatement-conc11-rep
 (b* ((abnf::csts (cst-statement-without-trailing-substatement-conc11-rep
                       abnf::cst)))
   (abnf::tree-listp abnf::csts))
 :rule-classes :rewrite)

Theorem: cst-statement-without-trailing-substatement-conc11-rep-match

(defthm cst-statement-without-trailing-substatement-conc11-rep-match
 (implies
  (and
   (cst-matchp abnf::cst
               "statement-without-trailing-substatement")
   (equal
       (cst-statement-without-trailing-substatement-conc? abnf::cst)
       11))
  (b* ((abnf::csts (cst-statement-without-trailing-substatement-conc11-rep
                        abnf::cst)))
    (cst-list-rep-matchp abnf::csts "throw-statement")))
 :rule-classes :rewrite)

Theorem: cst-statement-without-trailing-substatement-conc11-rep-of-tree-fix-cst

(defthm
 cst-statement-without-trailing-substatement-conc11-rep-of-tree-fix-cst
 (equal (cst-statement-without-trailing-substatement-conc11-rep
             (abnf::tree-fix abnf::cst))
        (cst-statement-without-trailing-substatement-conc11-rep
             abnf::cst)))

Theorem: cst-statement-without-trailing-substatement-conc11-rep-tree-equiv-congruence-on-cst

(defthm
 cst-statement-without-trailing-substatement-conc11-rep-tree-equiv-congruence-on-cst
 (implies (abnf::tree-equiv abnf::cst cst-equiv)
          (equal (cst-statement-without-trailing-substatement-conc11-rep
                      abnf::cst)
                 (cst-statement-without-trailing-substatement-conc11-rep
                      cst-equiv)))
 :rule-classes :congruence)

Function: cst-statement-without-trailing-substatement-conc12-rep

(defun cst-statement-without-trailing-substatement-conc12-rep
       (abnf::cst)
 (declare (xargs :guard (abnf::treep abnf::cst)))
 (declare
  (xargs
   :guard
   (and
    (cst-matchp abnf::cst
                "statement-without-trailing-substatement")
    (equal
       (cst-statement-without-trailing-substatement-conc? abnf::cst)
       12))))
 (abnf::tree-list-fix
  (nth
   0
   (cst-statement-without-trailing-substatement-conc12 abnf::cst))))

Theorem: tree-listp-of-cst-statement-without-trailing-substatement-conc12-rep

(defthm
 tree-listp-of-cst-statement-without-trailing-substatement-conc12-rep
 (b* ((abnf::csts (cst-statement-without-trailing-substatement-conc12-rep
                       abnf::cst)))
   (abnf::tree-listp abnf::csts))
 :rule-classes :rewrite)

Theorem: cst-statement-without-trailing-substatement-conc12-rep-match

(defthm cst-statement-without-trailing-substatement-conc12-rep-match
 (implies
  (and
   (cst-matchp abnf::cst
               "statement-without-trailing-substatement")
   (equal
       (cst-statement-without-trailing-substatement-conc? abnf::cst)
       12))
  (b* ((abnf::csts (cst-statement-without-trailing-substatement-conc12-rep
                        abnf::cst)))
    (cst-list-rep-matchp abnf::csts "try-statement")))
 :rule-classes :rewrite)

Theorem: cst-statement-without-trailing-substatement-conc12-rep-of-tree-fix-cst

(defthm
 cst-statement-without-trailing-substatement-conc12-rep-of-tree-fix-cst
 (equal (cst-statement-without-trailing-substatement-conc12-rep
             (abnf::tree-fix abnf::cst))
        (cst-statement-without-trailing-substatement-conc12-rep
             abnf::cst)))

Theorem: cst-statement-without-trailing-substatement-conc12-rep-tree-equiv-congruence-on-cst

(defthm
 cst-statement-without-trailing-substatement-conc12-rep-tree-equiv-congruence-on-cst
 (implies (abnf::tree-equiv abnf::cst cst-equiv)
          (equal (cst-statement-without-trailing-substatement-conc12-rep
                      abnf::cst)
                 (cst-statement-without-trailing-substatement-conc12-rep
                      cst-equiv)))
 :rule-classes :congruence)

Function: cst-statement-without-trailing-substatement-conc13-rep

(defun cst-statement-without-trailing-substatement-conc13-rep
       (abnf::cst)
 (declare (xargs :guard (abnf::treep abnf::cst)))
 (declare
  (xargs
   :guard
   (and
    (cst-matchp abnf::cst
                "statement-without-trailing-substatement")
    (equal
       (cst-statement-without-trailing-substatement-conc? abnf::cst)
       13))))
 (abnf::tree-list-fix
  (nth
   0
   (cst-statement-without-trailing-substatement-conc13 abnf::cst))))

Theorem: tree-listp-of-cst-statement-without-trailing-substatement-conc13-rep

(defthm
 tree-listp-of-cst-statement-without-trailing-substatement-conc13-rep
 (b* ((abnf::csts (cst-statement-without-trailing-substatement-conc13-rep
                       abnf::cst)))
   (abnf::tree-listp abnf::csts))
 :rule-classes :rewrite)

Theorem: cst-statement-without-trailing-substatement-conc13-rep-match

(defthm cst-statement-without-trailing-substatement-conc13-rep-match
 (implies
  (and
   (cst-matchp abnf::cst
               "statement-without-trailing-substatement")
   (equal
       (cst-statement-without-trailing-substatement-conc? abnf::cst)
       13))
  (b* ((abnf::csts (cst-statement-without-trailing-substatement-conc13-rep
                        abnf::cst)))
    (cst-list-rep-matchp abnf::csts "yield-statement")))
 :rule-classes :rewrite)

Theorem: cst-statement-without-trailing-substatement-conc13-rep-of-tree-fix-cst

(defthm
 cst-statement-without-trailing-substatement-conc13-rep-of-tree-fix-cst
 (equal (cst-statement-without-trailing-substatement-conc13-rep
             (abnf::tree-fix abnf::cst))
        (cst-statement-without-trailing-substatement-conc13-rep
             abnf::cst)))

Theorem: cst-statement-without-trailing-substatement-conc13-rep-tree-equiv-congruence-on-cst

(defthm
 cst-statement-without-trailing-substatement-conc13-rep-tree-equiv-congruence-on-cst
 (implies (abnf::tree-equiv abnf::cst cst-equiv)
          (equal (cst-statement-without-trailing-substatement-conc13-rep
                      abnf::cst)
                 (cst-statement-without-trailing-substatement-conc13-rep
                      cst-equiv)))
 :rule-classes :congruence)

Function: cst-empty-statement-conc-rep

(defun cst-empty-statement-conc-rep (abnf::cst)
  (declare (xargs :guard (abnf::treep abnf::cst)))
  (declare (xargs :guard (cst-matchp abnf::cst "empty-statement")))
  (abnf::tree-list-fix (nth 0
                            (cst-empty-statement-conc abnf::cst))))

Theorem: tree-listp-of-cst-empty-statement-conc-rep

(defthm tree-listp-of-cst-empty-statement-conc-rep
  (b* ((abnf::csts (cst-empty-statement-conc-rep abnf::cst)))
    (abnf::tree-listp abnf::csts))
  :rule-classes :rewrite)

Theorem: cst-empty-statement-conc-rep-match

(defthm cst-empty-statement-conc-rep-match
  (implies
       (cst-matchp abnf::cst "empty-statement")
       (b* ((abnf::csts (cst-empty-statement-conc-rep abnf::cst)))
         (cst-list-rep-matchp abnf::csts "\";\"")))
  :rule-classes :rewrite)

Theorem: cst-empty-statement-conc-rep-of-tree-fix-cst

(defthm cst-empty-statement-conc-rep-of-tree-fix-cst
  (equal (cst-empty-statement-conc-rep (abnf::tree-fix abnf::cst))
         (cst-empty-statement-conc-rep abnf::cst)))

Theorem: cst-empty-statement-conc-rep-tree-equiv-congruence-on-cst

(defthm cst-empty-statement-conc-rep-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-empty-statement-conc-rep abnf::cst)
                  (cst-empty-statement-conc-rep cst-equiv)))
  :rule-classes :congruence)

Function: cst-statement-expression-conc1-rep

(defun cst-statement-expression-conc1-rep (abnf::cst)
 (declare (xargs :guard (abnf::treep abnf::cst)))
 (declare
  (xargs
       :guard (and (cst-matchp abnf::cst "statement-expression")
                   (equal (cst-statement-expression-conc? abnf::cst)
                          1))))
 (abnf::tree-list-fix
      (nth 0
           (cst-statement-expression-conc1 abnf::cst))))

Theorem: tree-listp-of-cst-statement-expression-conc1-rep

(defthm tree-listp-of-cst-statement-expression-conc1-rep
  (b* ((abnf::csts (cst-statement-expression-conc1-rep abnf::cst)))
    (abnf::tree-listp abnf::csts))
  :rule-classes :rewrite)

Theorem: cst-statement-expression-conc1-rep-match

(defthm cst-statement-expression-conc1-rep-match
 (implies
   (and (cst-matchp abnf::cst "statement-expression")
        (equal (cst-statement-expression-conc? abnf::cst)
               1))
   (b* ((abnf::csts (cst-statement-expression-conc1-rep abnf::cst)))
     (cst-list-rep-matchp abnf::csts "assignment")))
 :rule-classes :rewrite)

Theorem: cst-statement-expression-conc1-rep-of-tree-fix-cst

(defthm cst-statement-expression-conc1-rep-of-tree-fix-cst
 (equal
     (cst-statement-expression-conc1-rep (abnf::tree-fix abnf::cst))
     (cst-statement-expression-conc1-rep abnf::cst)))

Theorem: cst-statement-expression-conc1-rep-tree-equiv-congruence-on-cst

(defthm
    cst-statement-expression-conc1-rep-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-statement-expression-conc1-rep abnf::cst)
                  (cst-statement-expression-conc1-rep cst-equiv)))
  :rule-classes :congruence)

Function: cst-statement-expression-conc2-rep

(defun cst-statement-expression-conc2-rep (abnf::cst)
 (declare (xargs :guard (abnf::treep abnf::cst)))
 (declare
  (xargs
       :guard (and (cst-matchp abnf::cst "statement-expression")
                   (equal (cst-statement-expression-conc? abnf::cst)
                          2))))
 (abnf::tree-list-fix
      (nth 0
           (cst-statement-expression-conc2 abnf::cst))))

Theorem: tree-listp-of-cst-statement-expression-conc2-rep

(defthm tree-listp-of-cst-statement-expression-conc2-rep
  (b* ((abnf::csts (cst-statement-expression-conc2-rep abnf::cst)))
    (abnf::tree-listp abnf::csts))
  :rule-classes :rewrite)

Theorem: cst-statement-expression-conc2-rep-match

(defthm cst-statement-expression-conc2-rep-match
 (implies
   (and (cst-matchp abnf::cst "statement-expression")
        (equal (cst-statement-expression-conc? abnf::cst)
               2))
   (b* ((abnf::csts (cst-statement-expression-conc2-rep abnf::cst)))
     (cst-list-rep-matchp abnf::csts "pre-increment-expression")))
 :rule-classes :rewrite)

Theorem: cst-statement-expression-conc2-rep-of-tree-fix-cst

(defthm cst-statement-expression-conc2-rep-of-tree-fix-cst
 (equal
     (cst-statement-expression-conc2-rep (abnf::tree-fix abnf::cst))
     (cst-statement-expression-conc2-rep abnf::cst)))

Theorem: cst-statement-expression-conc2-rep-tree-equiv-congruence-on-cst

(defthm
    cst-statement-expression-conc2-rep-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-statement-expression-conc2-rep abnf::cst)
                  (cst-statement-expression-conc2-rep cst-equiv)))
  :rule-classes :congruence)

Function: cst-statement-expression-conc3-rep

(defun cst-statement-expression-conc3-rep (abnf::cst)
 (declare (xargs :guard (abnf::treep abnf::cst)))
 (declare
  (xargs
       :guard (and (cst-matchp abnf::cst "statement-expression")
                   (equal (cst-statement-expression-conc? abnf::cst)
                          3))))
 (abnf::tree-list-fix
      (nth 0
           (cst-statement-expression-conc3 abnf::cst))))

Theorem: tree-listp-of-cst-statement-expression-conc3-rep

(defthm tree-listp-of-cst-statement-expression-conc3-rep
  (b* ((abnf::csts (cst-statement-expression-conc3-rep abnf::cst)))
    (abnf::tree-listp abnf::csts))
  :rule-classes :rewrite)

Theorem: cst-statement-expression-conc3-rep-match

(defthm cst-statement-expression-conc3-rep-match
 (implies
   (and (cst-matchp abnf::cst "statement-expression")
        (equal (cst-statement-expression-conc? abnf::cst)
               3))
   (b* ((abnf::csts (cst-statement-expression-conc3-rep abnf::cst)))
     (cst-list-rep-matchp abnf::csts "pre-decrement-expression")))
 :rule-classes :rewrite)

Theorem: cst-statement-expression-conc3-rep-of-tree-fix-cst

(defthm cst-statement-expression-conc3-rep-of-tree-fix-cst
 (equal
     (cst-statement-expression-conc3-rep (abnf::tree-fix abnf::cst))
     (cst-statement-expression-conc3-rep abnf::cst)))

Theorem: cst-statement-expression-conc3-rep-tree-equiv-congruence-on-cst

(defthm
    cst-statement-expression-conc3-rep-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-statement-expression-conc3-rep abnf::cst)
                  (cst-statement-expression-conc3-rep cst-equiv)))
  :rule-classes :congruence)

Function: cst-statement-expression-conc4-rep

(defun cst-statement-expression-conc4-rep (abnf::cst)
 (declare (xargs :guard (abnf::treep abnf::cst)))
 (declare
  (xargs
       :guard (and (cst-matchp abnf::cst "statement-expression")
                   (equal (cst-statement-expression-conc? abnf::cst)
                          4))))
 (abnf::tree-list-fix
      (nth 0
           (cst-statement-expression-conc4 abnf::cst))))

Theorem: tree-listp-of-cst-statement-expression-conc4-rep

(defthm tree-listp-of-cst-statement-expression-conc4-rep
  (b* ((abnf::csts (cst-statement-expression-conc4-rep abnf::cst)))
    (abnf::tree-listp abnf::csts))
  :rule-classes :rewrite)

Theorem: cst-statement-expression-conc4-rep-match

(defthm cst-statement-expression-conc4-rep-match
 (implies
   (and (cst-matchp abnf::cst "statement-expression")
        (equal (cst-statement-expression-conc? abnf::cst)
               4))
   (b* ((abnf::csts (cst-statement-expression-conc4-rep abnf::cst)))
     (cst-list-rep-matchp abnf::csts
                          "post-increment-expression")))
 :rule-classes :rewrite)

Theorem: cst-statement-expression-conc4-rep-of-tree-fix-cst

(defthm cst-statement-expression-conc4-rep-of-tree-fix-cst
 (equal
     (cst-statement-expression-conc4-rep (abnf::tree-fix abnf::cst))
     (cst-statement-expression-conc4-rep abnf::cst)))

Theorem: cst-statement-expression-conc4-rep-tree-equiv-congruence-on-cst

(defthm
    cst-statement-expression-conc4-rep-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-statement-expression-conc4-rep abnf::cst)
                  (cst-statement-expression-conc4-rep cst-equiv)))
  :rule-classes :congruence)

Function: cst-statement-expression-conc5-rep

(defun cst-statement-expression-conc5-rep (abnf::cst)
 (declare (xargs :guard (abnf::treep abnf::cst)))
 (declare
  (xargs
       :guard (and (cst-matchp abnf::cst "statement-expression")
                   (equal (cst-statement-expression-conc? abnf::cst)
                          5))))
 (abnf::tree-list-fix
      (nth 0
           (cst-statement-expression-conc5 abnf::cst))))

Theorem: tree-listp-of-cst-statement-expression-conc5-rep

(defthm tree-listp-of-cst-statement-expression-conc5-rep
  (b* ((abnf::csts (cst-statement-expression-conc5-rep abnf::cst)))
    (abnf::tree-listp abnf::csts))
  :rule-classes :rewrite)

Theorem: cst-statement-expression-conc5-rep-match

(defthm cst-statement-expression-conc5-rep-match
 (implies
   (and (cst-matchp abnf::cst "statement-expression")
        (equal (cst-statement-expression-conc? abnf::cst)
               5))
   (b* ((abnf::csts (cst-statement-expression-conc5-rep abnf::cst)))
     (cst-list-rep-matchp abnf::csts
                          "post-decrement-expression")))
 :rule-classes :rewrite)

Theorem: cst-statement-expression-conc5-rep-of-tree-fix-cst

(defthm cst-statement-expression-conc5-rep-of-tree-fix-cst
 (equal
     (cst-statement-expression-conc5-rep (abnf::tree-fix abnf::cst))
     (cst-statement-expression-conc5-rep abnf::cst)))

Theorem: cst-statement-expression-conc5-rep-tree-equiv-congruence-on-cst

(defthm
    cst-statement-expression-conc5-rep-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-statement-expression-conc5-rep abnf::cst)
                  (cst-statement-expression-conc5-rep cst-equiv)))
  :rule-classes :congruence)

Function: cst-statement-expression-conc6-rep

(defun cst-statement-expression-conc6-rep (abnf::cst)
 (declare (xargs :guard (abnf::treep abnf::cst)))
 (declare
  (xargs
       :guard (and (cst-matchp abnf::cst "statement-expression")
                   (equal (cst-statement-expression-conc? abnf::cst)
                          6))))
 (abnf::tree-list-fix
      (nth 0
           (cst-statement-expression-conc6 abnf::cst))))

Theorem: tree-listp-of-cst-statement-expression-conc6-rep

(defthm tree-listp-of-cst-statement-expression-conc6-rep
  (b* ((abnf::csts (cst-statement-expression-conc6-rep abnf::cst)))
    (abnf::tree-listp abnf::csts))
  :rule-classes :rewrite)

Theorem: cst-statement-expression-conc6-rep-match

(defthm cst-statement-expression-conc6-rep-match
 (implies
   (and (cst-matchp abnf::cst "statement-expression")
        (equal (cst-statement-expression-conc? abnf::cst)
               6))
   (b* ((abnf::csts (cst-statement-expression-conc6-rep abnf::cst)))
     (cst-list-rep-matchp abnf::csts "method-invocation")))
 :rule-classes :rewrite)

Theorem: cst-statement-expression-conc6-rep-of-tree-fix-cst

(defthm cst-statement-expression-conc6-rep-of-tree-fix-cst
 (equal
     (cst-statement-expression-conc6-rep (abnf::tree-fix abnf::cst))
     (cst-statement-expression-conc6-rep abnf::cst)))

Theorem: cst-statement-expression-conc6-rep-tree-equiv-congruence-on-cst

(defthm
    cst-statement-expression-conc6-rep-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-statement-expression-conc6-rep abnf::cst)
                  (cst-statement-expression-conc6-rep cst-equiv)))
  :rule-classes :congruence)

Function: cst-statement-expression-conc7-rep

(defun cst-statement-expression-conc7-rep (abnf::cst)
 (declare (xargs :guard (abnf::treep abnf::cst)))
 (declare
  (xargs
       :guard (and (cst-matchp abnf::cst "statement-expression")
                   (equal (cst-statement-expression-conc? abnf::cst)
                          7))))
 (abnf::tree-list-fix
      (nth 0
           (cst-statement-expression-conc7 abnf::cst))))

Theorem: tree-listp-of-cst-statement-expression-conc7-rep

(defthm tree-listp-of-cst-statement-expression-conc7-rep
  (b* ((abnf::csts (cst-statement-expression-conc7-rep abnf::cst)))
    (abnf::tree-listp abnf::csts))
  :rule-classes :rewrite)

Theorem: cst-statement-expression-conc7-rep-match

(defthm cst-statement-expression-conc7-rep-match
 (implies
   (and (cst-matchp abnf::cst "statement-expression")
        (equal (cst-statement-expression-conc? abnf::cst)
               7))
   (b* ((abnf::csts (cst-statement-expression-conc7-rep abnf::cst)))
     (cst-list-rep-matchp abnf::csts
                          "class-instance-creation-expression")))
 :rule-classes :rewrite)

Theorem: cst-statement-expression-conc7-rep-of-tree-fix-cst

(defthm cst-statement-expression-conc7-rep-of-tree-fix-cst
 (equal
     (cst-statement-expression-conc7-rep (abnf::tree-fix abnf::cst))
     (cst-statement-expression-conc7-rep abnf::cst)))

Theorem: cst-statement-expression-conc7-rep-tree-equiv-congruence-on-cst

(defthm
    cst-statement-expression-conc7-rep-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-statement-expression-conc7-rep abnf::cst)
                  (cst-statement-expression-conc7-rep cst-equiv)))
  :rule-classes :congruence)

Function: cst-case-constant-conc-rep

(defun cst-case-constant-conc-rep (abnf::cst)
  (declare (xargs :guard (abnf::treep abnf::cst)))
  (declare (xargs :guard (cst-matchp abnf::cst "case-constant")))
  (abnf::tree-list-fix (nth 0 (cst-case-constant-conc abnf::cst))))

Theorem: tree-listp-of-cst-case-constant-conc-rep

(defthm tree-listp-of-cst-case-constant-conc-rep
  (b* ((abnf::csts (cst-case-constant-conc-rep abnf::cst)))
    (abnf::tree-listp abnf::csts))
  :rule-classes :rewrite)

Theorem: cst-case-constant-conc-rep-match

(defthm cst-case-constant-conc-rep-match
  (implies
       (cst-matchp abnf::cst "case-constant")
       (b* ((abnf::csts (cst-case-constant-conc-rep abnf::cst)))
         (cst-list-rep-matchp abnf::csts "conditional-expression")))
  :rule-classes :rewrite)

Theorem: cst-case-constant-conc-rep-of-tree-fix-cst

(defthm cst-case-constant-conc-rep-of-tree-fix-cst
  (equal (cst-case-constant-conc-rep (abnf::tree-fix abnf::cst))
         (cst-case-constant-conc-rep abnf::cst)))

Theorem: cst-case-constant-conc-rep-tree-equiv-congruence-on-cst

(defthm cst-case-constant-conc-rep-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-case-constant-conc-rep abnf::cst)
                  (cst-case-constant-conc-rep cst-equiv)))
  :rule-classes :congruence)

Function: cst-case-pattern-conc-rep

(defun cst-case-pattern-conc-rep (abnf::cst)
  (declare (xargs :guard (abnf::treep abnf::cst)))
  (declare (xargs :guard (cst-matchp abnf::cst "case-pattern")))
  (abnf::tree-list-fix (nth 0 (cst-case-pattern-conc abnf::cst))))

Theorem: tree-listp-of-cst-case-pattern-conc-rep

(defthm tree-listp-of-cst-case-pattern-conc-rep
  (b* ((abnf::csts (cst-case-pattern-conc-rep abnf::cst)))
    (abnf::tree-listp abnf::csts))
  :rule-classes :rewrite)

Theorem: cst-case-pattern-conc-rep-match

(defthm cst-case-pattern-conc-rep-match
  (implies (cst-matchp abnf::cst "case-pattern")
           (b* ((abnf::csts (cst-case-pattern-conc-rep abnf::cst)))
             (cst-list-rep-matchp abnf::csts "pattern")))
  :rule-classes :rewrite)

Theorem: cst-case-pattern-conc-rep-of-tree-fix-cst

(defthm cst-case-pattern-conc-rep-of-tree-fix-cst
  (equal (cst-case-pattern-conc-rep (abnf::tree-fix abnf::cst))
         (cst-case-pattern-conc-rep abnf::cst)))

Theorem: cst-case-pattern-conc-rep-tree-equiv-congruence-on-cst

(defthm cst-case-pattern-conc-rep-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-case-pattern-conc-rep abnf::cst)
                  (cst-case-pattern-conc-rep cst-equiv)))
  :rule-classes :congruence)

Function: cst-for-statement-conc1-rep

(defun cst-for-statement-conc1-rep (abnf::cst)
  (declare (xargs :guard (abnf::treep abnf::cst)))
  (declare
       (xargs :guard (and (cst-matchp abnf::cst "for-statement")
                          (equal (cst-for-statement-conc? abnf::cst)
                                 1))))
  (abnf::tree-list-fix (nth 0 (cst-for-statement-conc1 abnf::cst))))

Theorem: tree-listp-of-cst-for-statement-conc1-rep

(defthm tree-listp-of-cst-for-statement-conc1-rep
  (b* ((abnf::csts (cst-for-statement-conc1-rep abnf::cst)))
    (abnf::tree-listp abnf::csts))
  :rule-classes :rewrite)

Theorem: cst-for-statement-conc1-rep-match

(defthm cst-for-statement-conc1-rep-match
 (implies (and (cst-matchp abnf::cst "for-statement")
               (equal (cst-for-statement-conc? abnf::cst)
                      1))
          (b* ((abnf::csts (cst-for-statement-conc1-rep abnf::cst)))
            (cst-list-rep-matchp abnf::csts "basic-for-statement")))
 :rule-classes :rewrite)

Theorem: cst-for-statement-conc1-rep-of-tree-fix-cst

(defthm cst-for-statement-conc1-rep-of-tree-fix-cst
  (equal (cst-for-statement-conc1-rep (abnf::tree-fix abnf::cst))
         (cst-for-statement-conc1-rep abnf::cst)))

Theorem: cst-for-statement-conc1-rep-tree-equiv-congruence-on-cst

(defthm cst-for-statement-conc1-rep-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-for-statement-conc1-rep abnf::cst)
                  (cst-for-statement-conc1-rep cst-equiv)))
  :rule-classes :congruence)

Function: cst-for-statement-conc2-rep

(defun cst-for-statement-conc2-rep (abnf::cst)
  (declare (xargs :guard (abnf::treep abnf::cst)))
  (declare
       (xargs :guard (and (cst-matchp abnf::cst "for-statement")
                          (equal (cst-for-statement-conc? abnf::cst)
                                 2))))
  (abnf::tree-list-fix (nth 0 (cst-for-statement-conc2 abnf::cst))))

Theorem: tree-listp-of-cst-for-statement-conc2-rep

(defthm tree-listp-of-cst-for-statement-conc2-rep
  (b* ((abnf::csts (cst-for-statement-conc2-rep abnf::cst)))
    (abnf::tree-listp abnf::csts))
  :rule-classes :rewrite)

Theorem: cst-for-statement-conc2-rep-match

(defthm cst-for-statement-conc2-rep-match
  (implies
       (and (cst-matchp abnf::cst "for-statement")
            (equal (cst-for-statement-conc? abnf::cst)
                   2))
       (b* ((abnf::csts (cst-for-statement-conc2-rep abnf::cst)))
         (cst-list-rep-matchp abnf::csts "enhanced-for-statement")))
  :rule-classes :rewrite)

Theorem: cst-for-statement-conc2-rep-of-tree-fix-cst

(defthm cst-for-statement-conc2-rep-of-tree-fix-cst
  (equal (cst-for-statement-conc2-rep (abnf::tree-fix abnf::cst))
         (cst-for-statement-conc2-rep abnf::cst)))

Theorem: cst-for-statement-conc2-rep-tree-equiv-congruence-on-cst

(defthm cst-for-statement-conc2-rep-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-for-statement-conc2-rep abnf::cst)
                  (cst-for-statement-conc2-rep cst-equiv)))
  :rule-classes :congruence)

Function: cst-for-statement-no-short-if-conc1-rep

(defun cst-for-statement-no-short-if-conc1-rep (abnf::cst)
 (declare (xargs :guard (abnf::treep abnf::cst)))
 (declare
  (xargs :guard
         (and (cst-matchp abnf::cst "for-statement-no-short-if")
              (equal (cst-for-statement-no-short-if-conc? abnf::cst)
                     1))))
 (abnf::tree-list-fix
      (nth 0
           (cst-for-statement-no-short-if-conc1 abnf::cst))))

Theorem: tree-listp-of-cst-for-statement-no-short-if-conc1-rep

(defthm tree-listp-of-cst-for-statement-no-short-if-conc1-rep
 (b*
  ((abnf::csts (cst-for-statement-no-short-if-conc1-rep abnf::cst)))
  (abnf::tree-listp abnf::csts))
 :rule-classes :rewrite)

Theorem: cst-for-statement-no-short-if-conc1-rep-match

(defthm cst-for-statement-no-short-if-conc1-rep-match
 (implies
     (and (cst-matchp abnf::cst "for-statement-no-short-if")
          (equal (cst-for-statement-no-short-if-conc? abnf::cst)
                 1))
     (b* ((abnf::csts
               (cst-for-statement-no-short-if-conc1-rep abnf::cst)))
       (cst-list-rep-matchp abnf::csts
                            "basic-for-statement-no-short-if")))
 :rule-classes :rewrite)

Theorem: cst-for-statement-no-short-if-conc1-rep-of-tree-fix-cst

(defthm cst-for-statement-no-short-if-conc1-rep-of-tree-fix-cst
  (equal (cst-for-statement-no-short-if-conc1-rep
              (abnf::tree-fix abnf::cst))
         (cst-for-statement-no-short-if-conc1-rep abnf::cst)))

Theorem: cst-for-statement-no-short-if-conc1-rep-tree-equiv-congruence-on-cst

(defthm
 cst-for-statement-no-short-if-conc1-rep-tree-equiv-congruence-on-cst
 (implies
      (abnf::tree-equiv abnf::cst cst-equiv)
      (equal (cst-for-statement-no-short-if-conc1-rep abnf::cst)
             (cst-for-statement-no-short-if-conc1-rep cst-equiv)))
 :rule-classes :congruence)

Function: cst-for-statement-no-short-if-conc2-rep

(defun cst-for-statement-no-short-if-conc2-rep (abnf::cst)
 (declare (xargs :guard (abnf::treep abnf::cst)))
 (declare
  (xargs :guard
         (and (cst-matchp abnf::cst "for-statement-no-short-if")
              (equal (cst-for-statement-no-short-if-conc? abnf::cst)
                     2))))
 (abnf::tree-list-fix
      (nth 0
           (cst-for-statement-no-short-if-conc2 abnf::cst))))

Theorem: tree-listp-of-cst-for-statement-no-short-if-conc2-rep

(defthm tree-listp-of-cst-for-statement-no-short-if-conc2-rep
 (b*
  ((abnf::csts (cst-for-statement-no-short-if-conc2-rep abnf::cst)))
  (abnf::tree-listp abnf::csts))
 :rule-classes :rewrite)

Theorem: cst-for-statement-no-short-if-conc2-rep-match

(defthm cst-for-statement-no-short-if-conc2-rep-match
 (implies
     (and (cst-matchp abnf::cst "for-statement-no-short-if")
          (equal (cst-for-statement-no-short-if-conc? abnf::cst)
                 2))
     (b* ((abnf::csts
               (cst-for-statement-no-short-if-conc2-rep abnf::cst)))
       (cst-list-rep-matchp abnf::csts
                            "enhanced-for-statement-no-short-if")))
 :rule-classes :rewrite)

Theorem: cst-for-statement-no-short-if-conc2-rep-of-tree-fix-cst

(defthm cst-for-statement-no-short-if-conc2-rep-of-tree-fix-cst
  (equal (cst-for-statement-no-short-if-conc2-rep
              (abnf::tree-fix abnf::cst))
         (cst-for-statement-no-short-if-conc2-rep abnf::cst)))

Theorem: cst-for-statement-no-short-if-conc2-rep-tree-equiv-congruence-on-cst

(defthm
 cst-for-statement-no-short-if-conc2-rep-tree-equiv-congruence-on-cst
 (implies
      (abnf::tree-equiv abnf::cst cst-equiv)
      (equal (cst-for-statement-no-short-if-conc2-rep abnf::cst)
             (cst-for-statement-no-short-if-conc2-rep cst-equiv)))
 :rule-classes :congruence)

Function: cst-for-init-conc1-rep

(defun cst-for-init-conc1-rep (abnf::cst)
  (declare (xargs :guard (abnf::treep abnf::cst)))
  (declare (xargs :guard (and (cst-matchp abnf::cst "for-init")
                              (equal (cst-for-init-conc? abnf::cst)
                                     1))))
  (abnf::tree-list-fix (nth 0 (cst-for-init-conc1 abnf::cst))))

Theorem: tree-listp-of-cst-for-init-conc1-rep

(defthm tree-listp-of-cst-for-init-conc1-rep
  (b* ((abnf::csts (cst-for-init-conc1-rep abnf::cst)))
    (abnf::tree-listp abnf::csts))
  :rule-classes :rewrite)

Theorem: cst-for-init-conc1-rep-match

(defthm cst-for-init-conc1-rep-match
  (implies (and (cst-matchp abnf::cst "for-init")
                (equal (cst-for-init-conc? abnf::cst)
                       1))
           (b* ((abnf::csts (cst-for-init-conc1-rep abnf::cst)))
             (cst-list-rep-matchp abnf::csts
                                  "statement-expression-list")))
  :rule-classes :rewrite)

Theorem: cst-for-init-conc1-rep-of-tree-fix-cst

(defthm cst-for-init-conc1-rep-of-tree-fix-cst
  (equal (cst-for-init-conc1-rep (abnf::tree-fix abnf::cst))
         (cst-for-init-conc1-rep abnf::cst)))

Theorem: cst-for-init-conc1-rep-tree-equiv-congruence-on-cst

(defthm cst-for-init-conc1-rep-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-for-init-conc1-rep abnf::cst)
                  (cst-for-init-conc1-rep cst-equiv)))
  :rule-classes :congruence)

Function: cst-for-init-conc2-rep

(defun cst-for-init-conc2-rep (abnf::cst)
  (declare (xargs :guard (abnf::treep abnf::cst)))
  (declare (xargs :guard (and (cst-matchp abnf::cst "for-init")
                              (equal (cst-for-init-conc? abnf::cst)
                                     2))))
  (abnf::tree-list-fix (nth 0 (cst-for-init-conc2 abnf::cst))))

Theorem: tree-listp-of-cst-for-init-conc2-rep

(defthm tree-listp-of-cst-for-init-conc2-rep
  (b* ((abnf::csts (cst-for-init-conc2-rep abnf::cst)))
    (abnf::tree-listp abnf::csts))
  :rule-classes :rewrite)

Theorem: cst-for-init-conc2-rep-match

(defthm cst-for-init-conc2-rep-match
  (implies (and (cst-matchp abnf::cst "for-init")
                (equal (cst-for-init-conc? abnf::cst)
                       2))
           (b* ((abnf::csts (cst-for-init-conc2-rep abnf::cst)))
             (cst-list-rep-matchp abnf::csts
                                  "local-variable-declaration")))
  :rule-classes :rewrite)

Theorem: cst-for-init-conc2-rep-of-tree-fix-cst

(defthm cst-for-init-conc2-rep-of-tree-fix-cst
  (equal (cst-for-init-conc2-rep (abnf::tree-fix abnf::cst))
         (cst-for-init-conc2-rep abnf::cst)))

Theorem: cst-for-init-conc2-rep-tree-equiv-congruence-on-cst

(defthm cst-for-init-conc2-rep-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-for-init-conc2-rep abnf::cst)
                  (cst-for-init-conc2-rep cst-equiv)))
  :rule-classes :congruence)

Function: cst-for-update-conc-rep

(defun cst-for-update-conc-rep (abnf::cst)
  (declare (xargs :guard (abnf::treep abnf::cst)))
  (declare (xargs :guard (cst-matchp abnf::cst "for-update")))
  (abnf::tree-list-fix (nth 0 (cst-for-update-conc abnf::cst))))

Theorem: tree-listp-of-cst-for-update-conc-rep

(defthm tree-listp-of-cst-for-update-conc-rep
  (b* ((abnf::csts (cst-for-update-conc-rep abnf::cst)))
    (abnf::tree-listp abnf::csts))
  :rule-classes :rewrite)

Theorem: cst-for-update-conc-rep-match

(defthm cst-for-update-conc-rep-match
  (implies (cst-matchp abnf::cst "for-update")
           (b* ((abnf::csts (cst-for-update-conc-rep abnf::cst)))
             (cst-list-rep-matchp abnf::csts
                                  "statement-expression-list")))
  :rule-classes :rewrite)

Theorem: cst-for-update-conc-rep-of-tree-fix-cst

(defthm cst-for-update-conc-rep-of-tree-fix-cst
  (equal (cst-for-update-conc-rep (abnf::tree-fix abnf::cst))
         (cst-for-update-conc-rep abnf::cst)))

Theorem: cst-for-update-conc-rep-tree-equiv-congruence-on-cst

(defthm cst-for-update-conc-rep-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-for-update-conc-rep abnf::cst)
                  (cst-for-update-conc-rep cst-equiv)))
  :rule-classes :congruence)

Function: cst-resource-conc1-rep

(defun cst-resource-conc1-rep (abnf::cst)
  (declare (xargs :guard (abnf::treep abnf::cst)))
  (declare (xargs :guard (and (cst-matchp abnf::cst "resource")
                              (equal (cst-resource-conc? abnf::cst)
                                     1))))
  (abnf::tree-list-fix (nth 0 (cst-resource-conc1 abnf::cst))))

Theorem: tree-listp-of-cst-resource-conc1-rep

(defthm tree-listp-of-cst-resource-conc1-rep
  (b* ((abnf::csts (cst-resource-conc1-rep abnf::cst)))
    (abnf::tree-listp abnf::csts))
  :rule-classes :rewrite)

Theorem: cst-resource-conc1-rep-match

(defthm cst-resource-conc1-rep-match
  (implies (and (cst-matchp abnf::cst "resource")
                (equal (cst-resource-conc? abnf::cst)
                       1))
           (b* ((abnf::csts (cst-resource-conc1-rep abnf::cst)))
             (cst-list-rep-matchp abnf::csts
                                  "local-variable-declaration")))
  :rule-classes :rewrite)

Theorem: cst-resource-conc1-rep-of-tree-fix-cst

(defthm cst-resource-conc1-rep-of-tree-fix-cst
  (equal (cst-resource-conc1-rep (abnf::tree-fix abnf::cst))
         (cst-resource-conc1-rep abnf::cst)))

Theorem: cst-resource-conc1-rep-tree-equiv-congruence-on-cst

(defthm cst-resource-conc1-rep-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-resource-conc1-rep abnf::cst)
                  (cst-resource-conc1-rep cst-equiv)))
  :rule-classes :congruence)

Function: cst-resource-conc2-rep

(defun cst-resource-conc2-rep (abnf::cst)
  (declare (xargs :guard (abnf::treep abnf::cst)))
  (declare (xargs :guard (and (cst-matchp abnf::cst "resource")
                              (equal (cst-resource-conc? abnf::cst)
                                     2))))
  (abnf::tree-list-fix (nth 0 (cst-resource-conc2 abnf::cst))))

Theorem: tree-listp-of-cst-resource-conc2-rep

(defthm tree-listp-of-cst-resource-conc2-rep
  (b* ((abnf::csts (cst-resource-conc2-rep abnf::cst)))
    (abnf::tree-listp abnf::csts))
  :rule-classes :rewrite)

Theorem: cst-resource-conc2-rep-match

(defthm cst-resource-conc2-rep-match
  (implies (and (cst-matchp abnf::cst "resource")
                (equal (cst-resource-conc? abnf::cst)
                       2))
           (b* ((abnf::csts (cst-resource-conc2-rep abnf::cst)))
             (cst-list-rep-matchp abnf::csts "variable-access")))
  :rule-classes :rewrite)

Theorem: cst-resource-conc2-rep-of-tree-fix-cst

(defthm cst-resource-conc2-rep-of-tree-fix-cst
  (equal (cst-resource-conc2-rep (abnf::tree-fix abnf::cst))
         (cst-resource-conc2-rep abnf::cst)))

Theorem: cst-resource-conc2-rep-tree-equiv-congruence-on-cst

(defthm cst-resource-conc2-rep-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-resource-conc2-rep abnf::cst)
                  (cst-resource-conc2-rep cst-equiv)))
  :rule-classes :congruence)

Function: cst-variable-access-conc1-rep

(defun cst-variable-access-conc1-rep (abnf::cst)
 (declare (xargs :guard (abnf::treep abnf::cst)))
 (declare
     (xargs :guard (and (cst-matchp abnf::cst "variable-access")
                        (equal (cst-variable-access-conc? abnf::cst)
                               1))))
 (abnf::tree-list-fix (nth 0
                           (cst-variable-access-conc1 abnf::cst))))

Theorem: tree-listp-of-cst-variable-access-conc1-rep

(defthm tree-listp-of-cst-variable-access-conc1-rep
  (b* ((abnf::csts (cst-variable-access-conc1-rep abnf::cst)))
    (abnf::tree-listp abnf::csts))
  :rule-classes :rewrite)

Theorem: cst-variable-access-conc1-rep-match

(defthm cst-variable-access-conc1-rep-match
  (implies
       (and (cst-matchp abnf::cst "variable-access")
            (equal (cst-variable-access-conc? abnf::cst)
                   1))
       (b* ((abnf::csts (cst-variable-access-conc1-rep abnf::cst)))
         (cst-list-rep-matchp abnf::csts "expression-name")))
  :rule-classes :rewrite)

Theorem: cst-variable-access-conc1-rep-of-tree-fix-cst

(defthm cst-variable-access-conc1-rep-of-tree-fix-cst
  (equal (cst-variable-access-conc1-rep (abnf::tree-fix abnf::cst))
         (cst-variable-access-conc1-rep abnf::cst)))

Theorem: cst-variable-access-conc1-rep-tree-equiv-congruence-on-cst

(defthm cst-variable-access-conc1-rep-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-variable-access-conc1-rep abnf::cst)
                  (cst-variable-access-conc1-rep cst-equiv)))
  :rule-classes :congruence)

Function: cst-variable-access-conc2-rep

(defun cst-variable-access-conc2-rep (abnf::cst)
 (declare (xargs :guard (abnf::treep abnf::cst)))
 (declare
     (xargs :guard (and (cst-matchp abnf::cst "variable-access")
                        (equal (cst-variable-access-conc? abnf::cst)
                               2))))
 (abnf::tree-list-fix (nth 0
                           (cst-variable-access-conc2 abnf::cst))))

Theorem: tree-listp-of-cst-variable-access-conc2-rep

(defthm tree-listp-of-cst-variable-access-conc2-rep
  (b* ((abnf::csts (cst-variable-access-conc2-rep abnf::cst)))
    (abnf::tree-listp abnf::csts))
  :rule-classes :rewrite)

Theorem: cst-variable-access-conc2-rep-match

(defthm cst-variable-access-conc2-rep-match
  (implies
       (and (cst-matchp abnf::cst "variable-access")
            (equal (cst-variable-access-conc? abnf::cst)
                   2))
       (b* ((abnf::csts (cst-variable-access-conc2-rep abnf::cst)))
         (cst-list-rep-matchp abnf::csts "field-access")))
  :rule-classes :rewrite)

Theorem: cst-variable-access-conc2-rep-of-tree-fix-cst

(defthm cst-variable-access-conc2-rep-of-tree-fix-cst
  (equal (cst-variable-access-conc2-rep (abnf::tree-fix abnf::cst))
         (cst-variable-access-conc2-rep abnf::cst)))

Theorem: cst-variable-access-conc2-rep-tree-equiv-congruence-on-cst

(defthm cst-variable-access-conc2-rep-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-variable-access-conc2-rep abnf::cst)
                  (cst-variable-access-conc2-rep cst-equiv)))
  :rule-classes :congruence)

Function: cst-pattern-conc1-rep

(defun cst-pattern-conc1-rep (abnf::cst)
  (declare (xargs :guard (abnf::treep abnf::cst)))
  (declare (xargs :guard (and (cst-matchp abnf::cst "pattern")
                              (equal (cst-pattern-conc? abnf::cst)
                                     1))))
  (abnf::tree-list-fix (nth 0 (cst-pattern-conc1 abnf::cst))))

Theorem: tree-listp-of-cst-pattern-conc1-rep

(defthm tree-listp-of-cst-pattern-conc1-rep
  (b* ((abnf::csts (cst-pattern-conc1-rep abnf::cst)))
    (abnf::tree-listp abnf::csts))
  :rule-classes :rewrite)

Theorem: cst-pattern-conc1-rep-match

(defthm cst-pattern-conc1-rep-match
  (implies (and (cst-matchp abnf::cst "pattern")
                (equal (cst-pattern-conc? abnf::cst) 1))
           (b* ((abnf::csts (cst-pattern-conc1-rep abnf::cst)))
             (cst-list-rep-matchp abnf::csts "type-pattern")))
  :rule-classes :rewrite)

Theorem: cst-pattern-conc1-rep-of-tree-fix-cst

(defthm cst-pattern-conc1-rep-of-tree-fix-cst
  (equal (cst-pattern-conc1-rep (abnf::tree-fix abnf::cst))
         (cst-pattern-conc1-rep abnf::cst)))

Theorem: cst-pattern-conc1-rep-tree-equiv-congruence-on-cst

(defthm cst-pattern-conc1-rep-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-pattern-conc1-rep abnf::cst)
                  (cst-pattern-conc1-rep cst-equiv)))
  :rule-classes :congruence)

Function: cst-pattern-conc2-rep

(defun cst-pattern-conc2-rep (abnf::cst)
  (declare (xargs :guard (abnf::treep abnf::cst)))
  (declare (xargs :guard (and (cst-matchp abnf::cst "pattern")
                              (equal (cst-pattern-conc? abnf::cst)
                                     2))))
  (abnf::tree-list-fix (nth 0 (cst-pattern-conc2 abnf::cst))))

Theorem: tree-listp-of-cst-pattern-conc2-rep

(defthm tree-listp-of-cst-pattern-conc2-rep
  (b* ((abnf::csts (cst-pattern-conc2-rep abnf::cst)))
    (abnf::tree-listp abnf::csts))
  :rule-classes :rewrite)

Theorem: cst-pattern-conc2-rep-match

(defthm cst-pattern-conc2-rep-match
  (implies (and (cst-matchp abnf::cst "pattern")
                (equal (cst-pattern-conc? abnf::cst) 2))
           (b* ((abnf::csts (cst-pattern-conc2-rep abnf::cst)))
             (cst-list-rep-matchp abnf::csts "record-pattern")))
  :rule-classes :rewrite)

Theorem: cst-pattern-conc2-rep-of-tree-fix-cst

(defthm cst-pattern-conc2-rep-of-tree-fix-cst
  (equal (cst-pattern-conc2-rep (abnf::tree-fix abnf::cst))
         (cst-pattern-conc2-rep abnf::cst)))

Theorem: cst-pattern-conc2-rep-tree-equiv-congruence-on-cst

(defthm cst-pattern-conc2-rep-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-pattern-conc2-rep abnf::cst)
                  (cst-pattern-conc2-rep cst-equiv)))
  :rule-classes :congruence)

Function: cst-type-pattern-conc-rep

(defun cst-type-pattern-conc-rep (abnf::cst)
  (declare (xargs :guard (abnf::treep abnf::cst)))
  (declare (xargs :guard (cst-matchp abnf::cst "type-pattern")))
  (abnf::tree-list-fix (nth 0 (cst-type-pattern-conc abnf::cst))))

Theorem: tree-listp-of-cst-type-pattern-conc-rep

(defthm tree-listp-of-cst-type-pattern-conc-rep
  (b* ((abnf::csts (cst-type-pattern-conc-rep abnf::cst)))
    (abnf::tree-listp abnf::csts))
  :rule-classes :rewrite)

Theorem: cst-type-pattern-conc-rep-match

(defthm cst-type-pattern-conc-rep-match
  (implies (cst-matchp abnf::cst "type-pattern")
           (b* ((abnf::csts (cst-type-pattern-conc-rep abnf::cst)))
             (cst-list-rep-matchp abnf::csts
                                  "local-variable-declaration")))
  :rule-classes :rewrite)

Theorem: cst-type-pattern-conc-rep-of-tree-fix-cst

(defthm cst-type-pattern-conc-rep-of-tree-fix-cst
  (equal (cst-type-pattern-conc-rep (abnf::tree-fix abnf::cst))
         (cst-type-pattern-conc-rep abnf::cst)))

Theorem: cst-type-pattern-conc-rep-tree-equiv-congruence-on-cst

(defthm cst-type-pattern-conc-rep-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-type-pattern-conc-rep abnf::cst)
                  (cst-type-pattern-conc-rep cst-equiv)))
  :rule-classes :congruence)

Function: cst-component-pattern-conc1-rep

(defun cst-component-pattern-conc1-rep (abnf::cst)
 (declare (xargs :guard (abnf::treep abnf::cst)))
 (declare
   (xargs :guard (and (cst-matchp abnf::cst "component-pattern")
                      (equal (cst-component-pattern-conc? abnf::cst)
                             1))))
 (abnf::tree-list-fix
      (nth 0
           (cst-component-pattern-conc1 abnf::cst))))

Theorem: tree-listp-of-cst-component-pattern-conc1-rep

(defthm tree-listp-of-cst-component-pattern-conc1-rep
  (b* ((abnf::csts (cst-component-pattern-conc1-rep abnf::cst)))
    (abnf::tree-listp abnf::csts))
  :rule-classes :rewrite)

Theorem: cst-component-pattern-conc1-rep-match

(defthm cst-component-pattern-conc1-rep-match
 (implies
      (and (cst-matchp abnf::cst "component-pattern")
           (equal (cst-component-pattern-conc? abnf::cst)
                  1))
      (b* ((abnf::csts (cst-component-pattern-conc1-rep abnf::cst)))
        (cst-list-rep-matchp abnf::csts "pattern")))
 :rule-classes :rewrite)

Theorem: cst-component-pattern-conc1-rep-of-tree-fix-cst

(defthm cst-component-pattern-conc1-rep-of-tree-fix-cst
 (equal (cst-component-pattern-conc1-rep (abnf::tree-fix abnf::cst))
        (cst-component-pattern-conc1-rep abnf::cst)))

Theorem: cst-component-pattern-conc1-rep-tree-equiv-congruence-on-cst

(defthm cst-component-pattern-conc1-rep-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-component-pattern-conc1-rep abnf::cst)
                  (cst-component-pattern-conc1-rep cst-equiv)))
  :rule-classes :congruence)

Function: cst-component-pattern-conc2-rep

(defun cst-component-pattern-conc2-rep (abnf::cst)
 (declare (xargs :guard (abnf::treep abnf::cst)))
 (declare
   (xargs :guard (and (cst-matchp abnf::cst "component-pattern")
                      (equal (cst-component-pattern-conc? abnf::cst)
                             2))))
 (abnf::tree-list-fix
      (nth 0
           (cst-component-pattern-conc2 abnf::cst))))

Theorem: tree-listp-of-cst-component-pattern-conc2-rep

(defthm tree-listp-of-cst-component-pattern-conc2-rep
  (b* ((abnf::csts (cst-component-pattern-conc2-rep abnf::cst)))
    (abnf::tree-listp abnf::csts))
  :rule-classes :rewrite)

Theorem: cst-component-pattern-conc2-rep-match

(defthm cst-component-pattern-conc2-rep-match
 (implies
      (and (cst-matchp abnf::cst "component-pattern")
           (equal (cst-component-pattern-conc? abnf::cst)
                  2))
      (b* ((abnf::csts (cst-component-pattern-conc2-rep abnf::cst)))
        (cst-list-rep-matchp abnf::csts "match-all-pattern")))
 :rule-classes :rewrite)

Theorem: cst-component-pattern-conc2-rep-of-tree-fix-cst

(defthm cst-component-pattern-conc2-rep-of-tree-fix-cst
 (equal (cst-component-pattern-conc2-rep (abnf::tree-fix abnf::cst))
        (cst-component-pattern-conc2-rep abnf::cst)))

Theorem: cst-component-pattern-conc2-rep-tree-equiv-congruence-on-cst

(defthm cst-component-pattern-conc2-rep-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-component-pattern-conc2-rep abnf::cst)
                  (cst-component-pattern-conc2-rep cst-equiv)))
  :rule-classes :congruence)

Function: cst-match-all-pattern-conc-rep

(defun cst-match-all-pattern-conc-rep (abnf::cst)
 (declare (xargs :guard (abnf::treep abnf::cst)))
 (declare (xargs :guard (cst-matchp abnf::cst "match-all-pattern")))
 (abnf::tree-list-fix (nth 0
                           (cst-match-all-pattern-conc abnf::cst))))

Theorem: tree-listp-of-cst-match-all-pattern-conc-rep

(defthm tree-listp-of-cst-match-all-pattern-conc-rep
  (b* ((abnf::csts (cst-match-all-pattern-conc-rep abnf::cst)))
    (abnf::tree-listp abnf::csts))
  :rule-classes :rewrite)

Theorem: cst-match-all-pattern-conc-rep-match

(defthm cst-match-all-pattern-conc-rep-match
  (implies
       (cst-matchp abnf::cst "match-all-pattern")
       (b* ((abnf::csts (cst-match-all-pattern-conc-rep abnf::cst)))
         (cst-list-rep-matchp abnf::csts "\"_\"")))
  :rule-classes :rewrite)

Theorem: cst-match-all-pattern-conc-rep-of-tree-fix-cst

(defthm cst-match-all-pattern-conc-rep-of-tree-fix-cst
  (equal (cst-match-all-pattern-conc-rep (abnf::tree-fix abnf::cst))
         (cst-match-all-pattern-conc-rep abnf::cst)))

Theorem: cst-match-all-pattern-conc-rep-tree-equiv-congruence-on-cst

(defthm cst-match-all-pattern-conc-rep-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-match-all-pattern-conc-rep abnf::cst)
                  (cst-match-all-pattern-conc-rep cst-equiv)))
  :rule-classes :congruence)

Function: cst-expression-conc1-rep

(defun cst-expression-conc1-rep (abnf::cst)
 (declare (xargs :guard (abnf::treep abnf::cst)))
 (declare (xargs :guard (and (cst-matchp abnf::cst "expression")
                             (equal (cst-expression-conc? abnf::cst)
                                    1))))
 (abnf::tree-list-fix (nth 0 (cst-expression-conc1 abnf::cst))))

Theorem: tree-listp-of-cst-expression-conc1-rep

(defthm tree-listp-of-cst-expression-conc1-rep
  (b* ((abnf::csts (cst-expression-conc1-rep abnf::cst)))
    (abnf::tree-listp abnf::csts))
  :rule-classes :rewrite)

Theorem: cst-expression-conc1-rep-match

(defthm cst-expression-conc1-rep-match
  (implies (and (cst-matchp abnf::cst "expression")
                (equal (cst-expression-conc? abnf::cst)
                       1))
           (b* ((abnf::csts (cst-expression-conc1-rep abnf::cst)))
             (cst-list-rep-matchp abnf::csts "lambda-expression")))
  :rule-classes :rewrite)

Theorem: cst-expression-conc1-rep-of-tree-fix-cst

(defthm cst-expression-conc1-rep-of-tree-fix-cst
  (equal (cst-expression-conc1-rep (abnf::tree-fix abnf::cst))
         (cst-expression-conc1-rep abnf::cst)))

Theorem: cst-expression-conc1-rep-tree-equiv-congruence-on-cst

(defthm cst-expression-conc1-rep-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-expression-conc1-rep abnf::cst)
                  (cst-expression-conc1-rep cst-equiv)))
  :rule-classes :congruence)

Function: cst-expression-conc2-rep

(defun cst-expression-conc2-rep (abnf::cst)
 (declare (xargs :guard (abnf::treep abnf::cst)))
 (declare (xargs :guard (and (cst-matchp abnf::cst "expression")
                             (equal (cst-expression-conc? abnf::cst)
                                    2))))
 (abnf::tree-list-fix (nth 0 (cst-expression-conc2 abnf::cst))))

Theorem: tree-listp-of-cst-expression-conc2-rep

(defthm tree-listp-of-cst-expression-conc2-rep
  (b* ((abnf::csts (cst-expression-conc2-rep abnf::cst)))
    (abnf::tree-listp abnf::csts))
  :rule-classes :rewrite)

Theorem: cst-expression-conc2-rep-match

(defthm cst-expression-conc2-rep-match
  (implies
       (and (cst-matchp abnf::cst "expression")
            (equal (cst-expression-conc? abnf::cst)
                   2))
       (b* ((abnf::csts (cst-expression-conc2-rep abnf::cst)))
         (cst-list-rep-matchp abnf::csts "assignment-expression")))
  :rule-classes :rewrite)

Theorem: cst-expression-conc2-rep-of-tree-fix-cst

(defthm cst-expression-conc2-rep-of-tree-fix-cst
  (equal (cst-expression-conc2-rep (abnf::tree-fix abnf::cst))
         (cst-expression-conc2-rep abnf::cst)))

Theorem: cst-expression-conc2-rep-tree-equiv-congruence-on-cst

(defthm cst-expression-conc2-rep-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-expression-conc2-rep abnf::cst)
                  (cst-expression-conc2-rep cst-equiv)))
  :rule-classes :congruence)

Function: cst-primary-conc1-rep

(defun cst-primary-conc1-rep (abnf::cst)
  (declare (xargs :guard (abnf::treep abnf::cst)))
  (declare (xargs :guard (and (cst-matchp abnf::cst "primary")
                              (equal (cst-primary-conc? abnf::cst)
                                     1))))
  (abnf::tree-list-fix (nth 0 (cst-primary-conc1 abnf::cst))))

Theorem: tree-listp-of-cst-primary-conc1-rep

(defthm tree-listp-of-cst-primary-conc1-rep
  (b* ((abnf::csts (cst-primary-conc1-rep abnf::cst)))
    (abnf::tree-listp abnf::csts))
  :rule-classes :rewrite)

Theorem: cst-primary-conc1-rep-match

(defthm cst-primary-conc1-rep-match
  (implies
       (and (cst-matchp abnf::cst "primary")
            (equal (cst-primary-conc? abnf::cst) 1))
       (b* ((abnf::csts (cst-primary-conc1-rep abnf::cst)))
         (cst-list-rep-matchp abnf::csts "primary-no-new-array")))
  :rule-classes :rewrite)

Theorem: cst-primary-conc1-rep-of-tree-fix-cst

(defthm cst-primary-conc1-rep-of-tree-fix-cst
  (equal (cst-primary-conc1-rep (abnf::tree-fix abnf::cst))
         (cst-primary-conc1-rep abnf::cst)))

Theorem: cst-primary-conc1-rep-tree-equiv-congruence-on-cst

(defthm cst-primary-conc1-rep-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-primary-conc1-rep abnf::cst)
                  (cst-primary-conc1-rep cst-equiv)))
  :rule-classes :congruence)

Function: cst-primary-conc2-rep

(defun cst-primary-conc2-rep (abnf::cst)
  (declare (xargs :guard (abnf::treep abnf::cst)))
  (declare (xargs :guard (and (cst-matchp abnf::cst "primary")
                              (equal (cst-primary-conc? abnf::cst)
                                     2))))
  (abnf::tree-list-fix (nth 0 (cst-primary-conc2 abnf::cst))))

Theorem: tree-listp-of-cst-primary-conc2-rep

(defthm tree-listp-of-cst-primary-conc2-rep
  (b* ((abnf::csts (cst-primary-conc2-rep abnf::cst)))
    (abnf::tree-listp abnf::csts))
  :rule-classes :rewrite)

Theorem: cst-primary-conc2-rep-match

(defthm cst-primary-conc2-rep-match
  (implies (and (cst-matchp abnf::cst "primary")
                (equal (cst-primary-conc? abnf::cst) 2))
           (b* ((abnf::csts (cst-primary-conc2-rep abnf::cst)))
             (cst-list-rep-matchp abnf::csts
                                  "array-creation-expression")))
  :rule-classes :rewrite)

Theorem: cst-primary-conc2-rep-of-tree-fix-cst

(defthm cst-primary-conc2-rep-of-tree-fix-cst
  (equal (cst-primary-conc2-rep (abnf::tree-fix abnf::cst))
         (cst-primary-conc2-rep abnf::cst)))

Theorem: cst-primary-conc2-rep-tree-equiv-congruence-on-cst

(defthm cst-primary-conc2-rep-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-primary-conc2-rep abnf::cst)
                  (cst-primary-conc2-rep cst-equiv)))
  :rule-classes :congruence)

Function: cst-array-creation-expression-conc1-rep

(defun cst-array-creation-expression-conc1-rep (abnf::cst)
 (declare (xargs :guard (abnf::treep abnf::cst)))
 (declare
  (xargs :guard
         (and (cst-matchp abnf::cst "array-creation-expression")
              (equal (cst-array-creation-expression-conc? abnf::cst)
                     1))))
 (abnf::tree-list-fix
      (nth 0
           (cst-array-creation-expression-conc1 abnf::cst))))

Theorem: tree-listp-of-cst-array-creation-expression-conc1-rep

(defthm tree-listp-of-cst-array-creation-expression-conc1-rep
 (b*
  ((abnf::csts (cst-array-creation-expression-conc1-rep abnf::cst)))
  (abnf::tree-listp abnf::csts))
 :rule-classes :rewrite)

Theorem: cst-array-creation-expression-conc1-rep-match

(defthm cst-array-creation-expression-conc1-rep-match
 (implies
     (and (cst-matchp abnf::cst "array-creation-expression")
          (equal (cst-array-creation-expression-conc? abnf::cst)
                 1))
     (b* ((abnf::csts
               (cst-array-creation-expression-conc1-rep abnf::cst)))
       (cst-list-rep-matchp
            abnf::csts
            "array-creation-expression-without-initializer")))
 :rule-classes :rewrite)

Theorem: cst-array-creation-expression-conc1-rep-of-tree-fix-cst

(defthm cst-array-creation-expression-conc1-rep-of-tree-fix-cst
  (equal (cst-array-creation-expression-conc1-rep
              (abnf::tree-fix abnf::cst))
         (cst-array-creation-expression-conc1-rep abnf::cst)))

Theorem: cst-array-creation-expression-conc1-rep-tree-equiv-congruence-on-cst

(defthm
 cst-array-creation-expression-conc1-rep-tree-equiv-congruence-on-cst
 (implies
      (abnf::tree-equiv abnf::cst cst-equiv)
      (equal (cst-array-creation-expression-conc1-rep abnf::cst)
             (cst-array-creation-expression-conc1-rep cst-equiv)))
 :rule-classes :congruence)

Function: cst-array-creation-expression-conc2-rep

(defun cst-array-creation-expression-conc2-rep (abnf::cst)
 (declare (xargs :guard (abnf::treep abnf::cst)))
 (declare
  (xargs :guard
         (and (cst-matchp abnf::cst "array-creation-expression")
              (equal (cst-array-creation-expression-conc? abnf::cst)
                     2))))
 (abnf::tree-list-fix
      (nth 0
           (cst-array-creation-expression-conc2 abnf::cst))))

Theorem: tree-listp-of-cst-array-creation-expression-conc2-rep

(defthm tree-listp-of-cst-array-creation-expression-conc2-rep
 (b*
  ((abnf::csts (cst-array-creation-expression-conc2-rep abnf::cst)))
  (abnf::tree-listp abnf::csts))
 :rule-classes :rewrite)

Theorem: cst-array-creation-expression-conc2-rep-match

(defthm cst-array-creation-expression-conc2-rep-match
 (implies
     (and (cst-matchp abnf::cst "array-creation-expression")
          (equal (cst-array-creation-expression-conc? abnf::cst)
                 2))
     (b* ((abnf::csts
               (cst-array-creation-expression-conc2-rep abnf::cst)))
       (cst-list-rep-matchp
            abnf::csts
            "array-creation-expression-with-initializer")))
 :rule-classes :rewrite)

Theorem: cst-array-creation-expression-conc2-rep-of-tree-fix-cst

(defthm cst-array-creation-expression-conc2-rep-of-tree-fix-cst
  (equal (cst-array-creation-expression-conc2-rep
              (abnf::tree-fix abnf::cst))
         (cst-array-creation-expression-conc2-rep abnf::cst)))

Theorem: cst-array-creation-expression-conc2-rep-tree-equiv-congruence-on-cst

(defthm
 cst-array-creation-expression-conc2-rep-tree-equiv-congruence-on-cst
 (implies
      (abnf::tree-equiv abnf::cst cst-equiv)
      (equal (cst-array-creation-expression-conc2-rep abnf::cst)
             (cst-array-creation-expression-conc2-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))))
 (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")))
 :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))))
 (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 "expression-name")))
 :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))))
 (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
                            "post-increment-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))))
 (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
                            "post-decrement-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-assignment-expression-conc1-rep

(defun cst-assignment-expression-conc1-rep (abnf::cst)
 (declare (xargs :guard (abnf::treep abnf::cst)))
 (declare
  (xargs
      :guard (and (cst-matchp abnf::cst "assignment-expression")
                  (equal (cst-assignment-expression-conc? abnf::cst)
                         1))))
 (abnf::tree-list-fix
      (nth 0
           (cst-assignment-expression-conc1 abnf::cst))))

Theorem: tree-listp-of-cst-assignment-expression-conc1-rep

(defthm tree-listp-of-cst-assignment-expression-conc1-rep
  (b* ((abnf::csts (cst-assignment-expression-conc1-rep abnf::cst)))
    (abnf::tree-listp abnf::csts))
  :rule-classes :rewrite)

Theorem: cst-assignment-expression-conc1-rep-match

(defthm cst-assignment-expression-conc1-rep-match
 (implies
  (and (cst-matchp abnf::cst "assignment-expression")
       (equal (cst-assignment-expression-conc? abnf::cst)
              1))
  (b* ((abnf::csts (cst-assignment-expression-conc1-rep abnf::cst)))
    (cst-list-rep-matchp abnf::csts "conditional-expression")))
 :rule-classes :rewrite)

Theorem: cst-assignment-expression-conc1-rep-of-tree-fix-cst

(defthm cst-assignment-expression-conc1-rep-of-tree-fix-cst
 (equal
    (cst-assignment-expression-conc1-rep (abnf::tree-fix abnf::cst))
    (cst-assignment-expression-conc1-rep abnf::cst)))

Theorem: cst-assignment-expression-conc1-rep-tree-equiv-congruence-on-cst

(defthm
   cst-assignment-expression-conc1-rep-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-assignment-expression-conc1-rep abnf::cst)
                  (cst-assignment-expression-conc1-rep cst-equiv)))
  :rule-classes :congruence)

Function: cst-assignment-expression-conc2-rep

(defun cst-assignment-expression-conc2-rep (abnf::cst)
 (declare (xargs :guard (abnf::treep abnf::cst)))
 (declare
  (xargs
      :guard (and (cst-matchp abnf::cst "assignment-expression")
                  (equal (cst-assignment-expression-conc? abnf::cst)
                         2))))
 (abnf::tree-list-fix
      (nth 0
           (cst-assignment-expression-conc2 abnf::cst))))

Theorem: tree-listp-of-cst-assignment-expression-conc2-rep

(defthm tree-listp-of-cst-assignment-expression-conc2-rep
  (b* ((abnf::csts (cst-assignment-expression-conc2-rep abnf::cst)))
    (abnf::tree-listp abnf::csts))
  :rule-classes :rewrite)

Theorem: cst-assignment-expression-conc2-rep-match

(defthm cst-assignment-expression-conc2-rep-match
 (implies
  (and (cst-matchp abnf::cst "assignment-expression")
       (equal (cst-assignment-expression-conc? abnf::cst)
              2))
  (b* ((abnf::csts (cst-assignment-expression-conc2-rep abnf::cst)))
    (cst-list-rep-matchp abnf::csts "assignment")))
 :rule-classes :rewrite)

Theorem: cst-assignment-expression-conc2-rep-of-tree-fix-cst

(defthm cst-assignment-expression-conc2-rep-of-tree-fix-cst
 (equal
    (cst-assignment-expression-conc2-rep (abnf::tree-fix abnf::cst))
    (cst-assignment-expression-conc2-rep abnf::cst)))

Theorem: cst-assignment-expression-conc2-rep-tree-equiv-congruence-on-cst

(defthm
   cst-assignment-expression-conc2-rep-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-assignment-expression-conc2-rep abnf::cst)
                  (cst-assignment-expression-conc2-rep cst-equiv)))
  :rule-classes :congruence)

Function: cst-left-hand-side-conc1-rep

(defun cst-left-hand-side-conc1-rep (abnf::cst)
 (declare (xargs :guard (abnf::treep abnf::cst)))
 (declare
      (xargs :guard (and (cst-matchp abnf::cst "left-hand-side")
                         (equal (cst-left-hand-side-conc? abnf::cst)
                                1))))
 (abnf::tree-list-fix (nth 0
                           (cst-left-hand-side-conc1 abnf::cst))))

Theorem: tree-listp-of-cst-left-hand-side-conc1-rep

(defthm tree-listp-of-cst-left-hand-side-conc1-rep
  (b* ((abnf::csts (cst-left-hand-side-conc1-rep abnf::cst)))
    (abnf::tree-listp abnf::csts))
  :rule-classes :rewrite)

Theorem: cst-left-hand-side-conc1-rep-match

(defthm cst-left-hand-side-conc1-rep-match
  (implies
       (and (cst-matchp abnf::cst "left-hand-side")
            (equal (cst-left-hand-side-conc? abnf::cst)
                   1))
       (b* ((abnf::csts (cst-left-hand-side-conc1-rep abnf::cst)))
         (cst-list-rep-matchp abnf::csts "expression-name")))
  :rule-classes :rewrite)

Theorem: cst-left-hand-side-conc1-rep-of-tree-fix-cst

(defthm cst-left-hand-side-conc1-rep-of-tree-fix-cst
  (equal (cst-left-hand-side-conc1-rep (abnf::tree-fix abnf::cst))
         (cst-left-hand-side-conc1-rep abnf::cst)))

Theorem: cst-left-hand-side-conc1-rep-tree-equiv-congruence-on-cst

(defthm cst-left-hand-side-conc1-rep-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-left-hand-side-conc1-rep abnf::cst)
                  (cst-left-hand-side-conc1-rep cst-equiv)))
  :rule-classes :congruence)

Function: cst-left-hand-side-conc2-rep

(defun cst-left-hand-side-conc2-rep (abnf::cst)
 (declare (xargs :guard (abnf::treep abnf::cst)))
 (declare
      (xargs :guard (and (cst-matchp abnf::cst "left-hand-side")
                         (equal (cst-left-hand-side-conc? abnf::cst)
                                2))))
 (abnf::tree-list-fix (nth 0
                           (cst-left-hand-side-conc2 abnf::cst))))

Theorem: tree-listp-of-cst-left-hand-side-conc2-rep

(defthm tree-listp-of-cst-left-hand-side-conc2-rep
  (b* ((abnf::csts (cst-left-hand-side-conc2-rep abnf::cst)))
    (abnf::tree-listp abnf::csts))
  :rule-classes :rewrite)

Theorem: cst-left-hand-side-conc2-rep-match

(defthm cst-left-hand-side-conc2-rep-match
  (implies
       (and (cst-matchp abnf::cst "left-hand-side")
            (equal (cst-left-hand-side-conc? abnf::cst)
                   2))
       (b* ((abnf::csts (cst-left-hand-side-conc2-rep abnf::cst)))
         (cst-list-rep-matchp abnf::csts "field-access")))
  :rule-classes :rewrite)

Theorem: cst-left-hand-side-conc2-rep-of-tree-fix-cst

(defthm cst-left-hand-side-conc2-rep-of-tree-fix-cst
  (equal (cst-left-hand-side-conc2-rep (abnf::tree-fix abnf::cst))
         (cst-left-hand-side-conc2-rep abnf::cst)))

Theorem: cst-left-hand-side-conc2-rep-tree-equiv-congruence-on-cst

(defthm cst-left-hand-side-conc2-rep-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-left-hand-side-conc2-rep abnf::cst)
                  (cst-left-hand-side-conc2-rep cst-equiv)))
  :rule-classes :congruence)

Function: cst-left-hand-side-conc3-rep

(defun cst-left-hand-side-conc3-rep (abnf::cst)
 (declare (xargs :guard (abnf::treep abnf::cst)))
 (declare
      (xargs :guard (and (cst-matchp abnf::cst "left-hand-side")
                         (equal (cst-left-hand-side-conc? abnf::cst)
                                3))))
 (abnf::tree-list-fix (nth 0
                           (cst-left-hand-side-conc3 abnf::cst))))

Theorem: tree-listp-of-cst-left-hand-side-conc3-rep

(defthm tree-listp-of-cst-left-hand-side-conc3-rep
  (b* ((abnf::csts (cst-left-hand-side-conc3-rep abnf::cst)))
    (abnf::tree-listp abnf::csts))
  :rule-classes :rewrite)

Theorem: cst-left-hand-side-conc3-rep-match

(defthm cst-left-hand-side-conc3-rep-match
  (implies
       (and (cst-matchp abnf::cst "left-hand-side")
            (equal (cst-left-hand-side-conc? abnf::cst)
                   3))
       (b* ((abnf::csts (cst-left-hand-side-conc3-rep abnf::cst)))
         (cst-list-rep-matchp abnf::csts "array-access")))
  :rule-classes :rewrite)

Theorem: cst-left-hand-side-conc3-rep-of-tree-fix-cst

(defthm cst-left-hand-side-conc3-rep-of-tree-fix-cst
  (equal (cst-left-hand-side-conc3-rep (abnf::tree-fix abnf::cst))
         (cst-left-hand-side-conc3-rep abnf::cst)))

Theorem: cst-left-hand-side-conc3-rep-tree-equiv-congruence-on-cst

(defthm cst-left-hand-side-conc3-rep-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-left-hand-side-conc3-rep abnf::cst)
                  (cst-left-hand-side-conc3-rep cst-equiv)))
  :rule-classes :congruence)

Function: cst-lambda-body-conc1-rep

(defun cst-lambda-body-conc1-rep (abnf::cst)
  (declare (xargs :guard (abnf::treep abnf::cst)))
  (declare
       (xargs :guard (and (cst-matchp abnf::cst "lambda-body")
                          (equal (cst-lambda-body-conc? abnf::cst)
                                 1))))
  (abnf::tree-list-fix (nth 0 (cst-lambda-body-conc1 abnf::cst))))

Theorem: tree-listp-of-cst-lambda-body-conc1-rep

(defthm tree-listp-of-cst-lambda-body-conc1-rep
  (b* ((abnf::csts (cst-lambda-body-conc1-rep abnf::cst)))
    (abnf::tree-listp abnf::csts))
  :rule-classes :rewrite)

Theorem: cst-lambda-body-conc1-rep-match

(defthm cst-lambda-body-conc1-rep-match
  (implies (and (cst-matchp abnf::cst "lambda-body")
                (equal (cst-lambda-body-conc? abnf::cst)
                       1))
           (b* ((abnf::csts (cst-lambda-body-conc1-rep abnf::cst)))
             (cst-list-rep-matchp abnf::csts "expression")))
  :rule-classes :rewrite)

Theorem: cst-lambda-body-conc1-rep-of-tree-fix-cst

(defthm cst-lambda-body-conc1-rep-of-tree-fix-cst
  (equal (cst-lambda-body-conc1-rep (abnf::tree-fix abnf::cst))
         (cst-lambda-body-conc1-rep abnf::cst)))

Theorem: cst-lambda-body-conc1-rep-tree-equiv-congruence-on-cst

(defthm cst-lambda-body-conc1-rep-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-lambda-body-conc1-rep abnf::cst)
                  (cst-lambda-body-conc1-rep cst-equiv)))
  :rule-classes :congruence)

Function: cst-lambda-body-conc2-rep

(defun cst-lambda-body-conc2-rep (abnf::cst)
  (declare (xargs :guard (abnf::treep abnf::cst)))
  (declare
       (xargs :guard (and (cst-matchp abnf::cst "lambda-body")
                          (equal (cst-lambda-body-conc? abnf::cst)
                                 2))))
  (abnf::tree-list-fix (nth 0 (cst-lambda-body-conc2 abnf::cst))))

Theorem: tree-listp-of-cst-lambda-body-conc2-rep

(defthm tree-listp-of-cst-lambda-body-conc2-rep
  (b* ((abnf::csts (cst-lambda-body-conc2-rep abnf::cst)))
    (abnf::tree-listp abnf::csts))
  :rule-classes :rewrite)

Theorem: cst-lambda-body-conc2-rep-match

(defthm cst-lambda-body-conc2-rep-match
  (implies (and (cst-matchp abnf::cst "lambda-body")
                (equal (cst-lambda-body-conc? abnf::cst)
                       2))
           (b* ((abnf::csts (cst-lambda-body-conc2-rep abnf::cst)))
             (cst-list-rep-matchp abnf::csts "block")))
  :rule-classes :rewrite)

Theorem: cst-lambda-body-conc2-rep-of-tree-fix-cst

(defthm cst-lambda-body-conc2-rep-of-tree-fix-cst
  (equal (cst-lambda-body-conc2-rep (abnf::tree-fix abnf::cst))
         (cst-lambda-body-conc2-rep abnf::cst)))

Theorem: cst-lambda-body-conc2-rep-tree-equiv-congruence-on-cst

(defthm cst-lambda-body-conc2-rep-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-lambda-body-conc2-rep abnf::cst)
                  (cst-lambda-body-conc2-rep cst-equiv)))
  :rule-classes :congruence)

Function: cst-unicode-input-character-conc1-rep-elem

(defun cst-unicode-input-character-conc1-rep-elem (abnf::cst)
 (declare (xargs :guard (abnf::treep abnf::cst)))
 (declare
  (xargs
    :guard (and (cst-matchp abnf::cst "unicode-input-character")
                (equal (cst-unicode-input-character-conc? abnf::cst)
                       1))))
 (abnf::tree-fix
      (nth 0
           (cst-unicode-input-character-conc1-rep abnf::cst))))

Theorem: treep-of-cst-unicode-input-character-conc1-rep-elem

(defthm treep-of-cst-unicode-input-character-conc1-rep-elem
  (b* ((abnf::cst1
            (cst-unicode-input-character-conc1-rep-elem abnf::cst)))
    (abnf::treep abnf::cst1))
  :rule-classes :rewrite)

Theorem: cst-unicode-input-character-conc1-rep-elem-match

(defthm cst-unicode-input-character-conc1-rep-elem-match
 (implies
  (and (cst-matchp abnf::cst "unicode-input-character")
       (equal (cst-unicode-input-character-conc? abnf::cst)
              1))
  (b* ((abnf::cst1
            (cst-unicode-input-character-conc1-rep-elem abnf::cst)))
    (cst-matchp abnf::cst1 "unicode-escape")))
 :rule-classes :rewrite)

Theorem: cst-unicode-input-character-conc1-rep-elem-of-tree-fix-cst

(defthm cst-unicode-input-character-conc1-rep-elem-of-tree-fix-cst
  (equal (cst-unicode-input-character-conc1-rep-elem
              (abnf::tree-fix abnf::cst))
         (cst-unicode-input-character-conc1-rep-elem abnf::cst)))

Theorem: cst-unicode-input-character-conc1-rep-elem-tree-equiv-congruence-on-cst

(defthm
 cst-unicode-input-character-conc1-rep-elem-tree-equiv-congruence-on-cst
 (implies
     (abnf::tree-equiv abnf::cst cst-equiv)
     (equal (cst-unicode-input-character-conc1-rep-elem abnf::cst)
            (cst-unicode-input-character-conc1-rep-elem cst-equiv)))
 :rule-classes :congruence)

Function: cst-unicode-input-character-conc2-rep-elem

(defun cst-unicode-input-character-conc2-rep-elem (abnf::cst)
 (declare (xargs :guard (abnf::treep abnf::cst)))
 (declare
  (xargs
    :guard (and (cst-matchp abnf::cst "unicode-input-character")
                (equal (cst-unicode-input-character-conc? abnf::cst)
                       2))))
 (abnf::tree-fix
      (nth 0
           (cst-unicode-input-character-conc2-rep abnf::cst))))

Theorem: treep-of-cst-unicode-input-character-conc2-rep-elem

(defthm treep-of-cst-unicode-input-character-conc2-rep-elem
  (b* ((abnf::cst1
            (cst-unicode-input-character-conc2-rep-elem abnf::cst)))
    (abnf::treep abnf::cst1))
  :rule-classes :rewrite)

Theorem: cst-unicode-input-character-conc2-rep-elem-match

(defthm cst-unicode-input-character-conc2-rep-elem-match
 (implies
  (and (cst-matchp abnf::cst "unicode-input-character")
       (equal (cst-unicode-input-character-conc? abnf::cst)
              2))
  (b* ((abnf::cst1
            (cst-unicode-input-character-conc2-rep-elem abnf::cst)))
    (cst-matchp abnf::cst1 "raw-input-character")))
 :rule-classes :rewrite)

Theorem: cst-unicode-input-character-conc2-rep-elem-of-tree-fix-cst

(defthm cst-unicode-input-character-conc2-rep-elem-of-tree-fix-cst
  (equal (cst-unicode-input-character-conc2-rep-elem
              (abnf::tree-fix abnf::cst))
         (cst-unicode-input-character-conc2-rep-elem abnf::cst)))

Theorem: cst-unicode-input-character-conc2-rep-elem-tree-equiv-congruence-on-cst

(defthm
 cst-unicode-input-character-conc2-rep-elem-tree-equiv-congruence-on-cst
 (implies
     (abnf::tree-equiv abnf::cst cst-equiv)
     (equal (cst-unicode-input-character-conc2-rep-elem abnf::cst)
            (cst-unicode-input-character-conc2-rep-elem cst-equiv)))
 :rule-classes :congruence)

Function: cst-raw-input-character-conc-rep-elem

(defun cst-raw-input-character-conc-rep-elem (abnf::cst)
  (declare (xargs :guard (abnf::treep abnf::cst)))
  (declare
       (xargs :guard (cst-matchp abnf::cst "raw-input-character")))
  (abnf::tree-fix
       (nth 0
            (cst-raw-input-character-conc-rep abnf::cst))))

Theorem: treep-of-cst-raw-input-character-conc-rep-elem

(defthm treep-of-cst-raw-input-character-conc-rep-elem
  (b*
    ((abnf::cst1 (cst-raw-input-character-conc-rep-elem abnf::cst)))
    (abnf::treep abnf::cst1))
  :rule-classes :rewrite)

Theorem: cst-raw-input-character-conc-rep-elem-match

(defthm cst-raw-input-character-conc-rep-elem-match
 (implies
   (cst-matchp abnf::cst "raw-input-character")
   (b*
    ((abnf::cst1 (cst-raw-input-character-conc-rep-elem abnf::cst)))
    (cst-matchp abnf::cst1 "%x0-FFFF")))
 :rule-classes :rewrite)

Theorem: cst-raw-input-character-conc-rep-elem-of-tree-fix-cst

(defthm cst-raw-input-character-conc-rep-elem-of-tree-fix-cst
 (equal
  (cst-raw-input-character-conc-rep-elem (abnf::tree-fix abnf::cst))
  (cst-raw-input-character-conc-rep-elem abnf::cst)))

Theorem: cst-raw-input-character-conc-rep-elem-tree-equiv-congruence-on-cst

(defthm
 cst-raw-input-character-conc-rep-elem-tree-equiv-congruence-on-cst
 (implies (abnf::tree-equiv abnf::cst cst-equiv)
          (equal (cst-raw-input-character-conc-rep-elem abnf::cst)
                 (cst-raw-input-character-conc-rep-elem cst-equiv)))
 :rule-classes :congruence)

Function: cst-input-character-conc-rep-elem

(defun cst-input-character-conc-rep-elem (abnf::cst)
  (declare (xargs :guard (abnf::treep abnf::cst)))
  (declare (xargs :guard (cst-matchp abnf::cst "input-character")))
  (abnf::tree-fix (nth 0
                       (cst-input-character-conc-rep abnf::cst))))

Theorem: treep-of-cst-input-character-conc-rep-elem

(defthm treep-of-cst-input-character-conc-rep-elem
  (b* ((abnf::cst1 (cst-input-character-conc-rep-elem abnf::cst)))
    (abnf::treep abnf::cst1))
  :rule-classes :rewrite)

Theorem: cst-input-character-conc-rep-elem-match

(defthm cst-input-character-conc-rep-elem-match
 (implies
    (cst-matchp abnf::cst "input-character")
    (b* ((abnf::cst1 (cst-input-character-conc-rep-elem abnf::cst)))
      (cst-matchp abnf::cst1 "unicode-input-character")))
 :rule-classes :rewrite)

Theorem: cst-input-character-conc-rep-elem-of-tree-fix-cst

(defthm cst-input-character-conc-rep-elem-of-tree-fix-cst
 (equal
      (cst-input-character-conc-rep-elem (abnf::tree-fix abnf::cst))
      (cst-input-character-conc-rep-elem abnf::cst)))

Theorem: cst-input-character-conc-rep-elem-tree-equiv-congruence-on-cst

(defthm
     cst-input-character-conc-rep-elem-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-input-character-conc-rep-elem abnf::cst)
                  (cst-input-character-conc-rep-elem cst-equiv)))
  :rule-classes :congruence)

Function: cst-input-element-conc1-rep-elem

(defun cst-input-element-conc1-rep-elem (abnf::cst)
  (declare (xargs :guard (abnf::treep abnf::cst)))
  (declare
       (xargs :guard (and (cst-matchp abnf::cst "input-element")
                          (equal (cst-input-element-conc? abnf::cst)
                                 1))))
  (abnf::tree-fix (nth 0
                       (cst-input-element-conc1-rep abnf::cst))))

Theorem: treep-of-cst-input-element-conc1-rep-elem

(defthm treep-of-cst-input-element-conc1-rep-elem
  (b* ((abnf::cst1 (cst-input-element-conc1-rep-elem abnf::cst)))
    (abnf::treep abnf::cst1))
  :rule-classes :rewrite)

Theorem: cst-input-element-conc1-rep-elem-match

(defthm cst-input-element-conc1-rep-elem-match
 (implies
     (and (cst-matchp abnf::cst "input-element")
          (equal (cst-input-element-conc? abnf::cst)
                 1))
     (b* ((abnf::cst1 (cst-input-element-conc1-rep-elem abnf::cst)))
       (cst-matchp abnf::cst1 "white-space")))
 :rule-classes :rewrite)

Theorem: cst-input-element-conc1-rep-elem-of-tree-fix-cst

(defthm cst-input-element-conc1-rep-elem-of-tree-fix-cst
  (equal
       (cst-input-element-conc1-rep-elem (abnf::tree-fix abnf::cst))
       (cst-input-element-conc1-rep-elem abnf::cst)))

Theorem: cst-input-element-conc1-rep-elem-tree-equiv-congruence-on-cst

(defthm
      cst-input-element-conc1-rep-elem-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-input-element-conc1-rep-elem abnf::cst)
                  (cst-input-element-conc1-rep-elem cst-equiv)))
  :rule-classes :congruence)

Function: cst-input-element-conc2-rep-elem

(defun cst-input-element-conc2-rep-elem (abnf::cst)
  (declare (xargs :guard (abnf::treep abnf::cst)))
  (declare
       (xargs :guard (and (cst-matchp abnf::cst "input-element")
                          (equal (cst-input-element-conc? abnf::cst)
                                 2))))
  (abnf::tree-fix (nth 0
                       (cst-input-element-conc2-rep abnf::cst))))

Theorem: treep-of-cst-input-element-conc2-rep-elem

(defthm treep-of-cst-input-element-conc2-rep-elem
  (b* ((abnf::cst1 (cst-input-element-conc2-rep-elem abnf::cst)))
    (abnf::treep abnf::cst1))
  :rule-classes :rewrite)

Theorem: cst-input-element-conc2-rep-elem-match

(defthm cst-input-element-conc2-rep-elem-match
 (implies
     (and (cst-matchp abnf::cst "input-element")
          (equal (cst-input-element-conc? abnf::cst)
                 2))
     (b* ((abnf::cst1 (cst-input-element-conc2-rep-elem abnf::cst)))
       (cst-matchp abnf::cst1 "comment")))
 :rule-classes :rewrite)

Theorem: cst-input-element-conc2-rep-elem-of-tree-fix-cst

(defthm cst-input-element-conc2-rep-elem-of-tree-fix-cst
  (equal
       (cst-input-element-conc2-rep-elem (abnf::tree-fix abnf::cst))
       (cst-input-element-conc2-rep-elem abnf::cst)))

Theorem: cst-input-element-conc2-rep-elem-tree-equiv-congruence-on-cst

(defthm
      cst-input-element-conc2-rep-elem-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-input-element-conc2-rep-elem abnf::cst)
                  (cst-input-element-conc2-rep-elem cst-equiv)))
  :rule-classes :congruence)

Function: cst-input-element-conc3-rep-elem

(defun cst-input-element-conc3-rep-elem (abnf::cst)
  (declare (xargs :guard (abnf::treep abnf::cst)))
  (declare
       (xargs :guard (and (cst-matchp abnf::cst "input-element")
                          (equal (cst-input-element-conc? abnf::cst)
                                 3))))
  (abnf::tree-fix (nth 0
                       (cst-input-element-conc3-rep abnf::cst))))

Theorem: treep-of-cst-input-element-conc3-rep-elem

(defthm treep-of-cst-input-element-conc3-rep-elem
  (b* ((abnf::cst1 (cst-input-element-conc3-rep-elem abnf::cst)))
    (abnf::treep abnf::cst1))
  :rule-classes :rewrite)

Theorem: cst-input-element-conc3-rep-elem-match

(defthm cst-input-element-conc3-rep-elem-match
 (implies
     (and (cst-matchp abnf::cst "input-element")
          (equal (cst-input-element-conc? abnf::cst)
                 3))
     (b* ((abnf::cst1 (cst-input-element-conc3-rep-elem abnf::cst)))
       (cst-matchp abnf::cst1 "token")))
 :rule-classes :rewrite)

Theorem: cst-input-element-conc3-rep-elem-of-tree-fix-cst

(defthm cst-input-element-conc3-rep-elem-of-tree-fix-cst
  (equal
       (cst-input-element-conc3-rep-elem (abnf::tree-fix abnf::cst))
       (cst-input-element-conc3-rep-elem abnf::cst)))

Theorem: cst-input-element-conc3-rep-elem-tree-equiv-congruence-on-cst

(defthm
      cst-input-element-conc3-rep-elem-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-input-element-conc3-rep-elem abnf::cst)
                  (cst-input-element-conc3-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))))
  (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 "identifier")))
  :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))))
  (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 "keyword")))
  :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))))
  (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 "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))))
  (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 "separator")))
  :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))))
  (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 "operator")))
  :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-sub-conc-rep-elem

(defun cst-sub-conc-rep-elem (abnf::cst)
  (declare (xargs :guard (abnf::treep abnf::cst)))
  (declare (xargs :guard (cst-matchp abnf::cst "sub")))
  (abnf::tree-fix (nth 0 (cst-sub-conc-rep abnf::cst))))

Theorem: treep-of-cst-sub-conc-rep-elem

(defthm treep-of-cst-sub-conc-rep-elem
  (b* ((abnf::cst1 (cst-sub-conc-rep-elem abnf::cst)))
    (abnf::treep abnf::cst1))
  :rule-classes :rewrite)

Theorem: cst-sub-conc-rep-elem-match

(defthm cst-sub-conc-rep-elem-match
  (implies (cst-matchp abnf::cst "sub")
           (b* ((abnf::cst1 (cst-sub-conc-rep-elem abnf::cst)))
             (cst-matchp abnf::cst1 "%d26")))
  :rule-classes :rewrite)

Theorem: cst-sub-conc-rep-elem-of-tree-fix-cst

(defthm cst-sub-conc-rep-elem-of-tree-fix-cst
  (equal (cst-sub-conc-rep-elem (abnf::tree-fix abnf::cst))
         (cst-sub-conc-rep-elem abnf::cst)))

Theorem: cst-sub-conc-rep-elem-tree-equiv-congruence-on-cst

(defthm cst-sub-conc-rep-elem-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-sub-conc-rep-elem abnf::cst)
                  (cst-sub-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))))
  (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 "traditional-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))))
  (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 "end-of-line-comment")))
  :rule-classes :rewrite)

Theorem: cst-comment-conc2-rep-elem-of-tree-fix-cst

(defthm cst-comment-conc2-rep-elem-of-tree-fix-cst
  (equal (cst-comment-conc2-rep-elem (abnf::tree-fix abnf::cst))
         (cst-comment-conc2-rep-elem abnf::cst)))

Theorem: cst-comment-conc2-rep-elem-tree-equiv-congruence-on-cst

(defthm cst-comment-conc2-rep-elem-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-comment-conc2-rep-elem abnf::cst)
                  (cst-comment-conc2-rep-elem cst-equiv)))
  :rule-classes :congruence)

Function: cst-not-star-conc1-rep-elem

(defun cst-not-star-conc1-rep-elem (abnf::cst)
  (declare (xargs :guard (abnf::treep abnf::cst)))
  (declare (xargs :guard (and (cst-matchp abnf::cst "not-star")
                              (equal (cst-not-star-conc? abnf::cst)
                                     1))))
  (abnf::tree-fix (nth 0 (cst-not-star-conc1-rep abnf::cst))))

Theorem: treep-of-cst-not-star-conc1-rep-elem

(defthm treep-of-cst-not-star-conc1-rep-elem
  (b* ((abnf::cst1 (cst-not-star-conc1-rep-elem abnf::cst)))
    (abnf::treep abnf::cst1))
  :rule-classes :rewrite)

Theorem: cst-not-star-conc1-rep-elem-match

(defthm cst-not-star-conc1-rep-elem-match
 (implies (and (cst-matchp abnf::cst "not-star")
               (equal (cst-not-star-conc? abnf::cst)
                      1))
          (b* ((abnf::cst1 (cst-not-star-conc1-rep-elem abnf::cst)))
            (cst-matchp abnf::cst1 "input-character")))
 :rule-classes :rewrite)

Theorem: cst-not-star-conc1-rep-elem-of-tree-fix-cst

(defthm cst-not-star-conc1-rep-elem-of-tree-fix-cst
  (equal (cst-not-star-conc1-rep-elem (abnf::tree-fix abnf::cst))
         (cst-not-star-conc1-rep-elem abnf::cst)))

Theorem: cst-not-star-conc1-rep-elem-tree-equiv-congruence-on-cst

(defthm cst-not-star-conc1-rep-elem-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-not-star-conc1-rep-elem abnf::cst)
                  (cst-not-star-conc1-rep-elem cst-equiv)))
  :rule-classes :congruence)

Function: cst-not-star-conc2-rep-elem

(defun cst-not-star-conc2-rep-elem (abnf::cst)
  (declare (xargs :guard (abnf::treep abnf::cst)))
  (declare (xargs :guard (and (cst-matchp abnf::cst "not-star")
                              (equal (cst-not-star-conc? abnf::cst)
                                     2))))
  (abnf::tree-fix (nth 0 (cst-not-star-conc2-rep abnf::cst))))

Theorem: treep-of-cst-not-star-conc2-rep-elem

(defthm treep-of-cst-not-star-conc2-rep-elem
  (b* ((abnf::cst1 (cst-not-star-conc2-rep-elem abnf::cst)))
    (abnf::treep abnf::cst1))
  :rule-classes :rewrite)

Theorem: cst-not-star-conc2-rep-elem-match

(defthm cst-not-star-conc2-rep-elem-match
 (implies (and (cst-matchp abnf::cst "not-star")
               (equal (cst-not-star-conc? abnf::cst)
                      2))
          (b* ((abnf::cst1 (cst-not-star-conc2-rep-elem abnf::cst)))
            (cst-matchp abnf::cst1 "line-terminator")))
 :rule-classes :rewrite)

Theorem: cst-not-star-conc2-rep-elem-of-tree-fix-cst

(defthm cst-not-star-conc2-rep-elem-of-tree-fix-cst
  (equal (cst-not-star-conc2-rep-elem (abnf::tree-fix abnf::cst))
         (cst-not-star-conc2-rep-elem abnf::cst)))

Theorem: cst-not-star-conc2-rep-elem-tree-equiv-congruence-on-cst

(defthm cst-not-star-conc2-rep-elem-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-not-star-conc2-rep-elem abnf::cst)
                  (cst-not-star-conc2-rep-elem cst-equiv)))
  :rule-classes :congruence)

Function: cst-not-star-not-slash-conc1-rep-elem

(defun cst-not-star-not-slash-conc1-rep-elem (abnf::cst)
 (declare (xargs :guard (abnf::treep abnf::cst)))
 (declare
  (xargs :guard (and (cst-matchp abnf::cst "not-star-not-slash")
                     (equal (cst-not-star-not-slash-conc? abnf::cst)
                            1))))
 (abnf::tree-fix
      (nth 0
           (cst-not-star-not-slash-conc1-rep abnf::cst))))

Theorem: treep-of-cst-not-star-not-slash-conc1-rep-elem

(defthm treep-of-cst-not-star-not-slash-conc1-rep-elem
  (b*
    ((abnf::cst1 (cst-not-star-not-slash-conc1-rep-elem abnf::cst)))
    (abnf::treep abnf::cst1))
  :rule-classes :rewrite)

Theorem: cst-not-star-not-slash-conc1-rep-elem-match

(defthm cst-not-star-not-slash-conc1-rep-elem-match
 (implies
   (and (cst-matchp abnf::cst "not-star-not-slash")
        (equal (cst-not-star-not-slash-conc? abnf::cst)
               1))
   (b*
    ((abnf::cst1 (cst-not-star-not-slash-conc1-rep-elem abnf::cst)))
    (cst-matchp abnf::cst1 "input-character")))
 :rule-classes :rewrite)

Theorem: cst-not-star-not-slash-conc1-rep-elem-of-tree-fix-cst

(defthm cst-not-star-not-slash-conc1-rep-elem-of-tree-fix-cst
 (equal
  (cst-not-star-not-slash-conc1-rep-elem (abnf::tree-fix abnf::cst))
  (cst-not-star-not-slash-conc1-rep-elem abnf::cst)))

Theorem: cst-not-star-not-slash-conc1-rep-elem-tree-equiv-congruence-on-cst

(defthm
 cst-not-star-not-slash-conc1-rep-elem-tree-equiv-congruence-on-cst
 (implies (abnf::tree-equiv abnf::cst cst-equiv)
          (equal (cst-not-star-not-slash-conc1-rep-elem abnf::cst)
                 (cst-not-star-not-slash-conc1-rep-elem cst-equiv)))
 :rule-classes :congruence)

Function: cst-not-star-not-slash-conc2-rep-elem

(defun cst-not-star-not-slash-conc2-rep-elem (abnf::cst)
 (declare (xargs :guard (abnf::treep abnf::cst)))
 (declare
  (xargs :guard (and (cst-matchp abnf::cst "not-star-not-slash")
                     (equal (cst-not-star-not-slash-conc? abnf::cst)
                            2))))
 (abnf::tree-fix
      (nth 0
           (cst-not-star-not-slash-conc2-rep abnf::cst))))

Theorem: treep-of-cst-not-star-not-slash-conc2-rep-elem

(defthm treep-of-cst-not-star-not-slash-conc2-rep-elem
  (b*
    ((abnf::cst1 (cst-not-star-not-slash-conc2-rep-elem abnf::cst)))
    (abnf::treep abnf::cst1))
  :rule-classes :rewrite)

Theorem: cst-not-star-not-slash-conc2-rep-elem-match

(defthm cst-not-star-not-slash-conc2-rep-elem-match
 (implies
   (and (cst-matchp abnf::cst "not-star-not-slash")
        (equal (cst-not-star-not-slash-conc? abnf::cst)
               2))
   (b*
    ((abnf::cst1 (cst-not-star-not-slash-conc2-rep-elem abnf::cst)))
    (cst-matchp abnf::cst1 "line-terminator")))
 :rule-classes :rewrite)

Theorem: cst-not-star-not-slash-conc2-rep-elem-of-tree-fix-cst

(defthm cst-not-star-not-slash-conc2-rep-elem-of-tree-fix-cst
 (equal
  (cst-not-star-not-slash-conc2-rep-elem (abnf::tree-fix abnf::cst))
  (cst-not-star-not-slash-conc2-rep-elem abnf::cst)))

Theorem: cst-not-star-not-slash-conc2-rep-elem-tree-equiv-congruence-on-cst

(defthm
 cst-not-star-not-slash-conc2-rep-elem-tree-equiv-congruence-on-cst
 (implies (abnf::tree-equiv abnf::cst cst-equiv)
          (equal (cst-not-star-not-slash-conc2-rep-elem abnf::cst)
                 (cst-not-star-not-slash-conc2-rep-elem cst-equiv)))
 :rule-classes :congruence)

Function: cst-identifier-conc-rep-elem

(defun cst-identifier-conc-rep-elem (abnf::cst)
  (declare (xargs :guard (abnf::treep abnf::cst)))
  (declare (xargs :guard (cst-matchp abnf::cst "identifier")))
  (abnf::tree-fix (nth 0 (cst-identifier-conc-rep abnf::cst))))

Theorem: treep-of-cst-identifier-conc-rep-elem

(defthm treep-of-cst-identifier-conc-rep-elem
  (b* ((abnf::cst1 (cst-identifier-conc-rep-elem abnf::cst)))
    (abnf::treep abnf::cst1))
  :rule-classes :rewrite)

Theorem: cst-identifier-conc-rep-elem-match

(defthm cst-identifier-conc-rep-elem-match
  (implies
       (cst-matchp abnf::cst "identifier")
       (b* ((abnf::cst1 (cst-identifier-conc-rep-elem abnf::cst)))
         (cst-matchp abnf::cst1 "identifier-chars")))
  :rule-classes :rewrite)

Theorem: cst-identifier-conc-rep-elem-of-tree-fix-cst

(defthm cst-identifier-conc-rep-elem-of-tree-fix-cst
  (equal (cst-identifier-conc-rep-elem (abnf::tree-fix abnf::cst))
         (cst-identifier-conc-rep-elem abnf::cst)))

Theorem: cst-identifier-conc-rep-elem-tree-equiv-congruence-on-cst

(defthm cst-identifier-conc-rep-elem-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-identifier-conc-rep-elem abnf::cst)
                  (cst-identifier-conc-rep-elem cst-equiv)))
  :rule-classes :congruence)

Function: cst-java-letter-conc-rep-elem

(defun cst-java-letter-conc-rep-elem (abnf::cst)
  (declare (xargs :guard (abnf::treep abnf::cst)))
  (declare (xargs :guard (cst-matchp abnf::cst "java-letter")))
  (abnf::tree-fix (nth 0
                       (cst-java-letter-conc-rep abnf::cst))))

Theorem: treep-of-cst-java-letter-conc-rep-elem

(defthm treep-of-cst-java-letter-conc-rep-elem
  (b* ((abnf::cst1 (cst-java-letter-conc-rep-elem abnf::cst)))
    (abnf::treep abnf::cst1))
  :rule-classes :rewrite)

Theorem: cst-java-letter-conc-rep-elem-match

(defthm cst-java-letter-conc-rep-elem-match
  (implies
       (cst-matchp abnf::cst "java-letter")
       (b* ((abnf::cst1 (cst-java-letter-conc-rep-elem abnf::cst)))
         (cst-matchp abnf::cst1 "raw-input-character")))
  :rule-classes :rewrite)

Theorem: cst-java-letter-conc-rep-elem-of-tree-fix-cst

(defthm cst-java-letter-conc-rep-elem-of-tree-fix-cst
  (equal (cst-java-letter-conc-rep-elem (abnf::tree-fix abnf::cst))
         (cst-java-letter-conc-rep-elem abnf::cst)))

Theorem: cst-java-letter-conc-rep-elem-tree-equiv-congruence-on-cst

(defthm cst-java-letter-conc-rep-elem-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-java-letter-conc-rep-elem abnf::cst)
                  (cst-java-letter-conc-rep-elem cst-equiv)))
  :rule-classes :congruence)

Function: cst-java-letter-or-digit-conc-rep-elem

(defun cst-java-letter-or-digit-conc-rep-elem (abnf::cst)
  (declare (xargs :guard (abnf::treep abnf::cst)))
  (declare
       (xargs :guard (cst-matchp abnf::cst "java-letter-or-digit")))
  (abnf::tree-fix
       (nth 0
            (cst-java-letter-or-digit-conc-rep abnf::cst))))

Theorem: treep-of-cst-java-letter-or-digit-conc-rep-elem

(defthm treep-of-cst-java-letter-or-digit-conc-rep-elem
  (b*
   ((abnf::cst1 (cst-java-letter-or-digit-conc-rep-elem abnf::cst)))
   (abnf::treep abnf::cst1))
  :rule-classes :rewrite)

Theorem: cst-java-letter-or-digit-conc-rep-elem-match

(defthm cst-java-letter-or-digit-conc-rep-elem-match
 (implies
  (cst-matchp abnf::cst "java-letter-or-digit")
  (b*
   ((abnf::cst1 (cst-java-letter-or-digit-conc-rep-elem abnf::cst)))
   (cst-matchp abnf::cst1 "raw-input-character")))
 :rule-classes :rewrite)

Theorem: cst-java-letter-or-digit-conc-rep-elem-of-tree-fix-cst

(defthm cst-java-letter-or-digit-conc-rep-elem-of-tree-fix-cst
  (equal (cst-java-letter-or-digit-conc-rep-elem
              (abnf::tree-fix abnf::cst))
         (cst-java-letter-or-digit-conc-rep-elem abnf::cst)))

Theorem: cst-java-letter-or-digit-conc-rep-elem-tree-equiv-congruence-on-cst

(defthm
 cst-java-letter-or-digit-conc-rep-elem-tree-equiv-congruence-on-cst
 (implies
      (abnf::tree-equiv abnf::cst cst-equiv)
      (equal (cst-java-letter-or-digit-conc-rep-elem abnf::cst)
             (cst-java-letter-or-digit-conc-rep-elem cst-equiv)))
 :rule-classes :congruence)

Function: cst-type-identifier-conc-rep-elem

(defun cst-type-identifier-conc-rep-elem (abnf::cst)
  (declare (xargs :guard (abnf::treep abnf::cst)))
  (declare (xargs :guard (cst-matchp abnf::cst "type-identifier")))
  (abnf::tree-fix (nth 0
                       (cst-type-identifier-conc-rep abnf::cst))))

Theorem: treep-of-cst-type-identifier-conc-rep-elem

(defthm treep-of-cst-type-identifier-conc-rep-elem
  (b* ((abnf::cst1 (cst-type-identifier-conc-rep-elem abnf::cst)))
    (abnf::treep abnf::cst1))
  :rule-classes :rewrite)

Theorem: cst-type-identifier-conc-rep-elem-match

(defthm cst-type-identifier-conc-rep-elem-match
 (implies
    (cst-matchp abnf::cst "type-identifier")
    (b* ((abnf::cst1 (cst-type-identifier-conc-rep-elem abnf::cst)))
      (cst-matchp abnf::cst1 "identifier")))
 :rule-classes :rewrite)

Theorem: cst-type-identifier-conc-rep-elem-of-tree-fix-cst

(defthm cst-type-identifier-conc-rep-elem-of-tree-fix-cst
 (equal
      (cst-type-identifier-conc-rep-elem (abnf::tree-fix abnf::cst))
      (cst-type-identifier-conc-rep-elem abnf::cst)))

Theorem: cst-type-identifier-conc-rep-elem-tree-equiv-congruence-on-cst

(defthm
     cst-type-identifier-conc-rep-elem-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-type-identifier-conc-rep-elem abnf::cst)
                  (cst-type-identifier-conc-rep-elem cst-equiv)))
  :rule-classes :congruence)

Function: cst-unqualified-method-identifier-conc-rep-elem

(defun cst-unqualified-method-identifier-conc-rep-elem (abnf::cst)
 (declare (xargs :guard (abnf::treep abnf::cst)))
 (declare
      (xargs :guard (cst-matchp abnf::cst
                                "unqualified-method-identifier")))
 (abnf::tree-fix
      (nth 0
           (cst-unqualified-method-identifier-conc-rep abnf::cst))))

Theorem: treep-of-cst-unqualified-method-identifier-conc-rep-elem

(defthm treep-of-cst-unqualified-method-identifier-conc-rep-elem
 (b*
  ((abnf::cst1
       (cst-unqualified-method-identifier-conc-rep-elem abnf::cst)))
  (abnf::treep abnf::cst1))
 :rule-classes :rewrite)

Theorem: cst-unqualified-method-identifier-conc-rep-elem-match

(defthm cst-unqualified-method-identifier-conc-rep-elem-match
 (implies
  (cst-matchp abnf::cst
              "unqualified-method-identifier")
  (b*
   ((abnf::cst1
       (cst-unqualified-method-identifier-conc-rep-elem abnf::cst)))
   (cst-matchp abnf::cst1 "identifier")))
 :rule-classes :rewrite)

Theorem: cst-unqualified-method-identifier-conc-rep-elem-of-tree-fix-cst

(defthm
    cst-unqualified-method-identifier-conc-rep-elem-of-tree-fix-cst
  (equal
       (cst-unqualified-method-identifier-conc-rep-elem
            (abnf::tree-fix abnf::cst))
       (cst-unqualified-method-identifier-conc-rep-elem abnf::cst)))

Theorem: cst-unqualified-method-identifier-conc-rep-elem-tree-equiv-congruence-on-cst

(defthm
 cst-unqualified-method-identifier-conc-rep-elem-tree-equiv-congruence-on-cst
 (implies
  (abnf::tree-equiv abnf::cst cst-equiv)
  (equal
       (cst-unqualified-method-identifier-conc-rep-elem abnf::cst)
       (cst-unqualified-method-identifier-conc-rep-elem cst-equiv)))
 :rule-classes :congruence)

Function: cst-keyword-conc1-rep-elem

(defun cst-keyword-conc1-rep-elem (abnf::cst)
  (declare (xargs :guard (abnf::treep abnf::cst)))
  (declare (xargs :guard (and (cst-matchp abnf::cst "keyword")
                              (equal (cst-keyword-conc? abnf::cst)
                                     1))))
  (abnf::tree-fix (nth 0 (cst-keyword-conc1-rep abnf::cst))))

Theorem: treep-of-cst-keyword-conc1-rep-elem

(defthm treep-of-cst-keyword-conc1-rep-elem
  (b* ((abnf::cst1 (cst-keyword-conc1-rep-elem abnf::cst)))
    (abnf::treep abnf::cst1))
  :rule-classes :rewrite)

Theorem: cst-keyword-conc1-rep-elem-match

(defthm cst-keyword-conc1-rep-elem-match
  (implies (and (cst-matchp abnf::cst "keyword")
                (equal (cst-keyword-conc? abnf::cst) 1))
           (b* ((abnf::cst1 (cst-keyword-conc1-rep-elem abnf::cst)))
             (cst-matchp abnf::cst1 "reserved-keyword")))
  :rule-classes :rewrite)

Theorem: cst-keyword-conc1-rep-elem-of-tree-fix-cst

(defthm cst-keyword-conc1-rep-elem-of-tree-fix-cst
  (equal (cst-keyword-conc1-rep-elem (abnf::tree-fix abnf::cst))
         (cst-keyword-conc1-rep-elem abnf::cst)))

Theorem: cst-keyword-conc1-rep-elem-tree-equiv-congruence-on-cst

(defthm cst-keyword-conc1-rep-elem-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-keyword-conc1-rep-elem abnf::cst)
                  (cst-keyword-conc1-rep-elem cst-equiv)))
  :rule-classes :congruence)

Function: cst-keyword-conc2-rep-elem

(defun cst-keyword-conc2-rep-elem (abnf::cst)
  (declare (xargs :guard (abnf::treep abnf::cst)))
  (declare (xargs :guard (and (cst-matchp abnf::cst "keyword")
                              (equal (cst-keyword-conc? abnf::cst)
                                     2))))
  (abnf::tree-fix (nth 0 (cst-keyword-conc2-rep abnf::cst))))

Theorem: treep-of-cst-keyword-conc2-rep-elem

(defthm treep-of-cst-keyword-conc2-rep-elem
  (b* ((abnf::cst1 (cst-keyword-conc2-rep-elem abnf::cst)))
    (abnf::treep abnf::cst1))
  :rule-classes :rewrite)

Theorem: cst-keyword-conc2-rep-elem-match

(defthm cst-keyword-conc2-rep-elem-match
  (implies (and (cst-matchp abnf::cst "keyword")
                (equal (cst-keyword-conc? abnf::cst) 2))
           (b* ((abnf::cst1 (cst-keyword-conc2-rep-elem abnf::cst)))
             (cst-matchp abnf::cst1 "contextual-keyword")))
  :rule-classes :rewrite)

Theorem: cst-keyword-conc2-rep-elem-of-tree-fix-cst

(defthm cst-keyword-conc2-rep-elem-of-tree-fix-cst
  (equal (cst-keyword-conc2-rep-elem (abnf::tree-fix abnf::cst))
         (cst-keyword-conc2-rep-elem abnf::cst)))

Theorem: cst-keyword-conc2-rep-elem-tree-equiv-congruence-on-cst

(defthm cst-keyword-conc2-rep-elem-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-keyword-conc2-rep-elem abnf::cst)
                  (cst-keyword-conc2-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))))
  (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 "integer-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))))
  (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 "floating-point-literal")))
  :rule-classes :rewrite)

Theorem: cst-literal-conc2-rep-elem-of-tree-fix-cst

(defthm cst-literal-conc2-rep-elem-of-tree-fix-cst
  (equal (cst-literal-conc2-rep-elem (abnf::tree-fix abnf::cst))
         (cst-literal-conc2-rep-elem abnf::cst)))

Theorem: cst-literal-conc2-rep-elem-tree-equiv-congruence-on-cst

(defthm cst-literal-conc2-rep-elem-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-literal-conc2-rep-elem abnf::cst)
                  (cst-literal-conc2-rep-elem cst-equiv)))
  :rule-classes :congruence)

Function: cst-literal-conc3-rep-elem

(defun cst-literal-conc3-rep-elem (abnf::cst)
  (declare (xargs :guard (abnf::treep abnf::cst)))
  (declare (xargs :guard (and (cst-matchp abnf::cst "literal")
                              (equal (cst-literal-conc? abnf::cst)
                                     3))))
  (abnf::tree-fix (nth 0 (cst-literal-conc3-rep abnf::cst))))

Theorem: treep-of-cst-literal-conc3-rep-elem

(defthm treep-of-cst-literal-conc3-rep-elem
  (b* ((abnf::cst1 (cst-literal-conc3-rep-elem abnf::cst)))
    (abnf::treep abnf::cst1))
  :rule-classes :rewrite)

Theorem: cst-literal-conc3-rep-elem-match

(defthm cst-literal-conc3-rep-elem-match
  (implies (and (cst-matchp abnf::cst "literal")
                (equal (cst-literal-conc? abnf::cst) 3))
           (b* ((abnf::cst1 (cst-literal-conc3-rep-elem abnf::cst)))
             (cst-matchp abnf::cst1 "boolean-literal")))
  :rule-classes :rewrite)

Theorem: cst-literal-conc3-rep-elem-of-tree-fix-cst

(defthm cst-literal-conc3-rep-elem-of-tree-fix-cst
  (equal (cst-literal-conc3-rep-elem (abnf::tree-fix abnf::cst))
         (cst-literal-conc3-rep-elem abnf::cst)))

Theorem: cst-literal-conc3-rep-elem-tree-equiv-congruence-on-cst

(defthm cst-literal-conc3-rep-elem-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-literal-conc3-rep-elem abnf::cst)
                  (cst-literal-conc3-rep-elem cst-equiv)))
  :rule-classes :congruence)

Function: cst-literal-conc4-rep-elem

(defun cst-literal-conc4-rep-elem (abnf::cst)
  (declare (xargs :guard (abnf::treep abnf::cst)))
  (declare (xargs :guard (and (cst-matchp abnf::cst "literal")
                              (equal (cst-literal-conc? abnf::cst)
                                     4))))
  (abnf::tree-fix (nth 0 (cst-literal-conc4-rep abnf::cst))))

Theorem: treep-of-cst-literal-conc4-rep-elem

(defthm treep-of-cst-literal-conc4-rep-elem
  (b* ((abnf::cst1 (cst-literal-conc4-rep-elem abnf::cst)))
    (abnf::treep abnf::cst1))
  :rule-classes :rewrite)

Theorem: cst-literal-conc4-rep-elem-match

(defthm cst-literal-conc4-rep-elem-match
  (implies (and (cst-matchp abnf::cst "literal")
                (equal (cst-literal-conc? abnf::cst) 4))
           (b* ((abnf::cst1 (cst-literal-conc4-rep-elem abnf::cst)))
             (cst-matchp abnf::cst1 "character-literal")))
  :rule-classes :rewrite)

Theorem: cst-literal-conc4-rep-elem-of-tree-fix-cst

(defthm cst-literal-conc4-rep-elem-of-tree-fix-cst
  (equal (cst-literal-conc4-rep-elem (abnf::tree-fix abnf::cst))
         (cst-literal-conc4-rep-elem abnf::cst)))

Theorem: cst-literal-conc4-rep-elem-tree-equiv-congruence-on-cst

(defthm cst-literal-conc4-rep-elem-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-literal-conc4-rep-elem abnf::cst)
                  (cst-literal-conc4-rep-elem cst-equiv)))
  :rule-classes :congruence)

Function: cst-literal-conc5-rep-elem

(defun cst-literal-conc5-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)
                                     5))))
  (abnf::tree-fix (nth 0 (cst-literal-conc5-rep abnf::cst))))

Theorem: treep-of-cst-literal-conc5-rep-elem

(defthm treep-of-cst-literal-conc5-rep-elem
  (b* ((abnf::cst1 (cst-literal-conc5-rep-elem abnf::cst)))
    (abnf::treep abnf::cst1))
  :rule-classes :rewrite)

Theorem: cst-literal-conc5-rep-elem-match

(defthm cst-literal-conc5-rep-elem-match
  (implies (and (cst-matchp abnf::cst "literal")
                (equal (cst-literal-conc? abnf::cst) 5))
           (b* ((abnf::cst1 (cst-literal-conc5-rep-elem abnf::cst)))
             (cst-matchp abnf::cst1 "string-literal")))
  :rule-classes :rewrite)

Theorem: cst-literal-conc5-rep-elem-of-tree-fix-cst

(defthm cst-literal-conc5-rep-elem-of-tree-fix-cst
  (equal (cst-literal-conc5-rep-elem (abnf::tree-fix abnf::cst))
         (cst-literal-conc5-rep-elem abnf::cst)))

Theorem: cst-literal-conc5-rep-elem-tree-equiv-congruence-on-cst

(defthm cst-literal-conc5-rep-elem-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-literal-conc5-rep-elem abnf::cst)
                  (cst-literal-conc5-rep-elem cst-equiv)))
  :rule-classes :congruence)

Function: cst-literal-conc6-rep-elem

(defun cst-literal-conc6-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)
                                     6))))
  (abnf::tree-fix (nth 0 (cst-literal-conc6-rep abnf::cst))))

Theorem: treep-of-cst-literal-conc6-rep-elem

(defthm treep-of-cst-literal-conc6-rep-elem
  (b* ((abnf::cst1 (cst-literal-conc6-rep-elem abnf::cst)))
    (abnf::treep abnf::cst1))
  :rule-classes :rewrite)

Theorem: cst-literal-conc6-rep-elem-match

(defthm cst-literal-conc6-rep-elem-match
  (implies (and (cst-matchp abnf::cst "literal")
                (equal (cst-literal-conc? abnf::cst) 6))
           (b* ((abnf::cst1 (cst-literal-conc6-rep-elem abnf::cst)))
             (cst-matchp abnf::cst1 "text-block")))
  :rule-classes :rewrite)

Theorem: cst-literal-conc6-rep-elem-of-tree-fix-cst

(defthm cst-literal-conc6-rep-elem-of-tree-fix-cst
  (equal (cst-literal-conc6-rep-elem (abnf::tree-fix abnf::cst))
         (cst-literal-conc6-rep-elem abnf::cst)))

Theorem: cst-literal-conc6-rep-elem-tree-equiv-congruence-on-cst

(defthm cst-literal-conc6-rep-elem-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-literal-conc6-rep-elem abnf::cst)
                  (cst-literal-conc6-rep-elem cst-equiv)))
  :rule-classes :congruence)

Function: cst-literal-conc7-rep-elem

(defun cst-literal-conc7-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)
                                     7))))
  (abnf::tree-fix (nth 0 (cst-literal-conc7-rep abnf::cst))))

Theorem: treep-of-cst-literal-conc7-rep-elem

(defthm treep-of-cst-literal-conc7-rep-elem
  (b* ((abnf::cst1 (cst-literal-conc7-rep-elem abnf::cst)))
    (abnf::treep abnf::cst1))
  :rule-classes :rewrite)

Theorem: cst-literal-conc7-rep-elem-match

(defthm cst-literal-conc7-rep-elem-match
  (implies (and (cst-matchp abnf::cst "literal")
                (equal (cst-literal-conc? abnf::cst) 7))
           (b* ((abnf::cst1 (cst-literal-conc7-rep-elem abnf::cst)))
             (cst-matchp abnf::cst1 "null-literal")))
  :rule-classes :rewrite)

Theorem: cst-literal-conc7-rep-elem-of-tree-fix-cst

(defthm cst-literal-conc7-rep-elem-of-tree-fix-cst
  (equal (cst-literal-conc7-rep-elem (abnf::tree-fix abnf::cst))
         (cst-literal-conc7-rep-elem abnf::cst)))

Theorem: cst-literal-conc7-rep-elem-tree-equiv-congruence-on-cst

(defthm cst-literal-conc7-rep-elem-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-literal-conc7-rep-elem abnf::cst)
                  (cst-literal-conc7-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))))
 (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 "decimal-integer-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))))
 (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 "hex-integer-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-integer-literal-conc3-rep-elem

(defun cst-integer-literal-conc3-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)
                               3))))
 (abnf::tree-fix (nth 0
                      (cst-integer-literal-conc3-rep abnf::cst))))

Theorem: treep-of-cst-integer-literal-conc3-rep-elem

(defthm treep-of-cst-integer-literal-conc3-rep-elem
  (b* ((abnf::cst1 (cst-integer-literal-conc3-rep-elem abnf::cst)))
    (abnf::treep abnf::cst1))
  :rule-classes :rewrite)

Theorem: cst-integer-literal-conc3-rep-elem-match

(defthm cst-integer-literal-conc3-rep-elem-match
 (implies
   (and (cst-matchp abnf::cst "integer-literal")
        (equal (cst-integer-literal-conc? abnf::cst)
               3))
   (b* ((abnf::cst1 (cst-integer-literal-conc3-rep-elem abnf::cst)))
     (cst-matchp abnf::cst1 "octal-integer-literal")))
 :rule-classes :rewrite)

Theorem: cst-integer-literal-conc3-rep-elem-of-tree-fix-cst

(defthm cst-integer-literal-conc3-rep-elem-of-tree-fix-cst
 (equal
     (cst-integer-literal-conc3-rep-elem (abnf::tree-fix abnf::cst))
     (cst-integer-literal-conc3-rep-elem abnf::cst)))

Theorem: cst-integer-literal-conc3-rep-elem-tree-equiv-congruence-on-cst

(defthm
    cst-integer-literal-conc3-rep-elem-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-integer-literal-conc3-rep-elem abnf::cst)
                  (cst-integer-literal-conc3-rep-elem cst-equiv)))
  :rule-classes :congruence)

Function: cst-integer-literal-conc4-rep-elem

(defun cst-integer-literal-conc4-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)
                               4))))
 (abnf::tree-fix (nth 0
                      (cst-integer-literal-conc4-rep abnf::cst))))

Theorem: treep-of-cst-integer-literal-conc4-rep-elem

(defthm treep-of-cst-integer-literal-conc4-rep-elem
  (b* ((abnf::cst1 (cst-integer-literal-conc4-rep-elem abnf::cst)))
    (abnf::treep abnf::cst1))
  :rule-classes :rewrite)

Theorem: cst-integer-literal-conc4-rep-elem-match

(defthm cst-integer-literal-conc4-rep-elem-match
 (implies
   (and (cst-matchp abnf::cst "integer-literal")
        (equal (cst-integer-literal-conc? abnf::cst)
               4))
   (b* ((abnf::cst1 (cst-integer-literal-conc4-rep-elem abnf::cst)))
     (cst-matchp abnf::cst1 "binary-integer-literal")))
 :rule-classes :rewrite)

Theorem: cst-integer-literal-conc4-rep-elem-of-tree-fix-cst

(defthm cst-integer-literal-conc4-rep-elem-of-tree-fix-cst
 (equal
     (cst-integer-literal-conc4-rep-elem (abnf::tree-fix abnf::cst))
     (cst-integer-literal-conc4-rep-elem abnf::cst)))

Theorem: cst-integer-literal-conc4-rep-elem-tree-equiv-congruence-on-cst

(defthm
    cst-integer-literal-conc4-rep-elem-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-integer-literal-conc4-rep-elem abnf::cst)
                  (cst-integer-literal-conc4-rep-elem cst-equiv)))
  :rule-classes :congruence)

Function: cst-integer-type-suffix-conc-rep-elem

(defun cst-integer-type-suffix-conc-rep-elem (abnf::cst)
  (declare (xargs :guard (abnf::treep abnf::cst)))
  (declare
       (xargs :guard (cst-matchp abnf::cst "integer-type-suffix")))
  (abnf::tree-fix
       (nth 0
            (cst-integer-type-suffix-conc-rep abnf::cst))))

Theorem: treep-of-cst-integer-type-suffix-conc-rep-elem

(defthm treep-of-cst-integer-type-suffix-conc-rep-elem
  (b*
    ((abnf::cst1 (cst-integer-type-suffix-conc-rep-elem abnf::cst)))
    (abnf::treep abnf::cst1))
  :rule-classes :rewrite)

Theorem: cst-integer-type-suffix-conc-rep-elem-match

(defthm cst-integer-type-suffix-conc-rep-elem-match
 (implies
   (cst-matchp abnf::cst "integer-type-suffix")
   (b*
    ((abnf::cst1 (cst-integer-type-suffix-conc-rep-elem abnf::cst)))
    (cst-matchp abnf::cst1 "\"l\"")))
 :rule-classes :rewrite)

Theorem: cst-integer-type-suffix-conc-rep-elem-of-tree-fix-cst

(defthm cst-integer-type-suffix-conc-rep-elem-of-tree-fix-cst
 (equal
  (cst-integer-type-suffix-conc-rep-elem (abnf::tree-fix abnf::cst))
  (cst-integer-type-suffix-conc-rep-elem abnf::cst)))

Theorem: cst-integer-type-suffix-conc-rep-elem-tree-equiv-congruence-on-cst

(defthm
 cst-integer-type-suffix-conc-rep-elem-tree-equiv-congruence-on-cst
 (implies (abnf::tree-equiv abnf::cst cst-equiv)
          (equal (cst-integer-type-suffix-conc-rep-elem abnf::cst)
                 (cst-integer-type-suffix-conc-rep-elem cst-equiv)))
 :rule-classes :congruence)

Function: cst-floating-point-literal-conc1-rep-elem

(defun cst-floating-point-literal-conc1-rep-elem (abnf::cst)
 (declare (xargs :guard (abnf::treep abnf::cst)))
 (declare
  (xargs
     :guard (and (cst-matchp abnf::cst "floating-point-literal")
                 (equal (cst-floating-point-literal-conc? abnf::cst)
                        1))))
 (abnf::tree-fix
      (nth 0
           (cst-floating-point-literal-conc1-rep abnf::cst))))

Theorem: treep-of-cst-floating-point-literal-conc1-rep-elem

(defthm treep-of-cst-floating-point-literal-conc1-rep-elem
  (b* ((abnf::cst1
            (cst-floating-point-literal-conc1-rep-elem abnf::cst)))
    (abnf::treep abnf::cst1))
  :rule-classes :rewrite)

Theorem: cst-floating-point-literal-conc1-rep-elem-match

(defthm cst-floating-point-literal-conc1-rep-elem-match
 (implies
   (and (cst-matchp abnf::cst "floating-point-literal")
        (equal (cst-floating-point-literal-conc? abnf::cst)
               1))
   (b* ((abnf::cst1
             (cst-floating-point-literal-conc1-rep-elem abnf::cst)))
     (cst-matchp abnf::cst1
                 "decimal-floating-point-literal")))
 :rule-classes :rewrite)

Theorem: cst-floating-point-literal-conc1-rep-elem-of-tree-fix-cst

(defthm cst-floating-point-literal-conc1-rep-elem-of-tree-fix-cst
  (equal (cst-floating-point-literal-conc1-rep-elem
              (abnf::tree-fix abnf::cst))
         (cst-floating-point-literal-conc1-rep-elem abnf::cst)))

Theorem: cst-floating-point-literal-conc1-rep-elem-tree-equiv-congruence-on-cst

(defthm
 cst-floating-point-literal-conc1-rep-elem-tree-equiv-congruence-on-cst
 (implies
      (abnf::tree-equiv abnf::cst cst-equiv)
      (equal (cst-floating-point-literal-conc1-rep-elem abnf::cst)
             (cst-floating-point-literal-conc1-rep-elem cst-equiv)))
 :rule-classes :congruence)

Function: cst-floating-point-literal-conc2-rep-elem

(defun cst-floating-point-literal-conc2-rep-elem (abnf::cst)
 (declare (xargs :guard (abnf::treep abnf::cst)))
 (declare
  (xargs
     :guard (and (cst-matchp abnf::cst "floating-point-literal")
                 (equal (cst-floating-point-literal-conc? abnf::cst)
                        2))))
 (abnf::tree-fix
      (nth 0
           (cst-floating-point-literal-conc2-rep abnf::cst))))

Theorem: treep-of-cst-floating-point-literal-conc2-rep-elem

(defthm treep-of-cst-floating-point-literal-conc2-rep-elem
  (b* ((abnf::cst1
            (cst-floating-point-literal-conc2-rep-elem abnf::cst)))
    (abnf::treep abnf::cst1))
  :rule-classes :rewrite)

Theorem: cst-floating-point-literal-conc2-rep-elem-match

(defthm cst-floating-point-literal-conc2-rep-elem-match
 (implies
   (and (cst-matchp abnf::cst "floating-point-literal")
        (equal (cst-floating-point-literal-conc? abnf::cst)
               2))
   (b* ((abnf::cst1
             (cst-floating-point-literal-conc2-rep-elem abnf::cst)))
     (cst-matchp abnf::cst1
                 "hexadecimal-floating-point-literal")))
 :rule-classes :rewrite)

Theorem: cst-floating-point-literal-conc2-rep-elem-of-tree-fix-cst

(defthm cst-floating-point-literal-conc2-rep-elem-of-tree-fix-cst
  (equal (cst-floating-point-literal-conc2-rep-elem
              (abnf::tree-fix abnf::cst))
         (cst-floating-point-literal-conc2-rep-elem abnf::cst)))

Theorem: cst-floating-point-literal-conc2-rep-elem-tree-equiv-congruence-on-cst

(defthm
 cst-floating-point-literal-conc2-rep-elem-tree-equiv-congruence-on-cst
 (implies
      (abnf::tree-equiv abnf::cst cst-equiv)
      (equal (cst-floating-point-literal-conc2-rep-elem abnf::cst)
             (cst-floating-point-literal-conc2-rep-elem cst-equiv)))
 :rule-classes :congruence)

Function: cst-exponent-indicator-conc-rep-elem

(defun cst-exponent-indicator-conc-rep-elem (abnf::cst)
 (declare (xargs :guard (abnf::treep abnf::cst)))
 (declare
      (xargs :guard (cst-matchp abnf::cst "exponent-indicator")))
 (abnf::tree-fix (nth 0
                      (cst-exponent-indicator-conc-rep abnf::cst))))

Theorem: treep-of-cst-exponent-indicator-conc-rep-elem

(defthm treep-of-cst-exponent-indicator-conc-rep-elem
 (b* ((abnf::cst1 (cst-exponent-indicator-conc-rep-elem abnf::cst)))
   (abnf::treep abnf::cst1))
 :rule-classes :rewrite)

Theorem: cst-exponent-indicator-conc-rep-elem-match

(defthm cst-exponent-indicator-conc-rep-elem-match
 (implies
   (cst-matchp abnf::cst "exponent-indicator")
   (b*
     ((abnf::cst1 (cst-exponent-indicator-conc-rep-elem abnf::cst)))
     (cst-matchp abnf::cst1 "\"e\"")))
 :rule-classes :rewrite)

Theorem: cst-exponent-indicator-conc-rep-elem-of-tree-fix-cst

(defthm cst-exponent-indicator-conc-rep-elem-of-tree-fix-cst
 (equal
   (cst-exponent-indicator-conc-rep-elem (abnf::tree-fix abnf::cst))
   (cst-exponent-indicator-conc-rep-elem abnf::cst)))

Theorem: cst-exponent-indicator-conc-rep-elem-tree-equiv-congruence-on-cst

(defthm
  cst-exponent-indicator-conc-rep-elem-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-exponent-indicator-conc-rep-elem abnf::cst)
                  (cst-exponent-indicator-conc-rep-elem cst-equiv)))
  :rule-classes :congruence)

Function: cst-binary-exponent-indicator-conc-rep-elem

(defun cst-binary-exponent-indicator-conc-rep-elem (abnf::cst)
 (declare (xargs :guard (abnf::treep abnf::cst)))
 (declare
  (xargs :guard (cst-matchp abnf::cst "binary-exponent-indicator")))
 (abnf::tree-fix
      (nth 0
           (cst-binary-exponent-indicator-conc-rep abnf::cst))))

Theorem: treep-of-cst-binary-exponent-indicator-conc-rep-elem

(defthm treep-of-cst-binary-exponent-indicator-conc-rep-elem
 (b* ((abnf::cst1
           (cst-binary-exponent-indicator-conc-rep-elem abnf::cst)))
   (abnf::treep abnf::cst1))
 :rule-classes :rewrite)

Theorem: cst-binary-exponent-indicator-conc-rep-elem-match

(defthm cst-binary-exponent-indicator-conc-rep-elem-match
 (implies
   (cst-matchp abnf::cst "binary-exponent-indicator")
   (b*
     ((abnf::cst1
           (cst-binary-exponent-indicator-conc-rep-elem abnf::cst)))
     (cst-matchp abnf::cst1 "\"p\"")))
 :rule-classes :rewrite)

Theorem: cst-binary-exponent-indicator-conc-rep-elem-of-tree-fix-cst

(defthm cst-binary-exponent-indicator-conc-rep-elem-of-tree-fix-cst
  (equal (cst-binary-exponent-indicator-conc-rep-elem
              (abnf::tree-fix abnf::cst))
         (cst-binary-exponent-indicator-conc-rep-elem abnf::cst)))

Theorem: cst-binary-exponent-indicator-conc-rep-elem-tree-equiv-congruence-on-cst

(defthm
 cst-binary-exponent-indicator-conc-rep-elem-tree-equiv-congruence-on-cst
 (implies
    (abnf::tree-equiv abnf::cst cst-equiv)
    (equal (cst-binary-exponent-indicator-conc-rep-elem abnf::cst)
           (cst-binary-exponent-indicator-conc-rep-elem cst-equiv)))
 :rule-classes :congruence)

Function: cst-single-character-conc-rep-elem

(defun cst-single-character-conc-rep-elem (abnf::cst)
  (declare (xargs :guard (abnf::treep abnf::cst)))
  (declare (xargs :guard (cst-matchp abnf::cst "single-character")))
  (abnf::tree-fix (nth 0
                       (cst-single-character-conc-rep abnf::cst))))

Theorem: treep-of-cst-single-character-conc-rep-elem

(defthm treep-of-cst-single-character-conc-rep-elem
  (b* ((abnf::cst1 (cst-single-character-conc-rep-elem abnf::cst)))
    (abnf::treep abnf::cst1))
  :rule-classes :rewrite)

Theorem: cst-single-character-conc-rep-elem-match

(defthm cst-single-character-conc-rep-elem-match
 (implies
   (cst-matchp abnf::cst "single-character")
   (b* ((abnf::cst1 (cst-single-character-conc-rep-elem abnf::cst)))
     (cst-matchp abnf::cst1 "input-character")))
 :rule-classes :rewrite)

Theorem: cst-single-character-conc-rep-elem-of-tree-fix-cst

(defthm cst-single-character-conc-rep-elem-of-tree-fix-cst
 (equal
     (cst-single-character-conc-rep-elem (abnf::tree-fix abnf::cst))
     (cst-single-character-conc-rep-elem abnf::cst)))

Theorem: cst-single-character-conc-rep-elem-tree-equiv-congruence-on-cst

(defthm
    cst-single-character-conc-rep-elem-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-single-character-conc-rep-elem abnf::cst)
                  (cst-single-character-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))))
 (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 "input-character")))
 :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))))
 (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 "escape-sequence")))
 :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-text-block-white-space-conc-rep-elem

(defun cst-text-block-white-space-conc-rep-elem (abnf::cst)
 (declare (xargs :guard (abnf::treep abnf::cst)))
 (declare
     (xargs :guard (cst-matchp abnf::cst "text-block-white-space")))
 (abnf::tree-fix
      (nth 0
           (cst-text-block-white-space-conc-rep abnf::cst))))

Theorem: treep-of-cst-text-block-white-space-conc-rep-elem

(defthm treep-of-cst-text-block-white-space-conc-rep-elem
  (b* ((abnf::cst1
            (cst-text-block-white-space-conc-rep-elem abnf::cst)))
    (abnf::treep abnf::cst1))
  :rule-classes :rewrite)

Theorem: cst-text-block-white-space-conc-rep-elem-match

(defthm cst-text-block-white-space-conc-rep-elem-match
 (implies
    (cst-matchp abnf::cst "text-block-white-space")
    (b* ((abnf::cst1
              (cst-text-block-white-space-conc-rep-elem abnf::cst)))
      (cst-matchp abnf::cst1 "white-space")))
 :rule-classes :rewrite)

Theorem: cst-text-block-white-space-conc-rep-elem-of-tree-fix-cst

(defthm cst-text-block-white-space-conc-rep-elem-of-tree-fix-cst
  (equal (cst-text-block-white-space-conc-rep-elem
              (abnf::tree-fix abnf::cst))
         (cst-text-block-white-space-conc-rep-elem abnf::cst)))

Theorem: cst-text-block-white-space-conc-rep-elem-tree-equiv-congruence-on-cst

(defthm
 cst-text-block-white-space-conc-rep-elem-tree-equiv-congruence-on-cst
 (implies
      (abnf::tree-equiv abnf::cst cst-equiv)
      (equal (cst-text-block-white-space-conc-rep-elem abnf::cst)
             (cst-text-block-white-space-conc-rep-elem cst-equiv)))
 :rule-classes :congruence)

Function: cst-text-block-character-conc1-rep-elem

(defun cst-text-block-character-conc1-rep-elem (abnf::cst)
 (declare (xargs :guard (abnf::treep abnf::cst)))
 (declare
  (xargs
       :guard (and (cst-matchp abnf::cst "text-block-character")
                   (equal (cst-text-block-character-conc? abnf::cst)
                          1))))
 (abnf::tree-fix
      (nth 0
           (cst-text-block-character-conc1-rep abnf::cst))))

Theorem: treep-of-cst-text-block-character-conc1-rep-elem

(defthm treep-of-cst-text-block-character-conc1-rep-elem
 (b*
  ((abnf::cst1 (cst-text-block-character-conc1-rep-elem abnf::cst)))
  (abnf::treep abnf::cst1))
 :rule-classes :rewrite)

Theorem: cst-text-block-character-conc1-rep-elem-match

(defthm cst-text-block-character-conc1-rep-elem-match
 (implies
     (and (cst-matchp abnf::cst "text-block-character")
          (equal (cst-text-block-character-conc? abnf::cst)
                 1))
     (b* ((abnf::cst1
               (cst-text-block-character-conc1-rep-elem abnf::cst)))
       (cst-matchp abnf::cst1 "input-character")))
 :rule-classes :rewrite)

Theorem: cst-text-block-character-conc1-rep-elem-of-tree-fix-cst

(defthm cst-text-block-character-conc1-rep-elem-of-tree-fix-cst
  (equal (cst-text-block-character-conc1-rep-elem
              (abnf::tree-fix abnf::cst))
         (cst-text-block-character-conc1-rep-elem abnf::cst)))

Theorem: cst-text-block-character-conc1-rep-elem-tree-equiv-congruence-on-cst

(defthm
 cst-text-block-character-conc1-rep-elem-tree-equiv-congruence-on-cst
 (implies
      (abnf::tree-equiv abnf::cst cst-equiv)
      (equal (cst-text-block-character-conc1-rep-elem abnf::cst)
             (cst-text-block-character-conc1-rep-elem cst-equiv)))
 :rule-classes :congruence)

Function: cst-text-block-character-conc2-rep-elem

(defun cst-text-block-character-conc2-rep-elem (abnf::cst)
 (declare (xargs :guard (abnf::treep abnf::cst)))
 (declare
  (xargs
       :guard (and (cst-matchp abnf::cst "text-block-character")
                   (equal (cst-text-block-character-conc? abnf::cst)
                          2))))
 (abnf::tree-fix
      (nth 0
           (cst-text-block-character-conc2-rep abnf::cst))))

Theorem: treep-of-cst-text-block-character-conc2-rep-elem

(defthm treep-of-cst-text-block-character-conc2-rep-elem
 (b*
  ((abnf::cst1 (cst-text-block-character-conc2-rep-elem abnf::cst)))
  (abnf::treep abnf::cst1))
 :rule-classes :rewrite)

Theorem: cst-text-block-character-conc2-rep-elem-match

(defthm cst-text-block-character-conc2-rep-elem-match
 (implies
     (and (cst-matchp abnf::cst "text-block-character")
          (equal (cst-text-block-character-conc? abnf::cst)
                 2))
     (b* ((abnf::cst1
               (cst-text-block-character-conc2-rep-elem abnf::cst)))
       (cst-matchp abnf::cst1 "escape-sequence")))
 :rule-classes :rewrite)

Theorem: cst-text-block-character-conc2-rep-elem-of-tree-fix-cst

(defthm cst-text-block-character-conc2-rep-elem-of-tree-fix-cst
  (equal (cst-text-block-character-conc2-rep-elem
              (abnf::tree-fix abnf::cst))
         (cst-text-block-character-conc2-rep-elem abnf::cst)))

Theorem: cst-text-block-character-conc2-rep-elem-tree-equiv-congruence-on-cst

(defthm
 cst-text-block-character-conc2-rep-elem-tree-equiv-congruence-on-cst
 (implies
      (abnf::tree-equiv abnf::cst cst-equiv)
      (equal (cst-text-block-character-conc2-rep-elem abnf::cst)
             (cst-text-block-character-conc2-rep-elem cst-equiv)))
 :rule-classes :congruence)

Function: cst-text-block-character-conc3-rep-elem

(defun cst-text-block-character-conc3-rep-elem (abnf::cst)
 (declare (xargs :guard (abnf::treep abnf::cst)))
 (declare
  (xargs
       :guard (and (cst-matchp abnf::cst "text-block-character")
                   (equal (cst-text-block-character-conc? abnf::cst)
                          3))))
 (abnf::tree-fix
      (nth 0
           (cst-text-block-character-conc3-rep abnf::cst))))

Theorem: treep-of-cst-text-block-character-conc3-rep-elem

(defthm treep-of-cst-text-block-character-conc3-rep-elem
 (b*
  ((abnf::cst1 (cst-text-block-character-conc3-rep-elem abnf::cst)))
  (abnf::treep abnf::cst1))
 :rule-classes :rewrite)

Theorem: cst-text-block-character-conc3-rep-elem-match

(defthm cst-text-block-character-conc3-rep-elem-match
 (implies
     (and (cst-matchp abnf::cst "text-block-character")
          (equal (cst-text-block-character-conc? abnf::cst)
                 3))
     (b* ((abnf::cst1
               (cst-text-block-character-conc3-rep-elem abnf::cst)))
       (cst-matchp abnf::cst1 "line-terminator")))
 :rule-classes :rewrite)

Theorem: cst-text-block-character-conc3-rep-elem-of-tree-fix-cst

(defthm cst-text-block-character-conc3-rep-elem-of-tree-fix-cst
  (equal (cst-text-block-character-conc3-rep-elem
              (abnf::tree-fix abnf::cst))
         (cst-text-block-character-conc3-rep-elem abnf::cst)))

Theorem: cst-text-block-character-conc3-rep-elem-tree-equiv-congruence-on-cst

(defthm
 cst-text-block-character-conc3-rep-elem-tree-equiv-congruence-on-cst
 (implies
      (abnf::tree-equiv abnf::cst cst-equiv)
      (equal (cst-text-block-character-conc3-rep-elem abnf::cst)
             (cst-text-block-character-conc3-rep-elem cst-equiv)))
 :rule-classes :congruence)

Function: cst-null-literal-conc-rep-elem

(defun cst-null-literal-conc-rep-elem (abnf::cst)
  (declare (xargs :guard (abnf::treep abnf::cst)))
  (declare (xargs :guard (cst-matchp abnf::cst "null-literal")))
  (abnf::tree-fix (nth 0
                       (cst-null-literal-conc-rep abnf::cst))))

Theorem: treep-of-cst-null-literal-conc-rep-elem

(defthm treep-of-cst-null-literal-conc-rep-elem
  (b* ((abnf::cst1 (cst-null-literal-conc-rep-elem abnf::cst)))
    (abnf::treep abnf::cst1))
  :rule-classes :rewrite)

Theorem: cst-null-literal-conc-rep-elem-match

(defthm cst-null-literal-conc-rep-elem-match
  (implies
       (cst-matchp abnf::cst "null-literal")
       (b* ((abnf::cst1 (cst-null-literal-conc-rep-elem abnf::cst)))
         (cst-matchp abnf::cst1 "%s\"null\"")))
  :rule-classes :rewrite)

Theorem: cst-null-literal-conc-rep-elem-of-tree-fix-cst

(defthm cst-null-literal-conc-rep-elem-of-tree-fix-cst
  (equal (cst-null-literal-conc-rep-elem (abnf::tree-fix abnf::cst))
         (cst-null-literal-conc-rep-elem abnf::cst)))

Theorem: cst-null-literal-conc-rep-elem-tree-equiv-congruence-on-cst

(defthm cst-null-literal-conc-rep-elem-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-null-literal-conc-rep-elem abnf::cst)
                  (cst-null-literal-conc-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))))
 (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))))
 (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 "reference-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-numeric-type-conc1-rep-elem

(defun cst-numeric-type-conc1-rep-elem (abnf::cst)
  (declare (xargs :guard (abnf::treep abnf::cst)))
  (declare
       (xargs :guard (and (cst-matchp abnf::cst "numeric-type")
                          (equal (cst-numeric-type-conc? abnf::cst)
                                 1))))
  (abnf::tree-fix (nth 0
                       (cst-numeric-type-conc1-rep abnf::cst))))

Theorem: treep-of-cst-numeric-type-conc1-rep-elem

(defthm treep-of-cst-numeric-type-conc1-rep-elem
  (b* ((abnf::cst1 (cst-numeric-type-conc1-rep-elem abnf::cst)))
    (abnf::treep abnf::cst1))
  :rule-classes :rewrite)

Theorem: cst-numeric-type-conc1-rep-elem-match

(defthm cst-numeric-type-conc1-rep-elem-match
 (implies
      (and (cst-matchp abnf::cst "numeric-type")
           (equal (cst-numeric-type-conc? abnf::cst)
                  1))
      (b* ((abnf::cst1 (cst-numeric-type-conc1-rep-elem abnf::cst)))
        (cst-matchp abnf::cst1 "integral-type")))
 :rule-classes :rewrite)

Theorem: cst-numeric-type-conc1-rep-elem-of-tree-fix-cst

(defthm cst-numeric-type-conc1-rep-elem-of-tree-fix-cst
 (equal (cst-numeric-type-conc1-rep-elem (abnf::tree-fix abnf::cst))
        (cst-numeric-type-conc1-rep-elem abnf::cst)))

Theorem: cst-numeric-type-conc1-rep-elem-tree-equiv-congruence-on-cst

(defthm cst-numeric-type-conc1-rep-elem-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-numeric-type-conc1-rep-elem abnf::cst)
                  (cst-numeric-type-conc1-rep-elem cst-equiv)))
  :rule-classes :congruence)

Function: cst-numeric-type-conc2-rep-elem

(defun cst-numeric-type-conc2-rep-elem (abnf::cst)
  (declare (xargs :guard (abnf::treep abnf::cst)))
  (declare
       (xargs :guard (and (cst-matchp abnf::cst "numeric-type")
                          (equal (cst-numeric-type-conc? abnf::cst)
                                 2))))
  (abnf::tree-fix (nth 0
                       (cst-numeric-type-conc2-rep abnf::cst))))

Theorem: treep-of-cst-numeric-type-conc2-rep-elem

(defthm treep-of-cst-numeric-type-conc2-rep-elem
  (b* ((abnf::cst1 (cst-numeric-type-conc2-rep-elem abnf::cst)))
    (abnf::treep abnf::cst1))
  :rule-classes :rewrite)

Theorem: cst-numeric-type-conc2-rep-elem-match

(defthm cst-numeric-type-conc2-rep-elem-match
 (implies
      (and (cst-matchp abnf::cst "numeric-type")
           (equal (cst-numeric-type-conc? abnf::cst)
                  2))
      (b* ((abnf::cst1 (cst-numeric-type-conc2-rep-elem abnf::cst)))
        (cst-matchp abnf::cst1 "floating-point-type")))
 :rule-classes :rewrite)

Theorem: cst-numeric-type-conc2-rep-elem-of-tree-fix-cst

(defthm cst-numeric-type-conc2-rep-elem-of-tree-fix-cst
 (equal (cst-numeric-type-conc2-rep-elem (abnf::tree-fix abnf::cst))
        (cst-numeric-type-conc2-rep-elem abnf::cst)))

Theorem: cst-numeric-type-conc2-rep-elem-tree-equiv-congruence-on-cst

(defthm cst-numeric-type-conc2-rep-elem-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-numeric-type-conc2-rep-elem abnf::cst)
                  (cst-numeric-type-conc2-rep-elem cst-equiv)))
  :rule-classes :congruence)

Function: cst-reference-type-conc1-rep-elem

(defun cst-reference-type-conc1-rep-elem (abnf::cst)
 (declare (xargs :guard (abnf::treep abnf::cst)))
 (declare
      (xargs :guard (and (cst-matchp abnf::cst "reference-type")
                         (equal (cst-reference-type-conc? abnf::cst)
                                1))))
 (abnf::tree-fix (nth 0
                      (cst-reference-type-conc1-rep abnf::cst))))

Theorem: treep-of-cst-reference-type-conc1-rep-elem

(defthm treep-of-cst-reference-type-conc1-rep-elem
  (b* ((abnf::cst1 (cst-reference-type-conc1-rep-elem abnf::cst)))
    (abnf::treep abnf::cst1))
  :rule-classes :rewrite)

Theorem: cst-reference-type-conc1-rep-elem-match

(defthm cst-reference-type-conc1-rep-elem-match
 (implies
    (and (cst-matchp abnf::cst "reference-type")
         (equal (cst-reference-type-conc? abnf::cst)
                1))
    (b* ((abnf::cst1 (cst-reference-type-conc1-rep-elem abnf::cst)))
      (cst-matchp abnf::cst1 "class-or-interface-type")))
 :rule-classes :rewrite)

Theorem: cst-reference-type-conc1-rep-elem-of-tree-fix-cst

(defthm cst-reference-type-conc1-rep-elem-of-tree-fix-cst
 (equal
      (cst-reference-type-conc1-rep-elem (abnf::tree-fix abnf::cst))
      (cst-reference-type-conc1-rep-elem abnf::cst)))

Theorem: cst-reference-type-conc1-rep-elem-tree-equiv-congruence-on-cst

(defthm
     cst-reference-type-conc1-rep-elem-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-reference-type-conc1-rep-elem abnf::cst)
                  (cst-reference-type-conc1-rep-elem cst-equiv)))
  :rule-classes :congruence)

Function: cst-reference-type-conc2-rep-elem

(defun cst-reference-type-conc2-rep-elem (abnf::cst)
 (declare (xargs :guard (abnf::treep abnf::cst)))
 (declare
      (xargs :guard (and (cst-matchp abnf::cst "reference-type")
                         (equal (cst-reference-type-conc? abnf::cst)
                                2))))
 (abnf::tree-fix (nth 0
                      (cst-reference-type-conc2-rep abnf::cst))))

Theorem: treep-of-cst-reference-type-conc2-rep-elem

(defthm treep-of-cst-reference-type-conc2-rep-elem
  (b* ((abnf::cst1 (cst-reference-type-conc2-rep-elem abnf::cst)))
    (abnf::treep abnf::cst1))
  :rule-classes :rewrite)

Theorem: cst-reference-type-conc2-rep-elem-match

(defthm cst-reference-type-conc2-rep-elem-match
 (implies
    (and (cst-matchp abnf::cst "reference-type")
         (equal (cst-reference-type-conc? abnf::cst)
                2))
    (b* ((abnf::cst1 (cst-reference-type-conc2-rep-elem abnf::cst)))
      (cst-matchp abnf::cst1 "type-variable")))
 :rule-classes :rewrite)

Theorem: cst-reference-type-conc2-rep-elem-of-tree-fix-cst

(defthm cst-reference-type-conc2-rep-elem-of-tree-fix-cst
 (equal
      (cst-reference-type-conc2-rep-elem (abnf::tree-fix abnf::cst))
      (cst-reference-type-conc2-rep-elem abnf::cst)))

Theorem: cst-reference-type-conc2-rep-elem-tree-equiv-congruence-on-cst

(defthm
     cst-reference-type-conc2-rep-elem-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-reference-type-conc2-rep-elem abnf::cst)
                  (cst-reference-type-conc2-rep-elem cst-equiv)))
  :rule-classes :congruence)

Function: cst-reference-type-conc3-rep-elem

(defun cst-reference-type-conc3-rep-elem (abnf::cst)
 (declare (xargs :guard (abnf::treep abnf::cst)))
 (declare
      (xargs :guard (and (cst-matchp abnf::cst "reference-type")
                         (equal (cst-reference-type-conc? abnf::cst)
                                3))))
 (abnf::tree-fix (nth 0
                      (cst-reference-type-conc3-rep abnf::cst))))

Theorem: treep-of-cst-reference-type-conc3-rep-elem

(defthm treep-of-cst-reference-type-conc3-rep-elem
  (b* ((abnf::cst1 (cst-reference-type-conc3-rep-elem abnf::cst)))
    (abnf::treep abnf::cst1))
  :rule-classes :rewrite)

Theorem: cst-reference-type-conc3-rep-elem-match

(defthm cst-reference-type-conc3-rep-elem-match
 (implies
    (and (cst-matchp abnf::cst "reference-type")
         (equal (cst-reference-type-conc? abnf::cst)
                3))
    (b* ((abnf::cst1 (cst-reference-type-conc3-rep-elem abnf::cst)))
      (cst-matchp abnf::cst1 "array-type")))
 :rule-classes :rewrite)

Theorem: cst-reference-type-conc3-rep-elem-of-tree-fix-cst

(defthm cst-reference-type-conc3-rep-elem-of-tree-fix-cst
 (equal
      (cst-reference-type-conc3-rep-elem (abnf::tree-fix abnf::cst))
      (cst-reference-type-conc3-rep-elem abnf::cst)))

Theorem: cst-reference-type-conc3-rep-elem-tree-equiv-congruence-on-cst

(defthm
     cst-reference-type-conc3-rep-elem-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-reference-type-conc3-rep-elem abnf::cst)
                  (cst-reference-type-conc3-rep-elem cst-equiv)))
  :rule-classes :congruence)

Function: cst-class-or-interface-type-conc1-rep-elem

(defun cst-class-or-interface-type-conc1-rep-elem (abnf::cst)
 (declare (xargs :guard (abnf::treep abnf::cst)))
 (declare
  (xargs
    :guard (and (cst-matchp abnf::cst "class-or-interface-type")
                (equal (cst-class-or-interface-type-conc? abnf::cst)
                       1))))
 (abnf::tree-fix
      (nth 0
           (cst-class-or-interface-type-conc1-rep abnf::cst))))

Theorem: treep-of-cst-class-or-interface-type-conc1-rep-elem

(defthm treep-of-cst-class-or-interface-type-conc1-rep-elem
  (b* ((abnf::cst1
            (cst-class-or-interface-type-conc1-rep-elem abnf::cst)))
    (abnf::treep abnf::cst1))
  :rule-classes :rewrite)

Theorem: cst-class-or-interface-type-conc1-rep-elem-match

(defthm cst-class-or-interface-type-conc1-rep-elem-match
 (implies
  (and (cst-matchp abnf::cst "class-or-interface-type")
       (equal (cst-class-or-interface-type-conc? abnf::cst)
              1))
  (b* ((abnf::cst1
            (cst-class-or-interface-type-conc1-rep-elem abnf::cst)))
    (cst-matchp abnf::cst1 "class-type")))
 :rule-classes :rewrite)

Theorem: cst-class-or-interface-type-conc1-rep-elem-of-tree-fix-cst

(defthm cst-class-or-interface-type-conc1-rep-elem-of-tree-fix-cst
  (equal (cst-class-or-interface-type-conc1-rep-elem
              (abnf::tree-fix abnf::cst))
         (cst-class-or-interface-type-conc1-rep-elem abnf::cst)))

Theorem: cst-class-or-interface-type-conc1-rep-elem-tree-equiv-congruence-on-cst

(defthm
 cst-class-or-interface-type-conc1-rep-elem-tree-equiv-congruence-on-cst
 (implies
     (abnf::tree-equiv abnf::cst cst-equiv)
     (equal (cst-class-or-interface-type-conc1-rep-elem abnf::cst)
            (cst-class-or-interface-type-conc1-rep-elem cst-equiv)))
 :rule-classes :congruence)

Function: cst-class-or-interface-type-conc2-rep-elem

(defun cst-class-or-interface-type-conc2-rep-elem (abnf::cst)
 (declare (xargs :guard (abnf::treep abnf::cst)))
 (declare
  (xargs
    :guard (and (cst-matchp abnf::cst "class-or-interface-type")
                (equal (cst-class-or-interface-type-conc? abnf::cst)
                       2))))
 (abnf::tree-fix
      (nth 0
           (cst-class-or-interface-type-conc2-rep abnf::cst))))

Theorem: treep-of-cst-class-or-interface-type-conc2-rep-elem

(defthm treep-of-cst-class-or-interface-type-conc2-rep-elem
  (b* ((abnf::cst1
            (cst-class-or-interface-type-conc2-rep-elem abnf::cst)))
    (abnf::treep abnf::cst1))
  :rule-classes :rewrite)

Theorem: cst-class-or-interface-type-conc2-rep-elem-match

(defthm cst-class-or-interface-type-conc2-rep-elem-match
 (implies
  (and (cst-matchp abnf::cst "class-or-interface-type")
       (equal (cst-class-or-interface-type-conc? abnf::cst)
              2))
  (b* ((abnf::cst1
            (cst-class-or-interface-type-conc2-rep-elem abnf::cst)))
    (cst-matchp abnf::cst1 "interface-type")))
 :rule-classes :rewrite)

Theorem: cst-class-or-interface-type-conc2-rep-elem-of-tree-fix-cst

(defthm cst-class-or-interface-type-conc2-rep-elem-of-tree-fix-cst
  (equal (cst-class-or-interface-type-conc2-rep-elem
              (abnf::tree-fix abnf::cst))
         (cst-class-or-interface-type-conc2-rep-elem abnf::cst)))

Theorem: cst-class-or-interface-type-conc2-rep-elem-tree-equiv-congruence-on-cst

(defthm
 cst-class-or-interface-type-conc2-rep-elem-tree-equiv-congruence-on-cst
 (implies
     (abnf::tree-equiv abnf::cst cst-equiv)
     (equal (cst-class-or-interface-type-conc2-rep-elem abnf::cst)
            (cst-class-or-interface-type-conc2-rep-elem cst-equiv)))
 :rule-classes :congruence)

Function: cst-interface-type-conc-rep-elem

(defun cst-interface-type-conc-rep-elem (abnf::cst)
  (declare (xargs :guard (abnf::treep abnf::cst)))
  (declare (xargs :guard (cst-matchp abnf::cst "interface-type")))
  (abnf::tree-fix (nth 0
                       (cst-interface-type-conc-rep abnf::cst))))

Theorem: treep-of-cst-interface-type-conc-rep-elem

(defthm treep-of-cst-interface-type-conc-rep-elem
  (b* ((abnf::cst1 (cst-interface-type-conc-rep-elem abnf::cst)))
    (abnf::treep abnf::cst1))
  :rule-classes :rewrite)

Theorem: cst-interface-type-conc-rep-elem-match

(defthm cst-interface-type-conc-rep-elem-match
 (implies
     (cst-matchp abnf::cst "interface-type")
     (b* ((abnf::cst1 (cst-interface-type-conc-rep-elem abnf::cst)))
       (cst-matchp abnf::cst1 "class-type")))
 :rule-classes :rewrite)

Theorem: cst-interface-type-conc-rep-elem-of-tree-fix-cst

(defthm cst-interface-type-conc-rep-elem-of-tree-fix-cst
  (equal
       (cst-interface-type-conc-rep-elem (abnf::tree-fix abnf::cst))
       (cst-interface-type-conc-rep-elem abnf::cst)))

Theorem: cst-interface-type-conc-rep-elem-tree-equiv-congruence-on-cst

(defthm
      cst-interface-type-conc-rep-elem-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-interface-type-conc-rep-elem abnf::cst)
                  (cst-interface-type-conc-rep-elem cst-equiv)))
  :rule-classes :congruence)

Function: cst-type-parameter-modifier-conc-rep-elem

(defun cst-type-parameter-modifier-conc-rep-elem (abnf::cst)
 (declare (xargs :guard (abnf::treep abnf::cst)))
 (declare
    (xargs :guard (cst-matchp abnf::cst "type-parameter-modifier")))
 (abnf::tree-fix
      (nth 0
           (cst-type-parameter-modifier-conc-rep abnf::cst))))

Theorem: treep-of-cst-type-parameter-modifier-conc-rep-elem

(defthm treep-of-cst-type-parameter-modifier-conc-rep-elem
  (b* ((abnf::cst1
            (cst-type-parameter-modifier-conc-rep-elem abnf::cst)))
    (abnf::treep abnf::cst1))
  :rule-classes :rewrite)

Theorem: cst-type-parameter-modifier-conc-rep-elem-match

(defthm cst-type-parameter-modifier-conc-rep-elem-match
 (implies
   (cst-matchp abnf::cst "type-parameter-modifier")
   (b* ((abnf::cst1
             (cst-type-parameter-modifier-conc-rep-elem abnf::cst)))
     (cst-matchp abnf::cst1 "annotation")))
 :rule-classes :rewrite)

Theorem: cst-type-parameter-modifier-conc-rep-elem-of-tree-fix-cst

(defthm cst-type-parameter-modifier-conc-rep-elem-of-tree-fix-cst
  (equal (cst-type-parameter-modifier-conc-rep-elem
              (abnf::tree-fix abnf::cst))
         (cst-type-parameter-modifier-conc-rep-elem abnf::cst)))

Theorem: cst-type-parameter-modifier-conc-rep-elem-tree-equiv-congruence-on-cst

(defthm
 cst-type-parameter-modifier-conc-rep-elem-tree-equiv-congruence-on-cst
 (implies
      (abnf::tree-equiv abnf::cst cst-equiv)
      (equal (cst-type-parameter-modifier-conc-rep-elem abnf::cst)
             (cst-type-parameter-modifier-conc-rep-elem cst-equiv)))
 :rule-classes :congruence)

Function: cst-type-argument-conc1-rep-elem

(defun cst-type-argument-conc1-rep-elem (abnf::cst)
  (declare (xargs :guard (abnf::treep abnf::cst)))
  (declare
       (xargs :guard (and (cst-matchp abnf::cst "type-argument")
                          (equal (cst-type-argument-conc? abnf::cst)
                                 1))))
  (abnf::tree-fix (nth 0
                       (cst-type-argument-conc1-rep abnf::cst))))

Theorem: treep-of-cst-type-argument-conc1-rep-elem

(defthm treep-of-cst-type-argument-conc1-rep-elem
  (b* ((abnf::cst1 (cst-type-argument-conc1-rep-elem abnf::cst)))
    (abnf::treep abnf::cst1))
  :rule-classes :rewrite)

Theorem: cst-type-argument-conc1-rep-elem-match

(defthm cst-type-argument-conc1-rep-elem-match
 (implies
     (and (cst-matchp abnf::cst "type-argument")
          (equal (cst-type-argument-conc? abnf::cst)
                 1))
     (b* ((abnf::cst1 (cst-type-argument-conc1-rep-elem abnf::cst)))
       (cst-matchp abnf::cst1 "reference-type")))
 :rule-classes :rewrite)

Theorem: cst-type-argument-conc1-rep-elem-of-tree-fix-cst

(defthm cst-type-argument-conc1-rep-elem-of-tree-fix-cst
  (equal
       (cst-type-argument-conc1-rep-elem (abnf::tree-fix abnf::cst))
       (cst-type-argument-conc1-rep-elem abnf::cst)))

Theorem: cst-type-argument-conc1-rep-elem-tree-equiv-congruence-on-cst

(defthm
      cst-type-argument-conc1-rep-elem-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-type-argument-conc1-rep-elem abnf::cst)
                  (cst-type-argument-conc1-rep-elem cst-equiv)))
  :rule-classes :congruence)

Function: cst-type-argument-conc2-rep-elem

(defun cst-type-argument-conc2-rep-elem (abnf::cst)
  (declare (xargs :guard (abnf::treep abnf::cst)))
  (declare
       (xargs :guard (and (cst-matchp abnf::cst "type-argument")
                          (equal (cst-type-argument-conc? abnf::cst)
                                 2))))
  (abnf::tree-fix (nth 0
                       (cst-type-argument-conc2-rep abnf::cst))))

Theorem: treep-of-cst-type-argument-conc2-rep-elem

(defthm treep-of-cst-type-argument-conc2-rep-elem
  (b* ((abnf::cst1 (cst-type-argument-conc2-rep-elem abnf::cst)))
    (abnf::treep abnf::cst1))
  :rule-classes :rewrite)

Theorem: cst-type-argument-conc2-rep-elem-match

(defthm cst-type-argument-conc2-rep-elem-match
 (implies
     (and (cst-matchp abnf::cst "type-argument")
          (equal (cst-type-argument-conc? abnf::cst)
                 2))
     (b* ((abnf::cst1 (cst-type-argument-conc2-rep-elem abnf::cst)))
       (cst-matchp abnf::cst1 "wildcard")))
 :rule-classes :rewrite)

Theorem: cst-type-argument-conc2-rep-elem-of-tree-fix-cst

(defthm cst-type-argument-conc2-rep-elem-of-tree-fix-cst
  (equal
       (cst-type-argument-conc2-rep-elem (abnf::tree-fix abnf::cst))
       (cst-type-argument-conc2-rep-elem abnf::cst)))

Theorem: cst-type-argument-conc2-rep-elem-tree-equiv-congruence-on-cst

(defthm
      cst-type-argument-conc2-rep-elem-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-type-argument-conc2-rep-elem abnf::cst)
                  (cst-type-argument-conc2-rep-elem cst-equiv)))
  :rule-classes :congruence)

Function: cst-method-name-conc-rep-elem

(defun cst-method-name-conc-rep-elem (abnf::cst)
  (declare (xargs :guard (abnf::treep abnf::cst)))
  (declare (xargs :guard (cst-matchp abnf::cst "method-name")))
  (abnf::tree-fix (nth 0
                       (cst-method-name-conc-rep abnf::cst))))

Theorem: treep-of-cst-method-name-conc-rep-elem

(defthm treep-of-cst-method-name-conc-rep-elem
  (b* ((abnf::cst1 (cst-method-name-conc-rep-elem abnf::cst)))
    (abnf::treep abnf::cst1))
  :rule-classes :rewrite)

Theorem: cst-method-name-conc-rep-elem-match

(defthm cst-method-name-conc-rep-elem-match
  (implies
       (cst-matchp abnf::cst "method-name")
       (b* ((abnf::cst1 (cst-method-name-conc-rep-elem abnf::cst)))
         (cst-matchp abnf::cst1
                     "unqualified-method-identifier")))
  :rule-classes :rewrite)

Theorem: cst-method-name-conc-rep-elem-of-tree-fix-cst

(defthm cst-method-name-conc-rep-elem-of-tree-fix-cst
  (equal (cst-method-name-conc-rep-elem (abnf::tree-fix abnf::cst))
         (cst-method-name-conc-rep-elem abnf::cst)))

Theorem: cst-method-name-conc-rep-elem-tree-equiv-congruence-on-cst

(defthm cst-method-name-conc-rep-elem-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-method-name-conc-rep-elem abnf::cst)
                  (cst-method-name-conc-rep-elem cst-equiv)))
  :rule-classes :congruence)

Function: cst-compilation-unit-conc1-rep-elem

(defun cst-compilation-unit-conc1-rep-elem (abnf::cst)
 (declare (xargs :guard (abnf::treep abnf::cst)))
 (declare
    (xargs :guard (and (cst-matchp abnf::cst "compilation-unit")
                       (equal (cst-compilation-unit-conc? abnf::cst)
                              1))))
 (abnf::tree-fix (nth 0
                      (cst-compilation-unit-conc1-rep abnf::cst))))

Theorem: treep-of-cst-compilation-unit-conc1-rep-elem

(defthm treep-of-cst-compilation-unit-conc1-rep-elem
  (b* ((abnf::cst1 (cst-compilation-unit-conc1-rep-elem abnf::cst)))
    (abnf::treep abnf::cst1))
  :rule-classes :rewrite)

Theorem: cst-compilation-unit-conc1-rep-elem-match

(defthm cst-compilation-unit-conc1-rep-elem-match
 (implies
  (and (cst-matchp abnf::cst "compilation-unit")
       (equal (cst-compilation-unit-conc? abnf::cst)
              1))
  (b* ((abnf::cst1 (cst-compilation-unit-conc1-rep-elem abnf::cst)))
    (cst-matchp abnf::cst1
                "ordinary-compilation-unit")))
 :rule-classes :rewrite)

Theorem: cst-compilation-unit-conc1-rep-elem-of-tree-fix-cst

(defthm cst-compilation-unit-conc1-rep-elem-of-tree-fix-cst
 (equal
    (cst-compilation-unit-conc1-rep-elem (abnf::tree-fix abnf::cst))
    (cst-compilation-unit-conc1-rep-elem abnf::cst)))

Theorem: cst-compilation-unit-conc1-rep-elem-tree-equiv-congruence-on-cst

(defthm
   cst-compilation-unit-conc1-rep-elem-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-compilation-unit-conc1-rep-elem abnf::cst)
                  (cst-compilation-unit-conc1-rep-elem cst-equiv)))
  :rule-classes :congruence)

Function: cst-compilation-unit-conc2-rep-elem

(defun cst-compilation-unit-conc2-rep-elem (abnf::cst)
 (declare (xargs :guard (abnf::treep abnf::cst)))
 (declare
    (xargs :guard (and (cst-matchp abnf::cst "compilation-unit")
                       (equal (cst-compilation-unit-conc? abnf::cst)
                              2))))
 (abnf::tree-fix (nth 0
                      (cst-compilation-unit-conc2-rep abnf::cst))))

Theorem: treep-of-cst-compilation-unit-conc2-rep-elem

(defthm treep-of-cst-compilation-unit-conc2-rep-elem
  (b* ((abnf::cst1 (cst-compilation-unit-conc2-rep-elem abnf::cst)))
    (abnf::treep abnf::cst1))
  :rule-classes :rewrite)

Theorem: cst-compilation-unit-conc2-rep-elem-match

(defthm cst-compilation-unit-conc2-rep-elem-match
 (implies
  (and (cst-matchp abnf::cst "compilation-unit")
       (equal (cst-compilation-unit-conc? abnf::cst)
              2))
  (b* ((abnf::cst1 (cst-compilation-unit-conc2-rep-elem abnf::cst)))
    (cst-matchp abnf::cst1 "compact-compilation-unit")))
 :rule-classes :rewrite)

Theorem: cst-compilation-unit-conc2-rep-elem-of-tree-fix-cst

(defthm cst-compilation-unit-conc2-rep-elem-of-tree-fix-cst
 (equal
    (cst-compilation-unit-conc2-rep-elem (abnf::tree-fix abnf::cst))
    (cst-compilation-unit-conc2-rep-elem abnf::cst)))

Theorem: cst-compilation-unit-conc2-rep-elem-tree-equiv-congruence-on-cst

(defthm
   cst-compilation-unit-conc2-rep-elem-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-compilation-unit-conc2-rep-elem abnf::cst)
                  (cst-compilation-unit-conc2-rep-elem cst-equiv)))
  :rule-classes :congruence)

Function: cst-compilation-unit-conc3-rep-elem

(defun cst-compilation-unit-conc3-rep-elem (abnf::cst)
 (declare (xargs :guard (abnf::treep abnf::cst)))
 (declare
    (xargs :guard (and (cst-matchp abnf::cst "compilation-unit")
                       (equal (cst-compilation-unit-conc? abnf::cst)
                              3))))
 (abnf::tree-fix (nth 0
                      (cst-compilation-unit-conc3-rep abnf::cst))))

Theorem: treep-of-cst-compilation-unit-conc3-rep-elem

(defthm treep-of-cst-compilation-unit-conc3-rep-elem
  (b* ((abnf::cst1 (cst-compilation-unit-conc3-rep-elem abnf::cst)))
    (abnf::treep abnf::cst1))
  :rule-classes :rewrite)

Theorem: cst-compilation-unit-conc3-rep-elem-match

(defthm cst-compilation-unit-conc3-rep-elem-match
 (implies
  (and (cst-matchp abnf::cst "compilation-unit")
       (equal (cst-compilation-unit-conc? abnf::cst)
              3))
  (b* ((abnf::cst1 (cst-compilation-unit-conc3-rep-elem abnf::cst)))
    (cst-matchp abnf::cst1 "modular-compilation-unit")))
 :rule-classes :rewrite)

Theorem: cst-compilation-unit-conc3-rep-elem-of-tree-fix-cst

(defthm cst-compilation-unit-conc3-rep-elem-of-tree-fix-cst
 (equal
    (cst-compilation-unit-conc3-rep-elem (abnf::tree-fix abnf::cst))
    (cst-compilation-unit-conc3-rep-elem abnf::cst)))

Theorem: cst-compilation-unit-conc3-rep-elem-tree-equiv-congruence-on-cst

(defthm
   cst-compilation-unit-conc3-rep-elem-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-compilation-unit-conc3-rep-elem abnf::cst)
                  (cst-compilation-unit-conc3-rep-elem cst-equiv)))
  :rule-classes :congruence)

Function: cst-package-modifier-conc-rep-elem

(defun cst-package-modifier-conc-rep-elem (abnf::cst)
  (declare (xargs :guard (abnf::treep abnf::cst)))
  (declare (xargs :guard (cst-matchp abnf::cst "package-modifier")))
  (abnf::tree-fix (nth 0
                       (cst-package-modifier-conc-rep abnf::cst))))

Theorem: treep-of-cst-package-modifier-conc-rep-elem

(defthm treep-of-cst-package-modifier-conc-rep-elem
  (b* ((abnf::cst1 (cst-package-modifier-conc-rep-elem abnf::cst)))
    (abnf::treep abnf::cst1))
  :rule-classes :rewrite)

Theorem: cst-package-modifier-conc-rep-elem-match

(defthm cst-package-modifier-conc-rep-elem-match
 (implies
   (cst-matchp abnf::cst "package-modifier")
   (b* ((abnf::cst1 (cst-package-modifier-conc-rep-elem abnf::cst)))
     (cst-matchp abnf::cst1 "annotation")))
 :rule-classes :rewrite)

Theorem: cst-package-modifier-conc-rep-elem-of-tree-fix-cst

(defthm cst-package-modifier-conc-rep-elem-of-tree-fix-cst
 (equal
     (cst-package-modifier-conc-rep-elem (abnf::tree-fix abnf::cst))
     (cst-package-modifier-conc-rep-elem abnf::cst)))

Theorem: cst-package-modifier-conc-rep-elem-tree-equiv-congruence-on-cst

(defthm
    cst-package-modifier-conc-rep-elem-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-package-modifier-conc-rep-elem abnf::cst)
                  (cst-package-modifier-conc-rep-elem cst-equiv)))
  :rule-classes :congruence)

Function: cst-import-declaration-conc1-rep-elem

(defun cst-import-declaration-conc1-rep-elem (abnf::cst)
 (declare (xargs :guard (abnf::treep abnf::cst)))
 (declare
  (xargs :guard (and (cst-matchp abnf::cst "import-declaration")
                     (equal (cst-import-declaration-conc? abnf::cst)
                            1))))
 (abnf::tree-fix
      (nth 0
           (cst-import-declaration-conc1-rep abnf::cst))))

Theorem: treep-of-cst-import-declaration-conc1-rep-elem

(defthm treep-of-cst-import-declaration-conc1-rep-elem
  (b*
    ((abnf::cst1 (cst-import-declaration-conc1-rep-elem abnf::cst)))
    (abnf::treep abnf::cst1))
  :rule-classes :rewrite)

Theorem: cst-import-declaration-conc1-rep-elem-match

(defthm cst-import-declaration-conc1-rep-elem-match
 (implies
   (and (cst-matchp abnf::cst "import-declaration")
        (equal (cst-import-declaration-conc? abnf::cst)
               1))
   (b*
    ((abnf::cst1 (cst-import-declaration-conc1-rep-elem abnf::cst)))
    (cst-matchp abnf::cst1
                "single-type-import-declaration")))
 :rule-classes :rewrite)

Theorem: cst-import-declaration-conc1-rep-elem-of-tree-fix-cst

(defthm cst-import-declaration-conc1-rep-elem-of-tree-fix-cst
 (equal
  (cst-import-declaration-conc1-rep-elem (abnf::tree-fix abnf::cst))
  (cst-import-declaration-conc1-rep-elem abnf::cst)))

Theorem: cst-import-declaration-conc1-rep-elem-tree-equiv-congruence-on-cst

(defthm
 cst-import-declaration-conc1-rep-elem-tree-equiv-congruence-on-cst
 (implies (abnf::tree-equiv abnf::cst cst-equiv)
          (equal (cst-import-declaration-conc1-rep-elem abnf::cst)
                 (cst-import-declaration-conc1-rep-elem cst-equiv)))
 :rule-classes :congruence)

Function: cst-import-declaration-conc2-rep-elem

(defun cst-import-declaration-conc2-rep-elem (abnf::cst)
 (declare (xargs :guard (abnf::treep abnf::cst)))
 (declare
  (xargs :guard (and (cst-matchp abnf::cst "import-declaration")
                     (equal (cst-import-declaration-conc? abnf::cst)
                            2))))
 (abnf::tree-fix
      (nth 0
           (cst-import-declaration-conc2-rep abnf::cst))))

Theorem: treep-of-cst-import-declaration-conc2-rep-elem

(defthm treep-of-cst-import-declaration-conc2-rep-elem
  (b*
    ((abnf::cst1 (cst-import-declaration-conc2-rep-elem abnf::cst)))
    (abnf::treep abnf::cst1))
  :rule-classes :rewrite)

Theorem: cst-import-declaration-conc2-rep-elem-match

(defthm cst-import-declaration-conc2-rep-elem-match
 (implies
   (and (cst-matchp abnf::cst "import-declaration")
        (equal (cst-import-declaration-conc? abnf::cst)
               2))
   (b*
    ((abnf::cst1 (cst-import-declaration-conc2-rep-elem abnf::cst)))
    (cst-matchp abnf::cst1
                "type-import-on-demand-declaration")))
 :rule-classes :rewrite)

Theorem: cst-import-declaration-conc2-rep-elem-of-tree-fix-cst

(defthm cst-import-declaration-conc2-rep-elem-of-tree-fix-cst
 (equal
  (cst-import-declaration-conc2-rep-elem (abnf::tree-fix abnf::cst))
  (cst-import-declaration-conc2-rep-elem abnf::cst)))

Theorem: cst-import-declaration-conc2-rep-elem-tree-equiv-congruence-on-cst

(defthm
 cst-import-declaration-conc2-rep-elem-tree-equiv-congruence-on-cst
 (implies (abnf::tree-equiv abnf::cst cst-equiv)
          (equal (cst-import-declaration-conc2-rep-elem abnf::cst)
                 (cst-import-declaration-conc2-rep-elem cst-equiv)))
 :rule-classes :congruence)

Function: cst-import-declaration-conc3-rep-elem

(defun cst-import-declaration-conc3-rep-elem (abnf::cst)
 (declare (xargs :guard (abnf::treep abnf::cst)))
 (declare
  (xargs :guard (and (cst-matchp abnf::cst "import-declaration")
                     (equal (cst-import-declaration-conc? abnf::cst)
                            3))))
 (abnf::tree-fix
      (nth 0
           (cst-import-declaration-conc3-rep abnf::cst))))

Theorem: treep-of-cst-import-declaration-conc3-rep-elem

(defthm treep-of-cst-import-declaration-conc3-rep-elem
  (b*
    ((abnf::cst1 (cst-import-declaration-conc3-rep-elem abnf::cst)))
    (abnf::treep abnf::cst1))
  :rule-classes :rewrite)

Theorem: cst-import-declaration-conc3-rep-elem-match

(defthm cst-import-declaration-conc3-rep-elem-match
 (implies
   (and (cst-matchp abnf::cst "import-declaration")
        (equal (cst-import-declaration-conc? abnf::cst)
               3))
   (b*
    ((abnf::cst1 (cst-import-declaration-conc3-rep-elem abnf::cst)))
    (cst-matchp abnf::cst1
                "single-static-import-declaration")))
 :rule-classes :rewrite)

Theorem: cst-import-declaration-conc3-rep-elem-of-tree-fix-cst

(defthm cst-import-declaration-conc3-rep-elem-of-tree-fix-cst
 (equal
  (cst-import-declaration-conc3-rep-elem (abnf::tree-fix abnf::cst))
  (cst-import-declaration-conc3-rep-elem abnf::cst)))

Theorem: cst-import-declaration-conc3-rep-elem-tree-equiv-congruence-on-cst

(defthm
 cst-import-declaration-conc3-rep-elem-tree-equiv-congruence-on-cst
 (implies (abnf::tree-equiv abnf::cst cst-equiv)
          (equal (cst-import-declaration-conc3-rep-elem abnf::cst)
                 (cst-import-declaration-conc3-rep-elem cst-equiv)))
 :rule-classes :congruence)

Function: cst-import-declaration-conc4-rep-elem

(defun cst-import-declaration-conc4-rep-elem (abnf::cst)
 (declare (xargs :guard (abnf::treep abnf::cst)))
 (declare
  (xargs :guard (and (cst-matchp abnf::cst "import-declaration")
                     (equal (cst-import-declaration-conc? abnf::cst)
                            4))))
 (abnf::tree-fix
      (nth 0
           (cst-import-declaration-conc4-rep abnf::cst))))

Theorem: treep-of-cst-import-declaration-conc4-rep-elem

(defthm treep-of-cst-import-declaration-conc4-rep-elem
  (b*
    ((abnf::cst1 (cst-import-declaration-conc4-rep-elem abnf::cst)))
    (abnf::treep abnf::cst1))
  :rule-classes :rewrite)

Theorem: cst-import-declaration-conc4-rep-elem-match

(defthm cst-import-declaration-conc4-rep-elem-match
 (implies
   (and (cst-matchp abnf::cst "import-declaration")
        (equal (cst-import-declaration-conc? abnf::cst)
               4))
   (b*
    ((abnf::cst1 (cst-import-declaration-conc4-rep-elem abnf::cst)))
    (cst-matchp abnf::cst1
                "static-import-on-demand-declaration")))
 :rule-classes :rewrite)

Theorem: cst-import-declaration-conc4-rep-elem-of-tree-fix-cst

(defthm cst-import-declaration-conc4-rep-elem-of-tree-fix-cst
 (equal
  (cst-import-declaration-conc4-rep-elem (abnf::tree-fix abnf::cst))
  (cst-import-declaration-conc4-rep-elem abnf::cst)))

Theorem: cst-import-declaration-conc4-rep-elem-tree-equiv-congruence-on-cst

(defthm
 cst-import-declaration-conc4-rep-elem-tree-equiv-congruence-on-cst
 (implies (abnf::tree-equiv abnf::cst cst-equiv)
          (equal (cst-import-declaration-conc4-rep-elem abnf::cst)
                 (cst-import-declaration-conc4-rep-elem cst-equiv)))
 :rule-classes :congruence)

Function: cst-import-declaration-conc5-rep-elem

(defun cst-import-declaration-conc5-rep-elem (abnf::cst)
 (declare (xargs :guard (abnf::treep abnf::cst)))
 (declare
  (xargs :guard (and (cst-matchp abnf::cst "import-declaration")
                     (equal (cst-import-declaration-conc? abnf::cst)
                            5))))
 (abnf::tree-fix
      (nth 0
           (cst-import-declaration-conc5-rep abnf::cst))))

Theorem: treep-of-cst-import-declaration-conc5-rep-elem

(defthm treep-of-cst-import-declaration-conc5-rep-elem
  (b*
    ((abnf::cst1 (cst-import-declaration-conc5-rep-elem abnf::cst)))
    (abnf::treep abnf::cst1))
  :rule-classes :rewrite)

Theorem: cst-import-declaration-conc5-rep-elem-match

(defthm cst-import-declaration-conc5-rep-elem-match
 (implies
   (and (cst-matchp abnf::cst "import-declaration")
        (equal (cst-import-declaration-conc? abnf::cst)
               5))
   (b*
    ((abnf::cst1 (cst-import-declaration-conc5-rep-elem abnf::cst)))
    (cst-matchp abnf::cst1
                "single-module-import-declaration")))
 :rule-classes :rewrite)

Theorem: cst-import-declaration-conc5-rep-elem-of-tree-fix-cst

(defthm cst-import-declaration-conc5-rep-elem-of-tree-fix-cst
 (equal
  (cst-import-declaration-conc5-rep-elem (abnf::tree-fix abnf::cst))
  (cst-import-declaration-conc5-rep-elem abnf::cst)))

Theorem: cst-import-declaration-conc5-rep-elem-tree-equiv-congruence-on-cst

(defthm
 cst-import-declaration-conc5-rep-elem-tree-equiv-congruence-on-cst
 (implies (abnf::tree-equiv abnf::cst cst-equiv)
          (equal (cst-import-declaration-conc5-rep-elem abnf::cst)
                 (cst-import-declaration-conc5-rep-elem cst-equiv)))
 :rule-classes :congruence)

Function: cst-class-declaration-conc1-rep-elem

(defun cst-class-declaration-conc1-rep-elem (abnf::cst)
 (declare (xargs :guard (abnf::treep abnf::cst)))
 (declare
   (xargs :guard (and (cst-matchp abnf::cst "class-declaration")
                      (equal (cst-class-declaration-conc? abnf::cst)
                             1))))
 (abnf::tree-fix (nth 0
                      (cst-class-declaration-conc1-rep abnf::cst))))

Theorem: treep-of-cst-class-declaration-conc1-rep-elem

(defthm treep-of-cst-class-declaration-conc1-rep-elem
 (b* ((abnf::cst1 (cst-class-declaration-conc1-rep-elem abnf::cst)))
   (abnf::treep abnf::cst1))
 :rule-classes :rewrite)

Theorem: cst-class-declaration-conc1-rep-elem-match

(defthm cst-class-declaration-conc1-rep-elem-match
 (implies
   (and (cst-matchp abnf::cst "class-declaration")
        (equal (cst-class-declaration-conc? abnf::cst)
               1))
   (b*
     ((abnf::cst1 (cst-class-declaration-conc1-rep-elem abnf::cst)))
     (cst-matchp abnf::cst1 "normal-class-declaration")))
 :rule-classes :rewrite)

Theorem: cst-class-declaration-conc1-rep-elem-of-tree-fix-cst

(defthm cst-class-declaration-conc1-rep-elem-of-tree-fix-cst
 (equal
   (cst-class-declaration-conc1-rep-elem (abnf::tree-fix abnf::cst))
   (cst-class-declaration-conc1-rep-elem abnf::cst)))

Theorem: cst-class-declaration-conc1-rep-elem-tree-equiv-congruence-on-cst

(defthm
  cst-class-declaration-conc1-rep-elem-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-class-declaration-conc1-rep-elem abnf::cst)
                  (cst-class-declaration-conc1-rep-elem cst-equiv)))
  :rule-classes :congruence)

Function: cst-class-declaration-conc2-rep-elem

(defun cst-class-declaration-conc2-rep-elem (abnf::cst)
 (declare (xargs :guard (abnf::treep abnf::cst)))
 (declare
   (xargs :guard (and (cst-matchp abnf::cst "class-declaration")
                      (equal (cst-class-declaration-conc? abnf::cst)
                             2))))
 (abnf::tree-fix (nth 0
                      (cst-class-declaration-conc2-rep abnf::cst))))

Theorem: treep-of-cst-class-declaration-conc2-rep-elem

(defthm treep-of-cst-class-declaration-conc2-rep-elem
 (b* ((abnf::cst1 (cst-class-declaration-conc2-rep-elem abnf::cst)))
   (abnf::treep abnf::cst1))
 :rule-classes :rewrite)

Theorem: cst-class-declaration-conc2-rep-elem-match

(defthm cst-class-declaration-conc2-rep-elem-match
 (implies
   (and (cst-matchp abnf::cst "class-declaration")
        (equal (cst-class-declaration-conc? abnf::cst)
               2))
   (b*
     ((abnf::cst1 (cst-class-declaration-conc2-rep-elem abnf::cst)))
     (cst-matchp abnf::cst1 "enum-declaration")))
 :rule-classes :rewrite)

Theorem: cst-class-declaration-conc2-rep-elem-of-tree-fix-cst

(defthm cst-class-declaration-conc2-rep-elem-of-tree-fix-cst
 (equal
   (cst-class-declaration-conc2-rep-elem (abnf::tree-fix abnf::cst))
   (cst-class-declaration-conc2-rep-elem abnf::cst)))

Theorem: cst-class-declaration-conc2-rep-elem-tree-equiv-congruence-on-cst

(defthm
  cst-class-declaration-conc2-rep-elem-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-class-declaration-conc2-rep-elem abnf::cst)
                  (cst-class-declaration-conc2-rep-elem cst-equiv)))
  :rule-classes :congruence)

Function: cst-class-declaration-conc3-rep-elem

(defun cst-class-declaration-conc3-rep-elem (abnf::cst)
 (declare (xargs :guard (abnf::treep abnf::cst)))
 (declare
   (xargs :guard (and (cst-matchp abnf::cst "class-declaration")
                      (equal (cst-class-declaration-conc? abnf::cst)
                             3))))
 (abnf::tree-fix (nth 0
                      (cst-class-declaration-conc3-rep abnf::cst))))

Theorem: treep-of-cst-class-declaration-conc3-rep-elem

(defthm treep-of-cst-class-declaration-conc3-rep-elem
 (b* ((abnf::cst1 (cst-class-declaration-conc3-rep-elem abnf::cst)))
   (abnf::treep abnf::cst1))
 :rule-classes :rewrite)

Theorem: cst-class-declaration-conc3-rep-elem-match

(defthm cst-class-declaration-conc3-rep-elem-match
 (implies
   (and (cst-matchp abnf::cst "class-declaration")
        (equal (cst-class-declaration-conc? abnf::cst)
               3))
   (b*
     ((abnf::cst1 (cst-class-declaration-conc3-rep-elem abnf::cst)))
     (cst-matchp abnf::cst1 "record-declaration")))
 :rule-classes :rewrite)

Theorem: cst-class-declaration-conc3-rep-elem-of-tree-fix-cst

(defthm cst-class-declaration-conc3-rep-elem-of-tree-fix-cst
 (equal
   (cst-class-declaration-conc3-rep-elem (abnf::tree-fix abnf::cst))
   (cst-class-declaration-conc3-rep-elem abnf::cst)))

Theorem: cst-class-declaration-conc3-rep-elem-tree-equiv-congruence-on-cst

(defthm
  cst-class-declaration-conc3-rep-elem-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-class-declaration-conc3-rep-elem abnf::cst)
                  (cst-class-declaration-conc3-rep-elem cst-equiv)))
  :rule-classes :congruence)

Function: cst-class-body-declaration-conc1-rep-elem

(defun cst-class-body-declaration-conc1-rep-elem (abnf::cst)
 (declare (xargs :guard (abnf::treep abnf::cst)))
 (declare
  (xargs
     :guard (and (cst-matchp abnf::cst "class-body-declaration")
                 (equal (cst-class-body-declaration-conc? abnf::cst)
                        1))))
 (abnf::tree-fix
      (nth 0
           (cst-class-body-declaration-conc1-rep abnf::cst))))

Theorem: treep-of-cst-class-body-declaration-conc1-rep-elem

(defthm treep-of-cst-class-body-declaration-conc1-rep-elem
  (b* ((abnf::cst1
            (cst-class-body-declaration-conc1-rep-elem abnf::cst)))
    (abnf::treep abnf::cst1))
  :rule-classes :rewrite)

Theorem: cst-class-body-declaration-conc1-rep-elem-match

(defthm cst-class-body-declaration-conc1-rep-elem-match
 (implies
   (and (cst-matchp abnf::cst "class-body-declaration")
        (equal (cst-class-body-declaration-conc? abnf::cst)
               1))
   (b* ((abnf::cst1
             (cst-class-body-declaration-conc1-rep-elem abnf::cst)))
     (cst-matchp abnf::cst1 "class-member-declaration")))
 :rule-classes :rewrite)

Theorem: cst-class-body-declaration-conc1-rep-elem-of-tree-fix-cst

(defthm cst-class-body-declaration-conc1-rep-elem-of-tree-fix-cst
  (equal (cst-class-body-declaration-conc1-rep-elem
              (abnf::tree-fix abnf::cst))
         (cst-class-body-declaration-conc1-rep-elem abnf::cst)))

Theorem: cst-class-body-declaration-conc1-rep-elem-tree-equiv-congruence-on-cst

(defthm
 cst-class-body-declaration-conc1-rep-elem-tree-equiv-congruence-on-cst
 (implies
      (abnf::tree-equiv abnf::cst cst-equiv)
      (equal (cst-class-body-declaration-conc1-rep-elem abnf::cst)
             (cst-class-body-declaration-conc1-rep-elem cst-equiv)))
 :rule-classes :congruence)

Function: cst-class-body-declaration-conc2-rep-elem

(defun cst-class-body-declaration-conc2-rep-elem (abnf::cst)
 (declare (xargs :guard (abnf::treep abnf::cst)))
 (declare
  (xargs
     :guard (and (cst-matchp abnf::cst "class-body-declaration")
                 (equal (cst-class-body-declaration-conc? abnf::cst)
                        2))))
 (abnf::tree-fix
      (nth 0
           (cst-class-body-declaration-conc2-rep abnf::cst))))

Theorem: treep-of-cst-class-body-declaration-conc2-rep-elem

(defthm treep-of-cst-class-body-declaration-conc2-rep-elem
  (b* ((abnf::cst1
            (cst-class-body-declaration-conc2-rep-elem abnf::cst)))
    (abnf::treep abnf::cst1))
  :rule-classes :rewrite)

Theorem: cst-class-body-declaration-conc2-rep-elem-match

(defthm cst-class-body-declaration-conc2-rep-elem-match
 (implies
   (and (cst-matchp abnf::cst "class-body-declaration")
        (equal (cst-class-body-declaration-conc? abnf::cst)
               2))
   (b* ((abnf::cst1
             (cst-class-body-declaration-conc2-rep-elem abnf::cst)))
     (cst-matchp abnf::cst1 "instance-initializer")))
 :rule-classes :rewrite)

Theorem: cst-class-body-declaration-conc2-rep-elem-of-tree-fix-cst

(defthm cst-class-body-declaration-conc2-rep-elem-of-tree-fix-cst
  (equal (cst-class-body-declaration-conc2-rep-elem
              (abnf::tree-fix abnf::cst))
         (cst-class-body-declaration-conc2-rep-elem abnf::cst)))

Theorem: cst-class-body-declaration-conc2-rep-elem-tree-equiv-congruence-on-cst

(defthm
 cst-class-body-declaration-conc2-rep-elem-tree-equiv-congruence-on-cst
 (implies
      (abnf::tree-equiv abnf::cst cst-equiv)
      (equal (cst-class-body-declaration-conc2-rep-elem abnf::cst)
             (cst-class-body-declaration-conc2-rep-elem cst-equiv)))
 :rule-classes :congruence)

Function: cst-class-body-declaration-conc3-rep-elem

(defun cst-class-body-declaration-conc3-rep-elem (abnf::cst)
 (declare (xargs :guard (abnf::treep abnf::cst)))
 (declare
  (xargs
     :guard (and (cst-matchp abnf::cst "class-body-declaration")
                 (equal (cst-class-body-declaration-conc? abnf::cst)
                        3))))
 (abnf::tree-fix
      (nth 0
           (cst-class-body-declaration-conc3-rep abnf::cst))))

Theorem: treep-of-cst-class-body-declaration-conc3-rep-elem

(defthm treep-of-cst-class-body-declaration-conc3-rep-elem
  (b* ((abnf::cst1
            (cst-class-body-declaration-conc3-rep-elem abnf::cst)))
    (abnf::treep abnf::cst1))
  :rule-classes :rewrite)

Theorem: cst-class-body-declaration-conc3-rep-elem-match

(defthm cst-class-body-declaration-conc3-rep-elem-match
 (implies
   (and (cst-matchp abnf::cst "class-body-declaration")
        (equal (cst-class-body-declaration-conc? abnf::cst)
               3))
   (b* ((abnf::cst1
             (cst-class-body-declaration-conc3-rep-elem abnf::cst)))
     (cst-matchp abnf::cst1 "static-initializer")))
 :rule-classes :rewrite)

Theorem: cst-class-body-declaration-conc3-rep-elem-of-tree-fix-cst

(defthm cst-class-body-declaration-conc3-rep-elem-of-tree-fix-cst
  (equal (cst-class-body-declaration-conc3-rep-elem
              (abnf::tree-fix abnf::cst))
         (cst-class-body-declaration-conc3-rep-elem abnf::cst)))

Theorem: cst-class-body-declaration-conc3-rep-elem-tree-equiv-congruence-on-cst

(defthm
 cst-class-body-declaration-conc3-rep-elem-tree-equiv-congruence-on-cst
 (implies
      (abnf::tree-equiv abnf::cst cst-equiv)
      (equal (cst-class-body-declaration-conc3-rep-elem abnf::cst)
             (cst-class-body-declaration-conc3-rep-elem cst-equiv)))
 :rule-classes :congruence)

Function: cst-class-body-declaration-conc4-rep-elem

(defun cst-class-body-declaration-conc4-rep-elem (abnf::cst)
 (declare (xargs :guard (abnf::treep abnf::cst)))
 (declare
  (xargs
     :guard (and (cst-matchp abnf::cst "class-body-declaration")
                 (equal (cst-class-body-declaration-conc? abnf::cst)
                        4))))
 (abnf::tree-fix
      (nth 0
           (cst-class-body-declaration-conc4-rep abnf::cst))))

Theorem: treep-of-cst-class-body-declaration-conc4-rep-elem

(defthm treep-of-cst-class-body-declaration-conc4-rep-elem
  (b* ((abnf::cst1
            (cst-class-body-declaration-conc4-rep-elem abnf::cst)))
    (abnf::treep abnf::cst1))
  :rule-classes :rewrite)

Theorem: cst-class-body-declaration-conc4-rep-elem-match

(defthm cst-class-body-declaration-conc4-rep-elem-match
 (implies
   (and (cst-matchp abnf::cst "class-body-declaration")
        (equal (cst-class-body-declaration-conc? abnf::cst)
               4))
   (b* ((abnf::cst1
             (cst-class-body-declaration-conc4-rep-elem abnf::cst)))
     (cst-matchp abnf::cst1 "constructor-declaration")))
 :rule-classes :rewrite)

Theorem: cst-class-body-declaration-conc4-rep-elem-of-tree-fix-cst

(defthm cst-class-body-declaration-conc4-rep-elem-of-tree-fix-cst
  (equal (cst-class-body-declaration-conc4-rep-elem
              (abnf::tree-fix abnf::cst))
         (cst-class-body-declaration-conc4-rep-elem abnf::cst)))

Theorem: cst-class-body-declaration-conc4-rep-elem-tree-equiv-congruence-on-cst

(defthm
 cst-class-body-declaration-conc4-rep-elem-tree-equiv-congruence-on-cst
 (implies
      (abnf::tree-equiv abnf::cst cst-equiv)
      (equal (cst-class-body-declaration-conc4-rep-elem abnf::cst)
             (cst-class-body-declaration-conc4-rep-elem cst-equiv)))
 :rule-classes :congruence)

Function: cst-variable-initializer-conc1-rep-elem

(defun cst-variable-initializer-conc1-rep-elem (abnf::cst)
 (declare (xargs :guard (abnf::treep abnf::cst)))
 (declare
  (xargs
       :guard (and (cst-matchp abnf::cst "variable-initializer")
                   (equal (cst-variable-initializer-conc? abnf::cst)
                          1))))
 (abnf::tree-fix
      (nth 0
           (cst-variable-initializer-conc1-rep abnf::cst))))

Theorem: treep-of-cst-variable-initializer-conc1-rep-elem

(defthm treep-of-cst-variable-initializer-conc1-rep-elem
 (b*
  ((abnf::cst1 (cst-variable-initializer-conc1-rep-elem abnf::cst)))
  (abnf::treep abnf::cst1))
 :rule-classes :rewrite)

Theorem: cst-variable-initializer-conc1-rep-elem-match

(defthm cst-variable-initializer-conc1-rep-elem-match
 (implies
     (and (cst-matchp abnf::cst "variable-initializer")
          (equal (cst-variable-initializer-conc? abnf::cst)
                 1))
     (b* ((abnf::cst1
               (cst-variable-initializer-conc1-rep-elem abnf::cst)))
       (cst-matchp abnf::cst1 "expression")))
 :rule-classes :rewrite)

Theorem: cst-variable-initializer-conc1-rep-elem-of-tree-fix-cst

(defthm cst-variable-initializer-conc1-rep-elem-of-tree-fix-cst
  (equal (cst-variable-initializer-conc1-rep-elem
              (abnf::tree-fix abnf::cst))
         (cst-variable-initializer-conc1-rep-elem abnf::cst)))

Theorem: cst-variable-initializer-conc1-rep-elem-tree-equiv-congruence-on-cst

(defthm
 cst-variable-initializer-conc1-rep-elem-tree-equiv-congruence-on-cst
 (implies
      (abnf::tree-equiv abnf::cst cst-equiv)
      (equal (cst-variable-initializer-conc1-rep-elem abnf::cst)
             (cst-variable-initializer-conc1-rep-elem cst-equiv)))
 :rule-classes :congruence)

Function: cst-variable-initializer-conc2-rep-elem

(defun cst-variable-initializer-conc2-rep-elem (abnf::cst)
 (declare (xargs :guard (abnf::treep abnf::cst)))
 (declare
  (xargs
       :guard (and (cst-matchp abnf::cst "variable-initializer")
                   (equal (cst-variable-initializer-conc? abnf::cst)
                          2))))
 (abnf::tree-fix
      (nth 0
           (cst-variable-initializer-conc2-rep abnf::cst))))

Theorem: treep-of-cst-variable-initializer-conc2-rep-elem

(defthm treep-of-cst-variable-initializer-conc2-rep-elem
 (b*
  ((abnf::cst1 (cst-variable-initializer-conc2-rep-elem abnf::cst)))
  (abnf::treep abnf::cst1))
 :rule-classes :rewrite)

Theorem: cst-variable-initializer-conc2-rep-elem-match

(defthm cst-variable-initializer-conc2-rep-elem-match
 (implies
     (and (cst-matchp abnf::cst "variable-initializer")
          (equal (cst-variable-initializer-conc? abnf::cst)
                 2))
     (b* ((abnf::cst1
               (cst-variable-initializer-conc2-rep-elem abnf::cst)))
       (cst-matchp abnf::cst1 "array-initializer")))
 :rule-classes :rewrite)

Theorem: cst-variable-initializer-conc2-rep-elem-of-tree-fix-cst

(defthm cst-variable-initializer-conc2-rep-elem-of-tree-fix-cst
  (equal (cst-variable-initializer-conc2-rep-elem
              (abnf::tree-fix abnf::cst))
         (cst-variable-initializer-conc2-rep-elem abnf::cst)))

Theorem: cst-variable-initializer-conc2-rep-elem-tree-equiv-congruence-on-cst

(defthm
 cst-variable-initializer-conc2-rep-elem-tree-equiv-congruence-on-cst
 (implies
      (abnf::tree-equiv abnf::cst cst-equiv)
      (equal (cst-variable-initializer-conc2-rep-elem abnf::cst)
             (cst-variable-initializer-conc2-rep-elem cst-equiv)))
 :rule-classes :congruence)

Function: cst-unann-type-conc1-rep-elem

(defun cst-unann-type-conc1-rep-elem (abnf::cst)
 (declare (xargs :guard (abnf::treep abnf::cst)))
 (declare (xargs :guard (and (cst-matchp abnf::cst "unann-type")
                             (equal (cst-unann-type-conc? abnf::cst)
                                    1))))
 (abnf::tree-fix (nth 0
                      (cst-unann-type-conc1-rep abnf::cst))))

Theorem: treep-of-cst-unann-type-conc1-rep-elem

(defthm treep-of-cst-unann-type-conc1-rep-elem
  (b* ((abnf::cst1 (cst-unann-type-conc1-rep-elem abnf::cst)))
    (abnf::treep abnf::cst1))
  :rule-classes :rewrite)

Theorem: cst-unann-type-conc1-rep-elem-match

(defthm cst-unann-type-conc1-rep-elem-match
  (implies
       (and (cst-matchp abnf::cst "unann-type")
            (equal (cst-unann-type-conc? abnf::cst)
                   1))
       (b* ((abnf::cst1 (cst-unann-type-conc1-rep-elem abnf::cst)))
         (cst-matchp abnf::cst1 "unann-primitive-type")))
  :rule-classes :rewrite)

Theorem: cst-unann-type-conc1-rep-elem-of-tree-fix-cst

(defthm cst-unann-type-conc1-rep-elem-of-tree-fix-cst
  (equal (cst-unann-type-conc1-rep-elem (abnf::tree-fix abnf::cst))
         (cst-unann-type-conc1-rep-elem abnf::cst)))

Theorem: cst-unann-type-conc1-rep-elem-tree-equiv-congruence-on-cst

(defthm cst-unann-type-conc1-rep-elem-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-unann-type-conc1-rep-elem abnf::cst)
                  (cst-unann-type-conc1-rep-elem cst-equiv)))
  :rule-classes :congruence)

Function: cst-unann-type-conc2-rep-elem

(defun cst-unann-type-conc2-rep-elem (abnf::cst)
 (declare (xargs :guard (abnf::treep abnf::cst)))
 (declare (xargs :guard (and (cst-matchp abnf::cst "unann-type")
                             (equal (cst-unann-type-conc? abnf::cst)
                                    2))))
 (abnf::tree-fix (nth 0
                      (cst-unann-type-conc2-rep abnf::cst))))

Theorem: treep-of-cst-unann-type-conc2-rep-elem

(defthm treep-of-cst-unann-type-conc2-rep-elem
  (b* ((abnf::cst1 (cst-unann-type-conc2-rep-elem abnf::cst)))
    (abnf::treep abnf::cst1))
  :rule-classes :rewrite)

Theorem: cst-unann-type-conc2-rep-elem-match

(defthm cst-unann-type-conc2-rep-elem-match
  (implies
       (and (cst-matchp abnf::cst "unann-type")
            (equal (cst-unann-type-conc? abnf::cst)
                   2))
       (b* ((abnf::cst1 (cst-unann-type-conc2-rep-elem abnf::cst)))
         (cst-matchp abnf::cst1 "unann-reference-type")))
  :rule-classes :rewrite)

Theorem: cst-unann-type-conc2-rep-elem-of-tree-fix-cst

(defthm cst-unann-type-conc2-rep-elem-of-tree-fix-cst
  (equal (cst-unann-type-conc2-rep-elem (abnf::tree-fix abnf::cst))
         (cst-unann-type-conc2-rep-elem abnf::cst)))

Theorem: cst-unann-type-conc2-rep-elem-tree-equiv-congruence-on-cst

(defthm cst-unann-type-conc2-rep-elem-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-unann-type-conc2-rep-elem abnf::cst)
                  (cst-unann-type-conc2-rep-elem cst-equiv)))
  :rule-classes :congruence)

Function: cst-unann-reference-type-conc1-rep-elem

(defun cst-unann-reference-type-conc1-rep-elem (abnf::cst)
 (declare (xargs :guard (abnf::treep abnf::cst)))
 (declare
  (xargs
       :guard (and (cst-matchp abnf::cst "unann-reference-type")
                   (equal (cst-unann-reference-type-conc? abnf::cst)
                          1))))
 (abnf::tree-fix
      (nth 0
           (cst-unann-reference-type-conc1-rep abnf::cst))))

Theorem: treep-of-cst-unann-reference-type-conc1-rep-elem

(defthm treep-of-cst-unann-reference-type-conc1-rep-elem
 (b*
  ((abnf::cst1 (cst-unann-reference-type-conc1-rep-elem abnf::cst)))
  (abnf::treep abnf::cst1))
 :rule-classes :rewrite)

Theorem: cst-unann-reference-type-conc1-rep-elem-match

(defthm cst-unann-reference-type-conc1-rep-elem-match
 (implies
     (and (cst-matchp abnf::cst "unann-reference-type")
          (equal (cst-unann-reference-type-conc? abnf::cst)
                 1))
     (b* ((abnf::cst1
               (cst-unann-reference-type-conc1-rep-elem abnf::cst)))
       (cst-matchp abnf::cst1
                   "unann-class-or-interface-type")))
 :rule-classes :rewrite)

Theorem: cst-unann-reference-type-conc1-rep-elem-of-tree-fix-cst

(defthm cst-unann-reference-type-conc1-rep-elem-of-tree-fix-cst
  (equal (cst-unann-reference-type-conc1-rep-elem
              (abnf::tree-fix abnf::cst))
         (cst-unann-reference-type-conc1-rep-elem abnf::cst)))

Theorem: cst-unann-reference-type-conc1-rep-elem-tree-equiv-congruence-on-cst

(defthm
 cst-unann-reference-type-conc1-rep-elem-tree-equiv-congruence-on-cst
 (implies
      (abnf::tree-equiv abnf::cst cst-equiv)
      (equal (cst-unann-reference-type-conc1-rep-elem abnf::cst)
             (cst-unann-reference-type-conc1-rep-elem cst-equiv)))
 :rule-classes :congruence)

Function: cst-unann-reference-type-conc2-rep-elem

(defun cst-unann-reference-type-conc2-rep-elem (abnf::cst)
 (declare (xargs :guard (abnf::treep abnf::cst)))
 (declare
  (xargs
       :guard (and (cst-matchp abnf::cst "unann-reference-type")
                   (equal (cst-unann-reference-type-conc? abnf::cst)
                          2))))
 (abnf::tree-fix
      (nth 0
           (cst-unann-reference-type-conc2-rep abnf::cst))))

Theorem: treep-of-cst-unann-reference-type-conc2-rep-elem

(defthm treep-of-cst-unann-reference-type-conc2-rep-elem
 (b*
  ((abnf::cst1 (cst-unann-reference-type-conc2-rep-elem abnf::cst)))
  (abnf::treep abnf::cst1))
 :rule-classes :rewrite)

Theorem: cst-unann-reference-type-conc2-rep-elem-match

(defthm cst-unann-reference-type-conc2-rep-elem-match
 (implies
     (and (cst-matchp abnf::cst "unann-reference-type")
          (equal (cst-unann-reference-type-conc? abnf::cst)
                 2))
     (b* ((abnf::cst1
               (cst-unann-reference-type-conc2-rep-elem abnf::cst)))
       (cst-matchp abnf::cst1 "unann-type-variable")))
 :rule-classes :rewrite)

Theorem: cst-unann-reference-type-conc2-rep-elem-of-tree-fix-cst

(defthm cst-unann-reference-type-conc2-rep-elem-of-tree-fix-cst
  (equal (cst-unann-reference-type-conc2-rep-elem
              (abnf::tree-fix abnf::cst))
         (cst-unann-reference-type-conc2-rep-elem abnf::cst)))

Theorem: cst-unann-reference-type-conc2-rep-elem-tree-equiv-congruence-on-cst

(defthm
 cst-unann-reference-type-conc2-rep-elem-tree-equiv-congruence-on-cst
 (implies
      (abnf::tree-equiv abnf::cst cst-equiv)
      (equal (cst-unann-reference-type-conc2-rep-elem abnf::cst)
             (cst-unann-reference-type-conc2-rep-elem cst-equiv)))
 :rule-classes :congruence)

Function: cst-unann-reference-type-conc3-rep-elem

(defun cst-unann-reference-type-conc3-rep-elem (abnf::cst)
 (declare (xargs :guard (abnf::treep abnf::cst)))
 (declare
  (xargs
       :guard (and (cst-matchp abnf::cst "unann-reference-type")
                   (equal (cst-unann-reference-type-conc? abnf::cst)
                          3))))
 (abnf::tree-fix
      (nth 0
           (cst-unann-reference-type-conc3-rep abnf::cst))))

Theorem: treep-of-cst-unann-reference-type-conc3-rep-elem

(defthm treep-of-cst-unann-reference-type-conc3-rep-elem
 (b*
  ((abnf::cst1 (cst-unann-reference-type-conc3-rep-elem abnf::cst)))
  (abnf::treep abnf::cst1))
 :rule-classes :rewrite)

Theorem: cst-unann-reference-type-conc3-rep-elem-match

(defthm cst-unann-reference-type-conc3-rep-elem-match
 (implies
     (and (cst-matchp abnf::cst "unann-reference-type")
          (equal (cst-unann-reference-type-conc? abnf::cst)
                 3))
     (b* ((abnf::cst1
               (cst-unann-reference-type-conc3-rep-elem abnf::cst)))
       (cst-matchp abnf::cst1 "unann-array-type")))
 :rule-classes :rewrite)

Theorem: cst-unann-reference-type-conc3-rep-elem-of-tree-fix-cst

(defthm cst-unann-reference-type-conc3-rep-elem-of-tree-fix-cst
  (equal (cst-unann-reference-type-conc3-rep-elem
              (abnf::tree-fix abnf::cst))
         (cst-unann-reference-type-conc3-rep-elem abnf::cst)))

Theorem: cst-unann-reference-type-conc3-rep-elem-tree-equiv-congruence-on-cst

(defthm
 cst-unann-reference-type-conc3-rep-elem-tree-equiv-congruence-on-cst
 (implies
      (abnf::tree-equiv abnf::cst cst-equiv)
      (equal (cst-unann-reference-type-conc3-rep-elem abnf::cst)
             (cst-unann-reference-type-conc3-rep-elem cst-equiv)))
 :rule-classes :congruence)

Function: cst-unann-class-or-interface-type-conc1-rep-elem

(defun cst-unann-class-or-interface-type-conc1-rep-elem (abnf::cst)
 (declare (xargs :guard (abnf::treep abnf::cst)))
 (declare
  (xargs
     :guard
     (and (cst-matchp abnf::cst
                      "unann-class-or-interface-type")
          (equal (cst-unann-class-or-interface-type-conc? abnf::cst)
                 1))))
 (abnf::tree-fix
     (nth 0
          (cst-unann-class-or-interface-type-conc1-rep abnf::cst))))

Theorem: treep-of-cst-unann-class-or-interface-type-conc1-rep-elem

(defthm treep-of-cst-unann-class-or-interface-type-conc1-rep-elem
 (b*
  ((abnf::cst1
      (cst-unann-class-or-interface-type-conc1-rep-elem abnf::cst)))
  (abnf::treep abnf::cst1))
 :rule-classes :rewrite)

Theorem: cst-unann-class-or-interface-type-conc1-rep-elem-match

(defthm cst-unann-class-or-interface-type-conc1-rep-elem-match
 (implies
  (and (cst-matchp abnf::cst
                   "unann-class-or-interface-type")
       (equal (cst-unann-class-or-interface-type-conc? abnf::cst)
              1))
  (b*
   ((abnf::cst1
      (cst-unann-class-or-interface-type-conc1-rep-elem abnf::cst)))
   (cst-matchp abnf::cst1 "unann-class-type")))
 :rule-classes :rewrite)

Theorem: cst-unann-class-or-interface-type-conc1-rep-elem-of-tree-fix-cst

(defthm
   cst-unann-class-or-interface-type-conc1-rep-elem-of-tree-fix-cst
 (equal
      (cst-unann-class-or-interface-type-conc1-rep-elem
           (abnf::tree-fix abnf::cst))
      (cst-unann-class-or-interface-type-conc1-rep-elem abnf::cst)))

Theorem: cst-unann-class-or-interface-type-conc1-rep-elem-tree-equiv-congruence-on-cst

(defthm
 cst-unann-class-or-interface-type-conc1-rep-elem-tree-equiv-congruence-on-cst
 (implies
  (abnf::tree-equiv abnf::cst cst-equiv)
  (equal
      (cst-unann-class-or-interface-type-conc1-rep-elem abnf::cst)
      (cst-unann-class-or-interface-type-conc1-rep-elem cst-equiv)))
 :rule-classes :congruence)

Function: cst-unann-class-or-interface-type-conc2-rep-elem

(defun cst-unann-class-or-interface-type-conc2-rep-elem (abnf::cst)
 (declare (xargs :guard (abnf::treep abnf::cst)))
 (declare
  (xargs
     :guard
     (and (cst-matchp abnf::cst
                      "unann-class-or-interface-type")
          (equal (cst-unann-class-or-interface-type-conc? abnf::cst)
                 2))))
 (abnf::tree-fix
     (nth 0
          (cst-unann-class-or-interface-type-conc2-rep abnf::cst))))

Theorem: treep-of-cst-unann-class-or-interface-type-conc2-rep-elem

(defthm treep-of-cst-unann-class-or-interface-type-conc2-rep-elem
 (b*
  ((abnf::cst1
      (cst-unann-class-or-interface-type-conc2-rep-elem abnf::cst)))
  (abnf::treep abnf::cst1))
 :rule-classes :rewrite)

Theorem: cst-unann-class-or-interface-type-conc2-rep-elem-match

(defthm cst-unann-class-or-interface-type-conc2-rep-elem-match
 (implies
  (and (cst-matchp abnf::cst
                   "unann-class-or-interface-type")
       (equal (cst-unann-class-or-interface-type-conc? abnf::cst)
              2))
  (b*
   ((abnf::cst1
      (cst-unann-class-or-interface-type-conc2-rep-elem abnf::cst)))
   (cst-matchp abnf::cst1 "unann-interface-type")))
 :rule-classes :rewrite)

Theorem: cst-unann-class-or-interface-type-conc2-rep-elem-of-tree-fix-cst

(defthm
   cst-unann-class-or-interface-type-conc2-rep-elem-of-tree-fix-cst
 (equal
      (cst-unann-class-or-interface-type-conc2-rep-elem
           (abnf::tree-fix abnf::cst))
      (cst-unann-class-or-interface-type-conc2-rep-elem abnf::cst)))

Theorem: cst-unann-class-or-interface-type-conc2-rep-elem-tree-equiv-congruence-on-cst

(defthm
 cst-unann-class-or-interface-type-conc2-rep-elem-tree-equiv-congruence-on-cst
 (implies
  (abnf::tree-equiv abnf::cst cst-equiv)
  (equal
      (cst-unann-class-or-interface-type-conc2-rep-elem abnf::cst)
      (cst-unann-class-or-interface-type-conc2-rep-elem cst-equiv)))
 :rule-classes :congruence)

Function: cst-unann-interface-type-conc-rep-elem

(defun cst-unann-interface-type-conc-rep-elem (abnf::cst)
  (declare (xargs :guard (abnf::treep abnf::cst)))
  (declare
       (xargs :guard (cst-matchp abnf::cst "unann-interface-type")))
  (abnf::tree-fix
       (nth 0
            (cst-unann-interface-type-conc-rep abnf::cst))))

Theorem: treep-of-cst-unann-interface-type-conc-rep-elem

(defthm treep-of-cst-unann-interface-type-conc-rep-elem
  (b*
   ((abnf::cst1 (cst-unann-interface-type-conc-rep-elem abnf::cst)))
   (abnf::treep abnf::cst1))
  :rule-classes :rewrite)

Theorem: cst-unann-interface-type-conc-rep-elem-match

(defthm cst-unann-interface-type-conc-rep-elem-match
 (implies
  (cst-matchp abnf::cst "unann-interface-type")
  (b*
   ((abnf::cst1 (cst-unann-interface-type-conc-rep-elem abnf::cst)))
   (cst-matchp abnf::cst1 "unann-class-type")))
 :rule-classes :rewrite)

Theorem: cst-unann-interface-type-conc-rep-elem-of-tree-fix-cst

(defthm cst-unann-interface-type-conc-rep-elem-of-tree-fix-cst
  (equal (cst-unann-interface-type-conc-rep-elem
              (abnf::tree-fix abnf::cst))
         (cst-unann-interface-type-conc-rep-elem abnf::cst)))

Theorem: cst-unann-interface-type-conc-rep-elem-tree-equiv-congruence-on-cst

(defthm
 cst-unann-interface-type-conc-rep-elem-tree-equiv-congruence-on-cst
 (implies
      (abnf::tree-equiv abnf::cst cst-equiv)
      (equal (cst-unann-interface-type-conc-rep-elem abnf::cst)
             (cst-unann-interface-type-conc-rep-elem cst-equiv)))
 :rule-classes :congruence)

Function: cst-unann-type-variable-conc-rep-elem

(defun cst-unann-type-variable-conc-rep-elem (abnf::cst)
  (declare (xargs :guard (abnf::treep abnf::cst)))
  (declare
       (xargs :guard (cst-matchp abnf::cst "unann-type-variable")))
  (abnf::tree-fix
       (nth 0
            (cst-unann-type-variable-conc-rep abnf::cst))))

Theorem: treep-of-cst-unann-type-variable-conc-rep-elem

(defthm treep-of-cst-unann-type-variable-conc-rep-elem
  (b*
    ((abnf::cst1 (cst-unann-type-variable-conc-rep-elem abnf::cst)))
    (abnf::treep abnf::cst1))
  :rule-classes :rewrite)

Theorem: cst-unann-type-variable-conc-rep-elem-match

(defthm cst-unann-type-variable-conc-rep-elem-match
 (implies
   (cst-matchp abnf::cst "unann-type-variable")
   (b*
    ((abnf::cst1 (cst-unann-type-variable-conc-rep-elem abnf::cst)))
    (cst-matchp abnf::cst1 "type-identifier")))
 :rule-classes :rewrite)

Theorem: cst-unann-type-variable-conc-rep-elem-of-tree-fix-cst

(defthm cst-unann-type-variable-conc-rep-elem-of-tree-fix-cst
 (equal
  (cst-unann-type-variable-conc-rep-elem (abnf::tree-fix abnf::cst))
  (cst-unann-type-variable-conc-rep-elem abnf::cst)))

Theorem: cst-unann-type-variable-conc-rep-elem-tree-equiv-congruence-on-cst

(defthm
 cst-unann-type-variable-conc-rep-elem-tree-equiv-congruence-on-cst
 (implies (abnf::tree-equiv abnf::cst cst-equiv)
          (equal (cst-unann-type-variable-conc-rep-elem abnf::cst)
                 (cst-unann-type-variable-conc-rep-elem cst-equiv)))
 :rule-classes :congruence)

Function: cst-exception-type-conc1-rep-elem

(defun cst-exception-type-conc1-rep-elem (abnf::cst)
 (declare (xargs :guard (abnf::treep abnf::cst)))
 (declare
      (xargs :guard (and (cst-matchp abnf::cst "exception-type")
                         (equal (cst-exception-type-conc? abnf::cst)
                                1))))
 (abnf::tree-fix (nth 0
                      (cst-exception-type-conc1-rep abnf::cst))))

Theorem: treep-of-cst-exception-type-conc1-rep-elem

(defthm treep-of-cst-exception-type-conc1-rep-elem
  (b* ((abnf::cst1 (cst-exception-type-conc1-rep-elem abnf::cst)))
    (abnf::treep abnf::cst1))
  :rule-classes :rewrite)

Theorem: cst-exception-type-conc1-rep-elem-match

(defthm cst-exception-type-conc1-rep-elem-match
 (implies
    (and (cst-matchp abnf::cst "exception-type")
         (equal (cst-exception-type-conc? abnf::cst)
                1))
    (b* ((abnf::cst1 (cst-exception-type-conc1-rep-elem abnf::cst)))
      (cst-matchp abnf::cst1 "class-type")))
 :rule-classes :rewrite)

Theorem: cst-exception-type-conc1-rep-elem-of-tree-fix-cst

(defthm cst-exception-type-conc1-rep-elem-of-tree-fix-cst
 (equal
      (cst-exception-type-conc1-rep-elem (abnf::tree-fix abnf::cst))
      (cst-exception-type-conc1-rep-elem abnf::cst)))

Theorem: cst-exception-type-conc1-rep-elem-tree-equiv-congruence-on-cst

(defthm
     cst-exception-type-conc1-rep-elem-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-exception-type-conc1-rep-elem abnf::cst)
                  (cst-exception-type-conc1-rep-elem cst-equiv)))
  :rule-classes :congruence)

Function: cst-exception-type-conc2-rep-elem

(defun cst-exception-type-conc2-rep-elem (abnf::cst)
 (declare (xargs :guard (abnf::treep abnf::cst)))
 (declare
      (xargs :guard (and (cst-matchp abnf::cst "exception-type")
                         (equal (cst-exception-type-conc? abnf::cst)
                                2))))
 (abnf::tree-fix (nth 0
                      (cst-exception-type-conc2-rep abnf::cst))))

Theorem: treep-of-cst-exception-type-conc2-rep-elem

(defthm treep-of-cst-exception-type-conc2-rep-elem
  (b* ((abnf::cst1 (cst-exception-type-conc2-rep-elem abnf::cst)))
    (abnf::treep abnf::cst1))
  :rule-classes :rewrite)

Theorem: cst-exception-type-conc2-rep-elem-match

(defthm cst-exception-type-conc2-rep-elem-match
 (implies
    (and (cst-matchp abnf::cst "exception-type")
         (equal (cst-exception-type-conc? abnf::cst)
                2))
    (b* ((abnf::cst1 (cst-exception-type-conc2-rep-elem abnf::cst)))
      (cst-matchp abnf::cst1 "type-variable")))
 :rule-classes :rewrite)

Theorem: cst-exception-type-conc2-rep-elem-of-tree-fix-cst

(defthm cst-exception-type-conc2-rep-elem-of-tree-fix-cst
 (equal
      (cst-exception-type-conc2-rep-elem (abnf::tree-fix abnf::cst))
      (cst-exception-type-conc2-rep-elem abnf::cst)))

Theorem: cst-exception-type-conc2-rep-elem-tree-equiv-congruence-on-cst

(defthm
     cst-exception-type-conc2-rep-elem-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-exception-type-conc2-rep-elem abnf::cst)
                  (cst-exception-type-conc2-rep-elem cst-equiv)))
  :rule-classes :congruence)

Function: cst-instance-initializer-conc-rep-elem

(defun cst-instance-initializer-conc-rep-elem (abnf::cst)
  (declare (xargs :guard (abnf::treep abnf::cst)))
  (declare
       (xargs :guard (cst-matchp abnf::cst "instance-initializer")))
  (abnf::tree-fix
       (nth 0
            (cst-instance-initializer-conc-rep abnf::cst))))

Theorem: treep-of-cst-instance-initializer-conc-rep-elem

(defthm treep-of-cst-instance-initializer-conc-rep-elem
  (b*
   ((abnf::cst1 (cst-instance-initializer-conc-rep-elem abnf::cst)))
   (abnf::treep abnf::cst1))
  :rule-classes :rewrite)

Theorem: cst-instance-initializer-conc-rep-elem-match

(defthm cst-instance-initializer-conc-rep-elem-match
 (implies
  (cst-matchp abnf::cst "instance-initializer")
  (b*
   ((abnf::cst1 (cst-instance-initializer-conc-rep-elem abnf::cst)))
   (cst-matchp abnf::cst1 "block")))
 :rule-classes :rewrite)

Theorem: cst-instance-initializer-conc-rep-elem-of-tree-fix-cst

(defthm cst-instance-initializer-conc-rep-elem-of-tree-fix-cst
  (equal (cst-instance-initializer-conc-rep-elem
              (abnf::tree-fix abnf::cst))
         (cst-instance-initializer-conc-rep-elem abnf::cst)))

Theorem: cst-instance-initializer-conc-rep-elem-tree-equiv-congruence-on-cst

(defthm
 cst-instance-initializer-conc-rep-elem-tree-equiv-congruence-on-cst
 (implies
      (abnf::tree-equiv abnf::cst cst-equiv)
      (equal (cst-instance-initializer-conc-rep-elem abnf::cst)
             (cst-instance-initializer-conc-rep-elem cst-equiv)))
 :rule-classes :congruence)

Function: cst-simple-type-name-conc-rep-elem

(defun cst-simple-type-name-conc-rep-elem (abnf::cst)
  (declare (xargs :guard (abnf::treep abnf::cst)))
  (declare (xargs :guard (cst-matchp abnf::cst "simple-type-name")))
  (abnf::tree-fix (nth 0
                       (cst-simple-type-name-conc-rep abnf::cst))))

Theorem: treep-of-cst-simple-type-name-conc-rep-elem

(defthm treep-of-cst-simple-type-name-conc-rep-elem
  (b* ((abnf::cst1 (cst-simple-type-name-conc-rep-elem abnf::cst)))
    (abnf::treep abnf::cst1))
  :rule-classes :rewrite)

Theorem: cst-simple-type-name-conc-rep-elem-match

(defthm cst-simple-type-name-conc-rep-elem-match
 (implies
   (cst-matchp abnf::cst "simple-type-name")
   (b* ((abnf::cst1 (cst-simple-type-name-conc-rep-elem abnf::cst)))
     (cst-matchp abnf::cst1 "type-identifier")))
 :rule-classes :rewrite)

Theorem: cst-simple-type-name-conc-rep-elem-of-tree-fix-cst

(defthm cst-simple-type-name-conc-rep-elem-of-tree-fix-cst
 (equal
     (cst-simple-type-name-conc-rep-elem (abnf::tree-fix abnf::cst))
     (cst-simple-type-name-conc-rep-elem abnf::cst)))

Theorem: cst-simple-type-name-conc-rep-elem-tree-equiv-congruence-on-cst

(defthm
    cst-simple-type-name-conc-rep-elem-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-simple-type-name-conc-rep-elem abnf::cst)
                  (cst-simple-type-name-conc-rep-elem cst-equiv)))
  :rule-classes :congruence)

Function: cst-enum-constant-modifier-conc-rep-elem

(defun cst-enum-constant-modifier-conc-rep-elem (abnf::cst)
 (declare (xargs :guard (abnf::treep abnf::cst)))
 (declare
     (xargs :guard (cst-matchp abnf::cst "enum-constant-modifier")))
 (abnf::tree-fix
      (nth 0
           (cst-enum-constant-modifier-conc-rep abnf::cst))))

Theorem: treep-of-cst-enum-constant-modifier-conc-rep-elem

(defthm treep-of-cst-enum-constant-modifier-conc-rep-elem
  (b* ((abnf::cst1
            (cst-enum-constant-modifier-conc-rep-elem abnf::cst)))
    (abnf::treep abnf::cst1))
  :rule-classes :rewrite)

Theorem: cst-enum-constant-modifier-conc-rep-elem-match

(defthm cst-enum-constant-modifier-conc-rep-elem-match
 (implies
    (cst-matchp abnf::cst "enum-constant-modifier")
    (b* ((abnf::cst1
              (cst-enum-constant-modifier-conc-rep-elem abnf::cst)))
      (cst-matchp abnf::cst1 "annotation")))
 :rule-classes :rewrite)

Theorem: cst-enum-constant-modifier-conc-rep-elem-of-tree-fix-cst

(defthm cst-enum-constant-modifier-conc-rep-elem-of-tree-fix-cst
  (equal (cst-enum-constant-modifier-conc-rep-elem
              (abnf::tree-fix abnf::cst))
         (cst-enum-constant-modifier-conc-rep-elem abnf::cst)))

Theorem: cst-enum-constant-modifier-conc-rep-elem-tree-equiv-congruence-on-cst

(defthm
 cst-enum-constant-modifier-conc-rep-elem-tree-equiv-congruence-on-cst
 (implies
      (abnf::tree-equiv abnf::cst cst-equiv)
      (equal (cst-enum-constant-modifier-conc-rep-elem abnf::cst)
             (cst-enum-constant-modifier-conc-rep-elem cst-equiv)))
 :rule-classes :congruence)

Function: cst-record-component-modifier-conc-rep-elem

(defun cst-record-component-modifier-conc-rep-elem (abnf::cst)
 (declare (xargs :guard (abnf::treep abnf::cst)))
 (declare
  (xargs :guard (cst-matchp abnf::cst "record-component-modifier")))
 (abnf::tree-fix
      (nth 0
           (cst-record-component-modifier-conc-rep abnf::cst))))

Theorem: treep-of-cst-record-component-modifier-conc-rep-elem

(defthm treep-of-cst-record-component-modifier-conc-rep-elem
 (b* ((abnf::cst1
           (cst-record-component-modifier-conc-rep-elem abnf::cst)))
   (abnf::treep abnf::cst1))
 :rule-classes :rewrite)

Theorem: cst-record-component-modifier-conc-rep-elem-match

(defthm cst-record-component-modifier-conc-rep-elem-match
 (implies
   (cst-matchp abnf::cst "record-component-modifier")
   (b*
     ((abnf::cst1
           (cst-record-component-modifier-conc-rep-elem abnf::cst)))
     (cst-matchp abnf::cst1 "annotation")))
 :rule-classes :rewrite)

Theorem: cst-record-component-modifier-conc-rep-elem-of-tree-fix-cst

(defthm cst-record-component-modifier-conc-rep-elem-of-tree-fix-cst
  (equal (cst-record-component-modifier-conc-rep-elem
              (abnf::tree-fix abnf::cst))
         (cst-record-component-modifier-conc-rep-elem abnf::cst)))

Theorem: cst-record-component-modifier-conc-rep-elem-tree-equiv-congruence-on-cst

(defthm
 cst-record-component-modifier-conc-rep-elem-tree-equiv-congruence-on-cst
 (implies
    (abnf::tree-equiv abnf::cst cst-equiv)
    (equal (cst-record-component-modifier-conc-rep-elem abnf::cst)
           (cst-record-component-modifier-conc-rep-elem cst-equiv)))
 :rule-classes :congruence)

Function: cst-record-body-declaration-conc1-rep-elem

(defun cst-record-body-declaration-conc1-rep-elem (abnf::cst)
 (declare (xargs :guard (abnf::treep abnf::cst)))
 (declare
  (xargs
    :guard (and (cst-matchp abnf::cst "record-body-declaration")
                (equal (cst-record-body-declaration-conc? abnf::cst)
                       1))))
 (abnf::tree-fix
      (nth 0
           (cst-record-body-declaration-conc1-rep abnf::cst))))

Theorem: treep-of-cst-record-body-declaration-conc1-rep-elem

(defthm treep-of-cst-record-body-declaration-conc1-rep-elem
  (b* ((abnf::cst1
            (cst-record-body-declaration-conc1-rep-elem abnf::cst)))
    (abnf::treep abnf::cst1))
  :rule-classes :rewrite)

Theorem: cst-record-body-declaration-conc1-rep-elem-match

(defthm cst-record-body-declaration-conc1-rep-elem-match
 (implies
  (and (cst-matchp abnf::cst "record-body-declaration")
       (equal (cst-record-body-declaration-conc? abnf::cst)
              1))
  (b* ((abnf::cst1
            (cst-record-body-declaration-conc1-rep-elem abnf::cst)))
    (cst-matchp abnf::cst1 "class-body-declaration")))
 :rule-classes :rewrite)

Theorem: cst-record-body-declaration-conc1-rep-elem-of-tree-fix-cst

(defthm cst-record-body-declaration-conc1-rep-elem-of-tree-fix-cst
  (equal (cst-record-body-declaration-conc1-rep-elem
              (abnf::tree-fix abnf::cst))
         (cst-record-body-declaration-conc1-rep-elem abnf::cst)))

Theorem: cst-record-body-declaration-conc1-rep-elem-tree-equiv-congruence-on-cst

(defthm
 cst-record-body-declaration-conc1-rep-elem-tree-equiv-congruence-on-cst
 (implies
     (abnf::tree-equiv abnf::cst cst-equiv)
     (equal (cst-record-body-declaration-conc1-rep-elem abnf::cst)
            (cst-record-body-declaration-conc1-rep-elem cst-equiv)))
 :rule-classes :congruence)

Function: cst-record-body-declaration-conc2-rep-elem

(defun cst-record-body-declaration-conc2-rep-elem (abnf::cst)
 (declare (xargs :guard (abnf::treep abnf::cst)))
 (declare
  (xargs
    :guard (and (cst-matchp abnf::cst "record-body-declaration")
                (equal (cst-record-body-declaration-conc? abnf::cst)
                       2))))
 (abnf::tree-fix
      (nth 0
           (cst-record-body-declaration-conc2-rep abnf::cst))))

Theorem: treep-of-cst-record-body-declaration-conc2-rep-elem

(defthm treep-of-cst-record-body-declaration-conc2-rep-elem
  (b* ((abnf::cst1
            (cst-record-body-declaration-conc2-rep-elem abnf::cst)))
    (abnf::treep abnf::cst1))
  :rule-classes :rewrite)

Theorem: cst-record-body-declaration-conc2-rep-elem-match

(defthm cst-record-body-declaration-conc2-rep-elem-match
 (implies
  (and (cst-matchp abnf::cst "record-body-declaration")
       (equal (cst-record-body-declaration-conc? abnf::cst)
              2))
  (b* ((abnf::cst1
            (cst-record-body-declaration-conc2-rep-elem abnf::cst)))
    (cst-matchp abnf::cst1
                "compact-constructor-declaration")))
 :rule-classes :rewrite)

Theorem: cst-record-body-declaration-conc2-rep-elem-of-tree-fix-cst

(defthm cst-record-body-declaration-conc2-rep-elem-of-tree-fix-cst
  (equal (cst-record-body-declaration-conc2-rep-elem
              (abnf::tree-fix abnf::cst))
         (cst-record-body-declaration-conc2-rep-elem abnf::cst)))

Theorem: cst-record-body-declaration-conc2-rep-elem-tree-equiv-congruence-on-cst

(defthm
 cst-record-body-declaration-conc2-rep-elem-tree-equiv-congruence-on-cst
 (implies
     (abnf::tree-equiv abnf::cst cst-equiv)
     (equal (cst-record-body-declaration-conc2-rep-elem abnf::cst)
            (cst-record-body-declaration-conc2-rep-elem cst-equiv)))
 :rule-classes :congruence)

Function: cst-interface-declaration-conc1-rep-elem

(defun cst-interface-declaration-conc1-rep-elem (abnf::cst)
 (declare (xargs :guard (abnf::treep abnf::cst)))
 (declare
  (xargs
      :guard (and (cst-matchp abnf::cst "interface-declaration")
                  (equal (cst-interface-declaration-conc? abnf::cst)
                         1))))
 (abnf::tree-fix
      (nth 0
           (cst-interface-declaration-conc1-rep abnf::cst))))

Theorem: treep-of-cst-interface-declaration-conc1-rep-elem

(defthm treep-of-cst-interface-declaration-conc1-rep-elem
  (b* ((abnf::cst1
            (cst-interface-declaration-conc1-rep-elem abnf::cst)))
    (abnf::treep abnf::cst1))
  :rule-classes :rewrite)

Theorem: cst-interface-declaration-conc1-rep-elem-match

(defthm cst-interface-declaration-conc1-rep-elem-match
 (implies
    (and (cst-matchp abnf::cst "interface-declaration")
         (equal (cst-interface-declaration-conc? abnf::cst)
                1))
    (b* ((abnf::cst1
              (cst-interface-declaration-conc1-rep-elem abnf::cst)))
      (cst-matchp abnf::cst1
                  "normal-interface-declaration")))
 :rule-classes :rewrite)

Theorem: cst-interface-declaration-conc1-rep-elem-of-tree-fix-cst

(defthm cst-interface-declaration-conc1-rep-elem-of-tree-fix-cst
  (equal (cst-interface-declaration-conc1-rep-elem
              (abnf::tree-fix abnf::cst))
         (cst-interface-declaration-conc1-rep-elem abnf::cst)))

Theorem: cst-interface-declaration-conc1-rep-elem-tree-equiv-congruence-on-cst

(defthm
 cst-interface-declaration-conc1-rep-elem-tree-equiv-congruence-on-cst
 (implies
      (abnf::tree-equiv abnf::cst cst-equiv)
      (equal (cst-interface-declaration-conc1-rep-elem abnf::cst)
             (cst-interface-declaration-conc1-rep-elem cst-equiv)))
 :rule-classes :congruence)

Function: cst-interface-declaration-conc2-rep-elem

(defun cst-interface-declaration-conc2-rep-elem (abnf::cst)
 (declare (xargs :guard (abnf::treep abnf::cst)))
 (declare
  (xargs
      :guard (and (cst-matchp abnf::cst "interface-declaration")
                  (equal (cst-interface-declaration-conc? abnf::cst)
                         2))))
 (abnf::tree-fix
      (nth 0
           (cst-interface-declaration-conc2-rep abnf::cst))))

Theorem: treep-of-cst-interface-declaration-conc2-rep-elem

(defthm treep-of-cst-interface-declaration-conc2-rep-elem
  (b* ((abnf::cst1
            (cst-interface-declaration-conc2-rep-elem abnf::cst)))
    (abnf::treep abnf::cst1))
  :rule-classes :rewrite)

Theorem: cst-interface-declaration-conc2-rep-elem-match

(defthm cst-interface-declaration-conc2-rep-elem-match
 (implies
    (and (cst-matchp abnf::cst "interface-declaration")
         (equal (cst-interface-declaration-conc? abnf::cst)
                2))
    (b* ((abnf::cst1
              (cst-interface-declaration-conc2-rep-elem abnf::cst)))
      (cst-matchp abnf::cst1
                  "annotation-interface-declaration")))
 :rule-classes :rewrite)

Theorem: cst-interface-declaration-conc2-rep-elem-of-tree-fix-cst

(defthm cst-interface-declaration-conc2-rep-elem-of-tree-fix-cst
  (equal (cst-interface-declaration-conc2-rep-elem
              (abnf::tree-fix abnf::cst))
         (cst-interface-declaration-conc2-rep-elem abnf::cst)))

Theorem: cst-interface-declaration-conc2-rep-elem-tree-equiv-congruence-on-cst

(defthm
 cst-interface-declaration-conc2-rep-elem-tree-equiv-congruence-on-cst
 (implies
      (abnf::tree-equiv abnf::cst cst-equiv)
      (equal (cst-interface-declaration-conc2-rep-elem abnf::cst)
             (cst-interface-declaration-conc2-rep-elem cst-equiv)))
 :rule-classes :congruence)

Function: cst-annotation-conc1-rep-elem

(defun cst-annotation-conc1-rep-elem (abnf::cst)
 (declare (xargs :guard (abnf::treep abnf::cst)))
 (declare (xargs :guard (and (cst-matchp abnf::cst "annotation")
                             (equal (cst-annotation-conc? abnf::cst)
                                    1))))
 (abnf::tree-fix (nth 0
                      (cst-annotation-conc1-rep abnf::cst))))

Theorem: treep-of-cst-annotation-conc1-rep-elem

(defthm treep-of-cst-annotation-conc1-rep-elem
  (b* ((abnf::cst1 (cst-annotation-conc1-rep-elem abnf::cst)))
    (abnf::treep abnf::cst1))
  :rule-classes :rewrite)

Theorem: cst-annotation-conc1-rep-elem-match

(defthm cst-annotation-conc1-rep-elem-match
  (implies
       (and (cst-matchp abnf::cst "annotation")
            (equal (cst-annotation-conc? abnf::cst)
                   1))
       (b* ((abnf::cst1 (cst-annotation-conc1-rep-elem abnf::cst)))
         (cst-matchp abnf::cst1 "normal-annotation")))
  :rule-classes :rewrite)

Theorem: cst-annotation-conc1-rep-elem-of-tree-fix-cst

(defthm cst-annotation-conc1-rep-elem-of-tree-fix-cst
  (equal (cst-annotation-conc1-rep-elem (abnf::tree-fix abnf::cst))
         (cst-annotation-conc1-rep-elem abnf::cst)))

Theorem: cst-annotation-conc1-rep-elem-tree-equiv-congruence-on-cst

(defthm cst-annotation-conc1-rep-elem-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-annotation-conc1-rep-elem abnf::cst)
                  (cst-annotation-conc1-rep-elem cst-equiv)))
  :rule-classes :congruence)

Function: cst-annotation-conc2-rep-elem

(defun cst-annotation-conc2-rep-elem (abnf::cst)
 (declare (xargs :guard (abnf::treep abnf::cst)))
 (declare (xargs :guard (and (cst-matchp abnf::cst "annotation")
                             (equal (cst-annotation-conc? abnf::cst)
                                    2))))
 (abnf::tree-fix (nth 0
                      (cst-annotation-conc2-rep abnf::cst))))

Theorem: treep-of-cst-annotation-conc2-rep-elem

(defthm treep-of-cst-annotation-conc2-rep-elem
  (b* ((abnf::cst1 (cst-annotation-conc2-rep-elem abnf::cst)))
    (abnf::treep abnf::cst1))
  :rule-classes :rewrite)

Theorem: cst-annotation-conc2-rep-elem-match

(defthm cst-annotation-conc2-rep-elem-match
  (implies
       (and (cst-matchp abnf::cst "annotation")
            (equal (cst-annotation-conc? abnf::cst)
                   2))
       (b* ((abnf::cst1 (cst-annotation-conc2-rep-elem abnf::cst)))
         (cst-matchp abnf::cst1 "marker-annotation")))
  :rule-classes :rewrite)

Theorem: cst-annotation-conc2-rep-elem-of-tree-fix-cst

(defthm cst-annotation-conc2-rep-elem-of-tree-fix-cst
  (equal (cst-annotation-conc2-rep-elem (abnf::tree-fix abnf::cst))
         (cst-annotation-conc2-rep-elem abnf::cst)))

Theorem: cst-annotation-conc2-rep-elem-tree-equiv-congruence-on-cst

(defthm cst-annotation-conc2-rep-elem-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-annotation-conc2-rep-elem abnf::cst)
                  (cst-annotation-conc2-rep-elem cst-equiv)))
  :rule-classes :congruence)

Function: cst-annotation-conc3-rep-elem

(defun cst-annotation-conc3-rep-elem (abnf::cst)
 (declare (xargs :guard (abnf::treep abnf::cst)))
 (declare (xargs :guard (and (cst-matchp abnf::cst "annotation")
                             (equal (cst-annotation-conc? abnf::cst)
                                    3))))
 (abnf::tree-fix (nth 0
                      (cst-annotation-conc3-rep abnf::cst))))

Theorem: treep-of-cst-annotation-conc3-rep-elem

(defthm treep-of-cst-annotation-conc3-rep-elem
  (b* ((abnf::cst1 (cst-annotation-conc3-rep-elem abnf::cst)))
    (abnf::treep abnf::cst1))
  :rule-classes :rewrite)

Theorem: cst-annotation-conc3-rep-elem-match

(defthm cst-annotation-conc3-rep-elem-match
  (implies
       (and (cst-matchp abnf::cst "annotation")
            (equal (cst-annotation-conc? abnf::cst)
                   3))
       (b* ((abnf::cst1 (cst-annotation-conc3-rep-elem abnf::cst)))
         (cst-matchp abnf::cst1
                     "single-element-annotation")))
  :rule-classes :rewrite)

Theorem: cst-annotation-conc3-rep-elem-of-tree-fix-cst

(defthm cst-annotation-conc3-rep-elem-of-tree-fix-cst
  (equal (cst-annotation-conc3-rep-elem (abnf::tree-fix abnf::cst))
         (cst-annotation-conc3-rep-elem abnf::cst)))

Theorem: cst-annotation-conc3-rep-elem-tree-equiv-congruence-on-cst

(defthm cst-annotation-conc3-rep-elem-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-annotation-conc3-rep-elem abnf::cst)
                  (cst-annotation-conc3-rep-elem cst-equiv)))
  :rule-classes :congruence)

Function: cst-element-value-conc1-rep-elem

(defun cst-element-value-conc1-rep-elem (abnf::cst)
  (declare (xargs :guard (abnf::treep abnf::cst)))
  (declare
       (xargs :guard (and (cst-matchp abnf::cst "element-value")
                          (equal (cst-element-value-conc? abnf::cst)
                                 1))))
  (abnf::tree-fix (nth 0
                       (cst-element-value-conc1-rep abnf::cst))))

Theorem: treep-of-cst-element-value-conc1-rep-elem

(defthm treep-of-cst-element-value-conc1-rep-elem
  (b* ((abnf::cst1 (cst-element-value-conc1-rep-elem abnf::cst)))
    (abnf::treep abnf::cst1))
  :rule-classes :rewrite)

Theorem: cst-element-value-conc1-rep-elem-match

(defthm cst-element-value-conc1-rep-elem-match
 (implies
     (and (cst-matchp abnf::cst "element-value")
          (equal (cst-element-value-conc? abnf::cst)
                 1))
     (b* ((abnf::cst1 (cst-element-value-conc1-rep-elem abnf::cst)))
       (cst-matchp abnf::cst1 "conditional-expression")))
 :rule-classes :rewrite)

Theorem: cst-element-value-conc1-rep-elem-of-tree-fix-cst

(defthm cst-element-value-conc1-rep-elem-of-tree-fix-cst
  (equal
       (cst-element-value-conc1-rep-elem (abnf::tree-fix abnf::cst))
       (cst-element-value-conc1-rep-elem abnf::cst)))

Theorem: cst-element-value-conc1-rep-elem-tree-equiv-congruence-on-cst

(defthm
      cst-element-value-conc1-rep-elem-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-element-value-conc1-rep-elem abnf::cst)
                  (cst-element-value-conc1-rep-elem cst-equiv)))
  :rule-classes :congruence)

Function: cst-element-value-conc2-rep-elem

(defun cst-element-value-conc2-rep-elem (abnf::cst)
  (declare (xargs :guard (abnf::treep abnf::cst)))
  (declare
       (xargs :guard (and (cst-matchp abnf::cst "element-value")
                          (equal (cst-element-value-conc? abnf::cst)
                                 2))))
  (abnf::tree-fix (nth 0
                       (cst-element-value-conc2-rep abnf::cst))))

Theorem: treep-of-cst-element-value-conc2-rep-elem

(defthm treep-of-cst-element-value-conc2-rep-elem
  (b* ((abnf::cst1 (cst-element-value-conc2-rep-elem abnf::cst)))
    (abnf::treep abnf::cst1))
  :rule-classes :rewrite)

Theorem: cst-element-value-conc2-rep-elem-match

(defthm cst-element-value-conc2-rep-elem-match
 (implies
     (and (cst-matchp abnf::cst "element-value")
          (equal (cst-element-value-conc? abnf::cst)
                 2))
     (b* ((abnf::cst1 (cst-element-value-conc2-rep-elem abnf::cst)))
       (cst-matchp abnf::cst1
                   "element-value-array-initializer")))
 :rule-classes :rewrite)

Theorem: cst-element-value-conc2-rep-elem-of-tree-fix-cst

(defthm cst-element-value-conc2-rep-elem-of-tree-fix-cst
  (equal
       (cst-element-value-conc2-rep-elem (abnf::tree-fix abnf::cst))
       (cst-element-value-conc2-rep-elem abnf::cst)))

Theorem: cst-element-value-conc2-rep-elem-tree-equiv-congruence-on-cst

(defthm
      cst-element-value-conc2-rep-elem-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-element-value-conc2-rep-elem abnf::cst)
                  (cst-element-value-conc2-rep-elem cst-equiv)))
  :rule-classes :congruence)

Function: cst-element-value-conc3-rep-elem

(defun cst-element-value-conc3-rep-elem (abnf::cst)
  (declare (xargs :guard (abnf::treep abnf::cst)))
  (declare
       (xargs :guard (and (cst-matchp abnf::cst "element-value")
                          (equal (cst-element-value-conc? abnf::cst)
                                 3))))
  (abnf::tree-fix (nth 0
                       (cst-element-value-conc3-rep abnf::cst))))

Theorem: treep-of-cst-element-value-conc3-rep-elem

(defthm treep-of-cst-element-value-conc3-rep-elem
  (b* ((abnf::cst1 (cst-element-value-conc3-rep-elem abnf::cst)))
    (abnf::treep abnf::cst1))
  :rule-classes :rewrite)

Theorem: cst-element-value-conc3-rep-elem-match

(defthm cst-element-value-conc3-rep-elem-match
 (implies
     (and (cst-matchp abnf::cst "element-value")
          (equal (cst-element-value-conc? abnf::cst)
                 3))
     (b* ((abnf::cst1 (cst-element-value-conc3-rep-elem abnf::cst)))
       (cst-matchp abnf::cst1 "annotation")))
 :rule-classes :rewrite)

Theorem: cst-element-value-conc3-rep-elem-of-tree-fix-cst

(defthm cst-element-value-conc3-rep-elem-of-tree-fix-cst
  (equal
       (cst-element-value-conc3-rep-elem (abnf::tree-fix abnf::cst))
       (cst-element-value-conc3-rep-elem abnf::cst)))

Theorem: cst-element-value-conc3-rep-elem-tree-equiv-congruence-on-cst

(defthm
      cst-element-value-conc3-rep-elem-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-element-value-conc3-rep-elem abnf::cst)
                  (cst-element-value-conc3-rep-elem cst-equiv)))
  :rule-classes :congruence)

Function: cst-block-statement-conc1-rep-elem

(defun cst-block-statement-conc1-rep-elem (abnf::cst)
 (declare (xargs :guard (abnf::treep abnf::cst)))
 (declare
     (xargs :guard (and (cst-matchp abnf::cst "block-statement")
                        (equal (cst-block-statement-conc? abnf::cst)
                               1))))
 (abnf::tree-fix (nth 0
                      (cst-block-statement-conc1-rep abnf::cst))))

Theorem: treep-of-cst-block-statement-conc1-rep-elem

(defthm treep-of-cst-block-statement-conc1-rep-elem
  (b* ((abnf::cst1 (cst-block-statement-conc1-rep-elem abnf::cst)))
    (abnf::treep abnf::cst1))
  :rule-classes :rewrite)

Theorem: cst-block-statement-conc1-rep-elem-match

(defthm cst-block-statement-conc1-rep-elem-match
 (implies
   (and (cst-matchp abnf::cst "block-statement")
        (equal (cst-block-statement-conc? abnf::cst)
               1))
   (b* ((abnf::cst1 (cst-block-statement-conc1-rep-elem abnf::cst)))
     (cst-matchp abnf::cst1
                 "local-class-or-interface-declaration")))
 :rule-classes :rewrite)

Theorem: cst-block-statement-conc1-rep-elem-of-tree-fix-cst

(defthm cst-block-statement-conc1-rep-elem-of-tree-fix-cst
 (equal
     (cst-block-statement-conc1-rep-elem (abnf::tree-fix abnf::cst))
     (cst-block-statement-conc1-rep-elem abnf::cst)))

Theorem: cst-block-statement-conc1-rep-elem-tree-equiv-congruence-on-cst

(defthm
    cst-block-statement-conc1-rep-elem-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-block-statement-conc1-rep-elem abnf::cst)
                  (cst-block-statement-conc1-rep-elem cst-equiv)))
  :rule-classes :congruence)

Function: cst-block-statement-conc2-rep-elem

(defun cst-block-statement-conc2-rep-elem (abnf::cst)
 (declare (xargs :guard (abnf::treep abnf::cst)))
 (declare
     (xargs :guard (and (cst-matchp abnf::cst "block-statement")
                        (equal (cst-block-statement-conc? abnf::cst)
                               2))))
 (abnf::tree-fix (nth 0
                      (cst-block-statement-conc2-rep abnf::cst))))

Theorem: treep-of-cst-block-statement-conc2-rep-elem

(defthm treep-of-cst-block-statement-conc2-rep-elem
  (b* ((abnf::cst1 (cst-block-statement-conc2-rep-elem abnf::cst)))
    (abnf::treep abnf::cst1))
  :rule-classes :rewrite)

Theorem: cst-block-statement-conc2-rep-elem-match

(defthm cst-block-statement-conc2-rep-elem-match
 (implies
   (and (cst-matchp abnf::cst "block-statement")
        (equal (cst-block-statement-conc? abnf::cst)
               2))
   (b* ((abnf::cst1 (cst-block-statement-conc2-rep-elem abnf::cst)))
     (cst-matchp abnf::cst1
                 "local-variable-declaration-statement")))
 :rule-classes :rewrite)

Theorem: cst-block-statement-conc2-rep-elem-of-tree-fix-cst

(defthm cst-block-statement-conc2-rep-elem-of-tree-fix-cst
 (equal
     (cst-block-statement-conc2-rep-elem (abnf::tree-fix abnf::cst))
     (cst-block-statement-conc2-rep-elem abnf::cst)))

Theorem: cst-block-statement-conc2-rep-elem-tree-equiv-congruence-on-cst

(defthm
    cst-block-statement-conc2-rep-elem-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-block-statement-conc2-rep-elem abnf::cst)
                  (cst-block-statement-conc2-rep-elem cst-equiv)))
  :rule-classes :congruence)

Function: cst-block-statement-conc3-rep-elem

(defun cst-block-statement-conc3-rep-elem (abnf::cst)
 (declare (xargs :guard (abnf::treep abnf::cst)))
 (declare
     (xargs :guard (and (cst-matchp abnf::cst "block-statement")
                        (equal (cst-block-statement-conc? abnf::cst)
                               3))))
 (abnf::tree-fix (nth 0
                      (cst-block-statement-conc3-rep abnf::cst))))

Theorem: treep-of-cst-block-statement-conc3-rep-elem

(defthm treep-of-cst-block-statement-conc3-rep-elem
  (b* ((abnf::cst1 (cst-block-statement-conc3-rep-elem abnf::cst)))
    (abnf::treep abnf::cst1))
  :rule-classes :rewrite)

Theorem: cst-block-statement-conc3-rep-elem-match

(defthm cst-block-statement-conc3-rep-elem-match
 (implies
   (and (cst-matchp abnf::cst "block-statement")
        (equal (cst-block-statement-conc? abnf::cst)
               3))
   (b* ((abnf::cst1 (cst-block-statement-conc3-rep-elem abnf::cst)))
     (cst-matchp abnf::cst1 "statement")))
 :rule-classes :rewrite)

Theorem: cst-block-statement-conc3-rep-elem-of-tree-fix-cst

(defthm cst-block-statement-conc3-rep-elem-of-tree-fix-cst
 (equal
     (cst-block-statement-conc3-rep-elem (abnf::tree-fix abnf::cst))
     (cst-block-statement-conc3-rep-elem abnf::cst)))

Theorem: cst-block-statement-conc3-rep-elem-tree-equiv-congruence-on-cst

(defthm
    cst-block-statement-conc3-rep-elem-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-block-statement-conc3-rep-elem abnf::cst)
                  (cst-block-statement-conc3-rep-elem cst-equiv)))
  :rule-classes :congruence)

Function: cst-local-class-or-interface-declaration-conc1-rep-elem

(defun cst-local-class-or-interface-declaration-conc1-rep-elem
       (abnf::cst)
 (declare (xargs :guard (abnf::treep abnf::cst)))
 (declare
  (xargs
   :guard
   (and
     (cst-matchp abnf::cst
                 "local-class-or-interface-declaration")
     (equal
          (cst-local-class-or-interface-declaration-conc? abnf::cst)
          1))))
 (abnf::tree-fix
  (nth
   0
   (cst-local-class-or-interface-declaration-conc1-rep abnf::cst))))

Theorem: treep-of-cst-local-class-or-interface-declaration-conc1-rep-elem

(defthm
   treep-of-cst-local-class-or-interface-declaration-conc1-rep-elem
  (b* ((abnf::cst1 (cst-local-class-or-interface-declaration-conc1-rep-elem
                        abnf::cst)))
    (abnf::treep abnf::cst1))
  :rule-classes :rewrite)

Theorem: cst-local-class-or-interface-declaration-conc1-rep-elem-match

(defthm
      cst-local-class-or-interface-declaration-conc1-rep-elem-match
 (implies
  (and
   (cst-matchp abnf::cst
               "local-class-or-interface-declaration")
   (equal (cst-local-class-or-interface-declaration-conc? abnf::cst)
          1))
  (b* ((abnf::cst1 (cst-local-class-or-interface-declaration-conc1-rep-elem
                        abnf::cst)))
    (cst-matchp abnf::cst1 "class-declaration")))
 :rule-classes :rewrite)

Theorem: cst-local-class-or-interface-declaration-conc1-rep-elem-of-tree-fix-cst

(defthm
 cst-local-class-or-interface-declaration-conc1-rep-elem-of-tree-fix-cst
 (equal (cst-local-class-or-interface-declaration-conc1-rep-elem
             (abnf::tree-fix abnf::cst))
        (cst-local-class-or-interface-declaration-conc1-rep-elem
             abnf::cst)))

Theorem: cst-local-class-or-interface-declaration-conc1-rep-elem-tree-equiv-congruence-on-cst

(defthm
 cst-local-class-or-interface-declaration-conc1-rep-elem-tree-equiv-congruence-on-cst
 (implies (abnf::tree-equiv abnf::cst cst-equiv)
          (equal (cst-local-class-or-interface-declaration-conc1-rep-elem
                      abnf::cst)
                 (cst-local-class-or-interface-declaration-conc1-rep-elem
                      cst-equiv)))
 :rule-classes :congruence)

Function: cst-local-class-or-interface-declaration-conc2-rep-elem

(defun cst-local-class-or-interface-declaration-conc2-rep-elem
       (abnf::cst)
 (declare (xargs :guard (abnf::treep abnf::cst)))
 (declare
  (xargs
   :guard
   (and
     (cst-matchp abnf::cst
                 "local-class-or-interface-declaration")
     (equal
          (cst-local-class-or-interface-declaration-conc? abnf::cst)
          2))))
 (abnf::tree-fix
  (nth
   0
   (cst-local-class-or-interface-declaration-conc2-rep abnf::cst))))

Theorem: treep-of-cst-local-class-or-interface-declaration-conc2-rep-elem

(defthm
   treep-of-cst-local-class-or-interface-declaration-conc2-rep-elem
  (b* ((abnf::cst1 (cst-local-class-or-interface-declaration-conc2-rep-elem
                        abnf::cst)))
    (abnf::treep abnf::cst1))
  :rule-classes :rewrite)

Theorem: cst-local-class-or-interface-declaration-conc2-rep-elem-match

(defthm
      cst-local-class-or-interface-declaration-conc2-rep-elem-match
 (implies
  (and
   (cst-matchp abnf::cst
               "local-class-or-interface-declaration")
   (equal (cst-local-class-or-interface-declaration-conc? abnf::cst)
          2))
  (b* ((abnf::cst1 (cst-local-class-or-interface-declaration-conc2-rep-elem
                        abnf::cst)))
    (cst-matchp abnf::cst1
                "normal-interface-declaration")))
 :rule-classes :rewrite)

Theorem: cst-local-class-or-interface-declaration-conc2-rep-elem-of-tree-fix-cst

(defthm
 cst-local-class-or-interface-declaration-conc2-rep-elem-of-tree-fix-cst
 (equal (cst-local-class-or-interface-declaration-conc2-rep-elem
             (abnf::tree-fix abnf::cst))
        (cst-local-class-or-interface-declaration-conc2-rep-elem
             abnf::cst)))

Theorem: cst-local-class-or-interface-declaration-conc2-rep-elem-tree-equiv-congruence-on-cst

(defthm
 cst-local-class-or-interface-declaration-conc2-rep-elem-tree-equiv-congruence-on-cst
 (implies (abnf::tree-equiv abnf::cst cst-equiv)
          (equal (cst-local-class-or-interface-declaration-conc2-rep-elem
                      abnf::cst)
                 (cst-local-class-or-interface-declaration-conc2-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))))
  (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
                     "statement-without-trailing-substatement")))
  :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))))
  (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 "labeled-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))))
  (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 "if-then-statement")))
  :rule-classes :rewrite)

Theorem: cst-statement-conc3-rep-elem-of-tree-fix-cst

(defthm cst-statement-conc3-rep-elem-of-tree-fix-cst
  (equal (cst-statement-conc3-rep-elem (abnf::tree-fix abnf::cst))
         (cst-statement-conc3-rep-elem abnf::cst)))

Theorem: cst-statement-conc3-rep-elem-tree-equiv-congruence-on-cst

(defthm cst-statement-conc3-rep-elem-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-statement-conc3-rep-elem abnf::cst)
                  (cst-statement-conc3-rep-elem cst-equiv)))
  :rule-classes :congruence)

Function: cst-statement-conc4-rep-elem

(defun cst-statement-conc4-rep-elem (abnf::cst)
  (declare (xargs :guard (abnf::treep abnf::cst)))
  (declare (xargs :guard (and (cst-matchp abnf::cst "statement")
                              (equal (cst-statement-conc? abnf::cst)
                                     4))))
  (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 "if-then-else-statement")))
  :rule-classes :rewrite)

Theorem: cst-statement-conc4-rep-elem-of-tree-fix-cst

(defthm cst-statement-conc4-rep-elem-of-tree-fix-cst
  (equal (cst-statement-conc4-rep-elem (abnf::tree-fix abnf::cst))
         (cst-statement-conc4-rep-elem abnf::cst)))

Theorem: cst-statement-conc4-rep-elem-tree-equiv-congruence-on-cst

(defthm cst-statement-conc4-rep-elem-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-statement-conc4-rep-elem abnf::cst)
                  (cst-statement-conc4-rep-elem cst-equiv)))
  :rule-classes :congruence)

Function: cst-statement-conc5-rep-elem

(defun cst-statement-conc5-rep-elem (abnf::cst)
  (declare (xargs :guard (abnf::treep abnf::cst)))
  (declare (xargs :guard (and (cst-matchp abnf::cst "statement")
                              (equal (cst-statement-conc? abnf::cst)
                                     5))))
  (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 "while-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))))
  (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 "for-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-no-short-if-conc1-rep-elem

(defun cst-statement-no-short-if-conc1-rep-elem (abnf::cst)
 (declare (xargs :guard (abnf::treep abnf::cst)))
 (declare
  (xargs
      :guard (and (cst-matchp abnf::cst "statement-no-short-if")
                  (equal (cst-statement-no-short-if-conc? abnf::cst)
                         1))))
 (abnf::tree-fix
      (nth 0
           (cst-statement-no-short-if-conc1-rep abnf::cst))))

Theorem: treep-of-cst-statement-no-short-if-conc1-rep-elem

(defthm treep-of-cst-statement-no-short-if-conc1-rep-elem
  (b* ((abnf::cst1
            (cst-statement-no-short-if-conc1-rep-elem abnf::cst)))
    (abnf::treep abnf::cst1))
  :rule-classes :rewrite)

Theorem: cst-statement-no-short-if-conc1-rep-elem-match

(defthm cst-statement-no-short-if-conc1-rep-elem-match
 (implies
    (and (cst-matchp abnf::cst "statement-no-short-if")
         (equal (cst-statement-no-short-if-conc? abnf::cst)
                1))
    (b* ((abnf::cst1
              (cst-statement-no-short-if-conc1-rep-elem abnf::cst)))
      (cst-matchp abnf::cst1
                  "statement-without-trailing-substatement")))
 :rule-classes :rewrite)

Theorem: cst-statement-no-short-if-conc1-rep-elem-of-tree-fix-cst

(defthm cst-statement-no-short-if-conc1-rep-elem-of-tree-fix-cst
  (equal (cst-statement-no-short-if-conc1-rep-elem
              (abnf::tree-fix abnf::cst))
         (cst-statement-no-short-if-conc1-rep-elem abnf::cst)))

Theorem: cst-statement-no-short-if-conc1-rep-elem-tree-equiv-congruence-on-cst

(defthm
 cst-statement-no-short-if-conc1-rep-elem-tree-equiv-congruence-on-cst
 (implies
      (abnf::tree-equiv abnf::cst cst-equiv)
      (equal (cst-statement-no-short-if-conc1-rep-elem abnf::cst)
             (cst-statement-no-short-if-conc1-rep-elem cst-equiv)))
 :rule-classes :congruence)

Function: cst-statement-no-short-if-conc2-rep-elem

(defun cst-statement-no-short-if-conc2-rep-elem (abnf::cst)
 (declare (xargs :guard (abnf::treep abnf::cst)))
 (declare
  (xargs
      :guard (and (cst-matchp abnf::cst "statement-no-short-if")
                  (equal (cst-statement-no-short-if-conc? abnf::cst)
                         2))))
 (abnf::tree-fix
      (nth 0
           (cst-statement-no-short-if-conc2-rep abnf::cst))))

Theorem: treep-of-cst-statement-no-short-if-conc2-rep-elem

(defthm treep-of-cst-statement-no-short-if-conc2-rep-elem
  (b* ((abnf::cst1
            (cst-statement-no-short-if-conc2-rep-elem abnf::cst)))
    (abnf::treep abnf::cst1))
  :rule-classes :rewrite)

Theorem: cst-statement-no-short-if-conc2-rep-elem-match

(defthm cst-statement-no-short-if-conc2-rep-elem-match
 (implies
    (and (cst-matchp abnf::cst "statement-no-short-if")
         (equal (cst-statement-no-short-if-conc? abnf::cst)
                2))
    (b* ((abnf::cst1
              (cst-statement-no-short-if-conc2-rep-elem abnf::cst)))
      (cst-matchp abnf::cst1
                  "labeled-statement-no-short-if")))
 :rule-classes :rewrite)

Theorem: cst-statement-no-short-if-conc2-rep-elem-of-tree-fix-cst

(defthm cst-statement-no-short-if-conc2-rep-elem-of-tree-fix-cst
  (equal (cst-statement-no-short-if-conc2-rep-elem
              (abnf::tree-fix abnf::cst))
         (cst-statement-no-short-if-conc2-rep-elem abnf::cst)))

Theorem: cst-statement-no-short-if-conc2-rep-elem-tree-equiv-congruence-on-cst

(defthm
 cst-statement-no-short-if-conc2-rep-elem-tree-equiv-congruence-on-cst
 (implies
      (abnf::tree-equiv abnf::cst cst-equiv)
      (equal (cst-statement-no-short-if-conc2-rep-elem abnf::cst)
             (cst-statement-no-short-if-conc2-rep-elem cst-equiv)))
 :rule-classes :congruence)

Function: cst-statement-no-short-if-conc3-rep-elem

(defun cst-statement-no-short-if-conc3-rep-elem (abnf::cst)
 (declare (xargs :guard (abnf::treep abnf::cst)))
 (declare
  (xargs
      :guard (and (cst-matchp abnf::cst "statement-no-short-if")
                  (equal (cst-statement-no-short-if-conc? abnf::cst)
                         3))))
 (abnf::tree-fix
      (nth 0
           (cst-statement-no-short-if-conc3-rep abnf::cst))))

Theorem: treep-of-cst-statement-no-short-if-conc3-rep-elem

(defthm treep-of-cst-statement-no-short-if-conc3-rep-elem
  (b* ((abnf::cst1
            (cst-statement-no-short-if-conc3-rep-elem abnf::cst)))
    (abnf::treep abnf::cst1))
  :rule-classes :rewrite)

Theorem: cst-statement-no-short-if-conc3-rep-elem-match

(defthm cst-statement-no-short-if-conc3-rep-elem-match
 (implies
    (and (cst-matchp abnf::cst "statement-no-short-if")
         (equal (cst-statement-no-short-if-conc? abnf::cst)
                3))
    (b* ((abnf::cst1
              (cst-statement-no-short-if-conc3-rep-elem abnf::cst)))
      (cst-matchp abnf::cst1
                  "if-then-else-statement-no-short-if")))
 :rule-classes :rewrite)

Theorem: cst-statement-no-short-if-conc3-rep-elem-of-tree-fix-cst

(defthm cst-statement-no-short-if-conc3-rep-elem-of-tree-fix-cst
  (equal (cst-statement-no-short-if-conc3-rep-elem
              (abnf::tree-fix abnf::cst))
         (cst-statement-no-short-if-conc3-rep-elem abnf::cst)))

Theorem: cst-statement-no-short-if-conc3-rep-elem-tree-equiv-congruence-on-cst

(defthm
 cst-statement-no-short-if-conc3-rep-elem-tree-equiv-congruence-on-cst
 (implies
      (abnf::tree-equiv abnf::cst cst-equiv)
      (equal (cst-statement-no-short-if-conc3-rep-elem abnf::cst)
             (cst-statement-no-short-if-conc3-rep-elem cst-equiv)))
 :rule-classes :congruence)

Function: cst-statement-no-short-if-conc4-rep-elem

(defun cst-statement-no-short-if-conc4-rep-elem (abnf::cst)
 (declare (xargs :guard (abnf::treep abnf::cst)))
 (declare
  (xargs
      :guard (and (cst-matchp abnf::cst "statement-no-short-if")
                  (equal (cst-statement-no-short-if-conc? abnf::cst)
                         4))))
 (abnf::tree-fix
      (nth 0
           (cst-statement-no-short-if-conc4-rep abnf::cst))))

Theorem: treep-of-cst-statement-no-short-if-conc4-rep-elem

(defthm treep-of-cst-statement-no-short-if-conc4-rep-elem
  (b* ((abnf::cst1
            (cst-statement-no-short-if-conc4-rep-elem abnf::cst)))
    (abnf::treep abnf::cst1))
  :rule-classes :rewrite)

Theorem: cst-statement-no-short-if-conc4-rep-elem-match

(defthm cst-statement-no-short-if-conc4-rep-elem-match
 (implies
    (and (cst-matchp abnf::cst "statement-no-short-if")
         (equal (cst-statement-no-short-if-conc? abnf::cst)
                4))
    (b* ((abnf::cst1
              (cst-statement-no-short-if-conc4-rep-elem abnf::cst)))
      (cst-matchp abnf::cst1
                  "while-statement-no-short-if")))
 :rule-classes :rewrite)

Theorem: cst-statement-no-short-if-conc4-rep-elem-of-tree-fix-cst

(defthm cst-statement-no-short-if-conc4-rep-elem-of-tree-fix-cst
  (equal (cst-statement-no-short-if-conc4-rep-elem
              (abnf::tree-fix abnf::cst))
         (cst-statement-no-short-if-conc4-rep-elem abnf::cst)))

Theorem: cst-statement-no-short-if-conc4-rep-elem-tree-equiv-congruence-on-cst

(defthm
 cst-statement-no-short-if-conc4-rep-elem-tree-equiv-congruence-on-cst
 (implies
      (abnf::tree-equiv abnf::cst cst-equiv)
      (equal (cst-statement-no-short-if-conc4-rep-elem abnf::cst)
             (cst-statement-no-short-if-conc4-rep-elem cst-equiv)))
 :rule-classes :congruence)

Function: cst-statement-no-short-if-conc5-rep-elem

(defun cst-statement-no-short-if-conc5-rep-elem (abnf::cst)
 (declare (xargs :guard (abnf::treep abnf::cst)))
 (declare
  (xargs
      :guard (and (cst-matchp abnf::cst "statement-no-short-if")
                  (equal (cst-statement-no-short-if-conc? abnf::cst)
                         5))))
 (abnf::tree-fix
      (nth 0
           (cst-statement-no-short-if-conc5-rep abnf::cst))))

Theorem: treep-of-cst-statement-no-short-if-conc5-rep-elem

(defthm treep-of-cst-statement-no-short-if-conc5-rep-elem
  (b* ((abnf::cst1
            (cst-statement-no-short-if-conc5-rep-elem abnf::cst)))
    (abnf::treep abnf::cst1))
  :rule-classes :rewrite)

Theorem: cst-statement-no-short-if-conc5-rep-elem-match

(defthm cst-statement-no-short-if-conc5-rep-elem-match
 (implies
    (and (cst-matchp abnf::cst "statement-no-short-if")
         (equal (cst-statement-no-short-if-conc? abnf::cst)
                5))
    (b* ((abnf::cst1
              (cst-statement-no-short-if-conc5-rep-elem abnf::cst)))
      (cst-matchp abnf::cst1
                  "for-statement-no-short-if")))
 :rule-classes :rewrite)

Theorem: cst-statement-no-short-if-conc5-rep-elem-of-tree-fix-cst

(defthm cst-statement-no-short-if-conc5-rep-elem-of-tree-fix-cst
  (equal (cst-statement-no-short-if-conc5-rep-elem
              (abnf::tree-fix abnf::cst))
         (cst-statement-no-short-if-conc5-rep-elem abnf::cst)))

Theorem: cst-statement-no-short-if-conc5-rep-elem-tree-equiv-congruence-on-cst

(defthm
 cst-statement-no-short-if-conc5-rep-elem-tree-equiv-congruence-on-cst
 (implies
      (abnf::tree-equiv abnf::cst cst-equiv)
      (equal (cst-statement-no-short-if-conc5-rep-elem abnf::cst)
             (cst-statement-no-short-if-conc5-rep-elem cst-equiv)))
 :rule-classes :congruence)

Function: cst-statement-without-trailing-substatement-conc1-rep-elem

(defun cst-statement-without-trailing-substatement-conc1-rep-elem
       (abnf::cst)
 (declare (xargs :guard (abnf::treep abnf::cst)))
 (declare
  (xargs
   :guard
   (and
    (cst-matchp abnf::cst
                "statement-without-trailing-substatement")
    (equal
       (cst-statement-without-trailing-substatement-conc? abnf::cst)
       1))))
 (abnf::tree-fix (nth 0
                      (cst-statement-without-trailing-substatement-conc1-rep
                           abnf::cst))))

Theorem: treep-of-cst-statement-without-trailing-substatement-conc1-rep-elem

(defthm
 treep-of-cst-statement-without-trailing-substatement-conc1-rep-elem
 (b* ((abnf::cst1 (cst-statement-without-trailing-substatement-conc1-rep-elem
                       abnf::cst)))
   (abnf::treep abnf::cst1))
 :rule-classes :rewrite)

Theorem: cst-statement-without-trailing-substatement-conc1-rep-elem-match

(defthm
   cst-statement-without-trailing-substatement-conc1-rep-elem-match
 (implies
  (and
   (cst-matchp abnf::cst
               "statement-without-trailing-substatement")
   (equal
       (cst-statement-without-trailing-substatement-conc? abnf::cst)
       1))
  (b* ((abnf::cst1 (cst-statement-without-trailing-substatement-conc1-rep-elem
                        abnf::cst)))
    (cst-matchp abnf::cst1 "block")))
 :rule-classes :rewrite)

Theorem: cst-statement-without-trailing-substatement-conc1-rep-elem-of-tree-fix-cst

(defthm
 cst-statement-without-trailing-substatement-conc1-rep-elem-of-tree-fix-cst
 (equal (cst-statement-without-trailing-substatement-conc1-rep-elem
             (abnf::tree-fix abnf::cst))
        (cst-statement-without-trailing-substatement-conc1-rep-elem
             abnf::cst)))

Theorem: cst-statement-without-trailing-substatement-conc1-rep-elem-tree-equiv-congruence-on-cst

(defthm
 cst-statement-without-trailing-substatement-conc1-rep-elem-tree-equiv-congruence-on-cst
 (implies (abnf::tree-equiv abnf::cst cst-equiv)
          (equal (cst-statement-without-trailing-substatement-conc1-rep-elem
                      abnf::cst)
                 (cst-statement-without-trailing-substatement-conc1-rep-elem
                      cst-equiv)))
 :rule-classes :congruence)

Function: cst-statement-without-trailing-substatement-conc2-rep-elem

(defun cst-statement-without-trailing-substatement-conc2-rep-elem
       (abnf::cst)
 (declare (xargs :guard (abnf::treep abnf::cst)))
 (declare
  (xargs
   :guard
   (and
    (cst-matchp abnf::cst
                "statement-without-trailing-substatement")
    (equal
       (cst-statement-without-trailing-substatement-conc? abnf::cst)
       2))))
 (abnf::tree-fix (nth 0
                      (cst-statement-without-trailing-substatement-conc2-rep
                           abnf::cst))))

Theorem: treep-of-cst-statement-without-trailing-substatement-conc2-rep-elem

(defthm
 treep-of-cst-statement-without-trailing-substatement-conc2-rep-elem
 (b* ((abnf::cst1 (cst-statement-without-trailing-substatement-conc2-rep-elem
                       abnf::cst)))
   (abnf::treep abnf::cst1))
 :rule-classes :rewrite)

Theorem: cst-statement-without-trailing-substatement-conc2-rep-elem-match

(defthm
   cst-statement-without-trailing-substatement-conc2-rep-elem-match
 (implies
  (and
   (cst-matchp abnf::cst
               "statement-without-trailing-substatement")
   (equal
       (cst-statement-without-trailing-substatement-conc? abnf::cst)
       2))
  (b* ((abnf::cst1 (cst-statement-without-trailing-substatement-conc2-rep-elem
                        abnf::cst)))
    (cst-matchp abnf::cst1 "empty-statement")))
 :rule-classes :rewrite)

Theorem: cst-statement-without-trailing-substatement-conc2-rep-elem-of-tree-fix-cst

(defthm
 cst-statement-without-trailing-substatement-conc2-rep-elem-of-tree-fix-cst
 (equal (cst-statement-without-trailing-substatement-conc2-rep-elem
             (abnf::tree-fix abnf::cst))
        (cst-statement-without-trailing-substatement-conc2-rep-elem
             abnf::cst)))

Theorem: cst-statement-without-trailing-substatement-conc2-rep-elem-tree-equiv-congruence-on-cst

(defthm
 cst-statement-without-trailing-substatement-conc2-rep-elem-tree-equiv-congruence-on-cst
 (implies (abnf::tree-equiv abnf::cst cst-equiv)
          (equal (cst-statement-without-trailing-substatement-conc2-rep-elem
                      abnf::cst)
                 (cst-statement-without-trailing-substatement-conc2-rep-elem
                      cst-equiv)))
 :rule-classes :congruence)

Function: cst-statement-without-trailing-substatement-conc3-rep-elem

(defun cst-statement-without-trailing-substatement-conc3-rep-elem
       (abnf::cst)
 (declare (xargs :guard (abnf::treep abnf::cst)))
 (declare
  (xargs
   :guard
   (and
    (cst-matchp abnf::cst
                "statement-without-trailing-substatement")
    (equal
       (cst-statement-without-trailing-substatement-conc? abnf::cst)
       3))))
 (abnf::tree-fix (nth 0
                      (cst-statement-without-trailing-substatement-conc3-rep
                           abnf::cst))))

Theorem: treep-of-cst-statement-without-trailing-substatement-conc3-rep-elem

(defthm
 treep-of-cst-statement-without-trailing-substatement-conc3-rep-elem
 (b* ((abnf::cst1 (cst-statement-without-trailing-substatement-conc3-rep-elem
                       abnf::cst)))
   (abnf::treep abnf::cst1))
 :rule-classes :rewrite)

Theorem: cst-statement-without-trailing-substatement-conc3-rep-elem-match

(defthm
   cst-statement-without-trailing-substatement-conc3-rep-elem-match
 (implies
  (and
   (cst-matchp abnf::cst
               "statement-without-trailing-substatement")
   (equal
       (cst-statement-without-trailing-substatement-conc? abnf::cst)
       3))
  (b* ((abnf::cst1 (cst-statement-without-trailing-substatement-conc3-rep-elem
                        abnf::cst)))
    (cst-matchp abnf::cst1 "expression-statement")))
 :rule-classes :rewrite)

Theorem: cst-statement-without-trailing-substatement-conc3-rep-elem-of-tree-fix-cst

(defthm
 cst-statement-without-trailing-substatement-conc3-rep-elem-of-tree-fix-cst
 (equal (cst-statement-without-trailing-substatement-conc3-rep-elem
             (abnf::tree-fix abnf::cst))
        (cst-statement-without-trailing-substatement-conc3-rep-elem
             abnf::cst)))

Theorem: cst-statement-without-trailing-substatement-conc3-rep-elem-tree-equiv-congruence-on-cst

(defthm
 cst-statement-without-trailing-substatement-conc3-rep-elem-tree-equiv-congruence-on-cst
 (implies (abnf::tree-equiv abnf::cst cst-equiv)
          (equal (cst-statement-without-trailing-substatement-conc3-rep-elem
                      abnf::cst)
                 (cst-statement-without-trailing-substatement-conc3-rep-elem
                      cst-equiv)))
 :rule-classes :congruence)

Function: cst-statement-without-trailing-substatement-conc4-rep-elem

(defun cst-statement-without-trailing-substatement-conc4-rep-elem
       (abnf::cst)
 (declare (xargs :guard (abnf::treep abnf::cst)))
 (declare
  (xargs
   :guard
   (and
    (cst-matchp abnf::cst
                "statement-without-trailing-substatement")
    (equal
       (cst-statement-without-trailing-substatement-conc? abnf::cst)
       4))))
 (abnf::tree-fix (nth 0
                      (cst-statement-without-trailing-substatement-conc4-rep
                           abnf::cst))))

Theorem: treep-of-cst-statement-without-trailing-substatement-conc4-rep-elem

(defthm
 treep-of-cst-statement-without-trailing-substatement-conc4-rep-elem
 (b* ((abnf::cst1 (cst-statement-without-trailing-substatement-conc4-rep-elem
                       abnf::cst)))
   (abnf::treep abnf::cst1))
 :rule-classes :rewrite)

Theorem: cst-statement-without-trailing-substatement-conc4-rep-elem-match

(defthm
   cst-statement-without-trailing-substatement-conc4-rep-elem-match
 (implies
  (and
   (cst-matchp abnf::cst
               "statement-without-trailing-substatement")
   (equal
       (cst-statement-without-trailing-substatement-conc? abnf::cst)
       4))
  (b* ((abnf::cst1 (cst-statement-without-trailing-substatement-conc4-rep-elem
                        abnf::cst)))
    (cst-matchp abnf::cst1 "assert-statement")))
 :rule-classes :rewrite)

Theorem: cst-statement-without-trailing-substatement-conc4-rep-elem-of-tree-fix-cst

(defthm
 cst-statement-without-trailing-substatement-conc4-rep-elem-of-tree-fix-cst
 (equal (cst-statement-without-trailing-substatement-conc4-rep-elem
             (abnf::tree-fix abnf::cst))
        (cst-statement-without-trailing-substatement-conc4-rep-elem
             abnf::cst)))

Theorem: cst-statement-without-trailing-substatement-conc4-rep-elem-tree-equiv-congruence-on-cst

(defthm
 cst-statement-without-trailing-substatement-conc4-rep-elem-tree-equiv-congruence-on-cst
 (implies (abnf::tree-equiv abnf::cst cst-equiv)
          (equal (cst-statement-without-trailing-substatement-conc4-rep-elem
                      abnf::cst)
                 (cst-statement-without-trailing-substatement-conc4-rep-elem
                      cst-equiv)))
 :rule-classes :congruence)

Function: cst-statement-without-trailing-substatement-conc5-rep-elem

(defun cst-statement-without-trailing-substatement-conc5-rep-elem
       (abnf::cst)
 (declare (xargs :guard (abnf::treep abnf::cst)))
 (declare
  (xargs
   :guard
   (and
    (cst-matchp abnf::cst
                "statement-without-trailing-substatement")
    (equal
       (cst-statement-without-trailing-substatement-conc? abnf::cst)
       5))))
 (abnf::tree-fix (nth 0
                      (cst-statement-without-trailing-substatement-conc5-rep
                           abnf::cst))))

Theorem: treep-of-cst-statement-without-trailing-substatement-conc5-rep-elem

(defthm
 treep-of-cst-statement-without-trailing-substatement-conc5-rep-elem
 (b* ((abnf::cst1 (cst-statement-without-trailing-substatement-conc5-rep-elem
                       abnf::cst)))
   (abnf::treep abnf::cst1))
 :rule-classes :rewrite)

Theorem: cst-statement-without-trailing-substatement-conc5-rep-elem-match

(defthm
   cst-statement-without-trailing-substatement-conc5-rep-elem-match
 (implies
  (and
   (cst-matchp abnf::cst
               "statement-without-trailing-substatement")
   (equal
       (cst-statement-without-trailing-substatement-conc? abnf::cst)
       5))
  (b* ((abnf::cst1 (cst-statement-without-trailing-substatement-conc5-rep-elem
                        abnf::cst)))
    (cst-matchp abnf::cst1 "switch-statement")))
 :rule-classes :rewrite)

Theorem: cst-statement-without-trailing-substatement-conc5-rep-elem-of-tree-fix-cst

(defthm
 cst-statement-without-trailing-substatement-conc5-rep-elem-of-tree-fix-cst
 (equal (cst-statement-without-trailing-substatement-conc5-rep-elem
             (abnf::tree-fix abnf::cst))
        (cst-statement-without-trailing-substatement-conc5-rep-elem
             abnf::cst)))

Theorem: cst-statement-without-trailing-substatement-conc5-rep-elem-tree-equiv-congruence-on-cst

(defthm
 cst-statement-without-trailing-substatement-conc5-rep-elem-tree-equiv-congruence-on-cst
 (implies (abnf::tree-equiv abnf::cst cst-equiv)
          (equal (cst-statement-without-trailing-substatement-conc5-rep-elem
                      abnf::cst)
                 (cst-statement-without-trailing-substatement-conc5-rep-elem
                      cst-equiv)))
 :rule-classes :congruence)

Function: cst-statement-without-trailing-substatement-conc6-rep-elem

(defun cst-statement-without-trailing-substatement-conc6-rep-elem
       (abnf::cst)
 (declare (xargs :guard (abnf::treep abnf::cst)))
 (declare
  (xargs
   :guard
   (and
    (cst-matchp abnf::cst
                "statement-without-trailing-substatement")
    (equal
       (cst-statement-without-trailing-substatement-conc? abnf::cst)
       6))))
 (abnf::tree-fix (nth 0
                      (cst-statement-without-trailing-substatement-conc6-rep
                           abnf::cst))))

Theorem: treep-of-cst-statement-without-trailing-substatement-conc6-rep-elem

(defthm
 treep-of-cst-statement-without-trailing-substatement-conc6-rep-elem
 (b* ((abnf::cst1 (cst-statement-without-trailing-substatement-conc6-rep-elem
                       abnf::cst)))
   (abnf::treep abnf::cst1))
 :rule-classes :rewrite)

Theorem: cst-statement-without-trailing-substatement-conc6-rep-elem-match

(defthm
   cst-statement-without-trailing-substatement-conc6-rep-elem-match
 (implies
  (and
   (cst-matchp abnf::cst
               "statement-without-trailing-substatement")
   (equal
       (cst-statement-without-trailing-substatement-conc? abnf::cst)
       6))
  (b* ((abnf::cst1 (cst-statement-without-trailing-substatement-conc6-rep-elem
                        abnf::cst)))
    (cst-matchp abnf::cst1 "do-statement")))
 :rule-classes :rewrite)

Theorem: cst-statement-without-trailing-substatement-conc6-rep-elem-of-tree-fix-cst

(defthm
 cst-statement-without-trailing-substatement-conc6-rep-elem-of-tree-fix-cst
 (equal (cst-statement-without-trailing-substatement-conc6-rep-elem
             (abnf::tree-fix abnf::cst))
        (cst-statement-without-trailing-substatement-conc6-rep-elem
             abnf::cst)))

Theorem: cst-statement-without-trailing-substatement-conc6-rep-elem-tree-equiv-congruence-on-cst

(defthm
 cst-statement-without-trailing-substatement-conc6-rep-elem-tree-equiv-congruence-on-cst
 (implies (abnf::tree-equiv abnf::cst cst-equiv)
          (equal (cst-statement-without-trailing-substatement-conc6-rep-elem
                      abnf::cst)
                 (cst-statement-without-trailing-substatement-conc6-rep-elem
                      cst-equiv)))
 :rule-classes :congruence)

Function: cst-statement-without-trailing-substatement-conc7-rep-elem

(defun cst-statement-without-trailing-substatement-conc7-rep-elem
       (abnf::cst)
 (declare (xargs :guard (abnf::treep abnf::cst)))
 (declare
  (xargs
   :guard
   (and
    (cst-matchp abnf::cst
                "statement-without-trailing-substatement")
    (equal
       (cst-statement-without-trailing-substatement-conc? abnf::cst)
       7))))
 (abnf::tree-fix (nth 0
                      (cst-statement-without-trailing-substatement-conc7-rep
                           abnf::cst))))

Theorem: treep-of-cst-statement-without-trailing-substatement-conc7-rep-elem

(defthm
 treep-of-cst-statement-without-trailing-substatement-conc7-rep-elem
 (b* ((abnf::cst1 (cst-statement-without-trailing-substatement-conc7-rep-elem
                       abnf::cst)))
   (abnf::treep abnf::cst1))
 :rule-classes :rewrite)

Theorem: cst-statement-without-trailing-substatement-conc7-rep-elem-match

(defthm
   cst-statement-without-trailing-substatement-conc7-rep-elem-match
 (implies
  (and
   (cst-matchp abnf::cst
               "statement-without-trailing-substatement")
   (equal
       (cst-statement-without-trailing-substatement-conc? abnf::cst)
       7))
  (b* ((abnf::cst1 (cst-statement-without-trailing-substatement-conc7-rep-elem
                        abnf::cst)))
    (cst-matchp abnf::cst1 "break-statement")))
 :rule-classes :rewrite)

Theorem: cst-statement-without-trailing-substatement-conc7-rep-elem-of-tree-fix-cst

(defthm
 cst-statement-without-trailing-substatement-conc7-rep-elem-of-tree-fix-cst
 (equal (cst-statement-without-trailing-substatement-conc7-rep-elem
             (abnf::tree-fix abnf::cst))
        (cst-statement-without-trailing-substatement-conc7-rep-elem
             abnf::cst)))

Theorem: cst-statement-without-trailing-substatement-conc7-rep-elem-tree-equiv-congruence-on-cst

(defthm
 cst-statement-without-trailing-substatement-conc7-rep-elem-tree-equiv-congruence-on-cst
 (implies (abnf::tree-equiv abnf::cst cst-equiv)
          (equal (cst-statement-without-trailing-substatement-conc7-rep-elem
                      abnf::cst)
                 (cst-statement-without-trailing-substatement-conc7-rep-elem
                      cst-equiv)))
 :rule-classes :congruence)

Function: cst-statement-without-trailing-substatement-conc8-rep-elem

(defun cst-statement-without-trailing-substatement-conc8-rep-elem
       (abnf::cst)
 (declare (xargs :guard (abnf::treep abnf::cst)))
 (declare
  (xargs
   :guard
   (and
    (cst-matchp abnf::cst
                "statement-without-trailing-substatement")
    (equal
       (cst-statement-without-trailing-substatement-conc? abnf::cst)
       8))))
 (abnf::tree-fix (nth 0
                      (cst-statement-without-trailing-substatement-conc8-rep
                           abnf::cst))))

Theorem: treep-of-cst-statement-without-trailing-substatement-conc8-rep-elem

(defthm
 treep-of-cst-statement-without-trailing-substatement-conc8-rep-elem
 (b* ((abnf::cst1 (cst-statement-without-trailing-substatement-conc8-rep-elem
                       abnf::cst)))
   (abnf::treep abnf::cst1))
 :rule-classes :rewrite)

Theorem: cst-statement-without-trailing-substatement-conc8-rep-elem-match

(defthm
   cst-statement-without-trailing-substatement-conc8-rep-elem-match
 (implies
  (and
   (cst-matchp abnf::cst
               "statement-without-trailing-substatement")
   (equal
       (cst-statement-without-trailing-substatement-conc? abnf::cst)
       8))
  (b* ((abnf::cst1 (cst-statement-without-trailing-substatement-conc8-rep-elem
                        abnf::cst)))
    (cst-matchp abnf::cst1 "continue-statement")))
 :rule-classes :rewrite)

Theorem: cst-statement-without-trailing-substatement-conc8-rep-elem-of-tree-fix-cst

(defthm
 cst-statement-without-trailing-substatement-conc8-rep-elem-of-tree-fix-cst
 (equal (cst-statement-without-trailing-substatement-conc8-rep-elem
             (abnf::tree-fix abnf::cst))
        (cst-statement-without-trailing-substatement-conc8-rep-elem
             abnf::cst)))

Theorem: cst-statement-without-trailing-substatement-conc8-rep-elem-tree-equiv-congruence-on-cst

(defthm
 cst-statement-without-trailing-substatement-conc8-rep-elem-tree-equiv-congruence-on-cst
 (implies (abnf::tree-equiv abnf::cst cst-equiv)
          (equal (cst-statement-without-trailing-substatement-conc8-rep-elem
                      abnf::cst)
                 (cst-statement-without-trailing-substatement-conc8-rep-elem
                      cst-equiv)))
 :rule-classes :congruence)

Function: cst-statement-without-trailing-substatement-conc9-rep-elem

(defun cst-statement-without-trailing-substatement-conc9-rep-elem
       (abnf::cst)
 (declare (xargs :guard (abnf::treep abnf::cst)))
 (declare
  (xargs
   :guard
   (and
    (cst-matchp abnf::cst
                "statement-without-trailing-substatement")
    (equal
       (cst-statement-without-trailing-substatement-conc? abnf::cst)
       9))))
 (abnf::tree-fix (nth 0
                      (cst-statement-without-trailing-substatement-conc9-rep
                           abnf::cst))))

Theorem: treep-of-cst-statement-without-trailing-substatement-conc9-rep-elem

(defthm
 treep-of-cst-statement-without-trailing-substatement-conc9-rep-elem
 (b* ((abnf::cst1 (cst-statement-without-trailing-substatement-conc9-rep-elem
                       abnf::cst)))
   (abnf::treep abnf::cst1))
 :rule-classes :rewrite)

Theorem: cst-statement-without-trailing-substatement-conc9-rep-elem-match

(defthm
   cst-statement-without-trailing-substatement-conc9-rep-elem-match
 (implies
  (and
   (cst-matchp abnf::cst
               "statement-without-trailing-substatement")
   (equal
       (cst-statement-without-trailing-substatement-conc? abnf::cst)
       9))
  (b* ((abnf::cst1 (cst-statement-without-trailing-substatement-conc9-rep-elem
                        abnf::cst)))
    (cst-matchp abnf::cst1 "return-statement")))
 :rule-classes :rewrite)

Theorem: cst-statement-without-trailing-substatement-conc9-rep-elem-of-tree-fix-cst

(defthm
 cst-statement-without-trailing-substatement-conc9-rep-elem-of-tree-fix-cst
 (equal (cst-statement-without-trailing-substatement-conc9-rep-elem
             (abnf::tree-fix abnf::cst))
        (cst-statement-without-trailing-substatement-conc9-rep-elem
             abnf::cst)))

Theorem: cst-statement-without-trailing-substatement-conc9-rep-elem-tree-equiv-congruence-on-cst

(defthm
 cst-statement-without-trailing-substatement-conc9-rep-elem-tree-equiv-congruence-on-cst
 (implies (abnf::tree-equiv abnf::cst cst-equiv)
          (equal (cst-statement-without-trailing-substatement-conc9-rep-elem
                      abnf::cst)
                 (cst-statement-without-trailing-substatement-conc9-rep-elem
                      cst-equiv)))
 :rule-classes :congruence)

Function: cst-statement-without-trailing-substatement-conc10-rep-elem

(defun cst-statement-without-trailing-substatement-conc10-rep-elem
       (abnf::cst)
 (declare (xargs :guard (abnf::treep abnf::cst)))
 (declare
  (xargs
   :guard
   (and
    (cst-matchp abnf::cst
                "statement-without-trailing-substatement")
    (equal
       (cst-statement-without-trailing-substatement-conc? abnf::cst)
       10))))
 (abnf::tree-fix (nth 0
                      (cst-statement-without-trailing-substatement-conc10-rep
                           abnf::cst))))

Theorem: treep-of-cst-statement-without-trailing-substatement-conc10-rep-elem

(defthm
 treep-of-cst-statement-without-trailing-substatement-conc10-rep-elem
 (b* ((abnf::cst1 (cst-statement-without-trailing-substatement-conc10-rep-elem
                       abnf::cst)))
   (abnf::treep abnf::cst1))
 :rule-classes :rewrite)

Theorem: cst-statement-without-trailing-substatement-conc10-rep-elem-match

(defthm
  cst-statement-without-trailing-substatement-conc10-rep-elem-match
 (implies
  (and
   (cst-matchp abnf::cst
               "statement-without-trailing-substatement")
   (equal
       (cst-statement-without-trailing-substatement-conc? abnf::cst)
       10))
  (b* ((abnf::cst1 (cst-statement-without-trailing-substatement-conc10-rep-elem
                        abnf::cst)))
    (cst-matchp abnf::cst1 "synchronized-statement")))
 :rule-classes :rewrite)

Theorem: cst-statement-without-trailing-substatement-conc10-rep-elem-of-tree-fix-cst

(defthm
 cst-statement-without-trailing-substatement-conc10-rep-elem-of-tree-fix-cst
 (equal (cst-statement-without-trailing-substatement-conc10-rep-elem
             (abnf::tree-fix abnf::cst))
        (cst-statement-without-trailing-substatement-conc10-rep-elem
             abnf::cst)))

Theorem: cst-statement-without-trailing-substatement-conc10-rep-elem-tree-equiv-congruence-on-cst

(defthm
 cst-statement-without-trailing-substatement-conc10-rep-elem-tree-equiv-congruence-on-cst
 (implies (abnf::tree-equiv abnf::cst cst-equiv)
          (equal (cst-statement-without-trailing-substatement-conc10-rep-elem
                      abnf::cst)
                 (cst-statement-without-trailing-substatement-conc10-rep-elem
                      cst-equiv)))
 :rule-classes :congruence)

Function: cst-statement-without-trailing-substatement-conc11-rep-elem

(defun cst-statement-without-trailing-substatement-conc11-rep-elem
       (abnf::cst)
 (declare (xargs :guard (abnf::treep abnf::cst)))
 (declare
  (xargs
   :guard
   (and
    (cst-matchp abnf::cst
                "statement-without-trailing-substatement")
    (equal
       (cst-statement-without-trailing-substatement-conc? abnf::cst)
       11))))
 (abnf::tree-fix (nth 0
                      (cst-statement-without-trailing-substatement-conc11-rep
                           abnf::cst))))

Theorem: treep-of-cst-statement-without-trailing-substatement-conc11-rep-elem

(defthm
 treep-of-cst-statement-without-trailing-substatement-conc11-rep-elem
 (b* ((abnf::cst1 (cst-statement-without-trailing-substatement-conc11-rep-elem
                       abnf::cst)))
   (abnf::treep abnf::cst1))
 :rule-classes :rewrite)

Theorem: cst-statement-without-trailing-substatement-conc11-rep-elem-match

(defthm
  cst-statement-without-trailing-substatement-conc11-rep-elem-match
 (implies
  (and
   (cst-matchp abnf::cst
               "statement-without-trailing-substatement")
   (equal
       (cst-statement-without-trailing-substatement-conc? abnf::cst)
       11))
  (b* ((abnf::cst1 (cst-statement-without-trailing-substatement-conc11-rep-elem
                        abnf::cst)))
    (cst-matchp abnf::cst1 "throw-statement")))
 :rule-classes :rewrite)

Theorem: cst-statement-without-trailing-substatement-conc11-rep-elem-of-tree-fix-cst

(defthm
 cst-statement-without-trailing-substatement-conc11-rep-elem-of-tree-fix-cst
 (equal (cst-statement-without-trailing-substatement-conc11-rep-elem
             (abnf::tree-fix abnf::cst))
        (cst-statement-without-trailing-substatement-conc11-rep-elem
             abnf::cst)))

Theorem: cst-statement-without-trailing-substatement-conc11-rep-elem-tree-equiv-congruence-on-cst

(defthm
 cst-statement-without-trailing-substatement-conc11-rep-elem-tree-equiv-congruence-on-cst
 (implies (abnf::tree-equiv abnf::cst cst-equiv)
          (equal (cst-statement-without-trailing-substatement-conc11-rep-elem
                      abnf::cst)
                 (cst-statement-without-trailing-substatement-conc11-rep-elem
                      cst-equiv)))
 :rule-classes :congruence)

Function: cst-statement-without-trailing-substatement-conc12-rep-elem

(defun cst-statement-without-trailing-substatement-conc12-rep-elem
       (abnf::cst)
 (declare (xargs :guard (abnf::treep abnf::cst)))
 (declare
  (xargs
   :guard
   (and
    (cst-matchp abnf::cst
                "statement-without-trailing-substatement")
    (equal
       (cst-statement-without-trailing-substatement-conc? abnf::cst)
       12))))
 (abnf::tree-fix (nth 0
                      (cst-statement-without-trailing-substatement-conc12-rep
                           abnf::cst))))

Theorem: treep-of-cst-statement-without-trailing-substatement-conc12-rep-elem

(defthm
 treep-of-cst-statement-without-trailing-substatement-conc12-rep-elem
 (b* ((abnf::cst1 (cst-statement-without-trailing-substatement-conc12-rep-elem
                       abnf::cst)))
   (abnf::treep abnf::cst1))
 :rule-classes :rewrite)

Theorem: cst-statement-without-trailing-substatement-conc12-rep-elem-match

(defthm
  cst-statement-without-trailing-substatement-conc12-rep-elem-match
 (implies
  (and
   (cst-matchp abnf::cst
               "statement-without-trailing-substatement")
   (equal
       (cst-statement-without-trailing-substatement-conc? abnf::cst)
       12))
  (b* ((abnf::cst1 (cst-statement-without-trailing-substatement-conc12-rep-elem
                        abnf::cst)))
    (cst-matchp abnf::cst1 "try-statement")))
 :rule-classes :rewrite)

Theorem: cst-statement-without-trailing-substatement-conc12-rep-elem-of-tree-fix-cst

(defthm
 cst-statement-without-trailing-substatement-conc12-rep-elem-of-tree-fix-cst
 (equal (cst-statement-without-trailing-substatement-conc12-rep-elem
             (abnf::tree-fix abnf::cst))
        (cst-statement-without-trailing-substatement-conc12-rep-elem
             abnf::cst)))

Theorem: cst-statement-without-trailing-substatement-conc12-rep-elem-tree-equiv-congruence-on-cst

(defthm
 cst-statement-without-trailing-substatement-conc12-rep-elem-tree-equiv-congruence-on-cst
 (implies (abnf::tree-equiv abnf::cst cst-equiv)
          (equal (cst-statement-without-trailing-substatement-conc12-rep-elem
                      abnf::cst)
                 (cst-statement-without-trailing-substatement-conc12-rep-elem
                      cst-equiv)))
 :rule-classes :congruence)

Function: cst-statement-without-trailing-substatement-conc13-rep-elem

(defun cst-statement-without-trailing-substatement-conc13-rep-elem
       (abnf::cst)
 (declare (xargs :guard (abnf::treep abnf::cst)))
 (declare
  (xargs
   :guard
   (and
    (cst-matchp abnf::cst
                "statement-without-trailing-substatement")
    (equal
       (cst-statement-without-trailing-substatement-conc? abnf::cst)
       13))))
 (abnf::tree-fix (nth 0
                      (cst-statement-without-trailing-substatement-conc13-rep
                           abnf::cst))))

Theorem: treep-of-cst-statement-without-trailing-substatement-conc13-rep-elem

(defthm
 treep-of-cst-statement-without-trailing-substatement-conc13-rep-elem
 (b* ((abnf::cst1 (cst-statement-without-trailing-substatement-conc13-rep-elem
                       abnf::cst)))
   (abnf::treep abnf::cst1))
 :rule-classes :rewrite)

Theorem: cst-statement-without-trailing-substatement-conc13-rep-elem-match

(defthm
  cst-statement-without-trailing-substatement-conc13-rep-elem-match
 (implies
  (and
   (cst-matchp abnf::cst
               "statement-without-trailing-substatement")
   (equal
       (cst-statement-without-trailing-substatement-conc? abnf::cst)
       13))
  (b* ((abnf::cst1 (cst-statement-without-trailing-substatement-conc13-rep-elem
                        abnf::cst)))
    (cst-matchp abnf::cst1 "yield-statement")))
 :rule-classes :rewrite)

Theorem: cst-statement-without-trailing-substatement-conc13-rep-elem-of-tree-fix-cst

(defthm
 cst-statement-without-trailing-substatement-conc13-rep-elem-of-tree-fix-cst
 (equal (cst-statement-without-trailing-substatement-conc13-rep-elem
             (abnf::tree-fix abnf::cst))
        (cst-statement-without-trailing-substatement-conc13-rep-elem
             abnf::cst)))

Theorem: cst-statement-without-trailing-substatement-conc13-rep-elem-tree-equiv-congruence-on-cst

(defthm
 cst-statement-without-trailing-substatement-conc13-rep-elem-tree-equiv-congruence-on-cst
 (implies (abnf::tree-equiv abnf::cst cst-equiv)
          (equal (cst-statement-without-trailing-substatement-conc13-rep-elem
                      abnf::cst)
                 (cst-statement-without-trailing-substatement-conc13-rep-elem
                      cst-equiv)))
 :rule-classes :congruence)

Function: cst-empty-statement-conc-rep-elem

(defun cst-empty-statement-conc-rep-elem (abnf::cst)
  (declare (xargs :guard (abnf::treep abnf::cst)))
  (declare (xargs :guard (cst-matchp abnf::cst "empty-statement")))
  (abnf::tree-fix (nth 0
                       (cst-empty-statement-conc-rep abnf::cst))))

Theorem: treep-of-cst-empty-statement-conc-rep-elem

(defthm treep-of-cst-empty-statement-conc-rep-elem
  (b* ((abnf::cst1 (cst-empty-statement-conc-rep-elem abnf::cst)))
    (abnf::treep abnf::cst1))
  :rule-classes :rewrite)

Theorem: cst-empty-statement-conc-rep-elem-match

(defthm cst-empty-statement-conc-rep-elem-match
 (implies
    (cst-matchp abnf::cst "empty-statement")
    (b* ((abnf::cst1 (cst-empty-statement-conc-rep-elem abnf::cst)))
      (cst-matchp abnf::cst1 "\";\"")))
 :rule-classes :rewrite)

Theorem: cst-empty-statement-conc-rep-elem-of-tree-fix-cst

(defthm cst-empty-statement-conc-rep-elem-of-tree-fix-cst
 (equal
      (cst-empty-statement-conc-rep-elem (abnf::tree-fix abnf::cst))
      (cst-empty-statement-conc-rep-elem abnf::cst)))

Theorem: cst-empty-statement-conc-rep-elem-tree-equiv-congruence-on-cst

(defthm
     cst-empty-statement-conc-rep-elem-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-empty-statement-conc-rep-elem abnf::cst)
                  (cst-empty-statement-conc-rep-elem cst-equiv)))
  :rule-classes :congruence)

Function: cst-statement-expression-conc1-rep-elem

(defun cst-statement-expression-conc1-rep-elem (abnf::cst)
 (declare (xargs :guard (abnf::treep abnf::cst)))
 (declare
  (xargs
       :guard (and (cst-matchp abnf::cst "statement-expression")
                   (equal (cst-statement-expression-conc? abnf::cst)
                          1))))
 (abnf::tree-fix
      (nth 0
           (cst-statement-expression-conc1-rep abnf::cst))))

Theorem: treep-of-cst-statement-expression-conc1-rep-elem

(defthm treep-of-cst-statement-expression-conc1-rep-elem
 (b*
  ((abnf::cst1 (cst-statement-expression-conc1-rep-elem abnf::cst)))
  (abnf::treep abnf::cst1))
 :rule-classes :rewrite)

Theorem: cst-statement-expression-conc1-rep-elem-match

(defthm cst-statement-expression-conc1-rep-elem-match
 (implies
     (and (cst-matchp abnf::cst "statement-expression")
          (equal (cst-statement-expression-conc? abnf::cst)
                 1))
     (b* ((abnf::cst1
               (cst-statement-expression-conc1-rep-elem abnf::cst)))
       (cst-matchp abnf::cst1 "assignment")))
 :rule-classes :rewrite)

Theorem: cst-statement-expression-conc1-rep-elem-of-tree-fix-cst

(defthm cst-statement-expression-conc1-rep-elem-of-tree-fix-cst
  (equal (cst-statement-expression-conc1-rep-elem
              (abnf::tree-fix abnf::cst))
         (cst-statement-expression-conc1-rep-elem abnf::cst)))

Theorem: cst-statement-expression-conc1-rep-elem-tree-equiv-congruence-on-cst

(defthm
 cst-statement-expression-conc1-rep-elem-tree-equiv-congruence-on-cst
 (implies
      (abnf::tree-equiv abnf::cst cst-equiv)
      (equal (cst-statement-expression-conc1-rep-elem abnf::cst)
             (cst-statement-expression-conc1-rep-elem cst-equiv)))
 :rule-classes :congruence)

Function: cst-statement-expression-conc2-rep-elem

(defun cst-statement-expression-conc2-rep-elem (abnf::cst)
 (declare (xargs :guard (abnf::treep abnf::cst)))
 (declare
  (xargs
       :guard (and (cst-matchp abnf::cst "statement-expression")
                   (equal (cst-statement-expression-conc? abnf::cst)
                          2))))
 (abnf::tree-fix
      (nth 0
           (cst-statement-expression-conc2-rep abnf::cst))))

Theorem: treep-of-cst-statement-expression-conc2-rep-elem

(defthm treep-of-cst-statement-expression-conc2-rep-elem
 (b*
  ((abnf::cst1 (cst-statement-expression-conc2-rep-elem abnf::cst)))
  (abnf::treep abnf::cst1))
 :rule-classes :rewrite)

Theorem: cst-statement-expression-conc2-rep-elem-match

(defthm cst-statement-expression-conc2-rep-elem-match
 (implies
     (and (cst-matchp abnf::cst "statement-expression")
          (equal (cst-statement-expression-conc? abnf::cst)
                 2))
     (b* ((abnf::cst1
               (cst-statement-expression-conc2-rep-elem abnf::cst)))
       (cst-matchp abnf::cst1 "pre-increment-expression")))
 :rule-classes :rewrite)

Theorem: cst-statement-expression-conc2-rep-elem-of-tree-fix-cst

(defthm cst-statement-expression-conc2-rep-elem-of-tree-fix-cst
  (equal (cst-statement-expression-conc2-rep-elem
              (abnf::tree-fix abnf::cst))
         (cst-statement-expression-conc2-rep-elem abnf::cst)))

Theorem: cst-statement-expression-conc2-rep-elem-tree-equiv-congruence-on-cst

(defthm
 cst-statement-expression-conc2-rep-elem-tree-equiv-congruence-on-cst
 (implies
      (abnf::tree-equiv abnf::cst cst-equiv)
      (equal (cst-statement-expression-conc2-rep-elem abnf::cst)
             (cst-statement-expression-conc2-rep-elem cst-equiv)))
 :rule-classes :congruence)

Function: cst-statement-expression-conc3-rep-elem

(defun cst-statement-expression-conc3-rep-elem (abnf::cst)
 (declare (xargs :guard (abnf::treep abnf::cst)))
 (declare
  (xargs
       :guard (and (cst-matchp abnf::cst "statement-expression")
                   (equal (cst-statement-expression-conc? abnf::cst)
                          3))))
 (abnf::tree-fix
      (nth 0
           (cst-statement-expression-conc3-rep abnf::cst))))

Theorem: treep-of-cst-statement-expression-conc3-rep-elem

(defthm treep-of-cst-statement-expression-conc3-rep-elem
 (b*
  ((abnf::cst1 (cst-statement-expression-conc3-rep-elem abnf::cst)))
  (abnf::treep abnf::cst1))
 :rule-classes :rewrite)

Theorem: cst-statement-expression-conc3-rep-elem-match

(defthm cst-statement-expression-conc3-rep-elem-match
 (implies
     (and (cst-matchp abnf::cst "statement-expression")
          (equal (cst-statement-expression-conc? abnf::cst)
                 3))
     (b* ((abnf::cst1
               (cst-statement-expression-conc3-rep-elem abnf::cst)))
       (cst-matchp abnf::cst1 "pre-decrement-expression")))
 :rule-classes :rewrite)

Theorem: cst-statement-expression-conc3-rep-elem-of-tree-fix-cst

(defthm cst-statement-expression-conc3-rep-elem-of-tree-fix-cst
  (equal (cst-statement-expression-conc3-rep-elem
              (abnf::tree-fix abnf::cst))
         (cst-statement-expression-conc3-rep-elem abnf::cst)))

Theorem: cst-statement-expression-conc3-rep-elem-tree-equiv-congruence-on-cst

(defthm
 cst-statement-expression-conc3-rep-elem-tree-equiv-congruence-on-cst
 (implies
      (abnf::tree-equiv abnf::cst cst-equiv)
      (equal (cst-statement-expression-conc3-rep-elem abnf::cst)
             (cst-statement-expression-conc3-rep-elem cst-equiv)))
 :rule-classes :congruence)

Function: cst-statement-expression-conc4-rep-elem

(defun cst-statement-expression-conc4-rep-elem (abnf::cst)
 (declare (xargs :guard (abnf::treep abnf::cst)))
 (declare
  (xargs
       :guard (and (cst-matchp abnf::cst "statement-expression")
                   (equal (cst-statement-expression-conc? abnf::cst)
                          4))))
 (abnf::tree-fix
      (nth 0
           (cst-statement-expression-conc4-rep abnf::cst))))

Theorem: treep-of-cst-statement-expression-conc4-rep-elem

(defthm treep-of-cst-statement-expression-conc4-rep-elem
 (b*
  ((abnf::cst1 (cst-statement-expression-conc4-rep-elem abnf::cst)))
  (abnf::treep abnf::cst1))
 :rule-classes :rewrite)

Theorem: cst-statement-expression-conc4-rep-elem-match

(defthm cst-statement-expression-conc4-rep-elem-match
 (implies
     (and (cst-matchp abnf::cst "statement-expression")
          (equal (cst-statement-expression-conc? abnf::cst)
                 4))
     (b* ((abnf::cst1
               (cst-statement-expression-conc4-rep-elem abnf::cst)))
       (cst-matchp abnf::cst1
                   "post-increment-expression")))
 :rule-classes :rewrite)

Theorem: cst-statement-expression-conc4-rep-elem-of-tree-fix-cst

(defthm cst-statement-expression-conc4-rep-elem-of-tree-fix-cst
  (equal (cst-statement-expression-conc4-rep-elem
              (abnf::tree-fix abnf::cst))
         (cst-statement-expression-conc4-rep-elem abnf::cst)))

Theorem: cst-statement-expression-conc4-rep-elem-tree-equiv-congruence-on-cst

(defthm
 cst-statement-expression-conc4-rep-elem-tree-equiv-congruence-on-cst
 (implies
      (abnf::tree-equiv abnf::cst cst-equiv)
      (equal (cst-statement-expression-conc4-rep-elem abnf::cst)
             (cst-statement-expression-conc4-rep-elem cst-equiv)))
 :rule-classes :congruence)

Function: cst-statement-expression-conc5-rep-elem

(defun cst-statement-expression-conc5-rep-elem (abnf::cst)
 (declare (xargs :guard (abnf::treep abnf::cst)))
 (declare
  (xargs
       :guard (and (cst-matchp abnf::cst "statement-expression")
                   (equal (cst-statement-expression-conc? abnf::cst)
                          5))))
 (abnf::tree-fix
      (nth 0
           (cst-statement-expression-conc5-rep abnf::cst))))

Theorem: treep-of-cst-statement-expression-conc5-rep-elem

(defthm treep-of-cst-statement-expression-conc5-rep-elem
 (b*
  ((abnf::cst1 (cst-statement-expression-conc5-rep-elem abnf::cst)))
  (abnf::treep abnf::cst1))
 :rule-classes :rewrite)

Theorem: cst-statement-expression-conc5-rep-elem-match

(defthm cst-statement-expression-conc5-rep-elem-match
 (implies
     (and (cst-matchp abnf::cst "statement-expression")
          (equal (cst-statement-expression-conc? abnf::cst)
                 5))
     (b* ((abnf::cst1
               (cst-statement-expression-conc5-rep-elem abnf::cst)))
       (cst-matchp abnf::cst1
                   "post-decrement-expression")))
 :rule-classes :rewrite)

Theorem: cst-statement-expression-conc5-rep-elem-of-tree-fix-cst

(defthm cst-statement-expression-conc5-rep-elem-of-tree-fix-cst
  (equal (cst-statement-expression-conc5-rep-elem
              (abnf::tree-fix abnf::cst))
         (cst-statement-expression-conc5-rep-elem abnf::cst)))

Theorem: cst-statement-expression-conc5-rep-elem-tree-equiv-congruence-on-cst

(defthm
 cst-statement-expression-conc5-rep-elem-tree-equiv-congruence-on-cst
 (implies
      (abnf::tree-equiv abnf::cst cst-equiv)
      (equal (cst-statement-expression-conc5-rep-elem abnf::cst)
             (cst-statement-expression-conc5-rep-elem cst-equiv)))
 :rule-classes :congruence)

Function: cst-statement-expression-conc6-rep-elem

(defun cst-statement-expression-conc6-rep-elem (abnf::cst)
 (declare (xargs :guard (abnf::treep abnf::cst)))
 (declare
  (xargs
       :guard (and (cst-matchp abnf::cst "statement-expression")
                   (equal (cst-statement-expression-conc? abnf::cst)
                          6))))
 (abnf::tree-fix
      (nth 0
           (cst-statement-expression-conc6-rep abnf::cst))))

Theorem: treep-of-cst-statement-expression-conc6-rep-elem

(defthm treep-of-cst-statement-expression-conc6-rep-elem
 (b*
  ((abnf::cst1 (cst-statement-expression-conc6-rep-elem abnf::cst)))
  (abnf::treep abnf::cst1))
 :rule-classes :rewrite)

Theorem: cst-statement-expression-conc6-rep-elem-match

(defthm cst-statement-expression-conc6-rep-elem-match
 (implies
     (and (cst-matchp abnf::cst "statement-expression")
          (equal (cst-statement-expression-conc? abnf::cst)
                 6))
     (b* ((abnf::cst1
               (cst-statement-expression-conc6-rep-elem abnf::cst)))
       (cst-matchp abnf::cst1 "method-invocation")))
 :rule-classes :rewrite)

Theorem: cst-statement-expression-conc6-rep-elem-of-tree-fix-cst

(defthm cst-statement-expression-conc6-rep-elem-of-tree-fix-cst
  (equal (cst-statement-expression-conc6-rep-elem
              (abnf::tree-fix abnf::cst))
         (cst-statement-expression-conc6-rep-elem abnf::cst)))

Theorem: cst-statement-expression-conc6-rep-elem-tree-equiv-congruence-on-cst

(defthm
 cst-statement-expression-conc6-rep-elem-tree-equiv-congruence-on-cst
 (implies
      (abnf::tree-equiv abnf::cst cst-equiv)
      (equal (cst-statement-expression-conc6-rep-elem abnf::cst)
             (cst-statement-expression-conc6-rep-elem cst-equiv)))
 :rule-classes :congruence)

Function: cst-statement-expression-conc7-rep-elem

(defun cst-statement-expression-conc7-rep-elem (abnf::cst)
 (declare (xargs :guard (abnf::treep abnf::cst)))
 (declare
  (xargs
       :guard (and (cst-matchp abnf::cst "statement-expression")
                   (equal (cst-statement-expression-conc? abnf::cst)
                          7))))
 (abnf::tree-fix
      (nth 0
           (cst-statement-expression-conc7-rep abnf::cst))))

Theorem: treep-of-cst-statement-expression-conc7-rep-elem

(defthm treep-of-cst-statement-expression-conc7-rep-elem
 (b*
  ((abnf::cst1 (cst-statement-expression-conc7-rep-elem abnf::cst)))
  (abnf::treep abnf::cst1))
 :rule-classes :rewrite)

Theorem: cst-statement-expression-conc7-rep-elem-match

(defthm cst-statement-expression-conc7-rep-elem-match
 (implies
     (and (cst-matchp abnf::cst "statement-expression")
          (equal (cst-statement-expression-conc? abnf::cst)
                 7))
     (b* ((abnf::cst1
               (cst-statement-expression-conc7-rep-elem abnf::cst)))
       (cst-matchp abnf::cst1
                   "class-instance-creation-expression")))
 :rule-classes :rewrite)

Theorem: cst-statement-expression-conc7-rep-elem-of-tree-fix-cst

(defthm cst-statement-expression-conc7-rep-elem-of-tree-fix-cst
  (equal (cst-statement-expression-conc7-rep-elem
              (abnf::tree-fix abnf::cst))
         (cst-statement-expression-conc7-rep-elem abnf::cst)))

Theorem: cst-statement-expression-conc7-rep-elem-tree-equiv-congruence-on-cst

(defthm
 cst-statement-expression-conc7-rep-elem-tree-equiv-congruence-on-cst
 (implies
      (abnf::tree-equiv abnf::cst cst-equiv)
      (equal (cst-statement-expression-conc7-rep-elem abnf::cst)
             (cst-statement-expression-conc7-rep-elem cst-equiv)))
 :rule-classes :congruence)

Function: cst-case-constant-conc-rep-elem

(defun cst-case-constant-conc-rep-elem (abnf::cst)
  (declare (xargs :guard (abnf::treep abnf::cst)))
  (declare (xargs :guard (cst-matchp abnf::cst "case-constant")))
  (abnf::tree-fix (nth 0
                       (cst-case-constant-conc-rep abnf::cst))))

Theorem: treep-of-cst-case-constant-conc-rep-elem

(defthm treep-of-cst-case-constant-conc-rep-elem
  (b* ((abnf::cst1 (cst-case-constant-conc-rep-elem abnf::cst)))
    (abnf::treep abnf::cst1))
  :rule-classes :rewrite)

Theorem: cst-case-constant-conc-rep-elem-match

(defthm cst-case-constant-conc-rep-elem-match
 (implies
      (cst-matchp abnf::cst "case-constant")
      (b* ((abnf::cst1 (cst-case-constant-conc-rep-elem abnf::cst)))
        (cst-matchp abnf::cst1 "conditional-expression")))
 :rule-classes :rewrite)

Theorem: cst-case-constant-conc-rep-elem-of-tree-fix-cst

(defthm cst-case-constant-conc-rep-elem-of-tree-fix-cst
 (equal (cst-case-constant-conc-rep-elem (abnf::tree-fix abnf::cst))
        (cst-case-constant-conc-rep-elem abnf::cst)))

Theorem: cst-case-constant-conc-rep-elem-tree-equiv-congruence-on-cst

(defthm cst-case-constant-conc-rep-elem-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-case-constant-conc-rep-elem abnf::cst)
                  (cst-case-constant-conc-rep-elem cst-equiv)))
  :rule-classes :congruence)

Function: cst-case-pattern-conc-rep-elem

(defun cst-case-pattern-conc-rep-elem (abnf::cst)
  (declare (xargs :guard (abnf::treep abnf::cst)))
  (declare (xargs :guard (cst-matchp abnf::cst "case-pattern")))
  (abnf::tree-fix (nth 0
                       (cst-case-pattern-conc-rep abnf::cst))))

Theorem: treep-of-cst-case-pattern-conc-rep-elem

(defthm treep-of-cst-case-pattern-conc-rep-elem
  (b* ((abnf::cst1 (cst-case-pattern-conc-rep-elem abnf::cst)))
    (abnf::treep abnf::cst1))
  :rule-classes :rewrite)

Theorem: cst-case-pattern-conc-rep-elem-match

(defthm cst-case-pattern-conc-rep-elem-match
  (implies
       (cst-matchp abnf::cst "case-pattern")
       (b* ((abnf::cst1 (cst-case-pattern-conc-rep-elem abnf::cst)))
         (cst-matchp abnf::cst1 "pattern")))
  :rule-classes :rewrite)

Theorem: cst-case-pattern-conc-rep-elem-of-tree-fix-cst

(defthm cst-case-pattern-conc-rep-elem-of-tree-fix-cst
  (equal (cst-case-pattern-conc-rep-elem (abnf::tree-fix abnf::cst))
         (cst-case-pattern-conc-rep-elem abnf::cst)))

Theorem: cst-case-pattern-conc-rep-elem-tree-equiv-congruence-on-cst

(defthm cst-case-pattern-conc-rep-elem-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-case-pattern-conc-rep-elem abnf::cst)
                  (cst-case-pattern-conc-rep-elem cst-equiv)))
  :rule-classes :congruence)

Function: cst-for-statement-conc1-rep-elem

(defun cst-for-statement-conc1-rep-elem (abnf::cst)
  (declare (xargs :guard (abnf::treep abnf::cst)))
  (declare
       (xargs :guard (and (cst-matchp abnf::cst "for-statement")
                          (equal (cst-for-statement-conc? abnf::cst)
                                 1))))
  (abnf::tree-fix (nth 0
                       (cst-for-statement-conc1-rep abnf::cst))))

Theorem: treep-of-cst-for-statement-conc1-rep-elem

(defthm treep-of-cst-for-statement-conc1-rep-elem
  (b* ((abnf::cst1 (cst-for-statement-conc1-rep-elem abnf::cst)))
    (abnf::treep abnf::cst1))
  :rule-classes :rewrite)

Theorem: cst-for-statement-conc1-rep-elem-match

(defthm cst-for-statement-conc1-rep-elem-match
 (implies
     (and (cst-matchp abnf::cst "for-statement")
          (equal (cst-for-statement-conc? abnf::cst)
                 1))
     (b* ((abnf::cst1 (cst-for-statement-conc1-rep-elem abnf::cst)))
       (cst-matchp abnf::cst1 "basic-for-statement")))
 :rule-classes :rewrite)

Theorem: cst-for-statement-conc1-rep-elem-of-tree-fix-cst

(defthm cst-for-statement-conc1-rep-elem-of-tree-fix-cst
  (equal
       (cst-for-statement-conc1-rep-elem (abnf::tree-fix abnf::cst))
       (cst-for-statement-conc1-rep-elem abnf::cst)))

Theorem: cst-for-statement-conc1-rep-elem-tree-equiv-congruence-on-cst

(defthm
      cst-for-statement-conc1-rep-elem-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-for-statement-conc1-rep-elem abnf::cst)
                  (cst-for-statement-conc1-rep-elem cst-equiv)))
  :rule-classes :congruence)

Function: cst-for-statement-conc2-rep-elem

(defun cst-for-statement-conc2-rep-elem (abnf::cst)
  (declare (xargs :guard (abnf::treep abnf::cst)))
  (declare
       (xargs :guard (and (cst-matchp abnf::cst "for-statement")
                          (equal (cst-for-statement-conc? abnf::cst)
                                 2))))
  (abnf::tree-fix (nth 0
                       (cst-for-statement-conc2-rep abnf::cst))))

Theorem: treep-of-cst-for-statement-conc2-rep-elem

(defthm treep-of-cst-for-statement-conc2-rep-elem
  (b* ((abnf::cst1 (cst-for-statement-conc2-rep-elem abnf::cst)))
    (abnf::treep abnf::cst1))
  :rule-classes :rewrite)

Theorem: cst-for-statement-conc2-rep-elem-match

(defthm cst-for-statement-conc2-rep-elem-match
 (implies
     (and (cst-matchp abnf::cst "for-statement")
          (equal (cst-for-statement-conc? abnf::cst)
                 2))
     (b* ((abnf::cst1 (cst-for-statement-conc2-rep-elem abnf::cst)))
       (cst-matchp abnf::cst1 "enhanced-for-statement")))
 :rule-classes :rewrite)

Theorem: cst-for-statement-conc2-rep-elem-of-tree-fix-cst

(defthm cst-for-statement-conc2-rep-elem-of-tree-fix-cst
  (equal
       (cst-for-statement-conc2-rep-elem (abnf::tree-fix abnf::cst))
       (cst-for-statement-conc2-rep-elem abnf::cst)))

Theorem: cst-for-statement-conc2-rep-elem-tree-equiv-congruence-on-cst

(defthm
      cst-for-statement-conc2-rep-elem-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-for-statement-conc2-rep-elem abnf::cst)
                  (cst-for-statement-conc2-rep-elem cst-equiv)))
  :rule-classes :congruence)

Function: cst-for-statement-no-short-if-conc1-rep-elem

(defun cst-for-statement-no-short-if-conc1-rep-elem (abnf::cst)
 (declare (xargs :guard (abnf::treep abnf::cst)))
 (declare
  (xargs :guard
         (and (cst-matchp abnf::cst "for-statement-no-short-if")
              (equal (cst-for-statement-no-short-if-conc? abnf::cst)
                     1))))
 (abnf::tree-fix
      (nth 0
           (cst-for-statement-no-short-if-conc1-rep abnf::cst))))

Theorem: treep-of-cst-for-statement-no-short-if-conc1-rep-elem

(defthm treep-of-cst-for-statement-no-short-if-conc1-rep-elem
  (b*
    ((abnf::cst1
          (cst-for-statement-no-short-if-conc1-rep-elem abnf::cst)))
    (abnf::treep abnf::cst1))
  :rule-classes :rewrite)

Theorem: cst-for-statement-no-short-if-conc1-rep-elem-match

(defthm cst-for-statement-no-short-if-conc1-rep-elem-match
 (implies
   (and (cst-matchp abnf::cst "for-statement-no-short-if")
        (equal (cst-for-statement-no-short-if-conc? abnf::cst)
               1))
   (b*
    ((abnf::cst1
          (cst-for-statement-no-short-if-conc1-rep-elem abnf::cst)))
    (cst-matchp abnf::cst1
                "basic-for-statement-no-short-if")))
 :rule-classes :rewrite)

Theorem: cst-for-statement-no-short-if-conc1-rep-elem-of-tree-fix-cst

(defthm cst-for-statement-no-short-if-conc1-rep-elem-of-tree-fix-cst
  (equal (cst-for-statement-no-short-if-conc1-rep-elem
              (abnf::tree-fix abnf::cst))
         (cst-for-statement-no-short-if-conc1-rep-elem abnf::cst)))

Theorem: cst-for-statement-no-short-if-conc1-rep-elem-tree-equiv-congruence-on-cst

(defthm
 cst-for-statement-no-short-if-conc1-rep-elem-tree-equiv-congruence-on-cst
 (implies
   (abnf::tree-equiv abnf::cst cst-equiv)
   (equal (cst-for-statement-no-short-if-conc1-rep-elem abnf::cst)
          (cst-for-statement-no-short-if-conc1-rep-elem cst-equiv)))
 :rule-classes :congruence)

Function: cst-for-statement-no-short-if-conc2-rep-elem

(defun cst-for-statement-no-short-if-conc2-rep-elem (abnf::cst)
 (declare (xargs :guard (abnf::treep abnf::cst)))
 (declare
  (xargs :guard
         (and (cst-matchp abnf::cst "for-statement-no-short-if")
              (equal (cst-for-statement-no-short-if-conc? abnf::cst)
                     2))))
 (abnf::tree-fix
      (nth 0
           (cst-for-statement-no-short-if-conc2-rep abnf::cst))))

Theorem: treep-of-cst-for-statement-no-short-if-conc2-rep-elem

(defthm treep-of-cst-for-statement-no-short-if-conc2-rep-elem
  (b*
    ((abnf::cst1
          (cst-for-statement-no-short-if-conc2-rep-elem abnf::cst)))
    (abnf::treep abnf::cst1))
  :rule-classes :rewrite)

Theorem: cst-for-statement-no-short-if-conc2-rep-elem-match

(defthm cst-for-statement-no-short-if-conc2-rep-elem-match
 (implies
   (and (cst-matchp abnf::cst "for-statement-no-short-if")
        (equal (cst-for-statement-no-short-if-conc? abnf::cst)
               2))
   (b*
    ((abnf::cst1
          (cst-for-statement-no-short-if-conc2-rep-elem abnf::cst)))
    (cst-matchp abnf::cst1
                "enhanced-for-statement-no-short-if")))
 :rule-classes :rewrite)

Theorem: cst-for-statement-no-short-if-conc2-rep-elem-of-tree-fix-cst

(defthm cst-for-statement-no-short-if-conc2-rep-elem-of-tree-fix-cst
  (equal (cst-for-statement-no-short-if-conc2-rep-elem
              (abnf::tree-fix abnf::cst))
         (cst-for-statement-no-short-if-conc2-rep-elem abnf::cst)))

Theorem: cst-for-statement-no-short-if-conc2-rep-elem-tree-equiv-congruence-on-cst

(defthm
 cst-for-statement-no-short-if-conc2-rep-elem-tree-equiv-congruence-on-cst
 (implies
   (abnf::tree-equiv abnf::cst cst-equiv)
   (equal (cst-for-statement-no-short-if-conc2-rep-elem abnf::cst)
          (cst-for-statement-no-short-if-conc2-rep-elem cst-equiv)))
 :rule-classes :congruence)

Function: cst-for-init-conc1-rep-elem

(defun cst-for-init-conc1-rep-elem (abnf::cst)
  (declare (xargs :guard (abnf::treep abnf::cst)))
  (declare (xargs :guard (and (cst-matchp abnf::cst "for-init")
                              (equal (cst-for-init-conc? abnf::cst)
                                     1))))
  (abnf::tree-fix (nth 0 (cst-for-init-conc1-rep abnf::cst))))

Theorem: treep-of-cst-for-init-conc1-rep-elem

(defthm treep-of-cst-for-init-conc1-rep-elem
  (b* ((abnf::cst1 (cst-for-init-conc1-rep-elem abnf::cst)))
    (abnf::treep abnf::cst1))
  :rule-classes :rewrite)

Theorem: cst-for-init-conc1-rep-elem-match

(defthm cst-for-init-conc1-rep-elem-match
 (implies (and (cst-matchp abnf::cst "for-init")
               (equal (cst-for-init-conc? abnf::cst)
                      1))
          (b* ((abnf::cst1 (cst-for-init-conc1-rep-elem abnf::cst)))
            (cst-matchp abnf::cst1
                        "statement-expression-list")))
 :rule-classes :rewrite)

Theorem: cst-for-init-conc1-rep-elem-of-tree-fix-cst

(defthm cst-for-init-conc1-rep-elem-of-tree-fix-cst
  (equal (cst-for-init-conc1-rep-elem (abnf::tree-fix abnf::cst))
         (cst-for-init-conc1-rep-elem abnf::cst)))

Theorem: cst-for-init-conc1-rep-elem-tree-equiv-congruence-on-cst

(defthm cst-for-init-conc1-rep-elem-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-for-init-conc1-rep-elem abnf::cst)
                  (cst-for-init-conc1-rep-elem cst-equiv)))
  :rule-classes :congruence)

Function: cst-for-init-conc2-rep-elem

(defun cst-for-init-conc2-rep-elem (abnf::cst)
  (declare (xargs :guard (abnf::treep abnf::cst)))
  (declare (xargs :guard (and (cst-matchp abnf::cst "for-init")
                              (equal (cst-for-init-conc? abnf::cst)
                                     2))))
  (abnf::tree-fix (nth 0 (cst-for-init-conc2-rep abnf::cst))))

Theorem: treep-of-cst-for-init-conc2-rep-elem

(defthm treep-of-cst-for-init-conc2-rep-elem
  (b* ((abnf::cst1 (cst-for-init-conc2-rep-elem abnf::cst)))
    (abnf::treep abnf::cst1))
  :rule-classes :rewrite)

Theorem: cst-for-init-conc2-rep-elem-match

(defthm cst-for-init-conc2-rep-elem-match
 (implies (and (cst-matchp abnf::cst "for-init")
               (equal (cst-for-init-conc? abnf::cst)
                      2))
          (b* ((abnf::cst1 (cst-for-init-conc2-rep-elem abnf::cst)))
            (cst-matchp abnf::cst1
                        "local-variable-declaration")))
 :rule-classes :rewrite)

Theorem: cst-for-init-conc2-rep-elem-of-tree-fix-cst

(defthm cst-for-init-conc2-rep-elem-of-tree-fix-cst
  (equal (cst-for-init-conc2-rep-elem (abnf::tree-fix abnf::cst))
         (cst-for-init-conc2-rep-elem abnf::cst)))

Theorem: cst-for-init-conc2-rep-elem-tree-equiv-congruence-on-cst

(defthm cst-for-init-conc2-rep-elem-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-for-init-conc2-rep-elem abnf::cst)
                  (cst-for-init-conc2-rep-elem cst-equiv)))
  :rule-classes :congruence)

Function: cst-for-update-conc-rep-elem

(defun cst-for-update-conc-rep-elem (abnf::cst)
  (declare (xargs :guard (abnf::treep abnf::cst)))
  (declare (xargs :guard (cst-matchp abnf::cst "for-update")))
  (abnf::tree-fix (nth 0 (cst-for-update-conc-rep abnf::cst))))

Theorem: treep-of-cst-for-update-conc-rep-elem

(defthm treep-of-cst-for-update-conc-rep-elem
  (b* ((abnf::cst1 (cst-for-update-conc-rep-elem abnf::cst)))
    (abnf::treep abnf::cst1))
  :rule-classes :rewrite)

Theorem: cst-for-update-conc-rep-elem-match

(defthm cst-for-update-conc-rep-elem-match
  (implies
       (cst-matchp abnf::cst "for-update")
       (b* ((abnf::cst1 (cst-for-update-conc-rep-elem abnf::cst)))
         (cst-matchp abnf::cst1
                     "statement-expression-list")))
  :rule-classes :rewrite)

Theorem: cst-for-update-conc-rep-elem-of-tree-fix-cst

(defthm cst-for-update-conc-rep-elem-of-tree-fix-cst
  (equal (cst-for-update-conc-rep-elem (abnf::tree-fix abnf::cst))
         (cst-for-update-conc-rep-elem abnf::cst)))

Theorem: cst-for-update-conc-rep-elem-tree-equiv-congruence-on-cst

(defthm cst-for-update-conc-rep-elem-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-for-update-conc-rep-elem abnf::cst)
                  (cst-for-update-conc-rep-elem cst-equiv)))
  :rule-classes :congruence)

Function: cst-resource-conc1-rep-elem

(defun cst-resource-conc1-rep-elem (abnf::cst)
  (declare (xargs :guard (abnf::treep abnf::cst)))
  (declare (xargs :guard (and (cst-matchp abnf::cst "resource")
                              (equal (cst-resource-conc? abnf::cst)
                                     1))))
  (abnf::tree-fix (nth 0 (cst-resource-conc1-rep abnf::cst))))

Theorem: treep-of-cst-resource-conc1-rep-elem

(defthm treep-of-cst-resource-conc1-rep-elem
  (b* ((abnf::cst1 (cst-resource-conc1-rep-elem abnf::cst)))
    (abnf::treep abnf::cst1))
  :rule-classes :rewrite)

Theorem: cst-resource-conc1-rep-elem-match

(defthm cst-resource-conc1-rep-elem-match
 (implies (and (cst-matchp abnf::cst "resource")
               (equal (cst-resource-conc? abnf::cst)
                      1))
          (b* ((abnf::cst1 (cst-resource-conc1-rep-elem abnf::cst)))
            (cst-matchp abnf::cst1
                        "local-variable-declaration")))
 :rule-classes :rewrite)

Theorem: cst-resource-conc1-rep-elem-of-tree-fix-cst

(defthm cst-resource-conc1-rep-elem-of-tree-fix-cst
  (equal (cst-resource-conc1-rep-elem (abnf::tree-fix abnf::cst))
         (cst-resource-conc1-rep-elem abnf::cst)))

Theorem: cst-resource-conc1-rep-elem-tree-equiv-congruence-on-cst

(defthm cst-resource-conc1-rep-elem-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-resource-conc1-rep-elem abnf::cst)
                  (cst-resource-conc1-rep-elem cst-equiv)))
  :rule-classes :congruence)

Function: cst-resource-conc2-rep-elem

(defun cst-resource-conc2-rep-elem (abnf::cst)
  (declare (xargs :guard (abnf::treep abnf::cst)))
  (declare (xargs :guard (and (cst-matchp abnf::cst "resource")
                              (equal (cst-resource-conc? abnf::cst)
                                     2))))
  (abnf::tree-fix (nth 0 (cst-resource-conc2-rep abnf::cst))))

Theorem: treep-of-cst-resource-conc2-rep-elem

(defthm treep-of-cst-resource-conc2-rep-elem
  (b* ((abnf::cst1 (cst-resource-conc2-rep-elem abnf::cst)))
    (abnf::treep abnf::cst1))
  :rule-classes :rewrite)

Theorem: cst-resource-conc2-rep-elem-match

(defthm cst-resource-conc2-rep-elem-match
 (implies (and (cst-matchp abnf::cst "resource")
               (equal (cst-resource-conc? abnf::cst)
                      2))
          (b* ((abnf::cst1 (cst-resource-conc2-rep-elem abnf::cst)))
            (cst-matchp abnf::cst1 "variable-access")))
 :rule-classes :rewrite)

Theorem: cst-resource-conc2-rep-elem-of-tree-fix-cst

(defthm cst-resource-conc2-rep-elem-of-tree-fix-cst
  (equal (cst-resource-conc2-rep-elem (abnf::tree-fix abnf::cst))
         (cst-resource-conc2-rep-elem abnf::cst)))

Theorem: cst-resource-conc2-rep-elem-tree-equiv-congruence-on-cst

(defthm cst-resource-conc2-rep-elem-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-resource-conc2-rep-elem abnf::cst)
                  (cst-resource-conc2-rep-elem cst-equiv)))
  :rule-classes :congruence)

Function: cst-variable-access-conc1-rep-elem

(defun cst-variable-access-conc1-rep-elem (abnf::cst)
 (declare (xargs :guard (abnf::treep abnf::cst)))
 (declare
     (xargs :guard (and (cst-matchp abnf::cst "variable-access")
                        (equal (cst-variable-access-conc? abnf::cst)
                               1))))
 (abnf::tree-fix (nth 0
                      (cst-variable-access-conc1-rep abnf::cst))))

Theorem: treep-of-cst-variable-access-conc1-rep-elem

(defthm treep-of-cst-variable-access-conc1-rep-elem
  (b* ((abnf::cst1 (cst-variable-access-conc1-rep-elem abnf::cst)))
    (abnf::treep abnf::cst1))
  :rule-classes :rewrite)

Theorem: cst-variable-access-conc1-rep-elem-match

(defthm cst-variable-access-conc1-rep-elem-match
 (implies
   (and (cst-matchp abnf::cst "variable-access")
        (equal (cst-variable-access-conc? abnf::cst)
               1))
   (b* ((abnf::cst1 (cst-variable-access-conc1-rep-elem abnf::cst)))
     (cst-matchp abnf::cst1 "expression-name")))
 :rule-classes :rewrite)

Theorem: cst-variable-access-conc1-rep-elem-of-tree-fix-cst

(defthm cst-variable-access-conc1-rep-elem-of-tree-fix-cst
 (equal
     (cst-variable-access-conc1-rep-elem (abnf::tree-fix abnf::cst))
     (cst-variable-access-conc1-rep-elem abnf::cst)))

Theorem: cst-variable-access-conc1-rep-elem-tree-equiv-congruence-on-cst

(defthm
    cst-variable-access-conc1-rep-elem-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-variable-access-conc1-rep-elem abnf::cst)
                  (cst-variable-access-conc1-rep-elem cst-equiv)))
  :rule-classes :congruence)

Function: cst-variable-access-conc2-rep-elem

(defun cst-variable-access-conc2-rep-elem (abnf::cst)
 (declare (xargs :guard (abnf::treep abnf::cst)))
 (declare
     (xargs :guard (and (cst-matchp abnf::cst "variable-access")
                        (equal (cst-variable-access-conc? abnf::cst)
                               2))))
 (abnf::tree-fix (nth 0
                      (cst-variable-access-conc2-rep abnf::cst))))

Theorem: treep-of-cst-variable-access-conc2-rep-elem

(defthm treep-of-cst-variable-access-conc2-rep-elem
  (b* ((abnf::cst1 (cst-variable-access-conc2-rep-elem abnf::cst)))
    (abnf::treep abnf::cst1))
  :rule-classes :rewrite)

Theorem: cst-variable-access-conc2-rep-elem-match

(defthm cst-variable-access-conc2-rep-elem-match
 (implies
   (and (cst-matchp abnf::cst "variable-access")
        (equal (cst-variable-access-conc? abnf::cst)
               2))
   (b* ((abnf::cst1 (cst-variable-access-conc2-rep-elem abnf::cst)))
     (cst-matchp abnf::cst1 "field-access")))
 :rule-classes :rewrite)

Theorem: cst-variable-access-conc2-rep-elem-of-tree-fix-cst

(defthm cst-variable-access-conc2-rep-elem-of-tree-fix-cst
 (equal
     (cst-variable-access-conc2-rep-elem (abnf::tree-fix abnf::cst))
     (cst-variable-access-conc2-rep-elem abnf::cst)))

Theorem: cst-variable-access-conc2-rep-elem-tree-equiv-congruence-on-cst

(defthm
    cst-variable-access-conc2-rep-elem-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-variable-access-conc2-rep-elem abnf::cst)
                  (cst-variable-access-conc2-rep-elem cst-equiv)))
  :rule-classes :congruence)

Function: cst-pattern-conc1-rep-elem

(defun cst-pattern-conc1-rep-elem (abnf::cst)
  (declare (xargs :guard (abnf::treep abnf::cst)))
  (declare (xargs :guard (and (cst-matchp abnf::cst "pattern")
                              (equal (cst-pattern-conc? abnf::cst)
                                     1))))
  (abnf::tree-fix (nth 0 (cst-pattern-conc1-rep abnf::cst))))

Theorem: treep-of-cst-pattern-conc1-rep-elem

(defthm treep-of-cst-pattern-conc1-rep-elem
  (b* ((abnf::cst1 (cst-pattern-conc1-rep-elem abnf::cst)))
    (abnf::treep abnf::cst1))
  :rule-classes :rewrite)

Theorem: cst-pattern-conc1-rep-elem-match

(defthm cst-pattern-conc1-rep-elem-match
  (implies (and (cst-matchp abnf::cst "pattern")
                (equal (cst-pattern-conc? abnf::cst) 1))
           (b* ((abnf::cst1 (cst-pattern-conc1-rep-elem abnf::cst)))
             (cst-matchp abnf::cst1 "type-pattern")))
  :rule-classes :rewrite)

Theorem: cst-pattern-conc1-rep-elem-of-tree-fix-cst

(defthm cst-pattern-conc1-rep-elem-of-tree-fix-cst
  (equal (cst-pattern-conc1-rep-elem (abnf::tree-fix abnf::cst))
         (cst-pattern-conc1-rep-elem abnf::cst)))

Theorem: cst-pattern-conc1-rep-elem-tree-equiv-congruence-on-cst

(defthm cst-pattern-conc1-rep-elem-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-pattern-conc1-rep-elem abnf::cst)
                  (cst-pattern-conc1-rep-elem cst-equiv)))
  :rule-classes :congruence)

Function: cst-pattern-conc2-rep-elem

(defun cst-pattern-conc2-rep-elem (abnf::cst)
  (declare (xargs :guard (abnf::treep abnf::cst)))
  (declare (xargs :guard (and (cst-matchp abnf::cst "pattern")
                              (equal (cst-pattern-conc? abnf::cst)
                                     2))))
  (abnf::tree-fix (nth 0 (cst-pattern-conc2-rep abnf::cst))))

Theorem: treep-of-cst-pattern-conc2-rep-elem

(defthm treep-of-cst-pattern-conc2-rep-elem
  (b* ((abnf::cst1 (cst-pattern-conc2-rep-elem abnf::cst)))
    (abnf::treep abnf::cst1))
  :rule-classes :rewrite)

Theorem: cst-pattern-conc2-rep-elem-match

(defthm cst-pattern-conc2-rep-elem-match
  (implies (and (cst-matchp abnf::cst "pattern")
                (equal (cst-pattern-conc? abnf::cst) 2))
           (b* ((abnf::cst1 (cst-pattern-conc2-rep-elem abnf::cst)))
             (cst-matchp abnf::cst1 "record-pattern")))
  :rule-classes :rewrite)

Theorem: cst-pattern-conc2-rep-elem-of-tree-fix-cst

(defthm cst-pattern-conc2-rep-elem-of-tree-fix-cst
  (equal (cst-pattern-conc2-rep-elem (abnf::tree-fix abnf::cst))
         (cst-pattern-conc2-rep-elem abnf::cst)))

Theorem: cst-pattern-conc2-rep-elem-tree-equiv-congruence-on-cst

(defthm cst-pattern-conc2-rep-elem-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-pattern-conc2-rep-elem abnf::cst)
                  (cst-pattern-conc2-rep-elem cst-equiv)))
  :rule-classes :congruence)

Function: cst-type-pattern-conc-rep-elem

(defun cst-type-pattern-conc-rep-elem (abnf::cst)
  (declare (xargs :guard (abnf::treep abnf::cst)))
  (declare (xargs :guard (cst-matchp abnf::cst "type-pattern")))
  (abnf::tree-fix (nth 0
                       (cst-type-pattern-conc-rep abnf::cst))))

Theorem: treep-of-cst-type-pattern-conc-rep-elem

(defthm treep-of-cst-type-pattern-conc-rep-elem
  (b* ((abnf::cst1 (cst-type-pattern-conc-rep-elem abnf::cst)))
    (abnf::treep abnf::cst1))
  :rule-classes :rewrite)

Theorem: cst-type-pattern-conc-rep-elem-match

(defthm cst-type-pattern-conc-rep-elem-match
  (implies
       (cst-matchp abnf::cst "type-pattern")
       (b* ((abnf::cst1 (cst-type-pattern-conc-rep-elem abnf::cst)))
         (cst-matchp abnf::cst1
                     "local-variable-declaration")))
  :rule-classes :rewrite)

Theorem: cst-type-pattern-conc-rep-elem-of-tree-fix-cst

(defthm cst-type-pattern-conc-rep-elem-of-tree-fix-cst
  (equal (cst-type-pattern-conc-rep-elem (abnf::tree-fix abnf::cst))
         (cst-type-pattern-conc-rep-elem abnf::cst)))

Theorem: cst-type-pattern-conc-rep-elem-tree-equiv-congruence-on-cst

(defthm cst-type-pattern-conc-rep-elem-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-type-pattern-conc-rep-elem abnf::cst)
                  (cst-type-pattern-conc-rep-elem cst-equiv)))
  :rule-classes :congruence)

Function: cst-component-pattern-conc1-rep-elem

(defun cst-component-pattern-conc1-rep-elem (abnf::cst)
 (declare (xargs :guard (abnf::treep abnf::cst)))
 (declare
   (xargs :guard (and (cst-matchp abnf::cst "component-pattern")
                      (equal (cst-component-pattern-conc? abnf::cst)
                             1))))
 (abnf::tree-fix (nth 0
                      (cst-component-pattern-conc1-rep abnf::cst))))

Theorem: treep-of-cst-component-pattern-conc1-rep-elem

(defthm treep-of-cst-component-pattern-conc1-rep-elem
 (b* ((abnf::cst1 (cst-component-pattern-conc1-rep-elem abnf::cst)))
   (abnf::treep abnf::cst1))
 :rule-classes :rewrite)

Theorem: cst-component-pattern-conc1-rep-elem-match

(defthm cst-component-pattern-conc1-rep-elem-match
 (implies
   (and (cst-matchp abnf::cst "component-pattern")
        (equal (cst-component-pattern-conc? abnf::cst)
               1))
   (b*
     ((abnf::cst1 (cst-component-pattern-conc1-rep-elem abnf::cst)))
     (cst-matchp abnf::cst1 "pattern")))
 :rule-classes :rewrite)

Theorem: cst-component-pattern-conc1-rep-elem-of-tree-fix-cst

(defthm cst-component-pattern-conc1-rep-elem-of-tree-fix-cst
 (equal
   (cst-component-pattern-conc1-rep-elem (abnf::tree-fix abnf::cst))
   (cst-component-pattern-conc1-rep-elem abnf::cst)))

Theorem: cst-component-pattern-conc1-rep-elem-tree-equiv-congruence-on-cst

(defthm
  cst-component-pattern-conc1-rep-elem-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-component-pattern-conc1-rep-elem abnf::cst)
                  (cst-component-pattern-conc1-rep-elem cst-equiv)))
  :rule-classes :congruence)

Function: cst-component-pattern-conc2-rep-elem

(defun cst-component-pattern-conc2-rep-elem (abnf::cst)
 (declare (xargs :guard (abnf::treep abnf::cst)))
 (declare
   (xargs :guard (and (cst-matchp abnf::cst "component-pattern")
                      (equal (cst-component-pattern-conc? abnf::cst)
                             2))))
 (abnf::tree-fix (nth 0
                      (cst-component-pattern-conc2-rep abnf::cst))))

Theorem: treep-of-cst-component-pattern-conc2-rep-elem

(defthm treep-of-cst-component-pattern-conc2-rep-elem
 (b* ((abnf::cst1 (cst-component-pattern-conc2-rep-elem abnf::cst)))
   (abnf::treep abnf::cst1))
 :rule-classes :rewrite)

Theorem: cst-component-pattern-conc2-rep-elem-match

(defthm cst-component-pattern-conc2-rep-elem-match
 (implies
   (and (cst-matchp abnf::cst "component-pattern")
        (equal (cst-component-pattern-conc? abnf::cst)
               2))
   (b*
     ((abnf::cst1 (cst-component-pattern-conc2-rep-elem abnf::cst)))
     (cst-matchp abnf::cst1 "match-all-pattern")))
 :rule-classes :rewrite)

Theorem: cst-component-pattern-conc2-rep-elem-of-tree-fix-cst

(defthm cst-component-pattern-conc2-rep-elem-of-tree-fix-cst
 (equal
   (cst-component-pattern-conc2-rep-elem (abnf::tree-fix abnf::cst))
   (cst-component-pattern-conc2-rep-elem abnf::cst)))

Theorem: cst-component-pattern-conc2-rep-elem-tree-equiv-congruence-on-cst

(defthm
  cst-component-pattern-conc2-rep-elem-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-component-pattern-conc2-rep-elem abnf::cst)
                  (cst-component-pattern-conc2-rep-elem cst-equiv)))
  :rule-classes :congruence)

Function: cst-match-all-pattern-conc-rep-elem

(defun cst-match-all-pattern-conc-rep-elem (abnf::cst)
 (declare (xargs :guard (abnf::treep abnf::cst)))
 (declare (xargs :guard (cst-matchp abnf::cst "match-all-pattern")))
 (abnf::tree-fix (nth 0
                      (cst-match-all-pattern-conc-rep abnf::cst))))

Theorem: treep-of-cst-match-all-pattern-conc-rep-elem

(defthm treep-of-cst-match-all-pattern-conc-rep-elem
  (b* ((abnf::cst1 (cst-match-all-pattern-conc-rep-elem abnf::cst)))
    (abnf::treep abnf::cst1))
  :rule-classes :rewrite)

Theorem: cst-match-all-pattern-conc-rep-elem-match

(defthm cst-match-all-pattern-conc-rep-elem-match
 (implies
  (cst-matchp abnf::cst "match-all-pattern")
  (b* ((abnf::cst1 (cst-match-all-pattern-conc-rep-elem abnf::cst)))
    (cst-matchp abnf::cst1 "\"_\"")))
 :rule-classes :rewrite)

Theorem: cst-match-all-pattern-conc-rep-elem-of-tree-fix-cst

(defthm cst-match-all-pattern-conc-rep-elem-of-tree-fix-cst
 (equal
    (cst-match-all-pattern-conc-rep-elem (abnf::tree-fix abnf::cst))
    (cst-match-all-pattern-conc-rep-elem abnf::cst)))

Theorem: cst-match-all-pattern-conc-rep-elem-tree-equiv-congruence-on-cst

(defthm
   cst-match-all-pattern-conc-rep-elem-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-match-all-pattern-conc-rep-elem abnf::cst)
                  (cst-match-all-pattern-conc-rep-elem cst-equiv)))
  :rule-classes :congruence)

Function: cst-expression-conc1-rep-elem

(defun cst-expression-conc1-rep-elem (abnf::cst)
 (declare (xargs :guard (abnf::treep abnf::cst)))
 (declare (xargs :guard (and (cst-matchp abnf::cst "expression")
                             (equal (cst-expression-conc? abnf::cst)
                                    1))))
 (abnf::tree-fix (nth 0
                      (cst-expression-conc1-rep abnf::cst))))

Theorem: treep-of-cst-expression-conc1-rep-elem

(defthm treep-of-cst-expression-conc1-rep-elem
  (b* ((abnf::cst1 (cst-expression-conc1-rep-elem abnf::cst)))
    (abnf::treep abnf::cst1))
  :rule-classes :rewrite)

Theorem: cst-expression-conc1-rep-elem-match

(defthm cst-expression-conc1-rep-elem-match
  (implies
       (and (cst-matchp abnf::cst "expression")
            (equal (cst-expression-conc? abnf::cst)
                   1))
       (b* ((abnf::cst1 (cst-expression-conc1-rep-elem abnf::cst)))
         (cst-matchp abnf::cst1 "lambda-expression")))
  :rule-classes :rewrite)

Theorem: cst-expression-conc1-rep-elem-of-tree-fix-cst

(defthm cst-expression-conc1-rep-elem-of-tree-fix-cst
  (equal (cst-expression-conc1-rep-elem (abnf::tree-fix abnf::cst))
         (cst-expression-conc1-rep-elem abnf::cst)))

Theorem: cst-expression-conc1-rep-elem-tree-equiv-congruence-on-cst

(defthm cst-expression-conc1-rep-elem-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-expression-conc1-rep-elem abnf::cst)
                  (cst-expression-conc1-rep-elem cst-equiv)))
  :rule-classes :congruence)

Function: cst-expression-conc2-rep-elem

(defun cst-expression-conc2-rep-elem (abnf::cst)
 (declare (xargs :guard (abnf::treep abnf::cst)))
 (declare (xargs :guard (and (cst-matchp abnf::cst "expression")
                             (equal (cst-expression-conc? abnf::cst)
                                    2))))
 (abnf::tree-fix (nth 0
                      (cst-expression-conc2-rep abnf::cst))))

Theorem: treep-of-cst-expression-conc2-rep-elem

(defthm treep-of-cst-expression-conc2-rep-elem
  (b* ((abnf::cst1 (cst-expression-conc2-rep-elem abnf::cst)))
    (abnf::treep abnf::cst1))
  :rule-classes :rewrite)

Theorem: cst-expression-conc2-rep-elem-match

(defthm cst-expression-conc2-rep-elem-match
  (implies
       (and (cst-matchp abnf::cst "expression")
            (equal (cst-expression-conc? abnf::cst)
                   2))
       (b* ((abnf::cst1 (cst-expression-conc2-rep-elem abnf::cst)))
         (cst-matchp abnf::cst1 "assignment-expression")))
  :rule-classes :rewrite)

Theorem: cst-expression-conc2-rep-elem-of-tree-fix-cst

(defthm cst-expression-conc2-rep-elem-of-tree-fix-cst
  (equal (cst-expression-conc2-rep-elem (abnf::tree-fix abnf::cst))
         (cst-expression-conc2-rep-elem abnf::cst)))

Theorem: cst-expression-conc2-rep-elem-tree-equiv-congruence-on-cst

(defthm cst-expression-conc2-rep-elem-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-expression-conc2-rep-elem abnf::cst)
                  (cst-expression-conc2-rep-elem cst-equiv)))
  :rule-classes :congruence)

Function: cst-primary-conc1-rep-elem

(defun cst-primary-conc1-rep-elem (abnf::cst)
  (declare (xargs :guard (abnf::treep abnf::cst)))
  (declare (xargs :guard (and (cst-matchp abnf::cst "primary")
                              (equal (cst-primary-conc? abnf::cst)
                                     1))))
  (abnf::tree-fix (nth 0 (cst-primary-conc1-rep abnf::cst))))

Theorem: treep-of-cst-primary-conc1-rep-elem

(defthm treep-of-cst-primary-conc1-rep-elem
  (b* ((abnf::cst1 (cst-primary-conc1-rep-elem abnf::cst)))
    (abnf::treep abnf::cst1))
  :rule-classes :rewrite)

Theorem: cst-primary-conc1-rep-elem-match

(defthm cst-primary-conc1-rep-elem-match
  (implies (and (cst-matchp abnf::cst "primary")
                (equal (cst-primary-conc? abnf::cst) 1))
           (b* ((abnf::cst1 (cst-primary-conc1-rep-elem abnf::cst)))
             (cst-matchp abnf::cst1 "primary-no-new-array")))
  :rule-classes :rewrite)

Theorem: cst-primary-conc1-rep-elem-of-tree-fix-cst

(defthm cst-primary-conc1-rep-elem-of-tree-fix-cst
  (equal (cst-primary-conc1-rep-elem (abnf::tree-fix abnf::cst))
         (cst-primary-conc1-rep-elem abnf::cst)))

Theorem: cst-primary-conc1-rep-elem-tree-equiv-congruence-on-cst

(defthm cst-primary-conc1-rep-elem-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-primary-conc1-rep-elem abnf::cst)
                  (cst-primary-conc1-rep-elem cst-equiv)))
  :rule-classes :congruence)

Function: cst-primary-conc2-rep-elem

(defun cst-primary-conc2-rep-elem (abnf::cst)
  (declare (xargs :guard (abnf::treep abnf::cst)))
  (declare (xargs :guard (and (cst-matchp abnf::cst "primary")
                              (equal (cst-primary-conc? abnf::cst)
                                     2))))
  (abnf::tree-fix (nth 0 (cst-primary-conc2-rep abnf::cst))))

Theorem: treep-of-cst-primary-conc2-rep-elem

(defthm treep-of-cst-primary-conc2-rep-elem
  (b* ((abnf::cst1 (cst-primary-conc2-rep-elem abnf::cst)))
    (abnf::treep abnf::cst1))
  :rule-classes :rewrite)

Theorem: cst-primary-conc2-rep-elem-match

(defthm cst-primary-conc2-rep-elem-match
  (implies (and (cst-matchp abnf::cst "primary")
                (equal (cst-primary-conc? abnf::cst) 2))
           (b* ((abnf::cst1 (cst-primary-conc2-rep-elem abnf::cst)))
             (cst-matchp abnf::cst1
                         "array-creation-expression")))
  :rule-classes :rewrite)

Theorem: cst-primary-conc2-rep-elem-of-tree-fix-cst

(defthm cst-primary-conc2-rep-elem-of-tree-fix-cst
  (equal (cst-primary-conc2-rep-elem (abnf::tree-fix abnf::cst))
         (cst-primary-conc2-rep-elem abnf::cst)))

Theorem: cst-primary-conc2-rep-elem-tree-equiv-congruence-on-cst

(defthm cst-primary-conc2-rep-elem-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-primary-conc2-rep-elem abnf::cst)
                  (cst-primary-conc2-rep-elem cst-equiv)))
  :rule-classes :congruence)

Function: cst-array-creation-expression-conc1-rep-elem

(defun cst-array-creation-expression-conc1-rep-elem (abnf::cst)
 (declare (xargs :guard (abnf::treep abnf::cst)))
 (declare
  (xargs :guard
         (and (cst-matchp abnf::cst "array-creation-expression")
              (equal (cst-array-creation-expression-conc? abnf::cst)
                     1))))
 (abnf::tree-fix
      (nth 0
           (cst-array-creation-expression-conc1-rep abnf::cst))))

Theorem: treep-of-cst-array-creation-expression-conc1-rep-elem

(defthm treep-of-cst-array-creation-expression-conc1-rep-elem
  (b*
    ((abnf::cst1
          (cst-array-creation-expression-conc1-rep-elem abnf::cst)))
    (abnf::treep abnf::cst1))
  :rule-classes :rewrite)

Theorem: cst-array-creation-expression-conc1-rep-elem-match

(defthm cst-array-creation-expression-conc1-rep-elem-match
 (implies
   (and (cst-matchp abnf::cst "array-creation-expression")
        (equal (cst-array-creation-expression-conc? abnf::cst)
               1))
   (b*
    ((abnf::cst1
          (cst-array-creation-expression-conc1-rep-elem abnf::cst)))
    (cst-matchp abnf::cst1
                "array-creation-expression-without-initializer")))
 :rule-classes :rewrite)

Theorem: cst-array-creation-expression-conc1-rep-elem-of-tree-fix-cst

(defthm cst-array-creation-expression-conc1-rep-elem-of-tree-fix-cst
  (equal (cst-array-creation-expression-conc1-rep-elem
              (abnf::tree-fix abnf::cst))
         (cst-array-creation-expression-conc1-rep-elem abnf::cst)))

Theorem: cst-array-creation-expression-conc1-rep-elem-tree-equiv-congruence-on-cst

(defthm
 cst-array-creation-expression-conc1-rep-elem-tree-equiv-congruence-on-cst
 (implies
   (abnf::tree-equiv abnf::cst cst-equiv)
   (equal (cst-array-creation-expression-conc1-rep-elem abnf::cst)
          (cst-array-creation-expression-conc1-rep-elem cst-equiv)))
 :rule-classes :congruence)

Function: cst-array-creation-expression-conc2-rep-elem

(defun cst-array-creation-expression-conc2-rep-elem (abnf::cst)
 (declare (xargs :guard (abnf::treep abnf::cst)))
 (declare
  (xargs :guard
         (and (cst-matchp abnf::cst "array-creation-expression")
              (equal (cst-array-creation-expression-conc? abnf::cst)
                     2))))
 (abnf::tree-fix
      (nth 0
           (cst-array-creation-expression-conc2-rep abnf::cst))))

Theorem: treep-of-cst-array-creation-expression-conc2-rep-elem

(defthm treep-of-cst-array-creation-expression-conc2-rep-elem
  (b*
    ((abnf::cst1
          (cst-array-creation-expression-conc2-rep-elem abnf::cst)))
    (abnf::treep abnf::cst1))
  :rule-classes :rewrite)

Theorem: cst-array-creation-expression-conc2-rep-elem-match

(defthm cst-array-creation-expression-conc2-rep-elem-match
 (implies
   (and (cst-matchp abnf::cst "array-creation-expression")
        (equal (cst-array-creation-expression-conc? abnf::cst)
               2))
   (b*
    ((abnf::cst1
          (cst-array-creation-expression-conc2-rep-elem abnf::cst)))
    (cst-matchp abnf::cst1
                "array-creation-expression-with-initializer")))
 :rule-classes :rewrite)

Theorem: cst-array-creation-expression-conc2-rep-elem-of-tree-fix-cst

(defthm cst-array-creation-expression-conc2-rep-elem-of-tree-fix-cst
  (equal (cst-array-creation-expression-conc2-rep-elem
              (abnf::tree-fix abnf::cst))
         (cst-array-creation-expression-conc2-rep-elem abnf::cst)))

Theorem: cst-array-creation-expression-conc2-rep-elem-tree-equiv-congruence-on-cst

(defthm
 cst-array-creation-expression-conc2-rep-elem-tree-equiv-congruence-on-cst
 (implies
   (abnf::tree-equiv abnf::cst cst-equiv)
   (equal (cst-array-creation-expression-conc2-rep-elem abnf::cst)
          (cst-array-creation-expression-conc2-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))))
 (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")))
 :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))))
 (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 "expression-name")))
 :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))))
 (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
                "post-increment-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))))
 (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
                "post-decrement-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-assignment-expression-conc1-rep-elem

(defun cst-assignment-expression-conc1-rep-elem (abnf::cst)
 (declare (xargs :guard (abnf::treep abnf::cst)))
 (declare
  (xargs
      :guard (and (cst-matchp abnf::cst "assignment-expression")
                  (equal (cst-assignment-expression-conc? abnf::cst)
                         1))))
 (abnf::tree-fix
      (nth 0
           (cst-assignment-expression-conc1-rep abnf::cst))))

Theorem: treep-of-cst-assignment-expression-conc1-rep-elem

(defthm treep-of-cst-assignment-expression-conc1-rep-elem
  (b* ((abnf::cst1
            (cst-assignment-expression-conc1-rep-elem abnf::cst)))
    (abnf::treep abnf::cst1))
  :rule-classes :rewrite)

Theorem: cst-assignment-expression-conc1-rep-elem-match

(defthm cst-assignment-expression-conc1-rep-elem-match
 (implies
    (and (cst-matchp abnf::cst "assignment-expression")
         (equal (cst-assignment-expression-conc? abnf::cst)
                1))
    (b* ((abnf::cst1
              (cst-assignment-expression-conc1-rep-elem abnf::cst)))
      (cst-matchp abnf::cst1 "conditional-expression")))
 :rule-classes :rewrite)

Theorem: cst-assignment-expression-conc1-rep-elem-of-tree-fix-cst

(defthm cst-assignment-expression-conc1-rep-elem-of-tree-fix-cst
  (equal (cst-assignment-expression-conc1-rep-elem
              (abnf::tree-fix abnf::cst))
         (cst-assignment-expression-conc1-rep-elem abnf::cst)))

Theorem: cst-assignment-expression-conc1-rep-elem-tree-equiv-congruence-on-cst

(defthm
 cst-assignment-expression-conc1-rep-elem-tree-equiv-congruence-on-cst
 (implies
      (abnf::tree-equiv abnf::cst cst-equiv)
      (equal (cst-assignment-expression-conc1-rep-elem abnf::cst)
             (cst-assignment-expression-conc1-rep-elem cst-equiv)))
 :rule-classes :congruence)

Function: cst-assignment-expression-conc2-rep-elem

(defun cst-assignment-expression-conc2-rep-elem (abnf::cst)
 (declare (xargs :guard (abnf::treep abnf::cst)))
 (declare
  (xargs
      :guard (and (cst-matchp abnf::cst "assignment-expression")
                  (equal (cst-assignment-expression-conc? abnf::cst)
                         2))))
 (abnf::tree-fix
      (nth 0
           (cst-assignment-expression-conc2-rep abnf::cst))))

Theorem: treep-of-cst-assignment-expression-conc2-rep-elem

(defthm treep-of-cst-assignment-expression-conc2-rep-elem
  (b* ((abnf::cst1
            (cst-assignment-expression-conc2-rep-elem abnf::cst)))
    (abnf::treep abnf::cst1))
  :rule-classes :rewrite)

Theorem: cst-assignment-expression-conc2-rep-elem-match

(defthm cst-assignment-expression-conc2-rep-elem-match
 (implies
    (and (cst-matchp abnf::cst "assignment-expression")
         (equal (cst-assignment-expression-conc? abnf::cst)
                2))
    (b* ((abnf::cst1
              (cst-assignment-expression-conc2-rep-elem abnf::cst)))
      (cst-matchp abnf::cst1 "assignment")))
 :rule-classes :rewrite)

Theorem: cst-assignment-expression-conc2-rep-elem-of-tree-fix-cst

(defthm cst-assignment-expression-conc2-rep-elem-of-tree-fix-cst
  (equal (cst-assignment-expression-conc2-rep-elem
              (abnf::tree-fix abnf::cst))
         (cst-assignment-expression-conc2-rep-elem abnf::cst)))

Theorem: cst-assignment-expression-conc2-rep-elem-tree-equiv-congruence-on-cst

(defthm
 cst-assignment-expression-conc2-rep-elem-tree-equiv-congruence-on-cst
 (implies
      (abnf::tree-equiv abnf::cst cst-equiv)
      (equal (cst-assignment-expression-conc2-rep-elem abnf::cst)
             (cst-assignment-expression-conc2-rep-elem cst-equiv)))
 :rule-classes :congruence)

Function: cst-left-hand-side-conc1-rep-elem

(defun cst-left-hand-side-conc1-rep-elem (abnf::cst)
 (declare (xargs :guard (abnf::treep abnf::cst)))
 (declare
      (xargs :guard (and (cst-matchp abnf::cst "left-hand-side")
                         (equal (cst-left-hand-side-conc? abnf::cst)
                                1))))
 (abnf::tree-fix (nth 0
                      (cst-left-hand-side-conc1-rep abnf::cst))))

Theorem: treep-of-cst-left-hand-side-conc1-rep-elem

(defthm treep-of-cst-left-hand-side-conc1-rep-elem
  (b* ((abnf::cst1 (cst-left-hand-side-conc1-rep-elem abnf::cst)))
    (abnf::treep abnf::cst1))
  :rule-classes :rewrite)

Theorem: cst-left-hand-side-conc1-rep-elem-match

(defthm cst-left-hand-side-conc1-rep-elem-match
 (implies
    (and (cst-matchp abnf::cst "left-hand-side")
         (equal (cst-left-hand-side-conc? abnf::cst)
                1))
    (b* ((abnf::cst1 (cst-left-hand-side-conc1-rep-elem abnf::cst)))
      (cst-matchp abnf::cst1 "expression-name")))
 :rule-classes :rewrite)

Theorem: cst-left-hand-side-conc1-rep-elem-of-tree-fix-cst

(defthm cst-left-hand-side-conc1-rep-elem-of-tree-fix-cst
 (equal
      (cst-left-hand-side-conc1-rep-elem (abnf::tree-fix abnf::cst))
      (cst-left-hand-side-conc1-rep-elem abnf::cst)))

Theorem: cst-left-hand-side-conc1-rep-elem-tree-equiv-congruence-on-cst

(defthm
     cst-left-hand-side-conc1-rep-elem-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-left-hand-side-conc1-rep-elem abnf::cst)
                  (cst-left-hand-side-conc1-rep-elem cst-equiv)))
  :rule-classes :congruence)

Function: cst-left-hand-side-conc2-rep-elem

(defun cst-left-hand-side-conc2-rep-elem (abnf::cst)
 (declare (xargs :guard (abnf::treep abnf::cst)))
 (declare
      (xargs :guard (and (cst-matchp abnf::cst "left-hand-side")
                         (equal (cst-left-hand-side-conc? abnf::cst)
                                2))))
 (abnf::tree-fix (nth 0
                      (cst-left-hand-side-conc2-rep abnf::cst))))

Theorem: treep-of-cst-left-hand-side-conc2-rep-elem

(defthm treep-of-cst-left-hand-side-conc2-rep-elem
  (b* ((abnf::cst1 (cst-left-hand-side-conc2-rep-elem abnf::cst)))
    (abnf::treep abnf::cst1))
  :rule-classes :rewrite)

Theorem: cst-left-hand-side-conc2-rep-elem-match

(defthm cst-left-hand-side-conc2-rep-elem-match
 (implies
    (and (cst-matchp abnf::cst "left-hand-side")
         (equal (cst-left-hand-side-conc? abnf::cst)
                2))
    (b* ((abnf::cst1 (cst-left-hand-side-conc2-rep-elem abnf::cst)))
      (cst-matchp abnf::cst1 "field-access")))
 :rule-classes :rewrite)

Theorem: cst-left-hand-side-conc2-rep-elem-of-tree-fix-cst

(defthm cst-left-hand-side-conc2-rep-elem-of-tree-fix-cst
 (equal
      (cst-left-hand-side-conc2-rep-elem (abnf::tree-fix abnf::cst))
      (cst-left-hand-side-conc2-rep-elem abnf::cst)))

Theorem: cst-left-hand-side-conc2-rep-elem-tree-equiv-congruence-on-cst

(defthm
     cst-left-hand-side-conc2-rep-elem-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-left-hand-side-conc2-rep-elem abnf::cst)
                  (cst-left-hand-side-conc2-rep-elem cst-equiv)))
  :rule-classes :congruence)

Function: cst-left-hand-side-conc3-rep-elem

(defun cst-left-hand-side-conc3-rep-elem (abnf::cst)
 (declare (xargs :guard (abnf::treep abnf::cst)))
 (declare
      (xargs :guard (and (cst-matchp abnf::cst "left-hand-side")
                         (equal (cst-left-hand-side-conc? abnf::cst)
                                3))))
 (abnf::tree-fix (nth 0
                      (cst-left-hand-side-conc3-rep abnf::cst))))

Theorem: treep-of-cst-left-hand-side-conc3-rep-elem

(defthm treep-of-cst-left-hand-side-conc3-rep-elem
  (b* ((abnf::cst1 (cst-left-hand-side-conc3-rep-elem abnf::cst)))
    (abnf::treep abnf::cst1))
  :rule-classes :rewrite)

Theorem: cst-left-hand-side-conc3-rep-elem-match

(defthm cst-left-hand-side-conc3-rep-elem-match
 (implies
    (and (cst-matchp abnf::cst "left-hand-side")
         (equal (cst-left-hand-side-conc? abnf::cst)
                3))
    (b* ((abnf::cst1 (cst-left-hand-side-conc3-rep-elem abnf::cst)))
      (cst-matchp abnf::cst1 "array-access")))
 :rule-classes :rewrite)

Theorem: cst-left-hand-side-conc3-rep-elem-of-tree-fix-cst

(defthm cst-left-hand-side-conc3-rep-elem-of-tree-fix-cst
 (equal
      (cst-left-hand-side-conc3-rep-elem (abnf::tree-fix abnf::cst))
      (cst-left-hand-side-conc3-rep-elem abnf::cst)))

Theorem: cst-left-hand-side-conc3-rep-elem-tree-equiv-congruence-on-cst

(defthm
     cst-left-hand-side-conc3-rep-elem-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-left-hand-side-conc3-rep-elem abnf::cst)
                  (cst-left-hand-side-conc3-rep-elem cst-equiv)))
  :rule-classes :congruence)

Function: cst-lambda-body-conc1-rep-elem

(defun cst-lambda-body-conc1-rep-elem (abnf::cst)
  (declare (xargs :guard (abnf::treep abnf::cst)))
  (declare
       (xargs :guard (and (cst-matchp abnf::cst "lambda-body")
                          (equal (cst-lambda-body-conc? abnf::cst)
                                 1))))
  (abnf::tree-fix (nth 0
                       (cst-lambda-body-conc1-rep abnf::cst))))

Theorem: treep-of-cst-lambda-body-conc1-rep-elem

(defthm treep-of-cst-lambda-body-conc1-rep-elem
  (b* ((abnf::cst1 (cst-lambda-body-conc1-rep-elem abnf::cst)))
    (abnf::treep abnf::cst1))
  :rule-classes :rewrite)

Theorem: cst-lambda-body-conc1-rep-elem-match

(defthm cst-lambda-body-conc1-rep-elem-match
  (implies
       (and (cst-matchp abnf::cst "lambda-body")
            (equal (cst-lambda-body-conc? abnf::cst)
                   1))
       (b* ((abnf::cst1 (cst-lambda-body-conc1-rep-elem abnf::cst)))
         (cst-matchp abnf::cst1 "expression")))
  :rule-classes :rewrite)

Theorem: cst-lambda-body-conc1-rep-elem-of-tree-fix-cst

(defthm cst-lambda-body-conc1-rep-elem-of-tree-fix-cst
  (equal (cst-lambda-body-conc1-rep-elem (abnf::tree-fix abnf::cst))
         (cst-lambda-body-conc1-rep-elem abnf::cst)))

Theorem: cst-lambda-body-conc1-rep-elem-tree-equiv-congruence-on-cst

(defthm cst-lambda-body-conc1-rep-elem-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-lambda-body-conc1-rep-elem abnf::cst)
                  (cst-lambda-body-conc1-rep-elem cst-equiv)))
  :rule-classes :congruence)

Function: cst-lambda-body-conc2-rep-elem

(defun cst-lambda-body-conc2-rep-elem (abnf::cst)
  (declare (xargs :guard (abnf::treep abnf::cst)))
  (declare
       (xargs :guard (and (cst-matchp abnf::cst "lambda-body")
                          (equal (cst-lambda-body-conc? abnf::cst)
                                 2))))
  (abnf::tree-fix (nth 0
                       (cst-lambda-body-conc2-rep abnf::cst))))

Theorem: treep-of-cst-lambda-body-conc2-rep-elem

(defthm treep-of-cst-lambda-body-conc2-rep-elem
  (b* ((abnf::cst1 (cst-lambda-body-conc2-rep-elem abnf::cst)))
    (abnf::treep abnf::cst1))
  :rule-classes :rewrite)

Theorem: cst-lambda-body-conc2-rep-elem-match

(defthm cst-lambda-body-conc2-rep-elem-match
  (implies
       (and (cst-matchp abnf::cst "lambda-body")
            (equal (cst-lambda-body-conc? abnf::cst)
                   2))
       (b* ((abnf::cst1 (cst-lambda-body-conc2-rep-elem abnf::cst)))
         (cst-matchp abnf::cst1 "block")))
  :rule-classes :rewrite)

Theorem: cst-lambda-body-conc2-rep-elem-of-tree-fix-cst

(defthm cst-lambda-body-conc2-rep-elem-of-tree-fix-cst
  (equal (cst-lambda-body-conc2-rep-elem (abnf::tree-fix abnf::cst))
         (cst-lambda-body-conc2-rep-elem abnf::cst)))

Theorem: cst-lambda-body-conc2-rep-elem-tree-equiv-congruence-on-cst

(defthm cst-lambda-body-conc2-rep-elem-tree-equiv-congruence-on-cst
  (implies (abnf::tree-equiv abnf::cst cst-equiv)
           (equal (cst-lambda-body-conc2-rep-elem abnf::cst)
                  (cst-lambda-body-conc2-rep-elem cst-equiv)))
  :rule-classes :congruence)

*grammar*-tree-operations

Definitions and Theorems

grammar-tree-operations